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

Row and Array Comparisons (IN, NOT_IN).

Browse source
This commit is contained in:
zer0sub 2019-06-04 11:52:37 +02:00
parent d69c67569a
commit 384c0c67f5
19 changed files with 170 additions and 231 deletions
Download patch file Download diff file Expand all files Collapse all files

161
sqlbuilder/bool_expression_test.go
View file

@ -1,8 +1,6 @@
package sqlbuilder
import (
"fmt"
"gotest.tools/assert"
"testing"
)
@ -18,6 +16,10 @@ func TestBoolExpressionNOT_EQ(t *testing.T) {
func TestBoolExpressionIS_TRUE(t *testing.T) {
assertExpressionSerialize(t, table1ColBool.IS_TRUE(), "table1.colBool IS TRUE")
assertExpressionSerialize(t, (Int(2).EQ(table1ColInt)).IS_TRUE(),
`($1 = table1.colInt) IS TRUE`, int64(2))
assertExpressionSerialize(t, (Int(2).EQ(table1ColInt)).IS_TRUE().AND(Int(4).EQ(table2ColInt)),
`(($1 = table1.colInt) IS TRUE AND ($2 = table2.colInt))`, int64(2), int64(4))
}
func TestBoolExpressionIS_NOT_TRUE(t *testing.T) {
@ -40,155 +42,32 @@ func TestBoolExpressionIS_NOT_UNKNOWN(t *testing.T) {
assertExpressionSerialize(t, table1ColBool.IS_NOT_UNKNOWN(), "table1.colBool IS NOT UNKNOWN")
}
func TestBinaryExpression(t *testing.T) {
boolExpression := EQ(Literal(2), Literal(3))
func TestBinaryBoolExpression(t *testing.T) {
boolExpression := Int(2).EQ(Int(3))
out := queryData{}
err := boolExpression.serialize(select_statement, &out)
assert.NilError(t, err)
assert.Equal(t, out.buff.String(), "($1 = $2)")
assert.Equal(t, len(out.args), 2)
t.Run("alias", func(t *testing.T) {
alias := boolExpression.AS("alias_eq_expression")
out := queryData{}
err := alias.serializeForProjection(select_statement, &out)
assert.NilError(t, err)
assert.Equal(t, out.buff.String(), `$1 = $2 AS "alias_eq_expression"`)
})
t.Run("and", func(t *testing.T) {
exp := boolExpression.AND(EQ(Literal(4), Literal(5)))
out := queryData{}
err := exp.serialize(select_statement, &out)
assert.NilError(t, err)
assert.Equal(t, out.buff.String(), `(($1 = $2) AND ($3 = $4))`)
})
t.Run("or", func(t *testing.T) {
exp := boolExpression.OR(EQ(Literal(4), Literal(5)))
out := queryData{}
err := exp.serialize(select_statement, &out)
assert.NilError(t, err)
assert.Equal(t, out.buff.String(), `(($1 = $2) OR ($3 = $4))`)
})
assertExpressionSerialize(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))
assertExpressionSerialize(t, boolExpression.AND(Int(4).EQ(Int(5))),
"(($1 = $2) AND ($3 = $4))", int64(2), int64(3), int64(4), int64(5))
assertExpressionSerialize(t, boolExpression.OR(Int(4).EQ(Int(5))),
"(($1 = $2) OR ($3 = $4))", int64(2), int64(3), int64(4), int64(5))
}
func TestUnaryExpression(t *testing.T) {
notExpression := NOT(EQ(Literal(2), Literal(1)))
out := queryData{}
err := notExpression.serialize(select_statement, &out)
assert.NilError(t, err)
assert.Equal(t, out.buff.String(), "NOT ($1 = $2)")
t.Run("alias", func(t *testing.T) {
alias := notExpression.AS("alias_not_expression")
out := queryData{}
err := alias.serializeForProjection(select_statement, &out)
assert.NilError(t, err)
assert.Equal(t, out.buff.String(), `NOT ($1 = $2) AS "alias_not_expression"`)
})
t.Run("and", func(t *testing.T) {
exp := notExpression.AND(EQ(Literal(4), Literal(5)))
out := queryData{}
err := exp.serialize(select_statement, &out)
assert.NilError(t, err)
assert.Equal(t, out.buff.String(), `(NOT ($1 = $2) AND ($3 = $4))`)
})
}
func TestUnaryIsTrueExpression(t *testing.T) {
exp := IS_TRUE(EQ(Literal(2), Literal(1)))
out := queryData{}
err := exp.serialize(select_statement, &out)
assert.NilError(t, err)
assert.Equal(t, out.buff.String(), "($1 = $2) IS TRUE")
t.Run("and", func(t *testing.T) {
exp := exp.AND(EQ(Literal(4), Literal(5)))
out := queryData{}
err := exp.serialize(select_statement, &out)
assert.NilError(t, err)
assert.Equal(t, out.buff.String(), `(($1 = $2) IS TRUE AND ($3 = $4))`)
})
}
func TestBoolLiteral(t *testing.T) {
literal := Bool(true)
out := queryData{}
err := literal.serialize(select_statement, &out)
assert.NilError(t, err)
assert.Equal(t, out.buff.String(), "$1")
assertExpressionSerialize(t, Bool(true), "$1", true)
assertExpressionSerialize(t, Bool(false), "$1", false)
}
func TestExists(t *testing.T) {
query := EXISTS(
assertExpressionSerialize(t, EXISTS(
table2.
SELECT(Literal(1)).
SELECT(Int(1)).
WHERE(table1Col1.EQ(table2Col3)),
)
out := queryData{}
err := query.serialize(select_statement, &out)
fmt.Println(out.buff.String())
assert.NilError(t, err)
expectedSql :=
),
`EXISTS (
SELECT $1
FROM db.table2
WHERE table1.col1 = table2.col3
)`
assert.Equal(t, out.buff.String(), expectedSql)
}
func TestIn(t *testing.T) {
query := Literal(1.11).IN(table1.SELECT(table1Col1))
out := queryData{}
err := query.serialize(select_statement, &out, NO_WRAP)
assert.NilError(t, err)
fmt.Println(out.buff.String())
assert.Equal(t, out.buff.String(), `$1 IN (
SELECT table1.col1 AS "table1.col1"
FROM db.table1
)`)
query2 := ROW(Literal(12), table1Col1).IN(table2.SELECT(table2Col3, table3Col1))
out = queryData{}
err = query2.serialize(select_statement, &out)
assert.NilError(t, err)
fmt.Println(out.buff.String())
assert.Equal(t, out.buff.String(), `(ROW($1, table1.col1) IN (
SELECT table2.col3 AS "table2.col3",
table3.col1 AS "table3.col1"
FROM db.table2
))`)
)`, int64(1))
}