From fcce8d4262fbfe3569124c010c4d0fbf5ba1b8e8 Mon Sep 17 00:00:00 2001 From: go-jet Date: Wed, 31 Jul 2019 13:02:30 +0200 Subject: [PATCH] MySQL int expressions. --- dialects.go | 54 ++++++ expression.go | 5 +- float_expression.go | 2 +- float_expression_test.go | 7 +- func_expression.go | 4 + integer_expression.go | 20 ++- integer_expression_test.go | 40 ++++- internal/testutils/test_utils.go | 7 +- literal_expression.go | 5 +- mysql/mysql_types.go | 4 + operators.go | 12 ++ operators_test.go | 8 +- tests/init/data/mysql/test_sample.sql | 38 ++--- tests/init/data/postgres/test_sample.sql | 14 +- tests/mysql/alltypes_test.go | 199 ++++++++++++++++++---- tests/postgres/alltypes_test.go | 201 ++++++++++++++++------- tests/testdata/common/common.go | 84 ++++++++++ tests/testdata/common/float_operators.go | 40 ----- tests/testdata/common/int_operators.json | 78 +++++++++ 19 files changed, 654 insertions(+), 168 deletions(-) create mode 100644 tests/testdata/common/common.go delete mode 100644 tests/testdata/common/float_operators.go create mode 100644 tests/testdata/common/int_operators.json diff --git a/dialects.go b/dialects.go index 1a70ddc..6b82011 100644 --- a/dialects.go +++ b/dialects.go @@ -28,6 +28,9 @@ func newMySQLDialect() Dialect { mySQLDialect.SerializeOverrides["IS DISTINCT FROM"] = mysql_IS_DISTINCT_FROM mySQLDialect.SerializeOverrides["IS NOT DISTINCT FROM"] = mysql_IS_NOT_DISTINCT_FROM + mySQLDialect.SerializeOverrides["/"] = mysql_DIVISION + mySQLDialect.SerializeOverrides["#"] = mysql_BIT_XOR + mySQLDialect.AliasQuoteChar = '"' mySQLDialect.IdentifierQuoteChar = '"' mySQLDialect.ArgumentPlaceholder = func(int) string { @@ -63,6 +66,57 @@ func newDialect(name, packageName string) Dialect { return newDialect } +func mysql_BIT_XOR(expressions ...Expression) serializeFunc { + return func(statement statementType, out *sqlBuilder, options ...serializeOption) error { + if len(expressions) != 2 { + return errors.New("Invalid number of expressions for operator") + } + + lhs := expressions[0] + rhs := expressions[1] + + if err := lhs.serialize(statement, out, options...); err != nil { + return err + } + + out.writeString("^") + + if err := rhs.serialize(statement, out, options...); err != nil { + return err + } + return nil + } +} + +func mysql_DIVISION(expressions ...Expression) serializeFunc { + return func(statement statementType, out *sqlBuilder, options ...serializeOption) error { + if len(expressions) != 2 { + return errors.New("Invalid number of expressions for operator") + } + + lhs := expressions[0] + rhs := expressions[1] + + if err := lhs.serialize(statement, out, options...); err != nil { + return err + } + + _, isLhsInt := lhs.(IntegerExpression) + _, isRhsInt := rhs.(IntegerExpression) + + if isLhsInt && isRhsInt { + out.writeString("DIV") + } else { + out.writeString("/") + } + + if err := rhs.serialize(statement, out, options...); err != nil { + return err + } + return nil + } +} + func mysql_IS_NOT_DISTINCT_FROM(expressions ...Expression) serializeFunc { return func(statement statementType, out *sqlBuilder, options ...serializeOption) error { if len(expressions) != 2 { diff --git a/expression.go b/expression.go index 273e1b2..4e5b2e4 100644 --- a/expression.go +++ b/expression.go @@ -171,7 +171,8 @@ func (p *prefixOpExpression) serialize(statement statementType, out *sqlBuilder, return errors.New("jet: Prefix Expression is nil") } - out.writeString(p.operator + " ") + out.writeString("(") + out.writeString(p.operator) if p.expression == nil { return errors.New("jet: nil prefix Expression") @@ -180,6 +181,8 @@ func (p *prefixOpExpression) serialize(statement statementType, out *sqlBuilder, return err } + out.writeString(")") + return nil } diff --git a/float_expression.go b/float_expression.go index 08b9364..f61cdc0 100644 --- a/float_expression.go +++ b/float_expression.go @@ -81,7 +81,7 @@ func (n *floatInterfaceImpl) MOD(expression NumericExpression) FloatExpression { } func (n *floatInterfaceImpl) POW(expression NumericExpression) FloatExpression { - return POWER(n.parent, expression) + return POW(n.parent, expression) } //---------------------------------------------------// diff --git a/float_expression_test.go b/float_expression_test.go index 693dcf9..d6051da 100644 --- a/float_expression_test.go +++ b/float_expression_test.go @@ -62,6 +62,9 @@ func TestFloatExpressionMUL(t *testing.T) { func TestFloatExpressionDIV(t *testing.T) { assertPostgreClauseSerialize(t, table1ColFloat.DIV(table2ColFloat), "(table1.col_float / table2.col_float)") assertPostgreClauseSerialize(t, table1ColFloat.DIV(Float(2.11)), "(table1.col_float / $1)", float64(2.11)) + + assertMySQLClauseSerialize(t, table1ColFloat.DIV(table2ColFloat), "(table1.col_float / table2.col_float)") + assertMySQLClauseSerialize(t, table1ColFloat.DIV(Float(2.11)), "(table1.col_float / ?)", float64(2.11)) } func TestFloatExpressionMOD(t *testing.T) { @@ -70,8 +73,8 @@ func TestFloatExpressionMOD(t *testing.T) { } func TestFloatExpressionPOW(t *testing.T) { - assertPostgreClauseSerialize(t, table1ColFloat.POW(table2ColFloat), "POWER(table1.col_float, table2.col_float)") - assertPostgreClauseSerialize(t, table1ColFloat.POW(Float(2.11)), "POWER(table1.col_float, $1)", float64(2.11)) + assertPostgreClauseSerialize(t, table1ColFloat.POW(table2ColFloat), "POW(table1.col_float, table2.col_float)") + assertPostgreClauseSerialize(t, table1ColFloat.POW(Float(2.11)), "POW(table1.col_float, $1)", float64(2.11)) } func TestFloatExp(t *testing.T) { diff --git a/func_expression.go b/func_expression.go index 1e23055..3b3965d 100644 --- a/func_expression.go +++ b/func_expression.go @@ -19,6 +19,10 @@ func ABSi(integerExpression IntegerExpression) IntegerExpression { return newIntegerFunc("ABS", integerExpression) } +func POW(base, exponent NumericExpression) FloatExpression { + return NewFloatFunc("POW", base, exponent) +} + func POWER(base, exponent NumericExpression) FloatExpression { return NewFloatFunc("POWER", base, exponent) } diff --git a/integer_expression.go b/integer_expression.go index 6d90645..7018ece 100644 --- a/integer_expression.go +++ b/integer_expression.go @@ -106,7 +106,7 @@ func (i *integerInterfaceImpl) MOD(expression IntegerExpression) IntegerExpressi } func (i *integerInterfaceImpl) POW(expression IntegerExpression) IntegerExpression { - return newBinaryIntegerExpression(i.parent, expression, "^") + return IntExp(POW(i.parent, expression)) } func (i *integerInterfaceImpl) BIT_AND(expression IntegerExpression) IntegerExpression { @@ -166,6 +166,24 @@ func newPrefixIntegerOperator(expression IntegerExpression, operator string) Int return &integerExpression } +//---------------------------------------------------// +type prefixFloatOpExpression struct { + expressionInterfaceImpl + floatInterfaceImpl + + prefixOpExpression +} + +func newPrefixFloatOperator(expression FloatExpression, operator string) FloatExpression { + floatOpExpression := prefixFloatOpExpression{} + floatOpExpression.prefixOpExpression = newPrefixExpression(expression, operator) + + floatOpExpression.expressionInterfaceImpl.parent = &floatOpExpression + floatOpExpression.floatInterfaceImpl.parent = &floatOpExpression + + return &floatOpExpression +} + //---------------------------------------------------// type integerExpressionWrapper struct { integerInterfaceImpl diff --git a/integer_expression_test.go b/integer_expression_test.go index eb9dc72..341a094 100644 --- a/integer_expression_test.go +++ b/integer_expression_test.go @@ -52,6 +52,9 @@ func TestIntegerExpressionMUL(t *testing.T) { func TestIntegerExpressionDIV(t *testing.T) { assertPostgreClauseSerialize(t, table1ColInt.DIV(table2ColInt), "(table1.col_int / table2.col_int)") assertPostgreClauseSerialize(t, table1ColInt.DIV(Int(11)), "(table1.col_int / $1)", int64(11)) + + assertMySQLClauseSerialize(t, table1ColInt.DIV(table2ColInt), "(table1.col_int DIV table2.col_int)") + assertMySQLClauseSerialize(t, table1ColInt.DIV(Int(11)), "(table1.col_int DIV ?)", int64(11)) } func TestIntExpressionMOD(t *testing.T) { @@ -60,13 +63,37 @@ func TestIntExpressionMOD(t *testing.T) { } func TestIntExpressionPOW(t *testing.T) { - assertPostgreClauseSerialize(t, table1ColInt.POW(table2ColInt), "(table1.col_int ^ table2.col_int)") - assertPostgreClauseSerialize(t, table1ColInt.POW(Int(11)), "(table1.col_int ^ $1)", int64(11)) + assertPostgreClauseSerialize(t, table1ColInt.POW(table2ColInt), "POW(table1.col_int, table2.col_int)") + assertPostgreClauseSerialize(t, table1ColInt.POW(Int(11)), "POW(table1.col_int, $1)", int64(11)) } func TestIntExpressionBIT_NOT(t *testing.T) { - assertPostgreClauseSerialize(t, BIT_NOT(table2ColInt), "~ table2.col_int") - assertPostgreClauseSerialize(t, BIT_NOT(Int(11)), "~ $1", int64(11)) + assertPostgreClauseSerialize(t, BIT_NOT(table2ColInt), "(~ table2.col_int)") + assertPostgreClauseSerialize(t, BIT_NOT(Int(11)), "(~ $1)", int64(11)) +} + +func TestIntExpressionBIT_AND(t *testing.T) { + assertPostgreClauseSerialize(t, table1ColInt.BIT_AND(table2ColInt), "(table1.col_int & table2.col_int)") + assertPostgreClauseSerialize(t, table1ColInt.BIT_AND(Int(11)), "(table1.col_int & $1)", int64(11)) + + assertMySQLClauseSerialize(t, table1ColInt.BIT_AND(table2ColInt), "(table1.col_int & table2.col_int)") + assertMySQLClauseSerialize(t, table1ColInt.BIT_AND(Int(11)), "(table1.col_int & ?)", int64(11)) +} + +func TestIntExpressionBIT_OR(t *testing.T) { + assertPostgreClauseSerialize(t, table1ColInt.BIT_OR(table2ColInt), "(table1.col_int | table2.col_int)") + assertPostgreClauseSerialize(t, table1ColInt.BIT_OR(Int(11)), "(table1.col_int | $1)", int64(11)) + + assertMySQLClauseSerialize(t, table1ColInt.BIT_OR(table2ColInt), "(table1.col_int | table2.col_int)") + assertMySQLClauseSerialize(t, table1ColInt.BIT_OR(Int(11)), "(table1.col_int | ?)", int64(11)) +} + +func TestIntExpressionBIT_XOR(t *testing.T) { + assertPostgreClauseSerialize(t, table1ColInt.BIT_XOR(table2ColInt), "(table1.col_int # table2.col_int)") + assertPostgreClauseSerialize(t, table1ColInt.BIT_XOR(Int(11)), "(table1.col_int # $1)", int64(11)) + + assertMySQLClauseSerialize(t, table1ColInt.BIT_XOR(table2ColInt), "(table1.col_int ^ table2.col_int)") + assertMySQLClauseSerialize(t, table1ColInt.BIT_XOR(Int(11)), "(table1.col_int ^ ?)", int64(11)) } func TestIntExpressionBIT_SHIFT_LEFT(t *testing.T) { @@ -84,3 +111,8 @@ func TestIntExpressionIntExp(t *testing.T) { assertPostgreClauseSerialize(t, IntExp(table1ColFloat.ADD(table2ColFloat)).ADD(Int(11)), "((table1.col_float + table2.col_float) + $1)", int64(11)) } + +func TestIntExpression_MINUSi(t *testing.T) { + assertPostgreClauseSerialize(t, MINUSi(table2ColInt), "(- table2.col_int)") + assertPostgreClauseSerialize(t, MINUSi(Int(3)), "(- $1)", int64(3)) +} diff --git a/internal/testutils/test_utils.go b/internal/testutils/test_utils.go index 7cb8e7a..afc84f8 100644 --- a/internal/testutils/test_utils.go +++ b/internal/testutils/test_utils.go @@ -46,8 +46,8 @@ func AssertJSONFile(t *testing.T, jsonFilePath string, data interface{}) { jsonData, err := json.MarshalIndent(data, "", "\t") assert.NilError(t, err) - assert.Assert(t, string(fileJSONData) == string(jsonData)) - //assert.DeepEqual(t, string(fileJSONData), string(jsonData)) + //assert.Assert(t, string(fileJSONData) == string(jsonData)) + assert.DeepEqual(t, string(fileJSONData), string(jsonData)) } func AssertStatementSql(t *testing.T, query jet.Statement, expectedQuery string, expectedArgs ...interface{}) { @@ -55,6 +55,9 @@ func AssertStatementSql(t *testing.T, query jet.Statement, expectedQuery string, assert.NilError(t, err) assert.Equal(t, queryStr, expectedQuery) + if len(expectedArgs) == 0 { + return + } assert.DeepEqual(t, args, expectedArgs) } diff --git a/literal_expression.go b/literal_expression.go index 3195767..1959018 100644 --- a/literal_expression.go +++ b/literal_expression.go @@ -41,10 +41,13 @@ type integerLiteralExpression struct { } // Int is constructor for integer expressions literals. -func Int(value int64) IntegerExpression { +func Int(value int64, constant ...bool) IntegerExpression { numLiteral := &integerLiteralExpression{} numLiteral.literalExpression = *literal(value) + if len(constant) > 0 && constant[0] == true { + numLiteral.constant = true + } numLiteral.literalExpression.parent = numLiteral numLiteral.integerInterfaceImpl.parent = numLiteral diff --git a/mysql/mysql_types.go b/mysql/mysql_types.go index 0d2f3fc..a91ba97 100644 --- a/mysql/mysql_types.go +++ b/mysql/mysql_types.go @@ -59,3 +59,7 @@ var TRUNC = TRUNCATE var TRUNCATE = func(floatExpression jet.FloatExpression, precision jet.IntegerExpression) jet.FloatExpression { return jet.NewFloatFunc("TRUNCATE", floatExpression, precision) } + +var MINUSi = jet.MINUSi +var MINUSf = jet.MINUSf +var BIT_NOT = jet.BIT_NOT diff --git a/operators.go b/operators.go index 7ac6247..4fe94b7 100644 --- a/operators.go +++ b/operators.go @@ -2,6 +2,18 @@ package jet import "errors" +// --------- Arithmetic operators -------------// + +// MINUSi changes the sign of the intExp. +func MINUSi(intExp IntegerExpression) IntegerExpression { + return newPrefixIntegerOperator(intExp, "-") +} + +// MINUSi changes the sign of the intExp. +func MINUSf(floatExp FloatExpression) FloatExpression { + return newPrefixFloatOperator(floatExp, "-") +} + //----------- Logical operators ---------------// // NOT returns negation of bool expression result diff --git a/operators_test.go b/operators_test.go index 957dda8..4272218 100644 --- a/operators_test.go +++ b/operators_test.go @@ -5,10 +5,10 @@ import "testing" func TestOperatorNOT(t *testing.T) { notExpression := NOT(Int(2).EQ(Int(1))) - assertPostgreClauseSerialize(t, NOT(table1ColBool), "NOT table1.col_bool") - assertPostgreClauseSerialize(t, notExpression, "NOT ($1 = $2)", int64(2), int64(1)) - assertProjectionSerialize(t, notExpression.AS("alias_not_expression"), `NOT ($1 = $2) AS "alias_not_expression"`, int64(2), int64(1)) - assertPostgreClauseSerialize(t, notExpression.AND(Int(4).EQ(Int(5))), `(NOT ($1 = $2) AND ($3 = $4))`, int64(2), int64(1), int64(4), int64(5)) + assertPostgreClauseSerialize(t, NOT(table1ColBool), "(NOT table1.col_bool)") + assertPostgreClauseSerialize(t, notExpression, "(NOT ($1 = $2))", int64(2), int64(1)) + assertProjectionSerialize(t, notExpression.AS("alias_not_expression"), `(NOT ($1 = $2)) AS "alias_not_expression"`, int64(2), int64(1)) + assertPostgreClauseSerialize(t, notExpression.AND(Int(4).EQ(Int(5))), `((NOT ($1 = $2)) AND ($3 = $4))`, int64(2), int64(1), int64(4), int64(5)) } func TestCase1(t *testing.T) { diff --git a/tests/init/data/mysql/test_sample.sql b/tests/init/data/mysql/test_sample.sql index 0823e86..1b24d3d 100644 --- a/tests/init/data/mysql/test_sample.sql +++ b/tests/init/data/mysql/test_sample.sql @@ -11,37 +11,37 @@ CREATE TABLE `all_types` ( `boolean` BOOLEAN NOT NULL, `boolean_ptr` BOOLEAN, - `tiny_int` TINYINT NOT NULL, - `utiny_int` TINYINT unsigned NOT NULL, + `tiny_int` TINYINT NOT NULL, + `u_tiny_int` TINYINT unsigned NOT NULL, - `small_int` SMALLINT NOT NULL, - `usmall_int` SMALLINT unsigned NOT NULL, + `small_int` SMALLINT NOT NULL, + `u_small_int` SMALLINT unsigned NOT NULL, - `medium_int` MEDIUMINT NOT NULL, - `umedium_int` MEDIUMINT unsigned NOT NULL, + `medium_int` MEDIUMINT NOT NULL, + `u_medium_int` MEDIUMINT unsigned NOT NULL, - `integer` INT NOT NULL, - `uinteger` INT unsigned NOT NULL, + `integer` INT NOT NULL, + `u_integer` INT unsigned NOT NULL, - `big_int` bigint(20) NOT NULL, - `ubig_int` bigint(20) unsigned NOT NULL, + `big_int` bigint(20) NOT NULL, + `u_big_int` bigint(20) unsigned NOT NULL, -- ptr `tiny_int_ptr` TINYINT, - `utiny_int_ptr` TINYINT unsigned, + `u_tiny_int_ptr` TINYINT unsigned, `small_int_ptr` SMALLINT, - `usmall_int_ptr` SMALLINT unsigned, + `u_small_int_ptr` SMALLINT unsigned, `medium_int_ptr` MEDIUMINT, - `umedium_int_ptr` MEDIUMINT unsigned, + `u_medium_int_ptr` MEDIUMINT unsigned, - `int_ptr` INT, - `uint_ptr` INT unsigned, + `integer_ptr` INT, + `u_integer_ptr` INT unsigned, `big_int_ptr` bigint(20), - `ubig_int_ptr` bigint(20) unsigned, + `u_big_int_ptr` bigint(20) unsigned, -- floats @@ -114,12 +114,12 @@ CREATE TABLE `all_types` ( INSERT INTO `all_types` VALUES (false, true, --3,3,-14,14,-150,150,-1600,1600,-17000,17000, --3,3,-14,14,-150,150,-1600,1600,-17000,17000, +-3,3,14,14,-150,150,-1600,1600,5000,50000, +-3,3,14,14,-150,150,-1600,1600,50000,50000, 1.11,1.11,2.22,2.22,3.33,3.33,4.44,4.44,5.55,5.55, _binary '\0',_binary '\0','2008-07-04','2008-07-04','2011-12-18 13:17:17','2011-12-18 13:17:17','2007-12-31 23:00:01','2007-12-31 23:00:01',2004,2004,'char','char','varchar','varchar',_binary 'binary\0\0\0\0\0\0\0\0\0\0\0\0\0\0',_binary 'binary\0\0\0\0\0\0\0\0\0\0\0\0\0\0',_binary 'varbinary',_binary 'varbinary',_binary 'blob',_binary 'blob','text','text','value1','value1','s1','s2','{\"key1\": \"value1\", \"key2\": \"value2\"}','{\"key1\": \"value1\", \"key2\": \"value2\"}'), (false, NULL, --3,3,-14,14,-150,150,-1600,1600,-17000,17000, +-3,3,14,14,-150,150,-1600,1600,5000,50000, NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, 1.11,NULL,2.22,NULL,3.33,NULL,4.44,NULL,5.55,NULL, _binary '\0',NULL,'2008-07-04',NULL,'2011-12-18 13:17:17',NULL,'2007-12-31 23:00:01',NULL,2004,NULL,'char',NULL,'varchar',NULL,_binary 'binary\0\0\0\0\0\0\0\0\0\0\0\0\0\0',NULL,_binary 'varbinary',NULL,_binary 'blob',NULL,'text',NULL,'value1',NULL,'s1',NULL,'{\"key1\": \"value1\", \"key2\": \"value2\"}',NULL); diff --git a/tests/init/data/postgres/test_sample.sql b/tests/init/data/postgres/test_sample.sql index ffc6734..5e5f55a 100644 --- a/tests/init/data/postgres/test_sample.sql +++ b/tests/init/data/postgres/test_sample.sql @@ -8,12 +8,12 @@ DROP TABLE IF EXISTS test_sample.all_types; CREATE TABLE test_sample.ALL_TYPES ( -- numeric - smallint_ptr smallint, - smallint smallint NOT NULL, + small_int_ptr smallint, + small_int smallint NOT NULL, integer_ptr integer, integer integer NOT NULL, - bigint_ptr bigint, - bigint bigint NOT NULL, + big_int_ptr bigint, + big_int bigint NOT NULL, decimal_ptr decimal(10, 2), decimal decimal(10, 2) NOT NULL, numeric_ptr numeric(20, 3), @@ -97,7 +97,7 @@ CREATE TABLE test_sample.ALL_TYPES ); INSERT INTO test_sample.ALL_types( - smallint_ptr, "smallint", integer_ptr, "integer", bigint_ptr, "bigint", decimal_ptr, "decimal", numeric_ptr, "numeric", real_ptr, "real", double_precision_ptr, double_precision, smallserial, serial, bigserial, + small_int_ptr, "small_int", integer_ptr, "integer", big_int_ptr, "big_int", decimal_ptr, "decimal", numeric_ptr, "numeric", real_ptr, "real", double_precision_ptr, double_precision, smallserial, serial, bigserial, -- money_ptr, money, character_varying_ptr, character_varying, character_ptr, "character", text_ptr, text, bytea_ptr, bytea, @@ -110,7 +110,7 @@ INSERT INTO test_sample.ALL_types( xml_ptr, xml, json_ptr, json, jsonb_ptr, jsonb, integer_array_ptr, integer_array, text_array_ptr, text_array, jsonb_array, text_multi_dim_array_ptr, text_multi_dim_array) -VALUES (1, 1, 300, 300, 50000, 5000, 1.11, 1.11, 2.22, 2.22, 5.55, 5.55, 11111111.22, 11111111.22, DEFAULT, DEFAULT, DEFAULT, +VALUES (14, 14, 300, 300, 50000, 5000, 1.11, 1.11, 2.22, 2.22, 5.55, 5.55, 11111111.22, 11111111.22, DEFAULT, DEFAULT, DEFAULT, -- 100000, 100000, 'ABBA', 'ABBA', 'JOHN', 'JOHN', 'Some text', 'Some text', 'bytea', 'bytea', @@ -124,7 +124,7 @@ VALUES (1, 1, 300, 300, 50000, 5000, 1.11, 1.11, 2.22, 2.22, 5.55, 5.55, 1111111 '{"a": 1, "b": 3}', '{"a": 1, "b": 3}', '{"a": 1, "b": 3}', '{"a": 1, "b": 3}', '{1, 2, 3}', '{1, 2, 3}', '{"breakfast", "consulting"}', '{"breakfast", "consulting"}', ARRAY['{"a": 1, "b": 2}'::jsonb, '{"a":3, "b": 4}'::jsonb], '{{"meeting", "lunch"}, {"training", "presentation"}}', '{{"meeting", "lunch"}, {"training", "presentation"}}') , - (NULL, 1, NULL, 300, NULL, 5000, NULL, 1.11, NULL, 2.22, NULL, 5.55, NULL, 11111111.22, DEFAULT, DEFAULT, DEFAULT, + (NULL, 14, NULL, 300, NULL, 5000, NULL, 1.11, NULL, 2.22, NULL, 5.55, NULL, 11111111.22, DEFAULT, DEFAULT, DEFAULT, -- NULL, 100000, NULL, 'ABBA', NULL, 'JOHN', NULL, 'Some text', NULL, 'bytea', diff --git a/tests/mysql/alltypes_test.go b/tests/mysql/alltypes_test.go index 7104a0b..d877601 100644 --- a/tests/mysql/alltypes_test.go +++ b/tests/mysql/alltypes_test.go @@ -167,8 +167,8 @@ SELECT (all_types.numeric = all_types.numeric) AS "eq1", TRUNCATE((all_types.decimal / ?), ?) AS "div2", TRUNCATE((all_types.decimal % all_types.decimal_ptr), ?) AS "mod1", TRUNCATE((all_types.decimal % ?), ?) AS "mod2", - TRUNCATE(POWER(all_types.decimal, all_types.decimal_ptr), ?) AS "pow1", - TRUNCATE(POWER(all_types.decimal, ?), ?) AS "pow2", + TRUNCATE(POW(all_types.decimal, all_types.decimal_ptr), ?) AS "pow1", + TRUNCATE(POW(all_types.decimal, ?), ?) AS "pow2", TRUNCATE(ABS(all_types.decimal), ?) AS "abs", TRUNCATE(POWER(all_types.decimal, ?), ?) AS "power", TRUNCATE(SQRT(all_types.decimal), ?) AS "sqrt", @@ -194,31 +194,170 @@ LIMIT ?; testutils.AssertJSONFile(t, "./testdata/common/float_operators.json", dest) } +func TestIntegerOperators(t *testing.T) { + query := AllTypes.SELECT( + AllTypes.BigInt, + AllTypes.BigIntPtr, + AllTypes.SmallInt, + AllTypes.SmallIntPtr, + + 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.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(MINUSi(AllTypes.SmallInt)).AS("bit_not_1"), + BIT_NOT(MINUSi(Int(11, true))).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"), + + ABSi(AllTypes.BigInt).AS("abs"), + SQRT(ABSi(AllTypes.BigInt)).AS("sqrt"), + CBRT(ABSi(AllTypes.BigInt)).AS("cbrt"), + ).LIMIT(2) + + //fmt.Println(query.Sql()) + + testutils.AssertStatementSql(t, query, ` +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", + all_types.small_int_ptr AS "all_types.small_int_ptr", + (all_types.big_int = all_types.big_int) AS "eq1", + (all_types.big_int = ?) AS "eq2", + (all_types.big_int != all_types.big_int_ptr) AS "neq1", + (all_types.big_int != ?) AS "neq2", + (NOT all_types.big_int <=> all_types.big_int) AS "distinct1", + (NOT all_types.big_int <=> ?) AS "distinct2", + (all_types.big_int <=> all_types.big_int) AS "not distinct1", + (all_types.big_int <=> ?) AS "not distinct2", + (all_types.big_int < all_types.big_int_ptr) AS "lt1", + (all_types.big_int < ?) AS "lt2", + (all_types.big_int <= all_types.big_int_ptr) AS "lte1", + (all_types.big_int <= ?) AS "lte2", + (all_types.big_int > all_types.big_int_ptr) AS "gt1", + (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.big_int + all_types.big_int) AS "add1", + (all_types.big_int + ?) AS "add2", + (all_types.big_int - all_types.big_int) AS "sub1", + (all_types.big_int - ?) AS "sub2", + (all_types.big_int * all_types.big_int) AS "mul1", + (all_types.big_int * ?) AS "mul2", + (all_types.big_int DIV all_types.big_int) AS "div1", + (all_types.big_int DIV ?) AS "div2", + (all_types.big_int % all_types.big_int) AS "mod1", + (all_types.big_int % ?) AS "mod2", + POW(all_types.small_int, (all_types.small_int DIV ?)) AS "pow1", + POW(all_types.small_int, ?) 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 | ?) AS "bit or 2", + (all_types.small_int ^ all_types.small_int) AS "bit xor 1", + (all_types.small_int ^ ?) AS "bit xor 2", + (~ (- all_types.small_int)) AS "bit_not_1", + (~ (- 11)) AS "bit_not_2", + (all_types.small_int << (all_types.small_int DIV ?)) AS "bit shift left 1", + (all_types.small_int << ?) AS "bit shift left 2", + (all_types.small_int >> (all_types.small_int DIV ?)) AS "bit shift right 1", + (all_types.small_int >> ?) AS "bit shift right 2", + ABS(all_types.big_int) AS "abs", + SQRT(ABS(all_types.big_int)) AS "sqrt", + POWER(ABS(all_types.big_int), (? / ?)) AS "cbrt" +FROM test_sample.all_types +LIMIT ?; +`) + + var dest []struct { + common.AllTypesIntegerExpResult `alias:"."` + } + + err := query.Query(db, &dest) + + assert.NilError(t, err) + + //testutils.JsonPrint(dest) + + testutils.AssertJSONFile(t, "./testdata/common/int_operators.json", dest) +} + var allTypesJson = ` [ { "Boolean": false, "BooleanPtr": true, "TinyInt": -3, - "UtinyInt": 3, - "SmallInt": -14, - "UsmallInt": 14, + "UTinyInt": 3, + "SmallInt": 14, + "USmallInt": 14, "MediumInt": -150, - "UmediumInt": 150, + "UMediumInt": 150, "Integer": -1600, - "Uinteger": 1600, - "BigInt": -17000, - "UbigInt": 17000, + "UInteger": 1600, + "BigInt": 5000, + "UBigInt": 50000, "TinyIntPtr": -3, - "UtinyIntPtr": 3, - "SmallIntPtr": -14, - "UsmallIntPtr": 14, + "UTinyIntPtr": 3, + "SmallIntPtr": 14, + "USmallIntPtr": 14, "MediumIntPtr": -150, - "UmediumIntPtr": 150, - "IntPtr": -1600, - "UintPtr": 1600, - "BigIntPtr": -17000, - "UbigIntPtr": 17000, + "UMediumIntPtr": 150, + "IntegerPtr": -1600, + "UIntegerPtr": 1600, + "BigIntPtr": 50000, + "UBigIntPtr": 50000, "Decimal": 1.11, "DecimalPtr": 1.11, "Numeric": 2.22, @@ -262,25 +401,25 @@ var allTypesJson = ` "Boolean": false, "BooleanPtr": null, "TinyInt": -3, - "UtinyInt": 3, - "SmallInt": -14, - "UsmallInt": 14, + "UTinyInt": 3, + "SmallInt": 14, + "USmallInt": 14, "MediumInt": -150, - "UmediumInt": 150, + "UMediumInt": 150, "Integer": -1600, - "Uinteger": 1600, - "BigInt": -17000, - "UbigInt": 17000, + "UInteger": 1600, + "BigInt": 5000, + "UBigInt": 50000, "TinyIntPtr": null, - "UtinyIntPtr": null, + "UTinyIntPtr": null, "SmallIntPtr": null, - "UsmallIntPtr": null, + "USmallIntPtr": null, "MediumIntPtr": null, - "UmediumIntPtr": null, - "IntPtr": null, - "UintPtr": null, + "UMediumIntPtr": null, + "IntegerPtr": null, + "UIntegerPtr": null, "BigIntPtr": null, - "UbigIntPtr": null, + "UBigIntPtr": null, "Decimal": 1.11, "DecimalPtr": null, "Numeric": 2.22, diff --git a/tests/postgres/alltypes_test.go b/tests/postgres/alltypes_test.go index 7c32483..730b5eb 100644 --- a/tests/postgres/alltypes_test.go +++ b/tests/postgres/alltypes_test.go @@ -1,6 +1,7 @@ package postgres import ( + "fmt" . "github.com/go-jet/jet" "github.com/go-jet/jet/internal/testutils" "github.com/go-jet/jet/tests/.gentestdata/jetdb/test_sample/model" @@ -58,10 +59,10 @@ func TestExpressionOperators(t *testing.T) { query := AllTypes.SELECT( AllTypes.Integer.IS_NULL(), AllTypes.Timestamp.IS_NOT_NULL(), - AllTypes.SmallintPtr.IN(Int(11), Int(22), NULL), - AllTypes.SmallintPtr.IN(AllTypes.SELECT(AllTypes.IntegerPtr)), - AllTypes.SmallintPtr.NOT_IN(Int(11), Int(22), NULL), - AllTypes.SmallintPtr.NOT_IN(AllTypes.SELECT(AllTypes.IntegerPtr)), + AllTypes.SmallIntPtr.IN(Int(11), Int(22), NULL), + AllTypes.SmallIntPtr.IN(AllTypes.SELECT(AllTypes.IntegerPtr)), + AllTypes.SmallIntPtr.NOT_IN(Int(11), Int(22), NULL), + AllTypes.SmallIntPtr.NOT_IN(AllTypes.SELECT(AllTypes.IntegerPtr)), CAST(String("TRUE")).AS_BOOL(), CAST(String("111")).AS_SMALLINT(), @@ -87,7 +88,7 @@ func TestExpressionOperators(t *testing.T) { TO_NUMBER(String("12,454"), String("99G999D9S")), TO_TIMESTAMP(String("05 Dec 2000"), String("DD Mon YYYY")), - COALESCE(AllTypes.IntegerPtr, AllTypes.SmallintPtr, NULL, Int(11)), + COALESCE(AllTypes.IntegerPtr, AllTypes.SmallIntPtr, NULL, Int(11)), NULLIF(AllTypes.Text, String("(none)")), GREATEST(AllTypes.Numeric, AllTypes.NumericPtr), LEAST(AllTypes.Numeric, AllTypes.NumericPtr), @@ -313,8 +314,8 @@ SELECT (all_types.numeric = all_types.numeric) AS "eq1", TRUNC((all_types.decimal / $21), $22) AS "div2", TRUNC((all_types.decimal % all_types.decimal_ptr), $23) AS "mod1", TRUNC((all_types.decimal % $24), $25) AS "mod2", - TRUNC(POWER(all_types.decimal, all_types.decimal_ptr), $26) AS "pow1", - TRUNC(POWER(all_types.decimal, $27), $28) AS "pow2", + TRUNC(POW(all_types.decimal, all_types.decimal_ptr), $26) AS "pow1", + TRUNC(POW(all_types.decimal, $27), $28) AS "pow2", TRUNC(ABS(all_types.decimal), $29) AS "abs", TRUNC(POWER(all_types.decimal, $30), $31) AS "power", TRUNC(SQRT(all_types.decimal), $32) AS "sqrt", @@ -344,53 +345,141 @@ LIMIT $35; func TestIntegerOperators(t *testing.T) { query := AllTypes.SELECT( - AllTypes.Integer.EQ(AllTypes.IntegerPtr), - AllTypes.Bigint.EQ(Int(12)), - //AllTypes.Smallint.NOT_EQ(AllTypes.Real), - AllTypes.Integer.NOT_EQ(AllTypes.IntegerPtr), - AllTypes.Bigint.NOT_EQ(Int(12)), - AllTypes.Integer.LT(AllTypes.IntegerPtr), - AllTypes.Bigint.LT(Int(65)), - //AllTypes.Smallint.LT_EQ(AllTypes.Numeric), - AllTypes.Integer.LT_EQ(AllTypes.IntegerPtr), - AllTypes.Bigint.LT_EQ(Int(65)), - //AllTypes.Smallint.GT_EQ(AllTypes.Numeric), - AllTypes.Integer.GT(AllTypes.IntegerPtr), - AllTypes.Bigint.GT(Int(65)), - AllTypes.Integer.GT_EQ(AllTypes.IntegerPtr), - AllTypes.Bigint.GT_EQ(Int(65)), + AllTypes.BigInt, + AllTypes.BigIntPtr, + AllTypes.SmallInt, + AllTypes.SmallIntPtr, - AllTypes.Integer.ADD(AllTypes.Integer), - AllTypes.Integer.ADD(Int(11)), - AllTypes.Integer.SUB(AllTypes.Integer), - AllTypes.Integer.SUB(Int(11)), - AllTypes.Integer.MUL(AllTypes.Integer), - AllTypes.Integer.MUL(Int(11)), - AllTypes.Integer.DIV(AllTypes.Integer), - AllTypes.Integer.DIV(Int(11)), - AllTypes.Integer.MOD(AllTypes.Integer), - AllTypes.Integer.MOD(Int(11)), - AllTypes.Integer.POW(AllTypes.Smallint), - AllTypes.Integer.POW(Int(11)), - AllTypes.Integer.BIT_AND(AllTypes.Smallint), - AllTypes.Integer.BIT_OR(AllTypes.Smallint), - AllTypes.Integer.BIT_XOR(Int(11)), - BIT_NOT(AllTypes.Integer), - AllTypes.Integer.BIT_SHIFT_LEFT(AllTypes.Smallint), - AllTypes.Integer.BIT_SHIFT_LEFT(Int(11)), - AllTypes.Integer.BIT_SHIFT_RIGHT(AllTypes.Smallint), - AllTypes.Integer.BIT_SHIFT_RIGHT(Int(11)), + AllTypes.BigInt.EQ(AllTypes.BigInt).AS("eq1"), + AllTypes.BigInt.EQ(Int(12)).AS("eq2"), - ABSi(AllTypes.Integer), - SQRT(AllTypes.Integer), - CBRT(AllTypes.Integer), - ) + AllTypes.BigInt.NOT_EQ(AllTypes.BigIntPtr).AS("neq1"), + AllTypes.BigInt.NOT_EQ(Int(12)).AS("neq2"), - //fmt.Println(query.DebugSql()) + AllTypes.BigInt.IS_DISTINCT_FROM(AllTypes.BigInt).AS("distinct1"), + AllTypes.BigInt.IS_DISTINCT_FROM(Int(12)).AS("distinct2"), - err := query.Query(db, &struct{}{}) + 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.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(MINUSi(AllTypes.SmallInt)).AS("bit_not_1"), + BIT_NOT(MINUSi(Int(11, true))).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"), + + ABSi(AllTypes.BigInt).AS("abs"), + SQRT(ABSi(AllTypes.BigInt)).AS("sqrt"), + CBRT(ABSi(AllTypes.BigInt)).AS("cbrt"), + ).LIMIT(2) + + fmt.Println(query.Sql()) + + testutils.AssertStatementSql(t, query, ` +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", + all_types.small_int_ptr AS "all_types.small_int_ptr", + (all_types.big_int = all_types.big_int) AS "eq1", + (all_types.big_int = $1) AS "eq2", + (all_types.big_int != all_types.big_int_ptr) AS "neq1", + (all_types.big_int != $2) AS "neq2", + (all_types.big_int IS DISTINCT FROM all_types.big_int) AS "distinct1", + (all_types.big_int IS DISTINCT FROM $3) 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) AS "not distinct2", + (all_types.big_int < all_types.big_int_ptr) AS "lt1", + (all_types.big_int < $5) AS "lt2", + (all_types.big_int <= all_types.big_int_ptr) AS "lte1", + (all_types.big_int <= $6) AS "lte2", + (all_types.big_int > all_types.big_int_ptr) AS "gt1", + (all_types.big_int > $7) AS "gt2", + (all_types.big_int >= all_types.big_int_ptr) AS "gte1", + (all_types.big_int >= $8) AS "gte2", + (all_types.big_int + all_types.big_int) AS "add1", + (all_types.big_int + $9) AS "add2", + (all_types.big_int - all_types.big_int) AS "sub1", + (all_types.big_int - $10) AS "sub2", + (all_types.big_int * all_types.big_int) AS "mul1", + (all_types.big_int * $11) AS "mul2", + (all_types.big_int / all_types.big_int) AS "div1", + (all_types.big_int / $12) AS "div2", + (all_types.big_int % all_types.big_int) AS "mod1", + (all_types.big_int % $13) AS "mod2", + POW(all_types.small_int, (all_types.small_int / $14)) AS "pow1", + POW(all_types.small_int, $15) 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 # all_types.small_int) AS "bit xor 1", + (all_types.small_int # $17) AS "bit xor 2", + (~ (- all_types.small_int)) AS "bit_not_1", + (~ (- 11)) AS "bit_not_2", + (all_types.small_int << (all_types.small_int / $18)) AS "bit shift left 1", + (all_types.small_int << $19) AS "bit shift left 2", + (all_types.small_int >> (all_types.small_int / $20)) AS "bit shift right 1", + (all_types.small_int >> $21) 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 $22; +`) + + var dest []struct { + common.AllTypesIntegerExpResult `alias:"."` + } + + err := query.Query(db, &dest) assert.NilError(t, err) + + //testutils.JsonSave("./testdata/common/int_operators.json", dest) + //testutils.JsonPrint(dest) + testutils.AssertJSONFile(t, "./testdata/common/int_operators.json", dest) } func TestTimeOperators(t *testing.T) { @@ -634,12 +723,12 @@ FROM` } var allTypesRow0 = model.AllTypes{ - SmallintPtr: Int16Ptr(1), - Smallint: 1, + SmallIntPtr: Int16Ptr(14), + SmallInt: 14, IntegerPtr: Int32Ptr(300), Integer: 300, - BigintPtr: Int64Ptr(50000), - Bigint: 5000, + BigIntPtr: Int64Ptr(50000), + BigInt: 5000, DecimalPtr: Float64Ptr(1.11), Decimal: 1.11, NumericPtr: Float64Ptr(2.22), @@ -700,12 +789,12 @@ var allTypesRow0 = model.AllTypes{ } var allTypesRow1 = model.AllTypes{ - SmallintPtr: nil, - Smallint: 1, + SmallIntPtr: nil, + SmallInt: 14, IntegerPtr: nil, Integer: 300, - BigintPtr: nil, - Bigint: 5000, + BigIntPtr: nil, + BigInt: 5000, DecimalPtr: nil, Decimal: 1.11, NumericPtr: nil, diff --git a/tests/testdata/common/common.go b/tests/testdata/common/common.go new file mode 100644 index 0000000..55f6554 --- /dev/null +++ b/tests/testdata/common/common.go @@ -0,0 +1,84 @@ +package common + +type EqualityExpResult struct { + Eq1 *bool + Eq2 *bool + Distinct1 *bool + Distinct2 *bool + NotDistinct1 *bool + NotDistinct2 *bool + Lt1 *bool + Lt2 *bool + Lte1 *bool + Lte2 *bool + Gt1 *bool + Gt2 *bool + Gte1 *bool + Gte2 *bool +} + +type AllTypesIntegerExpResult struct { + EqualityExpResult `alias:"."` + + Add1 *int64 + Add2 *int64 + Sub1 *int64 + Sub2 *int64 + Mul1 *int64 + Mul2 *int64 + Div1 *int64 + Div2 *int64 + Mod1 *int64 + Mod2 *int64 + Pow1 *int64 + Pow2 *int64 + BitAnd1 *int64 + BitAnd2 *int64 + BitOr1 *int64 + BitOr2 *int64 + BitXor1 *int64 + BitXor2 *int64 + BitShiftLeft1 *int64 + BitShiftLeft2 *int64 + BitShiftRight1 *int64 + BitShiftRight2 *int64 +} + +type FloatExpressionTestResult struct { + Eq1 *bool + Eq2 *bool + Eq3 *bool + Distinct1 *bool + Distinct2 *bool + Distinct3 *bool + NotDistinct1 *bool + NotDistinct2 *bool + NotDistinct3 *bool + Lt1 *bool + Lt2 *bool + Gt1 *bool + Gt2 *bool + Add1 *float64 + Add2 *float64 + Sub1 *float64 + Sub2 *float64 + Mul1 *float64 + Mul2 *float64 + Div1 *float64 + Div2 *float64 + Mod1 *float64 + Mod2 *float64 + Pow1 *float64 + Pow2 *float64 + + Abs *float64 + Power *float64 + Sqrt *float64 + Cbrt *float64 + Ceil *float64 + Floor *float64 + Round1 *float64 + Round2 *float64 + Sign *float64 + Trunc *float64 +} diff --git a/tests/testdata/common/float_operators.go b/tests/testdata/common/float_operators.go deleted file mode 100644 index f9c1a0a..0000000 --- a/tests/testdata/common/float_operators.go +++ /dev/null @@ -1,40 +0,0 @@ -package common - -type FloatExpressionTestResult struct { - Eq1 *bool - Eq2 *bool - Eq3 *bool - Distinct1 *bool - Distinct2 *bool - Distinct3 *bool - NotDistinct1 *bool - NotDistinct2 *bool - NotDistinct3 *bool - Lt1 *bool - Lt2 *bool - Gt1 *bool - Gt2 *bool - Add1 *float64 - Add2 *float64 - Sub1 *float64 - Sub2 *float64 - Mul1 *float64 - Mul2 *float64 - Div1 *float64 - Div2 *float64 - Mod1 *float64 - Mod2 *float64 - Pow1 *float64 - Pow2 *float64 - - Abs *float64 - Power *float64 - Sqrt *float64 - Cbrt *float64 - Ceil *float64 - Floor *float64 - Round1 *float64 - Round2 *float64 - Sign *float64 - Trunc *float64 -} diff --git a/tests/testdata/common/int_operators.json b/tests/testdata/common/int_operators.json new file mode 100644 index 0000000..249efff --- /dev/null +++ b/tests/testdata/common/int_operators.json @@ -0,0 +1,78 @@ +[ + { + "Eq1": true, + "Eq2": false, + "Distinct1": false, + "Distinct2": true, + "NotDistinct1": true, + "NotDistinct2": false, + "Lt1": true, + "Lt2": false, + "Lte1": true, + "Lte2": false, + "Gt1": false, + "Gt2": true, + "Gte1": false, + "Gte2": true, + "Add1": 10000, + "Add2": 5011, + "Sub1": 0, + "Sub2": 4989, + "Mul1": 25000000, + "Mul2": 55000, + "Div1": 1, + "Div2": 454, + "Mod1": 0, + "Mod2": 6, + "Pow1": 38416, + "Pow2": 7529536, + "BitAnd1": 14, + "BitAnd2": 14, + "BitOr1": 14, + "BitOr2": 30, + "BitXor1": 0, + "BitXor2": 5, + "BitShiftLeft1": 1792, + "BitShiftLeft2": 224, + "BitShiftRight1": 3, + "BitShiftRight2": 7 + }, + { + "Eq1": true, + "Eq2": false, + "Distinct1": false, + "Distinct2": true, + "NotDistinct1": true, + "NotDistinct2": false, + "Lt1": null, + "Lt2": false, + "Lte1": null, + "Lte2": false, + "Gt1": null, + "Gt2": true, + "Gte1": null, + "Gte2": true, + "Add1": 10000, + "Add2": 5011, + "Sub1": 0, + "Sub2": 4989, + "Mul1": 25000000, + "Mul2": 55000, + "Div1": 1, + "Div2": 454, + "Mod1": 0, + "Mod2": 6, + "Pow1": 38416, + "Pow2": 7529536, + "BitAnd1": 14, + "BitAnd2": 14, + "BitOr1": 14, + "BitOr2": 30, + "BitXor1": 0, + "BitXor2": 5, + "BitShiftLeft1": 1792, + "BitShiftLeft2": 224, + "BitShiftRight1": 3, + "BitShiftRight2": 7 + } +] \ No newline at end of file