Enum DataType 

pub enum DataType {
    Integer,
    Smallint,
    Bigint,
    Unsigned,
    Numeric {
        precision: u8,
        scale: u8,
    },
    Decimal {
        precision: u8,
        scale: u8,
    },
    Float {
        precision: u8,
    },
    Real,
    DoublePrecision,
    Character {
        length: usize,
    },
    Varchar {
        max_length: Option<usize>,
    },
    CharacterLargeObject,
    Name,
    Boolean,
    Date,
    Time {
        with_timezone: bool,
    },
    Timestamp {
        with_timezone: bool,
    },
    Interval {
        start_field: IntervalField,
        end_field: Option<IntervalField>,
    },
    BinaryLargeObject,
    Bit {
        length: Option<usize>,
    },
    Vector {
        dimensions: u32,
    },
    UserDefined {
        type_name: String,
    },
    Null,
}

SQL:1999 Data Types

Represents the type of a column or expression in SQL.

Variants

Integer

Smallint

Bigint

Unsigned

Numeric

Fields

precision: u8

scale: u8

Decimal

Fields

precision: u8

scale: u8

Float

Fields

precision: u8

Real

DoublePrecision

Character

Fields

length: usize

Varchar

Fields

max_length: Option<usize>

CharacterLargeObject

Name

Boolean

Date

Time

Fields

with_timezone: bool

Timestamp

Fields

with_timezone: bool

Interval

Fields

start_field: IntervalField

end_field: Option<IntervalField>

BinaryLargeObject

Bit

Fields

length: Option<usize>

Vector

Fields

dimensions: u32

UserDefined

Fields

type_name: String

Null

Implementations

impl DataType

pub fn coerce_to_common(&self, other: &DataType) -> Option<DataType>

Coerces two types to their common type according to SQL:1999 rules

Returns the result type that should be used when combining values of the two input types, or None if no implicit coercion exists.

Based on SQL:1999 Section 9.5 (Result of data type combinations).

pub fn is_compatible_with(&self, other: &DataType) -> bool

Check if this type is compatible with another type for operations

This now uses SQL:1999 type coercion rules. Types are compatible if they can be implicitly coerced to a common type.

pub fn estimated_size_bytes(&self) -> usize

Returns an estimated size in bytes for values of this type.

This is used for adaptive morsel sizing to maintain cache efficiency. Estimates are conservative (may overestimate) to ensure cache fitting.

Returns the estimated size in bytes for a single value of this type, including any overhead from the SqlValue enum representation.

pub fn sqlite_affinity(&self) -> TypeAffinity

Returns the SQLite type affinity for this data type.

SQLite determines affinity based on the declared type name:

1. If the type contains “INT” → INTEGER affinity
2. If the type contains “CHAR”, “CLOB”, or “TEXT” → TEXT affinity
3. If the type contains “BLOB” or has no type → BLOB/NONE affinity
4. If the type contains “REAL”, “FLOA”, or “DOUB” → REAL affinity
5. Otherwise → NUMERIC affinity

See: https://www.sqlite.org/datatype3.html#type_affinity

Trait Implementations

impl Clone for DataType

fn clone(&self) -> DataType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DataType

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

Formats the value using the given formatter.

impl PartialEq for DataType

fn eq(&self, other: &DataType) -> 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 Eq for DataType

impl StructuralPartialEq for DataType