Struct GenericWhereGenerator 

pub struct GenericWhereGenerator<D>
where
    D: SqlDialect,
{ /* private fields */ }

Generic WHERE clause SQL generator.

Replaces PostgresWhereGenerator, MySqlWhereGenerator, SqliteWhereGenerator, and SqlServerWhereGenerator — all dialect-specific primitives are delegated to D: SqlDialect.

Interior mutability

The parameter counter uses Cell<usize> (via ParamCounter). This is safe because:

• GenericWhereGenerator is not Sync — no concurrent access is possible.
• generate() resets the counter before every call.

Example

use fraiseql_db::dialect::PostgresDialect;
use fraiseql_db::where_generator::GenericWhereGenerator;
use fraiseql_db::{WhereClause, WhereOperator};
use serde_json::json;

let gen = GenericWhereGenerator::new(PostgresDialect);
let clause = WhereClause::Field {
    path: vec!["email".to_string()],
    operator: WhereOperator::Eq,
    value: json!("alice@example.com"),
};
let (sql, params) = gen.generate(&clause).unwrap();
assert_eq!(sql, "data->>'email' = $1");

Implementations

impl<D> GenericWhereGenerator<D>

where D: SqlDialect,

pub const fn new(dialect: D) -> GenericWhereGenerator<D>

Create a new generator for the given dialect.

pub fn generate( &self, clause: &WhereClause, ) -> Result<(String, Vec<Value>), FraiseQLError>

Generate SQL WHERE clause starting parameter numbering at 1.

Errors

Returns FraiseQLError::Validation if the clause uses an operator not supported by the dialect.

pub fn generate_with_param_offset( &self, clause: &WhereClause, offset: usize, ) -> Result<(String, Vec<Value>), FraiseQLError>

Generate SQL WHERE clause with parameter numbering starting after offset.

Use when the WHERE clause is appended to a query that already has bound parameters (e.g. cursor values in relay pagination).

Errors

Returns FraiseQLError::Validation if the clause uses an unsupported operator.

impl GenericWhereGenerator<PostgresDialect>

Constructor compatibility shim for PostgresWhereGenerator.

This impl block exposes the new() constructor the old concrete struct had.

pub const fn postgres_new() -> GenericWhereGenerator<PostgresDialect>

Create a new PostgreSQL WHERE generator.

Trait Implementations

impl<D> Default for GenericWhereGenerator<D>

where D: SqlDialect + Default,

fn default() -> GenericWhereGenerator<D>

Returns the “default value” for a type.