pub(all) enum Asc {
  Ascending
  Descending
}

pub(all) enum BinaryOperator {
  Eq
  Neq
  Lt
  Gt
  LtEq
  GtEq
  Spaceship
  Plus
  Minus
  Mul
  Div
  Mod
}

pub(all) enum DatetimeUnit {
  Year
  Month
  Day
  Hour
  Minute
  Second
}

pub(all) enum Expr {
  Identifier(String)
  Literal(Literal)
  BinaryOperation(Expr, BinaryOperator, Expr)
  UnaryOperation(UnaryOperator, Expr)
  FunctionCall(String, Array[Expr])
  Wildcard
  Datetime(String)
  Interval(String, IntervalQualifier)
}

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
}

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

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)
  TableAlias(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
  Unknown(Char)
  Eof
}

pub(all) enum UnaryOperator {
  Negate
  Not
}

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