Enum LogicalTypeId 

#[non_exhaustive]
#[repr(u32)]
pub enum LogicalTypeId {
    Invalid = 0,
    Boolean = 1,
    Tinyint = 2,
    Smallint = 3,
    Integer = 4,
    Bigint = 5,
    UTinyint = 6,
    USmallint = 7,
    UInteger = 8,
    UBigint = 9,
    Float = 10,
    Double = 11,
    Timestamp = 12,
    Date = 13,
    Time = 14,
    Interval = 15,
    Hugeint = 16,
    Varchar = 17,
    Blob = 18,
    Decimal = 19,
    TimestampS = 20,
    TimestampMs = 21,
    TimestampNs = 22,
    Enum = 23,
    List = 24,
    Struct = 25,
    Map = 26,
    Uuid = 27,
    Union = 28,
    Bit = 29,
    TimeTZ = 30,
    TimestampTZ = 31,
    UHugeint = 32,
    Array = 33,
    Any = 34,
    Bignum = 35,
    SqlNull = 36,
    StringLiteral = 37,
    IntegerLiteral = 38,
    TimeNs = 39,
    Geometry = 40,
    Variant = 41,
    Unsupported = 4_294_967_295,
}

Logical Type Id https://duckdb.org/docs/api/c/types

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.

Invalid = 0

Invalid

Boolean = 1

Boolean

Tinyint = 2

Tinyint

Smallint = 3

Smallint

Integer = 4

Integer

Bigint = 5

Bigint

UTinyint = 6

Unsigned Tinyint

USmallint = 7

Unsigned Smallint

UInteger = 8

Unsigned Integer

UBigint = 9

Unsigned Bigint

Float = 10

Float

Double = 11

Double

Timestamp = 12

Timestamp

Date = 13

Date

Time = 14

Time

Interval = 15

Interval

Hugeint = 16

Hugeint

Varchar = 17

Varchar

Blob = 18

Blob

Decimal = 19

Decimal

TimestampS = 20

Timestamp S

TimestampMs = 21

Timestamp MS

TimestampNs = 22

Timestamp NS

Enum = 23

Enum

List = 24

List

Struct = 25

Struct

Map = 26

Map

Uuid = 27

Uuid

Union = 28

Union

Bit = 29

Bit

TimeTZ = 30

Time TZ

TimestampTZ = 31

Timestamp TZ

UHugeint = 32

Unsigned Hugeint

Array = 33

Array

Any = 34

Any

Bignum = 35

Bignum

SqlNull = 36

SqlNull

StringLiteral = 37

String Literal

IntegerLiteral = 38

Integer Literal

TimeNs = 39

Time NS

Geometry = 40

Geometry

Variant = 41

VARIANT.

This type is exposed for metadata. Decoding VARIANT result columns is not supported because DuckDB does not expose C API helpers for decoding VARIANT values.

Unsupported = 4_294_967_295

DuckDB returned a type that this wrapper does not yet recognize

Trait Implementations

impl Clone for LogicalTypeId

fn clone(&self) -> LogicalTypeId

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for LogicalTypeId

impl Debug for LogicalTypeId

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

Formats the value using the given formatter.

impl Eq for LogicalTypeId

impl From<LogicalTypeId> for LogicalTypeHandle

fn from(id: LogicalTypeId) -> Self

Create a new LogicalTypeHandle from LogicalTypeId.

Panics

Panics for LogicalTypeId::Invalid and LogicalTypeId::Unsupported, which cannot be constructed as valid logical types.

impl From<u32> for LogicalTypeId

fn from(value: u32) -> Self

Convert from u32 to LogicalTypeId

impl PartialEq for LogicalTypeId

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for LogicalTypeId