Enum SQLiteType 

pub enum SQLiteType {
    Integer,
    Text,
    Blob,
    Real,
    Numeric,
    Any,
}

A SQLite column type as written in DDL.

These are the types a STRICT table accepts, plus NUMERIC; see SQLite datatypes. The type decides which column attributes are allowed (is_valid_flag).

Examples

use drizzle_types::sqlite::SQLiteType;

let int_type = SQLiteType::Integer;
assert_eq!(int_type.to_sql_type(), "INTEGER");
assert!(int_type.is_valid_flag("autoincrement"));

let text_type = SQLiteType::Text;
assert!(text_type.is_valid_flag("json"));
assert!(!text_type.is_valid_flag("autoincrement"));

Variants

Integer

SQLite INTEGER type - stores signed integers up to 8 bytes.

See: https://sqlite.org/datatype3.html#integer_datatype

Supports: primary keys, autoincrement, enums (discriminant storage)

Text

SQLite TEXT type - stores text in UTF-8, UTF-16BE, or UTF-16LE encoding.

See: https://sqlite.org/datatype3.html#text_datatype

Supports: enums (variant name storage), JSON (#[column(json)])

Blob

SQLite BLOB type - stores binary data exactly as input.

See: https://sqlite.org/datatype3.html#blob_datatype

Used for byte arrays and UUIDs.

Real

SQLite REAL type - stores floating point values as 8-byte IEEE floating point numbers.

See: https://sqlite.org/datatype3.html#real_datatype

Numeric

SQLite NUMERIC type - stores values as INTEGER, REAL, or TEXT depending on the value.

See: https://sqlite.org/datatype3.html#numeric_datatype

Any

SQLite ANY type - no type affinity, can store any type of data. This holds in STRICT tables; elsewhere SQLite gives a column declared ANY NUMERIC affinity. The default.

See: https://sqlite.org/stricttables.html

Implementations

impl SQLiteType

pub const fn from_attribute_name(name: &str) -> Option<Self>

Parses a type name from a column attribute, ignoring case. Returns None for unknown names.

Also accepts "number" (as NUMERIC) and "boolean" (as INTEGER).

pub const fn to_sql_type(&self) -> &'static str

Returns the type as written in DDL, such as "INTEGER".

pub const fn affinity(&self) -> SQLiteAffinity

Returns this type’s SQLite affinity.

pub const fn is_strict_allowed(&self) -> bool

Returns true if a STRICT table accepts this type: every type except NUMERIC.

pub fn is_valid_flag(&self, flag: &str) -> bool

Returns true if the column attribute flag can be used with this type.

Valid flags per type:

• INTEGER: primary, primary_key, unique, autoincrement, enum
• TEXT: primary, primary_key, unique, json, enum
• BLOB: primary, primary_key, unique
• REAL: primary, primary_key, unique
• NUMERIC: primary, primary_key, unique
• ANY: primary, primary_key, unique

Trait Implementations

impl Clone for SQLiteType

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for SQLiteType

impl Debug for SQLiteType

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

Formats the value using the given formatter.

impl Default for SQLiteType

fn default() -> Self

Returns the “default value” for a type.

impl Display for SQLiteType

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

Formats the value using the given formatter.

impl Eq for SQLiteType

impl Hash for SQLiteType

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

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for SQLiteType