mirror of
https://github.com/chaisql/chai.git
synced 2025-10-05 07:36:56 +08:00
588 lines
14 KiB
Go
588 lines
14 KiB
Go
package parser
|
|
|
|
import (
|
|
"math"
|
|
|
|
"github.com/genjidb/genji/internal/database"
|
|
"github.com/genjidb/genji/internal/expr"
|
|
"github.com/genjidb/genji/internal/query/statement"
|
|
"github.com/genjidb/genji/internal/sql/scanner"
|
|
"github.com/genjidb/genji/internal/stringutil"
|
|
)
|
|
|
|
// parseCreateStatement parses a create string and returns a Statement AST object.
|
|
// This function assumes the CREATE token has already been consumed.
|
|
func (p *Parser) parseCreateStatement() (statement.Statement, error) {
|
|
tok, pos, lit := p.ScanIgnoreWhitespace()
|
|
switch tok {
|
|
case scanner.TABLE:
|
|
return p.parseCreateTableStatement()
|
|
case scanner.UNIQUE:
|
|
if tok, pos, lit := p.ScanIgnoreWhitespace(); tok != scanner.INDEX {
|
|
return nil, newParseError(scanner.Tokstr(tok, lit), []string{"INDEX"}, pos)
|
|
}
|
|
|
|
return p.parseCreateIndexStatement(true)
|
|
case scanner.INDEX:
|
|
return p.parseCreateIndexStatement(false)
|
|
case scanner.SEQUENCE:
|
|
return p.parseCreateSequenceStatement()
|
|
}
|
|
|
|
return nil, newParseError(scanner.Tokstr(tok, lit), []string{"TABLE", "INDEX", "SEQUENCE"}, pos)
|
|
}
|
|
|
|
// parseCreateTableStatement parses a create table string and returns a Statement AST object.
|
|
// This function assumes the CREATE TABLE tokens have already been consumed.
|
|
func (p *Parser) parseCreateTableStatement() (*statement.CreateTableStmt, error) {
|
|
var stmt statement.CreateTableStmt
|
|
var err error
|
|
|
|
// Parse IF NOT EXISTS
|
|
stmt.IfNotExists, err = p.parseOptional(scanner.IF, scanner.NOT, scanner.EXISTS)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Parse table name
|
|
stmt.Info.TableName, err = p.parseIdent()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// parse field constraints
|
|
err = p.parseConstraints(&stmt)
|
|
return &stmt, err
|
|
}
|
|
|
|
func (p *Parser) parseFieldDefinition(fc *database.FieldConstraint) (err error) {
|
|
fc.Path, err = p.parsePath()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
fc.Type, err = p.parseType()
|
|
if err != nil {
|
|
p.Unscan()
|
|
}
|
|
|
|
err = p.parseFieldConstraint(fc)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if fc.Type.IsAny() && fc.DefaultValue == nil && !fc.IsNotNull && !fc.IsPrimaryKey && !fc.IsUnique {
|
|
tok, pos, lit := p.ScanIgnoreWhitespace()
|
|
return newParseError(scanner.Tokstr(tok, lit), []string{"CONSTRAINT", "TYPE"}, pos)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (p *Parser) parseConstraints(stmt *statement.CreateTableStmt) error {
|
|
// Parse ( token.
|
|
if ok, err := p.parseOptional(scanner.LPAREN); !ok || err != nil {
|
|
return err
|
|
}
|
|
|
|
// if set to true, the parser must no longer
|
|
// expect field definitions, but only table constraints.
|
|
var parsingTableConstraints bool
|
|
|
|
// Parse constraints.
|
|
for {
|
|
// we start by checking if it is a table constraint,
|
|
// as it's easier to determine
|
|
ok, err := p.parseTableConstraint(stmt)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// no table constraint found
|
|
if !ok && parsingTableConstraints {
|
|
tok, pos, lit := p.ScanIgnoreWhitespace()
|
|
return newParseError(scanner.Tokstr(tok, lit), []string{"CONSTRAINT", ")"}, pos)
|
|
}
|
|
|
|
// only PRIMARY KEY(path) is currently supported.
|
|
if ok {
|
|
parsingTableConstraints = true
|
|
}
|
|
|
|
// if set to false, we are still parsing field definitions
|
|
if !parsingTableConstraints {
|
|
var fc database.FieldConstraint
|
|
|
|
err = p.parseFieldDefinition(&fc)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
err = stmt.Info.FieldConstraints.Add(&fc)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
if tok, _, _ := p.ScanIgnoreWhitespace(); tok != scanner.COMMA {
|
|
p.Unscan()
|
|
break
|
|
}
|
|
}
|
|
|
|
// Parse required ) token.
|
|
if err := p.parseTokens(scanner.RPAREN); err != nil {
|
|
return err
|
|
}
|
|
|
|
// ensure only one primary key
|
|
var pkFound bool
|
|
for _, fc := range stmt.Info.FieldConstraints {
|
|
if fc.IsPrimaryKey {
|
|
if pkFound {
|
|
return stringutil.Errorf("table %q has more than one primary key", stmt.Info.TableName)
|
|
}
|
|
|
|
pkFound = true
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (p *Parser) parseFieldConstraint(fc *database.FieldConstraint) error {
|
|
for {
|
|
tok, pos, lit := p.ScanIgnoreWhitespace()
|
|
switch tok {
|
|
case scanner.PRIMARY:
|
|
// Parse "KEY"
|
|
if err := p.parseTokens(scanner.KEY); err != nil {
|
|
return err
|
|
}
|
|
|
|
// if it's already a primary key we return an error
|
|
if fc.IsPrimaryKey {
|
|
return newParseError(scanner.Tokstr(tok, lit), []string{"CONSTRAINT", ")"}, pos)
|
|
}
|
|
|
|
fc.IsPrimaryKey = true
|
|
case scanner.NOT:
|
|
// Parse "NULL"
|
|
if err := p.parseTokens(scanner.NULL); err != nil {
|
|
return err
|
|
}
|
|
|
|
// if it's already not null we return an error
|
|
if fc.IsNotNull {
|
|
return newParseError(scanner.Tokstr(tok, lit), []string{"CONSTRAINT", ")"}, pos)
|
|
}
|
|
|
|
fc.IsNotNull = true
|
|
case scanner.DEFAULT:
|
|
// if it has already a default value we return an error
|
|
if fc.HasDefaultValue() {
|
|
return newParseError(scanner.Tokstr(tok, lit), []string{"CONSTRAINT", ")"}, pos)
|
|
}
|
|
|
|
// Parse default value expression.
|
|
// Only a few tokens are allowed.
|
|
e, err := p.parseExprWithMinPrecedence(scanner.EQ.Precedence(),
|
|
scanner.EQ,
|
|
scanner.NEQ,
|
|
scanner.BITWISEOR,
|
|
scanner.BITWISEXOR,
|
|
scanner.BITWISEAND,
|
|
scanner.LT,
|
|
scanner.LTE,
|
|
scanner.GT,
|
|
scanner.GTE,
|
|
scanner.ADD,
|
|
scanner.SUB,
|
|
scanner.MUL,
|
|
scanner.DIV,
|
|
scanner.MOD,
|
|
scanner.CONCAT,
|
|
scanner.INTEGER,
|
|
scanner.NUMBER,
|
|
scanner.STRING,
|
|
scanner.TRUE,
|
|
scanner.FALSE,
|
|
scanner.NULL,
|
|
scanner.LPAREN, // only opening parenthesis are necessary
|
|
scanner.LBRACKET, // only opening brackets are necessary
|
|
scanner.NEXT,
|
|
)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
fc.DefaultValue = expr.Constraint(e)
|
|
case scanner.UNIQUE:
|
|
// if it's already unique we return an error
|
|
if fc.IsUnique {
|
|
return newParseError(scanner.Tokstr(tok, lit), []string{"CONSTRAINT", ")"}, pos)
|
|
}
|
|
|
|
fc.IsUnique = true
|
|
default:
|
|
p.Unscan()
|
|
return nil
|
|
}
|
|
}
|
|
}
|
|
|
|
func (p *Parser) parseTableConstraint(stmt *statement.CreateTableStmt) (bool, error) {
|
|
var err error
|
|
|
|
tok, _, _ := p.ScanIgnoreWhitespace()
|
|
switch tok {
|
|
case scanner.PRIMARY:
|
|
// Parse "KEY ("
|
|
err = p.parseTokens(scanner.KEY, scanner.LPAREN)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
|
|
primaryKeyPath, err := p.parsePath()
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
|
|
// Parse ")"
|
|
err = p.parseTokens(scanner.RPAREN)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
|
|
if pk := stmt.Info.FieldConstraints.GetPrimaryKey(); pk != nil {
|
|
return false, stringutil.Errorf("table %q has more than one primary key", stmt.Info.TableName)
|
|
}
|
|
fc := stmt.Info.FieldConstraints.Get(primaryKeyPath)
|
|
if fc == nil {
|
|
err = stmt.Info.FieldConstraints.Add(&database.FieldConstraint{
|
|
Path: primaryKeyPath,
|
|
IsPrimaryKey: true,
|
|
})
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
} else {
|
|
fc.IsPrimaryKey = true
|
|
}
|
|
|
|
return true, nil
|
|
case scanner.UNIQUE:
|
|
// Parse "("
|
|
err = p.parseTokens(scanner.LPAREN)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
|
|
uniquePath, err := p.parsePath()
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
|
|
// Parse ")"
|
|
err = p.parseTokens(scanner.RPAREN)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
|
|
fc := stmt.Info.FieldConstraints.Get(uniquePath)
|
|
if fc == nil {
|
|
err = stmt.Info.FieldConstraints.Add(&database.FieldConstraint{
|
|
Path: uniquePath,
|
|
IsUnique: true,
|
|
})
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
} else {
|
|
fc.IsUnique = true
|
|
}
|
|
|
|
return true, nil
|
|
default:
|
|
p.Unscan()
|
|
return false, nil
|
|
}
|
|
}
|
|
|
|
// parseCreateIndexStatement parses a create index string and returns a Statement AST object.
|
|
// This function assumes the CREATE INDEX or CREATE UNIQUE INDEX tokens have already been consumed.
|
|
func (p *Parser) parseCreateIndexStatement(unique bool) (*statement.CreateIndexStmt, error) {
|
|
var err error
|
|
var stmt statement.CreateIndexStmt
|
|
stmt.Info.Unique = unique
|
|
|
|
// Parse IF NOT EXISTS
|
|
stmt.IfNotExists, err = p.parseOptional(scanner.IF, scanner.NOT, scanner.EXISTS)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Parse optional index name
|
|
stmt.Info.IndexName, err = p.parseIdent()
|
|
if err != nil {
|
|
// if IF NOT EXISTS is set, index name is mandatory
|
|
if stmt.IfNotExists {
|
|
return nil, err
|
|
}
|
|
|
|
p.Unscan()
|
|
}
|
|
|
|
// Parse "ON"
|
|
if err := p.parseTokens(scanner.ON); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Parse table name
|
|
stmt.Info.TableName, err = p.parseIdent()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
paths, err := p.parsePathList()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if len(paths) == 0 {
|
|
tok, pos, lit := p.ScanIgnoreWhitespace()
|
|
return nil, newParseError(scanner.Tokstr(tok, lit), []string{"("}, pos)
|
|
}
|
|
|
|
stmt.Info.Paths = paths
|
|
|
|
return &stmt, nil
|
|
}
|
|
|
|
// This function assumes the CREATE SEQUENCE tokens have already been consumed.
|
|
func (p *Parser) parseCreateSequenceStatement() (*statement.CreateSequenceStmt, error) {
|
|
var stmt statement.CreateSequenceStmt
|
|
var err error
|
|
|
|
// Parse IF NOT EXISTS
|
|
stmt.IfNotExists, err = p.parseOptional(scanner.IF, scanner.NOT, scanner.EXISTS)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Parse sequence name
|
|
stmt.Info.Name, err = p.parseIdent()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var hasAsInt, hasNoMin, hasNoMax, hasNoCycle bool
|
|
var min, max, incrementBy, start, cache *int64
|
|
|
|
for {
|
|
// Parse AS [any int type]
|
|
// Only integers are supported
|
|
if ok, _ := p.parseOptional(scanner.AS); ok {
|
|
tok, pos, lit := p.ScanIgnoreWhitespace()
|
|
switch tok {
|
|
case scanner.TYPEINTEGER, scanner.TYPEINT, scanner.TYPEINT2, scanner.TYPEINT8, scanner.TYPETINYINT,
|
|
scanner.TYPEBIGINT, scanner.TYPEMEDIUMINT, scanner.TYPESMALLINT:
|
|
default:
|
|
return nil, newParseError(scanner.Tokstr(tok, lit), []string{"INT"}, pos)
|
|
}
|
|
|
|
if hasAsInt {
|
|
return nil, &ParseError{Message: "conflicting or redundant options"}
|
|
}
|
|
|
|
hasAsInt = true
|
|
continue
|
|
}
|
|
|
|
// Parse INCREMENT [BY] integer
|
|
if ok, _ := p.parseOptional(scanner.INCREMENT); ok {
|
|
// parse optional BY token
|
|
_, _ = p.parseOptional(scanner.BY)
|
|
|
|
if incrementBy != nil {
|
|
return nil, &ParseError{Message: "conflicting or redundant options"}
|
|
}
|
|
|
|
i, err := p.parseInteger()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if i == 0 {
|
|
return nil, &ParseError{Message: "INCREMENT must not be zero"}
|
|
}
|
|
incrementBy = &i
|
|
|
|
continue
|
|
}
|
|
|
|
// Parse NO [MINVALUE | MAXVALUE | CYCLE]
|
|
if ok, _ := p.parseOptional(scanner.NO); ok {
|
|
tok, pos, lit := p.ScanIgnoreWhitespace()
|
|
|
|
if tok == scanner.MINVALUE {
|
|
if hasNoMin {
|
|
return nil, &ParseError{Message: "conflicting or redundant options"}
|
|
}
|
|
hasNoMin = true
|
|
continue
|
|
}
|
|
|
|
if tok == scanner.MAXVALUE {
|
|
if hasNoMax {
|
|
return nil, &ParseError{Message: "conflicting or redundant options"}
|
|
}
|
|
hasNoMax = true
|
|
continue
|
|
}
|
|
|
|
if tok == scanner.CYCLE {
|
|
if hasNoCycle {
|
|
return nil, &ParseError{Message: "conflicting or redundant options"}
|
|
}
|
|
hasNoCycle = true
|
|
continue
|
|
}
|
|
|
|
return nil, newParseError(scanner.Tokstr(tok, lit), []string{"MINVALUE", "MAXVALUE", "CYCLE"}, pos)
|
|
}
|
|
|
|
// Parse MINVALUE integer
|
|
if ok, _ := p.parseOptional(scanner.MINVALUE); ok {
|
|
if hasNoMin || min != nil {
|
|
return nil, &ParseError{Message: "conflicting or redundant options"}
|
|
}
|
|
i, err := p.parseInteger()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
min = &i
|
|
continue
|
|
}
|
|
|
|
// Parse MAXVALUE integer
|
|
if ok, _ := p.parseOptional(scanner.MAXVALUE); ok {
|
|
if hasNoMax || max != nil {
|
|
return nil, &ParseError{Message: "conflicting or redundant options"}
|
|
}
|
|
i, err := p.parseInteger()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
max = &i
|
|
continue
|
|
}
|
|
|
|
// Parse START [WITH] integer
|
|
if ok, _ := p.parseOptional(scanner.START); ok {
|
|
// parse optional WITH token
|
|
_, _ = p.parseOptional(scanner.WITH)
|
|
|
|
if start != nil {
|
|
return nil, &ParseError{Message: "conflicting or redundant options"}
|
|
}
|
|
|
|
i, err := p.parseInteger()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
start = &i
|
|
continue
|
|
}
|
|
|
|
// Parse CACHE integer
|
|
if ok, _ := p.parseOptional(scanner.CACHE); ok {
|
|
if cache != nil {
|
|
return nil, &ParseError{Message: "conflicting or redundant options"}
|
|
}
|
|
|
|
v, err := p.parseInteger()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if v < 0 {
|
|
return nil, &ParseError{Message: "cache value must be positive"}
|
|
}
|
|
cache = &v
|
|
|
|
continue
|
|
}
|
|
|
|
// Parse CYCLE
|
|
if ok, _ := p.parseOptional(scanner.CYCLE); ok {
|
|
if hasNoCycle || stmt.Info.Cycle {
|
|
return nil, &ParseError{Message: "conflicting or redundant options"}
|
|
}
|
|
|
|
stmt.Info.Cycle = true
|
|
continue
|
|
}
|
|
|
|
break
|
|
}
|
|
|
|
// default value for increment is 1
|
|
if incrementBy != nil {
|
|
stmt.Info.IncrementBy = *incrementBy
|
|
} else {
|
|
stmt.Info.IncrementBy = 1
|
|
}
|
|
|
|
// determine if the sequence is ascending or descending
|
|
asc := stmt.Info.IncrementBy > 0
|
|
|
|
// default value for min is 1 if ascending
|
|
// or the minimum value of ints if descending
|
|
if min != nil {
|
|
stmt.Info.Min = *min
|
|
} else if asc {
|
|
stmt.Info.Min = 1
|
|
} else {
|
|
stmt.Info.Min = math.MinInt64
|
|
}
|
|
|
|
// default value for max is the maximum value of ints if ascending
|
|
// or the -1 if descending
|
|
if max != nil {
|
|
stmt.Info.Max = *max
|
|
} else if asc {
|
|
stmt.Info.Max = math.MaxInt64
|
|
} else {
|
|
stmt.Info.Max = -1
|
|
}
|
|
|
|
// check if min > max
|
|
if stmt.Info.Min > stmt.Info.Max {
|
|
return nil, &ParseError{Message: stringutil.Sprintf("MINVALUE (%d) must be less than MAXVALUE (%d)", stmt.Info.Min, stmt.Info.Max)}
|
|
}
|
|
|
|
// default value for start is min if ascending
|
|
// or max if descending
|
|
if start != nil {
|
|
stmt.Info.Start = *start
|
|
} else if asc {
|
|
stmt.Info.Start = stmt.Info.Min
|
|
} else {
|
|
stmt.Info.Start = stmt.Info.Max
|
|
}
|
|
|
|
// check if min < start < max
|
|
if stmt.Info.Start < stmt.Info.Min {
|
|
return nil, &ParseError{Message: stringutil.Sprintf("START value (%d) cannot be less than MINVALUE (%d)", stmt.Info.Start, stmt.Info.Min)}
|
|
}
|
|
if stmt.Info.Start > stmt.Info.Max {
|
|
return nil, &ParseError{Message: stringutil.Sprintf("START value (%d) cannot be greater than MAXVALUE (%d)", stmt.Info.Start, stmt.Info.Max)}
|
|
}
|
|
|
|
// default for cache is 1
|
|
if cache != nil {
|
|
stmt.Info.Cache = uint64(*cache)
|
|
} else {
|
|
stmt.Info.Cache = 1
|
|
}
|
|
return &stmt, err
|
|
}
|