parser_test.go

package sql_test

import (
	"strings"
	"testing"

	"github.com/go-test/deep"
	"github.com/rqlite/sql"
)

func TestParser_ParseStatement(t *testing.T) {
	t.Run("ErrNoStatement", func(t *testing.T) {
		AssertParseStatementError(t, `123`, `1:1: expected statement, found 123`)
	})

	t.Run("Pragma", func(t *testing.T) {
		AssertParseStatement(t, `PRAGMA pragma_name`, &sql.PragmaStatement{
			Pragma: pos(0),
			Expr:   &sql.Ident{NamePos: pos(7), Name: "pragma_name"},
		})
		AssertParseStatement(t, `PRAGMA pragma_name=true`, &sql.PragmaStatement{
			Pragma: pos(0),
			Expr: &sql.BinaryExpr{
				X:     &sql.Ident{NamePos: pos(7), Name: "pragma_name"},
				OpPos: pos(18),
				Op:    sql.EQ,
				Y:     &sql.BoolLit{ValuePos: pos(19), Value: true},
			},
		})
		AssertParseStatement(t, `PRAGMA pragma_name(N)`, &sql.PragmaStatement{
			Pragma: pos(0),
			Expr: &sql.Call{
				Name:   &sql.Ident{NamePos: pos(7), Name: "pragma_name"},
				Lparen: pos(18),
				Args: []sql.Expr{
					&sql.Ident{NamePos: pos(19), Name: "N"},
				},
				Rparen: pos(20),
			},
		})
		AssertParseStatement(t, `PRAGMA schema.pragma_name`, &sql.PragmaStatement{
			Pragma: pos(0),
			Schema: &sql.Ident{NamePos: pos(7), Name: "schema"},
			Dot:    pos(13),
			Expr:   &sql.Ident{NamePos: pos(14), Name: "pragma_name"},
		})

		// Pragma values are commonly keywords (ON, OFF, DELETE, WAL, FULL ...)
		// and must be accepted as names.
		AssertParseStatement(t, `PRAGMA foreign_keys = ON`, &sql.PragmaStatement{
			Pragma: pos(0),
			Expr: &sql.BinaryExpr{
				X:     &sql.Ident{Name: "foreign_keys", NamePos: pos(7)},
				OpPos: pos(20), Op: sql.EQ,
				Y: &sql.Ident{Name: "ON", NamePos: pos(22)},
			},
		})
		AssertParseStatement(t, `PRAGMA main.journal_mode = DELETE`, &sql.PragmaStatement{
			Pragma: pos(0),
			Schema: &sql.Ident{Name: "main", NamePos: pos(7)},
			Dot:    pos(11),
			Expr: &sql.BinaryExpr{
				X:     &sql.Ident{Name: "journal_mode", NamePos: pos(12)},
				OpPos: pos(25), Op: sql.EQ,
				Y: &sql.Ident{Name: "DELETE", NamePos: pos(27)},
			},
		})
		// A pragma value is a signed number, literal or name; the call form
		// takes exactly one value.
		AssertParseStatement(t, `PRAGMA foo(ON)`, &sql.PragmaStatement{
			Pragma: pos(0),
			Expr: &sql.Call{
				Name:   &sql.Ident{Name: "foo", NamePos: pos(7)},
				Lparen: pos(10),
				Args:   []sql.Expr{&sql.Ident{Name: "ON", NamePos: pos(11)}},
				Rparen: pos(13),
			},
		})
		AssertParseStatement(t, `PRAGMA foo = -1`, &sql.PragmaStatement{
			Pragma: pos(0),
			Expr: &sql.BinaryExpr{
				X:     &sql.Ident{Name: "foo", NamePos: pos(7)},
				OpPos: pos(11), Op: sql.EQ,
				Y: &sql.NumberLit{Value: "-1", ValuePos: pos(13)},
			},
		})
		AssertParseStatementError(t, `PRAGMA foo = 1 + 1`, "1:16: expected semicolon or EOF, found '+'")
		AssertParseStatementError(t, `PRAGMA foo(1, 2)`, "1:13: expected right paren, found ','")
		AssertParseStatementError(t, `PRAGMA schema.`, "1:14: expected pragma name, found 'EOF'")
		AssertParseStatementError(t, `PRAGMA .name`, "1:8: expected schema name, found '.'")
		AssertParseStatementError(t, `PRAGMA schema.name=`, "1:19: expected pragma value, found 'EOF'")
		AssertParseStatementError(t, `PRAGMA schema.name(`, "1:19: expected pragma value, found 'EOF'")
		AssertParseStatementError(t, `PRAGMA schema.name(arg`, "1:22: expected right paren, found 'EOF'")
	})

	t.Run("Explain", func(t *testing.T) {
		t.Run("", func(t *testing.T) {
			AssertParseStatement(t, `EXPLAIN BEGIN`, &sql.ExplainStatement{
				Explain: pos(0),
				Stmt: &sql.BeginStatement{
					Begin: pos(8),
				},
			})
		})
		t.Run("QueryPlan", func(t *testing.T) {
			AssertParseStatement(t, `EXPLAIN QUERY PLAN BEGIN`, &sql.ExplainStatement{
				Explain:   pos(0),
				Query:     pos(8),
				QueryPlan: pos(14),
				Stmt: &sql.BeginStatement{
					Begin: pos(19),
				},
			})
		})
		t.Run("QueryPlan SELECT", func(t *testing.T) {
			AssertParseStatement(t, `EXPLAIN QUERY PLAN SELECT foo`, &sql.ExplainStatement{
				Explain:   pos(0),
				Query:     pos(8),
				QueryPlan: pos(14),
				Stmt: &sql.SelectStatement{
					Select: pos(19),
					Columns: []*sql.ResultColumn{
						{Expr: &sql.Ident{NamePos: pos(26), Name: "foo"}},
					},
				},
			})
		})
		t.Run("ErrNoPlan", func(t *testing.T) {
			AssertParseStatementError(t, `EXPLAIN QUERY`, `1:13: expected PLAN, found 'EOF'`)
		})
		t.Run("ErrStmt", func(t *testing.T) {
			AssertParseStatementError(t, `EXPLAIN CREATE`, `1:9: expected TABLE, VIEW, INDEX, TRIGGER`)
		})
	})

	t.Run("Begin", func(t *testing.T) {
		t.Run("", func(t *testing.T) {
			AssertParseStatement(t, `BEGIN`, &sql.BeginStatement{
				Begin: pos(0),
			})
		})
		t.Run("Transaction", func(t *testing.T) {
			AssertParseStatement(t, `BEGIN TRANSACTION`, &sql.BeginStatement{
				Begin:       pos(0),
				Transaction: pos(6),
			})
		})
		t.Run("DeferredTransaction", func(t *testing.T) {
			AssertParseStatement(t, `BEGIN DEFERRED TRANSACTION`, &sql.BeginStatement{
				Begin:       pos(0),
				Deferred:    pos(6),
				Transaction: pos(15),
			})
		})
		t.Run("Immediate", func(t *testing.T) {
			AssertParseStatement(t, `BEGIN IMMEDIATE;`, &sql.BeginStatement{
				Begin:     pos(0),
				Immediate: pos(6),
			})
		})
		t.Run("Exclusive", func(t *testing.T) {
			AssertParseStatement(t, `BEGIN EXCLUSIVE`, &sql.BeginStatement{
				Begin:     pos(0),
				Exclusive: pos(6),
			})
		})
		t.Run("ErrOverrun", func(t *testing.T) {
			AssertParseStatementError(t, `BEGIN COMMIT`, `1:7: expected semicolon or EOF, found 'COMMIT'`)
		})
	})

	t.Run("Commit", func(t *testing.T) {
		t.Run("", func(t *testing.T) {
			AssertParseStatement(t, `COMMIT`, &sql.CommitStatement{
				Commit: pos(0),
			})
		})
		t.Run("Transaction", func(t *testing.T) {
			AssertParseStatement(t, `COMMIT TRANSACTION`, &sql.CommitStatement{
				Commit:      pos(0),
				Transaction: pos(7),
			})
		})
	})

	t.Run("End", func(t *testing.T) {
		t.Run("", func(t *testing.T) {
			AssertParseStatement(t, `END`, &sql.CommitStatement{
				End: pos(0),
			})
		})
		t.Run("Transaction", func(t *testing.T) {
			AssertParseStatement(t, `END TRANSACTION`, &sql.CommitStatement{
				End:         pos(0),
				Transaction: pos(4),
			})
		})
	})

	t.Run("Rollback", func(t *testing.T) {
		t.Run("", func(t *testing.T) {
			AssertParseStatement(t, `ROLLBACK`, &sql.RollbackStatement{
				Rollback: pos(0),
			})
		})
		t.Run("Transaction", func(t *testing.T) {
			AssertParseStatement(t, `ROLLBACK TRANSACTION`, &sql.RollbackStatement{
				Rollback:    pos(0),
				Transaction: pos(9),
			})
		})
		t.Run("To", func(t *testing.T) {
			AssertParseStatement(t, `ROLLBACK TO svpt`, &sql.RollbackStatement{
				Rollback: pos(0),
				To:       pos(9),
				SavepointName: &sql.Ident{
					Name:    "svpt",
					NamePos: pos(12),
				},
			})
		})
		t.Run("TransactionToSavepoint", func(t *testing.T) {
			AssertParseStatement(t, `ROLLBACK TRANSACTION TO SAVEPOINT "svpt"`, &sql.RollbackStatement{
				Rollback:    pos(0),
				Transaction: pos(9),
				To:          pos(21),
				Savepoint:   pos(24),
				SavepointName: &sql.Ident{
					Name:    "svpt",
					NamePos: pos(34),
					Quoted:  true,
				},
			})
		})
		t.Run("ErrSavepointName", func(t *testing.T) {
			AssertParseStatementError(t, `ROLLBACK TO SAVEPOINT 123`, `1:23: expected savepoint name, found 123`)
		})
	})

	t.Run("Savepoint", func(t *testing.T) {
		t.Run("Ident", func(t *testing.T) {
			AssertParseStatement(t, `SAVEPOINT svpt`, &sql.SavepointStatement{
				Savepoint: pos(0),
				Name: &sql.Ident{
					Name:    "svpt",
					NamePos: pos(10),
				},
			})
		})
		t.Run("String", func(t *testing.T) {
			AssertParseStatement(t, `SAVEPOINT "svpt"`, &sql.SavepointStatement{
				Savepoint: pos(0),
				Name: &sql.Ident{
					Name:    "svpt",
					NamePos: pos(10),
					Quoted:  true,
				},
			})
		})
		t.Run("ErrSavepointName", func(t *testing.T) {
			AssertParseStatementError(t, `SAVEPOINT 123`, `1:11: expected savepoint name, found 123`)
		})
	})

	t.Run("Release", func(t *testing.T) {
		t.Run("Ident", func(t *testing.T) {
			AssertParseStatement(t, `RELEASE svpt`, &sql.ReleaseStatement{
				Release: pos(0),
				Name: &sql.Ident{
					Name:    "svpt",
					NamePos: pos(8),
				},
			})
		})
		t.Run("String", func(t *testing.T) {
			AssertParseStatement(t, `RELEASE "svpt"`, &sql.ReleaseStatement{
				Release: pos(0),
				Name: &sql.Ident{
					Name:    "svpt",
					NamePos: pos(8),
					Quoted:  true,
				},
			})
		})
		t.Run("SavepointIdent", func(t *testing.T) {
			AssertParseStatement(t, `RELEASE SAVEPOINT svpt`, &sql.ReleaseStatement{
				Release:   pos(0),
				Savepoint: pos(8),
				Name: &sql.Ident{
					Name:    "svpt",
					NamePos: pos(18),
				},
			})
		})
		t.Run("ErrSavepointName", func(t *testing.T) {
			AssertParseStatementError(t, `RELEASE 123`, `1:9: expected savepoint name, found 123`)
		})
	})

	t.Run("CreateTable", func(t *testing.T) {
		AssertParseStatement(t, `CREATE TABLE tbl (col1 TEXT, col2 DECIMAL(10,5))`, &sql.CreateTableStatement{
			Create: pos(0),
			Table:  pos(7),
			Name: &sql.Ident{
				Name:    "tbl",
				NamePos: pos(13),
			},
			Lparen: pos(17),
			Columns: []*sql.ColumnDefinition{
				{
					Name: &sql.Ident{NamePos: pos(18), Name: "col1"},
					Type: &sql.Type{
						Name: &sql.Ident{NamePos: pos(23), Name: "TEXT"},
					},
				},
				{
					Name: &sql.Ident{NamePos: pos(29), Name: "col2"},
					Type: &sql.Type{
						Name:      &sql.Ident{NamePos: pos(34), Name: "DECIMAL"},
						Lparen:    pos(41),
						Precision: &sql.NumberLit{ValuePos: pos(42), Value: "10"},
						Scale:     &sql.NumberLit{ValuePos: pos(45), Value: "5"},
						Rparen:    pos(46),
					},
				},
			},
			Rparen: pos(47),
		})

		// No column type
		AssertParseStatement(t, `CREATE TABLE tbl (col1, col2)`, &sql.CreateTableStatement{
			Create: pos(0),
			Table:  pos(7),
			Name: &sql.Ident{
				Name:    "tbl",
				NamePos: pos(13),
			},
			Lparen: pos(17),
			Columns: []*sql.ColumnDefinition{
				{
					Name: &sql.Ident{NamePos: pos(18), Name: "col1"},
				},
				{
					Name: &sql.Ident{NamePos: pos(24), Name: "col2"},
				},
			},
			Rparen: pos(28),
		})

		// Column name as a bare keyword
		AssertParseStatement(t, `CREATE TABLE tbl (key)`, &sql.CreateTableStatement{
			Create: pos(0),
			Table:  pos(7),
			Name: &sql.Ident{
				Name:    "tbl",
				NamePos: pos(13),
			},
			Lparen: pos(17),
			Columns: []*sql.ColumnDefinition{
				{
					Name: &sql.Ident{NamePos: pos(18), Name: "key"},
				},
			},
			Rparen: pos(21),
		})

		// With comments
		AssertParseStatement(t, "CREATE TABLE tbl ( -- comment\n\tcol1 TEXT, -- comment\n\t  col2 TEXT)", &sql.CreateTableStatement{
			Create: pos(0),
			Table:  pos(7),
			Name: &sql.Ident{
				Name:    "tbl",
				NamePos: pos(13),
			},
			Lparen: pos(17),
			Columns: []*sql.ColumnDefinition{
				{
					Name: &sql.Ident{NamePos: sql.Pos{Offset: 31, Line: 2, Column: 2}, Name: "col1"},
					Type: &sql.Type{
						Name: &sql.Ident{NamePos: sql.Pos{Offset: 36, Line: 2, Column: 7}, Name: "TEXT"},
					},
				},
				{
					Name: &sql.Ident{NamePos: sql.Pos{Offset: 56, Line: 3, Column: 4}, Name: "col2"},
					Type: &sql.Type{
						Name: &sql.Ident{NamePos: sql.Pos{Offset: 61, Line: 3, Column: 9}, Name: "TEXT"},
					},
				},
			},
			Rparen: sql.Pos{Offset: 65, Line: 3, Column: 13},
		})

		AssertParseStatement(t, `CREATE TABLE tbl (col1 TEXT) WITHOUT ROWID`, &sql.CreateTableStatement{
			Create: pos(0),
			Table:  pos(7),
			Name: &sql.Ident{
				Name:    "tbl",
				NamePos: pos(13),
			},
			Lparen: pos(17),
			Columns: []*sql.ColumnDefinition{
				{
					Name: &sql.Ident{NamePos: pos(18), Name: "col1"},
					Type: &sql.Type{
						Name: &sql.Ident{NamePos: pos(23), Name: "TEXT"},
					},
				},
			},
			Rparen:  pos(27),
			Without: pos(29),
			Rowid:   pos(37),
		})

		AssertParseStatement(t, `CREATE TABLE tbl (col1 TEXT) STRICT`, &sql.CreateTableStatement{
			Create: pos(0),
			Table:  pos(7),
			Name: &sql.Ident{
				Name:    "tbl",
				NamePos: pos(13),
			},
			Lparen: pos(17),
			Columns: []*sql.ColumnDefinition{
				{
					Name: &sql.Ident{NamePos: pos(18), Name: "col1"},
					Type: &sql.Type{
						Name: &sql.Ident{NamePos: pos(23), Name: "TEXT"},
					},
				},
			},
			Rparen: pos(27),
			Strict: pos(29),
		})

		AssertParseStatement(t, `CREATE TABLE tbl (col1 TEXT) WITHOUT ROWID, STRICT`, &sql.CreateTableStatement{
			Create: pos(0),
			Table:  pos(7),
			Name: &sql.Ident{
				Name:    "tbl",
				NamePos: pos(13),
			},
			Lparen: pos(17),
			Columns: []*sql.ColumnDefinition{
				{
					Name: &sql.Ident{NamePos: pos(18), Name: "col1"},
					Type: &sql.Type{
						Name: &sql.Ident{NamePos: pos(23), Name: "TEXT"},
					},
				},
			},
			Rparen:  pos(27),
			Without: pos(29),
			Rowid:   pos(37),
			Strict:  pos(44),
		})

		AssertParseStatementError(t, `CREATE TABLE`, `1:12: expected table name, found 'EOF'`)
		// TEMP / TEMPORARY tables and views.
		AssertParseStatement(t, `CREATE TEMP TABLE tbl (col1 TEXT)`, &sql.CreateTableStatement{
			Create: pos(0),
			Temp:   pos(7),
			Table:  pos(12),
			Name:   &sql.Ident{Name: "tbl", NamePos: pos(18)},
			Lparen: pos(22),
			Columns: []*sql.ColumnDefinition{{
				Name: &sql.Ident{NamePos: pos(23), Name: "col1"},
				Type: &sql.Type{Name: &sql.Ident{NamePos: pos(28), Name: "TEXT"}},
			}},
			Rparen: pos(32),
		})
		AssertParseStatement(t, `CREATE TEMPORARY TABLE tbl (col1 TEXT)`, &sql.CreateTableStatement{
			Create: pos(0),
			Temp:   pos(7),
			Table:  pos(17),
			Name:   &sql.Ident{Name: "tbl", NamePos: pos(23)},
			Lparen: pos(27),
			Columns: []*sql.ColumnDefinition{{
				Name: &sql.Ident{NamePos: pos(28), Name: "col1"},
				Type: &sql.Type{Name: &sql.Ident{NamePos: pos(33), Name: "TEXT"}},
			}},
			Rparen: pos(37),
		})
		AssertParseStatement(t, `CREATE TEMP VIEW v AS SELECT 1`, &sql.CreateViewStatement{
			Create: pos(0),
			Temp:   pos(7),
			View:   pos(12),
			Name:   &sql.Ident{Name: "v", NamePos: pos(17)},
			As:     pos(19),
			Select: &sql.SelectStatement{
				Select:  pos(22),
				Columns: []*sql.ResultColumn{{Expr: &sql.NumberLit{ValuePos: pos(29), Value: "1"}}},
			},
		})
		AssertParseStatementError(t, `CREATE TEMP INDEX idx ON tbl (x)`, `1:13: expected TABLE, VIEW, or TRIGGER, found 'INDEX'`)
		AssertParseStatementError(t, `CREATE TABLE tbl `, `1:17: expected AS or left paren, found 'EOF'`)
		AssertParseStatementError(t, `CREATE TABLE tbl (`, `1:18: expected column name, CONSTRAINT, or right paren, found 'EOF'`)
		AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT`, `1:27: expected right paren, found 'EOF'`)
		AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT) WITHOUT`, `1:36: expected ROWID, found 'EOF'`)
		AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT) WITHOUT ROWID,`, `1:43: expected STRICT or WITHOUT ROWID, found 'EOF'`)
		// Column definitions must be separated by commas; a missing comma must
		// not silently start a new column. (A bare identifier directly after
		// the type is part of a multi-word type name, so a constraint is used
		// here to end the first definition.)
		AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT NOT NULL col2 INTEGER)`, `1:38: expected right paren, found col2`)
		// At least one column definition is required.
		AssertParseStatementError(t, `CREATE TABLE tbl ()`, `1:19: expected column name, found ')'`)
		AssertParseStatementError(t, `CREATE TABLE tbl (PRIMARY KEY (x))`, `1:19: expected column name, found 'PRIMARY'`)
		// A trailing comma is not valid; something must follow it.
		AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT,)`, `1:29: expected column name or CONSTRAINT, found ')'`)
		AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT, col2 INTEGER PRIMARY KEY col3)`, `1:55: expected right paren, found col3`)
		AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT) STRICT,`, `1:36: expected STRICT or WITHOUT ROWID, found 'EOF'`)

		AssertParseStatement(t, `CREATE TABLE IF NOT EXISTS tbl (col1 TEXT)`, &sql.CreateTableStatement{
			Create:      pos(0),
			Table:       pos(7),
			If:          pos(13),
			IfNot:       pos(16),
			IfNotExists: pos(20),
			Name: &sql.Ident{
				Name:    "tbl",
				NamePos: pos(27),
			},
			Lparen: pos(31),
			Columns: []*sql.ColumnDefinition{
				{
					Name: &sql.Ident{
						NamePos: pos(32),
						Name:    "col1",
					},
					Type: &sql.Type{
						Name: &sql.Ident{
							NamePos: pos(37),
							Name:    "TEXT",
						},
					},
				},
			},
			Rparen: pos(41),
		})

		AssertParseStatement(t, `CREATE TABLE tbl (col1 TEXT, ts DATETIME DEFAULT CURRENT_TIMESTAMP)`, &sql.CreateTableStatement{
			Create: pos(0),
			Table:  pos(7),
			Name: &sql.Ident{
				Name:    "tbl",
				NamePos: pos(13),
			},
			Lparen: pos(17),
			Columns: []*sql.ColumnDefinition{
				{
					Name: &sql.Ident{
						NamePos: pos(18),
						Name:    "col1",
					},
					Type: &sql.Type{
						Name: &sql.Ident{
							NamePos: pos(23),
							Name:    "TEXT",
						},
					},
				},
				{
					Name: &sql.Ident{
						NamePos: pos(29),
						Name:    "ts",
					},
					Type: &sql.Type{
						Name: &sql.Ident{
							NamePos: pos(32),
							Name:    "DATETIME",
						},
					},
					Constraints: []sql.Constraint{
						&sql.DefaultConstraint{
							Default: pos(41),
							Expr:    &sql.TimestampLit{Value: "CURRENT_TIMESTAMP", ValuePos: pos(49)},
						},
					},
				},
			},
			Rparen: pos(66),
		})

		AssertParseStatement(t, "CREATE TABLE t (c1 CHARACTER VARYING, c2 UUID, c3 TIMESTAMP)", &sql.CreateTableStatement{
			Create: pos(0),
			Table:  pos(7),
			Name: &sql.Ident{
				NamePos: pos(13),
				Name:    "t",
			},
			Lparen: pos(15),
			Columns: []*sql.ColumnDefinition{
				{
					Name: &sql.Ident{
						NamePos: pos(16),
						Name:    "c1",
					},
					Type: &sql.Type{
						Name: &sql.Ident{
							NamePos: pos(19),
							Name:    "CHARACTER VARYING",
						},
					},
				},
				{
					Name: &sql.Ident{
						NamePos: pos(38),
						Name:    "c2",
					},
					Type: &sql.Type{
						Name: &sql.Ident{
							NamePos: pos(41),
							Name:    "UUID",
						},
					},
				},
				{
					Name: &sql.Ident{
						NamePos: pos(47),
						Name:    "c3",
					},
					Type: &sql.Type{
						Name: &sql.Ident{
							NamePos: pos(50),
							Name:    "TIMESTAMP",
						},
					},
				},
			},
			Rparen: pos(59),
		})

		AssertParseStatement(t, "CREATE TABLE t (c1 NULL)", &sql.CreateTableStatement{
			Create: pos(0),
			Table:  pos(7),
			Name: &sql.Ident{
				NamePos: pos(13),
				Name:    "t",
			},
			Lparen: pos(15),
			Columns: []*sql.ColumnDefinition{
				{
					Name: &sql.Ident{
						NamePos: pos(16),
						Name:    "c1",
					},
					Type: &sql.Type{
						Name: &sql.Ident{
							NamePos: pos(19),
							Name:    "NULL",
						},
					},
				},
			},
			Rparen: pos(23),
		})

		AssertParseStatementError(t, `CREATE TABLE IF`, `1:15: expected NOT, found 'EOF'`)
		AssertParseStatementError(t, `CREATE TABLE IF NOT`, `1:19: expected EXISTS, found 'EOF'`)
		AssertParseStatementError(t, `CREATE TABLE tbl (col1`, `1:22: expected right paren, found 'EOF'`)
		AssertParseStatementError(t, `CREATE TABLE tbl (col1 DECIMAL(`, `1:31: expected precision, found 'EOF'`)
		AssertParseStatementError(t, `CREATE TABLE tbl (col1 DECIMAL(-12,`, `1:35: expected scale, found 'EOF'`)
		AssertParseStatementError(t, `CREATE TABLE tbl (col1 DECIMAL(1,2`, `1:34: expected right paren, found 'EOF'`)
		AssertParseStatementError(t, `CREATE TABLE tbl (col1 DECIMAL(1`, `1:32: expected right paren, found 'EOF'`)
		AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT CONSTRAINT`, `1:38: expected constraint name, found 'EOF'`)

		AssertParseStatement(t, `CREATE TABLE tbl AS SELECT foo`, &sql.CreateTableStatement{
			Create: pos(0),
			Table:  pos(7),
			Name: &sql.Ident{
				Name:    "tbl",
				NamePos: pos(13),
			},
			As: pos(17),
			Select: &sql.SelectStatement{
				Select: pos(20),
				Columns: []*sql.ResultColumn{
					{Expr: &sql.Ident{NamePos: pos(27), Name: "foo"}},
				},
			},
		})
		AssertParseStatement(t, `CREATE TABLE tbl AS WITH cte (x) AS (SELECT y) SELECT foo`, &sql.CreateTableStatement{
			Create: pos(0),
			Table:  pos(7),
			Name: &sql.Ident{
				Name:    "tbl",
				NamePos: pos(13),
			},
			As: pos(17),
			Select: &sql.SelectStatement{
				WithClause: &sql.WithClause{
					With: pos(20),
					CTEs: []*sql.CTE{
						{
							TableName:     &sql.Ident{NamePos: pos(25), Name: "cte"},
							ColumnsLparen: pos(29),
							Columns: []*sql.Ident{
								{NamePos: pos(30), Name: "x"},
							},
							ColumnsRparen: pos(31),
							As:            pos(33),
							SelectLparen:  pos(36),
							Select: &sql.SelectStatement{
								Select: pos(37),
								Columns: []*sql.ResultColumn{
									{Expr: &sql.Ident{NamePos: pos(44), Name: "y"}},
								},
							},
							SelectRparen: pos(45),
						},
					},
				},
				Select: pos(47),
				Columns: []*sql.ResultColumn{
					{Expr: &sql.Ident{NamePos: pos(54), Name: "foo"}},
				},
			},
		})
		AssertParseStatementError(t, `CREATE TABLE tbl AS`, `1:19: expected SELECT or VALUES, found 'EOF'`)
		AssertParseStatementError(t, `CREATE TABLE tbl AS WITH`, `1:24: expected table name, found 'EOF'`)

		t.Run("WithSchema", func(t *testing.T) {
			t.Run("Basic", func(t *testing.T) {
				AssertParseStatement(t, `CREATE TABLE main.tbl (col1 TEXT PRIMARY KEY, col2 INTEGER)`, &sql.CreateTableStatement{
					Create: pos(0),
					Table:  pos(7),
					Schema: &sql.Ident{Name: "main", NamePos: pos(13)},
					Name:   &sql.Ident{Name: "tbl", NamePos: pos(18)},
					Lparen: pos(22),
					Columns: []*sql.ColumnDefinition{
						{
							Name: &sql.Ident{Name: "col1", NamePos: pos(23)},
							Type: &sql.Type{
								Name: &sql.Ident{Name: "TEXT", NamePos: pos(28)},
							},
							Constraints: []sql.Constraint{
								&sql.PrimaryKeyConstraint{
									Primary: pos(33),
									Key:     pos(41),
								},
							},
						},
						{
							Name: &sql.Ident{Name: "col2", NamePos: pos(46)},
							Type: &sql.Type{
								Name: &sql.Ident{Name: "INTEGER", NamePos: pos(51)},
							},
						},
					},
					Rparen: pos(58),
				})
			})

			AssertParseStatementError(t, `CREATE TABLE main. (col1 TEXT PRIMARY KEY, col2 INTEGER)`, `1:20: expected table name, found '('`)
		})

		t.Run("WithComment", func(t *testing.T) {
			t.Run("SingleLine", func(t *testing.T) {
				AssertParseStatement(t, "CREATE TABLE tbl\n\t-- test one two\n\t(col1 TEXT)", &sql.CreateTableStatement{
					Create: pos(0),
					Table:  pos(7),
					Name:   &sql.Ident{Name: "tbl", NamePos: sql.Pos{Offset: 13, Line: 1, Column: 14}},
					Lparen: sql.Pos{Offset: 35, Line: 3, Column: 2},
					Columns: []*sql.ColumnDefinition{
						{
							Name: &sql.Ident{Name: "col1", NamePos: sql.Pos{Offset: 36, Line: 3, Column: 3}},
							Type: &sql.Type{
								Name: &sql.Ident{Name: "TEXT", NamePos: sql.Pos{Offset: 41, Line: 3, Column: 8}},
							},
						},
					},
					Rparen: sql.Pos{Offset: 45, Line: 3, Column: 12},
				})
			})
			t.Run("MultiLine", func(t *testing.T) {
				AssertParseStatement(t, "CREATE TABLE tbl\n\t/* test one\ntwo*/ (col1 TEXT)", &sql.CreateTableStatement{
					Create: pos(0),
					Table:  pos(7),
					Name:   &sql.Ident{Name: "tbl", NamePos: sql.Pos{Offset: 13, Line: 1, Column: 14}},
					Lparen: sql.Pos{Offset: 36, Line: 3, Column: 7},
					Columns: []*sql.ColumnDefinition{
						{
							Name: &sql.Ident{Name: "col1", NamePos: sql.Pos{Offset: 37, Line: 3, Column: 8}},
							Type: &sql.Type{
								Name: &sql.Ident{Name: "TEXT", NamePos: sql.Pos{Offset: 42, Line: 3, Column: 13}},
							},
						},
					},
					Rparen: sql.Pos{Offset: 46, Line: 3, Column: 17},
				})
			})
		})

		t.Run("ColumnConstraint", func(t *testing.T) {
			t.Run("PrimaryKey", func(t *testing.T) {
				t.Run("Simple", func(t *testing.T) {
					AssertParseStatement(t, `CREATE TABLE tbl (col1 TEXT PRIMARY KEY)`, &sql.CreateTableStatement{
						Create: pos(0),
						Table:  pos(7),
						Name:   &sql.Ident{Name: "tbl", NamePos: pos(13)},
						Lparen: pos(17),
						Columns: []*sql.ColumnDefinition{
							{
								Name: &sql.Ident{Name: "col1", NamePos: pos(18)},
								Type: &sql.Type{
									Name: &sql.Ident{Name: "TEXT", NamePos: pos(23)},
								},
								Constraints: []sql.Constraint{
									&sql.PrimaryKeyConstraint{
										Primary: pos(28),
										Key:     pos(36),
									},
								},
							},
						},
						Rparen: pos(39),
					})
				})
				t.Run("Full", func(t *testing.T) {
					stmt := ParseStatementOrFail(t, `CREATE TABLE tbl (col1 TEXT CONSTRAINT cons1 PRIMARY KEY AUTOINCREMENT)`).(*sql.CreateTableStatement)
					if diff := deep.Equal(stmt.Columns[0].Constraints[0], &sql.PrimaryKeyConstraint{
						Constraint:    pos(28),
						Name:          &sql.Ident{Name: "cons1", NamePos: pos(39)},
						Primary:       pos(45),
						Key:           pos(53),
						Autoincrement: pos(57),
					}); diff != nil {
						t.Fatal(diff)
					}
				})
				// Constraints may carry an ON CONFLICT clause. Both statements are
				// accepted by SQLite itself.
				t.Run("OnConflict", func(t *testing.T) {
					stmt := ParseStatementOrFail(t, `CREATE TABLE tbl (col1 INTEGER PRIMARY KEY ASC ON CONFLICT ROLLBACK AUTOINCREMENT, col2 TEXT NOT NULL ON CONFLICT REPLACE, col3 UNIQUE ON CONFLICT IGNORE, UNIQUE (col2) ON CONFLICT FAIL)`).(*sql.CreateTableStatement)
					if diff := deepEqual(stmt.Columns[0].Constraints[0], &sql.PrimaryKeyConstraint{
						Primary:       pos(31),
						Key:           pos(39),
						Asc:           pos(43),
						Conflict:      &sql.ConflictClause{On: pos(47), Conflict: pos(50), Rollback: pos(59)},
						Autoincrement: pos(68),
					}); diff != "" {
						t.Fatal(diff)
					}
					if diff := deepEqual(stmt.Columns[1].Constraints[0], &sql.NotNullConstraint{
						Not:      pos(93),
						Null:     pos(97),
						Conflict: &sql.ConflictClause{On: pos(102), Conflict: pos(105), Replace: pos(114)},
					}); diff != "" {
						t.Fatal(diff)
					}
					if diff := deepEqual(stmt.Columns[2].Constraints[0], &sql.UniqueConstraint{
						Unique:   pos(128),
						Conflict: &sql.ConflictClause{On: pos(135), Conflict: pos(138), Ignore: pos(147)},
					}); diff != "" {
						t.Fatal(diff)
					}
					if len(stmt.Constraints) != 1 {
						t.Fatalf("expected 1 table constraint, got %d", len(stmt.Constraints))
					} else if c := stmt.Constraints[0].(*sql.UniqueConstraint).Conflict; c == nil || !c.Fail.IsValid() {
						t.Fatalf("expected UNIQUE ... ON CONFLICT FAIL, got %v", c)
					}

					stmt = ParseStatementOrFail(t, `CREATE TABLE tbl2 (col1 INTEGER, col2 TEXT NOT NULL, PRIMARY KEY (col1) ON CONFLICT ABORT, UNIQUE (col2) ON CONFLICT FAIL)`).(*sql.CreateTableStatement)
					if len(stmt.Constraints) != 2 {
						t.Fatalf("expected 2 table constraints, got %d", len(stmt.Constraints))
					} else if c := stmt.Constraints[0].(*sql.PrimaryKeyConstraint).Conflict; c == nil || !c.Abort.IsValid() {
						t.Fatalf("expected PRIMARY KEY ... ON CONFLICT ABORT, got %v", c)
					}

					AssertParseStatementError(t, `CREATE TABLE tbl (col1 INTEGER NOT NULL ON CONFLICT)`, `1:52: expected ROLLBACK, ABORT, FAIL, IGNORE, or REPLACE, found ')'`)
					AssertParseStatementError(t, `CREATE TABLE tbl (col1 INTEGER NOT NULL ON DELETE)`, `1:44: expected CONFLICT, found 'DELETE'`)
				})
				// A column PRIMARY KEY may specify a sort order; it must not be
				// mistaken for the start of another column definition.
				t.Run("Desc", func(t *testing.T) {
					stmt := ParseStatementOrFail(t, `CREATE TABLE tbl (col1 INTEGER PRIMARY KEY DESC AUTOINCREMENT)`).(*sql.CreateTableStatement)
					if len(stmt.Columns) != 1 {
						t.Fatalf("expected 1 column, got %d", len(stmt.Columns))
					}
					if diff := deep.Equal(stmt.Columns[0].Constraints[0], &sql.PrimaryKeyConstraint{
						Primary:       pos(31),
						Key:           pos(39),
						Desc:          pos(43),
						Autoincrement: pos(48),
					}); diff != nil {
						t.Fatal(diff)
					}
				})
				t.Run("Asc", func(t *testing.T) {
					stmt := ParseStatementOrFail(t, `CREATE TABLE tbl (col1 INTEGER PRIMARY KEY ASC)`).(*sql.CreateTableStatement)
					if len(stmt.Columns) != 1 {
						t.Fatalf("expected 1 column, got %d", len(stmt.Columns))
					}
					if diff := deep.Equal(stmt.Columns[0].Constraints[0], &sql.PrimaryKeyConstraint{
						Primary: pos(31),
						Key:     pos(39),
						Asc:     pos(43),
					}); diff != nil {
						t.Fatal(diff)
					}
				})
				t.Run("ErrNoKey", func(t *testing.T) {
					AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT PRIMARY`, `1:35: expected KEY, found 'EOF'`)
				})
			})

			t.Run("NotNull", func(t *testing.T) {
				t.Run("ErrNoKey", func(t *testing.T) {
					AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT NOT`, `1:31: expected NULL, found 'EOF'`)
				})
				t.Run("Simple", func(t *testing.T) {
					AssertParseStatement(t, `CREATE TABLE tbl (col1 TEXT CONSTRAINT con1 NOT NULL)`, &sql.CreateTableStatement{
						Create: pos(0),
						Table:  pos(7),
						Name:   &sql.Ident{Name: "tbl", NamePos: pos(13)},
						Lparen: pos(17),
						Columns: []*sql.ColumnDefinition{
							{
								Name: &sql.Ident{Name: "col1", NamePos: pos(18)},
								Type: &sql.Type{
									Name: &sql.Ident{Name: "TEXT", NamePos: pos(23)},
								},
								Constraints: []sql.Constraint{
									&sql.NotNullConstraint{
										Constraint: pos(28),
										Name:       &sql.Ident{Name: "con1", NamePos: pos(39)},
										Not:        pos(44),
										Null:       pos(48),
									},
								},
							},
						},
						Rparen: pos(52),
					})
				})
			})

			t.Run("Unique", func(t *testing.T) {
				t.Run("Simple", func(t *testing.T) {
					AssertParseStatement(t, `CREATE TABLE tbl (col1 TEXT CONSTRAINT con1 UNIQUE)`, &sql.CreateTableStatement{
						Create: pos(0),
						Table:  pos(7),
						Name:   &sql.Ident{Name: "tbl", NamePos: pos(13)},
						Lparen: pos(17),
						Columns: []*sql.ColumnDefinition{
							{
								Name: &sql.Ident{Name: "col1", NamePos: pos(18)},
								Type: &sql.Type{
									Name: &sql.Ident{Name: "TEXT", NamePos: pos(23)},
								},
								Constraints: []sql.Constraint{
									&sql.UniqueConstraint{
										Constraint: pos(28),
										Name:       &sql.Ident{Name: "con1", NamePos: pos(39)},
										Unique:     pos(44),
									},
								},
							},
						},
						Rparen: pos(50),
					})
				})
			})
			t.Run("Check", func(t *testing.T) {
				AssertParseStatement(t, `CREATE TABLE tbl (col1 TEXT CHECK (col1 > 1))`, &sql.CreateTableStatement{
					Create: pos(0),
					Table:  pos(7),
					Name:   &sql.Ident{Name: "tbl", NamePos: pos(13)},
					Lparen: pos(17),
					Columns: []*sql.ColumnDefinition{
						{
							Name: &sql.Ident{Name: "col1", NamePos: pos(18)},
							Type: &sql.Type{
								Name: &sql.Ident{Name: "TEXT", NamePos: pos(23)},
							},
							Constraints: []sql.Constraint{
								&sql.CheckConstraint{
									Check:  pos(28),
									Lparen: pos(34),
									Expr: &sql.BinaryExpr{
										X:  &sql.Ident{Name: "col1", NamePos: pos(35)},
										Op: sql.GT, OpPos: pos(40),
										Y: &sql.NumberLit{Value: "1", ValuePos: pos(42)},
									},
									Rparen: pos(43),
								},
							},
						},
					},
					Rparen: pos(44),
				})
			})
			t.Run("Default", func(t *testing.T) {
				t.Run("Expr", func(t *testing.T) {
					AssertParseStatement(t, `CREATE TABLE tbl (col1 TEXT DEFAULT (1))`, &sql.CreateTableStatement{
						Create: pos(0),
						Table:  pos(7),
						Name:   &sql.Ident{Name: "tbl", NamePos: pos(13)},
						Lparen: pos(17),
						Columns: []*sql.ColumnDefinition{
							{
								Name: &sql.Ident{Name: "col1", NamePos: pos(18)},
								Type: &sql.Type{
									Name: &sql.Ident{Name: "TEXT", NamePos: pos(23)},
								},
								Constraints: []sql.Constraint{
									&sql.DefaultConstraint{
										Default: pos(28),
										Lparen:  pos(36),
										Expr:    &sql.NumberLit{Value: "1", ValuePos: pos(37)},
										Rparen:  pos(38),
									},
								},
							},
						},
						Rparen: pos(39),
					})
				})
				t.Run("String", func(t *testing.T) {
					stmt := ParseStatementOrFail(t, `CREATE TABLE tbl (col1 TEXT DEFAULT 'foo')`).(*sql.CreateTableStatement)
					if diff := deepEqual(stmt.Columns[0].Constraints[0], &sql.DefaultConstraint{
						Default: pos(28),
						Expr:    &sql.StringLit{Value: "foo", ValuePos: pos(36)},
					}); diff != "" {
						t.Fatal(diff)
					}
				})
				t.Run("DoubleQuotedIdent", func(t *testing.T) {
					stmt := ParseStatementOrFail(t, `CREATE TABLE tbl (col1 TEXT DEFAULT "foo")`).(*sql.CreateTableStatement)
					if diff := deepEqual(stmt.Columns[0].Constraints[0], &sql.DefaultConstraint{
						Default: pos(28),
						Expr:    &sql.StringLit{Value: "foo", ValuePos: pos(36)},
					}); diff != "" {
						t.Fatal(diff)
					}
				})
				t.Run("Blob", func(t *testing.T) {
					stmt := ParseStatementOrFail(t, `CREATE TABLE tbl (col1 TEXT DEFAULT x'0F0F')`).(*sql.CreateTableStatement)
					if diff := deepEqual(stmt.Columns[0].Constraints[0], &sql.DefaultConstraint{
						Default: pos(28),
						Expr:    &sql.BlobLit{Value: "0F0F", ValuePos: pos(36)},
					}); diff != "" {
						t.Fatal(diff)
					}
				})
				t.Run("Number", func(t *testing.T) {
					stmt := ParseStatementOrFail(t, `CREATE TABLE tbl (col1 TEXT DEFAULT 1)`).(*sql.CreateTableStatement)
					if diff := deepEqual(stmt.Columns[0].Constraints[0], &sql.DefaultConstraint{
						Default: pos(28),
						Expr:    &sql.NumberLit{Value: "1", ValuePos: pos(36)},
					}); diff != "" {
						t.Fatal(diff)
					}
				})
				t.Run("Null", func(t *testing.T) {
					stmt := ParseStatementOrFail(t, `CREATE TABLE tbl (col1 TEXT DEFAULT NULL)`).(*sql.CreateTableStatement)
					if diff := deepEqual(stmt.Columns[0].Constraints[0], &sql.DefaultConstraint{
						Default: pos(28),
						Expr:    &sql.NullLit{Pos: pos(36)},
					}); diff != "" {
						t.Fatal(diff)
					}
				})
				t.Run("Bool", func(t *testing.T) {
					stmt := ParseStatementOrFail(t, `CREATE TABLE tbl (col1 TEXT DEFAULT true)`).(*sql.CreateTableStatement)
					if diff := deepEqual(stmt.Columns[0].Constraints[0], &sql.DefaultConstraint{
						Default: pos(28),
						Expr:    &sql.BoolLit{Value: true, ValuePos: pos(36)},
					}); diff != "" {
						t.Fatal(diff)
					}
				})

				AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT DEFAULT +`, `1:37: expected signed number, found 'EOF'`)
				AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT DEFAULT -`, `1:37: expected signed number, found 'EOF'`)
				AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT DEFAULT `, `1:36: expected literal value, identifier or left paren, found 'EOF'`)
				AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT DEFAULT (TABLE`, `1:38: expected expression, found 'TABLE'`)
				AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT DEFAULT (true`, `1:41: expected right paren, found 'EOF'`)
			})

			t.Run("Generated", func(t *testing.T) {
				AssertParseStatement(t, `CREATE TABLE tbl (col1 TEXT GENERATED ALWAYS AS (1))`, &sql.CreateTableStatement{
					Create: pos(0),
					Table:  pos(7),
					Name:   &sql.Ident{Name: "tbl", NamePos: pos(13)},
					Lparen: pos(17),
					Columns: []*sql.ColumnDefinition{
						{
							Name: &sql.Ident{Name: "col1", NamePos: pos(18)},
							Type: &sql.Type{
								Name: &sql.Ident{Name: "TEXT", NamePos: pos(23)},
							},
							Constraints: []sql.Constraint{
								&sql.GeneratedConstraint{
									Generated: pos(28),
									Always:    pos(38),
									As:        pos(45),
									Lparen:    pos(48),
									Expr:      &sql.NumberLit{Value: "1", ValuePos: pos(49)},
									Rparen:    pos(50),
								},
							},
						},
					},
					Rparen: pos(51),
				})

				AssertParseStatement(t, `CREATE TABLE tbl (col1 TEXT AS (1) STORED)`, &sql.CreateTableStatement{
					Create: pos(0),
					Table:  pos(7),
					Name:   &sql.Ident{Name: "tbl", NamePos: pos(13)},
					Lparen: pos(17),
					Columns: []*sql.ColumnDefinition{
						{
							Name: &sql.Ident{Name: "col1", NamePos: pos(18)},
							Type: &sql.Type{
								Name: &sql.Ident{Name: "TEXT", NamePos: pos(23)},
							},
							Constraints: []sql.Constraint{
								&sql.GeneratedConstraint{
									As:     pos(28),
									Lparen: pos(31),
									Expr:   &sql.NumberLit{Value: "1", ValuePos: pos(32)},
									Rparen: pos(33),
									Stored: pos(35),
								},
							},
						},
					},
					Rparen: pos(41),
				})

				AssertParseStatement(t, `CREATE TABLE tbl (col1 TEXT AS (1) VIRTUAL)`, &sql.CreateTableStatement{
					Create: pos(0),
					Table:  pos(7),
					Name:   &sql.Ident{Name: "tbl", NamePos: pos(13)},
					Lparen: pos(17),
					Columns: []*sql.ColumnDefinition{
						{
							Name: &sql.Ident{Name: "col1", NamePos: pos(18)},
							Type: &sql.Type{
								Name: &sql.Ident{Name: "TEXT", NamePos: pos(23)},
							},
							Constraints: []sql.Constraint{
								&sql.GeneratedConstraint{
									As:      pos(28),
									Lparen:  pos(31),
									Expr:    &sql.NumberLit{Value: "1", ValuePos: pos(32)},
									Rparen:  pos(33),
									Virtual: pos(35),
								},
							},
						},
					},
					Rparen: pos(42),
				})

				AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT GENERATED`, `1:37: expected ALWAYS, found 'EOF'`)
				AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT GENERATED ALWAYS`, `1:44: expected AS, found 'EOF'`)
				AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT AS `, `1:31: expected left paren, found 'EOF'`)
				AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT AS (`, `1:32: expected expression, found 'EOF'`)
				AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT AS (1`, `1:33: expected right paren, found 'EOF'`)
			})

			t.Run("Collate", func(t *testing.T) {
				AssertParseStatement(t, `CREATE TABLE tbl (col1 TEXT COLLATE NOCASE)`, &sql.CreateTableStatement{
					Create: pos(0),
					Table:  pos(7),
					Name:   &sql.Ident{Name: "tbl", NamePos: pos(13)},
					Lparen: pos(17),
					Columns: []*sql.ColumnDefinition{
						{
							Name: &sql.Ident{Name: "col1", NamePos: pos(18)},
							Type: &sql.Type{
								Name: &sql.Ident{Name: "TEXT", NamePos: pos(23)},
							},
							Constraints: []sql.Constraint{
								&sql.CollateConstraint{
									Collate:   pos(28),
									Collation: &sql.Ident{NamePos: pos(36), Name: "NOCASE"},
								},
							},
						},
					},
					Rparen: pos(42),
				})

				AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT COLLATE`, `1:35: expected collation name, found 'EOF'`)
			})

			t.Run("ForeignKey", func(t *testing.T) {
				t.Run("Simple", func(t *testing.T) {
					AssertParseStatement(t, `CREATE TABLE tbl (col1 TEXT REFERENCES foo (col2))`, &sql.CreateTableStatement{
						Create: pos(0),
						Table:  pos(7),
						Name:   &sql.Ident{Name: "tbl", NamePos: pos(13)},
						Lparen: pos(17),
						Columns: []*sql.ColumnDefinition{
							{
								Name: &sql.Ident{Name: "col1", NamePos: pos(18)},
								Type: &sql.Type{
									Name: &sql.Ident{Name: "TEXT", NamePos: pos(23)},
								},
								Constraints: []sql.Constraint{
									&sql.ForeignKeyConstraint{
										References:    pos(28),
										ForeignTable:  &sql.Ident{Name: "foo", NamePos: pos(39)},
										ForeignLparen: pos(43),
										ForeignColumns: []*sql.Ident{
											{Name: "col2", NamePos: pos(44)},
										},
										ForeignRparen: pos(48),
									},
								},
							},
						},
						Rparen: pos(49),
					})
				})
				// INITIALLY must be followed by DEFERRED or IMMEDIATE.
				t.Run("ErrInitially", func(t *testing.T) {
					AssertParseStatementError(t, `CREATE TABLE tbl (col1 INTEGER REFERENCES other DEFERRABLE INITIALLY)`, `1:69: expected DEFERRED or IMMEDIATE, found ')'`)
					AssertParseStatementError(t, `CREATE TABLE tbl (col1 INTEGER REFERENCES other NOT DEFERRABLE INITIALLY)`, `1:73: expected DEFERRED or IMMEDIATE, found ')'`)
				})
				// MATCH clauses may appear among the ON clauses in any order.
				t.Run("Match", func(t *testing.T) {
					stmt := ParseStatementOrFail(t, `CREATE TABLE tbl (col1 INTEGER REFERENCES other (y) MATCH SIMPLE ON DELETE CASCADE MATCH FULL)`).(*sql.CreateTableStatement)
					if diff := deepEqual(stmt.Columns[0].Constraints[0], &sql.ForeignKeyConstraint{
						References:     pos(31),
						ForeignTable:   &sql.Ident{Name: "other", NamePos: pos(42)},
						ForeignLparen:  pos(48),
						ForeignColumns: []*sql.Ident{{Name: "y", NamePos: pos(49)}},
						ForeignRparen:  pos(50),
						Args: []*sql.ForeignKeyArg{
							{Match: pos(52), MatchName: &sql.Ident{Name: "SIMPLE", NamePos: pos(58)}},
							{On: pos(65), OnDelete: pos(68), Cascade: pos(75)},
							{Match: pos(83), MatchName: &sql.Ident{Name: "FULL", NamePos: pos(89)}},
						},
					}); diff != "" {
						t.Fatal(diff)
					}
					if got, want := stmt.String(), `CREATE TABLE "tbl" ("col1" INTEGER REFERENCES "other" ("y") MATCH SIMPLE ON DELETE CASCADE MATCH FULL)`; got != want {
						t.Fatalf("String()=%s, want %s", got, want)
					}
					AssertParseStatementError(t, `CREATE TABLE tbl (col1 INTEGER REFERENCES other MATCH)`, `1:54: expected match type, found ')'`)
				})
				// The foreign column list is optional; the parent table's primary
				// key is used when it is omitted.
				t.Run("NoColumnList", func(t *testing.T) {
					stmt := ParseStatementOrFail(t, `CREATE TABLE tbl (col1 INTEGER REFERENCES other ON DELETE CASCADE)`).(*sql.CreateTableStatement)
					if diff := deepEqual(stmt.Columns[0].Constraints[0], &sql.ForeignKeyConstraint{
						References:   pos(31),
						ForeignTable: &sql.Ident{Name: "other", NamePos: pos(42)},
						Args: []*sql.ForeignKeyArg{{
							On:       pos(48),
							OnDelete: pos(51),
							Cascade:  pos(58),
						}},
					}); diff != "" {
						t.Fatal(diff)
					}
				})
				t.Run("OnDeleteSetNull", func(t *testing.T) {
					stmt := ParseStatementOrFail(t, `CREATE TABLE tbl (col1 TEXT REFERENCES foo (col2) ON DELETE SET NULL)`).(*sql.CreateTableStatement)
					if diff := deepEqual(stmt.Columns[0].Constraints[0], &sql.ForeignKeyConstraint{
						References:    pos(28),
						ForeignTable:  &sql.Ident{Name: "foo", NamePos: pos(39)},
						ForeignLparen: pos(43),
						ForeignColumns: []*sql.Ident{
							{Name: "col2", NamePos: pos(44)},
						},
						ForeignRparen: pos(48),
						Args: []*sql.ForeignKeyArg{
							{
								On:       pos(50),
								OnDelete: pos(53),
								Set:      pos(60),
								SetNull:  pos(64),
							},
						},
					}); diff != "" {
						t.Fatal(diff)
					}
				})
				t.Run("OnDeleteSetDefault", func(t *testing.T) {
					stmt := ParseStatementOrFail(t, `CREATE TABLE tbl (col1 TEXT REFERENCES foo (col2) ON DELETE SET DEFAULT)`).(*sql.CreateTableStatement)
					if diff := deepEqual(stmt.Columns[0].Constraints[0], &sql.ForeignKeyConstraint{
						References:    pos(28),
						ForeignTable:  &sql.Ident{Name: "foo", NamePos: pos(39)},
						ForeignLparen: pos(43),
						ForeignColumns: []*sql.Ident{
							{Name: "col2", NamePos: pos(44)},
						},
						ForeignRparen: pos(48),
						Args: []*sql.ForeignKeyArg{
							{
								On:         pos(50),
								OnDelete:   pos(53),
								Set:        pos(60),
								SetDefault: pos(64),
							},
						},
					}); diff != "" {
						t.Fatal(diff)
					}
				})
				t.Run("OnDeleteSetDefault", func(t *testing.T) {
					stmt := ParseStatementOrFail(t, `CREATE TABLE tbl (col1 TEXT REFERENCES foo (col2) ON DELETE CASCADE)`).(*sql.CreateTableStatement)
					if diff := deepEqual(stmt.Columns[0].Constraints[0], &sql.ForeignKeyConstraint{
						References:    pos(28),
						ForeignTable:  &sql.Ident{Name: "foo", NamePos: pos(39)},
						ForeignLparen: pos(43),
						ForeignColumns: []*sql.Ident{
							{Name: "col2", NamePos: pos(44)},
						},
						ForeignRparen: pos(48),
						Args: []*sql.ForeignKeyArg{
							{
								On:       pos(50),
								OnDelete: pos(53),
								Cascade:  pos(60),
							},
						},
					}); diff != "" {
						t.Fatal(diff)
					}
				})
				t.Run("OnDeleteSetRestrict", func(t *testing.T) {
					stmt := ParseStatementOrFail(t, `CREATE TABLE tbl (col1 TEXT REFERENCES foo (col2) ON DELETE RESTRICT)`).(*sql.CreateTableStatement)
					if diff := deepEqual(stmt.Columns[0].Constraints[0], &sql.ForeignKeyConstraint{
						References:    pos(28),
						ForeignTable:  &sql.Ident{Name: "foo", NamePos: pos(39)},
						ForeignLparen: pos(43),
						ForeignColumns: []*sql.Ident{
							{Name: "col2", NamePos: pos(44)},
						},
						ForeignRparen: pos(48),
						Args: []*sql.ForeignKeyArg{
							{
								On:       pos(50),
								OnDelete: pos(53),
								Restrict: pos(60),
							},
						},
					}); diff != "" {
						t.Fatal(diff)
					}
				})
				t.Run("OnDeleteSetNoAction", func(t *testing.T) {
					stmt := ParseStatementOrFail(t, `CREATE TABLE tbl (col1 TEXT REFERENCES foo (col2) ON DELETE NO ACTION)`).(*sql.CreateTableStatement)
					if diff := deepEqual(stmt.Columns[0].Constraints[0], &sql.ForeignKeyConstraint{
						References:    pos(28),
						ForeignTable:  &sql.Ident{Name: "foo", NamePos: pos(39)},
						ForeignLparen: pos(43),
						ForeignColumns: []*sql.Ident{
							{Name: "col2", NamePos: pos(44)},
						},
						ForeignRparen: pos(48),
						Args: []*sql.ForeignKeyArg{
							{
								On:       pos(50),
								OnDelete: pos(53),
								No:       pos(60),
								NoAction: pos(63),
							},
						},
					}); diff != "" {
						t.Fatal(diff)
					}
				})
				t.Run("Multiple", func(t *testing.T) {
					stmt := ParseStatementOrFail(t, `CREATE TABLE tbl (col1 TEXT REFERENCES foo (col2) ON DELETE CASCADE ON UPDATE RESTRICT)`).(*sql.CreateTableStatement)
					if diff := deepEqual(stmt.Columns[0].Constraints[0], &sql.ForeignKeyConstraint{
						References:    pos(28),
						ForeignTable:  &sql.Ident{Name: "foo", NamePos: pos(39)},
						ForeignLparen: pos(43),
						ForeignColumns: []*sql.Ident{
							{Name: "col2", NamePos: pos(44)},
						},
						ForeignRparen: pos(48),
						Args: []*sql.ForeignKeyArg{
							{
								On:       pos(50),
								OnDelete: pos(53),
								Cascade:  pos(60),
							},
							{
								On:       pos(68),
								OnUpdate: pos(71),
								Restrict: pos(78),
							},
						},
					}); diff != "" {
						t.Fatal(diff)
					}
				})
				t.Run("Deferrable", func(t *testing.T) {
					stmt := ParseStatementOrFail(t, `CREATE TABLE tbl (col1 TEXT REFERENCES foo (col2) DEFERRABLE)`).(*sql.CreateTableStatement)
					if diff := deepEqual(stmt.Columns[0].Constraints[0], &sql.ForeignKeyConstraint{
						References:    pos(28),
						ForeignTable:  &sql.Ident{Name: "foo", NamePos: pos(39)},
						ForeignLparen: pos(43),
						ForeignColumns: []*sql.Ident{
							{Name: "col2", NamePos: pos(44)},
						},
						ForeignRparen: pos(48),
						Deferrable:    pos(50),
					}); diff != "" {
						t.Fatal(diff)
					}
				})
				t.Run("NotDeferrable", func(t *testing.T) {
					stmt := ParseStatementOrFail(t, `CREATE TABLE tbl (col1 TEXT REFERENCES foo (col2) NOT DEFERRABLE)`).(*sql.CreateTableStatement)
					if diff := deepEqual(stmt.Columns[0].Constraints[0], &sql.ForeignKeyConstraint{
						References:    pos(28),
						ForeignTable:  &sql.Ident{Name: "foo", NamePos: pos(39)},
						ForeignLparen: pos(43),
						ForeignColumns: []*sql.Ident{
							{Name: "col2", NamePos: pos(44)},
						},
						ForeignRparen: pos(48),
						Not:           pos(50),
						NotDeferrable: pos(54),
					}); diff != "" {
						t.Fatal(diff)
					}
				})
				t.Run("InitiallyDeferred", func(t *testing.T) {
					stmt := ParseStatementOrFail(t, `CREATE TABLE tbl (col1 TEXT REFERENCES foo (col2) DEFERRABLE INITIALLY DEFERRED)`).(*sql.CreateTableStatement)
					if diff := deepEqual(stmt.Columns[0].Constraints[0], &sql.ForeignKeyConstraint{
						References:    pos(28),
						ForeignTable:  &sql.Ident{Name: "foo", NamePos: pos(39)},
						ForeignLparen: pos(43),
						ForeignColumns: []*sql.Ident{
							{Name: "col2", NamePos: pos(44)},
						},
						ForeignRparen:     pos(48),
						Deferrable:        pos(50),
						Initially:         pos(61),
						InitiallyDeferred: pos(71),
					}); diff != "" {
						t.Fatal(diff)
					}
				})
				t.Run("InitiallyImmediate", func(t *testing.T) {
					stmt := ParseStatementOrFail(t, `CREATE TABLE tbl (col1 TEXT REFERENCES foo (col2) DEFERRABLE INITIALLY IMMEDIATE)`).(*sql.CreateTableStatement)
					if diff := deepEqual(stmt.Columns[0].Constraints[0], &sql.ForeignKeyConstraint{
						References:    pos(28),
						ForeignTable:  &sql.Ident{Name: "foo", NamePos: pos(39)},
						ForeignLparen: pos(43),
						ForeignColumns: []*sql.Ident{
							{Name: "col2", NamePos: pos(44)},
						},
						ForeignRparen:      pos(48),
						Deferrable:         pos(50),
						Initially:          pos(61),
						InitiallyImmediate: pos(71),
					}); diff != "" {
						t.Fatal(diff)
					}
				})
			})
		})

		t.Run("TableConstraint", func(t *testing.T) {
			// Table PRIMARY KEY columns are indexed columns and may be followed
			// by AUTOINCREMENT inside the parentheses.
			t.Run("PrimaryKeyIndexedColumns", func(t *testing.T) {
				stmt := ParseStatementOrFail(t, `CREATE TABLE tbl (col1, col2, PRIMARY KEY (col1 COLLATE NOCASE DESC, col2 ASC))`).(*sql.CreateTableStatement)
				if diff := deepEqual(stmt.Constraints[0], &sql.PrimaryKeyConstraint{
					Primary: pos(30),
					Key:     pos(38),
					Lparen:  pos(42),
					Columns: []*sql.IndexedColumn{
						{X: &sql.CollateExpr{X: &sql.Ident{Name: "col1", NamePos: pos(43)}, Collation: &sql.CollationClause{Collate: pos(48), Name: &sql.Ident{Name: "NOCASE", NamePos: pos(56)}}}, Desc: pos(63)},
						{X: &sql.Ident{Name: "col2", NamePos: pos(69)}, Asc: pos(74)},
					},
					Rparen: pos(77),
				}); diff != "" {
					t.Fatal(diff)
				}
				if got, want := stmt.String(), `CREATE TABLE "tbl" ("col1", "col2", PRIMARY KEY ("col1" COLLATE "NOCASE" DESC, "col2" ASC))`; got != want {
					t.Fatalf("String()=%s, want %s", got, want)
				}

				// AUTOINCREMENT goes inside the parens and, as SQLite requires,
				// on a single INTEGER column.
				stmt = ParseStatementOrFail(t, `CREATE TABLE tbl (col1 INTEGER, PRIMARY KEY (col1 AUTOINCREMENT))`).(*sql.CreateTableStatement)
				if diff := deepEqual(stmt.Constraints[0], &sql.PrimaryKeyConstraint{
					Primary:       pos(32),
					Key:           pos(40),
					Lparen:        pos(44),
					Columns:       []*sql.IndexedColumn{{X: &sql.Ident{Name: "col1", NamePos: pos(45)}}},
					Autoincrement: pos(50),
					Rparen:        pos(63),
				}); diff != "" {
					t.Fatal(diff)
				}
				if got, want := stmt.String(), `CREATE TABLE "tbl" ("col1" INTEGER, PRIMARY KEY ("col1" AUTOINCREMENT))`; got != want {
					t.Fatalf("String()=%s, want %s", got, want)
				}
				AssertParseStatementError(t, `CREATE TABLE tbl (col1, PRIMARY KEY (col1 AUTOINCREMENT, col2))`, `1:56: expected right paren, found ','`)
			})
			t.Run("PrimaryKey", func(t *testing.T) {
				AssertParseStatement(t, `CREATE TABLE tbl (col1 TEXT, PRIMARY KEY (col1, col2))`, &sql.CreateTableStatement{
					Create: pos(0),
					Table:  pos(7),
					Name:   &sql.Ident{Name: "tbl", NamePos: pos(13)},
					Lparen: pos(17),
					Columns: []*sql.ColumnDefinition{
						{
							Name: &sql.Ident{Name: "col1", NamePos: pos(18)},
							Type: &sql.Type{
								Name: &sql.Ident{Name: "TEXT", NamePos: pos(23)},
							},
						},
					},
					Constraints: []sql.Constraint{
						&sql.PrimaryKeyConstraint{
							Primary: pos(29),
							Key:     pos(37),
							Lparen:  pos(41),
							Columns: []*sql.IndexedColumn{
								{X: &sql.Ident{Name: "col1", NamePos: pos(42)}},
								{X: &sql.Ident{Name: "col2", NamePos: pos(48)}},
							},
							Rparen: pos(52),
						},
					},
					Rparen: pos(53),
				})

				AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT, PRIMARY`, `1:36: expected KEY, found 'EOF'`)
				AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT, PRIMARY KEY`, `1:40: expected left paren, found 'EOF'`)
				AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT, PRIMARY KEY (col1)`, `1:47: expected right paren, found 'EOF'`)
				AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT, PRIMARY KEY (1`, `1:43: expected comma or right paren, found 'EOF'`)
				AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT, PRIMARY KEY (foo x`, `1:47: expected comma or right paren, found x`)
			})
			t.Run("Unique", func(t *testing.T) {
				AssertParseStatement(t, `CREATE TABLE tbl (col1 TEXT, CONSTRAINT con1 UNIQUE (col1, col2 COLLATE NOCASE))`, &sql.CreateTableStatement{
					Create: pos(0),
					Table:  pos(7),
					Name:   &sql.Ident{Name: "tbl", NamePos: pos(13)},
					Lparen: pos(17),
					Columns: []*sql.ColumnDefinition{
						{
							Name: &sql.Ident{Name: "col1", NamePos: pos(18)},
							Type: &sql.Type{
								Name: &sql.Ident{Name: "TEXT", NamePos: pos(23)},
							},
						},
					},
					Constraints: []sql.Constraint{
						&sql.UniqueConstraint{
							Constraint: pos(29),
							Name:       &sql.Ident{Name: "con1", NamePos: pos(40)},
							Unique:     pos(45),
							Lparen:     pos(52),
							Columns: []*sql.IndexedColumn{
								{X: &sql.Ident{Name: "col1", NamePos: pos(53)}},
								{
									X: &sql.CollateExpr{
										X: &sql.Ident{Name: "col2", NamePos: pos(59)},
										Collation: &sql.CollationClause{
											Collate: pos(64),
											Name:    &sql.Ident{Name: "NOCASE", NamePos: pos(72)},
										},
									},
								},
							},
							Rparen: pos(78),
						},
					},
					Rparen: pos(79),
				})
				AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT, UNIQUE`, `1:35: expected left paren, found 'EOF'`)
				AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT, UNIQUE (1`, `1:38: expected comma or right paren, found 'EOF'`)
				AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT, UNIQUE (x y`, `1:40: expected comma or right paren, found y`)
			})
			t.Run("Check", func(t *testing.T) {
				AssertParseStatement(t, `CREATE TABLE tbl (col1 TEXT, CHECK(foo = bar))`, &sql.CreateTableStatement{
					Create: pos(0),
					Table:  pos(7),
					Name:   &sql.Ident{Name: "tbl", NamePos: pos(13)},
					Lparen: pos(17),
					Columns: []*sql.ColumnDefinition{
						{
							Name: &sql.Ident{Name: "col1", NamePos: pos(18)},
							Type: &sql.Type{
								Name: &sql.Ident{Name: "TEXT", NamePos: pos(23)},
							},
						},
					},
					Constraints: []sql.Constraint{
						&sql.CheckConstraint{
							Check:  pos(29),
							Lparen: pos(34),
							Expr: &sql.BinaryExpr{
								X:  &sql.Ident{Name: "foo", NamePos: pos(35)},
								Op: sql.EQ, OpPos: pos(39),
								Y: &sql.Ident{Name: "bar", NamePos: pos(41)},
							},
							Rparen: pos(44),
						},
					},
					Rparen: pos(45),
				})

				AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT, CHECK`, `1:34: expected left paren, found 'EOF'`)
				AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT, CHECK (TABLE`, `1:37: expected expression, found 'TABLE'`)
				AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT, CHECK (true`, `1:40: expected right paren, found 'EOF'`)
			})
			t.Run("ForeignKey", func(t *testing.T) {
				AssertParseStatement(t, `CREATE TABLE tbl (col1 TEXT, FOREIGN KEY (col1, col2) REFERENCES tbl2 (x, y))`, &sql.CreateTableStatement{
					Create: pos(0),
					Table:  pos(7),
					Name:   &sql.Ident{Name: "tbl", NamePos: pos(13)},
					Lparen: pos(17),
					Columns: []*sql.ColumnDefinition{
						{
							Name: &sql.Ident{Name: "col1", NamePos: pos(18)},
							Type: &sql.Type{
								Name: &sql.Ident{Name: "TEXT", NamePos: pos(23)},
							},
						},
					},
					Constraints: []sql.Constraint{
						&sql.ForeignKeyConstraint{
							Foreign:    pos(29),
							ForeignKey: pos(37),
							Lparen:     pos(41),
							Columns: []*sql.Ident{
								{Name: "col1", NamePos: pos(42)},
								{Name: "col2", NamePos: pos(48)},
							},
							Rparen:        pos(52),
							References:    pos(54),
							ForeignTable:  &sql.Ident{Name: "tbl2", NamePos: pos(65)},
							ForeignLparen: pos(70),
							ForeignColumns: []*sql.Ident{
								{Name: "x", NamePos: pos(71)},
								{Name: "y", NamePos: pos(74)},
							},
							ForeignRparen: pos(75),
						},
					},
					Rparen: pos(76),
				})

				AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT, FOREIGN`, `1:36: expected KEY, found 'EOF'`)
				AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT, FOREIGN KEY`, `1:40: expected left paren, found 'EOF'`)
				AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT, FOREIGN KEY (`, `1:42: expected column name, found 'EOF'`)
				AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT, FOREIGN KEY (x`, `1:43: expected comma or right paren, found 'EOF'`)
				AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT, FOREIGN KEY (x)`, `1:44: expected REFERENCES, found 'EOF'`)
				AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT, FOREIGN KEY (x) REFERENCES`, `1:55: expected foreign table name, found 'EOF'`)
				AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT, FOREIGN KEY (x) REFERENCES tbl`, `1:59: expected right paren, found 'EOF'`)
				AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT, FOREIGN KEY (x) REFERENCES tbl (`, `1:61: expected foreign column name, found 'EOF'`)
				AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT, FOREIGN KEY (x) REFERENCES tbl (x`, `1:62: expected comma or right paren, found 'EOF'`)
				AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT, FOREIGN KEY (x) REFERENCES tbl (x) ON`, `1:66: expected UPDATE or DELETE, found 'EOF'`)
				AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT, FOREIGN KEY (x) REFERENCES tbl (x) ON UPDATE SET`, `1:77: expected NULL or DEFAULT, found 'EOF'`)
				AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT, FOREIGN KEY (x) REFERENCES tbl (x) ON UPDATE NO`, `1:76: expected ACTION, found 'EOF'`)
				AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT, FOREIGN KEY (x) REFERENCES tbl (x) ON UPDATE TABLE`, `1:75: expected SET NULL, SET DEFAULT, CASCADE, RESTRICT, or NO ACTION, found 'TABLE'`)
				AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT, FOREIGN KEY (x) REFERENCES tbl (x) ON UPDATE CASCADE NOT`, `1:85: expected DEFERRABLE, found 'EOF'`)
			})
		})
	})

	t.Run("CreateVirtualTable", func(t *testing.T) {
		AssertParseStatement(t, `CREATE VIRTUAL TABLE vtbl USING mdl`, &sql.CreateVirtualTableStatement{
			Create:     pos(0),
			Virtual:    pos(7),
			Table:      pos(15),
			Name:       &sql.Ident{NamePos: pos(21), Name: "vtbl"},
			Using:      pos(26),
			ModuleName: &sql.Ident{NamePos: pos(32), Name: "mdl"},
		})

		AssertParseStatementError(t, `CREATE VIRTUAL TABLE vtbl`, "1:25: expected USING, found 'EOF'")
		AssertParseStatementError(t, `CREATE VIRTUAL TABLE vtbl USING`, "1:31: expected module name, found 'EOF'")

		t.Run("WithSchemaQualifiedTable", func(t *testing.T) {
			AssertParseStatement(t, `CREATE VIRTUAL TABLE schm.vtbl USING mdl`, &sql.CreateVirtualTableStatement{
				Create:     pos(0),
				Virtual:    pos(7),
				Table:      pos(15),
				Schema:     &sql.Ident{NamePos: pos(21), Name: "schm"},
				Dot:        pos(25),
				Name:       &sql.Ident{NamePos: pos(26), Name: "vtbl"},
				Using:      pos(31),
				ModuleName: &sql.Ident{NamePos: pos(37), Name: "mdl"},
			})
			AssertParseStatementError(t, `CREATE VIRTUAL TABLE schm.`, "1:26: expected table name, found 'EOF'")
			AssertParseStatementError(t, `CREATE VIRTUAL TABLE schm.vtbl`, "1:30: expected USING, found 'EOF'")
		})

		t.Run("WithIfNotExists", func(t *testing.T) {
			AssertParseStatement(t, `CREATE VIRTUAL TABLE IF NOT EXISTS vtbl USING mdl`, &sql.CreateVirtualTableStatement{
				Create:      pos(0),
				Virtual:     pos(7),
				Table:       pos(15),
				If:          pos(21),
				IfNot:       pos(24),
				IfNotExists: pos(28),
				Name:        &sql.Ident{NamePos: pos(35), Name: "vtbl"},
				Using:       pos(40),
				ModuleName:  &sql.Ident{NamePos: pos(46), Name: "mdl"},
			})
			AssertParseStatementError(t, `CREATE VIRTUAL TABLE IF`, "1:23: expected NOT, found 'EOF'")
			AssertParseStatementError(t, `CREATE VIRTUAL TABLE IF NOT`, "1:27: expected EXISTS, found 'EOF'")
			AssertParseStatementError(t, `CREATE VIRTUAL TABLE IF NOT EXIST`, "1:29: expected EXISTS, found EXIST")
			AssertParseStatementError(t, `CREATE VIRTUAL TABLE IF NOT EXISTS`, "1:34: expected schema or table name, found 'EOF'")
		})

		t.Run("WithArguments", func(t *testing.T) {
			AssertParseStatement(t, `CREATE VIRTUAL TABLE vtbl USING mdl(arg1)`, &sql.CreateVirtualTableStatement{
				Create:     pos(0),
				Virtual:    pos(7),
				Table:      pos(15),
				Name:       &sql.Ident{NamePos: pos(21), Name: "vtbl"},
				Using:      pos(26),
				ModuleName: &sql.Ident{NamePos: pos(32), Name: "mdl"},
				Lparen:     pos(35),
				Arguments: []*sql.ModuleArgument{
					{Name: &sql.Ident{NamePos: pos(36), Name: "arg1"}},
				},
				Rparen: pos(40),
			})
			AssertParseStatement(t, `CREATE VIRTUAL TABLE vtbl USING mdl(arg1,arg2='a',"arg3"=false)`, &sql.CreateVirtualTableStatement{
				Create:     pos(0),
				Virtual:    pos(7),
				Table:      pos(15),
				Name:       &sql.Ident{NamePos: pos(21), Name: "vtbl"},
				Using:      pos(26),
				ModuleName: &sql.Ident{NamePos: pos(32), Name: "mdl"},
				Lparen:     pos(35),
				Arguments: []*sql.ModuleArgument{
					{
						Name: &sql.Ident{NamePos: pos(36), Name: "arg1"},
					},
					{
						Name:    &sql.Ident{NamePos: pos(41), Name: "arg2"},
						Assign:  pos(45),
						Literal: &sql.StringLit{ValuePos: pos(46), Value: "a"},
					},
					{
						Name:    &sql.Ident{NamePos: pos(50), Name: "arg3", Quoted: true},
						Assign:  pos(56),
						Literal: &sql.BoolLit{ValuePos: pos(57), Value: false},
					},
				},
				Rparen: pos(62),
			})
			AssertParseStatement(t, `CREATE VIRTUAL TABLE vtbl USING mdl(arg1 TEXT)`, &sql.CreateVirtualTableStatement{
				Create:     pos(0),
				Virtual:    pos(7),
				Table:      pos(15),
				Name:       &sql.Ident{NamePos: pos(21), Name: "vtbl"},
				Using:      pos(26),
				ModuleName: &sql.Ident{NamePos: pos(32), Name: "mdl"},
				Lparen:     pos(35),
				Arguments: []*sql.ModuleArgument{
					{
						Name: &sql.Ident{NamePos: pos(36), Name: "arg1"},
						Type: &sql.Type{Name: &sql.Ident{NamePos: pos(41), Name: "TEXT"}},
					},
				},
				Rparen: pos(45),
			})

			AssertParseStatementError(t, `CREATE VIRTUAL TABLE vtbl USING mdl(`, "1:36: expected module argument name, found 'EOF'")
			AssertParseStatementError(t, `CREATE VIRTUAL TABLE vtbl USING mdl(arg1`, "1:40: expected comma or right paren, found 'EOF'")
			AssertParseStatementError(t, `CREATE VIRTUAL TABLE vtbl USING mdl(arg1=3`, "1:42: expected comma or right paren, found 'EOF'")
			AssertParseStatementError(t, `CREATE VIRTUAL TABLE vtbl USING mdl(arg1=3,`, "1:43: expected module argument name, found 'EOF'")
			// An empty argument list and free-form argument words are accepted,
			// as sqlite3 passes module arguments through as text.
			AssertParseStatements(t, `CREATE VIRTUAL TABLE vtbl USING mdl()`, 1)
			AssertParseStatementError(t, `CREATE VIRTUAL TABLE vtbl USING mdl(arg1 BLOB`, "1:45: expected comma or right paren, found 'EOF'")
			AssertParseStatements(t, `CREATE VIRTUAL TABLE vtbl USING mdl(arg1 arg2)`, 1)
			AssertParseStatementError(t, `CREATE VIRTUAL TABLE vtbl USING mdl(arg1 TEXT=value)`, "1:46: expected comma or right paren, found '='")
			AssertParseStatementError(t, `CREATE VIRTUAL TABLE vtbl USING mdl(=)`, "1:37: expected module argument name, found '='")
			AssertParseStatementError(t, `CREATE VIRTUAL TABLE vtbl USING mdl(key=)`, "1:41: expected expression, found ')'")
			AssertParseStatementError(t, `CREATE VIRTUAL TABLE vtbl USING mdl(=value)`, "1:37: expected module argument name, found '='")
		})
	})

	t.Run("DropTable", func(t *testing.T) {
		AssertParseStatement(t, `DROP TABLE vw`, &sql.DropTableStatement{
			Drop:  pos(0),
			Table: pos(5),
			Name:  &sql.Ident{NamePos: pos(11), Name: "vw"},
		})
		AssertParseStatement(t, `DROP TABLE IF EXISTS vw`, &sql.DropTableStatement{
			Drop:     pos(0),
			Table:    pos(5),
			If:       pos(11),
			IfExists: pos(14),
			Name:     &sql.Ident{NamePos: pos(21), Name: "vw"},
		})
		AssertParseStatementError(t, `DROP TABLE`, `1:10: expected table name, found 'EOF'`)
		AssertParseStatementError(t, `DROP TABLE IF`, `1:13: expected EXISTS, found 'EOF'`)
		AssertParseStatementError(t, `DROP TABLE IF EXISTS`, `1:20: expected table name, found 'EOF'`)
	})

	t.Run("CreateView", func(t *testing.T) {
		AssertParseStatement(t, `CREATE VIEW vw (col1, col2) AS SELECT x, y`, &sql.CreateViewStatement{
			Create: pos(0),
			View:   pos(7),
			Name:   &sql.Ident{NamePos: pos(12), Name: "vw"},
			Lparen: pos(15),
			Columns: []*sql.Ident{
				{NamePos: pos(16), Name: "col1"},
				{NamePos: pos(22), Name: "col2"},
			},
			Rparen: pos(26),
			As:     pos(28),
			Select: &sql.SelectStatement{
				Select: pos(31),
				Columns: []*sql.ResultColumn{
					{Expr: &sql.Ident{NamePos: pos(38), Name: "x"}},
					{Expr: &sql.Ident{NamePos: pos(41), Name: "y"}},
				},
			},
		})
		AssertParseStatement(t, `CREATE VIEW vw AS SELECT x`, &sql.CreateViewStatement{
			Create: pos(0),
			View:   pos(7),
			Name:   &sql.Ident{NamePos: pos(12), Name: "vw"},
			As:     pos(15),
			Select: &sql.SelectStatement{
				Select: pos(18),
				Columns: []*sql.ResultColumn{
					{Expr: &sql.Ident{NamePos: pos(25), Name: "x"}},
				},
			},
		})
		AssertParseStatement(t, `CREATE VIEW IF NOT EXISTS vw AS SELECT x`, &sql.CreateViewStatement{
			Create:      pos(0),
			View:        pos(7),
			If:          pos(12),
			IfNot:       pos(15),
			IfNotExists: pos(19),
			Name:        &sql.Ident{NamePos: pos(26), Name: "vw"},
			As:          pos(29),
			Select: &sql.SelectStatement{
				Select: pos(32),
				Columns: []*sql.ResultColumn{
					{Expr: &sql.Ident{NamePos: pos(39), Name: "x"}},
				},
			},
		})
		AssertParseStatementError(t, `CREATE VIEW`, `1:11: expected view name, found 'EOF'`)
		AssertParseStatementError(t, `CREATE VIEW IF`, `1:14: expected NOT, found 'EOF'`)
		AssertParseStatementError(t, `CREATE VIEW IF NOT`, `1:18: expected EXISTS, found 'EOF'`)
		AssertParseStatementError(t, `CREATE VIEW vw`, `1:14: expected AS, found 'EOF'`)
		AssertParseStatementError(t, `CREATE VIEW vw (`, `1:16: expected column name, found 'EOF'`)
		AssertParseStatementError(t, `CREATE VIEW vw (x`, `1:17: expected comma or right paren, found 'EOF'`)
		AssertParseStatementError(t, `CREATE VIEW vw AS`, `1:17: expected SELECT or VALUES, found 'EOF'`)
		AssertParseStatementError(t, `CREATE VIEW vw AS SELECT`, `1:24: expected expression, found 'EOF'`)
	})

	t.Run("DropView", func(t *testing.T) {
		AssertParseStatement(t, `DROP VIEW vw`, &sql.DropViewStatement{
			Drop: pos(0),
			View: pos(5),
			Name: &sql.Ident{NamePos: pos(10), Name: "vw"},
		})
		AssertParseStatement(t, `DROP VIEW IF EXISTS vw`, &sql.DropViewStatement{
			Drop:     pos(0),
			View:     pos(5),
			If:       pos(10),
			IfExists: pos(13),
			Name:     &sql.Ident{NamePos: pos(20), Name: "vw"},
		})
		AssertParseStatementError(t, `DROP`, `1:1: expected TABLE, VIEW, INDEX, or TRIGGER`)
		AssertParseStatementError(t, `DROP VIEW`, `1:9: expected view name, found 'EOF'`)
		AssertParseStatementError(t, `DROP VIEW IF`, `1:12: expected EXISTS, found 'EOF'`)
		AssertParseStatementError(t, `DROP VIEW IF EXISTS`, `1:19: expected view name, found 'EOF'`)
	})

	t.Run("CreateIndex", func(t *testing.T) {
		AssertParseStatement(t, `CREATE INDEX idx ON tbl (x ASC, y DESC, z)`, &sql.CreateIndexStatement{
			Create: pos(0),
			Index:  pos(7),
			Name:   &sql.Ident{NamePos: pos(13), Name: "idx"},
			On:     pos(17),
			Table:  &sql.Ident{NamePos: pos(20), Name: "tbl"},
			Lparen: pos(24),
			Columns: []*sql.IndexedColumn{
				{X: &sql.Ident{NamePos: pos(25), Name: "x"}, Asc: pos(27)},
				{X: &sql.Ident{NamePos: pos(32), Name: "y"}, Desc: pos(34)},
				{X: &sql.Ident{NamePos: pos(40), Name: "z"}},
			},
			Rparen: pos(41),
		})
		AssertParseStatement(t, `CREATE UNIQUE INDEX idx ON tbl (x)`, &sql.CreateIndexStatement{
			Create: pos(0),
			Unique: pos(7),
			Index:  pos(14),
			Name:   &sql.Ident{NamePos: pos(20), Name: "idx"},
			On:     pos(24),
			Table:  &sql.Ident{NamePos: pos(27), Name: "tbl"},
			Lparen: pos(31),
			Columns: []*sql.IndexedColumn{
				{X: &sql.Ident{NamePos: pos(32), Name: "x"}},
			},
			Rparen: pos(33),
		})
		AssertParseStatement(t, `CREATE INDEX idx ON tbl (x) WHERE true`, &sql.CreateIndexStatement{
			Create: pos(0),
			Index:  pos(7),
			Name:   &sql.Ident{NamePos: pos(13), Name: "idx"},
			On:     pos(17),
			Table:  &sql.Ident{NamePos: pos(20), Name: "tbl"},
			Lparen: pos(24),
			Columns: []*sql.IndexedColumn{
				{X: &sql.Ident{NamePos: pos(25), Name: "x"}},
			},
			Rparen:    pos(26),
			Where:     pos(28),
			WhereExpr: &sql.BoolLit{ValuePos: pos(34), Value: true},
		})
		AssertParseStatement(t, `CREATE INDEX IF NOT EXISTS idx ON tbl (x)`, &sql.CreateIndexStatement{
			Create:      pos(0),
			Index:       pos(7),
			If:          pos(13),
			IfNot:       pos(16),
			IfNotExists: pos(20),
			Name:        &sql.Ident{NamePos: pos(27), Name: "idx"},
			On:          pos(31),
			Table:       &sql.Ident{NamePos: pos(34), Name: "tbl"},
			Lparen:      pos(38),
			Columns: []*sql.IndexedColumn{
				{X: &sql.Ident{NamePos: pos(39), Name: "x"}},
			},
			Rparen: pos(40),
		})
		AssertParseStatement(t, `CREATE INDEX idx ON tbl (x COLLATE NOCASE)`, &sql.CreateIndexStatement{
			Create: pos(0),
			Index:  pos(7),
			Name:   &sql.Ident{NamePos: pos(13), Name: "idx"},
			On:     pos(17),
			Table:  &sql.Ident{NamePos: pos(20), Name: "tbl"},
			Lparen: pos(24),
			Columns: []*sql.IndexedColumn{
				{
					X: &sql.CollateExpr{
						X:         &sql.Ident{NamePos: pos(25), Name: "x"},
						Collation: &sql.CollationClause{Collate: pos(27), Name: &sql.Ident{NamePos: pos(35), Name: "NOCASE"}},
					},
				},
			},
			Rparen: pos(41),
		})
		AssertParseStatementError(t, `CREATE UNIQUE`, `1:13: expected INDEX, found 'EOF'`)
		AssertParseStatementError(t, `CREATE INDEX`, `1:12: expected index name, found 'EOF'`)
		AssertParseStatementError(t, `CREATE INDEX IF`, `1:15: expected NOT, found 'EOF'`)
		AssertParseStatementError(t, `CREATE INDEX IF NOT`, `1:19: expected EXISTS, found 'EOF'`)
		AssertParseStatementError(t, `CREATE INDEX idx`, `1:16: expected ON, found 'EOF'`)
		AssertParseStatementError(t, `CREATE INDEX idx ON`, `1:19: expected table name, found 'EOF'`)
		AssertParseStatementError(t, `CREATE INDEX idx ON tbl`, `1:23: expected left paren, found 'EOF'`)
		AssertParseStatementError(t, `CREATE INDEX idx ON tbl (`, `1:25: expected expression, found 'EOF'`)
		AssertParseStatementError(t, `CREATE INDEX idx ON tbl (x`, `1:26: expected comma or right paren, found 'EOF'`)
		AssertParseStatementError(t, `CREATE INDEX idx ON tbl (x) WHERE`, `1:33: expected expression, found 'EOF'`)
	})

	t.Run("DropIndex", func(t *testing.T) {
		AssertParseStatement(t, `DROP INDEX idx`, &sql.DropIndexStatement{
			Drop:  pos(0),
			Index: pos(5),
			Name:  &sql.Ident{NamePos: pos(11), Name: "idx"},
		})
		AssertParseStatement(t, `DROP INDEX IF EXISTS idx`, &sql.DropIndexStatement{
			Drop:     pos(0),
			Index:    pos(5),
			If:       pos(11),
			IfExists: pos(14),
			Name:     &sql.Ident{NamePos: pos(21), Name: "idx"},
		})
		AssertParseStatementError(t, `DROP INDEX`, `1:10: expected index name, found 'EOF'`)
		AssertParseStatementError(t, `DROP INDEX IF`, `1:13: expected EXISTS, found 'EOF'`)
		AssertParseStatementError(t, `DROP INDEX IF EXISTS`, `1:20: expected index name, found 'EOF'`)
	})

	t.Run("CreateTrigger", func(t *testing.T) {
		AssertParseStatement(t, `CREATE TRIGGER IF NOT EXISTS trig BEFORE INSERT ON tbl BEGIN DELETE FROM new; END`, &sql.CreateTriggerStatement{
			Create:      pos(0),
			Trigger:     pos(7),
			If:          pos(15),
			IfNot:       pos(18),
			IfNotExists: pos(22),
			Name:        &sql.Ident{NamePos: pos(29), Name: "trig"},
			Before:      pos(34),
			Insert:      pos(41),
			On:          pos(48),
			Table:       &sql.Ident{NamePos: pos(51), Name: "tbl"},
			Begin:       pos(55),
			Body: []sql.Statement{
				&sql.DeleteStatement{
					Delete: pos(61),
					From:   pos(68),
					Table: &sql.QualifiedTableName{
						Name: &sql.Ident{NamePos: pos(73), Name: "new"},
					},
				},
			},
			End: pos(78),
		})
		AssertParseStatement(t, `CREATE TEMP TRIGGER IF NOT EXISTS trig BEFORE INSERT ON tbl BEGIN DELETE FROM new; END`, &sql.CreateTriggerStatement{
			Create:      pos(0),
			Temp:        pos(7),
			Trigger:     pos(12),
			If:          pos(20),
			IfNot:       pos(23),
			IfNotExists: pos(27),
			Name:        &sql.Ident{NamePos: pos(34), Name: "trig"},
			Before:      pos(39),
			Insert:      pos(46),
			On:          pos(53),
			Table:       &sql.Ident{NamePos: pos(56), Name: "tbl"},
			Begin:       pos(60),
			Body: []sql.Statement{
				&sql.DeleteStatement{
					Delete: pos(66),
					From:   pos(73),
					Table: &sql.QualifiedTableName{
						Name: &sql.Ident{NamePos: pos(78), Name: "new"},
					},
				},
			},
			End: pos(83),
		})
		AssertParseStatement(t, `CREATE TRIGGER trig INSTEAD OF UPDATE ON tbl BEGIN SELECT *; END`, &sql.CreateTriggerStatement{
			Create:    pos(0),
			Trigger:   pos(7),
			Name:      &sql.Ident{NamePos: pos(15), Name: "trig"},
			Instead:   pos(20),
			InsteadOf: pos(28),
			Update:    pos(31),
			On:        pos(38),
			Table:     &sql.Ident{NamePos: pos(41), Name: "tbl"},
			Begin:     pos(45),
			Body: []sql.Statement{
				&sql.SelectStatement{
					Select:  pos(51),
					Columns: []*sql.ResultColumn{{Star: pos(58)}},
				},
			},
			End: pos(61),
		})
		AssertParseStatement(t, `CREATE TRIGGER trig INSTEAD OF UPDATE OF x, y ON tbl FOR EACH ROW WHEN true BEGIN SELECT *; END`, &sql.CreateTriggerStatement{
			Create:    pos(0),
			Trigger:   pos(7),
			Name:      &sql.Ident{NamePos: pos(15), Name: "trig"},
			Instead:   pos(20),
			InsteadOf: pos(28),
			Update:    pos(31),
			UpdateOf:  pos(38),
			UpdateOfColumns: []*sql.Ident{
				{NamePos: pos(41), Name: "x"},
				{NamePos: pos(44), Name: "y"},
			},
			On:         pos(46),
			Table:      &sql.Ident{NamePos: pos(49), Name: "tbl"},
			For:        pos(53),
			ForEach:    pos(57),
			ForEachRow: pos(62),
			When:       pos(66),
			WhenExpr:   &sql.BoolLit{ValuePos: pos(71), Value: true},
			Begin:      pos(76),
			Body: []sql.Statement{
				&sql.SelectStatement{
					Select:  pos(82),
					Columns: []*sql.ResultColumn{{Star: pos(89)}},
				},
			},
			End: pos(92),
		})
		AssertParseStatement(t, `CREATE TRIGGER trig AFTER UPDATE ON tbl BEGIN WITH cte (x) AS (SELECT y) SELECT *; END`, &sql.CreateTriggerStatement{
			Create:  pos(0),
			Trigger: pos(7),
			Name:    &sql.Ident{NamePos: pos(15), Name: "trig"},
			After:   pos(20),
			Update:  pos(26),
			On:      pos(33),
			Table:   &sql.Ident{NamePos: pos(36), Name: "tbl"},
			Begin:   pos(40),
			Body: []sql.Statement{
				&sql.SelectStatement{
					WithClause: &sql.WithClause{
						With: pos(46),
						CTEs: []*sql.CTE{
							{
								TableName:     &sql.Ident{NamePos: pos(51), Name: "cte"},
								ColumnsLparen: pos(55),
								Columns: []*sql.Ident{
									{NamePos: pos(56), Name: "x"},
								},
								ColumnsRparen: pos(57),
								As:            pos(59),
								SelectLparen:  pos(62),
								Select: &sql.SelectStatement{
									Select: pos(63),
									Columns: []*sql.ResultColumn{
										{Expr: &sql.Ident{NamePos: pos(70), Name: "y"}},
									},
								},
								SelectRparen: pos(71),
							},
						},
					},
					Select:  pos(73),
					Columns: []*sql.ResultColumn{{Star: pos(80)}},
				},
			},
			End: pos(83),
		})

		AssertParseStatementError(t, `CREATE TRIGGER`, `1:14: expected trigger name, found 'EOF'`)
		AssertParseStatementError(t, `CREATE TRIGGER IF`, `1:17: expected NOT, found 'EOF'`)
		AssertParseStatementError(t, `CREATE TRIGGER IF NOT`, `1:21: expected EXISTS, found 'EOF'`)
		AssertParseStatementError(t, `CREATE TRIGGER trig INSTEAD`, `1:27: expected OF, found 'EOF'`)
		AssertParseStatementError(t, `CREATE TRIGGER trig AFTER`, `1:25: expected DELETE, INSERT, or UPDATE, found 'EOF'`)
		AssertParseStatementError(t, `CREATE TRIGGER trig UPDATE OF`, `1:29: expected column name, found 'EOF'`)
		AssertParseStatementError(t, `CREATE TRIGGER trig UPDATE OF x,`, `1:32: expected column name, found 'EOF'`)
		AssertParseStatementError(t, `CREATE TRIGGER trig AFTER INSERT`, `1:32: expected ON, found 'EOF'`)
		AssertParseStatementError(t, `CREATE TRIGGER trig AFTER INSERT ON `, `1:36: expected table name, found 'EOF'`)
		AssertParseStatementError(t, `CREATE TRIGGER trig AFTER INSERT ON tbl FOR`, `1:43: expected EACH, found 'EOF'`)
		AssertParseStatementError(t, `CREATE TRIGGER trig AFTER INSERT ON tbl FOR EACH`, `1:48: expected ROW, found 'EOF'`)
		AssertParseStatementError(t, `CREATE TRIGGER trig AFTER INSERT ON tbl WHEN`, `1:44: expected expression, found 'EOF'`)
		AssertParseStatementError(t, `CREATE TRIGGER trig AFTER INSERT ON tbl`, `1:39: expected BEGIN, found 'EOF'`)
		AssertParseStatementError(t, `CREATE TRIGGER trig AFTER INSERT ON tbl BEGIN`, `1:45: expected statement, found 'EOF'`)
		AssertParseStatementError(t, `CREATE TRIGGER trig AFTER INSERT ON tbl BEGIN SELECT`, `1:52: expected expression, found 'EOF'`)
		AssertParseStatementError(t, `CREATE TRIGGER trig AFTER INSERT ON tbl BEGIN SELECT *`, `1:54: expected semicolon, found 'EOF'`)
		AssertParseStatementError(t, `CREATE TRIGGER trig AFTER INSERT ON tbl BEGIN SELECT *;`, `1:55: expected statement, found 'EOF'`)
		AssertParseStatementError(t, `CREATE TRIGGER trig DELETE ON tbl BEGIN INSERT INTO new DEFAULT VALUES; UPDATE new SET x = 1; END`, `1:65: expected non-DEFAULT VALUES, found 'VALUES'`)
		AssertParseStatementError(t, `CREATE TRIGGER trig AFTER INSERT ON foo BEGIN UPDATE baz AS b SET x = 1 WHERE NEW.id = 1; END;;`, `1:58: expected unqualified table name, found 'AS'`)
		AssertParseStatementError(t, `CREATE TRIGGER trig AFTER INSERT ON foo BEGIN UPDATE baz b SET x = 1 WHERE NEW.id = 1; END;;`, `1:58: expected unqualified table name, found b`)
		AssertParseStatementError(t, `CREATE TRIGGER trig AFTER INSERT ON foo BEGIN UPDATE baz INDEXED BY id SET x = 1 WHERE NEW.id = 1; END;;`, `1:58: expected unqualified table name, found 'INDEXED'`)
		AssertParseStatementError(t, `CREATE TRIGGER trig AFTER INSERT ON foo BEGIN DELETE FROM baz AS b WHERE NEW.id = 1; END;;`, `1:63: expected unqualified table name, found 'AS'`)
		AssertParseStatementError(t, `CREATE TRIGGER trig AFTER INSERT ON foo BEGIN DELETE FROM baz b WHERE NEW.id = 1; END;;`, `1:63: expected unqualified table name, found b`)
	})

	t.Run("DropTrigger", func(t *testing.T) {
		AssertParseStatement(t, `DROP TRIGGER trig`, &sql.DropTriggerStatement{
			Drop:    pos(0),
			Trigger: pos(5),
			Name:    &sql.Ident{NamePos: pos(13), Name: "trig"},
		})
		AssertParseStatement(t, `DROP TRIGGER IF EXISTS trig`, &sql.DropTriggerStatement{
			Drop:     pos(0),
			Trigger:  pos(5),
			If:       pos(13),
			IfExists: pos(16),
			Name:     &sql.Ident{NamePos: pos(23), Name: "trig"},
		})
		AssertParseStatementError(t, `DROP TRIGGER`, `1:12: expected trigger name, found 'EOF'`)
		AssertParseStatementError(t, `DROP TRIGGER IF`, `1:15: expected EXISTS, found 'EOF'`)
		AssertParseStatementError(t, `DROP TRIGGER IF EXISTS`, `1:22: expected trigger name, found 'EOF'`)
	})

	t.Run("Select", func(t *testing.T) {
		AssertParseStatement(t, `SELECT 5678`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{
					Expr: &sql.NumberLit{ValuePos: pos(7), Value: "5678"},
				},
			},
		})

		AssertParseStatement(t, `SELECT datetime('now')`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{
					Expr: &sql.Call{
						Name:   &sql.Ident{NamePos: pos(7), Name: "datetime"},
						Lparen: pos(15),
						Rparen: pos(21),
						Args: []sql.Expr{
							&sql.StringLit{ValuePos: pos(16), Value: "now"},
						},
					},
				},
			},
		})

		AssertParseStatement(t, `SELECT julianday('now')`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{
					Expr: &sql.Call{
						Name:   &sql.Ident{NamePos: pos(7), Name: "julianday"},
						Lparen: pos(16),
						Rparen: pos(22),
						Args: []sql.Expr{
							&sql.StringLit{ValuePos: pos(17), Value: "now"},
						},
					},
				},
			},
		})

		AssertParseStatement(t, `SELECT date('now','start of month','+1 month','-1 day')`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{
					Expr: &sql.Call{
						Name:   &sql.Ident{NamePos: pos(7), Name: "date"},
						Lparen: pos(11),
						Rparen: pos(54),
						Args: []sql.Expr{
							&sql.StringLit{ValuePos: pos(12), Value: "now"},
							&sql.StringLit{ValuePos: pos(18), Value: "start of month"},
							&sql.StringLit{ValuePos: pos(35), Value: "+1 month"},
							&sql.StringLit{ValuePos: pos(46), Value: "-1 day"},
						},
					},
				},
			},
		})

		AssertParseStatement(t, `SELECT like(NULL, FALSE);`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{
					Expr: &sql.Call{
						Name:   &sql.Ident{NamePos: pos(7), Name: "like"},
						Lparen: pos(11),
						Args: []sql.Expr{
							&sql.NullLit{Pos: pos(12)},
							&sql.BoolLit{ValuePos: pos(18), Value: false},
						},
						Rparen: pos(23),
					},
				},
			},
		})

		AssertParseStatement(t, `SELECT glob('*.txt', 'file.txt');`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{
					Expr: &sql.Call{
						Name:   &sql.Ident{NamePos: pos(7), Name: "glob"},
						Lparen: pos(11),
						Args: []sql.Expr{
							&sql.StringLit{ValuePos: pos(12), Value: "*.txt"},
							&sql.StringLit{ValuePos: pos(21), Value: "file.txt"},
						},
						Rparen: pos(31),
					},
				},
			},
		})

		AssertParseStatement(t, `SELECT if(TRUE, 'a', 'b');`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{
					Expr: &sql.Call{
						Name:   &sql.Ident{NamePos: pos(7), Name: "if"},
						Lparen: pos(9),
						Args: []sql.Expr{
							&sql.BoolLit{ValuePos: pos(10), Value: true},
							&sql.StringLit{ValuePos: pos(16), Value: "a"},
							&sql.StringLit{ValuePos: pos(21), Value: "b"},
						},
						Rparen: pos(24),
					},
				},
			},
		})

		AssertParseStatement(t, `SELECT replace(c0, 'a', 1);`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{
					Expr: &sql.Call{
						Name:   &sql.Ident{NamePos: pos(7), Name: "replace"},
						Lparen: pos(14),
						Args: []sql.Expr{
							&sql.Ident{NamePos: pos(15), Name: "c0"},
							&sql.StringLit{ValuePos: pos(19), Value: "a"},
							&sql.NumberLit{ValuePos: pos(24), Value: "1"},
						},
						Rparen: pos(25),
					},
				},
			},
		})

		AssertParseStatement(t, `SELECT 1 NOT NULL`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{
					Expr: &sql.Null{
						X:     &sql.NumberLit{ValuePos: pos(7), Value: "1"},
						OpPos: pos(9),
						Op:    sql.NOTNULL,
					},
				},
			},
		})
		AssertParseStatement(t, `SELECT 1 NOTNULL`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{
					Expr: &sql.Null{
						X:     &sql.NumberLit{ValuePos: pos(7), Value: "1"},
						OpPos: pos(9),
						Op:    sql.NOTNULL,
					},
				},
			},
		})
		AssertParseStatement(t, `SELECT 1 IS NULL`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{
					Expr: &sql.Null{
						X:     &sql.NumberLit{ValuePos: pos(7), Value: "1"},
						OpPos: pos(9),
						Op:    sql.ISNULL,
					},
				},
			},
		})
		AssertParseStatement(t, `SELECT 1 ISNULL`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{
					Expr: &sql.Null{
						X:     &sql.NumberLit{ValuePos: pos(7), Value: "1"},
						OpPos: pos(9),
						Op:    sql.ISNULL,
					},
				},
			},
		})
		AssertParseStatement(t, `SELECT 1 IS NULL AND false`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{
					Expr: &sql.BinaryExpr{
						X: &sql.Null{
							X:     &sql.NumberLit{ValuePos: pos(7), Value: "1"},
							OpPos: pos(9),
							Op:    sql.ISNULL,
						},
						OpPos: pos(17),
						Op:    sql.AND,
						Y:     &sql.BoolLit{ValuePos: pos(21), Value: false},
					},
				},
			},
		})
		AssertParseStatement(t, `SELECT 1 IS NOT NULL`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{
					Expr: &sql.Null{
						X:     &sql.NumberLit{ValuePos: pos(7), Value: "1"},
						OpPos: pos(9),
						Op:    sql.NOTNULL,
					},
				},
			},
		})
		AssertParseStatement(t, `SELECT 1 IS NOT NULL AND false`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{
					Expr: &sql.BinaryExpr{
						X: &sql.Null{
							X:     &sql.NumberLit{ValuePos: pos(7), Value: "1"},
							OpPos: pos(9),
							Op:    sql.NOTNULL,
						},
						OpPos: pos(21),
						Op:    sql.AND,
						Y:     &sql.BoolLit{ValuePos: pos(25), Value: false},
					},
				},
			},
		})

		AssertParseStatement(t, `SELECT * FROM tbl`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{Star: pos(7)},
			},
			From: pos(9),
			Source: &sql.QualifiedTableName{
				Name: &sql.Ident{NamePos: pos(14), Name: "tbl"},
			},
		})

		AssertParseStatement(t, `SELECT * FROM main.tbl;`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{Star: pos(7)},
			},
			From: pos(9),
			Source: &sql.QualifiedTableName{
				Schema: &sql.Ident{NamePos: pos(14), Name: "main"},
				Dot:    pos(18),
				Name:   &sql.Ident{NamePos: pos(19), Name: "tbl"},
			},
		})

		AssertParseStatement(t, `SELECT DISTINCT * FROM tbl`, &sql.SelectStatement{
			Select:   pos(0),
			Distinct: pos(7),
			Columns: []*sql.ResultColumn{
				{Star: pos(16)},
			},
			From: pos(18),
			Source: &sql.QualifiedTableName{
				Name: &sql.Ident{NamePos: pos(23), Name: "tbl"},
			},
		})

		AssertParseStatement(t, `SELECT ALL * FROM tbl`, &sql.SelectStatement{
			Select: pos(0),
			All:    pos(7),
			Columns: []*sql.ResultColumn{
				{Star: pos(11)},
			},
			From: pos(13),
			Source: &sql.QualifiedTableName{
				Name: &sql.Ident{NamePos: pos(18), Name: "tbl"},
			},
		})

		AssertParseStatement(t, `SELECT foo AS FOO, bar baz, tbl.* FROM tbl`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{
					Expr:  &sql.Ident{NamePos: pos(7), Name: "foo"},
					As:    pos(11),
					Alias: &sql.Ident{NamePos: pos(14), Name: "FOO"},
				},
				{
					Expr:  &sql.Ident{NamePos: pos(19), Name: "bar"},
					Alias: &sql.Ident{NamePos: pos(23), Name: "baz"},
				},
				{
					Expr: &sql.QualifiedRef{
						Table: &sql.Ident{NamePos: pos(28), Name: "tbl"},
						Dot:   pos(31),
						Star:  pos(32),
					},
				},
			},
			From: pos(34),
			Source: &sql.QualifiedTableName{
				Name: &sql.Ident{NamePos: pos(39), Name: "tbl"},
			},
		})
		AssertParseStatement(t, `SELECT * FROM tbl tbl2`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{Star: pos(7)},
			},
			From: pos(9),
			Source: &sql.QualifiedTableName{
				Name:  &sql.Ident{NamePos: pos(14), Name: "tbl"},
				Alias: &sql.Ident{NamePos: pos(18), Name: "tbl2"},
			},
		})
		AssertParseStatement(t, `SELECT * FROM tbl AS tbl2`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{Star: pos(7)},
			},
			From: pos(9),
			Source: &sql.QualifiedTableName{
				Name:  &sql.Ident{NamePos: pos(14), Name: "tbl"},
				As:    pos(18),
				Alias: &sql.Ident{NamePos: pos(21), Name: "tbl2"},
			},
		})
		AssertParseStatement(t, `SELECT * FROM main.tbl AS tbl2`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{Star: pos(7)},
			},
			From: pos(9),
			Source: &sql.QualifiedTableName{
				Schema: &sql.Ident{NamePos: pos(14), Name: "main"},
				Dot:    pos(18),
				Name:   &sql.Ident{NamePos: pos(19), Name: "tbl"},
				As:     pos(23),
				Alias:  &sql.Ident{NamePos: pos(26), Name: "tbl2"},
			},
		})
		AssertParseStatement(t, `SELECT * FROM tbl INDEXED BY idx`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{Star: pos(7)},
			},
			From: pos(9),
			Source: &sql.QualifiedTableName{
				Name:      &sql.Ident{NamePos: pos(14), Name: "tbl"},
				Indexed:   pos(18),
				IndexedBy: pos(26),
				Index:     &sql.Ident{NamePos: pos(29), Name: "idx"},
			},
		})
		AssertParseStatement(t, `SELECT * FROM tbl NOT INDEXED`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{Star: pos(7)},
			},
			From: pos(9),
			Source: &sql.QualifiedTableName{
				Name:       &sql.Ident{NamePos: pos(14), Name: "tbl"},
				Not:        pos(18),
				NotIndexed: pos(22),
			},
		})

		AssertParseStatement(t, `SELECT * FROM (SELECT *) AS tbl`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{Star: pos(7)},
			},
			From: pos(9),
			Source: &sql.ParenSource{
				Lparen: pos(14),
				X: &sql.SelectStatement{
					Select: pos(15),
					Columns: []*sql.ResultColumn{
						{Star: pos(22)},
					},
				},
				Rparen: pos(23),
				As:     pos(25),
				Alias:  &sql.Ident{NamePos: pos(28), Name: "tbl"},
			},
		})

		AssertParseStatement(t, `SELECT * FROM (VALUES (NULL))`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{Star: pos(7)},
			},
			From: pos(9),
			Source: &sql.ParenSource{
				Lparen: pos(14),
				X: &sql.SelectStatement{
					Values: pos(15),
					ValueLists: []*sql.ExprList{
						{
							Lparen: pos(22),
							Exprs: []sql.Expr{
								&sql.NullLit{Pos: pos(23)},
							},
							Rparen: pos(27),
						},
					},
				},
				Rparen: pos(28),
			},
		})
		AssertParseStatement(t, `SELECT * FROM ( t ) a`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{Star: pos(7)},
			},
			From: pos(9),
			Source: &sql.ParenSource{
				Lparen: pos(14),
				X: &sql.QualifiedTableName{
					Name: &sql.Ident{NamePos: pos(16), Name: "t"},
				},
				Rparen: pos(18),
				Alias:  &sql.Ident{NamePos: pos(20), Name: "a"},
			},
		})

		AssertParseStatement(t, `SELECT * FROM foo, bar`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{Star: pos(7)},
			},
			From: pos(9),
			Source: &sql.JoinClause{
				X: &sql.QualifiedTableName{
					Name: &sql.Ident{NamePos: pos(14), Name: "foo"},
				},
				Operator: &sql.JoinOperator{Comma: pos(17)},
				Y: &sql.QualifiedTableName{
					Name: &sql.Ident{NamePos: pos(19), Name: "bar"},
				},
			},
		})
		AssertParseStatement(t, `SELECT * FROM foo JOIN bar`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{Star: pos(7)},
			},
			From: pos(9),
			Source: &sql.JoinClause{
				X: &sql.QualifiedTableName{
					Name: &sql.Ident{NamePos: pos(14), Name: "foo"},
				},
				Operator: &sql.JoinOperator{Join: pos(18)},
				Y: &sql.QualifiedTableName{
					Name: &sql.Ident{NamePos: pos(23), Name: "bar"},
				},
			},
		})
		AssertParseStatement(t, `SELECT * FROM foo NATURAL JOIN bar`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{Star: pos(7)},
			},
			From: pos(9),
			Source: &sql.JoinClause{
				X: &sql.QualifiedTableName{
					Name: &sql.Ident{NamePos: pos(14), Name: "foo"},
				},
				Operator: &sql.JoinOperator{Natural: pos(18), Join: pos(26)},
				Y: &sql.QualifiedTableName{
					Name: &sql.Ident{NamePos: pos(31), Name: "bar"},
				},
			},
		})
		AssertParseStatement(t, `SELECT * FROM foo INNER JOIN bar ON true`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{Star: pos(7)},
			},
			From: pos(9),
			Source: &sql.JoinClause{
				X: &sql.QualifiedTableName{
					Name: &sql.Ident{NamePos: pos(14), Name: "foo"},
				},
				Operator: &sql.JoinOperator{Inner: pos(18), Join: pos(24)},
				Y: &sql.QualifiedTableName{
					Name: &sql.Ident{NamePos: pos(29), Name: "bar"},
				},
				Constraint: &sql.OnConstraint{
					On: pos(33),
					X:  &sql.BoolLit{ValuePos: pos(36), Value: true},
				},
			},
		})
		AssertParseStatement(t, `SELECT * FROM foo LEFT JOIN bar USING (x, y)`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{Star: pos(7)},
			},
			From: pos(9),
			Source: &sql.JoinClause{
				X: &sql.QualifiedTableName{
					Name: &sql.Ident{NamePos: pos(14), Name: "foo"},
				},
				Operator: &sql.JoinOperator{Left: pos(18), Join: pos(23)},
				Y: &sql.QualifiedTableName{
					Name: &sql.Ident{NamePos: pos(28), Name: "bar"},
				},
				Constraint: &sql.UsingConstraint{
					Using:  pos(32),
					Lparen: pos(38),
					Columns: []*sql.Ident{
						{NamePos: pos(39), Name: "x"},
						{NamePos: pos(42), Name: "y"},
					},
					Rparen: pos(43),
				},
			},
		})
		AssertParseStatement(t, `SELECT * FROM X INNER JOIN Y ON true INNER JOIN Z ON false`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{Star: pos(7)},
			},
			From: pos(9),
			Source: &sql.JoinClause{
				X: &sql.JoinClause{
					X: &sql.QualifiedTableName{
						Name: &sql.Ident{NamePos: pos(14), Name: "X"},
					},
					Operator: &sql.JoinOperator{Inner: pos(16), Join: pos(22)},
					Y: &sql.QualifiedTableName{
						Name: &sql.Ident{NamePos: pos(27), Name: "Y"},
					},
					Constraint: &sql.OnConstraint{
						On: pos(29),
						X:  &sql.BoolLit{ValuePos: pos(32), Value: true},
					},
				},
				Operator: &sql.JoinOperator{Inner: pos(37), Join: pos(43)},
				Y: &sql.QualifiedTableName{
					Name: &sql.Ident{NamePos: pos(48), Name: "Z"},
				},
				Constraint: &sql.OnConstraint{
					On: pos(50),
					X:  &sql.BoolLit{ValuePos: pos(53), Value: false},
				},
			},
		})
		AssertParseStatement(t, `SELECT * FROM X as a JOIN Y as b ON a.id = b.id JOIN Z as c ON b.id = c.id`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{Star: pos(7)},
			},
			From: pos(9),
			Source: &sql.JoinClause{
				X: &sql.JoinClause{
					X: &sql.QualifiedTableName{
						Name:  &sql.Ident{NamePos: pos(14), Name: "X"},
						As:    pos(16),
						Alias: &sql.Ident{NamePos: pos(19), Name: "a"},
					},
					Operator: &sql.JoinOperator{Join: pos(21)},
					Y: &sql.QualifiedTableName{
						Name:  &sql.Ident{NamePos: pos(26), Name: "Y"},
						As:    pos(28),
						Alias: &sql.Ident{NamePos: pos(31), Name: "b"},
					},
					Constraint: &sql.OnConstraint{
						On: pos(33),
						X: &sql.BinaryExpr{
							X: &sql.QualifiedRef{
								Table:  &sql.Ident{NamePos: pos(36), Name: "a"},
								Dot:    pos(37),
								Column: &sql.Ident{NamePos: pos(38), Name: "id"},
							},
							OpPos: pos(41),
							Op:    sql.EQ,
							Y: &sql.QualifiedRef{
								Table:  &sql.Ident{NamePos: pos(43), Name: "b"},
								Dot:    pos(44),
								Column: &sql.Ident{NamePos: pos(45), Name: "id"},
							},
						},
					},
				},
				Operator: &sql.JoinOperator{Join: pos(48)},
				Y: &sql.QualifiedTableName{
					Name:  &sql.Ident{NamePos: pos(53), Name: "Z"},
					As:    pos(55),
					Alias: &sql.Ident{NamePos: pos(58), Name: "c"},
				},
				Constraint: &sql.OnConstraint{
					On: pos(60),
					X: &sql.BinaryExpr{
						X: &sql.QualifiedRef{
							Table:  &sql.Ident{NamePos: pos(63), Name: "b"},
							Dot:    pos(64),
							Column: &sql.Ident{NamePos: pos(65), Name: "id"},
						},
						OpPos: pos(68),
						Op:    sql.EQ,
						Y: &sql.QualifiedRef{
							Table:  &sql.Ident{NamePos: pos(70), Name: "c"},
							Dot:    pos(71),
							Column: &sql.Ident{NamePos: pos(72), Name: "id"},
						},
					},
				},
			},
		})
		AssertParseStatement(t, `SELECT * FROM foo LEFT OUTER JOIN bar`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{Star: pos(7)},
			},
			From: pos(9),
			Source: &sql.JoinClause{
				X: &sql.QualifiedTableName{
					Name: &sql.Ident{NamePos: pos(14), Name: "foo"},
				},
				Operator: &sql.JoinOperator{Left: pos(18), Outer: pos(23), Join: pos(29)},
				Y: &sql.QualifiedTableName{
					Name: &sql.Ident{NamePos: pos(34), Name: "bar"},
				},
			},
		})
		// RIGHT and FULL joins must be parsed as join operators, not as a
		// table alias followed by an inner join.
		AssertParseStatement(t, `SELECT * FROM foo RIGHT JOIN bar`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{Star: pos(7)},
			},
			From: pos(9),
			Source: &sql.JoinClause{
				X: &sql.QualifiedTableName{
					Name: &sql.Ident{NamePos: pos(14), Name: "foo"},
				},
				Operator: &sql.JoinOperator{Right: pos(18), Join: pos(24)},
				Y: &sql.QualifiedTableName{
					Name: &sql.Ident{NamePos: pos(29), Name: "bar"},
				},
			},
		})
		AssertParseStatement(t, `SELECT * FROM foo RIGHT OUTER JOIN bar`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{Star: pos(7)},
			},
			From: pos(9),
			Source: &sql.JoinClause{
				X: &sql.QualifiedTableName{
					Name: &sql.Ident{NamePos: pos(14), Name: "foo"},
				},
				Operator: &sql.JoinOperator{Right: pos(18), Outer: pos(24), Join: pos(30)},
				Y: &sql.QualifiedTableName{
					Name: &sql.Ident{NamePos: pos(35), Name: "bar"},
				},
			},
		})
		AssertParseStatement(t, `SELECT * FROM foo FULL OUTER JOIN bar`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{Star: pos(7)},
			},
			From: pos(9),
			Source: &sql.JoinClause{
				X: &sql.QualifiedTableName{
					Name: &sql.Ident{NamePos: pos(14), Name: "foo"},
				},
				Operator: &sql.JoinOperator{Full: pos(18), Outer: pos(23), Join: pos(29)},
				Y: &sql.QualifiedTableName{
					Name: &sql.Ident{NamePos: pos(34), Name: "bar"},
				},
			},
		})
		AssertParseStatement(t, `SELECT * FROM foo NATURAL FULL JOIN bar`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{Star: pos(7)},
			},
			From: pos(9),
			Source: &sql.JoinClause{
				X: &sql.QualifiedTableName{
					Name: &sql.Ident{NamePos: pos(14), Name: "foo"},
				},
				Operator: &sql.JoinOperator{Natural: pos(18), Full: pos(26), Join: pos(31)},
				Y: &sql.QualifiedTableName{
					Name: &sql.Ident{NamePos: pos(36), Name: "bar"},
				},
			},
		})
		AssertParseStatement(t, `SELECT * FROM foo CROSS JOIN bar`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{Star: pos(7)},
			},
			From: pos(9),
			Source: &sql.JoinClause{
				X: &sql.QualifiedTableName{
					Name: &sql.Ident{NamePos: pos(14), Name: "foo"},
				},
				Operator: &sql.JoinOperator{Cross: pos(18), Join: pos(24)},
				Y: &sql.QualifiedTableName{
					Name: &sql.Ident{NamePos: pos(29), Name: "bar"},
				},
			},
		})
		AssertParseStatement(t, `SELECT * FROM A JOIN B ON 1 JOIN C ON 2 JOIN D ON 3`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{Star: pos(7)},
			},
			From: pos(9),
			Source: &sql.JoinClause{
				X: &sql.JoinClause{
					X: &sql.JoinClause{
						X:          &sql.QualifiedTableName{Name: &sql.Ident{NamePos: pos(14), Name: "A"}},
						Operator:   &sql.JoinOperator{Join: pos(16)},
						Y:          &sql.QualifiedTableName{Name: &sql.Ident{NamePos: pos(21), Name: "B"}},
						Constraint: &sql.OnConstraint{On: pos(23), X: &sql.NumberLit{ValuePos: pos(26), Value: "1"}},
					},
					Operator:   &sql.JoinOperator{Join: pos(28)},
					Y:          &sql.QualifiedTableName{Name: &sql.Ident{NamePos: pos(33), Name: "C"}},
					Constraint: &sql.OnConstraint{On: pos(35), X: &sql.NumberLit{ValuePos: pos(38), Value: "2"}},
				},
				Operator:   &sql.JoinOperator{Join: pos(40)},
				Y:          &sql.QualifiedTableName{Name: &sql.Ident{NamePos: pos(45), Name: "D"}},
				Constraint: &sql.OnConstraint{On: pos(47), X: &sql.NumberLit{ValuePos: pos(50), Value: "3"}},
			},
		})
		AssertParseStatement(t, `SELECT * FROM A JOIN B ON 1 JOIN C ON 2 JOIN D ON 3 JOIN E ON 4`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{Star: pos(7)},
			},
			From: pos(9),
			Source: &sql.JoinClause{
				X: &sql.JoinClause{
					X: &sql.JoinClause{
						X: &sql.JoinClause{
							X:          &sql.QualifiedTableName{Name: &sql.Ident{NamePos: pos(14), Name: "A"}},
							Operator:   &sql.JoinOperator{Join: pos(16)},
							Y:          &sql.QualifiedTableName{Name: &sql.Ident{NamePos: pos(21), Name: "B"}},
							Constraint: &sql.OnConstraint{On: pos(23), X: &sql.NumberLit{ValuePos: pos(26), Value: "1"}},
						},
						Operator:   &sql.JoinOperator{Join: pos(28)},
						Y:          &sql.QualifiedTableName{Name: &sql.Ident{NamePos: pos(33), Name: "C"}},
						Constraint: &sql.OnConstraint{On: pos(35), X: &sql.NumberLit{ValuePos: pos(38), Value: "2"}},
					},
					Operator:   &sql.JoinOperator{Join: pos(40)},
					Y:          &sql.QualifiedTableName{Name: &sql.Ident{NamePos: pos(45), Name: "D"}},
					Constraint: &sql.OnConstraint{On: pos(47), X: &sql.NumberLit{ValuePos: pos(50), Value: "3"}},
				},
				Operator:   &sql.JoinOperator{Join: pos(52)},
				Y:          &sql.QualifiedTableName{Name: &sql.Ident{NamePos: pos(57), Name: "E"}},
				Constraint: &sql.OnConstraint{On: pos(59), X: &sql.NumberLit{ValuePos: pos(62), Value: "4"}},
			},
		})

		AssertParseStatement(t, `WITH cte (foo, bar) AS (SELECT baz), xxx AS (SELECT yyy) SELECT bat`, &sql.SelectStatement{
			WithClause: &sql.WithClause{
				With: pos(0),
				CTEs: []*sql.CTE{
					{
						TableName:     &sql.Ident{NamePos: pos(5), Name: "cte"},
						ColumnsLparen: pos(9),
						Columns: []*sql.Ident{
							{NamePos: pos(10), Name: "foo"},
							{NamePos: pos(15), Name: "bar"},
						},
						ColumnsRparen: pos(18),
						As:            pos(20),
						SelectLparen:  pos(23),
						Select: &sql.SelectStatement{
							Select: pos(24),
							Columns: []*sql.ResultColumn{
								{Expr: &sql.Ident{NamePos: pos(31), Name: "baz"}},
							},
						},
						SelectRparen: pos(34),
					},
					{
						TableName:    &sql.Ident{NamePos: pos(37), Name: "xxx"},
						As:           pos(41),
						SelectLparen: pos(44),
						Select: &sql.SelectStatement{
							Select: pos(45),
							Columns: []*sql.ResultColumn{
								{Expr: &sql.Ident{NamePos: pos(52), Name: "yyy"}},
							},
						},
						SelectRparen: pos(55),
					},
				},
			},
			Select: pos(57),
			Columns: []*sql.ResultColumn{
				{Expr: &sql.Ident{NamePos: pos(64), Name: "bat"}},
			},
		})
		AssertParseStatement(t, `WITH RECURSIVE cte AS (SELECT foo) SELECT bar`, &sql.SelectStatement{
			WithClause: &sql.WithClause{
				With:      pos(0),
				Recursive: pos(5),
				CTEs: []*sql.CTE{
					{
						TableName:    &sql.Ident{NamePos: pos(15), Name: "cte"},
						As:           pos(19),
						SelectLparen: pos(22),
						Select: &sql.SelectStatement{
							Select: pos(23),
							Columns: []*sql.ResultColumn{
								{Expr: &sql.Ident{NamePos: pos(30), Name: "foo"}},
							},
						},
						SelectRparen: pos(33),
					},
				},
			},
			Select: pos(35),
			Columns: []*sql.ResultColumn{
				{Expr: &sql.Ident{NamePos: pos(42), Name: "bar"}},
			},
		})

		AssertParseStatement(t, `WITH cte AS MATERIALIZED (SELECT foo) SELECT bar`, &sql.SelectStatement{
			WithClause: &sql.WithClause{
				With: pos(0),
				CTEs: []*sql.CTE{
					{
						TableName:    &sql.Ident{NamePos: pos(5), Name: "cte"},
						As:           pos(9),
						Materialized: pos(12),
						SelectLparen: pos(25),
						Select: &sql.SelectStatement{
							Select: pos(26),
							Columns: []*sql.ResultColumn{
								{Expr: &sql.Ident{NamePos: pos(33), Name: "foo"}},
							},
						},
						SelectRparen: pos(36),
					},
				},
			},
			Select: pos(38),
			Columns: []*sql.ResultColumn{
				{Expr: &sql.Ident{NamePos: pos(45), Name: "bar"}},
			},
		})

		AssertParseStatement(t, `WITH cte AS NOT MATERIALIZED (SELECT foo) SELECT bar`, &sql.SelectStatement{
			WithClause: &sql.WithClause{
				With: pos(0),
				CTEs: []*sql.CTE{
					{
						TableName:    &sql.Ident{NamePos: pos(5), Name: "cte"},
						As:           pos(9),
						Not:          pos(12),
						Materialized: pos(16),
						SelectLparen: pos(29),
						Select: &sql.SelectStatement{
							Select: pos(30),
							Columns: []*sql.ResultColumn{
								{Expr: &sql.Ident{NamePos: pos(37), Name: "foo"}},
							},
						},
						SelectRparen: pos(40),
					},
				},
			},
			Select: pos(42),
			Columns: []*sql.ResultColumn{
				{Expr: &sql.Ident{NamePos: pos(49), Name: "bar"}},
			},
		})

		AssertParseStatement(t, `SELECT * WHERE true`, &sql.SelectStatement{
			Select:    pos(0),
			Columns:   []*sql.ResultColumn{{Star: pos(7)}},
			Where:     pos(9),
			WhereExpr: &sql.BoolLit{ValuePos: pos(15), Value: true},
		})

		AssertParseStatement(t, `SELECT 1 WHERE true AND true`, &sql.SelectStatement{
			Select:  pos(0),
			Columns: []*sql.ResultColumn{{Expr: &sql.NumberLit{ValuePos: pos(7), Value: "1"}}},
			Where:   pos(9),
			WhereExpr: &sql.BinaryExpr{
				X:     &sql.BoolLit{ValuePos: pos(15), Value: true},
				OpPos: pos(20),
				Op:    sql.AND,
				Y:     &sql.BoolLit{ValuePos: pos(24), Value: true},
			},
		})

		AssertParseStatement(t, `SELECT 1 WHERE true AND (0, 1) = (SELECT 2,3)`, &sql.SelectStatement{
			Select:  pos(0),
			Columns: []*sql.ResultColumn{{Expr: &sql.NumberLit{ValuePos: pos(7), Value: "1"}}}, Where: pos(9),
			WhereExpr: &sql.BinaryExpr{
				X:     &sql.BoolLit{ValuePos: pos(15), Value: true},
				OpPos: pos(20),
				Op:    sql.AND,
				Y: &sql.BinaryExpr{
					X: &sql.ExprList{
						Lparen: pos(24),
						Exprs: []sql.Expr{
							&sql.NumberLit{ValuePos: pos(25), Value: "0"},
							&sql.NumberLit{ValuePos: pos(28), Value: "1"},
						},
						Rparen: pos(29),
					},
					OpPos: pos(31),
					Op:    sql.EQ,
					Y: &sql.ParenExpr{
						Lparen: pos(33),
						X: sql.SelectExpr{
							SelectStatement: &sql.SelectStatement{
								Select: pos(34),
								Columns: []*sql.ResultColumn{
									{Expr: &sql.NumberLit{ValuePos: pos(41), Value: "2"}},
									{Expr: &sql.NumberLit{ValuePos: pos(43), Value: "3"}},
								},
							},
						},
						Rparen: pos(44),
					},
				},
			},
		})

		AssertParseStatement(t, `SELECT * GROUP BY foo, bar`, &sql.SelectStatement{
			Select:  pos(0),
			Columns: []*sql.ResultColumn{{Star: pos(7)}},
			Group:   pos(9),
			GroupBy: pos(15),
			GroupByExprs: []sql.Expr{
				&sql.Ident{NamePos: pos(18), Name: "foo"},
				&sql.Ident{NamePos: pos(23), Name: "bar"},
			},
		})
		AssertParseStatement(t, `SELECT * GROUP BY foo HAVING true`, &sql.SelectStatement{
			Select:  pos(0),
			Columns: []*sql.ResultColumn{{Star: pos(7)}},
			Group:   pos(9),
			GroupBy: pos(15),
			GroupByExprs: []sql.Expr{
				&sql.Ident{NamePos: pos(18), Name: "foo"},
			},
			Having:     pos(22),
			HavingExpr: &sql.BoolLit{ValuePos: pos(29), Value: true},
		})
		AssertParseStatement(t, `SELECT * WINDOW win1 AS (), win2 AS ()`, &sql.SelectStatement{
			Select:  pos(0),
			Columns: []*sql.ResultColumn{{Star: pos(7)}},
			Window:  pos(9),
			Windows: []*sql.Window{
				{
					Name: &sql.Ident{NamePos: pos(16), Name: "win1"},
					As:   pos(21),
					Definition: &sql.WindowDefinition{
						Lparen: pos(24),
						Rparen: pos(25),
					},
				},
				{
					Name: &sql.Ident{NamePos: pos(28), Name: "win2"},
					As:   pos(33),
					Definition: &sql.WindowDefinition{
						Lparen: pos(36),
						Rparen: pos(37),
					},
				},
			},
		})

		AssertParseStatement(t, `SELECT * ORDER BY foo ASC, bar DESC`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{Star: pos(7)},
			},
			Order:   pos(9),
			OrderBy: pos(15),
			OrderingTerms: []*sql.OrderingTerm{
				{X: &sql.Ident{NamePos: pos(18), Name: "foo"}, Asc: pos(22)},
				{X: &sql.Ident{NamePos: pos(27), Name: "bar"}, Desc: pos(31)},
			},
		})

		AssertParseStatement(t, `SELECT * ORDER BY random()`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{Star: pos(7)},
			},
			Order:   pos(9),
			OrderBy: pos(15),
			OrderingTerms: []*sql.OrderingTerm{
				{
					X: &sql.Call{
						Name:   &sql.Ident{NamePos: pos(18), Name: "random"},
						Lparen: pos(24),
						Rparen: pos(25),
					},
				},
			},
		})

		AssertParseStatement(t, `SELECT * ORDER BY c1 COLLATE BINARY;`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{Star: pos(7)},
			},
			Order:   pos(9),
			OrderBy: pos(15),
			OrderingTerms: []*sql.OrderingTerm{
				{
					X: &sql.CollateExpr{
						X: &sql.Ident{NamePos: pos(18), Name: "c1"},
						Collation: &sql.CollationClause{
							Collate: pos(21),
							Name:    &sql.Ident{NamePos: pos(29), Name: "BINARY"},
						},
					},
				},
			},
		})

		AssertParseStatement(t, `SELECT * ORDER BY c1 COLLATE NOCASE DESC;`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{Star: pos(7)},
			},
			Order:   pos(9),
			OrderBy: pos(15),
			OrderingTerms: []*sql.OrderingTerm{
				{
					X: &sql.CollateExpr{
						X: &sql.Ident{NamePos: pos(18), Name: "c1"},
						Collation: &sql.CollationClause{
							Collate: pos(21), Name: &sql.Ident{NamePos: pos(29), Name: "NOCASE"},
						},
					},
					Desc: pos(36),
				},
			},
		})

		AssertParseStatement(t, `SELECT * LIMIT 1`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{Star: pos(7)},
			},
			Limit:     pos(9),
			LimitExpr: &sql.NumberLit{ValuePos: pos(15), Value: "1"},
		})
		AssertParseStatement(t, `SELECT * LIMIT 1 OFFSET 2`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{Star: pos(7)},
			},
			Limit:      pos(9),
			LimitExpr:  &sql.NumberLit{ValuePos: pos(15), Value: "1"},
			Offset:     pos(17),
			OffsetExpr: &sql.NumberLit{ValuePos: pos(24), Value: "2"},
		})
		AssertParseStatement(t, `SELECT * LIMIT 1, 2`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{Star: pos(7)},
			},
			Limit:       pos(9),
			LimitExpr:   &sql.NumberLit{ValuePos: pos(15), Value: "1"},
			OffsetComma: pos(16),
			OffsetExpr:  &sql.NumberLit{ValuePos: pos(18), Value: "2"},
		})
		AssertParseStatement(t, `SELECT * UNION SELECT * ORDER BY foo`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{Star: pos(7)},
			},
			Union: pos(9),
			Compound: &sql.SelectStatement{
				Select: pos(15),
				Columns: []*sql.ResultColumn{
					{Star: pos(22)},
				},
			},
			Order:   pos(24),
			OrderBy: pos(30),
			OrderingTerms: []*sql.OrderingTerm{
				{X: &sql.Ident{NamePos: pos(33), Name: "foo"}},
			},
		})
		AssertParseStatement(t, `SELECT * UNION ALL SELECT *`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{Star: pos(7)},
			},
			Union:    pos(9),
			UnionAll: pos(15),
			Compound: &sql.SelectStatement{
				Select: pos(19),
				Columns: []*sql.ResultColumn{
					{Star: pos(26)},
				},
			},
		})
		AssertParseStatement(t, `SELECT * INTERSECT SELECT *`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{Star: pos(7)},
			},
			Intersect: pos(9),
			Compound: &sql.SelectStatement{
				Select: pos(19),
				Columns: []*sql.ResultColumn{
					{Star: pos(26)},
				},
			},
		})
		AssertParseStatement(t, `SELECT * EXCEPT SELECT *`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{Star: pos(7)},
			},
			Except: pos(9),
			Compound: &sql.SelectStatement{
				Select: pos(16),
				Columns: []*sql.ResultColumn{
					{Star: pos(23)},
				},
			},
		})

		AssertParseStatement(t, `VALUES (1, 2), (3, 4)`, &sql.SelectStatement{
			Values: pos(0),
			ValueLists: []*sql.ExprList{
				{
					Lparen: pos(7),
					Exprs: []sql.Expr{
						&sql.NumberLit{ValuePos: pos(8), Value: "1"},
						&sql.NumberLit{ValuePos: pos(11), Value: "2"},
					},
					Rparen: pos(12),
				},
				{
					Lparen: pos(15),
					Exprs: []sql.Expr{
						&sql.NumberLit{ValuePos: pos(16), Value: "3"},
						&sql.NumberLit{ValuePos: pos(19), Value: "4"},
					},
					Rparen: pos(20),
				},
			},
		})

		AssertParseStatement(t, `SELECT * FROM foo WHERE foo.elem = 0`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{
					Star: pos(7),
				},
			},
			From: pos(9),
			Source: &sql.QualifiedTableName{
				Name: &sql.Ident{
					NamePos: pos(14),
					Name:    "foo",
				},
			},
			Where: pos(18),
			WhereExpr: &sql.BinaryExpr{
				X: &sql.QualifiedRef{
					Table: &sql.Ident{
						NamePos: pos(24),
						Name:    "foo",
					},
					Dot: pos(27),
					Column: &sql.Ident{
						NamePos: pos(28),
						Name:    "elem",
					},
				},
				OpPos: pos(33),
				Op:    sql.EQ,
				Y: &sql.NumberLit{
					ValuePos: pos(35),
					Value:    "0",
				},
			},
		})

		// Test IN/NOT IN with table names in SELECT statements
		AssertParseStatement(t, `SELECT * FROM vals WHERE a NOT IN vals`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{Star: pos(7)},
			},
			From: pos(9),
			Source: &sql.QualifiedTableName{
				Name: &sql.Ident{NamePos: pos(14), Name: "vals"},
			},
			Where: pos(19),
			WhereExpr: &sql.BinaryExpr{
				X:     &sql.Ident{NamePos: pos(25), Name: "a"},
				OpPos: pos(27),
				Op:    sql.NOTIN,
				Y:     &sql.Ident{NamePos: pos(34), Name: "vals"},
			},
		})

		AssertParseStatement(t, `SELECT * FROM vals WHERE a IN main.vals`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{Star: pos(7)},
			},
			From: pos(9),
			Source: &sql.QualifiedTableName{
				Name: &sql.Ident{NamePos: pos(14), Name: "vals"},
			},
			Where: pos(19),
			WhereExpr: &sql.BinaryExpr{
				X:     &sql.Ident{NamePos: pos(25), Name: "a"},
				OpPos: pos(27),
				Op:    sql.IN,
				Y: &sql.QualifiedRef{
					Table:  &sql.Ident{NamePos: pos(30), Name: "main"},
					Dot:    pos(34),
					Column: &sql.Ident{NamePos: pos(35), Name: "vals"},
				},
			},
		})

		AssertParseStatement(t, `SELECT * FROM vals WHERE a NOT IN json_each('[]')`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{Star: pos(7)},
			},
			From: pos(9),
			Source: &sql.QualifiedTableName{
				Name: &sql.Ident{NamePos: pos(14), Name: "vals"},
			},
			Where: pos(19),
			WhereExpr: &sql.BinaryExpr{
				X:     &sql.Ident{NamePos: pos(25), Name: "a"},
				OpPos: pos(27),
				Op:    sql.NOTIN,
				Y: &sql.Call{
					Name:   &sql.Ident{NamePos: pos(34), Name: "json_each"},
					Lparen: pos(43),
					Args: []sql.Expr{
						&sql.StringLit{ValuePos: pos(44), Value: "[]"},
					},
					Rparen: pos(48),
				},
			},
		})

		// Test COLLATE as a postfix expression operator
		AssertParseStatement(t, `SELECT * FROM vals WHERE a < 'C' COLLATE NOCASE`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{Star: pos(7)},
			},
			From: pos(9),
			Source: &sql.QualifiedTableName{
				Name: &sql.Ident{NamePos: pos(14), Name: "vals"},
			},
			Where: pos(19),
			WhereExpr: &sql.BinaryExpr{
				X:     &sql.Ident{NamePos: pos(25), Name: "a"},
				OpPos: pos(27),
				Op:    sql.LT,
				Y: &sql.CollateExpr{
					X: &sql.StringLit{ValuePos: pos(29), Value: "C"},
					Collation: &sql.CollationClause{
						Collate: pos(33),
						Name:    &sql.Ident{NamePos: pos(41), Name: "NOCASE"},
					},
				},
			},
		})

		AssertParseStatement(t, `SELECT * FROM vals WHERE 'C' COLLATE NOCASE > a`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{Star: pos(7)},
			},
			From: pos(9),
			Source: &sql.QualifiedTableName{
				Name: &sql.Ident{NamePos: pos(14), Name: "vals"},
			},
			Where: pos(19),
			WhereExpr: &sql.BinaryExpr{
				X: &sql.CollateExpr{
					X: &sql.StringLit{ValuePos: pos(25), Value: "C"},
					Collation: &sql.CollationClause{
						Collate: pos(29),
						Name:    &sql.Ident{NamePos: pos(37), Name: "NOCASE"},
					},
				},
				OpPos: pos(44),
				Op:    sql.GT,
				Y:     &sql.Ident{NamePos: pos(46), Name: "a"},
			},
		})

		AssertParseStatement(t, `SELECT name COLLATE BINARY FROM users`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{
					Expr: &sql.CollateExpr{
						X: &sql.Ident{NamePos: pos(7), Name: "name"},
						Collation: &sql.CollationClause{
							Collate: pos(12),
							Name:    &sql.Ident{NamePos: pos(20), Name: "BINARY"},
						},
					},
				},
			},
			From: pos(27),
			Source: &sql.QualifiedTableName{
				Name: &sql.Ident{NamePos: pos(32), Name: "users"},
			},
		})

		AssertParseStatement(t, `SELECT rowid FROM foo`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{
					Expr: &sql.Ident{
						NamePos: pos(7),
						Name:    "rowid",
					},
				},
			},
			From: pos(13),
			Source: &sql.QualifiedTableName{
				Name: &sql.Ident{
					NamePos: pos(18),
					Name:    "foo",
				},
			},
		})

		AssertParseStatement(t, `SELECT rowid FROM foo ORDER BY rowid`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{
					Expr: &sql.Ident{
						NamePos: pos(7),
						Name:    "rowid",
					},
				},
			},
			From: pos(13),
			Source: &sql.QualifiedTableName{
				Name: &sql.Ident{
					NamePos: pos(18),
					Name:    "foo",
				},
			},
			Order:   pos(22),
			OrderBy: pos(28),
			OrderingTerms: []*sql.OrderingTerm{
				{
					X: &sql.Ident{
						NamePos: pos(31),
						Name:    "rowid",
					},
				},
			},
		})

		AssertParseStatement(t, `SELECT CURRENT_TIMESTAMP FROM foo`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{
					Expr: &sql.TimestampLit{
						ValuePos: pos(7),
						Value:    "CURRENT_TIMESTAMP",
					},
				},
			},
			From: pos(25),
			Source: &sql.QualifiedTableName{
				Name: &sql.Ident{
					NamePos: pos(30),
					Name:    "foo",
				},
			},
		})

		AssertParseStatement(t, `SELECT max(rowid) FROM foo`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{
					Expr: &sql.Call{
						Name: &sql.Ident{
							NamePos: pos(7),
							Name:    "max",
						},
						Lparen: pos(10),
						Rparen: pos(16),
						Args: []sql.Expr{
							&sql.Ident{
								NamePos: pos(11),
								Name:    "rowid",
							},
						},
					},
				},
			},
			From: pos(18),
			Source: &sql.QualifiedTableName{
				Name: &sql.Ident{
					NamePos: pos(23),
					Name:    "foo",
				},
			},
		})

		AssertParseStatement(t, `SELECT * FROM generate_series(1,3)`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{
					Star: pos(7),
				},
			},
			From: pos(9),
			Source: &sql.QualifiedTableFunctionName{
				Name: &sql.Ident{
					NamePos: pos(14),
					Name:    "generate_series",
				},
				Lparen: pos(29),
				Args: []sql.Expr{
					&sql.NumberLit{
						ValuePos: pos(30),
						Value:    "1",
					},
					&sql.NumberLit{
						ValuePos: pos(32),
						Value:    "3",
					},
				},
				Rparen: pos(33),
			},
		})

		AssertParseStatementError(t, `WITH `, `1:5: expected table name, found 'EOF'`)
		AssertParseStatementError(t, `WITH cte`, `1:8: expected AS, found 'EOF'`)
		AssertParseStatementError(t, `WITH cte (`, `1:10: expected column name, found 'EOF'`)
		AssertParseStatementError(t, `WITH cte (foo`, `1:13: expected comma or right paren, found 'EOF'`)
		AssertParseStatementError(t, `WITH cte (foo)`, `1:14: expected AS, found 'EOF'`)
		AssertParseStatementError(t, `WITH cte AS`, `1:11: expected left paren, found 'EOF'`)
		AssertParseStatementError(t, `WITH cte AS (`, `1:13: expected SELECT or VALUES, found 'EOF'`)
		AssertParseStatementError(t, `WITH cte AS (SELECT foo`, `1:23: expected right paren, found 'EOF'`)
		AssertParseStatementError(t, `WITH cte AS (SELECT foo)`, `1:24: expected SELECT, VALUES, INSERT, REPLACE, UPDATE, or DELETE, found 'EOF'`)
		AssertParseStatementError(t, `SELECT `, `1:7: expected expression, found 'EOF'`)
		// Time literals are not functions or table names.
		AssertParseStatementError(t, `SELECT CURRENT_TIMESTAMP(1)`, `1:25: expected semicolon or EOF, found '('`)
		AssertParseStatementError(t, `SELECT current_time()`, `1:20: expected semicolon or EOF, found '('`)
		AssertParseStatementError(t, `SELECT CURRENT_DATE.x FROM foo`, `1:20: expected semicolon or EOF, found '.'`)
		AssertParseStatementError(t, `SELECT 1+`, `1:9: expected expression, found 'EOF'`)
		AssertParseStatementError(t, `SELECT foo,`, `1:11: expected expression, found 'EOF'`)
		AssertParseStatementError(t, `SELECT foo AS`, `1:13: expected column alias, found 'EOF'`)
		AssertParseStatementError(t, `SELECT foo.* AS`, `1:14: expected semicolon or EOF, found 'AS'`)
		AssertParseStatementError(t, `SELECT foo FROM`, `1:15: expected table name or left paren, found 'EOF'`)
		AssertParseStatementError(t, `SELECT foo FROM foo INDEXED`, `1:27: expected BY, found 'EOF'`)
		AssertParseStatementError(t, `SELECT foo FROM foo INDEXED BY`, `1:30: expected index name, found 'EOF'`)
		AssertParseStatementError(t, `SELECT foo FROM foo NOT`, `1:23: expected INDEXED, found 'EOF'`)
		AssertParseStatementError(t, `SELECT * FROM foo INNER`, `1:23: expected JOIN, found 'EOF'`)
		AssertParseStatementError(t, `SELECT * FROM foo CROSS`, `1:23: expected JOIN, found 'EOF'`)
		AssertParseStatementError(t, `SELECT * FROM foo NATURAL`, `1:25: expected JOIN, found 'EOF'`)
		AssertParseStatementError(t, `SELECT * FROM foo LEFT`, `1:22: expected JOIN, found 'EOF'`)
		AssertParseStatementError(t, `SELECT * FROM foo LEFT OUTER`, `1:28: expected JOIN, found 'EOF'`)
		AssertParseStatementError(t, `SELECT * FROM foo,`, `1:18: expected table name or left paren, found 'EOF'`)
		AssertParseStatementError(t, `SELECT * FROM foo JOIN bar ON`, `1:29: expected expression, found 'EOF'`)
		AssertParseStatementError(t, `SELECT * FROM foo JOIN bar USING`, `1:32: expected left paren, found 'EOF'`)
		AssertParseStatementError(t, `SELECT * FROM foo JOIN bar USING (`, `1:34: expected column name, found 'EOF'`)
		AssertParseStatementError(t, `SELECT * FROM foo JOIN bar USING (x`, `1:35: expected comma or right paren, found 'EOF'`)
		AssertParseStatementError(t, `SELECT * FROM foo JOIN bar USING (x,`, `1:36: expected column name, found 'EOF'`)
		AssertParseStatementError(t, `SELECT * FROM (`, `1:15: expected table name or left paren, found 'EOF'`)
		AssertParseStatementError(t, `SELECT * FROM ((`, `1:16: expected table name or left paren, found 'EOF'`)
		AssertParseStatementError(t, `SELECT * FROM (SELECT`, `1:21: expected expression, found 'EOF'`)
		AssertParseStatementError(t, `SELECT * FROM (tbl`, `1:18: expected right paren, found 'EOF'`)
		AssertParseStatementError(t, `SELECT * FROM (SELECT *) AS`, `1:27: expected table alias, found 'EOF'`)
		AssertParseStatementError(t, `SELECT * FROM foo AS`, `1:20: expected table alias, found 'EOF'`)
		AssertParseStatementError(t, `SELECT foo WHERE`, `1:16: expected expression, found 'EOF'`)
		AssertParseStatementError(t, `SELECT * GROUP`, `1:14: expected BY, found 'EOF'`)
		AssertParseStatementError(t, `SELECT * GROUP BY`, `1:17: expected expression, found 'EOF'`)
		AssertParseStatementError(t, `SELECT * GROUP BY foo bar`, `1:23: expected semicolon or EOF, found bar`)
		AssertParseStatementError(t, `SELECT * GROUP BY foo HAVING`, `1:28: expected expression, found 'EOF'`)
		AssertParseStatementError(t, `SELECT * WINDOW`, `1:15: expected window name, found 'EOF'`)
		AssertParseStatementError(t, `SELECT * WINDOW win1`, `1:20: expected AS, found 'EOF'`)
		AssertParseStatementError(t, `SELECT * WINDOW win1 AS`, `1:23: expected left paren, found 'EOF'`)
		AssertParseStatementError(t, `SELECT * WINDOW win1 AS (`, `1:25: expected right paren, found 'EOF'`)
		AssertParseStatementError(t, `SELECT * WINDOW win1 AS () win2`, `1:28: expected semicolon or EOF, found win2`)
		AssertParseStatementError(t, `SELECT * ORDER`, `1:14: expected BY, found 'EOF'`)
		AssertParseStatementError(t, `SELECT * ORDER BY`, `1:17: expected expression, found 'EOF'`)
		AssertParseStatementError(t, `SELECT * ORDER BY 1,`, `1:20: expected expression, found 'EOF'`)
		AssertParseStatementError(t, `SELECT * LIMIT`, `1:14: expected expression, found 'EOF'`)
		AssertParseStatementError(t, `SELECT * LIMIT 1,`, `1:17: expected expression, found 'EOF'`)
		AssertParseStatementError(t, `SELECT * LIMIT 1 OFFSET`, `1:23: expected expression, found 'EOF'`)
		AssertParseStatementError(t, `VALUES`, `1:6: expected left paren, found 'EOF'`)
		AssertParseStatementError(t, `VALUES (`, `1:8: expected expression, found 'EOF'`)
		AssertParseStatementError(t, `VALUES (1`, `1:9: expected comma or right paren, found 'EOF'`)
		AssertParseStatementError(t, `VALUES (1,`, `1:10: expected expression, found 'EOF'`)
		AssertParseStatementError(t, `SELECT * UNION`, `1:14: expected SELECT or VALUES, found 'EOF'`)
	})

	t.Run("Insert", func(t *testing.T) {
		// CURRENT_TIME, CURRENT_DATE and CURRENT_TIMESTAMP are literals in an
		// expression, never identifiers: sqlite3 returns the time even when a
		// column of that name exists. Serializing them quoted would turn them
		// into (nonexistent) column references that SQLite then treats as
		// string literals.
		AssertParseStatement(t, `INSERT INTO tbl VALUES (CURRENT_TIME, current_date, CURRENT_TIMESTAMP)`, &sql.InsertStatement{
			Insert: pos(0),
			Into:   pos(7),
			Table:  &sql.Ident{NamePos: pos(12), Name: "tbl"},
			Values: pos(16),
			ValueLists: []*sql.ExprList{{
				Lparen: pos(23),
				Exprs: []sql.Expr{
					&sql.TimestampLit{ValuePos: pos(24), Value: "CURRENT_TIME"},
					&sql.TimestampLit{ValuePos: pos(38), Value: "current_date"},
					&sql.TimestampLit{ValuePos: pos(52), Value: "CURRENT_TIMESTAMP"},
				},
				Rparen: pos(69),
			}},
		})
		AssertParseStatement(t, `INSERT INTO tbl (x, y) VALUES (1, 2)`, &sql.InsertStatement{
			Insert:        pos(0),
			Into:          pos(7),
			Table:         &sql.Ident{NamePos: pos(12), Name: "tbl"},
			ColumnsLparen: pos(16),
			Columns: []*sql.Ident{
				{NamePos: pos(17), Name: "x"},
				{NamePos: pos(20), Name: "y"},
			},
			ColumnsRparen: pos(21),
			Values:        pos(23),
			ValueLists: []*sql.ExprList{{
				Lparen: pos(30),
				Exprs: []sql.Expr{
					&sql.NumberLit{ValuePos: pos(31), Value: "1"},
					&sql.NumberLit{ValuePos: pos(34), Value: "2"},
				},
				Rparen: pos(35),
			}},
		})
		AssertParseStatement(t, `INSERT INTO tbl (x, y) VALUES (?, ?)`, &sql.InsertStatement{
			Insert:        pos(0),
			Into:          pos(7),
			Table:         &sql.Ident{NamePos: pos(12), Name: "tbl"},
			ColumnsLparen: pos(16),
			Columns: []*sql.Ident{
				{NamePos: pos(17), Name: "x"},
				{NamePos: pos(20), Name: "y"},
			},
			ColumnsRparen: pos(21),
			Values:        pos(23),
			ValueLists: []*sql.ExprList{{
				Lparen: pos(30),
				Exprs: []sql.Expr{
					&sql.BindExpr{NamePos: pos(31), Name: "?"},
					&sql.BindExpr{NamePos: pos(34), Name: "?"},
				},
				Rparen: pos(35),
			}},
		})
		AssertParseStatement(t, `INSERT INTO tbl (x, y) VALUES (?1, ?2)`, &sql.InsertStatement{
			Insert:        pos(0),
			Into:          pos(7),
			Table:         &sql.Ident{NamePos: pos(12), Name: "tbl"},
			ColumnsLparen: pos(16),
			Columns: []*sql.Ident{
				{NamePos: pos(17), Name: "x"},
				{NamePos: pos(20), Name: "y"},
			},
			ColumnsRparen: pos(21),
			Values:        pos(23),
			ValueLists: []*sql.ExprList{{
				Lparen: pos(30),
				Exprs: []sql.Expr{
					&sql.BindExpr{NamePos: pos(31), Name: "?1"},
					&sql.BindExpr{NamePos: pos(35), Name: "?2"},
				},
				Rparen: pos(37),
			}},
		})
		AssertParseStatement(t, `INSERT INTO tbl (x, y) VALUES (:foo, :bar)`, &sql.InsertStatement{
			Insert:        pos(0),
			Into:          pos(7),
			Table:         &sql.Ident{NamePos: pos(12), Name: "tbl"},
			ColumnsLparen: pos(16),
			Columns: []*sql.Ident{
				{NamePos: pos(17), Name: "x"},
				{NamePos: pos(20), Name: "y"},
			},
			ColumnsRparen: pos(21),
			Values:        pos(23),
			ValueLists: []*sql.ExprList{{
				Lparen: pos(30),
				Exprs: []sql.Expr{
					&sql.BindExpr{NamePos: pos(31), Name: ":foo"},
					&sql.BindExpr{NamePos: pos(37), Name: ":bar"},
				},
				Rparen: pos(41),
			}},
		})
		AssertParseStatement(t, `INSERT INTO tbl (x, y) VALUES (@foo, @bar)`, &sql.InsertStatement{
			Insert:        pos(0),
			Into:          pos(7),
			Table:         &sql.Ident{NamePos: pos(12), Name: "tbl"},
			ColumnsLparen: pos(16),
			Columns: []*sql.Ident{
				{NamePos: pos(17), Name: "x"},
				{NamePos: pos(20), Name: "y"},
			},
			ColumnsRparen: pos(21),
			Values:        pos(23),
			ValueLists: []*sql.ExprList{{
				Lparen: pos(30),
				Exprs: []sql.Expr{
					&sql.BindExpr{NamePos: pos(31), Name: "@foo"},
					&sql.BindExpr{NamePos: pos(37), Name: "@bar"},
				},
				Rparen: pos(41),
			}},
		})
		AssertParseStatement(t, `INSERT INTO tbl (x, y) VALUES ($foo, $bar)`, &sql.InsertStatement{
			Insert:        pos(0),
			Into:          pos(7),
			Table:         &sql.Ident{NamePos: pos(12), Name: "tbl"},
			ColumnsLparen: pos(16),
			Columns: []*sql.Ident{
				{NamePos: pos(17), Name: "x"},
				{NamePos: pos(20), Name: "y"},
			},
			ColumnsRparen: pos(21),
			Values:        pos(23),
			ValueLists: []*sql.ExprList{{
				Lparen: pos(30),
				Exprs: []sql.Expr{
					&sql.BindExpr{NamePos: pos(31), Name: "$foo"},
					&sql.BindExpr{NamePos: pos(37), Name: "$bar"},
				},
				Rparen: pos(41),
			}},
		})
		AssertParseStatement(t, `INSERT INTO tbl (x, y) VALUES (1, random())`, &sql.InsertStatement{
			Insert:        pos(0),
			Into:          pos(7),
			Table:         &sql.Ident{NamePos: pos(12), Name: "tbl"},
			ColumnsLparen: pos(16),
			Columns: []*sql.Ident{
				{NamePos: pos(17), Name: "x"},
				{NamePos: pos(20), Name: "y"},
			},
			ColumnsRparen: pos(21),
			Values:        pos(23),
			ValueLists: []*sql.ExprList{{
				Lparen: pos(30),
				Exprs: []sql.Expr{
					&sql.NumberLit{ValuePos: pos(31), Value: "1"},
					&sql.Call{
						Name:   &sql.Ident{NamePos: pos(34), Name: "random"},
						Lparen: pos(40),
						Rparen: pos(41),
					},
				},
				Rparen: pos(42),
			}},
		})
		AssertParseStatement(t, `INSERT INTO tbl (x, y) VALUES (1, abs(random()))`, &sql.InsertStatement{
			Insert:        pos(0),
			Into:          pos(7),
			Table:         &sql.Ident{NamePos: pos(12), Name: "tbl"},
			ColumnsLparen: pos(16),
			Columns: []*sql.Ident{
				{NamePos: pos(17), Name: "x"},
				{NamePos: pos(20), Name: "y"},
			},
			ColumnsRparen: pos(21),
			Values:        pos(23),
			ValueLists: []*sql.ExprList{{
				Lparen: pos(30),
				Exprs: []sql.Expr{
					&sql.NumberLit{ValuePos: pos(31), Value: "1"},
					&sql.Call{
						Name:   &sql.Ident{NamePos: pos(34), Name: "abs"},
						Lparen: pos(37),
						Rparen: pos(46),
						Args: []sql.Expr{
							&sql.Call{
								Name:   &sql.Ident{NamePos: pos(38), Name: "random"},
								Lparen: pos(44),
								Rparen: pos(45),
							},
						},
					},
				},
				Rparen: pos(47),
			}},
		})
		AssertParseStatement(t, `REPLACE INTO tbl (x, y) VALUES (1, 2), (3, 4)`, &sql.InsertStatement{
			Replace:       pos(0),
			Into:          pos(8),
			Table:         &sql.Ident{NamePos: pos(13), Name: "tbl"},
			ColumnsLparen: pos(17),
			Columns: []*sql.Ident{
				{NamePos: pos(18), Name: "x"},
				{NamePos: pos(21), Name: "y"},
			},
			ColumnsRparen: pos(22),
			Values:        pos(24),
			ValueLists: []*sql.ExprList{
				{
					Lparen: pos(31),
					Exprs: []sql.Expr{
						&sql.NumberLit{ValuePos: pos(32), Value: "1"},
						&sql.NumberLit{ValuePos: pos(35), Value: "2"},
					},
					Rparen: pos(36),
				},
				{
					Lparen: pos(39),
					Exprs: []sql.Expr{
						&sql.NumberLit{ValuePos: pos(40), Value: "3"},
						&sql.NumberLit{ValuePos: pos(43), Value: "4"},
					},
					Rparen: pos(44),
				},
			},
		})

		AssertParseStatement(t, `INSERT OR REPLACE INTO tbl (x) VALUES (1)`, &sql.InsertStatement{
			Insert:          pos(0),
			InsertOr:        pos(7),
			InsertOrReplace: pos(10),
			Into:            pos(18),
			Table:           &sql.Ident{NamePos: pos(23), Name: "tbl"},
			ColumnsLparen:   pos(27),
			Columns: []*sql.Ident{
				{NamePos: pos(28), Name: "x"},
			},
			ColumnsRparen: pos(29),
			Values:        pos(31),
			ValueLists: []*sql.ExprList{{
				Lparen: pos(38),
				Exprs: []sql.Expr{
					&sql.NumberLit{ValuePos: pos(39), Value: "1"},
				},
				Rparen: pos(40),
			}},
		})
		AssertParseStatement(t, `INSERT OR ROLLBACK INTO tbl (x) VALUES (1)`, &sql.InsertStatement{
			Insert:           pos(0),
			InsertOr:         pos(7),
			InsertOrRollback: pos(10),
			Into:             pos(19),
			Table:            &sql.Ident{NamePos: pos(24), Name: "tbl"},
			ColumnsLparen:    pos(28),
			Columns: []*sql.Ident{
				{NamePos: pos(29), Name: "x"},
			},
			ColumnsRparen: pos(30),
			Values:        pos(32),
			ValueLists: []*sql.ExprList{{
				Lparen: pos(39),
				Exprs: []sql.Expr{
					&sql.NumberLit{ValuePos: pos(40), Value: "1"},
				},
				Rparen: pos(41),
			}},
		})
		AssertParseStatement(t, `INSERT OR ABORT INTO tbl (x) VALUES (1)`, &sql.InsertStatement{
			Insert:        pos(0),
			InsertOr:      pos(7),
			InsertOrAbort: pos(10),
			Into:          pos(16),
			Table:         &sql.Ident{NamePos: pos(21), Name: "tbl"},
			ColumnsLparen: pos(25),
			Columns: []*sql.Ident{
				{NamePos: pos(26), Name: "x"},
			},
			ColumnsRparen: pos(27),
			Values:        pos(29),
			ValueLists: []*sql.ExprList{{
				Lparen: pos(36),
				Exprs: []sql.Expr{
					&sql.NumberLit{ValuePos: pos(37), Value: "1"},
				},
				Rparen: pos(38),
			}},
		})
		AssertParseStatement(t, `INSERT OR FAIL INTO tbl VALUES (1)`, &sql.InsertStatement{
			Insert:       pos(0),
			InsertOr:     pos(7),
			InsertOrFail: pos(10),
			Into:         pos(15),
			Table:        &sql.Ident{NamePos: pos(20), Name: "tbl"},
			Values:       pos(24),
			ValueLists: []*sql.ExprList{{
				Lparen: pos(31),
				Exprs: []sql.Expr{
					&sql.NumberLit{ValuePos: pos(32), Value: "1"},
				},
				Rparen: pos(33),
			}},
		})
		AssertParseStatement(t, `INSERT OR IGNORE INTO tbl AS tbl2 VALUES (1)`, &sql.InsertStatement{
			Insert:         pos(0),
			InsertOr:       pos(7),
			InsertOrIgnore: pos(10),
			Into:           pos(17),
			Table:          &sql.Ident{NamePos: pos(22), Name: "tbl"},
			As:             pos(26),
			Alias:          &sql.Ident{NamePos: pos(29), Name: "tbl2"},
			Values:         pos(34),
			ValueLists: []*sql.ExprList{{
				Lparen: pos(41),
				Exprs: []sql.Expr{
					&sql.NumberLit{ValuePos: pos(42), Value: "1"},
				},
				Rparen: pos(43),
			}},
		})

		AssertParseStatement(t, `WITH cte (foo) AS (SELECT bar) INSERT INTO tbl VALUES (1)`, &sql.InsertStatement{
			WithClause: &sql.WithClause{
				With: pos(0),
				CTEs: []*sql.CTE{{
					TableName:     &sql.Ident{NamePos: pos(5), Name: "cte"},
					ColumnsLparen: pos(9),
					Columns: []*sql.Ident{
						{NamePos: pos(10), Name: "foo"},
					},
					ColumnsRparen: pos(13),
					As:            pos(15),
					SelectLparen:  pos(18),
					Select: &sql.SelectStatement{
						Select: pos(19),
						Columns: []*sql.ResultColumn{
							{Expr: &sql.Ident{NamePos: pos(26), Name: "bar"}},
						},
					},
					SelectRparen: pos(29),
				}},
			},
			Insert: pos(31),
			Into:   pos(38),
			Table:  &sql.Ident{NamePos: pos(43), Name: "tbl"},
			Values: pos(47),
			ValueLists: []*sql.ExprList{{
				Lparen: pos(54),
				Exprs: []sql.Expr{
					&sql.NumberLit{ValuePos: pos(55), Value: "1"},
				},
				Rparen: pos(56),
			}},
		})
		AssertParseStatement(t, `WITH cte (foo) AS (SELECT bar) INSERT INTO tbl VALUES (1)`, &sql.InsertStatement{
			WithClause: &sql.WithClause{
				With: pos(0),
				CTEs: []*sql.CTE{{
					TableName:     &sql.Ident{NamePos: pos(5), Name: "cte"},
					ColumnsLparen: pos(9),
					Columns: []*sql.Ident{
						{NamePos: pos(10), Name: "foo"},
					},
					ColumnsRparen: pos(13),
					As:            pos(15),
					SelectLparen:  pos(18),
					Select: &sql.SelectStatement{
						Select: pos(19),
						Columns: []*sql.ResultColumn{
							{Expr: &sql.Ident{NamePos: pos(26), Name: "bar"}},
						},
					},
					SelectRparen: pos(29),
				}},
			},
			Insert: pos(31),
			Into:   pos(38),
			Table:  &sql.Ident{NamePos: pos(43), Name: "tbl"},
			Values: pos(47),
			ValueLists: []*sql.ExprList{{
				Lparen: pos(54),
				Exprs: []sql.Expr{
					&sql.NumberLit{ValuePos: pos(55), Value: "1"},
				},
				Rparen: pos(56),
			}},
		})

		AssertParseStatement(t, `INSERT INTO tbl (x) SELECT y`, &sql.InsertStatement{
			Insert:        pos(0),
			Into:          pos(7),
			Table:         &sql.Ident{NamePos: pos(12), Name: "tbl"},
			ColumnsLparen: pos(16),
			Columns: []*sql.Ident{
				{NamePos: pos(17), Name: "x"},
			},
			ColumnsRparen: pos(18),
			Select: &sql.SelectStatement{
				Select: pos(20),
				Columns: []*sql.ResultColumn{
					{Expr: &sql.Ident{NamePos: pos(27), Name: "y"}},
				},
			},
		})

		AssertParseStatement(t, `INSERT INTO tbl (x) DEFAULT VALUES`, &sql.InsertStatement{
			Insert:        pos(0),
			Into:          pos(7),
			Table:         &sql.Ident{NamePos: pos(12), Name: "tbl"},
			ColumnsLparen: pos(16),
			Columns: []*sql.Ident{
				{NamePos: pos(17), Name: "x"},
			},
			ColumnsRparen: pos(18),
			Default:       pos(20),
			DefaultValues: pos(28),
		})

		AssertParseStatement(t, `INSERT INTO tbl (x) VALUES (1) ON CONFLICT (y ASC, z DESC) DO NOTHING`, &sql.InsertStatement{
			Insert:        pos(0),
			Into:          pos(7),
			Table:         &sql.Ident{NamePos: pos(12), Name: "tbl"},
			ColumnsLparen: pos(16),
			Columns: []*sql.Ident{
				{NamePos: pos(17), Name: "x"},
			},
			ColumnsRparen: pos(18),
			Values:        pos(20),
			ValueLists: []*sql.ExprList{{
				Lparen: pos(27),
				Exprs: []sql.Expr{
					&sql.NumberLit{ValuePos: pos(28), Value: "1"},
				},
				Rparen: pos(29),
			}},
			UpsertClauses: []*sql.UpsertClause{{
				On:         pos(31),
				OnConflict: pos(34),
				Lparen:     pos(43),
				Columns: []*sql.IndexedColumn{
					{X: &sql.Ident{NamePos: pos(44), Name: "y"}, Asc: pos(46)},
					{X: &sql.Ident{NamePos: pos(51), Name: "z"}, Desc: pos(53)},
				},
				Rparen:    pos(57),
				Do:        pos(59),
				DoNothing: pos(62),
			}},
		})
		AssertParseStatement(t, `INSERT INTO tbl (x) VALUES (1) RETURNING *`, &sql.InsertStatement{
			Insert:        pos(0),
			Into:          pos(7),
			Table:         &sql.Ident{NamePos: pos(12), Name: "tbl"},
			ColumnsLparen: pos(16),
			Columns: []*sql.Ident{
				{NamePos: pos(17), Name: "x"},
			},
			ColumnsRparen: pos(18),
			Values:        pos(20),
			ValueLists: []*sql.ExprList{{
				Lparen: pos(27),
				Exprs: []sql.Expr{
					&sql.NumberLit{ValuePos: pos(28), Value: "1"},
				},
				Rparen: pos(29),
			}},
			ReturningClause: &sql.ReturningClause{
				Returning: pos(31),
				Columns:   []*sql.ResultColumn{{Star: pos(41)}},
			},
		})
		AssertParseStatement(t, `INSERT INTO tbl (x) VALUES (1) RETURNING x`, &sql.InsertStatement{
			Insert:        pos(0),
			Into:          pos(7),
			Table:         &sql.Ident{NamePos: pos(12), Name: "tbl"},
			ColumnsLparen: pos(16),
			Columns: []*sql.Ident{
				{NamePos: pos(17), Name: "x"},
			},
			ColumnsRparen: pos(18),
			Values:        pos(20),
			ValueLists: []*sql.ExprList{{
				Lparen: pos(27),
				Exprs: []sql.Expr{
					&sql.NumberLit{ValuePos: pos(28), Value: "1"},
				},
				Rparen: pos(29),
			}},
			ReturningClause: &sql.ReturningClause{
				Returning: pos(31),
				Columns: []*sql.ResultColumn{
					{Expr: &sql.Ident{NamePos: pos(41), Name: "x"}},
				},
			},
		})
		AssertParseStatement(t, `INSERT INTO tbl (x) VALUES (1) RETURNING x AS y`, &sql.InsertStatement{
			Insert:        pos(0),
			Into:          pos(7),
			Table:         &sql.Ident{NamePos: pos(12), Name: "tbl"},
			ColumnsLparen: pos(16),
			Columns: []*sql.Ident{
				{NamePos: pos(17), Name: "x"},
			},
			ColumnsRparen: pos(18),
			Values:        pos(20),
			ValueLists: []*sql.ExprList{{
				Lparen: pos(27),
				Exprs: []sql.Expr{
					&sql.NumberLit{ValuePos: pos(28), Value: "1"},
				},
				Rparen: pos(29),
			}},
			ReturningClause: &sql.ReturningClause{
				Returning: pos(31),
				Columns: []*sql.ResultColumn{
					{Expr: &sql.Ident{NamePos: pos(41), Name: "x"}, As: pos(43), Alias: &sql.Ident{NamePos: pos(46), Name: "y"}},
				},
			},
		})
		AssertParseStatement(t, `INSERT INTO tbl (x) VALUES (1) RETURNING x,y`, &sql.InsertStatement{
			Insert:        pos(0),
			Into:          pos(7),
			Table:         &sql.Ident{NamePos: pos(12), Name: "tbl"},
			ColumnsLparen: pos(16),
			Columns: []*sql.Ident{
				{NamePos: pos(17), Name: "x"},
			},
			ColumnsRparen: pos(18),
			Values:        pos(20),
			ValueLists: []*sql.ExprList{{
				Lparen: pos(27),
				Exprs: []sql.Expr{
					&sql.NumberLit{ValuePos: pos(28), Value: "1"},
				},
				Rparen: pos(29),
			}},
			ReturningClause: &sql.ReturningClause{
				Returning: pos(31),
				Columns: []*sql.ResultColumn{
					{Expr: &sql.Ident{NamePos: pos(41), Name: "x"}},
					{Expr: &sql.Ident{NamePos: pos(43), Name: "y"}},
				},
			},
		})
		AssertParseStatement(t, `INSERT INTO tbl (x) VALUES (1) RETURNING x,y*2`, &sql.InsertStatement{
			Insert:        pos(0),
			Into:          pos(7),
			Table:         &sql.Ident{NamePos: pos(12), Name: "tbl"},
			ColumnsLparen: pos(16),
			Columns: []*sql.Ident{
				{NamePos: pos(17), Name: "x"},
			},
			ColumnsRparen: pos(18),
			Values:        pos(20),
			ValueLists: []*sql.ExprList{{
				Lparen: pos(27),
				Exprs: []sql.Expr{
					&sql.NumberLit{ValuePos: pos(28), Value: "1"},
				},
				Rparen: pos(29),
			}},
			ReturningClause: &sql.ReturningClause{
				Returning: pos(31),
				Columns: []*sql.ResultColumn{
					{Expr: &sql.Ident{NamePos: pos(41), Name: "x"}},
					{
						Expr: &sql.BinaryExpr{
							X:  &sql.Ident{Name: "y", NamePos: pos(43)},
							Op: sql.STAR, OpPos: pos(44),
							Y: &sql.NumberLit{Value: "2", ValuePos: pos(45)},
						},
					},
				},
			},
		})
		AssertParseStatement(t, `INSERT INTO tbl (x) VALUES (1) ON CONFLICT (y) WHERE true DO UPDATE SET foo = 1, (bar, baz) = 2 WHERE false`, &sql.InsertStatement{
			Insert:        pos(0),
			Into:          pos(7),
			Table:         &sql.Ident{NamePos: pos(12), Name: "tbl"},
			ColumnsLparen: pos(16),
			Columns: []*sql.Ident{
				{NamePos: pos(17), Name: "x"},
			},
			ColumnsRparen: pos(18),
			Values:        pos(20),
			ValueLists: []*sql.ExprList{{
				Lparen: pos(27),
				Exprs: []sql.Expr{
					&sql.NumberLit{ValuePos: pos(28), Value: "1"},
				},
				Rparen: pos(29),
			}},
			UpsertClauses: []*sql.UpsertClause{{
				On:         pos(31),
				OnConflict: pos(34),
				Lparen:     pos(43),
				Columns: []*sql.IndexedColumn{
					{X: &sql.Ident{NamePos: pos(44), Name: "y"}},
				},
				Rparen:      pos(45),
				Where:       pos(47),
				WhereExpr:   &sql.BoolLit{ValuePos: pos(53), Value: true},
				Do:          pos(58),
				DoUpdate:    pos(61),
				DoUpdateSet: pos(68),
				Assignments: []*sql.Assignment{
					{
						Columns: []*sql.Ident{
							{NamePos: pos(72), Name: "foo"},
						},
						Eq:   pos(76),
						Expr: &sql.NumberLit{ValuePos: pos(78), Value: "1"},
					},
					{
						Lparen: pos(81),
						Columns: []*sql.Ident{
							{NamePos: pos(82), Name: "bar"},
							{NamePos: pos(87), Name: "baz"},
						},
						Rparen: pos(90),
						Eq:     pos(92),
						Expr:   &sql.NumberLit{ValuePos: pos(94), Value: "2"},
					},
				},
				UpdateWhere:     pos(96),
				UpdateWhereExpr: &sql.BoolLit{ValuePos: pos(102), Value: false},
			}},
		})

		// Test schema-qualified table name
		AssertParseStatement(t, `INSERT INTO main.tableau VALUES (1, 2), (3, 4)`, &sql.InsertStatement{
			Insert: pos(0),
			Into:   pos(7),
			Schema: &sql.Ident{NamePos: pos(12), Name: "main"},
			Dot:    pos(16),
			Table:  &sql.Ident{NamePos: pos(17), Name: "tableau"},
			Values: pos(25),
			ValueLists: []*sql.ExprList{
				{
					Lparen: pos(32),
					Exprs: []sql.Expr{
						&sql.NumberLit{ValuePos: pos(33), Value: "1"},
						&sql.NumberLit{ValuePos: pos(36), Value: "2"},
					},
					Rparen: pos(37),
				},
				{
					Lparen: pos(40),
					Exprs: []sql.Expr{
						&sql.NumberLit{ValuePos: pos(41), Value: "3"},
						&sql.NumberLit{ValuePos: pos(44), Value: "4"},
					},
					Rparen: pos(45),
				},
			},
		})

		AssertParseStatementError(t, `INSERT`, `1:6: expected INTO, found 'EOF'`)
		AssertParseStatementError(t, `INSERT OR`, `1:9: expected ROLLBACK, REPLACE, ABORT, FAIL, or IGNORE, found 'EOF'`)
		AssertParseStatementError(t, `INSERT INTO`, `1:11: expected table name, found 'EOF'`)
		AssertParseStatementError(t, `INSERT INTO tbl AS`, `1:18: expected alias, found 'EOF'`)
		AssertParseStatementError(t, `INSERT INTO tbl `, `1:16: expected VALUES, SELECT, or DEFAULT VALUES, found 'EOF'`)
		AssertParseStatementError(t, `INSERT INTO tbl (`, `1:17: expected column name, found 'EOF'`)
		AssertParseStatementError(t, `INSERT INTO tbl (x`, `1:18: expected comma or right paren, found 'EOF'`)
		AssertParseStatementError(t, `INSERT INTO tbl (x)`, `1:19: expected VALUES, SELECT, or DEFAULT VALUES, found 'EOF'`)
		AssertParseStatementError(t, `INSERT INTO tbl (x) VALUES`, `1:26: expected left paren, found 'EOF'`)
		AssertParseStatementError(t, `INSERT INTO tbl (x) VALUES (`, `1:28: expected expression, found 'EOF'`)
		AssertParseStatementError(t, `INSERT INTO tbl (x) VALUES (1`, `1:29: expected comma or right paren, found 'EOF'`)
		AssertParseStatementError(t, `INSERT INTO tbl (x) SELECT`, `1:26: expected expression, found 'EOF'`)
		AssertParseStatementError(t, `INSERT INTO tbl (x) DEFAULT`, `1:27: expected VALUES, found 'EOF'`)
		AssertParseStatementError(t, `INSERT INTO tbl (x) VALUES (1) RETURNING`, `1:40: expected expression, found 'EOF'`)
		AssertParseStatementError(t, `INSERT INTO tbl (x) VALUES (1) ON`, `1:33: expected CONFLICT, found 'EOF'`)
		AssertParseStatementError(t, `INSERT INTO tbl (x) VALUES (1) ON CONFLICT (`, `1:44: expected expression, found 'EOF'`)
		AssertParseStatementError(t, `INSERT INTO tbl (x) VALUES (1) ON CONFLICT (x`, `1:45: expected comma or right paren, found 'EOF'`)
		AssertParseStatementError(t, `INSERT INTO tbl (x) VALUES (1) ON CONFLICT (x) WHERE`, `1:52: expected expression, found 'EOF'`)
		AssertParseStatementError(t, `INSERT INTO tbl (x) VALUES (1) ON CONFLICT (x)`, `1:46: expected DO, found 'EOF'`)
		AssertParseStatementError(t, `INSERT INTO tbl (x) VALUES (1) ON CONFLICT (x) DO`, `1:49: expected NOTHING or UPDATE SET, found 'EOF'`)
		AssertParseStatementError(t, `INSERT INTO tbl (x) VALUES (1) ON CONFLICT (x) DO UPDATE`, `1:56: expected SET, found 'EOF'`)
		AssertParseStatementError(t, `INSERT INTO tbl (x) VALUES (1) ON CONFLICT (x) DO UPDATE SET foo`, `1:64: expected =, found 'EOF'`)
		AssertParseStatementError(t, `INSERT INTO tbl (x) VALUES (1) ON CONFLICT (x) DO UPDATE SET foo =`, `1:66: expected expression, found 'EOF'`)
		AssertParseStatementError(t, `INSERT INTO tbl (x) VALUES (1) ON CONFLICT (x) DO UPDATE SET foo = 1 WHERE`, `1:74: expected expression, found 'EOF'`)
		AssertParseStatementError(t, `INSERT INTO tbl (x) VALUES (1) ON CONFLICT (x) DO UPDATE SET (`, `1:62: expected column name, found 'EOF'`)
		AssertParseStatementError(t, `INSERT INTO tbl (x) VALUES (1) ON CONFLICT (x) DO UPDATE SET (foo`, `1:65: expected comma or right paren, found 'EOF'`)
	})

	t.Run("Update", func(t *testing.T) {
		AssertParseStatement(t, `UPDATE tbl SET x = 1, y = 2`, &sql.UpdateStatement{
			Update: pos(0),
			Table: &sql.QualifiedTableName{
				Name: &sql.Ident{NamePos: pos(7), Name: "tbl"},
			},
			Set: pos(11),
			Assignments: []*sql.Assignment{
				{
					Columns: []*sql.Ident{{NamePos: pos(15), Name: "x"}},
					Eq:      pos(17),
					Expr:    &sql.NumberLit{ValuePos: pos(19), Value: "1"},
				},
				{
					Columns: []*sql.Ident{{NamePos: pos(22), Name: "y"}},
					Eq:      pos(24),
					Expr:    &sql.NumberLit{ValuePos: pos(26), Value: "2"},
				},
			},
		})
		AssertParseStatement(t, `UPDATE tbl SET x = 1 WHERE y = 2`, &sql.UpdateStatement{
			Update: pos(0),
			Table: &sql.QualifiedTableName{
				Name: &sql.Ident{NamePos: pos(7), Name: "tbl"},
			},
			Set: pos(11),
			Assignments: []*sql.Assignment{{
				Columns: []*sql.Ident{{NamePos: pos(15), Name: "x"}},
				Eq:      pos(17),
				Expr:    &sql.NumberLit{ValuePos: pos(19), Value: "1"},
			}},
			Where: pos(21),
			WhereExpr: &sql.BinaryExpr{
				X:     &sql.Ident{NamePos: pos(27), Name: "y"},
				OpPos: pos(29), Op: sql.EQ,
				Y: &sql.NumberLit{ValuePos: pos(31), Value: "2"},
			},
		})
		AssertParseStatement(t, `UPDATE OR ROLLBACK tbl SET x = 1`, &sql.UpdateStatement{
			Update:           pos(0),
			UpdateOr:         pos(7),
			UpdateOrRollback: pos(10),
			Table: &sql.QualifiedTableName{
				Name: &sql.Ident{NamePos: pos(19), Name: "tbl"},
			},
			Set: pos(23),
			Assignments: []*sql.Assignment{{
				Columns: []*sql.Ident{{NamePos: pos(27), Name: "x"}},
				Eq:      pos(29),
				Expr:    &sql.NumberLit{ValuePos: pos(31), Value: "1"},
			}},
		})
		AssertParseStatement(t, `UPDATE OR ABORT tbl SET x = 1`, &sql.UpdateStatement{
			Update:        pos(0),
			UpdateOr:      pos(7),
			UpdateOrAbort: pos(10),
			Table: &sql.QualifiedTableName{
				Name: &sql.Ident{NamePos: pos(16), Name: "tbl"},
			},
			Set: pos(20),
			Assignments: []*sql.Assignment{{
				Columns: []*sql.Ident{{NamePos: pos(24), Name: "x"}},
				Eq:      pos(26),
				Expr:    &sql.NumberLit{ValuePos: pos(28), Value: "1"},
			}},
		})
		AssertParseStatement(t, `UPDATE OR REPLACE tbl SET x = 1`, &sql.UpdateStatement{
			Update:          pos(0),
			UpdateOr:        pos(7),
			UpdateOrReplace: pos(10),
			Table: &sql.QualifiedTableName{
				Name: &sql.Ident{NamePos: pos(18), Name: "tbl"},
			},
			Set: pos(22),
			Assignments: []*sql.Assignment{{
				Columns: []*sql.Ident{{NamePos: pos(26), Name: "x"}},
				Eq:      pos(28),
				Expr:    &sql.NumberLit{ValuePos: pos(30), Value: "1"},
			}},
		})
		AssertParseStatement(t, `UPDATE OR FAIL tbl SET x = 1`, &sql.UpdateStatement{
			Update:       pos(0),
			UpdateOr:     pos(7),
			UpdateOrFail: pos(10),
			Table: &sql.QualifiedTableName{
				Name: &sql.Ident{NamePos: pos(15), Name: "tbl"},
			},
			Set: pos(19),
			Assignments: []*sql.Assignment{{
				Columns: []*sql.Ident{{NamePos: pos(23), Name: "x"}},
				Eq:      pos(25),
				Expr:    &sql.NumberLit{ValuePos: pos(27), Value: "1"},
			}},
		})
		AssertParseStatement(t, `UPDATE OR IGNORE tbl SET x = 1`, &sql.UpdateStatement{
			Update:         pos(0),
			UpdateOr:       pos(7),
			UpdateOrIgnore: pos(10),
			Table: &sql.QualifiedTableName{
				Name: &sql.Ident{NamePos: pos(17), Name: "tbl"},
			},
			Set: pos(21),
			Assignments: []*sql.Assignment{{
				Columns: []*sql.Ident{{NamePos: pos(25), Name: "x"}},
				Eq:      pos(27),
				Expr:    &sql.NumberLit{ValuePos: pos(29), Value: "1"},
			}},
		})
		AssertParseStatement(t, `WITH cte (x) AS (SELECT y) UPDATE tbl SET x = 1`, &sql.UpdateStatement{
			WithClause: &sql.WithClause{
				With: pos(0),
				CTEs: []*sql.CTE{
					{
						TableName:     &sql.Ident{NamePos: pos(5), Name: "cte"},
						ColumnsLparen: pos(9),
						Columns: []*sql.Ident{
							{NamePos: pos(10), Name: "x"},
						},
						ColumnsRparen: pos(11),
						As:            pos(13),
						SelectLparen:  pos(16),
						Select: &sql.SelectStatement{
							Select: pos(17),
							Columns: []*sql.ResultColumn{
								{Expr: &sql.Ident{NamePos: pos(24), Name: "y"}},
							},
						},
						SelectRparen: pos(25),
					},
				},
			},
			Update: pos(27),
			Table: &sql.QualifiedTableName{
				Name: &sql.Ident{NamePos: pos(34), Name: "tbl"},
			},
			Set: pos(38),
			Assignments: []*sql.Assignment{{
				Columns: []*sql.Ident{{NamePos: pos(42), Name: "x"}},
				Eq:      pos(44),
				Expr:    &sql.NumberLit{ValuePos: pos(46), Value: "1"},
			}},
		})

		// Test schema-qualified table name
		AssertParseStatement(t, `UPDATE main.tableau SET n2=n1`, &sql.UpdateStatement{
			Update: pos(0),
			Table: &sql.QualifiedTableName{
				Schema: &sql.Ident{NamePos: pos(7), Name: "main"},
				Dot:    pos(11),
				Name:   &sql.Ident{NamePos: pos(12), Name: "tableau"},
			},
			Set: pos(20),
			Assignments: []*sql.Assignment{{
				Columns: []*sql.Ident{{NamePos: pos(24), Name: "n2"}},
				Eq:      pos(26),
				Expr:    &sql.Ident{NamePos: pos(27), Name: "n1"},
			}},
		})

		// Test table alias with AS keyword
		AssertParseStatement(t, `UPDATE vals AS v SET a=upper(v.a)`, &sql.UpdateStatement{
			Update: pos(0),
			Table: &sql.QualifiedTableName{
				Name:  &sql.Ident{NamePos: pos(7), Name: "vals"},
				As:    pos(12),
				Alias: &sql.Ident{NamePos: pos(15), Name: "v"},
			},
			Set: pos(17),
			Assignments: []*sql.Assignment{{
				Columns: []*sql.Ident{{NamePos: pos(21), Name: "a"}},
				Eq:      pos(22),
				Expr: &sql.Call{
					Name:   &sql.Ident{NamePos: pos(23), Name: "upper"},
					Lparen: pos(28),
					Args: []sql.Expr{
						&sql.QualifiedRef{
							Table:  &sql.Ident{NamePos: pos(29), Name: "v"},
							Dot:    pos(30),
							Column: &sql.Ident{NamePos: pos(31), Name: "a"},
						},
					},
					Rparen: pos(32),
				},
			}},
		})

		// Test schema.table.column in expressions
		AssertParseStatement(t, `UPDATE main.vals SET a=lower(main.vals.a)`, &sql.UpdateStatement{
			Update: pos(0),
			Table: &sql.QualifiedTableName{
				Schema: &sql.Ident{NamePos: pos(7), Name: "main"},
				Dot:    pos(11),
				Name:   &sql.Ident{NamePos: pos(12), Name: "vals"},
			},
			Set: pos(17),
			Assignments: []*sql.Assignment{{
				Columns: []*sql.Ident{{NamePos: pos(21), Name: "a"}},
				Eq:      pos(22),
				Expr: &sql.Call{
					Name:   &sql.Ident{NamePos: pos(23), Name: "lower"},
					Lparen: pos(28),
					Args: []sql.Expr{
						&sql.QualifiedRef{
							Schema:    &sql.Ident{NamePos: pos(29), Name: "main"},
							SchemaPos: pos(33),
							Table:     &sql.Ident{NamePos: pos(34), Name: "vals"},
							Dot:       pos(38),
							Column:    &sql.Ident{NamePos: pos(39), Name: "a"},
						},
					},
					Rparen: pos(40),
				},
			}},
		})

		// Test table alias without AS keyword
		AssertParseStatement(t, `UPDATE vals v SET a=1`, &sql.UpdateStatement{
			Update: pos(0),
			Table: &sql.QualifiedTableName{
				Name:  &sql.Ident{NamePos: pos(7), Name: "vals"},
				Alias: &sql.Ident{NamePos: pos(12), Name: "v"},
			},
			Set: pos(14),
			Assignments: []*sql.Assignment{{
				Columns: []*sql.Ident{{NamePos: pos(18), Name: "a"}},
				Eq:      pos(19),
				Expr:    &sql.NumberLit{ValuePos: pos(20), Value: "1"},
			}},
		})

		// Test INDEXED BY clause
		AssertParseStatement(t, `UPDATE tbl INDEXED BY idx SET x=1`, &sql.UpdateStatement{
			Update: pos(0),
			Table: &sql.QualifiedTableName{
				Name:      &sql.Ident{NamePos: pos(7), Name: "tbl"},
				Indexed:   pos(11),
				IndexedBy: pos(19),
				Index:     &sql.Ident{NamePos: pos(22), Name: "idx"},
			},
			Set: pos(26),
			Assignments: []*sql.Assignment{{
				Columns: []*sql.Ident{{NamePos: pos(30), Name: "x"}},
				Eq:      pos(31),
				Expr:    &sql.NumberLit{ValuePos: pos(32), Value: "1"},
			}},
		})

		// Test NOT INDEXED clause
		AssertParseStatement(t, `UPDATE tbl NOT INDEXED SET x=1`, &sql.UpdateStatement{
			Update: pos(0),
			Table: &sql.QualifiedTableName{
				Name:       &sql.Ident{NamePos: pos(7), Name: "tbl"},
				Not:        pos(11),
				NotIndexed: pos(15),
			},
			Set: pos(23),
			Assignments: []*sql.Assignment{{
				Columns: []*sql.Ident{{NamePos: pos(27), Name: "x"}},
				Eq:      pos(28),
				Expr:    &sql.NumberLit{ValuePos: pos(29), Value: "1"},
			}},
		})

		// Test UPDATE FROM with simple table
		AssertParseStatement(t, `UPDATE t SET a=v.b FROM v`, &sql.UpdateStatement{
			Update: pos(0),
			Table: &sql.QualifiedTableName{
				Name: &sql.Ident{NamePos: pos(7), Name: "t"},
			},
			Set: pos(9),
			Assignments: []*sql.Assignment{{
				Columns: []*sql.Ident{{NamePos: pos(13), Name: "a"}},
				Eq:      pos(14),
				Expr: &sql.QualifiedRef{
					Table:  &sql.Ident{NamePos: pos(15), Name: "v"},
					Dot:    pos(16),
					Column: &sql.Ident{NamePos: pos(17), Name: "b"},
				},
			}},
			From: pos(19),
			Source: &sql.QualifiedTableName{
				Name: &sql.Ident{NamePos: pos(24), Name: "v"},
			},
		})

		// Test UPDATE FROM with subquery
		AssertParseStatement(t, `UPDATE t SET a=v.b FROM (SELECT b FROM v) AS v`, &sql.UpdateStatement{
			Update: pos(0),
			Table: &sql.QualifiedTableName{
				Name: &sql.Ident{NamePos: pos(7), Name: "t"},
			},
			Set: pos(9),
			Assignments: []*sql.Assignment{{
				Columns: []*sql.Ident{{NamePos: pos(13), Name: "a"}},
				Eq:      pos(14),
				Expr: &sql.QualifiedRef{
					Table:  &sql.Ident{NamePos: pos(15), Name: "v"},
					Dot:    pos(16),
					Column: &sql.Ident{NamePos: pos(17), Name: "b"},
				},
			}},
			From: pos(19),
			Source: &sql.ParenSource{
				Lparen: pos(24),
				X: &sql.SelectStatement{
					Select: pos(25),
					Columns: []*sql.ResultColumn{
						{Expr: &sql.Ident{NamePos: pos(32), Name: "b"}},
					},
					From: pos(34),
					Source: &sql.QualifiedTableName{
						Name: &sql.Ident{NamePos: pos(39), Name: "v"},
					},
				},
				Rparen: pos(40),
				As:     pos(42),
				Alias:  &sql.Ident{NamePos: pos(45), Name: "v"},
			},
		})

		// Test UPDATE FROM with WHERE clause
		AssertParseStatement(t, `UPDATE t SET a=v.b FROM v WHERE t.id = v.id`, &sql.UpdateStatement{
			Update: pos(0),
			Table: &sql.QualifiedTableName{
				Name: &sql.Ident{NamePos: pos(7), Name: "t"},
			},
			Set: pos(9),
			Assignments: []*sql.Assignment{{
				Columns: []*sql.Ident{{NamePos: pos(13), Name: "a"}},
				Eq:      pos(14),
				Expr: &sql.QualifiedRef{
					Table:  &sql.Ident{NamePos: pos(15), Name: "v"},
					Dot:    pos(16),
					Column: &sql.Ident{NamePos: pos(17), Name: "b"},
				},
			}},
			From: pos(19),
			Source: &sql.QualifiedTableName{
				Name: &sql.Ident{NamePos: pos(24), Name: "v"},
			},
			Where: pos(26),
			WhereExpr: &sql.BinaryExpr{
				X: &sql.QualifiedRef{
					Table:  &sql.Ident{NamePos: pos(32), Name: "t"},
					Dot:    pos(33),
					Column: &sql.Ident{NamePos: pos(34), Name: "id"},
				},
				OpPos: pos(37),
				Op:    sql.EQ,
				Y: &sql.QualifiedRef{
					Table:  &sql.Ident{NamePos: pos(39), Name: "v"},
					Dot:    pos(40),
					Column: &sql.Ident{NamePos: pos(41), Name: "id"},
				},
			},
		})

		// Test UPDATE FROM with JOIN
		AssertParseStatement(t, `UPDATE t SET a=v.b FROM v JOIN w ON v.id = w.id`, &sql.UpdateStatement{
			Update: pos(0),
			Table: &sql.QualifiedTableName{
				Name: &sql.Ident{NamePos: pos(7), Name: "t"},
			},
			Set: pos(9),
			Assignments: []*sql.Assignment{{
				Columns: []*sql.Ident{{NamePos: pos(13), Name: "a"}},
				Eq:      pos(14),
				Expr: &sql.QualifiedRef{
					Table:  &sql.Ident{NamePos: pos(15), Name: "v"},
					Dot:    pos(16),
					Column: &sql.Ident{NamePos: pos(17), Name: "b"},
				},
			}},
			From: pos(19),
			Source: &sql.JoinClause{
				X: &sql.QualifiedTableName{
					Name: &sql.Ident{NamePos: pos(24), Name: "v"},
				},
				Operator: &sql.JoinOperator{
					Join: pos(26),
				},
				Y: &sql.QualifiedTableName{
					Name: &sql.Ident{NamePos: pos(31), Name: "w"},
				},
				Constraint: &sql.OnConstraint{
					On: pos(33),
					X: &sql.BinaryExpr{
						X: &sql.QualifiedRef{
							Table:  &sql.Ident{NamePos: pos(36), Name: "v"},
							Dot:    pos(37),
							Column: &sql.Ident{NamePos: pos(38), Name: "id"},
						},
						OpPos: pos(41),
						Op:    sql.EQ,
						Y: &sql.QualifiedRef{
							Table:  &sql.Ident{NamePos: pos(43), Name: "w"},
							Dot:    pos(44),
							Column: &sql.Ident{NamePos: pos(45), Name: "id"},
						},
					},
				},
			},
		})

		AssertParseStatementError(t, `UPDATE`, `1:6: expected table name, found 'EOF'`)
		AssertParseStatementError(t, `UPDATE OR`, `1:9: expected ROLLBACK, REPLACE, ABORT, FAIL, or IGNORE, found 'EOF'`)
		AssertParseStatementError(t, `UPDATE tbl`, `1:10: expected SET, found 'EOF'`)
		AssertParseStatementError(t, `UPDATE tbl SET`, `1:14: expected column name or column list, found 'EOF'`)
		AssertParseStatementError(t, `UPDATE tbl SET x = `, `1:19: expected expression, found 'EOF'`)
		AssertParseStatementError(t, `UPDATE tbl SET x = 1 WHERE`, `1:26: expected expression, found 'EOF'`)
		AssertParseStatementError(t, `UPDATE tbl SET x = 1 WHERE y =`, `1:30: expected expression, found 'EOF'`)
	})

	t.Run("Delete", func(t *testing.T) {
		AssertParseStatement(t, `DELETE FROM tbl`, &sql.DeleteStatement{
			Delete: pos(0),
			From:   pos(7),
			Table: &sql.QualifiedTableName{
				Name: &sql.Ident{NamePos: pos(12), Name: "tbl"},
			},
		})
		AssertParseStatement(t, `DELETE FROM tbl WHERE x = 1`, &sql.DeleteStatement{
			Delete: pos(0),
			From:   pos(7),
			Table: &sql.QualifiedTableName{
				Name: &sql.Ident{NamePos: pos(12), Name: "tbl"},
			},
			Where: pos(16),
			WhereExpr: &sql.BinaryExpr{
				X:     &sql.Ident{NamePos: pos(22), Name: "x"},
				OpPos: pos(24), Op: sql.EQ,
				Y: &sql.NumberLit{ValuePos: pos(26), Value: "1"},
			},
		})
		AssertParseStatement(t, `DELETE FROM tbl WHERE x = 1 RETURNING x`, &sql.DeleteStatement{
			Delete: pos(0),
			From:   pos(7),
			Table: &sql.QualifiedTableName{
				Name: &sql.Ident{NamePos: pos(12), Name: "tbl"},
			},
			Where: pos(16),
			WhereExpr: &sql.BinaryExpr{
				X:     &sql.Ident{NamePos: pos(22), Name: "x"},
				OpPos: pos(24), Op: sql.EQ,
				Y: &sql.NumberLit{ValuePos: pos(26), Value: "1"},
			},
			ReturningClause: &sql.ReturningClause{
				Returning: pos(28),
				Columns:   []*sql.ResultColumn{{Expr: &sql.Ident{NamePos: pos(38), Name: "x"}}},
			},
		})
		AssertParseStatement(t, `WITH cte (x) AS (SELECT y) DELETE FROM tbl`, &sql.DeleteStatement{
			WithClause: &sql.WithClause{
				With: pos(0),
				CTEs: []*sql.CTE{
					{
						TableName:     &sql.Ident{NamePos: pos(5), Name: "cte"},
						ColumnsLparen: pos(9),
						Columns: []*sql.Ident{
							{NamePos: pos(10), Name: "x"},
						},
						ColumnsRparen: pos(11),
						As:            pos(13),
						SelectLparen:  pos(16),
						Select: &sql.SelectStatement{
							Select: pos(17),
							Columns: []*sql.ResultColumn{
								{Expr: &sql.Ident{NamePos: pos(24), Name: "y"}},
							},
						},
						SelectRparen: pos(25),
					},
				},
			},
			Delete: pos(27),
			From:   pos(34),
			Table: &sql.QualifiedTableName{
				Name: &sql.Ident{NamePos: pos(39), Name: "tbl"},
			},
		})
		AssertParseStatement(t, `DELETE FROM tbl ORDER BY x, y LIMIT 1 OFFSET 2`, &sql.DeleteStatement{
			Delete: pos(0),
			From:   pos(7),
			Table: &sql.QualifiedTableName{
				Name: &sql.Ident{NamePos: pos(12), Name: "tbl"},
			},
			Order:   pos(16),
			OrderBy: pos(22),
			OrderingTerms: []*sql.OrderingTerm{
				{X: &sql.Ident{NamePos: pos(25), Name: "x"}},
				{X: &sql.Ident{NamePos: pos(28), Name: "y"}},
			},
			Limit:      pos(30),
			LimitExpr:  &sql.NumberLit{ValuePos: pos(36), Value: "1"},
			Offset:     pos(38),
			OffsetExpr: &sql.NumberLit{ValuePos: pos(45), Value: "2"},
		})
		AssertParseStatement(t, `DELETE FROM tbl LIMIT 1`, &sql.DeleteStatement{
			Delete: pos(0),
			From:   pos(7),
			Table: &sql.QualifiedTableName{
				Name: &sql.Ident{NamePos: pos(12), Name: "tbl"},
			},
			Limit:     pos(16),
			LimitExpr: &sql.NumberLit{ValuePos: pos(22), Value: "1"},
		})
		AssertParseStatement(t, `DELETE FROM tbl LIMIT 1, 2`, &sql.DeleteStatement{
			Delete: pos(0),
			From:   pos(7),
			Table: &sql.QualifiedTableName{
				Name: &sql.Ident{NamePos: pos(12), Name: "tbl"},
			},
			Limit:       pos(16),
			LimitExpr:   &sql.NumberLit{ValuePos: pos(22), Value: "1"},
			OffsetComma: pos(23),
			OffsetExpr:  &sql.NumberLit{ValuePos: pos(25), Value: "2"},
		})

		AssertParseStatement(t, `DELETE FROM tbl1 WHERE id IN (SELECT tbl1_id FROM tbl2 WHERE foo = 'bar')`, &sql.DeleteStatement{
			Delete: pos(0),
			From:   pos(7),
			Table: &sql.QualifiedTableName{
				Name: &sql.Ident{NamePos: pos(12), Name: "tbl1"},
			},
			Where: pos(17),
			WhereExpr: &sql.BinaryExpr{
				X:     &sql.Ident{NamePos: pos(23), Name: "id"},
				OpPos: pos(26),
				Op:    sql.IN,
				Y: &sql.ExprList{
					Lparen: pos(29),
					Exprs: []sql.Expr{sql.SelectExpr{
						SelectStatement: &sql.SelectStatement{
							Select: pos(30),
							Columns: []*sql.ResultColumn{
								{
									Expr: &sql.Ident{NamePos: pos(37), Name: "tbl1_id"},
								},
							},
							From: pos(45),
							Source: &sql.QualifiedTableName{
								Name: &sql.Ident{NamePos: pos(50), Name: "tbl2"},
							},
							Where: pos(55),
							WhereExpr: &sql.BinaryExpr{
								X:     &sql.Ident{NamePos: pos(61), Name: "foo"},
								OpPos: pos(65),
								Op:    sql.EQ,
								Y:     &sql.StringLit{ValuePos: pos(67), Value: "bar"},
							},
						},
					}},
					Rparen: pos(72),
				},
			},
		})

		AssertParseStatementError(t, `DELETE`, `1:6: expected FROM, found 'EOF'`)
		AssertParseStatementError(t, `DELETE FROM`, `1:11: expected table name, found 'EOF'`)
		AssertParseStatementError(t, `DELETE FROM tbl WHERE`, `1:21: expected expression, found 'EOF'`)
		AssertParseStatementError(t, `DELETE FROM tbl ORDER `, `1:22: expected BY, found 'EOF'`)
		AssertParseStatementError(t, `DELETE FROM tbl ORDER BY`, `1:24: expected expression, found 'EOF'`)
		AssertParseStatementError(t, `DELETE FROM tbl ORDER BY x`, `1:26: expected LIMIT, found 'EOF'`)
		AssertParseStatementError(t, `DELETE FROM tbl LIMIT`, `1:21: expected expression, found 'EOF'`)
		AssertParseStatementError(t, `DELETE FROM tbl LIMIT 1,`, `1:24: expected expression, found 'EOF'`)
		AssertParseStatementError(t, `DELETE FROM tbl LIMIT 1 OFFSET`, `1:30: expected expression, found 'EOF'`)
	})

	t.Run("AlterTable", func(t *testing.T) {
		AssertParseStatement(t, `ALTER TABLE tbl RENAME TO new_tbl`, &sql.AlterTableStatement{
			Alter:    pos(0),
			Table:    pos(6),
			Name:     &sql.Ident{NamePos: pos(12), Name: "tbl"},
			Rename:   pos(16),
			RenameTo: pos(23),
			NewName:  &sql.Ident{NamePos: pos(26), Name: "new_tbl"},
		})
		AssertParseStatement(t, `ALTER TABLE tbl RENAME COLUMN col TO new_col`, &sql.AlterTableStatement{
			Alter:         pos(0),
			Table:         pos(6),
			Name:          &sql.Ident{NamePos: pos(12), Name: "tbl"},
			Rename:        pos(16),
			RenameColumn:  pos(23),
			ColumnName:    &sql.Ident{NamePos: pos(30), Name: "col"},
			To:            pos(34),
			NewColumnName: &sql.Ident{NamePos: pos(37), Name: "new_col"},
		})
		AssertParseStatement(t, `ALTER TABLE tbl RENAME col TO new_col`, &sql.AlterTableStatement{
			Alter:         pos(0),
			Table:         pos(6),
			Name:          &sql.Ident{NamePos: pos(12), Name: "tbl"},
			Rename:        pos(16),
			ColumnName:    &sql.Ident{NamePos: pos(23), Name: "col"},
			To:            pos(27),
			NewColumnName: &sql.Ident{NamePos: pos(30), Name: "new_col"},
		})
		AssertParseStatement(t, `ALTER TABLE tbl ADD COLUMN col TEXT PRIMARY KEY`, &sql.AlterTableStatement{
			Alter:     pos(0),
			Table:     pos(6),
			Name:      &sql.Ident{NamePos: pos(12), Name: "tbl"},
			Add:       pos(16),
			AddColumn: pos(20),
			ColumnDef: &sql.ColumnDefinition{
				Name: &sql.Ident{Name: "col", NamePos: pos(27)},
				Type: &sql.Type{
					Name: &sql.Ident{Name: "TEXT", NamePos: pos(31)},
				},
				Constraints: []sql.Constraint{
					&sql.PrimaryKeyConstraint{
						Primary: pos(36),
						Key:     pos(44),
					},
				},
			},
		})
		AssertParseStatement(t, `ALTER TABLE tbl ADD col TEXT`, &sql.AlterTableStatement{
			Alter: pos(0),
			Table: pos(6),
			Name:  &sql.Ident{NamePos: pos(12), Name: "tbl"},
			Add:   pos(16),
			ColumnDef: &sql.ColumnDefinition{
				Name: &sql.Ident{Name: "col", NamePos: pos(20)},
				Type: &sql.Type{
					Name: &sql.Ident{Name: "TEXT", NamePos: pos(24)},
				},
			},
		})
		AssertParseStatement(t, `ALTER TABLE tbl DROP COLUMN col`, &sql.AlterTableStatement{
			Alter:          pos(0),
			Table:          pos(6),
			Name:           &sql.Ident{NamePos: pos(12), Name: "tbl"},
			Drop:           pos(16),
			DropColumn:     pos(21),
			DropColumnName: &sql.Ident{NamePos: pos(28), Name: "col"},
		})

		AssertParseStatementError(t, `ALTER`, `1:5: expected TABLE, found 'EOF'`)
		AssertParseStatementError(t, `ALTER TABLE`, `1:11: expected table name, found 'EOF'`)
		AssertParseStatementError(t, `ALTER TABLE tbl`, `1:15: expected ADD, RENAME or DROP, found 'EOF'`)
		AssertParseStatementError(t, `ALTER TABLE tbl RENAME`, `1:22: expected COLUMN keyword or column name, found 'EOF'`)
		AssertParseStatementError(t, `ALTER TABLE tbl RENAME TO`, `1:25: expected new table name, found 'EOF'`)
		AssertParseStatementError(t, `ALTER TABLE tbl RENAME COLUMN`, `1:29: expected column name, found 'EOF'`)
		AssertParseStatementError(t, `ALTER TABLE tbl RENAME COLUMN col`, `1:33: expected TO, found 'EOF'`)
		AssertParseStatementError(t, `ALTER TABLE tbl RENAME COLUMN col TO`, `1:36: expected new column name, found 'EOF'`)
		AssertParseStatementError(t, `ALTER TABLE tbl ADD`, `1:19: expected COLUMN keyword or column name, found 'EOF'`)
		AssertParseStatementError(t, `ALTER TABLE tbl ADD COLUMN`, `1:26: expected column name, found 'EOF'`)
		AssertParseStatementError(t, `ALTER TABLE tbl DROP`, `1:20: expected COLUMN keyword or column name, found 'EOF'`)
	})

	t.Run("Analyze", func(t *testing.T) {
		AssertParseStatement(t, `ANALYZE`, &sql.AnalyzeStatement{
			Analyze: pos(0),
		})
		AssertParseStatement(t, `ANALYZE tbl`, &sql.AnalyzeStatement{
			Analyze: pos(0),
			Name:    &sql.Ident{NamePos: pos(8), Name: "tbl"},
		})
	})
	t.Run("Reindex", func(t *testing.T) {
		AssertParseStatement(t, `REINDEX`, &sql.ReindexStatement{
			Reindex: pos(0),
		})
		AssertParseStatement(t, `REINDEX tbl`, &sql.ReindexStatement{
			Reindex: pos(0),
			Name:    &sql.Ident{NamePos: pos(8), Name: "tbl"},
		})
		AssertParseStatement(t, `REINDEX schema.tbl`, &sql.ReindexStatement{
			Reindex: pos(0),
			Name: &sql.QualifiedRef{
				Table:  &sql.Ident{NamePos: pos(8), Name: "schema"},
				Dot:    pos(14),
				Column: &sql.Ident{NamePos: pos(15), Name: "tbl"},
			},
		})
	})

	// Keywords like DESC, ASC, KEY, etc. should be usable as identifiers in expressions
	t.Run("KeywordAsColumnName", func(t *testing.T) {
		// Test SELECT with 'desc' column name (keyword used as identifier)
		AssertParseStatement(t, `SELECT desc FROM t`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{Expr: &sql.Ident{NamePos: pos(7), Name: "desc"}},
			},
			From: pos(12),
			Source: &sql.QualifiedTableName{
				Name: &sql.Ident{NamePos: pos(17), Name: "t"},
			},
		})

		// Test SELECT with 'desc' column name and ORDER BY desc DESC, which
		// uses the 'desc' keyword both as an identifier and as a keyword.
		AssertParseStatement(t, `SELECT desc FROM t ORDER BY desc DESC`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{Expr: &sql.Ident{NamePos: pos(7), Name: "desc"}},
			},
			From: pos(12),
			Source: &sql.QualifiedTableName{
				Name: &sql.Ident{NamePos: pos(17), Name: "t"},
			},
			Order:   pos(19),
			OrderBy: pos(25),
			OrderingTerms: []*sql.OrderingTerm{
				{
					X:    &sql.Ident{NamePos: pos(28), Name: "desc"},
					Desc: pos(33),
				},
			},
		})

		// Test UPDATE with RETURNING desc
		AssertParseStatement(t, `UPDATE t SET desc = 'd1' RETURNING desc`, &sql.UpdateStatement{
			Update: pos(0),
			Table: &sql.QualifiedTableName{
				Name: &sql.Ident{NamePos: pos(7), Name: "t"},
			},
			Set: pos(9),
			Assignments: []*sql.Assignment{{
				Columns: []*sql.Ident{{NamePos: pos(13), Name: "desc"}},
				Eq:      pos(18),
				Expr:    &sql.StringLit{ValuePos: pos(20), Value: "d1"},
			}},
			ReturningClause: &sql.ReturningClause{
				Returning: pos(25),
				Columns:   []*sql.ResultColumn{{Expr: &sql.Ident{NamePos: pos(35), Name: "desc"}}},
			},
		})

		// Test DELETE with RETURNING desc
		AssertParseStatement(t, `DELETE FROM t WHERE desc = 'd1' RETURNING desc`, &sql.DeleteStatement{
			Delete: pos(0),
			From:   pos(7),
			Table: &sql.QualifiedTableName{
				Name: &sql.Ident{NamePos: pos(12), Name: "t"},
			},
			Where: pos(14),
			WhereExpr: &sql.BinaryExpr{
				X:     &sql.Ident{NamePos: pos(20), Name: "desc"},
				OpPos: pos(25), Op: sql.EQ,
				Y: &sql.StringLit{ValuePos: pos(27), Value: "d1"},
			},
			ReturningClause: &sql.ReturningClause{
				Returning: pos(32),
				Columns:   []*sql.ResultColumn{{Expr: &sql.Ident{NamePos: pos(42), Name: "desc"}}},
			},
		})

		// Test INSERT with RETURNING desc
		AssertParseStatement(t, `INSERT INTO t (desc) VALUES ('d1') RETURNING desc`, &sql.InsertStatement{
			Insert:        pos(0),
			Into:          pos(7),
			Table:         &sql.Ident{NamePos: pos(12), Name: "t"},
			ColumnsLparen: pos(14),
			Columns: []*sql.Ident{
				{NamePos: pos(15), Name: "desc"},
			},
			ColumnsRparen: pos(19),
			Values:        pos(21),
			ValueLists: []*sql.ExprList{
				{
					Lparen: pos(28),
					Exprs:  []sql.Expr{&sql.StringLit{ValuePos: pos(29), Value: "d1"}},
					Rparen: pos(33),
				},
			},
			ReturningClause: &sql.ReturningClause{
				Returning: pos(35),
				Columns:   []*sql.ResultColumn{{Expr: &sql.Ident{NamePos: pos(45), Name: "desc"}}},
			},
		})

		// Test with 'key' keyword as column name
		AssertParseStatement(t, `SELECT key FROM t`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{Expr: &sql.Ident{NamePos: pos(7), Name: "key"}},
			},
			From: pos(11),
			Source: &sql.QualifiedTableName{
				Name: &sql.Ident{NamePos: pos(16), Name: "t"},
			},
		})

		// Test with 'asc' keyword as column name
		AssertParseStatement(t, `SELECT asc FROM t`, &sql.SelectStatement{
			Select: pos(0),
			Columns: []*sql.ResultColumn{
				{Expr: &sql.Ident{NamePos: pos(7), Name: "asc"}},
			},
			From: pos(11),
			Source: &sql.QualifiedTableName{
				Name: &sql.Ident{NamePos: pos(16), Name: "t"},
			},
		})
	})

	// Tests for schema-qualified names
	t.Run("AlterTableWithSchema", func(t *testing.T) {
		AssertParseStatement(t, `ALTER TABLE main.t DROP COLUMN a`, &sql.AlterTableStatement{
			Alter:          pos(0),
			Table:          pos(6),
			Schema:         &sql.Ident{NamePos: pos(12), Name: "main"},
			Dot:            pos(16),
			Name:           &sql.Ident{NamePos: pos(17), Name: "t"},
			Drop:           pos(19),
			DropColumn:     pos(24),
			DropColumnName: &sql.Ident{NamePos: pos(31), Name: "a"},
		})
		AssertParseStatement(t, `ALTER TABLE schema.tbl RENAME TO new_tbl`, &sql.AlterTableStatement{
			Alter:    pos(0),
			Table:    pos(6),
			Schema:   &sql.Ident{NamePos: pos(12), Name: "schema"},
			Dot:      pos(18),
			Name:     &sql.Ident{NamePos: pos(19), Name: "tbl"},
			Rename:   pos(23),
			RenameTo: pos(30),
			NewName:  &sql.Ident{NamePos: pos(33), Name: "new_tbl"},
		})
		AssertParseStatement(t, `ALTER TABLE main.tbl ADD COLUMN col TEXT`, &sql.AlterTableStatement{
			Alter:     pos(0),
			Table:     pos(6),
			Schema:    &sql.Ident{NamePos: pos(12), Name: "main"},
			Dot:       pos(16),
			Name:      &sql.Ident{NamePos: pos(17), Name: "tbl"},
			Add:       pos(21),
			AddColumn: pos(25),
			ColumnDef: &sql.ColumnDefinition{
				Name: &sql.Ident{Name: "col", NamePos: pos(32)},
				Type: &sql.Type{
					Name: &sql.Ident{Name: "TEXT", NamePos: pos(36)},
				},
			},
		})
	})

	t.Run("CreateIndexWithSchema", func(t *testing.T) {
		AssertParseStatement(t, `CREATE INDEX main.idx ON vals (A)`, &sql.CreateIndexStatement{
			Create: pos(0),
			Index:  pos(7),
			Schema: &sql.Ident{NamePos: pos(13), Name: "main"},
			Dot:    pos(17),
			Name:   &sql.Ident{NamePos: pos(18), Name: "idx"},
			On:     pos(22),
			Table:  &sql.Ident{NamePos: pos(25), Name: "vals"},
			Lparen: pos(30),
			Columns: []*sql.IndexedColumn{
				{X: &sql.Ident{NamePos: pos(31), Name: "A"}},
			},
			Rparen: pos(32),
		})
		AssertParseStatement(t, `CREATE UNIQUE INDEX schema.idx ON tbl (x)`, &sql.CreateIndexStatement{
			Create: pos(0),
			Unique: pos(7),
			Index:  pos(14),
			Schema: &sql.Ident{NamePos: pos(20), Name: "schema"},
			Dot:    pos(26),
			Name:   &sql.Ident{NamePos: pos(27), Name: "idx"},
			On:     pos(31),
			Table:  &sql.Ident{NamePos: pos(34), Name: "tbl"},
			Lparen: pos(38),
			Columns: []*sql.IndexedColumn{
				{X: &sql.Ident{NamePos: pos(39), Name: "x"}},
			},
			Rparen: pos(40),
		})
	})

	t.Run("DropIndexWithSchema", func(t *testing.T) {
		AssertParseStatement(t, `DROP INDEX main.idx`, &sql.DropIndexStatement{
			Drop:   pos(0),
			Index:  pos(5),
			Schema: &sql.Ident{NamePos: pos(11), Name: "main"},
			Dot:    pos(15),
			Name:   &sql.Ident{NamePos: pos(16), Name: "idx"},
		})
		AssertParseStatement(t, `DROP INDEX IF EXISTS schema.idx`, &sql.DropIndexStatement{
			Drop:     pos(0),
			Index:    pos(5),
			If:       pos(11),
			IfExists: pos(14),
			Schema:   &sql.Ident{NamePos: pos(21), Name: "schema"},
			Dot:      pos(27),
			Name:     &sql.Ident{NamePos: pos(28), Name: "idx"},
		})
	})

	t.Run("DropTableWithSchema", func(t *testing.T) {
		AssertParseStatement(t, `DROP TABLE main.vals`, &sql.DropTableStatement{
			Drop:   pos(0),
			Table:  pos(5),
			Schema: &sql.Ident{NamePos: pos(11), Name: "main"},
			Dot:    pos(15),
			Name:   &sql.Ident{NamePos: pos(16), Name: "vals"},
		})
		AssertParseStatement(t, `DROP TABLE IF EXISTS schema.tbl`, &sql.DropTableStatement{
			Drop:     pos(0),
			Table:    pos(5),
			If:       pos(11),
			IfExists: pos(14),
			Schema:   &sql.Ident{NamePos: pos(21), Name: "schema"},
			Dot:      pos(27),
			Name:     &sql.Ident{NamePos: pos(28), Name: "tbl"},
		})
	})
}

func TestParser_ParseStatements(t *testing.T) {
	t.Run("EmptyInput", func(t *testing.T) {
		AssertParseStatements(t, ``, 0)
	})

	t.Run("SingleStatement", func(t *testing.T) {
		AssertParseStatements(t, `SELECT * FROM foo`, 1)
	})

	t.Run("MultipleStatementsWithSemicolons", func(t *testing.T) {
		AssertParseStatements(t, `SELECT * FROM foo; SELECT * FROM bar;`, 2)
	})

	t.Run("ThreeStatementsWithSemicolons", func(t *testing.T) {
		AssertParseStatements(t, `BEGIN; SELECT 1; COMMIT;`, 3)
	})

	t.Run("MixedStatementTypes", func(t *testing.T) {
		input := `
			CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT);
			INSERT INTO users (id, name) VALUES (1, 'Alice');
			SELECT * FROM users;
			UPDATE users SET name = 'Bob' WHERE id = 1;
			DELETE FROM users WHERE id = 1;
		`
		AssertParseStatements(t, input, 5)
	})

	t.Run("StatementWithoutTrailingSemicolon", func(t *testing.T) {
		AssertParseStatements(t, `SELECT * FROM foo`, 1)
	})

	t.Run("StatementWithLeadingWhitespace", func(t *testing.T) {
		AssertParseStatements(t, `  
			
			SELECT * FROM foo;
		`, 1)
	})

	t.Run("ExplainStatements", func(t *testing.T) {
		AssertParseStatements(t, `EXPLAIN SELECT * FROM foo; EXPLAIN QUERY PLAN SELECT * FROM bar;`, 2)
	})

	t.Run("PragmaStatements", func(t *testing.T) {
		AssertParseStatements(t, `PRAGMA journal_mode; PRAGMA foreign_keys = 'ON';`, 2)
	})

	t.Run("TransactionStatements", func(t *testing.T) {
		AssertParseStatements(t, `BEGIN TRANSACTION; ROLLBACK; BEGIN; COMMIT;`, 4)
	})

	t.Run("MissingSemicolonBetweenStatements", func(t *testing.T) {
		AssertParseStatementsError(t, `SELECT * FROM foo SELECT * FROM bar`, "semicolon or EOF")
	})

	t.Run("InvalidStatement", func(t *testing.T) {
		_, err := sql.NewParser(strings.NewReader(`INVALID STATEMENT;`)).ParseStatements()
		if err == nil {
			t.Fatal("ParseStatements() expected error, got nil")
		}
	})

	t.Run("EmptySemicolons", func(t *testing.T) {
		// Empty statements are skipped, as sqlite3 does.
		AssertParseStatements(t, `;;`, 0)
	})

	t.Run("CreateIndexStatements", func(t *testing.T) {
		AssertParseStatements(t, `CREATE INDEX idx_foo ON foo(bar); CREATE UNIQUE INDEX idx_baz ON baz(qux);`, 2)
	})

	t.Run("DropStatements", func(t *testing.T) {
		AssertParseStatements(t, `DROP TABLE foo; DROP INDEX idx; DROP VIEW v;`, 3)
	})

	t.Run("MixedWhitespaceAndComments", func(t *testing.T) {
		input := `
			SELECT * FROM foo;
			
			-- This is a comment
			SELECT * FROM bar;
		`
		AssertParseStatements(t, input, 2)
	})
}

func TestParser_ParseExpr(t *testing.T) {
	t.Run("Ident", func(t *testing.T) {
		AssertParseExpr(t, `fooBAR_123'`, &sql.Ident{NamePos: pos(0), Name: `fooBAR_123`})
	})
	t.Run("StringLit", func(t *testing.T) {
		AssertParseExpr(t, `'foo bar'`, &sql.StringLit{ValuePos: pos(0), Value: `foo bar`})
	})
	t.Run("BlobLit", func(t *testing.T) {
		AssertParseExpr(t, `x'0123'`, &sql.BlobLit{ValuePos: pos(0), Value: `0123`})
	})
	t.Run("Integer", func(t *testing.T) {
		AssertParseExpr(t, `123`, &sql.NumberLit{ValuePos: pos(0), Value: `123`})
	})
	t.Run("Float", func(t *testing.T) {
		AssertParseExpr(t, `123.456`, &sql.NumberLit{ValuePos: pos(0), Value: `123.456`})
	})
	t.Run("Null", func(t *testing.T) {
		AssertParseExpr(t, `NULL`, &sql.NullLit{Pos: pos(0)})
	})
	t.Run("Bool", func(t *testing.T) {
		AssertParseExpr(t, `true`, &sql.BoolLit{ValuePos: pos(0), Value: true})
		AssertParseExpr(t, `false`, &sql.BoolLit{ValuePos: pos(0), Value: false})
	})
	t.Run("Bind", func(t *testing.T) {
		AssertParseExpr(t, `$bar`, &sql.BindExpr{NamePos: pos(0), Name: "$bar"})
	})
	t.Run("UnaryExpr", func(t *testing.T) {
		AssertParseExpr(t, `-123`, &sql.UnaryExpr{OpPos: pos(0), Op: sql.MINUS, X: &sql.NumberLit{ValuePos: pos(1), Value: `123`}})
		AssertParseExpr(t, `NOT foo`, &sql.UnaryExpr{OpPos: pos(0), Op: sql.NOT, X: &sql.Ident{NamePos: pos(4), Name: "foo"}})
		// Unary NOT binds looser than comparison operators but tighter than AND/OR.
		AssertParseExpr(t, `NOT 1 = 2`, &sql.UnaryExpr{OpPos: pos(0), Op: sql.NOT, X: &sql.BinaryExpr{
			X:     &sql.NumberLit{ValuePos: pos(4), Value: "1"},
			OpPos: pos(6), Op: sql.EQ,
			Y: &sql.NumberLit{ValuePos: pos(8), Value: "2"},
		}})
		AssertParseExpr(t, `NOT a LIKE b`, &sql.UnaryExpr{OpPos: pos(0), Op: sql.NOT, X: &sql.BinaryExpr{
			X:     &sql.Ident{NamePos: pos(4), Name: "a"},
			OpPos: pos(6), Op: sql.LIKE,
			Y: &sql.Ident{NamePos: pos(11), Name: "b"},
		}})
		AssertParseExpr(t, `NOT 1 = 2 AND 3`, &sql.BinaryExpr{
			X: &sql.UnaryExpr{OpPos: pos(0), Op: sql.NOT, X: &sql.BinaryExpr{
				X:     &sql.NumberLit{ValuePos: pos(4), Value: "1"},
				OpPos: pos(6), Op: sql.EQ,
				Y: &sql.NumberLit{ValuePos: pos(8), Value: "2"},
			}},
			OpPos: pos(10), Op: sql.AND,
			Y: &sql.NumberLit{ValuePos: pos(14), Value: "3"},
		})
		AssertParseExpr(t, `NOT NOT 1`, &sql.UnaryExpr{OpPos: pos(0), Op: sql.NOT, X: &sql.UnaryExpr{OpPos: pos(4), Op: sql.NOT, X: &sql.NumberLit{ValuePos: pos(8), Value: "1"}}})
		AssertParseExpr(t, `~1`, &sql.UnaryExpr{OpPos: pos(0), Op: sql.BITNOT, X: &sql.NumberLit{ValuePos: pos(1), Value: "1"}})
		AssertParseExprError(t, `-`, `1:1: expected expression, found 'EOF'`)
	})
	t.Run("QualifiedRef", func(t *testing.T) {
		AssertParseExpr(t, `tbl.col`, &sql.QualifiedRef{
			Table:  &sql.Ident{NamePos: pos(0), Name: "tbl"},
			Dot:    pos(3),
			Column: &sql.Ident{NamePos: pos(4), Name: "col"},
		})
		AssertParseExpr(t, `"tbl"."col"`, &sql.QualifiedRef{
			Table:  &sql.Ident{NamePos: pos(0), Name: "tbl", Quoted: true},
			Dot:    pos(5),
			Column: &sql.Ident{NamePos: pos(6), Name: "col", Quoted: true},
		})
		AssertParseExpr(t, `schema.tbl.col`, &sql.QualifiedRef{
			Schema:    &sql.Ident{NamePos: pos(0), Name: "schema"},
			SchemaPos: pos(6),
			Table:     &sql.Ident{NamePos: pos(7), Name: "tbl"},
			Dot:       pos(10),
			Column:    &sql.Ident{NamePos: pos(11), Name: "col"},
		})
		AssertParseExpr(t, `"schema"."tbl"."col"`, &sql.QualifiedRef{
			Schema:    &sql.Ident{NamePos: pos(0), Name: "schema", Quoted: true},
			SchemaPos: pos(8),
			Table:     &sql.Ident{NamePos: pos(9), Name: "tbl", Quoted: true},
			Dot:       pos(14),
			Column:    &sql.Ident{NamePos: pos(15), Name: "col", Quoted: true},
		})
		AssertParseExpr(t, `main.vals.a`, &sql.QualifiedRef{
			Schema:    &sql.Ident{NamePos: pos(0), Name: "main"},
			SchemaPos: pos(4),
			Table:     &sql.Ident{NamePos: pos(5), Name: "vals"},
			Dot:       pos(9),
			Column:    &sql.Ident{NamePos: pos(10), Name: "a"},
		})
		AssertParseExprError(t, `tbl.`, `1:4: expected column name, found 'EOF'`)
	})
	t.Run("Exists", func(t *testing.T) {
		AssertParseExpr(t, `EXISTS (SELECT *)`, &sql.Exists{
			Exists: pos(0),
			Lparen: pos(7),
			Select: &sql.SelectStatement{
				Select: pos(8),
				Columns: []*sql.ResultColumn{
					{Star: pos(15)},
				},
			},
			Rparen: pos(16),
		})
		AssertParseExpr(t, `NOT EXISTS (SELECT *)`, &sql.Exists{
			Not:    pos(0),
			Exists: pos(4),
			Lparen: pos(11),
			Select: &sql.SelectStatement{
				Select: pos(12),
				Columns: []*sql.ResultColumn{
					{Star: pos(19)},
				},
			},
			Rparen: pos(20),
		})
		AssertParseExprError(t, `NOT`, `1:3: expected expression, found 'EOF'`)
		AssertParseExprError(t, `EXISTS`, `1:6: expected left paren, found 'EOF'`)
		AssertParseExprError(t, `EXISTS (`, `1:8: expected SELECT or VALUES, found 'EOF'`)
		AssertParseExprError(t, `EXISTS (SELECT`, `1:14: expected expression, found 'EOF'`)
		AssertParseExprError(t, `EXISTS (SELECT *`, `1:16: expected right paren, found 'EOF'`)
	})
	t.Run("BinaryExpr", func(t *testing.T) {
		AssertParseExpr(t, `1 + 2'`, &sql.BinaryExpr{
			X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
			OpPos: pos(2), Op: sql.PLUS,
			Y: &sql.NumberLit{ValuePos: pos(4), Value: "2"},
		})
		AssertParseExpr(t, `1 - 2'`, &sql.BinaryExpr{
			X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
			OpPos: pos(2), Op: sql.MINUS,
			Y: &sql.NumberLit{ValuePos: pos(4), Value: "2"},
		})
		AssertParseExpr(t, `1 * 2'`, &sql.BinaryExpr{
			X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
			OpPos: pos(2), Op: sql.STAR,
			Y: &sql.NumberLit{ValuePos: pos(4), Value: "2"},
		})
		AssertParseExpr(t, `1 / 2'`, &sql.BinaryExpr{
			X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
			OpPos: pos(2), Op: sql.SLASH,
			Y: &sql.NumberLit{ValuePos: pos(4), Value: "2"},
		})
		AssertParseExpr(t, `1 % 2'`, &sql.BinaryExpr{
			X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
			OpPos: pos(2), Op: sql.REM,
			Y: &sql.NumberLit{ValuePos: pos(4), Value: "2"},
		})
		AssertParseExpr(t, `1 || 2'`, &sql.BinaryExpr{
			X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
			OpPos: pos(2), Op: sql.CONCAT,
			Y: &sql.NumberLit{ValuePos: pos(5), Value: "2"},
		})
		AssertParseExpr(t, `1 << 2'`, &sql.BinaryExpr{
			X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
			OpPos: pos(2), Op: sql.LSHIFT,
			Y: &sql.NumberLit{ValuePos: pos(5), Value: "2"},
		})
		AssertParseExpr(t, `1 >> 2'`, &sql.BinaryExpr{
			X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
			OpPos: pos(2), Op: sql.RSHIFT,
			Y: &sql.NumberLit{ValuePos: pos(5), Value: "2"},
		})
		AssertParseExpr(t, `1 & 2'`, &sql.BinaryExpr{
			X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
			OpPos: pos(2), Op: sql.BITAND,
			Y: &sql.NumberLit{ValuePos: pos(4), Value: "2"},
		})
		AssertParseExpr(t, `1 | 2'`, &sql.BinaryExpr{
			X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
			OpPos: pos(2), Op: sql.BITOR,
			Y: &sql.NumberLit{ValuePos: pos(4), Value: "2"},
		})
		AssertParseExpr(t, `1 < 2'`, &sql.BinaryExpr{
			X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
			OpPos: pos(2), Op: sql.LT,
			Y: &sql.NumberLit{ValuePos: pos(4), Value: "2"},
		})
		AssertParseExpr(t, `1 <= 2'`, &sql.BinaryExpr{
			X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
			OpPos: pos(2), Op: sql.LE,
			Y: &sql.NumberLit{ValuePos: pos(5), Value: "2"},
		})
		AssertParseExpr(t, `1 > 2'`, &sql.BinaryExpr{
			X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
			OpPos: pos(2), Op: sql.GT,
			Y: &sql.NumberLit{ValuePos: pos(4), Value: "2"},
		})
		AssertParseExpr(t, `1 >= 2'`, &sql.BinaryExpr{
			X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
			OpPos: pos(2), Op: sql.GE,
			Y: &sql.NumberLit{ValuePos: pos(5), Value: "2"},
		})
		AssertParseExpr(t, `1 = 2'`, &sql.BinaryExpr{
			X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
			OpPos: pos(2), Op: sql.EQ,
			Y: &sql.NumberLit{ValuePos: pos(4), Value: "2"},
		})
		AssertParseExpr(t, `1 != 2'`, &sql.BinaryExpr{
			X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
			OpPos: pos(2), Op: sql.NE,
			Y: &sql.NumberLit{ValuePos: pos(5), Value: "2"},
		})
		AssertParseExpr(t, `(1 + 2)'`, &sql.ParenExpr{
			Lparen: pos(0),
			X: &sql.BinaryExpr{
				X:     &sql.NumberLit{ValuePos: pos(1), Value: "1"},
				OpPos: pos(3), Op: sql.PLUS,
				Y: &sql.NumberLit{ValuePos: pos(5), Value: "2"},
			},
			Rparen: pos(6),
		})
		AssertParseExprError(t, `(`, `1:1: expected expression, found 'EOF'`)
		// A parenthesized expression must be closed; stray tokens are an error.
		AssertParseExprError(t, `(1 2)`, `1:4: expected right paren, found 2`)
		AssertParseExprError(t, `(1`, `1:2: expected right paren, found 'EOF'`)
		AssertParseStatementError(t, `SELECT (1 2`, `1:11: expected right paren, found 2`)
		AssertParseExpr(t, `1 IS 2'`, &sql.BinaryExpr{
			X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
			OpPos: pos(2), Op: sql.IS,
			Y: &sql.NumberLit{ValuePos: pos(5), Value: "2"},
		})
		AssertParseExpr(t, `1 IS NOT 2'`, &sql.BinaryExpr{
			X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
			OpPos: pos(2), Op: sql.ISNOT,
			Y: &sql.NumberLit{ValuePos: pos(9), Value: "2"},
		})
		// IS [NOT] DISTINCT FROM is a null-safe (in)equality comparison.
		AssertParseExpr(t, `1 IS DISTINCT FROM 2`, &sql.BinaryExpr{
			X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
			OpPos: pos(2), Op: sql.ISDISTINCT,
			Y: &sql.NumberLit{ValuePos: pos(19), Value: "2"},
		})
		AssertParseExpr(t, `1 IS NOT DISTINCT FROM 2 AND 3`, &sql.BinaryExpr{
			X: &sql.BinaryExpr{
				X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
				OpPos: pos(2), Op: sql.ISNOTDISTINCT,
				Y: &sql.NumberLit{ValuePos: pos(23), Value: "2"},
			},
			OpPos: pos(25), Op: sql.AND,
			Y: &sql.NumberLit{ValuePos: pos(29), Value: "3"},
		})
		AssertParseExprError(t, `1 IS DISTINCT 2`, `1:15: expected FROM, found 2`)
		// IS NOT and the NOT-prefixed operators share the precedence of IS/LIKE,
		// so they must not swallow a following AND/OR.
		AssertParseExpr(t, `1 IS NOT 2 AND 3`, &sql.BinaryExpr{
			X: &sql.BinaryExpr{
				X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
				OpPos: pos(2), Op: sql.ISNOT,
				Y: &sql.NumberLit{ValuePos: pos(9), Value: "2"},
			},
			OpPos: pos(11), Op: sql.AND,
			Y: &sql.NumberLit{ValuePos: pos(15), Value: "3"},
		})
		AssertParseExpr(t, `1 NOT LIKE 2 OR 3`, &sql.BinaryExpr{
			X: &sql.BinaryExpr{
				X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
				OpPos: pos(2), Op: sql.NOTLIKE,
				Y: &sql.NumberLit{ValuePos: pos(11), Value: "2"},
			},
			OpPos: pos(13), Op: sql.OR,
			Y: &sql.NumberLit{ValuePos: pos(16), Value: "3"},
		})
		AssertParseExpr(t, `1 NOT GLOB 2 AND 3`, &sql.BinaryExpr{
			X: &sql.BinaryExpr{
				X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
				OpPos: pos(2), Op: sql.NOTGLOB,
				Y: &sql.NumberLit{ValuePos: pos(11), Value: "2"},
			},
			OpPos: pos(13), Op: sql.AND,
			Y: &sql.NumberLit{ValuePos: pos(17), Value: "3"},
		})
		// A NOT-prefixed operator binds tighter than a leading unary NOT.
		AssertParseExpr(t, `NOT 1 NOT LIKE 2`, &sql.UnaryExpr{OpPos: pos(0), Op: sql.NOT, X: &sql.BinaryExpr{
			X:     &sql.NumberLit{ValuePos: pos(4), Value: "1"},
			OpPos: pos(6), Op: sql.NOTLIKE,
			Y: &sql.NumberLit{ValuePos: pos(15), Value: "2"},
		}})
		AssertParseExpr(t, `1 LIKE 2'`, &sql.BinaryExpr{
			X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
			OpPos: pos(2), Op: sql.LIKE,
			Y: &sql.NumberLit{ValuePos: pos(7), Value: "2"},
		})
		AssertParseExpr(t, `1 NOT LIKE 2'`, &sql.BinaryExpr{
			X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
			OpPos: pos(2), Op: sql.NOTLIKE,
			Y: &sql.NumberLit{ValuePos: pos(11), Value: "2"},
		})
		AssertParseExpr(t, `1 GLOB 2'`, &sql.BinaryExpr{
			X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
			OpPos: pos(2), Op: sql.GLOB,
			Y: &sql.NumberLit{ValuePos: pos(7), Value: "2"},
		})
		AssertParseExpr(t, `1 NOT GLOB 2'`, &sql.BinaryExpr{
			X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
			OpPos: pos(2), Op: sql.NOTGLOB,
			Y: &sql.NumberLit{ValuePos: pos(11), Value: "2"},
		})
		AssertParseExpr(t, `1 REGEXP 2'`, &sql.BinaryExpr{
			X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
			OpPos: pos(2), Op: sql.REGEXP,
			Y: &sql.NumberLit{ValuePos: pos(9), Value: "2"},
		})
		AssertParseExpr(t, `1 NOT REGEXP 2'`, &sql.BinaryExpr{
			X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
			OpPos: pos(2), Op: sql.NOTREGEXP,
			Y: &sql.NumberLit{ValuePos: pos(13), Value: "2"},
		})
		AssertParseExpr(t, `1 MATCH 2'`, &sql.BinaryExpr{
			X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
			OpPos: pos(2), Op: sql.MATCH,
			Y: &sql.NumberLit{ValuePos: pos(8), Value: "2"},
		})
		AssertParseExpr(t, `1 NOT MATCH 2'`, &sql.BinaryExpr{
			X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
			OpPos: pos(2), Op: sql.NOTMATCH,
			Y: &sql.NumberLit{ValuePos: pos(12), Value: "2"},
		})
		AssertParseExpr(t, `1 LIKE 2 ESCAPE '@'`, &sql.BinaryExpr{
			X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
			OpPos: pos(2), Op: sql.LIKE,
			Y:          &sql.NumberLit{ValuePos: pos(7), Value: "2"},
			Escape:     pos(9),
			EscapeExpr: &sql.StringLit{ValuePos: pos(16), Value: "@"},
		})
		AssertParseExpr(t, `1 NOT LIKE 2 ESCAPE '@'`, &sql.BinaryExpr{
			X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
			OpPos: pos(2), Op: sql.NOTLIKE,
			Y:          &sql.NumberLit{ValuePos: pos(11), Value: "2"},
			Escape:     pos(13),
			EscapeExpr: &sql.StringLit{ValuePos: pos(20), Value: "@"},
		})
		// ESCAPE binds only to LIKE, not to GLOB, REGEXP or MATCH.
		AssertParseStatementError(t, `SELECT 1 GLOB 2 ESCAPE '@'`, `1:17: expected semicolon or EOF, found 'ESCAPE'`)
		AssertParseStatementError(t, `SELECT 1 REGEXP 2 ESCAPE '@'`, `1:19: expected semicolon or EOF, found 'ESCAPE'`)
		AssertParseStatementError(t, `SELECT 1 NOT MATCH 2 ESCAPE '@'`, `1:22: expected semicolon or EOF, found 'ESCAPE'`)
		// ESCAPE binds to the LIKE, not to a following AND/OR condition.
		AssertParseExpr(t, `1 LIKE 2 ESCAPE '@' AND 3`, &sql.BinaryExpr{
			X: &sql.BinaryExpr{
				X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
				OpPos: pos(2), Op: sql.LIKE,
				Y:          &sql.NumberLit{ValuePos: pos(7), Value: "2"},
				Escape:     pos(9),
				EscapeExpr: &sql.StringLit{ValuePos: pos(16), Value: "@"},
			},
			OpPos: pos(20), Op: sql.AND,
			Y: &sql.NumberLit{ValuePos: pos(24), Value: "3"},
		})
		AssertParseExprError(t, `1 LIKE 2 ESCAPE`, `1:15: expected expression, found 'EOF'`)
		AssertParseExprError(t, `1 NOT TABLE`, `1:7: expected IN, LIKE, GLOB, REGEXP, MATCH, BETWEEN, IS/NOT NULL, found 'TABLE'`)
		AssertParseExpr(t, `1 IN (2, 3)'`, &sql.BinaryExpr{
			X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
			OpPos: pos(2), Op: sql.IN,
			Y: &sql.ExprList{
				Lparen: pos(5),
				Exprs: []sql.Expr{
					&sql.NumberLit{ValuePos: pos(6), Value: "2"},
					&sql.NumberLit{ValuePos: pos(9), Value: "3"},
				},
				Rparen: pos(10),
			},
		})
		AssertParseExpr(t, `1 NOT IN (2, 3)'`, &sql.BinaryExpr{
			X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
			OpPos: pos(2), Op: sql.NOTIN,
			Y: &sql.ExprList{
				Lparen: pos(9),
				Exprs: []sql.Expr{
					&sql.NumberLit{ValuePos: pos(10), Value: "2"},
					&sql.NumberLit{ValuePos: pos(13), Value: "3"},
				},
				Rparen: pos(14),
			},
		})
		AssertParseExprError(t, `1 IN 2`, `1:6: expected left paren or table name, found 2`)
		AssertParseExprError(t, `1 IN (`, `1:6: expected expression, found 'EOF'`)
		AssertParseExprError(t, `1 IN (2 3`, `1:9: expected comma or right paren, found 3`)
		// Test table name in IN clause
		AssertParseExpr(t, `1 IN tbl`, &sql.BinaryExpr{
			X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
			OpPos: pos(2), Op: sql.IN,
			Y: &sql.Ident{NamePos: pos(5), Name: "tbl"},
		})
		AssertParseExpr(t, `1 NOT IN tbl`, &sql.BinaryExpr{
			X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
			OpPos: pos(2), Op: sql.NOTIN,
			Y: &sql.Ident{NamePos: pos(9), Name: "tbl"},
		})
		// Test schema-qualified table name in IN clause
		AssertParseExpr(t, `1 IN main.tbl`, &sql.BinaryExpr{
			X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
			OpPos: pos(2), Op: sql.IN,
			Y: &sql.QualifiedRef{
				Table:  &sql.Ident{NamePos: pos(5), Name: "main"},
				Dot:    pos(9),
				Column: &sql.Ident{NamePos: pos(10), Name: "tbl"},
			},
		})
		AssertParseExpr(t, `1 NOT IN schema1.tbl`, &sql.BinaryExpr{
			X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
			OpPos: pos(2), Op: sql.NOTIN,
			Y: &sql.QualifiedRef{
				Table:  &sql.Ident{NamePos: pos(9), Name: "schema1"},
				Dot:    pos(16),
				Column: &sql.Ident{NamePos: pos(17), Name: "tbl"},
			},
		})
		// Test table-valued function in IN clause
		AssertParseExpr(t, `1 IN func()`, &sql.BinaryExpr{
			X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
			OpPos: pos(2), Op: sql.IN,
			Y: &sql.Call{
				Name:   &sql.Ident{NamePos: pos(5), Name: "func"},
				Lparen: pos(9),
				Rparen: pos(10),
			},
		})
		AssertParseExpr(t, `1 NOT IN json_each('[1,2]')`, &sql.BinaryExpr{
			X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
			OpPos: pos(2), Op: sql.NOTIN,
			Y: &sql.Call{
				Name:   &sql.Ident{NamePos: pos(9), Name: "json_each"},
				Lparen: pos(18),
				Args: []sql.Expr{
					&sql.StringLit{ValuePos: pos(19), Value: "[1,2]"},
				},
				Rparen: pos(26),
			},
		})
		// Schema-qualified function calls are accepted in IN expressions.
		AssertParseExpr(t, `1 IN schema.func()`, &sql.BinaryExpr{
			X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
			OpPos: pos(2), Op: sql.IN,
			Y: &sql.Call{
				Schema: &sql.Ident{NamePos: pos(5), Name: "schema"},
				Dot:    pos(11),
				Name:   &sql.Ident{NamePos: pos(12), Name: "func"},
				Lparen: pos(16),
				Rparen: pos(17),
			},
		})
		AssertParseExpr(t, `1 BETWEEN 2 AND 3'`, &sql.BinaryExpr{
			X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
			OpPos: pos(2), Op: sql.BETWEEN,
			Y: &sql.Range{
				X:   &sql.NumberLit{ValuePos: pos(10), Value: "2"},
				And: pos(12),
				Y:   &sql.NumberLit{ValuePos: pos(16), Value: "3"},
			},
		})
		AssertParseExpr(t, `1 NOT BETWEEN 2 AND 3'`, &sql.BinaryExpr{
			X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
			OpPos: pos(2), Op: sql.NOTBETWEEN,
			Y: &sql.Range{
				X:   &sql.NumberLit{ValuePos: pos(14), Value: "2"},
				And: pos(16),
				Y:   &sql.NumberLit{ValuePos: pos(20), Value: "3"},
			},
		})
		AssertParseExpr(t, `1 -> 2`, &sql.BinaryExpr{
			X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
			OpPos: pos(2), Op: sql.JSON_EXTRACT_JSON,
			Y: &sql.NumberLit{ValuePos: pos(5), Value: "2"},
		})
		AssertParseExpr(t, `1 ->> 2`, &sql.BinaryExpr{
			X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
			OpPos: pos(2), Op: sql.JSON_EXTRACT_SQL,
			Y: &sql.NumberLit{ValuePos: pos(6), Value: "2"},
		})
		// The bounds of BETWEEN bind tighter than AND/OR, so a trailing
		// boolean operator applies to the whole BETWEEN expression.
		AssertParseExpr(t, `1 BETWEEN 2 AND 3 AND 4`, &sql.BinaryExpr{
			X: &sql.BinaryExpr{
				X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
				OpPos: pos(2), Op: sql.BETWEEN,
				Y: &sql.Range{
					X:   &sql.NumberLit{ValuePos: pos(10), Value: "2"},
					And: pos(12),
					Y:   &sql.NumberLit{ValuePos: pos(16), Value: "3"},
				},
			},
			OpPos: pos(18), Op: sql.AND,
			Y: &sql.NumberLit{ValuePos: pos(22), Value: "4"},
		})
		AssertParseExpr(t, `1 BETWEEN 2 AND 3 OR 4`, &sql.BinaryExpr{
			X: &sql.BinaryExpr{
				X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
				OpPos: pos(2), Op: sql.BETWEEN,
				Y: &sql.Range{
					X:   &sql.NumberLit{ValuePos: pos(10), Value: "2"},
					And: pos(12),
					Y:   &sql.NumberLit{ValuePos: pos(16), Value: "3"},
				},
			},
			OpPos: pos(18), Op: sql.OR,
			Y: &sql.NumberLit{ValuePos: pos(21), Value: "4"},
		})
		AssertParseExpr(t, `1 BETWEEN 2 + 1 AND 3 * 2`, &sql.BinaryExpr{
			X:     &sql.NumberLit{ValuePos: pos(0), Value: "1"},
			OpPos: pos(2), Op: sql.BETWEEN,
			Y: &sql.Range{
				X: &sql.BinaryExpr{
					X:     &sql.NumberLit{ValuePos: pos(10), Value: "2"},
					OpPos: pos(12), Op: sql.PLUS,
					Y: &sql.NumberLit{ValuePos: pos(14), Value: "1"},
				},
				And: pos(16),
				Y: &sql.BinaryExpr{
					X:     &sql.NumberLit{ValuePos: pos(20), Value: "3"},
					OpPos: pos(22), Op: sql.STAR,
					Y: &sql.NumberLit{ValuePos: pos(24), Value: "2"},
				},
			},
		})
		AssertParseExprError(t, `1 BETWEEN`, `1:9: expected expression, found 'EOF'`)
		AssertParseExprError(t, `1 BETWEEN 2`, `1:11: expected AND, found 'EOF'`)
		AssertParseExprError(t, `1 BETWEEN 2 + 3`, `1:15: expected AND, found 'EOF'`)
		AssertParseExprError(t, `1 BETWEEN 2 AND`, `1:15: expected expression, found 'EOF'`)
		AssertParseExprError(t, `1 + `, `1:4: expected expression, found 'EOF'`)
	})
	t.Run("Call", func(t *testing.T) {
		// ALL is accepted before the arguments like DISTINCT.
		AssertParseExpr(t, `count(ALL x)`, &sql.Call{
			Name:   &sql.Ident{NamePos: pos(0), Name: "count"},
			Lparen: pos(5),
			All:    pos(6),
			Args:   []sql.Expr{&sql.Ident{NamePos: pos(10), Name: "x"}},
			Rparen: pos(11),
		})
		AssertParseExprError(t, `f(1,)`, `1:5: expected expression, found ')'`)
		AssertParseExpr(t, `sum()`, &sql.Call{
			Name:   &sql.Ident{NamePos: pos(0), Name: "sum"},
			Lparen: pos(3),
			Rparen: pos(4),
		})
		AssertParseExpr(t, `sum(*)`, &sql.Call{
			Name:   &sql.Ident{NamePos: pos(0), Name: "sum"},
			Lparen: pos(3),
			Star:   pos(4),
			Rparen: pos(5),
		})
		AssertParseExpr(t, `sum(foo, 123)`, &sql.Call{
			Name:   &sql.Ident{NamePos: pos(0), Name: "sum"},
			Lparen: pos(3),
			Args: []sql.Expr{
				&sql.Ident{NamePos: pos(4), Name: "foo"},
				&sql.NumberLit{ValuePos: pos(9), Value: "123"},
			},
			Rparen: pos(12),
		})
		AssertParseExpr(t, `sum(distinct 'foo')`, &sql.Call{
			Name:     &sql.Ident{NamePos: pos(0), Name: "sum"},
			Lparen:   pos(3),
			Distinct: pos(4),
			Args: []sql.Expr{
				&sql.StringLit{ValuePos: pos(13), Value: "foo"},
			},
			Rparen: pos(18),
		})
		AssertParseExpr(t, `sum(1, sum(2, 3))`, &sql.Call{
			Name:   &sql.Ident{NamePos: pos(0), Name: "sum"},
			Lparen: pos(3),
			Args: []sql.Expr{
				&sql.NumberLit{ValuePos: pos(4), Value: "1"},
				&sql.Call{
					Name:   &sql.Ident{NamePos: pos(7), Name: "sum"},
					Lparen: pos(10),
					Args: []sql.Expr{
						&sql.NumberLit{ValuePos: pos(11), Value: "2"},
						&sql.NumberLit{ValuePos: pos(14), Value: "3"},
					},
					Rparen: pos(15),
				},
			},
			Rparen: pos(16),
		})
		AssertParseExpr(t, `sum(sum(1,2), sum(3, 4))`, &sql.Call{
			Name:   &sql.Ident{NamePos: pos(0), Name: "sum"},
			Lparen: pos(3),
			Args: []sql.Expr{
				&sql.Call{
					Name:   &sql.Ident{NamePos: pos(4), Name: "sum"},
					Lparen: pos(7),
					Args: []sql.Expr{
						&sql.NumberLit{ValuePos: pos(8), Value: "1"},
						&sql.NumberLit{ValuePos: pos(10), Value: "2"},
					},
					Rparen: pos(11),
				}, &sql.Call{
					Name:   &sql.Ident{NamePos: pos(14), Name: "sum"},
					Lparen: pos(17),
					Args: []sql.Expr{
						&sql.NumberLit{ValuePos: pos(18), Value: "3"},
						&sql.NumberLit{ValuePos: pos(21), Value: "4"},
					},
					Rparen: pos(22),
				},
			},
			Rparen: pos(23),
		})
		AssertParseExpr(t, `sum() filter (where true)`, &sql.Call{
			Name:   &sql.Ident{NamePos: pos(0), Name: "sum"},
			Lparen: pos(3),
			Rparen: pos(4),
			Filter: &sql.FilterClause{
				Filter: pos(6),
				Lparen: pos(13),
				Where:  pos(14),
				X:      &sql.BoolLit{ValuePos: pos(20), Value: true},
				Rparen: pos(24),
			},
		})
		AssertParseExpr(t, `sum() over win1`, &sql.Call{
			Name:   &sql.Ident{NamePos: pos(0), Name: "sum"},
			Lparen: pos(3),
			Rparen: pos(4),
			Over: &sql.OverClause{
				Over: pos(6),
				Name: &sql.Ident{NamePos: pos(11), Name: "win1"},
			},
		})
		AssertParseExpr(t, `sum() over (win1 partition by foo, bar order by baz ASC NULLS FIRST, biz)`, &sql.Call{
			Name:   &sql.Ident{NamePos: pos(0), Name: "sum"},
			Lparen: pos(3),
			Rparen: pos(4),
			Over: &sql.OverClause{
				Over: pos(6),
				Definition: &sql.WindowDefinition{
					Lparen:      pos(11),
					Base:        &sql.Ident{NamePos: pos(12), Name: "win1"},
					Partition:   pos(17),
					PartitionBy: pos(27),
					Partitions: []sql.Expr{
						&sql.Ident{NamePos: pos(30), Name: "foo"},
						&sql.Ident{NamePos: pos(35), Name: "bar"},
					},
					Order:   pos(39),
					OrderBy: pos(45),
					OrderingTerms: []*sql.OrderingTerm{
						{
							X:          &sql.Ident{NamePos: pos(48), Name: "baz"},
							Asc:        pos(52),
							Nulls:      pos(56),
							NullsFirst: pos(62),
						},
						{
							X: &sql.Ident{NamePos: pos(69), Name: "biz"},
						},
					},
					Rparen: pos(72),
				},
			},
		})
		AssertParseExpr(t, `sum() over (order by baz DESC NULLS LAST)`, &sql.Call{
			Name:   &sql.Ident{NamePos: pos(0), Name: "sum"},
			Lparen: pos(3),
			Rparen: pos(4),
			Over: &sql.OverClause{
				Over: pos(6),
				Definition: &sql.WindowDefinition{
					Lparen:  pos(11),
					Order:   pos(12),
					OrderBy: pos(18),
					OrderingTerms: []*sql.OrderingTerm{
						{
							X:         &sql.Ident{NamePos: pos(21), Name: "baz"},
							Desc:      pos(25),
							Nulls:     pos(30),
							NullsLast: pos(36),
						},
					},
					Rparen: pos(40),
				},
			},
		})
		AssertParseExpr(t, `sum() over (range foo preceding)`, &sql.Call{
			Name:   &sql.Ident{NamePos: pos(0), Name: "sum"},
			Lparen: pos(3),
			Rparen: pos(4),
			Over: &sql.OverClause{
				Over: pos(6),
				Definition: &sql.WindowDefinition{
					Lparen: pos(11),
					Frame: &sql.FrameSpec{
						Range:      pos(12),
						X:          &sql.Ident{NamePos: pos(18), Name: "foo"},
						PrecedingX: pos(22),
					},
					Rparen: pos(31),
				},
			},
		})
		AssertParseExpr(t, `sum() over (rows between foo following and bar preceding)`, &sql.Call{
			Name:   &sql.Ident{NamePos: pos(0), Name: "sum"},
			Lparen: pos(3),
			Rparen: pos(4),
			Over: &sql.OverClause{
				Over: pos(6),
				Definition: &sql.WindowDefinition{
					Lparen: pos(11),
					Frame: &sql.FrameSpec{
						Rows:       pos(12),
						Between:    pos(17),
						X:          &sql.Ident{NamePos: pos(25), Name: "foo"},
						FollowingX: pos(29),
						And:        pos(39),
						Y:          &sql.Ident{NamePos: pos(43), Name: "bar"},
						PrecedingY: pos(47),
					},
					Rparen: pos(56),
				},
			},
		})
		AssertParseExpr(t, `sum() over (rows between foo following and bar following)`, &sql.Call{
			Name:   &sql.Ident{NamePos: pos(0), Name: "sum"},
			Lparen: pos(3),
			Rparen: pos(4),
			Over: &sql.OverClause{
				Over: pos(6),
				Definition: &sql.WindowDefinition{
					Lparen: pos(11),
					Frame: &sql.FrameSpec{
						Rows:       pos(12),
						Between:    pos(17),
						X:          &sql.Ident{NamePos: pos(25), Name: "foo"},
						FollowingX: pos(29),
						And:        pos(39),
						Y:          &sql.Ident{NamePos: pos(43), Name: "bar"},
						FollowingY: pos(47),
					},
					Rparen: pos(56),
				},
			},
		})
		AssertParseExpr(t, `sum() over (groups between unbounded preceding and unbounded following)`, &sql.Call{
			Name:   &sql.Ident{NamePos: pos(0), Name: "sum"},
			Lparen: pos(3),
			Rparen: pos(4),
			Over: &sql.OverClause{
				Over: pos(6),
				Definition: &sql.WindowDefinition{
					Lparen: pos(11),
					Frame: &sql.FrameSpec{
						Groups:     pos(12),
						Between:    pos(19),
						UnboundedX: pos(27),
						PrecedingX: pos(37),
						And:        pos(47),
						UnboundedY: pos(51),
						FollowingY: pos(61),
					},
					Rparen: pos(70),
				},
			},
		})
		AssertParseExpr(t, `sum() over (groups between current row and current row)`, &sql.Call{
			Name:   &sql.Ident{NamePos: pos(0), Name: "sum"},
			Lparen: pos(3),
			Rparen: pos(4),
			Over: &sql.OverClause{
				Over: pos(6),
				Definition: &sql.WindowDefinition{
					Lparen: pos(11),
					Frame: &sql.FrameSpec{
						Groups:      pos(12),
						Between:     pos(19),
						CurrentX:    pos(27),
						CurrentRowX: pos(35),
						And:         pos(39),
						CurrentY:    pos(43),
						CurrentRowY: pos(51),
					},
					Rparen: pos(54),
				},
			},
		})
		AssertParseExpr(t, `sum() over (groups current row exclude no others)`, &sql.Call{
			Name:   &sql.Ident{NamePos: pos(0), Name: "sum"},
			Lparen: pos(3),
			Rparen: pos(4),
			Over: &sql.OverClause{
				Over: pos(6),
				Definition: &sql.WindowDefinition{
					Lparen: pos(11),
					Frame: &sql.FrameSpec{
						Groups:          pos(12),
						CurrentX:        pos(19),
						CurrentRowX:     pos(27),
						Exclude:         pos(31),
						ExcludeNo:       pos(39),
						ExcludeNoOthers: pos(42),
					},
					Rparen: pos(48),
				},
			},
		})
		AssertParseExpr(t, `sum() over (groups current row exclude current row)`, &sql.Call{
			Name:   &sql.Ident{NamePos: pos(0), Name: "sum"},
			Lparen: pos(3),
			Rparen: pos(4),
			Over: &sql.OverClause{
				Over: pos(6),
				Definition: &sql.WindowDefinition{
					Lparen: pos(11),
					Frame: &sql.FrameSpec{
						Groups:            pos(12),
						CurrentX:          pos(19),
						CurrentRowX:       pos(27),
						Exclude:           pos(31),
						ExcludeCurrent:    pos(39),
						ExcludeCurrentRow: pos(47),
					},
					Rparen: pos(50),
				},
			},
		})
		AssertParseExpr(t, `sum() over (groups current row exclude group)`, &sql.Call{
			Name:   &sql.Ident{NamePos: pos(0), Name: "sum"},
			Lparen: pos(3),
			Rparen: pos(4),
			Over: &sql.OverClause{
				Over: pos(6),
				Definition: &sql.WindowDefinition{
					Lparen: pos(11),
					Frame: &sql.FrameSpec{
						Groups:       pos(12),
						CurrentX:     pos(19),
						CurrentRowX:  pos(27),
						Exclude:      pos(31),
						ExcludeGroup: pos(39),
					},
					Rparen: pos(44),
				},
			},
		})
		AssertParseExpr(t, `sum() over (groups current row exclude ties)`, &sql.Call{
			Name:   &sql.Ident{NamePos: pos(0), Name: "sum"},
			Lparen: pos(3),
			Rparen: pos(4),
			Over: &sql.OverClause{
				Over: pos(6),
				Definition: &sql.WindowDefinition{
					Lparen: pos(11),
					Frame: &sql.FrameSpec{
						Groups:      pos(12),
						CurrentX:    pos(19),
						CurrentRowX: pos(27),
						Exclude:     pos(31),
						ExcludeTies: pos(39),
					},
					Rparen: pos(43),
				},
			},
		})

		AssertParseExprError(t, `sum(`, `1:4: expected expression, found 'EOF'`)
		AssertParseExprError(t, `sum(*`, `1:5: expected right paren, found 'EOF'`)
		AssertParseExprError(t, `sum(foo foo`, `1:9: expected comma or right paren, found foo`)
		AssertParseExprError(t, `sum() filter`, `1:12: expected left paren, found 'EOF'`)
		AssertParseExprError(t, `sum() filter (`, `1:14: expected WHERE, found 'EOF'`)
		AssertParseExprError(t, `sum() filter (where`, `1:19: expected expression, found 'EOF'`)
		AssertParseExprError(t, `sum() filter (where true`, `1:24: expected right paren, found 'EOF'`)
		AssertParseExprError(t, `sum() over`, `1:10: expected left paren, found 'EOF'`)
		AssertParseExprError(t, `sum() over (partition`, `1:21: expected BY, found 'EOF'`)
		AssertParseExprError(t, `sum() over (partition by`, `1:24: expected expression, found 'EOF'`)
		AssertParseExprError(t, `sum() over (partition by foo foo`, `1:30: expected right paren, found foo`)
		AssertParseExprError(t, `sum() over (order`, `1:17: expected BY, found 'EOF'`)
		AssertParseExprError(t, `sum() over (order by`, `1:20: expected expression, found 'EOF'`)
		AssertParseExprError(t, `sum() over (order by foo foo`, `1:26: expected right paren, found foo`)
		AssertParseExprError(t, `sum() over (order by foo nulls foo`, `1:32: expected FIRST or LAST, found foo`)
		AssertParseExprError(t, `sum() over (range between`, `1:25: expected expression, found 'EOF'`)
		AssertParseExprError(t, `sum() over (range between unbounded`, `1:35: expected PRECEDING, found 'EOF'`)
		AssertParseExprError(t, `sum() over (range between current`, `1:33: expected ROW, found 'EOF'`)
		AssertParseExprError(t, `sum() over (range between foo`, `1:29: expected PRECEDING or FOLLOWING, found 'EOF'`)
		AssertParseExprError(t, `sum() over (range between foo following`, `1:39: expected AND, found 'EOF'`)
		AssertParseExprError(t, `sum() over (range between foo following and`, `1:43: expected expression, found 'EOF'`)
		AssertParseExprError(t, `sum() over (range between foo following and unbounded`, `1:53: expected FOLLOWING, found 'EOF'`)
		AssertParseExprError(t, `sum() over (range between foo following and current`, `1:51: expected ROW, found 'EOF'`)
		AssertParseExprError(t, `sum() over (range between foo following and foo`, `1:47: expected PRECEDING or FOLLOWING, found 'EOF'`)
		AssertParseExprError(t, `sum() over (range current row exclude`, `1:37: expected NO OTHERS, CURRENT ROW, GROUP, or TIES, found 'EOF'`)
		AssertParseExprError(t, `sum() over (range current row exclude no`, `1:40: expected OTHERS, found 'EOF'`)
		AssertParseExprError(t, `sum() over (range current row exclude current`, `1:45: expected ROW, found 'EOF'`)
		AssertParseExprError(t, `sum() over (range foo following`, `1:23: expected PRECEDING, found 'FOLLOWING'`)
	})

	t.Run("Cast", func(t *testing.T) {
		AssertParseExpr(t, `CAST (1 AS INTEGER)`, &sql.CastExpr{
			Cast:   pos(0),
			Lparen: pos(5),
			X:      &sql.NumberLit{ValuePos: pos(6), Value: "1"},
			As:     pos(8),
			Type:   &sql.Type{Name: &sql.Ident{NamePos: pos(11), Name: "INTEGER"}},
			Rparen: pos(18),
		})

		AssertParseExpr(t, `CAST (20 AS SOME TYPE)`, &sql.CastExpr{
			Cast:   pos(0),
			Lparen: pos(5),
			X:      &sql.NumberLit{ValuePos: pos(6), Value: "20"},
			As:     pos(9),
			Type:   &sql.Type{Name: &sql.Ident{NamePos: pos(12), Name: "SOME TYPE"}},
			Rparen: pos(21),
		})

		AssertParseExprError(t, `CAST`, `1:4: expected left paren, found 'EOF'`)
		AssertParseExprError(t, `CAST (`, `1:6: expected expression, found 'EOF'`)
		AssertParseExprError(t, `CAST (1`, `1:7: expected AS, found 'EOF'`)
		AssertParseExprError(t, `CAST (1 AS`, `1:10: expected type name, found 'EOF'`)
		AssertParseExprError(t, `CAST (1 AS INTEGER`, `1:18: expected right paren, found 'EOF'`)
	})

	t.Run("Case", func(t *testing.T) {
		AssertParseExpr(t, `CASE 1 WHEN 2 THEN 3 WHEN 4 THEN 5 ELSE 6 END`, &sql.CaseExpr{
			Case:    pos(0),
			Operand: &sql.NumberLit{ValuePos: pos(5), Value: "1"},
			Blocks: []*sql.CaseBlock{
				{
					When:      pos(7),
					Condition: &sql.NumberLit{ValuePos: pos(12), Value: "2"},
					Then:      pos(14),
					Body:      &sql.NumberLit{ValuePos: pos(19), Value: "3"},
				},
				{
					When:      pos(21),
					Condition: &sql.NumberLit{ValuePos: pos(26), Value: "4"},
					Then:      pos(28),
					Body:      &sql.NumberLit{ValuePos: pos(33), Value: "5"},
				},
			},
			Else:     pos(35),
			ElseExpr: &sql.NumberLit{ValuePos: pos(40), Value: "6"},
			End:      pos(42),
		})
		AssertParseExpr(t, `CASE WHEN 1 THEN 2 END`, &sql.CaseExpr{
			Case: pos(0),
			Blocks: []*sql.CaseBlock{
				{
					When:      pos(5),
					Condition: &sql.NumberLit{ValuePos: pos(10), Value: "1"},
					Then:      pos(12),
					Body:      &sql.NumberLit{ValuePos: pos(17), Value: "2"},
				},
			},
			End: pos(19),
		})
		AssertParseExpr(t, `CASE WHEN 1 IS NULL THEN 2 END`, &sql.CaseExpr{
			Case: pos(0),
			Blocks: []*sql.CaseBlock{
				{
					When: pos(5),
					Condition: &sql.Null{
						X:     &sql.NumberLit{ValuePos: pos(10), Value: "1"},
						Op:    sql.ISNULL,
						OpPos: pos(12),
					},
					Then: pos(20),
					Body: &sql.NumberLit{ValuePos: pos(25), Value: "2"},
				},
			},
			End: pos(27),
		})
		AssertParseExpr(t, `CASE WHEN 1 IS NOT NULL THEN 2 END`, &sql.CaseExpr{
			Case: pos(0),
			Blocks: []*sql.CaseBlock{
				{
					When: pos(5),
					Condition: &sql.Null{
						X:     &sql.NumberLit{ValuePos: pos(10), Value: "1"},
						Op:    sql.NOTNULL,
						OpPos: pos(12),
					},
					Then: pos(24),
					Body: &sql.NumberLit{ValuePos: pos(29), Value: "2"},
				},
			},
			End: pos(31),
		})
		AssertParseExprError(t, `CASE`, `1:4: expected expression, found 'EOF'`)
		AssertParseExprError(t, `CASE 1`, `1:6: expected WHEN, found 'EOF'`)
		AssertParseExprError(t, `CASE WHEN`, `1:9: expected expression, found 'EOF'`)
		AssertParseExprError(t, `CASE WHEN 1`, `1:11: expected THEN, found 'EOF'`)
		AssertParseExprError(t, `CASE WHEN 1 THEN`, `1:16: expected expression, found 'EOF'`)
		AssertParseExprError(t, `CASE WHEN 1 THEN 2`, `1:18: expected WHEN, ELSE or END, found 'EOF'`)
		AssertParseExprError(t, `CASE WHEN 1 THEN 2 ELSE`, `1:23: expected expression, found 'EOF'`)
		AssertParseExprError(t, `CASE WHEN 1 THEN 2 ELSE 3`, `1:25: expected END, found 'EOF'`)
	})

	t.Run("Raise", func(t *testing.T) {
		AssertParseExpr(t, `RAISE(IGNORE)`, &sql.Raise{
			Raise:  pos(0),
			Lparen: pos(5),
			Ignore: pos(6),
			Rparen: pos(12),
		})
		AssertParseExpr(t, `RAISE(ROLLBACK, 'bad error')`, &sql.Raise{
			Raise:    pos(0),
			Lparen:   pos(5),
			Rollback: pos(6),
			Comma:    pos(14),
			Error:    &sql.StringLit{ValuePos: pos(16), Value: "bad error"},
			Rparen:   pos(27),
		})
		AssertParseExpr(t, `RAISE(ABORT, 'error')`, &sql.Raise{
			Raise:  pos(0),
			Lparen: pos(5),
			Abort:  pos(6),
			Comma:  pos(11),
			Error:  &sql.StringLit{ValuePos: pos(13), Value: "error"},
			Rparen: pos(20),
		})
		AssertParseExpr(t, `RAISE(FAIL, 'error')`, &sql.Raise{
			Raise:  pos(0),
			Lparen: pos(5),
			Fail:   pos(6),
			Comma:  pos(10),
			Error:  &sql.StringLit{ValuePos: pos(12), Value: "error"},
			Rparen: pos(19),
		})
		AssertParseExprError(t, `RAISE`, `1:5: expected left paren, found 'EOF'`)
		AssertParseExprError(t, `RAISE(`, `1:6: expected IGNORE, ROLLBACK, ABORT, or FAIL, found 'EOF'`)
		AssertParseExprError(t, `RAISE(IGNORE`, `1:12: expected right paren, found 'EOF'`)
		AssertParseExprError(t, `RAISE(ROLLBACK`, `1:14: expected comma, found 'EOF'`)
		AssertParseExprError(t, `RAISE(ROLLBACK,`, `1:15: expected error message, found 'EOF'`)
	})
}

// Ensure the parser returns an error on pathologically nested input instead
// of overflowing the stack.
func TestParser_DepthLimit(t *testing.T) {
	t.Run("NestedExprOK", func(t *testing.T) {
		AssertParseStatements(t, `SELECT `+strings.Repeat("(", 900)+`1`+strings.Repeat(")", 900), 1)
	})
	t.Run("NestedExpr", func(t *testing.T) {
		s := `SELECT ` + strings.Repeat("(", 2000) + `1` + strings.Repeat(")", 2000)
		AssertParseStatementsError(t, s, `parse tree is too deep (maximum depth 1000)`)
	})
	t.Run("NestedUnary", func(t *testing.T) {
		s := `SELECT ` + strings.Repeat("NOT ", 2000) + `1`
		AssertParseStatementsError(t, s, `parse tree is too deep (maximum depth 1000)`)
	})
	t.Run("NestedSourceOK", func(t *testing.T) {
		AssertParseStatements(t, `SELECT * FROM `+strings.Repeat("(", 500)+`tbl`+strings.Repeat(")", 500), 1)
	})
	t.Run("NestedSource", func(t *testing.T) {
		s := `SELECT * FROM ` + strings.Repeat("(", 2000) + `tbl` + strings.Repeat(")", 2000)
		AssertParseStatementsError(t, s, `parse tree is too deep (maximum depth 1000)`)
	})

	// The depth counter must reset between statements.
	t.Run("MultipleStatements", func(t *testing.T) {
		stmt := `SELECT ` + strings.Repeat("(", 800) + `1` + strings.Repeat(")", 800) + `; `
		AssertParseStatements(t, strings.Repeat(stmt, 3), 3)
	})
}

// Ensure schema-qualified table-valued functions are accepted where sqlite3
// accepts them: in FROM and as the right hand side of IN. A schema-qualified
// ordinary function call is a syntax error in sqlite3 and is rejected here too.
func TestParser_SchemaQualifiedFunctions(t *testing.T) {
	stmt := ParseStatementOrFail(t, `SELECT 1 FROM main.json_each('[1]') AS j WHERE 2 IN main.tf(3)`).(*sql.SelectStatement)
	if fn, ok := stmt.Source.(*sql.QualifiedTableFunctionName); !ok {
		t.Fatalf("source: expected *sql.QualifiedTableFunctionName, got %T", stmt.Source)
	} else if diff := deepEqual(fn, &sql.QualifiedTableFunctionName{
		Schema: &sql.Ident{Name: "main", NamePos: pos(14)},
		Dot:    pos(18),
		Name:   &sql.Ident{Name: "json_each", NamePos: pos(19)},
		Lparen: pos(28),
		Args:   []sql.Expr{&sql.StringLit{Value: "[1]", ValuePos: pos(29)}},
		Rparen: pos(34),
		As:     pos(36),
		Alias:  &sql.Ident{Name: "j", NamePos: pos(39)},
	}); diff != "" {
		t.Fatal(diff)
	}
	if in, ok := stmt.WhereExpr.(*sql.BinaryExpr); !ok || in.Op != sql.IN {
		t.Fatalf("where: expected IN expression, got %s", stmt.WhereExpr.String())
	} else if diff := deepEqual(in.Y, &sql.Call{
		Schema: &sql.Ident{Name: "main", NamePos: pos(52)},
		Dot:    pos(56),
		Name:   &sql.Ident{Name: "tf", NamePos: pos(57)},
		Lparen: pos(59),
		Args:   []sql.Expr{&sql.NumberLit{Value: "3", ValuePos: pos(60)}},
		Rparen: pos(61),
	}); diff != "" {
		t.Fatal(diff)
	}
	if got, want := stmt.String(), `SELECT 1 FROM "main"."json_each"('[1]') AS "j" WHERE 2 IN "main".tf(3)`; got != want {
		t.Fatalf("String()=%s, want %s", got, want)
	}

	AssertParseStatementError(t, `SELECT main.func(1)`, `1:17: expected semicolon or EOF, found '('`)

	// Plain column references are unaffected.
	AssertParseExpr(t, `tbl.col`, &sql.QualifiedRef{
		Table:  &sql.Ident{Name: "tbl", NamePos: pos(0)},
		Dot:    pos(3),
		Column: &sql.Ident{Name: "col", NamePos: pos(4)},
	})
}

// Ensure schema-qualified object names are accepted wherever SQLite allows them.
func TestParser_SchemaQualifiedNames(t *testing.T) {
	for _, tt := range []struct {
		s      string
		schema func(sql.Statement) (*sql.Ident, *sql.Ident)
	}{
		{`CREATE VIEW main.v AS SELECT 1`, func(st sql.Statement) (*sql.Ident, *sql.Ident) {
			v := st.(*sql.CreateViewStatement)
			return v.Schema, v.Name
		}},
		{`CREATE TRIGGER main.trg BEFORE DELETE ON t BEGIN SELECT 1; END`, func(st sql.Statement) (*sql.Ident, *sql.Ident) {
			v := st.(*sql.CreateTriggerStatement)
			return v.Schema, v.Name
		}},
		{`DROP TRIGGER IF EXISTS main.trg`, func(st sql.Statement) (*sql.Ident, *sql.Ident) {
			v := st.(*sql.DropTriggerStatement)
			return v.Schema, v.Name
		}},
		{`ANALYZE main.t`, func(st sql.Statement) (*sql.Ident, *sql.Ident) {
			v := st.(*sql.AnalyzeStatement)
			return v.Schema, v.Name
		}},
		{`DROP VIEW IF EXISTS main.v`, func(st sql.Statement) (*sql.Ident, *sql.Ident) {
			v := st.(*sql.DropViewStatement)
			return v.Schema, v.Name
		}},
		{`CREATE TRIGGER trg AFTER INSERT ON main.t BEGIN SELECT 1; END`, func(st sql.Statement) (*sql.Ident, *sql.Ident) {
			v := st.(*sql.CreateTriggerStatement)
			return v.TableSchema, v.Table
		}},
	} {
		stmt, err := sql.NewParser(strings.NewReader(tt.s)).ParseStatement()
		if err != nil {
			t.Errorf("%s: %v", tt.s, err)
			continue
		}
		schema, name := tt.schema(stmt)
		if schema == nil || schema.Name != "main" {
			t.Errorf("%s: schema=%v, want main", tt.s, schema)
		} else if name == nil || name.Name == "main" {
			t.Errorf("%s: name=%v", tt.s, name)
		}
		// Round trip.
		if stmt2, err := sql.NewParser(strings.NewReader(stmt.String())).ParseStatement(); err != nil {
			t.Errorf("%s: cannot re-parse %q: %v", tt.s, stmt.String(), err)
		} else if stmt2.String() != stmt.String() {
			t.Errorf("%s: unstable: %q != %q", tt.s, stmt.String(), stmt2.String())
		}
	}
}

// Ensure virtual table module arguments accept the forms FTS5 and other
// modules use: a column with a type-like word (UNINDEXED), a quoted or string
// name, an option assigned a function-call value, and no arguments at all.
func TestParser_ModuleArguments(t *testing.T) {
	// A real FTS5 declaration that sqlite3 executes, as does its String().
	stmt := ParseStatementOrFail(t, `CREATE VIRTUAL TABLE ft USING fts5(a UNINDEXED, 'b c', tokenize=porter, prefix='2 3')`).(*sql.CreateVirtualTableStatement)
	if len(stmt.Arguments) != 4 {
		t.Fatalf("expected 4 arguments, got %d", len(stmt.Arguments))
	}
	if got := stmt.Arguments[0].Type.Name.Name; got != "UNINDEXED" {
		t.Errorf("arg 0 type=%q, want UNINDEXED", got)
	}
	if got := stmt.Arguments[1].Name.Name; got != "b c" {
		t.Errorf("arg 1 name=%q, want %q", got, "b c")
	}
	if _, ok := stmt.Arguments[2].Literal.(*sql.Ident); !ok {
		t.Errorf("arg 2 value=%T, want *sql.Ident", stmt.Arguments[2].Literal)
	}
	if got, want := stmt.String(), `CREATE VIRTUAL TABLE "ft" USING "fts5" (a UNINDEXED,"b c",tokenize="porter",prefix='2 3')`; got != want {
		t.Fatalf("String()=%s, want %s", got, want)
	}
	if _, err := sql.NewParser(strings.NewReader(stmt.String())).ParseStatement(); err != nil {
		t.Fatalf("cannot re-parse %q: %v", stmt.String(), err)
	}
	// An empty argument list (dbstat takes none).
	stmt = ParseStatementOrFail(t, `CREATE VIRTUAL TABLE s USING dbstat()`).(*sql.CreateVirtualTableStatement)
	if len(stmt.Arguments) != 0 || stmt.String() != `CREATE VIRTUAL TABLE "s" USING "dbstat" ()` {
		t.Fatalf("unexpected: %s", stmt.String())
	}
	// R*Tree auxiliary columns are introduced by a "+" prefix.
	stmt = ParseStatementOrFail(t, `CREATE VIRTUAL TABLE r USING rtree(id, minX, maxX, +label TEXT, +other)`).(*sql.CreateVirtualTableStatement)
	if len(stmt.Arguments) != 5 || !stmt.Arguments[3].Plus.IsValid() || stmt.Arguments[3].Name.Name != "label" || stmt.Arguments[3].Type.Name.Name != "TEXT" || !stmt.Arguments[4].Plus.IsValid() {
		t.Fatalf("unexpected rtree arguments: %s", stmt.String())
	}
	if got, want := stmt.String(), `CREATE VIRTUAL TABLE "r" USING "rtree" (id,minX,maxX,+label TEXT,+other)`; got != want {
		t.Fatalf("String()=%s, want %s", got, want)
	}
	// An option whose value is a call parses as a Call.
	stmt = ParseStatementOrFail(t, `CREATE VIRTUAL TABLE vtbl USING mdl(c=d(e))`).(*sql.CreateVirtualTableStatement)
	if _, ok := stmt.Arguments[0].Literal.(*sql.Call); !ok {
		t.Errorf("value=%T, want *sql.Call", stmt.Arguments[0].Literal)
	}
}

// Ensure a string literal is accepted as a column or table alias, as sqlite3
// allows (as ::= AS nm | ids, where ids includes STRING).
func TestParser_StringAlias(t *testing.T) {
	stmt := ParseStatementOrFail(t, `SELECT x 'lbl', y AS 'lbl2' FROM t 'a' JOIN json_each('[1]') 'j'`).(*sql.SelectStatement)
	if diff := deepEqual(stmt.Columns[0].Alias, &sql.Ident{Name: "lbl", NamePos: pos(9), Quoted: true}); diff != "" {
		t.Fatal(diff)
	}
	if diff := deepEqual(stmt.Columns[1].Alias, &sql.Ident{Name: "lbl2", NamePos: pos(21), Quoted: true}); diff != "" {
		t.Fatal(diff)
	}
	join := stmt.Source.(*sql.JoinClause)
	if alias := join.X.(*sql.QualifiedTableName).Alias; alias == nil || alias.Name != "a" {
		t.Fatalf("table alias=%v, want a", alias)
	}
	if alias := join.Y.(*sql.QualifiedTableFunctionName).Alias; alias == nil || alias.Name != "j" {
		t.Fatalf("table function alias=%v, want j", alias)
	}
	if got, want := stmt.String(), `SELECT "x" AS "lbl", "y" AS "lbl2" FROM "t" AS "a" JOIN "json_each"('[1]') AS "j"`; got != want {
		t.Fatalf("String()=%s, want %s", got, want)
	}
}

// Ensure a bind parameter prefix without a name is rejected.
func TestParser_EmptyBindName(t *testing.T) {
	AssertParseStatementError(t, `SELECT $`, `1:8: expected expression, found 'ILLEGAL'`)
	AssertParseStatementError(t, `SELECT * FROM t WHERE x = :`, `1:27: expected expression, found 'ILLEGAL'`)
}

// Ensure HAVING is accepted without GROUP BY, as SQLite 3.39+ allows.
func TestParser_HavingWithoutGroupBy(t *testing.T) {
	stmt := ParseStatementOrFail(t, `SELECT count(*) FROM t HAVING count(*) > 1`).(*sql.SelectStatement)
	if stmt.HavingExpr == nil || stmt.GroupByExprs != nil {
		t.Fatalf("expected HAVING without GROUP BY, got %s", stmt.String())
	}
	if got, want := stmt.String(), `SELECT count(*) FROM "t" HAVING count(*) > 1`; got != want {
		t.Fatalf("String()=%s, want %s", got, want)
	}
}

// Ensure empty statements (stray semicolons) are skipped, as sqlite3 does.
func TestParser_EmptyStatements(t *testing.T) {
	AssertParseStatements(t, `;`, 0)
	AssertParseStatements(t, `;;`, 0)
	AssertParseStatements(t, `SELECT 1;; SELECT 2`, 2)
	AssertParseStatements(t, `; SELECT 1;`, 1)
}

func TestParser_Vacuum(t *testing.T) {
	AssertParseStatement(t, `VACUUM`, &sql.VacuumStatement{Vacuum: pos(0)})
	AssertParseStatement(t, `VACUUM main`, &sql.VacuumStatement{Vacuum: pos(0), Schema: &sql.Ident{Name: "main", NamePos: pos(7)}})
	AssertParseStatement(t, `VACUUM INTO 'f'`, &sql.VacuumStatement{Vacuum: pos(0), Into: pos(7), Filename: &sql.StringLit{Value: "f", ValuePos: pos(12)}})
	AssertParseStatement(t, `VACUUM main INTO 'f'`, &sql.VacuumStatement{
		Vacuum:   pos(0),
		Schema:   &sql.Ident{Name: "main", NamePos: pos(7)},
		Into:     pos(12),
		Filename: &sql.StringLit{Value: "f", ValuePos: pos(17)},
	})
	AssertParseStatementError(t, `VACUUM INTO`, "1:11: expected expression, found 'EOF'")
}

func TestParser_Attach(t *testing.T) {
	AssertParseStatement(t, `ATTACH 'f' AS d`, &sql.AttachStatement{
		Attach: pos(0),
		Expr:   &sql.StringLit{Value: "f", ValuePos: pos(7)},
		As:     pos(11),
		Schema: &sql.Ident{Name: "d", NamePos: pos(14)},
	})
	AssertParseStatement(t, `ATTACH DATABASE 'f' AS d KEY 'k'`, &sql.AttachStatement{
		Attach:   pos(0),
		Database: pos(7),
		Expr:     &sql.StringLit{Value: "f", ValuePos: pos(16)},
		As:       pos(20),
		Schema:   &sql.Ident{Name: "d", NamePos: pos(23)},
		Key:      pos(25),
		KeyExpr:  &sql.StringLit{Value: "k", ValuePos: pos(29)},
	})
	AssertParseStatementError(t, `ATTACH 'f'`, "1:10: expected AS, found 'EOF'")
	AssertParseStatementError(t, `ATTACH 'f' AS`, "1:13: expected schema name, found 'EOF'")
}

func TestParser_Detach(t *testing.T) {
	AssertParseStatement(t, `DETACH d`, &sql.DetachStatement{Detach: pos(0), Schema: &sql.Ident{Name: "d", NamePos: pos(7)}})
	AssertParseStatement(t, `DETACH DATABASE d`, &sql.DetachStatement{Detach: pos(0), Database: pos(7), Schema: &sql.Ident{Name: "d", NamePos: pos(16)}})
	AssertParseStatementError(t, `DETACH`, "1:6: expected schema name, found 'EOF'")
}

// Ensure the SELECT of an INSERT may itself begin with a WITH clause.
func TestParser_InsertWithSelect(t *testing.T) {
	stmt := ParseStatementOrFail(t, `INSERT INTO t (x) WITH c AS (SELECT 1) SELECT * FROM c`).(*sql.InsertStatement)
	if stmt.Select == nil || stmt.Select.WithClause == nil || len(stmt.Select.WithClause.CTEs) != 1 {
		t.Fatalf("expected select with one CTE, got %s", stmt.String())
	}
	if got, want := stmt.String(), `INSERT INTO "t" ("x") WITH "c" AS (SELECT 1) SELECT * FROM "c"`; got != want {
		t.Fatalf("String()=%s, want %s", got, want)
	}
}

// Ensure an INSERT may carry several ON CONFLICT clauses. Only the last may
// omit the conflict target, as in sqlite3.
func TestParser_MultipleUpsertClauses(t *testing.T) {
	stmt := ParseStatementOrFail(t, `INSERT INTO t VALUES (1, 2) ON CONFLICT (x) DO NOTHING ON CONFLICT (y) DO UPDATE SET x = 1 ON CONFLICT DO NOTHING`).(*sql.InsertStatement)
	if len(stmt.UpsertClauses) != 3 {
		t.Fatalf("expected 3 upsert clauses, got %d", len(stmt.UpsertClauses))
	}
	if got, want := stmt.String(), `INSERT INTO "t" VALUES (1, 2) ON CONFLICT ("x") DO NOTHING ON CONFLICT ("y") DO UPDATE SET "x" = 1 ON CONFLICT DO NOTHING`; got != want {
		t.Fatalf("String()=%s, want %s", got, want)
	}
	if c := stmt.Clone(); len(c.UpsertClauses) != 3 || c.UpsertClauses[0] == stmt.UpsertClauses[0] {
		t.Fatal("Clone() did not deep copy upsert clauses")
	}
	AssertParseStatementError(t, `INSERT INTO t VALUES (1) ON CONFLICT DO NOTHING ON CONFLICT (x) DO NOTHING`, `1:49: expected semicolon or EOF, found 'ON'`)
}

// Ensure ORDER BY and LIMIT are rejected directly after a VALUES clause, as
// sqlite3 does, while still being accepted after a compound ending in SELECT.
func TestParser_ValuesOrderByLimit(t *testing.T) {
	AssertParseStatementError(t, `VALUES (1) ORDER BY 1`, `1:12: expected semicolon or EOF, found 'ORDER'`)
	AssertParseStatementError(t, `VALUES (1) LIMIT 1`, `1:12: expected semicolon or EOF, found 'LIMIT'`)
	AssertParseStatementError(t, `SELECT 1 UNION VALUES (2) LIMIT 1`, `1:27: expected semicolon or EOF, found 'LIMIT'`)
	stmt := ParseStatementOrFail(t, `VALUES (1), (2) UNION ALL SELECT 3 ORDER BY 1 LIMIT 2`)
	if got, want := stmt.String(), `VALUES (1), (2) UNION ALL SELECT 3 ORDER BY 1 LIMIT 2`; got != want {
		t.Fatalf("String()=%s, want %s", got, want)
	}
}

// Ensure TCL-style bind parameters with "::" and "(...)" suffixes parse.
func TestParser_TclBindParameters(t *testing.T) {
	AssertParseExpr(t, `$v::int`, &sql.BindExpr{Name: "$v::int", NamePos: pos(0)})
	stmt := ParseStatementOrFail(t, `SELECT $v::int, $v(1) FROM t`)
	if got, want := stmt.String(), `SELECT $v::int, $v(1) FROM "t"`; got != want {
		t.Fatalf("String()=%s, want %s", got, want)
	}
}

// Ensure COLLATE clauses may be chained, as sqlite3 allows.
func TestParser_ChainedCollate(t *testing.T) {
	AssertParseExpr(t, `x COLLATE NOCASE COLLATE BINARY`, &sql.CollateExpr{
		X: &sql.CollateExpr{
			X:         &sql.Ident{Name: "x", NamePos: pos(0)},
			Collation: &sql.CollationClause{Collate: pos(2), Name: &sql.Ident{Name: "NOCASE", NamePos: pos(10)}},
		},
		Collation: &sql.CollationClause{Collate: pos(17), Name: &sql.Ident{Name: "BINARY", NamePos: pos(25)}},
	})
	stmt := ParseStatementOrFail(t, `SELECT x COLLATE NOCASE COLLATE BINARY FROM t`)
	if got, want := stmt.String(), `SELECT "x" COLLATE "NOCASE" COLLATE "BINARY" FROM "t"`; got != want {
		t.Fatalf("String()=%s, want %s", got, want)
	}
}

// Ensure identifiers may contain non-ASCII characters and '$', as in SQLite.
func TestParser_NonASCIIIdents(t *testing.T) {
	stmt := ParseStatementOrFail(t, `SELECT 日本語, café, a$b FROM (SELECT 1 AS 日本語, 2 AS café, 3 AS a$b)`).(*sql.SelectStatement)
	if got, want := stmt.String(), `SELECT "日本語", "café", "a$b" FROM (SELECT 1 AS "日本語", 2 AS "café", 3 AS "a$b")`; got != want {
		t.Fatalf("String()=%s, want %s", got, want)
	}
	AssertParseExpr(t, `ü`, &sql.Ident{Name: "ü", NamePos: pos(0)})
}

// Ensure a CONSTRAINT name with no constraint after it is accepted (SQLite
// ignores it) rather than crashing the parser, and that a name followed by
// something that is not a constraint is a parse error.
func TestParser_EmptyConstraint(t *testing.T) {
	stmt := ParseStatementOrFail(t, `CREATE TABLE tbl (col1 INTEGER CONSTRAINT c, col2 CONSTRAINT d NOT NULL, CONSTRAINT e)`).(*sql.CreateTableStatement)
	if diff := deepEqual(stmt.Columns[0].Constraints, []sql.Constraint{
		&sql.EmptyConstraint{Constraint: pos(31), Name: &sql.Ident{Name: "c", NamePos: pos(42)}},
	}); diff != "" {
		t.Fatal(diff)
	}
	if diff := deepEqual(stmt.Columns[1].Constraints, []sql.Constraint{
		&sql.NotNullConstraint{Constraint: pos(50), Name: &sql.Ident{Name: "d", NamePos: pos(61)}, Not: pos(63), Null: pos(67)},
	}); diff != "" {
		t.Fatal(diff)
	}
	if diff := deepEqual(stmt.Constraints, []sql.Constraint{
		&sql.EmptyConstraint{Constraint: pos(73), Name: &sql.Ident{Name: "e", NamePos: pos(84)}},
	}); diff != "" {
		t.Fatal(diff)
	}
	if got, want := stmt.String(), `CREATE TABLE "tbl" ("col1" INTEGER CONSTRAINT "c", "col2" CONSTRAINT "d" NOT NULL, CONSTRAINT "e")`; got != want {
		t.Fatalf("String()=%s, want %s", got, want)
	}
	AssertParseStatementError(t, `CREATE TABLE tbl (col1 INTEGER CONSTRAINT c FOO)`, `1:45: expected PRIMARY KEY, NOT NULL, UNIQUE, CHECK, DEFAULT, COLLATE, REFERENCES, or GENERATED, found FOO`)
	AssertParseStatementError(t, `CREATE TABLE tbl (col1, CONSTRAINT c FOO)`, `1:38: expected PRIMARY KEY, UNIQUE, CHECK, or FOREIGN KEY, found FOO`)
}

// Ensure a DEFAULT value may be a bare identifier, which SQLite stores as a
// string: `DEFAULT abc` is the same as `DEFAULT 'abc'`.
func TestParser_DefaultIdent(t *testing.T) {
	stmt := ParseStatementOrFail(t, `CREATE TABLE tbl (col1 TEXT DEFAULT abc, col2 TEXT DEFAULT key)`).(*sql.CreateTableStatement)
	if diff := deepEqual(stmt.Columns[0].Constraints[0], &sql.DefaultConstraint{
		Default: pos(28),
		Expr:    &sql.Ident{NamePos: pos(36), Name: "abc"},
	}); diff != "" {
		t.Fatal(diff)
	}
	if got, want := stmt.String(), `CREATE TABLE "tbl" ("col1" TEXT DEFAULT abc, "col2" TEXT DEFAULT key)`; got != want {
		t.Fatalf("String()=%s, want %s", got, want)
	}
	AssertParseStatementError(t, `CREATE TABLE tbl (col1 TEXT DEFAULT)`, `1:36: expected literal value, identifier or left paren, found ')'`)
}

// Ensure type names may be quoted identifiers, string literals or fallback
// keywords, as sqlite3 allows (typename ::= ids | typename ids).
func TestParser_TypeNames(t *testing.T) {
	for _, tt := range []struct{ s, typ string }{
		{`CREATE TABLE tbl (col1 "my type")`, "my type"},
		{`CREATE TABLE tbl (col1 'my type')`, "my type"},
		{"CREATE TABLE tbl (col1 `bt type`(10))", "bt type"},
		{`CREATE TABLE tbl (col1 key)`, "key"},
		{`CREATE TABLE tbl (col1 INTEGER key)`, "INTEGER key"},
		{`CREATE TABLE tbl (col1 UNSIGNED BIG INT NOT NULL)`, "UNSIGNED BIG INT"},
	} {
		stmt := ParseStatementOrFail(t, tt.s).(*sql.CreateTableStatement)
		if len(stmt.Columns) != 1 {
			t.Errorf("%s: expected 1 column, got %d", tt.s, len(stmt.Columns))
		} else if got := stmt.Columns[0].Type.Name.Name; got != tt.typ {
			t.Errorf("%s: type=%q, want %q", tt.s, got, tt.typ)
		}
		if _, err := sql.NewParser(strings.NewReader(stmt.String())).ParseStatement(); err != nil {
			t.Errorf("%s: cannot re-parse %q: %v", tt.s, stmt.String(), err)
		}
	}
	// GENERATED starts a constraint and is never part of a type name.
	stmt := ParseStatementOrFail(t, `CREATE TABLE tbl (col1 INTEGER GENERATED ALWAYS AS (1), col2)`).(*sql.CreateTableStatement)
	if got := stmt.Columns[0].Type.Name.Name; got != "INTEGER" {
		t.Errorf("type=%q, want INTEGER", got)
	} else if len(stmt.Columns[0].Constraints) != 1 {
		t.Errorf("expected generated constraint, got %v", stmt.Columns[0].Constraints)
	}
	// The type of a CAST may be empty, as sqlite3 allows.
	AssertParseExpr(t, `CAST(1 AS)`, &sql.CastExpr{
		Cast:   pos(0),
		Lparen: pos(4),
		X:      &sql.NumberLit{Value: "1", ValuePos: pos(5)},
		As:     pos(7),
		Rparen: pos(9),
	})
	if e, err := sql.NewParser(strings.NewReader(`CAST(1 AS "weird type")`)).ParseExpr(); err != nil {
		t.Fatal(err)
	} else if got := e.(*sql.CastExpr).Type.Name.Name; got != "weird type" {
		t.Errorf("CAST type=%q, want %q", got, "weird type")
	}
}

// Ensure rowid and fallback keywords are accepted as column names after a dot
// and in INSERT column lists, as sqlite3 does.
func TestParser_RowidAndKeywordColumns(t *testing.T) {
	AssertParseExpr(t, `t.rowid`, &sql.QualifiedRef{
		Table:  &sql.Ident{Name: "t", NamePos: pos(0)},
		Dot:    pos(1),
		Column: &sql.Ident{Name: "rowid", NamePos: pos(2)},
	})
	AssertParseExpr(t, `main.t.key`, &sql.QualifiedRef{
		Schema:    &sql.Ident{Name: "main", NamePos: pos(0)},
		SchemaPos: pos(4),
		Table:     &sql.Ident{Name: "t", NamePos: pos(5)},
		Dot:       pos(6),
		Column:    &sql.Ident{Name: "key", NamePos: pos(7)},
	})
	for _, s := range []string{
		`INSERT INTO t (rowid, x) VALUES (1, 2)`,
		`UPDATE t SET rowid = 1`,
		`SELECT t.rowid, t.key FROM t`,
	} {
		stmt, err := sql.NewParser(strings.NewReader(s)).ParseStatement()
		if err != nil {
			t.Errorf("%s: %v", s, err)
		} else if _, err := sql.NewParser(strings.NewReader(stmt.String())).ParseStatement(); err != nil {
			t.Errorf("%s: cannot re-parse %q: %v", s, stmt.String(), err)
		}
	}
}

// Ensure names that are not SQLite keywords can be used as identifiers.
func TestParser_NonKeywordIdents(t *testing.T) {
	for _, s := range []string{
		`SELECT vector, span, truth FROM tbl`,
		`SELECT function, register, variable FROM tbl`,
		`CREATE TABLE tbl (vector BLOB, strict INTEGER, stored TEXT)`,
		`SELECT * FROM vector WHERE span > 1`,
		`SELECT [a b], [c] FROM [my table]`,
	} {
		stmt, err := sql.NewParser(strings.NewReader(s)).ParseStatement()
		if err != nil {
			t.Errorf("%s: %v", s, err)
		} else if _, err := sql.NewParser(strings.NewReader(stmt.String())).ParseStatement(); err != nil {
			t.Errorf("%s: cannot re-parse %q: %v", s, stmt.String(), err)
		}
	}
}

// Ensure operators that are not valid binary operators are rejected rather
// than accepted as expressions that cannot be re-serialized.
func TestParser_InvalidBinaryOp(t *testing.T) {
	AssertParseStatementError(t, `SELECT 1 ~ 2`, `1:10: expected semicolon or EOF, found '~'`)
	AssertParseStatementError(t, `SELECT 1 ESCAPE 2`, `1:10: expected semicolon or EOF, found 'ESCAPE'`)
	AssertParseStatementError(t, `SELECT * FROM tbl WHERE x = 'y' ESCAPE '@'`, `1:33: expected semicolon or EOF, found 'ESCAPE'`)
}

func TestError_Error(t *testing.T) {
	err := &sql.Error{Msg: "test"}
	if got, want := err.Error(), `test`; got != want {
		t.Fatalf("Error()=%s, want %s", got, want)
	}
}

// ParseStatementOrFail parses a statement from s. Fail on error.
func ParseStatementOrFail(tb testing.TB, s string) sql.Statement {
	tb.Helper()
	stmt, err := sql.NewParser(strings.NewReader(s)).ParseStatement()
	if err != nil {
		tb.Fatal(err)
	}
	return stmt
}

// AssertParseStatement asserts the value of the first parse of s.
func AssertParseStatement(tb testing.TB, s string, want sql.Statement) {
	tb.Helper()
	stmt, err := sql.NewParser(strings.NewReader(s)).ParseStatement()
	if err != nil {
		tb.Fatal(err)
	} else if diff := deep.Equal(stmt, want); diff != nil {
		tb.Fatalf("mismatch:\n%s", strings.Join(diff, "\n"))
	}
}

// AssertParseStatementError asserts s parses to a given error string.
func AssertParseStatementError(tb testing.TB, s string, want string) {
	tb.Helper()
	_, err := sql.NewParser(strings.NewReader(s)).ParseStatement()
	if err == nil || err.Error() != want {
		tb.Fatalf("ParseStatement()=%q, want %q", err, want)
	}
}

// AssertParseStatements asserts the count of statements parsed from s.
func AssertParseStatements(tb testing.TB, s string, wantCount int) {
	tb.Helper()
	stmts, err := sql.NewParser(strings.NewReader(s)).ParseStatements()
	if err != nil {
		tb.Fatal(err)
	} else if len(stmts) != wantCount {
		tb.Fatalf("ParseStatements()=%d statements, want %d", len(stmts), wantCount)
	}
}

// AssertParseStatementsError asserts s parses to a given error substring.
func AssertParseStatementsError(tb testing.TB, s string, wantSubstring string) {
	tb.Helper()
	_, err := sql.NewParser(strings.NewReader(s)).ParseStatements()
	if err == nil {
		tb.Fatal("ParseStatements() expected error, got nil")
	}
	if !strings.Contains(err.Error(), wantSubstring) {
		tb.Fatalf("ParseStatements() error=%q, want error containing %q", err, wantSubstring)
	}
}

// ParseExprOrFail parses a expression from s. Fail on error.
func ParseExprOrFail(tb testing.TB, s string) sql.Expr {
	tb.Helper()
	stmt, err := sql.NewParser(strings.NewReader(s)).ParseExpr()
	if err != nil {
		tb.Fatal(err)
	}
	return stmt
}

// AssertParseExpr asserts the value of the first parse of s.
func AssertParseExpr(tb testing.TB, s string, want sql.Expr) {
	tb.Helper()
	stmt, err := sql.NewParser(strings.NewReader(s)).ParseExpr()
	if err != nil {
		tb.Fatal(err)
	} else if diff := deep.Equal(stmt, want); diff != nil {
		tb.Fatalf("mismatch:\n%s", strings.Join(diff, "\n"))
	}
}

// AssertParseExprError asserts s parses to a given error string.
func AssertParseExprError(tb testing.TB, s string, want string) {
	tb.Helper()
	_, err := sql.NewParser(strings.NewReader(s)).ParseExpr()
	if err == nil || err.Error() != want {
		tb.Fatalf("ParseExpr()=%q, want %q", err, want)
	}
}

// pos is a helper function for generating positions based on offset for one-line parsing.
func pos(offset int) sql.Pos {
	return sql.Pos{Offset: offset, Line: 1, Column: offset + 1}
}

func deepEqual(a, b interface{}) string {
	return strings.Join(deep.Equal(a, b), "\n")
}

func Benchmark_NewParser(b *testing.B) {
	s := `SELECT * FROM foo WHERE bar = 1 AND baz > 2 ORDER BY qux DESC LIMIT 10`
	for i := 0; i < b.N; i++ {
		parser := sql.NewParser(strings.NewReader(s))
		_, err := parser.ParseStatement()
		if err != nil {
			b.Fatal(err)
		}
	}
}