From d0533f73fb8164a1187af6319d899ccf0c0bb24c Mon Sep 17 00:00:00 2001 From: go-jet Date: Tue, 30 Jul 2019 11:18:12 +0200 Subject: [PATCH] MySQL bool expressions. --- bool_expression_test.go | 93 ++++++++++---- cast_test.go | 32 ++--- column_test.go | 4 +- column_types_test.go | 24 ++-- date_expression_test.go | 32 ++--- dialects.go | 27 +++- execution/execution.go | 43 +++++-- execution/internal/null_types.go | 30 ++++- expression.go | 7 +- expression_test.go | 24 ++-- float_expression_test.go | 62 ++++----- func_expression_test.go | 120 +++++++++--------- integer_expression_test.go | 64 +++++----- internal/testutils/test_utils.go | 9 +- literal_expression_test.go | 2 +- operators_test.go | 10 +- string_expression_test.go | 56 ++++---- table_test.go | 28 ++-- tests/all_types_test.go | 86 ++++++++++--- tests/chinook_db_test.go | 8 +- tests/delete_test.go | 4 +- tests/init/data/mysql/test_sample.sql | 7 +- tests/init/init.go | 1 + tests/insert_test.go | 14 +- tests/lock_test.go | 4 +- .../{mysql_test.go => mysql_main_test.go} | 8 +- tests/mysql/sakila_test.go | 8 +- tests/mysql/sample_test.go | 79 ++++++++++++ tests/sample_test.go | 8 +- tests/select_test.go | 52 ++++---- .../common_db_results/bool_operators.json | 38 ++++++ tests/update_test.go | 16 +-- time_expression_test.go | 36 +++--- timestamp_expression_test.go | 36 +++--- timestampz_expression_test.go | 36 +++--- timez_expression_test.go | 36 +++--- utils_test.go | 12 +- 37 files changed, 720 insertions(+), 436 deletions(-) rename tests/mysql/{mysql_test.go => mysql_main_test.go} (64%) create mode 100644 tests/testdata/common_db_results/bool_operators.json diff --git a/bool_expression_test.go b/bool_expression_test.go index 70ab9f8..3d3d3b5 100644 --- a/bool_expression_test.go +++ b/bool_expression_test.go @@ -6,74 +6,105 @@ import ( func TestBoolExpressionEQ(t *testing.T) { assertClauseSerializeErr(t, table1ColBool.EQ(nil), "jet: nil rhs") - assertClauseSerialize(t, table1ColBool.EQ(table2ColBool), "(table1.col_bool = table2.col_bool)") - assertClauseSerialize(t, table1ColBool.EQ(Bool(true)), "(table1.col_bool = $1)", true) + assertPostgreClauseSerialize(t, table1ColBool.EQ(table2ColBool), "(table1.col_bool = table2.col_bool)") + assertPostgreClauseSerialize(t, table1ColBool.EQ(Bool(true)), "(table1.col_bool = $1)", true) + + assertMySQLClauseSerialize(t, table1ColBool.EQ(table2ColBool), "(table1.col_bool = table2.col_bool)") + assertMySQLClauseSerialize(t, table1ColBool.EQ(Bool(true)), "(table1.col_bool = ?)", true) } func TestBoolExpressionNOT_EQ(t *testing.T) { - assertClauseSerialize(t, table1ColBool.NOT_EQ(table2ColBool), "(table1.col_bool != table2.col_bool)") - assertClauseSerialize(t, table1ColBool.NOT_EQ(Bool(true)), "(table1.col_bool != $1)", true) + assertPostgreClauseSerialize(t, table1ColBool.NOT_EQ(table2ColBool), "(table1.col_bool != table2.col_bool)") + assertPostgreClauseSerialize(t, table1ColBool.NOT_EQ(Bool(true)), "(table1.col_bool != $1)", true) + + assertMySQLClauseSerialize(t, table1ColBool.NOT_EQ(table2ColBool), "(table1.col_bool != table2.col_bool)") + assertMySQLClauseSerialize(t, table1ColBool.NOT_EQ(Bool(true)), "(table1.col_bool != ?)", true) } func TestBoolExpressionIS_DISTINCT_FROM(t *testing.T) { - assertClauseSerialize(t, table1ColBool.IS_DISTINCT_FROM(table2ColBool), "(table1.col_bool IS DISTINCT FROM table2.col_bool)") - assertClauseSerialize(t, table1ColBool.IS_DISTINCT_FROM(Bool(false)), "(table1.col_bool IS DISTINCT FROM $1)", false) + assertPostgreClauseSerialize(t, table1ColBool.IS_DISTINCT_FROM(table2ColBool), "(table1.col_bool IS DISTINCT FROM table2.col_bool)") + assertPostgreClauseSerialize(t, table1ColBool.IS_DISTINCT_FROM(Bool(false)), "(table1.col_bool IS DISTINCT FROM $1)", false) + + assertMySQLClauseSerialize(t, table1ColBool.IS_DISTINCT_FROM(table2ColBool), "(NOT table1.col_bool <=> table2.col_bool)") + assertMySQLClauseSerialize(t, table1ColBool.IS_DISTINCT_FROM(Bool(false)), "(NOT table1.col_bool <=> ?)", false) } func TestBoolExpressionIS_NOT_DISTINCT_FROM(t *testing.T) { - assertClauseSerialize(t, table1ColBool.IS_NOT_DISTINCT_FROM(table2ColBool), "(table1.col_bool IS NOT DISTINCT FROM table2.col_bool)") - assertClauseSerialize(t, table1ColBool.IS_NOT_DISTINCT_FROM(Bool(false)), "(table1.col_bool IS NOT DISTINCT FROM $1)", false) + assertPostgreClauseSerialize(t, table1ColBool.IS_NOT_DISTINCT_FROM(table2ColBool), "(table1.col_bool IS NOT DISTINCT FROM table2.col_bool)") + assertPostgreClauseSerialize(t, table1ColBool.IS_NOT_DISTINCT_FROM(Bool(false)), "(table1.col_bool IS NOT DISTINCT FROM $1)", false) + + assertMySQLClauseSerialize(t, table1ColBool.IS_NOT_DISTINCT_FROM(table2ColBool), "(table1.col_bool <=> table2.col_bool)") + assertMySQLClauseSerialize(t, table1ColBool.IS_NOT_DISTINCT_FROM(Bool(false)), "(table1.col_bool <=> ?)", false) + } func TestBoolExpressionIS_TRUE(t *testing.T) { - assertClauseSerialize(t, table1ColBool.IS_TRUE(), "table1.col_bool IS TRUE") - assertClauseSerialize(t, (Int(2).EQ(table1ColInt)).IS_TRUE(), + assertPostgreClauseSerialize(t, table1ColBool.IS_TRUE(), "table1.col_bool IS TRUE") + assertPostgreClauseSerialize(t, (Int(2).EQ(table1ColInt)).IS_TRUE(), `($1 = table1.col_int) IS TRUE`, int64(2)) - assertClauseSerialize(t, (Int(2).EQ(table1ColInt)).IS_TRUE().AND(Int(4).EQ(table2ColInt)), + assertPostgreClauseSerialize(t, (Int(2).EQ(table1ColInt)).IS_TRUE().AND(Int(4).EQ(table2ColInt)), `(($1 = table1.col_int) IS TRUE AND ($2 = table2.col_int))`, int64(2), int64(4)) + + assertMySQLClauseSerialize(t, table1ColBool.IS_TRUE(), "table1.col_bool IS TRUE") + assertMySQLClauseSerialize(t, (Int(2).EQ(table1ColInt)).IS_TRUE(), + `(? = table1.col_int) IS TRUE`, int64(2)) + assertMySQLClauseSerialize(t, (Int(2).EQ(table1ColInt)).IS_TRUE().AND(Int(4).EQ(table2ColInt)), + `((? = table1.col_int) IS TRUE AND (? = table2.col_int))`, int64(2), int64(4)) } func TestBoolExpressionIS_NOT_TRUE(t *testing.T) { - assertClauseSerialize(t, table1ColBool.IS_NOT_TRUE(), "table1.col_bool IS NOT TRUE") + assertPostgreClauseSerialize(t, table1ColBool.IS_NOT_TRUE(), "table1.col_bool IS NOT TRUE") + + assertMySQLClauseSerialize(t, table1ColBool.IS_NOT_TRUE(), "table1.col_bool IS NOT TRUE") } func TestBoolExpressionIS_FALSE(t *testing.T) { - assertClauseSerialize(t, table1ColBool.IS_FALSE(), "table1.col_bool IS FALSE") + assertPostgreClauseSerialize(t, table1ColBool.IS_FALSE(), "table1.col_bool IS FALSE") + + assertMySQLClauseSerialize(t, table1ColBool.IS_FALSE(), "table1.col_bool IS FALSE") } func TestBoolExpressionIS_NOT_FALSE(t *testing.T) { - assertClauseSerialize(t, table1ColBool.IS_NOT_FALSE(), "table1.col_bool IS NOT FALSE") + assertPostgreClauseSerialize(t, table1ColBool.IS_NOT_FALSE(), "table1.col_bool IS NOT FALSE") } func TestBoolExpressionIS_UNKNOWN(t *testing.T) { - assertClauseSerialize(t, table1ColBool.IS_UNKNOWN(), "table1.col_bool IS UNKNOWN") + assertPostgreClauseSerialize(t, table1ColBool.IS_UNKNOWN(), "table1.col_bool IS UNKNOWN") + + assertMySQLClauseSerialize(t, table1ColBool.IS_UNKNOWN(), "table1.col_bool IS UNKNOWN") } func TestBoolExpressionIS_NOT_UNKNOWN(t *testing.T) { - assertClauseSerialize(t, table1ColBool.IS_NOT_UNKNOWN(), "table1.col_bool IS NOT UNKNOWN") + assertPostgreClauseSerialize(t, table1ColBool.IS_NOT_UNKNOWN(), "table1.col_bool IS NOT UNKNOWN") + + assertMySQLClauseSerialize(t, table1ColBool.IS_NOT_UNKNOWN(), "table1.col_bool IS NOT UNKNOWN") } func TestBinaryBoolExpression(t *testing.T) { boolExpression := Int(2).EQ(Int(3)) - assertClauseSerialize(t, boolExpression, "($1 = $2)", int64(2), int64(3)) + assertPostgreClauseSerialize(t, boolExpression, "($1 = $2)", int64(2), int64(3)) + assertProjectionSerialize(t, boolExpression, "$1 = $2", int64(2), int64(3)) assertProjectionSerialize(t, boolExpression.AS("alias_eq_expression"), `($1 = $2) AS "alias_eq_expression"`, int64(2), int64(3)) - assertClauseSerialize(t, boolExpression.AND(Int(4).EQ(Int(5))), + assertPostgreClauseSerialize(t, boolExpression.AND(Int(4).EQ(Int(5))), "(($1 = $2) AND ($3 = $4))", int64(2), int64(3), int64(4), int64(5)) - assertClauseSerialize(t, boolExpression.OR(Int(4).EQ(Int(5))), + assertPostgreClauseSerialize(t, boolExpression.OR(Int(4).EQ(Int(5))), "(($1 = $2) OR ($3 = $4))", int64(2), int64(3), int64(4), int64(5)) } func TestBoolLiteral(t *testing.T) { - assertClauseSerialize(t, Bool(true), "$1", true) - assertClauseSerialize(t, Bool(false), "$1", false) + assertPostgreClauseSerialize(t, Bool(true), "$1", true) + assertPostgreClauseSerialize(t, Bool(false), "$1", false) + + assertMySQLClauseSerialize(t, Bool(true), "?", true) + assertMySQLClauseSerialize(t, Bool(false), "?", false) } func TestExists(t *testing.T) { - assertClauseSerialize(t, EXISTS( + assertPostgreClauseSerialize(t, EXISTS( table2. SELECT(Int(1)). WHERE(table1Col1.EQ(table2Col3)), @@ -83,9 +114,23 @@ func TestExists(t *testing.T) { FROM db.table2 WHERE table1.col1 = table2.col3 )`, int64(1)) + + assertMySQLClauseSerialize(t, EXISTS( + table2. + SELECT(Int(1)). + WHERE(table1Col1.EQ(table2Col3)), + ), + `EXISTS ( + SELECT ? + FROM db.table2 + WHERE table1.col1 = table2.col3 +)`, int64(1)) } func TestBoolExp(t *testing.T) { - assertClauseSerialize(t, BoolExp(String("true")), "$1", "true") - assertClauseSerialize(t, BoolExp(String("true")).IS_TRUE(), "$1 IS TRUE", "true") + assertPostgreClauseSerialize(t, BoolExp(String("true")), "$1", "true") + assertPostgreClauseSerialize(t, BoolExp(String("true")).IS_TRUE(), "$1 IS TRUE", "true") + + assertMySQLClauseSerialize(t, BoolExp(String("true")), "?", "true") + assertMySQLClauseSerialize(t, BoolExp(String("true")).IS_TRUE(), "? IS TRUE", "true") } diff --git a/cast_test.go b/cast_test.go index 20f5170..dfac7da 100644 --- a/cast_test.go +++ b/cast_test.go @@ -3,56 +3,56 @@ package jet import "testing" func TestExpressionCAST_AS_BOOL(t *testing.T) { - assertClauseSerialize(t, CAST(Int(1)).AS_BOOL(), "$1::boolean", int64(1)) - assertClauseSerialize(t, CAST(table2Col3).AS_BOOL(), "table2.col3::boolean") - assertClauseSerialize(t, CAST(table2Col3.ADD(table2Col3)).AS_BOOL(), "(table2.col3 + table2.col3)::boolean") + assertPostgreClauseSerialize(t, CAST(Int(1)).AS_BOOL(), "$1::boolean", int64(1)) + assertPostgreClauseSerialize(t, CAST(table2Col3).AS_BOOL(), "table2.col3::boolean") + assertPostgreClauseSerialize(t, CAST(table2Col3.ADD(table2Col3)).AS_BOOL(), "(table2.col3 + table2.col3)::boolean") } func TestExpressionCAST_AS_SMALLINT(t *testing.T) { - assertClauseSerialize(t, CAST(table2Col3).AS_SMALLINT(), "table2.col3::smallint") + assertPostgreClauseSerialize(t, CAST(table2Col3).AS_SMALLINT(), "table2.col3::smallint") } func TestExpressionCAST_AS_INTEGER(t *testing.T) { - assertClauseSerialize(t, CAST(table2Col3).AS_INTEGER(), "table2.col3::integer") + assertPostgreClauseSerialize(t, CAST(table2Col3).AS_INTEGER(), "table2.col3::integer") } func TestExpressionCAST_AS_BIGINT(t *testing.T) { - assertClauseSerialize(t, CAST(table2Col3).AS_BIGINT(), "table2.col3::bigint") + assertPostgreClauseSerialize(t, CAST(table2Col3).AS_BIGINT(), "table2.col3::bigint") } func TestExpressionCAST_AS_NUMERIC(t *testing.T) { - assertClauseSerialize(t, CAST(table2Col3).AS_NUMERIC(11, 11), "table2.col3::numeric(11, 11)") - assertClauseSerialize(t, CAST(table2Col3).AS_NUMERIC(11), "table2.col3::numeric(11)") + assertPostgreClauseSerialize(t, CAST(table2Col3).AS_NUMERIC(11, 11), "table2.col3::numeric(11, 11)") + assertPostgreClauseSerialize(t, CAST(table2Col3).AS_NUMERIC(11), "table2.col3::numeric(11)") } func TestExpressionCAST_AS_REAL(t *testing.T) { - assertClauseSerialize(t, CAST(table2Col3).AS_REAL(), "table2.col3::real") + assertPostgreClauseSerialize(t, CAST(table2Col3).AS_REAL(), "table2.col3::real") } func TestExpressionCAST_AS_DOUBLE(t *testing.T) { - assertClauseSerialize(t, CAST(table2Col3).AS_DOUBLE(), "table2.col3::double precision") + assertPostgreClauseSerialize(t, CAST(table2Col3).AS_DOUBLE(), "table2.col3::double precision") } func TestExpressionCAST_AS_TEXT(t *testing.T) { - assertClauseSerialize(t, CAST(table2Col3).AS_TEXT(), "table2.col3::text") + assertPostgreClauseSerialize(t, CAST(table2Col3).AS_TEXT(), "table2.col3::text") } func TestExpressionCAST_AS_DATE(t *testing.T) { - assertClauseSerialize(t, CAST(table2Col3).AS_DATE(), "table2.col3::date") + assertPostgreClauseSerialize(t, CAST(table2Col3).AS_DATE(), "table2.col3::date") } func TestExpressionCAST_AS_TIME(t *testing.T) { - assertClauseSerialize(t, CAST(table2Col3).AS_TIME(), "table2.col3::time without time zone") + assertPostgreClauseSerialize(t, CAST(table2Col3).AS_TIME(), "table2.col3::time without time zone") } func TestExpressionCAST_AS_TIMEZ(t *testing.T) { - assertClauseSerialize(t, CAST(table2Col3).AS_TIMEZ(), "table2.col3::time with time zone") + assertPostgreClauseSerialize(t, CAST(table2Col3).AS_TIMEZ(), "table2.col3::time with time zone") } func TestExpressionCAST_AS_TIMESTAMP(t *testing.T) { - assertClauseSerialize(t, CAST(table2Col3).AS_TIMESTAMP(), "table2.col3::timestamp without time zone") + assertPostgreClauseSerialize(t, CAST(table2Col3).AS_TIMESTAMP(), "table2.col3::timestamp without time zone") } func TestExpressionCAST_AS_TIMESTAMPZ(t *testing.T) { - assertClauseSerialize(t, CAST(table2Col3).AS_TIMESTAMPZ(), "table2.col3::timestamp with time zone") + assertPostgreClauseSerialize(t, CAST(table2Col3).AS_TIMESTAMPZ(), "table2.col3::timestamp with time zone") } diff --git a/column_test.go b/column_test.go index 376c4f0..807ab8e 100644 --- a/column_test.go +++ b/column_test.go @@ -6,9 +6,9 @@ func TestColumn(t *testing.T) { column := newColumn("col", "", nil) column.expressionInterfaceImpl.parent = &column - assertClauseSerialize(t, column, "col") + assertPostgreClauseSerialize(t, column, "col") column.setTableName("table1") - assertClauseSerialize(t, column, "table1.col") + assertPostgreClauseSerialize(t, column, "table1.col") assertProjectionSerialize(t, &column, `table1.col AS "table1.col"`) assertProjectionSerialize(t, column.AS("alias1"), `table1.col AS "alias1"`) } diff --git a/column_types_test.go b/column_types_test.go index df8c241..8acd889 100644 --- a/column_types_test.go +++ b/column_types_test.go @@ -8,38 +8,38 @@ var subQuery = table1.SELECT(table1ColFloat, table1ColInt).AsTable("sub_query") func TestNewBoolColumn(t *testing.T) { boolColumn := BoolColumn("colBool").From(subQuery) - assertClauseSerialize(t, boolColumn, `sub_query."colBool"`) - assertClauseSerialize(t, boolColumn.EQ(Bool(true)), `(sub_query."colBool" = $1)`, true) + assertPostgreClauseSerialize(t, boolColumn, `sub_query."colBool"`) + assertPostgreClauseSerialize(t, boolColumn.EQ(Bool(true)), `(sub_query."colBool" = $1)`, true) assertProjectionSerialize(t, boolColumn, `sub_query."colBool" AS "colBool"`) boolColumn2 := table1ColBool.From(subQuery) - assertClauseSerialize(t, boolColumn2, `sub_query."table1.col_bool"`) - assertClauseSerialize(t, boolColumn2.EQ(Bool(true)), `(sub_query."table1.col_bool" = $1)`, true) + assertPostgreClauseSerialize(t, boolColumn2, `sub_query."table1.col_bool"`) + assertPostgreClauseSerialize(t, boolColumn2.EQ(Bool(true)), `(sub_query."table1.col_bool" = $1)`, true) assertProjectionSerialize(t, boolColumn2, `sub_query."table1.col_bool" AS "table1.col_bool"`) } func TestNewIntColumn(t *testing.T) { intColumn := IntegerColumn("col_int").From(subQuery) - assertClauseSerialize(t, intColumn, `sub_query."col_int"`) - assertClauseSerialize(t, intColumn.EQ(Int(12)), `(sub_query."col_int" = $1)`, int64(12)) + assertPostgreClauseSerialize(t, intColumn, `sub_query."col_int"`) + assertPostgreClauseSerialize(t, intColumn.EQ(Int(12)), `(sub_query."col_int" = $1)`, int64(12)) assertProjectionSerialize(t, intColumn, `sub_query."col_int" AS "col_int"`) intColumn2 := table1ColInt.From(subQuery) - assertClauseSerialize(t, intColumn2, `sub_query."table1.col_int"`) - assertClauseSerialize(t, intColumn2.EQ(Int(14)), `(sub_query."table1.col_int" = $1)`, int64(14)) + assertPostgreClauseSerialize(t, intColumn2, `sub_query."table1.col_int"`) + assertPostgreClauseSerialize(t, intColumn2.EQ(Int(14)), `(sub_query."table1.col_int" = $1)`, int64(14)) assertProjectionSerialize(t, intColumn2, `sub_query."table1.col_int" AS "table1.col_int"`) } func TestNewFloatColumnColumn(t *testing.T) { floatColumn := FloatColumn("col_float").From(subQuery) - assertClauseSerialize(t, floatColumn, `sub_query."col_float"`) - assertClauseSerialize(t, floatColumn.EQ(Float(1.11)), `(sub_query."col_float" = $1)`, float64(1.11)) + assertPostgreClauseSerialize(t, floatColumn, `sub_query."col_float"`) + assertPostgreClauseSerialize(t, floatColumn.EQ(Float(1.11)), `(sub_query."col_float" = $1)`, float64(1.11)) assertProjectionSerialize(t, floatColumn, `sub_query."col_float" AS "col_float"`) floatColumn2 := table1ColFloat.From(subQuery) - assertClauseSerialize(t, floatColumn2, `sub_query."table1.col_float"`) - assertClauseSerialize(t, floatColumn2.EQ(Float(2.22)), `(sub_query."table1.col_float" = $1)`, float64(2.22)) + assertPostgreClauseSerialize(t, floatColumn2, `sub_query."table1.col_float"`) + assertPostgreClauseSerialize(t, floatColumn2.EQ(Float(2.22)), `(sub_query."table1.col_float" = $1)`, float64(2.22)) assertProjectionSerialize(t, floatColumn2, `sub_query."table1.col_float" AS "table1.col_float"`) } diff --git a/date_expression_test.go b/date_expression_test.go index 2565c67..af606b2 100644 --- a/date_expression_test.go +++ b/date_expression_test.go @@ -5,41 +5,41 @@ import "testing" var dateVar = Date(2000, 12, 30) func TestDateExpressionEQ(t *testing.T) { - assertClauseSerialize(t, table1ColDate.EQ(table2ColDate), "(table1.col_date = table2.col_date)") - assertClauseSerialize(t, table1ColDate.EQ(dateVar), "(table1.col_date = $1::date)", "2000-12-30") + assertPostgreClauseSerialize(t, table1ColDate.EQ(table2ColDate), "(table1.col_date = table2.col_date)") + assertPostgreClauseSerialize(t, table1ColDate.EQ(dateVar), "(table1.col_date = $1::date)", "2000-12-30") } func TestDateExpressionNOT_EQ(t *testing.T) { - assertClauseSerialize(t, table1ColDate.NOT_EQ(table2ColDate), "(table1.col_date != table2.col_date)") - assertClauseSerialize(t, table1ColDate.NOT_EQ(dateVar), "(table1.col_date != $1::date)", "2000-12-30") + assertPostgreClauseSerialize(t, table1ColDate.NOT_EQ(table2ColDate), "(table1.col_date != table2.col_date)") + assertPostgreClauseSerialize(t, table1ColDate.NOT_EQ(dateVar), "(table1.col_date != $1::date)", "2000-12-30") } func TestDateExpressionIS_DISTINCT_FROM(t *testing.T) { - assertClauseSerialize(t, table1ColDate.IS_DISTINCT_FROM(table2ColDate), "(table1.col_date IS DISTINCT FROM table2.col_date)") - assertClauseSerialize(t, table1ColDate.IS_DISTINCT_FROM(dateVar), "(table1.col_date IS DISTINCT FROM $1::date)", "2000-12-30") + assertPostgreClauseSerialize(t, table1ColDate.IS_DISTINCT_FROM(table2ColDate), "(table1.col_date IS DISTINCT FROM table2.col_date)") + assertPostgreClauseSerialize(t, table1ColDate.IS_DISTINCT_FROM(dateVar), "(table1.col_date IS DISTINCT FROM $1::date)", "2000-12-30") } func TestDateExpressionIS_NOT_DISTINCT_FROM(t *testing.T) { - assertClauseSerialize(t, table1ColDate.IS_NOT_DISTINCT_FROM(table2ColDate), "(table1.col_date IS NOT DISTINCT FROM table2.col_date)") - assertClauseSerialize(t, table1ColDate.IS_NOT_DISTINCT_FROM(dateVar), "(table1.col_date IS NOT DISTINCT FROM $1::date)", "2000-12-30") + assertPostgreClauseSerialize(t, table1ColDate.IS_NOT_DISTINCT_FROM(table2ColDate), "(table1.col_date IS NOT DISTINCT FROM table2.col_date)") + assertPostgreClauseSerialize(t, table1ColDate.IS_NOT_DISTINCT_FROM(dateVar), "(table1.col_date IS NOT DISTINCT FROM $1::date)", "2000-12-30") } func TestDateExpressionGT(t *testing.T) { - assertClauseSerialize(t, table1ColDate.GT(table2ColDate), "(table1.col_date > table2.col_date)") - assertClauseSerialize(t, table1ColDate.GT(dateVar), "(table1.col_date > $1::date)", "2000-12-30") + assertPostgreClauseSerialize(t, table1ColDate.GT(table2ColDate), "(table1.col_date > table2.col_date)") + assertPostgreClauseSerialize(t, table1ColDate.GT(dateVar), "(table1.col_date > $1::date)", "2000-12-30") } func TestDateExpressionGT_EQ(t *testing.T) { - assertClauseSerialize(t, table1ColDate.GT_EQ(table2ColDate), "(table1.col_date >= table2.col_date)") - assertClauseSerialize(t, table1ColDate.GT_EQ(dateVar), "(table1.col_date >= $1::date)", "2000-12-30") + assertPostgreClauseSerialize(t, table1ColDate.GT_EQ(table2ColDate), "(table1.col_date >= table2.col_date)") + assertPostgreClauseSerialize(t, table1ColDate.GT_EQ(dateVar), "(table1.col_date >= $1::date)", "2000-12-30") } func TestDateExpressionLT(t *testing.T) { - assertClauseSerialize(t, table1ColDate.LT(table2ColDate), "(table1.col_date < table2.col_date)") - assertClauseSerialize(t, table1ColDate.LT(dateVar), "(table1.col_date < $1::date)", "2000-12-30") + assertPostgreClauseSerialize(t, table1ColDate.LT(table2ColDate), "(table1.col_date < table2.col_date)") + assertPostgreClauseSerialize(t, table1ColDate.LT(dateVar), "(table1.col_date < $1::date)", "2000-12-30") } func TestDateExpressionLT_EQ(t *testing.T) { - assertClauseSerialize(t, table1ColDate.LT_EQ(table2ColDate), "(table1.col_date <= table2.col_date)") - assertClauseSerialize(t, table1ColDate.LT_EQ(dateVar), "(table1.col_date <= $1::date)", "2000-12-30") + assertPostgreClauseSerialize(t, table1ColDate.LT_EQ(table2ColDate), "(table1.col_date <= table2.col_date)") + assertPostgreClauseSerialize(t, table1ColDate.LT_EQ(dateVar), "(table1.col_date <= $1::date)", "2000-12-30") } diff --git a/dialects.go b/dialects.go index f571092..1a70ddc 100644 --- a/dialects.go +++ b/dialects.go @@ -13,7 +13,6 @@ var ( func newPostgresDialect() Dialect { postgresDialect := newDialect("PostgreSQL", "postgres") - postgresDialect.OperatorOverrides["IS DISTINCT FROM"] = postgresIS_DISTINCT_FROM postgresDialect.CastOverride = postgresCAST postgresDialect.AliasQuoteChar = '"' postgresDialect.IdentifierQuoteChar = '"' @@ -27,6 +26,8 @@ func newPostgresDialect() Dialect { func newMySQLDialect() Dialect { mySQLDialect := newDialect("MySQL", "mysql") + mySQLDialect.SerializeOverrides["IS DISTINCT FROM"] = mysql_IS_DISTINCT_FROM + mySQLDialect.SerializeOverrides["IS NOT DISTINCT FROM"] = mysql_IS_NOT_DISTINCT_FROM mySQLDialect.AliasQuoteChar = '"' mySQLDialect.IdentifierQuoteChar = '"' mySQLDialect.ArgumentPlaceholder = func(int) string { @@ -39,7 +40,7 @@ func newMySQLDialect() Dialect { type Dialect struct { Name string PackageName string - OperatorOverrides map[string]serializeOverride + SerializeOverrides map[string]serializeOverride CastOverride castOverride AliasQuoteChar byte IdentifierQuoteChar byte @@ -47,7 +48,7 @@ type Dialect struct { } func (d *Dialect) serializeOverride(operator string) serializeOverride { - return d.OperatorOverrides[operator] + return d.SerializeOverrides[operator] } type queryPlaceholderFunc func(ord int) string @@ -57,12 +58,12 @@ func newDialect(name, packageName string) Dialect { Name: name, PackageName: packageName, } - newDialect.OperatorOverrides = make(map[string]serializeOverride) + newDialect.SerializeOverrides = make(map[string]serializeOverride) return newDialect } -func postgresIS_DISTINCT_FROM(expressions ...Expression) serializeFunc { +func mysql_IS_NOT_DISTINCT_FROM(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") @@ -71,7 +72,7 @@ func postgresIS_DISTINCT_FROM(expressions ...Expression) serializeFunc { return err } - out.writeString("IS DISTINCT FROM") + out.writeString("<=>") if err := expressions[1].serialize(statement, out); err != nil { return err @@ -81,6 +82,20 @@ func postgresIS_DISTINCT_FROM(expressions ...Expression) serializeFunc { } } +func mysql_IS_DISTINCT_FROM(expressions ...Expression) serializeFunc { + return func(statement statementType, out *sqlBuilder, options ...serializeOption) error { + out.writeString("NOT") + + err := mysql_IS_NOT_DISTINCT_FROM(expressions...)(statement, out, options...) + + if err != nil { + return err + } + + return nil + } +} + func postgresCAST(expression Expression, castType string) serializeFunc { return func(statement statementType, out *sqlBuilder, options ...serializeOption) error { if err := expression.serialize(statement, out, options...); err != nil { diff --git a/execution/execution.go b/execution/execution.go index 0236444..b50eefd 100644 --- a/execution/execution.go +++ b/execution/execution.go @@ -8,7 +8,6 @@ import ( "fmt" "github.com/go-jet/jet/execution/internal" "github.com/go-jet/jet/internal/utils" - "github.com/go-sql-driver/mysql" "github.com/google/uuid" "reflect" "strconv" @@ -521,10 +520,31 @@ func isSimpleModelType(objType reflect.Type) bool { return false } +func isIntegerType(value reflect.Type) bool { + switch value { + case int8Type, unit8Type, int16Type, uint16Type, + int32Type, uint32Type, int64Type, uint64Type: + return true + } + + return false +} + func tryAssign(source, destination reflect.Value) bool { if source.Type().ConvertibleTo(destination.Type()) { source = source.Convert(destination.Type()) } + + if isIntegerType(source.Type()) && destination.Type() == boolType { + intValue := source.Int() + + if intValue == 1 { + source = reflect.ValueOf(true) + } else if intValue == 0 { + source = reflect.ValueOf(false) + } + } + if source.Type().AssignableTo(destination.Type()) { destination.Set(source) return true @@ -594,6 +614,7 @@ func createScanValue(columnTypes []*sql.ColumnType) []interface{} { return values } +var boolType = reflect.TypeOf(true) var int8Type = reflect.TypeOf(int8(1)) var unit8Type = reflect.TypeOf(uint8(1)) var int16Type = reflect.TypeOf(int16(1)) @@ -606,13 +627,17 @@ var float32Type = reflect.TypeOf(float32(1.1)) var float64Type = reflect.TypeOf(float64(1.1)) var nullInt8Type = reflect.TypeOf(internal.NullInt8{}) -var nullUInt8Type = reflect.TypeOf(internal.NullUInt8{}) + +//var nullUInt8Type = reflect.TypeOf(internal.NullUInt8{}) var nullInt16Type = reflect.TypeOf(internal.NullInt16{}) -var nullUInt16Type = reflect.TypeOf(internal.NullUInt16{}) + +//var nullUInt16Type = reflect.TypeOf(internal.NullUInt16{}) var nullInt32Type = reflect.TypeOf(internal.NullInt32{}) -var nullUInt32Type = reflect.TypeOf(internal.NullUInt32{}) + +//var nullUInt32Type = reflect.TypeOf(internal.NullUInt32{}) var nullInt64Type = reflect.TypeOf(sql.NullInt64{}) -var nullUInt64Type = reflect.TypeOf(internal.NullUInt64{}) + +//var nullUInt64Type = reflect.TypeOf(internal.NullUInt64{}) var nullFloat32Type = reflect.TypeOf(internal.NullFloat32{}) var nullFloat64Type = reflect.TypeOf(sql.NullFloat64{}) @@ -622,17 +647,11 @@ var nullStringType = reflect.TypeOf(sql.NullString{}) var nullBoolType = reflect.TypeOf(sql.NullBool{}) var nullTimeType = reflect.TypeOf(internal.NullTime{}) -var mySQLNullTime = reflect.TypeOf(mysql.NullTime{}) var nullByteArrayType = reflect.TypeOf(internal.NullByteArray{}) func newScanType(columnType *sql.ColumnType) reflect.Type { - switch columnType.ScanType() { - case mySQLNullTime: - return mySQLNullTime - } - switch columnType.DatabaseTypeName() { case "TINYINT": return nullInt8Type @@ -652,7 +671,7 @@ func newScanType(columnType *sql.ColumnType) reflect.Type { return nullBoolType case "BYTEA", "BINARY", "VARBINARY", "BLOB": return nullByteArrayType - case "DATE", "TIMESTAMP", "TIMESTAMPTZ", "TIME", "TIMETZ": + case "DATE", "DATETIME", "TIMESTAMP", "TIMESTAMPTZ", "TIME", "TIMETZ": return nullTimeType default: return nullStringType diff --git a/execution/internal/null_types.go b/execution/internal/null_types.go index 6a70689..77a2ca0 100644 --- a/execution/internal/null_types.go +++ b/execution/internal/null_types.go @@ -43,8 +43,20 @@ type NullTime struct { } // Scan implements the Scanner interface. -func (nt *NullTime) Scan(value interface{}) error { - nt.Time, nt.Valid = value.(time.Time) +func (nt *NullTime) Scan(value interface{}) (err error) { + switch v := value.(type) { + case time.Time: + nt.Time, nt.Valid = v, true + return + case []byte: + nt.Time, nt.Valid = parseTime(string(v)) + return + case string: + nt.Time, nt.Valid = parseTime(v) + return + } + + nt.Valid = false return nil } @@ -56,6 +68,20 @@ func (nt NullTime) Value() (driver.Value, error) { return nt.Time, nil } +const formatTime = "2006-01-02 15:04:05.999999" + +func parseTime(timeStr string) (t time.Time, valid bool) { + + switch len(timeStr) { + case 10, 19, 21, 22, 23, 24, 25, 26: + format := formatTime[:len(timeStr)] + t, err := time.Parse(format, timeStr) + return t, err == nil + } + + return t, false +} + //===============================================================// // NullInt8 struct diff --git a/expression.go b/expression.go index d35b2e3..273e1b2 100644 --- a/expression.go +++ b/expression.go @@ -123,8 +123,11 @@ func (c *binaryOpExpression) serialize(statement statementType, out *sqlBuilder, out.writeString("(") } - if dialectOveride := out.dialect.serializeOverride(c.operator); dialectOveride != nil { - err = dialectOveride(c.lhs, c.rhs)(statement, out, options...) + if serializeOverride := out.dialect.serializeOverride(c.operator); serializeOverride != nil { + + serializeOverrideFunc := serializeOverride(c.lhs, c.rhs) + err = serializeOverrideFunc(statement, out, options...) + } else { if err := c.lhs.serialize(statement, out); err != nil { return err diff --git a/expression_test.go b/expression_test.go index da0e033..1bf002d 100644 --- a/expression_test.go +++ b/expression_test.go @@ -5,35 +5,35 @@ import ( ) func TestExpressionIS_NULL(t *testing.T) { - assertClauseSerialize(t, table2Col3.IS_NULL(), "table2.col3 IS NULL") - assertClauseSerialize(t, table2Col3.ADD(table2Col3).IS_NULL(), "(table2.col3 + table2.col3) IS NULL") + assertPostgreClauseSerialize(t, table2Col3.IS_NULL(), "table2.col3 IS NULL") + assertPostgreClauseSerialize(t, table2Col3.ADD(table2Col3).IS_NULL(), "(table2.col3 + table2.col3) IS NULL") assertClauseSerializeErr(t, table2Col3.ADD(nil), "jet: nil rhs") } func TestExpressionIS_NOT_NULL(t *testing.T) { - assertClauseSerialize(t, table2Col3.IS_NOT_NULL(), "table2.col3 IS NOT NULL") - assertClauseSerialize(t, table2Col3.ADD(table2Col3).IS_NOT_NULL(), "(table2.col3 + table2.col3) IS NOT NULL") + assertPostgreClauseSerialize(t, table2Col3.IS_NOT_NULL(), "table2.col3 IS NOT NULL") + assertPostgreClauseSerialize(t, table2Col3.ADD(table2Col3).IS_NOT_NULL(), "(table2.col3 + table2.col3) IS NOT NULL") } func TestExpressionIS_DISTINCT_FROM(t *testing.T) { - assertClauseSerialize(t, table2Col3.IS_DISTINCT_FROM(table2Col4), "(table2.col3 IS DISTINCT FROM table2.col4)") - assertClauseSerialize(t, table2Col3.ADD(table2Col3).IS_DISTINCT_FROM(Int(23)), "((table2.col3 + table2.col3) IS DISTINCT FROM $1)", int64(23)) + assertPostgreClauseSerialize(t, table2Col3.IS_DISTINCT_FROM(table2Col4), "(table2.col3 IS DISTINCT FROM table2.col4)") + assertPostgreClauseSerialize(t, table2Col3.ADD(table2Col3).IS_DISTINCT_FROM(Int(23)), "((table2.col3 + table2.col3) IS DISTINCT FROM $1)", int64(23)) } func TestExpressionIS_NOT_DISTINCT_FROM(t *testing.T) { - assertClauseSerialize(t, table2Col3.IS_NOT_DISTINCT_FROM(table2Col4), "(table2.col3 IS NOT DISTINCT FROM table2.col4)") - assertClauseSerialize(t, table2Col3.ADD(table2Col3).IS_NOT_DISTINCT_FROM(Int(23)), "((table2.col3 + table2.col3) IS NOT DISTINCT FROM $1)", int64(23)) + assertPostgreClauseSerialize(t, table2Col3.IS_NOT_DISTINCT_FROM(table2Col4), "(table2.col3 IS NOT DISTINCT FROM table2.col4)") + assertPostgreClauseSerialize(t, table2Col3.ADD(table2Col3).IS_NOT_DISTINCT_FROM(Int(23)), "((table2.col3 + table2.col3) IS NOT DISTINCT FROM $1)", int64(23)) } func TestIN(t *testing.T) { - assertClauseSerialize(t, Float(1.11).IN(table1.SELECT(table1Col1)), + assertPostgreClauseSerialize(t, Float(1.11).IN(table1.SELECT(table1Col1)), `($1 IN (( SELECT table1.col1 AS "table1.col1" FROM db.table1 )))`, float64(1.11)) - assertClauseSerialize(t, ROW(Int(12), table1Col1).IN(table2.SELECT(table2Col3, table3Col1)), + assertPostgreClauseSerialize(t, ROW(Int(12), table1Col1).IN(table2.SELECT(table2Col3, table3Col1)), `(ROW($1, table1.col1) IN (( SELECT table2.col3 AS "table2.col3", table3.col1 AS "table3.col1" @@ -43,13 +43,13 @@ func TestIN(t *testing.T) { func TestNOT_IN(t *testing.T) { - assertClauseSerialize(t, Float(1.11).NOT_IN(table1.SELECT(table1Col1)), + assertPostgreClauseSerialize(t, Float(1.11).NOT_IN(table1.SELECT(table1Col1)), `($1 NOT IN (( SELECT table1.col1 AS "table1.col1" FROM db.table1 )))`, float64(1.11)) - assertClauseSerialize(t, ROW(Int(12), table1Col1).NOT_IN(table2.SELECT(table2Col3, table3Col1)), + assertPostgreClauseSerialize(t, ROW(Int(12), table1Col1).NOT_IN(table2.SELECT(table2Col3, table3Col1)), `(ROW($1, table1.col1) NOT IN (( SELECT table2.col3 AS "table2.col3", table3.col1 AS "table3.col1" diff --git a/float_expression_test.go b/float_expression_test.go index e9103e9..58dfc34 100644 --- a/float_expression_test.go +++ b/float_expression_test.go @@ -5,78 +5,78 @@ import ( ) func TestFloatExpressionEQ(t *testing.T) { - assertClauseSerialize(t, table1ColFloat.EQ(table2ColFloat), "(table1.col_float = table2.col_float)") - assertClauseSerialize(t, table1ColFloat.EQ(Float(2.11)), "(table1.col_float = $1)", float64(2.11)) + assertPostgreClauseSerialize(t, table1ColFloat.EQ(table2ColFloat), "(table1.col_float = table2.col_float)") + assertPostgreClauseSerialize(t, table1ColFloat.EQ(Float(2.11)), "(table1.col_float = $1)", float64(2.11)) } func TestFloatExpressionNOT_EQ(t *testing.T) { - assertClauseSerialize(t, table1ColFloat.NOT_EQ(table2ColFloat), "(table1.col_float != table2.col_float)") - assertClauseSerialize(t, table1ColFloat.NOT_EQ(Float(2.11)), "(table1.col_float != $1)", float64(2.11)) + assertPostgreClauseSerialize(t, table1ColFloat.NOT_EQ(table2ColFloat), "(table1.col_float != table2.col_float)") + assertPostgreClauseSerialize(t, table1ColFloat.NOT_EQ(Float(2.11)), "(table1.col_float != $1)", float64(2.11)) } func TestFloatExpressionIS_DISTINCT_FROM(t *testing.T) { - assertClauseSerialize(t, table1ColFloat.IS_DISTINCT_FROM(table2ColFloat), "(table1.col_float IS DISTINCT FROM table2.col_float)") - assertClauseSerialize(t, table1ColFloat.IS_DISTINCT_FROM(Float(2.11)), "(table1.col_float IS DISTINCT FROM $1)", float64(2.11)) + assertPostgreClauseSerialize(t, table1ColFloat.IS_DISTINCT_FROM(table2ColFloat), "(table1.col_float IS DISTINCT FROM table2.col_float)") + assertPostgreClauseSerialize(t, table1ColFloat.IS_DISTINCT_FROM(Float(2.11)), "(table1.col_float IS DISTINCT FROM $1)", float64(2.11)) } func TestFloatExpressionIS_NOT_DISTINCT_FROM(t *testing.T) { - assertClauseSerialize(t, table1ColFloat.IS_NOT_DISTINCT_FROM(table2ColFloat), "(table1.col_float IS NOT DISTINCT FROM table2.col_float)") - assertClauseSerialize(t, table1ColFloat.IS_NOT_DISTINCT_FROM(Float(2.11)), "(table1.col_float IS NOT DISTINCT FROM $1)", float64(2.11)) + assertPostgreClauseSerialize(t, table1ColFloat.IS_NOT_DISTINCT_FROM(table2ColFloat), "(table1.col_float IS NOT DISTINCT FROM table2.col_float)") + assertPostgreClauseSerialize(t, table1ColFloat.IS_NOT_DISTINCT_FROM(Float(2.11)), "(table1.col_float IS NOT DISTINCT FROM $1)", float64(2.11)) } func TestFloatExpressionGT(t *testing.T) { - assertClauseSerialize(t, table1ColFloat.GT(table2ColFloat), "(table1.col_float > table2.col_float)") - assertClauseSerialize(t, table1ColFloat.GT(Float(2.11)), "(table1.col_float > $1)", float64(2.11)) + assertPostgreClauseSerialize(t, table1ColFloat.GT(table2ColFloat), "(table1.col_float > table2.col_float)") + assertPostgreClauseSerialize(t, table1ColFloat.GT(Float(2.11)), "(table1.col_float > $1)", float64(2.11)) } func TestFloatExpressionGT_EQ(t *testing.T) { - assertClauseSerialize(t, table1ColFloat.GT_EQ(table2ColFloat), "(table1.col_float >= table2.col_float)") - assertClauseSerialize(t, table1ColFloat.GT_EQ(Float(2.11)), "(table1.col_float >= $1)", float64(2.11)) + assertPostgreClauseSerialize(t, table1ColFloat.GT_EQ(table2ColFloat), "(table1.col_float >= table2.col_float)") + assertPostgreClauseSerialize(t, table1ColFloat.GT_EQ(Float(2.11)), "(table1.col_float >= $1)", float64(2.11)) } func TestFloatExpressionLT(t *testing.T) { - assertClauseSerialize(t, table1ColFloat.LT(table2ColFloat), "(table1.col_float < table2.col_float)") - assertClauseSerialize(t, table1ColFloat.LT(Float(2.11)), "(table1.col_float < $1)", float64(2.11)) + assertPostgreClauseSerialize(t, table1ColFloat.LT(table2ColFloat), "(table1.col_float < table2.col_float)") + assertPostgreClauseSerialize(t, table1ColFloat.LT(Float(2.11)), "(table1.col_float < $1)", float64(2.11)) } func TestFloatExpressionLT_EQ(t *testing.T) { - assertClauseSerialize(t, table1ColFloat.LT_EQ(table2ColFloat), "(table1.col_float <= table2.col_float)") - assertClauseSerialize(t, table1ColFloat.LT_EQ(Float(2.11)), "(table1.col_float <= $1)", float64(2.11)) + assertPostgreClauseSerialize(t, table1ColFloat.LT_EQ(table2ColFloat), "(table1.col_float <= table2.col_float)") + assertPostgreClauseSerialize(t, table1ColFloat.LT_EQ(Float(2.11)), "(table1.col_float <= $1)", float64(2.11)) } func TestFloatExpressionADD(t *testing.T) { - assertClauseSerialize(t, table1ColFloat.ADD(table2ColFloat), "(table1.col_float + table2.col_float)") - assertClauseSerialize(t, table1ColFloat.ADD(Float(2.11)), "(table1.col_float + $1)", float64(2.11)) + assertPostgreClauseSerialize(t, table1ColFloat.ADD(table2ColFloat), "(table1.col_float + table2.col_float)") + assertPostgreClauseSerialize(t, table1ColFloat.ADD(Float(2.11)), "(table1.col_float + $1)", float64(2.11)) } func TestFloatExpressionSUB(t *testing.T) { - assertClauseSerialize(t, table1ColFloat.SUB(table2ColFloat), "(table1.col_float - table2.col_float)") - assertClauseSerialize(t, table1ColFloat.SUB(Float(2.11)), "(table1.col_float - $1)", float64(2.11)) + assertPostgreClauseSerialize(t, table1ColFloat.SUB(table2ColFloat), "(table1.col_float - table2.col_float)") + assertPostgreClauseSerialize(t, table1ColFloat.SUB(Float(2.11)), "(table1.col_float - $1)", float64(2.11)) } func TestFloatExpressionMUL(t *testing.T) { - assertClauseSerialize(t, table1ColFloat.MUL(table2ColFloat), "(table1.col_float * table2.col_float)") - assertClauseSerialize(t, table1ColFloat.MUL(Float(2.11)), "(table1.col_float * $1)", float64(2.11)) + assertPostgreClauseSerialize(t, table1ColFloat.MUL(table2ColFloat), "(table1.col_float * table2.col_float)") + assertPostgreClauseSerialize(t, table1ColFloat.MUL(Float(2.11)), "(table1.col_float * $1)", float64(2.11)) } func TestFloatExpressionDIV(t *testing.T) { - assertClauseSerialize(t, table1ColFloat.DIV(table2ColFloat), "(table1.col_float / table2.col_float)") - assertClauseSerialize(t, table1ColFloat.DIV(Float(2.11)), "(table1.col_float / $1)", float64(2.11)) + 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)) } func TestFloatExpressionMOD(t *testing.T) { - assertClauseSerialize(t, table1ColFloat.MOD(table2ColFloat), "(table1.col_float % table2.col_float)") - assertClauseSerialize(t, table1ColFloat.MOD(Float(2.11)), "(table1.col_float % $1)", float64(2.11)) + assertPostgreClauseSerialize(t, table1ColFloat.MOD(table2ColFloat), "(table1.col_float % table2.col_float)") + assertPostgreClauseSerialize(t, table1ColFloat.MOD(Float(2.11)), "(table1.col_float % $1)", float64(2.11)) } func TestFloatExpressionPOW(t *testing.T) { - assertClauseSerialize(t, table1ColFloat.POW(table2ColFloat), "(table1.col_float ^ table2.col_float)") - assertClauseSerialize(t, table1ColFloat.POW(Float(2.11)), "(table1.col_float ^ $1)", float64(2.11)) + assertPostgreClauseSerialize(t, table1ColFloat.POW(table2ColFloat), "(table1.col_float ^ table2.col_float)") + assertPostgreClauseSerialize(t, table1ColFloat.POW(Float(2.11)), "(table1.col_float ^ $1)", float64(2.11)) } func TestFloatExp(t *testing.T) { - assertClauseSerialize(t, FloatExp(table1ColInt), "table1.col_int") - assertClauseSerialize(t, FloatExp(table1ColInt.ADD(table3ColInt)), "(table1.col_int + table3.col_int)") - assertClauseSerialize(t, FloatExp(table1ColInt.ADD(table3ColInt)).ADD(Float(11.11)), + assertPostgreClauseSerialize(t, FloatExp(table1ColInt), "table1.col_int") + assertPostgreClauseSerialize(t, FloatExp(table1ColInt.ADD(table3ColInt)), "(table1.col_int + table3.col_int)") + assertPostgreClauseSerialize(t, FloatExp(table1ColInt.ADD(table3ColInt)).ADD(Float(11.11)), "((table1.col_int + table3.col_int) + $1)", float64(11.11)) } diff --git a/func_expression_test.go b/func_expression_test.go index fa4a0a5..d2af26e 100644 --- a/func_expression_test.go +++ b/func_expression_test.go @@ -5,158 +5,158 @@ import ( ) func TestFuncAVG(t *testing.T) { - assertClauseSerialize(t, AVG(table1ColFloat), "AVG(table1.col_float)") - assertClauseSerialize(t, AVG(table1ColInt), "AVG(table1.col_int)") + assertPostgreClauseSerialize(t, AVG(table1ColFloat), "AVG(table1.col_float)") + assertPostgreClauseSerialize(t, AVG(table1ColInt), "AVG(table1.col_int)") } func TestFuncBIT_AND(t *testing.T) { - assertClauseSerialize(t, BIT_AND(table1ColInt), "BIT_AND(table1.col_int)") + assertPostgreClauseSerialize(t, BIT_AND(table1ColInt), "BIT_AND(table1.col_int)") } func TestFuncBIT_OR(t *testing.T) { - assertClauseSerialize(t, BIT_OR(table1ColInt), "BIT_OR(table1.col_int)") + assertPostgreClauseSerialize(t, BIT_OR(table1ColInt), "BIT_OR(table1.col_int)") } func TestFuncBOOL_AND(t *testing.T) { - assertClauseSerialize(t, BOOL_AND(table1ColBool), "BOOL_AND(table1.col_bool)") + assertPostgreClauseSerialize(t, BOOL_AND(table1ColBool), "BOOL_AND(table1.col_bool)") } func TestFuncBOOL_OR(t *testing.T) { - assertClauseSerialize(t, BOOL_OR(table1ColBool), "BOOL_OR(table1.col_bool)") + assertPostgreClauseSerialize(t, BOOL_OR(table1ColBool), "BOOL_OR(table1.col_bool)") } func TestFuncEVERY(t *testing.T) { - assertClauseSerialize(t, EVERY(table1ColBool), "EVERY(table1.col_bool)") + assertPostgreClauseSerialize(t, EVERY(table1ColBool), "EVERY(table1.col_bool)") } func TestFuncMIN(t *testing.T) { t.Run("float", func(t *testing.T) { - assertClauseSerialize(t, MINf(table1ColFloat), "MIN(table1.col_float)") + assertPostgreClauseSerialize(t, MINf(table1ColFloat), "MIN(table1.col_float)") }) t.Run("integer", func(t *testing.T) { - assertClauseSerialize(t, MINi(table1ColInt), "MIN(table1.col_int)") + assertPostgreClauseSerialize(t, MINi(table1ColInt), "MIN(table1.col_int)") }) } func TestFuncMAX(t *testing.T) { t.Run("float", func(t *testing.T) { - assertClauseSerialize(t, MAXf(table1ColFloat), "MAX(table1.col_float)") - assertClauseSerialize(t, MAXf(Float(11.2222)), "MAX($1)", float64(11.2222)) + assertPostgreClauseSerialize(t, MAXf(table1ColFloat), "MAX(table1.col_float)") + assertPostgreClauseSerialize(t, MAXf(Float(11.2222)), "MAX($1)", float64(11.2222)) }) t.Run("integer", func(t *testing.T) { - assertClauseSerialize(t, MAXi(table1ColInt), "MAX(table1.col_int)") - assertClauseSerialize(t, MAXi(Int(11)), "MAX($1)", int64(11)) + assertPostgreClauseSerialize(t, MAXi(table1ColInt), "MAX(table1.col_int)") + assertPostgreClauseSerialize(t, MAXi(Int(11)), "MAX($1)", int64(11)) }) } func TestFuncSUM(t *testing.T) { t.Run("float", func(t *testing.T) { - assertClauseSerialize(t, SUMf(table1ColFloat), "SUM(table1.col_float)") - assertClauseSerialize(t, SUMf(Float(11.2222)), "SUM($1)", float64(11.2222)) + assertPostgreClauseSerialize(t, SUMf(table1ColFloat), "SUM(table1.col_float)") + assertPostgreClauseSerialize(t, SUMf(Float(11.2222)), "SUM($1)", float64(11.2222)) }) t.Run("integer", func(t *testing.T) { - assertClauseSerialize(t, SUMi(table1ColInt), "SUM(table1.col_int)") - assertClauseSerialize(t, SUMi(Int(11)), "SUM($1)", int64(11)) + assertPostgreClauseSerialize(t, SUMi(table1ColInt), "SUM(table1.col_int)") + assertPostgreClauseSerialize(t, SUMi(Int(11)), "SUM($1)", int64(11)) }) } func TestFuncCOUNT(t *testing.T) { - assertClauseSerialize(t, COUNT(STAR), "COUNT(*)") - assertClauseSerialize(t, COUNT(table1ColFloat), "COUNT(table1.col_float)") - assertClauseSerialize(t, COUNT(Float(11.2222)), "COUNT($1)", float64(11.2222)) + assertPostgreClauseSerialize(t, COUNT(STAR), "COUNT(*)") + assertPostgreClauseSerialize(t, COUNT(table1ColFloat), "COUNT(table1.col_float)") + assertPostgreClauseSerialize(t, COUNT(Float(11.2222)), "COUNT($1)", float64(11.2222)) } func TestFuncABS(t *testing.T) { t.Run("float", func(t *testing.T) { - assertClauseSerialize(t, ABSf(table1ColFloat), "ABS(table1.col_float)") - assertClauseSerialize(t, ABSf(Float(11.2222)), "ABS($1)", float64(11.2222)) + assertPostgreClauseSerialize(t, ABSf(table1ColFloat), "ABS(table1.col_float)") + assertPostgreClauseSerialize(t, ABSf(Float(11.2222)), "ABS($1)", float64(11.2222)) }) t.Run("integer", func(t *testing.T) { - assertClauseSerialize(t, ABSi(table1ColInt), "ABS(table1.col_int)") - assertClauseSerialize(t, ABSi(Int(11)), "ABS($1)", int64(11)) + assertPostgreClauseSerialize(t, ABSi(table1ColInt), "ABS(table1.col_int)") + assertPostgreClauseSerialize(t, ABSi(Int(11)), "ABS($1)", int64(11)) }) } func TestFuncSQRT(t *testing.T) { - assertClauseSerialize(t, SQRT(table1ColFloat), "SQRT(table1.col_float)") - assertClauseSerialize(t, SQRT(Float(11.2222)), "SQRT($1)", float64(11.2222)) - assertClauseSerialize(t, SQRT(table1ColInt), "SQRT(table1.col_int)") - assertClauseSerialize(t, SQRT(Int(11)), "SQRT($1)", int64(11)) + assertPostgreClauseSerialize(t, SQRT(table1ColFloat), "SQRT(table1.col_float)") + assertPostgreClauseSerialize(t, SQRT(Float(11.2222)), "SQRT($1)", float64(11.2222)) + assertPostgreClauseSerialize(t, SQRT(table1ColInt), "SQRT(table1.col_int)") + assertPostgreClauseSerialize(t, SQRT(Int(11)), "SQRT($1)", int64(11)) } func TestFuncCBRT(t *testing.T) { - assertClauseSerialize(t, CBRT(table1ColFloat), "CBRT(table1.col_float)") - assertClauseSerialize(t, CBRT(Float(11.2222)), "CBRT($1)", float64(11.2222)) - assertClauseSerialize(t, CBRT(table1ColInt), "CBRT(table1.col_int)") - assertClauseSerialize(t, CBRT(Int(11)), "CBRT($1)", int64(11)) + assertPostgreClauseSerialize(t, CBRT(table1ColFloat), "CBRT(table1.col_float)") + assertPostgreClauseSerialize(t, CBRT(Float(11.2222)), "CBRT($1)", float64(11.2222)) + assertPostgreClauseSerialize(t, CBRT(table1ColInt), "CBRT(table1.col_int)") + assertPostgreClauseSerialize(t, CBRT(Int(11)), "CBRT($1)", int64(11)) } func TestFuncCEIL(t *testing.T) { - assertClauseSerialize(t, CEIL(table1ColFloat), "CEIL(table1.col_float)") - assertClauseSerialize(t, CEIL(Float(11.2222)), "CEIL($1)", float64(11.2222)) + assertPostgreClauseSerialize(t, CEIL(table1ColFloat), "CEIL(table1.col_float)") + assertPostgreClauseSerialize(t, CEIL(Float(11.2222)), "CEIL($1)", float64(11.2222)) } func TestFuncFLOOR(t *testing.T) { - assertClauseSerialize(t, FLOOR(table1ColFloat), "FLOOR(table1.col_float)") - assertClauseSerialize(t, FLOOR(Float(11.2222)), "FLOOR($1)", float64(11.2222)) + assertPostgreClauseSerialize(t, FLOOR(table1ColFloat), "FLOOR(table1.col_float)") + assertPostgreClauseSerialize(t, FLOOR(Float(11.2222)), "FLOOR($1)", float64(11.2222)) } func TestFuncROUND(t *testing.T) { - assertClauseSerialize(t, ROUND(table1ColFloat), "ROUND(table1.col_float)") - assertClauseSerialize(t, ROUND(Float(11.2222)), "ROUND($1)", float64(11.2222)) + assertPostgreClauseSerialize(t, ROUND(table1ColFloat), "ROUND(table1.col_float)") + assertPostgreClauseSerialize(t, ROUND(Float(11.2222)), "ROUND($1)", float64(11.2222)) - assertClauseSerialize(t, ROUND(table1ColFloat, Int(2)), "ROUND(table1.col_float, $1)", int64(2)) - assertClauseSerialize(t, ROUND(Float(11.2222), Int(1)), "ROUND($1, $2)", float64(11.2222), int64(1)) + assertPostgreClauseSerialize(t, ROUND(table1ColFloat, Int(2)), "ROUND(table1.col_float, $1)", int64(2)) + assertPostgreClauseSerialize(t, ROUND(Float(11.2222), Int(1)), "ROUND($1, $2)", float64(11.2222), int64(1)) } func TestFuncSIGN(t *testing.T) { - assertClauseSerialize(t, SIGN(table1ColFloat), "SIGN(table1.col_float)") - assertClauseSerialize(t, SIGN(Float(11.2222)), "SIGN($1)", float64(11.2222)) + assertPostgreClauseSerialize(t, SIGN(table1ColFloat), "SIGN(table1.col_float)") + assertPostgreClauseSerialize(t, SIGN(Float(11.2222)), "SIGN($1)", float64(11.2222)) } func TestFuncTRUNC(t *testing.T) { - assertClauseSerialize(t, TRUNC(table1ColFloat), "TRUNC(table1.col_float)") - assertClauseSerialize(t, TRUNC(Float(11.2222)), "TRUNC($1)", float64(11.2222)) + assertPostgreClauseSerialize(t, TRUNC(table1ColFloat), "TRUNC(table1.col_float)") + assertPostgreClauseSerialize(t, TRUNC(Float(11.2222)), "TRUNC($1)", float64(11.2222)) - assertClauseSerialize(t, TRUNC(table1ColFloat, Int(2)), "TRUNC(table1.col_float, $1)", int64(2)) - assertClauseSerialize(t, TRUNC(Float(11.2222), Int(1)), "TRUNC($1, $2)", float64(11.2222), int64(1)) + assertPostgreClauseSerialize(t, TRUNC(table1ColFloat, Int(2)), "TRUNC(table1.col_float, $1)", int64(2)) + assertPostgreClauseSerialize(t, TRUNC(Float(11.2222), Int(1)), "TRUNC($1, $2)", float64(11.2222), int64(1)) } func TestFuncLN(t *testing.T) { - assertClauseSerialize(t, LN(table1ColFloat), "LN(table1.col_float)") - assertClauseSerialize(t, LN(Float(11.2222)), "LN($1)", float64(11.2222)) + assertPostgreClauseSerialize(t, LN(table1ColFloat), "LN(table1.col_float)") + assertPostgreClauseSerialize(t, LN(Float(11.2222)), "LN($1)", float64(11.2222)) } func TestFuncLOG(t *testing.T) { - assertClauseSerialize(t, LOG(table1ColFloat), "LOG(table1.col_float)") - assertClauseSerialize(t, LOG(Float(11.2222)), "LOG($1)", float64(11.2222)) + assertPostgreClauseSerialize(t, LOG(table1ColFloat), "LOG(table1.col_float)") + assertPostgreClauseSerialize(t, LOG(Float(11.2222)), "LOG($1)", float64(11.2222)) } func TestFuncCOALESCE(t *testing.T) { - assertClauseSerialize(t, COALESCE(table1ColFloat), "COALESCE(table1.col_float)") - assertClauseSerialize(t, COALESCE(Float(11.2222), NULL, String("str")), "COALESCE($1, NULL, $2)", float64(11.2222), "str") + assertPostgreClauseSerialize(t, COALESCE(table1ColFloat), "COALESCE(table1.col_float)") + assertPostgreClauseSerialize(t, COALESCE(Float(11.2222), NULL, String("str")), "COALESCE($1, NULL, $2)", float64(11.2222), "str") } func TestFuncNULLIF(t *testing.T) { - assertClauseSerialize(t, NULLIF(table1ColFloat, table2ColInt), "NULLIF(table1.col_float, table2.col_int)") - assertClauseSerialize(t, NULLIF(Float(11.2222), NULL), "NULLIF($1, NULL)", float64(11.2222)) + assertPostgreClauseSerialize(t, NULLIF(table1ColFloat, table2ColInt), "NULLIF(table1.col_float, table2.col_int)") + assertPostgreClauseSerialize(t, NULLIF(Float(11.2222), NULL), "NULLIF($1, NULL)", float64(11.2222)) } func TestFuncGREATEST(t *testing.T) { - assertClauseSerialize(t, GREATEST(table1ColFloat), "GREATEST(table1.col_float)") - assertClauseSerialize(t, GREATEST(Float(11.2222), NULL, String("str")), "GREATEST($1, NULL, $2)", float64(11.2222), "str") + assertPostgreClauseSerialize(t, GREATEST(table1ColFloat), "GREATEST(table1.col_float)") + assertPostgreClauseSerialize(t, GREATEST(Float(11.2222), NULL, String("str")), "GREATEST($1, NULL, $2)", float64(11.2222), "str") } func TestFuncLEAST(t *testing.T) { - assertClauseSerialize(t, LEAST(table1ColFloat), "LEAST(table1.col_float)") - assertClauseSerialize(t, LEAST(Float(11.2222), NULL, String("str")), "LEAST($1, NULL, $2)", float64(11.2222), "str") + assertPostgreClauseSerialize(t, LEAST(table1ColFloat), "LEAST(table1.col_float)") + assertPostgreClauseSerialize(t, LEAST(Float(11.2222), NULL, String("str")), "LEAST($1, NULL, $2)", float64(11.2222), "str") } func TestTO_ASCII(t *testing.T) { - assertClauseSerialize(t, TO_ASCII(String("Karel")), `TO_ASCII($1)`, "Karel") - assertClauseSerialize(t, TO_ASCII(String("Karel")), `TO_ASCII($1)`, "Karel") + assertPostgreClauseSerialize(t, TO_ASCII(String("Karel")), `TO_ASCII($1)`, "Karel") + assertPostgreClauseSerialize(t, TO_ASCII(String("Karel")), `TO_ASCII($1)`, "Karel") } diff --git a/integer_expression_test.go b/integer_expression_test.go index 27e439a..eb9dc72 100644 --- a/integer_expression_test.go +++ b/integer_expression_test.go @@ -5,82 +5,82 @@ import ( ) func TestIntegerExpressionEQ(t *testing.T) { - assertClauseSerialize(t, table1ColInt.EQ(table2ColInt), "(table1.col_int = table2.col_int)") - assertClauseSerialize(t, table1ColInt.EQ(Int(11)), "(table1.col_int = $1)", int64(11)) + assertPostgreClauseSerialize(t, table1ColInt.EQ(table2ColInt), "(table1.col_int = table2.col_int)") + assertPostgreClauseSerialize(t, table1ColInt.EQ(Int(11)), "(table1.col_int = $1)", int64(11)) } func TestIntegerExpressionNOT_EQ(t *testing.T) { - assertClauseSerialize(t, table1ColInt.NOT_EQ(table2ColInt), "(table1.col_int != table2.col_int)") - assertClauseSerialize(t, table1ColInt.NOT_EQ(Int(11)), "(table1.col_int != $1)", int64(11)) + assertPostgreClauseSerialize(t, table1ColInt.NOT_EQ(table2ColInt), "(table1.col_int != table2.col_int)") + assertPostgreClauseSerialize(t, table1ColInt.NOT_EQ(Int(11)), "(table1.col_int != $1)", int64(11)) } func TestIntegerExpressionGT(t *testing.T) { - assertClauseSerialize(t, table1ColInt.GT(table2ColInt), "(table1.col_int > table2.col_int)") - assertClauseSerialize(t, table1ColInt.GT(Int(11)), "(table1.col_int > $1)", int64(11)) + assertPostgreClauseSerialize(t, table1ColInt.GT(table2ColInt), "(table1.col_int > table2.col_int)") + assertPostgreClauseSerialize(t, table1ColInt.GT(Int(11)), "(table1.col_int > $1)", int64(11)) } func TestIntegerExpressionGT_EQ(t *testing.T) { - assertClauseSerialize(t, table1ColInt.GT_EQ(table2ColInt), "(table1.col_int >= table2.col_int)") - assertClauseSerialize(t, table1ColInt.GT_EQ(Int(11)), "(table1.col_int >= $1)", int64(11)) + assertPostgreClauseSerialize(t, table1ColInt.GT_EQ(table2ColInt), "(table1.col_int >= table2.col_int)") + assertPostgreClauseSerialize(t, table1ColInt.GT_EQ(Int(11)), "(table1.col_int >= $1)", int64(11)) } func TestIntegerExpressionLT(t *testing.T) { - assertClauseSerialize(t, table1ColInt.LT(table2ColInt), "(table1.col_int < table2.col_int)") - assertClauseSerialize(t, table1ColInt.LT(Int(11)), "(table1.col_int < $1)", int64(11)) + assertPostgreClauseSerialize(t, table1ColInt.LT(table2ColInt), "(table1.col_int < table2.col_int)") + assertPostgreClauseSerialize(t, table1ColInt.LT(Int(11)), "(table1.col_int < $1)", int64(11)) } func TestIntegerExpressionLT_EQ(t *testing.T) { - assertClauseSerialize(t, table1ColInt.LT_EQ(table2ColInt), "(table1.col_int <= table2.col_int)") - assertClauseSerialize(t, table1ColInt.LT_EQ(Int(11)), "(table1.col_int <= $1)", int64(11)) + assertPostgreClauseSerialize(t, table1ColInt.LT_EQ(table2ColInt), "(table1.col_int <= table2.col_int)") + assertPostgreClauseSerialize(t, table1ColInt.LT_EQ(Int(11)), "(table1.col_int <= $1)", int64(11)) } func TestIntegerExpressionADD(t *testing.T) { - assertClauseSerialize(t, table1ColInt.ADD(table2ColInt), "(table1.col_int + table2.col_int)") - assertClauseSerialize(t, table1ColInt.ADD(Int(11)), "(table1.col_int + $1)", int64(11)) + assertPostgreClauseSerialize(t, table1ColInt.ADD(table2ColInt), "(table1.col_int + table2.col_int)") + assertPostgreClauseSerialize(t, table1ColInt.ADD(Int(11)), "(table1.col_int + $1)", int64(11)) } func TestIntegerExpressionSUB(t *testing.T) { - assertClauseSerialize(t, table1ColInt.SUB(table2ColInt), "(table1.col_int - table2.col_int)") - assertClauseSerialize(t, table1ColInt.SUB(Int(11)), "(table1.col_int - $1)", int64(11)) + assertPostgreClauseSerialize(t, table1ColInt.SUB(table2ColInt), "(table1.col_int - table2.col_int)") + assertPostgreClauseSerialize(t, table1ColInt.SUB(Int(11)), "(table1.col_int - $1)", int64(11)) } func TestIntegerExpressionMUL(t *testing.T) { - assertClauseSerialize(t, table1ColInt.MUL(table2ColInt), "(table1.col_int * table2.col_int)") - assertClauseSerialize(t, table1ColInt.MUL(Int(11)), "(table1.col_int * $1)", int64(11)) + assertPostgreClauseSerialize(t, table1ColInt.MUL(table2ColInt), "(table1.col_int * table2.col_int)") + assertPostgreClauseSerialize(t, table1ColInt.MUL(Int(11)), "(table1.col_int * $1)", int64(11)) } func TestIntegerExpressionDIV(t *testing.T) { - assertClauseSerialize(t, table1ColInt.DIV(table2ColInt), "(table1.col_int / table2.col_int)") - assertClauseSerialize(t, table1ColInt.DIV(Int(11)), "(table1.col_int / $1)", int64(11)) + assertPostgreClauseSerialize(t, table1ColInt.DIV(table2ColInt), "(table1.col_int / table2.col_int)") + assertPostgreClauseSerialize(t, table1ColInt.DIV(Int(11)), "(table1.col_int / $1)", int64(11)) } func TestIntExpressionMOD(t *testing.T) { - assertClauseSerialize(t, table1ColInt.MOD(table2ColInt), "(table1.col_int % table2.col_int)") - assertClauseSerialize(t, table1ColInt.MOD(Int(11)), "(table1.col_int % $1)", int64(11)) + assertPostgreClauseSerialize(t, table1ColInt.MOD(table2ColInt), "(table1.col_int % table2.col_int)") + assertPostgreClauseSerialize(t, table1ColInt.MOD(Int(11)), "(table1.col_int % $1)", int64(11)) } func TestIntExpressionPOW(t *testing.T) { - assertClauseSerialize(t, table1ColInt.POW(table2ColInt), "(table1.col_int ^ table2.col_int)") - assertClauseSerialize(t, table1ColInt.POW(Int(11)), "(table1.col_int ^ $1)", int64(11)) + assertPostgreClauseSerialize(t, table1ColInt.POW(table2ColInt), "(table1.col_int ^ table2.col_int)") + assertPostgreClauseSerialize(t, table1ColInt.POW(Int(11)), "(table1.col_int ^ $1)", int64(11)) } func TestIntExpressionBIT_NOT(t *testing.T) { - assertClauseSerialize(t, BIT_NOT(table2ColInt), "~ table2.col_int") - assertClauseSerialize(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_SHIFT_LEFT(t *testing.T) { - assertClauseSerialize(t, table1ColInt.BIT_SHIFT_LEFT(table2ColInt), "(table1.col_int << table2.col_int)") - assertClauseSerialize(t, table1ColInt.BIT_SHIFT_LEFT(Int(11)), "(table1.col_int << $1)", int64(11)) + assertPostgreClauseSerialize(t, table1ColInt.BIT_SHIFT_LEFT(table2ColInt), "(table1.col_int << table2.col_int)") + assertPostgreClauseSerialize(t, table1ColInt.BIT_SHIFT_LEFT(Int(11)), "(table1.col_int << $1)", int64(11)) } func TestIntExpressionBIT_SHIFT_RIGHT(t *testing.T) { - assertClauseSerialize(t, table1ColInt.BIT_SHIFT_RIGHT(table2ColInt), "(table1.col_int >> table2.col_int)") - assertClauseSerialize(t, table1ColInt.BIT_SHIFT_RIGHT(Int(11)), "(table1.col_int >> $1)", int64(11)) + assertPostgreClauseSerialize(t, table1ColInt.BIT_SHIFT_RIGHT(table2ColInt), "(table1.col_int >> table2.col_int)") + assertPostgreClauseSerialize(t, table1ColInt.BIT_SHIFT_RIGHT(Int(11)), "(table1.col_int >> $1)", int64(11)) } func TestIntExpressionIntExp(t *testing.T) { - assertClauseSerialize(t, IntExp(table1ColFloat), "table1.col_float") - assertClauseSerialize(t, IntExp(table1ColFloat.ADD(table2ColFloat)).ADD(Int(11)), + assertPostgreClauseSerialize(t, IntExp(table1ColFloat), "table1.col_float") + assertPostgreClauseSerialize(t, IntExp(table1ColFloat.ADD(table2ColFloat)).ADD(Int(11)), "((table1.col_float + table2.col_float) + $1)", int64(11)) } diff --git a/internal/testutils/test_utils.go b/internal/testutils/test_utils.go index 30a688c..c3b6374 100644 --- a/internal/testutils/test_utils.go +++ b/internal/testutils/test_utils.go @@ -47,10 +47,17 @@ func AssertJSONFile(t *testing.T, jsonFilePath string, data interface{}) { assert.NilError(t, err) assert.Assert(t, string(fileJSONData) == string(jsonData)) - //assert.Equal(t, string(fileJSONData), string(jsonData)) + //assert.DeepEqual(t, string(fileJSONData), string(jsonData)) } func AssertStatementSql(t *testing.T, query jet.Statement, expectedQuery string, expectedArgs ...interface{}) { + queryStr, args, err := query.Sql() + assert.NilError(t, err) + assert.Equal(t, queryStr, expectedQuery) + assert.DeepEqual(t, args, expectedArgs) +} + +func AssertDebugStatementSql(t *testing.T, query jet.Statement, expectedQuery string, expectedArgs ...interface{}) { _, args, err := query.Sql() assert.NilError(t, err) //assert.Equal(t, queryStr, expectedQuery) diff --git a/literal_expression_test.go b/literal_expression_test.go index 4752ce2..466f6b9 100644 --- a/literal_expression_test.go +++ b/literal_expression_test.go @@ -3,5 +3,5 @@ package jet import "testing" func TestRawExpression(t *testing.T) { - assertClauseSerialize(t, RAW("current_database()"), "current_database()") + assertPostgreClauseSerialize(t, RAW("current_database()"), "current_database()") } diff --git a/operators_test.go b/operators_test.go index 84fc65b..957dda8 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))) - assertClauseSerialize(t, NOT(table1ColBool), "NOT table1.col_bool") - assertClauseSerialize(t, notExpression, "NOT ($1 = $2)", int64(2), int64(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)) - assertClauseSerialize(t, notExpression.AND(Int(4).EQ(Int(5))), `(NOT ($1 = $2) AND ($3 = $4))`, int64(2), int64(1), int64(4), int64(5)) + 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) { @@ -16,7 +16,7 @@ func TestCase1(t *testing.T) { WHEN(table3Col1.EQ(Int(1))).THEN(table3Col1.ADD(Int(1))). WHEN(table3Col1.EQ(Int(2))).THEN(table3Col1.ADD(Int(2))) - assertClauseSerialize(t, query, `(CASE WHEN table3.col1 = $1 THEN table3.col1 + $2 WHEN table3.col1 = $3 THEN table3.col1 + $4 END)`, + assertPostgreClauseSerialize(t, query, `(CASE WHEN table3.col1 = $1 THEN table3.col1 + $2 WHEN table3.col1 = $3 THEN table3.col1 + $4 END)`, int64(1), int64(1), int64(2), int64(2)) } @@ -26,6 +26,6 @@ func TestCase2(t *testing.T) { WHEN(Int(2)).THEN(table3Col1.ADD(Int(2))). ELSE(Int(0)) - assertClauseSerialize(t, query, `(CASE table3.col1 WHEN $1 THEN table3.col1 + $2 WHEN $3 THEN table3.col1 + $4 ELSE $5 END)`, + assertPostgreClauseSerialize(t, query, `(CASE table3.col1 WHEN $1 THEN table3.col1 + $2 WHEN $3 THEN table3.col1 + $4 ELSE $5 END)`, int64(1), int64(1), int64(2), int64(2), int64(0)) } diff --git a/string_expression_test.go b/string_expression_test.go index a1209ce..4be5ac5 100644 --- a/string_expression_test.go +++ b/string_expression_test.go @@ -6,77 +6,77 @@ import ( func TestStringEQ(t *testing.T) { exp := table3StrCol.EQ(table2ColStr) - assertClauseSerialize(t, exp, "(table3.col2 = table2.col_str)") + assertPostgreClauseSerialize(t, exp, "(table3.col2 = table2.col_str)") exp = table3StrCol.EQ(String("JOHN")) - assertClauseSerialize(t, exp, "(table3.col2 = $1)", "JOHN") + assertPostgreClauseSerialize(t, exp, "(table3.col2 = $1)", "JOHN") } func TestStringNOT_EQ(t *testing.T) { exp := table3StrCol.NOT_EQ(table2ColStr) - assertClauseSerialize(t, exp, "(table3.col2 != table2.col_str)") - assertClauseSerialize(t, table3StrCol.NOT_EQ(String("JOHN")), "(table3.col2 != $1)", "JOHN") + assertPostgreClauseSerialize(t, exp, "(table3.col2 != table2.col_str)") + assertPostgreClauseSerialize(t, table3StrCol.NOT_EQ(String("JOHN")), "(table3.col2 != $1)", "JOHN") } func TestStringExpressionIS_DISTINCT_FROM(t *testing.T) { - assertClauseSerialize(t, table3StrCol.IS_DISTINCT_FROM(table2ColStr), "(table3.col2 IS DISTINCT FROM table2.col_str)") - assertClauseSerialize(t, table3StrCol.IS_DISTINCT_FROM(String("JOHN")), "(table3.col2 IS DISTINCT FROM $1)", "JOHN") + assertPostgreClauseSerialize(t, table3StrCol.IS_DISTINCT_FROM(table2ColStr), "(table3.col2 IS DISTINCT FROM table2.col_str)") + assertPostgreClauseSerialize(t, table3StrCol.IS_DISTINCT_FROM(String("JOHN")), "(table3.col2 IS DISTINCT FROM $1)", "JOHN") } func TestStringExpressionIS_NOT_DISTINCT_FROM(t *testing.T) { - assertClauseSerialize(t, table3StrCol.IS_NOT_DISTINCT_FROM(table2ColStr), "(table3.col2 IS NOT DISTINCT FROM table2.col_str)") - assertClauseSerialize(t, table3StrCol.IS_NOT_DISTINCT_FROM(String("JOHN")), "(table3.col2 IS NOT DISTINCT FROM $1)", "JOHN") + assertPostgreClauseSerialize(t, table3StrCol.IS_NOT_DISTINCT_FROM(table2ColStr), "(table3.col2 IS NOT DISTINCT FROM table2.col_str)") + assertPostgreClauseSerialize(t, table3StrCol.IS_NOT_DISTINCT_FROM(String("JOHN")), "(table3.col2 IS NOT DISTINCT FROM $1)", "JOHN") } func TestStringGT(t *testing.T) { exp := table3StrCol.GT(table2ColStr) - assertClauseSerialize(t, exp, "(table3.col2 > table2.col_str)") - assertClauseSerialize(t, table3StrCol.GT(String("JOHN")), "(table3.col2 > $1)", "JOHN") + assertPostgreClauseSerialize(t, exp, "(table3.col2 > table2.col_str)") + assertPostgreClauseSerialize(t, table3StrCol.GT(String("JOHN")), "(table3.col2 > $1)", "JOHN") } func TestStringGT_EQ(t *testing.T) { exp := table3StrCol.GT_EQ(table2ColStr) - assertClauseSerialize(t, exp, "(table3.col2 >= table2.col_str)") - assertClauseSerialize(t, table3StrCol.GT_EQ(String("JOHN")), "(table3.col2 >= $1)", "JOHN") + assertPostgreClauseSerialize(t, exp, "(table3.col2 >= table2.col_str)") + assertPostgreClauseSerialize(t, table3StrCol.GT_EQ(String("JOHN")), "(table3.col2 >= $1)", "JOHN") } func TestStringLT(t *testing.T) { exp := table3StrCol.LT(table2ColStr) - assertClauseSerialize(t, exp, "(table3.col2 < table2.col_str)") - assertClauseSerialize(t, table3StrCol.LT(String("JOHN")), "(table3.col2 < $1)", "JOHN") + assertPostgreClauseSerialize(t, exp, "(table3.col2 < table2.col_str)") + assertPostgreClauseSerialize(t, table3StrCol.LT(String("JOHN")), "(table3.col2 < $1)", "JOHN") } func TestStringLT_EQ(t *testing.T) { exp := table3StrCol.LT_EQ(table2ColStr) - assertClauseSerialize(t, exp, "(table3.col2 <= table2.col_str)") - assertClauseSerialize(t, table3StrCol.LT_EQ(String("JOHN")), "(table3.col2 <= $1)", "JOHN") + assertPostgreClauseSerialize(t, exp, "(table3.col2 <= table2.col_str)") + assertPostgreClauseSerialize(t, table3StrCol.LT_EQ(String("JOHN")), "(table3.col2 <= $1)", "JOHN") } func TestStringCONCAT(t *testing.T) { - assertClauseSerialize(t, table3StrCol.CONCAT(table2ColStr), "(table3.col2 || table2.col_str)") - assertClauseSerialize(t, table3StrCol.CONCAT(String("JOHN")), "(table3.col2 || $1)", "JOHN") + assertPostgreClauseSerialize(t, table3StrCol.CONCAT(table2ColStr), "(table3.col2 || table2.col_str)") + assertPostgreClauseSerialize(t, table3StrCol.CONCAT(String("JOHN")), "(table3.col2 || $1)", "JOHN") } func TestStringLIKE(t *testing.T) { - assertClauseSerialize(t, table3StrCol.LIKE(table2ColStr), "(table3.col2 LIKE table2.col_str)") - assertClauseSerialize(t, table3StrCol.LIKE(String("JOHN")), "(table3.col2 LIKE $1)", "JOHN") + assertPostgreClauseSerialize(t, table3StrCol.LIKE(table2ColStr), "(table3.col2 LIKE table2.col_str)") + assertPostgreClauseSerialize(t, table3StrCol.LIKE(String("JOHN")), "(table3.col2 LIKE $1)", "JOHN") } func TestStringNOT_LIKE(t *testing.T) { - assertClauseSerialize(t, table3StrCol.NOT_LIKE(table2ColStr), "(table3.col2 NOT LIKE table2.col_str)") - assertClauseSerialize(t, table3StrCol.NOT_LIKE(String("JOHN")), "(table3.col2 NOT LIKE $1)", "JOHN") + assertPostgreClauseSerialize(t, table3StrCol.NOT_LIKE(table2ColStr), "(table3.col2 NOT LIKE table2.col_str)") + assertPostgreClauseSerialize(t, table3StrCol.NOT_LIKE(String("JOHN")), "(table3.col2 NOT LIKE $1)", "JOHN") } func TestStringSIMILAR_TO(t *testing.T) { - assertClauseSerialize(t, table3StrCol.SIMILAR_TO(table2ColStr), "(table3.col2 SIMILAR TO table2.col_str)") - assertClauseSerialize(t, table3StrCol.SIMILAR_TO(String("JOHN")), "(table3.col2 SIMILAR TO $1)", "JOHN") + assertPostgreClauseSerialize(t, table3StrCol.SIMILAR_TO(table2ColStr), "(table3.col2 SIMILAR TO table2.col_str)") + assertPostgreClauseSerialize(t, table3StrCol.SIMILAR_TO(String("JOHN")), "(table3.col2 SIMILAR TO $1)", "JOHN") } func TestStringNOT_SIMILAR_TO(t *testing.T) { - assertClauseSerialize(t, table3StrCol.NOT_SIMILAR_TO(table2ColStr), "(table3.col2 NOT SIMILAR TO table2.col_str)") - assertClauseSerialize(t, table3StrCol.NOT_SIMILAR_TO(String("JOHN")), "(table3.col2 NOT SIMILAR TO $1)", "JOHN") + assertPostgreClauseSerialize(t, table3StrCol.NOT_SIMILAR_TO(table2ColStr), "(table3.col2 NOT SIMILAR TO table2.col_str)") + assertPostgreClauseSerialize(t, table3StrCol.NOT_SIMILAR_TO(String("JOHN")), "(table3.col2 NOT SIMILAR TO $1)", "JOHN") } func TestStringExp(t *testing.T) { - assertClauseSerialize(t, StringExp(table2ColFloat), "table2.col_float") - assertClauseSerialize(t, StringExp(table2ColFloat).NOT_LIKE(String("abc")), "(table2.col_float NOT LIKE $1)", "abc") + assertPostgreClauseSerialize(t, StringExp(table2ColFloat), "table2.col_float") + assertPostgreClauseSerialize(t, StringExp(table2ColFloat).NOT_LIKE(String("abc")), "(table2.col_float NOT LIKE $1)", "abc") } diff --git a/table_test.go b/table_test.go index 9a90da6..e7f20b2 100644 --- a/table_test.go +++ b/table_test.go @@ -12,17 +12,17 @@ func TestJoinNilInputs(t *testing.T) { } func TestINNER_JOIN(t *testing.T) { - assertClauseSerialize(t, table1. + assertPostgreClauseSerialize(t, table1. INNER_JOIN(table2, table1ColInt.EQ(table2ColInt)), `db.table1 INNER JOIN db.table2 ON (table1.col_int = table2.col_int)`) - assertClauseSerialize(t, table1. + assertPostgreClauseSerialize(t, table1. INNER_JOIN(table2, table1ColInt.EQ(table2ColInt)). INNER_JOIN(table3, table1ColInt.EQ(table3ColInt)), `db.table1 INNER JOIN db.table2 ON (table1.col_int = table2.col_int) INNER JOIN db.table3 ON (table1.col_int = table3.col_int)`) - assertClauseSerialize(t, table1. + assertPostgreClauseSerialize(t, table1. INNER_JOIN(table2, table1ColInt.EQ(Int(1))). INNER_JOIN(table3, table1ColInt.EQ(Int(2))), `db.table1 @@ -31,17 +31,17 @@ INNER JOIN db.table3 ON (table1.col_int = $2)`, int64(1), int64(2)) } func TestLEFT_JOIN(t *testing.T) { - assertClauseSerialize(t, table1. + assertPostgreClauseSerialize(t, table1. LEFT_JOIN(table2, table1ColInt.EQ(table2ColInt)), `db.table1 LEFT JOIN db.table2 ON (table1.col_int = table2.col_int)`) - assertClauseSerialize(t, table1. + assertPostgreClauseSerialize(t, table1. LEFT_JOIN(table2, table1ColInt.EQ(table2ColInt)). LEFT_JOIN(table3, table1ColInt.EQ(table3ColInt)), `db.table1 LEFT JOIN db.table2 ON (table1.col_int = table2.col_int) LEFT JOIN db.table3 ON (table1.col_int = table3.col_int)`) - assertClauseSerialize(t, table1. + assertPostgreClauseSerialize(t, table1. LEFT_JOIN(table2, table1ColInt.EQ(Int(1))). LEFT_JOIN(table3, table1ColInt.EQ(Int(2))), `db.table1 @@ -50,17 +50,17 @@ LEFT JOIN db.table3 ON (table1.col_int = $2)`, int64(1), int64(2)) } func TestRIGHT_JOIN(t *testing.T) { - assertClauseSerialize(t, table1. + assertPostgreClauseSerialize(t, table1. RIGHT_JOIN(table2, table1ColInt.EQ(table2ColInt)), `db.table1 RIGHT JOIN db.table2 ON (table1.col_int = table2.col_int)`) - assertClauseSerialize(t, table1. + assertPostgreClauseSerialize(t, table1. RIGHT_JOIN(table2, table1ColInt.EQ(table2ColInt)). RIGHT_JOIN(table3, table1ColInt.EQ(table3ColInt)), `db.table1 RIGHT JOIN db.table2 ON (table1.col_int = table2.col_int) RIGHT JOIN db.table3 ON (table1.col_int = table3.col_int)`) - assertClauseSerialize(t, table1. + assertPostgreClauseSerialize(t, table1. RIGHT_JOIN(table2, table1ColInt.EQ(Int(1))). RIGHT_JOIN(table3, table1ColInt.EQ(Int(2))), `db.table1 @@ -69,17 +69,17 @@ RIGHT JOIN db.table3 ON (table1.col_int = $2)`, int64(1), int64(2)) } func TestFULL_JOIN(t *testing.T) { - assertClauseSerialize(t, table1. + assertPostgreClauseSerialize(t, table1. FULL_JOIN(table2, table1ColInt.EQ(table2ColInt)), `db.table1 FULL JOIN db.table2 ON (table1.col_int = table2.col_int)`) - assertClauseSerialize(t, table1. + assertPostgreClauseSerialize(t, table1. FULL_JOIN(table2, table1ColInt.EQ(table2ColInt)). FULL_JOIN(table3, table1ColInt.EQ(table3ColInt)), `db.table1 FULL JOIN db.table2 ON (table1.col_int = table2.col_int) FULL JOIN db.table3 ON (table1.col_int = table3.col_int)`) - assertClauseSerialize(t, table1. + assertPostgreClauseSerialize(t, table1. FULL_JOIN(table2, table1ColInt.EQ(Int(1))). FULL_JOIN(table3, table1ColInt.EQ(Int(2))), `db.table1 @@ -88,11 +88,11 @@ FULL JOIN db.table3 ON (table1.col_int = $2)`, int64(1), int64(2)) } func TestCROSS_JOIN(t *testing.T) { - assertClauseSerialize(t, table1. + assertPostgreClauseSerialize(t, table1. CROSS_JOIN(table2), `db.table1 CROSS JOIN db.table2`) - assertClauseSerialize(t, table1. + assertPostgreClauseSerialize(t, table1. CROSS_JOIN(table2). CROSS_JOIN(table3), `db.table1 diff --git a/tests/all_types_test.go b/tests/all_types_test.go index 6d09a94..5050517 100644 --- a/tests/all_types_test.go +++ b/tests/all_types_test.go @@ -174,29 +174,75 @@ func TestStringOperators(t *testing.T) { func TestBoolOperators(t *testing.T) { query := AllTypes.SELECT( - AllTypes.Boolean.EQ(AllTypes.BooleanPtr), - AllTypes.Boolean.EQ(Bool(true)), - AllTypes.Boolean.NOT_EQ(AllTypes.BooleanPtr), - AllTypes.Boolean.NOT_EQ(Bool(false)), - AllTypes.Boolean.IS_DISTINCT_FROM(AllTypes.BooleanPtr), - AllTypes.Boolean.IS_DISTINCT_FROM(Bool(true)), - AllTypes.Boolean.IS_NOT_DISTINCT_FROM(AllTypes.BooleanPtr), - AllTypes.Boolean.IS_NOT_DISTINCT_FROM(Bool(true)), - AllTypes.Boolean.IS_TRUE(), - AllTypes.Boolean.IS_NOT_TRUE(), - AllTypes.Boolean.IS_NOT_FALSE(), - AllTypes.Boolean.IS_UNKNOWN(), - AllTypes.Boolean.IS_NOT_UNKNOWN(), + AllTypes.Boolean.EQ(AllTypes.BooleanPtr).AS("EQ1"), + AllTypes.Boolean.EQ(Bool(true)).AS("EQ2"), + AllTypes.Boolean.NOT_EQ(AllTypes.BooleanPtr).AS("NEq1"), + AllTypes.Boolean.NOT_EQ(Bool(false)).AS("NEq2"), + AllTypes.Boolean.IS_DISTINCT_FROM(AllTypes.BooleanPtr).AS("distinct1"), + AllTypes.Boolean.IS_DISTINCT_FROM(Bool(true)).AS("distinct2"), + AllTypes.Boolean.IS_NOT_DISTINCT_FROM(AllTypes.BooleanPtr).AS("not_distinct_1"), + AllTypes.Boolean.IS_NOT_DISTINCT_FROM(Bool(true)).AS("NOTDISTINCT2"), + AllTypes.Boolean.IS_TRUE().AS("ISTRUE"), + AllTypes.Boolean.IS_NOT_TRUE().AS("isnottrue"), + AllTypes.Boolean.IS_FALSE().AS("is_False"), + AllTypes.Boolean.IS_NOT_FALSE().AS("is not false"), + AllTypes.Boolean.IS_UNKNOWN().AS("is unknown"), + AllTypes.Boolean.IS_NOT_UNKNOWN().AS("is_not_unknown"), - AllTypes.Boolean.AND(AllTypes.Boolean).EQ(AllTypes.Boolean.AND(AllTypes.Boolean)), - AllTypes.Boolean.OR(AllTypes.Boolean).EQ(AllTypes.Boolean.AND(AllTypes.Boolean)), - ) + AllTypes.Boolean.AND(AllTypes.Boolean).EQ(AllTypes.Boolean.AND(AllTypes.Boolean)).AS("complex1"), + AllTypes.Boolean.OR(AllTypes.Boolean).EQ(AllTypes.Boolean.AND(AllTypes.Boolean)).AS("complex2"), + ).LIMIT(2) - //fmt.Println(query.DebugSql()) + //fmt.Println(query.Sql()) - err := query.Query(db, &struct{}{}) + testutils.AssertStatementSql(t, query, ` +SELECT (all_types.boolean = all_types.boolean_ptr) AS "EQ1", + (all_types.boolean = $1) AS "EQ2", + (all_types.boolean != all_types.boolean_ptr) AS "NEq1", + (all_types.boolean != $2) AS "NEq2", + (all_types.boolean IS DISTINCT FROM all_types.boolean_ptr) AS "distinct1", + (all_types.boolean IS DISTINCT FROM $3) AS "distinct2", + (all_types.boolean IS NOT DISTINCT FROM all_types.boolean_ptr) AS "not_distinct_1", + (all_types.boolean IS NOT DISTINCT FROM $4) AS "NOTDISTINCT2", + all_types.boolean IS TRUE AS "ISTRUE", + all_types.boolean IS NOT TRUE AS "isnottrue", + all_types.boolean IS FALSE AS "is_False", + all_types.boolean IS NOT FALSE AS "is not false", + all_types.boolean IS UNKNOWN AS "is unknown", + all_types.boolean IS NOT UNKNOWN AS "is_not_unknown", + ((all_types.boolean AND all_types.boolean) = (all_types.boolean AND all_types.boolean)) AS "complex1", + ((all_types.boolean OR all_types.boolean) = (all_types.boolean AND all_types.boolean)) AS "complex2" +FROM test_sample.all_types +LIMIT $5; +`, true, false, true, true, int64(2)) + + var dest []struct { + Eq1 *bool + Eq2 *bool + NEq1 *bool + NEq2 *bool + Distinct1 *bool + Distinct2 *bool + NotDistinct1 *bool + NotDistinct2 *bool + IsTrue *bool + IsNotTrue *bool + IsFalse *bool + IsNotFalse *bool + IsUnknown *bool + IsNotUnknown *bool + + Complex1 *bool + Complex2 *bool + } + + err := query.Query(db, &dest) assert.NilError(t, err) + + testutils.JsonPrint(dest) + + testutils.AssertJSONFile(t, "./testdata/common_db_results/bool_operators.json", dest) } func TestFloatOperators(t *testing.T) { @@ -507,7 +553,7 @@ SELECT "subQuery"."all_types.boolean" AS "all_types.boolean", "subQuery"."aliasedColumn" AS "aliasedColumn" FROM` - testutils.AssertStatementSql(t, stmt1, expectedSQL+expected.sql+";\n", expected.args...) + testutils.AssertDebugStatementSql(t, stmt1, expectedSQL+expected.sql+";\n", expected.args...) dest1 := []model.AllTypes{} err := stmt1.Query(db, &dest1) @@ -530,7 +576,7 @@ FROM` //fmt.Println(stmt2.DebugSql()) - testutils.AssertStatementSql(t, stmt2, expectedSQL+expected.sql+";\n", expected.args...) + testutils.AssertDebugStatementSql(t, stmt2, expectedSQL+expected.sql+";\n", expected.args...) dest2 := []model.AllTypes{} err = stmt2.Query(db, &dest2) diff --git a/tests/chinook_db_test.go b/tests/chinook_db_test.go index a520216..0a22cf8 100644 --- a/tests/chinook_db_test.go +++ b/tests/chinook_db_test.go @@ -16,7 +16,7 @@ func TestSelect(t *testing.T) { SELECT(Album.AllColumns). ORDER_BY(Album.AlbumId.ASC()) - testutils.AssertStatementSql(t, stmt, ` + testutils.AssertDebugStatementSql(t, stmt, ` SELECT "Album"."AlbumId" AS "Album.AlbumId", "Album"."Title" AS "Album.Title", "Album"."ArtistId" AS "Album.ArtistId" @@ -126,7 +126,7 @@ func TestSelfJoin(t *testing.T) { ). ORDER_BY(Employee.EmployeeId) - testutils.AssertStatementSql(t, stmt, ` + testutils.AssertDebugStatementSql(t, stmt, ` SELECT "Employee"."EmployeeId" AS "Employee.EmployeeId", "Employee"."FirstName" AS "Employee.FirstName", "Employee"."LastName" AS "Employee.LastName", @@ -210,7 +210,7 @@ func TestUnionForQuotedNames(t *testing.T) { ORDER_BY(Album.AlbumId) //fmt.Println(stmt.DebugSql()) - testutils.AssertStatementSql(t, stmt, ` + testutils.AssertDebugStatementSql(t, stmt, ` ( ( SELECT "Album"."AlbumId" AS "Album.AlbumId", @@ -294,7 +294,7 @@ func TestSubQueriesForQuotedNames(t *testing.T) { SELECT(first10Artist.AllColumns(), first10Albums.AllColumns()). ORDER_BY(artistID) - testutils.AssertStatementSql(t, stmt, ` + testutils.AssertDebugStatementSql(t, stmt, ` SELECT "first10Artist"."Artist.ArtistId" AS "Artist.ArtistId", "first10Artist"."Artist.Name" AS "Artist.Name", "first10Albums"."Album.AlbumId" AS "Album.AlbumId", diff --git a/tests/delete_test.go b/tests/delete_test.go index ea76544..639aae2 100644 --- a/tests/delete_test.go +++ b/tests/delete_test.go @@ -22,7 +22,7 @@ WHERE link.name IN ('Gmail', 'Outlook'); DELETE(). WHERE(Link.Name.IN(String("Gmail"), String("Outlook"))) - testutils.AssertStatementSql(t, deleteStmt, expectedSQL, "Gmail", "Outlook") + testutils.AssertDebugStatementSql(t, deleteStmt, expectedSQL, "Gmail", "Outlook") assertExec(t, deleteStmt, 2) } @@ -42,7 +42,7 @@ RETURNING link.id AS "link.id", WHERE(Link.Name.IN(String("Gmail"), String("Outlook"))). RETURNING(Link.AllColumns) - testutils.AssertStatementSql(t, deleteStmt, expectedSQL, "Gmail", "Outlook") + testutils.AssertDebugStatementSql(t, deleteStmt, expectedSQL, "Gmail", "Outlook") dest := []model.Link{} diff --git a/tests/init/data/mysql/test_sample.sql b/tests/init/data/mysql/test_sample.sql index 371ac75..1ab3015 100644 --- a/tests/init/data/mysql/test_sample.sql +++ b/tests/init/data/mysql/test_sample.sql @@ -8,6 +8,9 @@ DROP TABLE IF EXISTS `all_types`; CREATE TABLE `all_types` ( + `boolean` BOOLEAN NOT NULL, + `boolean_ptr` BOOLEAN, + `tiny_int` TINYINT NOT NULL, `utiny_int` TINYINT unsigned NOT NULL, @@ -107,8 +110,8 @@ CREATE TABLE `all_types` ( ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci; INSERT INTO `all_types` VALUES -(-3,3,-14,14,-150,150,-1600,1600,-17000,17000,-3,3,-14,14,-150,150,-1600,1600,-17000,17000,1.11,1.11,2.22,2.22,3.33,3.33,4.44,4.44,_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\"}'), -(-3,3,-14,14,-150,150,-1600,1600,-17000,17000,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,1.11,NULL,2.22,NULL,3.33,NULL,4.44,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); +(false, true, -3,3,-14,14,-150,150,-1600,1600,-17000,17000,-3,3,-14,14,-150,150,-1600,1600,-17000,17000,1.11,1.11,2.22,2.22,3.33,3.33,4.44,4.44,_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,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,1.11,NULL,2.22,NULL,3.33,NULL,4.44,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/init.go b/tests/init/init.go index 683637e..768a3ad 100644 --- a/tests/init/init.go +++ b/tests/init/init.go @@ -7,6 +7,7 @@ import ( "github.com/go-jet/jet/generator/mysql" "github.com/go-jet/jet/generator/postgres" "github.com/go-jet/jet/tests/dbconfig" + _ "github.com/go-sql-driver/mysql" _ "github.com/lib/pq" "io/ioutil" "os" diff --git a/tests/insert_test.go b/tests/insert_test.go index 98f08e5..54e341a 100644 --- a/tests/insert_test.go +++ b/tests/insert_test.go @@ -31,7 +31,7 @@ RETURNING link.id AS "link.id", VALUES(102, "http://www.yahoo.com", "Yahoo", nil). RETURNING(Link.AllColumns) - testutils.AssertStatementSql(t, insertQuery, expectedSQL, + testutils.AssertDebugStatementSql(t, insertQuery, expectedSQL, 100, "http://www.postgresqltutorial.com", "PostgreSQL Tutorial", 101, "http://www.google.com", "Google", 102, "http://www.yahoo.com", "Yahoo", nil) @@ -85,7 +85,7 @@ INSERT INTO test_sample.link VALUES stmt := Link.INSERT(). VALUES(100, "http://www.postgresqltutorial.com", "PostgreSQL Tutorial", DEFAULT) - testutils.AssertStatementSql(t, stmt, expectedSQL, + testutils.AssertDebugStatementSql(t, stmt, expectedSQL, 100, "http://www.postgresqltutorial.com", "PostgreSQL Tutorial") assertExec(t, stmt, 1) @@ -107,7 +107,7 @@ INSERT INTO test_sample.link (url, name) VALUES INSERT(Link.URL, Link.Name). MODEL(linkData) - testutils.AssertStatementSql(t, query, expectedSQL, "http://www.duckduckgo.com", "Duck Duck go") + testutils.AssertDebugStatementSql(t, query, expectedSQL, "http://www.duckduckgo.com", "Duck Duck go") assertExec(t, query, 1) } @@ -129,7 +129,7 @@ INSERT INTO test_sample.link VALUES INSERT(). MODEL(linkData) - testutils.AssertStatementSql(t, query, expectedSQL, int32(1000), "http://www.duckduckgo.com", "Duck Duck go", nil) + testutils.AssertDebugStatementSql(t, query, expectedSQL, int32(1000), "http://www.duckduckgo.com", "Duck Duck go", nil) assertExec(t, query, 1) } @@ -161,7 +161,7 @@ INSERT INTO test_sample.link (url, name) VALUES INSERT(Link.URL, Link.Name). MODELS([]model.Link{tutorial, google, yahoo}) - testutils.AssertStatementSql(t, stmt, expectedSQL, + testutils.AssertDebugStatementSql(t, stmt, expectedSQL, "http://www.postgresqltutorial.com", "PostgreSQL Tutorial", "http://www.google.com", "Google", "http://www.yahoo.com", "Yahoo") @@ -194,7 +194,7 @@ INSERT INTO test_sample.link (url, name, description) VALUES MODEL(google). MODELS([]model.Link{google, yahoo}) - testutils.AssertStatementSql(t, stmt, expectedSQL, + testutils.AssertDebugStatementSql(t, stmt, expectedSQL, "http://www.postgresqltutorial.com", "PostgreSQL Tutorial", "http://www.google.com", "Google", nil, "http://www.google.com", "Google", nil, @@ -231,7 +231,7 @@ RETURNING link.id AS "link.id", ). RETURNING(Link.AllColumns) - testutils.AssertStatementSql(t, query, expectedSQL, int64(0)) + testutils.AssertDebugStatementSql(t, query, expectedSQL, int64(0)) dest := []model.Link{} diff --git a/tests/lock_test.go b/tests/lock_test.go index b436ef5..b266a54 100644 --- a/tests/lock_test.go +++ b/tests/lock_test.go @@ -29,7 +29,7 @@ LOCK TABLE dvds.address IN` for _, lockMode := range testData { query := Address.LOCK().IN(lockMode) - testutils.AssertStatementSql(t, query, expectedSQL+" "+string(lockMode)+" MODE;\n") + testutils.AssertDebugStatementSql(t, query, expectedSQL+" "+string(lockMode)+" MODE;\n") tx, _ := db.Begin() @@ -45,7 +45,7 @@ LOCK TABLE dvds.address IN` for _, lockMode := range testData { query := Address.LOCK().IN(lockMode).NOWAIT() - testutils.AssertStatementSql(t, query, expectedSQL+" "+string(lockMode)+" MODE NOWAIT;\n") + testutils.AssertDebugStatementSql(t, query, expectedSQL+" "+string(lockMode)+" MODE NOWAIT;\n") tx, _ := db.Begin() diff --git a/tests/mysql/mysql_test.go b/tests/mysql/mysql_main_test.go similarity index 64% rename from tests/mysql/mysql_test.go rename to tests/mysql/mysql_main_test.go index 135a92b..f544f18 100644 --- a/tests/mysql/mysql_test.go +++ b/tests/mysql/mysql_main_test.go @@ -2,11 +2,9 @@ package mysql import ( "database/sql" - "fmt" "github.com/go-jet/jet/tests/dbconfig" - //_ "github.com/go-sql-driver/mysql" - _ "github.com/ziutek/mymysql/godrv" + _ "github.com/go-sql-driver/mysql" "github.com/pkg/profile" "os" @@ -18,10 +16,8 @@ var db *sql.DB func TestMain(m *testing.M) { defer profile.Start().Stop() - fmt.Println(dbconfig.MySQLConnectionString) - var err error - db, err = sql.Open("mysql", "jet:jet@tcp(localhost:3306)/") + db, err = sql.Open("mysql", dbconfig.MySQLConnectionString) if err != nil { panic("Failed to connect to test db" + err.Error()) } diff --git a/tests/mysql/sakila_test.go b/tests/mysql/sakila_test.go index 2502a0a..182ec53 100644 --- a/tests/mysql/sakila_test.go +++ b/tests/mysql/sakila_test.go @@ -1,14 +1,11 @@ package mysql import ( - "github.com/davecgh/go-spew/spew" "github.com/go-jet/jet/internal/testutils" . "github.com/go-jet/jet/mysql" - "gotest.tools/assert" - "reflect" - "github.com/go-jet/jet/tests/.gentestdata/sakila/model" . "github.com/go-jet/jet/tests/.gentestdata/sakila/table" + "gotest.tools/assert" "testing" ) @@ -20,9 +17,8 @@ SELECT DISTINCT actor.actor_id AS "actor.actor_id", actor.last_name AS "actor.last_name", actor.last_update AS "actor.last_update" FROM sakila.actor -WHERE actor.actor_id = 1; +WHERE actor.actor_id = ?; ` - spew.Dump(reflect.TypeOf(db.Driver()).String()) query := Actor. SELECT(Actor.AllColumns). diff --git a/tests/mysql/sample_test.go b/tests/mysql/sample_test.go index 73b3ef3..78f9895 100644 --- a/tests/mysql/sample_test.go +++ b/tests/mysql/sample_test.go @@ -4,6 +4,9 @@ import ( "github.com/go-jet/jet/internal/testutils" "github.com/go-jet/jet/tests/.gentestdata/mysql/test_sample/model" . "github.com/go-jet/jet/tests/.gentestdata/mysql/test_sample/table" + + . "github.com/go-jet/jet/mysql" + "gotest.tools/assert" "testing" ) @@ -23,9 +26,83 @@ func TestAllTypes(t *testing.T) { testutils.AssertJSON(t, dest, allTypesJson) } +func TestBoolOperators(t *testing.T) { + query := AllTypes.SELECT( + AllTypes.Boolean.EQ(AllTypes.BooleanPtr).AS("EQ1"), + AllTypes.Boolean.EQ(Bool(true)).AS("EQ2"), + AllTypes.Boolean.NOT_EQ(AllTypes.BooleanPtr).AS("NEq1"), + AllTypes.Boolean.NOT_EQ(Bool(false)).AS("NEq2"), + AllTypes.Boolean.IS_DISTINCT_FROM(AllTypes.BooleanPtr).AS("distinct1"), + AllTypes.Boolean.IS_DISTINCT_FROM(Bool(true)).AS("distinct2"), + AllTypes.Boolean.IS_NOT_DISTINCT_FROM(AllTypes.BooleanPtr).AS("not_distinct_1"), + AllTypes.Boolean.IS_NOT_DISTINCT_FROM(Bool(true)).AS("NOTDISTINCT2"), + AllTypes.Boolean.IS_TRUE().AS("ISTRUE"), + AllTypes.Boolean.IS_NOT_TRUE().AS("isnottrue"), + AllTypes.Boolean.IS_FALSE().AS("is_False"), + AllTypes.Boolean.IS_NOT_FALSE().AS("is not false"), + AllTypes.Boolean.IS_UNKNOWN().AS("is unknown"), + AllTypes.Boolean.IS_NOT_UNKNOWN().AS("is_not_unknown"), + + AllTypes.Boolean.AND(AllTypes.Boolean).EQ(AllTypes.Boolean.AND(AllTypes.Boolean)).AS("complex1"), + AllTypes.Boolean.OR(AllTypes.Boolean).EQ(AllTypes.Boolean.AND(AllTypes.Boolean)).AS("complex2"), + ) + + //fmt.Println(query.Sql()) + + testutils.AssertStatementSql(t, query, ` +SELECT (all_types.boolean = all_types.boolean_ptr) AS "EQ1", + (all_types.boolean = ?) AS "EQ2", + (all_types.boolean != all_types.boolean_ptr) AS "NEq1", + (all_types.boolean != ?) AS "NEq2", + (NOT all_types.boolean <=> all_types.boolean_ptr) AS "distinct1", + (NOT all_types.boolean <=> ?) AS "distinct2", + (all_types.boolean <=> all_types.boolean_ptr) AS "not_distinct_1", + (all_types.boolean <=> ?) AS "NOTDISTINCT2", + all_types.boolean IS TRUE AS "ISTRUE", + all_types.boolean IS NOT TRUE AS "isnottrue", + all_types.boolean IS FALSE AS "is_False", + all_types.boolean IS NOT FALSE AS "is not false", + all_types.boolean IS UNKNOWN AS "is unknown", + all_types.boolean IS NOT UNKNOWN AS "is_not_unknown", + ((all_types.boolean AND all_types.boolean) = (all_types.boolean AND all_types.boolean)) AS "complex1", + ((all_types.boolean OR all_types.boolean) = (all_types.boolean AND all_types.boolean)) AS "complex2" +FROM test_sample.all_types; +`, true, false, true, true) + + var dest []struct { + Eq1 *bool + Eq2 *bool + NEq1 *bool + NEq2 *bool + Distinct1 *bool + Distinct2 *bool + NotDistinct1 *bool + NotDistinct2 *bool + IsTrue *bool + IsNotTrue *bool + IsFalse *bool + IsNotFalse *bool + IsUnknown *bool + IsNotUnknown *bool + + Complex1 *bool + Complex2 *bool + } + + err := query.Query(db, &dest) + + assert.NilError(t, err) + + testutils.JsonPrint(dest) + + testutils.AssertJSONFile(t, "./testdata/common_db_results/bool_operators.json", dest) +} + var allTypesJson = ` [ { + "Boolean": false, + "BooleanPtr": true, "TinyInt": -3, "UtinyInt": 3, "SmallInt": -14, @@ -84,6 +161,8 @@ var allTypesJson = ` "JSONPtr": "{\"key1\": \"value1\", \"key2\": \"value2\"}" }, { + "Boolean": false, + "BooleanPtr": null, "TinyInt": -3, "UtinyInt": 3, "SmallInt": -14, diff --git a/tests/sample_test.go b/tests/sample_test.go index 90fa7ac..f335d84 100644 --- a/tests/sample_test.go +++ b/tests/sample_test.go @@ -15,7 +15,7 @@ func TestUUIDType(t *testing.T) { SELECT(AllTypes.UUID, AllTypes.UUIDPtr). WHERE(AllTypes.UUID.EQ(String("a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11"))) - testutils.AssertStatementSql(t, query, ` + testutils.AssertDebugStatementSql(t, query, ` SELECT all_types.uuid AS "all_types.uuid", all_types.uuid_ptr AS "all_types.uuid_ptr" FROM test_sample.all_types @@ -34,7 +34,7 @@ func TestEnumType(t *testing.T) { query := Person. SELECT(Person.AllColumns) - testutils.AssertStatementSql(t, query, ` + testutils.AssertDebugStatementSql(t, query, ` SELECT person.person_id AS "person.person_id", person.first_name AS "person.first_name", person.last_name AS "person.last_name", @@ -98,7 +98,7 @@ ORDER BY employee.employee_id; ). ORDER_BY(Employee.EmployeeID) - testutils.AssertStatementSql(t, query, expectedSQL) + testutils.AssertDebugStatementSql(t, query, expectedSQL) type Manager model.Employee @@ -134,7 +134,7 @@ ORDER BY employee.employee_id; func TestWierdNamesTable(t *testing.T) { stmt := WeirdNamesTable.SELECT(WeirdNamesTable.AllColumns) - testutils.AssertStatementSql(t, stmt, ` + testutils.AssertDebugStatementSql(t, stmt, ` SELECT "WEIRD NAMES TABLE".weird_column_name1 AS "WEIRD NAMES TABLE.weird_column_name1", "WEIRD NAMES TABLE"."Weird_Column_Name2" AS "WEIRD NAMES TABLE.Weird_Column_Name2", "WEIRD NAMES TABLE"."wEiRd_cOluMn_nAmE3" AS "WEIRD NAMES TABLE.wEiRd_cOluMn_nAmE3", diff --git a/tests/select_test.go b/tests/select_test.go index 45fb2b8..b198e73 100644 --- a/tests/select_test.go +++ b/tests/select_test.go @@ -25,7 +25,7 @@ WHERE actor.actor_id = 1; DISTINCT(). WHERE(Actor.ActorID.EQ(Int(1))) - testutils.AssertStatementSql(t, query, expectedSQL, int64(1)) + testutils.AssertDebugStatementSql(t, query, expectedSQL, int64(1)) actor := model.Actor{} err := query.Query(db, &actor) @@ -75,7 +75,7 @@ LIMIT 30; ORDER_BY(Payment.PaymentID.ASC()). LIMIT(30) - testutils.AssertStatementSql(t, query, expectedSQL, int64(30)) + testutils.AssertDebugStatementSql(t, query, expectedSQL, int64(30)) dest := []model.Payment{} @@ -104,7 +104,7 @@ ORDER BY customer.customer_id ASC; query := Customer.SELECT(Customer.AllColumns).ORDER_BY(Customer.CustomerID.ASC()) - testutils.AssertStatementSql(t, query, expectedSQL) + testutils.AssertDebugStatementSql(t, query, expectedSQL) err := query.Query(db, &customers) assert.NilError(t, err) @@ -157,7 +157,7 @@ LIMIT 12; ). LIMIT(12) - testutils.AssertStatementSql(t, query, expectedSQL, int64(1), int64(1), int64(10), int64(1), int64(2), int64(1), int64(12)) + testutils.AssertDebugStatementSql(t, query, expectedSQL, int64(1), int64(1), int64(10), int64(1), int64(2), int64(1), int64(12)) } func TestJoinQueryStruct(t *testing.T) { @@ -225,7 +225,7 @@ LIMIT 1000; ORDER_BY(Film.FilmID.ASC()). LIMIT(1000) - testutils.AssertStatementSql(t, query, expectedSQL, int64(1000)) + testutils.AssertDebugStatementSql(t, query, expectedSQL, int64(1000)) var languageActorFilm []struct { model.Language @@ -291,7 +291,7 @@ LIMIT 15; WHERE(Film.Rating.EQ(enum.MpaaRating.Nc17)). LIMIT(15) - testutils.AssertStatementSql(t, query, expectedSQL, int64(15)) + testutils.AssertDebugStatementSql(t, query, expectedSQL, int64(15)) err := query.Query(db, &filmsPerLanguage) @@ -326,7 +326,7 @@ func TestExecution1(t *testing.T) { WHERE(City.City.EQ(String("London")).OR(City.City.EQ(String("York")))). ORDER_BY(City.CityID, Address.AddressID, Customer.CustomerID) - testutils.AssertStatementSql(t, stmt, ` + testutils.AssertDebugStatementSql(t, stmt, ` SELECT city.city_id AS "city.city_id", city.city AS "city.city", address.address_id AS "address.address_id", @@ -400,7 +400,7 @@ func TestExecution2(t *testing.T) { WHERE(City.City.EQ(String("London")).OR(City.City.EQ(String("York")))). ORDER_BY(City.CityID, Address.AddressID, Customer.CustomerID) - testutils.AssertStatementSql(t, stmt, ` + testutils.AssertDebugStatementSql(t, stmt, ` SELECT city.city_id AS "my_city.id", city.city AS "myCity.Name", address.address_id AS "My_Address.id", @@ -458,7 +458,7 @@ func TestExecution3(t *testing.T) { WHERE(City.City.EQ(String("London")).OR(City.City.EQ(String("York")))). ORDER_BY(City.CityID, Address.AddressID, Customer.CustomerID) - testutils.AssertStatementSql(t, stmt, ` + testutils.AssertDebugStatementSql(t, stmt, ` SELECT city.city_id AS "city_id", city.city AS "city_name", customer.customer_id AS "customer_id", @@ -515,7 +515,7 @@ func TestExecution4(t *testing.T) { WHERE(City.City.EQ(String("London")).OR(City.City.EQ(String("York")))). ORDER_BY(City.CityID, Address.AddressID, Customer.CustomerID) - testutils.AssertStatementSql(t, stmt, ` + testutils.AssertDebugStatementSql(t, stmt, ` SELECT city.city_id AS "city.city_id", city.city AS "city.city", customer.customer_id AS "customer.customer_id", @@ -686,7 +686,7 @@ ORDER BY customer.customer_id ASC; SELECT(Customer.AllColumns, Address.AllColumns). ORDER_BY(Customer.CustomerID.ASC()) - testutils.AssertStatementSql(t, query, expectedSQL) + testutils.AssertDebugStatementSql(t, query, expectedSQL) allCustomersAndAddress := []struct { Address *model.Address @@ -739,7 +739,7 @@ LIMIT 1000; ORDER_BY(Customer.CustomerID.ASC()). LIMIT(1000) - testutils.AssertStatementSql(t, query, expectedSQL, int64(1000)) + testutils.AssertDebugStatementSql(t, query, expectedSQL, int64(1000)) var customerAddresCrosJoined []struct { model.Customer @@ -794,7 +794,7 @@ ORDER BY f1.film_id ASC; SELECT(f1.AllColumns, f2.AllColumns). ORDER_BY(f1.FilmID.ASC()) - testutils.AssertStatementSql(t, query, expectedSQL) + testutils.AssertDebugStatementSql(t, query, expectedSQL) type F1 model.Film type F2 model.Film @@ -836,7 +836,7 @@ LIMIT 1000; ORDER_BY(f1.Length.ASC(), f1.Title.ASC(), f2.Title.ASC()). LIMIT(1000) - testutils.AssertStatementSql(t, query, expectedSQL, int64(1000)) + testutils.AssertDebugStatementSql(t, query, expectedSQL, int64(1000)) type thesameLengthFilms struct { Title1 string @@ -898,7 +898,7 @@ FROM dvds.actor rRatingFilms.AllColumns(), ) - testutils.AssertStatementSql(t, query, expectedQuery) + testutils.AssertDebugStatementSql(t, query, expectedQuery) dest := []model.Actor{} @@ -916,7 +916,7 @@ FROM dvds.film; MAXf(Film.RentalRate).AS("max_film_rate"), ) - testutils.AssertStatementSql(t, query, expectedQuery) + testutils.AssertDebugStatementSql(t, query, expectedQuery) ret := struct { MaxFilmRate float64 @@ -961,7 +961,7 @@ ORDER BY film.film_id ASC; WHERE(Film.RentalRate.EQ(maxFilmRentalRate)). ORDER_BY(Film.FilmID.ASC()) - testutils.AssertStatementSql(t, query, expectedSQL) + testutils.AssertDebugStatementSql(t, query, expectedSQL) maxRentalRateFilms := []model.Film{} err := query.Query(db, &maxRentalRateFilms) @@ -1019,7 +1019,7 @@ ORDER BY SUM(payment.amount) ASC; SUMf(Payment.Amount).GT(Float(100)), ) - testutils.AssertStatementSql(t, customersPaymentQuery, expectedSQL, float64(100)) + testutils.AssertDebugStatementSql(t, customersPaymentQuery, expectedSQL, float64(100)) type CustomerPaymentSum struct { CustomerID int16 @@ -1089,7 +1089,7 @@ ORDER BY customer_payment_sum."amount_sum" ASC; ). ORDER_BY(amountSum.ASC()) - testutils.AssertStatementSql(t, query, expectedSQL) + testutils.AssertDebugStatementSql(t, query, expectedSQL) type CustomerWithAmounts struct { Customer *model.Customer @@ -1174,7 +1174,7 @@ ORDER BY payment.payment_date ASC; WHERE(Payment.PaymentDate.LT(Timestamp(2007, 02, 14, 22, 16, 01, 0))). ORDER_BY(Payment.PaymentDate.ASC()) - testutils.AssertStatementSql(t, query, expectedSQL, "2007-02-14 22:16:01.000") + testutils.AssertDebugStatementSql(t, query, expectedSQL, "2007-02-14 22:16:01.000") payments := []model.Payment{} @@ -1228,7 +1228,7 @@ OFFSET 20; LIMIT(10). OFFSET(20) - testutils.AssertStatementSql(t, query, expectedQuery, float64(100), float64(200), int64(10), int64(20)) + testutils.AssertDebugStatementSql(t, query, expectedQuery, float64(100), float64(200), int64(10), int64(20)) dest := []model.Payment{} @@ -1302,7 +1302,7 @@ LIMIT 20; ORDER_BY(Payment.PaymentID.ASC()). LIMIT(20) - testutils.AssertStatementSql(t, query, expectedQuery, int64(1), "ONE", int64(2), "TWO", int64(3), "THREE", "OTHER", int64(20)) + testutils.AssertDebugStatementSql(t, query, expectedQuery, int64(1), "ONE", int64(2), "TWO", int64(3), "THREE", "OTHER", int64(20)) dest := []struct { StaffIDNum string @@ -1338,7 +1338,7 @@ FOR` for lockType, lockTypeStr := range getRowLockTestData() { query.FOR(lockType) - testutils.AssertStatementSql(t, query, expectedSQL+" "+lockTypeStr+";\n", int64(3)) + testutils.AssertDebugStatementSql(t, query, expectedSQL+" "+lockTypeStr+";\n", int64(3)) tx, _ := db.Begin() @@ -1354,7 +1354,7 @@ FOR` for lockType, lockTypeStr := range getRowLockTestData() { query.FOR(lockType.NOWAIT()) - testutils.AssertStatementSql(t, query, expectedSQL+" "+lockTypeStr+" NOWAIT;\n", int64(3)) + testutils.AssertDebugStatementSql(t, query, expectedSQL+" "+lockTypeStr+" NOWAIT;\n", int64(3)) tx, _ := db.Begin() @@ -1370,7 +1370,7 @@ FOR` for lockType, lockTypeStr := range getRowLockTestData() { query.FOR(lockType.SKIP_LOCKED()) - testutils.AssertStatementSql(t, query, expectedSQL+" "+lockTypeStr+" SKIP LOCKED;\n", int64(3)) + testutils.AssertDebugStatementSql(t, query, expectedSQL+" "+lockTypeStr+" SKIP LOCKED;\n", int64(3)) tx, _ := db.Begin() @@ -1441,7 +1441,7 @@ ORDER BY actor.actor_id ASC, film.film_id ASC; Film.FilmID.ASC(), ) - testutils.AssertStatementSql(t, stmt, expectedSQL, "English", "Action", int64(180)) + testutils.AssertDebugStatementSql(t, stmt, expectedSQL, "English", "Action", int64(180)) var dest []struct { model.Actor diff --git a/tests/testdata/common_db_results/bool_operators.json b/tests/testdata/common_db_results/bool_operators.json new file mode 100644 index 0000000..e3f8edf --- /dev/null +++ b/tests/testdata/common_db_results/bool_operators.json @@ -0,0 +1,38 @@ +[ + { + "Eq1": false, + "Eq2": false, + "NEq1": true, + "NEq2": false, + "Distinct1": true, + "Distinct2": true, + "NotDistinct1": false, + "NotDistinct2": false, + "IsTrue": false, + "IsNotTrue": true, + "IsFalse": true, + "IsNotFalse": false, + "IsUnknown": false, + "IsNotUnknown": true, + "Complex1": true, + "Complex2": true + }, + { + "Eq1": null, + "Eq2": false, + "NEq1": null, + "NEq2": false, + "Distinct1": true, + "Distinct2": true, + "NotDistinct1": false, + "NotDistinct2": false, + "IsTrue": false, + "IsNotTrue": true, + "IsFalse": true, + "IsNotFalse": false, + "IsUnknown": false, + "IsNotUnknown": true, + "Complex1": true, + "Complex2": true + } +] \ No newline at end of file diff --git a/tests/update_test.go b/tests/update_test.go index da2da48..9dcf7ba 100644 --- a/tests/update_test.go +++ b/tests/update_test.go @@ -24,7 +24,7 @@ UPDATE test_sample.link SET (name, url) = ('Bong', 'http://bong.com') WHERE link.name = 'Bing'; ` - testutils.AssertStatementSql(t, query, expectedSQL, "Bong", "http://bong.com", "Bing") + testutils.AssertDebugStatementSql(t, query, expectedSQL, "Bong", "http://bong.com", "Bing") assertExec(t, query, 1) @@ -69,7 +69,7 @@ SET (name, url) = (( WHERE link.name = 'Bing'; ` - testutils.AssertStatementSql(t, query, expectedSQL, "Bong", "Bing", "Bing") + testutils.AssertDebugStatementSql(t, query, expectedSQL, "Bong", "Bing", "Bing") assertExec(t, query, 1) } @@ -93,7 +93,7 @@ RETURNING link.id AS "link.id", WHERE(Link.Name.EQ(String("Ask"))). RETURNING(Link.AllColumns) - testutils.AssertStatementSql(t, stmt, expectedSQL, "DuckDuckGo", "http://www.duckduckgo.com", "Ask") + testutils.AssertDebugStatementSql(t, stmt, expectedSQL, "DuckDuckGo", "http://www.duckduckgo.com", "Ask") links := []model.Link{} @@ -127,7 +127,7 @@ SET (id, url, name, description) = ( ) WHERE link.id = 0; ` - testutils.AssertStatementSql(t, stmt, expectedSQL, int64(0), int64(0)) + testutils.AssertDebugStatementSql(t, stmt, expectedSQL, int64(0), int64(0)) assertExec(t, stmt, 1) } @@ -152,7 +152,7 @@ SET (id, url, name, description) = ( ) WHERE link.id = 0; ` - testutils.AssertStatementSql(t, stmt, expectedSQL, int64(0), int64(0)) + testutils.AssertDebugStatementSql(t, stmt, expectedSQL, int64(0), int64(0)) assertExecErr(t, stmt, "pq: number of columns does not match number of values") } @@ -176,7 +176,7 @@ UPDATE test_sample.link SET (id, url, name, description) = (201, 'http://www.duckduckgo.com', 'DuckDuckGo', NULL) WHERE link.id = 201; ` - testutils.AssertStatementSql(t, stmt, expectedSQL, int32(201), "http://www.duckduckgo.com", "DuckDuckGo", nil, int64(201)) + testutils.AssertDebugStatementSql(t, stmt, expectedSQL, int32(201), "http://www.duckduckgo.com", "DuckDuckGo", nil, int64(201)) assertExec(t, stmt, 1) } @@ -203,7 +203,7 @@ UPDATE test_sample.link SET (description, name, url) = (NULL, 'DuckDuckGo', 'http://www.duckduckgo.com') WHERE link.id = 201; ` - testutils.AssertStatementSql(t, stmt, expectedSQL, nil, "DuckDuckGo", "http://www.duckduckgo.com", int64(201)) + testutils.AssertDebugStatementSql(t, stmt, expectedSQL, nil, "DuckDuckGo", "http://www.duckduckgo.com", int64(201)) assertExec(t, stmt, 1) } @@ -239,7 +239,7 @@ UPDATE test_sample.link SET (id, url, name, description, rel) = ('http://www.duckduckgo.com', 'DuckDuckGo', NULL, NULL) WHERE link.id = 201; ` - testutils.AssertStatementSql(t, stmt, expectedSQL, "http://www.duckduckgo.com", "DuckDuckGo", nil, nil, int64(201)) + testutils.AssertDebugStatementSql(t, stmt, expectedSQL, "http://www.duckduckgo.com", "DuckDuckGo", nil, nil, int64(201)) assertExecErr(t, stmt, "pq: number of columns does not match number of values") } diff --git a/time_expression_test.go b/time_expression_test.go index 44d54ad..bcfb816 100644 --- a/time_expression_test.go +++ b/time_expression_test.go @@ -7,47 +7,47 @@ import ( var timeVar = Time(10, 20, 0, 0) func TestTimeExpressionEQ(t *testing.T) { - assertClauseSerialize(t, table1ColTime.EQ(table2ColTime), "(table1.col_time = table2.col_time)") - assertClauseSerialize(t, table1ColTime.EQ(timeVar), "(table1.col_time = $1::time without time zone)", "10:20:00.000") + assertPostgreClauseSerialize(t, table1ColTime.EQ(table2ColTime), "(table1.col_time = table2.col_time)") + assertPostgreClauseSerialize(t, table1ColTime.EQ(timeVar), "(table1.col_time = $1::time without time zone)", "10:20:00.000") } func TestTimeExpressionNOT_EQ(t *testing.T) { - assertClauseSerialize(t, table1ColTime.NOT_EQ(table2ColTime), "(table1.col_time != table2.col_time)") - assertClauseSerialize(t, table1ColTime.NOT_EQ(timeVar), "(table1.col_time != $1::time without time zone)", "10:20:00.000") + assertPostgreClauseSerialize(t, table1ColTime.NOT_EQ(table2ColTime), "(table1.col_time != table2.col_time)") + assertPostgreClauseSerialize(t, table1ColTime.NOT_EQ(timeVar), "(table1.col_time != $1::time without time zone)", "10:20:00.000") } func TestTimeExpressionIS_DISTINCT_FROM(t *testing.T) { - assertClauseSerialize(t, table1ColTime.IS_DISTINCT_FROM(table2ColTime), "(table1.col_time IS DISTINCT FROM table2.col_time)") - assertClauseSerialize(t, table1ColTime.IS_DISTINCT_FROM(timeVar), "(table1.col_time IS DISTINCT FROM $1::time without time zone)", "10:20:00.000") + assertPostgreClauseSerialize(t, table1ColTime.IS_DISTINCT_FROM(table2ColTime), "(table1.col_time IS DISTINCT FROM table2.col_time)") + assertPostgreClauseSerialize(t, table1ColTime.IS_DISTINCT_FROM(timeVar), "(table1.col_time IS DISTINCT FROM $1::time without time zone)", "10:20:00.000") } func TestTimeExpressionIS_NOT_DISTINCT_FROM(t *testing.T) { - assertClauseSerialize(t, table1ColTime.IS_NOT_DISTINCT_FROM(table2ColTime), "(table1.col_time IS NOT DISTINCT FROM table2.col_time)") - assertClauseSerialize(t, table1ColTime.IS_NOT_DISTINCT_FROM(timeVar), "(table1.col_time IS NOT DISTINCT FROM $1::time without time zone)", "10:20:00.000") + assertPostgreClauseSerialize(t, table1ColTime.IS_NOT_DISTINCT_FROM(table2ColTime), "(table1.col_time IS NOT DISTINCT FROM table2.col_time)") + assertPostgreClauseSerialize(t, table1ColTime.IS_NOT_DISTINCT_FROM(timeVar), "(table1.col_time IS NOT DISTINCT FROM $1::time without time zone)", "10:20:00.000") } func TestTimeExpressionLT(t *testing.T) { - assertClauseSerialize(t, table1ColTime.LT(table2ColTime), "(table1.col_time < table2.col_time)") - assertClauseSerialize(t, table1ColTime.LT(timeVar), "(table1.col_time < $1::time without time zone)", "10:20:00.000") + assertPostgreClauseSerialize(t, table1ColTime.LT(table2ColTime), "(table1.col_time < table2.col_time)") + assertPostgreClauseSerialize(t, table1ColTime.LT(timeVar), "(table1.col_time < $1::time without time zone)", "10:20:00.000") } func TestTimeExpressionLT_EQ(t *testing.T) { - assertClauseSerialize(t, table1ColTime.LT_EQ(table2ColTime), "(table1.col_time <= table2.col_time)") - assertClauseSerialize(t, table1ColTime.LT_EQ(timeVar), "(table1.col_time <= $1::time without time zone)", "10:20:00.000") + assertPostgreClauseSerialize(t, table1ColTime.LT_EQ(table2ColTime), "(table1.col_time <= table2.col_time)") + assertPostgreClauseSerialize(t, table1ColTime.LT_EQ(timeVar), "(table1.col_time <= $1::time without time zone)", "10:20:00.000") } func TestTimeExpressionGT(t *testing.T) { - assertClauseSerialize(t, table1ColTime.GT(table2ColTime), "(table1.col_time > table2.col_time)") - assertClauseSerialize(t, table1ColTime.GT(timeVar), "(table1.col_time > $1::time without time zone)", "10:20:00.000") + assertPostgreClauseSerialize(t, table1ColTime.GT(table2ColTime), "(table1.col_time > table2.col_time)") + assertPostgreClauseSerialize(t, table1ColTime.GT(timeVar), "(table1.col_time > $1::time without time zone)", "10:20:00.000") } func TestTimeExpressionGT_EQ(t *testing.T) { - assertClauseSerialize(t, table1ColTime.GT_EQ(table2ColTime), "(table1.col_time >= table2.col_time)") - assertClauseSerialize(t, table1ColTime.GT_EQ(timeVar), "(table1.col_time >= $1::time without time zone)", "10:20:00.000") + assertPostgreClauseSerialize(t, table1ColTime.GT_EQ(table2ColTime), "(table1.col_time >= table2.col_time)") + assertPostgreClauseSerialize(t, table1ColTime.GT_EQ(timeVar), "(table1.col_time >= $1::time without time zone)", "10:20:00.000") } func TestTimeExp(t *testing.T) { - assertClauseSerialize(t, TimeExp(table1ColFloat), "table1.col_float") - assertClauseSerialize(t, TimeExp(table1ColFloat).LT(Time(1, 1, 1, 1)), + assertPostgreClauseSerialize(t, TimeExp(table1ColFloat), "table1.col_float") + assertPostgreClauseSerialize(t, TimeExp(table1ColFloat).LT(Time(1, 1, 1, 1)), "(table1.col_float < $1::time without time zone)", string("01:01:01.001")) } diff --git a/timestamp_expression_test.go b/timestamp_expression_test.go index 1c44091..2754f9e 100644 --- a/timestamp_expression_test.go +++ b/timestamp_expression_test.go @@ -5,48 +5,48 @@ import "testing" var timestamp = Timestamp(2000, 1, 31, 10, 20, 0, 0) func TestTimestampExpressionEQ(t *testing.T) { - assertClauseSerialize(t, table1ColTimestamp.EQ(table2ColTimestamp), "(table1.col_timestamp = table2.col_timestamp)") - assertClauseSerialize(t, table1ColTimestamp.EQ(timestamp), + assertPostgreClauseSerialize(t, table1ColTimestamp.EQ(table2ColTimestamp), "(table1.col_timestamp = table2.col_timestamp)") + assertPostgreClauseSerialize(t, table1ColTimestamp.EQ(timestamp), "(table1.col_timestamp = $1::timestamp without time zone)", "2000-01-31 10:20:00.000") } func TestTimestampExpressionNOT_EQ(t *testing.T) { - assertClauseSerialize(t, table1ColTimestamp.NOT_EQ(table2ColTimestamp), "(table1.col_timestamp != table2.col_timestamp)") - assertClauseSerialize(t, table1ColTimestamp.NOT_EQ(timestamp), "(table1.col_timestamp != $1::timestamp without time zone)", "2000-01-31 10:20:00.000") + assertPostgreClauseSerialize(t, table1ColTimestamp.NOT_EQ(table2ColTimestamp), "(table1.col_timestamp != table2.col_timestamp)") + assertPostgreClauseSerialize(t, table1ColTimestamp.NOT_EQ(timestamp), "(table1.col_timestamp != $1::timestamp without time zone)", "2000-01-31 10:20:00.000") } func TestTimestampExpressionIS_DISTINCT_FROM(t *testing.T) { - assertClauseSerialize(t, table1ColTimestamp.IS_DISTINCT_FROM(table2ColTimestamp), "(table1.col_timestamp IS DISTINCT FROM table2.col_timestamp)") - assertClauseSerialize(t, table1ColTimestamp.IS_DISTINCT_FROM(timestamp), "(table1.col_timestamp IS DISTINCT FROM $1::timestamp without time zone)", "2000-01-31 10:20:00.000") + assertPostgreClauseSerialize(t, table1ColTimestamp.IS_DISTINCT_FROM(table2ColTimestamp), "(table1.col_timestamp IS DISTINCT FROM table2.col_timestamp)") + assertPostgreClauseSerialize(t, table1ColTimestamp.IS_DISTINCT_FROM(timestamp), "(table1.col_timestamp IS DISTINCT FROM $1::timestamp without time zone)", "2000-01-31 10:20:00.000") } func TestTimestampExpressionIS_NOT_DISTINCT_FROM(t *testing.T) { - assertClauseSerialize(t, table1ColTimestamp.IS_NOT_DISTINCT_FROM(table2ColTimestamp), "(table1.col_timestamp IS NOT DISTINCT FROM table2.col_timestamp)") - assertClauseSerialize(t, table1ColTimestamp.IS_NOT_DISTINCT_FROM(timestamp), "(table1.col_timestamp IS NOT DISTINCT FROM $1::timestamp without time zone)", "2000-01-31 10:20:00.000") + assertPostgreClauseSerialize(t, table1ColTimestamp.IS_NOT_DISTINCT_FROM(table2ColTimestamp), "(table1.col_timestamp IS NOT DISTINCT FROM table2.col_timestamp)") + assertPostgreClauseSerialize(t, table1ColTimestamp.IS_NOT_DISTINCT_FROM(timestamp), "(table1.col_timestamp IS NOT DISTINCT FROM $1::timestamp without time zone)", "2000-01-31 10:20:00.000") } func TestTimestampExpressionLT(t *testing.T) { - assertClauseSerialize(t, table1ColTimestamp.LT(table2ColTimestamp), "(table1.col_timestamp < table2.col_timestamp)") - assertClauseSerialize(t, table1ColTimestamp.LT(timestamp), "(table1.col_timestamp < $1::timestamp without time zone)", "2000-01-31 10:20:00.000") + assertPostgreClauseSerialize(t, table1ColTimestamp.LT(table2ColTimestamp), "(table1.col_timestamp < table2.col_timestamp)") + assertPostgreClauseSerialize(t, table1ColTimestamp.LT(timestamp), "(table1.col_timestamp < $1::timestamp without time zone)", "2000-01-31 10:20:00.000") } func TestTimestampExpressionLT_EQ(t *testing.T) { - assertClauseSerialize(t, table1ColTimestamp.LT_EQ(table2ColTimestamp), "(table1.col_timestamp <= table2.col_timestamp)") - assertClauseSerialize(t, table1ColTimestamp.LT_EQ(timestamp), "(table1.col_timestamp <= $1::timestamp without time zone)", "2000-01-31 10:20:00.000") + assertPostgreClauseSerialize(t, table1ColTimestamp.LT_EQ(table2ColTimestamp), "(table1.col_timestamp <= table2.col_timestamp)") + assertPostgreClauseSerialize(t, table1ColTimestamp.LT_EQ(timestamp), "(table1.col_timestamp <= $1::timestamp without time zone)", "2000-01-31 10:20:00.000") } func TestTimestampExpressionGT(t *testing.T) { - assertClauseSerialize(t, table1ColTimestamp.GT(table2ColTimestamp), "(table1.col_timestamp > table2.col_timestamp)") - assertClauseSerialize(t, table1ColTimestamp.GT(timestamp), "(table1.col_timestamp > $1::timestamp without time zone)", "2000-01-31 10:20:00.000") + assertPostgreClauseSerialize(t, table1ColTimestamp.GT(table2ColTimestamp), "(table1.col_timestamp > table2.col_timestamp)") + assertPostgreClauseSerialize(t, table1ColTimestamp.GT(timestamp), "(table1.col_timestamp > $1::timestamp without time zone)", "2000-01-31 10:20:00.000") } func TestTimestampExpressionGT_EQ(t *testing.T) { - assertClauseSerialize(t, table1ColTimestamp.GT_EQ(table2ColTimestamp), "(table1.col_timestamp >= table2.col_timestamp)") - assertClauseSerialize(t, table1ColTimestamp.GT_EQ(timestamp), "(table1.col_timestamp >= $1::timestamp without time zone)", "2000-01-31 10:20:00.000") + assertPostgreClauseSerialize(t, table1ColTimestamp.GT_EQ(table2ColTimestamp), "(table1.col_timestamp >= table2.col_timestamp)") + assertPostgreClauseSerialize(t, table1ColTimestamp.GT_EQ(timestamp), "(table1.col_timestamp >= $1::timestamp without time zone)", "2000-01-31 10:20:00.000") } func TestTimestampExp(t *testing.T) { - assertClauseSerialize(t, TimestampExp(table1ColFloat), "table1.col_float") - assertClauseSerialize(t, TimestampExp(table1ColFloat).LT(timestamp), + assertPostgreClauseSerialize(t, TimestampExp(table1ColFloat), "table1.col_float") + assertPostgreClauseSerialize(t, TimestampExp(table1ColFloat).LT(timestamp), "(table1.col_float < $1::timestamp without time zone)", "2000-01-31 10:20:00.000") } diff --git a/timestampz_expression_test.go b/timestampz_expression_test.go index 3451b3f..f2f814c 100644 --- a/timestampz_expression_test.go +++ b/timestampz_expression_test.go @@ -5,48 +5,48 @@ import "testing" var timestampz = Timestampz(2000, 1, 31, 10, 20, 0, 0, 2) func TestTimestampzExpressionEQ(t *testing.T) { - assertClauseSerialize(t, table1ColTimestampz.EQ(table2ColTimestampz), "(table1.col_timestampz = table2.col_timestampz)") - assertClauseSerialize(t, table1ColTimestampz.EQ(timestampz), + assertPostgreClauseSerialize(t, table1ColTimestampz.EQ(table2ColTimestampz), "(table1.col_timestampz = table2.col_timestampz)") + assertPostgreClauseSerialize(t, table1ColTimestampz.EQ(timestampz), "(table1.col_timestampz = $1::timestamp with time zone)", "2000-01-31 10:20:00.000 +002") } func TestTimestampzExpressionNOT_EQ(t *testing.T) { - assertClauseSerialize(t, table1ColTimestampz.NOT_EQ(table2ColTimestampz), "(table1.col_timestampz != table2.col_timestampz)") - assertClauseSerialize(t, table1ColTimestampz.NOT_EQ(timestampz), "(table1.col_timestampz != $1::timestamp with time zone)", "2000-01-31 10:20:00.000 +002") + assertPostgreClauseSerialize(t, table1ColTimestampz.NOT_EQ(table2ColTimestampz), "(table1.col_timestampz != table2.col_timestampz)") + assertPostgreClauseSerialize(t, table1ColTimestampz.NOT_EQ(timestampz), "(table1.col_timestampz != $1::timestamp with time zone)", "2000-01-31 10:20:00.000 +002") } func TestTimestampzExpressionIS_DISTINCT_FROM(t *testing.T) { - assertClauseSerialize(t, table1ColTimestampz.IS_DISTINCT_FROM(table2ColTimestampz), "(table1.col_timestampz IS DISTINCT FROM table2.col_timestampz)") - assertClauseSerialize(t, table1ColTimestampz.IS_DISTINCT_FROM(timestampz), "(table1.col_timestampz IS DISTINCT FROM $1::timestamp with time zone)", "2000-01-31 10:20:00.000 +002") + assertPostgreClauseSerialize(t, table1ColTimestampz.IS_DISTINCT_FROM(table2ColTimestampz), "(table1.col_timestampz IS DISTINCT FROM table2.col_timestampz)") + assertPostgreClauseSerialize(t, table1ColTimestampz.IS_DISTINCT_FROM(timestampz), "(table1.col_timestampz IS DISTINCT FROM $1::timestamp with time zone)", "2000-01-31 10:20:00.000 +002") } func TestTimestampzExpressionIS_NOT_DISTINCT_FROM(t *testing.T) { - assertClauseSerialize(t, table1ColTimestampz.IS_NOT_DISTINCT_FROM(table2ColTimestampz), "(table1.col_timestampz IS NOT DISTINCT FROM table2.col_timestampz)") - assertClauseSerialize(t, table1ColTimestampz.IS_NOT_DISTINCT_FROM(timestampz), "(table1.col_timestampz IS NOT DISTINCT FROM $1::timestamp with time zone)", "2000-01-31 10:20:00.000 +002") + assertPostgreClauseSerialize(t, table1ColTimestampz.IS_NOT_DISTINCT_FROM(table2ColTimestampz), "(table1.col_timestampz IS NOT DISTINCT FROM table2.col_timestampz)") + assertPostgreClauseSerialize(t, table1ColTimestampz.IS_NOT_DISTINCT_FROM(timestampz), "(table1.col_timestampz IS NOT DISTINCT FROM $1::timestamp with time zone)", "2000-01-31 10:20:00.000 +002") } func TestTimestampzExpressionLT(t *testing.T) { - assertClauseSerialize(t, table1ColTimestampz.LT(table2ColTimestampz), "(table1.col_timestampz < table2.col_timestampz)") - assertClauseSerialize(t, table1ColTimestampz.LT(timestampz), "(table1.col_timestampz < $1::timestamp with time zone)", "2000-01-31 10:20:00.000 +002") + assertPostgreClauseSerialize(t, table1ColTimestampz.LT(table2ColTimestampz), "(table1.col_timestampz < table2.col_timestampz)") + assertPostgreClauseSerialize(t, table1ColTimestampz.LT(timestampz), "(table1.col_timestampz < $1::timestamp with time zone)", "2000-01-31 10:20:00.000 +002") } func TestTimestampzExpressionLT_EQ(t *testing.T) { - assertClauseSerialize(t, table1ColTimestampz.LT_EQ(table2ColTimestampz), "(table1.col_timestampz <= table2.col_timestampz)") - assertClauseSerialize(t, table1ColTimestampz.LT_EQ(timestampz), "(table1.col_timestampz <= $1::timestamp with time zone)", "2000-01-31 10:20:00.000 +002") + assertPostgreClauseSerialize(t, table1ColTimestampz.LT_EQ(table2ColTimestampz), "(table1.col_timestampz <= table2.col_timestampz)") + assertPostgreClauseSerialize(t, table1ColTimestampz.LT_EQ(timestampz), "(table1.col_timestampz <= $1::timestamp with time zone)", "2000-01-31 10:20:00.000 +002") } func TestTimestampzExpressionGT(t *testing.T) { - assertClauseSerialize(t, table1ColTimestampz.GT(table2ColTimestampz), "(table1.col_timestampz > table2.col_timestampz)") - assertClauseSerialize(t, table1ColTimestampz.GT(timestampz), "(table1.col_timestampz > $1::timestamp with time zone)", "2000-01-31 10:20:00.000 +002") + assertPostgreClauseSerialize(t, table1ColTimestampz.GT(table2ColTimestampz), "(table1.col_timestampz > table2.col_timestampz)") + assertPostgreClauseSerialize(t, table1ColTimestampz.GT(timestampz), "(table1.col_timestampz > $1::timestamp with time zone)", "2000-01-31 10:20:00.000 +002") } func TestTimestampzExpressionGT_EQ(t *testing.T) { - assertClauseSerialize(t, table1ColTimestampz.GT_EQ(table2ColTimestampz), "(table1.col_timestampz >= table2.col_timestampz)") - assertClauseSerialize(t, table1ColTimestampz.GT_EQ(timestampz), "(table1.col_timestampz >= $1::timestamp with time zone)", "2000-01-31 10:20:00.000 +002") + assertPostgreClauseSerialize(t, table1ColTimestampz.GT_EQ(table2ColTimestampz), "(table1.col_timestampz >= table2.col_timestampz)") + assertPostgreClauseSerialize(t, table1ColTimestampz.GT_EQ(timestampz), "(table1.col_timestampz >= $1::timestamp with time zone)", "2000-01-31 10:20:00.000 +002") } func TestTimestampzExp(t *testing.T) { - assertClauseSerialize(t, TimestampzExp(table1ColFloat), "table1.col_float") - assertClauseSerialize(t, TimestampzExp(table1ColFloat).LT(timestampz), + assertPostgreClauseSerialize(t, TimestampzExp(table1ColFloat), "table1.col_float") + assertPostgreClauseSerialize(t, TimestampzExp(table1ColFloat).LT(timestampz), "(table1.col_float < $1::timestamp with time zone)", "2000-01-31 10:20:00.000 +002") } diff --git a/timez_expression_test.go b/timez_expression_test.go index 1d2c641..df553e6 100644 --- a/timez_expression_test.go +++ b/timez_expression_test.go @@ -5,47 +5,47 @@ import "testing" var timezVar = Timez(10, 20, 0, 0, 4) func TestTimezExpressionEQ(t *testing.T) { - assertClauseSerialize(t, table1ColTimez.EQ(table2ColTimez), "(table1.col_timez = table2.col_timez)") - assertClauseSerialize(t, table1ColTimez.EQ(timezVar), "(table1.col_timez = $1::time with time zone)", "10:20:00.000 +04") + assertPostgreClauseSerialize(t, table1ColTimez.EQ(table2ColTimez), "(table1.col_timez = table2.col_timez)") + assertPostgreClauseSerialize(t, table1ColTimez.EQ(timezVar), "(table1.col_timez = $1::time with time zone)", "10:20:00.000 +04") } func TestTimezExpressionNOT_EQ(t *testing.T) { - assertClauseSerialize(t, table1ColTimez.NOT_EQ(table2ColTimez), "(table1.col_timez != table2.col_timez)") - assertClauseSerialize(t, table1ColTimez.NOT_EQ(timezVar), "(table1.col_timez != $1::time with time zone)", "10:20:00.000 +04") + assertPostgreClauseSerialize(t, table1ColTimez.NOT_EQ(table2ColTimez), "(table1.col_timez != table2.col_timez)") + assertPostgreClauseSerialize(t, table1ColTimez.NOT_EQ(timezVar), "(table1.col_timez != $1::time with time zone)", "10:20:00.000 +04") } func TestTimezExpressionIS_DISTINCT_FROM(t *testing.T) { - assertClauseSerialize(t, table1ColTimez.IS_DISTINCT_FROM(table2ColTimez), "(table1.col_timez IS DISTINCT FROM table2.col_timez)") - assertClauseSerialize(t, table1ColTimez.IS_DISTINCT_FROM(timezVar), "(table1.col_timez IS DISTINCT FROM $1::time with time zone)", "10:20:00.000 +04") + assertPostgreClauseSerialize(t, table1ColTimez.IS_DISTINCT_FROM(table2ColTimez), "(table1.col_timez IS DISTINCT FROM table2.col_timez)") + assertPostgreClauseSerialize(t, table1ColTimez.IS_DISTINCT_FROM(timezVar), "(table1.col_timez IS DISTINCT FROM $1::time with time zone)", "10:20:00.000 +04") } func TestTimezExpressionIS_NOT_DISTINCT_FROM(t *testing.T) { - assertClauseSerialize(t, table1ColTimez.IS_NOT_DISTINCT_FROM(table2ColTimez), "(table1.col_timez IS NOT DISTINCT FROM table2.col_timez)") - assertClauseSerialize(t, table1ColTimez.IS_NOT_DISTINCT_FROM(timezVar), "(table1.col_timez IS NOT DISTINCT FROM $1::time with time zone)", "10:20:00.000 +04") + assertPostgreClauseSerialize(t, table1ColTimez.IS_NOT_DISTINCT_FROM(table2ColTimez), "(table1.col_timez IS NOT DISTINCT FROM table2.col_timez)") + assertPostgreClauseSerialize(t, table1ColTimez.IS_NOT_DISTINCT_FROM(timezVar), "(table1.col_timez IS NOT DISTINCT FROM $1::time with time zone)", "10:20:00.000 +04") } func TestTimezExpressionLT(t *testing.T) { - assertClauseSerialize(t, table1ColTimez.LT(table2ColTimez), "(table1.col_timez < table2.col_timez)") - assertClauseSerialize(t, table1ColTimez.LT(timezVar), "(table1.col_timez < $1::time with time zone)", "10:20:00.000 +04") + assertPostgreClauseSerialize(t, table1ColTimez.LT(table2ColTimez), "(table1.col_timez < table2.col_timez)") + assertPostgreClauseSerialize(t, table1ColTimez.LT(timezVar), "(table1.col_timez < $1::time with time zone)", "10:20:00.000 +04") } func TestTimezExpressionLT_EQ(t *testing.T) { - assertClauseSerialize(t, table1ColTimez.LT_EQ(table2ColTimez), "(table1.col_timez <= table2.col_timez)") - assertClauseSerialize(t, table1ColTimez.LT_EQ(timezVar), "(table1.col_timez <= $1::time with time zone)", "10:20:00.000 +04") + assertPostgreClauseSerialize(t, table1ColTimez.LT_EQ(table2ColTimez), "(table1.col_timez <= table2.col_timez)") + assertPostgreClauseSerialize(t, table1ColTimez.LT_EQ(timezVar), "(table1.col_timez <= $1::time with time zone)", "10:20:00.000 +04") } func TestTimezExpressionGT(t *testing.T) { - assertClauseSerialize(t, table1ColTimez.GT(table2ColTimez), "(table1.col_timez > table2.col_timez)") - assertClauseSerialize(t, table1ColTimez.GT(timezVar), "(table1.col_timez > $1::time with time zone)", "10:20:00.000 +04") + assertPostgreClauseSerialize(t, table1ColTimez.GT(table2ColTimez), "(table1.col_timez > table2.col_timez)") + assertPostgreClauseSerialize(t, table1ColTimez.GT(timezVar), "(table1.col_timez > $1::time with time zone)", "10:20:00.000 +04") } func TestTimezExpressionGT_EQ(t *testing.T) { - assertClauseSerialize(t, table1ColTimez.GT_EQ(table2ColTimez), "(table1.col_timez >= table2.col_timez)") - assertClauseSerialize(t, table1ColTimez.GT_EQ(timezVar), "(table1.col_timez >= $1::time with time zone)", "10:20:00.000 +04") + assertPostgreClauseSerialize(t, table1ColTimez.GT_EQ(table2ColTimez), "(table1.col_timez >= table2.col_timez)") + assertPostgreClauseSerialize(t, table1ColTimez.GT_EQ(timezVar), "(table1.col_timez >= $1::time with time zone)", "10:20:00.000 +04") } func TestTimezExp(t *testing.T) { - assertClauseSerialize(t, TimezExp(table1ColFloat), "table1.col_float") - assertClauseSerialize(t, TimezExp(table1ColFloat).LT(Timez(1, 1, 1, 1, 4)), + assertPostgreClauseSerialize(t, TimezExp(table1ColFloat), "table1.col_float") + assertPostgreClauseSerialize(t, TimezExp(table1ColFloat).LT(Timez(1, 1, 1, 1, 4)), "(table1.col_float < $1::time with time zone)", string("01:01:01.001 +04")) } diff --git a/utils_test.go b/utils_test.go index f37b833..c1ee1f1 100644 --- a/utils_test.go +++ b/utils_test.go @@ -72,7 +72,7 @@ var table3 = NewTable( table3ColInt, table3StrCol) -func assertClauseSerialize(t *testing.T, clause clause, query string, args ...interface{}) { +func assertPostgreClauseSerialize(t *testing.T, clause clause, query string, args ...interface{}) { out := sqlBuilder{dialect: PostgreSQL} err := clause.serialize(selectStatement, &out) @@ -82,6 +82,16 @@ func assertClauseSerialize(t *testing.T, clause clause, query string, args ...in assert.DeepEqual(t, out.args, args) } +func assertMySQLClauseSerialize(t *testing.T, clause clause, query string, args ...interface{}) { + out := sqlBuilder{dialect: MySQL} + err := clause.serialize(selectStatement, &out) + + assert.NilError(t, err) + + assert.DeepEqual(t, out.buff.String(), query) + assert.DeepEqual(t, out.args, args) +} + func assertClauseSerializeErr(t *testing.T, clause clause, errString string) { out := sqlBuilder{dialect: PostgreSQL} err := clause.serialize(selectStatement, &out)