Crate chain_builder 

Chain Builder

A typed, dialect-aware SQL query builder for Rust.

Generic over a Dialect (PostgreSQL / MySQL / SQLite), with typed bind parameters via IntoBind, dialect-correct placeholders ($N for Postgres, ? for MySQL/SQLite), automatic identifier escaping, and an optional sqlx handoff for execution.

Example

use chain_builder::{QueryBuilder, Postgres, Order};

let (sql, binds) = QueryBuilder::<Postgres>::table("users")
    .db("mydb")                       // multi-tenant: one connection, many DBs
    .select(["id", "name"])
    .where_eq("status", "active")
    .where_in("role", ["admin", "staff"])
    .order_by("name", Order::Desc)
    .paginate(2, 20)
    .to_sql();

assert!(sql.starts_with(r#"SELECT "id", "name" FROM "mydb"."users""#));
assert_eq!(binds.len(), 5); // active, admin, staff, limit, offset

With a dialect’s sqlx_* feature enabled, QueryBuilder::to_sqlx_query and the fetch_* helpers turn a builder into a ready-to-execute sqlx query.

Re-exports

pub use builder::ConflictAction;

pub use builder::Cte;

pub use builder::Having;

pub use builder::Join;

pub use builder::JoinClause;

pub use builder::JoinCond;

pub use builder::JoinKind;

pub use builder::Method;

pub use builder::OnConflict;

pub use builder::Order;

pub use builder::QueryBuilder;

pub use compile::compile;

pub use dialect::Dialect;

pub use dialect::MySql;

pub use dialect::Postgres;

pub use dialect::Sqlite;

pub use dialect::UpsertStyle;

pub use value::IntoBind;

pub use value::Value;

pub use where_::Conj;

pub use where_::Predicate;

pub use where_::WhereBuilder;

pub use sqlx_bind::SqlxDialect;

Modules

builder

Typed, dialect-aware query builder.

compile

SQL compilation: turn a QueryBuilder into (sql, binds).

dialect

SQL dialect markers and the Dialect trait.

fetch

Typed fetch / execution helpers for v2 (feature = "sqlx_*").

ident

Dialect-aware SQL identifier escaping.

sqlx_bind

sqlx handoff for v2 (feature = "sqlx_*").

value

Bound value model for v2.

where_

WHERE-clause predicate model and the nested-group accumulator.