pub(open) trait Engine {
  async exec(Self, query : Query) -> QueryResult
  async exec_raw(Self, sql : String, params : FixedArray[Param]) -> QueryResult
  async migrate_table(Self, table_schema : Json) -> QueryResult
  close(Self) -> Unit
}

pub(open) trait FromParam {
  from_param(Param) -> Self raise ParamDecodeError
}

pub(open) trait QueryBuilder {
  to_statement(Self) -> Statement
}

pub(open) trait ToParam {
  to_param(Self) -> Param
}

pub(all) suberror ParamDecodeError {
  ParamDecodeError(String)
}

pub(all) struct ConnectionPool[C] {
  idle : 
@moonbitlang/async/aqueue.Queue
Queue[C]
  permits : 
@moonbitlang/async/semaphore.Semaphore
Semaphore
  closed : Bool
}

pub(all) struct DeleteStatement {
  from : String
  where_ : FixedArray[Where]
}

pub(all) struct InsertStatement {
  into : String
  columns : FixedArray[String]
  values : FixedArray[Param]
  rows : FixedArray[FixedArray[Param]]
}

pub(all) enum OrderBy {
  Asc(String)
  Desc(String)
}

pub(all) enum Param {
  Null
  Bool(Bool)
  Byte(Byte)
  Int(Int)
  Int16(Int16)
  UInt16(UInt16)
  UInt(UInt)
  UInt64(UInt64)
  Int64(Int64)
  BigInt(
@moonbitlang/core/bigint.BigInt
BigInt)
  Float(Float)
  Double(Double)
  Decimal(String)
  Date(
@oboard/morm/time.PlainDate
PlainDate, String?)
  Time(
@oboard/morm/time.PlainTime
PlainTime, String?)
  DateTime(
@oboard/morm/time.PlainDateTime
PlainDateTime, String?)
  Timestamp(
@oboard/morm/time.ZonedDateTime
ZonedDateTime, String?)
  Uuid(String)
  Json(Json)
  String(String)
  Bytes(Bytes)
}

pub(all) enum Query {
  Statement(Statement)
  Raw(String, FixedArray[Param])
  Tx(TxOp)
}

pub(all) struct QueryResult {
  ok : Bool
  rows_affected : Int
  rows : FixedArray[Json]
  error : String?
}

pub(all) struct SelectStatement {
  select : String
  from : String
  joins : FixedArray[String]
  where_ : FixedArray[Where]
  order_by : FixedArray[OrderBy]
  limit : Int?
  offset : Int?
}

pub(all) struct Set {
  col : String
  value : Param
}

pub(all) enum Statement {
  Select(SelectStatement)
  Insert(InsertStatement)
  Upsert(UpsertStatement)
  Update(UpdateStatement)
  Delete(DeleteStatement)
}

pub(all) enum TxOp {
  Begin
  Commit
  Rollback
  Savepoint(String)
  RollbackToSavepoint(String)
}

pub(all) struct UpdateStatement {
  table : String
  sets : FixedArray[Set]
  where_ : FixedArray[Where]
}

pub(all) struct UpsertStatement {
  table : String
  sets : FixedArray[Set]
  conflict_target : FixedArray[String]
  update_sets : FixedArray[Set]
}

pub(all) struct Where {
  col : String
  value : Param
  ty : WhereType
}

pub(all) enum WhereType {
  Eq
  Ne
  Gt
  Lt
  Gte
  Lte
  Like
}

fn bytes_to_hex(data : Bytes) -> String

fn decode_json_column(value : Json, storage : String) -> Json raise ParamDecodeError

async fn[E : Engine] exec(engine : E, query : Query) -> QueryResult

async fn[E : Engine, Q : QueryBuilder] exec_query(engine : E, query : Q) -> QueryResult

fn format_plain_date(value : 
@oboard/morm/time.PlainDate
PlainDate, format : String?) -> String

fn format_plain_date_time(value : 
@oboard/morm/time.PlainDateTime
PlainDateTime, format : String?) -> String

fn format_plain_time(value : 
@oboard/morm/time.PlainTime
PlainTime, format : String?) -> String

fn format_zoned_date_time(value : 
@oboard/morm/time.ZonedDateTime
ZonedDateTime, format : String?) -> String

fn[T : FromParam] from_param(value : Param) -> T raise ParamDecodeError

fn param_from_json_value(json : Json) -> Param

async fn[E : Engine] preload_belongs_to_default(engine : E, sql : String, target_key : String, key_params : FixedArray[Param]) -> Map[String, Json]

async fn[E : Engine] preload_has_many_default(engine : E, sql : String, target_key : String, key_params : FixedArray[Param]) -> Map[String, Array[Json]]

fn preload_in_sql_dollar(table : String, key_col : String, count : Int) -> String

fn preload_in_sql_qmark(table : String, key_col : String, count : Int) -> String

async fn[E : Engine] preload_many_to_many_default(engine : E, sql : String, key_params : FixedArray[Param]) -> Map[String, Array[Json]]

fn preload_many_to_many_sql_dollar(target_table : String, target_key : String, join_table : String, join_owner_key : String, join_target_key : String, count : Int) -> String

fn preload_many_to_many_sql_qmark(target_table : String, target_key : String, join_table : String, join_owner_key : String, join_target_key : String, count : Int) -> String

fn render_default_sql(stmt : Statement) -> (String, FixedArray[Param])

fn[T : ToParam] to_param(value : T) -> Param

async fn[E : Engine] tx_begin(engine : E) -> QueryResult

async fn[E : Engine] tx_commit(engine : E) -> QueryResult

async fn[E : Engine] tx_rollback(engine : E) -> QueryResult

async fn[E : Engine] tx_rollback_to_savepoint(engine : E, name : String) -> QueryResult

async fn[E : Engine] tx_savepoint(engine : E, name : String) -> QueryResult