Enum PgValue 

pub enum PgValue {
    Null,
    Bool(bool),
    Int2(i16),
    Int4(i32),
    Int8(i64),
    Float4(f32),
    Float8(f64),
    Text(String),
    Bytes(Vec<u8>),
    Json(String),
    Jsonb(Vec<u8>),
    Uuid([u8; 16]),
    Date(i32),
    Time(i64),
    Timestamp(i64),
    Timestamptz(i64),
    Interval {
        months: i32,
        days: i32,
        microseconds: i64,
    },
    Inet(String),
    Numeric(String),
    MacAddr([u8; 6]),
    Point {
        x: f64,
        y: f64,
    },
    MacAddr8([u8; 8]),
    Bit {
        len: u32,
        data: Vec<u8>,
    },
    Range(String),
    Array(Vec<PgValue>),
}

A PostgreSQL value that can be used as a query parameter or read from a row.

Variants

Null

Bool(bool)

Int2(i16)

Int4(i32)

Int8(i64)

Float4(f32)

Float8(f64)

Text(String)

Bytes(Vec<u8>)

Json(String)

Jsonb(Vec<u8>)

Uuid([u8; 16])

UUID stored as 16-byte array.

Date(i32)

Date: days since 2000-01-01 (PostgreSQL epoch).

Time(i64)

Time: microseconds since midnight.

Timestamp(i64)

Timestamp: microseconds since 2000-01-01 00:00:00 (PostgreSQL epoch).

Timestamptz(i64)

Timestamptz: microseconds since 2000-01-01 00:00:00 UTC.

Interval

Interval: months, days, microseconds.

Fields

months: i32

days: i32

microseconds: i64

Inet(String)

Network address (stored as text representation).

Numeric(String)

Numeric (stored as text representation for lossless precision).

MacAddr([u8; 6])

MAC address stored as 6 bytes.

Point

2D point: (x, y).

Fields

x: f64

y: f64

MacAddr8([u8; 8])

MAC address stored as 8 bytes (EUI-64).

Bit

Bit string: number of bits + packed bytes.

Fields

len: u32

data: Vec<u8>

Range(String)

Range value (stored as text representation). Examples: "[1,10)", "[2024-01-01,2024-12-31]", "empty".

Array(Vec<PgValue>)

Array of values (homogeneous).

Implementations

impl PgValue

pub fn to_text_bytes(&self) -> Option<Vec<u8>>

Encode this value as text-format bytes for use as a query parameter.

pub fn to_binary_bytes(&self) -> Option<Vec<u8>>

Encode this value as binary-format bytes for use as a query parameter.

Returns None for Null; Some(bytes) for everything else. The binary format matches what PostgreSQL expects when the parameter format code is 1 (binary).

pub fn prefers_binary(&self) -> bool

Determine if this value should be sent as binary or text format.

Returns true for types that have an efficient binary encoding (scalars, dates, etc.), false for types best sent as text (arrays, numeric, inet).

pub fn from_text(type_oid: u32, data: &[u8]) -> Result<PgValue, PgError>

Parse a text-format column value based on its type OID.

pub fn from_binary(type_oid: u32, data: &[u8]) -> Result<PgValue, PgError>

Parse a binary-format column value based on its type OID.

pub fn as_i32(&self) -> Option<i32>

Try to extract as i32.

pub fn as_i64(&self) -> Option<i64>

Try to extract as i64.

pub fn as_str(&self) -> Option<&str>

Try to extract as &str.

pub fn as_bool(&self) -> Option<bool>

Try to extract as bool.

pub fn as_f64(&self) -> Option<f64>

Try to extract as f64.

pub fn is_null(&self) -> bool

Returns true if this is a Null value.

Trait Implementations

impl Clone for PgValue

fn clone(&self) -> PgValue

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PgValue

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

Formats the value using the given formatter.

impl PartialEq for PgValue

fn eq(&self, other: &PgValue) -> 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 ToSql for PgValue

fn to_sql(&self) -> PgValue

Convert this value to a PgValue for use as a query parameter.

fn type_oid(&self) -> u32

The PostgreSQL type OID this value maps to (0 = let the server decide).

impl StructuralPartialEq for PgValue