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

pub(all) 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)
}

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

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
}

type Lexer

type LexerError

pub(all) 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(all) 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(all) enum Statement {
  Select(SelectStmt)
}

pub(all) enum TableRef {
  Table(String, String?)
  SubQuery(SelectStmt, String?)
}

pub(all) enum Token {
  Keyword(Keyword)
  Identifier(String)
  Number(String)
  StringLiteral(String)
  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(all) enum UnaryOperator {
  Negate
  Not
}

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