pub enum BinaryOperator {
  Eq
  Neq
  Lt
  Gt
  LtEq
  GtEq
  Spaceship
  Plus
  Minus
  Mul
  Div
  Mod
  And
  Or
}

pub struct CaseExpr {
  operand : Expr?
  when_then_clauses : Array[(Expr, Expr)]
  else_expr : Expr?
}

pub struct ColumnDef {
  name : String
  data_type : DataType
  options : Array[ColumnDefOption]
}

pub enum ColumnDefOption {
  NotNull
  Unique
  Default(Expr)
}

pub struct CreateTableStmt {
  name : String
  columns : Array[ColumnDef]
  primary_key : String?
}

type CreateViewStmt

pub enum DataType {
  Integer
  Float(Int?)
  Real
  Double
  Char(Int)
  Varchar(Int)
  Text
  Boolean
  Timestamp
  Blob
}

pub enum DatetimeUnit {
  Year
  Month
  Day
  Hour
  Minute
  Second
}

pub struct DropViewStmt {
  name : String
}

pub enum DuplicateTreatment {
  Distinct
  All
}

pub enum Expr {
  Identifier(String)
  CompoundIdentifier(Array[String])
  Literal(Literal)
  BinaryOperation(Expr, BinaryOperator, Expr)
  UnaryOperation(UnaryOperator, Expr)
  FunctionCall(String, DuplicateTreatment?, Array[Expr])
  Wildcard
  Datetime(String)
  Interval(String, IntervalQualifier)
  Like(Bool, Expr, Expr)
  ILike(Bool, Expr, Expr)
  SubQuery(SelectStmt)
  Exists(Bool, SelectStmt)
  Between(Bool, Expr, Expr, Expr)
  Extract(PrimaryDatetimeField, Expr)
  Case(CaseExpr)
  InList(Bool, Expr, Array[Expr])
  InSubQuery(Bool, Expr, SelectStmt)
  Substring(Expr, Expr?, Expr?)
}

pub enum IntervalQualifier {
  Single(PrimaryDatetimeField)
  Range(PrimaryDatetimeField, PrimaryDatetimeField)
}

pub struct Join {
  table_ref : TableRef
  join_operator : JoinOperator
}

pub enum JoinConstraint {
  On(Expr)
  Using(Array[String])
  None
}

pub enum JoinOperator {
  Join(JoinConstraint)
  Left(JoinConstraint)
  LeftOuter(JoinConstraint)
  Right(JoinConstraint)
  RightOuter(JoinConstraint)
  Full(JoinConstraint)
  FullOuter(JoinConstraint)
  Inner(JoinConstraint)
  Cross
}

pub(all) enum Keyword {
  Select
  From
  Where
  As
  Group
  Order
  By
  Asc
  Desc
  Nulls
  First
  Last
  Year
  Month
  Day
  Hour
  Minute
  Second
  Date
  Interval
  To
  Like
  Not
  ILike
  Exists
  Between
  And
  Or
  Extract
  Case
  When
  Then
  Else
  Having
  End
  In
  Join
  Left
  Right
  Full
  Outer
  Inner
  Cross
  On
  Using
  Limit
  Offset
  Create
  Table
  Integer
  Int
  Smallint
  Bigint
  Real
  Double
  Precision
  Char
  Character
  Varchar
  Varing
  Text
  Time
  Boolean
  Float
  Timestamp
  Blob
  Null
  Default
  Unique
  View
  Drop
  Distinct
  All
  Substring
  For
}

type LexerError

pub enum Literal {
  Integer(Int)
  Double(Double)
  String(String)
  Boolean(Bool)
  Null
}

pub struct OrderByExpr {
  expr : Expr
  asc : Bool?
  nulls_first : Bool?
}

type ParserError

pub(all) enum Precedence {
  PlusMinus
  MulDivMod
  Eq
  Like
  And
  Or
  Between
  UnaryNot
}

type PrimaryDatetimeField

pub enum Projection {
  Wildcard
  UnamedExpr(Expr)
  AliasedExpr(Expr, String)
}

pub struct SelectStmt {
  projections : Array[Projection]
  from : Array[TableRef]
  where_clause : Expr?
  group_by : Array[Expr]
  having : Expr?
  order_by : Array[OrderByExpr]
  limit : Expr?
  offset : Expr?
}

pub suberror SqlParserError {
  LexerError(LexerError)
  ParserError(ParserError)
}

pub enum Statement {
  Select(SelectStmt)
  CreateTable(CreateTableStmt)
  CreateView(CreateViewStmt)
  DropView(DropViewStmt)
}

pub struct Statements {
  stmts : Array[Statement]
}

pub struct TableAlias {
  name : String
  columns : Array[String]
}

pub enum TableFactor {
  Column(String, TableAlias?)
  SubQuery(SelectStmt, TableAlias?)
}

pub struct TableRef {
  factor : TableFactor
  joins : Array[Join]
}

pub(all) enum Token {
  Keyword(Keyword)
  Identifier(String)
  Number(String)
  StringLiteral(String)
  Boolean(Bool)
  Comma
  Semicolon
  Eq
  DoubleEq
  Neq
  Lt
  Gt
  LtEq
  GtEq
  Spaceship
  Plus
  Minus
  Mul
  Div
  Mod
  LBracket
  RBracket
  LBrace
  RBrace
  LParen
  RParen
  Period
  Unknown(Char)
  Eof
}

pub enum UnaryOperator {
  Plus
  Minus
  Not
}

pub struct ViewColumnDef {
  name : String
}

fn lex(input : String) -> Array[Token] raise LexerError

fn parse(tokens : ArrayView[Token]) -> Array[Statement] raise ParserError

fn parse_sql(input : String) -> Statements raise SqlParserError