Struct ColumnTypeInfo 

#[non_exhaustive]
pub struct ColumnTypeInfo {
    pub declared_name: String,
    pub array_dimensions: u32,
    pub base_type: Option<String>,
    pub kind: ColumnTypeKind,
}

Structured type information for a result column.

Returned by Statement::get_column_type_info. Surfaces the array depth and custom-type resolution that the SQLite-compat get_column_decltype API does not expose, and also carries the inferred-affinity result for computed expressions (SELECT 1+1, function calls in subqueries, etc.) — the consumer asks one question, the API decides which path applies.

For a direct table-column reference, declared_name is the literal string the user wrote in CREATE TABLE ("INTEGER", "cents", "VARCHAR"), array_dimensions is the bracket depth, and base_type / kind carry any CREATE TYPE / CREATE DOMAIN resolution.

For a literal (SELECT 42, SELECT 'x', SELECT 3.14), declared_name is the primitive that matches the literal’s parsed value type ("INTEGER", "TEXT", "REAL"). For a typed expression — CAST, rowid, or anything else SQLite’s affinity rules can pin down — it’s the inferred primitive. In both cases array_dimensions is 0, base_type is None, and kind is ColumnTypeKind::Builtin. When neither path produces a usable primitive (binary arithmetic that SQLite refuses to propagate through, BLOB literals, NULL literals, function calls without declared return affinity), get_column_type_info returns Ok(None) rather than fabricating a name — callers can fall through to their own default.

New fields may be added over time; the struct is marked #[non_exhaustive] so consumers must use struct-update or accessor patterns rather than exhaustive matches.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

declared_name: String

The declared type name as written in CREATE TABLE — e.g. "INTEGER", "VARCHAR", or the name of a CREATE TYPE / CREATE DOMAIN such as "cents". This is the same string get_column_decltype returns.

array_dimensions: u32

Array dimensionality: 0 for scalar columns, 1 for INTEGER[], 2 for TEXT[][], etc.

base_type: Option<String>

For columns whose declared type resolves to a CREATE TYPE or CREATE DOMAIN definition, this is the underlying primitive type name ("INTEGER", "TEXT", "REAL", "BLOB", or "NUMERIC"). None when the declared name is a built-in primitive directly.

Use this to distinguish “the user wrote INTEGER” (base_type: None) from “the user wrote cents, which happens to be INTEGER underneath” (base_type: Some("INTEGER")).

kind: ColumnTypeKind

Classification of the declared type. Distinguishes BUILTIN (the declared name is a primitive) from the four CREATE TYPE/CREATE DOMAIN flavours.

This matters for callers like wire-protocol layers that need to map a column to its native type code: a column declared as a STRUCT type stores a BLOB on disk (base_type is Some("BLOB")), but the caller usually wants to expose it as a composite/JSON type rather than raw bytes. The kind field carries that distinction directly without forcing the caller to re-query the schema.

Trait Implementations

impl Clone for ColumnTypeInfo

fn clone(&self) -> ColumnTypeInfo

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ColumnTypeInfo

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

Formats the value using the given formatter.

impl Eq for ColumnTypeInfo

impl PartialEq for ColumnTypeInfo

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ColumnTypeInfo