Enum ColumnType 

pub enum ColumnType {
    SmallInteger,
    Integer,
    BigInteger,
    Oid,
    Xid,
    Boolean,
    Text,
    Name,
    Uuid,
    Varchar(Option<u32>),
    Bpchar,
    Character(u32),
    Real,
    DoublePrecision,
    Numeric {
        precision: Option<u32>,
        scale: Option<i32>,
    },
    Json,
    JsonB,
    Bytea,
    InternalChar,
    Regproc,
    Regclass,
    Regnamespace,
    Regtype,
    PgNodeTree,
    AclItem,
    Int2Vector,
    OidVector,
    AnyArray,
    Record,
    Array(Box<ColumnType>),
    Date,
    Time,
    TimeTz,
    Timestamp,
    TimestampTz,
    Interval,
    Vector(u32),
    Tensor(u32),
    Domain {
        schema: String,
        name: String,
        oid: u32,
        base: Box<ColumnType>,
    },
}

Variants

SmallInteger

Integer

BigInteger

Oid

PostgreSQL object identifier (pg_catalog.oid).

Xid

PostgreSQL transaction identifier (pg_catalog.xid).

Boolean

Text

Name

Uuid

Varchar(Option<u32>)

Bpchar

Internal unconstrained bpchar type used after common-type selection.

Character(u32)

PostgreSQL blank-padded CHARACTER(n) / CHAR(n) (bpchar). The length counts Unicode scalar values and defaults to one when the declaration omits an explicit modifier.

Real

DoublePrecision

Numeric

NUMERIC(precision, scale) – exact decimal storage. When scale is Some(s) the engine rounds INSERT values to s fractional digits. precision is captured for round-tripping the catalog text but is not currently enforced.

Fields

precision: Option<u32>

scale: Option<i32>

Json

JSON / JSONB columns store typed JSON values.

JsonB

JSONB columns store typed JSON values with PostgreSQL JSONB operators.

Bytea

BYTEA columns store opaque bytes.

InternalChar

PostgreSQL’s internal single-byte "char" catalog type.

Regproc

Regclass

PostgreSQL relation object identifier (pg_catalog.regclass).

Regnamespace

PostgreSQL namespace object identifier (pg_catalog.regnamespace).

Regtype

PgNodeTree

AclItem

Int2Vector

OidVector

AnyArray

Record

PostgreSQL’s anonymous composite pseudo-type (OID 2249).

Array(Box<ColumnType>)

A PostgreSQL array whose elements retain their declared SQL type. Nested array bounds are represented recursively.

Date

DATE columns store days since 1970-01-01.

Time

TIME columns store microseconds since midnight.

TimeTz

TIME WITH TIME ZONE columns store local time plus offset.

Timestamp

TIMESTAMP WITHOUT TIME ZONE columns store naive microseconds since 1970-01-01 00:00:00.

TimestampTz

TIMESTAMP WITH TIME ZONE columns store UTC microseconds since 1970-01-01 00:00:00Z.

Interval

Vector(u32)

VECTOR(N) columns store an N-dimensional f32 embedding.

Tensor(u32)

TENSOR(N) columns store an array of N-dimensional f32 embeddings. The row remains the retrieval identity; vector indexes score against the best element in the tensor.

Domain

A named PostgreSQL domain retaining both its own type identity and the base type used for value conversion and operator selection.

Fields

schema: String

name: String

oid: u32

base: Box<ColumnType>

Implementations

impl ColumnType

pub fn is_integer(&self) -> bool

pub fn is_character_string(&self) -> bool

pub fn from_sql_name(name: &str) -> Result<Self, SQLError>

Parse the canonical or accepted spelling of one implemented SQL type. This is shared by expression binding and row-schema propagation so a cast’s declared type is not reconstructed from its runtime value.

pub fn sql_name(&self) -> String

pub fn regtype_name(&self) -> String

Name emitted by PostgreSQL’s regtype output, including pg_typeof(...).

Trait Implementations

impl Clone for ColumnType

fn clone(&self) -> ColumnType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ColumnType

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ColumnType

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ColumnType

impl PartialEq for ColumnType

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for ColumnType

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ColumnType