Struct SQL 

pub struct SQL<'a, V>
where
    V: SQLParam,
{
    pub chunks: SmallVec<[SQLChunk<'a, V>; 8]>,
}

SQL fragment builder with flat chunk storage.

Uses SmallVec<[SQLChunk; 8]> for inline storage of typical SQL fragments without heap allocation.

Fields

chunks: SmallVec<[SQLChunk<'a, V>; 8]>

Implementations

impl<'a, V> SQL<'a, V>

where V: SQLParam,

pub const fn empty() -> SQL<'a, V>

Creates an empty SQL fragment

pub fn token(t: Token) -> SQL<'a, V>

Creates SQL with a single token

pub fn with_capacity_chunks(capacity: usize) -> SQL<'a, V>

Creates an empty SQL fragment with pre-allocated chunk capacity.

pub fn ident(name: impl Into<Cow<'a, str>>) -> SQL<'a, V>

Creates SQL with a quoted identifier

pub fn raw(text: impl Into<Cow<'a, str>>) -> SQL<'a, V>

Creates SQL with raw text (unquoted)

pub fn param(value: impl Into<Cow<'a, V>>) -> SQL<'a, V>

Creates SQL with a single parameter value

pub fn bytes(bytes: impl Into<Cow<'a, [u8]>>) -> SQL<'a, V>

where V: From<&'a [u8]> + From<Vec<u8>> + Into<Cow<'a, V>>,

Creates SQL with a binary parameter value (BLOB/bytea)

Prefer this over SQL::param(Vec<u8>) to avoid list semantics.

pub fn placeholder(name: &'static str) -> SQL<'a, V>

Creates SQL with a named placeholder (no value, for prepared statements)

pub fn table(table: &'static dyn SQLTableInfo) -> SQL<'a, V>

Creates SQL referencing a table

pub fn column(column: &'static dyn SQLColumnInfo) -> SQL<'a, V>

Creates SQL referencing a column

pub fn func(name: &'static str, args: SQL<'a, V>) -> SQL<'a, V>

Creates SQL for a function call: NAME(args) Subqueries are automatically wrapped in parentheses: NAME((SELECT …))

pub fn append(self, other: impl Into<SQL<'a, V>>) -> SQL<'a, V>

Append another SQL fragment (flat extend)

pub fn push(self, chunk: impl Into<SQLChunk<'a, V>>) -> SQL<'a, V>

Push a single chunk

pub fn with_capacity(self, additional: usize) -> SQL<'a, V>

Pre-allocates capacity for additional chunks

pub fn join<T>(sqls: T, separator: Token) -> SQL<'a, V>

where T: IntoIterator, <T as IntoIterator>::Item: ToSQL<'a, V>,

Joins multiple SQL fragments with a separator

pub fn parens(self) -> SQL<'a, V>

Wrap in parentheses: (self)

pub fn is_subquery(&self) -> bool

Check if this SQL fragment is a subquery (starts with SELECT)

pub fn alias(self, name: impl Into<Cow<'a, str>>) -> SQL<'a, V>

Creates an aliased version: self AS “name”

pub fn param_list<I>(values: I) -> SQL<'a, V>

where I: IntoIterator, <I as IntoIterator>::Item: Into<Cow<'a, V>>,

Creates a comma-separated list of parameters

pub fn assignments<I, T>(pairs: I) -> SQL<'a, V>

where I: IntoIterator<Item = (&'static str, T)>, T: Into<Cow<'a, V>>,

Creates a comma-separated list of column assignments: “col” = ?

pub fn into_owned(self) -> OwnedSQL<V>

Converts to owned version (consuming self to avoid clone)

pub fn sql(&self) -> String

Returns the SQL string with dialect-appropriate placeholders Uses $1, $2, ... for PostgreSQL, ? for SQLite/MySQL

pub fn write_to(&self, buf: &mut impl Write)

Write SQL to a buffer with dialect-appropriate placeholders Uses $1, $2, ... for PostgreSQL, ? or :name for SQLite, ? for MySQL Named placeholders use :name syntax only for SQLite; PostgreSQL always uses $N

pub fn write_chunk_to( &self, buf: &mut impl Write, chunk: &SQLChunk<'a, V>, index: usize, )

Write a single chunk with pattern detection

pub fn write_qualified_columns( &self, buf: &mut impl Write, table: &(dyn SQLTableInfo + 'static), )

Write fully qualified columns

pub fn params(&self) -> impl Iterator<Item = &V>

Returns an iterator over references to parameter values (avoids allocating a Vec - callers can collect if needed)

pub fn bind<T>( self, params: impl IntoIterator>>, ) -> SQL<'a, V>

where T: SQLParam + Into<V>, <impl IntoIterator as IntoIterator>::Item: Into<ParamBind<'a, T>>,

Bind named parameters

Trait Implementations

impl<'a, V> AsRef<SQL<'a, V>> for SQL<'a, V>

where V: SQLParam + 'a,

fn as_ref(&self) -> &SQL<'a, V>

Converts this type into a shared reference of the (usually inferred) input type.

impl<'a, V> Clone for SQL<'a, V>

where V: Clone + SQLParam,

fn clone(&self) -> SQL<'a, V>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, V> Debug for SQL<'a, V>

where V: Debug + SQLParam,

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

Formats the value using the given formatter.

impl<'a, V> Default for SQL<'a, V>

where V: SQLParam,

fn default() -> SQL<'a, V>

Returns the “default value” for a type.

impl<'a, V> Display for SQL<'a, V>

where V: SQLParam + Display,

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

Formats the value using the given formatter.

impl<'a, V> Expr<'a, V> for SQL<'a, V>

where V: SQLParam + 'a,

type SQLType = Any

The SQL data type this expression evaluates to.

type Nullable = Null

Whether this expression can be NULL.

type Aggregate = Scalar

Whether this is an aggregate (COUNT, SUM) or scalar expression.

impl<'a, T, V> From<&T> for SQL<'a, V>

where T: ToSQL<'a, V>, V: SQLParam,

fn from(value: &T) -> SQL<'a, V>

Converts to this type from the input type.

impl<'a, V> From<&'a str> for SQL<'a, V>

where V: SQLParam + 'a,

fn from(s: &'a str) -> SQL<'a, V>

Converts to this type from the input type.

impl<'a> From<OwnedPostgresValue> for SQL<'a, OwnedPostgresValue>

fn from(value: OwnedPostgresValue) -> Self

Converts to this type from the input type.

impl<'a> From<PostgresValue<'a>> for SQL<'a, PostgresValue<'a>>

fn from(value: PostgresValue<'a>) -> Self

Converts to this type from the input type.

impl<'a, V, T, N, A> From<SQLExpr<'a, V, T, N, A>> for SQL<'a, V>

where V: SQLParam, T: DataType, N: Nullability, A: AggregateKind,

fn from(expr: SQLExpr<'a, V, T, N, A>) -> SQL<'a, V>

Converts to this type from the input type.

impl<'a, V> From<Token> for SQL<'a, V>

where V: SQLParam,

fn from(value: Token) -> SQL<'a, V>

Converts to this type from the input type.

impl<'a, V, T> FromIterator<T> for SQL<'a, V>

where V: SQLParam, SQLChunk<'a, V>: From<T>,

fn from_iter<I>(iter: I) -> SQL<'a, V>

where I: IntoIterator<Item = T>,

Creates a value from an iterator.

impl<'a, V> IntoIterator for SQL<'a, V>

where V: SQLParam,

type Item = SQLChunk<'a, V>

The type of the elements being iterated over.

type IntoIter = IntoIter<[SQLChunk<'a, V>; 8]>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <SQL<'a, V> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, V> ToSQL<'a, V> for SQL<'a, V>

where V: SQLParam + 'a,

fn to_sql(&self) -> SQL<'a, V>

fn alias(&self, alias: &'static str) -> SQL<'a, V>