type Row = Array[Value]

pub(all) suberror ExecuteError {
  ExecuteError(String, cause~ : Error?)
}

pub(all) suberror PyException {
  PyException(String, String)
}

pub enum Code {
  Const(Value)
  Name(String)
  Attr(Code, String)
  Subscript(Code, Code)
  Call(Code, Array[Code])
  Lambda(Array[String], Code)
  IfExp(Code, Code, Code)
  BoolOp(Bool, Array[Code])
  Not(Code)
  Unary(String, Code)
  Binary(String, Code, Code)
  Compare(Code, Array[(String, Code)])
  ListDisplay(Array[Code])
  TupleDisplay(Array[Code])
  DictDisplay(Array[(Code, Code)])
}

pub struct Context {
  tables : Array[(String?, Table)]
  table_ : Table?
  range_readers : Map[String?, Reader]
  row_readers : Map[String?, Reader]
  env : Map[String, Value]
  scope : Value
}

pub(all) struct PyDate {
  year : Int
  month : Int
  day : Int
} derive(Eq)

pub(all) struct PyDateTime {
  date : PyDate
  time : PyTime
  tz : Int?
}

pub(all) struct PyFunc {
  name : String
  call : (Array[Value]) -> Value raise
}

pub(all) struct PyTime {
  hour : Int
  minute : Int
  second : Int
  microsecond : Int
} derive(Eq)

pub(all) struct PyTimeDelta {
  days : Int64
  seconds : Int
  microseconds : Int
} derive(Eq)

pub struct PythonExecutor {
  env : Map[String, Value]
  tables : Tables
  // private fields
}

pub struct RangeReader {
  table : Table?
  start : Int
  stop : Int
}

pub enum Reader {
  Row(RowReader)
  Range(RangeReader)
}

pub struct RowReader {
  columns : Map[String, Int]
  row : Array[Value]
}

pub struct Table {
  columns : Array[String]
  column_range : (Int, Int)?
  reader : RowReader
  rows : Array[Array[Value]]
  range_reader : RangeReader
}

pub(all) enum TableData {
  Records(Array[Array[(String, Value)]])
  Tbl(Table)
  Nested(Map[String, TableData])
}

pub struct TableIter {
  table : Table
  index : Int
}

pub struct Tables {
  mapping : Map[String, TableData]
  supported_table_args : Array[String]
}

pub(all) enum Value {
  Null
  Bool(Bool)
  Int(Int64)
  Float(Double)
  Str(String)
  List(Array[Value])
  Tuple(Array[Value])
  Dict(Array[(Value, Value)])
  Set(Array[Value])
  Date(PyDate)
  Time(PyTime)
  DateTime(PyDateTime)
  TimeDelta(PyTimeDelta)
  Iter(Array[Value])
  Func(PyFunc)
  Module(String)
  DTypeV(
@bobzhang/sqlglot/core.DType
DType)
  Readers(Map[String?, Reader])
  ReaderV(Reader)
  RevKey(Value)
}

fn compile_python(source : String) -> Code raise PyException

fn date_fromisoformat(v : Value) -> PyDate raise PyException

fn datetime_fromisoformat(v : Value) -> PyDateTime raise PyException

let default_env : Map[String, Value]

fn ensure_tables(d : Map[String, TableData]?, dialect? : 
@bobzhang/sqlglot/core.Dialect
Dialect) -> Tables raise 
@bobzhang/sqlglot/core.SqlglotError
SqlglotError

fn error_message(e : Error) -> String

fn eval_code(code : Code, globals : Map[String, Value], scope : Value) -> Value raise

fn[T : 
@bobzhang/sqlglot/core.IntoPy
IntoPy] execute(sql : T, schema? : Map[String, 
@bobzhang/sqlglot/optimizer.SchemaNode
SchemaNode], mapping_schema? : 
@bobzhang/sqlglot/optimizer.MappingSchema
MappingSchema, read? : String, dialect? : String, tables? : Map[String, TableData]) -> Table raise

fn float_repr(d : Double) -> String

fn hash_key(v : Value) -> String raise PyException

fn py_abs(a : Value) -> Value raise PyException

fn py_add(a : Value, b : Value) -> Value raise PyException

fn py_bitop(op : String, a : Value, b : Value) -> Value raise PyException

fn py_eq(a : Value, b : Value) -> Bool

fn py_float(v : Value) -> Value raise PyException

fn py_floordiv(a : Value, b : Value) -> Value raise PyException

fn py_fsum(values : Array[Value]) -> Double raise PyException

fn py_ge(a : Value, b : Value) -> Bool raise PyException

fn py_getitem(container : Value, key : Value) -> Value raise PyException

fn py_gt(a : Value, b : Value) -> Bool raise PyException

fn py_int(v : Value) -> Value raise PyException

fn py_invert(a : Value) -> Value raise PyException

fn py_iter(v : Value) -> Array[Value] raise PyException

fn py_le(a : Value, b : Value) -> Bool raise PyException

fn py_len(v : Value) -> Int raise PyException

fn py_lt(a : Value, b : Value) -> Bool raise PyException

fn py_max(values : Array[Value]) -> Value raise PyException

fn py_min(values : Array[Value]) -> Value raise PyException

fn py_mod(a : Value, b : Value) -> Value raise PyException

fn py_mul(a : Value, b : Value) -> Value raise PyException

fn py_neg(a : Value) -> Value raise PyException

fn py_pos(a : Value) -> Value raise PyException

fn py_pow(a : Value, b : Value) -> Value raise PyException

fn py_round(x : Value, ndigits : Value) -> Value raise PyException

fn py_set(values : Array[Value]) -> Array[Value] raise PyException

fn py_set_union(a : Array[Value], b : Array[Value]) -> Array[Value] raise PyException

fn py_slice(v : Value, start : Value, stop : Value, step? : Int) -> Value raise PyException

fn py_sub(a : Value, b : Value) -> Value raise PyException

fn py_sum(values : Array[Value]) -> Value raise PyException

fn py_truediv(a : Value, b : Value) -> Value raise PyException

fn python_dialect() -> 
@bobzhang/sqlglot/core.Dialect
Dialect

fn python_generate(expression : 
@bobzhang/sqlglot/core.Expr
Expr, identify? : Bool) -> String raise 
@bobzhang/sqlglot/core.SqlglotError
SqlglotError

fn strftime(dt : PyDateTime, fmt : String) -> String

fn strptime(s : String, fmt : String) -> PyDateTime raise PyException

fn time_fromisoformat(v : Value) -> PyTime raise PyException