mirror of
https://github.com/chaisql/chai.git
synced 2025-10-30 18:36:27 +08:00
908 lines
20 KiB
Go
908 lines
20 KiB
Go
/*
|
|
* CODE GENERATED AUTOMATICALLY WITH github.com/genjidb/genji/dev/gensqltest
|
|
* THIS FILE SHOULD NOT BE EDITED BY HAND
|
|
*/
|
|
package statement_test
|
|
|
|
import (
|
|
"regexp"
|
|
"testing"
|
|
|
|
"github.com/genjidb/genji"
|
|
"github.com/genjidb/genji/internal/testutil"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestGenInsertStatements(t *testing.T) {
|
|
setup := func(t *testing.T, db *genji.DB) {
|
|
t.Helper()
|
|
|
|
q := `
|
|
CREATE TABLE test;
|
|
CREATE TABLE test_idx;
|
|
CREATE INDEX idx_a ON test_idx (a);
|
|
CREATE INDEX idx_b ON test_idx (b);
|
|
CREATE INDEX idx_c ON test_idx (c);
|
|
`
|
|
err := db.Exec(q)
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
t.Run("values, no columns", func(t *testing.T) {
|
|
db, err := genji.Open(":memory:")
|
|
require.NoError(t, err)
|
|
defer db.Close()
|
|
|
|
setup(t, db)
|
|
|
|
t.Run(`INSERT INTO test VALUES ("a", 'b', 'c');`, func(t *testing.T) {
|
|
q := `
|
|
INSERT INTO test VALUES ("a", 'b', 'c');
|
|
`
|
|
err := db.Exec(q)
|
|
require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
|
|
})
|
|
|
|
})
|
|
|
|
// --------------------------------------------------------------------------
|
|
t.Run("values, with columns", func(t *testing.T) {
|
|
db, err := genji.Open(":memory:")
|
|
require.NoError(t, err)
|
|
defer db.Close()
|
|
|
|
setup(t, db)
|
|
|
|
t.Run(`INSERT INTO test (a, b, c) VALUES ('a', 'b', 'c');`, func(t *testing.T) {
|
|
q := `
|
|
INSERT INTO test (a, b, c) VALUES ('a', 'b', 'c');
|
|
SELECT pk(), * FROM test;
|
|
`
|
|
res, err := db.Query(q)
|
|
require.NoError(t, err)
|
|
defer res.Close()
|
|
raw := `
|
|
{
|
|
"pk()": 1,
|
|
"a": "a",
|
|
"b": "b",
|
|
"c":"c"
|
|
}
|
|
`
|
|
testutil.RequireStreamEq(t, raw, res)
|
|
})
|
|
|
|
})
|
|
|
|
// --------------------------------------------------------------------------
|
|
t.Run("values, ident", func(t *testing.T) {
|
|
db, err := genji.Open(":memory:")
|
|
require.NoError(t, err)
|
|
defer db.Close()
|
|
|
|
setup(t, db)
|
|
|
|
t.Run(`INSERT INTO test (a) VALUES (a);`, func(t *testing.T) {
|
|
q := `
|
|
INSERT INTO test (a) VALUES (a);
|
|
`
|
|
err := db.Exec(q)
|
|
require.NotNil(t, err, "expected error, got nil")
|
|
require.Regexp(t, regexp.MustCompile("field not found"), err.Error())
|
|
})
|
|
|
|
})
|
|
|
|
// --------------------------------------------------------------------------
|
|
t.Run("values, ident string", func(t *testing.T) {
|
|
db, err := genji.Open(":memory:")
|
|
require.NoError(t, err)
|
|
defer db.Close()
|
|
|
|
setup(t, db)
|
|
|
|
t.Run(`INSERT INTO test (a) VALUES (`+"`"+`a`+"`"+`);`, func(t *testing.T) {
|
|
q := `
|
|
INSERT INTO test (a) VALUES (` + "`" + `a` + "`" + `);
|
|
`
|
|
err := db.Exec(q)
|
|
require.NotNil(t, err, "expected error, got nil")
|
|
require.Regexp(t, regexp.MustCompile("field not found"), err.Error())
|
|
})
|
|
|
|
})
|
|
|
|
// --------------------------------------------------------------------------
|
|
t.Run("values, fields ident string", func(t *testing.T) {
|
|
db, err := genji.Open(":memory:")
|
|
require.NoError(t, err)
|
|
defer db.Close()
|
|
|
|
setup(t, db)
|
|
|
|
t.Run(`INSERT INTO test (a, `+"`"+`foo bar`+"`"+`) VALUES ('c', 'd');`, func(t *testing.T) {
|
|
q := `
|
|
INSERT INTO test (a, ` + "`" + `foo bar` + "`" + `) VALUES ('c', 'd');
|
|
SELECT pk(), * FROM test;
|
|
`
|
|
res, err := db.Query(q)
|
|
require.NoError(t, err)
|
|
defer res.Close()
|
|
raw := `
|
|
{
|
|
"pk()": 1,
|
|
"a": "c",
|
|
"foo bar": "d"
|
|
}
|
|
`
|
|
testutil.RequireStreamEq(t, raw, res)
|
|
})
|
|
|
|
})
|
|
|
|
// --------------------------------------------------------------------------
|
|
t.Run("values, list", func(t *testing.T) {
|
|
db, err := genji.Open(":memory:")
|
|
require.NoError(t, err)
|
|
defer db.Close()
|
|
|
|
setup(t, db)
|
|
|
|
t.Run(`INSERT INTO test (a, b, c) VALUES ("a", 'b', [1, 2, 3]);`, func(t *testing.T) {
|
|
q := `
|
|
INSERT INTO test (a, b, c) VALUES ("a", 'b', [1, 2, 3]);
|
|
SELECT pk(), * FROM test;
|
|
`
|
|
res, err := db.Query(q)
|
|
require.NoError(t, err)
|
|
defer res.Close()
|
|
raw := `
|
|
{
|
|
"pk()": 1,
|
|
"a": "a",
|
|
"b":"b",
|
|
"c": [1.0, 2.0, 3.0]
|
|
}
|
|
`
|
|
testutil.RequireStreamEq(t, raw, res)
|
|
})
|
|
|
|
})
|
|
|
|
// --------------------------------------------------------------------------
|
|
t.Run("values, document", func(t *testing.T) {
|
|
db, err := genji.Open(":memory:")
|
|
require.NoError(t, err)
|
|
defer db.Close()
|
|
|
|
setup(t, db)
|
|
|
|
t.Run(`INSERT INTO test (a, b, c) VALUES ("a", 'b', {c: 1, d: c + 1});`, func(t *testing.T) {
|
|
q := `
|
|
INSERT INTO test (a, b, c) VALUES ("a", 'b', {c: 1, d: c + 1});
|
|
SELECT pk(), * FROM test;
|
|
`
|
|
res, err := db.Query(q)
|
|
require.NoError(t, err)
|
|
defer res.Close()
|
|
raw := `
|
|
{
|
|
"pk()": 1,
|
|
"a": "a",
|
|
"b": "b",
|
|
"c": {
|
|
"c": 1.0,
|
|
"d": 2.0
|
|
}
|
|
}
|
|
`
|
|
testutil.RequireStreamEq(t, raw, res)
|
|
})
|
|
|
|
})
|
|
|
|
// --------------------------------------------------------------------------
|
|
t.Run("document", func(t *testing.T) {
|
|
db, err := genji.Open(":memory:")
|
|
require.NoError(t, err)
|
|
defer db.Close()
|
|
|
|
setup(t, db)
|
|
|
|
t.Run(`INSERT INTO test VALUES {a: 'a', b: 2.3, c: 1 = 1};`, func(t *testing.T) {
|
|
q := `
|
|
INSERT INTO test VALUES {a: 'a', b: 2.3, c: 1 = 1};
|
|
SELECT pk(), * FROM test;
|
|
`
|
|
res, err := db.Query(q)
|
|
require.NoError(t, err)
|
|
defer res.Close()
|
|
raw := `
|
|
{
|
|
"pk()": 1,
|
|
"a": "a",
|
|
"b": 2.3,
|
|
"c": true
|
|
}
|
|
`
|
|
testutil.RequireStreamEq(t, raw, res)
|
|
})
|
|
|
|
})
|
|
|
|
// --------------------------------------------------------------------------
|
|
t.Run("document, list", func(t *testing.T) {
|
|
db, err := genji.Open(":memory:")
|
|
require.NoError(t, err)
|
|
defer db.Close()
|
|
|
|
setup(t, db)
|
|
|
|
t.Run(`INSERT INTO test VALUES {a: [1, 2, 3]};`, func(t *testing.T) {
|
|
q := `
|
|
INSERT INTO test VALUES {a: [1, 2, 3]};
|
|
SELECT pk(), * FROM test;
|
|
`
|
|
res, err := db.Query(q)
|
|
require.NoError(t, err)
|
|
defer res.Close()
|
|
raw := `
|
|
{
|
|
"pk()": 1,
|
|
"a": [
|
|
1.0,
|
|
2.0,
|
|
3.0
|
|
]
|
|
}
|
|
`
|
|
testutil.RequireStreamEq(t, raw, res)
|
|
})
|
|
|
|
})
|
|
|
|
// --------------------------------------------------------------------------
|
|
t.Run("document, strings", func(t *testing.T) {
|
|
db, err := genji.Open(":memory:")
|
|
require.NoError(t, err)
|
|
defer db.Close()
|
|
|
|
setup(t, db)
|
|
|
|
t.Run(`INSERT INTO test VALUES {'a': 'a', b: 2.3};`, func(t *testing.T) {
|
|
q := `
|
|
INSERT INTO test VALUES {'a': 'a', b: 2.3};
|
|
SELECT pk(), * FROM test;
|
|
/*result:
|
|
{
|
|
"pk()": 1,
|
|
"a": "a",
|
|
"b": 2.3
|
|
}
|
|
*/
|
|
`
|
|
res, err := db.Query(q)
|
|
require.NoError(t, err)
|
|
defer res.Close()
|
|
})
|
|
|
|
})
|
|
|
|
// --------------------------------------------------------------------------
|
|
t.Run("document, double quotes", func(t *testing.T) {
|
|
db, err := genji.Open(":memory:")
|
|
require.NoError(t, err)
|
|
defer db.Close()
|
|
|
|
setup(t, db)
|
|
|
|
t.Run(`INSERT INTO test VALUES {"a": "b"};`, func(t *testing.T) {
|
|
q := `
|
|
INSERT INTO test VALUES {"a": "b"};
|
|
SELECT pk(), * FROM test;
|
|
`
|
|
res, err := db.Query(q)
|
|
require.NoError(t, err)
|
|
defer res.Close()
|
|
raw := `
|
|
{
|
|
"pk()": 1,
|
|
"a": "b"
|
|
}
|
|
`
|
|
testutil.RequireStreamEq(t, raw, res)
|
|
})
|
|
|
|
})
|
|
|
|
// --------------------------------------------------------------------------
|
|
t.Run("document, references to other field", func(t *testing.T) {
|
|
db, err := genji.Open(":memory:")
|
|
require.NoError(t, err)
|
|
defer db.Close()
|
|
|
|
setup(t, db)
|
|
|
|
t.Run(`INSERT INTO test VALUES {a: 400, b: a * 4};`, func(t *testing.T) {
|
|
q := `
|
|
INSERT INTO test VALUES {a: 400, b: a * 4};
|
|
SELECT pk(), * FROM test;
|
|
`
|
|
res, err := db.Query(q)
|
|
require.NoError(t, err)
|
|
defer res.Close()
|
|
raw := `
|
|
{"pk()":1,"a":400.0,"b":1600.0}
|
|
`
|
|
testutil.RequireStreamEq(t, raw, res)
|
|
})
|
|
|
|
})
|
|
|
|
// --------------------------------------------------------------------------
|
|
t.Run("index, values, no columns", func(t *testing.T) {
|
|
db, err := genji.Open(":memory:")
|
|
require.NoError(t, err)
|
|
defer db.Close()
|
|
|
|
setup(t, db)
|
|
|
|
t.Run(`INSERT INTO test_idx VALUES ("a", 'b', 'c');`, func(t *testing.T) {
|
|
q := `
|
|
INSERT INTO test_idx VALUES ("a", 'b', 'c');
|
|
`
|
|
err := db.Exec(q)
|
|
require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
|
|
})
|
|
|
|
})
|
|
|
|
// --------------------------------------------------------------------------
|
|
t.Run("index, values, with columns", func(t *testing.T) {
|
|
db, err := genji.Open(":memory:")
|
|
require.NoError(t, err)
|
|
defer db.Close()
|
|
|
|
setup(t, db)
|
|
|
|
t.Run(`INSERT INTO test_idx (a, b, c) VALUES ('a', 'b', 'c');`, func(t *testing.T) {
|
|
q := `
|
|
INSERT INTO test_idx (a, b, c) VALUES ('a', 'b', 'c');
|
|
SELECT pk(), * FROM test_idx;
|
|
`
|
|
res, err := db.Query(q)
|
|
require.NoError(t, err)
|
|
defer res.Close()
|
|
raw := `
|
|
{
|
|
"pk()": 1,
|
|
"a": "a",
|
|
"b": "b",
|
|
"c": "c"
|
|
}
|
|
`
|
|
testutil.RequireStreamEq(t, raw, res)
|
|
})
|
|
|
|
})
|
|
|
|
// --------------------------------------------------------------------------
|
|
t.Run("index, values, ident", func(t *testing.T) {
|
|
db, err := genji.Open(":memory:")
|
|
require.NoError(t, err)
|
|
defer db.Close()
|
|
|
|
setup(t, db)
|
|
|
|
t.Run(`INSERT INTO test_idx (a) VALUES (a);`, func(t *testing.T) {
|
|
q := `
|
|
INSERT INTO test_idx (a) VALUES (a);
|
|
`
|
|
err := db.Exec(q)
|
|
require.NotNil(t, err, "expected error, got nil")
|
|
require.Regexp(t, regexp.MustCompile("field not found"), err.Error())
|
|
})
|
|
|
|
})
|
|
|
|
// --------------------------------------------------------------------------
|
|
t.Run("index, values, ident string", func(t *testing.T) {
|
|
db, err := genji.Open(":memory:")
|
|
require.NoError(t, err)
|
|
defer db.Close()
|
|
|
|
setup(t, db)
|
|
|
|
t.Run(`INSERT INTO test_idx (a) VALUES (`+"`"+`a`+"`"+`);`, func(t *testing.T) {
|
|
q := `
|
|
INSERT INTO test_idx (a) VALUES (` + "`" + `a` + "`" + `);
|
|
`
|
|
err := db.Exec(q)
|
|
require.NotNil(t, err, "expected error, got nil")
|
|
require.Regexp(t, regexp.MustCompile("field not found"), err.Error())
|
|
})
|
|
|
|
})
|
|
|
|
// --------------------------------------------------------------------------
|
|
t.Run("index, values, fields ident string", func(t *testing.T) {
|
|
db, err := genji.Open(":memory:")
|
|
require.NoError(t, err)
|
|
defer db.Close()
|
|
|
|
setup(t, db)
|
|
|
|
t.Run(`INSERT INTO test_idx (a, `+"`"+`foo bar`+"`"+`) VALUES ('c', 'd');`, func(t *testing.T) {
|
|
q := `
|
|
INSERT INTO test_idx (a, ` + "`" + `foo bar` + "`" + `) VALUES ('c', 'd');
|
|
SELECT pk(), * FROM test_idx;
|
|
`
|
|
res, err := db.Query(q)
|
|
require.NoError(t, err)
|
|
defer res.Close()
|
|
raw := `
|
|
{
|
|
"pk()": 1,
|
|
"a": "c",
|
|
"foo bar": "d"
|
|
}
|
|
`
|
|
testutil.RequireStreamEq(t, raw, res)
|
|
})
|
|
|
|
})
|
|
|
|
// --------------------------------------------------------------------------
|
|
t.Run("index, values, list", func(t *testing.T) {
|
|
db, err := genji.Open(":memory:")
|
|
require.NoError(t, err)
|
|
defer db.Close()
|
|
|
|
setup(t, db)
|
|
|
|
t.Run(`INSERT INTO test_idx (a, b, c) VALUES ("a", 'b', [1, 2, 3]);`, func(t *testing.T) {
|
|
q := `
|
|
INSERT INTO test_idx (a, b, c) VALUES ("a", 'b', [1, 2, 3]);
|
|
SELECT pk(), * FROM test_idx;
|
|
`
|
|
res, err := db.Query(q)
|
|
require.NoError(t, err)
|
|
defer res.Close()
|
|
raw := `
|
|
{
|
|
"pk()": 1,
|
|
"a": "a",
|
|
"b":"b",
|
|
"c": [1.0, 2.0, 3.0]
|
|
}
|
|
`
|
|
testutil.RequireStreamEq(t, raw, res)
|
|
})
|
|
|
|
})
|
|
|
|
// --------------------------------------------------------------------------
|
|
t.Run("index, values, document", func(t *testing.T) {
|
|
db, err := genji.Open(":memory:")
|
|
require.NoError(t, err)
|
|
defer db.Close()
|
|
|
|
setup(t, db)
|
|
|
|
t.Run(`INSERT INTO test_idx (a, b, c) VALUES ("a", 'b', {c: 1, d: c + 1});`, func(t *testing.T) {
|
|
q := `
|
|
INSERT INTO test_idx (a, b, c) VALUES ("a", 'b', {c: 1, d: c + 1});
|
|
SELECT pk(), * FROM test_idx;
|
|
`
|
|
res, err := db.Query(q)
|
|
require.NoError(t, err)
|
|
defer res.Close()
|
|
raw := `
|
|
{
|
|
"pk()": 1,
|
|
"a": "a",
|
|
"b": "b",
|
|
"c": {
|
|
"c": 1.0,
|
|
"d": 2.0
|
|
}
|
|
}
|
|
`
|
|
testutil.RequireStreamEq(t, raw, res)
|
|
})
|
|
|
|
})
|
|
|
|
// --------------------------------------------------------------------------
|
|
t.Run("index, document", func(t *testing.T) {
|
|
db, err := genji.Open(":memory:")
|
|
require.NoError(t, err)
|
|
defer db.Close()
|
|
|
|
setup(t, db)
|
|
|
|
t.Run(`INSERT INTO test_idx VALUES {a: 'a', b: 2.3, c: 1 = 1};`, func(t *testing.T) {
|
|
q := `
|
|
INSERT INTO test_idx VALUES {a: 'a', b: 2.3, c: 1 = 1};
|
|
SELECT pk(), * FROM test_idx;
|
|
`
|
|
res, err := db.Query(q)
|
|
require.NoError(t, err)
|
|
defer res.Close()
|
|
raw := `
|
|
{
|
|
"pk()": 1,
|
|
"a": "a",
|
|
"b": 2.3,
|
|
"c": true
|
|
}
|
|
`
|
|
testutil.RequireStreamEq(t, raw, res)
|
|
})
|
|
|
|
})
|
|
|
|
// --------------------------------------------------------------------------
|
|
t.Run("index, document, list", func(t *testing.T) {
|
|
db, err := genji.Open(":memory:")
|
|
require.NoError(t, err)
|
|
defer db.Close()
|
|
|
|
setup(t, db)
|
|
|
|
t.Run(`INSERT INTO test_idx VALUES {a: [1, 2, 3]};`, func(t *testing.T) {
|
|
q := `
|
|
INSERT INTO test_idx VALUES {a: [1, 2, 3]};
|
|
SELECT pk(), * FROM test_idx;
|
|
`
|
|
res, err := db.Query(q)
|
|
require.NoError(t, err)
|
|
defer res.Close()
|
|
raw := `
|
|
{
|
|
"pk()": 1,
|
|
"a": [
|
|
1.0,
|
|
2.0,
|
|
3.0
|
|
]
|
|
}
|
|
`
|
|
testutil.RequireStreamEq(t, raw, res)
|
|
})
|
|
|
|
})
|
|
|
|
// --------------------------------------------------------------------------
|
|
t.Run("index, document, strings", func(t *testing.T) {
|
|
db, err := genji.Open(":memory:")
|
|
require.NoError(t, err)
|
|
defer db.Close()
|
|
|
|
setup(t, db)
|
|
|
|
t.Run(`INSERT INTO test_idx VALUES {'a': 'a', b: 2.3};`, func(t *testing.T) {
|
|
q := `
|
|
INSERT INTO test_idx VALUES {'a': 'a', b: 2.3};
|
|
SELECT pk(), * FROM test_idx;
|
|
/*result:
|
|
{
|
|
"pk()": 1,
|
|
"a": "a",
|
|
"b": 2.3
|
|
}
|
|
*/
|
|
`
|
|
res, err := db.Query(q)
|
|
require.NoError(t, err)
|
|
defer res.Close()
|
|
})
|
|
|
|
})
|
|
|
|
// --------------------------------------------------------------------------
|
|
t.Run("index, document, double quotes", func(t *testing.T) {
|
|
db, err := genji.Open(":memory:")
|
|
require.NoError(t, err)
|
|
defer db.Close()
|
|
|
|
setup(t, db)
|
|
|
|
t.Run(`INSERT INTO test_idx VALUES {"a": "b"};`, func(t *testing.T) {
|
|
q := `
|
|
INSERT INTO test_idx VALUES {"a": "b"};
|
|
SELECT pk(), * FROM test_idx;
|
|
`
|
|
res, err := db.Query(q)
|
|
require.NoError(t, err)
|
|
defer res.Close()
|
|
raw := `
|
|
{
|
|
"pk()": 1,
|
|
"a": "b"
|
|
}
|
|
`
|
|
testutil.RequireStreamEq(t, raw, res)
|
|
})
|
|
|
|
})
|
|
|
|
// --------------------------------------------------------------------------
|
|
t.Run("index, document, references to other field", func(t *testing.T) {
|
|
db, err := genji.Open(":memory:")
|
|
require.NoError(t, err)
|
|
defer db.Close()
|
|
|
|
setup(t, db)
|
|
|
|
t.Run(`INSERT INTO test_idx VALUES {a: 400, b: a * 4};`, func(t *testing.T) {
|
|
q := `
|
|
INSERT INTO test_idx VALUES {a: 400, b: a * 4};
|
|
SELECT pk(), * FROM test_idx;
|
|
`
|
|
res, err := db.Query(q)
|
|
require.NoError(t, err)
|
|
defer res.Close()
|
|
raw := `
|
|
{"pk()":1,"a":400.0,"b":1600.0}
|
|
`
|
|
testutil.RequireStreamEq(t, raw, res)
|
|
})
|
|
|
|
})
|
|
|
|
// --------------------------------------------------------------------------
|
|
t.Run("read-only tables", func(t *testing.T) {
|
|
db, err := genji.Open(":memory:")
|
|
require.NoError(t, err)
|
|
defer db.Close()
|
|
|
|
setup(t, db)
|
|
|
|
t.Run(`INSERT INTO __genji_tables VALUES {a: 400, b: a * 4};`, func(t *testing.T) {
|
|
q := `
|
|
INSERT INTO __genji_tables VALUES {a: 400, b: a * 4};
|
|
`
|
|
err := db.Exec(q)
|
|
require.NotNil(t, err, "expected error, got nil")
|
|
require.Regexp(t, regexp.MustCompile("cannot write to read-only table"), err.Error())
|
|
})
|
|
|
|
})
|
|
|
|
// --------------------------------------------------------------------------
|
|
t.Run("insert with primary keys", func(t *testing.T) {
|
|
db, err := genji.Open(":memory:")
|
|
require.NoError(t, err)
|
|
defer db.Close()
|
|
|
|
setup(t, db)
|
|
|
|
t.Run(`CREATE TABLE testpk (foo INTEGER PRIMARY KEY);`, func(t *testing.T) {
|
|
q := `
|
|
CREATE TABLE testpk (foo INTEGER PRIMARY KEY);
|
|
INSERT INTO testpk (bar) VALUES (1);
|
|
`
|
|
err := db.Exec(q)
|
|
require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
|
|
})
|
|
|
|
t.Run(`INSERT INTO testpk (bar, foo) VALUES (1, 2);`, func(t *testing.T) {
|
|
q := `
|
|
INSERT INTO testpk (bar, foo) VALUES (1, 2);
|
|
INSERT INTO testpk (bar, foo) VALUES (1, 2);
|
|
`
|
|
err := db.Exec(q)
|
|
require.NotNil(t, err, "expected error, got nil")
|
|
require.Regexp(t, regexp.MustCompile("duplicate"), err.Error())
|
|
})
|
|
|
|
})
|
|
|
|
// --------------------------------------------------------------------------
|
|
t.Run("insert with shadowing", func(t *testing.T) {
|
|
db, err := genji.Open(":memory:")
|
|
require.NoError(t, err)
|
|
defer db.Close()
|
|
|
|
setup(t, db)
|
|
|
|
t.Run(`INSERT INTO test (`+"`"+`pk()`+"`"+`, `+"`"+`key`+"`"+`) VALUES (1, 2);`, func(t *testing.T) {
|
|
q := `
|
|
INSERT INTO test (` + "`" + `pk()` + "`" + `, ` + "`" + `key` + "`" + `) VALUES (1, 2);
|
|
`
|
|
res, err := db.Query(q)
|
|
require.NoError(t, err)
|
|
defer res.Close()
|
|
})
|
|
|
|
})
|
|
|
|
// --------------------------------------------------------------------------
|
|
t.Run("insert with types constraints", func(t *testing.T) {
|
|
db, err := genji.Open(":memory:")
|
|
require.NoError(t, err)
|
|
defer db.Close()
|
|
|
|
setup(t, db)
|
|
|
|
t.Run(`CREATE TABLE test_tc(`, func(t *testing.T) {
|
|
q := `
|
|
CREATE TABLE test_tc(
|
|
b bool, db double,
|
|
i integer, bb blob, byt bytes,
|
|
t text, a array, d document
|
|
);
|
|
INSERT INTO test_tc
|
|
VALUES {
|
|
i: 10000000000, db: 21.21, b: true,
|
|
bb: "YmxvYlZhbHVlCg==", byt: "Ynl0ZXNWYWx1ZQ==",
|
|
t: "text", a: [1, "foo", true], d: {"foo": "bar"}
|
|
};
|
|
SELECT * FROM test_tc;
|
|
`
|
|
res, err := db.Query(q)
|
|
require.NoError(t, err)
|
|
defer res.Close()
|
|
raw := `
|
|
{
|
|
"i": 10000000000,
|
|
"db": 21.21,
|
|
"b": true,
|
|
"bb": CAST("YmxvYlZhbHVlCg==" AS BLOB),
|
|
"byt": CAST("Ynl0ZXNWYWx1ZQ==" AS BYTES),
|
|
"t": "text",
|
|
"a": [
|
|
1.0,
|
|
"foo",
|
|
true
|
|
],
|
|
"d": {
|
|
"foo": "bar"
|
|
}
|
|
}
|
|
`
|
|
testutil.RequireStreamEq(t, raw, res)
|
|
})
|
|
|
|
})
|
|
|
|
// --------------------------------------------------------------------------
|
|
t.Run("insert with inferred constraints", func(t *testing.T) {
|
|
db, err := genji.Open(":memory:")
|
|
require.NoError(t, err)
|
|
defer db.Close()
|
|
|
|
setup(t, db)
|
|
|
|
t.Run(`CREATE TABLE test_ic(a INTEGER, s.b TEXT);`, func(t *testing.T) {
|
|
q := `
|
|
CREATE TABLE test_ic(a INTEGER, s.b TEXT);
|
|
INSERT INTO test_ic VALUES {s: 1};
|
|
`
|
|
err := db.Exec(q)
|
|
require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
|
|
})
|
|
|
|
})
|
|
|
|
// --------------------------------------------------------------------------
|
|
t.Run("insert with on conflict do nothing", func(t *testing.T) {
|
|
db, err := genji.Open(":memory:")
|
|
require.NoError(t, err)
|
|
defer db.Close()
|
|
|
|
setup(t, db)
|
|
|
|
t.Run(`CREATE TABLE test_oc(a INTEGER UNIQUE, b INTEGER PRIMARY KEY, c INTEGER UNIQUE DEFAULT 10);`, func(t *testing.T) {
|
|
q := `
|
|
CREATE TABLE test_oc(a INTEGER UNIQUE, b INTEGER PRIMARY KEY, c INTEGER UNIQUE DEFAULT 10);
|
|
INSERT INTO test_oc (a, b, c) VALUES (1, 1, 1);
|
|
INSERT INTO test_oc (a, b, c) VALUES (1, 2, 3) ON CONFLICT DO NOTHING;
|
|
INSERT INTO test_oc (a, b, c) VALUES (2, 1, 4) ON CONFLICT DO NOTHING;
|
|
INSERT INTO test_oc (a, b, c) VALUES (2, 2, 1) ON CONFLICT DO NOTHING;
|
|
INSERT INTO test_oc (a, b) VALUES (2, 2) ON CONFLICT DO NOTHING;
|
|
SELECT * FROM test_oc;
|
|
`
|
|
res, err := db.Query(q)
|
|
require.NoError(t, err)
|
|
defer res.Close()
|
|
raw := `
|
|
{
|
|
a: 1,
|
|
b: 1,
|
|
c: 1
|
|
}
|
|
{
|
|
a: 2,
|
|
b: 2,
|
|
c: 10
|
|
}
|
|
`
|
|
testutil.RequireStreamEq(t, raw, res)
|
|
})
|
|
|
|
})
|
|
|
|
// --------------------------------------------------------------------------
|
|
t.Run("insert with on conflict do replace, pk", func(t *testing.T) {
|
|
db, err := genji.Open(":memory:")
|
|
require.NoError(t, err)
|
|
defer db.Close()
|
|
|
|
setup(t, db)
|
|
|
|
t.Run(`CREATE TABLE test_oc(a INTEGER PRIMARY KEY);`, func(t *testing.T) {
|
|
q := `
|
|
CREATE TABLE test_oc(a INTEGER PRIMARY KEY);
|
|
INSERT INTO test_oc (a, b, c) VALUES (1, 1, 1);
|
|
INSERT INTO test_oc (a, b, c) VALUES (1, 2, 3) ON CONFLICT DO REPLACE;
|
|
SELECT * FROM test_oc;
|
|
`
|
|
res, err := db.Query(q)
|
|
require.NoError(t, err)
|
|
defer res.Close()
|
|
raw := `
|
|
{
|
|
a: 1,
|
|
b: 2.0,
|
|
c: 3.0
|
|
}
|
|
`
|
|
testutil.RequireStreamEq(t, raw, res)
|
|
})
|
|
|
|
})
|
|
|
|
// --------------------------------------------------------------------------
|
|
t.Run("insert with on conflict do replace, unique", func(t *testing.T) {
|
|
db, err := genji.Open(":memory:")
|
|
require.NoError(t, err)
|
|
defer db.Close()
|
|
|
|
setup(t, db)
|
|
|
|
t.Run(`CREATE TABLE test_oc(a INTEGER UNIQUE);`, func(t *testing.T) {
|
|
q := `
|
|
CREATE TABLE test_oc(a INTEGER UNIQUE);
|
|
INSERT INTO test_oc (a, b, c) VALUES (1, 1, 1);
|
|
INSERT INTO test_oc (a, b, c) VALUES (1, 2, 3) ON CONFLICT DO REPLACE;
|
|
SELECT * FROM test_oc;
|
|
`
|
|
res, err := db.Query(q)
|
|
require.NoError(t, err)
|
|
defer res.Close()
|
|
raw := `
|
|
{
|
|
a: 1,
|
|
b: 2.0,
|
|
c: 3.0
|
|
}
|
|
`
|
|
testutil.RequireStreamEq(t, raw, res)
|
|
})
|
|
|
|
})
|
|
|
|
// --------------------------------------------------------------------------
|
|
t.Run("insert with on conflict do replace, not null", func(t *testing.T) {
|
|
db, err := genji.Open(":memory:")
|
|
require.NoError(t, err)
|
|
defer db.Close()
|
|
|
|
setup(t, db)
|
|
|
|
t.Run(`CREATE TABLE test_oc(a INTEGER NOT NULL);`, func(t *testing.T) {
|
|
q := `
|
|
CREATE TABLE test_oc(a INTEGER NOT NULL);
|
|
INSERT INTO test_oc (b, c) VALUES (1, 1) ON CONFLICT DO REPLACE;
|
|
`
|
|
err := db.Exec(q)
|
|
require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
|
|
})
|
|
|
|
})
|
|
|
|
}
|