Rename the parent pointer to root, as the pointer often references expression multiple layers above the current expression.

internal/jet/blob_expression.go

@@ -25,61 +25,61 @@ type BlobExpression interface {
 }
 
 type blobInterfaceImpl struct {
-	parent BlobExpression
+	root BlobExpression
 }
 
 func (b *blobInterfaceImpl) isStringOrBlob() {}
 
 func (b *blobInterfaceImpl) EQ(rhs BlobExpression) BoolExpression {
-	return Eq(b.parent, rhs)
+	return Eq(b.root, rhs)
 }
 
 func (b *blobInterfaceImpl) NOT_EQ(rhs BlobExpression) BoolExpression {
-	return NotEq(b.parent, rhs)
+	return NotEq(b.root, rhs)
 }
 
 func (b *blobInterfaceImpl) IS_DISTINCT_FROM(rhs BlobExpression) BoolExpression {
-	return IsDistinctFrom(b.parent, rhs)
+	return IsDistinctFrom(b.root, rhs)
 }
 
 func (b *blobInterfaceImpl) IS_NOT_DISTINCT_FROM(rhs BlobExpression) BoolExpression {
-	return IsNotDistinctFrom(b.parent, rhs)
+	return IsNotDistinctFrom(b.root, rhs)
 }
 
 func (b *blobInterfaceImpl) GT(rhs BlobExpression) BoolExpression {
-	return Gt(b.parent, rhs)
+	return Gt(b.root, rhs)
 }
 
 func (b *blobInterfaceImpl) GT_EQ(rhs BlobExpression) BoolExpression {
-	return GtEq(b.parent, rhs)
+	return GtEq(b.root, rhs)
 }
 
 func (b *blobInterfaceImpl) LT(rhs BlobExpression) BoolExpression {
-	return Lt(b.parent, rhs)
+	return Lt(b.root, rhs)
 }
 
 func (b *blobInterfaceImpl) LT_EQ(rhs BlobExpression) BoolExpression {
-	return LtEq(b.parent, rhs)
+	return LtEq(b.root, rhs)
 }
 
 func (b *blobInterfaceImpl) BETWEEN(min, max BlobExpression) BoolExpression {
-	return NewBetweenOperatorExpression(b.parent, min, max, false)
+	return NewBetweenOperatorExpression(b.root, min, max, false)
 }
 
 func (b *blobInterfaceImpl) NOT_BETWEEN(min, max BlobExpression) BoolExpression {
-	return NewBetweenOperatorExpression(b.parent, min, max, true)
+	return NewBetweenOperatorExpression(b.root, min, max, true)
 }
 
 func (b *blobInterfaceImpl) CONCAT(rhs BlobExpression) BlobExpression {
-	return BlobExp(newBinaryStringOperatorExpression(b.parent, rhs, StringConcatOperator))
+	return BlobExp(newBinaryStringOperatorExpression(b.root, rhs, StringConcatOperator))
 }
 
 func (b *blobInterfaceImpl) LIKE(pattern BlobExpression) BoolExpression {
-	return newBinaryBoolOperatorExpression(b.parent, pattern, "LIKE")
+	return newBinaryBoolOperatorExpression(b.root, pattern, "LIKE")
 }
 
 func (b *blobInterfaceImpl) NOT_LIKE(pattern BlobExpression) BoolExpression {
-	return newBinaryBoolOperatorExpression(b.parent, pattern, "NOT LIKE")
+	return newBinaryBoolOperatorExpression(b.root, pattern, "NOT LIKE")
 }
 
 //---------------------------------------------------//
@@ -91,8 +91,8 @@ type blobExpressionWrapper struct {
 
 func newBlobExpressionWrap(expression Expression) BlobExpression {
 	blobExpressionWrap := &blobExpressionWrapper{Expression: expression}
-	blobExpressionWrap.blobInterfaceImpl.parent = blobExpressionWrap
+	blobExpressionWrap.blobInterfaceImpl.root = blobExpressionWrap
-	expression.setParent(blobExpressionWrap)
+	expression.setRoot(blobExpressionWrap)
 	return blobExpressionWrap
 }
 

internal/jet/bool_expression.go

@@ -33,55 +33,55 @@ type BoolExpression interface {
 }
 
 type boolInterfaceImpl struct {
-	parent BoolExpression
+	root BoolExpression
 }
 
 func (b *boolInterfaceImpl) EQ(expression BoolExpression) BoolExpression {
-	return Eq(b.parent, expression)
+	return Eq(b.root, expression)
 }
 
 func (b *boolInterfaceImpl) NOT_EQ(expression BoolExpression) BoolExpression {
-	return NotEq(b.parent, expression)
+	return NotEq(b.root, expression)
 }
 
 func (b *boolInterfaceImpl) IS_DISTINCT_FROM(rhs BoolExpression) BoolExpression {
-	return IsDistinctFrom(b.parent, rhs)
+	return IsDistinctFrom(b.root, rhs)
 }
 
 func (b *boolInterfaceImpl) IS_NOT_DISTINCT_FROM(rhs BoolExpression) BoolExpression {
-	return IsNotDistinctFrom(b.parent, rhs)
+	return IsNotDistinctFrom(b.root, rhs)
 }
 
 func (b *boolInterfaceImpl) AND(expression BoolExpression) BoolExpression {
-	return newBinaryBoolOperatorExpression(b.parent, expression, "AND")
+	return newBinaryBoolOperatorExpression(b.root, expression, "AND")
 }
 
 func (b *boolInterfaceImpl) OR(expression BoolExpression) BoolExpression {
-	return newBinaryBoolOperatorExpression(b.parent, expression, "OR")
+	return newBinaryBoolOperatorExpression(b.root, expression, "OR")
 }
 
 func (b *boolInterfaceImpl) IS_TRUE() BoolExpression {
-	return newPostfixBoolOperatorExpression(b.parent, "IS TRUE")
+	return newPostfixBoolOperatorExpression(b.root, "IS TRUE")
 }
 
 func (b *boolInterfaceImpl) IS_NOT_TRUE() BoolExpression {
-	return newPostfixBoolOperatorExpression(b.parent, "IS NOT TRUE")
+	return newPostfixBoolOperatorExpression(b.root, "IS NOT TRUE")
 }
 
 func (b *boolInterfaceImpl) IS_FALSE() BoolExpression {
-	return newPostfixBoolOperatorExpression(b.parent, "IS FALSE")
+	return newPostfixBoolOperatorExpression(b.root, "IS FALSE")
 }
 
 func (b *boolInterfaceImpl) IS_NOT_FALSE() BoolExpression {
-	return newPostfixBoolOperatorExpression(b.parent, "IS NOT FALSE")
+	return newPostfixBoolOperatorExpression(b.root, "IS NOT FALSE")
 }
 
 func (b *boolInterfaceImpl) IS_UNKNOWN() BoolExpression {
-	return newPostfixBoolOperatorExpression(b.parent, "IS UNKNOWN")
+	return newPostfixBoolOperatorExpression(b.root, "IS UNKNOWN")
 }
 
 func (b *boolInterfaceImpl) IS_NOT_UNKNOWN() BoolExpression {
-	return newPostfixBoolOperatorExpression(b.parent, "IS NOT UNKNOWN")
+	return newPostfixBoolOperatorExpression(b.root, "IS NOT UNKNOWN")
 }
 
 func newBinaryBoolOperatorExpression(lhs, rhs Expression, operator string, additionalParams ...Expression) BoolExpression {
@@ -103,8 +103,8 @@ type boolExpressionWrapper struct {
 
 func newBoolExpressionWrap(expression Expression) BoolExpression {
 	boolExpressionWrap := &boolExpressionWrapper{Expression: expression}
-	boolExpressionWrap.boolInterfaceImpl.parent = boolExpressionWrap
+	boolExpressionWrap.boolInterfaceImpl.root = boolExpressionWrap
-	expression.setParent(boolExpressionWrap)
+	expression.setRoot(boolExpressionWrap)
 	return boolExpressionWrap
 }
 

internal/jet/cast.go

@@ -24,7 +24,7 @@ func (b *castImpl) AS(castType string) Expression {
 		cast:       string(castType),
 	}
 
-	castExp.ExpressionInterfaceImpl.Parent = castExp
+	castExp.ExpressionInterfaceImpl.Root = castExp
 
 	return castExp
 }

internal/jet/column.go

@@ -39,16 +39,16 @@ type ColumnExpressionImpl struct {
 }
 
 // NewColumnImpl creates new ColumnExpressionImpl
-func NewColumnImpl(name string, tableName string, parent ColumnExpression) *ColumnExpressionImpl {
+func NewColumnImpl(name string, tableName string, root ColumnExpression) *ColumnExpressionImpl {
 	newColumn := &ColumnExpressionImpl{
 		name:      name,
 		tableName: tableName,
 	}
 
-	if parent != nil {
+	if root != nil {
-		newColumn.ExpressionInterfaceImpl.Parent = parent
+		newColumn.ExpressionInterfaceImpl.Root = root
 	} else {
-		newColumn.ExpressionInterfaceImpl.Parent = newColumn
+		newColumn.ExpressionInterfaceImpl.Root = newColumn
 	}
 
 	return newColumn
@@ -100,11 +100,11 @@ func (c *ColumnExpressionImpl) serializeForProjection(statement StatementType, o
 
 func (c *ColumnExpressionImpl) serializeForJsonObjEntry(statement StatementType, out *SQLBuilder) {
 	out.WriteJsonObjKey(snaker.SnakeToCamel(c.name, false))
-	c.Parent.serializeForJsonValue(statement, out)
+	c.Root.serializeForJsonValue(statement, out)
 }
 
 func (c *ColumnExpressionImpl) serializeForRowToJsonProjection(statement StatementType, out *SQLBuilder) {
-	c.Parent.serializeForJsonValue(statement, out)
+	c.Root.serializeForJsonValue(statement, out)
 
 	out.WriteString("AS")
 

internal/jet/column_types.go

@@ -37,7 +37,7 @@ func (i *boolColumnImpl) SET(boolExp BoolExpression) ColumnAssigment {
 func BoolColumn(name string) ColumnBool {
 	boolColumn := &boolColumnImpl{}
 	boolColumn.ColumnExpressionImpl = NewColumnImpl(name, "", boolColumn)
-	boolColumn.boolInterfaceImpl.parent = boolColumn
+	boolColumn.boolInterfaceImpl.root = boolColumn
 
 	return boolColumn
 }
@@ -80,7 +80,7 @@ func (i *floatColumnImpl) SET(floatExp FloatExpression) ColumnAssigment {
 // FloatColumn creates named float column.
 func FloatColumn(name string) ColumnFloat {
 	floatColumn := &floatColumnImpl{}
-	floatColumn.floatInterfaceImpl.parent = floatColumn
+	floatColumn.floatInterfaceImpl.root = floatColumn
 	floatColumn.ColumnExpressionImpl = NewColumnImpl(name, "", floatColumn)
 
 	return floatColumn
@@ -125,7 +125,7 @@ func (i *integerColumnImpl) SET(intExp IntegerExpression) ColumnAssigment {
 // IntegerColumn creates named integer column.
 func IntegerColumn(name string) ColumnInteger {
 	integerColumn := &integerColumnImpl{}
-	integerColumn.integerInterfaceImpl.parent = integerColumn
+	integerColumn.integerInterfaceImpl.root = integerColumn
 	integerColumn.ColumnExpressionImpl = NewColumnImpl(name, "", integerColumn)
 
 	return integerColumn
@@ -171,7 +171,7 @@ func (i *stringColumnImpl) SET(stringExp StringExpression) ColumnAssigment {
 // StringColumn creates named string column.
 func StringColumn(name string) ColumnString {
 	stringColumn := &stringColumnImpl{}
-	stringColumn.stringInterfaceImpl.parent = stringColumn
+	stringColumn.stringInterfaceImpl.root = stringColumn
 	stringColumn.ColumnExpressionImpl = NewColumnImpl(name, "", stringColumn)
 
 	return stringColumn
@@ -216,7 +216,7 @@ func (i *blobColumnImpl) SET(blobExp BlobExpression) ColumnAssigment {
 // BlobColumn creates named blob column.
 func BlobColumn(name string) ColumnBlob {
 	blobColumn := &blobColumnImpl{}
-	blobColumn.blobInterfaceImpl.parent = blobColumn
+	blobColumn.blobInterfaceImpl.root = blobColumn
 	blobColumn.ColumnExpressionImpl = NewColumnImpl(name, "", blobColumn)
 
 	return blobColumn
@@ -260,7 +260,7 @@ func (i *timeColumnImpl) SET(timeExp TimeExpression) ColumnAssigment {
 // TimeColumn creates named time column
 func TimeColumn(name string) ColumnTime {
 	timeColumn := &timeColumnImpl{}
-	timeColumn.timeInterfaceImpl.parent = timeColumn
+	timeColumn.timeInterfaceImpl.root = timeColumn
 	timeColumn.ColumnExpressionImpl = NewColumnImpl(name, "", timeColumn)
 	return timeColumn
 }
@@ -303,7 +303,7 @@ func (i *timezColumnImpl) SET(timezExp TimezExpression) ColumnAssigment {
 // TimezColumn creates named time with time zone column.
 func TimezColumn(name string) ColumnTimez {
 	timezColumn := &timezColumnImpl{}
-	timezColumn.timezInterfaceImpl.parent = timezColumn
+	timezColumn.timezInterfaceImpl.root = timezColumn
 	timezColumn.ColumnExpressionImpl = NewColumnImpl(name, "", timezColumn)
 
 	return timezColumn
@@ -347,7 +347,7 @@ func (i *timestampColumnImpl) SET(timestampExp TimestampExpression) ColumnAssigm
 // TimestampColumn creates named timestamp column
 func TimestampColumn(name string) ColumnTimestamp {
 	timestampColumn := &timestampColumnImpl{}
-	timestampColumn.timestampInterfaceImpl.parent = timestampColumn
+	timestampColumn.timestampInterfaceImpl.root = timestampColumn
 	timestampColumn.ColumnExpressionImpl = NewColumnImpl(name, "", timestampColumn)
 
 	return timestampColumn
@@ -391,7 +391,7 @@ func (i *timestampzColumnImpl) SET(timestampzExp TimestampzExpression) ColumnAss
 // TimestampzColumn creates named timestamp with time zone column.
 func TimestampzColumn(name string) ColumnTimestampz {
 	timestampzColumn := &timestampzColumnImpl{}
-	timestampzColumn.timestampzInterfaceImpl.parent = timestampzColumn
+	timestampzColumn.timestampzInterfaceImpl.root = timestampzColumn
 	timestampzColumn.ColumnExpressionImpl = NewColumnImpl(name, "", timestampzColumn)
 
 	return timestampzColumn
@@ -435,7 +435,7 @@ func (i *dateColumnImpl) SET(dateExp DateExpression) ColumnAssigment {
 // DateColumn creates named date column.
 func DateColumn(name string) ColumnDate {
 	dateColumn := &dateColumnImpl{}
-	dateColumn.dateInterfaceImpl.parent = dateColumn
+	dateColumn.dateInterfaceImpl.root = dateColumn
 	dateColumn.ColumnExpressionImpl = NewColumnImpl(name, "", dateColumn)
 	return dateColumn
 }
@@ -481,7 +481,7 @@ func (i *intervalColumnImpl) From(subQuery SelectTable) ColumnInterval {
 func IntervalColumn(name string) ColumnInterval {
 	intervalColumn := &intervalColumnImpl{}
 	intervalColumn.ColumnExpressionImpl = NewColumnImpl(name, "", intervalColumn)
-	intervalColumn.intervalInterfaceImpl.parent = intervalColumn
+	intervalColumn.intervalInterfaceImpl.root = intervalColumn
 	return intervalColumn
 }
 
@@ -524,7 +524,7 @@ func (i *rangeColumnImpl[T]) SET(rangeExp Range[T]) ColumnAssigment {
 // RangeColumn creates named range column.
 func RangeColumn[T Expression](name string) ColumnRange[T] {
 	rangeColumn := &rangeColumnImpl[T]{}
-	rangeColumn.rangeInterfaceImpl.parent = rangeColumn
+	rangeColumn.rangeInterfaceImpl.root = rangeColumn
 	rangeColumn.ColumnExpressionImpl = NewColumnImpl(name, "", rangeColumn)
 
 	return rangeColumn

internal/jet/date_expression.go

@@ -21,55 +21,55 @@ type DateExpression interface {
 }
 
 type dateInterfaceImpl struct {
-	parent DateExpression
+	root DateExpression
 }
 
 func (d *dateInterfaceImpl) EQ(rhs DateExpression) BoolExpression {
-	return Eq(d.parent, rhs)
+	return Eq(d.root, rhs)
 }
 
 func (d *dateInterfaceImpl) NOT_EQ(rhs DateExpression) BoolExpression {
-	return NotEq(d.parent, rhs)
+	return NotEq(d.root, rhs)
 }
 
 func (d *dateInterfaceImpl) IS_DISTINCT_FROM(rhs DateExpression) BoolExpression {
-	return IsDistinctFrom(d.parent, rhs)
+	return IsDistinctFrom(d.root, rhs)
 }
 
 func (d *dateInterfaceImpl) IS_NOT_DISTINCT_FROM(rhs DateExpression) BoolExpression {
-	return IsNotDistinctFrom(d.parent, rhs)
+	return IsNotDistinctFrom(d.root, rhs)
 }
 
 func (d *dateInterfaceImpl) LT(rhs DateExpression) BoolExpression {
-	return Lt(d.parent, rhs)
+	return Lt(d.root, rhs)
 }
 
 func (d *dateInterfaceImpl) LT_EQ(rhs DateExpression) BoolExpression {
-	return LtEq(d.parent, rhs)
+	return LtEq(d.root, rhs)
 }
 
 func (d *dateInterfaceImpl) GT(rhs DateExpression) BoolExpression {
-	return Gt(d.parent, rhs)
+	return Gt(d.root, rhs)
 }
 
 func (d *dateInterfaceImpl) GT_EQ(rhs DateExpression) BoolExpression {
-	return GtEq(d.parent, rhs)
+	return GtEq(d.root, rhs)
 }
 
 func (d *dateInterfaceImpl) BETWEEN(min, max DateExpression) BoolExpression {
-	return NewBetweenOperatorExpression(d.parent, min, max, false)
+	return NewBetweenOperatorExpression(d.root, min, max, false)
 }
 
 func (d *dateInterfaceImpl) NOT_BETWEEN(min, max DateExpression) BoolExpression {
-	return NewBetweenOperatorExpression(d.parent, min, max, true)
+	return NewBetweenOperatorExpression(d.root, min, max, true)
 }
 
 func (d *dateInterfaceImpl) ADD(rhs Interval) TimestampExpression {
-	return TimestampExp(Add(d.parent, rhs))
+	return TimestampExp(Add(d.root, rhs))
 }
 
 func (d *dateInterfaceImpl) SUB(rhs Interval) TimestampExpression {
-	return TimestampExp(Sub(d.parent, rhs))
+	return TimestampExp(Sub(d.root, rhs))
 }
 
 //---------------------------------------------------//
@@ -81,8 +81,8 @@ type dateExpressionWrapper struct {
 
 func newDateExpressionWrap(expression Expression) DateExpression {
 	dateExpressionWrap := &dateExpressionWrapper{Expression: expression}
-	dateExpressionWrap.dateInterfaceImpl.parent = dateExpressionWrap
+	dateExpressionWrap.dateInterfaceImpl.root = dateExpressionWrap
-	expression.setParent(dateExpressionWrap)
+	expression.setRoot(dateExpressionWrap)
 	return dateExpressionWrap
 }
 

internal/jet/enum_value.go

@@ -11,8 +11,8 @@ type enumValue struct {
 func NewEnumValue(name string) StringExpression {
 	enumValue := &enumValue{name: name}
 
-	enumValue.ExpressionInterfaceImpl.Parent = enumValue
+	enumValue.ExpressionInterfaceImpl.Root = enumValue
-	enumValue.stringInterfaceImpl.parent = enumValue
+	enumValue.stringInterfaceImpl.root = enumValue
 
 	return enumValue
 }

internal/jet/expression.go

@@ -11,7 +11,7 @@ type Expression interface {
 	OrderByClause
 
 	serializeForJsonValue(statement StatementType, out *SQLBuilder)
-	setParent(parent Expression)
+	setRoot(root Expression)
 
 	// IS_NULL tests expression whether it is a NULL value.
 	IS_NULL() BoolExpression
@@ -34,69 +34,69 @@ type Expression interface {
 
 // ExpressionInterfaceImpl implements Expression interface methods
 type ExpressionInterfaceImpl struct {
-	Parent Expression
+	Root Expression
 }
 
-func (e *ExpressionInterfaceImpl) setParent(parent Expression) {
+func (e *ExpressionInterfaceImpl) setRoot(root Expression) {
-	e.Parent = parent
+	e.Root = root
 }
 
 func (e *ExpressionInterfaceImpl) fromImpl(subQuery SelectTable) Projection {
 	panic(fmt.Sprintf("jet: can't export unaliased expression subQuery: %s, expression: %s",
-		subQuery.Alias(), serializeToDefaultDebugString(e.Parent)))
+		subQuery.Alias(), serializeToDefaultDebugString(e.Root)))
 }
 
 // IS_NULL tests expression whether it is a NULL value.
 func (e *ExpressionInterfaceImpl) IS_NULL() BoolExpression {
-	return newPostfixBoolOperatorExpression(e.Parent, "IS NULL")
+	return newPostfixBoolOperatorExpression(e.Root, "IS NULL")
 }
 
 // IS_NOT_NULL tests expression whether it is a non-NULL value.
 func (e *ExpressionInterfaceImpl) IS_NOT_NULL() BoolExpression {
-	return newPostfixBoolOperatorExpression(e.Parent, "IS NOT NULL")
+	return newPostfixBoolOperatorExpression(e.Root, "IS NOT NULL")
 }
 
 // IN checks if this expressions matches any in expressions list
 func (e *ExpressionInterfaceImpl) IN(expressions ...Expression) BoolExpression {
-	return newBinaryBoolOperatorExpression(e.Parent, wrap(expressions...), "IN")
+	return newBinaryBoolOperatorExpression(e.Root, wrap(expressions...), "IN")
 }
 
 // NOT_IN checks if this expressions is different of all expressions in expressions list
 func (e *ExpressionInterfaceImpl) NOT_IN(expressions ...Expression) BoolExpression {
-	return newBinaryBoolOperatorExpression(e.Parent, wrap(expressions...), "NOT IN")
+	return newBinaryBoolOperatorExpression(e.Root, wrap(expressions...), "NOT IN")
 }
 
 // AS the temporary alias name to assign to the expression
 func (e *ExpressionInterfaceImpl) AS(alias string) Projection {
-	return newAlias(e.Parent, alias)
+	return newAlias(e.Root, alias)
 }
 
 // ASC expression will be used to sort a query result in ascending order
 func (e *ExpressionInterfaceImpl) ASC() OrderByClause {
-	return newOrderByAscending(e.Parent, true)
+	return newOrderByAscending(e.Root, true)
 }
 
 // DESC expression will be used to sort a query result in descending order
 func (e *ExpressionInterfaceImpl) DESC() OrderByClause {
-	return newOrderByAscending(e.Parent, false)
+	return newOrderByAscending(e.Root, false)
 }
 
 // NULLS_FIRST specifies sort where null values appear before all non-null values
 func (e *ExpressionInterfaceImpl) NULLS_FIRST() OrderByClause {
-	return newOrderByNullsFirst(e.Parent, true)
+	return newOrderByNullsFirst(e.Root, true)
 }
 
 // NULLS_LAST specifies sort where null values appear after all non-null values
 func (e *ExpressionInterfaceImpl) NULLS_LAST() OrderByClause {
-	return newOrderByNullsFirst(e.Parent, false)
+	return newOrderByNullsFirst(e.Root, false)
 }
 
 func (e *ExpressionInterfaceImpl) serializeForGroupBy(statement StatementType, out *SQLBuilder) {
-	e.Parent.serialize(statement, out, NoWrap)
+	e.Root.serialize(statement, out, NoWrap)
 }
 
 func (e *ExpressionInterfaceImpl) serializeForProjection(statement StatementType, out *SQLBuilder) {
-	e.Parent.serialize(statement, out, NoWrap)
+	e.Root.serialize(statement, out, NoWrap)
 }
 
 func (e *ExpressionInterfaceImpl) serializeForJsonObjEntry(statement StatementType, out *SQLBuilder) {
@@ -108,11 +108,11 @@ func (e *ExpressionInterfaceImpl) serializeForRowToJsonProjection(statement Stat
 }
 
 func (e *ExpressionInterfaceImpl) serializeForJsonValue(statement StatementType, out *SQLBuilder) {
-	out.Dialect.JsonValueEncode(e.Parent).serialize(statement, out)
+	out.Dialect.JsonValueEncode(e.Root).serialize(statement, out)
 }
 
 func (e *ExpressionInterfaceImpl) serializeForOrderBy(statement StatementType, out *SQLBuilder) {
-	e.Parent.serialize(statement, out, NoWrap)
+	e.Root.serialize(statement, out, NoWrap)
 }
 
 // Representation of binary operations (e.g. comparisons, arithmetic)
@@ -136,7 +136,7 @@ func NewBinaryOperatorExpression(lhs, rhs Serializer, operator string, additiona
 		binaryExpression.additionalParam = additionalParam[0]
 	}
 
-	binaryExpression.ExpressionInterfaceImpl.Parent = binaryExpression
+	binaryExpression.ExpressionInterfaceImpl.Root = binaryExpression
 
 	return complexExpr(binaryExpression)
 }
@@ -165,7 +165,7 @@ func newExpressionListOperator(operator string, expressions ...Expression) *expr
 		expressions: expressions,
 	}
 
-	ret.ExpressionInterfaceImpl.Parent = ret
+	ret.ExpressionInterfaceImpl.Root = ret
 
 	return ret
 }
@@ -224,7 +224,7 @@ func newPrefixOperatorExpression(expression Expression, operator string) Express
 		expression: expression,
 		operator:   operator,
 	}
-	prefixExpression.ExpressionInterfaceImpl.Parent = prefixExpression
+	prefixExpression.ExpressionInterfaceImpl.Root = prefixExpression
 
 	return complexExpr(prefixExpression)
 }
@@ -248,7 +248,7 @@ func newPostfixOperatorExpression(expression Expression, operator string) *postf
 		operator:   operator,
 	}
 
-	postfixOpExpression.ExpressionInterfaceImpl.Parent = postfixOpExpression
+	postfixOpExpression.ExpressionInterfaceImpl.Root = postfixOpExpression
 
 	return postfixOpExpression
 }
@@ -276,7 +276,7 @@ func NewBetweenOperatorExpression(expression, min, max Expression, notBetween bo
 		max:        max,
 	}
 
-	newBetweenOperator.ExpressionInterfaceImpl.Parent = newBetweenOperator
+	newBetweenOperator.ExpressionInterfaceImpl.Root = newBetweenOperator
 
 	return BoolExp(complexExpr(newBetweenOperator))
 }
@@ -301,7 +301,7 @@ func CustomExpression(parts ...Serializer) Expression {
 	ret := customExpression{
 		parts: parts,
 	}
-	ret.ExpressionInterfaceImpl.Parent = &ret
+	ret.ExpressionInterfaceImpl.Root = &ret
 	return &ret
 }
 
@@ -318,7 +318,7 @@ type complexExpression struct {
 
 func complexExpr(expression Expression) Expression {
 	complexExpression := &complexExpression{expressions: expression}
-	complexExpression.ExpressionInterfaceImpl.Parent = complexExpression
+	complexExpression.ExpressionInterfaceImpl.Root = complexExpression
 
 	return complexExpression
 }

internal/jet/float_expression.go

@@ -27,71 +27,71 @@ type FloatExpression interface {
 
 type floatInterfaceImpl struct {
 	numericExpressionImpl
-	parent FloatExpression
+	root FloatExpression
 }
 
 func (n *floatInterfaceImpl) EQ(rhs FloatExpression) BoolExpression {
-	return Eq(n.parent, rhs)
+	return Eq(n.root, rhs)
 }
 
 func (n *floatInterfaceImpl) NOT_EQ(rhs FloatExpression) BoolExpression {
-	return NotEq(n.parent, rhs)
+	return NotEq(n.root, rhs)
 }
 
 func (n *floatInterfaceImpl) IS_DISTINCT_FROM(rhs FloatExpression) BoolExpression {
-	return IsDistinctFrom(n.parent, rhs)
+	return IsDistinctFrom(n.root, rhs)
 }
 
 func (n *floatInterfaceImpl) IS_NOT_DISTINCT_FROM(rhs FloatExpression) BoolExpression {
-	return IsNotDistinctFrom(n.parent, rhs)
+	return IsNotDistinctFrom(n.root, rhs)
 }
 
 func (n *floatInterfaceImpl) GT(rhs FloatExpression) BoolExpression {
-	return Gt(n.parent, rhs)
+	return Gt(n.root, rhs)
 }
 
 func (n *floatInterfaceImpl) GT_EQ(rhs FloatExpression) BoolExpression {
-	return GtEq(n.parent, rhs)
+	return GtEq(n.root, rhs)
 }
 
 func (n *floatInterfaceImpl) LT(rhs FloatExpression) BoolExpression {
-	return Lt(n.parent, rhs)
+	return Lt(n.root, rhs)
 }
 
 func (n *floatInterfaceImpl) LT_EQ(rhs FloatExpression) BoolExpression {
-	return LtEq(n.parent, rhs)
+	return LtEq(n.root, rhs)
 }
 
 func (n *floatInterfaceImpl) BETWEEN(min, max FloatExpression) BoolExpression {
-	return NewBetweenOperatorExpression(n.parent, min, max, false)
+	return NewBetweenOperatorExpression(n.root, min, max, false)
 }
 
 func (n *floatInterfaceImpl) NOT_BETWEEN(min, max FloatExpression) BoolExpression {
-	return NewBetweenOperatorExpression(n.parent, min, max, true)
+	return NewBetweenOperatorExpression(n.root, min, max, true)
 }
 
 func (n *floatInterfaceImpl) ADD(rhs NumericExpression) FloatExpression {
-	return FloatExp(Add(n.parent, rhs))
+	return FloatExp(Add(n.root, rhs))
 }
 
 func (n *floatInterfaceImpl) SUB(rhs NumericExpression) FloatExpression {
-	return FloatExp(Sub(n.parent, rhs))
+	return FloatExp(Sub(n.root, rhs))
 }
 
 func (n *floatInterfaceImpl) MUL(rhs NumericExpression) FloatExpression {
-	return FloatExp(Mul(n.parent, rhs))
+	return FloatExp(Mul(n.root, rhs))
 }
 
 func (n *floatInterfaceImpl) DIV(rhs NumericExpression) FloatExpression {
-	return FloatExp(Div(n.parent, rhs))
+	return FloatExp(Div(n.root, rhs))
 }
 
 func (n *floatInterfaceImpl) MOD(rhs NumericExpression) FloatExpression {
-	return FloatExp(Mod(n.parent, rhs))
+	return FloatExp(Mod(n.root, rhs))
 }
 
 func (n *floatInterfaceImpl) POW(rhs NumericExpression) FloatExpression {
-	return POW(n.parent, rhs)
+	return POW(n.root, rhs)
 }
 
 //---------------------------------------------------//
@@ -103,8 +103,8 @@ type floatExpressionWrapper struct {
 
 func newFloatExpressionWrap(expression Expression) FloatExpression {
 	floatExpressionWrap := &floatExpressionWrapper{Expression: expression}
-	floatExpressionWrap.floatInterfaceImpl.parent = floatExpressionWrap
+	floatExpressionWrap.floatInterfaceImpl.root = floatExpressionWrap
-	expression.setParent(floatExpressionWrap)
+	expression.setRoot(floatExpressionWrap)
 	return floatExpressionWrap
 }
 

internal/jet/func_expression.go

@@ -674,16 +674,16 @@ type funcExpressionImpl struct {
 }
 
 // NewFunc creates new function with name and expressions parameters
-func NewFunc(name string, expressions []Expression, parent Expression) *funcExpressionImpl {
+func NewFunc(name string, expressions []Expression, root Expression) *funcExpressionImpl {
 	funcExp := &funcExpressionImpl{
 		name:       name,
 		parameters: parametersSerializer(expressions),
 	}
 
-	if parent != nil {
+	if root != nil {
-		funcExp.ExpressionInterfaceImpl.Parent = parent
+		funcExp.ExpressionInterfaceImpl.Root = root
 	} else {
-		funcExp.ExpressionInterfaceImpl.Parent = funcExp
+		funcExp.ExpressionInterfaceImpl.Root = funcExp
 	}
 
 	return funcExp
@@ -732,7 +732,7 @@ func (p parametersSerializer) serialize(statement StatementType, out *SQLBuilder
 func newWindowFunc(name string, expressions ...Expression) windowExpression {
 	newFun := NewFunc(name, expressions, nil)
 	windowExpr := newWindowExpression(newFun)
-	newFun.ExpressionInterfaceImpl.Parent = windowExpr
+	newFun.ExpressionInterfaceImpl.Root = windowExpr
 
 	return windowExpr
 }
@@ -746,8 +746,8 @@ func newBoolFunc(name string, expressions ...Expression) BoolExpression {
 	boolFunc := &boolFunc{}
 
 	boolFunc.funcExpressionImpl = *NewFunc(name, expressions, boolFunc)
-	boolFunc.boolInterfaceImpl.parent = boolFunc
+	boolFunc.boolInterfaceImpl.root = boolFunc
-	boolFunc.ExpressionInterfaceImpl.Parent = boolFunc
+	boolFunc.ExpressionInterfaceImpl.Root = boolFunc
 
 	return boolFunc
 }
@@ -758,8 +758,8 @@ func newBoolWindowFunc(name string, expressions ...Expression) boolWindowExpress
 
 	boolFunc.funcExpressionImpl = *NewFunc(name, expressions, boolFunc)
 	intWindowFunc := newBoolWindowExpression(boolFunc)
-	boolFunc.boolInterfaceImpl.parent = intWindowFunc
+	boolFunc.boolInterfaceImpl.root = intWindowFunc
-	boolFunc.ExpressionInterfaceImpl.Parent = intWindowFunc
+	boolFunc.ExpressionInterfaceImpl.Root = intWindowFunc
 
 	return intWindowFunc
 }
@@ -774,7 +774,7 @@ func NewFloatFunc(name string, expressions ...Expression) FloatExpression {
 	floatFunc := &floatFunc{}
 
 	floatFunc.funcExpressionImpl = *NewFunc(name, expressions, floatFunc)
-	floatFunc.floatInterfaceImpl.parent = floatFunc
+	floatFunc.floatInterfaceImpl.root = floatFunc
 
 	return floatFunc
 }
@@ -785,8 +785,8 @@ func NewFloatWindowFunc(name string, expressions ...Expression) floatWindowExpre
 
 	floatFunc.funcExpressionImpl = *NewFunc(name, expressions, floatFunc)
 	floatWindowFunc := newFloatWindowExpression(floatFunc)
-	floatFunc.floatInterfaceImpl.parent = floatWindowFunc
+	floatFunc.floatInterfaceImpl.root = floatWindowFunc
-	floatFunc.ExpressionInterfaceImpl.Parent = floatWindowFunc
+	floatFunc.ExpressionInterfaceImpl.Root = floatWindowFunc
 
 	return floatWindowFunc
 }
@@ -800,7 +800,7 @@ func newIntegerFunc(name string, expressions ...Expression) IntegerExpression {
 	intFunc := &integerFunc{}
 
 	intFunc.funcExpressionImpl = *NewFunc(name, expressions, intFunc)
-	intFunc.integerInterfaceImpl.parent = intFunc
+	intFunc.integerInterfaceImpl.root = intFunc
 
 	return intFunc
 }
@@ -811,8 +811,8 @@ func newIntegerWindowFunc(name string, expressions ...Expression) integerWindowE
 
 	integerFunc.funcExpressionImpl = *NewFunc(name, expressions, integerFunc)
 	intWindowFunc := newIntegerWindowExpression(integerFunc)
-	integerFunc.integerInterfaceImpl.parent = intWindowFunc
+	integerFunc.integerInterfaceImpl.root = intWindowFunc
-	integerFunc.ExpressionInterfaceImpl.Parent = intWindowFunc
+	integerFunc.ExpressionInterfaceImpl.Root = intWindowFunc
 
 	return intWindowFunc
 }
@@ -827,7 +827,7 @@ func NewStringFunc(name string, expressions ...Expression) StringExpression {
 	stringFunc := &stringFunc{}
 
 	stringFunc.funcExpressionImpl = *NewFunc(name, expressions, stringFunc)
-	stringFunc.stringInterfaceImpl.parent = stringFunc
+	stringFunc.stringInterfaceImpl.root = stringFunc
 
 	return stringFunc
 }
@@ -842,7 +842,7 @@ func NewDateFunc(name string, expressions ...Expression) *dateFunc {
 	dateFunc := &dateFunc{}
 
 	dateFunc.funcExpressionImpl = *NewFunc(name, expressions, dateFunc)
-	dateFunc.dateInterfaceImpl.parent = dateFunc
+	dateFunc.dateInterfaceImpl.root = dateFunc
 
 	return dateFunc
 }
@@ -857,7 +857,7 @@ func NewTimeFunc(name string, expressions ...Expression) *timeFunc {
 	timeFun := &timeFunc{}
 
 	timeFun.funcExpressionImpl = *NewFunc(name, expressions, timeFun)
-	timeFun.timeInterfaceImpl.parent = timeFun
+	timeFun.timeInterfaceImpl.root = timeFun
 
 	return timeFun
 }
@@ -871,7 +871,7 @@ func newTimezFunc(name string, expressions ...Expression) *timezFunc {
 	timezFun := &timezFunc{}
 
 	timezFun.funcExpressionImpl = *NewFunc(name, expressions, timezFun)
-	timezFun.timezInterfaceImpl.parent = timezFun
+	timezFun.timezInterfaceImpl.root = timezFun
 
 	return timezFun
 }
@@ -886,7 +886,7 @@ func NewTimestampFunc(name string, expressions ...Expression) *timestampFunc {
 	timestampFunc := &timestampFunc{}
 
 	timestampFunc.funcExpressionImpl = *NewFunc(name, expressions, timestampFunc)
-	timestampFunc.timestampInterfaceImpl.parent = timestampFunc
+	timestampFunc.timestampInterfaceImpl.root = timestampFunc
 
 	return timestampFunc
 }
@@ -900,7 +900,7 @@ func newTimestampzFunc(name string, expressions ...Expression) *timestampzFunc {
 	timestampzFunc := &timestampzFunc{}
 
 	timestampzFunc.funcExpressionImpl = *NewFunc(name, expressions, timestampzFunc)
-	timestampzFunc.timestampzInterfaceImpl.parent = timestampzFunc
+	timestampzFunc.timestampzInterfaceImpl.root = timestampzFunc
 
 	return timestampzFunc
 }

internal/jet/integer_expression.go

@@ -39,91 +39,91 @@ type (
 
 type integerInterfaceImpl struct {
 	numericExpressionImpl
-	parent IntegerExpression
+	root IntegerExpression
 }
 
 func (i *integerInterfaceImpl) EQ(rhs IntegerExpression) BoolExpression {
-	return Eq(i.parent, rhs)
+	return Eq(i.root, rhs)
 }
 
 func (i *integerInterfaceImpl) NOT_EQ(rhs IntegerExpression) BoolExpression {
-	return NotEq(i.parent, rhs)
+	return NotEq(i.root, rhs)
 }
 
 func (i *integerInterfaceImpl) IS_DISTINCT_FROM(rhs IntegerExpression) BoolExpression {
-	return IsDistinctFrom(i.parent, rhs)
+	return IsDistinctFrom(i.root, rhs)
 }
 
 func (i *integerInterfaceImpl) IS_NOT_DISTINCT_FROM(rhs IntegerExpression) BoolExpression {
-	return IsNotDistinctFrom(i.parent, rhs)
+	return IsNotDistinctFrom(i.root, rhs)
 }
 
 func (i *integerInterfaceImpl) GT(rhs IntegerExpression) BoolExpression {
-	return Gt(i.parent, rhs)
+	return Gt(i.root, rhs)
 }
 
 func (i *integerInterfaceImpl) GT_EQ(rhs IntegerExpression) BoolExpression {
-	return GtEq(i.parent, rhs)
+	return GtEq(i.root, rhs)
 }
 
 func (i *integerInterfaceImpl) LT(rhs IntegerExpression) BoolExpression {
-	return Lt(i.parent, rhs)
+	return Lt(i.root, rhs)
 }
 
 func (i *integerInterfaceImpl) LT_EQ(rhs IntegerExpression) BoolExpression {
-	return LtEq(i.parent, rhs)
+	return LtEq(i.root, rhs)
 }
 
 func (i *integerInterfaceImpl) BETWEEN(min, max IntegerExpression) BoolExpression {
-	return NewBetweenOperatorExpression(i.parent, min, max, false)
+	return NewBetweenOperatorExpression(i.root, min, max, false)
 }
 
 func (i *integerInterfaceImpl) NOT_BETWEEN(min, max IntegerExpression) BoolExpression {
-	return NewBetweenOperatorExpression(i.parent, min, max, true)
+	return NewBetweenOperatorExpression(i.root, min, max, true)
 }
 
 func (i *integerInterfaceImpl) ADD(rhs IntegerExpression) IntegerExpression {
-	return IntExp(Add(i.parent, rhs))
+	return IntExp(Add(i.root, rhs))
 }
 
 func (i *integerInterfaceImpl) SUB(rhs IntegerExpression) IntegerExpression {
-	return IntExp(Sub(i.parent, rhs))
+	return IntExp(Sub(i.root, rhs))
 }
 
 func (i *integerInterfaceImpl) MUL(rhs IntegerExpression) IntegerExpression {
-	return IntExp(Mul(i.parent, rhs))
+	return IntExp(Mul(i.root, rhs))
 }
 
 func (i *integerInterfaceImpl) DIV(rhs IntegerExpression) IntegerExpression {
-	return IntExp(Div(i.parent, rhs))
+	return IntExp(Div(i.root, rhs))
 }
 
 func (i *integerInterfaceImpl) MOD(rhs IntegerExpression) IntegerExpression {
-	return IntExp(Mod(i.parent, rhs))
+	return IntExp(Mod(i.root, rhs))
 }
 
 func (i *integerInterfaceImpl) POW(rhs IntegerExpression) IntegerExpression {
-	return IntExp(POW(i.parent, rhs))
+	return IntExp(POW(i.root, rhs))
 }
 
 func (i *integerInterfaceImpl) BIT_AND(rhs IntegerExpression) IntegerExpression {
-	return newBinaryIntegerOperatorExpression(i.parent, rhs, "&")
+	return newBinaryIntegerOperatorExpression(i.root, rhs, "&")
 }
 
 func (i *integerInterfaceImpl) BIT_OR(rhs IntegerExpression) IntegerExpression {
-	return newBinaryIntegerOperatorExpression(i.parent, rhs, "|")
+	return newBinaryIntegerOperatorExpression(i.root, rhs, "|")
 }
 
 func (i *integerInterfaceImpl) BIT_XOR(rhs IntegerExpression) IntegerExpression {
-	return newBinaryIntegerOperatorExpression(i.parent, rhs, "#")
+	return newBinaryIntegerOperatorExpression(i.root, rhs, "#")
 }
 
 func (i *integerInterfaceImpl) BIT_SHIFT_LEFT(intExpression IntegerExpression) IntegerExpression {
-	return newBinaryIntegerOperatorExpression(i.parent, intExpression, "<<")
+	return newBinaryIntegerOperatorExpression(i.root, intExpression, "<<")
 }
 
 func (i *integerInterfaceImpl) BIT_SHIFT_RIGHT(intExpression IntegerExpression) IntegerExpression {
-	return newBinaryIntegerOperatorExpression(i.parent, intExpression, ">>")
+	return newBinaryIntegerOperatorExpression(i.root, intExpression, ">>")
 }
 
 func newBinaryIntegerOperatorExpression(lhs, rhs IntegerExpression, operator string) IntegerExpression {
@@ -142,8 +142,8 @@ type integerExpressionWrapper struct {
 
 func newIntExpressionWrap(expression Expression) IntegerExpression {
 	intExpressionWrap := &integerExpressionWrapper{Expression: expression}
-	intExpressionWrap.integerInterfaceImpl.parent = intExpressionWrap
+	intExpressionWrap.integerInterfaceImpl.root = intExpressionWrap
-	expression.setParent(intExpressionWrap)
+	expression.setRoot(intExpressionWrap)
 
 	return intExpressionWrap
 }

internal/jet/interval_expression.go

@@ -25,65 +25,65 @@ type IntervalExpression interface {
 }
 
 type intervalInterfaceImpl struct {
-	parent IntervalExpression
+	root IntervalExpression
 }
 
 func (i *intervalInterfaceImpl) isInterval() {}
 
 func (i *intervalInterfaceImpl) EQ(rhs IntervalExpression) BoolExpression {
-	return Eq(i.parent, rhs)
+	return Eq(i.root, rhs)
 }
 
 func (i *intervalInterfaceImpl) NOT_EQ(rhs IntervalExpression) BoolExpression {
-	return NotEq(i.parent, rhs)
+	return NotEq(i.root, rhs)
 }
 
 func (i *intervalInterfaceImpl) IS_DISTINCT_FROM(rhs IntervalExpression) BoolExpression {
-	return IsDistinctFrom(i.parent, rhs)
+	return IsDistinctFrom(i.root, rhs)
 }
 
 func (i *intervalInterfaceImpl) IS_NOT_DISTINCT_FROM(rhs IntervalExpression) BoolExpression {
-	return IsNotDistinctFrom(i.parent, rhs)
+	return IsNotDistinctFrom(i.root, rhs)
 }
 
 func (i *intervalInterfaceImpl) LT(rhs IntervalExpression) BoolExpression {
-	return Lt(i.parent, rhs)
+	return Lt(i.root, rhs)
 }
 
 func (i *intervalInterfaceImpl) LT_EQ(rhs IntervalExpression) BoolExpression {
-	return LtEq(i.parent, rhs)
+	return LtEq(i.root, rhs)
 }
 
 func (i *intervalInterfaceImpl) GT(rhs IntervalExpression) BoolExpression {
-	return Gt(i.parent, rhs)
+	return Gt(i.root, rhs)
 }
 
 func (i *intervalInterfaceImpl) GT_EQ(rhs IntervalExpression) BoolExpression {
-	return GtEq(i.parent, rhs)
+	return GtEq(i.root, rhs)
 }
 
 func (i *intervalInterfaceImpl) BETWEEN(min, max IntervalExpression) BoolExpression {
-	return NewBetweenOperatorExpression(i.parent, min, max, false)
+	return NewBetweenOperatorExpression(i.root, min, max, false)
 }
 
 func (i *intervalInterfaceImpl) NOT_BETWEEN(min, max IntervalExpression) BoolExpression {
-	return NewBetweenOperatorExpression(i.parent, min, max, true)
+	return NewBetweenOperatorExpression(i.root, min, max, true)
 }
 
 func (i *intervalInterfaceImpl) ADD(rhs IntervalExpression) IntervalExpression {
-	return IntervalExp(Add(i.parent, rhs))
+	return IntervalExp(Add(i.root, rhs))
 }
 
 func (i *intervalInterfaceImpl) SUB(rhs IntervalExpression) IntervalExpression {
-	return IntervalExp(Sub(i.parent, rhs))
+	return IntervalExp(Sub(i.root, rhs))
 }
 
 func (i *intervalInterfaceImpl) MUL(rhs NumericExpression) IntervalExpression {
-	return IntervalExp(Mul(i.parent, rhs))
+	return IntervalExp(Mul(i.root, rhs))
 }
 
 func (i *intervalInterfaceImpl) DIV(rhs NumericExpression) IntervalExpression {
-	return IntervalExp(Div(i.parent, rhs))
+	return IntervalExp(Div(i.root, rhs))
 }
 
 type intervalWrapper struct {
@@ -93,8 +93,8 @@ type intervalWrapper struct {
 
 func newIntervalExpressionWrap(expression Expression) IntervalExpression {
 	intervalWrap := &intervalWrapper{Expression: expression}
-	intervalWrap.intervalInterfaceImpl.parent = intervalWrap
+	intervalWrap.intervalInterfaceImpl.root = intervalWrap
-	expression.setParent(intervalWrap)
+	expression.setRoot(intervalWrap)
 	return intervalWrap
 }
 

internal/jet/literal_expression.go

@@ -27,7 +27,7 @@ func literal(value interface{}, optionalConstant ...bool) *literalExpressionImpl
 		exp.constant = optionalConstant[0]
 	}
 
-	exp.ExpressionInterfaceImpl.Parent = &exp
+	exp.ExpressionInterfaceImpl.Root = &exp
 
 	return &exp
 }
@@ -72,8 +72,8 @@ func intLiteral(value interface{}) IntegerExpression {
 
 	numLiteral.literalExpressionImpl = *literal(value)
 
-	numLiteral.literalExpressionImpl.Parent = numLiteral
+	numLiteral.literalExpressionImpl.Root = numLiteral
-	numLiteral.integerInterfaceImpl.parent = numLiteral
+	numLiteral.integerInterfaceImpl.root = numLiteral
 
 	return numLiteral
 }
@@ -129,7 +129,7 @@ func Bool(value bool) BoolExpression {
 	boolLiteralExpression := boolLiteralExpression{}
 
 	boolLiteralExpression.literalExpressionImpl = *literal(value)
-	boolLiteralExpression.boolInterfaceImpl.parent = &boolLiteralExpression
+	boolLiteralExpression.boolInterfaceImpl.root = &boolLiteralExpression
 
 	return &boolLiteralExpression
 }
@@ -145,7 +145,7 @@ func Float(value float64) FloatExpression {
 	floatLiteral := floatLiteral{}
 	floatLiteral.literalExpressionImpl = *literal(value)
 
-	floatLiteral.floatInterfaceImpl.parent = &floatLiteral
+	floatLiteral.floatInterfaceImpl.root = &floatLiteral
 
 	return &floatLiteral
 }
@@ -155,7 +155,7 @@ func Decimal(value string) FloatExpression {
 	floatLiteral := floatLiteral{}
 	floatLiteral.literalExpressionImpl = *literal(value)
 
-	floatLiteral.floatInterfaceImpl.parent = &floatLiteral
+	floatLiteral.floatInterfaceImpl.root = &floatLiteral
 
 	return &floatLiteral
 }
@@ -171,7 +171,7 @@ func String(value string) StringExpression {
 	stringLiteral := stringLiteral{}
 	stringLiteral.literalExpressionImpl = *literal(value)
 
-	stringLiteral.stringInterfaceImpl.parent = &stringLiteral
+	stringLiteral.stringInterfaceImpl.root = &stringLiteral
 
 	return &stringLiteral
 }
@@ -190,7 +190,7 @@ func Time(hour, minute, second int, nanoseconds ...time.Duration) TimeExpression
 	timeStr += formatNanoseconds(nanoseconds...)
 	timeLiteral.literalExpressionImpl = *literal(timeStr)
 
-	timeLiteral.timeInterfaceImpl.parent = timeLiteral
+	timeLiteral.timeInterfaceImpl.root = timeLiteral
 
 	return timeLiteral
 }
@@ -199,7 +199,7 @@ func Time(hour, minute, second int, nanoseconds ...time.Duration) TimeExpression
 func TimeT(t time.Time) TimeExpression {
 	timeLiteral := &timeLiteral{}
 	timeLiteral.literalExpressionImpl = *literal(t)
-	timeLiteral.timeInterfaceImpl.parent = timeLiteral
+	timeLiteral.timeInterfaceImpl.root = timeLiteral
 
 	return timeLiteral
 }
@@ -226,7 +226,7 @@ func Timez(hour, minute, second int, nanoseconds time.Duration, timezone string)
 func TimezT(t time.Time) TimezExpression {
 	timeLiteral := &timezLiteral{}
 	timeLiteral.literalExpressionImpl = *literal(t)
-	timeLiteral.timezInterfaceImpl.parent = timeLiteral
+	timeLiteral.timezInterfaceImpl.root = timeLiteral
 
 	return timeLiteral
 }
@@ -244,7 +244,7 @@ func Timestamp(year int, month time.Month, day, hour, minute, second int, nanose
 	timeStr := fmt.Sprintf("%04d-%02d-%02d %02d:%02d:%02d", year, month, day, hour, minute, second)
 	timeStr += formatNanoseconds(nanoseconds...)
 	timestamp.literalExpressionImpl = *literal(timeStr)
-	timestamp.timestampInterfaceImpl.parent = timestamp
+	timestamp.timestampInterfaceImpl.root = timestamp
 	return timestamp
 }
 
@@ -252,7 +252,7 @@ func Timestamp(year int, month time.Month, day, hour, minute, second int, nanose
 func TimestampT(t time.Time) TimestampExpression {
 	timestamp := &timestampLiteral{}
 	timestamp.literalExpressionImpl = *literal(t)
-	timestamp.timestampInterfaceImpl.parent = timestamp
+	timestamp.timestampInterfaceImpl.root = timestamp
 	return timestamp
 }
 
@@ -271,7 +271,7 @@ func Timestampz(year int, month time.Month, day, hour, minute, second int, nanos
 	timeStr += " " + timezone
 
 	timestamp.literalExpressionImpl = *literal(timeStr)
-	timestamp.timestampzInterfaceImpl.parent = timestamp
+	timestamp.timestampzInterfaceImpl.root = timestamp
 	return timestamp
 }
 
@@ -279,7 +279,7 @@ func Timestampz(year int, month time.Month, day, hour, minute, second int, nanos
 func TimestampzT(t time.Time) TimestampzExpression {
 	timestamp := &timestampzLiteral{}
 	timestamp.literalExpressionImpl = *literal(t)
-	timestamp.timestampzInterfaceImpl.parent = timestamp
+	timestamp.timestampzInterfaceImpl.root = timestamp
 	return timestamp
 }
 
@@ -296,7 +296,7 @@ func Date(year int, month time.Month, day int) DateExpression {
 
 	timeStr := fmt.Sprintf("%04d-%02d-%02d", year, month, day)
 	dateLiteral.literalExpressionImpl = *literal(timeStr)
-	dateLiteral.dateInterfaceImpl.parent = dateLiteral
+	dateLiteral.dateInterfaceImpl.root = dateLiteral
 
 	return dateLiteral
 }
@@ -305,7 +305,7 @@ func Date(year int, month time.Month, day int) DateExpression {
 func DateT(t time.Time) DateExpression {
 	dateLiteral := &dateLiteral{}
 	dateLiteral.literalExpressionImpl = *literal(t)
-	dateLiteral.dateInterfaceImpl.parent = dateLiteral
+	dateLiteral.dateInterfaceImpl.root = dateLiteral
 
 	return dateLiteral
 }
@@ -346,7 +346,7 @@ type nullLiteral struct {
 func newNullLiteral() Expression {
 	nullExpression := &nullLiteral{}
 
-	nullExpression.ExpressionInterfaceImpl.Parent = nullExpression
+	nullExpression.ExpressionInterfaceImpl.Root = nullExpression
 
 	return nullExpression
 }
@@ -363,7 +363,7 @@ type starLiteral struct {
 func newStarLiteral() Expression {
 	starExpression := &starLiteral{}
 
-	starExpression.ExpressionInterfaceImpl.Parent = starExpression
+	starExpression.ExpressionInterfaceImpl.Root = starExpression
 
 	return starExpression
 }
@@ -407,7 +407,7 @@ func Raw(raw string, namedArgs ...map[string]interface{}) Expression {
 		Raw:           raw,
 		NamedArgument: namedArguments,
 	}
-	rawExp.ExpressionInterfaceImpl.Parent = rawExp
+	rawExp.ExpressionInterfaceImpl.Root = rawExp
 
 	return rawExp
 }

internal/jet/operators.go

@@ -132,7 +132,7 @@ func CASE(expression ...Expression) CaseOperator {
 		caseExp.expression = expression[0]
 	}
 
-	caseExp.ExpressionInterfaceImpl.Parent = caseExp
+	caseExp.ExpressionInterfaceImpl.Root = caseExp
 
 	return caseExp
 }

internal/jet/order_set_aggregate_functions.go

@@ -42,7 +42,7 @@ func newOrderSetAggregateFuncExpression(aggFunc OrderSetAggregateFunc) *orderSet
 		OrderSetAggregateFunc: aggFunc,
 	}
 
-	ret.ExpressionInterfaceImpl.Parent = ret
+	ret.ExpressionInterfaceImpl.Root = ret
 
 	return ret
 }

internal/jet/range_expression.go

@@ -29,85 +29,85 @@ type Range[T Expression] interface {
 }
 
 type rangeInterfaceImpl[T Expression] struct {
-	parent Range[T]
+	root Range[T]
 }
 
 func (r *rangeInterfaceImpl[T]) EQ(rhs Range[T]) BoolExpression {
-	return Eq(r.parent, rhs)
+	return Eq(r.root, rhs)
 }
 
 func (r *rangeInterfaceImpl[T]) NOT_EQ(rhs Range[T]) BoolExpression {
-	return NotEq(r.parent, rhs)
+	return NotEq(r.root, rhs)
 }
 
 func (r *rangeInterfaceImpl[T]) LT(rhs Range[T]) BoolExpression {
-	return Lt(r.parent, rhs)
+	return Lt(r.root, rhs)
 }
 
 func (r *rangeInterfaceImpl[T]) LT_EQ(rhs Range[T]) BoolExpression {
-	return LtEq(r.parent, rhs)
+	return LtEq(r.root, rhs)
 
 }
 
 func (r *rangeInterfaceImpl[T]) GT(rhs Range[T]) BoolExpression {
-	return Gt(r.parent, rhs)
+	return Gt(r.root, rhs)
 
 }
 
 func (r *rangeInterfaceImpl[T]) GT_EQ(rhs Range[T]) BoolExpression {
-	return GtEq(r.parent, rhs)
+	return GtEq(r.root, rhs)
 }
 
 func (r *rangeInterfaceImpl[T]) CONTAINS(rhs T) BoolExpression {
-	return Contains(r.parent, rhs)
+	return Contains(r.root, rhs)
 }
 
 func (r *rangeInterfaceImpl[T]) CONTAINS_RANGE(rhs Range[T]) BoolExpression {
-	return Contains(r.parent, rhs)
+	return Contains(r.root, rhs)
 }
 
 func (r *rangeInterfaceImpl[T]) OVERLAP(rhs Range[T]) BoolExpression {
-	return Overlap(r.parent, rhs)
+	return Overlap(r.root, rhs)
 }
 
 func (r *rangeInterfaceImpl[T]) UNION(rhs Range[T]) Range[T] {
-	return RangeExp[T](Add(r.parent, rhs))
+	return RangeExp[T](Add(r.root, rhs))
 }
 
 func (r *rangeInterfaceImpl[T]) INTERSECTION(rhs Range[T]) Range[T] {
-	return RangeExp[T](Mul(r.parent, rhs))
+	return RangeExp[T](Mul(r.root, rhs))
 }
 
 func (r *rangeInterfaceImpl[T]) DIFFERENCE(rhs Range[T]) Range[T] {
-	return RangeExp[T](Sub(r.parent, rhs))
+	return RangeExp[T](Sub(r.root, rhs))
 }
 
 func (r *rangeInterfaceImpl[T]) UPPER_BOUND() T {
-	return UPPER_BOUND(r.parent)
+	return UPPER_BOUND(r.root)
 }
 
 func (r *rangeInterfaceImpl[T]) LOWER_BOUND() T {
-	return LOWER_BOUND(r.parent)
+	return LOWER_BOUND(r.root)
 }
 
 func (r *rangeInterfaceImpl[T]) IS_EMPTY() BoolExpression {
-	return IS_EMPTY(r.parent)
+	return IS_EMPTY(r.root)
 }
 
 func (r *rangeInterfaceImpl[T]) LOWER_INC() BoolExpression {
-	return LOWER_INC(r.parent)
+	return LOWER_INC(r.root)
 }
 
 func (r *rangeInterfaceImpl[T]) UPPER_INC() BoolExpression {
-	return UPPER_INC(r.parent)
+	return UPPER_INC(r.root)
 }
 
 func (r *rangeInterfaceImpl[T]) LOWER_INF() BoolExpression {
-	return LOWER_INF(r.parent)
+	return LOWER_INF(r.root)
 }
 
 func (r *rangeInterfaceImpl[T]) UPPER_INF() BoolExpression {
-	return UPPER_INF(r.parent)
+	return UPPER_INF(r.root)
 }
 
 //---------------------------------------------------//
@@ -119,8 +119,8 @@ type rangeExpressionWrapper[T Expression] struct {
 
 func newRangeExpressionWrap[T Expression](expression Expression) Range[T] {
 	rangeExpressionWrap := &rangeExpressionWrapper[T]{Expression: expression}
-	rangeExpressionWrap.rangeInterfaceImpl.parent = rangeExpressionWrap
+	rangeExpressionWrap.rangeInterfaceImpl.root = rangeExpressionWrap
-	expression.setParent(rangeExpressionWrap)
+	expression.setRoot(rangeExpressionWrap)
 	return rangeExpressionWrap
 }
 

internal/jet/raw_statement.go

@@ -13,7 +13,7 @@ func RawStatement(dialect Dialect, rawQuery string, namedArgument ...map[string]
 		statementInterfaceImpl: statementInterfaceImpl{
 			dialect:       dialect,
 			statementType: "",
-			parent:        nil,
+			root:          nil,
 		},
 		RawQuery: rawQuery,
 	}
@@ -22,7 +22,7 @@ func RawStatement(dialect Dialect, rawQuery string, namedArgument ...map[string]
 		newRawStatement.NamedArguments = namedArgument[0]
 	}
 
-	newRawStatement.parent = &newRawStatement
+	newRawStatement.root = &newRawStatement
 
 	return &newRawStatement
 }

internal/jet/row_expression.go

@@ -17,41 +17,41 @@ type RowExpression interface {
 }
 
 type rowInterfaceImpl struct {
-	parent      Expression
+	root        Expression
 	dialect     Dialect
 	expressions []Expression
 }
 
 func (n *rowInterfaceImpl) EQ(rhs RowExpression) BoolExpression {
-	return Eq(n.parent, rhs)
+	return Eq(n.root, rhs)
 }
 
 func (n *rowInterfaceImpl) NOT_EQ(rhs RowExpression) BoolExpression {
-	return NotEq(n.parent, rhs)
+	return NotEq(n.root, rhs)
 }
 
 func (n *rowInterfaceImpl) IS_DISTINCT_FROM(rhs RowExpression) BoolExpression {
-	return IsDistinctFrom(n.parent, rhs)
+	return IsDistinctFrom(n.root, rhs)
 }
 
 func (n *rowInterfaceImpl) IS_NOT_DISTINCT_FROM(rhs RowExpression) BoolExpression {
-	return IsNotDistinctFrom(n.parent, rhs)
+	return IsNotDistinctFrom(n.root, rhs)
 }
 
 func (n *rowInterfaceImpl) GT(rhs RowExpression) BoolExpression {
-	return Gt(n.parent, rhs)
+	return Gt(n.root, rhs)
 }
 
 func (n *rowInterfaceImpl) GT_EQ(rhs RowExpression) BoolExpression {
-	return GtEq(n.parent, rhs)
+	return GtEq(n.root, rhs)
 }
 
 func (n *rowInterfaceImpl) LT(rhs RowExpression) BoolExpression {
-	return Lt(n.parent, rhs)
+	return Lt(n.root, rhs)
 }
 
 func (n *rowInterfaceImpl) LT_EQ(rhs RowExpression) BoolExpression {
-	return LtEq(n.parent, rhs)
+	return LtEq(n.root, rhs)
 }
 
 func (n *rowInterfaceImpl) projections() ProjectionList {
@@ -72,7 +72,7 @@ type rowExpressionWrapper struct {
 
 func newRowExpression(name string, dialect Dialect, expressions ...Expression) RowExpression {
 	ret := &rowExpressionWrapper{}
-	ret.rowInterfaceImpl.parent = ret
+	ret.rowInterfaceImpl.root = ret
 
 	ret.Expression = NewFunc(name, expressions, ret)
 	ret.dialect = dialect
@@ -96,6 +96,6 @@ func WRAP(dialect Dialect, expressions ...Expression) RowExpression {
 // Note: This does not modify the generated SQL builder output by adding a SQL CAST operation.
 func RowExp(expression Expression) RowExpression {
 	rowExpressionWrap := rowExpressionWrapper{Expression: expression}
-	rowExpressionWrap.rowInterfaceImpl.parent = &rowExpressionWrap
+	rowExpressionWrap.rowInterfaceImpl.root = &rowExpressionWrap
 	return &rowExpressionWrap
 }

internal/jet/statement.go

@@ -77,14 +77,14 @@ type SerializerHasProjections interface {
 type statementInterfaceImpl struct {
 	dialect       Dialect
 	statementType StatementType
-	parent        SerializerStatement
+	root          SerializerStatement
 }
 
 func (s *statementInterfaceImpl) Sql() (query string, args []interface{}) {
 
 	queryData := &SQLBuilder{Dialect: s.dialect}
 
-	s.parent.serialize(s.statementType, queryData, NoWrap)
+	s.root.serialize(s.statementType, queryData, NoWrap)
 
 	query, args = queryData.finalize()
 	return
@@ -93,7 +93,7 @@ func (s *statementInterfaceImpl) Sql() (query string, args []interface{}) {
 func (s *statementInterfaceImpl) DebugSql() (query string) {
 	sqlBuilder := &SQLBuilder{Dialect: s.dialect, Debug: true}
 
-	s.parent.serialize(s.statementType, sqlBuilder, NoWrap)
+	s.root.serialize(s.statementType, sqlBuilder, NoWrap)
 
 	query, _ = sqlBuilder.finalize()
 	return
@@ -222,14 +222,14 @@ type ExpressionStatement interface {
 // NewExpressionStatementImpl creates new expression statement
 func NewExpressionStatementImpl(Dialect Dialect,
 	statementType StatementType,
-	parent ExpressionStatement,
+	root ExpressionStatement,
 	clauses ...Clause) ExpressionStatement {
 
 	return &expressionStatementImpl{
-		ExpressionInterfaceImpl{Parent: parent},
+		ExpressionInterfaceImpl{Root: root},
 		statementImpl{
 			statementInterfaceImpl: statementInterfaceImpl{
-				parent:        parent,
+				root:          root,
 				dialect:       Dialect,
 				statementType: statementType,
 			},
@@ -252,10 +252,10 @@ func (e *expressionStatementImpl) serializeForRowToJsonProjection(statement Stat
 }
 
 // NewStatementImpl creates new statementImpl
-func NewStatementImpl(Dialect Dialect, statementType StatementType, parent SerializerStatement, clauses ...Clause) SerializerStatement {
+func NewStatementImpl(Dialect Dialect, statementType StatementType, root SerializerStatement, clauses ...Clause) SerializerStatement {
 	return &statementImpl{
 		statementInterfaceImpl: statementInterfaceImpl{
-			parent:        parent,
+			root:          root,
 			dialect:       Dialect,
 			statementType: statementType,
 		},

internal/jet/string_expression.go

@@ -27,69 +27,69 @@ type StringExpression interface {
 }
 
 type stringInterfaceImpl struct {
-	parent StringExpression
+	root StringExpression
 }
 
 func (s *stringInterfaceImpl) isStringOrBlob() {}
 
 func (s *stringInterfaceImpl) EQ(rhs StringExpression) BoolExpression {
-	return Eq(s.parent, rhs)
+	return Eq(s.root, rhs)
 }
 
 func (s *stringInterfaceImpl) NOT_EQ(rhs StringExpression) BoolExpression {
-	return NotEq(s.parent, rhs)
+	return NotEq(s.root, rhs)
 }
 
 func (s *stringInterfaceImpl) IS_DISTINCT_FROM(rhs StringExpression) BoolExpression {
-	return IsDistinctFrom(s.parent, rhs)
+	return IsDistinctFrom(s.root, rhs)
 }
 
 func (s *stringInterfaceImpl) IS_NOT_DISTINCT_FROM(rhs StringExpression) BoolExpression {
-	return IsNotDistinctFrom(s.parent, rhs)
+	return IsNotDistinctFrom(s.root, rhs)
 }
 
 func (s *stringInterfaceImpl) GT(rhs StringExpression) BoolExpression {
-	return Gt(s.parent, rhs)
+	return Gt(s.root, rhs)
 }
 
 func (s *stringInterfaceImpl) GT_EQ(rhs StringExpression) BoolExpression {
-	return GtEq(s.parent, rhs)
+	return GtEq(s.root, rhs)
 }
 
 func (s *stringInterfaceImpl) LT(rhs StringExpression) BoolExpression {
-	return Lt(s.parent, rhs)
+	return Lt(s.root, rhs)
 }
 
 func (s *stringInterfaceImpl) LT_EQ(rhs StringExpression) BoolExpression {
-	return LtEq(s.parent, rhs)
+	return LtEq(s.root, rhs)
 }
 
 func (s *stringInterfaceImpl) BETWEEN(min, max StringExpression) BoolExpression {
-	return NewBetweenOperatorExpression(s.parent, min, max, false)
+	return NewBetweenOperatorExpression(s.root, min, max, false)
 }
 
 func (s *stringInterfaceImpl) NOT_BETWEEN(min, max StringExpression) BoolExpression {
-	return NewBetweenOperatorExpression(s.parent, min, max, true)
+	return NewBetweenOperatorExpression(s.root, min, max, true)
 }
 
 func (s *stringInterfaceImpl) CONCAT(rhs Expression) StringExpression {
-	return newBinaryStringOperatorExpression(s.parent, rhs, StringConcatOperator)
+	return newBinaryStringOperatorExpression(s.root, rhs, StringConcatOperator)
 }
 
 func (s *stringInterfaceImpl) LIKE(pattern StringExpression) BoolExpression {
-	return newBinaryBoolOperatorExpression(s.parent, pattern, "LIKE")
+	return newBinaryBoolOperatorExpression(s.root, pattern, "LIKE")
 }
 
 func (s *stringInterfaceImpl) NOT_LIKE(pattern StringExpression) BoolExpression {
-	return newBinaryBoolOperatorExpression(s.parent, pattern, "NOT LIKE")
+	return newBinaryBoolOperatorExpression(s.root, pattern, "NOT LIKE")
 }
 
 func (s *stringInterfaceImpl) REGEXP_LIKE(pattern StringExpression, caseSensitive ...bool) BoolExpression {
-	return newBinaryBoolOperatorExpression(s.parent, pattern, StringRegexpLikeOperator, Bool(len(caseSensitive) > 0 && caseSensitive[0]))
+	return newBinaryBoolOperatorExpression(s.root, pattern, StringRegexpLikeOperator, Bool(len(caseSensitive) > 0 && caseSensitive[0]))
 }
 
 func (s *stringInterfaceImpl) NOT_REGEXP_LIKE(pattern StringExpression, caseSensitive ...bool) BoolExpression {
-	return newBinaryBoolOperatorExpression(s.parent, pattern, StringNotRegexpLikeOperator, Bool(len(caseSensitive) > 0 && caseSensitive[0]))
+	return newBinaryBoolOperatorExpression(s.root, pattern, StringNotRegexpLikeOperator, Bool(len(caseSensitive) > 0 && caseSensitive[0]))
 }
 
 // ---------------------------------------------------//
@@ -106,8 +106,8 @@ type stringExpressionWrapper struct {
 
 func newStringExpressionWrap(expression Expression) StringExpression {
 	stringExpressionWrap := &stringExpressionWrapper{Expression: expression}
-	stringExpressionWrap.stringInterfaceImpl.parent = stringExpressionWrap
+	stringExpressionWrap.stringInterfaceImpl.root = stringExpressionWrap
-	expression.setParent(stringExpressionWrap)
+	expression.setRoot(stringExpressionWrap)
 	return stringExpressionWrap
 }
 

internal/jet/time_expression.go

@@ -21,55 +21,55 @@ type TimeExpression interface {
 }
 
 type timeInterfaceImpl struct {
-	parent TimeExpression
+	root TimeExpression
 }
 
 func (t *timeInterfaceImpl) EQ(rhs TimeExpression) BoolExpression {
-	return Eq(t.parent, rhs)
+	return Eq(t.root, rhs)
 }
 
 func (t *timeInterfaceImpl) NOT_EQ(rhs TimeExpression) BoolExpression {
-	return NotEq(t.parent, rhs)
+	return NotEq(t.root, rhs)
 }
 
 func (t *timeInterfaceImpl) IS_DISTINCT_FROM(rhs TimeExpression) BoolExpression {
-	return IsDistinctFrom(t.parent, rhs)
+	return IsDistinctFrom(t.root, rhs)
 }
 
 func (t *timeInterfaceImpl) IS_NOT_DISTINCT_FROM(rhs TimeExpression) BoolExpression {
-	return IsNotDistinctFrom(t.parent, rhs)
+	return IsNotDistinctFrom(t.root, rhs)
 }
 
 func (t *timeInterfaceImpl) LT(rhs TimeExpression) BoolExpression {
-	return Lt(t.parent, rhs)
+	return Lt(t.root, rhs)
 }
 
 func (t *timeInterfaceImpl) LT_EQ(rhs TimeExpression) BoolExpression {
-	return LtEq(t.parent, rhs)
+	return LtEq(t.root, rhs)
 }
 
 func (t *timeInterfaceImpl) GT(rhs TimeExpression) BoolExpression {
-	return Gt(t.parent, rhs)
+	return Gt(t.root, rhs)
 }
 
 func (t *timeInterfaceImpl) GT_EQ(rhs TimeExpression) BoolExpression {
-	return GtEq(t.parent, rhs)
+	return GtEq(t.root, rhs)
 }
 
 func (t *timeInterfaceImpl) BETWEEN(min, max TimeExpression) BoolExpression {
-	return NewBetweenOperatorExpression(t.parent, min, max, false)
+	return NewBetweenOperatorExpression(t.root, min, max, false)
 }
 
 func (t *timeInterfaceImpl) NOT_BETWEEN(min, max TimeExpression) BoolExpression {
-	return NewBetweenOperatorExpression(t.parent, min, max, true)
+	return NewBetweenOperatorExpression(t.root, min, max, true)
 }
 
 func (t *timeInterfaceImpl) ADD(rhs Interval) TimeExpression {
-	return TimeExp(Add(t.parent, rhs))
+	return TimeExp(Add(t.root, rhs))
 }
 
 func (t *timeInterfaceImpl) SUB(rhs Interval) TimeExpression {
-	return TimeExp(Sub(t.parent, rhs))
+	return TimeExp(Sub(t.root, rhs))
 }
 
 //---------------------------------------------------//
@@ -81,8 +81,8 @@ type timeExpressionWrapper struct {
 
 func newTimeExpressionWrap(expression Expression) TimeExpression {
 	timeExpressionWrap := &timeExpressionWrapper{Expression: expression}
-	timeExpressionWrap.timeInterfaceImpl.parent = timeExpressionWrap
+	timeExpressionWrap.timeInterfaceImpl.root = timeExpressionWrap
-	expression.setParent(timeExpressionWrap)
+	expression.setRoot(timeExpressionWrap)
 	return timeExpressionWrap
 }
 

internal/jet/timestamp_expression.go

@@ -21,55 +21,55 @@ type TimestampExpression interface {
 }
 
 type timestampInterfaceImpl struct {
-	parent TimestampExpression
+	root TimestampExpression
 }
 
 func (t *timestampInterfaceImpl) EQ(rhs TimestampExpression) BoolExpression {
-	return Eq(t.parent, rhs)
+	return Eq(t.root, rhs)
 }
 
 func (t *timestampInterfaceImpl) NOT_EQ(rhs TimestampExpression) BoolExpression {
-	return NotEq(t.parent, rhs)
+	return NotEq(t.root, rhs)
 }
 
 func (t *timestampInterfaceImpl) IS_DISTINCT_FROM(rhs TimestampExpression) BoolExpression {
-	return IsDistinctFrom(t.parent, rhs)
+	return IsDistinctFrom(t.root, rhs)
 }
 
 func (t *timestampInterfaceImpl) IS_NOT_DISTINCT_FROM(rhs TimestampExpression) BoolExpression {
-	return IsNotDistinctFrom(t.parent, rhs)
+	return IsNotDistinctFrom(t.root, rhs)
 }
 
 func (t *timestampInterfaceImpl) LT(rhs TimestampExpression) BoolExpression {
-	return Lt(t.parent, rhs)
+	return Lt(t.root, rhs)
 }
 
 func (t *timestampInterfaceImpl) LT_EQ(rhs TimestampExpression) BoolExpression {
-	return LtEq(t.parent, rhs)
+	return LtEq(t.root, rhs)
 }
 
 func (t *timestampInterfaceImpl) GT(rhs TimestampExpression) BoolExpression {
-	return Gt(t.parent, rhs)
+	return Gt(t.root, rhs)
 }
 
 func (t *timestampInterfaceImpl) GT_EQ(rhs TimestampExpression) BoolExpression {
-	return GtEq(t.parent, rhs)
+	return GtEq(t.root, rhs)
 }
 
 func (t *timestampInterfaceImpl) BETWEEN(min, max TimestampExpression) BoolExpression {
-	return NewBetweenOperatorExpression(t.parent, min, max, false)
+	return NewBetweenOperatorExpression(t.root, min, max, false)
 }
 
 func (t *timestampInterfaceImpl) NOT_BETWEEN(min, max TimestampExpression) BoolExpression {
-	return NewBetweenOperatorExpression(t.parent, min, max, true)
+	return NewBetweenOperatorExpression(t.root, min, max, true)
 }
 
 func (t *timestampInterfaceImpl) ADD(rhs Interval) TimestampExpression {
-	return TimestampExp(Add(t.parent, rhs))
+	return TimestampExp(Add(t.root, rhs))
 }
 
 func (t *timestampInterfaceImpl) SUB(rhs Interval) TimestampExpression {
-	return TimestampExp(Sub(t.parent, rhs))
+	return TimestampExp(Sub(t.root, rhs))
 }
 
 //-------------------------------------------------
@@ -81,8 +81,8 @@ type timestampExpressionWrapper struct {
 
 func newTimestampExpressionWrap(expression Expression) TimestampExpression {
 	timestampExpressionWrap := &timestampExpressionWrapper{Expression: expression}
-	timestampExpressionWrap.timestampInterfaceImpl.parent = timestampExpressionWrap
+	timestampExpressionWrap.timestampInterfaceImpl.root = timestampExpressionWrap
-	expression.setParent(timestampExpressionWrap)
+	expression.setRoot(timestampExpressionWrap)
 	return timestampExpressionWrap
 }
 

internal/jet/timestampz_expression.go

@@ -21,55 +21,55 @@ type TimestampzExpression interface {
 }
 
 type timestampzInterfaceImpl struct {
-	parent TimestampzExpression
+	root TimestampzExpression
 }
 
 func (t *timestampzInterfaceImpl) EQ(rhs TimestampzExpression) BoolExpression {
-	return Eq(t.parent, rhs)
+	return Eq(t.root, rhs)
 }
 
 func (t *timestampzInterfaceImpl) NOT_EQ(rhs TimestampzExpression) BoolExpression {
-	return NotEq(t.parent, rhs)
+	return NotEq(t.root, rhs)
 }
 
 func (t *timestampzInterfaceImpl) IS_DISTINCT_FROM(rhs TimestampzExpression) BoolExpression {
-	return IsDistinctFrom(t.parent, rhs)
+	return IsDistinctFrom(t.root, rhs)
 }
 
 func (t *timestampzInterfaceImpl) IS_NOT_DISTINCT_FROM(rhs TimestampzExpression) BoolExpression {
-	return IsNotDistinctFrom(t.parent, rhs)
+	return IsNotDistinctFrom(t.root, rhs)
 }
 
 func (t *timestampzInterfaceImpl) LT(rhs TimestampzExpression) BoolExpression {
-	return Lt(t.parent, rhs)
+	return Lt(t.root, rhs)
 }
 
 func (t *timestampzInterfaceImpl) LT_EQ(rhs TimestampzExpression) BoolExpression {
-	return LtEq(t.parent, rhs)
+	return LtEq(t.root, rhs)
 }
 
 func (t *timestampzInterfaceImpl) GT(rhs TimestampzExpression) BoolExpression {
-	return Gt(t.parent, rhs)
+	return Gt(t.root, rhs)
 }
 
 func (t *timestampzInterfaceImpl) GT_EQ(rhs TimestampzExpression) BoolExpression {
-	return GtEq(t.parent, rhs)
+	return GtEq(t.root, rhs)
 }
 
 func (t *timestampzInterfaceImpl) BETWEEN(min, max TimestampzExpression) BoolExpression {
-	return NewBetweenOperatorExpression(t.parent, min, max, false)
+	return NewBetweenOperatorExpression(t.root, min, max, false)
 }
 
 func (t *timestampzInterfaceImpl) NOT_BETWEEN(min, max TimestampzExpression) BoolExpression {
-	return NewBetweenOperatorExpression(t.parent, min, max, true)
+	return NewBetweenOperatorExpression(t.root, min, max, true)
 }
 
 func (t *timestampzInterfaceImpl) ADD(rhs Interval) TimestampzExpression {
-	return TimestampzExp(Add(t.parent, rhs))
+	return TimestampzExp(Add(t.root, rhs))
 }
 
 func (t *timestampzInterfaceImpl) SUB(rhs Interval) TimestampzExpression {
-	return TimestampzExp(Sub(t.parent, rhs))
+	return TimestampzExp(Sub(t.root, rhs))
 }
 
 //-------------------------------------------------
@@ -81,8 +81,8 @@ type timestampzExpressionWrapper struct {
 
 func newTimestampzExpressionWrap(expression Expression) TimestampzExpression {
 	timestampzExpressionWrap := &timestampzExpressionWrapper{Expression: expression}
-	timestampzExpressionWrap.timestampzInterfaceImpl.parent = timestampzExpressionWrap
+	timestampzExpressionWrap.timestampzInterfaceImpl.root = timestampzExpressionWrap
-	expression.setParent(timestampzExpressionWrap)
+	expression.setRoot(timestampzExpressionWrap)
 	return timestampzExpressionWrap
 }
 

internal/jet/timez_expression.go

@@ -21,55 +21,55 @@ type TimezExpression interface {
 }
 
 type timezInterfaceImpl struct {
-	parent TimezExpression
+	root TimezExpression
 }
 
 func (t *timezInterfaceImpl) EQ(rhs TimezExpression) BoolExpression {
-	return Eq(t.parent, rhs)
+	return Eq(t.root, rhs)
 }
 
 func (t *timezInterfaceImpl) NOT_EQ(rhs TimezExpression) BoolExpression {
-	return NotEq(t.parent, rhs)
+	return NotEq(t.root, rhs)
 }
 
 func (t *timezInterfaceImpl) IS_DISTINCT_FROM(rhs TimezExpression) BoolExpression {
-	return IsDistinctFrom(t.parent, rhs)
+	return IsDistinctFrom(t.root, rhs)
 }
 
 func (t *timezInterfaceImpl) IS_NOT_DISTINCT_FROM(rhs TimezExpression) BoolExpression {
-	return IsNotDistinctFrom(t.parent, rhs)
+	return IsNotDistinctFrom(t.root, rhs)
 }
 
 func (t *timezInterfaceImpl) LT(rhs TimezExpression) BoolExpression {
-	return Lt(t.parent, rhs)
+	return Lt(t.root, rhs)
 }
 
 func (t *timezInterfaceImpl) LT_EQ(rhs TimezExpression) BoolExpression {
-	return LtEq(t.parent, rhs)
+	return LtEq(t.root, rhs)
 }
 
 func (t *timezInterfaceImpl) GT(rhs TimezExpression) BoolExpression {
-	return Gt(t.parent, rhs)
+	return Gt(t.root, rhs)
 }
 
 func (t *timezInterfaceImpl) GT_EQ(rhs TimezExpression) BoolExpression {
-	return GtEq(t.parent, rhs)
+	return GtEq(t.root, rhs)
 }
 
 func (t *timezInterfaceImpl) BETWEEN(min, max TimezExpression) BoolExpression {
-	return NewBetweenOperatorExpression(t.parent, min, max, false)
+	return NewBetweenOperatorExpression(t.root, min, max, false)
 }
 
 func (t *timezInterfaceImpl) NOT_BETWEEN(min, max TimezExpression) BoolExpression {
-	return NewBetweenOperatorExpression(t.parent, min, max, true)
+	return NewBetweenOperatorExpression(t.root, min, max, true)
 }
 
 func (t *timezInterfaceImpl) ADD(rhs Interval) TimezExpression {
-	return TimezExp(Add(t.parent, rhs))
+	return TimezExp(Add(t.root, rhs))
 }
 
 func (t *timezInterfaceImpl) SUB(rhs Interval) TimezExpression {
-	return TimezExp(Sub(t.parent, rhs))
+	return TimezExp(Sub(t.root, rhs))
 }
 
 //---------------------------------------------------//
@@ -81,8 +81,8 @@ type timezExpressionWrapper struct {
 
 func newTimezExpressionWrap(expression Expression) TimezExpression {
 	timezExpressionWrap := &timezExpressionWrapper{Expression: expression}
-	timezExpressionWrap.timezInterfaceImpl.parent = timezExpressionWrap
+	timezExpressionWrap.timezInterfaceImpl.root = timezExpressionWrap
-	expression.setParent(timezExpressionWrap)
+	expression.setRoot(timezExpressionWrap)
 	return timezExpressionWrap
 }
 

internal/jet/window_func.go

@@ -15,15 +15,15 @@ type windowImpl struct {
 	frameUnits  string
 	start, end  FrameExtent
 
-	parent Window
+	root Window
 }
 
-func newWindowImpl(parent Window) *windowImpl {
+func newWindowImpl(root Window) *windowImpl {
 	newWindow := &windowImpl{}
-	if parent == nil {
+	if root == nil {
-		newWindow.parent = newWindow
+		newWindow.root = newWindow
 	} else {
-		newWindow.parent = parent
+		newWindow.root = root
 	}
 
 	return newWindow
@@ -62,25 +62,25 @@ func (w *windowImpl) serialize(statement StatementType, out *SQLBuilder, options
 
 func (w *windowImpl) ORDER_BY(exprs ...OrderByClause) Window {
 	w.orderBy.List = exprs
-	return w.parent
+	return w.root
 }
 
 func (w *windowImpl) ROWS(start FrameExtent, end ...FrameExtent) Window {
 	w.frameUnits = "ROWS"
 	w.setFrameRange(start, end...)
-	return w.parent
+	return w.root
 }
 
 func (w *windowImpl) RANGE(start FrameExtent, end ...FrameExtent) Window {
 	w.frameUnits = "RANGE"
 	w.setFrameRange(start, end...)
-	return w.parent
+	return w.root
 }
 
 func (w *windowImpl) GROUPS(start FrameExtent, end ...FrameExtent) Window {
 	w.frameUnits = "GROUPS"
 	w.setFrameRange(start, end...)
-	return w.parent
+	return w.root
 }
 
 func (w *windowImpl) setFrameRange(start FrameExtent, end ...FrameExtent) {
@@ -167,7 +167,7 @@ func (f frameExtentKeyword) isFrameExtent() {}
 // WindowName is used to specify window reference from WINDOW clause
 func WindowName(name string) Window {
 	newWindow := &windowName{name: name}
-	newWindow.parent = newWindow
+	newWindow.root = newWindow
 	return newWindow
 }
 

internal/jet/with_statement.go

@@ -12,7 +12,7 @@ func WITH(dialect Dialect, recursive bool, cte ...*CommonTableExpression) func(s
 			statementType: WithStatementType,
 		},
 	}
-	newWithImpl.parent = newWithImpl
+	newWithImpl.root = newWithImpl
 
 	return func(primaryStatement Statement) Statement {
 		serializerStatement, ok := primaryStatement.(SerializerStatement)

mysql/lateral.go

@@ -18,7 +18,7 @@ func (l lateralImpl) AS(alias string) SelectTable {
 		SelectTable: jet.NewLateral(l.selectStmt, alias),
 	}
 
-	subQuery.readableTableInterfaceImpl.parent = subQuery
+	subQuery.readableTableInterfaceImpl.root = subQuery
 
 	return subQuery
 }

mysql/select_statement.go

@@ -89,7 +89,7 @@ func newSelectStatement(stmtType jet.StatementType, table ReadableTable, project
 	newSelect.ShareLock.Name = "LOCK IN SHARE MODE"
 	newSelect.ShareLock.InNewLine = true
 
-	newSelect.setOperatorsImpl.parent = newSelect
+	newSelect.setOperatorsImpl.root = newSelect
 
 	return newSelect
 }

mysql/select_table.go

@@ -18,7 +18,7 @@ func newSelectTable(selectStmt jet.SerializerHasProjections, alias string, colum
 		SelectTable: jet.NewSelectTable(selectStmt, alias, columnAliases),
 	}
 
-	subQuery.readableTableInterfaceImpl.parent = subQuery
+	subQuery.readableTableInterfaceImpl.root = subQuery
 
 	return subQuery
 }

mysql/set_statement.go

@@ -35,15 +35,15 @@ type setOperators interface {
 }
 
 type setOperatorsImpl struct {
-	parent setOperators
+	root setOperators
 }
 
 func (s *setOperatorsImpl) UNION(rhs SelectStatement) setStatement {
-	return UNION(s.parent, rhs)
+	return UNION(s.root, rhs)
 }
 
 func (s *setOperatorsImpl) UNION_ALL(rhs SelectStatement) setStatement {
-	return UNION_ALL(s.parent, rhs)
+	return UNION_ALL(s.root, rhs)
 }
 
 type setStatementImpl struct {
@@ -64,7 +64,7 @@ func newSetStatementImpl(operator string, all bool, selects []jet.SerializerStat
 	newSetStatement.setOperator.Selects = selects
 	newSetStatement.setOperator.Limit.Count = -1
 
-	newSetStatement.setOperatorsImpl.parent = newSetStatement
+	newSetStatement.setOperatorsImpl.root = newSetStatement
 
 	return newSetStatement
 }

mysql/table.go

@@ -45,35 +45,35 @@ type ReadableTable interface {
 }
 
 type readableTableInterfaceImpl struct {
-	parent ReadableTable
+	root ReadableTable
 }
 
 // Generates a select query on the current tableName.
 func (r readableTableInterfaceImpl) SELECT(projection1 Projection, projections ...Projection) SelectStatement {
-	return newSelectStatement(jet.SelectStatementType, r.parent, append([]Projection{projection1}, projections...))
+	return newSelectStatement(jet.SelectStatementType, r.root, append([]Projection{projection1}, projections...))
 }
 
 // Creates a inner join tableName Expression using onCondition.
 func (r readableTableInterfaceImpl) INNER_JOIN(table ReadableTable, onCondition BoolExpression) joinSelectUpdateTable {
-	return newJoinTable(r.parent, table, jet.InnerJoin, onCondition)
+	return newJoinTable(r.root, table, jet.InnerJoin, onCondition)
 }
 
 // Creates a left join tableName Expression using onCondition.
 func (r readableTableInterfaceImpl) LEFT_JOIN(table ReadableTable, onCondition BoolExpression) joinSelectUpdateTable {
-	return newJoinTable(r.parent, table, jet.LeftJoin, onCondition)
+	return newJoinTable(r.root, table, jet.LeftJoin, onCondition)
 }
 
 // Creates a right join tableName Expression using onCondition.
 func (r readableTableInterfaceImpl) RIGHT_JOIN(table ReadableTable, onCondition BoolExpression) joinSelectUpdateTable {
-	return newJoinTable(r.parent, table, jet.RightJoin, onCondition)
+	return newJoinTable(r.root, table, jet.RightJoin, onCondition)
 }
 
 func (r readableTableInterfaceImpl) FULL_JOIN(table ReadableTable, onCondition BoolExpression) joinSelectUpdateTable {
-	return newJoinTable(r.parent, table, jet.FullJoin, onCondition)
+	return newJoinTable(r.root, table, jet.FullJoin, onCondition)
 }
 
 func (r readableTableInterfaceImpl) CROSS_JOIN(table ReadableTable) joinSelectUpdateTable {
-	return newJoinTable(r.parent, table, jet.CrossJoin, nil)
+	return newJoinTable(r.root, table, jet.CrossJoin, nil)
 }
 
 // NewTable creates new table with schema Name, table Name and list of columns
@@ -82,8 +82,8 @@ func NewTable(schemaName, name, alias string, columns ...jet.ColumnExpression) T
 		SerializerTable: jet.NewTable(schemaName, name, alias, columns...),
 	}
 
-	t.readableTableInterfaceImpl.parent = t
+	t.readableTableInterfaceImpl.root = t
-	t.parent = t
+	t.root = t
 
 	return t
 }
@@ -91,23 +91,23 @@ func NewTable(schemaName, name, alias string, columns ...jet.ColumnExpression) T
 type tableImpl struct {
 	jet.SerializerTable
 	readableTableInterfaceImpl
-	parent Table
+	root Table
 }
 
 func (t *tableImpl) INSERT(columns ...jet.Column) InsertStatement {
-	return newInsertStatement(t.parent, jet.UnwidColumnList(columns))
+	return newInsertStatement(t.root, jet.UnwidColumnList(columns))
 }
 
 func (t *tableImpl) UPDATE(columns ...jet.Column) UpdateStatement {
-	return newUpdateStatement(t.parent, jet.UnwidColumnList(columns))
+	return newUpdateStatement(t.root, jet.UnwidColumnList(columns))
 }
 
 func (t *tableImpl) DELETE() DeleteStatement {
-	return newDeleteStatement(t.parent)
+	return newDeleteStatement(t.root)
 }
 
 func (t *tableImpl) LOCK() LockStatement {
-	return LOCK(t.parent)
+	return LOCK(t.root)
 }
 
 type joinTable struct {
@@ -120,8 +120,8 @@ func newJoinTable(lhs jet.Serializer, rhs jet.Serializer, joinType jet.JoinType,
 		JoinTable: jet.NewJoinTable(lhs, rhs, joinType, onCondition),
 	}
 
-	newJoinTable.readableTableInterfaceImpl.parent = newJoinTable
+	newJoinTable.readableTableInterfaceImpl.root = newJoinTable
-	newJoinTable.parent = newJoinTable
+	newJoinTable.root = newJoinTable
 
 	return newJoinTable
 }

mysql/with_statement.go

@@ -35,7 +35,7 @@ func CTE(name string, columns ...jet.ColumnExpression) CommonTableExpression {
 		CommonTableExpression:      jet.CTE(name, columns...),
 	}
 
-	cte.parent = cte
+	cte.root = cte
 
 	return cte
 }

postgres/lateral.go

@@ -18,7 +18,7 @@ func (l lateralImpl) AS(alias string) SelectTable {
 		SelectTable: jet.NewLateral(l.selectStmt, alias),
 	}
 
-	subQuery.readableTableInterfaceImpl.parent = subQuery
+	subQuery.readableTableInterfaceImpl.root = subQuery
 
 	return subQuery
 }

postgres/select_table.go

@@ -18,7 +18,7 @@ func newSelectTable(serializerWithProjections jet.SerializerHasProjections, alia
 		SelectTable: jet.NewSelectTable(serializerWithProjections, alias, columnAliases),
 	}
 
-	subQuery.readableTableInterfaceImpl.parent = subQuery
+	subQuery.readableTableInterfaceImpl.root = subQuery
 
 	return subQuery
 }

postgres/table.go

@@ -50,55 +50,55 @@ type WritableTable interface {
 }
 
 type readableTableInterfaceImpl struct {
-	parent ReadableTable
+	root ReadableTable
 }
 
 // Generates a select query on the current tableName.
 func (r readableTableInterfaceImpl) SELECT(projection1 Projection, projections ...Projection) SelectStatement {
-	return newSelectStatement(jet.SelectStatementType, r.parent, append([]Projection{projection1}, projections...))
+	return newSelectStatement(jet.SelectStatementType, r.root, append([]Projection{projection1}, projections...))
 }
 
 // Creates a inner join tableName Expression using onCondition.
 func (r readableTableInterfaceImpl) INNER_JOIN(table ReadableTable, onCondition BoolExpression) ReadableTable {
-	return newJoinTable(r.parent, table, jet.InnerJoin, onCondition)
+	return newJoinTable(r.root, table, jet.InnerJoin, onCondition)
 }
 
 // Creates a left join tableName Expression using onCondition.
 func (r readableTableInterfaceImpl) LEFT_JOIN(table ReadableTable, onCondition BoolExpression) ReadableTable {
-	return newJoinTable(r.parent, table, jet.LeftJoin, onCondition)
+	return newJoinTable(r.root, table, jet.LeftJoin, onCondition)
 }
 
 // Creates a right join tableName Expression using onCondition.
 func (r readableTableInterfaceImpl) RIGHT_JOIN(table ReadableTable, onCondition BoolExpression) ReadableTable {
-	return newJoinTable(r.parent, table, jet.RightJoin, onCondition)
+	return newJoinTable(r.root, table, jet.RightJoin, onCondition)
 }
 
 func (r readableTableInterfaceImpl) FULL_JOIN(table ReadableTable, onCondition BoolExpression) ReadableTable {
-	return newJoinTable(r.parent, table, jet.FullJoin, onCondition)
+	return newJoinTable(r.root, table, jet.FullJoin, onCondition)
 }
 
 func (r readableTableInterfaceImpl) CROSS_JOIN(table ReadableTable) ReadableTable {
-	return newJoinTable(r.parent, table, jet.CrossJoin, nil)
+	return newJoinTable(r.root, table, jet.CrossJoin, nil)
 }
 
 type writableTableInterfaceImpl struct {
-	parent WritableTable
+	root WritableTable
 }
 
 func (w *writableTableInterfaceImpl) INSERT(columns ...jet.Column) InsertStatement {
-	return newInsertStatement(w.parent, jet.UnwidColumnList(columns))
+	return newInsertStatement(w.root, jet.UnwidColumnList(columns))
 }
 
 func (w *writableTableInterfaceImpl) UPDATE(columns ...jet.Column) UpdateStatement {
-	return newUpdateStatement(w.parent, jet.UnwidColumnList(columns))
+	return newUpdateStatement(w.root, jet.UnwidColumnList(columns))
 }
 
 func (w *writableTableInterfaceImpl) DELETE() DeleteStatement {
-	return newDeleteStatement(w.parent)
+	return newDeleteStatement(w.root)
 }
 
 func (w *writableTableInterfaceImpl) LOCK() LockStatement {
-	return LOCK(w.parent)
+	return LOCK(w.root)
 }
 
 type tableImpl struct {
@@ -115,8 +115,8 @@ func NewTable(schemaName, name, alias string, columns ...jet.ColumnExpression) T
 		SerializerTable: jet.NewTable(schemaName, name, alias, columns...),
 	}
 
-	t.readableTableInterfaceImpl.parent = t
+	t.readableTableInterfaceImpl.root = t
-	t.writableTableInterfaceImpl.parent = t
+	t.writableTableInterfaceImpl.root = t
 
 	return t
 }
@@ -131,7 +131,7 @@ func newJoinTable(lhs jet.Serializer, rhs jet.Serializer, joinType jet.JoinType,
 		JoinTable: jet.NewJoinTable(lhs, rhs, joinType, onCondition),
 	}
 
-	newJoinTable.readableTableInterfaceImpl.parent = newJoinTable
+	newJoinTable.readableTableInterfaceImpl.root = newJoinTable
 
 	return newJoinTable
 }

postgres/with_statement.go

@@ -36,7 +36,7 @@ func CTE(name string, columns ...jet.ColumnExpression) CommonTableExpression {
 		CommonTableExpression:      jet.CTE(name, columns...),
 	}
 
-	cte.parent = cte
+	cte.root = cte
 
 	return cte
 }

sqlite/select_statement.go

@@ -77,7 +77,7 @@ func newSelectStatement(table ReadableTable, projections []Projection) SelectSta
 	newSelect.ShareLock.Name = "LOCK IN SHARE MODE"
 	newSelect.ShareLock.InNewLine = true
 
-	newSelect.setOperatorsImpl.parent = newSelect
+	newSelect.setOperatorsImpl.root = newSelect
 
 	return newSelect
 }

sqlite/select_table.go

@@ -18,7 +18,7 @@ func newSelectTable(selectStmt jet.SerializerHasProjections, alias string, colum
 		SelectTable: jet.NewSelectTable(selectStmt, alias, columnAliases),
 	}
 
-	subQuery.readableTableInterfaceImpl.parent = subQuery
+	subQuery.readableTableInterfaceImpl.root = subQuery
 
 	return subQuery
 }

sqlite/set_statement.go

@@ -35,15 +35,15 @@ type setOperators interface {
 }
 
 type setOperatorsImpl struct {
-	parent setOperators
+	root setOperators
 }
 
 func (s *setOperatorsImpl) UNION(rhs SelectStatement) setStatement {
-	return UNION(s.parent, rhs)
+	return UNION(s.root, rhs)
 }
 
 func (s *setOperatorsImpl) UNION_ALL(rhs SelectStatement) setStatement {
-	return UNION_ALL(s.parent, rhs)
+	return UNION_ALL(s.root, rhs)
 }
 
 type setStatementImpl struct {
@@ -65,7 +65,7 @@ func newSetStatementImpl(operator string, all bool, selects []jet.SerializerStat
 	newSetStatement.setOperator.Limit.Count = -1
 	newSetStatement.setOperator.SkipSelectWrap = true
 
-	newSetStatement.setOperatorsImpl.parent = newSetStatement
+	newSetStatement.setOperatorsImpl.root = newSetStatement
 
 	return newSetStatement
 }

sqlite/table.go

@@ -44,35 +44,35 @@ type ReadableTable interface {
 }
 
 type readableTableInterfaceImpl struct {
-	parent ReadableTable
+	root ReadableTable
 }
 
 // Generates a select query on the current tableName.
 func (r readableTableInterfaceImpl) SELECT(projection1 Projection, projections ...Projection) SelectStatement {
-	return newSelectStatement(r.parent, append([]Projection{projection1}, projections...))
+	return newSelectStatement(r.root, append([]Projection{projection1}, projections...))
 }
 
 // Creates a inner join tableName Expression using onCondition.
 func (r readableTableInterfaceImpl) INNER_JOIN(table ReadableTable, onCondition BoolExpression) joinSelectUpdateTable {
-	return newJoinTable(r.parent, table, jet.InnerJoin, onCondition)
+	return newJoinTable(r.root, table, jet.InnerJoin, onCondition)
 }
 
 // Creates a left join tableName Expression using onCondition.
 func (r readableTableInterfaceImpl) LEFT_JOIN(table ReadableTable, onCondition BoolExpression) joinSelectUpdateTable {
-	return newJoinTable(r.parent, table, jet.LeftJoin, onCondition)
+	return newJoinTable(r.root, table, jet.LeftJoin, onCondition)
 }
 
 // Creates a right join tableName Expression using onCondition.
 func (r readableTableInterfaceImpl) RIGHT_JOIN(table ReadableTable, onCondition BoolExpression) joinSelectUpdateTable {
-	return newJoinTable(r.parent, table, jet.RightJoin, onCondition)
+	return newJoinTable(r.root, table, jet.RightJoin, onCondition)
 }
 
 func (r readableTableInterfaceImpl) FULL_JOIN(table ReadableTable, onCondition BoolExpression) joinSelectUpdateTable {
-	return newJoinTable(r.parent, table, jet.FullJoin, onCondition)
+	return newJoinTable(r.root, table, jet.FullJoin, onCondition)
 }
 
 func (r readableTableInterfaceImpl) CROSS_JOIN(table ReadableTable) joinSelectUpdateTable {
-	return newJoinTable(r.parent, table, jet.CrossJoin, nil)
+	return newJoinTable(r.root, table, jet.CrossJoin, nil)
 }
 
 // NewTable creates new table with schema Name, table Name and list of columns
@@ -81,8 +81,8 @@ func NewTable(schemaName, name, alias string, columns ...jet.ColumnExpression) T
 		SerializerTable: jet.NewTable(schemaName, name, alias, columns...),
 	}
 
-	t.readableTableInterfaceImpl.parent = t
+	t.readableTableInterfaceImpl.root = t
-	t.parent = t
+	t.root = t
 
 	return t
 }
@@ -90,19 +90,19 @@ func NewTable(schemaName, name, alias string, columns ...jet.ColumnExpression) T
 type tableImpl struct {
 	jet.SerializerTable
 	readableTableInterfaceImpl
-	parent Table
+	root Table
 }
 
 func (t *tableImpl) INSERT(columns ...jet.Column) InsertStatement {
-	return newInsertStatement(t.parent, jet.UnwidColumnList(columns))
+	return newInsertStatement(t.root, jet.UnwidColumnList(columns))
 }
 
 func (t *tableImpl) UPDATE(columns ...jet.Column) UpdateStatement {
-	return newUpdateStatement(t.parent, jet.UnwidColumnList(columns))
+	return newUpdateStatement(t.root, jet.UnwidColumnList(columns))
 }
 
 func (t *tableImpl) DELETE() DeleteStatement {
-	return newDeleteStatement(t.parent)
+	return newDeleteStatement(t.root)
 }
 
 type joinTable struct {
@@ -115,8 +115,8 @@ func newJoinTable(lhs jet.Serializer, rhs jet.Serializer, joinType jet.JoinType,
 		JoinTable: jet.NewJoinTable(lhs, rhs, joinType, onCondition),
 	}
 
-	newJoinTable.readableTableInterfaceImpl.parent = newJoinTable
+	newJoinTable.readableTableInterfaceImpl.root = newJoinTable
-	newJoinTable.parent = newJoinTable
+	newJoinTable.root = newJoinTable
 
 	return newJoinTable
 }

sqlite/with_statement.go

@@ -36,7 +36,7 @@ func CTE(name string, columns ...jet.ColumnExpression) CommonTableExpression {
 		CommonTableExpression:      jet.CTE(name, columns...),
 	}
 
-	cte.parent = cte
+	cte.root = cte
 
 	return cte
 }