zishuo/chaisql
1
0
Fork 0
mirror of https://github.com/chaisql/chai.git synced 2025-09-26 19:51:21 +08:00
Code Issues Packages Projects Releases Wiki Activity

use single quotes for text

Browse Source
This commit is contained in:
Asdine El Hrychy
2025-09-21 11:28:55 +05:30
parent 4ed42be27b
commit a60e2f33e1
57 changed files with 823 additions and 818 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
cmd/chai/dbutil/exec_test.go
View File

@@ -30,7 +30,7 @@ func TestExecSQL(t *testing.T) {
`), &got)
require.NoError(t, err)
require.Equal(t, "a|b\n1|\"a\"\n2|\"b\"\n3|\"c\"\n\nb|a\n\"a\"|1\n\"b\"|2\n\"c\"|3\n", got.String())
require.Equal(t, "a|b\n1|'a'\n2|'b'\n3|'c'\n\nb|a\n'a'|1\n'b'|2\n'c'|3\n", got.String())
var res struct {
A int

2
db_test.go
View File

@@ -97,7 +97,7 @@ func TestOpen(t *testing.T) {
`{"name":"seqD", "namespace":null, "owner_table_columns":null, "owner_table_name":null, "rowid_sequence_name":null, "sql":"CREATE SEQUENCE seqD INCREMENT BY 10 MINVALUE 100 START WITH 500 CYCLE", "type":"sequence"}`,
`{"name":"tableA", "namespace":10, "owner_table_columns":null, "owner_table_name":null, "rowid_sequence_name":null, "sql":"CREATE TABLE tableA (a INTEGER NOT NULL, b DOUBLE PRECISION NOT NULL, CONSTRAINT tableA_a_unique UNIQUE (a), CONSTRAINT tableA_pk PRIMARY KEY (b))", "type":"table"}`,
`{"name":"tableA_a_idx", "namespace":11, "owner_table_columns":"a", "owner_table_name":"tableA", "rowid_sequence_name":null, "sql":"CREATE UNIQUE INDEX tableA_a_idx ON tableA (a)", "type":"index"}`,
`{"name":"tableB", "namespace":12, "owner_table_columns":null, "owner_table_name":null, "rowid_sequence_name":null, "sql":"CREATE TABLE tableB (a TEXT NOT NULL DEFAULT \"hello\", CONSTRAINT tableB_pk PRIMARY KEY (a))", "type":"table"}`,
`{"name":"tableB", "namespace":12, "owner_table_columns":null, "owner_table_name":null, "rowid_sequence_name":null, "sql":"CREATE TABLE tableB (a TEXT NOT NULL DEFAULT 'hello', CONSTRAINT tableB_pk PRIMARY KEY (a))", "type":"table"}`,
`{"name":"tableC", "namespace":13, "owner_table_columns":null, "owner_table_name":null, "rowid_sequence_name":null, "sql":"CREATE TABLE tableC (a INTEGER NOT NULL, b INTEGER, CONSTRAINT tableC_pk PRIMARY KEY (a))", "type":"table"}`,
`{"name":"tableC_a_b_idx", "namespace":14, "owner_table_columns":null, "owner_table_name":"tableC", "rowid_sequence_name":null, "sql":"CREATE INDEX tableC_a_b_idx ON tableC (a, b)", "type":"index"}`,
}

42
internal/encoding/helpers_test.go
View File

@@ -76,24 +76,24 @@ func TestCompare(t *testing.T) {
{`(1e50)`, `(1.0)`, 1},
// text
{`("a")`, `("a")`, 0},
{`("b")`, `("a")`, 1},
{`("a")`, `("b")`, -1},
{`("a")`, `("aa")`, -1},
{`("aaaa")`, `("aab")`, -1},
{`('a')`, `('a')`, 0},
{`('b')`, `('a')`, 1},
{`('a')`, `('b')`, -1},
{`('a')`, `('aa')`, -1},
{`('aaaa')`, `('aab')`, -1},
// bytea
{`("\xaa")`, `("\xaa")`, 0},
{`("\xab")`, `("\xaa")`, 1},
{`("\xaa")`, `("\xab")`, -1},
{`("\xaa")`, `("\xaaaa")`, -1},
{`('\xaa')`, `('\xaa')`, 0},
{`('\xab')`, `('\xaa')`, 1},
{`('\xaa')`, `('\xab')`, -1},
{`('\xaa')`, `('\xaaaa')`, -1},
// different types
{`(null)`, `(true)`, -4},
{`(true)`, `(1)`, -43},
{`(1)`, `(1.0)`, -41},
{`(1.0)`, `("a")`, -8},
{`("a")`, `("\x00")`, -5},
{`(1.0)`, `('a')`, -8},
{`('a')`, `('\x00')`, -5},
// consecutive values
{`(1, 2, 3)`, `(1, 2, 3)`, 0},
@@ -146,8 +146,8 @@ func TestCompareOrder(t *testing.T) {
{`(1)`, `(2)`, 1, []bool{true}},
{`(60)`, `(30)`, 2, []bool{false}},
{`(60)`, `(30)`, -2, []bool{true}},
{`(30, "hello")`, `(30, "bye")`, 1, []bool{true, false}},
{`(30, "hello")`, `(30, "bye")`, -1, []bool{true, true}},
{`(30, 'hello')`, `(30, 'bye')`, 1, []bool{true, false}},
{`(30, 'hello')`, `(30, 'bye')`, -1, []bool{true, true}},
}
for _, test := range tests {
@@ -233,16 +233,16 @@ func TestAbbreviatedKey(t *testing.T) {
{`(1, -1e50)`, 1<<48 | uint64(encoding.Float64Value)<<40 | uint64(math.Float64bits(-1e50)^(1<<64-1))>>24},
// text
{`(1, "abc")`, 1<<48 | uint64(encoding.TextValue)<<40 | uint64('a')<<32 | uint64('b')<<24 | uint64('c')<<16},
{`(1, "abcdefghijkl")`, 1<<48 | uint64(encoding.TextValue)<<40 | uint64('a')<<32 | uint64('b')<<24 | uint64('c')<<16 | uint64('d')<<8 | uint64('e')},
{`(1, "abcdefghijkl` + strings.Repeat("m", 100) + `")`, 1<<48 | uint64(encoding.TextValue)<<40 | uint64('a')<<32 | uint64('b')<<24 | uint64('c')<<16 | uint64('d')<<8 | uint64('e')},
{`(1, "abcdefghijkl` + strings.Repeat("m", 10000) + `")`, 1<<48 | uint64(encoding.TextValue)<<40 | uint64('a')<<32 | uint64('b')<<24 | uint64('c')<<16 | uint64('d')<<8 | uint64('e')},
{`(1, 'abc')`, 1<<48 | uint64(encoding.TextValue)<<40 | uint64('a')<<32 | uint64('b')<<24 | uint64('c')<<16},
{`(1, 'abcdefghijkl')`, 1<<48 | uint64(encoding.TextValue)<<40 | uint64('a')<<32 | uint64('b')<<24 | uint64('c')<<16 | uint64('d')<<8 | uint64('e')},
{`(1, 'abcdefghijkl` + strings.Repeat("m", 100) + `')`, 1<<48 | uint64(encoding.TextValue)<<40 | uint64('a')<<32 | uint64('b')<<24 | uint64('c')<<16 | uint64('d')<<8 | uint64('e')},
{`(1, 'abcdefghijkl` + strings.Repeat("m", 10000) + `')`, 1<<48 | uint64(encoding.TextValue)<<40 | uint64('a')<<32 | uint64('b')<<24 | uint64('c')<<16 | uint64('d')<<8 | uint64('e')},
// bytea
{`(1, "\xab")`, 1<<48 | uint64(encoding.ByteaValue)<<40 | uint64(0xab)<<32},
{`(1, "\xabcdefabcdef")`, 1<<48 | uint64(encoding.ByteaValue)<<40 | uint64(0xab)<<32 | uint64(0xcd)<<24 | uint64(0xef)<<16 | uint64(0xab)<<8 | uint64(0xcd)},
{`(1, "\xabcdefabcdef` + strings.Repeat("c", 100) + `")`, 1<<48 | uint64(encoding.ByteaValue)<<40 | uint64(0xab)<<32 | uint64(0xcd)<<24 | uint64(0xef)<<16 | uint64(0xab)<<8 | uint64(0xcd)},
{`(1, "\xabcdefabcdef` + strings.Repeat("c", 1000) + `")`, 1<<48 | uint64(encoding.ByteaValue)<<40 | uint64(0xab)<<32 | uint64(0xcd)<<24 | uint64(0xef)<<16 | uint64(0xab)<<8 | uint64(0xcd)},
{`(1, '\xab')`, 1<<48 | uint64(encoding.ByteaValue)<<40 | uint64(0xab)<<32},
{`(1, '\xabcdefabcdef')`, 1<<48 | uint64(encoding.ByteaValue)<<40 | uint64(0xab)<<32 | uint64(0xcd)<<24 | uint64(0xef)<<16 | uint64(0xab)<<8 | uint64(0xcd)},
{`(1, '\xabcdefabcdef` + strings.Repeat("c", 100) + `')`, 1<<48 | uint64(encoding.ByteaValue)<<40 | uint64(0xab)<<32 | uint64(0xcd)<<24 | uint64(0xef)<<16 | uint64(0xab)<<8 | uint64(0xcd)},
{`(1, '\xabcdefabcdef` + strings.Repeat("c", 1000) + `')`, 1<<48 | uint64(encoding.ByteaValue)<<40 | uint64(0xab)<<32 | uint64(0xcd)<<24 | uint64(0xef)<<16 | uint64(0xab)<<8 | uint64(0xcd)},
}
for _, test := range tests {

2
internal/expr/expr_test.go
View File

@@ -18,7 +18,7 @@ func TestString(t *testing.T) {
"true",
"500",
`foo`,
`"hello"`,
`'hello'`,
"CAST(10 AS integer)",
}

2
internal/query/statement/select_test.go
View File

@@ -32,7 +32,7 @@ func TestSelectStmt(t *testing.T) {
{"With columns", "SELECT color, shape FROM test", false, `[{"color":"red","shape":"square"},{"color":"blue","shape":null},{"color":null,"shape":null}]`, nil},
{"No cond, wildcard and other column", "SELECT *, color FROM test", false, `[{"k":1,"color":"red","size":10,"shape":"square","height":null,"weight":null,"color":"red"}, {"k":2,"color":"blue","size":10,"shape":null,"height":null,"weight":100,"color":"blue"}, {"k":3,"color":null,"size":null,"shape":null,"height":100,"weight":200,"color":null}]`, nil},
{"With DISTINCT", "SELECT DISTINCT * FROM test", false, `[{"k":1,"color":"red","size":10,"shape":"square","height":null,"weight":null},{"k":2,"color":"blue","size":10,"shape":null,"height":null,"weight":100},{"k":3,"color":null,"size":null,"shape":null,"height":100,"weight":200}]`, nil},
{"With DISTINCT and expr", "SELECT DISTINCT 'a' FROM test", false, `[{"\"a\"":"a"}]`, nil},
{"With DISTINCT and expr", "SELECT DISTINCT 'a' FROM test", false, `[{"'a'":"a"}]`, nil},
{"With expr columns", "SELECT color, color != 'red' AS notred FROM test", false, `[{"color":"red","notred":false},{"color":"blue","notred":true},{"color":null,"notred":null}]`, nil},
{"With eq op", "SELECT * FROM test WHERE size = 10", false, `[{"k":1,"color":"red","size":10,"shape":"square","height":null,"weight":null},{"k":2,"color":"blue","size":10,"shape":null,"height":null,"weight":100}]`, nil},
{"With neq op", "SELECT * FROM test WHERE color != 'red'", false, `[{"k":2,"color":"blue","size":10,"shape":null,"height":null,"weight":100}]`, nil},

2
internal/query/statement/update_test.go
View File

@@ -21,7 +21,7 @@ func TestUpdateStmt(t *testing.T) {
{"Read-only table", `UPDATE __chai_catalog SET a = 1`, true, "", nil},
{"SET / No cond", `UPDATE test SET a = 'boo'`, false, `[{"a":"boo","b":"bar1","c":"baz1","d":null,"e":null},{"a":"boo","b":"bar2","c":null,"d":null,"e":null},{"a":"boo","b":null,"c":null,"d":"bar3","e":"baz3"}]`, nil},
{"SET / No cond / with ident string", "UPDATE test SET `a` = 'boo'", false, `[{"a":"boo","b":"bar1","c":"baz1","d":null,"e":null},{"a":"boo","b":"bar2","c":null,"d":null,"e":null},{"a":"boo","b":null,"c":null,"d":"bar3","e":"baz3"}]`, nil},
{"SET / No cond / with ident string", "UPDATE test SET \"a\" = 'boo'", false, `[{"a":"boo","b":"bar1","c":"baz1","d":null,"e":null},{"a":"boo","b":"bar2","c":null,"d":null,"e":null},{"a":"boo","b":null,"c":null,"d":"bar3","e":"baz3"}]`, nil},
{"SET / No cond / with multiple idents and constraint", `UPDATE test SET a = c`, true, ``, nil},
{"SET / No cond / with multiple idents", `UPDATE test SET b = c`, false, `[{"a":"foo1","b":"baz1","c":"baz1","d":null,"e":null},{"a":"foo2","b":null,"c":null,"d":null,"e":null},{"a":"foo3","b":null,"c":null,"d":"bar3","e":"baz3"}]`, nil},
{"SET / No cond / with missing column", "UPDATE test SET f = 'boo'", true, "", nil},

2
internal/sql/parser/expr_test.go
View File

@@ -32,7 +32,7 @@ func TestParserExpr(t *testing.T) {
{"-float64", "-10.0", testutil.DoubleValue(-10), false},
// strings
{"double quoted string", `"10.0"`, testutil.TextValue("10.0"), false},
{"double quoted string", `'10.0'`, testutil.TextValue("10.0"), false},
{"single quoted string", "'-10.0'", testutil.TextValue("-10.0"), false},
// byteas

4
internal/sql/parser/select_test.go
View File

@@ -163,7 +163,7 @@ func TestParserSelect(t *testing.T) {
true, false},
{"With nextval", "SELECT nextval('foo') FROM test",
stream.New(table.Scan("test")).
Pipe(rows.Project(parseNamedExpr(t, "nextval(\"foo\")"))),
Pipe(rows.Project(parseNamedExpr(t, "nextval('foo')"))),
false, false},
{"WithUnionAll", "SELECT * FROM test1 UNION ALL SELECT * FROM test2",
stream.New(stream.Concat(
@@ -381,7 +381,7 @@ func TestParserSelect(t *testing.T) {
stream.New(table.Scan("c")).
Pipe(rows.Project(expr.Wildcard{})),
)),
stream.New(table.Scan("d")).Pipe(rows.Project(parseNamedExpr(t, "nextval(\"foo\")"))),
stream.New(table.Scan("d")).Pipe(rows.Project(parseNamedExpr(t, "nextval('foo')"))),
)),
false, false,
},

13
internal/sql/scanner/scanner.go
View File

@@ -56,9 +56,7 @@ func (s *scanner) Scan() (tok Token, pos Pos, lit string) {
switch ch0 {
case eof:
return EOF, pos, ""
case '`':
s.r.unread()
case '"':
case '`', '"':
s.r.unread()
return s.scanIdent(true)
case '\'':
@@ -609,6 +607,15 @@ func scanString(r io.RuneReader) (string, error) {
_, _ = buf.WriteRune('\\')
case '"':
_, _ = buf.WriteRune('"')
case '\'':
_, _ = buf.WriteRune('\'')
case 'x', 'X':
// preserve hex escape sequences (e.g. \xAF) as raw text so the
// parser can interpret them as bytea hex. Write the backslash and
// the x/X character into the output and continue reading the
// subsequent hex digits normally.
_, _ = buf.WriteRune('\\')
_, _ = buf.WriteRune(ch1)
default:
return string(ch0) + string(ch1), errBadEscape
}

3
internal/sql/scanner/scanner_test.go
View File

@@ -269,12 +269,11 @@ func TestScanString(t *testing.T) {
{in: `'foo\r\nbar\r\n\trm'`, out: "foo\r\nbar\r\n\trm"},
{in: `'foo\\bar'`, out: `foo\bar`},
{in: `'foo\"bar'`, out: `foo"bar`},
{in: `'foo\'bar'`, out: `foo'bar`},
{in: `'\xAF'`, out: `\xAF`},
{in: `"foo` + "\n", out: `foo`, err: "bad string"}, // newline in string
{in: `"foo`, out: `foo`, err: "bad string"}, // unclosed quotes
{in: `"foo\xbar"`, out: `\x`, err: "bad escape"}, // invalid escape
{in: `"foo\xbar"`, out: `foo\xbar`, err: ""}, // preserved hex escape sequence
}
for i, tt := range tests {

2
internal/types/bigint.go
View File

@@ -87,7 +87,7 @@ func (v BigintValue) CastAs(target Type) (Value, error) {
return NewTextValue(v.String()), nil
}
return nil, errors.Errorf("cannot cast %s as %s", v.Type(), target)
return nil, errors.Errorf("cannot cast %q as %q", v.Type(), target)
}
func (v BigintValue) EQ(other Value) (bool, error) {

7
internal/types/blob.go
View File

@@ -58,9 +58,10 @@ func (v ByteaValue) String() string {
func (v ByteaValue) MarshalText() ([]byte, error) {
var dst bytes.Buffer
dst.WriteString("\"\\x")
// Use single quotes for SQL bytea hex literal: '\x...'
dst.WriteString("'\\x")
_, _ = hex.NewEncoder(&dst).Write(v)
dst.WriteByte('"')
dst.WriteByte('\'')
return dst.Bytes(), nil
}
@@ -88,7 +89,7 @@ func (v ByteaValue) CastAs(target Type) (Value, error) {
return NewTextValue(base64.StdEncoding.EncodeToString([]byte(v))), nil
}
return nil, errors.Errorf("cannot cast %s as %s", v.Type(), target)
return nil, errors.Errorf("cannot cast %q as %q", v.Type(), target)
}
func (v ByteaValue) EQ(other Value) (bool, error) {

2
internal/types/boolean.go
View File

@@ -83,7 +83,7 @@ func (v BooleanValue) CastAs(target Type) (Value, error) {
return NewTextValue(v.String()), nil
}
return nil, errors.Errorf("cannot cast %s as %s", v.Type(), target)
return nil, errors.Errorf("cannot cast %q as %q", v.Type(), target)
}
func (v BooleanValue) ConvertToIndexedType(t Type) (Value, error) {

2
internal/types/double.go
View File

@@ -122,7 +122,7 @@ func (v DoublePrecisionValue) CastAs(target Type) (Value, error) {
return NewTextValue(string(enc)), nil
}
return nil, errors.Errorf("cannot cast %s as %s", v.Type(), target)
return nil, errors.Errorf("cannot cast %q as %q", v.Type(), target)
}
func (v DoublePrecisionValue) EQ(other Value) (bool, error) {

2
internal/types/integer.go
View File

@@ -90,7 +90,7 @@ func (v IntegerValue) CastAs(target Type) (Value, error) {
return NewTextValue(v.String()), nil
}
return nil, errors.Errorf("cannot cast %s as %s", v.Type(), target)
return nil, errors.Errorf("cannot cast %q as %q", v.Type(), target)
}
func (v IntegerValue) EQ(other Value) (bool, error) {

13
internal/types/text.go
View File

@@ -53,7 +53,12 @@ func (v TextValue) IsZero() (bool, error) {
}
func (v TextValue) String() string {
return strconv.Quote(string(v))
// Use single quotes for SQL string literal representation.
// strconv.Quote always uses double quotes, so build the quoted
// representation manually, escaping single quotes inside the text.
s := string(v)
s = strings.ReplaceAll(s, "'", "\\'")
return "'" + s + "'"
}
func (v TextValue) MarshalText() ([]byte, error) {
@@ -61,7 +66,9 @@ func (v TextValue) MarshalText() ([]byte, error) {
}
func (v TextValue) MarshalJSON() ([]byte, error) {
return v.MarshalText()
// JSON must use double quotes. Use strconv.Quote to produce a valid
// JSON string regardless of the SQL text literal representation.
return []byte(strconv.Quote(string(v))), nil
}
func (v TextValue) Encode(dst []byte) ([]byte, error) {
@@ -129,7 +136,7 @@ func (v TextValue) CastAs(target Type) (Value, error) {
return NewByteaValue(b), nil
}
return nil, errors.Errorf("cannot cast %s as %s", v.Type(), target)
return nil, errors.Errorf("cannot cast %q as %q", v.Type(), target)
}
func (v TextValue) EQ(other Value) (bool, error) {

2
internal/types/timestamp.go
View File

@@ -86,7 +86,7 @@ func (v TimestampValue) CastAs(target Type) (Value, error) {
return NewTextValue(v.String()), nil
}
return nil, errors.Errorf("cannot cast %s as %s", v.Type(), target)
return nil, errors.Errorf("cannot cast %q as %q", v.Type(), target)
}
func (v TimestampValue) EQ(other Value) (bool, error) {

4
internal/types/value_test.go
View File

@@ -20,8 +20,8 @@ func TestValueMarshalText(t *testing.T) {
value any
expected string
}{
{"bytes", []byte("bar"), `"\x626172"`},
{"string", "bar", `"bar"`},
{"bytes", []byte("bar"), `'\x626172'`},
{"string", "bar", `'bar'`},
{"bool", true, "true"},
{"int", int32(10), "10"},
{"float64", 10.0, "10.0"},

30
sqltests/ALTER_TABLE/add_column.sql
View File

@@ -4,11 +4,11 @@ CREATE TABLE test(a int primary key);
-- test: column constraints are updated
INSERT INTO test VALUES (1), (2);
ALTER TABLE test ADD COLUMN b int DEFAULT 0;
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND name = "test";
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND name = 'test';
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (a INTEGER NOT NULL, b INTEGER DEFAULT 0, CONSTRAINT test_pk PRIMARY KEY (a))"
name: 'test',
sql: 'CREATE TABLE test (a INTEGER NOT NULL, b INTEGER DEFAULT 0, CONSTRAINT test_pk PRIMARY KEY (a))'
}
*/
@@ -18,12 +18,12 @@ ALTER TABLE test ADD COLUMN b int DEFAULT 0;
SELECT * FROM test;
/* result:
{
"a": 1,
"b": 0
a: 1,
b: 0
}
{
"a": 2,
"b": 0
a: 2,
b: 0
}
*/
@@ -38,12 +38,12 @@ ALTER TABLE test ADD COLUMN b int NOT NULL DEFAULT 10;
SELECT * FROM test;
/* result:
{
"a": 1,
"b": 10,
a: 1,
b: 10,
}
{
"a": 2,
"b": 10
a: 2,
b: 10
}
*/
@@ -53,12 +53,12 @@ ALTER TABLE test ADD COLUMN b int UNIQUE;
SELECT * FROM test;
/* result:
{
"a": 1,
"b": null
a: 1,
b: null
}
{
"a": 2,
"b": null
a: 2,
b: null
}
*/

6
sqltests/ALTER_TABLE/rename.sql
View File

@@ -3,11 +3,11 @@ CREATE TABLE test(a int primary key);
-- test: rename
ALTER TABLE test RENAME TO test2;
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND (name = "test2" OR name = "test");
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND (name = 'test2' OR name = 'test');
/* result:
{
"name": "test2",
"sql": "CREATE TABLE test2 (a INTEGER NOT NULL, CONSTRAINT test_pk PRIMARY KEY (a))"
"name": 'test2',
"sql": 'CREATE TABLE test2 (a INTEGER NOT NULL, CONSTRAINT test_pk PRIMARY KEY (a))'
}
*/

50
sqltests/CREATE_INDEX/base.sql
View File

@@ -3,23 +3,23 @@ CREATE TABLE test (a int primary key);
-- test: named index
CREATE INDEX test_a_idx ON test(a);
SELECT name, owner_table_name AS table_name, sql FROM __chai_catalog WHERE type = "index";
SELECT name, owner_table_name AS table_name, sql FROM __chai_catalog WHERE type = 'index';
/* result:
{
"name": "test_a_idx",
"table_name": "test",
"sql": "CREATE INDEX test_a_idx ON test (a)"
"name": 'test_a_idx',
"table_name": 'test',
"sql": 'CREATE INDEX test_a_idx ON test (a)'
}
*/
-- test: named unique index
CREATE UNIQUE INDEX test_a_idx ON test(a);
SELECT name, owner_table_name AS table_name, sql FROM __chai_catalog WHERE type = "index";
SELECT name, owner_table_name AS table_name, sql FROM __chai_catalog WHERE type = 'index';
/* result:
{
"name": "test_a_idx",
"table_name": "test",
"sql": "CREATE UNIQUE INDEX test_a_idx ON test (a)"
"name": 'test_a_idx',
"table_name": 'test',
"sql": 'CREATE UNIQUE INDEX test_a_idx ON test (a)',
}
*/
@@ -36,12 +36,12 @@ CREATE UNIQUE INDEX test_a_idx ON test(a);
-- test: IF NOT EXISTS
CREATE INDEX test_a_idx ON test(a);
CREATE INDEX IF NOT EXISTS test_a_idx ON test(a);
SELECT name, owner_table_name AS table_name, sql FROM __chai_catalog WHERE type = "index";
SELECT name, owner_table_name AS table_name, sql FROM __chai_catalog WHERE type = 'index';
/* result:
{
"name": "test_a_idx",
"table_name": "test",
"sql": "CREATE INDEX test_a_idx ON test (a)"
"name": 'test_a_idx',
"table_name": 'test',
"sql": 'CREATE INDEX test_a_idx ON test (a)'
}
*/
@@ -50,27 +50,27 @@ CREATE INDEX ON test(a);
CREATE INDEX ON test(a);
CREATE INDEX test_a_idx2 ON test(a);
CREATE INDEX ON test(a);
SELECT name, owner_table_name AS table_name, sql FROM __chai_catalog WHERE type = "index" ORDER BY name;
SELECT name, owner_table_name AS table_name, sql FROM __chai_catalog WHERE type = 'index' ORDER BY name;
/* result:
{
"name": "test_a_idx",
"table_name": "test",
"sql": "CREATE INDEX test_a_idx ON test (a)"
"name": 'test_a_idx',
"table_name": 'test',
"sql": 'CREATE INDEX test_a_idx ON test (a)'
}
{
"name": "test_a_idx1",
"table_name": "test",
"sql": "CREATE INDEX test_a_idx1 ON test (a)"
"name": 'test_a_idx1',
"table_name": 'test',
"sql": 'CREATE INDEX test_a_idx1 ON test (a)'
}
{
"name": "test_a_idx2",
"table_name": "test",
"sql": "CREATE INDEX test_a_idx2 ON test (a)"
"name": 'test_a_idx2',
"table_name": 'test',
"sql": 'CREATE INDEX test_a_idx2 ON test (a)'
}
{
"name": "test_a_idx3",
"table_name": "test",
"sql": "CREATE INDEX test_a_idx3 ON test (a)"
"name": 'test_a_idx3',
"table_name": 'test',
"sql": 'CREATE INDEX test_a_idx3 ON test (a)'
}
*/

22
sqltests/CREATE_SEQUENCE/basic.sql
View File

@@ -1,38 +1,38 @@
-- test: no config
CREATE SEQUENCE seq;
SELECT name, type, sql FROM __chai_catalog WHERE type = "sequence" AND name = "seq";
SELECT name, type, sql FROM __chai_catalog WHERE type = 'sequence' AND name = 'seq';
/* result:
{
"name": "seq",
"type": "sequence",
"sql": "CREATE SEQUENCE seq"
"name": 'seq',
"type": 'sequence',
"sql": 'CREATE SEQUENCE seq'
}
*/
-- test: __chai_sequence table
CREATE SEQUENCE seq;
SELECT name FROM __chai_sequence WHERE name = "seq";
SELECT name FROM __chai_sequence WHERE name = 'seq';
/* result:
{
"name": "seq"
"name": 'seq'
}
*/
-- test: IF NOT EXISTS
CREATE SEQUENCE IF NOT EXISTS seq;
SELECT name, type, sql FROM __chai_catalog WHERE type = "sequence" AND name = "seq";
SELECT name, type, sql FROM __chai_catalog WHERE type = 'sequence' AND name = 'seq';
/* result:
{
"name": "seq",
"type": "sequence",
"sql": "CREATE SEQUENCE seq"
"name": 'seq',
"type": 'sequence',
"sql": 'CREATE SEQUENCE seq'
}
*/
-- test: IF NOT EXISTS is idempotent
CREATE SEQUENCE IF NOT EXISTS seq;
CREATE SEQUENCE IF NOT EXISTS seq;
SELECT COUNT(*) AS c FROM __chai_sequence WHERE name = "seq";
SELECT COUNT(*) AS c FROM __chai_sequence WHERE name = 'seq';
/* result:
{
"c": 1

24
sqltests/CREATE_SEQUENCE/cache_cycle.sql
View File

@@ -1,11 +1,11 @@
-- test: CACHE 10
CREATE SEQUENCE seq CACHE 10;
SELECT name, type, sql FROM __chai_catalog WHERE type = "sequence" AND name = "seq";
SELECT name, type, sql FROM __chai_catalog WHERE type = 'sequence' AND name = 'seq';
/* result:
{
"name": "seq",
"type": "sequence",
"sql": "CREATE SEQUENCE seq CACHE 10"
"name": 'seq',
"type": 'sequence',
"sql": 'CREATE SEQUENCE seq CACHE 10'
}
*/
@@ -23,22 +23,22 @@ CREATE SEQUENCE seq CACHE 0;
-- test: CACHE 1 should be default and not printed
CREATE SEQUENCE seq CACHE 1;
SELECT name, type, sql FROM __chai_catalog WHERE type = "sequence" AND name = "seq";
SELECT name, type, sql FROM __chai_catalog WHERE type = 'sequence' AND name = 'seq';
/* result:
{
"name": "seq",
"type": "sequence",
"sql": "CREATE SEQUENCE seq"
"name": 'seq',
"type": 'sequence',
"sql": 'CREATE SEQUENCE seq'
}
*/
-- test: CYCLE
CREATE SEQUENCE seq CYCLE;
SELECT name, type, sql FROM __chai_catalog WHERE type = "sequence" AND name = "seq";
SELECT name, type, sql FROM __chai_catalog WHERE type = 'sequence' AND name = 'seq';
/* result:
{
"name": "seq",
"type": "sequence",
"sql": "CREATE SEQUENCE seq CYCLE"
"name": 'seq',
"type": 'sequence',
"sql": 'CREATE SEQUENCE seq CYCLE'
}
*/

40
sqltests/CREATE_SEQUENCE/combinations.sql
View File

@@ -1,22 +1,22 @@
-- test: ORDER 1 (combined options)
CREATE SEQUENCE seq AS INTEGER INCREMENT BY 2 NO MINVALUE MAXVALUE 10 START WITH 5 CACHE 5 CYCLE;
SELECT name, type, sql FROM __chai_catalog WHERE type = "sequence" AND name = "seq";
SELECT name, type, sql FROM __chai_catalog WHERE type = 'sequence' AND name = 'seq';
/* result:
{
"name": "seq",
"type": "sequence",
"sql": "CREATE SEQUENCE seq INCREMENT BY 2 MAXVALUE 10 START WITH 5 CACHE 5 CYCLE"
"name": 'seq',
"type": 'sequence',
"sql": 'CREATE SEQUENCE seq INCREMENT BY 2 MAXVALUE 10 START WITH 5 CACHE 5 CYCLE'
}
*/
-- test: ORDER 2 (same options different order)
CREATE SEQUENCE seq CYCLE MAXVALUE 10 INCREMENT BY 2 START WITH 5 AS INTEGER NO MINVALUE CACHE 5;
SELECT name, type, sql FROM __chai_catalog WHERE type = "sequence" AND name = "seq";
SELECT name, type, sql FROM __chai_catalog WHERE type = 'sequence' AND name = 'seq';
/* result:
{
"name": "seq",
"type": "sequence",
"sql": "CREATE SEQUENCE seq INCREMENT BY 2 MAXVALUE 10 START WITH 5 CACHE 5 CYCLE"
"name": 'seq',
"type": 'sequence',
"sql": 'CREATE SEQUENCE seq INCREMENT BY 2 MAXVALUE 10 START WITH 5 CACHE 5 CYCLE'
}
*/
@@ -46,33 +46,33 @@ CREATE SEQUENCE seq MINVALUE 5 MAXVALUE 10 START -100;
-- test: DESC MINVALUE/MAXVALUE
CREATE SEQUENCE seq MINVALUE 10 MAXVALUE 100 INCREMENT BY -1;
SELECT name, type, sql FROM __chai_catalog WHERE type = "sequence" AND name = "seq";
SELECT name, type, sql FROM __chai_catalog WHERE type = 'sequence' AND name = 'seq';
/* result:
{
"name": "seq",
"type": "sequence",
"sql": "CREATE SEQUENCE seq INCREMENT BY -1 MINVALUE 10 MAXVALUE 100"
"name": 'seq',
"type": 'sequence',
"sql": 'CREATE SEQUENCE seq INCREMENT BY -1 MINVALUE 10 MAXVALUE 100'
}
*/
-- test: NO MINVALUE DESC
CREATE SEQUENCE seq NO MINVALUE MAXVALUE 100 INCREMENT BY -1;
SELECT name, type, sql FROM __chai_catalog WHERE type = "sequence" AND name = "seq";
SELECT name, type, sql FROM __chai_catalog WHERE type = 'sequence' AND name = 'seq';
/* result:
{
"name": "seq",
"type": "sequence",
"sql": "CREATE SEQUENCE seq INCREMENT BY -1 MAXVALUE 100"
"name": 'seq',
"type": 'sequence',
"sql": 'CREATE SEQUENCE seq INCREMENT BY -1 MAXVALUE 100'
}
*/
-- test: NO MAXVALUE DESC (should only print increment)
CREATE SEQUENCE seq NO MINVALUE NO MAXVALUE INCREMENT BY -1;
SELECT name, type, sql FROM __chai_catalog WHERE type = "sequence" AND name = "seq";
SELECT name, type, sql FROM __chai_catalog WHERE type = 'sequence' AND name = 'seq';
/* result:
{
"name": "seq",
"type": "sequence",
"sql": "CREATE SEQUENCE seq INCREMENT BY -1"
"name": 'seq',
"type": 'sequence',
"sql": 'CREATE SEQUENCE seq INCREMENT BY -1'
}
*/

16
sqltests/CREATE_SEQUENCE/edge_cases.sql
View File

@@ -32,12 +32,12 @@ CREATE SEQUENCE seq CYCLE CYCLE;
-- test: INCREMENT shorthand negative
CREATE SEQUENCE seq INCREMENT -1;
SELECT name, type, sql FROM __chai_catalog WHERE type = "sequence" AND name = "seq";
SELECT name, type, sql FROM __chai_catalog WHERE type = 'sequence' AND name = 'seq';
/* result:
{
"name": "seq",
"type": "sequence",
"sql": "CREATE SEQUENCE seq INCREMENT BY -1"
"name": 'seq',
"type": 'sequence',
"sql": 'CREATE SEQUENCE seq INCREMENT BY -1'
}
*/
@@ -47,12 +47,12 @@ CREATE SEQUENCE seq CACHE 0;
-- test: CACHE 1 should be default and not printed
CREATE SEQUENCE seq CACHE 1;
SELECT name, type, sql FROM __chai_catalog WHERE type = "sequence" AND name = "seq";
SELECT name, type, sql FROM __chai_catalog WHERE type = 'sequence' AND name = 'seq';
/* result:
{
"name": "seq",
"type": "sequence",
"sql": "CREATE SEQUENCE seq"
"name": 'seq',
"type": 'sequence',
"sql": 'CREATE SEQUENCE seq'
}
*/

32
sqltests/CREATE_SEQUENCE/increment.sql
View File

@@ -1,22 +1,22 @@
-- test: INCREMENT 10
CREATE SEQUENCE seq INCREMENT 10;
SELECT name, type, sql FROM __chai_catalog WHERE type = "sequence" AND name = "seq";
SELECT name, type, sql FROM __chai_catalog WHERE type = 'sequence' AND name = 'seq';
/* result:
{
"name": "seq",
"type": "sequence",
"sql": "CREATE SEQUENCE seq INCREMENT BY 10"
"name": 'seq',
"type": 'sequence',
"sql": 'CREATE SEQUENCE seq INCREMENT BY 10'
}
*/
-- test: INCREMENT BY 10
CREATE SEQUENCE seq INCREMENT BY 10;
SELECT name, type, sql FROM __chai_catalog WHERE type = "sequence" AND name = "seq";
SELECT name, type, sql FROM __chai_catalog WHERE type = 'sequence' AND name = 'seq';
/* result:
{
"name": "seq",
"type": "sequence",
"sql": "CREATE SEQUENCE seq INCREMENT BY 10"
"name": 'seq',
"type": 'sequence',
"sql": 'CREATE SEQUENCE seq INCREMENT BY 10'
}
*/
@@ -26,23 +26,23 @@ CREATE SEQUENCE seq INCREMENT BY 0;
-- test: INCREMENT BY -10
CREATE SEQUENCE seq INCREMENT BY -10;
SELECT name, type, sql FROM __chai_catalog WHERE type = "sequence" AND name = "seq";
SELECT name, type, sql FROM __chai_catalog WHERE type = 'sequence' AND name = 'seq';
/* result:
{
"name": "seq",
"type": "sequence",
"sql": "CREATE SEQUENCE seq INCREMENT BY -10"
"name": 'seq',
"type": 'sequence',
"sql": 'CREATE SEQUENCE seq INCREMENT BY -10'
}
*/
-- test: INCREMENT shorthand negative
CREATE SEQUENCE seq INCREMENT -1;
SELECT name, type, sql FROM __chai_catalog WHERE type = "sequence" AND name = "seq";
SELECT name, type, sql FROM __chai_catalog WHERE type = 'sequence' AND name = 'seq';
/* result:
{
"name": "seq",
"type": "sequence",
"sql": "CREATE SEQUENCE seq INCREMENT BY -1"
"name": 'seq',
"type": 'sequence',
"sql": 'CREATE SEQUENCE seq INCREMENT BY -1'
}
*/

56
sqltests/CREATE_SEQUENCE/ranges.sql
View File

@@ -1,33 +1,33 @@
-- test: NO MINVALUE
CREATE SEQUENCE seq NO MINVALUE;
SELECT name, type, sql FROM __chai_catalog WHERE type = "sequence" AND name = "seq";
SELECT name, type, sql FROM __chai_catalog WHERE type = 'sequence' AND name = 'seq';
/* result:
{
"name": "seq",
"type": "sequence",
"sql": "CREATE SEQUENCE seq"
"name": 'seq',
"type": 'sequence',
"sql": 'CREATE SEQUENCE seq'
}
*/
-- test: NO MAXVALUE
CREATE SEQUENCE seq NO MAXVALUE;
SELECT name, type, sql FROM __chai_catalog WHERE type = "sequence" AND name = "seq";
SELECT name, type, sql FROM __chai_catalog WHERE type = 'sequence' AND name = 'seq';
/* result:
{
"name": "seq",
"type": "sequence",
"sql": "CREATE SEQUENCE seq"
"name": 'seq',
"type": 'sequence',
"sql": 'CREATE SEQUENCE seq'
}
*/
-- test: MINVALUE 10
CREATE SEQUENCE seq MINVALUE 10;
SELECT name, type, sql FROM __chai_catalog WHERE type = "sequence" AND name = "seq";
SELECT name, type, sql FROM __chai_catalog WHERE type = 'sequence' AND name = 'seq';
/* result:
{
"name": "seq",
"type": "sequence",
"sql": "CREATE SEQUENCE seq MINVALUE 10"
"name": 'seq',
"type": 'sequence',
"sql": 'CREATE SEQUENCE seq MINVALUE 10'
}
*/
@@ -37,12 +37,12 @@ CREATE SEQUENCE seq MINVALUE 'hello';
-- test: MAXVALUE 10
CREATE SEQUENCE seq MAXVALUE 10;
SELECT name, type, sql FROM __chai_catalog WHERE type = "sequence" AND name = "seq";
SELECT name, type, sql FROM __chai_catalog WHERE type = 'sequence' AND name = 'seq';
/* result:
{
"name": "seq",
"type": "sequence",
"sql": "CREATE SEQUENCE seq MAXVALUE 10"
"name": 'seq',
"type": 'sequence',
"sql": 'CREATE SEQUENCE seq MAXVALUE 10'
}
*/
@@ -52,12 +52,12 @@ CREATE SEQUENCE seq MAXVALUE 'hello';
-- test: START WITH 10
CREATE SEQUENCE seq START WITH 10;
SELECT name, type, sql FROM __chai_catalog WHERE type = "sequence" AND name = "seq";
SELECT name, type, sql FROM __chai_catalog WHERE type = 'sequence' AND name = 'seq';
/* result:
{
"name": "seq",
"type": "sequence",
"sql": "CREATE SEQUENCE seq START WITH 10"
"name": 'seq',
"type": 'sequence',
"sql": 'CREATE SEQUENCE seq START WITH 10'
}
*/
@@ -67,22 +67,22 @@ CREATE SEQUENCE seq START WITH 'hello';
-- test: START 10
CREATE SEQUENCE seq START 10;
SELECT name, type, sql FROM __chai_catalog WHERE type = "sequence" AND name = "seq";
SELECT name, type, sql FROM __chai_catalog WHERE type = 'sequence' AND name = 'seq';
/* result:
{
"name": "seq",
"type": "sequence",
"sql": "CREATE SEQUENCE seq START WITH 10"
"name": 'seq',
"type": 'sequence',
"sql": 'CREATE SEQUENCE seq START WITH 10'
}
*/
-- test: START equal to default should be omitted
CREATE SEQUENCE seq START 1;
SELECT name, type, sql FROM __chai_catalog WHERE type = "sequence" AND name = "seq";
SELECT name, type, sql FROM __chai_catalog WHERE type = 'sequence' AND name = 'seq';
/* result:
{
"name": "seq",
"type": "sequence",
"sql": "CREATE SEQUENCE seq"
"name": 'seq',
"type": 'sequence',
"sql": 'CREATE SEQUENCE seq'
}
*/

24
sqltests/CREATE_SEQUENCE/types.sql
View File

@@ -1,11 +1,11 @@
-- test: AS TINYINT (use bigint for Postgres compatibility)
CREATE SEQUENCE seq AS bigint;
SELECT name, type, sql FROM __chai_catalog WHERE type = "sequence" AND name = "seq";
SELECT name, type, sql FROM __chai_catalog WHERE type = 'sequence' AND name = 'seq';
/* result:
{
"name": "seq",
"type": "sequence",
"sql": "CREATE SEQUENCE seq"
"name": 'seq',
"type": 'sequence',
"sql": 'CREATE SEQUENCE seq'
}
*/
@@ -15,22 +15,22 @@ CREATE SEQUENCE seq AS DOUBLE;
-- test: AS INT is accepted (no-op in canonical SQL)
CREATE SEQUENCE seq AS INT;
SELECT name, type, sql FROM __chai_catalog WHERE type = "sequence" AND name = "seq";
SELECT name, type, sql FROM __chai_catalog WHERE type = 'sequence' AND name = 'seq';
/* result:
{
"name": "seq",
"type": "sequence",
"sql": "CREATE SEQUENCE seq"
"name": 'seq',
"type": 'sequence',
"sql": 'CREATE SEQUENCE seq'
}
*/
-- test: AS SMALLINT is accepted (no-op in canonical SQL)
CREATE SEQUENCE seq AS SMALLINT;
SELECT name, type, sql FROM __chai_catalog WHERE type = "sequence" AND name = "seq";
SELECT name, type, sql FROM __chai_catalog WHERE type = 'sequence' AND name = 'seq';
/* result:
{
"name": "seq",
"type": "sequence",
"sql": "CREATE SEQUENCE seq"
"name": 'seq',
"type": 'sequence',
"sql": 'CREATE SEQUENCE seq'
}
*/

18
sqltests/CREATE_TABLE/base.sql
View File

@@ -1,10 +1,10 @@
-- test: basic
CREATE TABLE test(a int primary key);
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND name = "test";
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND name = 'test';
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (a INTEGER NOT NULL, CONSTRAINT test_pk PRIMARY KEY (a))"
"name": 'test',
"sql": 'CREATE TABLE test (a INTEGER NOT NULL, CONSTRAINT test_pk PRIMARY KEY (a))'
}
*/
@@ -16,21 +16,21 @@ CREATE TABLE test(a int primary key);
-- test: if not exists
CREATE TABLE test(a int primary key);
CREATE TABLE IF NOT EXISTS test(b int primary key);
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND name = "test";
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND name = 'test';
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (a INTEGER NOT NULL, CONSTRAINT test_pk PRIMARY KEY (a))"
"name": 'test',
"sql": 'CREATE TABLE test (a INTEGER NOT NULL, CONSTRAINT test_pk PRIMARY KEY (a))'
}
*/
-- test: if not exists, twice
CREATE TABLE IF NOT EXISTS test(a int primary key);
CREATE TABLE IF NOT EXISTS test(a int primary key);
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND name = "test";
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND name = 'test';
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (a INTEGER NOT NULL, CONSTRAINT test_pk PRIMARY KEY (a))"
"name": 'test',
"sql": 'CREATE TABLE test (a INTEGER NOT NULL, CONSTRAINT test_pk PRIMARY KEY (a))'
}
*/

40
sqltests/CREATE_TABLE/check.sql
View File

@@ -2,12 +2,12 @@
CREATE TABLE test (
a INT PRIMARY KEY CHECK(a > 10 AND a < 20)
);
SELECT name, type, sql FROM __chai_catalog WHERE name = "test";
SELECT name, type, sql FROM __chai_catalog WHERE name = 'test';
/* result:
{
name: "test",
type: "table",
sql: "CREATE TABLE test (a INTEGER NOT NULL, CONSTRAINT test_pk PRIMARY KEY (a), CONSTRAINT test_check CHECK (a > 10 AND a < 20))"
name: 'test',
type: 'table',
sql: 'CREATE TABLE test (a INTEGER NOT NULL, CONSTRAINT test_pk PRIMARY KEY (a), CONSTRAINT test_check CHECK (a > 10 AND a < 20))'
}
*/
@@ -21,12 +21,12 @@ CREATE TABLE test (
CREATE TABLE test (
a INT CHECK (a > 10) DEFAULT 100 NOT NULL PRIMARY KEY
);
SELECT name, type, sql FROM __chai_catalog WHERE name = "test";
SELECT name, type, sql FROM __chai_catalog WHERE name = 'test';
/* result:
{
name: "test",
type: "table",
sql: "CREATE TABLE test (a INTEGER NOT NULL DEFAULT 100, CONSTRAINT test_check CHECK (a > 10), CONSTRAINT test_pk PRIMARY KEY (a))"
name: 'test',
type: 'table',
sql: 'CREATE TABLE test (a INTEGER NOT NULL DEFAULT 100, CONSTRAINT test_check CHECK (a > 10), CONSTRAINT test_pk PRIMARY KEY (a))'
}
*/
@@ -40,12 +40,12 @@ CREATE TABLE test (
CREATE TABLE test (
a INT PRIMARY KEY CHECK (a > 10) DEFAULT 0
);
SELECT name, type, sql FROM __chai_catalog WHERE name = "test";
SELECT name, type, sql FROM __chai_catalog WHERE name = 'test';
/* result:
{
name: "test",
type: "table",
sql: "CREATE TABLE test (a INTEGER NOT NULL DEFAULT 0, CONSTRAINT test_pk PRIMARY KEY (a), CONSTRAINT test_check CHECK (a > 10))"
name: 'test',
type: 'table',
sql: 'CREATE TABLE test (a INTEGER NOT NULL DEFAULT 0, CONSTRAINT test_pk PRIMARY KEY (a), CONSTRAINT test_check CHECK (a > 10))'
}
*/
@@ -54,12 +54,12 @@ CREATE TABLE test (
a INT PRIMARY KEY CHECK (a > 10 AND b < 10),
b INT
);
SELECT name, type, sql FROM __chai_catalog WHERE name = "test";
SELECT name, type, sql FROM __chai_catalog WHERE name = 'test';
/* result:
{
name: "test",
type: "table",
sql: "CREATE TABLE test (a INTEGER NOT NULL, b INTEGER, CONSTRAINT test_pk PRIMARY KEY (a), CONSTRAINT test_check CHECK (a > 10 AND b < 10))"
name: 'test',
type: 'table',
sql: 'CREATE TABLE test (a INTEGER NOT NULL, b INTEGER, CONSTRAINT test_pk PRIMARY KEY (a), CONSTRAINT test_check CHECK (a > 10 AND b < 10))'
}
*/
@@ -69,11 +69,11 @@ CREATE TABLE test (
CHECK (a > 10),
CHECK (a > 20)
);
SELECT name, type, sql FROM __chai_catalog WHERE name = "test";
SELECT name, type, sql FROM __chai_catalog WHERE name = 'test';
/* result:
{
name: "test",
type: "table",
sql: "CREATE TABLE test (a INTEGER NOT NULL, CONSTRAINT test_pk PRIMARY KEY (a), CONSTRAINT test_check CHECK (a > 10), CONSTRAINT test_check1 CHECK (a > 20))"
name: 'test',
type: 'table',
sql: 'CREATE TABLE test (a INTEGER NOT NULL, CONSTRAINT test_pk PRIMARY KEY (a), CONSTRAINT test_check CHECK (a > 10), CONSTRAINT test_check1 CHECK (a > 20))'
}
*/

36
sqltests/CREATE_TABLE/constraints.sql
View File

@@ -1,59 +1,59 @@
-- test: type
CREATE TABLE test(pk INT PRIMARY KEY, a INTEGER);
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND name = "test";
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND name = 'test';
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (pk INTEGER NOT NULL, a INTEGER, CONSTRAINT test_pk PRIMARY KEY (pk))"
"name": 'test',
"sql": 'CREATE TABLE test (pk INTEGER NOT NULL, a INTEGER, CONSTRAINT test_pk PRIMARY KEY (pk))'
}
*/
-- test: NOT NULL
CREATE TABLE test(pk INT PRIMARY KEY, a INT NOT NULL);
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND name = "test";
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND name = 'test';
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (pk INTEGER NOT NULL, a INTEGER NOT NULL, CONSTRAINT test_pk PRIMARY KEY (pk))"
"name": 'test',
"sql": 'CREATE TABLE test (pk INTEGER NOT NULL, a INTEGER NOT NULL, CONSTRAINT test_pk PRIMARY KEY (pk))'
}
*/
-- test: default
CREATE TABLE test(pk INT PRIMARY KEY, a INT DEFAULT 10);
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND name = "test";
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND name = 'test';
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (pk INTEGER NOT NULL, a INTEGER DEFAULT 10, CONSTRAINT test_pk PRIMARY KEY (pk))"
"name": 'test',
"sql": 'CREATE TABLE test (pk INTEGER NOT NULL, a INTEGER DEFAULT 10, CONSTRAINT test_pk PRIMARY KEY (pk))'
}
*/
-- test: unique
CREATE TABLE test(pk INT PRIMARY KEY, a INT UNIQUE);
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND name = "test";
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND name = 'test';
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (pk INTEGER NOT NULL, a INTEGER, CONSTRAINT test_pk PRIMARY KEY (pk), CONSTRAINT test_a_unique UNIQUE (a))"
"name": 'test',
"sql": 'CREATE TABLE test (pk INTEGER NOT NULL, a INTEGER, CONSTRAINT test_pk PRIMARY KEY (pk), CONSTRAINT test_a_unique UNIQUE (a))'
}
*/
-- test: check
CREATE TABLE test(pk INT PRIMARY KEY, a INT CHECK(a > 10));
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND name = "test";
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND name = 'test';
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (pk INTEGER NOT NULL, a INTEGER, CONSTRAINT test_pk PRIMARY KEY (pk), CONSTRAINT test_check CHECK (a > 10))"
"name": 'test',
"sql": 'CREATE TABLE test (pk INTEGER NOT NULL, a INTEGER, CONSTRAINT test_pk PRIMARY KEY (pk), CONSTRAINT test_check CHECK (a > 10))'
}
*/
-- test: all compatible constraints
CREATE TABLE test(a INT PRIMARY KEY NOT NULL DEFAULT 10 UNIQUE CHECK(a >= 10));
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND name = "test";
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND name = 'test';
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (a INTEGER NOT NULL DEFAULT 10, CONSTRAINT test_pk PRIMARY KEY (a), CONSTRAINT test_a_unique UNIQUE (a), CONSTRAINT test_check CHECK (a >= 10))"
"name": 'test',
"sql": 'CREATE TABLE test (a INTEGER NOT NULL DEFAULT 10, CONSTRAINT test_pk PRIMARY KEY (a), CONSTRAINT test_a_unique UNIQUE (a), CONSTRAINT test_check CHECK (a >= 10))'
}
*/

72
sqltests/CREATE_TABLE/default.sql
View File

@@ -1,30 +1,30 @@
-- test: same type
CREATE TABLE test(pk INT PRIMARY KEY, a INT DEFAULT 10);
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND name = "test";
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND name = 'test';
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (pk INTEGER NOT NULL, a INTEGER DEFAULT 10, CONSTRAINT test_pk PRIMARY KEY (pk))"
"name": 'test',
"sql": 'CREATE TABLE test (pk INTEGER NOT NULL, a INTEGER DEFAULT 10, CONSTRAINT test_pk PRIMARY KEY (pk))'
}
*/
-- test: compatible type
CREATE TABLE test(pk INT PRIMARY KEY, a DOUBLE PRECISION DEFAULT 10);
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND name = "test";
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND name = 'test';
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (pk INTEGER NOT NULL, a DOUBLE PRECISION DEFAULT 10, CONSTRAINT test_pk PRIMARY KEY (pk))"
"name": 'test',
"sql": 'CREATE TABLE test (pk INTEGER NOT NULL, a DOUBLE PRECISION DEFAULT 10, CONSTRAINT test_pk PRIMARY KEY (pk))'
}
*/
-- test: expr
CREATE TABLE test(pk INT PRIMARY KEY, a DOUBLE PRECISION DEFAULT 1 + 4 / 4);
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND name = "test";
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND name = 'test';
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (pk INTEGER NOT NULL, a DOUBLE PRECISION DEFAULT 1 + 4 / 4, CONSTRAINT test_pk PRIMARY KEY (pk))"
"name": 'test',
"sql": 'CREATE TABLE test (pk INTEGER NOT NULL, a DOUBLE PRECISION DEFAULT 1 + 4 / 4, CONSTRAINT test_pk PRIMARY KEY (pk))'
}
*/
@@ -38,21 +38,21 @@ CREATE TABLE test(pk INT PRIMARY KEY, a DOUBLE PRECISION DEFAULT pk());
-- test: compatible type
CREATE TABLE test(pk INT PRIMARY KEY, a DOUBLE PRECISION DEFAULT 10);
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND name = "test";
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND name = 'test';
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (pk INTEGER NOT NULL, a DOUBLE PRECISION DEFAULT 10, CONSTRAINT test_pk PRIMARY KEY (pk))"
"name": 'test',
"sql": 'CREATE TABLE test (pk INTEGER NOT NULL, a DOUBLE PRECISION DEFAULT 10, CONSTRAINT test_pk PRIMARY KEY (pk))'
}
*/
-- test: expr
CREATE TABLE test(pk INT PRIMARY KEY, a DOUBLE PRECISION DEFAULT 1 + 4 / 4);
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND name = "test";
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND name = 'test';
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (pk INTEGER NOT NULL, a DOUBLE PRECISION DEFAULT 1 + 4 / 4, CONSTRAINT test_pk PRIMARY KEY (pk))"
"name": 'test',
"sql": 'CREATE TABLE test (pk INTEGER NOT NULL, a DOUBLE PRECISION DEFAULT 1 + 4 / 4, CONSTRAINT test_pk PRIMARY KEY (pk))'
}
*/
@@ -65,31 +65,31 @@ CREATE TABLE test(pk INT PRIMARY KEY, a DOUBLE PRECISION DEFAULT pk());
-- error:
-- test: same type
CREATE TABLE test(pk INT PRIMARY KEY, a INT DEFAULT 10);
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND name = "test";
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND name = 'test';
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (pk INTEGER NOT NULL, a INTEGER DEFAULT 10, CONSTRAINT test_pk PRIMARY KEY (pk))"
"name": 'test',
"sql": 'CREATE TABLE test (pk INTEGER NOT NULL, a INTEGER DEFAULT 10, CONSTRAINT test_pk PRIMARY KEY (pk))'
}
*/
-- test: compatible type
CREATE TABLE test(pk INT PRIMARY KEY, a DOUBLE PRECISION DEFAULT 10);
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND name = "test";
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND name = 'test';
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (pk INTEGER NOT NULL, a DOUBLE PRECISION DEFAULT 10, CONSTRAINT test_pk PRIMARY KEY (pk))"
"name": 'test',
"sql": 'CREATE TABLE test (pk INTEGER NOT NULL, a DOUBLE PRECISION DEFAULT 10, CONSTRAINT test_pk PRIMARY KEY (pk))'
}
*/
-- test: expr
CREATE TABLE test(pk INT PRIMARY KEY, a DOUBLE PRECISION DEFAULT 1 + 4 / 4);
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND name = "test";
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND name = 'test';
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (pk INTEGER NOT NULL, a DOUBLE PRECISION DEFAULT 1 + 4 / 4, CONSTRAINT test_pk PRIMARY KEY (pk))"
"name": 'test',
"sql": 'CREATE TABLE test (pk INTEGER NOT NULL, a DOUBLE PRECISION DEFAULT 1 + 4 / 4, CONSTRAINT test_pk PRIMARY KEY (pk))'
}
*/
@@ -116,42 +116,42 @@ CREATE TABLE test(pk INT PRIMARY KEY, a BYTEA DEFAULT b);
-- test: DEFAULT nextval sequence
CREATE SEQUENCE seq1;
CREATE TABLE test(pk INT PRIMARY KEY, a INTEGER DEFAULT nextval('seq1'));
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND name = "test";
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND name = 'test';
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (pk INTEGER NOT NULL, a INTEGER DEFAULT nextval(\"seq1\"), CONSTRAINT test_pk PRIMARY KEY (pk))"
"name": 'test',
"sql": 'CREATE TABLE test (pk INTEGER NOT NULL, a INTEGER DEFAULT nextval(\'seq1\'), CONSTRAINT test_pk PRIMARY KEY (pk))'
}
*/
-- test: DEFAULT with parentheses
CREATE TABLE test(pk INT PRIMARY KEY, a INTEGER DEFAULT (1 + 2));
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND name = "test";
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND name = 'test';
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (pk INTEGER NOT NULL, a INTEGER DEFAULT 1 + 2, CONSTRAINT test_pk PRIMARY KEY (pk))"
"name": 'test',
"sql": 'CREATE TABLE test (pk INTEGER NOT NULL, a INTEGER DEFAULT 1 + 2, CONSTRAINT test_pk PRIMARY KEY (pk))'
}
*/
-- test: DEFAULT (nextval sequence)
CREATE SEQUENCE seq_paren;
CREATE TABLE test(pk INT PRIMARY KEY, a INTEGER DEFAULT (nextval('seq_paren')));
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND name = "test";
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND name = 'test';
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (pk INTEGER NOT NULL, a INTEGER DEFAULT nextval(\"seq_paren\"), CONSTRAINT test_pk PRIMARY KEY (pk))"
"name": 'test',
"sql": 'CREATE TABLE test (pk INTEGER NOT NULL, a INTEGER DEFAULT nextval(\'seq_paren\'), CONSTRAINT test_pk PRIMARY KEY (pk))'
}
*/
-- test: DEFAULT with nested parentheses
CREATE TABLE test(pk INT PRIMARY KEY, a INTEGER DEFAULT ((1)));
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND name = "test";
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND name = 'test';
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (pk INTEGER NOT NULL, a INTEGER DEFAULT (1), CONSTRAINT test_pk PRIMARY KEY (pk))"
"name": 'test',
"sql": 'CREATE TABLE test (pk INTEGER NOT NULL, a INTEGER DEFAULT (1), CONSTRAINT test_pk PRIMARY KEY (pk))'
}
*/

6
sqltests/CREATE_TABLE/not_null.sql
View File

@@ -1,10 +1,10 @@
-- test: basic
CREATE TABLE test(pk INT PRIMARY KEY, a INTEGER NOT NULL);
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND name = "test";
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND name = 'test';
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (pk INTEGER NOT NULL, a INTEGER NOT NULL, CONSTRAINT test_pk PRIMARY KEY (pk))"
"name": 'test',
"sql": 'CREATE TABLE test (pk INTEGER NOT NULL, a INTEGER NOT NULL, CONSTRAINT test_pk PRIMARY KEY (pk))'
}
*/

42
sqltests/CREATE_TABLE/primary_key.sql
View File

@@ -1,30 +1,30 @@
-- test: basic
CREATE TABLE test(a INTEGER PRIMARY KEY);
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND name = "test";
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND name = 'test';
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (a INTEGER NOT NULL, CONSTRAINT test_pk PRIMARY KEY (a))"
"name": 'test',
"sql": 'CREATE TABLE test (a INTEGER NOT NULL, CONSTRAINT test_pk PRIMARY KEY (a))'
}
*/
-- test: with ASC order
CREATE TABLE test(a INT PRIMARY KEY ASC);
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND name = "test";
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND name = 'test';
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (a INTEGER NOT NULL, CONSTRAINT test_pk PRIMARY KEY (a))"
"name": 'test',
"sql": 'CREATE TABLE test (a INTEGER NOT NULL, CONSTRAINT test_pk PRIMARY KEY (a))'
}
*/
-- test: with DESC order
CREATE TABLE test(a INT PRIMARY KEY DESC);
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND name = "test";
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND name = 'test';
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (a INTEGER NOT NULL, CONSTRAINT test_pk PRIMARY KEY (a DESC))"
"name": 'test',
"sql": 'CREATE TABLE test (a INTEGER NOT NULL, CONSTRAINT test_pk PRIMARY KEY (a DESC))'
}
*/
@@ -38,31 +38,31 @@ CREATE TABLE test(a INT PRIMARY KEY, b INT PRIMARY KEY);
-- test: table constraint: one column
CREATE TABLE test(a INT, PRIMARY KEY(a));
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND name = "test";
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND name = 'test';
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (a INTEGER NOT NULL, CONSTRAINT test_pk PRIMARY KEY (a))"
"name": 'test',
"sql": 'CREATE TABLE test (a INTEGER NOT NULL, CONSTRAINT test_pk PRIMARY KEY (a))'
}
*/
-- test: table constraint: multiple columns
CREATE TABLE test(a INT, b INT, PRIMARY KEY(a, b));
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND name = "test";
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND name = 'test';
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (a INTEGER NOT NULL, b INTEGER NOT NULL, CONSTRAINT test_pk PRIMARY KEY (a, b))"
"name": 'test',
"sql": 'CREATE TABLE test (a INTEGER NOT NULL, b INTEGER NOT NULL, CONSTRAINT test_pk PRIMARY KEY (a, b))'
}
*/
-- test: table constraint: multiple columns: with order
CREATE TABLE test(a INT, b INT, c INT, PRIMARY KEY(a DESC, b, c ASC));
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND name = "test";
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND name = 'test';
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (a INTEGER NOT NULL, b INTEGER NOT NULL, c INTEGER NOT NULL, CONSTRAINT test_pk PRIMARY KEY (a DESC, b, c))"
"name": 'test',
"sql": 'CREATE TABLE test (a INTEGER NOT NULL, b INTEGER NOT NULL, c INTEGER NOT NULL, CONSTRAINT test_pk PRIMARY KEY (a DESC, b, c))'
}
*/
@@ -84,10 +84,10 @@ CREATE TABLE test(a INT PRIMARY KEY, b INT, PRIMARY KEY(b));
-- test: named table constraint preserved for PRIMARY KEY
CREATE TABLE test(a INTEGER, b INTEGER, CONSTRAINT my_pk PRIMARY KEY (a DESC, b));
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND name = "test";
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND name = 'test';
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (a INTEGER NOT NULL, b INTEGER NOT NULL, CONSTRAINT my_pk PRIMARY KEY (a DESC, b))"
"name": 'test',
"sql": 'CREATE TABLE test (a INTEGER NOT NULL, b INTEGER NOT NULL, CONSTRAINT my_pk PRIMARY KEY (a DESC, b))'
}
*/

90
sqltests/CREATE_TABLE/types.sql
View File

@@ -1,60 +1,60 @@
-- test: INTEGER
CREATE TABLE test (pk INT PRIMARY KEY, a INTEGER);
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND name = "test";
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND name = 'test';
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (pk INTEGER NOT NULL, a INTEGER, CONSTRAINT test_pk PRIMARY KEY (pk))"
"name": 'test',
"sql": 'CREATE TABLE test (pk INTEGER NOT NULL, a INTEGER, CONSTRAINT test_pk PRIMARY KEY (pk))'
}
*/
-- test: BIGINT
CREATE TABLE test (pk INT PRIMARY KEY, a BIGINT);
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND name = "test";
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND name = 'test';
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (pk INTEGER NOT NULL, a BIGINT, CONSTRAINT test_pk PRIMARY KEY (pk))"
"name": 'test',
"sql": 'CREATE TABLE test (pk INTEGER NOT NULL, a BIGINT, CONSTRAINT test_pk PRIMARY KEY (pk))'
}
*/
-- test: DOUBLE
CREATE TABLE test (pk INT PRIMARY KEY, a DOUBLE PRECISION);
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND name = "test";
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND name = 'test';
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (pk INTEGER NOT NULL, a DOUBLE PRECISION, CONSTRAINT test_pk PRIMARY KEY (pk))"
"name": 'test',
"sql": 'CREATE TABLE test (pk INTEGER NOT NULL, a DOUBLE PRECISION, CONSTRAINT test_pk PRIMARY KEY (pk))'
}
*/
-- test: BOOLEAN
CREATE TABLE test (pk INT PRIMARY KEY, a BOOLEAN);
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND name = "test";
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND name = 'test';
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (pk INTEGER NOT NULL, a BOOLEAN, CONSTRAINT test_pk PRIMARY KEY (pk))"
"name": 'test',
"sql": 'CREATE TABLE test (pk INTEGER NOT NULL, a BOOLEAN, CONSTRAINT test_pk PRIMARY KEY (pk))'
}
*/
-- test: BYTEA
CREATE TABLE test (pk INT PRIMARY KEY, a BYTEA);
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND name = "test";
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND name = 'test';
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (pk INTEGER NOT NULL, a BYTEA, CONSTRAINT test_pk PRIMARY KEY (pk))"
"name": 'test',
"sql": 'CREATE TABLE test (pk INTEGER NOT NULL, a BYTEA, CONSTRAINT test_pk PRIMARY KEY (pk))'
}
*/
-- test: TEXT
CREATE TABLE test (pk INT PRIMARY KEY, a TEXT);
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND name = "test";
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND name = 'test';
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (pk INTEGER NOT NULL, a TEXT, CONSTRAINT test_pk PRIMARY KEY (pk))"
"name": 'test',
"sql": 'CREATE TABLE test (pk INTEGER NOT NULL, a TEXT, CONSTRAINT test_pk PRIMARY KEY (pk))'
}
*/
@@ -64,90 +64,90 @@ CREATE TABLE test (pk INT PRIMARY KEY, a INT, a TEXT);
-- test: INTEGER ALIAS: INT
CREATE TABLE test (pk INT PRIMARY KEY, a INT);
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND name = "test";
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND name = 'test';
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (pk INTEGER NOT NULL, a INTEGER, CONSTRAINT test_pk PRIMARY KEY (pk))"
"name": 'test',
"sql": 'CREATE TABLE test (pk INTEGER NOT NULL, a INTEGER, CONSTRAINT test_pk PRIMARY KEY (pk))'
}
*/
-- test: INT ALIAS: TINYINT
CREATE TABLE test (pk INT PRIMARY KEY, a TINYINT);
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND name = "test";
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND name = 'test';
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (pk INTEGER NOT NULL, a INTEGER, CONSTRAINT test_pk PRIMARY KEY (pk))"
"name": 'test',
"sql": 'CREATE TABLE test (pk INTEGER NOT NULL, a INTEGER, CONSTRAINT test_pk PRIMARY KEY (pk))'
}
*/
-- test: INT ALIAS: mediumint
CREATE TABLE test (pk INT PRIMARY KEY, a INTEGER);
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND name = "test";
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND name = 'test';
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (pk INTEGER NOT NULL, a INTEGER, CONSTRAINT test_pk PRIMARY KEY (pk))"
"name": 'test',
"sql": 'CREATE TABLE test (pk INTEGER NOT NULL, a INTEGER, CONSTRAINT test_pk PRIMARY KEY (pk))'
}
*/
-- test: INT ALIAS: mediumint
CREATE TABLE test (pk INT PRIMARY KEY, a mediumint);
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND name = "test";
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND name = 'test';
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (pk INTEGER NOT NULL, a INTEGER, CONSTRAINT test_pk PRIMARY KEY (pk))"
"name": 'test',
"sql": 'CREATE TABLE test (pk INTEGER NOT NULL, a INTEGER, CONSTRAINT test_pk PRIMARY KEY (pk))'
}
*/
-- test: INT ALIAS: INT2
CREATE TABLE test (pk INT PRIMARY KEY, a int2);
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND name = "test";
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND name = 'test';
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (pk INTEGER NOT NULL, a INTEGER, CONSTRAINT test_pk PRIMARY KEY (pk))"
"name": 'test',
"sql": 'CREATE TABLE test (pk INTEGER NOT NULL, a INTEGER, CONSTRAINT test_pk PRIMARY KEY (pk))'
}
*/
-- test: BIGINT ALIAS: INT8
CREATE TABLE test (pk INT PRIMARY KEY, a int8);
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND name = "test";
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND name = 'test';
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (pk INTEGER NOT NULL, a BIGINT, CONSTRAINT test_pk PRIMARY KEY (pk))"
"name": 'test',
"sql": 'CREATE TABLE test (pk INTEGER NOT NULL, a BIGINT, CONSTRAINT test_pk PRIMARY KEY (pk))'
}
*/
-- test: BOOLEAN ALIAS: BOOL
CREATE TABLE test (pk INT PRIMARY KEY, a BOOL);
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND name = "test";
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND name = 'test';
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (pk INTEGER NOT NULL, a BOOLEAN, CONSTRAINT test_pk PRIMARY KEY (pk))"
"name": 'test',
"sql": 'CREATE TABLE test (pk INTEGER NOT NULL, a BOOLEAN, CONSTRAINT test_pk PRIMARY KEY (pk))'
}
*/
-- test: TEXT ALIAS: VARCHAR(n)
CREATE TABLE test (pk INT PRIMARY KEY, a VARCHAR(255));
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND name = "test";
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND name = 'test';
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (pk INTEGER NOT NULL, a TEXT, CONSTRAINT test_pk PRIMARY KEY (pk))"
"name": 'test',
"sql": 'CREATE TABLE test (pk INTEGER NOT NULL, a TEXT, CONSTRAINT test_pk PRIMARY KEY (pk))'
}
*/
-- test: TEXT ALIAS: character(n)
CREATE TABLE test (pk INT PRIMARY KEY, a character(255));
SELECT name, sql FROM __chai_catalog WHERE type = "table" AND name = "test";
SELECT name, sql FROM __chai_catalog WHERE type = 'table' AND name = 'test';
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (pk INTEGER NOT NULL, a TEXT, CONSTRAINT test_pk PRIMARY KEY (pk))"
"name": 'test',
"sql": 'CREATE TABLE test (pk INTEGER NOT NULL, a TEXT, CONSTRAINT test_pk PRIMARY KEY (pk))'
}
*/

80
sqltests/CREATE_TABLE/unique.sql
View File

@@ -3,17 +3,17 @@ CREATE TABLE test(pk INT PRIMARY KEY, a INT UNIQUE);
SELECT name, sql
FROM __chai_catalog
WHERE
(type = "table" AND name = "test")
(type = 'table' AND name = 'test')
OR
(type = "index" AND name = "test_a_idx");
(type = 'index' AND name = 'test_a_idx');
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (pk INTEGER NOT NULL, a INTEGER, CONSTRAINT test_pk PRIMARY KEY (pk), CONSTRAINT test_a_unique UNIQUE (a))"
"name": 'test',
"sql": 'CREATE TABLE test (pk INTEGER NOT NULL, a INTEGER, CONSTRAINT test_pk PRIMARY KEY (pk), CONSTRAINT test_a_unique UNIQUE (a))'
}
{
"name": "test_a_idx",
"sql": "CREATE UNIQUE INDEX test_a_idx ON test (a)"
"name": 'test_a_idx',
"sql": 'CREATE UNIQUE INDEX test_a_idx ON test (a)'
}
*/
@@ -22,21 +22,21 @@ CREATE TABLE test(pk INT PRIMARY KEY, a INT UNIQUE, b DOUBLE PRECISION UNIQUE);
SELECT name, sql
FROM __chai_catalog
WHERE
(type = "table" AND name = "test")
(type = 'table' AND name = 'test')
OR
(type = "index" AND owner_table_name = "test");
(type = 'index' AND owner_table_name = 'test');
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (pk INTEGER NOT NULL, a INTEGER, b DOUBLE PRECISION, CONSTRAINT test_pk PRIMARY KEY (pk), CONSTRAINT test_a_unique UNIQUE (a), CONSTRAINT test_b_unique UNIQUE (b))"
"name": 'test',
"sql": 'CREATE TABLE test (pk INTEGER NOT NULL, a INTEGER, b DOUBLE PRECISION, CONSTRAINT test_pk PRIMARY KEY (pk), CONSTRAINT test_a_unique UNIQUE (a), CONSTRAINT test_b_unique UNIQUE (b))'
}
{
"name": "test_a_idx",
"sql": "CREATE UNIQUE INDEX test_a_idx ON test (a)"
"name": 'test_a_idx',
"sql": 'CREATE UNIQUE INDEX test_a_idx ON test (a)'
}
{
"name": "test_b_idx",
"sql": "CREATE UNIQUE INDEX test_b_idx ON test (b)"
"name": 'test_b_idx',
"sql": 'CREATE UNIQUE INDEX test_b_idx ON test (b)'
}
*/
@@ -45,17 +45,17 @@ CREATE TABLE test(a INT PRIMARY KEY, UNIQUE(a));
SELECT name, sql
FROM __chai_catalog
WHERE
(type = "table" AND name = "test")
(type = 'table' AND name = 'test')
OR
(type = "index" AND name = "test_a_idx");
(type = 'index' AND name = 'test_a_idx');
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (a INTEGER NOT NULL, CONSTRAINT test_pk PRIMARY KEY (a), CONSTRAINT test_a_unique UNIQUE (a))"
"name": 'test',
"sql": 'CREATE TABLE test (a INTEGER NOT NULL, CONSTRAINT test_pk PRIMARY KEY (a), CONSTRAINT test_a_unique UNIQUE (a))'
}
{
"name": "test_a_idx",
"sql": "CREATE UNIQUE INDEX test_a_idx ON test (a)"
"name": 'test_a_idx',
"sql": 'CREATE UNIQUE INDEX test_a_idx ON test (a)'
}
*/
@@ -64,17 +64,17 @@ CREATE TABLE test(a INT PRIMARY KEY, b INT, UNIQUE(a, b));
SELECT name, sql
FROM __chai_catalog
WHERE
(type = "table" AND name = "test")
(type = 'table' AND name = 'test')
OR
(type = "index" AND name = "test_a_b_idx");
(type = 'index' AND name = 'test_a_b_idx');
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (a INTEGER NOT NULL, b INTEGER, CONSTRAINT test_pk PRIMARY KEY (a), CONSTRAINT test_a_b_unique UNIQUE (a, b))"
"name": 'test',
"sql": 'CREATE TABLE test (a INTEGER NOT NULL, b INTEGER, CONSTRAINT test_pk PRIMARY KEY (a), CONSTRAINT test_a_b_unique UNIQUE (a, b))'
}
{
"name": "test_a_b_idx",
"sql": "CREATE UNIQUE INDEX test_a_b_idx ON test (a, b)"
"name": 'test_a_b_idx',
"sql": 'CREATE UNIQUE INDEX test_a_b_idx ON test (a, b)'
}
*/
@@ -83,17 +83,17 @@ CREATE TABLE test(a INT PRIMARY KEY, b INT, c INT, UNIQUE(a DESC, b ASC, c));
SELECT name, sql
FROM __chai_catalog
WHERE
(type = "table" AND name = "test")
(type = 'table' AND name = 'test')
OR
(type = "index" AND name = "test_a_b_c_idx");
(type = 'index' AND name = 'test_a_b_c_idx');
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (a INTEGER NOT NULL, b INTEGER, c INTEGER, CONSTRAINT test_pk PRIMARY KEY (a), CONSTRAINT test_a_b_c_unique UNIQUE (a DESC, b, c))"
"name": 'test',
"sql": 'CREATE TABLE test (a INTEGER NOT NULL, b INTEGER, c INTEGER, CONSTRAINT test_pk PRIMARY KEY (a), CONSTRAINT test_a_b_c_unique UNIQUE (a DESC, b, c))'
}
{
"name": "test_a_b_c_idx",
"sql": "CREATE UNIQUE INDEX test_a_b_c_idx ON test (a DESC, b, c)"
"name": 'test_a_b_c_idx',
"sql": 'CREATE UNIQUE INDEX test_a_b_c_idx ON test (a DESC, b, c)'
}
*/
@@ -118,20 +118,20 @@ CREATE TABLE test(a INT UNIQUE, b INT PRIMARY KEY, UNIQUE(b));
SELECT name, sql
FROM __chai_catalog
WHERE
(type = "table" AND name = "test")
(type = 'table' AND name = 'test')
OR
(type = "index" AND owner_table_name = "test");
(type = 'index' AND owner_table_name = 'test');
/* result:
{
"name": "test",
"sql": "CREATE TABLE test (a INTEGER, b INTEGER NOT NULL, CONSTRAINT test_a_unique UNIQUE (a), CONSTRAINT test_pk PRIMARY KEY (b), CONSTRAINT test_b_unique UNIQUE (b))"
"name": 'test',
"sql": 'CREATE TABLE test (a INTEGER, b INTEGER NOT NULL, CONSTRAINT test_a_unique UNIQUE (a), CONSTRAINT test_pk PRIMARY KEY (b), CONSTRAINT test_b_unique UNIQUE (b))'
}
{
"name": "test_a_idx",
"sql": "CREATE UNIQUE INDEX test_a_idx ON test (a)"
"name": 'test_a_idx',
"sql": 'CREATE UNIQUE INDEX test_a_idx ON test (a)'
}
{
"name": "test_b_idx",
"sql": "CREATE UNIQUE INDEX test_b_idx ON test (b)"
"name": 'test_b_idx',
"sql": 'CREATE UNIQUE INDEX test_b_idx ON test (b)'
}
*/

18
sqltests/INSERT/check.sql
View File

@@ -5,36 +5,36 @@ on the result of the evaluation of the expression.
-- test: boolean check constraint
CREATE TABLE test (a text PRIMARY KEY CHECK(true));
INSERT INTO test (a) VALUES ("hello");
INSERT INTO test (a) VALUES ('hello');
SELECT * FROM test;
/* result:
{
a: "hello"
a: 'hello'
}
*/
-- test: non-boolean check constraint, numeric result
CREATE TABLE test (a text PRIMARY KEY CHECK(1 + 1));
INSERT INTO test (a) VALUES ("hello");
INSERT INTO test (a) VALUES ('hello');
SELECT * FROM test;
/* result:
{
a: "hello"
a: 'hello'
}
*/
-- test: non-boolean check constraint
CREATE TABLE test (a text PRIMARY KEY CHECK("hello"));
INSERT INTO test (a) VALUES ("hello");
CREATE TABLE test (a text PRIMARY KEY CHECK('hello'));
INSERT INTO test (a) VALUES ('hello');
-- error: row violates check constraint "test_check"
-- test: non-boolean check constraint, NULL
CREATE TABLE test (a text PRIMARY KEY CHECK(NULL));
INSERT INTO test (a) VALUES ("hello");
INSERT INTO test (a) VALUES ('hello');
SELECT * FROM test;
/* result:
{
a: "hello"
a: 'hello'
}
*/
@@ -65,7 +65,7 @@ INSERT INTO test (a) VALUES (40);
-- test: text
CREATE TABLE test (a INT PRIMARY KEY CHECK(a > 10));
INSERT INTO test (a) VALUES ("hello");
INSERT INTO test (a) VALUES ('hello');
-- error: cannot cast "hello" as integer: strconv.ParseInt: parsing "hello": invalid syntax
-- test: null

12
sqltests/INSERT/misc.sql
View File

@@ -19,16 +19,16 @@ CREATE TABLE test_tc(
i bigint, bb bytea, byt bytes,
t text primary key
);
INSERT INTO test_tc (i, db, b, bb, byt, t) VALUES (10000000000, 21.21, true, "YmxvYlZhbHVlCg==", "Ynl0ZXNWYWx1ZQ==", "text");
INSERT INTO test_tc (i, db, b, bb, byt, t) VALUES (10000000000, 21.21, true, 'YmxvYlZhbHVlCg==', 'Ynl0ZXNWYWx1ZQ==', 'text');
SELECT * FROM test_tc;
/* result:
{
"b": true,
"db": 21.21,
"i": 10000000000,
"bb": CAST("YmxvYlZhbHVlCg==" AS BYTEA),
"byt": CAST("Ynl0ZXNWYWx1ZQ==" AS BYTES),
"t": "text"
"bb": CAST('YmxvYlZhbHVlCg==' AS BYTEA),
"byt": CAST('Ynl0ZXNWYWx1ZQ==' AS BYTES),
"t": 'text'
}
*/
@@ -157,7 +157,7 @@ INSERT INTO test VALUES (1);
CREATE TABLE test (a int PRIMARY KEY);
EXPLAIN INSERT INTO test (a) VALUES (1);
/* result:
{plan: "rows.Emit((1)) | table.Validate(\"test\") | table.GenerateKey(\"test\") | table.Insert(\"test\") | discard()"}
{plan: 'rows.Emit((1)) | table.Validate("test") | table.GenerateKey("test") | table.Insert("test") | discard()'}
*/
-- test: with columns
@@ -167,6 +167,6 @@ SELECT * FROM test;
/* result:
{
a: 1,
b: "a"
b: 'a'
}
*/

32
sqltests/INSERT/values.sql
View File

@@ -4,9 +4,9 @@ INSERT INTO test (a, b, c) VALUES ('a', 'b', 'c');
SELECT * FROM test;
/* result:
{
"a": "a",
"b": "b",
"c": "c"
"a": 'a',
"b": 'b',
"c": 'c'
}
*/
@@ -16,8 +16,8 @@ INSERT INTO test (b, a) VALUES ('b', 'a');
SELECT * FROM test;
/* result:
{
"a": "a",
"b": "b",
"a": 'a',
"b": 'b',
"c": null
}
*/
@@ -29,13 +29,13 @@ INSERT INTO test (b, a, c, d) VALUES ('b', 'a', 'c', 'd');
-- test: VALUES, no columns, all values
CREATE TABLE test (a TEXT PRIMARY KEY, b TEXT, c TEXT);
INSERT INTO test VALUES ("a", 'b', 'c');
INSERT INTO test VALUES ('a', 'b', 'c');
SELECT * FROM test;
/* result:
{
"a": "a",
"b": "b",
"c": "c"
"a": 'a',
"b": 'b',
"c": 'c'
}
*/
@@ -45,8 +45,8 @@ INSERT INTO test VALUES ('a', 'b');
SELECT * FROM test;
/* result:
{
"a": "a",
"b": "b",
"a": 'a',
"b": 'b',
"c": null
}
*/
@@ -58,17 +58,17 @@ INSERT INTO test (a) VALUES (a);
-- test: VALUES, ident string
CREATE TABLE test (a TEXT PRIMARY KEY, b TEXT, c TEXT);
INSERT INTO test (a) VALUES (`a`);
INSERT INTO test (a) VALUES ("a");
-- error: no table specified
-- test: VALUES, columns ident string
CREATE TABLE test (a TEXT PRIMARY KEY, `foo bar` TEXT);
INSERT INTO test (a, `foo bar`) VALUES ('a', 'foo bar');
CREATE TABLE test (a TEXT PRIMARY KEY, "foo bar" TEXT);
INSERT INTO test (a, "foo bar") VALUES ('a', 'foo bar');
SELECT * FROM test;
/* result:
{
"a": "a",
"foo bar": "foo bar"
"a": 'a',
"foo bar": 'foo bar'
}
*/

10
sqltests/SELECT/STRINGS/lower.sql
View File

@@ -9,7 +9,7 @@ CREATE TABLE test(
INSERT INTO test (pk, a, b, c, d) VALUES (
1,
"FOO",
'FOO',
42,
true,
42.42
@@ -19,7 +19,7 @@ INSERT INTO test (pk, a, b, c, d) VALUES (
SELECT LOWER(a) FROM test;
/* result:
{
"LOWER(a)": "foo"
"LOWER(a)": 'foo'
}
*/
@@ -53,7 +53,7 @@ SELECT LOWER(d) FROM test;
SELECT LOWER(CAST(b as TEXT)) FROM test;
/* result:
{
"LOWER(CAST(b AS text))": "42"
"LOWER(CAST(b AS text))": '42'
}
*/
@@ -61,7 +61,7 @@ SELECT LOWER(CAST(b as TEXT)) FROM test;
SELECT LOWER(CAST(c as TEXT)) FROM test;
/* result:
{
"LOWER(CAST(c AS text))": "true"
"LOWER(CAST(c AS text))": 'true'
}
*/
@@ -69,6 +69,6 @@ SELECT LOWER(CAST(c as TEXT)) FROM test;
SELECT LOWER(CAST(d as TEXT)) FROM test;
/* result:
{
"LOWER(CAST(d AS text))": "42.42"
"LOWER(CAST(d AS text))": '42.42'
}
*/

36
sqltests/SELECT/STRINGS/ltrim.sql
View File

@@ -4,63 +4,63 @@ CREATE TABLE test(
a TEXT
);
INSERT INTO test (pk, a) VALUES (1, " hello "), (2, "!hello!"), (3, " !hello! ");
INSERT INTO test (pk, a) VALUES (1, ' hello '), (2, '!hello!'), (3, ' !hello! ');
-- test: LTRIM TEXT default
SELECT LTRIM(a) FROM test;
/* result:
{
"LTRIM(a)": "hello "
"LTRIM(a)": 'hello '
}
{
"LTRIM(a)": "!hello!"
"LTRIM(a)": '!hello!'
}
{
"LTRIM(a)": "!hello! "
"LTRIM(a)": '!hello! '
}
*/
-- test: LTRIM TEXT with param
SELECT LTRIM(a, "!") FROM test;
SELECT LTRIM(a, '!') FROM test;
/* result:
{
"LTRIM(a, \"!\")": " hello "
"LTRIM(a, '!')": ' hello '
}
{
"LTRIM(a, \"!\")": "hello!"
"LTRIM(a, '!')": 'hello!'
}
{
"LTRIM(a, \"!\")": " !hello! "
"LTRIM(a, '!')": ' !hello! '
}
*/
-- test: LTRIM TEXT with multiple char params
SELECT LTRIM(a, " !") FROM test;
SELECT LTRIM(a, ' !') FROM test;
/* result:
{
"LTRIM(a, \" !\")": "hello "
"LTRIM(a, ' !')": 'hello '
}
{
"LTRIM(a, \" !\")": "hello!"
"LTRIM(a, ' !')": 'hello!'
}
{
"LTRIM(a, \" !\")": "hello! "
"LTRIM(a, ' !')": 'hello! '
}
*/
-- test: LTRIM TEXT with multiple char params
SELECT LTRIM(a, "hel !") FROM test;
SELECT LTRIM(a, 'hel !') FROM test;
/* result:
{
"LTRIM(a, \"hel !\")": "o "
"LTRIM(a, 'hel !')": 'o '
}
{
"LTRIM(a, \"hel !\")": "o!"
"LTRIM(a, 'hel !')": 'o!'
}
{
"LTRIM(a, \"hel !\")": "o! "
"LTRIM(a, 'hel !')": 'o! '
}
*/
@@ -90,9 +90,9 @@ SELECT LTRIM(42.42);
*/
-- test: LTRIM STRING wrong param
SELECT LTRIM(" hello ", 42);
SELECT LTRIM(' hello ', 42);
/* result:
{
"LTRIM(\" hello \", 42)": NULL
"LTRIM(' hello ', 42)": NULL
}
*/

38
sqltests/SELECT/STRINGS/rtrim.sql
View File

@@ -4,67 +4,65 @@ CREATE TABLE test(
a TEXT
);
INSERT INTO test (pk, a) VALUES (1, " hello "), (2, "!hello!"), (3, " !hello! ");
INSERT INTO test (pk, a) VALUES (1, ' hello '), (2, '!hello!'), (3, ' !hello! ');
-- test: RTRIM TEXT default
SELECT RTRIM(a) FROM test;
/* result:
{
"RTRIM(a)": " hello"
"RTRIM(a)": ' hello'
}
{
"RTRIM(a)": "!hello!"
"RTRIM(a)": '!hello!'
}
{
"RTRIM(a)": " !hello!"
"RTRIM(a)": ' !hello!'
}
*/
-- test: RTRIM TEXT with param
SELECT RTRIM(a, "!") FROM test;
SELECT RTRIM(a, '!') FROM test;
/* result:
{
"RTRIM(a, \"!\")": " hello "
"RTRIM(a, '!')": ' hello '
}
{
"RTRIM(a, \"!\")": "!hello"
"RTRIM(a, '!')": '!hello'
}
{
"RTRIM(a, \"!\")": " !hello! "
"RTRIM(a, '!')": ' !hello! '
}
*/
-- test: RTRIM TEXT with multiple char params
SELECT RTRIM(a, " !") FROM test;
SELECT RTRIM(a, ' !') FROM test;
/* result:
{
"RTRIM(a, \" !\")": " hello"
"RTRIM(a, ' !')": ' hello'
}
{
"RTRIM(a, \" !\")": "!hello"
"RTRIM(a, ' !')": '!hello'
}
{
"RTRIM(a, \" !\")": " !hello"
"RTRIM(a, ' !')": ' !hello'
}
*/
-- test: RTRIM TEXT with multiple char params
SELECT RTRIM(a, "hel !") FROM test;
SELECT RTRIM(a, 'hel !') FROM test;
/* result:
{
"RTRIM(a, \"hel !\")": " hello"
"RTRIM(a, 'hel !')": ' hello'
}
{
"RTRIM(a, \"hel !\")": "!hello"
"RTRIM(a, 'hel !')": '!hello'
}
{
"RTRIM(a, \"hel !\")": " !hello"
"RTRIM(a, 'hel !')": ' !hello'
}
*/
-- test: RTRIM BOOL
SELECT RTRIM(true);
/* result:
@@ -90,9 +88,9 @@ SELECT RTRIM(42.42);
*/
-- test: RTRIM STRING wrong param
SELECT RTRIM(" hello ", 42);
SELECT RTRIM(' hello ', 42);
/* result:
{
"RTRIM(\" hello \", 42)": NULL
"RTRIM(' hello ', 42)": NULL
}
*/

37
sqltests/SELECT/STRINGS/trim.sql
View File

@@ -4,63 +4,62 @@ CREATE TABLE test(
a TEXT
);
INSERT INTO test (pk, a) VALUES (1, " hello "), (2, "!hello!"), (3, " !hello! ");
INSERT INTO test (pk, a) VALUES (1, ' hello '), (2, '!hello!'), (3, ' !hello! ');
-- test: TRIM TEXT default
SELECT TRIM(a) FROM test;
/* result:
{
"TRIM(a)": "hello"
"TRIM(a)": 'hello'
}
{
"TRIM(a)": "!hello!"
"TRIM(a)": '!hello!'
}
{
"TRIM(a)": "!hello!"
"TRIM(a)": '!hello!'
}
*/
-- test: TRIM TEXT with param
SELECT TRIM(a, "!") FROM test;
SELECT TRIM(a, '!') FROM test;
/* result:
{
"TRIM(a, \"!\")": " hello "
"TRIM(a, '!')": ' hello '
}
{
"TRIM(a, \"!\")": "hello"
"TRIM(a, '!')": 'hello'
}
{
"TRIM(a, \"!\")": " !hello! "
"TRIM(a, '!')": ' !hello! '
}
*/
-- test: TRIM TEXT with multiple char params
SELECT TRIM(a, " !") FROM test;
SELECT TRIM(a, ' !') FROM test;
/* result:
{
"TRIM(a, \" !\")": "hello"
"TRIM(a, ' !')": 'hello'
}
{
"TRIM(a, \" !\")": "hello"
"TRIM(a, ' !')": 'hello'
}
{
"TRIM(a, \" !\")": "hello"
"TRIM(a, ' !')": 'hello'
}
*/
-- test: TRIM TEXT with multiple char params
SELECT TRIM(a, "hel !") FROM test;
SELECT TRIM(a, 'hel !') FROM test;
/* result:
{
"TRIM(a, \"hel !\")": "o"
"TRIM(a, 'hel !')": 'o'
}
{
"TRIM(a, \"hel !\")": "o"
"TRIM(a, 'hel !')": 'o'
}
{
"TRIM(a, \"hel !\")": "o"
"TRIM(a, 'hel !')": 'o'
}
*/
@@ -90,9 +89,9 @@ SELECT TRIM(42.42);
*/
-- test: TRIM STRING wrong param
SELECT TRIM(" hello ", 42);
SELECT TRIM(' hello ', 42);
/* result:
{
"TRIM(\" hello \", 42)": NULL
"TRIM(' hello ', 42)": NULL
}
*/

10
sqltests/SELECT/STRINGS/upper.sql
View File

@@ -7,7 +7,7 @@ CREATE TABLE test(
);
INSERT INTO test (a, b, c, d) VALUES (
"foo",
'foo',
42,
true,
42.42,
@@ -17,7 +17,7 @@ INSERT INTO test (a, b, c, d) VALUES (
SELECT UPPER(a) FROM test;
/* result:
{
"UPPER(a)": "FOO"
"UPPER(a)": 'FOO'
}
*/
@@ -51,7 +51,7 @@ SELECT UPPER(d) FROM test;
SELECT UPPER(CAST(b as TEXT)) FROM test;
/* result:
{
"UPPER(CAST(b AS text))": "42"
"UPPER(CAST(b AS text))": '42'
}
*/
@@ -59,7 +59,7 @@ SELECT UPPER(CAST(b as TEXT)) FROM test;
SELECT UPPER(CAST(c as TEXT)) FROM test;
/* result:
{
"UPPER(CAST(c AS text))": "TRUE"
"UPPER(CAST(c AS text))": 'TRUE'
}
*/
@@ -67,7 +67,7 @@ SELECT UPPER(CAST(c as TEXT)) FROM test;
SELECT UPPER(CAST(d as TEXT)) FROM test;
/* result:
{
"UPPER(CAST(d AS text))": "42.42"
"UPPER(CAST(d AS text))": '42.42'
}
*/

512
sqltests/SELECT/WHERE/comp.sql
View File

File diff suppressed because it is too large Load Diff

18
sqltests/SELECT/distinct.sql
View File

@@ -11,7 +11,7 @@ INSERT INTO test(pk, a, b, c) VALUES
SELECT DISTINCT 'a' FROM test;
/* result:
{
`"a"`: "a",
"'a'": 'a',
}
*/
@@ -21,31 +21,31 @@ SELECT DISTINCT * FROM test;
{
pk: 1,
a: 1,
b: "foo",
b: 'foo',
c: true
}
{
pk: 2,
a: 1,
b: "bar",
b: 'bar',
c: false
}
{
pk: 3,
a: 1,
b: "bar",
b: 'bar',
c: null
}
{
pk: 4,
a: 2,
b: "baz",
b: 'baz',
c: null
}
{
pk: 5,
a: 2,
b: "baz",
b: 'baz',
c: null
}
*/
@@ -77,14 +77,14 @@ SELECT DISTINCT a, b FROM test;
/* result:
{
a: 1,
b: "bar"
b: 'bar'
}
{
a: 1,
b: "foo"
b: 'foo'
}
{
a: 2,
b: "baz"
b: 'baz'
}
*/

8
sqltests/SELECT/order_by_desc_index.sql
View File

@@ -28,7 +28,7 @@ SELECT a, b FROM test ORDER BY a;
EXPLAIN SELECT a FROM test ORDER BY a;
/* result:
{
plan: "index.ScanReverse(\"test_a_b_idx\") | rows.Project(a)"
plan: 'index.ScanReverse("test_a_b_idx") | rows.Project(a)'
}
*/
@@ -78,7 +78,7 @@ SELECT a, b FROM test ORDER BY b DESC;
EXPLAIN SELECT a, b FROM test ORDER BY b DESC;
/* result:
{
plan: "table.ScanReverse(\"test\") | rows.Project(a, b)"
plan: 'table.ScanReverse("test") | rows.Project(a, b)'
}
*/
@@ -107,7 +107,7 @@ SELECT a, b FROM test ORDER BY a DESC;
EXPLAIN SELECT a, b FROM test ORDER BY a DESC;
/* result:
{
plan: "index.Scan(\"test_a_b_idx\") | rows.Project(a, b)"
plan: 'index.Scan("test_a_b_idx") | rows.Project(a, b)'
}
*/
@@ -128,7 +128,7 @@ SELECT a, b FROM test WHERE a = 100 ORDER BY b DESC;
EXPLAIN SELECT a, b FROM test WHERE a = 100 ORDER BY b DESC;
/* result:
{
plan: "index.Scan(\"test_a_b_idx\", [{\"min\": (100), \"exact\": true}]) | rows.Project(a, b)"
plan: 'index.Scan("test_a_b_idx", [{"min": (100), "exact": true}]) | rows.Project(a, b)'
}
*/

4
sqltests/SELECT/order_by_desc_pk.sql
View File

@@ -53,7 +53,7 @@ SELECT b FROM test ORDER BY a DESC;
EXPLAIN SELECT b FROM test ORDER BY a DESC;
/* result:
{
plan: "table.Scan(\"test\") | rows.Project(b)"
plan: 'table.Scan("test") | rows.Project(b)'
}
*/
@@ -78,6 +78,6 @@ SELECT * FROM test ORDER BY a DESC;
EXPLAIN SELECT * FROM test ORDER BY a DESC;
/* result:
{
plan: "table.Scan(\"test\")"
plan: 'table.Scan("test")'
}
*/

8
sqltests/SELECT/order_by_desc_pk_composite.sql
View File

@@ -27,7 +27,7 @@ SELECT a, b FROM test ORDER BY a;
EXPLAIN SELECT a FROM test ORDER BY a;
/* result:
{
plan: "table.ScanReverse(\"test\") | rows.Project(a)"
plan: 'table.ScanReverse("test") | rows.Project(a)'
}
*/
@@ -77,7 +77,7 @@ SELECT a, b FROM test ORDER BY b DESC;
EXPLAIN SELECT a, b FROM test ORDER BY b DESC;
/* result:
{
plan: "table.Scan(\"test\") | rows.Project(a, b) | rows.TempTreeSortReverse(b)"
plan: 'table.Scan("test") | rows.Project(a, b) | rows.TempTreeSortReverse(b)'
}
*/
@@ -106,7 +106,7 @@ SELECT a, b FROM test ORDER BY a DESC;
EXPLAIN SELECT a, b FROM test ORDER BY a DESC;
/* result:
{
plan: "table.Scan(\"test\") | rows.Project(a, b)"
plan: 'table.Scan("test") | rows.Project(a, b)'
}
*/
@@ -127,7 +127,7 @@ SELECT a, b FROM test WHERE a = 100 ORDER BY b DESC;
EXPLAIN SELECT a, b FROM test WHERE a = 100 ORDER BY b DESC;
/* result:
{
plan: "table.Scan(\"test\", [{\"min\": (100), \"exact\": true}]) | rows.Project(a, b)"
plan: 'table.Scan("test", [{"min": (100), "exact": true}]) | rows.Project(a, b)'
}
*/

36
sqltests/SELECT/order_by_timestamp.sql
View File

@@ -1,6 +1,6 @@
-- setup:
CREATE TABLE test(pk int primary key, a timestamp );
INSERT INTO test VALUES (1, "2023"), (2, "2025"), (3, "2021"), (4, "2000");
CREATE TABLE test(pk int primary key, a timestamp);
INSERT INTO test VALUES (1, '2023'), (2, '2025'), (3, '2021'), (4, '2000');
-- suite: no index
@@ -11,16 +11,16 @@ CREATE INDEX ON test(a);
SELECT a FROM test ORDER BY a;
/* result:
{
a: "2000-01-01T00:00:00Z",
a: '2000-01-01T00:00:00Z',
}
{
a: "2021-01-01T00:00:00Z"
a: '2021-01-01T00:00:00Z'
}
{
a: "2023-01-01T00:00:00Z"
a: '2023-01-01T00:00:00Z'
}
{
a: "2025-01-01T00:00:00Z"
a: '2025-01-01T00:00:00Z'
}
*/
@@ -29,19 +29,19 @@ SELECT * FROM test ORDER BY a;
/* result:
{
pk: 4,
a: "2000-01-01T00:00:00Z",
a: '2000-01-01T00:00:00Z',
}
{
pk: 3,
a: "2021-01-01T00:00:00Z"
a: '2021-01-01T00:00:00Z'
}
{
pk: 1,
a: "2023-01-01T00:00:00Z"
a: '2023-01-01T00:00:00Z'
}
{
pk: 2,
a: "2025-01-01T00:00:00Z"
a: '2025-01-01T00:00:00Z'
}
*/
@@ -49,16 +49,16 @@ SELECT * FROM test ORDER BY a;
SELECT a FROM test ORDER BY a DESC;
/* result:
{
a: "2025-01-01T00:00:00Z",
a: '2025-01-01T00:00:00Z',
}
{
a: "2023-01-01T00:00:00Z"
a: '2023-01-01T00:00:00Z'
}
{
a: "2021-01-01T00:00:00Z"
a: '2021-01-01T00:00:00Z'
}
{
a: "2000-01-01T00:00:00Z"
a: '2000-01-01T00:00:00Z'
}
*/
@@ -67,18 +67,18 @@ SELECT * FROM test ORDER BY a DESC;
/* result:
{
pk: 2,
a: "2025-01-01T00:00:00Z",
a: '2025-01-01T00:00:00Z',
}
{
pk: 1,
a: "2023-01-01T00:00:00Z"
a: '2023-01-01T00:00:00Z'
}
{
pk: 3,
a: "2021-01-01T00:00:00Z"
a: '2021-01-01T00:00:00Z'
}
{
pk: 4,
a: "2000-01-01T00:00:00Z"
a: '2000-01-01T00:00:00Z'
}
*/

10
sqltests/SELECT/projection_no_table.sql
View File

@@ -16,16 +16,10 @@ SELECT 1 + 1 * 2 / 4;
{"1 + 1 * 2 / 4": 1}
*/
-- test: escaping, double quotes
-- test: double quotes
SELECT '"A"';
/* result:
{`"\\"A\\""`: "\"A\""}
*/
-- test: escaping, single quotes
SELECT "'A'";
/* result:
{`"'A'"`: "'A'"}
{"'\"A\"'": '"A"'}
*/
-- test: aliases

30
sqltests/SELECT/union.sql
View File

@@ -4,7 +4,7 @@ CREATE TABLE bar(a DOUBLE PRECISION PRIMARY KEY, b DOUBLE PRECISION);
CREATE TABLE baz(x TEXT PRIMARY KEY, y TEXT);
INSERT INTO foo (a,b) VALUES (1.0, 1.0), (2.0, 2.0);
INSERT INTO bar (a,b) VALUES (2.0, 2.0), (3.0, 3.0);
INSERT INTO baz (x,y) VALUES ("a", "a"), ("b", "b");
INSERT INTO baz (x,y) VALUES ('a', 'a'), ('b', 'b');
-- test: basic union all
SELECT * FROM foo
@@ -24,17 +24,17 @@ SELECT * FROM baz;
/* result:
{"a": 1.0, "b": 1.0}
{"a": 2.0, "b": 2.0}
{"a": "a", "b": "a"}
{"a": "b", "b": "b"}
{"a": 'a', "b": 'a'}
{"a": 'b', "b": 'b'}
*/
-- test: union all with conditions
SELECT * FROM foo WHERE a > 1
UNION ALL
SELECT * FROM baz WHERE x != "b";
SELECT * FROM baz WHERE x != 'b';
/* result:
{"a": 2.0, "b": 2.0}
{"a": "a", "b": "a"}
{"a": 'a', "b": 'a'}
*/
-- test: self union all
@@ -57,8 +57,8 @@ SELECT * FROM baz;
{"a": 2.0, "b": 2.0}
{"a": 2.0, "b": 2.0}
{"a": 3.0, "b": 3.0}
{"a": "a", "b": "a"}
{"a": "b", "b": "b"}
{"a": 'a', "b": 'a'}
{"a": 'b', "b": 'b'}
*/
-- test: basic union
@@ -78,17 +78,17 @@ SELECT * FROM baz;
/* result:
{"a": 1.0, "b": 1.0}
{"a": 2.0, "b": 2.0}
{"a": "a", "b": "a"}
{"a": "b", "b": "b"}
{"a": 'a', "b": 'a'}
{"a": 'b', "b": 'b'}
*/
-- test: union with conditions
SELECT * FROM foo WHERE a > 1
UNION
SELECT * FROM baz WHERE x != "b";
SELECT * FROM baz WHERE x != 'b';
/* result:
{"a": 2.0, "b": 2.0}
{"a": "a", "b": "a"}
{"a": 'a', "b": 'a'}
*/
-- test: self union
@@ -120,8 +120,8 @@ SELECT * FROM baz;
{"a": 2.0, "b": 2.0}
{"a": 2.0, "b": 2.0}
{"a": 3.0, "b": 3.0}
{"a": "a", "b": "a"}
{"a": "b", "b": "b"}
{"a": 'a', "b": 'a'}
{"a": 'b', "b": 'b'}
*/
-- test: combined unions
@@ -134,5 +134,5 @@ SELECT * FROM baz;
{"a": 1.0, "b": 1.0}
{"a": 2.0, "b": 2.0}
{"a": 3.0, "b": 3.0}
{"a": "a", "b": "a"}
{"a": "b", "b": "b"}
{"a": 'a', "b": 'a'}
{"a": 'b', "b": 'b'}

2
sqltests/SEQUENCES/base.sql
View File

@@ -12,7 +12,7 @@ CREATE SEQUENCE seq1;
SELECT nextval('seq1');
/* result:
{
"nextval(\"seq1\")": 1
"nextval('seq1')": 1
}
*/

14
sqltests/expr/cast.sql
View File

@@ -12,7 +12,7 @@ true
'1'
! CAST (1 AS BYTEA)
'cannot cast integer as bytea'
'cannot cast "integer" as "bytea"'
-- test: source(DOUBLE PRECISION)
> CAST (1.1 AS DOUBLE PRECISION)
@@ -22,13 +22,13 @@ true
1
! CAST (1.1 AS BOOL)
'cannot cast double precision as bool'
'cannot cast "double precision" as "boolean"'
> CAST (1.1 AS TEXT)
'1.1'
! CAST (1.1 AS BYTEA)
'cannot cast double precision as bytea'
'cannot cast "double precision" as "bytea"'
-- test: source(BOOL)
> CAST (true AS BOOL)
@@ -41,13 +41,13 @@ true
0
! CAST (true AS DOUBLE PRECISION)
'cannot cast boolean as double'
'cannot cast "boolean" as "double precision"'
> CAST (true AS TEXT)
'true'
! CAST (true AS BYTEA)
'cannot cast boolean as bytea'
'cannot cast "boolean" as "bytea"'
-- test: source(TEXT)
> CAST ('a' AS TEXT)
@@ -119,10 +119,10 @@ false
'\xAF'
! CAST ('\xAF' AS INT)
'cannot cast bytea as integer'
'cannot cast "bytea" as "integer"'
! CAST ('\xAF' AS DOUBLE PRECISION)
'cannot cast bytea as double'
'cannot cast "bytea" as "double precision"'
> CAST ('\x617364696e65' AS TEXT)
'YXNkaW5l'

4
sqltests/expr/literal.sql
View File

@@ -79,10 +79,10 @@ false
> typeof('hello')
'text'
> "hello"
> 'hello'
'hello'
> typeof("hello")
> typeof('hello')
'text'
-- test: literals/byteas

6
sqltests/planning/precalculate.sql
View File

@@ -5,7 +5,7 @@ CREATE table test(pk int primary key, a int);
EXPLAIN SELECT * FROM test WHERE 3 + 4 > a + 3 % 2;
/* result:
{
plan: "table.Scan(\"test\") | rows.Filter(7 > a + 1)"
plan: 'table.Scan("test") | rows.Filter(7 > a + 1)'
}
*/
@@ -13,7 +13,7 @@ EXPLAIN SELECT * FROM test WHERE 3 + 4 > a + 3 % 2;
EXPLAIN SELECT * FROM test WHERE 4 + 3 + a BETWEEN 3 + 6 AND 5 * 10;
/* result:
{
plan: "table.Scan(\"test\") | rows.Filter(7 + a BETWEEN 9 AND 50)"
plan: 'table.Scan("test") | rows.Filter(7 + a BETWEEN 9 AND 50)'
}
*/
@@ -21,6 +21,6 @@ EXPLAIN SELECT * FROM test WHERE 4 + 3 + a BETWEEN 3 + 6 AND 5 * 10;
EXPLAIN SELECT * FROM test WHERE 4 * 3 BETWEEN 3 + 6 AND 5 * 10;
/* result:
{
plan: "table.Scan(\"test\")"
plan: 'table.Scan("test")'
}
*/

4
sqltests/planning/where_pk.sql
View File

@@ -14,7 +14,7 @@ VALUES
EXPLAIN SELECT * FROM test WHERE a = 10 AND b = 5;
/* result:
{
"plan": 'table.Scan("test", [{\"min\": (10, 5), \"exact\": true}])'
"plan": 'table.Scan("test", [{"min": (10, 5), "exact": true}])'
}
*/
@@ -22,7 +22,7 @@ EXPLAIN SELECT * FROM test WHERE a = 10 AND b = 5;
EXPLAIN SELECT * FROM test WHERE a > 10 AND b = 5;
/* result:
{
"plan": 'table.Scan(\"test\", [{"min": (10), "exclusive": true}]) | rows.Filter(b = 5)'
"plan": 'table.Scan("test", [{"min": (10), "exclusive": true}]) | rows.Filter(b = 5)'
}
*/