diff --git a/internal/jet/blob_expression.go b/internal/jet/blob_expression.go index 435c68e..7d5dbfe 100644 --- a/internal/jet/blob_expression.go +++ b/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 - expression.setParent(blobExpressionWrap) + blobExpressionWrap.blobInterfaceImpl.root = blobExpressionWrap + expression.setRoot(blobExpressionWrap) return blobExpressionWrap } diff --git a/internal/jet/bool_expression.go b/internal/jet/bool_expression.go index 450375c..5660a06 100644 --- a/internal/jet/bool_expression.go +++ b/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 - expression.setParent(boolExpressionWrap) + boolExpressionWrap.boolInterfaceImpl.root = boolExpressionWrap + expression.setRoot(boolExpressionWrap) return boolExpressionWrap } diff --git a/internal/jet/cast.go b/internal/jet/cast.go index e8045e7..311ab88 100644 --- a/internal/jet/cast.go +++ b/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 } diff --git a/internal/jet/column.go b/internal/jet/column.go index dda19ff..7d108df 100644 --- a/internal/jet/column.go +++ b/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 { - newColumn.ExpressionInterfaceImpl.Parent = parent + if root != nil { + 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") diff --git a/internal/jet/column_types.go b/internal/jet/column_types.go index 00e333e..cec0530 100644 --- a/internal/jet/column_types.go +++ b/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 := ×tampColumnImpl{} - 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 := ×tampzColumnImpl{} - 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 diff --git a/internal/jet/date_expression.go b/internal/jet/date_expression.go index 2f62a50..a7b1743 100644 --- a/internal/jet/date_expression.go +++ b/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 - expression.setParent(dateExpressionWrap) + dateExpressionWrap.dateInterfaceImpl.root = dateExpressionWrap + expression.setRoot(dateExpressionWrap) return dateExpressionWrap } diff --git a/internal/jet/enum_value.go b/internal/jet/enum_value.go index 17e8c74..4864c74 100644 --- a/internal/jet/enum_value.go +++ b/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.stringInterfaceImpl.parent = enumValue + enumValue.ExpressionInterfaceImpl.Root = enumValue + enumValue.stringInterfaceImpl.root = enumValue return enumValue } diff --git a/internal/jet/expression.go b/internal/jet/expression.go index 2ec5edc..42b63f2 100644 --- a/internal/jet/expression.go +++ b/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) { - e.Parent = parent +func (e *ExpressionInterfaceImpl) setRoot(root Expression) { + 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 } diff --git a/internal/jet/float_expression.go b/internal/jet/float_expression.go index f695ec3..f2d5a23 100644 --- a/internal/jet/float_expression.go +++ b/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 - expression.setParent(floatExpressionWrap) + floatExpressionWrap.floatInterfaceImpl.root = floatExpressionWrap + expression.setRoot(floatExpressionWrap) return floatExpressionWrap } diff --git a/internal/jet/func_expression.go b/internal/jet/func_expression.go index 46c8f0d..4ea2a4f 100644 --- a/internal/jet/func_expression.go +++ b/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 { - funcExp.ExpressionInterfaceImpl.Parent = parent + if root != nil { + 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.ExpressionInterfaceImpl.Parent = boolFunc + boolFunc.boolInterfaceImpl.root = 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.ExpressionInterfaceImpl.Parent = intWindowFunc + boolFunc.boolInterfaceImpl.root = 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.ExpressionInterfaceImpl.Parent = floatWindowFunc + floatFunc.floatInterfaceImpl.root = 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.ExpressionInterfaceImpl.Parent = intWindowFunc + integerFunc.integerInterfaceImpl.root = 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 := ×tampFunc{} 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 := ×tampzFunc{} timestampzFunc.funcExpressionImpl = *NewFunc(name, expressions, timestampzFunc) - timestampzFunc.timestampzInterfaceImpl.parent = timestampzFunc + timestampzFunc.timestampzInterfaceImpl.root = timestampzFunc return timestampzFunc } diff --git a/internal/jet/integer_expression.go b/internal/jet/integer_expression.go index d2761fc..cd6e25e 100644 --- a/internal/jet/integer_expression.go +++ b/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 - expression.setParent(intExpressionWrap) + intExpressionWrap.integerInterfaceImpl.root = intExpressionWrap + expression.setRoot(intExpressionWrap) return intExpressionWrap } diff --git a/internal/jet/interval_expression.go b/internal/jet/interval_expression.go index 5d49462..9026e04 100644 --- a/internal/jet/interval_expression.go +++ b/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 - expression.setParent(intervalWrap) + intervalWrap.intervalInterfaceImpl.root = intervalWrap + expression.setRoot(intervalWrap) return intervalWrap } diff --git a/internal/jet/literal_expression.go b/internal/jet/literal_expression.go index a2eec63..b8baa51 100644 --- a/internal/jet/literal_expression.go +++ b/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.integerInterfaceImpl.parent = numLiteral + numLiteral.literalExpressionImpl.Root = 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 := ×tampLiteral{} 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 := ×tampzLiteral{} 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 } diff --git a/internal/jet/operators.go b/internal/jet/operators.go index c453c3e..8c7cc16 100644 --- a/internal/jet/operators.go +++ b/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 } diff --git a/internal/jet/order_set_aggregate_functions.go b/internal/jet/order_set_aggregate_functions.go index c853845..288f8a3 100644 --- a/internal/jet/order_set_aggregate_functions.go +++ b/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 } diff --git a/internal/jet/range_expression.go b/internal/jet/range_expression.go index 77ed290..cfd26cf 100644 --- a/internal/jet/range_expression.go +++ b/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 - expression.setParent(rangeExpressionWrap) + rangeExpressionWrap.rangeInterfaceImpl.root = rangeExpressionWrap + expression.setRoot(rangeExpressionWrap) return rangeExpressionWrap } diff --git a/internal/jet/raw_statement.go b/internal/jet/raw_statement.go index 427b3c8..ec551f0 100644 --- a/internal/jet/raw_statement.go +++ b/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 } diff --git a/internal/jet/row_expression.go b/internal/jet/row_expression.go index a07d140..6df1c60 100644 --- a/internal/jet/row_expression.go +++ b/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 } diff --git a/internal/jet/statement.go b/internal/jet/statement.go index bfa9e8e..b2f951a 100644 --- a/internal/jet/statement.go +++ b/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, }, diff --git a/internal/jet/string_expression.go b/internal/jet/string_expression.go index c7f1158..5d373ca 100644 --- a/internal/jet/string_expression.go +++ b/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 - expression.setParent(stringExpressionWrap) + stringExpressionWrap.stringInterfaceImpl.root = stringExpressionWrap + expression.setRoot(stringExpressionWrap) return stringExpressionWrap } diff --git a/internal/jet/time_expression.go b/internal/jet/time_expression.go index 215d3bc..dde3a7c 100644 --- a/internal/jet/time_expression.go +++ b/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 - expression.setParent(timeExpressionWrap) + timeExpressionWrap.timeInterfaceImpl.root = timeExpressionWrap + expression.setRoot(timeExpressionWrap) return timeExpressionWrap } diff --git a/internal/jet/timestamp_expression.go b/internal/jet/timestamp_expression.go index 222b1e4..23a7fb9 100644 --- a/internal/jet/timestamp_expression.go +++ b/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 := ×tampExpressionWrapper{Expression: expression} - timestampExpressionWrap.timestampInterfaceImpl.parent = timestampExpressionWrap - expression.setParent(timestampExpressionWrap) + timestampExpressionWrap.timestampInterfaceImpl.root = timestampExpressionWrap + expression.setRoot(timestampExpressionWrap) return timestampExpressionWrap } diff --git a/internal/jet/timestampz_expression.go b/internal/jet/timestampz_expression.go index 6500251..77ddb44 100644 --- a/internal/jet/timestampz_expression.go +++ b/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 := ×tampzExpressionWrapper{Expression: expression} - timestampzExpressionWrap.timestampzInterfaceImpl.parent = timestampzExpressionWrap - expression.setParent(timestampzExpressionWrap) + timestampzExpressionWrap.timestampzInterfaceImpl.root = timestampzExpressionWrap + expression.setRoot(timestampzExpressionWrap) return timestampzExpressionWrap } diff --git a/internal/jet/timez_expression.go b/internal/jet/timez_expression.go index 590ec96..0371915 100644 --- a/internal/jet/timez_expression.go +++ b/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 - expression.setParent(timezExpressionWrap) + timezExpressionWrap.timezInterfaceImpl.root = timezExpressionWrap + expression.setRoot(timezExpressionWrap) return timezExpressionWrap } diff --git a/internal/jet/window_func.go b/internal/jet/window_func.go index 6602495..fe28077 100644 --- a/internal/jet/window_func.go +++ b/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 { - newWindow.parent = newWindow + if root == nil { + 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 } diff --git a/internal/jet/with_statement.go b/internal/jet/with_statement.go index d507072..3d94247 100644 --- a/internal/jet/with_statement.go +++ b/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) diff --git a/mysql/lateral.go b/mysql/lateral.go index 30ebb49..5b89b5d 100644 --- a/mysql/lateral.go +++ b/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 } diff --git a/mysql/select_statement.go b/mysql/select_statement.go index 915fe93..a0dfd0d 100644 --- a/mysql/select_statement.go +++ b/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 } diff --git a/mysql/select_table.go b/mysql/select_table.go index 8ca06d4..7ecf9e0 100644 --- a/mysql/select_table.go +++ b/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 } diff --git a/mysql/set_statement.go b/mysql/set_statement.go index 7147f00..a38dfa2 100644 --- a/mysql/set_statement.go +++ b/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 } diff --git a/mysql/table.go b/mysql/table.go index ebc67e2..1d02fc2 100644 --- a/mysql/table.go +++ b/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.parent = t + t.readableTableInterfaceImpl.root = 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.parent = newJoinTable + newJoinTable.readableTableInterfaceImpl.root = newJoinTable + newJoinTable.root = newJoinTable return newJoinTable } diff --git a/mysql/with_statement.go b/mysql/with_statement.go index 03b4d5b..6511729 100644 --- a/mysql/with_statement.go +++ b/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 } diff --git a/postgres/lateral.go b/postgres/lateral.go index 7b0ded6..eca3568 100644 --- a/postgres/lateral.go +++ b/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 } diff --git a/postgres/select_table.go b/postgres/select_table.go index 5f57c1d..78dbba5 100644 --- a/postgres/select_table.go +++ b/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 } diff --git a/postgres/table.go b/postgres/table.go index aa54213..f89577f 100644 --- a/postgres/table.go +++ b/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.writableTableInterfaceImpl.parent = t + t.readableTableInterfaceImpl.root = 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 } diff --git a/postgres/with_statement.go b/postgres/with_statement.go index 99ddc8f..f851f4b 100644 --- a/postgres/with_statement.go +++ b/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 } diff --git a/sqlite/select_statement.go b/sqlite/select_statement.go index 531ae76..68856cf 100644 --- a/sqlite/select_statement.go +++ b/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 } diff --git a/sqlite/select_table.go b/sqlite/select_table.go index 7421f4b..6bd5ae8 100644 --- a/sqlite/select_table.go +++ b/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 } diff --git a/sqlite/set_statement.go b/sqlite/set_statement.go index 47723a3..662415a 100644 --- a/sqlite/set_statement.go +++ b/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 } diff --git a/sqlite/table.go b/sqlite/table.go index 6d70f7f..0ddc2ff 100644 --- a/sqlite/table.go +++ b/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.parent = t + t.readableTableInterfaceImpl.root = 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.parent = newJoinTable + newJoinTable.readableTableInterfaceImpl.root = newJoinTable + newJoinTable.root = newJoinTable return newJoinTable } diff --git a/sqlite/with_statement.go b/sqlite/with_statement.go index b05da7d..038f9a0 100644 --- a/sqlite/with_statement.go +++ b/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 }