Enum Value 

pub enum Value {
    Bool(bool),
    I8(i8),
    I16(i16),
    I32(i32),
    I64(i64),
    U8(u8),
    U16(u16),
    U32(u32),
    U64(u64),
    SparseRecord(SparseRecord),
    Null,
    Record(ValueRecord),
    List(Vec<Value>),
    String(String),
    Bytes(Vec<u8>),
    Uuid(Uuid),
    Decimal(Decimal),
    BigDecimal(BigDecimal),
    Timestamp(Timestamp),
    Zoned(Zoned),
    Date(Date),
    Time(Time),
    DateTime(DateTime),
}

A dynamically typed value used throughout Toasty’s query engine.

Value represents any concrete data value that flows through the query pipeline: field values read from or written to the database, literal constants in expressions, and intermediate results during query evaluation.

Each variant wraps a Rust type that corresponds to a Type variant. Use Value::infer_ty to obtain the matching type, and Value::is_a to check compatibility.

Construction

Values are typically created via From conversions from Rust primitives:

use toasty_core::stmt::Value;

let v = Value::from(42_i64);
assert_eq!(v, 42_i64);

let v = Value::from("hello");
assert_eq!(v, "hello");

let v = Value::null();
assert!(v.is_null());

let v = Value::from(true);
assert_eq!(v, true);

Variants

Bool(bool)

Boolean value

I8(i8)

Signed 8-bit integer

I16(i16)

Signed 16-bit integer

I32(i32)

Signed 32-bit integer

I64(i64)

Signed 64-bit integer

U8(u8)

Unsigned 8-bit integer

U16(u16)

Unsigned 16-bit integer

U32(u32)

Unsigned 32-bit integer

U64(u64)

Unsigned 64-bit integer

SparseRecord(SparseRecord)

A typed record

Null

Null value

Record(ValueRecord)

Record value, either borrowed or owned

List(Vec<Value>)

A list of values of the same type

String(String)

String value, either borrowed or owned

Bytes(Vec<u8>)

An array of bytes that is more efficient than List(u8)

Uuid(Uuid)

128-bit universally unique identifier (UUID)

Decimal(Decimal)

A fixed-precision decimal number. See [rust_decimal::Decimal].

BigDecimal(BigDecimal)

An arbitrary-precision decimal number. See [bigdecimal::BigDecimal].

Timestamp(Timestamp)

An instant in time represented as the number of nanoseconds since the Unix epoch. See [jiff::Timestamp].

Zoned(Zoned)

A time zone aware instant in time. See [jiff::Zoned]

Date(Date)

A representation of a civil date in the Gregorian calendar. See [jiff::civil::Date].

Time(Time)

A representation of civil “wall clock” time. See [jiff::civil::Time].

DateTime(DateTime)

A representation of a civil datetime in the Gregorian calendar. See [jiff::civil::DateTime].

Implementations

impl Value

pub fn to_i8(&self) -> Option<i8>

Attempts to convert this value to the target integer type.

Returns None if the value is not an integer variant or is out of range for the target type. Conversion works across all integer widths and signedness.

pub fn to_i8_unwrap(&self) -> i8

Converts this value to the target integer type, panicking on failure.

Panics

Panics if the value is not an integer variant or is out of range.

pub fn to_i16(&self) -> Option<i16>

Attempts to convert this value to the target integer type.

Returns None if the value is not an integer variant or is out of range for the target type. Conversion works across all integer widths and signedness.

pub fn to_i16_unwrap(&self) -> i16

Converts this value to the target integer type, panicking on failure.

Panics

Panics if the value is not an integer variant or is out of range.

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

Attempts to convert this value to the target integer type.

Returns None if the value is not an integer variant or is out of range for the target type. Conversion works across all integer widths and signedness.

pub fn to_i32_unwrap(&self) -> i32

Converts this value to the target integer type, panicking on failure.

Panics

Panics if the value is not an integer variant or is out of range.

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

Attempts to convert this value to the target integer type.

Returns None if the value is not an integer variant or is out of range for the target type. Conversion works across all integer widths and signedness.

pub fn to_i64_unwrap(&self) -> i64

Converts this value to the target integer type, panicking on failure.

Panics

Panics if the value is not an integer variant or is out of range.

pub fn to_u8(&self) -> Option<u8>

Attempts to convert this value to the target integer type.

Returns None if the value is not an integer variant or is out of range for the target type. Conversion works across all integer widths and signedness.

pub fn to_u8_unwrap(&self) -> u8

Converts this value to the target integer type, panicking on failure.

Panics

Panics if the value is not an integer variant or is out of range.

pub fn to_u16(&self) -> Option<u16>

Attempts to convert this value to the target integer type.

Returns None if the value is not an integer variant or is out of range for the target type. Conversion works across all integer widths and signedness.

pub fn to_u16_unwrap(&self) -> u16

Converts this value to the target integer type, panicking on failure.

Panics

Panics if the value is not an integer variant or is out of range.

pub fn to_u32(&self) -> Option<u32>

Attempts to convert this value to the target integer type.

Returns None if the value is not an integer variant or is out of range for the target type. Conversion works across all integer widths and signedness.

pub fn to_u32_unwrap(&self) -> u32

Converts this value to the target integer type, panicking on failure.

Panics

Panics if the value is not an integer variant or is out of range.

pub fn to_u64(&self) -> Option<u64>

Attempts to convert this value to the target integer type.

Returns None if the value is not an integer variant or is out of range for the target type. Conversion works across all integer widths and signedness.

pub fn to_u64_unwrap(&self) -> u64

Converts this value to the target integer type, panicking on failure.

Panics

Panics if the value is not an integer variant or is out of range.

impl Value

pub fn empty_sparse_record() -> Self

Creates an empty Value::SparseRecord with no populated fields.

pub fn sparse_record(fields: PathFieldSet, record: ValueRecord) -> Self

Creates a Value::SparseRecord by distributing values from record into the positions specified by fields.

pub fn into_sparse_record(self) -> SparseRecord

Consumes this value and returns the contained SparseRecord, panicking if this is not a Value::SparseRecord.

Panics

Panics if the value is not a SparseRecord variant.

impl Value

pub const fn null() -> Self

Returns a null value.

Examples

let v = Value::null();
assert!(v.is_null());

pub const fn is_null(&self) -> bool

Returns true if this value is Value::Null.

Examples

assert!(Value::Null.is_null());
assert!(!Value::from(1_i64).is_null());

pub const fn is_record(&self) -> bool

Returns true if this value is a Value::Record.

pub fn record_from_vec(fields: Vec<Self>) -> Self

Creates a Value::Record from a vector of field values.

Examples

let record = Value::record_from_vec(vec![Value::from(1_i64), Value::from("name")]);
assert!(record.is_record());

pub const fn from_bool(src: bool) -> Self

Creates a boolean value.

Examples

let v = Value::from_bool(true);
assert_eq!(v, true);

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

Returns the contained string slice if this is a Value::String, or None otherwise.

pub fn as_string_unwrap(&self) -> &str

Returns the contained string slice, panicking if this is not a Value::String.

Panics

Panics if the value is not a String variant.

pub fn as_record(&self) -> Option<&ValueRecord>

Returns a reference to the contained ValueRecord if this is a Value::Record, or None otherwise.

pub fn as_record_unwrap(&self) -> &ValueRecord

Returns a reference to the contained ValueRecord, panicking if this is not a Value::Record.

Panics

Panics if the value is not a Record variant.

pub fn as_record_mut_unwrap(&mut self) -> &mut ValueRecord

Returns a mutable reference to the contained ValueRecord, panicking if this is not a Value::Record.

Panics

Panics if the value is not a Record variant.

pub fn into_record(self) -> ValueRecord

Consumes this value and returns the contained ValueRecord, panicking if this is not a Value::Record.

Panics

Panics if the value is not a Record variant.

pub fn is_a(&self, ty: &Type) -> bool

Returns true if this value is compatible with the given Type.

Null values are compatible with any type. For union types, the value must be compatible with at least one member type.

pub fn infer_ty(&self) -> Type

Infers and returns the Type of this value.

Examples

assert_eq!(Value::from(42_i64).infer_ty(), Type::I64);
assert_eq!(Value::from("hello").infer_ty(), Type::String);
assert_eq!(Value::Null.infer_ty(), Type::Null);

pub fn entry(&self, path: impl EntryPath) -> Entry<'_>

Navigates into this value using the given path and returns an Entry reference to the nested value.

For records, each step indexes into the record’s fields. For lists, each step indexes into the list’s elements.

Panics

Panics if the path is invalid for the value’s structure.

pub fn take(&mut self) -> Self

Takes the value out, replacing it with Value::Null.

Examples

let mut v = Value::from(42_i64);
let taken = v.take();
assert_eq!(taken, 42_i64);
assert!(v.is_null());

impl Value

pub fn list_from_vec(items: Vec<Self>) -> Self

Creates a Value::List from a vector of values.

Examples

let list = Value::list_from_vec(vec![Value::from(1_i64), Value::from(2_i64)]);
assert!(list.is_list());

pub fn is_list(&self) -> bool

Returns true if this value is a Value::List.

pub fn into_list_unwrap(self) -> Vec<Value>

Consumes this value and returns the inner Vec<Value>, panicking if this is not a Value::List.

Panics

Panics if the value is not a List variant.

Trait Implementations

impl AsRef<Value> for Value

fn as_ref(&self) -> &Self

Converts this type into a shared reference of the (usually inferred) input type.

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

Formats the value using the given formatter.

impl Default for Value

fn default() -> Value

Returns the “default value” for a type.

impl From<&String> for Value

fn from(src: &String) -> Self

Converts to this type from the input type.

impl<'a> From<&'a Value> for Entry<'a>

fn from(value: &'a Value) -> Self

Converts to this type from the input type.

impl From<&i16> for Value

fn from(value: &i16) -> Self

Converts to this type from the input type.

impl From<&i32> for Value

fn from(value: &i32) -> Self

Converts to this type from the input type.

impl From<&i64> for Value

fn from(value: &i64) -> Self

Converts to this type from the input type.

impl From<&i8> for Value

fn from(value: &i8) -> Self

Converts to this type from the input type.

impl From<&isize> for Value

fn from(value: &isize) -> Self

Converts to this type from the input type.

impl<'a> From<&'a mut Value> for EntryMut<'a>

fn from(value: &'a mut Value) -> Self

Converts to this type from the input type.

impl From<&str> for Value

fn from(src: &str) -> Self

Converts to this type from the input type.

impl From<&u16> for Value

fn from(value: &u16) -> Self

Converts to this type from the input type.

impl From<&u32> for Value

fn from(value: &u32) -> Self

Converts to this type from the input type.

impl From<&u64> for Value

fn from(value: &u64) -> Self

Converts to this type from the input type.

impl From<&u8> for Value

fn from(value: &u8) -> Self

Converts to this type from the input type.

impl From<&usize> for Value

fn from(value: &usize) -> Self

Converts to this type from the input type.

impl From<BigDecimal> for Value

Available on crate feature bigdecimal only.

fn from(value: BigDecimal) -> Self

Converts to this type from the input type.

impl From<Date> for Value

fn from(value: Date) -> Self

Converts to this type from the input type.

impl From<DateTime> for Value

fn from(value: DateTime) -> Self

Converts to this type from the input type.

impl From<Decimal> for Value

Available on crate feature rust_decimal only.

fn from(value: Decimal) -> Self

Converts to this type from the input type.

impl<T> From<Option<T>> for Value

where Self: From<T>,

fn from(value: Option<T>) -> Self

Converts to this type from the input type.

impl From<SparseRecord> for Value

fn from(value: SparseRecord) -> Self

Converts to this type from the input type.

impl From<String> for Value

fn from(src: String) -> Self

Converts to this type from the input type.

impl From<Time> for Value

fn from(value: Time) -> Self

Converts to this type from the input type.

impl From<Timestamp> for Value

fn from(value: Timestamp) -> Self

Converts to this type from the input type.

impl From<Uuid> for Value

fn from(value: Uuid) -> Self

Converts to this type from the input type.

impl From<Value> for Expr

fn from(value: Value) -> Self

Converts to this type from the input type.

impl From<Value> for ValueStream

fn from(src: Value) -> Self

Converts to this type from the input type.

impl From<ValueRecord> for Value

fn from(value: ValueRecord) -> Self

Converts to this type from the input type.

impl From<Vec<Value>> for Value

fn from(value: Vec<Value>) -> Self

Converts to this type from the input type.

impl From<Vec<u8>> for Value

fn from(value: Vec<u8>) -> Self

Converts to this type from the input type.

impl From<Zoned> for Value

fn from(value: Zoned) -> Self

Converts to this type from the input type.

impl From<bool> for Value

fn from(src: bool) -> Self

Converts to this type from the input type.

impl From<i16> for Value

fn from(value: i16) -> Self

Converts to this type from the input type.

impl From<i32> for Value

fn from(value: i32) -> Self

Converts to this type from the input type.

impl From<i64> for Value

fn from(value: i64) -> Self

Converts to this type from the input type.

impl From<i8> for Value

fn from(value: i8) -> Self

Converts to this type from the input type.

impl From<isize> for Value

fn from(value: isize) -> Self

Converts to this type from the input type.

impl From<u16> for Value

fn from(value: u16) -> Self

Converts to this type from the input type.

impl From<u32> for Value

fn from(value: u32) -> Self

Converts to this type from the input type.

impl From<u64> for Value

fn from(value: u64) -> Self

Converts to this type from the input type.

impl From<u8> for Value

fn from(value: u8) -> Self

Converts to this type from the input type.

impl From<usize> for Value

fn from(value: usize) -> Self

Converts to this type from the input type.

impl Hash for Value

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Like<&[u8]> for Value

fn like(&self, pattern: &&[u8]) -> bool

Returns true if self matches the pattern other.

impl Like<&String> for Value

fn like(&self, pattern: &&String) -> bool

Returns true if self matches the pattern other.

impl Like<&str> for Value

fn like(&self, pattern: &&str) -> bool

Returns true if self matches the pattern other.

impl<T1> Like<(T1,)> for Value

where Value: Like<T1>,

fn like(&self, pattern: &(T1,)) -> bool

Returns true if self matches the pattern other.

impl<T1, T2> Like<(T1, T2)> for Value

where Value: Like<T1> + Like<T2>,

fn like(&self, pattern: &(T1, T2)) -> bool

Returns true if self matches the pattern other.

impl<T1, T2, T3> Like<(T1, T2, T3)> for Value

where Value: Like<T1> + Like<T2> + Like<T3>,

fn like(&self, pattern: &(T1, T2, T3)) -> bool

Returns true if self matches the pattern other.

impl<T1, T2, T3, T4> Like<(T1, T2, T3, T4)> for Value

where Value: Like<T1> + Like<T2> + Like<T3> + Like<T4>,

fn like(&self, pattern: &(T1, T2, T3, T4)) -> bool

Returns true if self matches the pattern other.

impl<T1, T2, T3, T4, T5> Like<(T1, T2, T3, T4, T5)> for Value

where Value: Like<T1> + Like<T2> + Like<T3> + Like<T4> + Like<T5>,

fn like(&self, pattern: &(T1, T2, T3, T4, T5)) -> bool

Returns true if self matches the pattern other.

impl<T1, T2, T3, T4, T5, T6> Like<(T1, T2, T3, T4, T5, T6)> for Value

where Value: Like<T1> + Like<T2> + Like<T3> + Like<T4> + Like<T5> + Like<T6>,

fn like(&self, pattern: &(T1, T2, T3, T4, T5, T6)) -> bool

Returns true if self matches the pattern other.

impl<T1, T2, T3, T4, T5, T6, T7> Like<(T1, T2, T3, T4, T5, T6, T7)> for Value

where Value: Like<T1> + Like<T2> + Like<T3> + Like<T4> + Like<T5> + Like<T6> + Like<T7>,

fn like(&self, pattern: &(T1, T2, T3, T4, T5, T6, T7)) -> bool

Returns true if self matches the pattern other.

impl<T1, T2, T3, T4, T5, T6, T7, T8> Like<(T1, T2, T3, T4, T5, T6, T7, T8)> for Value

where Value: Like<T1> + Like<T2> + Like<T3> + Like<T4> + Like<T5> + Like<T6> + Like<T7> + Like<T8>,

fn like(&self, pattern: &(T1, T2, T3, T4, T5, T6, T7, T8)) -> bool

Returns true if self matches the pattern other.

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9> Like<(T1, T2, T3, T4, T5, T6, T7, T8, T9)> for Value

where Value: Like<T1> + Like<T2> + Like<T3> + Like<T4> + Like<T5> + Like<T6> + Like<T7> + Like<T8> + Like<T9>,

fn like(&self, pattern: &(T1, T2, T3, T4, T5, T6, T7, T8, T9)) -> bool

Returns true if self matches the pattern other.

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Like<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> for Value

where Value: Like<T1> + Like<T2> + Like<T3> + Like<T4> + Like<T5> + Like<T6> + Like<T7> + Like<T8> + Like<T9> + Like<T10>,

fn like(&self, pattern: &(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) -> bool

Returns true if self matches the pattern other.

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Like<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> for Value

where Value: Like<T1> + Like<T2> + Like<T3> + Like<T4> + Like<T5> + Like<T6> + Like<T7> + Like<T8> + Like<T9> + Like<T10> + Like<T11>,

fn like(&self, pattern: &(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) -> bool

Returns true if self matches the pattern other.

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Like<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> for Value

where Value: Like<T1> + Like<T2> + Like<T3> + Like<T4> + Like<T5> + Like<T6> + Like<T7> + Like<T8> + Like<T9> + Like<T10> + Like<T11> + Like<T12>,

fn like( &self, pattern: &(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), ) -> bool

Returns true if self matches the pattern other.

impl Like<String> for Value

Convenience implementation for matching Value against String

fn like(&self, pattern: &String) -> bool

Returns true if self matches the pattern other.

impl Like<Uuid> for Value

fn like(&self, other: &Uuid) -> bool

Returns true if self matches the pattern other.

impl Like<Value> for Expr

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

Returns true if self matches the pattern other.

impl Like<i16> for Value

Available on crate feature assert-struct only.

fn like(&self, pattern: &i16) -> bool

Returns true if self matches the pattern other.

impl Like<i32> for Value

Available on crate feature assert-struct only.

fn like(&self, pattern: &i32) -> bool

Returns true if self matches the pattern other.

impl Like<i64> for Value

Available on crate feature assert-struct only.

fn like(&self, pattern: &i64) -> bool

Returns true if self matches the pattern other.

impl Like<i8> for Value

Available on crate feature assert-struct only.

fn like(&self, pattern: &i8) -> bool

Returns true if self matches the pattern other.

impl Like<isize> for Value

Available on crate feature assert-struct only.

fn like(&self, pattern: &isize) -> bool

Returns true if self matches the pattern other.

impl Like<u16> for Value

Available on crate feature assert-struct only.

fn like(&self, pattern: &u16) -> bool

Returns true if self matches the pattern other.

impl Like<u32> for Value

Available on crate feature assert-struct only.

fn like(&self, pattern: &u32) -> bool

Returns true if self matches the pattern other.

impl Like<u64> for Value

Available on crate feature assert-struct only.

fn like(&self, pattern: &u64) -> bool

Returns true if self matches the pattern other.

impl Like<u8> for Value

Available on crate feature assert-struct only.

fn like(&self, pattern: &u8) -> bool

Returns true if self matches the pattern other.

impl Like<usize> for Value

Available on crate feature assert-struct only.

fn like(&self, pattern: &usize) -> bool

Returns true if self matches the pattern other.

impl PartialEq<&str> for Value

PartialEq<&str> for Value

fn eq(&self, other: &&str) -> 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<T, const N: usize> PartialEq<[T; N]> for Value

where T: PartialEq<Value>,

fn eq(&self, other: &[T; N]) -> 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<T0> PartialEq<(T0,)> for Value

where Value: PartialEq<T0>,

fn eq(&self, other: &(T0,)) -> 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<T0, T1> PartialEq<(T0, T1)> for Value

where Value: PartialEq<T0> + PartialEq<T1>,

fn eq(&self, other: &(T0, T1)) -> 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<T0, T1, T2> PartialEq<(T0, T1, T2)> for Value

where Value: PartialEq<T0> + PartialEq<T1> + PartialEq<T2>,

fn eq(&self, other: &(T0, T1, T2)) -> 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<T0, T1, T2, T3> PartialEq<(T0, T1, T2, T3)> for Value

where Value: PartialEq<T0> + PartialEq<T1> + PartialEq<T2> + PartialEq<T3>,

fn eq(&self, other: &(T0, T1, T2, T3)) -> 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<T0, T1, T2, T3, T4> PartialEq<(T0, T1, T2, T3, T4)> for Value

where Value: PartialEq<T0> + PartialEq<T1> + PartialEq<T2> + PartialEq<T3> + PartialEq<T4>,

fn eq(&self, other: &(T0, T1, T2, T3, T4)) -> 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<T0, T1, T2, T3, T4, T5> PartialEq<(T0, T1, T2, T3, T4, T5)> for Value

where Value: PartialEq<T0> + PartialEq<T1> + PartialEq<T2> + PartialEq<T3> + PartialEq<T4> + PartialEq<T5>,

fn eq(&self, other: &(T0, T1, T2, T3, T4, T5)) -> 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<T0, T1, T2, T3, T4, T5, T6> PartialEq<(T0, T1, T2, T3, T4, T5, T6)> for Value

where Value: PartialEq<T0> + PartialEq<T1> + PartialEq<T2> + PartialEq<T3> + PartialEq<T4> + PartialEq<T5> + PartialEq<T6>,

fn eq(&self, other: &(T0, T1, T2, T3, T4, T5, T6)) -> 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<T0, T1, T2, T3, T4, T5, T6, T7> PartialEq<(T0, T1, T2, T3, T4, T5, T6, T7)> for Value

where Value: PartialEq<T0> + PartialEq<T1> + PartialEq<T2> + PartialEq<T3> + PartialEq<T4> + PartialEq<T5> + PartialEq<T6> + PartialEq<T7>,

fn eq(&self, other: &(T0, T1, T2, T3, T4, T5, T6, T7)) -> 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<T0, T1, T2, T3, T4, T5, T6, T7, T8> PartialEq<(T0, T1, T2, T3, T4, T5, T6, T7, T8)> for Value

where Value: PartialEq<T0> + PartialEq<T1> + PartialEq<T2> + PartialEq<T3> + PartialEq<T4> + PartialEq<T5> + PartialEq<T6> + PartialEq<T7> + PartialEq<T8>,

fn eq(&self, other: &(T0, T1, T2, T3, T4, T5, T6, T7, T8)) -> 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<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> PartialEq<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> for Value

where Value: PartialEq<T0> + PartialEq<T1> + PartialEq<T2> + PartialEq<T3> + PartialEq<T4> + PartialEq<T5> + PartialEq<T6> + PartialEq<T7> + PartialEq<T8> + PartialEq<T9>,

fn eq(&self, other: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)) -> 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<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> PartialEq<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> for Value

where Value: PartialEq<T0> + PartialEq<T1> + PartialEq<T2> + PartialEq<T3> + PartialEq<T4> + PartialEq<T5> + PartialEq<T6> + PartialEq<T7> + PartialEq<T8> + PartialEq<T9> + PartialEq<T10>,

fn eq(&self, other: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) -> 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<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> PartialEq<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> for Value

where Value: PartialEq<T0> + PartialEq<T1> + PartialEq<T2> + PartialEq<T3> + PartialEq<T4> + PartialEq<T5> + PartialEq<T6> + PartialEq<T7> + PartialEq<T8> + PartialEq<T9> + PartialEq<T10> + PartialEq<T11>,

fn eq(&self, other: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) -> 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 PartialEq<String> for Value

PartialEq for Value

fn eq(&self, other: &String) -> 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 PartialEq<Value> for &str

PartialEq for &str

fn eq(&self, other: &Value) -> 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<T, const N: usize> PartialEq<Value> for [T; N]

where T: PartialEq<Value>,

fn eq(&self, other: &Value) -> 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<T0> PartialEq<Value> for (T0,)

where T0: PartialEq<Value>,

fn eq(&self, other: &Value) -> 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<T0, T1> PartialEq<Value> for (T0, T1)

where T0: PartialEq<Value>, T1: PartialEq<Value>,

fn eq(&self, other: &Value) -> 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<T0, T1, T2> PartialEq<Value> for (T0, T1, T2)

where T0: PartialEq<Value>, T1: PartialEq<Value>, T2: PartialEq<Value>,

fn eq(&self, other: &Value) -> 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<T0, T1, T2, T3> PartialEq<Value> for (T0, T1, T2, T3)

where T0: PartialEq<Value>, T1: PartialEq<Value>, T2: PartialEq<Value>, T3: PartialEq<Value>,

fn eq(&self, other: &Value) -> 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<T0, T1, T2, T3, T4> PartialEq<Value> for (T0, T1, T2, T3, T4)

where T0: PartialEq<Value>, T1: PartialEq<Value>, T2: PartialEq<Value>, T3: PartialEq<Value>, T4: PartialEq<Value>,

fn eq(&self, other: &Value) -> 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<T0, T1, T2, T3, T4, T5> PartialEq<Value> for (T0, T1, T2, T3, T4, T5)

where T0: PartialEq<Value>, T1: PartialEq<Value>, T2: PartialEq<Value>, T3: PartialEq<Value>, T4: PartialEq<Value>, T5: PartialEq<Value>,

fn eq(&self, other: &Value) -> 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<T0, T1, T2, T3, T4, T5, T6> PartialEq<Value> for (T0, T1, T2, T3, T4, T5, T6)

where T0: PartialEq<Value>, T1: PartialEq<Value>, T2: PartialEq<Value>, T3: PartialEq<Value>, T4: PartialEq<Value>, T5: PartialEq<Value>, T6: PartialEq<Value>,

fn eq(&self, other: &Value) -> 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<T0, T1, T2, T3, T4, T5, T6, T7> PartialEq<Value> for (T0, T1, T2, T3, T4, T5, T6, T7)

where T0: PartialEq<Value>, T1: PartialEq<Value>, T2: PartialEq<Value>, T3: PartialEq<Value>, T4: PartialEq<Value>, T5: PartialEq<Value>, T6: PartialEq<Value>, T7: PartialEq<Value>,

fn eq(&self, other: &Value) -> 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<T0, T1, T2, T3, T4, T5, T6, T7, T8> PartialEq<Value> for (T0, T1, T2, T3, T4, T5, T6, T7, T8)

where T0: PartialEq<Value>, T1: PartialEq<Value>, T2: PartialEq<Value>, T3: PartialEq<Value>, T4: PartialEq<Value>, T5: PartialEq<Value>, T6: PartialEq<Value>, T7: PartialEq<Value>, T8: PartialEq<Value>,

fn eq(&self, other: &Value) -> 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<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> PartialEq<Value> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

where T0: PartialEq<Value>, T1: PartialEq<Value>, T2: PartialEq<Value>, T3: PartialEq<Value>, T4: PartialEq<Value>, T5: PartialEq<Value>, T6: PartialEq<Value>, T7: PartialEq<Value>, T8: PartialEq<Value>, T9: PartialEq<Value>,

fn eq(&self, other: &Value) -> 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<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> PartialEq<Value> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

where T0: PartialEq<Value>, T1: PartialEq<Value>, T2: PartialEq<Value>, T3: PartialEq<Value>, T4: PartialEq<Value>, T5: PartialEq<Value>, T6: PartialEq<Value>, T7: PartialEq<Value>, T8: PartialEq<Value>, T9: PartialEq<Value>, T10: PartialEq<Value>,

fn eq(&self, other: &Value) -> 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<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> PartialEq<Value> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

where T0: PartialEq<Value>, T1: PartialEq<Value>, T2: PartialEq<Value>, T3: PartialEq<Value>, T4: PartialEq<Value>, T5: PartialEq<Value>, T6: PartialEq<Value>, T7: PartialEq<Value>, T8: PartialEq<Value>, T9: PartialEq<Value>, T10: PartialEq<Value>, T11: PartialEq<Value>,

fn eq(&self, other: &Value) -> 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 PartialEq<Value> for String

PartialEq for String

fn eq(&self, other: &Value) -> 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 PartialEq<Value> for bool

Reverse PartialEq implementation for convenience

fn eq(&self, other: &Value) -> 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 PartialEq<Value> for i16

fn eq(&self, other: &Value) -> 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 PartialEq<Value> for i32

fn eq(&self, other: &Value) -> 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 PartialEq<Value> for i64

fn eq(&self, other: &Value) -> 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 PartialEq<Value> for i8

fn eq(&self, other: &Value) -> 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 PartialEq<Value> for str

PartialEq for str

fn eq(&self, other: &Value) -> 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 PartialEq<Value> for u16

fn eq(&self, other: &Value) -> 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 PartialEq<Value> for u32

fn eq(&self, other: &Value) -> 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 PartialEq<Value> for u64

fn eq(&self, other: &Value) -> 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 PartialEq<Value> for u8

fn eq(&self, other: &Value) -> 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 PartialEq<bool> for Value

PartialEq implementation for Value and primitive type

fn eq(&self, other: &bool) -> 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 PartialEq<i16> for Value

fn eq(&self, other: &i16) -> 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 PartialEq<i32> for Value

fn eq(&self, other: &i32) -> 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 PartialEq<i64> for Value

fn eq(&self, other: &i64) -> 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 PartialEq<i8> for Value

fn eq(&self, other: &i8) -> 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 PartialEq<str> for Value

PartialEq for Value

fn eq(&self, other: &str) -> 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 PartialEq<u16> for Value

fn eq(&self, other: &u16) -> 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 PartialEq<u32> for Value

fn eq(&self, other: &u32) -> 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 PartialEq<u64> for Value

fn eq(&self, other: &u64) -> 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 PartialEq<u8> for Value

fn eq(&self, other: &u8) -> 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 PartialEq for Value

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

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

Compares two values if they are of the same type.

Returns None for:

• null values (SQL semantics, e.g., null comparisons are undefined)
• Comparisons across different types
• Types without natural ordering (records, lists, etc.)

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Project for &Value

fn project(self, projection: &Projection) -> Option<Expr>

Applies the projection and returns the resulting expression.

impl Project for Value

fn project(self, projection: &Projection) -> Option<Expr>

Applies the projection and returns the resulting expression.

impl TryFrom<&Value> for isize

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: &Value) -> Result<Self>

Performs the conversion.

impl TryFrom<&Value> for usize

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: &Value) -> Result<Self>

Performs the conversion.

impl TryFrom<Value> for BigDecimal

Available on crate feature bigdecimal only.

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: Value) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Value> for Date

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: Value) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Value> for DateTime

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: Value) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Value> for Decimal

Available on crate feature rust_decimal only.

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: Value) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Value> for String

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: Value) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Value> for Time

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: Value) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Value> for Timestamp

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: Value) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Value> for Uuid

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: Value) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Value> for Vec<u8>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: Value) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Value> for Zoned

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: Value) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Value> for bool

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: Value) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Value> for i16

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: Value) -> Result<Self>

Performs the conversion.

impl TryFrom<Value> for i32

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: Value) -> Result<Self>

Performs the conversion.

impl TryFrom<Value> for i64

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: Value) -> Result<Self>

Performs the conversion.

impl TryFrom<Value> for i8

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: Value) -> Result<Self>

Performs the conversion.

impl TryFrom<Value> for isize

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: Value) -> Result<Self>

Performs the conversion.

impl TryFrom<Value> for u16

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: Value) -> Result<Self>

Performs the conversion.

impl TryFrom<Value> for u32

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: Value) -> Result<Self>

Performs the conversion.

impl TryFrom<Value> for u64

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: Value) -> Result<Self>

Performs the conversion.

impl TryFrom<Value> for u8

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: Value) -> Result<Self>

Performs the conversion.

impl TryFrom<Value> for usize

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: Value) -> Result<Self>

Performs the conversion.

impl Eq for Value

impl StructuralPartialEq for Value