superbigcup325/moonlake/types

superbigcup325/moonlake/types does not have a README file

SqlError

pub(all) suberror SqlError {
  Parse(String)
  Bind(String)
  Scan(String)
  Execute(String)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Structured error: one variant per pipeline stage carrying the reason.

impl Show for SqlError

SqlError::equal

source

fn SqlError::equal(SqlError, SqlError) -> Bool

SqlError::message

source

fn SqlError::message(self : SqlError) -> String

SqlError::not_equal

source

fn SqlError::not_equal(x : SqlError, y : SqlError) -> Bool

SqlError::output

source

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

SqlError::stage

source

fn SqlError::stage(self : SqlError) -> String

SqlError::to_repr

source

fn SqlError::to_repr(SqlError) -> @moonbitlang/core/debug.Repr
Repr

SqlError::to_string

source

fn SqlError::to_string(self : SqlError) -> String

ArithOp

source

pub(all) enum ArithOp {
  Add
  Sub
  Mul
  Div
  Mod
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

ArithOp::equal

source

fn ArithOp::equal(ArithOp, ArithOp) -> Bool

ArithOp::not_equal

source

fn ArithOp::not_equal(x : ArithOp, y : ArithOp) -> Bool

ArithOp::to_repr

source

fn ArithOp::to_repr(ArithOp) -> @moonbitlang/core/debug.Repr
Repr

CmpOp

source

pub(all) enum CmpOp {
  Eq
  Neq
  Lt
  Le
  Gt
  Ge
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

CmpOp::apply

source

fn CmpOp::apply(self : CmpOp, ord : Int?) -> Scalar

Apply a comparison operator to a three-valued ordering result (Scalar::compare output): None ordering stays NULL.

CmpOp::equal

source

fn CmpOp::equal(CmpOp, CmpOp) -> Bool

CmpOp::flip

source

fn CmpOp::flip(self : CmpOp) -> CmpOp

The operator that compares swapped operands: a < b is b.flip > a.

CmpOp::not_equal

source

fn CmpOp::not_equal(x : CmpOp, y : CmpOp) -> Bool

CmpOp::to_repr

source

fn CmpOp::to_repr(CmpOp) -> @moonbitlang/core/debug.Repr
Repr

ColumnVector

source

pub(all) enum ColumnVector {
  I32(FixedArray[Int], FixedArray[Bool])
  I64(FixedArray[Int64], FixedArray[Bool])
  F64(FixedArray[Double], FixedArray[Bool])
  BoolV(FixedArray[Bool], FixedArray[Bool])
  StrV(FixedArray[String], FixedArray[Bool])
  DateV(FixedArray[Int], FixedArray[Bool])
}

ColumnVector::dtype

source

fn ColumnVector::dtype(self : ColumnVector) -> DataType

ColumnVector::get

source

fn ColumnVector::get(self : ColumnVector, i : Int) -> Scalar

Element access with validity: invalid slots come back as Null.

ColumnVector::len

source

fn ColumnVector::len(self : ColumnVector) -> Int

ColumnVector::make

source

fn ColumnVector::make(dtype : DataType, n : Int) -> ColumnVector

Allocate an all-valid vector of the given type and length.

ColumnVector::set

source

fn ColumnVector::set(self : ColumnVector, i : Int, v : Scalar) -> Unit

Write a scalar at position i. Writing Null marks the slot invalid. Type must match the vector (caller responsibility, binder-checked).

DataBatch

source

pub struct DataBatch {
  columns : Array[ColumnVector]
  row_count : Int
}

A chunk of rows in column form.

DataBatch::columns

source

fn DataBatch::columns(self : DataBatch) -> Array[ColumnVector]

DataBatch::from_spill_bytes

source

fn DataBatch::from_spill_bytes(buf : Bytes) -> Array[DataBatch] raise SqlError

Deserialize batches from the spill wire format. A corrupt buffer is an Execute error; spill files never outlive the process, so earlier versions (MLSPILL1, MLSPILL2) are rejected by the magic rather than read.

DataBatch::new

source

fn DataBatch::new(columns : Array[ColumnVector], row_count : Int) -> DataBatch

DataBatch::row_count

source

fn DataBatch::row_count(self : DataBatch) -> Int

DataBatch::to_spill_bytes

source

fn DataBatch::to_spill_bytes(batches : Array[DataBatch]) -> Bytes raise SqlError

Serialize batches into the spill wire format.

DataType

source

pub(all) enum DataType {
  Int32
  Int64
  Float64
  Str
  Bool
  Date
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Column data types supported by the engine (v1).

DataType::equal

source

fn DataType::equal(DataType, DataType) -> Bool

DataType::not_equal

source

fn DataType::not_equal(x : DataType, y : DataType) -> Bool

DataType::to_repr

source

fn DataType::to_repr(DataType) -> @moonbitlang/core/debug.Repr
Repr

DataType::to_string

source

fn DataType::to_string(self : DataType) -> String

Scalar

source

pub(all) enum Scalar {
  Null
  Boolean(Bool)
  Int32(Int)
  Int64(Int64)
  Float64(Double)
  Str(String)
  Date(Int)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

A single value. Null participates in three-valued logic (see compare and logic helpers below).

Scalar::arith

source

fn Scalar::arith(op : ArithOp, a : Scalar, b : Scalar) -> Scalar

Arithmetic with NULL propagation. Operand types must match (binder inserts Promote nodes to unify them beforehand). Division follows DuckDB: / is true division and always yields Float64 (the binder promotes both sides), so a zero divisor is IEEE ±inf (0/0 is nan), not an error; % is C fmod — the result takes the dividend's sign — and x % 0 is NULL.

Scalar::compare

source

fn Scalar::compare(a : Scalar, b : Scalar) -> Int?

Three-valued comparison: Some(-1|0|1), or None when either side is Null or the types do not compare (binder guarantees matching types).

Scalar::compare_nn

source

fn Scalar::compare_nn(a : Scalar, b : Scalar) -> Int

Non-null total compare: -1|0|1, or 0 when the values do not compare (binder guarantees matching types). Callers that pre-filter NULL — sort comparators, min/max folds — use this instead of Scalar::compare to avoid an Option allocation per comparison.

Scalar::equal

source

fn Scalar::equal(Scalar, Scalar) -> Bool

Scalar::logic_and

source

fn Scalar::logic_and(a : Scalar, b : Scalar) -> Scalar

Three-valued AND: false dominates.

Scalar::logic_not

source

fn Scalar::logic_not(a : Scalar) -> Scalar

Scalar::logic_or

source

fn Scalar::logic_or(a : Scalar, b : Scalar) -> Scalar

Three-valued OR: true dominates.

Scalar::not_equal

source

fn Scalar::not_equal(x : Scalar, y : Scalar) -> Bool

Scalar::to_repr

source

fn Scalar::to_repr(Scalar) -> @moonbitlang/core/debug.Repr
Repr

Scalar::to_string

source

fn Scalar::to_string(self : Scalar) -> String

add_months

source

fn add_months(days : Int, n : Int) -> Int

Shift epoch days by n calendar months (a year is 12 months), clamping the day of month to the target month's length (Jan 31 + 1 month = Feb 28; 1996-03-31 + 1 month = 1996-04-30).

civil_from_days

source

fn civil_from_days(z : Int) -> (Int, Int, Int)

days_from_civil

source

fn days_from_civil(y : Int, m : Int, d : Int) -> Int

epoch_day

source

fn epoch_day(days : Int) -> Int

epoch_month

source

fn epoch_month(days : Int) -> Int

epoch_to_string

source

fn epoch_to_string(days : Int) -> String

epoch_year

source

fn epoch_year(days : Int) -> Int

Calendar field extraction from epoch days (EXTRACT support).

parse_bool

source

fn parse_bool(s : String) -> Bool?

parse_bool_bytes

source

fn parse_bool_bytes(buf : Bytes, start : Int, end : Int) -> Bool?

parse_date

source

fn parse_date(s : String) -> Int?

Strict ISO parse: "yyyy-mm-dd" with real calendar validation. Returns epoch days, or None on any malformed input.

parse_date_bytes

source

fn parse_date_bytes(buf : Bytes, start : Int, end : Int) -> Int?

Strict ISO "yyyy-mm-dd" over a byte range, mirroring parse_date.

parse_f64

source

fn parse_f64(s : String) -> Double?

[sign] digits [ . digits ] [ (e|E) [sign] digits ], else None. Digits accumulate in Double — an Int64 accumulator would wrap exactly the way this parser exists to prevent — so arbitrarily long inputs degrade to the nearest float64 instead of flipping sign.

parse_f64_bytes

source

fn parse_f64_bytes(buf : Bytes, start : Int, end : Int) -> Double?

parse_i32

source

fn parse_i32(s : String) -> Int?

Optional sign then digits, else None, range-checked to int32: a value outside [-2^31, 2^31-1] returns None so callers promote or report instead of wrapping silently.

parse_i32_bytes

source

fn parse_i32_bytes(buf : Bytes, start : Int, end : Int) -> Int?

parse_i64

source

fn parse_i64(s : String) -> Int64?

Optional sign then digits, else None, range-checked to int64. Accumulates as a negative magnitude — -2^63 is representable while +2^63 is not, so negating at the end stays exact.

parse_i64_bytes

source

fn parse_i64_bytes(buf : Bytes, start : Int, end : Int) -> Int64?

Source Files

Site source Report issue Packages Build queue Skills Statistics

#SqlError

#SqlError::equal

#SqlError::message

#SqlError::not_equal

#SqlError::output

#SqlError::stage

#SqlError::to_repr

#SqlError::to_string

#ArithOp

#ArithOp::equal

#ArithOp::not_equal

#ArithOp::to_repr

#CmpOp

#CmpOp::apply

#CmpOp::equal

#CmpOp::flip

#CmpOp::not_equal

#CmpOp::to_repr

#ColumnVector

#ColumnVector::dtype

#ColumnVector::get

#ColumnVector::len

#ColumnVector::make

#ColumnVector::set

#DataBatch

#DataBatch::columns

#DataBatch::from_spill_bytes

#DataBatch::new

#DataBatch::row_count

#DataBatch::to_spill_bytes

#DataType

#DataType::equal

#DataType::not_equal

#DataType::to_repr

#DataType::to_string

#Scalar

#Scalar::arith

#Scalar::compare

#Scalar::compare_nn

#Scalar::equal

#Scalar::logic_and

#Scalar::logic_not

#Scalar::logic_or

#Scalar::not_equal

#Scalar::to_repr

#Scalar::to_string

#add_months

#civil_from_days

#days_from_civil

#epoch_day

#epoch_month

#epoch_to_string

#epoch_year

#parse_bool

#parse_bool_bytes

#parse_date

#parse_date_bytes

#parse_f64

#parse_f64_bytes

#parse_i32

#parse_i32_bytes

#parse_i64

#parse_i64_bytes

Source Files

SqlError

SqlError::equal

SqlError::message

SqlError::not_equal

SqlError::output

SqlError::stage

SqlError::to_repr

SqlError::to_string

ArithOp

ArithOp::equal

ArithOp::not_equal

ArithOp::to_repr

CmpOp

CmpOp::apply

CmpOp::equal

CmpOp::flip

CmpOp::not_equal

CmpOp::to_repr

ColumnVector

ColumnVector::dtype

ColumnVector::get

ColumnVector::len

ColumnVector::make

ColumnVector::set

DataBatch

DataBatch::columns

DataBatch::from_spill_bytes

DataBatch::new

DataBatch::row_count

DataBatch::to_spill_bytes

DataType

DataType::equal

DataType::not_equal

DataType::to_repr

DataType::to_string

Scalar

Scalar::arith

Scalar::compare

Scalar::compare_nn

Scalar::equal

Scalar::logic_and

Scalar::logic_not

Scalar::logic_or

Scalar::not_equal

Scalar::to_repr

Scalar::to_string

add_months

civil_from_days

days_from_civil

epoch_day

epoch_month

epoch_to_string

epoch_year

parse_bool

parse_bool_bytes

parse_date

parse_date_bytes

parse_f64

parse_f64_bytes

parse_i32

parse_i32_bytes

parse_i64

parse_i64_bytes