diff --git a/internal/jet/date_expression.go b/internal/jet/date_expression.go index 27c2035..560688a 100644 --- a/internal/jet/date_expression.go +++ b/internal/jet/date_expression.go @@ -13,6 +13,8 @@ type DateExpression interface { LT_EQ(rhs DateExpression) BoolExpression GT(rhs DateExpression) BoolExpression GT_EQ(rhs DateExpression) BoolExpression + BETWEEN(min, max DateExpression) BoolExpression + NOT_BETWEEN(min, max DateExpression) BoolExpression ADD(rhs Interval) TimestampExpression SUB(rhs Interval) TimestampExpression @@ -54,6 +56,14 @@ func (d *dateInterfaceImpl) GT_EQ(rhs DateExpression) BoolExpression { return GtEq(d.parent, rhs) } +func (d *dateInterfaceImpl) BETWEEN(min, max DateExpression) BoolExpression { + return NewBetweenOperatorExpression(d.parent, min, max, false) +} + +func (d *dateInterfaceImpl) NOT_BETWEEN(min, max DateExpression) BoolExpression { + return NewBetweenOperatorExpression(d.parent, min, max, true) +} + func (d *dateInterfaceImpl) ADD(rhs Interval) TimestampExpression { return TimestampExp(Add(d.parent, rhs)) } diff --git a/internal/jet/expression.go b/internal/jet/expression.go index 14e6a9b..ad5c205 100644 --- a/internal/jet/expression.go +++ b/internal/jet/expression.go @@ -196,3 +196,45 @@ func (p *postfixOpExpression) serialize(statement StatementType, out *SQLBuilder out.WriteString(p.operator) } + +type betweenOperatorExpression struct { + ExpressionInterfaceImpl + + expression Expression + notBetween bool + min Expression + max Expression +} + +// NewBetweenOperatorExpression creates new BETWEEN operator expression +func NewBetweenOperatorExpression(expression, min, max Expression, notBetween bool) BoolExpression { + newBetweenOperator := &betweenOperatorExpression{ + expression: expression, + notBetween: notBetween, + min: min, + max: max, + } + + newBetweenOperator.ExpressionInterfaceImpl.Parent = newBetweenOperator + + return BoolExp(newBetweenOperator) +} + +func (p *betweenOperatorExpression) serialize(statement StatementType, out *SQLBuilder, options ...SerializeOption) { + if !contains(options, NoWrap) { + out.WriteString("(") + } + + p.expression.serialize(statement, out, FallTrough(options)...) + if p.notBetween { + out.WriteString("NOT") + } + out.WriteString("BETWEEN") + p.min.serialize(statement, out, FallTrough(options)...) + out.WriteString("AND") + p.max.serialize(statement, out, FallTrough(options)...) + + if !contains(options, NoWrap) { + out.WriteString(")") + } +} diff --git a/internal/jet/float_expression.go b/internal/jet/float_expression.go index 20c8d3f..3fb30fe 100644 --- a/internal/jet/float_expression.go +++ b/internal/jet/float_expression.go @@ -14,6 +14,8 @@ type FloatExpression interface { LT_EQ(rhs FloatExpression) BoolExpression GT(rhs FloatExpression) BoolExpression GT_EQ(rhs FloatExpression) BoolExpression + BETWEEN(min, max FloatExpression) BoolExpression + NOT_BETWEEN(min, max FloatExpression) BoolExpression ADD(rhs NumericExpression) FloatExpression SUB(rhs NumericExpression) FloatExpression @@ -60,6 +62,14 @@ func (n *floatInterfaceImpl) LT_EQ(rhs FloatExpression) BoolExpression { return LtEq(n.parent, rhs) } +func (n *floatInterfaceImpl) BETWEEN(min, max FloatExpression) BoolExpression { + return NewBetweenOperatorExpression(n.parent, min, max, false) +} + +func (n *floatInterfaceImpl) NOT_BETWEEN(min, max FloatExpression) BoolExpression { + return NewBetweenOperatorExpression(n.parent, min, max, true) +} + func (n *floatInterfaceImpl) ADD(rhs NumericExpression) FloatExpression { return FloatExp(Add(n.parent, rhs)) } diff --git a/internal/jet/integer_expression.go b/internal/jet/integer_expression.go index ff2a0a0..32d15e0 100644 --- a/internal/jet/integer_expression.go +++ b/internal/jet/integer_expression.go @@ -5,46 +5,29 @@ type IntegerExpression interface { Expression numericExpression - // Check if expression is equal to rhs EQ(rhs IntegerExpression) BoolExpression - // Check if expression is not equal to rhs NOT_EQ(rhs IntegerExpression) BoolExpression - // Check if expression is distinct from rhs IS_DISTINCT_FROM(rhs IntegerExpression) BoolExpression - // Check if expression is not distinct from rhs IS_NOT_DISTINCT_FROM(rhs IntegerExpression) BoolExpression - // Check if expression is less then rhs LT(rhs IntegerExpression) BoolExpression - // Check if expression is less then equal rhs LT_EQ(rhs IntegerExpression) BoolExpression - // Check if expression is greater then rhs GT(rhs IntegerExpression) BoolExpression - // Check if expression is greater then equal rhs GT_EQ(rhs IntegerExpression) BoolExpression + BETWEEN(min, max IntegerExpression) BoolExpression + NOT_BETWEEN(min, max IntegerExpression) BoolExpression - // expression + rhs ADD(rhs IntegerExpression) IntegerExpression - // expression - rhs SUB(rhs IntegerExpression) IntegerExpression - // expression * rhs MUL(rhs IntegerExpression) IntegerExpression - // expression / rhs DIV(rhs IntegerExpression) IntegerExpression - // expression % rhs MOD(rhs IntegerExpression) IntegerExpression - // expression ^ rhs POW(rhs IntegerExpression) IntegerExpression - // expression & rhs BIT_AND(rhs IntegerExpression) IntegerExpression - // expression | rhs BIT_OR(rhs IntegerExpression) IntegerExpression - // expression # rhs BIT_XOR(rhs IntegerExpression) IntegerExpression - // expression << rhs BIT_SHIFT_LEFT(shift IntegerExpression) IntegerExpression - // expression >> rhs BIT_SHIFT_RIGHT(shift IntegerExpression) IntegerExpression } @@ -85,6 +68,14 @@ func (i *integerInterfaceImpl) LT_EQ(rhs IntegerExpression) BoolExpression { return LtEq(i.parent, rhs) } +func (i *integerInterfaceImpl) BETWEEN(min, max IntegerExpression) BoolExpression { + return NewBetweenOperatorExpression(i.parent, min, max, false) +} + +func (i *integerInterfaceImpl) NOT_BETWEEN(min, max IntegerExpression) BoolExpression { + return NewBetweenOperatorExpression(i.parent, min, max, true) +} + func (i *integerInterfaceImpl) ADD(rhs IntegerExpression) IntegerExpression { return IntExp(Add(i.parent, rhs)) } diff --git a/internal/jet/integer_expression_test.go b/internal/jet/integer_expression_test.go index 7920545..a20981b 100644 --- a/internal/jet/integer_expression_test.go +++ b/internal/jet/integer_expression_test.go @@ -99,3 +99,9 @@ func TestIntExpressionIntExp(t *testing.T) { assertClauseSerialize(t, IntExp(table1ColFloat.ADD(table2ColFloat)).ADD(Int(11)), "((table1.col_float + table2.col_float) + $1)", int64(11)) } + +func TestIntExpressionBetween(t *testing.T) { + assertClauseSerialize(t, table1ColInt.BETWEEN(Int(1), table1Col3), "(table1.col_int BETWEEN $1 AND table1.col3)", int64(1)) + assertClauseSerialize(t, table1ColInt.BETWEEN(Int(1), table1Col3).AND(table1ColBool), + "((table1.col_int BETWEEN $1 AND table1.col3) AND table1.col_bool)", int64(1)) +} diff --git a/internal/jet/string_expression.go b/internal/jet/string_expression.go index 3c56896..4e7efa6 100644 --- a/internal/jet/string_expression.go +++ b/internal/jet/string_expression.go @@ -13,6 +13,8 @@ type StringExpression interface { LT_EQ(rhs StringExpression) BoolExpression GT(rhs StringExpression) BoolExpression GT_EQ(rhs StringExpression) BoolExpression + BETWEEN(min, max StringExpression) BoolExpression + NOT_BETWEEN(min, max StringExpression) BoolExpression CONCAT(rhs Expression) StringExpression @@ -59,6 +61,14 @@ func (s *stringInterfaceImpl) LT_EQ(rhs StringExpression) BoolExpression { return LtEq(s.parent, rhs) } +func (s *stringInterfaceImpl) BETWEEN(min, max StringExpression) BoolExpression { + return NewBetweenOperatorExpression(s.parent, min, max, false) +} + +func (s *stringInterfaceImpl) NOT_BETWEEN(min, max StringExpression) BoolExpression { + return NewBetweenOperatorExpression(s.parent, min, max, true) +} + func (s *stringInterfaceImpl) CONCAT(rhs Expression) StringExpression { return newBinaryStringOperatorExpression(s.parent, rhs, StringConcatOperator) } diff --git a/internal/jet/time_expression.go b/internal/jet/time_expression.go index 4fd7047..efd146f 100644 --- a/internal/jet/time_expression.go +++ b/internal/jet/time_expression.go @@ -13,6 +13,8 @@ type TimeExpression interface { LT_EQ(rhs TimeExpression) BoolExpression GT(rhs TimeExpression) BoolExpression GT_EQ(rhs TimeExpression) BoolExpression + BETWEEN(min, max TimeExpression) BoolExpression + NOT_BETWEEN(min, max TimeExpression) BoolExpression ADD(rhs Interval) TimeExpression SUB(rhs Interval) TimeExpression @@ -54,6 +56,14 @@ func (t *timeInterfaceImpl) GT_EQ(rhs TimeExpression) BoolExpression { return GtEq(t.parent, rhs) } +func (t *timeInterfaceImpl) BETWEEN(min, max TimeExpression) BoolExpression { + return NewBetweenOperatorExpression(t.parent, min, max, false) +} + +func (t *timeInterfaceImpl) NOT_BETWEEN(min, max TimeExpression) BoolExpression { + return NewBetweenOperatorExpression(t.parent, min, max, true) +} + func (t *timeInterfaceImpl) ADD(rhs Interval) TimeExpression { return TimeExp(Add(t.parent, rhs)) } diff --git a/internal/jet/timestamp_expression.go b/internal/jet/timestamp_expression.go index f4cdd0b..1013ce1 100644 --- a/internal/jet/timestamp_expression.go +++ b/internal/jet/timestamp_expression.go @@ -13,6 +13,8 @@ type TimestampExpression interface { LT_EQ(rhs TimestampExpression) BoolExpression GT(rhs TimestampExpression) BoolExpression GT_EQ(rhs TimestampExpression) BoolExpression + BETWEEN(min, max TimestampExpression) BoolExpression + NOT_BETWEEN(min, max TimestampExpression) BoolExpression ADD(rhs Interval) TimestampExpression SUB(rhs Interval) TimestampExpression @@ -54,6 +56,14 @@ func (t *timestampInterfaceImpl) GT_EQ(rhs TimestampExpression) BoolExpression { return GtEq(t.parent, rhs) } +func (t *timestampInterfaceImpl) BETWEEN(min, max TimestampExpression) BoolExpression { + return NewBetweenOperatorExpression(t.parent, min, max, false) +} + +func (t *timestampInterfaceImpl) NOT_BETWEEN(min, max TimestampExpression) BoolExpression { + return NewBetweenOperatorExpression(t.parent, min, max, true) +} + func (t *timestampInterfaceImpl) ADD(rhs Interval) TimestampExpression { return TimestampExp(Add(t.parent, rhs)) } diff --git a/internal/jet/timestampz_expression.go b/internal/jet/timestampz_expression.go index 0112a3c..b8fe103 100644 --- a/internal/jet/timestampz_expression.go +++ b/internal/jet/timestampz_expression.go @@ -13,6 +13,8 @@ type TimestampzExpression interface { LT_EQ(rhs TimestampzExpression) BoolExpression GT(rhs TimestampzExpression) BoolExpression GT_EQ(rhs TimestampzExpression) BoolExpression + BETWEEN(min, max TimestampzExpression) BoolExpression + NOT_BETWEEN(min, max TimestampzExpression) BoolExpression ADD(rhs Interval) TimestampzExpression SUB(rhs Interval) TimestampzExpression @@ -54,6 +56,14 @@ func (t *timestampzInterfaceImpl) GT_EQ(rhs TimestampzExpression) BoolExpression return GtEq(t.parent, rhs) } +func (t *timestampzInterfaceImpl) BETWEEN(min, max TimestampzExpression) BoolExpression { + return NewBetweenOperatorExpression(t.parent, min, max, false) +} + +func (t *timestampzInterfaceImpl) NOT_BETWEEN(min, max TimestampzExpression) BoolExpression { + return NewBetweenOperatorExpression(t.parent, min, max, true) +} + func (t *timestampzInterfaceImpl) ADD(rhs Interval) TimestampzExpression { return TimestampzExp(Add(t.parent, rhs)) } diff --git a/internal/jet/timez_expression.go b/internal/jet/timez_expression.go index d36ec80..8896dce 100644 --- a/internal/jet/timez_expression.go +++ b/internal/jet/timez_expression.go @@ -13,6 +13,8 @@ type TimezExpression interface { LT_EQ(rhs TimezExpression) BoolExpression GT(rhs TimezExpression) BoolExpression GT_EQ(rhs TimezExpression) BoolExpression + BETWEEN(min, max TimezExpression) BoolExpression + NOT_BETWEEN(min, max TimezExpression) BoolExpression ADD(rhs Interval) TimezExpression SUB(rhs Interval) TimezExpression @@ -54,6 +56,14 @@ func (t *timezInterfaceImpl) GT_EQ(rhs TimezExpression) BoolExpression { return GtEq(t.parent, rhs) } +func (t *timezInterfaceImpl) BETWEEN(min, max TimezExpression) BoolExpression { + return NewBetweenOperatorExpression(t.parent, min, max, false) +} + +func (t *timezInterfaceImpl) NOT_BETWEEN(min, max TimezExpression) BoolExpression { + return NewBetweenOperatorExpression(t.parent, min, max, true) +} + func (t *timezInterfaceImpl) ADD(rhs Interval) TimezExpression { return TimezExp(Add(t.parent, rhs)) } diff --git a/postgres/interval_expression.go b/postgres/interval_expression.go index 6f5ab58..68d33bc 100644 --- a/postgres/interval_expression.go +++ b/postgres/interval_expression.go @@ -41,6 +41,8 @@ type IntervalExpression interface { LT_EQ(rhs IntervalExpression) BoolExpression GT(rhs IntervalExpression) BoolExpression GT_EQ(rhs IntervalExpression) BoolExpression + BETWEEN(min, max IntervalExpression) BoolExpression + NOT_BETWEEN(min, max IntervalExpression) BoolExpression ADD(rhs IntervalExpression) IntervalExpression SUB(rhs IntervalExpression) IntervalExpression @@ -87,6 +89,14 @@ func (i *intervalInterfaceImpl) GT_EQ(rhs IntervalExpression) BoolExpression { return jet.GtEq(i.parent, rhs) } +func (i *intervalInterfaceImpl) BETWEEN(min, max IntervalExpression) BoolExpression { + return jet.NewBetweenOperatorExpression(i.parent, min, max, false) +} + +func (i *intervalInterfaceImpl) NOT_BETWEEN(min, max IntervalExpression) BoolExpression { + return jet.NewBetweenOperatorExpression(i.parent, min, max, true) +} + func (i *intervalInterfaceImpl) ADD(rhs IntervalExpression) IntervalExpression { return IntervalExp(jet.Add(i.parent, rhs)) } diff --git a/tests/mysql/alltypes_test.go b/tests/mysql/alltypes_test.go index 4ae7f5b..15a4862 100644 --- a/tests/mysql/alltypes_test.go +++ b/tests/mysql/alltypes_test.go @@ -216,6 +216,8 @@ func TestFloatOperators(t *testing.T) { AllTypes.Numeric.LT(Float(34.56)).AS("lt2"), AllTypes.Numeric.GT(Float(124)).AS("gt1"), AllTypes.Numeric.GT(Float(34.56)).AS("gt2"), + AllTypes.Numeric.BETWEEN(Float(1.34), AllTypes.Decimal).AS("between"), + AllTypes.Numeric.NOT_BETWEEN(AllTypes.Decimal.MUL(Float(3)), Float(100.12)).AS("not_between"), TRUNC(AllTypes.Decimal.ADD(AllTypes.Decimal), Int(2)).AS("add1"), TRUNC(AllTypes.Decimal.ADD(Float(11.22)), Int(2)).AS("add2"), @@ -244,11 +246,9 @@ func TestFloatOperators(t *testing.T) { TRUNC(AllTypes.Decimal, Int(1)).AS("trunc"), ).LIMIT(2) - queryStr, _ := query.Sql() + // fmt.Println(query.Sql()) - //fmt.Println(queryStr) - - require.Equal(t, queryStr, strings.Replace(` + testutils.AssertStatementSql(t, query, strings.Replace(` SELECT (all_types.'numeric' = all_types.'numeric') AS "eq1", (all_types.'decimal' = ?) AS "eq2", (all_types.'real' = ?) AS "eq3", @@ -262,6 +262,8 @@ SELECT (all_types.'numeric' = all_types.'numeric') AS "eq1", (all_types.'numeric' < ?) AS "lt2", (all_types.'numeric' > ?) AS "gt1", (all_types.'numeric' > ?) AS "gt2", + (all_types.'numeric' BETWEEN ? AND all_types.'decimal') AS "between", + (all_types.'numeric' NOT BETWEEN (all_types.'decimal' * ?) AND ?) AS "not_between", TRUNCATE((all_types.'decimal' + all_types.'decimal'), ?) AS "add1", TRUNCATE((all_types.'decimal' + ?), ?) AS "add2", TRUNCATE((all_types.'decimal' - all_types.decimal_ptr), ?) AS "sub1", @@ -308,61 +310,48 @@ func TestIntegerOperators(t *testing.T) { AllTypes.BigInt.EQ(AllTypes.BigInt).AS("eq1"), AllTypes.BigInt.EQ(Int(12)).AS("eq2"), - AllTypes.BigInt.NOT_EQ(AllTypes.BigIntPtr).AS("neq1"), AllTypes.BigInt.NOT_EQ(Int(12)).AS("neq2"), - AllTypes.BigInt.IS_DISTINCT_FROM(AllTypes.BigInt).AS("distinct1"), AllTypes.BigInt.IS_DISTINCT_FROM(Int(12)).AS("distinct2"), - AllTypes.BigInt.IS_NOT_DISTINCT_FROM(AllTypes.BigInt).AS("not distinct1"), AllTypes.BigInt.IS_NOT_DISTINCT_FROM(Int(12)).AS("not distinct2"), AllTypes.BigInt.LT(AllTypes.BigIntPtr).AS("lt1"), AllTypes.BigInt.LT(Int(65)).AS("lt2"), - AllTypes.BigInt.LT_EQ(AllTypes.BigIntPtr).AS("lte1"), AllTypes.BigInt.LT_EQ(Int(65)).AS("lte2"), - AllTypes.BigInt.GT(AllTypes.BigIntPtr).AS("gt1"), AllTypes.BigInt.GT(Int(65)).AS("gt2"), - AllTypes.BigInt.GT_EQ(AllTypes.BigIntPtr).AS("gte1"), AllTypes.BigInt.GT_EQ(Int(65)).AS("gte2"), + AllTypes.Integer.BETWEEN(Int(11), Int(200)).AS("between"), + AllTypes.Integer.NOT_BETWEEN(Int(66), Int(77)).AS("not_between"), AllTypes.BigInt.ADD(AllTypes.BigInt).AS("add1"), AllTypes.BigInt.ADD(Int(11)).AS("add2"), - AllTypes.BigInt.SUB(AllTypes.BigInt).AS("sub1"), AllTypes.BigInt.SUB(Int(11)).AS("sub2"), - AllTypes.BigInt.MUL(AllTypes.BigInt).AS("mul1"), AllTypes.BigInt.MUL(Int(11)).AS("mul2"), - AllTypes.BigInt.DIV(AllTypes.BigInt).AS("div1"), AllTypes.BigInt.DIV(Int(11)).AS("div2"), - AllTypes.BigInt.MOD(AllTypes.BigInt).AS("mod1"), AllTypes.BigInt.MOD(Int(11)).AS("mod2"), - AllTypes.SmallInt.POW(AllTypes.SmallInt.DIV(Int(3))).AS("pow1"), AllTypes.SmallInt.POW(Int(6)).AS("pow2"), AllTypes.SmallInt.BIT_AND(AllTypes.SmallInt).AS("bit_and1"), AllTypes.SmallInt.BIT_AND(AllTypes.SmallInt).AS("bit_and2"), - AllTypes.SmallInt.BIT_OR(AllTypes.SmallInt).AS("bit or 1"), AllTypes.SmallInt.BIT_OR(Int(22)).AS("bit or 2"), - AllTypes.SmallInt.BIT_XOR(AllTypes.SmallInt).AS("bit xor 1"), AllTypes.SmallInt.BIT_XOR(Int(11)).AS("bit xor 2"), - BIT_NOT(Int(-1).MUL(AllTypes.SmallInt)).AS("bit_not_1"), BIT_NOT(Int(-1).MUL(Int(11))).AS("bit_not_2"), AllTypes.SmallInt.BIT_SHIFT_LEFT(AllTypes.SmallInt.DIV(Int(2))).AS("bit shift left 1"), AllTypes.SmallInt.BIT_SHIFT_LEFT(Int(4)).AS("bit shift left 2"), - AllTypes.SmallInt.BIT_SHIFT_RIGHT(AllTypes.SmallInt.DIV(Int(5))).AS("bit shift right 1"), AllTypes.SmallInt.BIT_SHIFT_RIGHT(Int(1)).AS("bit shift right 2"), @@ -371,9 +360,9 @@ func TestIntegerOperators(t *testing.T) { CBRT(ABSi(AllTypes.BigInt)).AS("cbrt"), ).LIMIT(2) - //fmt.Println(query.Sql()) + // fmt.Println(query.Sql()) - testutils.AssertStatementSql(t, query, ` + testutils.AssertStatementSql(t, query, strings.ReplaceAll(` SELECT all_types.big_int AS "all_types.big_int", all_types.big_int_ptr AS "all_types.big_int_ptr", all_types.small_int AS "all_types.small_int", @@ -394,6 +383,8 @@ SELECT all_types.big_int AS "all_types.big_int", (all_types.big_int > ?) AS "gt2", (all_types.big_int >= all_types.big_int_ptr) AS "gte1", (all_types.big_int >= ?) AS "gte2", + (all_types.''integer'' BETWEEN ? AND ?) AS "between", + (all_types.''integer'' NOT BETWEEN ? AND ?) AS "not_between", (all_types.big_int + all_types.big_int) AS "add1", (all_types.big_int + ?) AS "add2", (all_types.big_int - all_types.big_int) AS "sub1", @@ -423,7 +414,7 @@ SELECT all_types.big_int AS "all_types.big_int", POWER(ABS(all_types.big_int), (? / ?)) AS "cbrt" FROM test_sample.all_types LIMIT ?; -`) +`, "''", "`")) var dest []struct { common.AllTypesIntegerExpResult `alias:"."` @@ -453,6 +444,8 @@ func TestStringOperators(t *testing.T) { AllTypes.Text.LT(String("Text")), AllTypes.Text.LT_EQ(AllTypes.VarCharPtr), AllTypes.Text.LT_EQ(String("Text")), + AllTypes.Text.BETWEEN(String("min"), String("max")), + AllTypes.Text.NOT_BETWEEN(AllTypes.VarChar, AllTypes.CharPtr), AllTypes.Text.CONCAT(String("text2")), AllTypes.Text.CONCAT(Int(11)), AllTypes.Text.LIKE(String("abc")), @@ -520,24 +513,21 @@ func TestTimeExpressions(t *testing.T) { AllTypes.TimePtr.NOT_EQ(AllTypes.Time), AllTypes.TimePtr.NOT_EQ(Time(20, 16, 6)), - AllTypes.Time.IS_DISTINCT_FROM(AllTypes.Time), AllTypes.Time.IS_DISTINCT_FROM(Time(19, 26, 6)), - AllTypes.Time.IS_NOT_DISTINCT_FROM(AllTypes.Time), AllTypes.Time.IS_NOT_DISTINCT_FROM(Time(18, 36, 6)), AllTypes.Time.LT(AllTypes.Time), AllTypes.Time.LT(Time(17, 46, 6)), - AllTypes.Time.LT_EQ(AllTypes.Time), AllTypes.Time.LT_EQ(Time(16, 56, 56)), - AllTypes.Time.GT(AllTypes.Time), AllTypes.Time.GT(Time(15, 16, 46)), - AllTypes.Time.GT_EQ(AllTypes.Time), AllTypes.Time.GT_EQ(Time(14, 26, 36)), + AllTypes.Time.BETWEEN(Time(11, 0, 30, 100), AllTypes.TimePtr), + AllTypes.Time.NOT_BETWEEN(AllTypes.TimePtr, AllTypes.Time.ADD(INTERVAL(2, HOUR))), AllTypes.Time.ADD(INTERVAL(10, MINUTE)), AllTypes.Time.ADD(INTERVALe(AllTypes.Integer, MINUTE)), @@ -575,6 +565,8 @@ SELECT CAST('20:34:58' AS TIME), all_types.time > CAST('15:16:46' AS TIME), all_types.time >= all_types.time, all_types.time >= CAST('14:26:36' AS TIME), + all_types.time BETWEEN CAST('11:00:30.0000001' AS TIME) AND all_types.time_ptr, + all_types.time NOT BETWEEN all_types.time_ptr AND (all_types.time + INTERVAL 2 HOUR), all_types.time + INTERVAL 10 MINUTE, all_types.time + INTERVAL all_types.''integer'' MINUTE, all_types.time + INTERVAL 3 HOUR, @@ -586,7 +578,7 @@ SELECT CAST('20:34:58' AS TIME), CURRENT_TIME(3) FROM test_sample.all_types; `, "''", "`", -1), "20:34:58", "23:06:06", "22:06:06.011", "21:06:06.011111", "20:16:06", - "19:26:06", "18:36:06", "17:46:06", "16:56:56", "15:16:46", "14:26:36") + "19:26:06", "18:36:06", "17:46:06", "16:56:56", "15:16:46", "14:26:36", "11:00:30.0000001") dest := []struct{}{} err := query.Query(db, &dest) @@ -600,27 +592,23 @@ func TestDateExpressions(t *testing.T) { AllTypes.Date.EQ(AllTypes.Date), AllTypes.Date.EQ(Date(2019, 6, 6)), - AllTypes.DatePtr.NOT_EQ(AllTypes.Date), AllTypes.DatePtr.NOT_EQ(Date(2019, 1, 6)), - AllTypes.Date.IS_DISTINCT_FROM(AllTypes.Date), AllTypes.Date.IS_DISTINCT_FROM(Date(2019, 2, 6)), - AllTypes.Date.IS_NOT_DISTINCT_FROM(AllTypes.Date), AllTypes.Date.IS_NOT_DISTINCT_FROM(Date(2019, 3, 6)), AllTypes.Date.LT(AllTypes.Date), AllTypes.Date.LT(Date(2019, 4, 6)), - AllTypes.Date.LT_EQ(AllTypes.Date), AllTypes.Date.LT_EQ(Date(2019, 5, 5)), - AllTypes.Date.GT(AllTypes.Date), AllTypes.Date.GT(Date(2019, 1, 4)), - AllTypes.Date.GT_EQ(AllTypes.Date), AllTypes.Date.GT_EQ(Date(2019, 2, 3)), + AllTypes.Date.BETWEEN(Date(2000, 2, 2), AllTypes.DatePtr), + AllTypes.Date.NOT_BETWEEN(AllTypes.DatePtr, Date(2000, 2, 2)), AllTypes.Date.ADD(INTERVAL("10:20.000100", MINUTE_MICROSECOND)), AllTypes.Date.ADD(INTERVALe(AllTypes.BigInt, MINUTE)), @@ -653,6 +641,8 @@ SELECT CAST('2009-11-17' AS DATE), all_types.date > CAST('2019-01-04' AS DATE), all_types.date >= all_types.date, all_types.date >= CAST('2019-02-03' AS DATE), + all_types.date BETWEEN CAST('2000-02-02' AS DATE) AND all_types.date_ptr, + all_types.date NOT BETWEEN all_types.date_ptr AND CAST('2000-02-02' AS DATE), all_types.date + INTERVAL '10:20.000100' MINUTE_MICROSECOND, all_types.date + INTERVAL all_types.big_int MINUTE, all_types.date + INTERVAL 15 HOUR, @@ -676,27 +666,23 @@ func TestDateTimeExpressions(t *testing.T) { query := AllTypes.SELECT( AllTypes.DateTime.EQ(AllTypes.DateTime), AllTypes.DateTime.EQ(dateTime), - AllTypes.DateTimePtr.NOT_EQ(AllTypes.DateTime), AllTypes.DateTimePtr.NOT_EQ(DateTime(2019, 6, 6, 10, 2, 46, 100*time.Millisecond)), - AllTypes.DateTime.IS_DISTINCT_FROM(AllTypes.DateTime), AllTypes.DateTime.IS_DISTINCT_FROM(dateTime), - AllTypes.DateTime.IS_NOT_DISTINCT_FROM(AllTypes.DateTime), AllTypes.DateTime.IS_NOT_DISTINCT_FROM(dateTime), AllTypes.DateTime.LT(AllTypes.DateTime), AllTypes.DateTime.LT(dateTime), - AllTypes.DateTime.LT_EQ(AllTypes.DateTime), AllTypes.DateTime.LT_EQ(dateTime), - AllTypes.DateTime.GT(AllTypes.DateTime), AllTypes.DateTime.GT(dateTime), - AllTypes.DateTime.GT_EQ(AllTypes.DateTime), AllTypes.DateTime.GT_EQ(dateTime), + AllTypes.DateTime.BETWEEN(AllTypes.DateTimePtr, AllTypes.TimestampPtr), + AllTypes.DateTime.NOT_BETWEEN(AllTypes.DateTimePtr, AllTypes.TimestampPtr), AllTypes.DateTime.ADD(INTERVAL("05:10:20.000100", HOUR_MICROSECOND)), AllTypes.DateTime.ADD(INTERVALe(AllTypes.BigInt, HOUR)), @@ -710,7 +696,7 @@ func TestDateTimeExpressions(t *testing.T) { NOW(1), ) - //Println(query.DebugSql()) + //fmt.Println(query.DebugSql()) testutils.AssertDebugStatementSql(t, query, ` SELECT all_types.date_time = all_types.date_time, @@ -729,6 +715,8 @@ SELECT all_types.date_time = all_types.date_time, all_types.date_time > CAST('2019-06-06 10:02:46' AS DATETIME), all_types.date_time >= all_types.date_time, all_types.date_time >= CAST('2019-06-06 10:02:46' AS DATETIME), + all_types.date_time BETWEEN all_types.date_time_ptr AND all_types.timestamp_ptr, + all_types.date_time NOT BETWEEN all_types.date_time_ptr AND all_types.timestamp_ptr, all_types.date_time + INTERVAL '05:10:20.000100' HOUR_MICROSECOND, all_types.date_time + INTERVAL all_types.big_int HOUR, all_types.date_time + INTERVAL 2 HOUR, @@ -753,27 +741,23 @@ func TestTimestampExpressions(t *testing.T) { query := AllTypes.SELECT( AllTypes.Timestamp.EQ(AllTypes.Timestamp), AllTypes.Timestamp.EQ(timestamp), - AllTypes.TimestampPtr.NOT_EQ(AllTypes.Timestamp), AllTypes.TimestampPtr.NOT_EQ(Timestamp(2019, 6, 6, 10, 2, 46, 100*time.Millisecond)), - AllTypes.Timestamp.IS_DISTINCT_FROM(AllTypes.Timestamp), AllTypes.Timestamp.IS_DISTINCT_FROM(timestamp), - AllTypes.Timestamp.IS_NOT_DISTINCT_FROM(AllTypes.Timestamp), AllTypes.Timestamp.IS_NOT_DISTINCT_FROM(timestamp), AllTypes.Timestamp.LT(AllTypes.Timestamp), AllTypes.Timestamp.LT(timestamp), - AllTypes.Timestamp.LT_EQ(AllTypes.Timestamp), AllTypes.Timestamp.LT_EQ(timestamp), - AllTypes.Timestamp.GT(AllTypes.Timestamp), AllTypes.Timestamp.GT(timestamp), - AllTypes.Timestamp.GT_EQ(AllTypes.Timestamp), AllTypes.Timestamp.GT_EQ(timestamp), + AllTypes.Timestamp.BETWEEN(AllTypes.DateTimePtr, AllTypes.TimestampPtr), + AllTypes.Timestamp.NOT_BETWEEN(AllTypes.DateTimePtr, AllTypes.TimestampPtr), AllTypes.Timestamp.ADD(INTERVAL("05:10:20.000100", HOUR_MICROSECOND)), AllTypes.Timestamp.ADD(INTERVALe(AllTypes.BigInt, HOUR)), @@ -806,6 +790,8 @@ SELECT all_types.timestamp = all_types.timestamp, all_types.timestamp > TIMESTAMP('2019-06-06 10:02:46'), all_types.timestamp >= all_types.timestamp, all_types.timestamp >= TIMESTAMP('2019-06-06 10:02:46'), + all_types.timestamp BETWEEN all_types.date_time_ptr AND all_types.timestamp_ptr, + all_types.timestamp NOT BETWEEN all_types.date_time_ptr AND all_types.timestamp_ptr, all_types.timestamp + INTERVAL '05:10:20.000100' HOUR_MICROSECOND, all_types.timestamp + INTERVAL all_types.big_int HOUR, all_types.timestamp + INTERVAL 2 HOUR, diff --git a/tests/postgres/alltypes_test.go b/tests/postgres/alltypes_test.go index a70fffe..1f3f177 100644 --- a/tests/postgres/alltypes_test.go +++ b/tests/postgres/alltypes_test.go @@ -361,6 +361,8 @@ func TestStringOperators(t *testing.T) { AllTypes.Text.LT(String("Text")), AllTypes.Text.LT_EQ(AllTypes.VarChar), AllTypes.Text.LT_EQ(String("Text")), + AllTypes.Text.BETWEEN(String("min"), String("max")), + AllTypes.Text.NOT_BETWEEN(AllTypes.VarChar, AllTypes.CharPtr), AllTypes.Text.CONCAT(String("text2")), AllTypes.Text.CONCAT(Int(11)), AllTypes.Text.LIKE(String("abc")), @@ -513,6 +515,8 @@ func TestFloatOperators(t *testing.T) { AllTypes.Numeric.LT(Float(34.56)).AS("lt2"), AllTypes.Numeric.GT(Float(124)).AS("gt1"), AllTypes.Numeric.GT(Float(34.56)).AS("gt2"), + AllTypes.Numeric.BETWEEN(Float(1.34), AllTypes.Decimal).AS("between"), + AllTypes.Numeric.NOT_BETWEEN(AllTypes.Decimal.MUL(Float(3)), Float(100.12)).AS("not_between"), TRUNC(AllTypes.Decimal.ADD(AllTypes.Decimal), Uint8(2)).AS("add1"), TRUNC(AllTypes.Decimal.ADD(Float(11.22)), Int8(2)).AS("add2"), @@ -557,30 +561,32 @@ SELECT (all_types.numeric = all_types.numeric) AS "eq1", (all_types.numeric < $8) AS "lt2", (all_types.numeric > $9) AS "gt1", (all_types.numeric > $10) AS "gt2", - TRUNC((all_types.decimal + all_types.decimal), $11::smallint) AS "add1", - TRUNC((all_types.decimal + $12), $13::smallint) AS "add2", - TRUNC((all_types.decimal - all_types.decimal_ptr), $14::integer) AS "sub1", - TRUNC((all_types.decimal - $15), $16::smallint) AS "sub2", - TRUNC((all_types.decimal * all_types.decimal_ptr), $17::smallint) AS "mul1", - TRUNC((all_types.decimal * $18), $19::integer) AS "mul2", - TRUNC((all_types.decimal / all_types.decimal_ptr), $20::integer) AS "div1", - TRUNC((all_types.decimal / $21), $22::smallint) AS "div2", - TRUNC((all_types.decimal % all_types.decimal_ptr), $23::smallint) AS "mod1", - TRUNC((all_types.decimal % $24), $25::smallint) AS "mod2", - TRUNC(POW(all_types.decimal, all_types.decimal_ptr), $26::smallint) AS "pow1", - TRUNC(POW(all_types.decimal, $27), $28::smallint) AS "pow2", - TRUNC(ABS(all_types.decimal), $29::smallint) AS "abs", - TRUNC(POWER(all_types.decimal, $30), $31::smallint) AS "power", - TRUNC(SQRT(all_types.decimal), $32::smallint) AS "sqrt", - TRUNC(CBRT(all_types.decimal)::decimal, $33::smallint) AS "cbrt", + (all_types.numeric BETWEEN $11 AND all_types.decimal) AS "between", + (all_types.numeric NOT BETWEEN (all_types.decimal * $12) AND $13) AS "not_between", + TRUNC((all_types.decimal + all_types.decimal), $14::smallint) AS "add1", + TRUNC((all_types.decimal + $15), $16::smallint) AS "add2", + TRUNC((all_types.decimal - all_types.decimal_ptr), $17::integer) AS "sub1", + TRUNC((all_types.decimal - $18), $19::smallint) AS "sub2", + TRUNC((all_types.decimal * all_types.decimal_ptr), $20::smallint) AS "mul1", + TRUNC((all_types.decimal * $21), $22::integer) AS "mul2", + TRUNC((all_types.decimal / all_types.decimal_ptr), $23::integer) AS "div1", + TRUNC((all_types.decimal / $24), $25::smallint) AS "div2", + TRUNC((all_types.decimal % all_types.decimal_ptr), $26::smallint) AS "mod1", + TRUNC((all_types.decimal % $27), $28::smallint) AS "mod2", + TRUNC(POW(all_types.decimal, all_types.decimal_ptr), $29::smallint) AS "pow1", + TRUNC(POW(all_types.decimal, $30), $31::smallint) AS "pow2", + TRUNC(ABS(all_types.decimal), $32::smallint) AS "abs", + TRUNC(POWER(all_types.decimal, $33), $34::smallint) AS "power", + TRUNC(SQRT(all_types.decimal), $35::smallint) AS "sqrt", + TRUNC(CBRT(all_types.decimal)::decimal, $36::smallint) AS "cbrt", CEIL(all_types.real) AS "ceil", FLOOR(all_types.real) AS "floor", ROUND(all_types.decimal) AS "round1", ROUND(all_types.decimal, all_types.integer) AS "round2", SIGN(all_types.real) AS "sign", - TRUNC(all_types.decimal, $34::integer) AS "trunc" + TRUNC(all_types.decimal, $37::integer) AS "trunc" FROM test_sample.all_types -LIMIT $35; +LIMIT $38; `) var dest []struct { @@ -592,6 +598,7 @@ LIMIT $35; require.NoError(t, err) //testutils.PrintJson(dest) + // testutils.SaveJSONFile(dest, "./testdata/results/common/float_operators.json") testutils.AssertJSONFile(t, dest, "./testdata/results/common/float_operators.json") } @@ -605,52 +612,41 @@ func TestIntegerOperators(t *testing.T) { AllTypes.BigInt.EQ(AllTypes.BigInt).AS("eq1"), AllTypes.BigInt.EQ(Int64(12)).AS("eq2"), - AllTypes.BigInt.NOT_EQ(AllTypes.BigIntPtr).AS("neq1"), AllTypes.BigInt.NOT_EQ(Int64(12)).AS("neq2"), - AllTypes.BigInt.IS_DISTINCT_FROM(AllTypes.BigInt).AS("distinct1"), AllTypes.BigInt.IS_DISTINCT_FROM(Int32(12)).AS("distinct2"), - AllTypes.BigInt.IS_NOT_DISTINCT_FROM(AllTypes.BigInt).AS("not distinct1"), AllTypes.BigInt.IS_NOT_DISTINCT_FROM(Int32(12)).AS("not distinct2"), + AllTypes.Integer.BETWEEN(Int(11), Int(200)).AS("between"), + AllTypes.Integer.NOT_BETWEEN(Int(66), Int(77)).AS("not_between"), AllTypes.BigInt.LT(AllTypes.BigIntPtr).AS("lt1"), AllTypes.BigInt.LT(Uint8(65)).AS("lt2"), - AllTypes.BigInt.LT_EQ(AllTypes.BigIntPtr).AS("lte1"), AllTypes.BigInt.LT_EQ(Uint16(65)).AS("lte2"), - AllTypes.BigInt.GT(AllTypes.BigIntPtr).AS("gt1"), AllTypes.BigInt.GT(Uint32(65)).AS("gt2"), - AllTypes.BigInt.GT_EQ(AllTypes.BigIntPtr).AS("gte1"), AllTypes.BigInt.GT_EQ(Uint64(65)).AS("gte2"), AllTypes.BigInt.ADD(AllTypes.BigInt).AS("add1"), AllTypes.BigInt.ADD(Int(11)).AS("add2"), - AllTypes.BigInt.SUB(AllTypes.BigInt).AS("sub1"), AllTypes.BigInt.SUB(Int8(11)).AS("sub2"), - AllTypes.BigInt.MUL(AllTypes.BigInt).AS("mul1"), AllTypes.BigInt.MUL(Int16(11)).AS("mul2"), - AllTypes.BigInt.DIV(AllTypes.BigInt).AS("div1"), AllTypes.BigInt.DIV(Int32(11)).AS("div2"), - AllTypes.BigInt.MOD(AllTypes.BigInt).AS("mod1"), AllTypes.BigInt.MOD(Int64(11)).AS("mod2"), - AllTypes.SmallInt.POW(AllTypes.SmallInt.DIV(Int8(3))).AS("pow1"), AllTypes.SmallInt.POW(Int8(6)).AS("pow2"), AllTypes.SmallInt.BIT_AND(AllTypes.SmallInt).AS("bit_and1"), AllTypes.SmallInt.BIT_AND(AllTypes.SmallInt).AS("bit_and2"), - AllTypes.SmallInt.BIT_OR(AllTypes.SmallInt).AS("bit or 1"), AllTypes.SmallInt.BIT_OR(Int(22)).AS("bit or 2"), - AllTypes.SmallInt.BIT_XOR(AllTypes.SmallInt).AS("bit xor 1"), AllTypes.SmallInt.BIT_XOR(Int(11)).AS("bit xor 2"), @@ -659,7 +655,6 @@ func TestIntegerOperators(t *testing.T) { AllTypes.SmallInt.BIT_SHIFT_LEFT(AllTypes.SmallInt.DIV(Int8(2))).AS("bit shift left 1"), AllTypes.SmallInt.BIT_SHIFT_LEFT(Int(4)).AS("bit shift left 2"), - AllTypes.SmallInt.BIT_SHIFT_RIGHT(AllTypes.SmallInt.DIV(Int(5))).AS("bit shift right 1"), AllTypes.SmallInt.BIT_SHIFT_RIGHT(Int(1)).AS("bit shift right 2"), @@ -683,43 +678,45 @@ SELECT all_types.big_int AS "all_types.big_int", (all_types.big_int IS DISTINCT FROM $3::integer) AS "distinct2", (all_types.big_int IS NOT DISTINCT FROM all_types.big_int) AS "not distinct1", (all_types.big_int IS NOT DISTINCT FROM $4::integer) AS "not distinct2", + (all_types.integer BETWEEN $5 AND $6) AS "between", + (all_types.integer NOT BETWEEN $7 AND $8) AS "not_between", (all_types.big_int < all_types.big_int_ptr) AS "lt1", - (all_types.big_int < $5::smallint) AS "lt2", + (all_types.big_int < $9::smallint) AS "lt2", (all_types.big_int <= all_types.big_int_ptr) AS "lte1", - (all_types.big_int <= $6::integer) AS "lte2", + (all_types.big_int <= $10::integer) AS "lte2", (all_types.big_int > all_types.big_int_ptr) AS "gt1", - (all_types.big_int > $7::bigint) AS "gt2", + (all_types.big_int > $11::bigint) AS "gt2", (all_types.big_int >= all_types.big_int_ptr) AS "gte1", - (all_types.big_int >= $8::bigint) AS "gte2", + (all_types.big_int >= $12::bigint) AS "gte2", (all_types.big_int + all_types.big_int) AS "add1", - (all_types.big_int + $9) AS "add2", + (all_types.big_int + $13) AS "add2", (all_types.big_int - all_types.big_int) AS "sub1", - (all_types.big_int - $10::smallint) AS "sub2", + (all_types.big_int - $14::smallint) AS "sub2", (all_types.big_int * all_types.big_int) AS "mul1", - (all_types.big_int * $11::smallint) AS "mul2", + (all_types.big_int * $15::smallint) AS "mul2", (all_types.big_int / all_types.big_int) AS "div1", - (all_types.big_int / $12::integer) AS "div2", + (all_types.big_int / $16::integer) AS "div2", (all_types.big_int % all_types.big_int) AS "mod1", - (all_types.big_int % $13::bigint) AS "mod2", - POW(all_types.small_int, (all_types.small_int / $14::smallint)) AS "pow1", - POW(all_types.small_int, $15::smallint) AS "pow2", + (all_types.big_int % $17::bigint) AS "mod2", + POW(all_types.small_int, (all_types.small_int / $18::smallint)) AS "pow1", + POW(all_types.small_int, $19::smallint) AS "pow2", (all_types.small_int & all_types.small_int) AS "bit_and1", (all_types.small_int & all_types.small_int) AS "bit_and2", (all_types.small_int | all_types.small_int) AS "bit or 1", - (all_types.small_int | $16) AS "bit or 2", + (all_types.small_int | $20) AS "bit or 2", (all_types.small_int # all_types.small_int) AS "bit xor 1", - (all_types.small_int # $17) AS "bit xor 2", - (~ ($18 * all_types.small_int)) AS "bit_not_1", + (all_types.small_int # $21) AS "bit xor 2", + (~ ($22 * all_types.small_int)) AS "bit_not_1", (~ -11) AS "bit_not_2", - (all_types.small_int << (all_types.small_int / $19::smallint)) AS "bit shift left 1", - (all_types.small_int << $20) AS "bit shift left 2", - (all_types.small_int >> (all_types.small_int / $21)) AS "bit shift right 1", - (all_types.small_int >> $22) AS "bit shift right 2", + (all_types.small_int << (all_types.small_int / $23::smallint)) AS "bit shift left 1", + (all_types.small_int << $24) AS "bit shift left 2", + (all_types.small_int >> (all_types.small_int / $25)) AS "bit shift right 1", + (all_types.small_int >> $26) AS "bit shift right 2", ABS(all_types.big_int) AS "abs", SQRT(ABS(all_types.big_int)) AS "sqrt", CBRT(ABS(all_types.big_int)) AS "cbrt" FROM test_sample.all_types -LIMIT $23; +LIMIT $27; `) var dest []struct { @@ -730,7 +727,7 @@ LIMIT $23; require.NoError(t, err) - //testutils.SaveJsonFile("./testdata/common/int_operators.json", dest) + //testutils.SaveJSONFile(dest, "./testdata/results/common/int_operators.json") //testutils.PrintJson(dest) testutils.AssertJSONFile(t, dest, "./testdata/results/common/int_operators.json") } @@ -761,21 +758,18 @@ func TestTimeExpression(t *testing.T) { AllTypes.Time.IS_DISTINCT_FROM(AllTypes.Time), AllTypes.Time.IS_DISTINCT_FROM(Time(23, 6, 6, 100)), - AllTypes.Time.IS_NOT_DISTINCT_FROM(AllTypes.Time), AllTypes.Time.IS_NOT_DISTINCT_FROM(Time(23, 6, 6, 200)), - AllTypes.Time.LT(AllTypes.Time), AllTypes.Time.LT(Time(23, 6, 6, 22)), - AllTypes.Time.LT_EQ(AllTypes.Time), AllTypes.Time.LT_EQ(Time(23, 6, 6, 33)), - AllTypes.Time.GT(AllTypes.Time), AllTypes.Time.GT(Time(23, 6, 6, 0)), - AllTypes.Time.GT_EQ(AllTypes.Time), AllTypes.Time.GT_EQ(Time(23, 6, 6, 1)), + AllTypes.Time.BETWEEN(Time(11, 0, 30, 100), TimeT(time.Now())), + AllTypes.Time.NOT_BETWEEN(AllTypes.TimePtr, AllTypes.Time.ADD(INTERVAL(2, HOUR))), AllTypes.Date.ADD(INTERVAL(1, HOUR)), AllTypes.Date.SUB(INTERVAL(1, MINUTE)), @@ -783,12 +777,20 @@ func TestTimeExpression(t *testing.T) { AllTypes.Time.SUB(INTERVAL(1, MINUTE)), AllTypes.Timez.ADD(INTERVAL(1, HOUR)), AllTypes.Timez.SUB(INTERVAL(1, MINUTE)), + AllTypes.Timez.BETWEEN(TimezT(time.Now()), AllTypes.TimezPtr), + AllTypes.Timez.NOT_BETWEEN(AllTypes.Timez, TimezT(time.Now())), AllTypes.Timestamp.ADD(INTERVAL(1, HOUR)), AllTypes.Timestamp.SUB(INTERVAL(1, MINUTE)), + AllTypes.Timestamp.BETWEEN(AllTypes.TimestampPtr, TimestampT(time.Now())), + AllTypes.Timestamp.NOT_BETWEEN(TimestampT(time.Now()), AllTypes.TimestampPtr), AllTypes.Timestampz.ADD(INTERVAL(1, HOUR)), AllTypes.Timestampz.SUB(INTERVAL(1, MINUTE)), + AllTypes.Timestamp.BETWEEN(AllTypes.TimestampPtr, TimestampT(time.Now())), + AllTypes.Timestamp.NOT_BETWEEN(AllTypes.TimestampPtr, TimestampT(time.Now())), AllTypes.Date.SUB(CAST(String("04:05:06")).AS_INTERVAL()), + AllTypes.Date.BETWEEN(Date(2000, 2, 2), DateT(time.Now())), + AllTypes.Date.NOT_BETWEEN(AllTypes.DatePtr, DateT(time.Now().Add(20*time.Hour))), CURRENT_DATE(), CURRENT_TIME(), @@ -849,6 +851,8 @@ func TestInterval(t *testing.T) { AllTypes.Interval.LT_EQ(AllTypes.IntervalPtr).EQ(AllTypes.BooleanPtr), AllTypes.Interval.GT(AllTypes.IntervalPtr).EQ(AllTypes.BooleanPtr), AllTypes.Interval.GT_EQ(AllTypes.IntervalPtr).EQ(AllTypes.BooleanPtr), + AllTypes.Interval.BETWEEN(INTERVAL(1, HOUR), INTERVAL(2, HOUR)), + AllTypes.Interval.NOT_BETWEEN(AllTypes.IntervalPtr, INTERVALd(30*time.Second)), AllTypes.Interval.ADD(AllTypes.IntervalPtr).EQ(INTERVALd(17*time.Second)), AllTypes.Interval.SUB(AllTypes.IntervalPtr).EQ(INTERVAL(100, MICROSECOND)), AllTypes.IntervalPtr.MUL(Int(11)).EQ(AllTypes.Interval), diff --git a/tests/sqlite/alltypes_test.go b/tests/sqlite/alltypes_test.go index 523d959..1d90bf2 100644 --- a/tests/sqlite/alltypes_test.go +++ b/tests/sqlite/alltypes_test.go @@ -347,10 +347,13 @@ func TestFloatOperators(t *testing.T) { AllTypes.Numeric.IS_NOT_DISTINCT_FROM(AllTypes.Numeric).AS("not_distinct1"), AllTypes.Decimal.IS_NOT_DISTINCT_FROM(Float(12)).AS("not_distinct2"), AllTypes.Real.IS_NOT_DISTINCT_FROM(Float(12.12)).AS("not_distinct3"), + AllTypes.Numeric.LT(Float(124)).AS("lt1"), AllTypes.Numeric.LT(Float(34.56)).AS("lt2"), AllTypes.Numeric.GT(Float(124)).AS("gt1"), AllTypes.Numeric.GT(Float(34.56)).AS("gt2"), + AllTypes.Numeric.BETWEEN(Float(1.34), AllTypes.Decimal).AS("between"), + AllTypes.Numeric.NOT_BETWEEN(AllTypes.Decimal.MUL(Float(3)), Float(100.12)).AS("not_between"), AllTypes.Decimal.ADD(AllTypes.Decimal).AS("add1"), AllTypes.Decimal.ADD(Float(11.22)).AS("add2"), @@ -395,6 +398,8 @@ SELECT (all_types.numeric = all_types.numeric) AS "eq1", (all_types.numeric < ?) AS "lt2", (all_types.numeric > ?) AS "gt1", (all_types.numeric > ?) AS "gt2", + (all_types.numeric BETWEEN ? AND all_types.decimal) AS "between", + (all_types.numeric NOT BETWEEN (all_types.decimal * ?) AND ?) AS "not_between", (all_types.decimal + all_types.decimal) AS "add1", (all_types.decimal + ?) AS "add2", (all_types.decimal - all_types.decimal_ptr) AS "sub1", @@ -441,40 +446,32 @@ func TestIntegerOperators(t *testing.T) { AllTypes.BigInt.EQ(AllTypes.BigInt).AS("eq1"), AllTypes.BigInt.EQ(Int(12)).AS("eq2"), - AllTypes.BigInt.NOT_EQ(AllTypes.BigIntPtr).AS("neq1"), AllTypes.BigInt.NOT_EQ(Int(12)).AS("neq2"), - AllTypes.BigInt.IS_DISTINCT_FROM(AllTypes.BigInt).AS("distinct1"), AllTypes.BigInt.IS_DISTINCT_FROM(Int(12)).AS("distinct2"), - AllTypes.BigInt.IS_NOT_DISTINCT_FROM(AllTypes.BigInt).AS("not distinct1"), AllTypes.BigInt.IS_NOT_DISTINCT_FROM(Int(12)).AS("not distinct2"), AllTypes.BigInt.LT(AllTypes.BigIntPtr).AS("lt1"), AllTypes.BigInt.LT(Int(65)).AS("lt2"), - AllTypes.BigInt.LT_EQ(AllTypes.BigIntPtr).AS("lte1"), AllTypes.BigInt.LT_EQ(Int(65)).AS("lte2"), - AllTypes.BigInt.GT(AllTypes.BigIntPtr).AS("gt1"), AllTypes.BigInt.GT(Int(65)).AS("gt2"), - AllTypes.BigInt.GT_EQ(AllTypes.BigIntPtr).AS("gte1"), AllTypes.BigInt.GT_EQ(Int(65)).AS("gte2"), + AllTypes.Integer.BETWEEN(Int(11), Int(200)).AS("between"), + AllTypes.Integer.NOT_BETWEEN(Int(66), Int(77)).AS("not_between"), AllTypes.BigInt.ADD(AllTypes.BigInt).AS("add1"), AllTypes.BigInt.ADD(Int(11)).AS("add2"), - AllTypes.BigInt.SUB(AllTypes.BigInt).AS("sub1"), AllTypes.BigInt.SUB(Int(11)).AS("sub2"), - AllTypes.BigInt.MUL(AllTypes.BigInt).AS("mul1"), AllTypes.BigInt.MUL(Int(11)).AS("mul2"), - AllTypes.BigInt.DIV(AllTypes.BigInt).AS("div1"), AllTypes.BigInt.DIV(Int(11)).AS("div2"), - AllTypes.BigInt.MOD(AllTypes.BigInt).AS("mod1"), AllTypes.BigInt.MOD(Int(11)).AS("mod2"), @@ -483,19 +480,15 @@ func TestIntegerOperators(t *testing.T) { AllTypes.SmallInt.BIT_AND(AllTypes.SmallInt).AS("bit_and1"), AllTypes.SmallInt.BIT_AND(AllTypes.SmallInt).AS("bit_and2"), - AllTypes.SmallInt.BIT_OR(AllTypes.SmallInt).AS("bit or 1"), AllTypes.SmallInt.BIT_OR(Int(22)).AS("bit or 2"), - AllTypes.SmallInt.BIT_XOR(AllTypes.SmallInt).AS("bit xor 1"), AllTypes.SmallInt.BIT_XOR(Int(11)).AS("bit xor 2"), - BIT_NOT(Int(-1).MUL(AllTypes.SmallInt)).AS("bit_not_1"), BIT_NOT(Int(-1).MUL(Int(11))).AS("bit_not_2"), AllTypes.SmallInt.BIT_SHIFT_LEFT(AllTypes.SmallInt.DIV(Int(2))).AS("bit shift left 1"), AllTypes.SmallInt.BIT_SHIFT_LEFT(Int(4)).AS("bit shift left 2"), - AllTypes.SmallInt.BIT_SHIFT_RIGHT(AllTypes.SmallInt.DIV(Int(5))).AS("bit shift right 1"), AllTypes.SmallInt.BIT_SHIFT_RIGHT(Int(1)).AS("bit shift right 2"), @@ -522,7 +515,8 @@ func TestIntegerOperators(t *testing.T) { require.Equal(t, *dest[0].BitXor2, int64(5)) require.Equal(t, *dest[0].BitShiftLeft1, int64(1792)) require.Equal(t, *dest[0].BitShiftRight2, int64(7)) - + require.Equal(t, *dest[0].Between, false) + require.Equal(t, *dest[0].NotBetween, true) } func TestStringOperators(t *testing.T) { @@ -540,6 +534,8 @@ func TestStringOperators(t *testing.T) { AllTypes.Text.LT(String("Text")), AllTypes.Text.LT_EQ(AllTypes.VarCharPtr), AllTypes.Text.LT_EQ(String("Text")), + AllTypes.Text.BETWEEN(String("min"), String("max")), + AllTypes.Text.NOT_BETWEEN(AllTypes.VarChar, AllTypes.CharPtr), AllTypes.Text.CONCAT(String("text2")), AllTypes.Text.CONCAT(Int(11)), AllTypes.Text.LIKE(String("abc")), @@ -717,27 +713,23 @@ func TestDateExpressions(t *testing.T) { AllTypes.Date.EQ(AllTypes.Date), AllTypes.Date.EQ(Date(2019, 6, 6)), - AllTypes.DatePtr.NOT_EQ(AllTypes.Date), AllTypes.DatePtr.NOT_EQ(Date(2019, 1, 6)), - AllTypes.Date.IS_DISTINCT_FROM(AllTypes.Date).AS("distinct1"), AllTypes.Date.IS_DISTINCT_FROM(Date(2008, 7, 4)).AS("distinct2"), - AllTypes.Date.IS_NOT_DISTINCT_FROM(AllTypes.Date), AllTypes.Date.IS_NOT_DISTINCT_FROM(Date(2019, 3, 6)), AllTypes.Date.LT(AllTypes.Date), AllTypes.Date.LT(Date(2019, 4, 6)), - AllTypes.Date.LT_EQ(AllTypes.Date), AllTypes.Date.LT_EQ(Date(2019, 5, 5)), - AllTypes.Date.GT(AllTypes.Date), AllTypes.Date.GT(Date(2019, 1, 4)), - AllTypes.Date.GT_EQ(AllTypes.Date), AllTypes.Date.GT_EQ(Date(2019, 2, 3)), + AllTypes.Date.BETWEEN(Date(2000, 2, 2), AllTypes.DatePtr), + AllTypes.Date.NOT_BETWEEN(AllTypes.DatePtr, Date(2000, 2, 2)), //AllTypes.Date.ADD(INTERVAL2(2, HOUR)), //AllTypes.Date.ADD(INTERVAL2(1, DAY, 7, MONTH)), @@ -790,12 +782,12 @@ func TestTimeExpressions(t *testing.T) { AllTypes.TimePtr.NOT_EQ(AllTypes.Time), AllTypes.TimePtr.NOT_EQ(Time(20, 16, 6)), - AllTypes.Time.IS_DISTINCT_FROM(AllTypes.Time), AllTypes.Time.IS_DISTINCT_FROM(Time(19, 26, 6)), - AllTypes.Time.IS_NOT_DISTINCT_FROM(AllTypes.Time), AllTypes.Time.IS_NOT_DISTINCT_FROM(Time(18, 36, 6)), + AllTypes.Time.BETWEEN(Time(11, 0, 30, 100), AllTypes.TimePtr), + AllTypes.Time.NOT_BETWEEN(AllTypes.TimePtr, TIME(time.Now())), AllTypes.Time.LT(AllTypes.Time), AllTypes.Time.LT(Time(17, 46, 6)), @@ -822,6 +814,8 @@ func TestTimeExpressions(t *testing.T) { CURRENT_TIME(), ) + //fmt.Println(query.DebugSql()) + var dest struct { Time1 string Time2 time.Time @@ -855,27 +849,23 @@ func TestDateTimeExpressions(t *testing.T) { AllTypes.DateTime.EQ(AllTypes.DateTime), AllTypes.DateTime.EQ(dateTime), - AllTypes.DateTimePtr.NOT_EQ(AllTypes.DateTime), AllTypes.DateTimePtr.NOT_EQ(DateTime(2019, 6, 6, 10, 2, 46, 100*time.Millisecond)), - AllTypes.DateTime.IS_DISTINCT_FROM(AllTypes.DateTime), AllTypes.DateTime.IS_DISTINCT_FROM(dateTime), - AllTypes.DateTime.IS_NOT_DISTINCT_FROM(AllTypes.DateTime), AllTypes.DateTime.IS_NOT_DISTINCT_FROM(dateTime), AllTypes.DateTime.LT(AllTypes.DateTime), AllTypes.DateTime.LT(dateTime), - AllTypes.DateTime.LT_EQ(AllTypes.DateTime), AllTypes.DateTime.LT_EQ(dateTime), - AllTypes.DateTime.GT(AllTypes.DateTime), AllTypes.DateTime.GT(dateTime), - AllTypes.DateTime.GT_EQ(AllTypes.DateTime), AllTypes.DateTime.GT_EQ(dateTime), + AllTypes.DateTime.BETWEEN(AllTypes.DateTimePtr, AllTypes.TimestampPtr), + AllTypes.DateTime.NOT_BETWEEN(AllTypes.DateTimePtr, AllTypes.TimestampPtr), //AllTypes.DateTime.ADD(INTERVAL("05:10:20.000100", HOUR_MICROSECOND)), //AllTypes.DateTime.ADD(INTERVALe(AllTypes.BigInt, HOUR)),