sql.lalrpop

// MIT License
//
// Copyright (c) 2018-2021 Hans-Martin Will
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.

use ast;
use symbols;

grammar;

// Lexer specification, with the primary purpose of making language keywords case insensitive
match {
    r"(?i)action" => "ACTION",
    r"(?i)add" => "ADD",
    r"(?i)all" => "ALL",
    r"(?i)alter" => "ALTER",
    r"(?i)and" => "AND",
    r"(?i)as" => "AS",
    r"(?i)asc" => "ASC",
    r"(?i)attach" => "ATTACH",
    r"(?i)authorization" => "AUTHORIZATION",

    r"(?i)between" => "BETWEEN",
    r"(?i)binary" => "BINARY",
    r"(?i)bit" => "BIT",
    r"(?i)by" => "BY",
    r"(?i)bool" => "BOOL",
    r"(?i)boolean" => "BOOLEAN",

    r"(?i)case" => "CASE",
    r"(?i)cascade" => "CASCADE",
    r"(?i)cascaded" => "CASCADED",
    r"(?i)char" => "CHAR",
    r"(?i)character" => "CHARACTER",
    r"(?i)check" => "CHECK",
    r"(?i)collate" => "COLLATE",
    r"(?i)column" => "COLUMN",
    r"(?i)constraint" => "CONSTRAINT",
    r"(?i)create" => "CREATE",
    r"(?i)cross" => "CROSS",
    r"(?i)current_date" => "CURRENT_DATE",
    r"(?i)current_time" => "CURRENT_TIME",
    r"(?i)current_timestamp" => "CURRENT_TIMESTAMP",
    
    r"(?i)date" => "DATE",
    r"(?i)day" => "DAY",
    r"(?i)dec" => "DEC",
    r"(?i)decimal" => "DECIMAL",
    r"(?i)default" => "DEFAULT",
    r"(?i)deferred" => "DEFERRED",
    r"(?i)deferrable" => "DEFERRABLE",
    r"(?i)delete" => "DELETE",
    r"(?i)desc" => "DESC",
    r"(?i)describe" => "DESCRIBE",
    r"(?i)distinct" => "DISTINCT",
    r"(?i)double" => "DOUBLE",
    r"(?i)domain" => "DOMAIN",
    r"(?i)drop" => "DROP",
    
    r"(?i)else" => "ELSE",
    r"(?i)end" => "END",
    r"(?i)explain" => "EXPLAIN",
    r"(?i)except" => "EXCEPT",
    
    r"(?i)file" => "FILE",
    r"(?i)float" => "FLOAT",
    r"(?i)foreign" => "FOREIGN",
    r"(?i)from" => "FROM",
    r"(?i)full" => "FULL",

    r"(?i)group" => "GROUP",

    r"(?i)having" => "HAVING",
    r"(?i)hour" => "HOUR",

    r"(?i)immediate" => "IMMEDIATE",
    r"(?i)in" => "IN",
    r"(?i)initially" => "INITIALLY",
    r"(?i)inner" => "INNER",
    r"(?i)insert" => "INSERT",
    r"(?i)int" => "INT",
    r"(?i)integer" => "INTEGER",
    r"(?i)intersect" => "INTERSECT",
    r"(?i)interval" => "INTERVAL",
    r"(?i)into" => "INTO",
    r"(?i)is" => "IS",
    r"(?i)isnull" => "ISNULL",

    r"(?i)join" => "JOIN",
    
    r"(?i)key" => "KEY",    

    r"(?i)left" => "LEFT",    
    r"(?i)limit" => "LIMIT",
    r"(?i)like" => "LIKE",
    r"(?i)local" => "LOCAL",

    r"(?i)match" => "MATCH",
    r"(?i)minute" => "MINUTE",
    r"(?i)month" => "MONTH",

    r"(?i)natural" => "NATURAL",
    r"(?i)no" => "NO",
    r"(?i)not" => "NOT",
    r"(?i)notnull" => "NOTNULL",
    r"(?i)null" => "NULL",
    r"(?i)numeric" => "NUMERIC",
    
    r"(?i)offset" => "OFFSET",
    r"(?i)on" => "ON",
    r"(?i)option" => "OPTION",
    r"(?i)or" => "OR",
    r"(?i)order" => "ORDER",
    r"(?i)outer" => "OUTER",
    
    r"(?i)partial" => "PARTIAL",
    r"(?i)plan" => "PLAN",
    r"(?i)precision" => "PRECISION",
    r"(?i)primary" => "PRIMARY",

    r"(?i)query" => "QUERY",

    r"(?i)real" => "REAL",
    r"(?i)references" => "REFERENCES",
    r"(?i)restrict" => "RESTRICT",
    r"(?i)right" => "RIGHT",

    r"(?i)schema" => "SCHEMA",
    r"(?i)second" => "SECOND",
    r"(?i)select" => "SELECT",
    r"(?i)set" => "SET",
    r"(?i)smallint" => "SMALLINT",
    r"(?i)st_geometry" => "ST_GEOMETRY",
    r"(?i)st_geography" => "ST_GEOGRAPHY",

    r"(?i)table" => "TABLE",
    r"(?i)then" => "THEN",
    r"(?i)time" => "TIME",
    r"(?i)timestamp" => "TIMESTAMP",
    r"(?i)to" => "TO",
    
    r"(?i)update" => "UPDATE",
    r"(?i)union" => "UNION",
    r"(?i)unique" => "UNIQUE",
    r"(?i)using" => "USING",

    r"(?i)values" => "VALUES",
    r"(?i)varbinary" => "VARBINARY",
    r"(?i)varchar" => "VARCHAR",
    r"(?i)varying" => "VARYING",
    r"(?i)view" => "VIEW",

    r"(?i)when" => "WHEN",
    r"(?i)where" => "WHERE",
    r"(?i)with" => "WITH",

    r"(?i)year" => "YEAR",

    r"(?i)zone" => "ZONE",

    "," => ",",
    "." => ".",
    "(" => "(",
    ")" => ")",
    "*" => "*",
    "/" => "/",
    "+" => "+",
    "-" => "-",
    "=" => "=",
    "!=" => "!=",
    "<" => "<",
    "<=" => "<=",
    ">" => ">",
    ">=" => ">=",
    "||" => "||"
} else {
    r"[A-Za-z_][A-Za-z0-9_]*" => ID,
    r"[0-9]+(\.[0-9]*)?(E[+-]?[0-9]+)?" => NUMERIC_LIT_1,
    r"\.[0-9]+(E[+-]?[0-9]+)?" => NUMERIC_LIT_2,
    r"0x[0-9A-Fa-f]+" => HEX_LIT,
    r"'[^[[:cntrl:]]']*'" => STRING_LIT
}

//
// Names
//

UserName: symbols::Name = {
    <user: Identifier> => user,
};

SchemaName: symbols::Name = {
    <schema: Identifier> => schema,
};

NameQualifier: symbols::Name = {
    <schema: SchemaName> "." => schema,
};

CharacterSetName: ast::QualifiedName = {
    <schema: NameQualifier?> <name: Identifier> => ast::QualifiedName { schema, name },
};

TableName: ast::QualifiedName = {
    <schema: NameQualifier?> <name: Identifier> => ast::QualifiedName { schema, name },
};

DomainName: ast::QualifiedName = {
    <schema: NameQualifier?> <name: Identifier> => ast::QualifiedName { schema, name },
};

ConstraintName: ast::QualifiedName = {
    <schema: NameQualifier?> <name: Identifier> => ast::QualifiedName { schema, name },
};

ViewName: ast::QualifiedName = {
    <schema: NameQualifier?> <name: Identifier> => ast::QualifiedName { schema, name },
};

TableOrViewName: ast::QualifiedName = {
    <schema: NameQualifier?> <name: Identifier> => ast::QualifiedName { schema, name },
};

//
// Statements
//

pub SqlStatement: ast::SqlStatement = {
    <statement: Statement> => ast::SqlStatement::Statement(statement),
    "EXPLAIN" ("QUERY" "PLAN")? <statement: Statement> => ast::SqlStatement::ExplainQueryPlan(statement),
    <statement: AttachStatement> => ast::SqlStatement::Attach(statement),
    <statement: DescribeStatement> => ast::SqlStatement::Describe(statement),

    CreateSchemaStatement => ast::SqlStatement::CreateSchema(<>),
    DropSchemaStatement => ast::SqlStatement::DropSchema(<>),

    AlterDomainStatement => ast::SqlStatement::AlterDomain(<>),
    CreateDomainStatement => ast::SqlStatement::CreateDomain(<>),
    DropDomainStatement => ast::SqlStatement::DropDomain(<>),

    AlterTableStatement => ast::SqlStatement::AlterTable(<>),
    CreateTableStatement => ast::SqlStatement::CreateTable(<>),
    DropTableStatement => ast::SqlStatement::DropTable(<>),

    CreateViewStatement => ast::SqlStatement::CreateView(<>),
    DropViewStatement => ast::SqlStatement::DropView(<>),
};

Statement: ast::Statement = {
    SelectStatement => ast::Statement::Select(<>),
    InsertStatement => ast::Statement::Insert(<>),
    DeleteStatement => ast::Statement::Delete(<>),
    UpdateStatement => ast::Statement::Update(<>),
};

//
// Data Definition
//

CreateSchemaStatement: ast::CreateSchemaStatement = {
    "CREATE" "SCHEMA" <name: Identifier> <authorization_user: AuthorizationUser?> <default_character_set: DefaultCharacterSetName?> 
        => ast::CreateSchemaStatement { 
            name,
            authorization_user,
            default_character_set
        },
    "CREATE" "SCHEMA" <authorization_user: AuthorizationUser> <default_character_set: DefaultCharacterSetName?> 
        => ast::CreateSchemaStatement { 
            name: authorization_user.clone(),
            authorization_user: Some(authorization_user),
            default_character_set
        },
};

AuthorizationUser: symbols::Name = {
    "AUTHORIZATION" <name: UserName> => name,
};

DefaultCharacterSetName: ast::QualifiedName = {
    "DEFAULT" "CHARACTER" "SET" <name: CharacterSetName> => name,
};

DropSchemaStatement: ast::DropSchemaStatement = {
    "DROP" "SCHEMA" <name: Identifier> <drop_mode: DropMode> => ast::DropSchemaStatement { name, drop_mode },
};

DropMode: ast::DropMode = {
    "RESTRICT" => ast::DropMode::Restrict,
    "CASCADE" => ast::DropMode::Cascade,
};

CreateDomainStatement: ast::CreateDomainStatement = {
    "CREATE" "DOMAIN" <name: DomainName> "AS"? <data_type: DataType> <default: DefaultDefinition?> 
        <constraints: DomainConstraintDefinitionList>
        => ast::CreateDomainStatement { 
            name,
            data_type,
            default,
            constraints
        },
};

DefaultDefinition: ast::Literal = {
    "DEFAULT" <default: DefaultValue> => default,
};

DefaultValue: ast::Literal = {
    NumericLiteral => ast::Literal::NumericLiteral(<>),
    StringLiteral => ast::Literal::StringLiteral(<>),
    "NULL" => ast::Literal::Null,
    NiladicFunction,
};

DomainConstraintDefinitionList: Vec<ast::CheckConstraint> = {
    DomainConstraintDefinition*,
};

DomainConstraintDefinition: ast::CheckConstraint = {
    <name: NamedConstraint?> "CHECK" "(" <condition: ConditionalExpression> ")" 
        => ast::CheckConstraint { name, condition },
};

ConditionalExpression: Box<ast::Expression> = {
    Expression,
};

NamedConstraint: ast::QualifiedName = {
    "CONSTRAINT" <name: ConstraintName> => name,
};

AlterDomainStatement: ast::AlterDomainStatement = {
    "ALTER" "DOMAIN" <name: DomainName> <action: DomainAlterationAction> => ast::AlterDomainStatement { name, action },
};

DomainAlterationAction: ast::AlterDomainAction = {
    "SET" <default: DefaultDefinition> => ast::AlterDomainAction::SetDefault(default),
    "DROP" "DEFAULT" => ast::AlterDomainAction::DropDefault,
    "ADD" <constraint: DomainConstraintDefinition> => ast::AlterDomainAction::AddConstraint(constraint),
    "DROP" "CONSTRAINT" <name: ConstraintName> => ast::AlterDomainAction::DropConstraint(name),
};

DropDomainStatement: ast::DropDomainStatement = {
    "DROP" "DOMAIN" <name: DomainName> <drop_mode: DropMode> => ast::DropDomainStatement { name, drop_mode },
};

AlterTableStatement: ast::AlterTableStatement = {
    "ALTER" "TABLE" <name: TableName> <action: TableAlterationAction> => ast::AlterTableStatement { name, action },
};

TableAlterationAction: ast::AlterTableAction = {
    TableColumnAlterationAction,
    TableConstraintAlterationAction,
};

TableColumnAlterationAction: ast::AlterTableAction = {
    "ADD" "COLUMN"? <column: ColumnDefinition> => ast::AlterTableAction::AddColumn(column),
    "ALTER" "COLUMN"? <name: Identifier> "SET" <default: DefaultDefinition> => ast::AlterTableAction::SetColumnDefault { name, default },
    "ALTER" "COLUMN"? <name: Identifier> "DROP" "DEFAULT" => ast::AlterTableAction::DropColumnDefault(name),
    "DROP" "COLUMN"? <name: Identifier> <drop_mode: DropMode> => ast::AlterTableAction::DropColumn { name, drop_mode },
};

TableConstraintAlterationAction: ast::AlterTableAction = {
    "ADD" <constraint: TableConstraintKind> => ast::AlterTableAction::AddConstraint(constraint),
    "DROP" "CONSTRAINT" <name: ConstraintName> <drop_mode: DropMode> => ast::AlterTableAction::DropConstraint { name, drop_mode },
};

CreateTableStatement: ast::CreateTableStatement = {
    "CREATE" "TABLE" <name: TableName> <columns_constraints: BaseTableElementCommaList> 
        => {
            let (columns, constraints) = columns_constraints;
            ast::CreateTableStatement { name, columns, constraints }   
        },
};

BaseTableElementCommaList: (Vec<ast::ColumnDefinition>, Vec<ast::TableConstraint>) = {
    <column: ColumnDefinition> => (vec![column], vec![]),
    <constraint: TableConstraintKind> => (vec![], vec![constraint]),
    <columns_constraints: BaseTableElementCommaList> "," <column: ColumnDefinition> 
        => {
            let (mut columns, constraints) = columns_constraints;
            columns.push(column);
            (columns, constraints)
        },
    <columns_constraints: BaseTableElementCommaList> "," <constraint: TableConstraintKind> 
        => {
            let (columns, mut constraints) = columns_constraints;
            constraints.push(constraint);
            (columns, constraints)
        },
};

ColumnDefinition: ast::ColumnDefinition = {
    <name: Identifier> <data_type: DataType> <default: DefaultDefinition?> <constraints: ColumnConstraintDefinitionList> 
        => ast::ColumnDefinition {
            name,
            column_type: ast::ColumnType::DataType(data_type),
            default,
            constraints
        },
        <name: Identifier> <domain_name: DomainName> <default: DefaultDefinition?> <constraints: ColumnConstraintDefinitionList> 
        => ast::ColumnDefinition {
            name,
            column_type: ast::ColumnType::Domain(domain_name),
            default,
            constraints
        },
};

ColumnConstraintDefinitionList: Vec<ast::ColumnConstraint> = {
    ColumnConstraintDefinition*,
};

ColumnConstraintDefinition: ast::ColumnConstraint = {
    <name: NamedConstraint?> "NOT" "NULL" 
        => ast::ColumnConstraint { name, constraint: ast::ColumnConstraintKind::NotNull },
    <name: NamedConstraint?> "PRIMARY" "KEY" 
        => ast::ColumnConstraint { name, constraint: ast::ColumnConstraintKind::PrimaryKey },
    <name: NamedConstraint?> "UNIQUE" 
        => ast::ColumnConstraint { name, constraint: ast::ColumnConstraintKind::Unique },
    <name: NamedConstraint?> <reference: ReferencesDef> 
        => ast::ColumnConstraint { name, constraint: ast::ColumnConstraintKind::References(reference) },
    <name: NamedConstraint?> "CHECK" "(" <condition: ConditionalExpression> ")" 
        => ast::ColumnConstraint { name, constraint: ast::ColumnConstraintKind::Check(condition) },
};

ReferencesDef: ast::Reference = {
    "REFERENCES" <table: TableName> <columns: ColumnNameList?> <match_mode: MatchMode?> <on_delete: OnDeleteAction?> <on_update: OnUpdateAction?> 
        => ast::Reference {
            table,
            columns,
            match_mode,
            on_update,
            on_delete
        },
};

MatchMode: ast::MatchMode = {
    "MATCH" "FULL" => ast::MatchMode::Full,
    "MATCH" "PARTIAL" => ast::MatchMode::Partial,
};

OnDeleteAction: ast::ReferentialAction = {
    "ON" "DELETE" <action: ReferentialAction> => action,
};

OnUpdateAction: ast::ReferentialAction = {
    "ON" "UPDATE" <action: ReferentialAction> => action,
};

ReferentialAction: ast::ReferentialAction = {
    "NO" "ACTION" => ast::ReferentialAction::NoAction,
    "CASCADE" => ast::ReferentialAction::Cascade,
    "SET" "DEFAULT" => ast::ReferentialAction::SetDefault,
    "SET" "NULL" => ast::ReferentialAction::SetNull,
};

TableConstraintKind: ast::TableConstraint = {
    <name: NamedConstraint?> <constraint: UniqueKeyDef> => ast::TableConstraint { name, constraint },
    <name: NamedConstraint?> <constraint: PrimaryKeyDef> => ast::TableConstraint { name, constraint },
    <name: NamedConstraint?> <constraint: ForeignKeyDef> => ast::TableConstraint { name, constraint },
    <name: NamedConstraint?> <constraint: CheckConstraintDef> => ast::TableConstraint { name, constraint },
};

UniqueKeyDef: ast::TableConstraintKind = {
    "UNIQUE" <columns: ColumnNameList> => ast::TableConstraintKind::Unique(columns),
};

PrimaryKeyDef: ast::TableConstraintKind = {
    "PRIMARY" "KEY" <columns: ColumnNameList> => ast::TableConstraintKind::PrimaryKey(columns),
};

ForeignKeyDef: ast::TableConstraintKind = {
    "FOREIGN" "KEY" <columns: ColumnNameList> <reference: ReferencesDef> 
        => ast::TableConstraintKind::ForeignKey { columns, reference },
};

CheckConstraintDef: ast::TableConstraintKind = {
    "CHECK" "(" <condition: ConditionalExpression> ")" => ast::TableConstraintKind::Check(condition),
};

DropTableStatement: ast::DropTableStatement = {
    "DROP" "TABLE" <name: TableName> <drop_mode: DropMode> => ast::DropTableStatement { name, drop_mode },
};

CreateViewStatement: ast::CreateViewStatement = {
    "CREATE" "VIEW" <name: ViewName> <columns: ColumnNameList?>
        "AS" <expression: TableExpression> <view_check_option: CreateViewOption?> 
        => ast::CreateViewStatement { 
            name,
            columns,
            expression,
            view_check_option
        },
};

CreateViewOption: ast::ViewCheckOption = {
    "WITH" "CASCADED"? "CHECK" "OPTION" => ast::ViewCheckOption::Cascaded,
    "WITH" "LOCAL" "CHECK" "OPTION" => ast::ViewCheckOption::Local,
};

DropViewStatement: ast::DropViewStatement = {
    "DROP" "VIEW" <name: ViewName> <drop_mode: DropMode> => ast::DropViewStatement { name, drop_mode },
};

//
// Data Types
//

DataType: ast::DataType = {
    CharacterType,
    BinaryType,
    LogicalType,
    NumericType,
    GeometryType,
    DateTimeType,
};

CharacterType: ast::DataType = {
    Character <length: LengthSpecification?> => ast::DataType::Char(length.unwrap_or(1)),
    Character "VARYING" <length: LengthSpecification> => ast::DataType::VarChar(length),
    "VARCHAR" <length: LengthSpecification> => ast::DataType::VarChar(length),
};

Character = {
    "CHAR",
    "CHARACTER",
};

Decimal = {
    "DEC",
    "DECIMAL",
};

Integer = {
    "INT",
    "INTEGER",
};

Boolean = {
    "BOOL",
    "BOOLEAN",
};

LengthSpecification: usize = {
    "(" <length: IntegerLiteral> ")" => length,
};

FractionSpecification: usize = {
    "(" <fraction: IntegerLiteral> ")" => fraction,
};

IntegerLiteral: usize = {
    // the regex for numeric literals should limit values to proper SQL literals
    // this will correctly fail for floating point literals
    <num:NumericLiteral> => <>.parse::<usize>().unwrap(),
};

BinaryType: ast::DataType = {
    "BINARY" <length: LengthSpecification?> => ast::DataType::Binary(length.unwrap_or(1)),
    "VARYING" "BINARY" <length: LengthSpecification> => ast::DataType::VarBinary(length),
    "VARBINARY" <length: LengthSpecification> => ast::DataType::VarBinary(length),
};

LogicalType: ast::DataType = {
    // Apparently bit strings are no longer part of newer versions the standard
    //"BIT" LengthSpecification? => (),
    //"VARYING" "BIT" LengthSpecification => (),
    Boolean => ast::DataType::Boolean,
};

NumericType: ast::DataType = {
    ExactNumericType,
    ApproximateNumericType,
};

ExactNumericType: ast::DataType = {
    "NUMERIC" <prec: PrecisionSpecification?> => ast::DataType::Numeric(prec.unwrap_or(ast::DEFAULT_NUMERIC_PRECISION)),
    Decimal <prec: PrecisionSpecification?> => ast::DataType::Numeric(prec.unwrap_or(ast::DEFAULT_DECIMAL_PRECISION)),
    Integer => ast::DataType::Decimal(ast::INTEGER_NUMERIC_PRECISION),
    "SMALLINT" => ast::DataType::Decimal(ast::SMALLINT_DECIMAL_PRECISION),
};

ApproximateNumericType: ast::DataType = {
    "FLOAT" <frac: FractionSpecification?> => ast::DataType::Float(frac.unwrap_or(ast::DEFAULT_FLOAT_MANTISSA)),
    "REAL" => ast::DataType::Float(ast::DEFAULT_REAL_MANTISSA),
    "DOUBLE" "PRECISION" => ast::DataType::Float(ast::DEFAULT_DOUBLE_PRECISION_MANTISSA),
};

PrecisionSpecification: ast::PrecisionSpecification = {
    "(" <digits: IntegerLiteral> ")" => ast::PrecisionSpecification { digits, fractions: 0 },
    "(" <digits: IntegerLiteral> "," <fractions:IntegerLiteral> ")" => ast::PrecisionSpecification { digits, fractions: 0 },
};

GeometryType: ast::DataType = {
    "ST_GEOGRAPHY" <length: LengthSpecification> => ast::DataType::Geography(length),
    "ST_GEOMETRY" <length: LengthSpecification> => ast::DataType::Geometry(length),
};

DateTimeType: ast::DataType = {
    "DATE" => ast::DataType::Date,
    "TIME" => ast::DataType::Time,
    "TIMESTAMP" => ast::DataType::Timestamp,
    <interval: IntervalType> => ast::DataType::Interval(interval),
};

IntervalType: ast::IntervalType = {
    "INTERVAL" <unit:IntervalUnit> <prec: PrecisionSpecification?> => 
        ast::IntervalType { 
            from: ast::IntervalBound(unit, prec.unwrap_or_else(|| unit.default_precision())), 
            to: None 
        },
    "INTERVAL" <from_unit: IntervalUnit> <from_prec: PrecisionSpecification?> 
        "TO" <to_unit: IntervalUnit> <to_prec: PrecisionSpecification?> =>
        ast::IntervalType { 
            from: ast::IntervalBound(from_unit, from_prec.unwrap_or_else(|| from_unit.default_precision())), 
            to: Some(ast::IntervalBound(to_unit, to_prec.unwrap_or_else(|| to_unit.default_precision()))), 
        },
};

IntervalUnit: ast::IntervalUnit = {
    "YEAR" => ast::IntervalUnit::Year,
    "MONTH" => ast::IntervalUnit::Month,
    "DAY" => ast::IntervalUnit::Day,
    "HOUR" => ast::IntervalUnit::Hour,
    "MINUTE" => ast::IntervalUnit::Minute,
    "SECOND" => ast::IntervalUnit::Second,
};

//
// Data Manipulation
//

InsertStatement: ast::InsertStatement = {
    TableExpressions? "INSERT" "INTO" <table_name:QualifiedIdentifier> <columns:ColumnNameList?> <source:SelectCore> =>
        ast::InsertStatement { table_name, columns, source }, 
};

ColumnNameList: Vec<symbols::Name> = {
    "(" <ids:IdentifierList> ")" => ids,
};

DeleteStatement: ast::DeleteStatement = {
    TableExpressions? "DELETE" "FROM" <table_name:QualifiedIdentifier> <where_expr:WhereClause?> =>
        ast::DeleteStatement { table_name, where_expr },
};

UpdateStatement: ast::UpdateStatement = {
    TableExpressions? "UPDATE" <table_name:QualifiedIdentifier> 
    "SET" <assignments: Assignments> <where_expr:WhereClause?> =>
        ast::UpdateStatement { table_name, assignments, where_expr },
};

Assignments: Vec<ast::Assignment> = {
    Assignment => vec![<>],
    <assignments:Assignments> "," <assignment:Assignment> => ast::append(assignments, assignment),
};

Assignment: ast::Assignment = {
    <columns:IdentifierList> "=" <expr:Expression> => ast::Assignment { columns, expr },
};

SelectStatement: ast::SelectStatement = {
    <ctl:TableExpressions> <expr:SelectCoreList> <ordering:OrderByClause?> <limit:LimitClause?> => 
        ast::SelectStatement {
            common: ctl,
            expr,
            order_by: ordering.unwrap_or(Vec::new()),
            limit
        },
    <expr:SelectCoreList> <ordering:OrderByClause?> <limit:LimitClause?> => 
        ast::SelectStatement {
            common: vec![],
            expr,
            order_by: ordering.unwrap_or(Vec::new()),
            limit
        },
};

TableExpressions: Vec<ast::CommonTableExpression> = {
    "WITH" <ctl:CommonTableExpressionList> => ctl,
};

CommonTableExpressionList: Vec<ast::CommonTableExpression> = {
    <cte:CommonTableExpression> => vec![cte],
    <ctl:CommonTableExpressionList> "," <cte:CommonTableExpression> => ast::append(ctl, cte),
};

CommonTableExpression: ast::CommonTableExpression = {
    <id:Identifier> "AS" "(" <query:SelectStatement> ")" => ast::CommonTableExpression {
        identifier: id,
        column_names: None,
        query,
    },
    <id:Identifier> "(" <column_names:IdentifierList> ")" "AS" "(" <query: SelectStatement> ")" => ast::CommonTableExpression {
        identifier: id,
        column_names: Some(column_names),
        query,
    },
};

SelectCoreList: Box<ast::SetExpression> = {
    SelectCore,
    <left:SelectCoreList> <op:CompoundOperator> <right:SelectCore> =>
        Box::new(ast::SetExpression::Op { op, left, right }),
};

CompoundOperator: ast::SetOperator = {
    "UNION" => ast::SetOperator::Union,
    "UNION" "ALL" => ast::SetOperator::UnionAll,
    "INTERSECT" => ast::SetOperator::Intersect,
    "EXCEPT" => ast::SetOperator::Except,
};

SelectCore: Box<ast::SetExpression> = {
    "SELECT" <mode:SelectMode> <columns:ResultColumns> <where_expr:WhereClause?> <group_by:GroupByClause?> =>
        Box::new(ast::SetExpression::Query{ mode, columns, from: Vec::new(), where_expr, group_by }),
    "SELECT" <mode:SelectMode> <columns:ResultColumns> <from:FromClause> <where_expr:WhereClause?> <group_by:GroupByClause?> =>
        Box::new(ast::SetExpression::Query{ mode, columns, from, where_expr, group_by }),
    "VALUES" <tuples:TupleList> => Box::new(ast::SetExpression::Values(tuples)),
};

SelectMode: ast::SelectMode = {
    "ALL"? => ast::SelectMode::All,
    "DISTINCT" => ast::SelectMode::Distinct,
};

TupleList: Vec<Vec<Box<ast::Expression>>> = {
    Tuple => vec![<>],
    <tuples:TupleList> "," <tuple:Tuple> => ast::append(tuples, tuple),
};

Tuple: Vec<Box<ast::Expression>> = {
    "(" <exprs:ExpressionList> ")" => exprs,
};

ResultColumns: ast::ResultColumns = {
    "*" => ast::ResultColumns::All,
    ResultColumnList => ast::ResultColumns::List(<>),
};

ResultColumnList: Vec<Box<ast::ResultColumn>> = {
    ResultColumn => vec![<>],
    <columns:ResultColumnList> "," <column:ResultColumn> => ast::append(columns, column),
};

ResultColumn: Box<ast::ResultColumn> = {
    <expr:Expression> =>
        Box::new(ast::ResultColumn::Expr { expr, rename: None }),
    <expr:Expression> "AS"? <rename:Identifier> =>
        Box::new(ast::ResultColumn::Expr { expr, rename: Some(rename) }),
    <name:Identifier> "." "*" => Box::new(ast::ResultColumn::AllFrom(name)),
};

QualifiedIdentifier: Vec<symbols::Name> = {
    Identifier => vec![<>],
    <i1:Identifier> "." <i2:Identifier> => vec![i1, i2],
    <i1:Identifier> "." <i2:Identifier> "." <i3:Identifier> => vec![i1, i2, i3],
};

FromClause: Vec<Box<ast::TableExpression>> = {
    "FROM" <exprs:TableExpressionList> => exprs,
};

TableExpressionList: Vec<Box<ast::TableExpression>> = {
    TableExpression => vec![<>],
    <exprs:TableExpressionList> "," <expr:TableExpression> => ast::append(exprs, expr),
};

TableExpression: Box<ast::TableExpression> = {
    TableOrSubQuery,
    <left:TableExpression> <op:JoinOperator> <right:TableOrSubQuery> <constraint:JoinConstraint> =>
        Box::new(ast::TableExpression::Join { left, op, right, constraint }),
};

TableOrSubQuery: Box<ast::TableExpression> = {
    <name:QualifiedIdentifier> <alias:TableAlias?> =>
        Box::new(ast::TableExpression::Named { name, alias }),
    "(" <select:SelectStatement> ")" <alias:TableAlias?> =>
        Box::new(ast::TableExpression::Select { select, alias }),
    "(" <expr:TableExpression> ")" => expr,
};

TableAlias: symbols::Name = {
    "AS"? <name:Identifier> => name,
};

JoinOperator: ast::JoinOperator = {
    <join:JoinType?> "JOIN" => ast::JoinOperator::Join(join.unwrap_or(ast::JoinType::Inner)),
    "NATURAL" <join:JoinType?> "JOIN" => ast::JoinOperator::Natural(join.unwrap_or(ast::JoinType::Inner)),
    "CROSS" "JOIN" => ast::JoinOperator::Cross,
};

JoinType: ast::JoinType = {
    "LEFT" "OUTER"? => ast::JoinType::Left,
    "RIGHT" "OUTER"? => ast::JoinType::Right,
    "FULL" "OUTER"? => ast::JoinType::Full,
    "INNER" => ast::JoinType::Inner,
};

JoinConstraint: ast::JoinConstraint = {
    "ON" <expr:Expression> => ast::JoinConstraint::Expr(expr),
    "USING" "(" <ids:IdentifierList> ")" => ast::JoinConstraint::Columns(ids),
};

IdentifierList: Vec<symbols::Name> = {
    Identifier => vec![<>],
    <ids:IdentifierList> "," <id:Identifier> => ast::append(ids, id),
};

WhereClause: Box<ast::Expression> = {
    "WHERE" <expr:Expression> => expr,
};

GroupByClause: ast::GroupBy = {
    "GROUP" "BY" <groupings:ExpressionList> => ast::GroupBy { groupings, having: None },
    "GROUP" "BY" <groupings:ExpressionList> "HAVING" <expr:Expression> =>
        ast::GroupBy { groupings, having: Some(expr) },
};

OrderByClause: Vec<ast::Ordering> = {
    "ORDER" "BY" <ordering:OrderingTermList> => ordering,
};

OrderingTermList: Vec<ast::Ordering> = {
    OrderingTerm => vec![<>],
    <terms:OrderingTermList> "," <term:OrderingTerm> => ast::append(terms, term),
};

OrderingTerm: ast::Ordering = {
    <expr:Expression> <collation:OrderingCollation?> <direction:OrderingDirection> => 
        ast::Ordering { expr, collation, direction },
};

OrderingCollation: symbols::Name = {
    "COLLATE" <name:Identifier> => name,
};

OrderingDirection: ast::OrderingDirection = {
    "ASC"? => ast::OrderingDirection::Ascending,
    "DESC" => ast::OrderingDirection::Descending,
};

LimitClause: ast::Limit = {
    "LIMIT" <number_rows:Expression> => ast::Limit { number_rows, offset_value: None },
    "LIMIT" <number_rows:Expression> "," <offset:Expression> =>
        ast::Limit { number_rows, offset_value: Some(offset) },
    "LIMIT" <number_rows:Expression> "OFFSET" <offset:Expression> =>
        ast::Limit { number_rows, offset_value: Some(offset) },    
};

AttachStatement: ast::AttachStatement = {
    "ATTACH" "FILE" <path: StringLiteral> "AS" <schema: NameQualifier?> <name: Identifier> => 
        ast::AttachStatement::new(schema, name, path),
};

DescribeStatement: ast::DescribeStatement = {
    "DESCRIBE" <schema: NameQualifier?> <name: Identifier> => 
        ast::DescribeStatement::new(schema, name),
};

//
// Expressions
//

ExpressionList: Vec<Box<ast::Expression>> = {
    Expression => vec![<>],
    <exprs:ExpressionList> "," <expr:Expression> => ast::append(exprs, expr),
};

PrimaryExpression: Box<ast::Expression> = {
    "(" <exprs:ExpressionList> ")" => {
        if exprs.len() == 1 {
            let mut copy = exprs;
            copy.remove(0)
        } else {
            Box::new(ast::Expression::MakeTuple(exprs))
        }
    },
    "(" <select:SelectStatement> ")" => Box::new(ast::Expression::Select(select)),
    LiteralValue => Box::new(ast::Expression::Literal(<>)),
    QualifiedIdentifier => Box::new(ast::Expression::QualifiedIdentifier(<>)),
};

UnaryExpression: Box<ast::Expression> = {
    PrimaryExpression,
    "+" <expr:UnaryExpression> => expr,
    "-" <expr:UnaryExpression> => Box::new(ast::Expression::Unary { op: ast::UnaryOperator::Negate, expr }),
};

MultiplicativeExpression: Box<ast::Expression> = {
    UnaryExpression,
    <left:MultiplicativeExpression> "*" <right:UnaryExpression> =>
        Box::new(ast::Expression::Binary { op: ast::BinaryOperator::Multiply, left, right }),
    <left:MultiplicativeExpression> "/" <right:UnaryExpression> =>
        Box::new(ast::Expression::Binary { op: ast::BinaryOperator::Divide, left, right }),
};

AdditiveExpression: Box<ast::Expression> = {
    MultiplicativeExpression,
    <left:AdditiveExpression> "+" <right:MultiplicativeExpression> =>
        Box::new(ast::Expression::Binary { op: ast::BinaryOperator::Add, left, right }),
    <left:AdditiveExpression> "-" <right:MultiplicativeExpression> =>
        Box::new(ast::Expression::Binary { op: ast::BinaryOperator::Subtract, left, right }),
    <left:AdditiveExpression> "||" <right:MultiplicativeExpression> =>
        Box::new(ast::Expression::Binary { op: ast::BinaryOperator::Concat, left, right }),
};

ComparativeExpression: Box<ast::Expression> = {
    AdditiveExpression,
    <left:ComparativeExpression> "=" <right:AdditiveExpression> =>
        Box::new(ast::Expression::Comparison { op: ast::ComparisonOperator::Equal, left, right }),
    <left:ComparativeExpression> "!=" <right:AdditiveExpression> =>
        Box::new(ast::Expression::Comparison { op: ast::ComparisonOperator::NotEqual, left, right }),
    <left:ComparativeExpression> "<" <right:AdditiveExpression> =>
        Box::new(ast::Expression::Comparison { op: ast::ComparisonOperator::LessThan, left, right }),
    <left:ComparativeExpression> ">" <right:AdditiveExpression> =>
        Box::new(ast::Expression::Comparison { op: ast::ComparisonOperator::GreaterThan, left, right }),
    <left:ComparativeExpression> "<=" <right:AdditiveExpression> =>
        Box::new(ast::Expression::Comparison { op: ast::ComparisonOperator::LessEqual, left, right }),
    <left:ComparativeExpression> ">=" <right:AdditiveExpression> =>
        Box::new(ast::Expression::Comparison { op: ast::ComparisonOperator::GreaterEqual, left, right }),
    <left:ComparativeExpression> "IS" "NULL" =>
        Box::new(ast::Expression::Unary { op: ast::UnaryOperator::IsNull, expr: left }),
    <left:ComparativeExpression> "IS" "NOT" "NULL" => {
        let not_null = Box::new(ast::Expression::Unary { op: ast::UnaryOperator::IsNull, expr: left });
        Box::new(ast::Expression::Unary { op: ast::UnaryOperator::Not, expr: not_null })
    },
    <left:ComparativeExpression> "LIKE" <right:AdditiveExpression> =>
        Box::new(ast::Expression::Comparison { op: ast::ComparisonOperator::Like, left, right }),

    <expr:ComparativeExpression> "ISNULL" =>
        Box::new(ast::Expression::Unary { op: ast::UnaryOperator::IsNull, expr }),
    <expr:ComparativeExpression> "NOTNULL" =>
        Box::new(ast::Expression::Unary { op: ast::UnaryOperator::Not,
                 expr: Box::new(ast::Expression::Unary { op: ast::UnaryOperator::IsNull, expr }) }),
    <expr:ComparativeExpression> "NOT" "NULL" =>
        Box::new(ast::Expression::Unary { op: ast::UnaryOperator::Not,
                 expr: Box::new(ast::Expression::Unary { op: ast::UnaryOperator::IsNull, expr }) }),

    <expr:ComparativeExpression> "IN" "("  ")" =>
        Box::new(ast::Expression::In { expr, set: ast::SetSpecification::List(Vec::new()) }),
    <expr:ComparativeExpression> "NOT" "IN" "("  ")" =>
        Box::new(ast::Expression::Unary { op: ast::UnaryOperator::Not,        
            expr: Box::new(ast::Expression::In { expr, set: ast::SetSpecification::List(Vec::new()) }) }),

    <expr:ComparativeExpression> "IN" "(" <exprs:ExpressionList> ")" =>
        Box::new(ast::Expression::In { expr, set: ast::SetSpecification::List(exprs) }),
    <expr:ComparativeExpression> "NOT" "IN" "(" <exprs:ExpressionList> ")" =>
        Box::new(ast::Expression::Unary { op: ast::UnaryOperator::Not,        
            expr: Box::new(ast::Expression::In { expr, set: ast::SetSpecification::List(exprs) }) }),

    <expr:ComparativeExpression> "IN" "(" <select:SelectStatement> ")" =>
        Box::new(ast::Expression::In { expr, set: ast::SetSpecification::Select(select)} ),
    <expr:ComparativeExpression> "NOT" "IN" "(" <select:SelectStatement> ")" =>
        Box::new(ast::Expression::Unary { op: ast::UnaryOperator::Not,        
            expr: Box::new(ast::Expression::In { expr, set: ast::SetSpecification::Select(select) }) }),

    <expr:ComparativeExpression> "IN" <name:QualifiedIdentifier> =>
        Box::new(ast::Expression::In { expr, set: ast::SetSpecification::Name(name) }),
    <expr:ComparativeExpression> "NOT" "IN" <name:QualifiedIdentifier> =>
        Box::new(ast::Expression::Unary { op: ast::UnaryOperator::Not,        
            expr: Box::new(ast::Expression::In { expr, set: ast::SetSpecification::Name(name) }) }),

    <expr:ComparativeExpression> "BETWEEN" <lower:AdditiveExpression> "AND" <upper:AdditiveExpression> =>
        Box::new(ast::Expression::Between { expr, lower, upper }),
    <expr:ComparativeExpression> "NOT" "BETWEEN" <lower:AdditiveExpression> "AND" <upper:AdditiveExpression> =>
        Box::new(ast::Expression::Unary { op: ast::UnaryOperator::Not,
            expr: Box::new(ast::Expression::Between { expr, lower, upper }) }),
};

ComplexExpression: Box<ast::Expression> = {
    ComparativeExpression,
    CaseExpression,
};

CaseExpression: Box<ast::Expression> = {
    "CASE" <expr:Expression?> <when_part:WhenClause+> <else_part:ElseClause?> "END" =>
        Box::new(ast::Expression::Case { expr, when_part, else_part }),
};

WhenClause: ast::WhenClause = {
    "WHEN" <when:Expression> "THEN" <then:Expression> => ast::WhenClause { guard: when, body:then},
};

ElseClause: Box<ast::Expression> = {
    "ELSE" <expr:Expression> => expr,
};

NotExpression: Box<ast::Expression> = {
    ComplexExpression,
    "NOT" <expr:ComplexExpression> => Box::new(ast::Expression::Unary { op: ast::UnaryOperator::Not, expr }),
};

AndExpression: Box<ast::Expression> = {
    NotExpression,
    <left:AndExpression> "AND" <right:NotExpression> =>
        Box::new(ast::Expression::Binary { op: ast::BinaryOperator::And, left, right }),
};

OrExpression: Box<ast::Expression> = {
    AndExpression,
    <left:OrExpression> "OR" <right:AndExpression> =>
        Box::new(ast::Expression::Binary { op: ast::BinaryOperator::Or, left, right }),
};

Expression: Box<ast::Expression> = {
    OrExpression,
};

//
// Tokens
//

LiteralValue: ast::Literal = {
    NumericLiteral => ast::Literal::NumericLiteral(<>),
    StringLiteral => ast::Literal::StringLiteral(<>),
    "NULL" => ast::Literal::Null,
    NiladicFunction,
    "DATE" <s:StringLiteral> => ast::Literal::DateLiteral(s),
    "TIME" <s:StringLiteral> => ast::Literal::TimeLiteral(s),
    "TIMESTAMP" <s:StringLiteral> => ast::Literal::TimestampLiteral(s),
};

NiladicFunction: ast::Literal = {
    "CURRENT_TIME" => ast::Literal::CurrentTime,
    "CURRENT_DATE" => ast::Literal::CurrentDate,
    "CURRENT_TIMESTAMP" => ast::Literal::CurrentTimestamp,
}

Identifier: symbols::Name = ID => symbols::Name::from(<>);

NumericLiteral: String = {
    NUMERIC_LIT_1 => <>.to_string(),
    NUMERIC_LIT_2 => <>.to_string(),
    HEX_LIT => <>.to_string(),
};

StringLiteral: String = STRING_LIT => <>[1..<>.len() - 1].to_string();