Trait Decode 

pub trait Decode<'a>: 'a + Sized {
    // Required methods
    fn compatible(data_type: &DataTypeNode) -> bool;
    fn decode(
        reader: &mut ValueReader<'a>,
    ) -> Result<Self, Box<dyn StdError + Send + Sync>>;

    // Provided methods
    fn decode_null(
        data_type: &DataTypeNode,
    ) -> Result<Self, Box<dyn StdError + Send + Sync>> { ... }
    fn decode_array(
        data: ArrayData<'a>,
    ) -> Result<Self, Box<dyn StdError + Send + Sync>> { ... }
    fn decode_tuple(
        data: TupleIter<'a>,
    ) -> Result<Self, Box<dyn StdError + Send + Sync>> { ... }
    fn decode_map(
        key_data: ArrayData<'a>,
        value_data: ArrayData<'a>,
    ) -> Result<Self, Box<dyn StdError + Send + Sync>> { ... }
}

Decode a Rust type from its equivalent in ClickHouse’s Native format.

Required Methods

fn compatible(data_type: &DataTypeNode) -> bool

Return true if the given data type is compatible with this Rust type.

The implementation should accept both LowCardinality(_) and SimpleAggregateFunction(_, _) as valid; the data provided during decode will be identical to the unwrapped type.

Use DataTypeNode::remove_compatible_wrappers() when matching on types.

fn decode( reader: &mut ValueReader<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

Decode the given value, which may involve parsing.

The exact error type should not be considered stable.

Provided Methods

fn decode_null( data_type: &DataTypeNode, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

Decode a NULL value.

Default implementation returns an error.

fn decode_array( data: ArrayData<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

Decode an array of values.

Default implementation returns an error.

Do not override unless implementing a custom array/slice type like Vec<T>.

Generic implementations for Vec<T> and Box<[T]> are already provided.

fn decode_tuple( data: TupleIter<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

Decode a tuple of values.

Default implementation returns an error.

Do not override unless implementing a custom tuple struct type.

Generic implementations for (T...) up to 16 elements are already provided.

fn decode_map( key_data: ArrayData<'a>, value_data: ArrayData<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

Decode a Map.

Default implementation returns an error.

Do not override unless implementing a custom map type like HashMap<K, V>.

Generic implementations for HashMap and BTreeMap are already provided.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl Decode<'_> for IpAddr

Accepts either a IPv4 or IPv6 type.

Note: No Encode Impl

ClickHouse does not have a polymorphic IP address type, so this cannot be infallibly encoded.

fn compatible(data_type: &DataTypeNode) -> bool

fn decode( reader: &mut ValueReader<'_>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

impl Decode<'_> for Ipv4Addr

fn compatible(data_type: &DataTypeNode) -> bool

fn decode( reader: &mut ValueReader<'_>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

impl Decode<'_> for Ipv6Addr

fn compatible(data_type: &DataTypeNode) -> bool

fn decode( reader: &mut ValueReader<'_>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

impl Decode<'_> for Uuid

Available on crate feature uuid only.

fn compatible(data_type: &DataTypeNode) -> bool

fn decode( reader: &mut ValueReader<'_>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

impl Decode<'_> for bool

fn decode( reader: &mut ValueReader<'_>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

Decode this type from Bool.

fn compatible(data_type: &DataTypeNode) -> bool

impl<'a, K, V, S> Decode<'a> for HashMap<K, V, S>

where K: Decode<'a> + Hash + Eq, V: Decode<'a>, S: BuildHasher + Default + 'a,

fn compatible(data_type: &DataTypeNode) -> bool

fn decode( reader: &mut ValueReader<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

fn decode_map( key_data: ArrayData<'a>, value_data: ArrayData<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

impl<'a, K, V> Decode<'a> for BTreeMap<K, V>

where K: Decode<'a> + Ord + Eq, V: Decode<'a>,

fn compatible(data_type: &DataTypeNode) -> bool

fn decode( reader: &mut ValueReader<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

fn decode_map( key_data: ArrayData<'a>, value_data: ArrayData<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

impl<'a, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Decode<'a> for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)

where T1: Decode<'a>, T2: Decode<'a>, T3: Decode<'a>, T4: Decode<'a>, T5: Decode<'a>, T6: Decode<'a>, T7: Decode<'a>, T8: Decode<'a>, T9: Decode<'a>, T10: Decode<'a>, T11: Decode<'a>, T12: Decode<'a>, T13: Decode<'a>, T14: Decode<'a>, T15: Decode<'a>, T16: Decode<'a>,

fn compatible(data_type: &DataTypeNode) -> bool

fn decode( reader: &mut ValueReader<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

fn decode_tuple( data: TupleIter<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

impl<'a, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Decode<'a> for (T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)

where T2: Decode<'a>, T3: Decode<'a>, T4: Decode<'a>, T5: Decode<'a>, T6: Decode<'a>, T7: Decode<'a>, T8: Decode<'a>, T9: Decode<'a>, T10: Decode<'a>, T11: Decode<'a>, T12: Decode<'a>, T13: Decode<'a>, T14: Decode<'a>, T15: Decode<'a>, T16: Decode<'a>,

fn compatible(data_type: &DataTypeNode) -> bool

fn decode( reader: &mut ValueReader<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

fn decode_tuple( data: TupleIter<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

impl<'a, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Decode<'a> for (T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)

where T3: Decode<'a>, T4: Decode<'a>, T5: Decode<'a>, T6: Decode<'a>, T7: Decode<'a>, T8: Decode<'a>, T9: Decode<'a>, T10: Decode<'a>, T11: Decode<'a>, T12: Decode<'a>, T13: Decode<'a>, T14: Decode<'a>, T15: Decode<'a>, T16: Decode<'a>,

fn compatible(data_type: &DataTypeNode) -> bool

fn decode( reader: &mut ValueReader<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

fn decode_tuple( data: TupleIter<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

impl<'a, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Decode<'a> for (T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)

where T4: Decode<'a>, T5: Decode<'a>, T6: Decode<'a>, T7: Decode<'a>, T8: Decode<'a>, T9: Decode<'a>, T10: Decode<'a>, T11: Decode<'a>, T12: Decode<'a>, T13: Decode<'a>, T14: Decode<'a>, T15: Decode<'a>, T16: Decode<'a>,

fn compatible(data_type: &DataTypeNode) -> bool

fn decode( reader: &mut ValueReader<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

fn decode_tuple( data: TupleIter<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

impl<'a, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Decode<'a> for (T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)

where T5: Decode<'a>, T6: Decode<'a>, T7: Decode<'a>, T8: Decode<'a>, T9: Decode<'a>, T10: Decode<'a>, T11: Decode<'a>, T12: Decode<'a>, T13: Decode<'a>, T14: Decode<'a>, T15: Decode<'a>, T16: Decode<'a>,

fn compatible(data_type: &DataTypeNode) -> bool

fn decode( reader: &mut ValueReader<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

fn decode_tuple( data: TupleIter<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

impl<'a, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Decode<'a> for (T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)

where T6: Decode<'a>, T7: Decode<'a>, T8: Decode<'a>, T9: Decode<'a>, T10: Decode<'a>, T11: Decode<'a>, T12: Decode<'a>, T13: Decode<'a>, T14: Decode<'a>, T15: Decode<'a>, T16: Decode<'a>,

fn compatible(data_type: &DataTypeNode) -> bool

fn decode( reader: &mut ValueReader<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

fn decode_tuple( data: TupleIter<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

impl<'a, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Decode<'a> for (T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)

where T7: Decode<'a>, T8: Decode<'a>, T9: Decode<'a>, T10: Decode<'a>, T11: Decode<'a>, T12: Decode<'a>, T13: Decode<'a>, T14: Decode<'a>, T15: Decode<'a>, T16: Decode<'a>,

fn compatible(data_type: &DataTypeNode) -> bool

fn decode( reader: &mut ValueReader<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

fn decode_tuple( data: TupleIter<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

impl<'a, T8, T9, T10, T11, T12, T13, T14, T15, T16> Decode<'a> for (T8, T9, T10, T11, T12, T13, T14, T15, T16)

where T8: Decode<'a>, T9: Decode<'a>, T10: Decode<'a>, T11: Decode<'a>, T12: Decode<'a>, T13: Decode<'a>, T14: Decode<'a>, T15: Decode<'a>, T16: Decode<'a>,

fn compatible(data_type: &DataTypeNode) -> bool

fn decode( reader: &mut ValueReader<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

fn decode_tuple( data: TupleIter<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

impl<'a, T9, T10, T11, T12, T13, T14, T15, T16> Decode<'a> for (T9, T10, T11, T12, T13, T14, T15, T16)

where T9: Decode<'a>, T10: Decode<'a>, T11: Decode<'a>, T12: Decode<'a>, T13: Decode<'a>, T14: Decode<'a>, T15: Decode<'a>, T16: Decode<'a>,

fn compatible(data_type: &DataTypeNode) -> bool

fn decode( reader: &mut ValueReader<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

fn decode_tuple( data: TupleIter<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

impl<'a, T10, T11, T12, T13, T14, T15, T16> Decode<'a> for (T10, T11, T12, T13, T14, T15, T16)

where T10: Decode<'a>, T11: Decode<'a>, T12: Decode<'a>, T13: Decode<'a>, T14: Decode<'a>, T15: Decode<'a>, T16: Decode<'a>,

fn compatible(data_type: &DataTypeNode) -> bool

fn decode( reader: &mut ValueReader<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

fn decode_tuple( data: TupleIter<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

impl<'a, T11, T12, T13, T14, T15, T16> Decode<'a> for (T11, T12, T13, T14, T15, T16)

where T11: Decode<'a>, T12: Decode<'a>, T13: Decode<'a>, T14: Decode<'a>, T15: Decode<'a>, T16: Decode<'a>,

fn compatible(data_type: &DataTypeNode) -> bool

fn decode( reader: &mut ValueReader<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

fn decode_tuple( data: TupleIter<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

impl<'a, T12, T13, T14, T15, T16> Decode<'a> for (T12, T13, T14, T15, T16)

where T12: Decode<'a>, T13: Decode<'a>, T14: Decode<'a>, T15: Decode<'a>, T16: Decode<'a>,

fn compatible(data_type: &DataTypeNode) -> bool

fn decode( reader: &mut ValueReader<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

fn decode_tuple( data: TupleIter<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

impl<'a, T13, T14, T15, T16> Decode<'a> for (T13, T14, T15, T16)

where T13: Decode<'a>, T14: Decode<'a>, T15: Decode<'a>, T16: Decode<'a>,

fn compatible(data_type: &DataTypeNode) -> bool

fn decode( reader: &mut ValueReader<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

fn decode_tuple( data: TupleIter<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

impl<'a, T14, T15, T16> Decode<'a> for (T14, T15, T16)

where T14: Decode<'a>, T15: Decode<'a>, T16: Decode<'a>,

fn compatible(data_type: &DataTypeNode) -> bool

fn decode( reader: &mut ValueReader<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

fn decode_tuple( data: TupleIter<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

impl<'a, T15, T16> Decode<'a> for (T15, T16)

where T15: Decode<'a>, T16: Decode<'a>,

fn compatible(data_type: &DataTypeNode) -> bool

fn decode( reader: &mut ValueReader<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

fn decode_tuple( data: TupleIter<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

impl<'a, T16> Decode<'a> for (T16,)

where T16: Decode<'a>,

fn compatible(data_type: &DataTypeNode) -> bool

fn decode( reader: &mut ValueReader<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

fn decode_tuple( data: TupleIter<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

impl<'a, T: Decode<'a> + 'a> Decode<'a> for Vec<T>

fn compatible(data_type: &DataTypeNode) -> bool

fn decode( reader: &mut ValueReader<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

fn decode_array( data: ArrayData<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

impl<'a, T: Decode<'a>> Decode<'a> for Option<T>

fn compatible(data_type: &DataTypeNode) -> bool

fn decode( reader: &mut ValueReader<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

fn decode_null( _data_type: &DataTypeNode, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

fn decode_array( data: ArrayData<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

fn decode_tuple( data: TupleIter<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

impl<'a> Decode<'a> for &'a str

Zero-copy decoding for strings.

fn decode( reader: &mut ValueReader<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

Decode this type from String or FixedString.

Errors

If the string data is not valid UTF-8.

fn compatible(data_type: &DataTypeNode) -> bool

impl<'a> Decode<'a> for String

fn decode( reader: &mut ValueReader<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

Decode this type from String or FixedString.

Errors

If the string data is not valid UTF-8.

fn compatible(data_type: &DataTypeNode) -> bool

impl<'a> Decode<'a> for f32

fn decode( reader: &mut ValueReader<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

Decode this type from Float32.

fn compatible(data_type: &DataTypeNode) -> bool

impl<'a> Decode<'a> for f64

fn decode( reader: &mut ValueReader<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

Decode this type from Float64.

fn compatible(data_type: &DataTypeNode) -> bool

impl<'a> Decode<'a> for i8

fn decode( reader: &mut ValueReader<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

Decode this type from Int8.

fn compatible(data_type: &DataTypeNode) -> bool

impl<'a> Decode<'a> for i16

fn decode( reader: &mut ValueReader<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

Decode this type from Int16.

fn compatible(data_type: &DataTypeNode) -> bool

impl<'a> Decode<'a> for i32

fn decode( reader: &mut ValueReader<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

Decode this type from Int32.

fn compatible(data_type: &DataTypeNode) -> bool

impl<'a> Decode<'a> for i64

fn decode( reader: &mut ValueReader<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

Decode this type from Int64.

fn compatible(data_type: &DataTypeNode) -> bool

impl<'a> Decode<'a> for i128

fn decode( reader: &mut ValueReader<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

Decode this type from Int128.

fn compatible(data_type: &DataTypeNode) -> bool

impl<'a> Decode<'a> for u8

fn decode( reader: &mut ValueReader<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

Decode this type from UInt8.

fn compatible(data_type: &DataTypeNode) -> bool

impl<'a> Decode<'a> for u16

fn decode( reader: &mut ValueReader<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

Decode this type from UInt16.

fn compatible(data_type: &DataTypeNode) -> bool

impl<'a> Decode<'a> for u32

fn decode( reader: &mut ValueReader<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

Decode this type from UInt32.

fn compatible(data_type: &DataTypeNode) -> bool

impl<'a> Decode<'a> for u64

fn decode( reader: &mut ValueReader<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

Decode this type from UInt64.

fn compatible(data_type: &DataTypeNode) -> bool

impl<'a> Decode<'a> for u128

fn decode( reader: &mut ValueReader<'a>, ) -> Result<Self, Box<dyn StdError + Send + Sync>>

Decode this type from UInt128.

fn compatible(data_type: &DataTypeNode) -> bool

Implementors