Enum DataType 

pub enum DataType {
    Boolean,
    SmallInt,
    Integer,
    BigInt,
    Float,
    Double,
    Decimal {
        precision: u8,
        scale: u8,
    },
    Varchar {
        max_length: Option<u32>,
    },
    Char {
        length: u32,
    },
    Text,
    Blob,
    Date,
    Time,
    Timestamp {
        with_timezone: bool,
    },
    Interval,
    Array(Box<DataType>),
    Struct(Vec<(String, DataType)>),
    Map(Box<DataType>, Box<DataType>),
    Null,
    Unknown,
}

SQL data types supported by smelt

This enum represents the logical SQL types. Backend-specific variations (e.g., DuckDB’s HUGEINT) are mapped to these canonical types.

Variants

Boolean

Boolean (TRUE/FALSE)

SmallInt

Small integer (2 bytes, -32768 to 32767)

Integer

Integer (4 bytes)

BigInt

Big integer (8 bytes)

Float

Single-precision floating point

Double

Double-precision floating point

Decimal

Exact decimal with precision and scale

Fields

precision: u8

scale: u8

Varchar

Variable-length string with optional max length

Fields

max_length: Option<u32>

Char

Fixed-length string

Fields

length: u32

Text

Unbounded text

Blob

Binary large object

Date

Calendar date (year, month, day)

Time

Time of day

Timestamp

Timestamp (date + time)

Fields

with_timezone: bool

Interval

Time interval

Array(Box<DataType>)

Array of elements

Struct(Vec<(String, DataType)>)

Struct with named fields: STRUCT(a INTEGER, b VARCHAR)

Map(Box<DataType>, Box<DataType>)

Map from key type to value type: MAP(VARCHAR, INTEGER)

Null

NULL literal type

Unknown

Type could not be determined (error recovery)

Implementations

impl DataType

pub fn is_numeric(&self) -> bool

Check if this type is numeric (supports arithmetic operations)

pub fn is_string(&self) -> bool

Check if this type is a string type

pub fn is_complex(&self) -> bool

Check if this type is a complex/nested type (Array, Struct, Map)

pub fn is_temporal(&self) -> bool

Check if this type is a date/time type

pub fn normalize(&self) -> DataType

Normalize this type to its canonical form for comparison.

• Text → Varchar { max_length: None } (canonical string type)
• Recursively normalizes Array elements, Struct fields, Map key/value
• All other types are returned as-is

pub fn to_backend_sql(&self) -> String

Format as SQL type string for backend compilation.

Translates smelt-internal types to what backends actually support:

• Text → "VARCHAR" (backends don’t distinguish Text from VARCHAR)

pub fn to_sql(&self) -> String

Format as SQL type string for the default dialect

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 Display for DataType

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

Formats the value using the given formatter.

impl Hash for DataType

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 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