Gleipnir/jet
4
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity Actions

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

Browse source
This commit is contained in:
go-jet 2025-03-09 19:06:17 +01:00
parent 1f3215c879
commit cfc264221b
41 changed files with 390 additions and 390 deletions
Download patch file Download diff file Expand all files Collapse all files

32
internal/jet/blob_expression.go
View file

@ -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
}

30
internal/jet/bool_expression.go
View file

@ -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
}

2
internal/jet/cast.go
View file

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

12
internal/jet/column.go
View file

@ -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")

24
internal/jet/column_types.go
View file

@ -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

30
internal/jet/date_expression.go
View file

@ -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
}

4
internal/jet/enum_value.go
View file

@ -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
}

50
internal/jet/expression.go
View file

@ -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
}

38
internal/jet/float_expression.go
View file

@ -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
}

42
internal/jet/func_expression.go
View file

@ -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 := &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
}

48
internal/jet/integer_expression.go
View file

@ -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
}

34
internal/jet/interval_expression.go
View file

@ -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
}

38
internal/jet/literal_expression.go
View file

@ -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 := &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
}

2
internal/jet/operators.go
View file

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

2
internal/jet/order_set_aggregate_functions.go
View file

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

44
internal/jet/range_expression.go
View file

@ -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
}

4
internal/jet/raw_statement.go
View file

@ -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
}

22
internal/jet/row_expression.go
View file

@ -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
}

16
internal/jet/statement.go
View file

@ -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,
},

36
internal/jet/string_expression.go
View file

@ -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
}

30
internal/jet/time_expression.go
View file

@ -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
}

30
internal/jet/timestamp_expression.go
View file

@ -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
expression.setParent(timestampExpressionWrap)
timestampExpressionWrap.timestampInterfaceImpl.root = timestampExpressionWrap
expression.setRoot(timestampExpressionWrap)
return timestampExpressionWrap
}

30
internal/jet/timestampz_expression.go
View file

@ -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
expression.setParent(timestampzExpressionWrap)
timestampzExpressionWrap.timestampzInterfaceImpl.root = timestampzExpressionWrap
expression.setRoot(timestampzExpressionWrap)
return timestampzExpressionWrap
}

30
internal/jet/timez_expression.go
View file

@ -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
}

20
internal/jet/window_func.go
View file

@ -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
}

2
internal/jet/with_statement.go
View file

@ -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)

2
mysql/lateral.go
View file

@ -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
}

2
mysql/select_statement.go
View file

@ -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
}

2
mysql/select_table.go
View file

@ -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
}

8
mysql/set_statement.go
View file

@ -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
}

32
mysql/table.go
View file

@ -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
}

2
mysql/with_statement.go
View file

@ -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
}

2
postgres/lateral.go
View file

@ -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
}

2
postgres/select_table.go
View file

@ -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
}

30
postgres/table.go
View file

@ -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
}

2
postgres/with_statement.go
View file

@ -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
}

2
sqlite/select_statement.go
View file

@ -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
}

2
sqlite/select_table.go
View file

@ -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
}

8
sqlite/set_statement.go
View file

@ -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
}

30
sqlite/table.go
View file

@ -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
}

2
sqlite/with_statement.go
View file

@ -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
}