scriptoriumadmin/featurebase
1
0
Fork 0
mirror of https://github.com/featurebasedb/featurebase.git synced 2026-08-28 10:54:59 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
featurebase/sql3/parser/ast_test.go
Travis Turner 00ef2380e5
Batch insert via SQL (multiple tuples) (#2243) 
* Formatting adjustments made during code review.

While reviewing the BULK INSERT logic (in order to decide how best to
approach "ingest via sql" in the cloud), I made a few formatting and
comment changes. I'm just adding them here as a separate commit so they
don't muddy up my actual work.

* Parser modifications to support mulitple tuples in INSERT INTO

This commit doesn't include all of the changes required in the
planner. Fow now, the planner is simply modified to continue supporting
a single tuple (the first tuple in the list).

* Update the planner to handle multiple INSERT INTO tuples

This is part 1. It's still using the existing logic which builds an
ImportRequest for every record (and every field!).

The next step will involve using a client.Batch to handle the records.

* Introduce client.Importer interface (used by client.Batch)

Instead of the Batch having a pointer to a client, this puts an
interface there instead (which the client implements). It also allows us
to inject a different importer (i.e. other than a featurebase.client)
into the Batch.

* Decouple batch from client

This commit pulls batch-specific code out of the client package and into
a new batch package. It introduces the batch.Importer interface, the
methods of which replace all the calls that batch was previously making
directly to client methods.

Finally, it contains two implementations of the batch.Importer
interface: one is a wrapper around client, and the other is a wrapper
around featurebase.API.

* Use docker (instead of MustRunCluster) for internal batch tests

Because the `batch` package tests are internal, using
test.MustRunCluster() resulted in an import loop (because it eventually
imports `server`, and we can't have that). So this commit replaces the
use of `test.MustRunCluster()` with docker. The setup is basically the
same as that used in the idk docker tests.

Here we also remove all client-side references to `UseIngestAPI`, which
is an experimental (json) ingest api. It's still suppored on the server,
but here we remove the external usage of it.

* cherry-pick fix

* Use batch.Import() for sql3 INSERT INTO statements

* Thread logger into sql3

* fix batch test

* Fix some shadowing complaint by linter

* Address some test issues related to stringsets

* Exclude batch integration tests from CI

* Address PR feedback

- Added description to batch.README
- Consolidated grep commands in .gitlab-ci.yml
- Removed some debugging comments
- Replaces some inadvertantly removed license headers

* Add batch package to gitlab CI

* Updated CI for batch package

Updated CI include path

Update gitlab ci

Update CI

Update CI

Trying new include path for ci

Updated gitlab ci include path

Made idk race job optional for sonarcloud upload

add testdata directory

remove testenv from dockercompose file

use GIT_STRATEGY clone in batch CI

add testdata volume to dockercompose

Co-authored-by: Fletcher Haynes <fletcher.haynes@generalassemb.ly>
2022-10-29 14:24:33 -05:00

1264 lines
47 KiB
Go
Raw Blame History

// Copyright 2021 Molecula Corp. All rights reserved.
package parser_test
import (
"reflect"
"strings"
"testing"
"github.com/go-test/deep"
"github.com/molecula/featurebase/v3/sql3/parser"
)
func TestExprString(t *testing.T) {
if got, want := parser.ExprString(&parser.NullLit{}), "NULL"; got != want {
t.Fatalf("ExprString()=%q, want %q", got, want)
} else if got, want := parser.ExprString(nil), ""; got != want {
t.Fatalf("ExprString()=%q, want %q", got, want)
}
}
func TestSplitExprTree(t *testing.T) {
t.Run("AND-only", func(t *testing.T) {
AssertSplitExprTree(t, `x = 1 AND y = 2 AND z = 3`, []parser.Expr{
&parser.BinaryExpr{X: &parser.Ident{Name: "x"}, Op: parser.EQ, Y: &parser.IntegerLit{Value: "1"}},
&parser.BinaryExpr{X: &parser.Ident{Name: "y"}, Op: parser.EQ, Y: &parser.IntegerLit{Value: "2"}},
&parser.BinaryExpr{X: &parser.Ident{Name: "z"}, Op: parser.EQ, Y: &parser.IntegerLit{Value: "3"}},
})
})
t.Run("OR", func(t *testing.T) {
AssertSplitExprTree(t, `x = 1 AND (y = 2 OR y = 3) AND z = 4`, []parser.Expr{
&parser.BinaryExpr{X: &parser.Ident{Name: "x"}, Op: parser.EQ, Y: &parser.IntegerLit{Value: "1"}},
&parser.BinaryExpr{
X: &parser.BinaryExpr{X: &parser.Ident{Name: "y"}, Op: parser.EQ, Y: &parser.IntegerLit{Value: "2"}},
Op: parser.OR,
Y: &parser.BinaryExpr{X: &parser.Ident{Name: "y"}, Op: parser.EQ, Y: &parser.IntegerLit{Value: "3"}},
},
&parser.BinaryExpr{X: &parser.Ident{Name: "z"}, Op: parser.EQ, Y: &parser.IntegerLit{Value: "4"}},
})
})
t.Run("ParenExpr", func(t *testing.T) {
AssertSplitExprTree(t, `x = 1 AND (y = 2 AND z = 3)`, []parser.Expr{
&parser.BinaryExpr{X: &parser.Ident{Name: "x"}, Op: parser.EQ, Y: &parser.IntegerLit{Value: "1"}},
&parser.BinaryExpr{X: &parser.Ident{Name: "y"}, Op: parser.EQ, Y: &parser.IntegerLit{Value: "2"}},
&parser.BinaryExpr{X: &parser.Ident{Name: "z"}, Op: parser.EQ, Y: &parser.IntegerLit{Value: "3"}},
})
})
}
func AssertSplitExprTree(tb testing.TB, s string, want []parser.Expr) {
tb.Helper()
if diff := deep.Equal(parser.SplitExprTree(StripExprPos(parser.MustParseExprString(s))), want); diff != nil {
tb.Fatal("mismatch: \n" + strings.Join(diff, "\n"))
}
}
func TestAlterTableStatement_String(t *testing.T) {
AssertStatementStringer(t, &parser.AlterTableStatement{
Name: &parser.Ident{Name: "foo"},
OldColumnName: &parser.Ident{Name: "col1"},
NewColumnName: &parser.Ident{Name: "col2"},
}, `ALTER TABLE "foo" RENAME COLUMN "col1" TO "col2"`)
AssertStatementStringer(t, &parser.AlterTableStatement{
Name: &parser.Ident{Name: "foo"},
ColumnDef: &parser.ColumnDefinition{
Name: &parser.Ident{Name: "bar"},
Type: &parser.Type{Name: &parser.Ident{Name: "INTEGER"}},
},
}, `ALTER TABLE "foo" ADD COLUMN "bar" INTEGER`)
AssertStatementStringer(t, &parser.AlterTableStatement{
Name: &parser.Ident{Name: "foo"},
DropColumnName: &parser.Ident{Name: "bar"},
}, `ALTER TABLE "foo" DROP COLUMN "bar"`)
}
/*func TestAnalyzeStatement_String(t *testing.T) {
AssertStatementStringer(t, &parser.AnalyzeStatement{Name: &parser.Ident{Name: "foo"}}, `ANALYZE "foo"`)
}*/
func TestBeginStatement_String(t *testing.T) {
t.Skip("BEGIN is currently disabled in the parser")
AssertStatementStringer(t, &parser.BeginStatement{}, `BEGIN`)
AssertStatementStringer(t, &parser.BeginStatement{Deferred: pos(0)}, `BEGIN DEFERRED`)
AssertStatementStringer(t, &parser.BeginStatement{Immediate: pos(0)}, `BEGIN IMMEDIATE`)
AssertStatementStringer(t, &parser.BeginStatement{Exclusive: pos(0)}, `BEGIN EXCLUSIVE`)
AssertStatementStringer(t, &parser.BeginStatement{Immediate: pos(0), Transaction: pos(0)}, `BEGIN IMMEDIATE TRANSACTION`)
}
func TestCommitStatement_String(t *testing.T) {
t.Skip("COMMIT is currently disabled in the parser")
AssertStatementStringer(t, &parser.CommitStatement{}, `COMMIT`)
AssertStatementStringer(t, &parser.CommitStatement{End: pos(0)}, `END`)
AssertStatementStringer(t, &parser.CommitStatement{End: pos(0), Transaction: pos(0)}, `END TRANSACTION`)
}
func TestCreateIndexStatement_String(t *testing.T) {
t.Skip("CREATE INDEX is currently disabled in the parser")
AssertStatementStringer(t, &parser.CreateIndexStatement{
Name: &parser.Ident{Name: "foo"},
Table: &parser.Ident{Name: "bar"},
Columns: []*parser.IndexedColumn{{X: &parser.Ident{Name: "baz"}}},
}, `CREATE INDEX "foo" ON "bar" ("baz")`)
AssertStatementStringer(t, &parser.CreateIndexStatement{
Unique: pos(0),
IfNotExists: pos(0),
Name: &parser.Ident{Name: "foo"},
Table: &parser.Ident{Name: "bar"},
Columns: []*parser.IndexedColumn{
{X: &parser.Ident{Name: "baz"}},
{X: &parser.Ident{Name: "bat"}},
},
WhereExpr: &parser.BoolLit{Value: true},
}, `CREATE UNIQUE INDEX IF NOT EXISTS "foo" ON "bar" ("baz", "bat") WHERE TRUE`)
}
func TestCreateTableStatement_String(t *testing.T) {
AssertStatementStringer(t, &parser.CreateTableStatement{
Name: &parser.Ident{Name: "foo"},
IfNotExists: pos(0),
Columns: []*parser.ColumnDefinition{
{
Name: &parser.Ident{Name: "bar"},
Type: &parser.Type{Name: &parser.Ident{Name: "INTEGER"}},
},
{
Name: &parser.Ident{Name: "baz"},
Type: &parser.Type{Name: &parser.Ident{Name: "STRING"}},
},
},
}, `CREATE TABLE IF NOT EXISTS "foo" ("bar" INTEGER, "baz" STRING)`)
AssertStatementStringer(t, &parser.CreateTableStatement{
Name: &parser.Ident{Name: "foo"},
IfNotExists: pos(0),
Columns: []*parser.ColumnDefinition{
{
Name: &parser.Ident{Name: "boolcol"},
Type: &parser.Type{Name: &parser.Ident{Name: "BOOL"}},
},
{
Name: &parser.Ident{Name: "decimalcol"},
Type: &parser.Type{Name: &parser.Ident{Name: "DECIMAL"}},
Constraints: []parser.Constraint{
&parser.MinConstraint{Expr: &parser.IntegerLit{Value: "100.25"}},
&parser.MaxConstraint{Expr: &parser.IntegerLit{Value: "1000.75"}},
},
},
{
Name: &parser.Ident{Name: "idcol"},
Type: &parser.Type{Name: &parser.Ident{Name: "ID"}},
Constraints: []parser.Constraint{
&parser.CacheTypeConstraint{
CacheTypeValue: "RANKED",
Size: pos(0),
SizeExpr: &parser.IntegerLit{Value: "10000"},
},
},
},
{
Name: &parser.Ident{Name: "idsetcol"},
Type: &parser.Type{Name: &parser.Ident{Name: "IDSET"}},
Constraints: []parser.Constraint{
&parser.CacheTypeConstraint{
CacheTypeValue: "RANKED",
Size: pos(0),
SizeExpr: &parser.IntegerLit{Value: "10000"},
},
},
},
{
Name: &parser.Ident{Name: "intcol"},
Type: &parser.Type{Name: &parser.Ident{Name: "INTEGER"}},
Constraints: []parser.Constraint{
&parser.MinConstraint{Expr: &parser.IntegerLit{Value: "100"}},
&parser.MaxConstraint{Expr: &parser.IntegerLit{Value: "1000"}},
},
},
{
Name: &parser.Ident{Name: "stringcol"},
Type: &parser.Type{Name: &parser.Ident{Name: "STRING"}},
Constraints: []parser.Constraint{
&parser.CacheTypeConstraint{
CacheTypeValue: "RANKED",
Size: pos(0),
SizeExpr: &parser.IntegerLit{Value: "10000"},
},
},
},
{
Name: &parser.Ident{Name: "stringsetcol"},
Type: &parser.Type{Name: &parser.Ident{Name: "STRINGSET"}},
Constraints: []parser.Constraint{
&parser.CacheTypeConstraint{
CacheTypeValue: "RANKED",
Size: pos(0),
SizeExpr: &parser.IntegerLit{Value: "10000"},
},
},
},
{
Name: &parser.Ident{Name: "timestampcol"},
Type: &parser.Type{Name: &parser.Ident{Name: "TIMESTAMP"}},
Constraints: []parser.Constraint{
&parser.TimeUnitConstraint{
Expr: &parser.StringLit{Value: "s"},
Epoch: pos(0),
EpochExpr: &parser.StringLit{Value: "2021-01-01T00:00:00Z"},
},
},
},
},
}, `CREATE TABLE IF NOT EXISTS "foo" (`+
`"boolcol" BOOL, `+
`"decimalcol" DECIMAL MIN 100.25 MAX 1000.75, `+
`"idcol" ID CACHETYPE RANKED SIZE 10000, `+
`"idsetcol" IDSET CACHETYPE RANKED SIZE 10000, `+
`"intcol" INTEGER MIN 100 MAX 1000, `+
`"stringcol" STRING CACHETYPE RANKED SIZE 10000, `+
`"stringsetcol" STRINGSET CACHETYPE RANKED SIZE 10000, `+
`"timestampcol" TIMESTAMP TIMEUNIT 's' EPOCH '2021-01-01T00:00:00Z'`+
`)`)
}
func OLDTestCreateTableStatement_String(t *testing.T) {
t.Skip("These tests refer to an older version of CREATE TABLE")
AssertStatementStringer(t, &parser.CreateTableStatement{
Name: &parser.Ident{Name: "foo"},
IfNotExists: pos(0),
Columns: []*parser.ColumnDefinition{
{
Name: &parser.Ident{Name: "bar"},
Type: &parser.Type{Name: &parser.Ident{Name: "INTEGER"}},
},
{
Name: &parser.Ident{Name: "baz"},
Type: &parser.Type{Name: &parser.Ident{Name: "TEXT"}},
},
},
}, `CREATE TABLE IF NOT EXISTS "foo" ("bar" INTEGER, "baz" TEXT)`)
AssertStatementStringer(t, &parser.CreateTableStatement{
Name: &parser.Ident{Name: "foo"},
Columns: []*parser.ColumnDefinition{{
Name: &parser.Ident{Name: "bar"},
Type: &parser.Type{Name: &parser.Ident{Name: "INTEGER"}},
Constraints: []parser.Constraint{
&parser.PrimaryKeyConstraint{Autoincrement: pos(0)},
&parser.NotNullConstraint{Name: &parser.Ident{Name: "nn"}},
&parser.DefaultConstraint{Name: &parser.Ident{Name: "def"}, Expr: &parser.IntegerLit{Value: "123"}},
&parser.DefaultConstraint{Expr: &parser.IntegerLit{Value: "456"}, Lparen: pos(0)},
&parser.UniqueConstraint{},
},
}},
}, `CREATE TABLE "foo" ("bar" INTEGER PRIMARY KEY AUTOINCREMENT CONSTRAINT "nn" NOT NULL CONSTRAINT "def" DEFAULT 123 DEFAULT (456) UNIQUE)`)
AssertStatementStringer(t, &parser.CreateTableStatement{
Name: &parser.Ident{Name: "foo"},
Columns: []*parser.ColumnDefinition{{
Name: &parser.Ident{Name: "bar"},
Type: &parser.Type{Name: &parser.Ident{Name: "INTEGER"}},
Constraints: []parser.Constraint{
&parser.ForeignKeyConstraint{
ForeignTable: &parser.Ident{Name: "x"},
ForeignColumns: []*parser.Ident{{Name: "y"}},
Args: []*parser.ForeignKeyArg{
{OnDelete: pos(0), SetNull: pos(0)},
{OnUpdate: pos(0), SetDefault: pos(0)},
{OnUpdate: pos(0), Cascade: pos(0)},
{OnUpdate: pos(0), Restrict: pos(0)},
{OnUpdate: pos(0), NoAction: pos(0)},
},
},
},
}},
}, `CREATE TABLE "foo" ("bar" INTEGER REFERENCES "x" ("y") ON DELETE SET NULL ON UPDATE SET DEFAULT ON UPDATE CASCADE ON UPDATE RESTRICT ON UPDATE NO ACTION)`)
AssertStatementStringer(t, &parser.CreateTableStatement{
Name: &parser.Ident{Name: "foo"},
Columns: []*parser.ColumnDefinition{{
Name: &parser.Ident{Name: "bar"},
Type: &parser.Type{Name: &parser.Ident{Name: "INTEGER"}},
Constraints: []parser.Constraint{
&parser.ForeignKeyConstraint{
ForeignTable: &parser.Ident{Name: "x"},
ForeignColumns: []*parser.Ident{{Name: "y"}},
Deferrable: pos(0),
InitiallyDeferred: pos(0),
},
},
}},
}, `CREATE TABLE "foo" ("bar" INTEGER REFERENCES "x" ("y") DEFERRABLE INITIALLY DEFERRED)`)
AssertStatementStringer(t, &parser.CreateTableStatement{
Name: &parser.Ident{Name: "foo"},
Columns: []*parser.ColumnDefinition{{
Name: &parser.Ident{Name: "bar"},
Type: &parser.Type{Name: &parser.Ident{Name: "INTEGER"}},
Constraints: []parser.Constraint{
&parser.ForeignKeyConstraint{
ForeignTable: &parser.Ident{Name: "x"},
ForeignColumns: []*parser.Ident{{Name: "y"}},
NotDeferrable: pos(0),
InitiallyImmediate: pos(0),
},
},
}},
}, `CREATE TABLE "foo" ("bar" INTEGER REFERENCES "x" ("y") NOT DEFERRABLE INITIALLY IMMEDIATE)`)
AssertStatementStringer(t, &parser.CreateTableStatement{
Name: &parser.Ident{Name: "foo"},
Columns: []*parser.ColumnDefinition{{
Name: &parser.Ident{Name: "bar"},
Type: &parser.Type{Name: &parser.Ident{Name: "DECIMAL"}, Precision: &parser.IntegerLit{Value: "100"}},
}},
Constraints: []parser.Constraint{
&parser.PrimaryKeyConstraint{
Name: &parser.Ident{Name: "pk"},
Columns: []*parser.Ident{
{Name: "x"},
{Name: "y"},
},
},
&parser.UniqueConstraint{
Name: &parser.Ident{Name: "uniq"},
Columns: []*parser.Ident{
{Name: "x"},
{Name: "y"},
},
},
&parser.CheckConstraint{
Name: &parser.Ident{Name: "chk"},
Expr: &parser.BoolLit{Value: true},
},
},
}, `CREATE TABLE "foo" ("bar" DECIMAL(100), CONSTRAINT "pk" PRIMARY KEY ("x", "y"), CONSTRAINT "uniq" UNIQUE ("x", "y"), CONSTRAINT "chk" CHECK (TRUE))`)
AssertStatementStringer(t, &parser.CreateTableStatement{
Name: &parser.Ident{Name: "foo"},
Columns: []*parser.ColumnDefinition{{
Name: &parser.Ident{Name: "bar"},
Type: &parser.Type{Name: &parser.Ident{Name: "DECIMAL"}, Precision: &parser.IntegerLit{Value: "100"}, Scale: &parser.IntegerLit{Value: "200"}},
}},
Constraints: []parser.Constraint{
&parser.ForeignKeyConstraint{
Name: &parser.Ident{Name: "fk"},
Columns: []*parser.Ident{{Name: "a"}, {Name: "b"}},
ForeignTable: &parser.Ident{Name: "x"},
ForeignColumns: []*parser.Ident{{Name: "y"}, {Name: "z"}},
},
},
}, `CREATE TABLE "foo" ("bar" DECIMAL(100,200), CONSTRAINT "fk" FOREIGN KEY ("a", "b") REFERENCES "x" ("y", "z"))`)
AssertStatementStringer(t, &parser.CreateTableStatement{
Name: &parser.Ident{Name: "foo"},
Select: &parser.SelectStatement{
Columns: []*parser.ResultColumn{{Star: pos(0)}},
},
}, `CREATE TABLE "foo" AS SELECT *`)
}
func TestCreateTriggerStatement_String(t *testing.T) {
t.Skip("CREATE TRIGGER is currently disabled in the parser")
AssertStatementStringer(t, &parser.CreateTriggerStatement{
Name: &parser.Ident{Name: "trig"},
Insert: pos(0),
Table: &parser.Ident{Name: "tbl"},
Body: []parser.Statement{
&parser.DeleteStatement{Table: &parser.QualifiedTableName{Name: &parser.Ident{Name: "tbl2"}}},
},
}, `CREATE TRIGGER "trig" INSERT ON "tbl" BEGIN DELETE FROM "tbl2"; END`)
AssertStatementStringer(t, &parser.CreateTriggerStatement{
Name: &parser.Ident{Name: "trig"},
Before: pos(0),
Delete: pos(0),
ForEachRow: pos(0),
Table: &parser.Ident{Name: "tbl"},
Body: []parser.Statement{
&parser.DeleteStatement{Table: &parser.QualifiedTableName{Name: &parser.Ident{Name: "x"}}},
},
}, `CREATE TRIGGER "trig" BEFORE DELETE ON "tbl" FOR EACH ROW BEGIN DELETE FROM "x"; END`)
AssertStatementStringer(t, &parser.CreateTriggerStatement{
IfNotExists: pos(0),
Name: &parser.Ident{Name: "trig"},
After: pos(0),
Update: pos(0),
Table: &parser.Ident{Name: "tbl"},
WhenExpr: &parser.BoolLit{Value: true},
Body: []parser.Statement{
&parser.DeleteStatement{Table: &parser.QualifiedTableName{Name: &parser.Ident{Name: "x"}}},
},
}, `CREATE TRIGGER IF NOT EXISTS "trig" AFTER UPDATE ON "tbl" WHEN TRUE BEGIN DELETE FROM "x"; END`)
AssertStatementStringer(t, &parser.CreateTriggerStatement{
Name: &parser.Ident{Name: "trig"},
InsteadOf: pos(0),
Update: pos(0),
UpdateOf: pos(0),
UpdateOfColumns: []*parser.Ident{{Name: "x"}, {Name: "y"}},
Table: &parser.Ident{Name: "tbl"},
Body: []parser.Statement{
&parser.DeleteStatement{Table: &parser.QualifiedTableName{Name: &parser.Ident{Name: "x"}}},
},
}, `CREATE TRIGGER "trig" INSTEAD OF UPDATE OF "x", "y" ON "tbl" BEGIN DELETE FROM "x"; END`)
}
func TestCreateViewStatement_String(t *testing.T) {
t.Skip("CREATE VIEW is currently disabled in the parser")
AssertStatementStringer(t, &parser.CreateViewStatement{
Name: &parser.Ident{Name: "vw"},
Columns: []*parser.Ident{
{Name: "x"},
{Name: "y"},
},
Select: &parser.SelectStatement{
Columns: []*parser.ResultColumn{{Star: pos(0)}},
},
}, `CREATE VIEW "vw" ("x", "y") AS SELECT *`)
AssertStatementStringer(t, &parser.CreateViewStatement{
IfNotExists: pos(0),
Name: &parser.Ident{Name: "vw"},
Select: &parser.SelectStatement{
Columns: []*parser.ResultColumn{{Star: pos(0)}},
},
}, `CREATE VIEW IF NOT EXISTS "vw" AS SELECT *`)
}
func TestDeleteStatement_String(t *testing.T) {
AssertStatementStringer(t, &parser.DeleteStatement{
Table: &parser.QualifiedTableName{Name: &parser.Ident{Name: "tbl"}, Alias: &parser.Ident{Name: "tbl2"}},
}, `DELETE FROM "tbl" AS "tbl2"`)
// AssertStatementStringer(t, &sql.DeleteStatement{
// Table: &sql.QualifiedTableName{Name: &sql.Ident{Name: "tbl"}, Index: &sql.Ident{Name: "idx"}},
// }, `DELETE FROM "tbl" INDEXED BY "idx"`)
// AssertStatementStringer(t, &sql.DeleteStatement{
// Table: &sql.QualifiedTableName{Name: &sql.Ident{Name: "tbl"}, NotIndexed: pos(0)},
// }, `DELETE FROM "tbl" NOT INDEXED`)
/*AssertStatementStringer(t, &parser.DeleteStatement{
Table: &parser.QualifiedTableName{Name: &parser.Ident{Name: "tbl"}},
WhereExpr: &parser.BoolLit{Value: true},
OrderingTerms: []*parser.OrderingTerm{
{X: &parser.Ident{Name: "x"}},
{X: &parser.Ident{Name: "y"}},
},
LimitExpr: &parser.IntegerLit{Value: "10"},
OffsetExpr: &parser.IntegerLit{Value: "5"},
}, `DELETE FROM "tbl" WHERE TRUE ORDER BY "x", "y" LIMIT 10 OFFSET 5`)*/
// AssertStatementStringer(t, &sql.DeleteStatement{
// WithClause: &sql.WithClause{
// Recursive: pos(0),
// CTEs: []*sql.CTE{{
// TableName: &sql.Ident{Name: "cte"},
// Select: &sql.SelectStatement{
// Columns: []*sql.ResultColumn{{Star: pos(0)}},
// },
// }},
// },
// Table: &sql.QualifiedTableName{Name: &sql.Ident{Name: "tbl"}},
// }, `WITH RECURSIVE "cte" AS (SELECT *) DELETE FROM "tbl"`)
}
func TestDropIndexStatement_String(t *testing.T) {
t.Skip("DROP INDEX is currently disabled in the parser")
AssertStatementStringer(t, &parser.DropIndexStatement{
Name: &parser.Ident{Name: "idx"},
}, `DROP INDEX "idx"`)
AssertStatementStringer(t, &parser.DropIndexStatement{
IfExists: pos(0),
Name: &parser.Ident{Name: "idx"},
}, `DROP INDEX IF EXISTS "idx"`)
}
func TestDropTableStatement_String(t *testing.T) {
AssertStatementStringer(t, &parser.DropTableStatement{
Name: &parser.Ident{Name: "tbl"},
}, `DROP TABLE "tbl"`)
AssertStatementStringer(t, &parser.DropTableStatement{
IfExists: pos(0),
Name: &parser.Ident{Name: "tbl"},
}, `DROP TABLE IF EXISTS "tbl"`)
}
func TestDropTriggerStatement_String(t *testing.T) {
t.Skip("DROP TRIGGER is currently disabled in the parser")
AssertStatementStringer(t, &parser.DropTriggerStatement{
Name: &parser.Ident{Name: "trig"},
}, `DROP TRIGGER "trig"`)
AssertStatementStringer(t, &parser.DropTriggerStatement{
IfExists: pos(0),
Name: &parser.Ident{Name: "trig"},
}, `DROP TRIGGER IF EXISTS "trig"`)
}
func TestDropViewStatement_String(t *testing.T) {
t.Skip("DROP VIEW is currently disabled in the parser")
AssertStatementStringer(t, &parser.DropViewStatement{
Name: &parser.Ident{Name: "vw"},
}, `DROP VIEW "vw"`)
AssertStatementStringer(t, &parser.DropViewStatement{
IfExists: pos(0),
Name: &parser.Ident{Name: "vw"},
}, `DROP VIEW IF EXISTS "vw"`)
}
func TestExplainStatement_String(t *testing.T) {
t.Skip("These are currently disabled in the parser")
AssertStatementStringer(t, &parser.ExplainStatement{
Stmt: &parser.DropViewStatement{
Name: &parser.Ident{Name: "vw"},
},
}, `EXPLAIN DROP VIEW "vw"`)
AssertStatementStringer(t, &parser.ExplainStatement{
QueryPlan: pos(0),
Stmt: &parser.DropViewStatement{
Name: &parser.Ident{Name: "vw"},
},
}, `EXPLAIN QUERY PLAN DROP VIEW "vw"`)
}
func TestInsertStatement_String(t *testing.T) {
/*AssertStatementStringer(t, &parser.InsertStatement{
Table: &parser.Ident{Name: "tbl"},
DefaultValues: pos(0),
}, `INSERT INTO "tbl" DEFAULT VALUES`)*/
/*AssertStatementStringer(t, &parser.InsertStatement{
Table: &parser.Ident{Name: "tbl"},
Alias: &parser.Ident{Name: "x"},
DefaultValues: pos(0),
}, `INSERT INTO "tbl" AS "x" DEFAULT VALUES`)*/
/*AssertStatementStringer(t, &parser.InsertStatement{
InsertOrReplace: pos(0),
Table: &parser.Ident{Name: "tbl"},
DefaultValues: pos(0),
}, `INSERT OR REPLACE INTO "tbl" DEFAULT VALUES`)*/
/*AssertStatementStringer(t, &parser.InsertStatement{
InsertOrRollback: pos(0),
Table: &parser.Ident{Name: "tbl"},
DefaultValues: pos(0),
}, `INSERT OR ROLLBACK INTO "tbl" DEFAULT VALUES`)*/
/*AssertStatementStringer(t, &parser.InsertStatement{
InsertOrAbort: pos(0),
Table: &parser.Ident{Name: "tbl"},
DefaultValues: pos(0),
}, `INSERT OR ABORT INTO "tbl" DEFAULT VALUES`)*/
/*AssertStatementStringer(t, &parser.InsertStatement{
InsertOrFail: pos(0),
Table: &parser.Ident{Name: "tbl"},
DefaultValues: pos(0),
}, `INSERT OR FAIL INTO "tbl" DEFAULT VALUES`)*/
/*AssertStatementStringer(t, &parser.InsertStatement{
InsertOrIgnore: pos(0),
Table: &parser.Ident{Name: "tbl"},
DefaultValues: pos(0),
}, `INSERT OR IGNORE INTO "tbl" DEFAULT VALUES`)*/
/*AssertStatementStringer(t, &parser.InsertStatement{
Replace: pos(0),
Table: &parser.Ident{Name: "tbl"},
DefaultValues: pos(0),
}, `REPLACE INTO "tbl" DEFAULT VALUES`)*/
/*AssertStatementStringer(t, &parser.InsertStatement{
Table: &parser.Ident{Name: "tbl"},
Select: &parser.SelectStatement{
Columns: []*parser.ResultColumn{{Star: pos(0)}},
},
}, `INSERT INTO "tbl" SELECT *`)*/
AssertStatementStringer(t, &parser.InsertStatement{
Table: &parser.Ident{Name: "tbl"},
Columns: []*parser.Ident{
{Name: "x"},
{Name: "y"},
},
TupleList: []*parser.ExprList{
{
Exprs: []parser.Expr{&parser.NullLit{}, &parser.NullLit{}},
},
},
}, `INSERT INTO "tbl" ("x", "y") VALUES (NULL, NULL)`)
AssertStatementStringer(t, &parser.InsertStatement{
Table: &parser.Ident{Name: "tbl"},
Columns: []*parser.Ident{
{Name: "x"},
{Name: "y"},
},
TupleList: []*parser.ExprList{
{
Exprs: []parser.Expr{&parser.IntegerLit{Value: "1"}, &parser.IntegerLit{Value: "2"}},
},
{
Exprs: []parser.Expr{&parser.IntegerLit{Value: "3"}, &parser.IntegerLit{Value: "4"}},
},
},
}, `INSERT INTO "tbl" ("x", "y") VALUES (1, 2), (3, 4)`)
// AssertStatementStringer(t, &sql.InsertStatement{
// WithClause: &sql.WithClause{
// CTEs: []*sql.CTE{
// {
// TableName: &sql.Ident{Name: "cte"},
// Select: &sql.SelectStatement{
// Columns: []*sql.ResultColumn{{Star: pos(0)}},
// },
// },
// {
// TableName: &sql.Ident{Name: "cte2"},
// Select: &sql.SelectStatement{
// Columns: []*sql.ResultColumn{{Star: pos(0)}},
// },
// },
// },
// },
// Table: &sql.Ident{Name: "tbl"},
// DefaultValues: pos(0),
// }, `WITH "cte" AS (SELECT *), "cte2" AS (SELECT *) INSERT INTO "tbl" DEFAULT VALUES`)
/*AssertStatementStringer(t, &parser.InsertStatement{
Table: &parser.Ident{Name: "tbl"},
DefaultValues: pos(0),
UpsertClause: &parser.UpsertClause{
DoNothing: pos(0),
},
}, `INSERT INTO "tbl" DEFAULT VALUES ON CONFLICT DO NOTHING`)*/
/*AssertStatementStringer(t, &parser.InsertStatement{
Table: &parser.Ident{Name: "tbl"},
DefaultValues: pos(0),
UpsertClause: &parser.UpsertClause{
Columns: []*parser.IndexedColumn{
{X: &parser.Ident{Name: "x"}, Asc: pos(0)},
{X: &parser.Ident{Name: "y"}, Desc: pos(0)},
},
WhereExpr: &parser.BoolLit{Value: true},
Assignments: []*parser.Assignment{
{Columns: []*parser.Ident{{Name: "x"}}, Expr: &parser.IntegerLit{Value: "100"}},
{Columns: []*parser.Ident{{Name: "y"}, {Name: "z"}}, Expr: &parser.IntegerLit{Value: "200"}},
},
UpdateWhereExpr: &parser.BoolLit{Value: false},
},
}, `INSERT INTO "tbl" DEFAULT VALUES ON CONFLICT ("x" ASC, "y" DESC) WHERE TRUE DO UPDATE SET "x" = 100, ("y", "z") = 200 WHERE FALSE`)*/
}
func TestReleaseStatement_String(t *testing.T) {
t.Skip("RELEASE is currently disabled in the parser")
AssertStatementStringer(t, &parser.ReleaseStatement{Name: &parser.Ident{Name: "x"}}, `RELEASE "x"`)
AssertStatementStringer(t, &parser.ReleaseStatement{Savepoint: pos(0), Name: &parser.Ident{Name: "x"}}, `RELEASE SAVEPOINT "x"`)
}
func TestRollbackStatement_String(t *testing.T) {
t.Skip("ROLLBACK is currently disabled in the parser")
AssertStatementStringer(t, &parser.RollbackStatement{}, `ROLLBACK`)
AssertStatementStringer(t, &parser.RollbackStatement{Transaction: pos(0)}, `ROLLBACK TRANSACTION`)
AssertStatementStringer(t, &parser.RollbackStatement{SavepointName: &parser.Ident{Name: "x"}}, `ROLLBACK TO "x"`)
AssertStatementStringer(t, &parser.RollbackStatement{Savepoint: pos(0), SavepointName: &parser.Ident{Name: "x"}}, `ROLLBACK TO SAVEPOINT "x"`)
}
func TestSavepointStatement_String(t *testing.T) {
t.Skip("SAVEPOINT is currently disabled in the parser")
AssertStatementStringer(t, &parser.SavepointStatement{Name: &parser.Ident{Name: "x"}}, `SAVEPOINT "x"`)
}
func TestSelectStatement_String(t *testing.T) {
AssertStatementStringer(t, &parser.SelectStatement{
Columns: []*parser.ResultColumn{
{Expr: &parser.Ident{Name: "x"}, Alias: &parser.Ident{Name: "y"}},
{Expr: &parser.Ident{Name: "z"}},
},
}, `SELECT "x" AS "y", "z"`)
AssertStatementStringer(t, &parser.SelectStatement{
Distinct: pos(0),
Columns: []*parser.ResultColumn{
{Expr: &parser.Ident{Name: "x"}},
},
}, `SELECT DISTINCT "x"`)
// AssertStatementStringer(t, &sql.SelectStatement{
// All: pos(0),
// Columns: []*sql.ResultColumn{
// {Expr: &sql.Ident{Name: "x"}},
// },
// }, `SELECT ALL "x"`)
AssertStatementStringer(t, &parser.SelectStatement{
Columns: []*parser.ResultColumn{{Star: pos(0)}},
Source: &parser.QualifiedTableName{Name: &parser.Ident{Name: "tbl"}},
WhereExpr: &parser.BoolLit{Value: true},
GroupByExprs: []parser.Expr{&parser.Ident{Name: "x"}, &parser.Ident{Name: "y"}},
HavingExpr: &parser.Ident{Name: "z"},
}, `SELECT * FROM "tbl" WHERE TRUE GROUP BY "x", "y" HAVING "z"`)
AssertStatementStringer(t, &parser.SelectStatement{
Columns: []*parser.ResultColumn{{Star: pos(0)}},
Source: &parser.ParenSource{
X: &parser.SelectStatement{Columns: []*parser.ResultColumn{{Star: pos(0)}}},
Alias: &parser.Ident{Name: "tbl"},
},
}, `SELECT * FROM (SELECT *) AS "tbl"`)
AssertStatementStringer(t, &parser.SelectStatement{
Columns: []*parser.ResultColumn{{Star: pos(0)}},
Source: &parser.ParenSource{
X: &parser.SelectStatement{Columns: []*parser.ResultColumn{{Star: pos(0)}}},
},
}, `SELECT * FROM (SELECT *)`)
AssertStatementStringer(t, &parser.SelectStatement{
Columns: []*parser.ResultColumn{{Star: pos(0)}},
Source: &parser.QualifiedTableName{Name: &parser.Ident{Name: "tbl"}},
Windows: []*parser.Window{
{
Name: &parser.Ident{Name: "win1"},
Definition: &parser.WindowDefinition{
Base: &parser.Ident{Name: "base"},
Partitions: []parser.Expr{&parser.Ident{Name: "x"}, &parser.Ident{Name: "y"}},
OrderingTerms: []*parser.OrderingTerm{
{X: &parser.Ident{Name: "x"}, Asc: pos(0), NullsFirst: pos(0)},
{X: &parser.Ident{Name: "y"}, Desc: pos(0), NullsLast: pos(0)},
},
Frame: &parser.FrameSpec{
Range: pos(0),
UnboundedX: pos(0),
PrecedingX: pos(0),
},
},
},
{
Name: &parser.Ident{Name: "win2"},
Definition: &parser.WindowDefinition{
Base: &parser.Ident{Name: "base2"},
},
},
},
}, `SELECT * FROM "tbl" WINDOW "win1" AS ("base" PARTITION BY "x", "y" ORDER BY "x" ASC NULLS FIRST, "y" DESC NULLS LAST RANGE UNBOUNDED PRECEDING), "win2" AS ("base2")`)
// AssertStatementStringer(t, &sql.SelectStatement{
// WithClause: &sql.WithClause{
// CTEs: []*sql.CTE{{
// TableName: &sql.Ident{Name: "cte"},
// Columns: []*sql.Ident{
// {Name: "x"},
// {Name: "y"},
// },
// Select: &sql.SelectStatement{
// Columns: []*sql.ResultColumn{{Star: pos(0)}},
// },
// }},
// },
// ValueLists: []*sql.ExprList{
// {Exprs: []sql.Expr{&sql.NumberLit{Value: "1"}, &sql.NumberLit{Value: "2"}}},
// {Exprs: []sql.Expr{&sql.NumberLit{Value: "3"}, &sql.NumberLit{Value: "4"}}},
// },
// }, `WITH "cte" ("x", "y") AS (SELECT *) VALUES (1, 2), (3, 4)`)
AssertStatementStringer(t, &parser.SelectStatement{
Columns: []*parser.ResultColumn{{Star: pos(0)}},
Union: pos(0),
Compound: &parser.SelectStatement{
Columns: []*parser.ResultColumn{{Star: pos(0)}},
},
}, `SELECT * UNION SELECT *`)
AssertStatementStringer(t, &parser.SelectStatement{
Columns: []*parser.ResultColumn{{Star: pos(0)}},
Union: pos(0),
UnionAll: pos(0),
Compound: &parser.SelectStatement{
Columns: []*parser.ResultColumn{{Star: pos(0)}},
},
}, `SELECT * UNION ALL SELECT *`)
AssertStatementStringer(t, &parser.SelectStatement{
Columns: []*parser.ResultColumn{{Star: pos(0)}},
Intersect: pos(0),
Compound: &parser.SelectStatement{
Columns: []*parser.ResultColumn{{Star: pos(0)}},
},
}, `SELECT * INTERSECT SELECT *`)
AssertStatementStringer(t, &parser.SelectStatement{
Columns: []*parser.ResultColumn{{Star: pos(0)}},
Except: pos(0),
Compound: &parser.SelectStatement{
Columns: []*parser.ResultColumn{{Star: pos(0)}},
},
}, `SELECT * EXCEPT SELECT *`)
AssertStatementStringer(t, &parser.SelectStatement{
Columns: []*parser.ResultColumn{{Star: pos(0)}},
OrderingTerms: []*parser.OrderingTerm{
{X: &parser.Ident{Name: "x"}},
{X: &parser.Ident{Name: "y"}},
},
}, `SELECT * ORDER BY "x", "y"`)
AssertStatementStringer(t, &parser.SelectStatement{
Columns: []*parser.ResultColumn{{Star: pos(0)}},
Source: &parser.JoinClause{
X: &parser.QualifiedTableName{Name: &parser.Ident{Name: "x"}},
Operator: &parser.JoinOperator{Comma: pos(0)},
Y: &parser.QualifiedTableName{Name: &parser.Ident{Name: "y"}},
},
}, `SELECT * FROM "x", "y"`)
AssertStatementStringer(t, &parser.SelectStatement{
Columns: []*parser.ResultColumn{{Star: pos(0)}},
Source: &parser.JoinClause{
X: &parser.QualifiedTableName{Name: &parser.Ident{Name: "x"}},
Operator: &parser.JoinOperator{},
Y: &parser.QualifiedTableName{Name: &parser.Ident{Name: "y"}},
Constraint: &parser.OnConstraint{X: &parser.BoolLit{Value: true}},
},
}, `SELECT * FROM "x" JOIN "y" ON TRUE`)
AssertStatementStringer(t, &parser.SelectStatement{
Columns: []*parser.ResultColumn{{Star: pos(0)}},
Source: &parser.JoinClause{
X: &parser.QualifiedTableName{Name: &parser.Ident{Name: "x"}},
Operator: &parser.JoinOperator{Natural: pos(0), Inner: pos(0)},
Y: &parser.QualifiedTableName{Name: &parser.Ident{Name: "y"}},
Constraint: &parser.UsingConstraint{
Columns: []*parser.Ident{{Name: "a"}, {Name: "b"}},
},
},
}, `SELECT * FROM "x" NATURAL INNER JOIN "y" USING ("a", "b")`)
AssertStatementStringer(t, &parser.SelectStatement{
Columns: []*parser.ResultColumn{{Star: pos(0)}},
Source: &parser.JoinClause{
X: &parser.QualifiedTableName{Name: &parser.Ident{Name: "x"}},
Operator: &parser.JoinOperator{Left: pos(0)},
Y: &parser.QualifiedTableName{Name: &parser.Ident{Name: "y"}},
},
}, `SELECT * FROM "x" LEFT JOIN "y"`)
AssertStatementStringer(t, &parser.SelectStatement{
Columns: []*parser.ResultColumn{{Star: pos(0)}},
Source: &parser.JoinClause{
X: &parser.QualifiedTableName{Name: &parser.Ident{Name: "x"}},
Operator: &parser.JoinOperator{Left: pos(0), Outer: pos(0)},
Y: &parser.QualifiedTableName{Name: &parser.Ident{Name: "y"}},
},
}, `SELECT * FROM "x" LEFT OUTER JOIN "y"`)
AssertStatementStringer(t, &parser.SelectStatement{
Columns: []*parser.ResultColumn{{Star: pos(0)}},
Source: &parser.JoinClause{
X: &parser.QualifiedTableName{Name: &parser.Ident{Name: "x"}},
Operator: &parser.JoinOperator{Cross: pos(0)},
Y: &parser.QualifiedTableName{Name: &parser.Ident{Name: "y"}},
},
}, `SELECT * FROM "x" CROSS JOIN "y"`)
}
func TestUpdateStatement_String(t *testing.T) {
AssertStatementStringer(t, &parser.UpdateStatement{
Table: &parser.QualifiedTableName{Name: &parser.Ident{Name: "tbl"}},
Assignments: []*parser.Assignment{
{Columns: []*parser.Ident{{Name: "x"}}, Expr: &parser.IntegerLit{Value: "100"}},
{Columns: []*parser.Ident{{Name: "y"}}, Expr: &parser.IntegerLit{Value: "200"}},
},
WhereExpr: &parser.BoolLit{Value: true},
}, `UPDATE "tbl" SET "x" = 100, "y" = 200 WHERE TRUE`)
AssertStatementStringer(t, &parser.UpdateStatement{
UpdateOrRollback: pos(0),
Table: &parser.QualifiedTableName{Name: &parser.Ident{Name: "tbl"}},
Assignments: []*parser.Assignment{
{Columns: []*parser.Ident{{Name: "x"}}, Expr: &parser.IntegerLit{Value: "100"}},
},
}, `UPDATE OR ROLLBACK "tbl" SET "x" = 100`)
AssertStatementStringer(t, &parser.UpdateStatement{
UpdateOrAbort: pos(0),
Table: &parser.QualifiedTableName{Name: &parser.Ident{Name: "tbl"}},
Assignments: []*parser.Assignment{
{Columns: []*parser.Ident{{Name: "x"}}, Expr: &parser.IntegerLit{Value: "100"}},
},
}, `UPDATE OR ABORT "tbl" SET "x" = 100`)
AssertStatementStringer(t, &parser.UpdateStatement{
UpdateOrReplace: pos(0),
Table: &parser.QualifiedTableName{Name: &parser.Ident{Name: "tbl"}},
Assignments: []*parser.Assignment{
{Columns: []*parser.Ident{{Name: "x"}}, Expr: &parser.IntegerLit{Value: "100"}},
},
}, `UPDATE OR REPLACE "tbl" SET "x" = 100`)
AssertStatementStringer(t, &parser.UpdateStatement{
UpdateOrFail: pos(0),
Table: &parser.QualifiedTableName{Name: &parser.Ident{Name: "tbl"}},
Assignments: []*parser.Assignment{
{Columns: []*parser.Ident{{Name: "x"}}, Expr: &parser.IntegerLit{Value: "100"}},
},
}, `UPDATE OR FAIL "tbl" SET "x" = 100`)
AssertStatementStringer(t, &parser.UpdateStatement{
UpdateOrIgnore: pos(0),
Table: &parser.QualifiedTableName{Name: &parser.Ident{Name: "tbl"}},
Assignments: []*parser.Assignment{
{Columns: []*parser.Ident{{Name: "x"}}, Expr: &parser.IntegerLit{Value: "100"}},
},
}, `UPDATE OR IGNORE "tbl" SET "x" = 100`)
// AssertStatementStringer(t, &sql.UpdateStatement{
// WithClause: &sql.WithClause{
// CTEs: []*sql.CTE{{
// TableName: &sql.Ident{Name: "cte"},
// Select: &sql.SelectStatement{
// Columns: []*sql.ResultColumn{{Star: pos(0)}},
// },
// }},
// },
// Table: &sql.QualifiedTableName{Name: &sql.Ident{Name: "tbl"}},
// Assignments: []*sql.Assignment{
// {Columns: []*sql.Ident{{Name: "x"}}, Expr: &sql.NumberLit{Value: "100"}},
// },
// }, `WITH "cte" AS (SELECT *) UPDATE "tbl" SET "x" = 100`)
}
func TestIdent_String(t *testing.T) {
AssertExprStringer(t, &parser.Ident{Name: "foo"}, `"foo"`)
AssertExprStringer(t, &parser.Ident{Name: "foo \" bar"}, `"foo "" bar"`)
}
func TestStringLit_String(t *testing.T) {
AssertExprStringer(t, &parser.StringLit{Value: "foo"}, `'foo'`)
AssertExprStringer(t, &parser.StringLit{Value: "foo ' bar"}, `'foo '' bar'`)
}
func TestNumberLit_String(t *testing.T) {
AssertExprStringer(t, &parser.IntegerLit{Value: "123.45"}, `123.45`)
}
func TestBoolLit_String(t *testing.T) {
AssertExprStringer(t, &parser.BoolLit{Value: true}, `TRUE`)
AssertExprStringer(t, &parser.BoolLit{Value: false}, `FALSE`)
}
func TestNullLit_String(t *testing.T) {
AssertExprStringer(t, &parser.NullLit{}, `NULL`)
}
func TestParenExpr_String(t *testing.T) {
AssertExprStringer(t, &parser.ParenExpr{X: &parser.NullLit{}}, `(NULL)`)
}
func TestUnaryExpr_String(t *testing.T) {
AssertExprStringer(t, &parser.UnaryExpr{Op: parser.PLUS, X: &parser.IntegerLit{Value: "100"}}, `+100`)
AssertExprStringer(t, &parser.UnaryExpr{Op: parser.MINUS, X: &parser.IntegerLit{Value: "100"}}, `-100`)
AssertNodeStringerPanic(t, &parser.UnaryExpr{X: &parser.IntegerLit{Value: "100"}}, `sql.UnaryExpr.String(): invalid op ILLEGAL`)
}
func TestBinaryExpr_String(t *testing.T) {
AssertExprStringer(t, &parser.BinaryExpr{Op: parser.PLUS, X: &parser.IntegerLit{Value: "1"}, Y: &parser.IntegerLit{Value: "2"}}, `1 + 2`)
AssertExprStringer(t, &parser.BinaryExpr{Op: parser.MINUS, X: &parser.IntegerLit{Value: "1"}, Y: &parser.IntegerLit{Value: "2"}}, `1 - 2`)
AssertExprStringer(t, &parser.BinaryExpr{Op: parser.STAR, X: &parser.IntegerLit{Value: "1"}, Y: &parser.IntegerLit{Value: "2"}}, `1 * 2`)
AssertExprStringer(t, &parser.BinaryExpr{Op: parser.SLASH, X: &parser.IntegerLit{Value: "1"}, Y: &parser.IntegerLit{Value: "2"}}, `1 / 2`)
AssertExprStringer(t, &parser.BinaryExpr{Op: parser.REM, X: &parser.IntegerLit{Value: "1"}, Y: &parser.IntegerLit{Value: "2"}}, `1 % 2`)
AssertExprStringer(t, &parser.BinaryExpr{Op: parser.CONCAT, X: &parser.IntegerLit{Value: "1"}, Y: &parser.IntegerLit{Value: "2"}}, `1 || 2`)
AssertExprStringer(t, &parser.BinaryExpr{Op: parser.BETWEEN, X: &parser.IntegerLit{Value: "1"}, Y: &parser.Range{X: &parser.IntegerLit{Value: "2"}, Y: &parser.IntegerLit{Value: "3"}}}, `1 BETWEEN 2 AND 3`)
AssertExprStringer(t, &parser.BinaryExpr{Op: parser.NOTBETWEEN, X: &parser.IntegerLit{Value: "1"}, Y: &parser.BinaryExpr{Op: parser.AND, X: &parser.IntegerLit{Value: "2"}, Y: &parser.IntegerLit{Value: "3"}}}, `1 NOT BETWEEN 2 AND 3`)
AssertExprStringer(t, &parser.BinaryExpr{Op: parser.LSHIFT, X: &parser.IntegerLit{Value: "1"}, Y: &parser.IntegerLit{Value: "2"}}, `1 << 2`)
AssertExprStringer(t, &parser.BinaryExpr{Op: parser.RSHIFT, X: &parser.IntegerLit{Value: "1"}, Y: &parser.IntegerLit{Value: "2"}}, `1 >> 2`)
AssertExprStringer(t, &parser.BinaryExpr{Op: parser.BITAND, X: &parser.IntegerLit{Value: "1"}, Y: &parser.IntegerLit{Value: "2"}}, `1 & 2`)
AssertExprStringer(t, &parser.BinaryExpr{Op: parser.BITOR, X: &parser.IntegerLit{Value: "1"}, Y: &parser.IntegerLit{Value: "2"}}, `1 | 2`)
AssertExprStringer(t, &parser.BinaryExpr{Op: parser.LT, X: &parser.IntegerLit{Value: "1"}, Y: &parser.IntegerLit{Value: "2"}}, `1 < 2`)
AssertExprStringer(t, &parser.BinaryExpr{Op: parser.LE, X: &parser.IntegerLit{Value: "1"}, Y: &parser.IntegerLit{Value: "2"}}, `1 <= 2`)
AssertExprStringer(t, &parser.BinaryExpr{Op: parser.GT, X: &parser.IntegerLit{Value: "1"}, Y: &parser.IntegerLit{Value: "2"}}, `1 > 2`)
AssertExprStringer(t, &parser.BinaryExpr{Op: parser.GE, X: &parser.IntegerLit{Value: "1"}, Y: &parser.IntegerLit{Value: "2"}}, `1 >= 2`)
AssertExprStringer(t, &parser.BinaryExpr{Op: parser.EQ, X: &parser.IntegerLit{Value: "1"}, Y: &parser.IntegerLit{Value: "2"}}, `1 = 2`)
AssertExprStringer(t, &parser.BinaryExpr{Op: parser.NE, X: &parser.IntegerLit{Value: "1"}, Y: &parser.IntegerLit{Value: "2"}}, `1 != 2`)
AssertExprStringer(t, &parser.BinaryExpr{Op: parser.IS, X: &parser.IntegerLit{Value: "1"}, Y: &parser.IntegerLit{Value: "2"}}, `1 IS 2`)
AssertExprStringer(t, &parser.BinaryExpr{Op: parser.ISNOT, X: &parser.IntegerLit{Value: "1"}, Y: &parser.IntegerLit{Value: "2"}}, `1 IS NOT 2`)
AssertExprStringer(t, &parser.BinaryExpr{Op: parser.IN, X: &parser.IntegerLit{Value: "1"}, Y: &parser.ExprList{Exprs: []parser.Expr{&parser.IntegerLit{Value: "2"}}}}, `1 IN (2)`)
AssertExprStringer(t, &parser.BinaryExpr{Op: parser.NOTIN, X: &parser.IntegerLit{Value: "1"}, Y: &parser.ExprList{Exprs: []parser.Expr{&parser.IntegerLit{Value: "2"}}}}, `1 NOT IN (2)`)
AssertExprStringer(t, &parser.BinaryExpr{Op: parser.LIKE, X: &parser.IntegerLit{Value: "1"}, Y: &parser.IntegerLit{Value: "2"}}, `1 LIKE 2`)
AssertExprStringer(t, &parser.BinaryExpr{Op: parser.NOTLIKE, X: &parser.IntegerLit{Value: "1"}, Y: &parser.IntegerLit{Value: "2"}}, `1 NOT LIKE 2`)
AssertExprStringer(t, &parser.BinaryExpr{Op: parser.GLOB, X: &parser.IntegerLit{Value: "1"}, Y: &parser.IntegerLit{Value: "2"}}, `1 GLOB 2`)
AssertExprStringer(t, &parser.BinaryExpr{Op: parser.NOTGLOB, X: &parser.IntegerLit{Value: "1"}, Y: &parser.IntegerLit{Value: "2"}}, `1 NOT GLOB 2`)
AssertExprStringer(t, &parser.BinaryExpr{Op: parser.MATCH, X: &parser.IntegerLit{Value: "1"}, Y: &parser.IntegerLit{Value: "2"}}, `1 MATCH 2`)
AssertExprStringer(t, &parser.BinaryExpr{Op: parser.NOTMATCH, X: &parser.IntegerLit{Value: "1"}, Y: &parser.IntegerLit{Value: "2"}}, `1 NOT MATCH 2`)
AssertExprStringer(t, &parser.BinaryExpr{Op: parser.REGEXP, X: &parser.IntegerLit{Value: "1"}, Y: &parser.IntegerLit{Value: "2"}}, `1 REGEXP 2`)
AssertExprStringer(t, &parser.BinaryExpr{Op: parser.NOTREGEXP, X: &parser.IntegerLit{Value: "1"}, Y: &parser.IntegerLit{Value: "2"}}, `1 NOT REGEXP 2`)
AssertExprStringer(t, &parser.BinaryExpr{Op: parser.AND, X: &parser.IntegerLit{Value: "1"}, Y: &parser.IntegerLit{Value: "2"}}, `1 AND 2`)
AssertExprStringer(t, &parser.BinaryExpr{Op: parser.OR, X: &parser.IntegerLit{Value: "1"}, Y: &parser.IntegerLit{Value: "2"}}, `1 OR 2`)
AssertNodeStringerPanic(t, &parser.BinaryExpr{}, `sql.BinaryExpr.String(): invalid op ILLEGAL`)
}
func TestCastExpr_String(t *testing.T) {
AssertExprStringer(t, &parser.CastExpr{X: &parser.IntegerLit{Value: "1"}, Type: &parser.Type{Name: &parser.Ident{Name: "INTEGER"}}}, `CAST(1 AS INTEGER)`)
}
func TestCaseExpr_String(t *testing.T) {
AssertExprStringer(t, &parser.CaseExpr{
Operand: &parser.Ident{Name: "foo"},
Blocks: []*parser.CaseBlock{
{Condition: &parser.IntegerLit{Value: "1"}, Body: &parser.BoolLit{Value: true}},
{Condition: &parser.IntegerLit{Value: "2"}, Body: &parser.BoolLit{Value: false}},
},
ElseExpr: &parser.NullLit{},
}, `CASE "foo" WHEN 1 THEN TRUE WHEN 2 THEN FALSE ELSE NULL END`)
AssertExprStringer(t, &parser.CaseExpr{
Blocks: []*parser.CaseBlock{
{Condition: &parser.IntegerLit{Value: "1"}, Body: &parser.BoolLit{Value: true}},
},
}, `CASE WHEN 1 THEN TRUE END`)
}
func TestExprList_String(t *testing.T) {
AssertExprStringer(t, &parser.ExprList{Exprs: []parser.Expr{&parser.NullLit{}}}, `(NULL)`)
AssertExprStringer(t, &parser.ExprList{Exprs: []parser.Expr{&parser.NullLit{}, &parser.NullLit{}}}, `(NULL, NULL)`)
}
func TestQualifiedRef_String(t *testing.T) {
AssertExprStringer(t, &parser.QualifiedRef{Table: &parser.Ident{Name: "tbl"}, Column: &parser.Ident{Name: "col"}}, `"tbl"."col"`)
AssertExprStringer(t, &parser.QualifiedRef{Table: &parser.Ident{Name: "tbl"}, Star: pos(0)}, `"tbl".*`)
}
func TestCall_String(t *testing.T) {
AssertExprStringer(t, &parser.Call{Name: &parser.Ident{Name: "foo"}}, `foo()`)
AssertExprStringer(t, &parser.Call{Name: &parser.Ident{Name: "foo"}, Star: pos(0)}, `foo(*)`)
AssertExprStringer(t, &parser.Call{
Name: &parser.Ident{Name: "foo"},
Distinct: pos(0),
Args: []parser.Expr{
&parser.NullLit{},
&parser.NullLit{},
},
}, `foo(DISTINCT NULL, NULL)`)
AssertExprStringer(t, &parser.Call{
Name: &parser.Ident{Name: "foo"},
Filter: &parser.FilterClause{
X: &parser.BoolLit{Value: true},
},
}, `foo() FILTER (WHERE TRUE)`)
AssertExprStringer(t, &parser.Call{
Name: &parser.Ident{Name: "foo"},
Over: &parser.OverClause{
Name: &parser.Ident{Name: "win"},
},
}, `foo() OVER "win"`)
t.Run("FrameSpec", func(t *testing.T) {
AssertExprStringer(t, &parser.Call{
Name: &parser.Ident{Name: "foo"},
Over: &parser.OverClause{
Definition: &parser.WindowDefinition{
Frame: &parser.FrameSpec{
Rows: pos(0),
X: &parser.NullLit{},
PrecedingX: pos(0),
ExcludeNoOthers: pos(0),
},
},
},
}, `foo() OVER (ROWS NULL PRECEDING EXCLUDE NO OTHERS)`)
AssertExprStringer(t, &parser.Call{
Name: &parser.Ident{Name: "foo"},
Over: &parser.OverClause{
Definition: &parser.WindowDefinition{
Frame: &parser.FrameSpec{
Groups: pos(0),
CurrentRowX: pos(0),
ExcludeCurrentRow: pos(0),
},
},
},
}, `foo() OVER (GROUPS CURRENT ROW EXCLUDE CURRENT ROW)`)
AssertExprStringer(t, &parser.Call{
Name: &parser.Ident{Name: "foo"},
Over: &parser.OverClause{
Definition: &parser.WindowDefinition{
Frame: &parser.FrameSpec{
Rows: pos(0),
UnboundedX: pos(0),
PrecedingX: pos(0),
Between: pos(0),
CurrentRowY: pos(0),
},
},
},
}, `foo() OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)`)
AssertExprStringer(t, &parser.Call{
Name: &parser.Ident{Name: "foo"},
Over: &parser.OverClause{
Definition: &parser.WindowDefinition{
Frame: &parser.FrameSpec{
Rows: pos(0),
X: &parser.NullLit{},
PrecedingX: pos(0),
Between: pos(0),
CurrentRowY: pos(0),
},
},
},
}, `foo() OVER (ROWS BETWEEN NULL PRECEDING AND CURRENT ROW)`)
AssertExprStringer(t, &parser.Call{
Name: &parser.Ident{Name: "foo"},
Over: &parser.OverClause{
Definition: &parser.WindowDefinition{
Frame: &parser.FrameSpec{
Range: pos(0),
X: &parser.NullLit{},
FollowingX: pos(0),
Between: pos(0),
Y: &parser.BoolLit{Value: true},
PrecedingY: pos(0),
ExcludeGroup: pos(0),
},
},
},
}, `foo() OVER (RANGE BETWEEN NULL FOLLOWING AND TRUE PRECEDING EXCLUDE GROUP)`)
AssertExprStringer(t, &parser.Call{
Name: &parser.Ident{Name: "foo"},
Over: &parser.OverClause{
Definition: &parser.WindowDefinition{
Frame: &parser.FrameSpec{
Range: pos(0),
CurrentRowX: pos(0),
Between: pos(0),
Y: &parser.BoolLit{Value: true},
FollowingY: pos(0),
ExcludeTies: pos(0),
},
},
},
}, `foo() OVER (RANGE BETWEEN CURRENT ROW AND TRUE FOLLOWING EXCLUDE TIES)`)
AssertExprStringer(t, &parser.Call{
Name: &parser.Ident{Name: "foo"},
Over: &parser.OverClause{
Definition: &parser.WindowDefinition{
Frame: &parser.FrameSpec{
Range: pos(0),
CurrentRowX: pos(0),
Between: pos(0),
CurrentRowY: pos(0),
},
},
},
}, `foo() OVER (RANGE BETWEEN CURRENT ROW AND CURRENT ROW)`)
AssertExprStringer(t, &parser.Call{
Name: &parser.Ident{Name: "foo"},
Over: &parser.OverClause{
Definition: &parser.WindowDefinition{
Frame: &parser.FrameSpec{
Range: pos(0),
CurrentRowX: pos(0),
Between: pos(0),
UnboundedY: pos(0),
FollowingY: pos(0),
},
},
},
}, `foo() OVER (RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)`)
})
}
func TestExists_String(t *testing.T) {
AssertExprStringer(t, &parser.Exists{
Select: &parser.SelectStatement{
Columns: []*parser.ResultColumn{
{Star: pos(0)},
},
},
}, `EXISTS (SELECT *)`)
AssertExprStringer(t, &parser.Exists{
Not: pos(0),
Exists: pos(0),
Select: &parser.SelectStatement{
Columns: []*parser.ResultColumn{
{Star: pos(0)},
},
},
}, `NOT EXISTS (SELECT *)`)
}
func AssertExprStringer(tb testing.TB, expr parser.Expr, s string) {
tb.Helper()
if str := expr.String(); str != s {
tb.Fatalf("String()=%s, expected %s", str, s)
} else if _, err := parser.NewParser(strings.NewReader(str)).ParseExpr(); err != nil {
tb.Fatalf("cannot parse string: %s; err=%s", str, err)
}
}
func AssertStatementStringer(tb testing.TB, stmt parser.Statement, s string) {
tb.Helper()
if str := stmt.String(); str != s {
tb.Fatalf("String()=%s, expected %s", str, s)
} else if _, err := parser.NewParser(strings.NewReader(str)).ParseStatement(); err != nil {
tb.Fatalf("cannot parse string: %s; err=%s", str, err)
}
}
func AssertNodeStringerPanic(tb testing.TB, node parser.Node, msg string) {
tb.Helper()
var r interface{}
func() {
defer func() { r = recover() }()
_ = node.String()
}()
if r == nil {
tb.Fatal("expected node stringer to panic")
} else if r != msg {
tb.Fatalf("recover()=%s, want %s", r, msg)
}
}
// StripPos removes the position data from a node and its children.
// This function returns the root argument passed in.
func StripPos(root parser.Node) parser.Node {
zero := reflect.ValueOf(parser.Pos{})
_, _ = parser.Walk(parser.VisitFunc(func(node parser.Node) (parser.Node, error) {
value := reflect.Indirect(reflect.ValueOf(node))
for i := 0; i < value.NumField(); i++ {
if field := value.Field(i); field.Type() == zero.Type() {
field.Set(zero)
}
}
return node, nil
}), root)
return root
}
func StripExprPos(root parser.Expr) parser.Expr {
StripPos(root)
return root
}
Reference in a new issue View git blame Copy permalink