TypeId Reference

quack_rs::types::TypeId is the enum of DuckDB column types that the quack-rs builder APIs accept. Each variant names one of the C API's DUCKDB_TYPE_* integer constants, which libduckdb-sys exposes as DUCKDB_TYPE_DUCKDB_TYPE_* (for example libduckdb_sys::DUCKDB_TYPE_DUCKDB_TYPE_BIGINT).

Full variant table

Feature gate for Geometry / Variant: DUCKDB_TYPE_GEOMETRY (40) and DUCKDB_TYPE_VARIANT (41) require the duckdb-1-5-3 feature, which layers on top of duckdb-1-5 and needs libduckdb-sys >= 1.10503.0 (DuckDB 1.5.3). VARIANT entered the C type enum in DuckDB 1.5.3, after the duckdb-1-5 feature's 1.5.0 floor, and GEOMETRY is gated with it so that one feature covers both. Gating them separately avoids breaking consumers pinned to libduckdb-sys 1.10500–1.10502 (DuckDB 1.5.0–1.5.2). See Known Limitations.

Methods

to_duckdb_type() → DUCKDB_TYPE

Converts to the raw C API integer constant. Used internally by the builder APIs.

#![allow(unused)]
fn main() {
use quack_rs::types::TypeId;

let raw: libduckdb_sys::DUCKDB_TYPE = TypeId::BigInt.to_duckdb_type();
}

from_duckdb_type(raw) → TypeId

Converts a raw DUCKDB_TYPE constant back into a TypeId. Recognizes every variant available in the active feature set, including TIME_NS, ANY, BIGNUM, SQLNULL, INTEGER_LITERAL and STRING_LITERAL (no feature needed: all six exist in every DuckDB this crate supports) and the duckdb-1-5-3 values (GEOMETRY, VARIANT) when that feature is enabled. Panics if the value does not correspond to any variant available in the current feature configuration; try_from_duckdb_type returns None instead.

#![allow(unused)]
fn main() {
use quack_rs::types::TypeId;

let type_id = TypeId::from_duckdb_type(libduckdb_sys::DUCKDB_TYPE_DUCKDB_TYPE_BIGINT);
assert_eq!(type_id, TypeId::BigInt);
assert_eq!(TypeId::try_from_duckdb_type(9_999), None);
}

is_composite() and composite_constructor_hint()

DECIMAL, ENUM, LIST, STRUCT, MAP, ARRAY and UNION carry parameters that a bare type id cannot express, so duckdb_create_logical_type cannot build them. is_composite() returns true for these seven, and composite_constructor_hint() names the LogicalType constructor to use instead:

#![allow(unused)]
fn main() {
use quack_rs::types::TypeId;

assert!(TypeId::List.is_composite());
assert_eq!(
    TypeId::List.composite_constructor_hint(),
    Some("LogicalType::list(element_type)")
);
assert_eq!(TypeId::BigInt.composite_constructor_hint(), None);
}

sql_name() → &'static str

Returns the SQL type name as a static string.

#![allow(unused)]
fn main() {
use quack_rs::types::TypeId;
assert_eq!(TypeId::BigInt.sql_name(), "BIGINT");
assert_eq!(TypeId::Varchar.sql_name(), "VARCHAR");
assert_eq!(TypeId::TimestampTz.sql_name(), "TIMESTAMPTZ");
}

Display

TypeId implements Display, which outputs the SQL name:

#![allow(unused)]
fn main() {
use quack_rs::types::TypeId;
println!("{}", TypeId::Interval);  // prints: INTERVAL
let s = format!("{}", TypeId::UBigInt); // "UBIGINT"
assert_eq!(s, "UBIGINT");
assert_eq!(TypeId::Interval.to_string(), "INTERVAL");
}

VectorReader/VectorWriter mapping

The read and write methods on VectorReader/VectorWriter map to TypeId variants as follows:

List, Map, Struct and Array are nested vectors: use the helpers in Complex Types (ListVector, MapVector, StructVector, ArrayVector, StructReader / StructWriter, ListBuilder).

Enum, Union, Bit, TimeNs, Any, Varint, SqlNull, IntegerLiteral, StringLiteral, Geometry and Variant do not yet have dedicated read/write helpers. Access these via the raw data pointer from duckdb_vector_get_data.

Properties

TypeId implements Debug, Clone, Copy, PartialEq, Eq, and Hash, so it can be used as a map key or set element and compared in match expressions:

#![allow(unused)]
fn main() {
use std::collections::HashMap;
use quack_rs::types::TypeId;

let mut type_names: HashMap<TypeId, &str> = HashMap::new();
type_names.insert(TypeId::BigInt, "count");
type_names.insert(TypeId::Varchar, "label");
}

#[non_exhaustive]

TypeId is marked #[non_exhaustive], so quack-rs can add variants for new DuckDB types without a breaking change. A match on TypeId outside quack-rs needs a wildcard arm:

#![allow(unused)]
fn main() {
use quack_rs::types::TypeId;
fn demo(type_id: TypeId) {
match type_id {
    TypeId::BigInt => { /* ... */ }
    TypeId::Varchar => { /* ... */ }
    _ => { /* handle future types */ }
}
}
}

LogicalType

For types that require parameters (such as DECIMAL(p, s) or LIST(INTEGER)), use quack_rs::types::LogicalType:

#![allow(unused)]
fn main() {
use quack_rs::types::{LogicalType, TypeId};

let lt = LogicalType::new(TypeId::BigInt);
// or use the From impl:
let lt: LogicalType = TypeId::BigInt.into();
// LogicalType implements Drop → calls duckdb_destroy_logical_type automatically
}

LogicalType wraps duckdb_logical_type with RAII cleanup, preventing the memory leak described in Pitfall L7.

Constructors

Each constructor except from_raw has a try_ form (try_new, try_decimal, try_list, …) that returns an error instead of panicking on invalid input, such as a composite TypeId passed to new, a DECIMAL width above 38, or a UNION with more than MAX_UNION_MEMBERS (255) members.

Introspection methods

The introspection methods are all unsafe, because they call into a loaded DuckDB:

get_type_id, get_alias, set_alias, decimal_width, decimal_scale, decimal_internal_type, enum_internal_type, enum_dictionary_size, enum_dictionary_value, list_child_type, map_key_type, map_value_type, struct_child_count, struct_child_name, struct_child_type, union_member_count, union_member_name, union_member_type, array_size, array_child_type.

See Type System for the full introspection table.