use single quotes for text

cmd/chai/dbutil/exec_test.go

@@ -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

db_test.go

@@ -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"}`,
 	}

internal/encoding/helpers_test.go

@@ -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 {

internal/expr/expr_test.go

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

internal/query/statement/select_test.go

@@ -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},

internal/query/statement/update_test.go

@@ -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},

internal/sql/parser/expr_test.go

@@ -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

internal/sql/parser/select_test.go

@@ -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,
 		},

internal/sql/scanner/scanner.go

@@ -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
 			}

internal/sql/scanner/scanner_test.go

@@ -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 {

internal/types/bigint.go

@@ -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) {

internal/types/blob.go

@@ -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) {

internal/types/boolean.go

@@ -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) {

internal/types/double.go

@@ -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) {

internal/types/integer.go

@@ -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) {

internal/types/text.go

@@ -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) {

internal/types/timestamp.go

@@ -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) {

internal/types/value_test.go

@@ -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"},

sqltests/ALTER_TABLE/add_column.sql

@@ -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
 }
 */
 

sqltests/ALTER_TABLE/rename.sql

@@ -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))'
 }
 */
 

sqltests/CREATE_INDEX/base.sql

@@ -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)'
 }
 */
 

sqltests/CREATE_SEQUENCE/basic.sql

@@ -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

sqltests/CREATE_SEQUENCE/cache_cycle.sql

@@ -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'
 }
 */

sqltests/CREATE_SEQUENCE/combinations.sql

@@ -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'
 }
 */

sqltests/CREATE_SEQUENCE/edge_cases.sql

@@ -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'
 }
 */
 

sqltests/CREATE_SEQUENCE/increment.sql

@@ -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'
 }
 */
 

sqltests/CREATE_SEQUENCE/ranges.sql

@@ -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'
 }
 */

sqltests/CREATE_SEQUENCE/types.sql

@@ -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'
 }
 */

sqltests/CREATE_TABLE/base.sql

@@ -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))'
 }
 */

sqltests/CREATE_TABLE/check.sql

@@ -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))'
 }
 */

sqltests/CREATE_TABLE/constraints.sql

@@ -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))'
 }
 */

sqltests/CREATE_TABLE/default.sql

@@ -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))'
 }
 */
 

sqltests/CREATE_TABLE/not_null.sql

@@ -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))'
 }
 */
 

sqltests/CREATE_TABLE/primary_key.sql

@@ -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))'
 }
 */

sqltests/CREATE_TABLE/types.sql

@@ -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))'
 }
 */

sqltests/CREATE_TABLE/unique.sql

@@ -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)'
 }
 */

sqltests/INSERT/check.sql

@@ -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

sqltests/INSERT/misc.sql

@@ -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'
 }
 */

sqltests/INSERT/values.sql

@@ -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'
 }
 */
 

sqltests/SELECT/STRINGS/lower.sql

@@ -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' 
 }
 */

sqltests/SELECT/STRINGS/ltrim.sql

@@ -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
 }
 */

sqltests/SELECT/STRINGS/rtrim.sql

@@ -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
 }
 */

sqltests/SELECT/STRINGS/trim.sql

@@ -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
 }
 */

sqltests/SELECT/STRINGS/upper.sql

@@ -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'
 }
 */
 

sqltests/SELECT/distinct.sql

@@ -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'
 }
 */

sqltests/SELECT/order_by_desc_index.sql

@@ -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)'
 }
 */
 

sqltests/SELECT/order_by_desc_pk.sql

@@ -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")'
 }
 */

sqltests/SELECT/order_by_desc_pk_composite.sql

@@ -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)'
 }
 */
 

sqltests/SELECT/order_by_timestamp.sql

@@ -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'
 }
 */

sqltests/SELECT/projection_no_table.sql

@@ -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

sqltests/SELECT/union.sql

@@ -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'}

sqltests/SEQUENCES/base.sql

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

sqltests/expr/cast.sql

@@ -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'

sqltests/expr/literal.sql

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

sqltests/planning/precalculate.sql

@@ -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")'
 }
 */

sqltests/planning/where_pk.sql

@@ -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)'
 }
 */