package sql

import (

"fmt"

"io"

"strings"

)

// maxParseDepth is the maximum nesting depth of expressions and sources.

// It bounds parser recursion so that pathologically nested input returns an

// error instead of overflowing the stack. It matches SQLite's default

// SQLITE_MAX_EXPR_DEPTH.

const maxParseDepth = 1000

// Parser represents a SQL parser.

type Parser struct {

s *Scanner

pos Pos // current position

tok Token // current token

lit string // current literal value

full bool // buffer full

depth int // expression & source nesting depth

}

// incDepth increments the nesting depth, returning an error at pos if the

// maximum is exceeded. Each call must be paired with a call to decDepth.

func (p *Parser) incDepth(pos Pos) error {

p.depth++

if p.depth > maxParseDepth {

return &Error{Pos: pos, Msg: fmt.Sprintf("parse tree is too deep (maximum depth %d)", maxParseDepth)}

}

return nil

}

func (p *Parser) decDepth() {

p.depth--

}

// NewParser returns a new instance of Parser that reads from r.

func NewParser(r io.RuneReader) *Parser {

return &Parser{

s: NewScanner(r),

}

}

// ParseExprString parses s into an expression. Returns nil if s is blank.

func ParseExprString(s string) (Expr, error) {

if s == "" {

return nil, nil

}

return NewParser(strings.NewReader(s)).ParseExpr()

}

// MustParseExprString parses s into an expression. Panic on error.

func MustParseExprString(s string) Expr {

expr, err := ParseExprString(s)

if err != nil {

panic(err)

}

return expr

}

func (p *Parser) ParseStatement() (stmt Statement, err error) {

switch tok := p.peek(); tok {

case EOF:

return nil, io.EOF

case EXPLAIN:

if stmt, err = p.parseExplainStatement(); err != nil {

return stmt, err

}

default:

if stmt, err = p.parseNonExplainStatement(); err != nil {

return stmt, err

}

}

// Read trailing semicolon or end of file.

if tok := p.peek(); tok != EOF && tok != SEMI {

return stmt, p.errorExpected(p.pos, p.tok, "semicolon or EOF")

}

p.scan()

return stmt, nil

}

func (p *Parser) ParseStatements() (stmts []Statement, err error) {

for {

// Skip empty statements.

for p.peek() == SEMI {

p.scan()

}

switch tok := p.peek(); tok {

case EOF:

return stmts, nil

case EXPLAIN:

if stmt, err := p.parseExplainStatement(); err != nil {

return nil, err

} else {

stmts = append(stmts, stmt)

}

default:

if stmt, err := p.parseNonExplainStatement(); err != nil {

return nil, err

} else {

stmts = append(stmts, stmt)

}

}

if tok := p.peek(); tok != EOF && tok != SEMI {

return stmts, p.errorExpected(p.pos, p.tok, "semicolon or EOF")

}

p.scan()

}

}

// parseExplain parses EXPLAIN [QUERY PLAN] STMT.

func (p *Parser) parseExplainStatement() (_ *ExplainStatement, err error) {

var tok Token

// Parse initial "EXPLAIN" token.

var stmt ExplainStatement

stmt.Explain, tok, _ = p.scan()

assert(tok == EXPLAIN)

// Parse optional "QUERY PLAN" tokens.

if p.peek() == QUERY {

stmt.Query, _, _ = p.scan()

if p.peek() != PLAN {

return &stmt, p.errorExpected(p.pos, p.tok, "PLAN")

}

stmt.QueryPlan, _, _ = p.scan()

}

// Parse statement to be explained.

if stmt.Stmt, err = p.parseNonExplainStatement(); err != nil {

return &stmt, err

}

return &stmt, nil

}

// parseStmt parses all statement types.

func (p *Parser) parseNonExplainStatement() (Statement, error) {

switch p.peek() {

case PRAGMA:

return p.parsePragmaStatement()

case ANALYZE:

return p.parseAnalyzeStatement()

case REINDEX:

return p.parseReindexStatement()

case ALTER:

return p.parseAlterTableStatement()

case BEGIN:

return p.parseBeginStatement()

case COMMIT, END:

return p.parseCommitStatement()

case ROLLBACK:

return p.parseRollbackStatement()

case SAVEPOINT:

return p.parseSavepointStatement()

case RELEASE:

return p.parseReleaseStatement()

case DETACH:

return p.parseDetachStatement()

case ATTACH:

return p.parseAttachStatement()

case VACUUM:

return p.parseVacuumStatement()

case CREATE:

return p.parseCreateStatement()

case DROP:

return p.parseDropStatement()

case SELECT, VALUES:

return p.parseSelectStatement(false, nil)

case INSERT, REPLACE:

return p.parseInsertStatement(false, nil)

case UPDATE:

return p.parseUpdateStatement(false, nil)

case DELETE:

return p.parseDeleteStatement(false, nil)

case WITH:

return p.parseWithStatement(false)

default:

return nil, p.errorExpected(p.pos, p.tok, "statement")

}

}

// parseWithStatement is called only from parseNonExplainStatement as we don't

// know what kind of statement we'll have after the CTEs (e.g. SELECT, INSERT, etc).

func (p *Parser) parseWithStatement(inTrigger bool) (Statement, error) {

withClause, err := p.parseWithClause()

if err != nil {

return nil, err

}

switch p.peek() {

case SELECT, VALUES:

return p.parseSelectStatement(false, withClause)

case INSERT, REPLACE:

return p.parseInsertStatement(inTrigger, withClause)

case UPDATE:

return p.parseUpdateStatement(inTrigger, withClause)

case DELETE:

return p.parseDeleteStatement(inTrigger, withClause)

default:

return nil, p.errorExpected(p.pos, p.tok, "SELECT, VALUES, INSERT, REPLACE, UPDATE, or DELETE")

}

}

func (p *Parser) parseBeginStatement() (*BeginStatement, error) {

assert(p.peek() == BEGIN)

var stmt BeginStatement

stmt.Begin, _, _ = p.scan()

// Parse transaction type.

switch p.peek() {

case DEFERRED:

stmt.Deferred, _, _ = p.scan()

case IMMEDIATE:

stmt.Immediate, _, _ = p.scan()

case EXCLUSIVE:

stmt.Exclusive, _, _ = p.scan()

}

// Parse optional TRANSCTION keyword.

if p.peek() == TRANSACTION {

stmt.Transaction, _, _ = p.scan()

}

return &stmt, nil

}

func (p *Parser) parseCommitStatement() (*CommitStatement, error) {

assert(p.peek() == COMMIT || p.peek() == END)

var stmt CommitStatement

if p.peek() == COMMIT {

stmt.Commit, _, _ = p.scan()

} else {

stmt.End, _, _ = p.scan()

}

if p.peek() == TRANSACTION {

stmt.Transaction, _, _ = p.scan()

}

return &stmt, nil

}

func (p *Parser) parseRollbackStatement() (_ *RollbackStatement, err error) {

assert(p.peek() == ROLLBACK)

var stmt RollbackStatement

stmt.Rollback, _, _ = p.scan()

// Parse optional "TRANSACTION".

if p.peek() == TRANSACTION {

stmt.Transaction, _, _ = p.scan()

}

// Parse optional "TO SAVEPOINT savepoint-name"

if p.peek() == TO {

stmt.To, _, _ = p.scan()

if p.peek() == SAVEPOINT {

stmt.Savepoint, _, _ = p.scan()

}

if stmt.SavepointName, err = p.parseIdent("savepoint name"); err != nil {

return &stmt, err

}

}

return &stmt, nil

}

func (p *Parser) parseSavepointStatement() (_ *SavepointStatement, err error) {

assert(p.peek() == SAVEPOINT)

var stmt SavepointStatement

stmt.Savepoint, _, _ = p.scan()

if stmt.Name, err = p.parseIdent("savepoint name"); err != nil {

return &stmt, err

}

return &stmt, nil

}

func (p *Parser) parseReleaseStatement() (_ *ReleaseStatement, err error) {

assert(p.peek() == RELEASE)

var stmt ReleaseStatement

stmt.Release, _, _ = p.scan()

if p.peek() == SAVEPOINT {

stmt.Savepoint, _, _ = p.scan()

}

if stmt.Name, err = p.parseIdent("savepoint name"); err != nil {

return &stmt, err

}

return &stmt, nil

}

func (p *Parser) parseCreateStatement() (Statement, error) {

assert(p.peek() == CREATE)

pos, tok, _ := p.scan()

// Optional TEMP/TEMPORARY applies to tables, views and triggers only.

var tempPos Pos

if p.peek() == TEMP || p.peek() == TEMPORARY {

tempPos, _, _ = p.scan()

}

switch p.peek() {

case TABLE:

return p.parseCreateTableStatement(pos, tempPos)

case VIEW:

return p.parseCreateViewStatement(pos, tempPos)

case TRIGGER:

return p.parseCreateTriggerStatement(pos, tempPos)

}

if tempPos.IsValid() {

return nil, p.errorExpected(p.pos, p.tok, "TABLE, VIEW, or TRIGGER")

}

switch p.peek() {

case VIRTUAL:

return p.parseCreateVirtualTableStatement(pos)

case INDEX, UNIQUE:

return p.parseCreateIndexStatement(pos)

default:

return nil, p.errorExpected(pos, tok, "TABLE, VIEW, INDEX, TRIGGER")

}

}

func (p *Parser) parseDropStatement() (Statement, error) {

assert(p.peek() == DROP)

pos, tok, _ := p.scan()

switch p.peek() {

case TABLE:

return p.parseDropTableStatement(pos)

case VIEW:

return p.parseDropViewStatement(pos)

case INDEX:

return p.parseDropIndexStatement(pos)

case TRIGGER:

return p.parseDropTriggerStatement(pos)

default:

return nil, p.errorExpected(pos, tok, "TABLE, VIEW, INDEX, or TRIGGER")

}

}

func (p *Parser) parseCreateTableStatement(createPos, tempPos Pos) (_ *CreateTableStatement, err error) {

assert(p.peek() == TABLE)

var stmt CreateTableStatement

stmt.Create = createPos

stmt.Temp = tempPos

stmt.Table, _, _ = p.scan()

// Parse optional "IF NOT EXISTS".

if p.peek() == IF {

stmt.If, _, _ = p.scan()

pos, tok, _ := p.scan()

if tok != NOT {

return &stmt, p.errorExpected(pos, tok, "NOT")

}

stmt.IfNot = pos

pos, tok, _ = p.scan()

if tok != EXISTS {

return &stmt, p.errorExpected(pos, tok, "EXISTS")

}

stmt.IfNotExists = pos

}

// Parse the first identifier (either schema or table name)

firstIdent, err := p.parseIdent("table name")

if err != nil {

return &stmt, err

}

// Check if it's a schema.table format

if p.peek() == DOT {

// First identifier is the schema name

stmt.Schema = firstIdent

// Consume the dot

p.scan()

// Parse the table name

if stmt.Name, err = p.parseIdent("table name"); err != nil {

return &stmt, err

}

} else {

// Just a table name without schema

stmt.Name = firstIdent

}

// Parse either a column/constraint list or build table from "AS <select>".

switch p.peek() {

case LP:

stmt.Lparen, _, _ = p.scan()

if stmt.Columns, err = p.parseColumnDefinitions(); err != nil {

return &stmt, err

} else if len(stmt.Columns) == 0 {

// SQLite requires at least one column definition.

return &stmt, p.errorExpected(p.pos, p.tok, "column name")

} else if stmt.Constraints, err = p.parseTableConstraints(); err != nil {

return &stmt, err

}

if p.peek() != RP {

return &stmt, p.errorExpected(p.pos, p.tok, "right paren")

}

stmt.Rparen, _, _ = p.scan()

if p.peek() == STRICT || p.peek() == WITHOUT {

for {

switch p.peek() {

case STRICT:

stmt.Strict, _, _ = p.scan()

case WITHOUT:

stmt.Without, _, _ = p.scan()

if p.peek() != ROWID {

return &stmt, p.errorExpected(p.pos, p.tok, "ROWID")

}

stmt.Rowid, _, _ = p.scan()

default:

return &stmt, p.errorExpected(p.pos, p.tok, "STRICT or WITHOUT ROWID")

}

if p.peek() != COMMA {

break

}

p.scan()

}

}

return &stmt, nil

case AS:

stmt.As, _, _ = p.scan()

if stmt.Select, err = p.parseSelectStatement(false, nil); err != nil {

return &stmt, err

}

return &stmt, nil

default:

return &stmt, p.errorExpected(p.pos, p.tok, "AS or left paren")

}

}

func (p *Parser) parseColumnDefinitions() (_ []*ColumnDefinition, err error) {

var columns []*ColumnDefinition

for {

if tok := p.peek(); isIdentToken(tok) || isBareToken(tok) {

col, err := p.parseColumnDefinition()

columns = append(columns, col)

if err != nil {

return columns, err

}

// Column definitions must be comma separated. Without a comma the

// list is complete and the caller verifies what follows. After a

// comma another column or a table constraint is required.

if p.peek() != COMMA {

return columns, nil

}

p.scan()

if p.peek() == RP {

return columns, p.errorExpected(p.pos, p.tok, "column name or CONSTRAINT")

}

} else if tok == RP || isConstraintStartToken(tok, true) {

return columns, nil

} else {

return columns, p.errorExpected(p.pos, p.tok, "column name, CONSTRAINT, or right paren")

}

}

}

func (p *Parser) parseColumnDefinition() (_ *ColumnDefinition, err error) {

var col ColumnDefinition

if col.Name, err = p.parseIdent("column name"); err != nil {

return &col, err

}

if isTypeNameToken(p.peek()) {

if col.Type, err = p.parseType(); err != nil {

return &col, err

}

}

if col.Constraints, err = p.parseColumnConstraints(); err != nil {

return &col, err

}

return &col, nil

}

func (p *Parser) parseTableConstraints() (_ []Constraint, err error) {

if !isConstraintStartToken(p.peek(), true) {

return nil, nil

}

var a []Constraint

for {

cons, err := p.parseConstraint(true)

if cons != nil {

a = append(a, cons)

}

if err != nil {

return a, err

}

// Scan delimiting comma.

if p.peek() != COMMA {

return a, nil

}

p.scan()

}

}

func (p *Parser) parseColumnConstraints() (_ []Constraint, err error) {

var a []Constraint

for isConstraintStartToken(p.peek(), false) {

cons, err := p.parseConstraint(false)

if cons != nil {

a = append(a, cons)

}

if err != nil {

return a, err

}

}

return a, nil

}

func (p *Parser) parseConstraint(isTable bool) (_ Constraint, err error) {

assert(isConstraintStartToken(p.peek(), isTable))

var constraintPos Pos

var name *Ident

// Parse constraint name, if specified.

if p.peek() == CONSTRAINT {

constraintPos, _, _ = p.scan()

if name, err = p.parseIdent("constraint name"); err != nil {

return nil, err

}

}

// Table constraints only use a subset of column constraints.

if isTable {

switch p.peek() {

case PRIMARY:

return p.parsePrimaryKeyConstraint(constraintPos, name, isTable)

case UNIQUE:

return p.parseUniqueConstraint(constraintPos, name, isTable)

case CHECK:

return p.parseCheckConstraint(constraintPos, name)

default:

assert(p.peek() == FOREIGN)

return p.parseForeignKeyConstraint(constraintPos, name, isTable)

}

}

// Parse column constraints.

switch p.peek() {

case PRIMARY:

return p.parsePrimaryKeyConstraint(constraintPos, name, isTable)

case NOT:

return p.parseNotNullConstraint(constraintPos, name)

case UNIQUE:

return p.parseUniqueConstraint(constraintPos, name, isTable)

case CHECK:

return p.parseCheckConstraint(constraintPos, name)

case DEFAULT:

return p.parseDefaultConstraint(constraintPos, name)

case GENERATED, AS:

return p.parseGeneratedConstraint(constraintPos, name)

case COLLATE:

return p.parseCollateConstraint(constraintPos, name)

default:

assert(p.peek() == REFERENCES)

return p.parseForeignKeyConstraint(constraintPos, name, isTable)

}

}

func (p *Parser) parsePrimaryKeyConstraint(constraintPos Pos, name *Ident, isTable bool) (_ *PrimaryKeyConstraint, err error) {

assert(p.peek() == PRIMARY)

var cons PrimaryKeyConstraint

cons.Constraint = constraintPos

cons.Name = name

cons.Primary, _, _ = p.scan()

if p.peek() != KEY {

return &cons, p.errorExpected(p.pos, p.tok, "KEY")

}

cons.Key, _, _ = p.scan()

// Table constraints specify columns; column constraints specify sort direction.

if isTable {

if p.peek() != LP {

return &cons, p.errorExpected(p.pos, p.tok, "left paren")

}

cons.Lparen, _, _ = p.scan()

for {

col, err := p.parseIndexedColumn()

if err != nil {

return &cons, err

}

cons.Columns = append(cons.Columns, col)

// AUTOINCREMENT may follow the last column, inside the parens.

if p.peek() == AUTOINCREMENT {

cons.Autoincrement, _, _ = p.scan()

if p.peek() != RP {

return &cons, p.errorExpected(p.pos, p.tok, "right paren")

}

}

if p.peek() == RP {

break

} else if p.peek() != COMMA {

return &cons, p.errorExpected(p.pos, p.tok, "comma or right paren")

}

p.scan()

}

cons.Rparen, _, _ = p.scan()

}

if !isTable {

switch p.peek() {

case ASC:

cons.Asc, _, _ = p.scan()

case DESC:

cons.Desc, _, _ = p.scan()

}

}

if p.peek() == ON {

if cons.Conflict, err = p.parseConflictClause(); err != nil {

return &cons, err

}

}

if !isTable && p.peek() == AUTOINCREMENT {

cons.Autoincrement, _, _ = p.scan()

}

return &cons, nil

}

// parseConflictClause parses "ON CONFLICT <algorithm>" following a constraint.

func (p *Parser) parseConflictClause() (_ *ConflictClause, err error) {

assert(p.peek() == ON)

var clause ConflictClause

clause.On, _, _ = p.scan()

if p.peek() != CONFLICT {

return &clause, p.errorExpected(p.pos, p.tok, "CONFLICT")

}

clause.Conflict, _, _ = p.scan()

switch p.peek() {

case ROLLBACK:

clause.Rollback, _, _ = p.scan()

case ABORT:

clause.Abort, _, _ = p.scan()

case FAIL:

clause.Fail, _, _ = p.scan()

case IGNORE:

clause.Ignore, _, _ = p.scan()

case REPLACE:

clause.Replace, _, _ = p.scan()

default:

return &clause, p.errorExpected(p.pos, p.tok, "ROLLBACK, ABORT, FAIL, IGNORE, or REPLACE")

}

return &clause, nil

}

func (p *Parser) parseNotNullConstraint(constraintPos Pos, name *Ident) (_ *NotNullConstraint, err error) {

assert(p.peek() == NOT)

var cons NotNullConstraint

cons.Constraint = constraintPos

cons.Name = name

cons.Not, _, _ = p.scan()

if p.peek() != NULL {

return &cons, p.errorExpected(p.pos, p.tok, "NULL")

}

cons.Null, _, _ = p.scan()

if p.peek() == ON {

if cons.Conflict, err = p.parseConflictClause(); err != nil {

return &cons, err

}

}

return &cons, nil

}

func (p *Parser) parseUniqueConstraint(constraintPos Pos, name *Ident, isTable bool) (_ *UniqueConstraint, err error) {

assert(p.peek() == UNIQUE)

var cons UniqueConstraint

cons.Constraint = constraintPos

cons.Name = name

cons.Unique, _, _ = p.scan()

if isTable {

if p.peek() != LP {

return &cons, p.errorExpected(p.pos, p.tok, "left paren")

}

cons.Lparen, _, _ = p.scan()

for {

col, err := p.parseIndexedColumn()

if err != nil {

return &cons, err

}

cons.Columns = append(cons.Columns, col)

if p.peek() == RP {

break

} else if p.peek() != COMMA {

return &cons, p.errorExpected(p.pos, p.tok, "comma or right paren")

}

p.scan()

}

cons.Rparen, _, _ = p.scan()

}

if p.peek() == ON {

if cons.Conflict, err = p.parseConflictClause(); err != nil {

return &cons, err

}

}

return &cons, nil

}

func (p *Parser) parseCheckConstraint(constraintPos Pos, name *Ident) (_ *CheckConstraint, err error) {

assert(p.peek() == CHECK)

var cons CheckConstraint

cons.Constraint = constraintPos

cons.Name = name

cons.Check, _, _ = p.scan()

if p.peek() != LP {

return &cons, p.errorExpected(p.pos, p.tok, "left paren")

}

cons.Lparen, _, _ = p.scan()

if cons.Expr, err = p.ParseExpr(); err != nil {

return &cons, err

}

if p.peek() != RP {

return &cons, p.errorExpected(p.pos, p.tok, "right paren")

}

cons.Rparen, _, _ = p.scan()

return &cons, nil

}

func (p *Parser) parseDefaultConstraint(constraintPos Pos, name *Ident) (_ *DefaultConstraint, err error) {

assert(p.peek() == DEFAULT)

var cons DefaultConstraint

cons.Constraint = constraintPos

cons.Name = name

cons.Default, _, _ = p.scan()

// This parses a double-quoted identifier as a string value even though

// SQLite docs say that it shouldn't if DQS is disabled. For that reason,

// we are including it only on the DEFAULT value parsing.

//

// See: https://github.com/rqlite/sql/issues/18

if p.peek() == QIDENT {

pos, _, lit := p.scan()

cons.Expr = &StringLit{ValuePos: pos, Value: lit}

} else if isLiteralToken(p.peek()) {

cons.Expr = p.mustParseLiteral()

} else if p.peek() == PLUS || p.peek() == MINUS {

if cons.Expr, err = p.parseSignedNumber("signed number"); err != nil {

return &cons, err

}

} else if isNameToken(p.peek()) {

// A bare identifier, which SQLite treats as a string value.

if cons.Expr, err = p.parseIdent("default value"); err != nil {

return &cons, err

}

} else {

if p.peek() != LP {

return &cons, p.errorExpected(p.pos, p.tok, "literal value, identifier or left paren")

}

cons.Lparen, _, _ = p.scan()

if cons.Expr, err = p.ParseExpr(); err != nil {

return &cons, err

}

if p.peek() != RP {

return &cons, p.errorExpected(p.pos, p.tok, "right paren")

}

cons.Rparen, _, _ = p.scan()

}

return &cons, nil

}

func (p *Parser) parseGeneratedConstraint(constraintPos Pos, name *Ident) (_ *GeneratedConstraint, err error) {

assert(p.peek() == GENERATED || p.peek() == AS)

var cons GeneratedConstraint

cons.Constraint = constraintPos

cons.Name = name

if p.peek() == GENERATED {

cons.Generated, _, _ = p.scan()

if p.peek() != ALWAYS {

return &cons, p.errorExpected(p.pos, p.tok, "ALWAYS")

}

cons.Always, _, _ = p.scan()

}

if p.peek() != AS {

return &cons, p.errorExpected(p.pos, p.tok, "AS")

}

cons.As, _, _ = p.scan()

if p.peek() != LP {

return &cons, p.errorExpected(p.pos, p.tok, "left paren")

}

cons.Lparen, _, _ = p.scan()

if cons.Expr, err = p.ParseExpr(); err != nil {

return &cons, err

}

if p.peek() != RP {

return &cons, p.errorExpected(p.pos, p.tok, "right paren")

}

cons.Rparen, _, _ = p.scan()

switch p.peek() {

case STORED:

cons.Stored, _, _ = p.scan()

case VIRTUAL:

cons.Virtual, _, _ = p.scan()

}

return &cons, nil

}

func (p *Parser) parseCollateConstraint(constraintPos Pos, name *Ident) (_ *CollateConstraint, err error) {

assert(p.peek() == COLLATE)

var cons CollateConstraint

cons.Constraint = constraintPos

cons.Name = name

if p.peek() != COLLATE {

return &cons, p.errorExpected(p.pos, p.tok, "COLLATE")

}

cons.Collate, _, _ = p.scan()

collation, err := p.parseIdent("collation name")

if err != nil {

return &cons, err

}

cons.Collation = collation

return &cons, nil

}

func (p *Parser) parseForeignKeyConstraint(constraintPos Pos, name *Ident, isTable bool) (_ *ForeignKeyConstraint, err error) {

var cons ForeignKeyConstraint

cons.Constraint = constraintPos

cons.Name = name

// Table constraints start with "FOREIGN KEY (col1, col2, etc)".

if isTable {

assert(p.peek() == FOREIGN)

cons.Foreign, _, _ = p.scan()

if p.peek() != KEY {

return &cons, p.errorExpected(p.pos, p.tok, "KEY")

}

cons.ForeignKey, _, _ = p.scan()

if p.peek() != LP {

return &cons, p.errorExpected(p.pos, p.tok, "left paren")

}

cons.Lparen, _, _ = p.scan()

for {

col, err := p.parseIdent("column name")

if err != nil {

return &cons, err

}

cons.Columns = append(cons.Columns, col)

if p.peek() == RP {

break

} else if p.peek() != COMMA {

return &cons, p.errorExpected(p.pos, p.tok, "comma or right paren")

}

p.scan()

}

cons.Rparen, _, _ = p.scan()

}

if p.peek() != REFERENCES {

return &cons, p.errorExpected(p.pos, p.tok, "REFERENCES")

}

cons.References, _, _ = p.scan()

if cons.ForeignTable, err = p.parseIdent("foreign table name"); err != nil {

return &cons, err

}

// Parse optional column list. When omitted, the parent table's primary

// key is the referenced column set.

if p.peek() == LP {

cons.ForeignLparen, _, _ = p.scan()

for {

col, err := p.parseIdent("foreign column name")

if err != nil {

return &cons, err

}

cons.ForeignColumns = append(cons.ForeignColumns, col)

if p.peek() == RP {

break

} else if p.peek() != COMMA {

return &cons, p.errorExpected(p.pos, p.tok, "comma or right paren")

}

p.scan()

}

cons.ForeignRparen, _, _ = p.scan()

}

// Parse foreign key args: any mix of "MATCH name" and "ON UPDATE|DELETE action".

for p.peek() == ON || p.peek() == MATCH {

var arg ForeignKeyArg

if p.peek() == MATCH {

arg.Match, _, _ = p.scan()

if arg.MatchName, err = p.parseIdent("match type"); err != nil {

return &cons, err

}

cons.Args = append(cons.Args, &arg)

continue

}

arg.On, _, _ = p.scan()

// Parse foreign key type.

if p.peek() == UPDATE {

arg.OnUpdate, _, _ = p.scan()

} else if p.peek() == DELETE {

arg.OnDelete, _, _ = p.scan()

} else {

return &cons, p.errorExpected(p.pos, p.tok, "UPDATE or DELETE")

}

// Parse foreign key action.

if p.peek() == SET {

arg.Set, _, _ = p.scan()

if p.peek() == NULL {

arg.SetNull, _, _ = p.scan()

} else if p.peek() == DEFAULT {

arg.SetDefault, _, _ = p.scan()

} else {

return &cons, p.errorExpected(p.pos, p.tok, "NULL or DEFAULT")

}

} else if p.peek() == CASCADE {

arg.Cascade, _, _ = p.scan()

} else if p.peek() == RESTRICT {

arg.Restrict, _, _ = p.scan()

} else if p.peek() == NO {

arg.No, _, _ = p.scan()

if p.peek() == ACTION {

arg.NoAction, _, _ = p.scan()

} else {

return &cons, p.errorExpected(p.pos, p.tok, "ACTION")

}

} else {

return &cons, p.errorExpected(p.pos, p.tok, "SET NULL, SET DEFAULT, CASCADE, RESTRICT, or NO ACTION")

}

cons.Args = append(cons.Args, &arg)

}

// Parse deferrable subclause.

if p.peek() == NOT || p.peek() == DEFERRABLE {

if p.peek() == NOT {