Enum DatabaseType 

pub enum DatabaseType {
    PostgreSQL,
    MySQL,
    SQLite,
    SQLServer,
}

Database types supported by FraiseQL.

Stability

This enum is intentionally not #[non_exhaustive]. All match sites in the codebase must handle every variant explicitly, giving compile-time assurance that new database backends are fully integrated before release.

Adding a new variant is a semver-breaking change (minor version bump with migration guide), because downstream exhaustive match expressions will fail to compile. If you match on DatabaseType and want forward compatibility, add a wildcard arm:

match db_type {
    DatabaseType::PostgreSQL => { /* ... */ }
    DatabaseType::MySQL      => { /* ... */ }
    DatabaseType::SQLite     => { /* ... */ }
    DatabaseType::SQLServer  => { /* ... */ }
    // no wildcard needed — exhaustive by design
}

Variants

PostgreSQL

PostgreSQL database (primary, full feature set).

MySQL

MySQL database (secondary support).

SQLite

SQLite database (local dev, testing).

SQLServer

SQL Server database (enterprise).

Implementations

impl DatabaseType

pub fn json_field_expr(self, key: &str) -> String

Return a SQL expression that extracts a text value from the data JSONB column.

The key must already be validated via OrderByClause::validate_field_name and converted to snake_case storage form via OrderByClause::storage_key.

Examples

use fraiseql_db::DatabaseType;

assert_eq!(DatabaseType::PostgreSQL.json_field_expr("created_at"), "data->>'created_at'");
assert_eq!(DatabaseType::MySQL.json_field_expr("name"), "JSON_UNQUOTE(JSON_EXTRACT(data, '$.name'))");

pub fn typed_json_field_expr( self, key: &str, field_type: OrderByFieldType, ) -> String

Return a SQL expression that extracts and casts a value from the data JSONB column for ORDER BY sorting.

When field_type is OrderByFieldType::Text this is identical to json_field_expr. For numeric, date, and boolean types the expression is wrapped in a dialect-specific cast so the database sorts by the typed value instead of the raw text ("9" > "10" is wrong for numbers).

Examples

use fraiseql_db::{DatabaseType, OrderByFieldType};

assert_eq!(
    DatabaseType::PostgreSQL.typed_json_field_expr("amount", OrderByFieldType::Numeric),
    "(data->>'amount')::numeric"
);
assert_eq!(
    DatabaseType::MySQL.typed_json_field_expr("amount", OrderByFieldType::Numeric),
    "CAST(JSON_UNQUOTE(JSON_EXTRACT(data, '$.amount')) AS DECIMAL(38,12))"
);

pub const fn supports(self, feature: Feature) -> bool

Check whether this dialect supports feature.

All checks are const-friendly and zero-cost at runtime.

pub const fn suggestion_for(self, feature: Feature) -> Option<&'static str>

Return a human-readable migration suggestion for an unsupported feature.

None means no specific guidance is available beyond the error message.

impl DatabaseType

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

Get database type as string.

Trait Implementations

impl Clone for DatabaseType

fn clone(&self) -> DatabaseType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DatabaseType

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DatabaseType

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for DatabaseType

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

Formats the value using the given formatter.

impl Hash for DatabaseType

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 DatabaseType

fn eq(&self, other: &DatabaseType) -> 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 Serialize for DatabaseType

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for DatabaseType

impl Eq for DatabaseType

impl StructuralPartialEq for DatabaseType