Struct SQL 

pub struct SQL<'a, 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: SQLParam> SQL<'a, V>

pub const fn empty() -> Self

Creates an empty SQL fragment

pub const fn raw_const(text: &'static str) -> Self

Creates SQL with raw text at const time.

pub fn token(t: Token) -> Self

Creates SQL with a single token

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

Creates SQL with a quoted identifier

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

Creates SQL with raw text (unquoted)

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

Creates SQL with a single parameter value

pub fn placeholder(name: &'static str) -> Self

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

pub fn table(table: &'static dyn SQLTableInfo) -> Self

Creates SQL referencing a table

pub fn column(column: &'static dyn SQLColumnInfo) -> Self

Creates SQL referencing a column

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

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

Append another SQL fragment (flat extend)

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

Push a single chunk

pub fn with_capacity(self, additional: usize) -> Self

Pre-allocates capacity for additional chunks

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

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

Joins multiple SQL fragments with a separator

pub fn parens(self) -> Self

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

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

Creates a comma-separated list of parameters

pub fn assignments<I, T>(pairs: I) -> Self

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>

pub fn sql(&self) -> String

Returns the SQL string

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

Write SQL to a buffer

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

Write fully qualified columns

pub fn params(&self) -> Vec<&V>

Returns references to parameter values

pub fn bind<T: SQLParam + Into<V>>( self, params: impl IntoIterator<Item: Into<ParamBind<'a, T>>>, ) -> SQL<'a, V>

Bind named parameters

Trait Implementations

impl<'a, V: SQLParam + 'a> AsRef<SQL<'a, V>> for SQL<'a, V>

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

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

impl<'a, V: Clone + SQLParam> Clone for SQL<'a, V>

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 + SQLParam> Debug for SQL<'a, V>

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

Formats the value using the given formatter.

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

fn default() -> Self

Returns the “default value” for a type.

impl<'a, V: SQLParam + Display> Display for SQL<'a, V>

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

Formats the value using the given formatter.

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

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

fn from(value: &T) -> Self

Converts to this type from the input type.

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

fn from(s: &'a str) -> Self

Converts to this type from the input type.

impl<'a, V: SQLParam> From<SQL<'a, V>> for OwnedSQL<V>

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

Converts to this type from the input type.

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

fn from(value: Token) -> Self

Converts to this type from the input type.

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

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

fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self

Creates a value from an iterator.

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

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) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, V: SQLParam + 'a> ToSQL<'a, V> for SQL<'a, V>

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

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