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 enum DatetimeUnit {
  Year
  Month
  Day
  Hour
  Minute
  Second
}

pub enum Expr {
  Identifier(String)
  CompoundIdentifier(Array[String])
  Literal(Literal)
  BinaryOperation(Expr, BinaryOperator, Expr)
  UnaryOperation(UnaryOperator, Expr)
  FunctionCall(String, 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)
}

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
}

type Lexer

type LexerError

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

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

pub struct Parser {
  input : Array[Token]
  offset : Int
}

type ParserError

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

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 : Int?
  offset : Int?
}

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

pub enum Statement {
  Select(SelectStmt)
}

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)
  Null
  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 {
  Negate
  Not
}

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