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),
}

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>

pub fn to_i8_unwrap(&self) -> i8

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

pub fn to_i16_unwrap(&self) -> i16

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

pub fn to_i32_unwrap(&self) -> i32

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

pub fn to_i64_unwrap(&self) -> i64

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

pub fn to_u8_unwrap(&self) -> u8

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

pub fn to_u16_unwrap(&self) -> u16

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

pub fn to_u32_unwrap(&self) -> u32

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

pub fn to_u64_unwrap(&self) -> u64

impl Value

pub fn empty_sparse_record() -> Self

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

pub fn into_sparse_record(self) -> SparseRecord

impl Value

pub const fn null() -> Self

Returns a ValueCow representing null

pub const fn is_null(&self) -> bool

pub const fn is_record(&self) -> bool

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

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

Create a ValueCow representing the given boolean value

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

pub fn expect_string(&self) -> &str

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

pub fn expect_record(&self) -> &ValueRecord

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

pub fn into_record(self) -> ValueRecord

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

pub fn infer_ty(&self) -> Type

Infer the type of a value

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

pub fn take(&mut self) -> Self

impl Value

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

pub fn is_list(&self) -> bool

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

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>

impl Project for Value

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

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