func (me *crudExecTest) TestScanVals() {
t := me.T()
mDb, err := sqlmock.New()
assert.NoError(t, err)
sqlmock.ExpectQuery(`SELECT "id" FROM "items"`).
WillReturnError(fmt.Errorf("query error"))
sqlmock.ExpectQuery(`SELECT "id" FROM "items"`).
WithArgs().
WillReturnRows(sqlmock.NewRows([]string{"id"}).FromCSVString("1\n2"))
sqlmock.ExpectQuery(`SELECT "id" FROM "items"`).
WithArgs().
WillReturnRows(sqlmock.NewRows([]string{"id"}).FromCSVString("1\n2"))
db := New("db-mock", mDb)
exec := newCrudExec(db, nil, `SELECT "id" FROM "items"`)
var id int64
var ids []int64
assert.EqualError(t, exec.ScanVals(ids), "goqu: Type must be a pointer to a slice when calling ScanVals")
assert.EqualError(t, exec.ScanVals(&id), "goqu: Type must be a pointer to a slice when calling ScanVals")
assert.EqualError(t, exec.ScanVals(&ids), "query error")
assert.NoError(t, exec.ScanVals(&ids))
assert.Equal(t, ids, []int64{1, 2})
var pointers []*int64
assert.NoError(t, exec.ScanVals(&pointers))
assert.Len(t, pointers, 2)
assert.Equal(t, *pointers[0], 1)
assert.Equal(t, *pointers[1], 2)
}
func (me *datasetTest) TestInsertSqlWithMaps() {
t := me.T()
ds1 := From("items")
sql, _, err := ds1.ToInsertSql(map[string]interface{}{"name": "Test", "address": "111 Test Addr"})
assert.NoError(t, err)
assert.Equal(t, sql, `INSERT INTO "items" ("address", "name") VALUES ('111 Test Addr', 'Test')`)
sql, _, err = ds1.ToInsertSql(
map[string]interface{}{"address": "111 Test Addr", "name": "Test1"},
map[string]interface{}{"address": "211 Test Addr", "name": "Test2"},
map[string]interface{}{"address": "311 Test Addr", "name": "Test3"},
map[string]interface{}{"address": "411 Test Addr", "name": "Test4"},
)
assert.NoError(t, err)
assert.Equal(t, sql, `INSERT INTO "items" ("address", "name") VALUES ('111 Test Addr', 'Test1'), ('211 Test Addr', 'Test2'), ('311 Test Addr', 'Test3'), ('411 Test Addr', 'Test4')`)
_, _, err = ds1.ToInsertSql(
map[string]interface{}{"address": "111 Test Addr", "name": "Test1"},
map[string]interface{}{"address": "211 Test Addr"},
map[string]interface{}{"address": "311 Test Addr", "name": "Test3"},
map[string]interface{}{"address": "411 Test Addr", "name": "Test4"},
)
assert.EqualError(t, err, "goqu: Rows with different value length expected 2 got 1")
}
func (me *databaseTest) TestScanStructs() {
t := me.T()
mDb, err := sqlmock.New()
assert.NoError(t, err)
sqlmock.ExpectQuery(`SELECT \* FROM "items"`).
WithArgs().
WillReturnRows(sqlmock.NewRows([]string{"address", "name"}).FromCSVString("111 Test Addr,Test1\n211 Test Addr,Test2"))
sqlmock.ExpectQuery(`SELECT "test" FROM "items"`).
WithArgs().
WillReturnRows(sqlmock.NewRows([]string{"test"}).FromCSVString("test1\ntest2"))
db := New("db-mock", mDb)
var items []testActionItem
assert.NoError(t, db.ScanStructs(&items, `SELECT * FROM "items"`))
assert.Len(t, items, 2)
assert.Equal(t, items[0].Address, "111 Test Addr")
assert.Equal(t, items[0].Name, "Test1")
assert.Equal(t, items[1].Address, "211 Test Addr")
assert.Equal(t, items[1].Name, "Test2")
items = items[0:0]
assert.EqualError(t, db.ScanStructs(items, `SELECT * FROM "items"`), "goqu: Type must be a pointer to a slice when calling ScanStructs")
assert.EqualError(t, db.ScanStructs(&testActionItem{}, `SELECT * FROM "items"`), "goqu: Type must be a pointer to a slice when calling ScanStructs")
assert.EqualError(t, db.ScanStructs(&items, `SELECT "test" FROM "items"`), `goqu: Unable to find corresponding field to column "test" returned by query`)
}
func (me *postgresTest) TestDelete() {
t := me.T()
ds := me.db.From("entry")
var e entry
found, err := ds.Where(goqu.I("int").Eq(9)).Select("id").ScanStruct(&e)
assert.NoError(t, err)
assert.True(t, found)
_, err = ds.Where(goqu.I("id").Eq(e.Id)).Delete().Exec()
assert.NoError(t, err)
count, err := ds.Count()
assert.NoError(t, err)
assert.Equal(t, count, 9)
var id uint32
found, err = ds.Where(goqu.I("id").Eq(e.Id)).ScanVal(&id)
assert.NoError(t, err)
assert.False(t, found)
e = entry{}
found, err = ds.Where(goqu.I("int").Eq(8)).Select("id").ScanStruct(&e)
assert.NoError(t, err)
assert.True(t, found)
assert.NotEqual(t, e.Id, 0)
id = 0
_, err = ds.Where(goqu.I("id").Eq(e.Id)).Returning("id").Delete().ScanVal(&id)
assert.NoError(t, err)
assert.Equal(t, id, e.Id)
}
func (me *datasetTest) TestScanStructs_WithPreparedStatements() {
t := me.T()
mDb, err := sqlmock.New()
assert.NoError(t, err)
sqlmock.ExpectQuery(`SELECT "address", "name" FROM "items" WHERE \(\("address" = \?\) AND \("name" IN \(\?, \?, \?\)\)\)`).
WithArgs("111 Test Addr", "Bob", "Sally", "Billy").
WillReturnRows(sqlmock.NewRows([]string{"address", "name"}).FromCSVString("111 Test Addr,Test1\n211 Test Addr,Test2"))
sqlmock.ExpectQuery(`SELECT "test" FROM "items" WHERE \(\("address" = \?\) AND \("name" IN \(\?, \?, \?\)\)\)`).
WithArgs("111 Test Addr", "Bob", "Sally", "Billy").
WillReturnRows(sqlmock.NewRows([]string{"test"}).FromCSVString("test1\ntest2"))
db := New("mock", mDb)
var items []dsTestActionItem
assert.NoError(t, db.From("items").Prepared(true).Where(Ex{"name": []string{"Bob", "Sally", "Billy"}, "address": "111 Test Addr"}).ScanStructs(&items))
assert.Len(t, items, 2)
assert.Equal(t, items[0].Address, "111 Test Addr")
assert.Equal(t, items[0].Name, "Test1")
assert.Equal(t, items[1].Address, "211 Test Addr")
assert.Equal(t, items[1].Name, "Test2")
items = items[0:0]
assert.EqualError(t, db.From("items").ScanStructs(items), "goqu: Type must be a pointer to a slice when calling ScanStructs")
assert.EqualError(t, db.From("items").ScanStructs(&dsTestActionItem{}), "goqu: Type must be a pointer to a slice when calling ScanStructs")
assert.EqualError(t, db.From("items").
Prepared(true).
Select("test").
Where(Ex{"name": []string{"Bob", "Sally", "Billy"}, "address": "111 Test Addr"}).
ScanStructs(&items), `goqu: Unable to find corresponding field to column "test" returned by query`)
}
func (me *datasetTest) TestJoin() {
t := me.T()
ds1 := From("items")
sql, _, err := ds1.Join(I("players").As("p"), On(Ex{"p.id": I("items.playerId")})).ToSql()
assert.NoError(t, err)
assert.Equal(t, sql, `SELECT * FROM "items" INNER JOIN "players" AS "p" ON ("p"."id" = "items"."playerId")`)
sql, _, err = ds1.Join(ds1.From("players").As("p"), On(Ex{"p.id": I("items.playerId")})).ToSql()
assert.NoError(t, err)
assert.Equal(t, sql, `SELECT * FROM "items" INNER JOIN (SELECT * FROM "players") AS "p" ON ("p"."id" = "items"."playerId")`)
sql, _, err = ds1.Join(I("v1").Table("test"), On(Ex{"v1.test.id": I("items.playerId")})).ToSql()
assert.NoError(t, err)
assert.Equal(t, sql, `SELECT * FROM "items" INNER JOIN "v1"."test" ON ("v1"."test"."id" = "items"."playerId")`)
sql, _, err = ds1.Join(I("test"), Using(I("name"), I("common_id"))).ToSql()
assert.NoError(t, err)
assert.Equal(t, sql, `SELECT * FROM "items" INNER JOIN "test" USING ("name", "common_id")`)
sql, _, err = ds1.Join(I("test"), Using("name", "common_id")).ToSql()
assert.NoError(t, err)
assert.Equal(t, sql, `SELECT * FROM "items" INNER JOIN "test" USING ("name", "common_id")`)
}
func (me *mysqlTest) TestDelete() {
t := me.T()
ds := me.db.From("entry")
var e entry
found, err := ds.Where(goqu.I("int").Eq(9)).Select("id").ScanStruct(&e)
assert.NoError(t, err)
assert.True(t, found)
_, err = ds.Where(goqu.I("id").Eq(e.Id)).Delete().Exec()
assert.NoError(t, err)
count, err := ds.Count()
assert.NoError(t, err)
assert.Equal(t, count, 9)
var id uint32
found, err = ds.Where(goqu.I("id").Eq(e.Id)).ScanVal(&id)
assert.NoError(t, err)
assert.False(t, found)
e = entry{}
found, err = ds.Where(goqu.I("int").Eq(8)).Select("id").ScanStruct(&e)
assert.NoError(t, err)
assert.True(t, found)
assert.NotEqual(t, e.Id, 0)
id = 0
_, err = ds.Where(goqu.I("id").Eq(e.Id)).Returning("id").Delete().ScanVal(&id)
assert.Equal(t, err.Error(), "goqu: Adapter does not support RETURNING clause")
}
func (me *datasetTest) TestPreparedWhere() {
t := me.T()
ds1 := From("test")
b := ds1.Where(Ex{
"a": true,
"b": Op{"neq": true},
"c": false,
"d": Op{"neq": false},
})
sql, args, err := b.Prepared(true).ToSql()
assert.NoError(t, err)
assert.Equal(t, args, []interface{}{})
assert.Equal(t, sql, `SELECT * FROM "test" WHERE (("a" IS TRUE) AND ("b" IS NOT TRUE) AND ("c" IS FALSE) AND ("d" IS NOT FALSE))`)
b = ds1.Where(Ex{
"a": "a",
"b": Op{"neq": "b"},
"c": Op{"gt": "c"},
"d": Op{"gte": "d"},
"e": Op{"lt": "e"},
"f": Op{"lte": "f"},
})
sql, args, err = b.Prepared(true).ToSql()
assert.NoError(t, err)
assert.Equal(t, args, []interface{}{"a", "b", "c", "d", "e", "f"})
assert.Equal(t, sql, `SELECT * FROM "test" WHERE (("a" = ?) AND ("b" != ?) AND ("c" > ?) AND ("d" >= ?) AND ("e" < ?) AND ("f" <= ?))`)
}
func (me *datasetTest) TestGroupBy() {
t := me.T()
ds1 := From("test")
b := ds1.Where(
I("a").Gt(1),
).GroupBy("created")
sql, _, err := b.ToSql()
assert.NoError(t, err)
assert.Equal(t, sql, `SELECT * FROM "test" WHERE ("a" > 1) GROUP BY "created"`)
b = ds1.Where(
I("a").Gt(1),
).GroupBy(Literal("created::DATE"))
sql, _, err = b.ToSql()
assert.NoError(t, err)
assert.Equal(t, sql, `SELECT * FROM "test" WHERE ("a" > 1) GROUP BY created::DATE`)
b = ds1.Where(
I("a").Gt(1),
).GroupBy("name", Literal("created::DATE"))
sql, _, err = b.ToSql()
assert.NoError(t, err)
assert.Equal(t, sql, `SELECT * FROM "test" WHERE ("a" > 1) GROUP BY "name", created::DATE`)
}
func (me *datasetTest) TestHaving() {
t := me.T()
ds1 := From("test")
b := ds1.Having(Ex{
"a": Op{"gt": 1},
}).GroupBy("created")
sql, _, err := b.ToSql()
assert.NoError(t, err)
assert.Equal(t, sql, `SELECT * FROM "test" GROUP BY "created" HAVING ("a" > 1)`)
b = ds1.Where(Ex{"b": true}).
Having(Ex{"a": Op{"gt": 1}}).
GroupBy("created")
sql, _, err = b.ToSql()
assert.NoError(t, err)
assert.Equal(t, sql, `SELECT * FROM "test" WHERE ("b" IS TRUE) GROUP BY "created" HAVING ("a" > 1)`)
b = ds1.Having(Ex{"a": Op{"gt": 1}})
sql, _, err = b.ToSql()
assert.NoError(t, err)
assert.Equal(t, sql, `SELECT * FROM "test" HAVING ("a" > 1)`)
b = ds1.Having(Ex{"a": Op{"gt": 1}}).Having(Ex{"b": 2})
sql, _, err = b.ToSql()
assert.NoError(t, err)
assert.Equal(t, sql, `SELECT * FROM "test" HAVING (("a" > 1) AND ("b" = 2))`)
}
func (me *databaseTest) TestScanStruct() {
t := me.T()
mDb, err := sqlmock.New()
assert.NoError(t, err)
sqlmock.ExpectQuery(`SELECT \* FROM "items" LIMIT 1`).
WithArgs().
WillReturnRows(sqlmock.NewRows([]string{"address", "name"}).FromCSVString("111 Test Addr,Test1"))
sqlmock.ExpectQuery(`SELECT "test" FROM "items" LIMIT 1`).
WithArgs().
WillReturnRows(sqlmock.NewRows([]string{"test"}).FromCSVString("test1\ntest2"))
db := New("mock", mDb)
var item testActionItem
found, err := db.ScanStruct(&item, `SELECT * FROM "items" LIMIT 1`)
assert.NoError(t, err)
assert.True(t, found)
assert.Equal(t, item.Address, "111 Test Addr")
assert.Equal(t, item.Name, "Test1")
_, err = db.ScanStruct(item, `SELECT * FROM "items" LIMIT 1`)
assert.EqualError(t, err, "goqu: Type must be a pointer to a struct when calling ScanStruct")
_, err = db.ScanStruct([]testActionItem{}, `SELECT * FROM "items" LIMIT 1`)
assert.EqualError(t, err, "goqu: Type must be a pointer to a struct when calling ScanStruct")
_, err = db.ScanStruct(&item, `SELECT "test" FROM "items" LIMIT 1`)
assert.EqualError(t, err, `goqu: Unable to find corresponding field to column "test" returned by query`)
}
func (me *datasetTest) TestInsertWithGoquPkTagSql() {
t := me.T()
ds1 := From("items")
type item struct {
Id uint32 `db:"id" goqu:"pk,skipinsert"`
Address string `db:"address"`
Name string `db:"name"`
}
sql, _, err := ds1.ToInsertSql(item{Name: "Test", Address: "111 Test Addr"})
assert.NoError(t, err)
assert.Equal(t, sql, `INSERT INTO "items" ("address", "name") VALUES ('111 Test Addr', 'Test')`)
sql, _, err = ds1.ToInsertSql(map[string]interface{}{"name": "Test", "address": "111 Test Addr"})
assert.NoError(t, err)
assert.Equal(t, sql, `INSERT INTO "items" ("address", "name") VALUES ('111 Test Addr', 'Test')`)
sql, _, err = ds1.ToInsertSql(
item{Name: "Test1", Address: "111 Test Addr"},
item{Name: "Test2", Address: "211 Test Addr"},
item{Name: "Test3", Address: "311 Test Addr"},
item{Name: "Test4", Address: "411 Test Addr"},
)
assert.NoError(t, err)
assert.Equal(t, sql, `INSERT INTO "items" ("address", "name") VALUES ('111 Test Addr', 'Test1'), ('211 Test Addr', 'Test2'), ('311 Test Addr', 'Test3'), ('411 Test Addr', 'Test4')`)
}
func (me *datasetTest) TestPreparedTruncateSql() {
t := me.T()
ds1 := From("items")
sql, args, err := ds1.ToTruncateSql()
assert.NoError(t, err)
assert.Equal(t, args, []interface{}{})
assert.Equal(t, sql, `TRUNCATE "items"`)
}
func (me *datasetTest) TestPreparedFunctionExpressionsInHaving() {
t := me.T()
ds1 := From("items")
sql, args, err := ds1.GroupBy("name").Having(SUM("amount").Gt(0)).Prepared(true).ToSql()
assert.NoError(t, err)
assert.Equal(t, args, []interface{}{0})
assert.Equal(t, sql, `SELECT * FROM "items" GROUP BY "name" HAVING (SUM("amount") > ?)`)
}
func (me *datasetTest) TestPreparedUpdateSqlWithMaps() {
t := me.T()
ds1 := From("items")
sql, args, err := ds1.Prepared(true).ToUpdateSql(Record{"name": "Test", "address": "111 Test Addr"})
assert.NoError(t, err)
assert.Equal(t, args, []interface{}{"111 Test Addr", "Test"})
assert.Equal(t, sql, `UPDATE "items" SET "address"=?,"name"=?`)
}
func (me *datasetTest) TestPreparedInsertSqlWitSqlBuilder() {
t := me.T()
ds1 := From("items")
sql, args, err := ds1.Prepared(true).ToInsertSql(From("other_items").Where(I("b").Gt(10)))
assert.NoError(t, err)
assert.Equal(t, args, []interface{}{10})
assert.Equal(t, sql, `INSERT INTO "items" SELECT * FROM "other_items" WHERE ("b" > ?)`)
}
func (me *datasetTest) TestPreparedClearOffset() {
t := me.T()
ds1 := From("test")
b := ds1.Where(I("a").Gt(1)).Offset(10).ClearOffset()
sql, args, err := b.Prepared(true).ToSql()
assert.NoError(t, err)
assert.Equal(t, args, []interface{}{1})
assert.Equal(t, sql, `SELECT * FROM "test" WHERE ("a" > ?)`)
}
func (me *datasetTest) TestDeleteSqlWithReturning() {
t := me.T()
ds1 := From("items")
sql, _, err := ds1.Returning("id").ToDeleteSql()
assert.NoError(t, err)
assert.Equal(t, sql, `DELETE FROM "items" RETURNING "id"`)
sql, _, err = ds1.Returning("id").Where(I("id").IsNotNull()).ToDeleteSql()
assert.NoError(t, err)
assert.Equal(t, sql, `DELETE FROM "items" WHERE ("id" IS NOT NULL) RETURNING "id"`)
}
func (me *datasetTest) TestLiteralColumnList() {
t := me.T()
buf := NewSqlBuilder(false)
ds := From("test")
assert.NoError(t, ds.Literal(me.Truncate(buf), cols("a", Literal("true"))))
assert.Equal(t, buf.String(), `"a", true`)
buf = NewSqlBuilder(true)
assert.NoError(t, ds.Literal(me.Truncate(buf), cols("a", Literal("true"))))
assert.Equal(t, buf.args, []interface{}{})
assert.Equal(t, buf.String(), `"a", true`)
}
func (me *datasetTest) TestLiteralCastExpression() {
t := me.T()
buf := NewSqlBuilder(false)
ds := From("test")
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Cast("DATE")))
assert.Equal(t, buf.String(), `CAST("a" AS DATE)`)
buf = NewSqlBuilder(true)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Cast("DATE")))
assert.Equal(t, buf.args, []interface{}{})
assert.Equal(t, buf.String(), `CAST("a" AS DATE)`)
}
func (me *datasetTest) TestPreparedUpdateSqlWithValuer() {
t := me.T()
ds1 := From("items")
type item struct {
Name string `db:"name"`
Data valuerType `db:"data"`
}
sql, args, err := ds1.Returning(I("items").All()).Prepared(true).ToUpdateSql(item{Name: "Test", Data: []byte(`Hello`)})
assert.NoError(t, err)
assert.Equal(t, args, []interface{}{"Test", "Hello World"})
assert.Equal(t, sql, `UPDATE "items" SET "name"=?,"data"=? RETURNING "items".*`)
}
func (me *datasetTest) TestPreparedUpdateSqlWithSkipupdateTag() {
t := me.T()
ds1 := From("items")
type item struct {
Address string `db:"address" goqu:"skipupdate"`
Name string `db:"name"`
}
sql, args, err := ds1.Prepared(true).ToUpdateSql(item{Name: "Test", Address: "111 Test Addr"})
assert.NoError(t, err)
assert.Equal(t, args, []interface{}{"Test"})
assert.Equal(t, sql, `UPDATE "items" SET "name"=?`)
}
func (me *datasetTest) TestLiteraSlice() {
t := me.T()
buf := NewSqlBuilder(false)
ds := From("test")
assert.NoError(t, ds.Literal(me.Truncate(buf), []string{"a", "b", "c"}))
assert.Equal(t, buf.String(), `('a', 'b', 'c')`)
buf = NewSqlBuilder(true)
assert.NoError(t, ds.Literal(me.Truncate(buf), []string{"a", "b", "c"}))
assert.Equal(t, buf.args, []interface{}{"a", "b", "c"})
assert.Equal(t, buf.String(), `(?, ?, ?)`)
}
func (me *datasetTest) TestLiteralUpdateExpression() {
t := me.T()
buf := NewSqlBuilder(false)
ds := From("test")
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Set(1)))
assert.Equal(t, buf.String(), `"a"=1`)
buf = NewSqlBuilder(true)
assert.NoError(t, ds.Literal(me.Truncate(buf), I("a").Set(1)))
assert.Equal(t, buf.args, []interface{}{1})
assert.Equal(t, buf.String(), `"a"=?`)
}
func (me *datasetAdapterTest) TestPlaceholderSql() {
t := me.T()
buf := goqu.NewSqlBuilder(true)
dsAdapter := newDatasetAdapter(goqu.From("test"))
dsAdapter.PlaceHolderSql(buf, 1)
dsAdapter.PlaceHolderSql(buf, 2)
dsAdapter.PlaceHolderSql(buf, 3)
dsAdapter.PlaceHolderSql(buf, 4)
sql, args := buf.ToSql()
assert.Equal(t, args, []interface{}{1, 2, 3, 4})
assert.Equal(t, sql, "????")
}
func (me *datasetTest) TestLiteralNilTypes() {
t := me.T()
buf := NewSqlBuilder(false)
ds := From("test")
assert.NoError(t, ds.Literal(me.Truncate(buf), nil))
assert.Equal(t, buf.String(), "NULL")
buf = NewSqlBuilder(true)
assert.NoError(t, ds.Literal(me.Truncate(buf), nil))
assert.Equal(t, buf.args, []interface{}{nil})
assert.Equal(t, buf.String(), "?")
}
func (me *datasetTest) TestWhere() {
t := me.T()
ds1 := From("test")
b := ds1.Where(
I("a").Eq(true),
I("a").Neq(true),
I("a").Eq(false),
I("a").Neq(false),
)
sql, _, err := b.ToSql()
assert.NoError(t, err)
assert.Equal(t, sql, `SELECT * FROM "test" WHERE (("a" IS TRUE) AND ("a" IS NOT TRUE) AND ("a" IS FALSE) AND ("a" IS NOT FALSE))`)
b = ds1.Where(
I("a").Eq("a"),
I("b").Neq("b"),
I("c").Gt("c"),
I("d").Gte("d"),
I("e").Lt("e"),
I("f").Lte("f"),
)
sql, _, err = b.ToSql()
assert.NoError(t, err)
assert.Equal(t, sql, `SELECT * FROM "test" WHERE (("a" = 'a') AND ("b" != 'b') AND ("c" > 'c') AND ("d" >= 'd') AND ("e" < 'e') AND ("f" <= 'f'))`)
b = ds1.Where(
I("a").Eq(From("test2").Select("id")),
)
sql, _, err = b.ToSql()
assert.NoError(t, err)
assert.Equal(t, sql, `SELECT * FROM "test" WHERE ("a" IN (SELECT "id" FROM "test2"))`)
b = ds1.Where(Ex{
"a": "a",
"b": Op{"neq": "b"},
"c": Op{"gt": "c"},
"d": Op{"gte": "d"},
"e": Op{"lt": "e"},
"f": Op{"lte": "f"},
})
sql, _, err = b.ToSql()
assert.NoError(t, err)
assert.Equal(t, sql, `SELECT * FROM "test" WHERE (("a" = 'a') AND ("b" != 'b') AND ("c" > 'c') AND ("d" >= 'd') AND ("e" < 'e') AND ("f" <= 'f'))`)
b = ds1.Where(Ex{
"a": From("test2").Select("id"),
})
sql, _, err = b.ToSql()
assert.NoError(t, err)
assert.Equal(t, sql, `SELECT * FROM "test" WHERE ("a" IN (SELECT "id" FROM "test2"))`)
}
func (me *datasetTest) TestSelectAppend() {
t := me.T()
ds1 := From("test")
sql, _, err := ds1.ToSql()
assert.NoError(t, err)
assert.Equal(t, sql, `SELECT * FROM "test"`)
b := ds1.Select("a").SelectAppend("b").SelectAppend("c")
sql, _, err = b.ToSql()
assert.NoError(t, err)
assert.Equal(t, sql, `SELECT "a", "b", "c" FROM "test"`)
}
func (me *datasetTest) TestOrderAppend() {
t := me.T()
b := From("test").Order(I("a").Asc().NullsFirst()).OrderAppend(I("b").Desc().NullsLast())
sql, _, err := b.ToSql()
assert.NoError(t, err)
assert.Equal(t, sql, `SELECT * FROM "test" ORDER BY "a" ASC NULLS FIRST, "b" DESC NULLS LAST`)
b = From("test").OrderAppend(I("a").Asc().NullsFirst()).OrderAppend(I("b").Desc().NullsLast())
sql, _, err = b.ToSql()
assert.NoError(t, err)
assert.Equal(t, sql, `SELECT * FROM "test" ORDER BY "a" ASC NULLS FIRST, "b" DESC NULLS LAST`)
}
func (me *datasetTest) TestFullOuterJoin() {
t := me.T()
ds1 := From("items")
sql, _, err := ds1.
FullOuterJoin(I("categories"), On(Ex{"categories.categoryId": I("items.id")})).
Order(I("stamp").Asc()).ToSql()
assert.NoError(t, err)
assert.Equal(t, sql, `SELECT * FROM "items" FULL OUTER JOIN "categories" ON ("categories"."categoryId" = "items"."id") ORDER BY "stamp" ASC`)
sql, _, err = ds1.FullOuterJoin(I("categories"), On(Ex{"categories.categoryId": I("items.id")})).ToSql()
assert.NoError(t, err)
assert.Equal(t, sql, `SELECT * FROM "items" FULL OUTER JOIN "categories" ON ("categories"."categoryId" = "items"."id")`)
}