drizzle_sqlite/traits/

value.rs

//! Traits for decoding `SQLite` values into Rust types and for custom
//! column types.
//!
//! [`FromSQLiteValue`] decodes one cell. [`DrizzleRowByIndex`] reads cells
//! from a rusqlite, libsql or turso row by position, and
//! [`DrizzleRowByName`] reads rusqlite and libsql rows by column name.
//! Implement [`DrizzleSQLiteColumn`] to use your own type as a
//! column in a `#[SQLiteTable]`.

use crate::prelude::*;
use crate::values::{OwnedSQLiteValue, SQLiteValue, SQLiteValueRef};
use drizzle_core::conv::checked_float_to_int;
use drizzle_core::error::DrizzleError;

/// The `SQLite` type affinity of a SQL type marker such as
/// [`Integer`](crate::types::Integer) or [`Text`](crate::types::Text).
pub trait SQLiteAffinity: drizzle_core::types::DataType {
    /// The affinity as written in DDL (`"INTEGER"`, `"TEXT"`, ...).
    const SQL_TYPE: &'static str;
}

macro_rules! impl_sqlite_affinity {
    ($($marker:ty => $sql_type:literal),+ $(,)?) => {
        $(
            impl SQLiteAffinity for $marker {
                const SQL_TYPE: &'static str = $sql_type;
            }
        )+
    };
}

impl_sqlite_affinity! {
    crate::types::Integer => "INTEGER",
    crate::types::Text => "TEXT",
    crate::types::Blob => "BLOB",
    crate::types::Real => "REAL",
    crate::types::Numeric => "NUMERIC",
    crate::types::Any => "ANY",
}

/// A Rust type that can be stored in a `SQLite` column.
///
/// `#[derive(SQLiteEnum)]` implements this for enums. Implement it by hand to
/// use your own type as a field of a `#[SQLiteTable]`: [`SQLType`] picks the
/// column's affinity, [`decode`] reads a cell, and [`encode`] writes one.
/// Implementing it also gives the type [`FromSQLiteValue`] and
/// `From<T> for SQLiteValue`.
///
/// `From<T> for SQLiteValue` goes through [`encode_owned`], because insert
/// and update models keep their values after the source is dropped. Override
/// `encode_owned` when the type can hand over its buffer without copying.
///
/// [`SQLType`]: Self::SQLType
/// [`decode`]: Self::decode
/// [`encode`]: Self::encode
/// [`encode_owned`]: Self::encode_owned
///
/// # Examples
///
/// A `u32` stored as four big-endian bytes:
///
/// ```
/// use drizzle_core::error::DrizzleError;
/// use drizzle_sqlite::traits::{DrizzleSQLiteColumn, FromSQLiteValue};
/// use drizzle_sqlite::types::Blob;
/// use drizzle_sqlite::values::{SQLiteValue, SQLiteValueRef};
/// use std::borrow::Cow;
///
/// struct U32Be(u32);
///
/// impl DrizzleSQLiteColumn for U32Be {
///     type SQLType = Blob;
///
///     fn decode(value: SQLiteValueRef<'_>) -> Result<Self, DrizzleError> {
///         let SQLiteValueRef::Blob(bytes) = value else {
///             return Err(DrizzleError::ConversionError("expected a BLOB".into()));
///         };
///         let bytes: [u8; 4] = bytes
///             .try_into()
///             .map_err(|_| DrizzleError::ConversionError("expected 4 bytes".into()))?;
///         Ok(Self(u32::from_be_bytes(bytes)))
///     }
///
///     fn encode(&self) -> SQLiteValue<'_> {
///         SQLiteValue::Blob(Cow::Owned(self.0.to_be_bytes().to_vec()))
///     }
/// }
///
/// let value = SQLiteValue::from(U32Be(7));
/// assert_eq!(value, SQLiteValue::Blob(Cow::Borrowed(&[0, 0, 0, 7][..])));
/// assert_eq!(U32Be::from_sqlite_blob(&[0, 0, 1, 0]).unwrap().0, 256);
/// assert!(U32Be::from_sqlite_text("7").is_err());
/// ```
#[diagnostic::on_unimplemented(
    message = "`{Self}` cannot be used as a SQLite column type",
    note = "add #[derive(SQLiteEnum)] for enum types, or use a supported primitive type"
)]
pub trait DrizzleSQLiteColumn: Sized {
    /// The SQL type marker of the column: one of the markers in
    /// [`crate::types`] (`Integer`, `Text`, `Blob`, `Real`, `Numeric`, `Any`).
    ///
    /// It sets the column's affinity in DDL and which expressions the column
    /// can be used in.
    type SQLType: SQLiteAffinity;

    /// The affinity as written in DDL. Defaults to the affinity of
    /// [`SQLType`](Self::SQLType).
    ///
    /// Kept for source compatibility. Schema generation reads the affinity
    /// from `SQLType`, so overriding this constant does not change the
    /// column type.
    const SQL_TYPE: &'static str = <Self::SQLType as SQLiteAffinity>::SQL_TYPE;

    /// Decodes a cell read from the database.
    ///
    /// Reject storage classes the type does not accept (including `NULL`)
    /// with [`DrizzleError::ConversionError`].
    ///
    /// # Errors
    ///
    /// Returns [`DrizzleError::ConversionError`] if `value` cannot be decoded
    /// as this custom column type.
    fn decode(value: SQLiteValueRef<'_>) -> Result<Self, DrizzleError>;

    /// Encodes the value as a bind parameter, borrowing from `self` where
    /// possible.
    fn encode(&self) -> SQLiteValue<'_>;

    /// Encodes the value as an owned bind parameter.
    ///
    /// The default calls [`encode`](Self::encode) and copies the result.
    /// Override it when the type can move its string or byte buffer into the
    /// value instead.
    fn encode_owned(self) -> OwnedSQLiteValue {
        self.encode().into_owned()
    }

    /// Decodes a cell from the JSON produced by the relational query API
    /// (`query` feature).
    ///
    /// The default unwraps the storage-class tag with
    /// [`decode_projected_sqlite_value`] and calls [`decode`](Self::decode).
    ///
    /// # Errors
    ///
    /// Returns [`DrizzleError::ConversionError`] if the JSON is not a valid
    /// tagged value or [`decode`](Self::decode) rejects it.
    #[cfg(feature = "query")]
    fn decode_json(value: &serde_json::Value) -> Result<Self, DrizzleError> {
        let value = decode_projected_sqlite_value(value)?;
        let value = value.as_value();
        Self::decode(value.as_ref())
    }
}

/// Decodes a tagged cell from the JSON produced by the relational query API.
///
/// Custom column types are projected as
/// `{"$drizzle_storage": <typeof(column)>, "$drizzle_value": <value>}`, with
/// BLOBs as hex strings. Keeping the storage class means a TEXT cell in a
/// BLOB column decodes as TEXT, rather than being read as hex bytes. JSON
/// `null` decodes as [`OwnedSQLiteValue::Null`].
///
/// # Errors
///
/// Returns [`DrizzleError::ConversionError`] if the object or its tags are
/// missing, the storage class is unknown, the value does not match its
/// storage class, or the BLOB hex is invalid.
///
/// # Examples
///
/// ```
/// use drizzle_sqlite::traits::decode_projected_sqlite_value;
/// use drizzle_sqlite::values::OwnedSQLiteValue;
///
/// let cell = serde_json::json!({"$drizzle_storage": "blob", "$drizzle_value": "00ff"});
/// let value = decode_projected_sqlite_value(&cell).unwrap();
/// assert_eq!(value, OwnedSQLiteValue::Blob(vec![0x00, 0xff].into_boxed_slice()));
/// assert!(decode_projected_sqlite_value(&serde_json::json!("00ff")).is_err());
/// ```
#[cfg(feature = "query")]
pub fn decode_projected_sqlite_value(
    value: &serde_json::Value,
) -> Result<OwnedSQLiteValue, DrizzleError> {
    if value.is_null() {
        return Ok(OwnedSQLiteValue::Null);
    }

    let object = value.as_object().ok_or_else(|| {
        DrizzleError::ConversionError("SQLite query value is missing its storage tag".into())
    })?;
    let storage = object
        .get("$drizzle_storage")
        .and_then(serde_json::Value::as_str)
        .ok_or_else(|| {
            DrizzleError::ConversionError("SQLite query value has no valid $drizzle_storage".into())
        })?;
    let value = object.get("$drizzle_value").ok_or_else(|| {
        DrizzleError::ConversionError("SQLite query value has no $drizzle_value".into())
    })?;

    match storage {
        "integer" => value
            .as_i64()
            .map(OwnedSQLiteValue::Integer)
            .ok_or_else(|| {
                DrizzleError::ConversionError(
                    "SQLite INTEGER query value is not a JSON integer".into(),
                )
            }),
        "real" => value.as_f64().map(OwnedSQLiteValue::Real).ok_or_else(|| {
            DrizzleError::ConversionError("SQLite REAL query value is not a JSON number".into())
        }),
        "text" => value
            .as_str()
            .map(|value| OwnedSQLiteValue::Text(value.to_owned()))
            .ok_or_else(|| {
                DrizzleError::ConversionError("SQLite TEXT query value is not a JSON string".into())
            }),
        "blob" => value
            .as_str()
            .ok_or_else(|| {
                DrizzleError::ConversionError("SQLite BLOB query value is not a hex string".into())
            })
            .and_then(decode_projected_blob)
            .map(|value| OwnedSQLiteValue::Blob(value.into_boxed_slice())),
        other => Err(DrizzleError::ConversionError(
            format!("unknown SQLite query storage class `{other}`").into(),
        )),
    }
}

#[cfg(feature = "query")]
fn decode_projected_blob(value: &str) -> Result<Vec<u8>, DrizzleError> {
    let (chunks, remainder) = value.as_bytes().as_chunks::<2>();
    let mut bytes = Vec::with_capacity(value.len() / 2);
    for chunk in chunks {
        let high = decode_hex_nibble(chunk[0])?;
        let low = decode_hex_nibble(chunk[1])?;
        bytes.push((high << 4) | low);
    }
    if !remainder.is_empty() {
        return Err(DrizzleError::ConversionError(
            "hex-encoded SQLite BLOB has odd length".into(),
        ));
    }
    Ok(bytes)
}

#[cfg(feature = "query")]
fn decode_hex_nibble(value: u8) -> Result<u8, DrizzleError> {
    match value {
        b'0'..=b'9' => Ok(value - b'0'),
        b'a'..=b'f' => Ok(value - b'a' + 10),
        b'A'..=b'F' => Ok(value - b'A' + 10),
        _ => Err(DrizzleError::ConversionError(
            "SQLite BLOB query value contains a non-hex byte".into(),
        )),
    }
}

impl<'a, T> From<T> for SQLiteValue<'a>
where
    T: DrizzleSQLiteColumn,
{
    fn from(value: T) -> Self {
        value.encode_owned().into()
    }
}

/// Decodes a Rust value from a `SQLite` value.
///
/// `SQLite` has five storage classes (NULL, INTEGER, REAL, TEXT, BLOB), and
/// this trait has one method per class. Return
/// [`DrizzleError::ConversionError`] from the ones your type does not
/// accept. `NULL` is rejected unless you override
/// [`from_sqlite_null`](Self::from_sqlite_null), as `Option<T>` does.
///
/// Every [`DrizzleSQLiteColumn`] type (including `#[derive(SQLiteEnum)]`
/// enums) gets this trait through a blanket impl, so implement
/// `DrizzleSQLiteColumn` instead when the type is also used as a column.
pub trait FromSQLiteValue: Sized {
    /// Decodes an INTEGER.
    ///
    /// # Errors
    ///
    /// Returns [`DrizzleError::ConversionError`] if `value` cannot be represented as `Self`.
    fn from_sqlite_integer(value: i64) -> Result<Self, DrizzleError>;

    /// Decodes a TEXT value.
    ///
    /// # Errors
    ///
    /// Returns [`DrizzleError::ConversionError`] if `value` cannot be parsed or represented as `Self`.
    fn from_sqlite_text(value: &str) -> Result<Self, DrizzleError>;

    /// Decodes a REAL value.
    ///
    /// # Errors
    ///
    /// Returns [`DrizzleError::ConversionError`] if `value` cannot be represented as `Self`.
    fn from_sqlite_real(value: f64) -> Result<Self, DrizzleError>;

    /// Decodes a BLOB.
    ///
    /// # Errors
    ///
    /// Returns [`DrizzleError::ConversionError`] if `value` cannot be interpreted as `Self`.
    fn from_sqlite_blob(value: &[u8]) -> Result<Self, DrizzleError>;

    /// Decodes any borrowed value by calling the method for its storage
    /// class.
    ///
    /// # Errors
    ///
    /// Returns [`DrizzleError::ConversionError`] if `value` cannot be
    /// represented as `Self`.
    fn from_sqlite_ref(value: SQLiteValueRef<'_>) -> Result<Self, DrizzleError> {
        match value {
            SQLiteValueRef::Integer(value) => Self::from_sqlite_integer(value),
            SQLiteValueRef::Text(value) => Self::from_sqlite_text(value),
            SQLiteValueRef::Real(value) => Self::from_sqlite_real(value),
            SQLiteValueRef::Blob(value) => Self::from_sqlite_blob(value),
            SQLiteValueRef::Null => Self::from_sqlite_null(),
        }
    }

    /// Decodes `NULL`.
    ///
    /// # Errors
    ///
    /// The default implementation always returns [`DrizzleError::ConversionError`];
    /// override for nullable-aware types (e.g. [`Option`]).
    fn from_sqlite_null() -> Result<Self, DrizzleError> {
        Err(DrizzleError::ConversionError(
            "unexpected NULL value".into(),
        ))
    }

    /// Decodes a rusqlite `ValueRef`.
    ///
    /// # Errors
    ///
    /// Returns [`DrizzleError::ConversionError`] if the underlying conversion fails,
    /// including UTF-8 decoding failures for TEXT values.
    #[cfg(feature = "rusqlite")]
    fn from_value_ref(value: ::rusqlite::types::ValueRef<'_>) -> Result<Self, DrizzleError> {
        let value = SQLiteValueRef::try_from_rusqlite_value_ref(value)?;
        Self::from_sqlite_ref(value)
    }
}

impl<T> FromSQLiteValue for T
where
    T: DrizzleSQLiteColumn,
{
    fn from_sqlite_ref(value: SQLiteValueRef<'_>) -> Result<Self, DrizzleError> {
        T::decode(value)
    }

    fn from_sqlite_integer(value: i64) -> Result<Self, DrizzleError> {
        T::decode(SQLiteValueRef::Integer(value))
    }

    fn from_sqlite_text(value: &str) -> Result<Self, DrizzleError> {
        T::decode(SQLiteValueRef::Text(value))
    }

    fn from_sqlite_real(value: f64) -> Result<Self, DrizzleError> {
        T::decode(SQLiteValueRef::Real(value))
    }

    fn from_sqlite_blob(value: &[u8]) -> Result<Self, DrizzleError> {
        T::decode(SQLiteValueRef::Blob(value))
    }

    fn from_sqlite_null() -> Result<Self, DrizzleError> {
        T::decode(SQLiteValueRef::Null)
    }
}

/// A driver row whose columns can be read by position.
///
/// Implemented for `rusqlite::Row`, `libsql::Row` and `turso::Row` when the
/// matching feature is enabled.
pub trait DrizzleRowByIndex {
    /// Reads and decodes the column at `idx` (0-based).
    ///
    /// # Errors
    ///
    /// Returns [`DrizzleError`] if the index is out of range or the column value
    /// cannot be converted to `T`.
    fn get_column<T: FromSQLiteValue>(&self, idx: usize) -> Result<T, DrizzleError>;
}

/// A driver row whose columns can also be read by name.
///
/// Implemented for `rusqlite::Row` and `libsql::Row` when the matching
/// feature is enabled.
pub trait DrizzleRowByName: DrizzleRowByIndex {
    /// Reads and decodes the column called `name`.
    ///
    /// # Errors
    ///
    /// Returns [`DrizzleError`] if the name does not resolve to a column or the
    /// column value cannot be converted to `T`.
    fn get_column_by_name<T: FromSQLiteValue>(&self, name: &str) -> Result<T, DrizzleError>;
}

// =============================================================================
// Primitive implementations
// =============================================================================

/// Macro to implement `FromSQLiteValue` for integer types (handles narrowing conversion from i64)
macro_rules! impl_from_sqlite_value_int {
    // Special case for i64 - no conversion needed
    (i64) => {
        impl FromSQLiteValue for i64 {
            fn from_sqlite_integer(value: i64) -> Result<Self, DrizzleError> {
                Ok(value)
            }

            fn from_sqlite_text(value: &str) -> Result<Self, DrizzleError> {
                value.parse().map_err(|e| {
                    DrizzleError::ConversionError(format!("cannot parse '{}' as i64: {}", value, e).into())
                })
            }

            fn from_sqlite_real(value: f64) -> Result<Self, DrizzleError> {
                checked_float_to_int(value, "i64")
            }

            fn from_sqlite_blob(_value: &[u8]) -> Result<Self, DrizzleError> {
                Err(DrizzleError::ConversionError("cannot convert BLOB to i64".into()))
            }
        }
    };
    // Unsigned 64-bit widths: stored with their bits reinterpreted as i64
    // (see `From<u64> for SQLiteValue`), so a negative INTEGER is a value
    // above `i64::MAX`.
    (unsigned64: $($ty:ty),+ $(,)?) => {
        $(
            impl FromSQLiteValue for $ty {
                fn from_sqlite_integer(value: i64) -> Result<Self, DrizzleError> {
                    unsigned_from_stored_bits(value, stringify!($ty))
                }

                fn from_sqlite_text(value: &str) -> Result<Self, DrizzleError> {
                    value.parse().map_err(|e| {
                        DrizzleError::ConversionError(
                            format!("cannot parse '{}' as {}: {}", value, stringify!($ty), e).into()
                        )
                    })
                }

                fn from_sqlite_real(value: f64) -> Result<Self, DrizzleError> {
                    checked_float_to_int(value, stringify!($ty))
                }

                fn from_sqlite_blob(_value: &[u8]) -> Result<Self, DrizzleError> {
                    Err(DrizzleError::ConversionError(
                        concat!("cannot convert BLOB to ", stringify!($ty)).into()
                    ))
                }
            }
        )+
    };
    // General case for other integer types - uses try_into for narrowing
    ($($ty:ty),+ $(,)?) => {
        $(
            impl FromSQLiteValue for $ty {
                fn from_sqlite_integer(value: i64) -> Result<Self, DrizzleError> {
                    value.try_into().map_err(|e| {
                        DrizzleError::ConversionError(
                            format!("i64 {} out of range for {}: {}", value, stringify!($ty), e).into(),
                        )
                    })
                }

                fn from_sqlite_text(value: &str) -> Result<Self, DrizzleError> {
                    value.parse().map_err(|e| {
                        DrizzleError::ConversionError(
                            format!("cannot parse '{}' as {}: {}", value, stringify!($ty), e).into()
                        )
                    })
                }

                fn from_sqlite_real(value: f64) -> Result<Self, DrizzleError> {
                    checked_float_to_int(value, stringify!($ty))
                }

                fn from_sqlite_blob(_value: &[u8]) -> Result<Self, DrizzleError> {
                    Err(DrizzleError::ConversionError(
                        concat!("cannot convert BLOB to ", stringify!($ty)).into()
                    ))
                }
            }
        )+
    };
}

/// Reads a `u64`/`usize` INTEGER, whose bits were stored reinterpreted as
/// `i64`.
fn unsigned_from_stored_bits<T>(value: i64, name: &str) -> Result<T, DrizzleError>
where
    T: TryFrom<u64>,
    T::Error: core::fmt::Display,
{
    T::try_from(value.cast_unsigned()).map_err(|e| {
        DrizzleError::ConversionError(format!("i64 {value} out of range for {name}: {e}").into())
    })
}

/// IEEE 754 `f64` representation of an `i64` built from two exact halves via
/// [`From`], matching the semantics of `i as f64` without an `as`-cast.
#[inline]
fn i64_to_f64(i: i64) -> f64 {
    let high = i32::try_from(i >> 32).expect("sign-extended high word fits in i32");
    let low = u32::try_from(i & 0xFFFF_FFFF).expect("masked low word fits in u32");
    f64::from(high) * 4_294_967_296.0_f64 + f64::from(low)
}

// Integer types
impl_from_sqlite_value_int!(i64);
impl_from_sqlite_value_int!(i8, i16, i32, isize, u8, u16, u32);
impl_from_sqlite_value_int!(unsigned64: u64, usize);

// f64 — `i64` widening via split-halves is exact in the mantissa range and
// matches direct `as` cast beyond it; no cast is needed for f64→f64.
impl FromSQLiteValue for f64 {
    fn from_sqlite_integer(value: i64) -> Result<Self, DrizzleError> {
        Ok(i64_to_f64(value))
    }

    fn from_sqlite_text(value: &str) -> Result<Self, DrizzleError> {
        value.parse().map_err(|e| {
            DrizzleError::ConversionError(format!("cannot parse '{value}' as f64: {e}").into())
        })
    }

    fn from_sqlite_real(value: f64) -> Result<Self, DrizzleError> {
        Ok(value)
    }

    fn from_sqlite_blob(_value: &[u8]) -> Result<Self, DrizzleError> {
        Err(DrizzleError::ConversionError(
            "cannot convert BLOB to f64".into(),
        ))
    }
}

fn narrow_to_f32(value: f64) -> Result<f32, DrizzleError> {
    // Round-trip through a decimal string so IEEE 754 round-to-nearest is
    // applied explicitly (and clippy doesn't flag the conversion as a lossy
    // numeric cast).
    format!("{value}").parse::<f32>().map_err(|e| {
        DrizzleError::ConversionError(format!("cannot convert REAL {value} to f32: {e}").into())
    })
}

// f32 — narrowing from both `i64` and `f64` is intentionally lossy; SQLite
// round-trips the value through `f64` storage so we defer to the standard
// IEEE 754 narrowing conversion. These casts are the only correct semantics.
impl FromSQLiteValue for f32 {
    fn from_sqlite_integer(value: i64) -> Result<Self, DrizzleError> {
        // Go via f64 (exact) then narrow to f32.
        narrow_to_f32(i64_to_f64(value))
    }

    fn from_sqlite_text(value: &str) -> Result<Self, DrizzleError> {
        value.parse().map_err(|e| {
            DrizzleError::ConversionError(format!("cannot parse '{value}' as f32: {e}").into())
        })
    }

    fn from_sqlite_real(value: f64) -> Result<Self, DrizzleError> {
        narrow_to_f32(value)
    }

    fn from_sqlite_blob(_value: &[u8]) -> Result<Self, DrizzleError> {
        Err(DrizzleError::ConversionError(
            "cannot convert BLOB to f32".into(),
        ))
    }
}

impl FromSQLiteValue for bool {
    fn from_sqlite_integer(value: i64) -> Result<Self, DrizzleError> {
        Ok(value != 0)
    }

    fn from_sqlite_text(value: &str) -> Result<Self, DrizzleError> {
        match value.to_lowercase().as_str() {
            "true" | "1" | "yes" | "on" => Ok(true),
            "false" | "0" | "no" | "off" => Ok(false),
            _ => Err(DrizzleError::ConversionError(
                format!("cannot parse '{value}' as bool").into(),
            )),
        }
    }

    fn from_sqlite_real(value: f64) -> Result<Self, DrizzleError> {
        Ok(value != 0.0)
    }

    fn from_sqlite_blob(_value: &[u8]) -> Result<Self, DrizzleError> {
        Err(DrizzleError::ConversionError(
            "cannot convert BLOB to bool".into(),
        ))
    }
}

impl FromSQLiteValue for String {
    fn from_sqlite_integer(value: i64) -> Result<Self, DrizzleError> {
        Ok(value.to_string())
    }

    fn from_sqlite_text(value: &str) -> Result<Self, DrizzleError> {
        Ok(value.to_string())
    }

    fn from_sqlite_real(value: f64) -> Result<Self, DrizzleError> {
        Ok(value.to_string())
    }

    fn from_sqlite_blob(value: &[u8]) -> Result<Self, DrizzleError> {
        Self::from_utf8(value.to_vec()).map_err(|e| {
            DrizzleError::ConversionError(format!("invalid UTF-8 in BLOB: {e}").into())
        })
    }
}

impl FromSQLiteValue for compact_str::CompactString {
    fn from_sqlite_integer(value: i64) -> Result<Self, DrizzleError> {
        Ok(Self::new(value.to_string()))
    }

    fn from_sqlite_text(value: &str) -> Result<Self, DrizzleError> {
        Ok(Self::new(value))
    }

    fn from_sqlite_real(value: f64) -> Result<Self, DrizzleError> {
        Ok(Self::new(value.to_string()))
    }

    fn from_sqlite_blob(value: &[u8]) -> Result<Self, DrizzleError> {
        let s = String::from_utf8(value.to_vec()).map_err(|e| {
            DrizzleError::ConversionError(format!("invalid UTF-8 in BLOB: {e}").into())
        })?;
        Ok(Self::new(s))
    }
}

impl FromSQLiteValue for Box<String> {
    fn from_sqlite_integer(value: i64) -> Result<Self, DrizzleError> {
        String::from_sqlite_integer(value).map(Self::new)
    }

    fn from_sqlite_text(value: &str) -> Result<Self, DrizzleError> {
        String::from_sqlite_text(value).map(Self::new)
    }

    fn from_sqlite_real(value: f64) -> Result<Self, DrizzleError> {
        String::from_sqlite_real(value).map(Self::new)
    }

    fn from_sqlite_blob(value: &[u8]) -> Result<Self, DrizzleError> {
        String::from_sqlite_blob(value).map(Self::new)
    }
}

impl FromSQLiteValue for Rc<String> {
    fn from_sqlite_integer(value: i64) -> Result<Self, DrizzleError> {
        String::from_sqlite_integer(value).map(Self::new)
    }

    fn from_sqlite_text(value: &str) -> Result<Self, DrizzleError> {
        String::from_sqlite_text(value).map(Self::new)
    }

    fn from_sqlite_real(value: f64) -> Result<Self, DrizzleError> {
        String::from_sqlite_real(value).map(Self::new)
    }

    fn from_sqlite_blob(value: &[u8]) -> Result<Self, DrizzleError> {
        String::from_sqlite_blob(value).map(Self::new)
    }
}

impl FromSQLiteValue for Arc<String> {
    fn from_sqlite_integer(value: i64) -> Result<Self, DrizzleError> {
        String::from_sqlite_integer(value).map(Self::new)
    }

    fn from_sqlite_text(value: &str) -> Result<Self, DrizzleError> {
        String::from_sqlite_text(value).map(Self::new)
    }

    fn from_sqlite_real(value: f64) -> Result<Self, DrizzleError> {
        String::from_sqlite_real(value).map(Self::new)
    }

    fn from_sqlite_blob(value: &[u8]) -> Result<Self, DrizzleError> {
        String::from_sqlite_blob(value).map(Self::new)
    }
}

impl FromSQLiteValue for Box<str> {
    fn from_sqlite_integer(value: i64) -> Result<Self, DrizzleError> {
        String::from_sqlite_integer(value).map(String::into_boxed_str)
    }

    fn from_sqlite_text(value: &str) -> Result<Self, DrizzleError> {
        String::from_sqlite_text(value).map(String::into_boxed_str)
    }

    fn from_sqlite_real(value: f64) -> Result<Self, DrizzleError> {
        String::from_sqlite_real(value).map(String::into_boxed_str)
    }

    fn from_sqlite_blob(value: &[u8]) -> Result<Self, DrizzleError> {
        String::from_sqlite_blob(value).map(String::into_boxed_str)
    }
}

impl FromSQLiteValue for Rc<str> {
    fn from_sqlite_integer(value: i64) -> Result<Self, DrizzleError> {
        String::from_sqlite_integer(value).map(Self::from)
    }

    fn from_sqlite_text(value: &str) -> Result<Self, DrizzleError> {
        String::from_sqlite_text(value).map(Self::from)
    }

    fn from_sqlite_real(value: f64) -> Result<Self, DrizzleError> {
        String::from_sqlite_real(value).map(Self::from)
    }

    fn from_sqlite_blob(value: &[u8]) -> Result<Self, DrizzleError> {
        String::from_sqlite_blob(value).map(Self::from)
    }
}

impl FromSQLiteValue for Arc<str> {
    fn from_sqlite_integer(value: i64) -> Result<Self, DrizzleError> {
        String::from_sqlite_integer(value).map(Self::from)
    }

    fn from_sqlite_text(value: &str) -> Result<Self, DrizzleError> {
        String::from_sqlite_text(value).map(Self::from)
    }

    fn from_sqlite_real(value: f64) -> Result<Self, DrizzleError> {
        String::from_sqlite_real(value).map(Self::from)
    }

    fn from_sqlite_blob(value: &[u8]) -> Result<Self, DrizzleError> {
        String::from_sqlite_blob(value).map(Self::from)
    }
}

impl FromSQLiteValue for Vec<u8> {
    fn from_sqlite_integer(value: i64) -> Result<Self, DrizzleError> {
        Ok(value.to_le_bytes().to_vec())
    }

    fn from_sqlite_text(value: &str) -> Result<Self, DrizzleError> {
        Ok(value.as_bytes().to_vec())
    }

    fn from_sqlite_real(value: f64) -> Result<Self, DrizzleError> {
        Ok(value.to_le_bytes().to_vec())
    }

    fn from_sqlite_blob(value: &[u8]) -> Result<Self, DrizzleError> {
        Ok(value.to_vec())
    }
}

#[cfg(feature = "bytes")]
impl FromSQLiteValue for bytes::Bytes {
    fn from_sqlite_integer(value: i64) -> Result<Self, DrizzleError> {
        Vec::<u8>::from_sqlite_integer(value).map(Self::from)
    }

    fn from_sqlite_text(value: &str) -> Result<Self, DrizzleError> {
        Vec::<u8>::from_sqlite_text(value).map(Self::from)
    }

    fn from_sqlite_real(value: f64) -> Result<Self, DrizzleError> {
        Vec::<u8>::from_sqlite_real(value).map(Self::from)
    }

    fn from_sqlite_blob(value: &[u8]) -> Result<Self, DrizzleError> {
        Ok(Self::copy_from_slice(value))
    }
}

#[cfg(feature = "bytes")]
impl FromSQLiteValue for bytes::BytesMut {
    fn from_sqlite_integer(value: i64) -> Result<Self, DrizzleError> {
        Vec::<u8>::from_sqlite_integer(value).map(|v| Self::from(v.as_slice()))
    }

    fn from_sqlite_text(value: &str) -> Result<Self, DrizzleError> {
        Vec::<u8>::from_sqlite_text(value).map(|v| Self::from(v.as_slice()))
    }

    fn from_sqlite_real(value: f64) -> Result<Self, DrizzleError> {
        Vec::<u8>::from_sqlite_real(value).map(|v| Self::from(v.as_slice()))
    }

    fn from_sqlite_blob(value: &[u8]) -> Result<Self, DrizzleError> {
        Ok(Self::from(value))
    }
}

#[cfg(feature = "smallvec")]
impl<const N: usize> FromSQLiteValue for smallvec::SmallVec<[u8; N]> {
    fn from_sqlite_integer(_value: i64) -> Result<Self, DrizzleError> {
        Err(DrizzleError::ConversionError(
            "cannot convert INTEGER to SmallVec<u8>, use BLOB".into(),
        ))
    }

    fn from_sqlite_text(_value: &str) -> Result<Self, DrizzleError> {
        Err(DrizzleError::ConversionError(
            "cannot convert TEXT to SmallVec<u8>, use BLOB".into(),
        ))
    }

    fn from_sqlite_real(_value: f64) -> Result<Self, DrizzleError> {
        Err(DrizzleError::ConversionError(
            "cannot convert REAL to SmallVec<u8>, use BLOB".into(),
        ))
    }

    fn from_sqlite_blob(value: &[u8]) -> Result<Self, DrizzleError> {
        let mut out = Self::new();
        out.extend_from_slice(value);
        Ok(out)
    }
}

impl FromSQLiteValue for Box<Vec<u8>> {
    fn from_sqlite_integer(value: i64) -> Result<Self, DrizzleError> {
        Vec::<u8>::from_sqlite_integer(value).map(Self::new)
    }

    fn from_sqlite_text(value: &str) -> Result<Self, DrizzleError> {
        Vec::<u8>::from_sqlite_text(value).map(Self::new)
    }

    fn from_sqlite_real(value: f64) -> Result<Self, DrizzleError> {
        Vec::<u8>::from_sqlite_real(value).map(Self::new)
    }

    fn from_sqlite_blob(value: &[u8]) -> Result<Self, DrizzleError> {
        Vec::<u8>::from_sqlite_blob(value).map(Self::new)
    }
}

impl FromSQLiteValue for Rc<Vec<u8>> {
    fn from_sqlite_integer(value: i64) -> Result<Self, DrizzleError> {
        Vec::<u8>::from_sqlite_integer(value).map(Self::new)
    }

    fn from_sqlite_text(value: &str) -> Result<Self, DrizzleError> {
        Vec::<u8>::from_sqlite_text(value).map(Self::new)
    }

    fn from_sqlite_real(value: f64) -> Result<Self, DrizzleError> {
        Vec::<u8>::from_sqlite_real(value).map(Self::new)
    }

    fn from_sqlite_blob(value: &[u8]) -> Result<Self, DrizzleError> {
        Vec::<u8>::from_sqlite_blob(value).map(Self::new)
    }
}

impl FromSQLiteValue for Arc<Vec<u8>> {
    fn from_sqlite_integer(value: i64) -> Result<Self, DrizzleError> {
        Vec::<u8>::from_sqlite_integer(value).map(Self::new)
    }

    fn from_sqlite_text(value: &str) -> Result<Self, DrizzleError> {
        Vec::<u8>::from_sqlite_text(value).map(Self::new)
    }

    fn from_sqlite_real(value: f64) -> Result<Self, DrizzleError> {
        Vec::<u8>::from_sqlite_real(value).map(Self::new)
    }

    fn from_sqlite_blob(value: &[u8]) -> Result<Self, DrizzleError> {
        Vec::<u8>::from_sqlite_blob(value).map(Self::new)
    }
}

// Option<T> implementation - handles NULL values
impl<T: FromSQLiteValue> FromSQLiteValue for Option<T> {
    fn from_sqlite_integer(value: i64) -> Result<Self, DrizzleError> {
        T::from_sqlite_integer(value).map(Some)
    }

    fn from_sqlite_text(value: &str) -> Result<Self, DrizzleError> {
        T::from_sqlite_text(value).map(Some)
    }

    fn from_sqlite_real(value: f64) -> Result<Self, DrizzleError> {
        T::from_sqlite_real(value).map(Some)
    }

    fn from_sqlite_blob(value: &[u8]) -> Result<Self, DrizzleError> {
        T::from_sqlite_blob(value).map(Some)
    }

    fn from_sqlite_null() -> Result<Self, DrizzleError> {
        Ok(None)
    }
}

// =============================================================================
// Driver-specific DrizzleRow implementations
// =============================================================================

#[cfg(feature = "rusqlite")]
impl DrizzleRowByIndex for rusqlite::Row<'_> {
    fn get_column<T: FromSQLiteValue>(&self, idx: usize) -> Result<T, DrizzleError> {
        let value_ref = self.get_ref(idx)?;
        match value_ref {
            rusqlite::types::ValueRef::Integer(i) => T::from_sqlite_integer(i),
            rusqlite::types::ValueRef::Text(s) => {
                let s = core::str::from_utf8(s).map_err(|e| {
                    DrizzleError::ConversionError(format!("invalid UTF-8: {e}").into())
                })?;
                T::from_sqlite_text(s)
            }
            rusqlite::types::ValueRef::Real(r) => T::from_sqlite_real(r),
            rusqlite::types::ValueRef::Blob(b) => T::from_sqlite_blob(b),
            rusqlite::types::ValueRef::Null => T::from_sqlite_null(),
        }
    }
}

#[cfg(feature = "rusqlite")]
impl DrizzleRowByName for rusqlite::Row<'_> {
    fn get_column_by_name<T: FromSQLiteValue>(&self, name: &str) -> Result<T, DrizzleError> {
        let idx = self.as_ref().column_index(name)?;
        DrizzleRowByIndex::get_column(self, idx)
    }
}

#[cfg(feature = "libsql")]
impl DrizzleRowByIndex for libsql::Row {
    fn get_column<T: FromSQLiteValue>(&self, idx: usize) -> Result<T, DrizzleError> {
        let idx_i32 = i32::try_from(idx).map_err(|e| {
            DrizzleError::ConversionError(format!("column index {idx} out of range: {e}").into())
        })?;
        let value = self.get_value(idx_i32)?;
        match value {
            libsql::Value::Integer(i) => T::from_sqlite_integer(i),
            libsql::Value::Text(ref s) => T::from_sqlite_text(s),
            libsql::Value::Real(r) => T::from_sqlite_real(r),
            libsql::Value::Blob(ref b) => T::from_sqlite_blob(b),
            libsql::Value::Null => T::from_sqlite_null(),
        }
    }
}

#[cfg(feature = "libsql")]
impl DrizzleRowByName for libsql::Row {
    fn get_column_by_name<T: FromSQLiteValue>(&self, name: &str) -> Result<T, DrizzleError> {
        let idx = (0..self.column_count())
            .find(|&i| self.column_name(i) == Some(name))
            .ok_or_else(|| {
                DrizzleError::ConversionError(format!("column '{name}' not found").into())
            })?;

        let idx_usize = usize::try_from(idx).map_err(|e| {
            DrizzleError::ConversionError(format!("column index {idx} negative: {e}").into())
        })?;
        DrizzleRowByIndex::get_column(self, idx_usize)
    }
}

#[cfg(feature = "turso")]
impl DrizzleRowByIndex for turso::Row {
    fn get_column<T: FromSQLiteValue>(&self, idx: usize) -> Result<T, DrizzleError> {
        let value = self.get_value(idx)?;
        if value.is_null() {
            T::from_sqlite_null()
        } else if let Some(&i) = value.as_integer() {
            T::from_sqlite_integer(i)
        } else if let Some(s) = value.as_text() {
            T::from_sqlite_text(s)
        } else if let Some(&r) = value.as_real() {
            T::from_sqlite_real(r)
        } else if let Some(b) = value.as_blob() {
            T::from_sqlite_blob(b)
        } else {
            Err(DrizzleError::ConversionError(
                "unknown SQLite value type".into(),
            ))
        }
    }
}

// =============================================================================
// UUID support (when feature enabled)
// =============================================================================

#[cfg(feature = "uuid")]
impl FromSQLiteValue for uuid::Uuid {
    fn from_sqlite_integer(_value: i64) -> Result<Self, DrizzleError> {
        Err(DrizzleError::ConversionError(
            "cannot convert INTEGER to UUID".into(),
        ))
    }

    fn from_sqlite_text(value: &str) -> Result<Self, DrizzleError> {
        Self::parse_str(value).map_err(|e| {
            DrizzleError::ConversionError(format!("invalid UUID string '{value}': {e}").into())
        })
    }

    fn from_sqlite_real(_value: f64) -> Result<Self, DrizzleError> {
        Err(DrizzleError::ConversionError(
            "cannot convert REAL to UUID".into(),
        ))
    }

    fn from_sqlite_blob(value: &[u8]) -> Result<Self, DrizzleError> {
        Self::from_slice(value)
            .map_err(|e| DrizzleError::ConversionError(format!("invalid UUID bytes: {e}").into()))
    }
}

// =============================================================================
// Chrono date/time types (parse from ISO-8601 text)
// =============================================================================

#[cfg(feature = "chrono")]
impl FromSQLiteValue for chrono::NaiveDate {
    fn from_sqlite_integer(_value: i64) -> Result<Self, DrizzleError> {
        Err(DrizzleError::ConversionError(
            "cannot convert INTEGER to NaiveDate".into(),
        ))
    }

    fn from_sqlite_text(value: &str) -> Result<Self, DrizzleError> {
        value.parse().map_err(|e| {
            DrizzleError::ConversionError(
                format!("cannot parse '{value}' as NaiveDate: {e}").into(),
            )
        })
    }

    fn from_sqlite_real(_value: f64) -> Result<Self, DrizzleError> {
        Err(DrizzleError::ConversionError(
            "cannot convert REAL to NaiveDate".into(),
        ))
    }

    fn from_sqlite_blob(_value: &[u8]) -> Result<Self, DrizzleError> {
        Err(DrizzleError::ConversionError(
            "cannot convert BLOB to NaiveDate".into(),
        ))
    }
}

#[cfg(feature = "chrono")]
impl FromSQLiteValue for chrono::NaiveTime {
    fn from_sqlite_integer(_value: i64) -> Result<Self, DrizzleError> {
        Err(DrizzleError::ConversionError(
            "cannot convert INTEGER to NaiveTime".into(),
        ))
    }

    fn from_sqlite_text(value: &str) -> Result<Self, DrizzleError> {
        value.parse().map_err(|e| {
            DrizzleError::ConversionError(
                format!("cannot parse '{value}' as NaiveTime: {e}").into(),
            )
        })
    }

    fn from_sqlite_real(_value: f64) -> Result<Self, DrizzleError> {
        Err(DrizzleError::ConversionError(
            "cannot convert REAL to NaiveTime".into(),
        ))
    }

    fn from_sqlite_blob(_value: &[u8]) -> Result<Self, DrizzleError> {
        Err(DrizzleError::ConversionError(
            "cannot convert BLOB to NaiveTime".into(),
        ))
    }
}

#[cfg(feature = "chrono")]
impl FromSQLiteValue for chrono::NaiveDateTime {
    fn from_sqlite_integer(_value: i64) -> Result<Self, DrizzleError> {
        Err(DrizzleError::ConversionError(
            "cannot convert INTEGER to NaiveDateTime".into(),
        ))
    }

    fn from_sqlite_text(value: &str) -> Result<Self, DrizzleError> {
        chrono_text::naive(value).map_err(|e| {
            DrizzleError::ConversionError(
                format!("cannot parse '{value}' as NaiveDateTime: {e}").into(),
            )
        })
    }

    fn from_sqlite_real(_value: f64) -> Result<Self, DrizzleError> {
        Err(DrizzleError::ConversionError(
            "cannot convert REAL to NaiveDateTime".into(),
        ))
    }

    fn from_sqlite_blob(_value: &[u8]) -> Result<Self, DrizzleError> {
        Err(DrizzleError::ConversionError(
            "cannot convert BLOB to NaiveDateTime".into(),
        ))
    }
}

#[cfg(feature = "chrono")]
impl FromSQLiteValue for chrono::DateTime<chrono::FixedOffset> {
    fn from_sqlite_integer(_value: i64) -> Result<Self, DrizzleError> {
        Err(DrizzleError::ConversionError(
            "cannot convert INTEGER to DateTime<FixedOffset>".into(),
        ))
    }

    fn from_sqlite_text(value: &str) -> Result<Self, DrizzleError> {
        chrono_text::fixed(value).map_err(|e| {
            DrizzleError::ConversionError(
                format!("cannot parse '{value}' as DateTime<FixedOffset>: {e}").into(),
            )
        })
    }

    fn from_sqlite_real(_value: f64) -> Result<Self, DrizzleError> {
        Err(DrizzleError::ConversionError(
            "cannot convert REAL to DateTime<FixedOffset>".into(),
        ))
    }

    fn from_sqlite_blob(_value: &[u8]) -> Result<Self, DrizzleError> {
        Err(DrizzleError::ConversionError(
            "cannot convert BLOB to DateTime<FixedOffset>".into(),
        ))
    }
}

#[cfg(feature = "chrono")]
impl FromSQLiteValue for chrono::DateTime<chrono::Utc> {
    fn from_sqlite_integer(_value: i64) -> Result<Self, DrizzleError> {
        Err(DrizzleError::ConversionError(
            "cannot convert INTEGER to DateTime<Utc>".into(),
        ))
    }

    fn from_sqlite_text(value: &str) -> Result<Self, DrizzleError> {
        chrono_text::utc(value).map_err(|e| {
            DrizzleError::ConversionError(
                format!("cannot parse '{value}' as DateTime<Utc>: {e}").into(),
            )
        })
    }

    fn from_sqlite_real(_value: f64) -> Result<Self, DrizzleError> {
        Err(DrizzleError::ConversionError(
            "cannot convert REAL to DateTime<Utc>".into(),
        ))
    }

    fn from_sqlite_blob(_value: &[u8]) -> Result<Self, DrizzleError> {
        Err(DrizzleError::ConversionError(
            "cannot convert BLOB to DateTime<Utc>".into(),
        ))
    }
}

// =============================================================================
// Text parsers for chrono and time, and the time crate's date/time types
// =============================================================================

/// Parsers for the text chrono values are stored as.
///
/// The SQLite conversions write a `NaiveDateTime` with a space between date
/// and time, as SQLite's own date and time functions do, and chrono's
/// `FromStr` reads only ISO 8601's `T`. Each parser accepts both, and reads a
/// date and time without an offset as UTC.
#[cfg(feature = "chrono")]
pub(crate) mod chrono_text {
    use chrono::{DateTime, FixedOffset, NaiveDateTime, Offset, ParseResult, Utc};

    /// SQLite's `YYYY-MM-DD HH:MM:SS[.fraction]`, or ISO 8601.
    pub(crate) fn naive(text: &str) -> ParseResult<NaiveDateTime> {
        NaiveDateTime::parse_from_str(text, "%Y-%m-%d %H:%M:%S%.f").or_else(|_| text.parse())
    }

    /// RFC 3339, or a date and time without an offset, which is UTC.
    pub(crate) fn fixed(text: &str) -> ParseResult<DateTime<FixedOffset>> {
        DateTime::parse_from_rfc3339(text).or_else(|error| {
            naive(text)
                .map(|value| DateTime::from_naive_utc_and_offset(value, Utc.fix()))
                .map_err(|_| error)
        })
    }

    /// A date and time with an offset, or without one, which is UTC.
    pub(crate) fn utc(text: &str) -> ParseResult<DateTime<Utc>> {
        text.parse().or_else(|error| {
            naive(text)
                .map(|value| DateTime::from_naive_utc_and_offset(value, Utc))
                .map_err(|_| error)
        })
    }
}

/// Parsers for the text `time` values are stored as.
///
/// Each accepts what the SQLite conversions write and the forms SQLite's own
/// date and time functions produce (`HH:MM:SS`, a space between date and time,
/// no offset for UTC).
#[cfg(feature = "time")]
pub(crate) mod time_text {
    use time::format_description::well_known::{Iso8601, Rfc3339};
    use time::macros::format_description;

    /// `HH:MM:SS[.fraction]`. Versions before 0.2.0 wrote ISO 8601's `T`
    /// prefix, which is accepted too.
    pub(crate) fn time(text: &str) -> Result<time::Time, time::error::Parse> {
        let text = text.strip_prefix('T').unwrap_or(text);
        time::Time::parse(
            text,
            format_description!("[hour]:[minute]:[second].[subsecond]"),
        )
        .or_else(|_| time::Time::parse(text, format_description!("[hour]:[minute]:[second]")))
    }

    /// ISO 8601, or SQLite's `YYYY-MM-DD HH:MM:SS[.fraction]`.
    pub(crate) fn primitive(text: &str) -> Result<time::PrimitiveDateTime, time::error::Parse> {
        time::PrimitiveDateTime::parse(text, &Iso8601::DATE_TIME)
            .or_else(|_| {
                time::PrimitiveDateTime::parse(
                    text,
                    format_description!(
                        "[year]-[month]-[day] [hour]:[minute]:[second].[subsecond]"
                    ),
                )
            })
            .or_else(|_| {
                time::PrimitiveDateTime::parse(
                    text,
                    format_description!("[year]-[month]-[day] [hour]:[minute]:[second]"),
                )
            })
    }

    /// RFC 3339, or a date and time without an offset, which is UTC.
    pub(crate) fn offset(text: &str) -> Result<time::OffsetDateTime, time::error::Parse> {
        time::OffsetDateTime::parse(text, &Rfc3339).or_else(|error| {
            primitive(text)
                .map(time::PrimitiveDateTime::assume_utc)
                .map_err(|_| error)
        })
    }
}

#[cfg(feature = "time")]
impl FromSQLiteValue for time::Date {
    fn from_sqlite_integer(_value: i64) -> Result<Self, DrizzleError> {
        Err(DrizzleError::ConversionError(
            "cannot convert INTEGER to time::Date".into(),
        ))
    }

    fn from_sqlite_text(value: &str) -> Result<Self, DrizzleError> {
        Self::parse(value, &time::format_description::well_known::Iso8601::DATE).map_err(|e| {
            DrizzleError::ConversionError(
                format!("cannot parse '{value}' as time::Date: {e}").into(),
            )
        })
    }

    fn from_sqlite_real(_value: f64) -> Result<Self, DrizzleError> {
        Err(DrizzleError::ConversionError(
            "cannot convert REAL to time::Date".into(),
        ))
    }

    fn from_sqlite_blob(_value: &[u8]) -> Result<Self, DrizzleError> {
        Err(DrizzleError::ConversionError(
            "cannot convert BLOB to time::Date".into(),
        ))
    }
}

#[cfg(feature = "time")]
impl FromSQLiteValue for time::Time {
    fn from_sqlite_integer(_value: i64) -> Result<Self, DrizzleError> {
        Err(DrizzleError::ConversionError(
            "cannot convert INTEGER to time::Time".into(),
        ))
    }

    fn from_sqlite_text(value: &str) -> Result<Self, DrizzleError> {
        time_text::time(value).map_err(|e| {
            DrizzleError::ConversionError(
                format!("cannot parse '{value}' as time::Time: {e}").into(),
            )
        })
    }

    fn from_sqlite_real(_value: f64) -> Result<Self, DrizzleError> {
        Err(DrizzleError::ConversionError(
            "cannot convert REAL to time::Time".into(),
        ))
    }

    fn from_sqlite_blob(_value: &[u8]) -> Result<Self, DrizzleError> {
        Err(DrizzleError::ConversionError(
            "cannot convert BLOB to time::Time".into(),
        ))
    }
}

#[cfg(feature = "time")]
impl FromSQLiteValue for time::PrimitiveDateTime {
    fn from_sqlite_integer(_value: i64) -> Result<Self, DrizzleError> {
        Err(DrizzleError::ConversionError(
            "cannot convert INTEGER to time::PrimitiveDateTime".into(),
        ))
    }

    fn from_sqlite_text(value: &str) -> Result<Self, DrizzleError> {
        time_text::primitive(value).map_err(|e| {
            DrizzleError::ConversionError(
                format!("cannot parse '{value}' as time::PrimitiveDateTime: {e}").into(),
            )
        })
    }

    fn from_sqlite_real(_value: f64) -> Result<Self, DrizzleError> {
        Err(DrizzleError::ConversionError(
            "cannot convert REAL to time::PrimitiveDateTime".into(),
        ))
    }

    fn from_sqlite_blob(_value: &[u8]) -> Result<Self, DrizzleError> {
        Err(DrizzleError::ConversionError(
            "cannot convert BLOB to time::PrimitiveDateTime".into(),
        ))
    }
}

#[cfg(feature = "time")]
impl FromSQLiteValue for time::OffsetDateTime {
    fn from_sqlite_integer(_value: i64) -> Result<Self, DrizzleError> {
        Err(DrizzleError::ConversionError(
            "cannot convert INTEGER to time::OffsetDateTime".into(),
        ))
    }

    fn from_sqlite_text(value: &str) -> Result<Self, DrizzleError> {
        time_text::offset(value).map_err(|e| {
            DrizzleError::ConversionError(
                format!("cannot parse '{value}' as time::OffsetDateTime: {e}").into(),
            )
        })
    }

    fn from_sqlite_real(_value: f64) -> Result<Self, DrizzleError> {
        Err(DrizzleError::ConversionError(
            "cannot convert REAL to time::OffsetDateTime".into(),
        ))
    }

    fn from_sqlite_blob(_value: &[u8]) -> Result<Self, DrizzleError> {
        Err(DrizzleError::ConversionError(
            "cannot convert BLOB to time::OffsetDateTime".into(),
        ))
    }
}

// =============================================================================
// jiff (parse from ISO 8601 text)
// =============================================================================

/// Parses SQLite text as the jiff value named `name`.
#[cfg(feature = "jiff")]
fn parse_jiff<T: core::str::FromStr<Err = jiff::Error>>(
    value: &str,
    name: &str,
) -> Result<T, DrizzleError> {
    value.parse().map_err(|e: jiff::Error| {
        DrizzleError::ConversionError(format!("cannot parse '{value}' as {name}: {e}").into())
    })
}

/// Implements [`FromSQLiteValue`] for jiff types, which SQLite stores as text.
#[cfg(feature = "jiff")]
macro_rules! impl_from_sqlite_value_jiff {
    ($($ty:ty => $name:literal, $parse:expr;)+) => {$(
        impl FromSQLiteValue for $ty {
            fn from_sqlite_integer(_value: i64) -> Result<Self, DrizzleError> {
                Err(DrizzleError::ConversionError(
                    concat!("cannot convert INTEGER to ", $name).into(),
                ))
            }

            fn from_sqlite_text(value: &str) -> Result<Self, DrizzleError> {
                $parse(value)
            }

            fn from_sqlite_real(_value: f64) -> Result<Self, DrizzleError> {
                Err(DrizzleError::ConversionError(
                    concat!("cannot convert REAL to ", $name).into(),
                ))
            }

            fn from_sqlite_blob(_value: &[u8]) -> Result<Self, DrizzleError> {
                Err(DrizzleError::ConversionError(
                    concat!("cannot convert BLOB to ", $name).into(),
                ))
            }
        }
    )+};
}

#[cfg(feature = "jiff")]
impl_from_sqlite_value_jiff! {
    jiff::civil::Date => "jiff::civil::Date",
        |value| parse_jiff(value, "jiff::civil::Date");
    jiff::civil::Time => "jiff::civil::Time",
        |value| parse_jiff(value, "jiff::civil::Time");
    jiff::civil::DateTime => "jiff::civil::DateTime",
        |value| parse_jiff(value, "jiff::civil::DateTime");
    // RFC 3339 as the conversion writes it; text without an offset (as
    // SQLite's own `CURRENT_TIMESTAMP` writes) is UTC.
    jiff::Timestamp => "jiff::Timestamp", |value: &str| {
        value.parse().or_else(|_| {
            let civil: jiff::civil::DateTime = parse_jiff(value, "jiff::Timestamp")?;
            jiff::tz::Offset::UTC.to_timestamp(civil).map_err(|e| {
                DrizzleError::ConversionError(
                    format!("cannot convert '{value}' to jiff::Timestamp: {e}").into(),
                )
            })
        })
    };
}

// =============================================================================
// Decimal (parse from text)
// =============================================================================

#[cfg(feature = "rust-decimal")]
impl FromSQLiteValue for rust_decimal::Decimal {
    fn from_sqlite_integer(value: i64) -> Result<Self, DrizzleError> {
        Ok(Self::from(value))
    }

    fn from_sqlite_text(value: &str) -> Result<Self, DrizzleError> {
        value.parse().map_err(|e| {
            DrizzleError::ConversionError(format!("cannot parse '{value}' as Decimal: {e}").into())
        })
    }

    fn from_sqlite_real(value: f64) -> Result<Self, DrizzleError> {
        Self::try_from(value).map_err(|e| {
            DrizzleError::ConversionError(
                format!("cannot convert REAL {value} to Decimal: {e}").into(),
            )
        })
    }

    fn from_sqlite_blob(_value: &[u8]) -> Result<Self, DrizzleError> {
        Err(DrizzleError::ConversionError(
            "cannot convert BLOB to Decimal".into(),
        ))
    }
}

// =============================================================================
// Duration types
// =============================================================================

#[cfg(feature = "chrono")]
impl FromSQLiteValue for chrono::Duration {
    fn from_sqlite_integer(value: i64) -> Result<Self, DrizzleError> {
        Ok(Self::seconds(value))
    }

    fn from_sqlite_text(value: &str) -> Result<Self, DrizzleError> {
        let error = || {
            DrizzleError::ConversionError(
                format!("cannot parse '{value}' as chrono::Duration").into(),
            )
        };
        let (negative, secs, nanos) = crate::values::duration::parse(value).ok_or_else(error)?;
        let secs = i64::try_from(secs).map_err(|_| error())?;
        let duration = Self::new(secs, nanos).ok_or_else(error)?;
        Ok(if negative { -duration } else { duration })
    }

    fn from_sqlite_real(value: f64) -> Result<Self, DrizzleError> {
        let millis: i64 = format!("{:.0}", value * 1000.0).parse().map_err(|e| {
            DrizzleError::ConversionError(
                format!("cannot convert REAL {value} to chrono::Duration: {e}").into(),
            )
        })?;
        Ok(Self::milliseconds(millis))
    }

    fn from_sqlite_blob(_value: &[u8]) -> Result<Self, DrizzleError> {
        Err(DrizzleError::ConversionError(
            "cannot convert BLOB to chrono::Duration".into(),
        ))
    }
}

#[cfg(feature = "time")]
impl FromSQLiteValue for time::Duration {
    fn from_sqlite_integer(value: i64) -> Result<Self, DrizzleError> {
        Ok(Self::seconds(value))
    }

    fn from_sqlite_text(value: &str) -> Result<Self, DrizzleError> {
        let error = || {
            DrizzleError::ConversionError(
                format!("cannot parse '{value}' as time::Duration").into(),
            )
        };
        let (negative, secs, nanos) = crate::values::duration::parse(value).ok_or_else(error)?;
        let secs = i64::try_from(secs).map_err(|_| error())?;
        // `nanos` is below 1_000_000_000, so it always fits in an i32.
        let duration = Self::new(secs, nanos as i32);
        Ok(if negative { -duration } else { duration })
    }

    fn from_sqlite_real(value: f64) -> Result<Self, DrizzleError> {
        Ok(Self::seconds_f64(value))
    }

    fn from_sqlite_blob(_value: &[u8]) -> Result<Self, DrizzleError> {
        Err(DrizzleError::ConversionError(
            "cannot convert BLOB to time::Duration".into(),
        ))
    }
}

// =============================================================================
// JSON support (serde_json::Value)
// =============================================================================

#[cfg(feature = "serde")]
impl FromSQLiteValue for serde_json::Value {
    fn from_sqlite_integer(value: i64) -> Result<Self, DrizzleError> {
        Ok(Self::Number(value.into()))
    }

    fn from_sqlite_text(value: &str) -> Result<Self, DrizzleError> {
        serde_json::from_str(value).map_err(|e| {
            DrizzleError::ConversionError(format!("cannot parse '{value}' as JSON: {e}").into())
        })
    }

    fn from_sqlite_real(value: f64) -> Result<Self, DrizzleError> {
        serde_json::Number::from_f64(value)
            .map(serde_json::Value::Number)
            .ok_or_else(|| {
                DrizzleError::ConversionError(
                    format!("cannot convert non-finite REAL {value} to JSON").into(),
                )
            })
    }

    fn from_sqlite_blob(value: &[u8]) -> Result<Self, DrizzleError> {
        serde_json::from_slice(value).map_err(|e| {
            DrizzleError::ConversionError(format!("cannot parse BLOB as JSON: {e}").into())
        })
    }
}

// =============================================================================
// ArrayVec/ArrayString support
// =============================================================================

#[cfg(feature = "arrayvec")]
impl<const N: usize> FromSQLiteValue for arrayvec::ArrayString<N> {
    fn from_sqlite_integer(value: i64) -> Result<Self, DrizzleError> {
        let s = value.to_string();
        Self::from(&s).map_err(|_| {
            DrizzleError::ConversionError(
                format!(
                    "String length {} exceeds ArrayString capacity {}",
                    s.len(),
                    N
                )
                .into(),
            )
        })
    }

    fn from_sqlite_text(value: &str) -> Result<Self, DrizzleError> {
        Self::from(value).map_err(|_| {
            DrizzleError::ConversionError(
                format!(
                    "Text length {} exceeds ArrayString capacity {}",
                    value.len(),
                    N
                )
                .into(),
            )
        })
    }

    fn from_sqlite_real(value: f64) -> Result<Self, DrizzleError> {
        let s = value.to_string();
        Self::from(&s).map_err(|_| {
            DrizzleError::ConversionError(
                format!(
                    "String length {} exceeds ArrayString capacity {}",
                    s.len(),
                    N
                )
                .into(),
            )
        })
    }

    fn from_sqlite_blob(value: &[u8]) -> Result<Self, DrizzleError> {
        let s = String::from_utf8(value.to_vec())
            .map_err(|e| DrizzleError::ConversionError(format!("invalid UTF-8: {e}").into()))?;
        Self::from(&s).map_err(|_| {
            DrizzleError::ConversionError(
                format!(
                    "String length {} exceeds ArrayString capacity {}",
                    s.len(),
                    N
                )
                .into(),
            )
        })
    }
}

#[cfg(feature = "arrayvec")]
impl<const N: usize> FromSQLiteValue for arrayvec::ArrayVec<u8, N> {
    fn from_sqlite_integer(_value: i64) -> Result<Self, DrizzleError> {
        Err(DrizzleError::ConversionError(
            "cannot convert INTEGER to ArrayVec<u8>, use BLOB".into(),
        ))
    }

    fn from_sqlite_text(_value: &str) -> Result<Self, DrizzleError> {
        Err(DrizzleError::ConversionError(
            "cannot convert TEXT to ArrayVec<u8>, use BLOB".into(),
        ))
    }

    fn from_sqlite_real(_value: f64) -> Result<Self, DrizzleError> {
        Err(DrizzleError::ConversionError(
            "cannot convert REAL to ArrayVec<u8>, use BLOB".into(),
        ))
    }

    fn from_sqlite_blob(value: &[u8]) -> Result<Self, DrizzleError> {
        Self::try_from(value).map_err(|_| {
            DrizzleError::ConversionError(
                format!(
                    "Blob length {} exceeds ArrayVec capacity {}",
                    value.len(),
                    N
                )
                .into(),
            )
        })
    }
}