🥮 mooncakes.io
    Sign in

    codeworm96/magpiedb/engine does not have a README file

    Row

    source
    type Row = Array[Value]

    Rows stay as a public convenience type; internal operators should stay columnar.

    ColumnDef

    source
    pub(all) struct ColumnDef {
      name : String
      data_type : LogicalType
      nullable : Bool
    } derive(Eq, 
    Debug    )

    Column metadata is stable across chunks and result sets.
    impl Show for ColumnDef

    DataChunk

    source
    pub(all) struct DataChunk {
      schema : Schema
      columns : Array[Vector]
      len : Int
    } derive(Eq, 
    Debug    )

    DataChunk is the internal execution batch: many aligned column vectors, no rows.
    impl Show for DataChunk

    DataChunk::column_count

    source
    fn DataChunk::column_count(self : DataChunk) -> Int

    DataChunk::empty

    source
    fn DataChunk::empty(schema : Schema) -> DataChunk

    Chunk construction follows schema order so downstream operators can index cheaply.

    DataChunk::is_empty

    source
    fn DataChunk::is_empty(self : DataChunk) -> Bool

    DataChunk::is_full

    source
    fn DataChunk::is_full(self : DataChunk) -> Bool

    LogicalType

    source
    pub(all) enum LogicalType {
      Null
      Boolean
      BigInt
      Double
      Varchar
    } derive(Eq, 
    Debug    )

    Scalar logical types shared by planning, scanning, and execution.
    impl Show for LogicalType

    Schema

    source
    pub(all) struct Schema {
      columns : Array[ColumnDef]
    } derive(Eq, 
    Debug    )

    Schemas describe column order and names; vectors follow this order exactly.

    Schema::column_count

    source
    fn Schema::column_count(self : Schema) -> Int

    Schema::column_index

    source
    fn Schema::column_index(self : Schema, name : String) -> Int?

    Column names are resolved by exact schema order for deterministic plans/results.

    ValidityMask

    source
    pub(all) struct ValidityMask {
      bits : Array[Bool]
    } derive(Eq, 
    Debug    )

    Nullability is tracked separately from typed buffers to avoid sentinel values.

    ValidityMask::all_null

    source
    fn ValidityMask::all_null(len : Int) -> ValidityMask

    ValidityMask::all_valid

    source
    fn ValidityMask::all_valid(len : Int) -> ValidityMask

    ValidityMask::is_valid

    source
    fn ValidityMask::is_valid(self : ValidityMask, index : Int) -> Bool?

    ValidityMask::len

    source
    fn ValidityMask::len(self : ValidityMask) -> Int

    ValidityMask::new

    source
    fn ValidityMask::new(bits : Array[Bool]) -> ValidityMask

    Value

    source
    pub(all) enum Value {
      Null
      Boolean(Bool)
      BigInt(Int64)
      Double(Double)
      Varchar(String)
    } derive(Eq, 
    Debug    )

    Public scalar value container used at API boundaries.
    impl Show for Value

    Value::is_null

    source
    fn Value::is_null(self : Value) -> Bool

    Value::logical_type

    source
    fn Value::logical_type(self : Value) -> LogicalType

    Vector

    source
    pub(all) struct Vector {
      logical_type : LogicalType
      values : VectorBuffer
      validity : ValidityMask
    } derive(Eq, 
    Debug    )

    A vector is one typed column plus its validity mask.

    Vector::is_empty

    source
    fn Vector::is_empty(self : Vector) -> Bool

    Vector::len

    source
    fn Vector::len(self : Vector) -> Int

    VectorBuffer

    source
    pub(all) enum VectorBuffer {
      Nulls(Int)
      Bool(Array[Bool])
      Int64(Array[Int64])
      Double(Array[Double])
      Varchar(Array[String])
    } derive(Eq, 
    Debug    )

    Typed buffers hold only non-null payload storage for one logical column.

    chunk_row_at

    source
    fn chunk_row_at(chunk : DataChunk, row_index : Int) -> Array[Value]

    chunks_to_rows

    source
    fn chunks_to_rows(chunks : Array[DataChunk]) -> Array[Array[Value]]

    empty_vector

    source
    fn empty_vector(logical_type : LogicalType) -> Vector

    Empty vectors still carry a logical type so operators can preserve schemas.

    fixed_vector_size

    source
    let fixed_vector_size : Int

    The executor processes chunks in fixed-size vectors from the start.

    vector_value_at

    source
    fn vector_value_at(vector : Vector, row_index : Int) -> Value

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io