Struct GenericWhereGenerator 

pub struct GenericWhereGenerator<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: SqlDialect> GenericWhereGenerator<D>

pub const fn new(dialect: D) -> Self

Create a new generator for the given dialect.

pub fn with_indexed_columns(self, cols: Arc<HashSet<String>>) -> Self

Attach an indexed-columns set (PostgreSQL optimisation).

When a WHERE path matches a column name in this set, the generator emits "col_name" = $N instead of data->>'col_name' = $N.

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

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>)>

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.

These impl blocks expose the same new() / with_indexed_columns() constructors that the old concrete struct had.

pub const fn postgres_new() -> Self

Create a new PostgreSQL WHERE generator.

pub fn postgres_with_indexed_columns( indexed_columns: Arc<HashSet<String>>, ) -> Self

Create a new PostgreSQL WHERE generator with indexed columns for a view.

When indexed columns are provided, the generator uses them instead of JSONB extraction for nested paths that have corresponding indexed columns.

Arguments

• indexed_columns - Set of indexed column names for the current view

Example

use fraiseql_db::postgres::PostgresWhereGenerator;
use std::collections::HashSet;
use std::sync::Arc;

let mut columns = HashSet::new();
columns.insert("items__product__category__code".to_string());
let generator = PostgresWhereGenerator::postgres_with_indexed_columns(Arc::new(columns));

Trait Implementations

impl<D: SqlDialect + Default> Default for GenericWhereGenerator<D>

fn default() -> Self

Returns the “default value” for a type.

impl<D: SqlDialect> ExtendedOperatorHandler for GenericWhereGenerator<D>

fn generate_extended_sql( &self, operator: &ExtendedOperator, field_sql: &str, params: &mut Vec<Value>, ) -> Result<String>

Generate database-specific SQL for an extended operator.