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

MySQL int expressions.

Browse source
This commit is contained in:
go-jet 2019-07-31 13:02:30 +02:00
parent 163ecf4c42
commit fcce8d4262
19 changed files with 654 additions and 168 deletions
Download patch file Download diff file Expand all files Collapse all files

38
tests/init/data/mysql/test_sample.sql
View file

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

14
tests/init/data/postgres/test_sample.sql
View file

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

199
tests/mysql/alltypes_test.go
View file

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

201
tests/postgres/alltypes_test.go
View file

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

84
tests/testdata/common/common.go vendored Normal file
View file

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

40
tests/testdata/common/float_operators.go vendored
View file

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

78
tests/testdata/common/int_operators.json vendored Normal file
View file

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