Enum D1TypeInfo 

#[non_exhaustive]
pub enum D1TypeInfo {
    Null,
    Integer,
    Real,
    Text,
    Blob,
}

The storage class of a single value, which is all these backends report.

There is no declared column type to go on: D1 and Durable Object storage hand back JavaScript values, not SQLite’s column metadata. So the type is read off each value as it arrives, and a column’s type is the type of whatever is in it.

Non-exhaustive, like Value: a new storage class must not break a match outside this crate.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Null

A NULL value, or a column with no non-NULL value to type it by.

Integer

A whole number within ±(2^53 − 1).

Real

Any other number.

Text

A string.

Blob

Bytes.

Trait Implementations

impl Clone for TypeInfo

fn clone(&self) -> TypeInfo

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for TypeInfo

impl Debug for TypeInfo

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

Formats the value using the given formatter.

impl Display for TypeInfo

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

Formats the value using the given formatter.

impl Eq for TypeInfo

impl Hash for TypeInfo

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

where __H: Hasher,

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 PartialEq for TypeInfo

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for TypeInfo

impl TypeInfo for TypeInfo

fn is_null(&self) -> bool

fn name(&self) -> &str

Returns the database system name of the type. Length specifiers should not be included. Common type names are VARCHAR, TEXT, or INT. Type names should be uppercase. They should be a rough approximation of how they are written in SQL in the given database.

fn type_compatible(&self, other: &Self) -> bool

where Self: Sized,

Return true if self and other represent mutually compatible types.