Enum Value 

#[non_exhaustive]
pub enum Value {
    Null,
    Bool(bool),
    I8(i8),
    I16(i16),
    I32(i32),
    I64(i64),
    U8(u8),
    U16(u16),
    U32(u32),
    U64(u64),
    F32(f32),
    F64(f64),
    Text(String),
    Bytes(Vec<u8>),
    Array(Vec<Value>),
    Custom(Arc<dyn CustomValue>),
}

A bound argument.

keelson carries its own value enum rather than being generic over a driver’s parameter type. That keeps Expression free of any backend type parameter, and it means a built query’s arguments can be inspected — printed, compared, serialised — without a database in the loop.

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.

Null

SQL NULL.

Bool(bool)

A boolean.

I8(i8)

An 8-bit signed integer.

I16(i16)

A 16-bit signed integer.

I32(i32)

A 32-bit signed integer.

I64(i64)

A 64-bit signed integer.

U8(u8)

An 8-bit unsigned integer.

U16(u16)

A 16-bit unsigned integer.

U32(u32)

A 32-bit unsigned integer.

U64(u64)

A 64-bit unsigned integer.

F32(f32)

A single-precision float.

F64(f64)

A double-precision float.

Text(String)

Character data.

Bytes(Vec<u8>)

Binary data — BYTEA, BLOB.

Array(Vec<Value>)

A homogeneous array, for dialects that have one (PostgreSQL).

Custom(Arc<dyn CustomValue>)

Escape hatch for dialect-specific types. Backends downcast through CustomValue::as_any.

Implementations

impl Value

pub fn array<T, I>(items: I) -> Value

where T: ToValue, I: IntoIterator<Item = T>,

Build a Value::Array from anything iterable.

There is deliberately no blanket ToValue for Vec<T>: it would collide with Vec<u8>, which must stay Value::Bytes so BYTEA/BLOB binds correctly. Arrays are therefore explicit.

pub fn custom<C>(value: C) -> Value

where C: CustomValue,

Wrap a dialect-specific value.

pub fn is_null(&self) -> bool

Whether this is Value::Null.

pub fn type_name(&self) -> &'static str

The variant name, for error messages.

Trait Implementations

impl Clone for Value

fn clone(&self) -> Value

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Value

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

Formats the value using the given formatter.

impl FromValue for Value

fn from_value(v: Value) -> Result<Value, Error>

Consume a Value and produce Self, or explain why not.

impl IntoExpr for Value

fn into_expr(self) -> Expr

Perform the conversion.

impl IntoExprList for Value

fn into_expr_list(self) -> Vec<Expr>

Perform the conversion.

impl PartialEq for Value

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Value

Value serialises as the underlying scalar, never as a tagged enum.

This is what makes Vec<Value> comparable against a plain JSON array of arguments — Value::I32(100) becomes 100, not {"I32":100} — which is the shape the test suite compares against.

fn serialize<S>( &self, s: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl ToValue for Value

fn to_value(self) -> Value

Consume self and produce the argument to bind.