Enum SqlValue 

pub enum SqlValue {
    Integer(i64),
    Smallint(i16),
    Bigint(i64),
    Unsigned(u64),
    Numeric(f64),
    Float(f32),
    Real(f64),
    Double(f64),
    Character(StringValue),
    Varchar(StringValue),
    Boolean(bool),
    Date(Date),
    Time(Time),
    Timestamp(Timestamp),
    Interval(Interval),
    Vector(Vec<f32>),
    Blob(Vec<u8>),
    Null,
}

SQL Values - runtime representation of data

Represents actual values in SQL, including NULL.

String types use StringValue (ArcStr) which provides O(1) cloning. Strings ≤22 bytes are stored inline (small string optimization) avoiding heap allocation.

Variants

Integer(i64)

Smallint(i16)

Bigint(i64)

Unsigned(u64)

Numeric(f64)

Float(f32)

Real(f64)

Double(f64)

Character(StringValue)

Varchar(StringValue)

Boolean(bool)

Date(Date)

Time(Time)

Timestamp(Timestamp)

Interval(Interval)

Vector(Vec<f32>)

Blob(Vec<u8>)

Null

Implementations

impl SqlValue

pub fn is_null(&self) -> bool

Check if this value is NULL

pub fn type_name(&self) -> &'static str

Get the type name as a string (for error messages)

pub fn get_type(&self) -> DataType

Get the data type of this value

pub fn estimated_size_bytes(&self) -> usize

Estimate the memory size of this value in bytes

Used for memory limit tracking during query execution. Provides a reasonable approximation including heap allocations.

Trait Implementations

impl Clone for SqlValue

fn clone(&self) -> SqlValue

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SqlValue

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

Formats the value using the given formatter.

impl Display for SqlValue

Display implementation for SqlValue (how values are shown to users)

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

Formats the value using the given formatter.

impl Hash for SqlValue

Hash implementation for SqlValue

Custom implementation to handle floating-point values correctly:

• NaN values are treated as equal (hash to same value)
• Uses to_bits() for floats to ensure consistent hashing
• NULL hashes to a specific value

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for SqlValue

Ord implementation for SqlValue

Required for BTreeMap usage in indexes for efficient range queries.

For index storage and sorting purposes, we define a total ordering where:

• NULL is treated as “less than” all other values (NULLS FIRST semantics)
• NaNs are treated as “greater than” all other floats for consistency
• Type mismatches use a type-based ordering (e.g., integers < floats < strings)
• Within each type, use natural ordering

Note: This differs from SQL comparison semantics (which uses three-valued logic) but is necessary for BTreeMap keys which require total ordering.

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for SqlValue

PartialEq implementation for SqlValue

For DISTINCT operations and BTreeMap keys, we need Eq semantics where:

• NULL == NULL (for grouping purposes, unlike SQL comparison)
• NaN == NaN (for grouping purposes, unlike IEEE 754)
• All other values use standard equality

This is consistent with the Ord implementation and satisfies BTreeMap requirements.

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for SqlValue

PartialOrd implementation for SQL value comparison

Implements SQL:1999 comparison semantics:

• NULL comparisons return None (SQL UNKNOWN)
• Type mismatches return None (incomparable)
• NaN in floating point returns None (IEEE 754 semantics)
• All other comparisons follow Rust’s natural ordering

Note: This intentionally differs from Ord::cmp which provides total ordering for sorting operations. PartialOrd represents SQL comparison semantics where NULL and type mismatches are incomparable.

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for SqlValue

Eq implementation for SqlValue

For DISTINCT operations, we need Eq semantics where:

• NULL == NULL (for grouping purposes, unlike SQL comparison)
• NaN == NaN (for grouping purposes, unlike IEEE 754)
• All other values use standard equality