🥮 mooncakes.io

    oboard/morm/engine does not have a README file

    Engine

    source
    pub(open) trait Engine {
      async fn page(Self, query : &QueryBuilder, pageable : Pageable) -> QueryResult
      async fn page_raw(Self, sql : String, params : FixedArray[Param], pageable : Pageable) -> QueryResult
      async fn exec(Self, query : &QueryBuilder) -> QueryResult
      async fn exec_raw(Self, sql : String, params : FixedArray[Param]) -> QueryResult
      async fn migrate_table(Self, table_schema : 
    Table    ) -> QueryResult
      fn close(Self) -> Unit
    }

    FromParam

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

    impl FromParam for Unit
    impl FromParam for Bool
    impl FromParam for Byte
    impl FromParam for Int
    impl FromParam for Int16
    impl FromParam for Int64
    impl FromParam for UInt
    impl FromParam for UInt16
    impl FromParam for UInt64
    impl FromParam for Float
    impl FromParam for Double
    impl FromParam for String
    impl FromParam for Option[T]
    impl FromParam for Bytes
    impl FromParam for BigInt
    impl FromParam for Json

    QueryBuilder

    source
    pub(open) trait QueryBuilder {
      fn to_query(Self) -> Query
    }

    ToParam

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

    impl ToParam for Unit
    impl ToParam for Bool
    impl ToParam for Byte
    impl ToParam for Int
    impl ToParam for Int16
    impl ToParam for Int64
    impl ToParam for UInt
    impl ToParam for UInt16
    impl ToParam for UInt64
    impl ToParam for Float
    impl ToParam for Double
    impl ToParam for String
    impl ToParam for Bytes
    impl ToParam for BigInt
    impl ToParam for Json
    impl ToParam for Map[String, Param]

    ParamDecodeError

    source
    pub(all) suberror ParamDecodeError {
      ParamDecodeError(String)
    } derive(Eq, ToJson)

    ParamDecodeError::equal

    source

    ParamDecodeError::not_equal

    source
    fn ParamDecodeError::not_equal(x : ParamDecodeError, y : ParamDecodeError) -> Bool

    ParamDecodeError::output

    source
    fn ParamDecodeError::output(self : ParamDecodeError, logger : &Logger) -> Unit

    ParamDecodeError::to_json

    source

    ParamDecodeError::to_string

    source
    fn ParamDecodeError::to_string(self : ParamDecodeError) -> String

    ConnectionPool

    source
    pub(all) struct ConnectionPool[C] {
      idle : 
    Queue    [C]
      permits : 
    Semaphore
      closed : Bool
    }

    ConnectionPool::ConnectionPool

    source
    fn[C] ConnectionPool::ConnectionPool(max_open : Int, max_idle? : Int) -> ConnectionPool[C]

    ConnectionPool::borrow

    source
    async fn[C] ConnectionPool::borrow(self : ConnectionPool[C], open_conn : async () -> Result[C, String]) -> Result[C, String]

    ConnectionPool::close

    source
    fn[C] ConnectionPool::close(self : ConnectionPool[C], close_conn : (C) -> Unit) -> Unit

    ConnectionPool::release

    source
    fn[C] ConnectionPool::release(self : ConnectionPool[C], conn : C, close_conn : (C) -> Unit, reusable? : Bool) -> Unit

    DeleteStatement

    source
    pub(all) struct DeleteStatement {
      from : String
      where_ : FixedArray[Where]
    } derive(Eq, ToJson, 
    FromJson    )

    DeleteStatement::equal

    source

    DeleteStatement::from_json

    source

    DeleteStatement::not_equal

    source
    fn DeleteStatement::not_equal(x : DeleteStatement, y : DeleteStatement) -> Bool

    DeleteStatement::output

    source
    fn DeleteStatement::output(self : DeleteStatement, logger : &Logger) -> Unit

    DeleteStatement::to_json

    source

    DeleteStatement::to_string

    source
    fn DeleteStatement::to_string(self : DeleteStatement) -> String

    InsertStatement

    source
    pub(all) struct InsertStatement {
      into : String
      columns : FixedArray[String]
      values : FixedArray[Param]
      rows : FixedArray[FixedArray[Param]]
    } derive(Eq, ToJson, 
    FromJson    )

    InsertStatement::equal

    source

    InsertStatement::from_json

    source

    InsertStatement::not_equal

    source
    fn InsertStatement::not_equal(x : InsertStatement, y : InsertStatement) -> Bool

    InsertStatement::output

    source
    fn InsertStatement::output(self : InsertStatement, logger : &Logger) -> Unit

    InsertStatement::to_json

    source

    InsertStatement::to_string

    source
    fn InsertStatement::to_string(self : InsertStatement) -> String

    OrderBy

    source
    pub(all) enum OrderBy {
      Asc(String)
      Desc(String)
    } derive(Eq, ToJson, 
    FromJson    )

    impl Show for OrderBy

    OrderBy::equal

    source
    fn OrderBy::equal(OrderBy, OrderBy) -> Bool

    OrderBy::from_json

    source

    OrderBy::not_equal

    source
    fn OrderBy::not_equal(x : OrderBy, y : OrderBy) -> Bool

    OrderBy::output

    source
    fn OrderBy::output(self : OrderBy, logger : &Logger) -> Unit

    OrderBy::to_json

    source
    fn OrderBy::to_json(OrderBy) -> Json

    OrderBy::to_string

    source
    fn OrderBy::to_string(self : OrderBy) -> String

    Page

    source
    pub(all) struct Page[T] {
      content : FixedArray[T]
      total_elements : Int
      total_pages : Int
      number : Int
      size : Int
      first : Bool
      last : Bool
      empty : Bool
    } derive(Eq, ToJson, 
    FromJson    )

    impl Show for Page[T]
    impl FromParam for Page[T]

    Page::equal

    source
    fn[T : Eq] Page::equal(Page[T], Page[T]) -> Bool

    Page::from_json

    source

    Page::from_param

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

    Page::not_equal

    source
    fn[T : Eq] Page::not_equal(x : Page[T], y : Page[T]) -> Bool

    Page::output

    source
    fn[T] Page::output(self : Page[T], logger : &Logger) -> Unit

    Page::to_json

    source
    fn[T : ToJson] Page::to_json(Page[T]) -> Json

    Page::to_string

    source
    fn[T] Page::to_string(self : Page[T]) -> String

    Pageable

    source
    pub(all) struct Pageable {
      page : Int
      size : Int
      sort : Sort?
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    impl Show for Pageable

    Pageable::equal

    source
    fn Pageable::equal(Pageable, Pageable) -> Bool

    Pageable::from_json

    source

    Pageable::not_equal

    source
    fn Pageable::not_equal(x : Pageable, y : Pageable) -> Bool

    Pageable::output

    source
    fn Pageable::output(self : Pageable, logger : &Logger) -> Unit

    Pageable::to_json

    source
    fn Pageable::to_json(Pageable) -> Json

    Pageable::to_repr

    source

    Pageable::to_string

    source
    fn Pageable::to_string(self : Pageable) -> String

    Param

    source
    pub(all) enum Param {
      Null
      Bool(Bool)
      Byte(Byte)
      Int(Int)
      Int16(Int16)
      UInt16(UInt16)
      UInt(UInt)
      UInt64(UInt64)
      Int64(Int64)
      BigInt(
    BigInt    )
      Float(Float)
      Double(Double)
      Decimal(String)
      Date(
    PlainDate    , String?)
      Time(
    PlainTime    , String?)
      DateTime(
    PlainDateTime    , String?)
      Timestamp(
    ZonedDateTime    , String?)
      Uuid(String)
      Object(Map[String, Param])
      Json(Json)
      String(String)
      Bytes(Bytes)
    }

    impl Eq for Param
    impl Show for Param
    impl ToJson for Param
    impl FromJson for Param
    impl FromParam for Param
    impl ToParam for Param

    Param::equal

    source
    fn Param::equal(self : Param, other : Param) -> Bool

    Param::from_json

    source

    Param::from_param

    source
    fn Param::from_param(self : Param) -> Param raise ParamDecodeError

    Param::not_equal

    source
    fn Param::not_equal(x : Param, y : Param) -> Bool

    Param::output

    source
    fn Param::output(self : Param, logger : &Logger) -> Unit

    Param::to_json

    source
    fn Param::to_json(self : Param) -> Json

    Param::to_param

    source
    fn Param::to_param(self : Param) -> Param

    Param::to_string

    source
    fn Param::to_string(self : Param) -> String

    Query

    source
    pub(all) enum Query {
      Statement(Statement)
      Raw(String, FixedArray[Param])
      Tx(TxOp)
    } derive(Eq, ToJson, 
    FromJson    )

    impl Show for Query

    Query::equal

    source
    fn Query::equal(Query, Query) -> Bool

    Query::from_json

    source

    Query::not_equal

    source
    fn Query::not_equal(x : Query, y : Query) -> Bool

    Query::output

    source
    fn Query::output(self : Query, logger : &Logger) -> Unit

    Query::to_json

    source
    fn Query::to_json(Query) -> Json

    Query::to_query

    source
    fn Query::to_query(self : Query) -> Query

    Query::to_string

    source
    fn Query::to_string(self : Query) -> String

    QueryResult

    source
    pub(all) struct QueryResult {
      ok : Bool
      rows_affected : Int
      rows : FixedArray[Map[String, Param]]
      error : String?
    } derive(Eq, ToJson, 
    FromJson    )

    impl Show for QueryResult

    QueryResult::equal

    source
    fn QueryResult::equal(QueryResult, QueryResult) -> Bool

    QueryResult::from_json

    source

    QueryResult::not_equal

    source
    fn QueryResult::not_equal(x : QueryResult, y : QueryResult) -> Bool

    QueryResult::output

    source
    fn QueryResult::output(self : QueryResult, logger : &Logger) -> Unit

    QueryResult::to_json

    source
    fn QueryResult::to_json(QueryResult) -> Json

    QueryResult::to_string

    source
    fn QueryResult::to_string(self : QueryResult) -> String

    SelectStatement

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

    SelectStatement::equal

    source

    SelectStatement::from_json

    source

    SelectStatement::not_equal

    source
    fn SelectStatement::not_equal(x : SelectStatement, y : SelectStatement) -> Bool

    SelectStatement::output

    source
    fn SelectStatement::output(self : SelectStatement, logger : &Logger) -> Unit

    SelectStatement::to_json

    source

    SelectStatement::to_string

    source
    fn SelectStatement::to_string(self : SelectStatement) -> String

    Set

    source
    pub(all) struct Set {
      col : String
      value : Param
    } derive(Eq, ToJson, 
    FromJson    )

    impl Show for Set

    Set::equal

    source
    fn Set::equal(Set, Set) -> Bool

    Set::from_json

    source

    Set::not_equal

    source
    fn Set::not_equal(x : Set, y : Set) -> Bool

    Set::output

    source
    fn Set::output(self : Set, logger : &Logger) -> Unit

    Set::to_json

    source
    fn Set::to_json(Set) -> Json

    Set::to_string

    source
    fn Set::to_string(self : Set) -> String

    Sort

    source
    pub(all) struct Sort {
      property : String
      direction : SortDirection
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    impl Show for Sort

    Sort::equal

    source
    fn Sort::equal(Sort, Sort) -> Bool

    Sort::from_json

    source

    Sort::not_equal

    source
    fn Sort::not_equal(x : Sort, y : Sort) -> Bool

    Sort::output

    source
    fn Sort::output(self : Sort, logger : &Logger) -> Unit

    Sort::to_json

    source
    fn Sort::to_json(Sort) -> Json

    Sort::to_repr

    source

    Sort::to_string

    source
    fn Sort::to_string(self : Sort) -> String

    SortDirection

    source
    pub(all) enum SortDirection {
      Asc
      Desc
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    SortDirection::equal

    source

    SortDirection::from_json

    source

    SortDirection::not_equal

    source
    fn SortDirection::not_equal(x : SortDirection, y : SortDirection) -> Bool

    SortDirection::output

    source
    fn SortDirection::output(self : SortDirection, logger : &Logger) -> Unit

    SortDirection::to_json

    source

    SortDirection::to_repr

    source

    SortDirection::to_string

    source
    fn SortDirection::to_string(self : SortDirection) -> String

    Statement

    source
    pub(all) enum Statement {
      Select(SelectStatement)
      Insert(InsertStatement)
      Upsert(UpsertStatement)
      Update(UpdateStatement)
      Delete(DeleteStatement)
    } derive(Eq, ToJson, 
    FromJson    )

    impl Show for Statement

    Statement::equal

    source
    fn Statement::equal(Statement, Statement) -> Bool

    Statement::from_json

    source

    Statement::not_equal

    source
    fn Statement::not_equal(x : Statement, y : Statement) -> Bool

    Statement::output

    source
    fn Statement::output(self : Statement, logger : &Logger) -> Unit

    Statement::to_json

    source
    fn Statement::to_json(Statement) -> Json

    Statement::to_string

    source
    fn Statement::to_string(self : Statement) -> String

    TxOp

    source
    pub(all) enum TxOp {
      Begin
      Commit
      Rollback
      Savepoint(String)
      RollbackToSavepoint(String)
    } derive(Eq, ToJson, 
    FromJson    )

    impl Show for TxOp

    TxOp::equal

    source
    fn TxOp::equal(TxOp, TxOp) -> Bool

    TxOp::from_json

    source

    TxOp::not_equal

    source
    fn TxOp::not_equal(x : TxOp, y : TxOp) -> Bool

    TxOp::output

    source
    fn TxOp::output(self : TxOp, logger : &Logger) -> Unit

    TxOp::to_json

    source
    fn TxOp::to_json(TxOp) -> Json

    TxOp::to_string

    source
    fn TxOp::to_string(self : TxOp) -> String

    UpdateStatement

    source
    pub(all) struct UpdateStatement {
      table : String
      sets : FixedArray[Set]
      where_ : FixedArray[Where]
    } derive(Eq, ToJson, 
    FromJson    )

    UpdateStatement::equal

    source

    UpdateStatement::from_json

    source

    UpdateStatement::not_equal

    source
    fn UpdateStatement::not_equal(x : UpdateStatement, y : UpdateStatement) -> Bool

    UpdateStatement::output

    source
    fn UpdateStatement::output(self : UpdateStatement, logger : &Logger) -> Unit

    UpdateStatement::to_json

    source

    UpdateStatement::to_string

    source
    fn UpdateStatement::to_string(self : UpdateStatement) -> String

    UpsertStatement

    source
    pub(all) struct UpsertStatement {
      table : String
      sets : FixedArray[Set]
      conflict_target : FixedArray[String]
      update_sets : FixedArray[Set]
    } derive(Eq, ToJson, 
    FromJson    )

    UpsertStatement::equal

    source

    UpsertStatement::from_json

    source

    UpsertStatement::not_equal

    source
    fn UpsertStatement::not_equal(x : UpsertStatement, y : UpsertStatement) -> Bool

    UpsertStatement::output

    source
    fn UpsertStatement::output(self : UpsertStatement, logger : &Logger) -> Unit

    UpsertStatement::to_json

    source

    UpsertStatement::to_string

    source
    fn UpsertStatement::to_string(self : UpsertStatement) -> String

    Where

    source
    pub(all) struct Where {
      col : String
      value : Param
      ty : WhereType
    } derive(Eq, ToJson, 
    FromJson    )

    impl Show for Where

    Where::equal

    source
    fn Where::equal(Where, Where) -> Bool

    Where::from_json

    source

    Where::not_equal

    source
    fn Where::not_equal(x : Where, y : Where) -> Bool

    Where::output

    source
    fn Where::output(self : Where, logger : &Logger) -> Unit

    Where::to_json

    source
    fn Where::to_json(Where) -> Json

    Where::to_string

    source
    fn Where::to_string(self : Where) -> String

    WhereType

    source
    pub(all) enum WhereType {
      Eq
      Ne
      Gt
      Lt
      Gte
      Lte
      Like
    } derive(Eq, ToJson, 
    FromJson    )

    impl Show for WhereType

    WhereType::equal

    source
    fn WhereType::equal(WhereType, WhereType) -> Bool

    WhereType::from_json

    source

    WhereType::not_equal

    source
    fn WhereType::not_equal(x : WhereType, y : WhereType) -> Bool

    WhereType::output

    source
    fn WhereType::output(self : WhereType, logger : &Logger) -> Unit

    WhereType::to_json

    source
    fn WhereType::to_json(WhereType) -> Json

    WhereType::to_string

    source
    fn WhereType::to_string(self : WhereType) -> String

    bytes_to_hex

    source
    fn bytes_to_hex(data : Bytes) -> String

    decode_json_column

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

    enum_from_param

    source
    fn[T : 
    FromJson    ] enum_from_param(value : Param) -> T raise ParamDecodeError

    enum_to_param

    source
    fn[T : ToJson] enum_to_param(value : T) -> Param raise ParamDecodeError

    format_plain_date

    source
    fn format_plain_date(value : 
    PlainDate    , format : String?) -> String

    format_plain_date_time

    source
    fn format_plain_date_time(value : 
    PlainDateTime    , format : String?) -> String

    format_plain_time

    source
    fn format_plain_time(value : 
    PlainTime    , format : String?) -> String

    format_zoned_date_time

    source
    fn format_zoned_date_time(value : 
    ZonedDateTime    , format : String?) -> String

    from_param

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

    param_from_json_value

    source
    fn param_from_json_value(json : Json) -> Param

    param_row_from_json

    source
    fn param_row_from_json(row : Json) -> Map[String, Param]

    preload_belongs_to_default

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

    preload_has_many_default

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

    preload_in_sql_dollar

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

    preload_in_sql_qmark

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

    preload_many_to_many_default

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

    preload_many_to_many_sql_dollar

    source
    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

    preload_many_to_many_sql_qmark

    source
    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

    render_default_sql

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

    Default renderer (MySQL/Sqlite style placeholders and upsert syntax).

    render_query_sql

    source
    fn render_query_sql(query : &QueryBuilder) -> (String, FixedArray[Param])

    to_param

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

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io