Enum NumpyDtype 

#[non_exhaustive]
pub enum NumpyDtype {
    I64Direct,
    F64Direct,
    DateI64Direct,
    TimestampMicrosDirect,
    TimestampNanosDirect,
    LongDirect,
    UuidDirect,
    Long256Direct,
    Ipv4Direct,
    CharDirect,
    I8Direct,
    I16Direct,
    I32Direct,
    I8WidenToI32,
    I16WidenToI32,
    I32WidenToI64,
    U8WidenToI32,
    U16WidenToI32,
    U32WidenToI64,
    U64WidenToI64,
    F32Direct,
    F16Widen,
    Bool,
    DatetimeSecToMicros,
    DatetimeMinuteToMicros,
    DatetimeHourToMicros,
    DatetimeDayToMicros,
    DatetimeWeekToMicros,
    DatetimeMonthToMicros,
    DatetimeYearToMicros,
    Decimal64 {
        scale: u8,
    },
    Decimal128 {
        scale: u8,
    },
    Decimal256 {
        scale: u8,
    },
    GeohashI8 {
        bits: u8,
    },
    GeohashI16 {
        bits: u8,
    },
    GeohashI32 {
        bits: u8,
    },
    GeohashI64 {
        bits: u8,
    },
    F64Ndarray {
        ndim: u8,
        shape: [u32; 32],
    },
}

Numpy source-dtype tag. The chunk’s NumpyDeferred variant stores one; the encoder walks it at flush.

Scale (decimal) and bit-width (geohash) values must be validated by the caller (push_numpy_deferred / the FFI dispatcher) before being embedded — emit code trusts them and does not re-check ranges.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

I64Direct

F64Direct

DateI64Direct

TimestampMicrosDirect

TimestampNanosDirect

LongDirect

UuidDirect

Long256Direct

Ipv4Direct

CharDirect

I8Direct

I16Direct

I32Direct

I8WidenToI32

I16WidenToI32

I32WidenToI64

U8WidenToI32

U16WidenToI32

U32WidenToI64

U64WidenToI64

F32Direct

F16Widen

Bool

DatetimeSecToMicros

DatetimeMinuteToMicros

DatetimeHourToMicros

DatetimeDayToMicros

DatetimeWeekToMicros

DatetimeMonthToMicros

DatetimeYearToMicros

Decimal64

Fields

scale: u8

Decimal128

Fields

scale: u8

Decimal256

Fields

scale: u8

GeohashI8

Fields

bits: u8

GeohashI16

Fields

bits: u8

GeohashI32

Fields

bits: u8

GeohashI64

Fields

bits: u8

F64Ndarray

f64 ndarray: rectangular tensor of shape (row_count, dim[0], dim[1], …). ndim is 1..=MAX_ARRAY_DIMS; only the first ndim entries of shape are meaningful — trailing entries are zero. All rows share this shape (numpy ndarrays are rectangular).

Fields

ndim: u8

shape: [u32; 32]

Implementations

impl NumpyDtype

pub fn wire_type(&self) -> u8

QWP wire-type byte for the column slot this dtype produces.

pub fn bytes_per_row(&self) -> usize

Per-row wire payload size for the upfront frame-size estimate. Bool is bit-packed so the true cost is row_count.div_ceil(8); reporting 1 here keeps the estimate as a (correct) over-bound. The leading scale / bits byte for decimal / geohash is a fixed +1 per column and is rolled into the column’s null-overhead allowance by the caller.

pub fn validate(&self) -> Result<()>

Reject dtype configurations that the encoder cannot safely allocate for. Currently bounds F64Ndarray’s shape to 1..=MAX_ARRAY_DIMS dimensions, non-zero per-dimension extents, and prod(shape) <= MAX_NDARRAY_LEAF_ELEMS to keep the per-row reservation well under isize::MAX. All other variants are inherently bounded by their wire-type encoding.

pub fn source_elem_size(&self) -> Result<usize>

Source-buffer stride in bytes per row — how many bytes the flush-time encoder (emit_into_wire) reads per row from the caller’s data pointer. This is the source element width, which is decoupled from the wire width (e.g. U8WidenToI32 reads 1 source byte but emits 4): the bounds check must use the read stride, never the wire stride.

Callers use this to validate a caller-supplied buffer byte length against row_count before parking the raw pointer for deferred, zero-copy encode — without it a mis-tagged dtype or an inflated row_count would walk the pointer past the real allocation at flush time (host-memory info-leak onto the wire, or a segfault).

For NumpyDtype::F64Ndarray each row is a full tensor, so the stride is prod(shape[..ndim]) * size_of::<f64>(). The shape is already range-bounded by Self::validate (prod <= MAX_NDARRAY_LEAF_ELEMS, ndim <= MAX_ARRAY_DIMS), so the multiply cannot overflow once validated; the checked_mul is defensive in case this is ever called on an unvalidated value.

Trait Implementations

impl Clone for NumpyDtype

fn clone(&self) -> NumpyDtype

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for NumpyDtype

impl Debug for NumpyDtype

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for NumpyDtype

impl PartialEq for NumpyDtype

fn eq(&self, other: &NumpyDtype) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for NumpyDtype