Struct SQL 

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

A SQL statement or fragment with parameters.

This type is used to build SQL statements with proper parameter handling. It keeps track of both the SQL text and the parameters to be bound.

Fields

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

The chunks that make up this SQL statement or fragment.

Implementations

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

pub const fn new<'b>(chunks: [SQLChunk<'b, V>; 3]) -> SQL<'b, V>

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

Creates a new empty SQL fragment.

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

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

Helper to create const SQL

pub const fn wildcard() -> Self

Creates a wildcard SELECT fragment: “*”

pub const fn null() -> Self

Creates a NULL SQL fragment

pub const fn true() -> Self

Creates a TRUE SQL fragment

pub const fn false() -> Self

Creates a FALSE SQL fragment

pub fn raw<T: AsRef<str>>(sql: T) -> Self

Creates a new SQL fragment from a raw string.

The string is treated as literal SQL text, not a parameter.

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

Creates a new SQL fragment representing a parameter.

A default positional placeholder (‘?’) is used, and the provided value is stored for later binding. Accepts both owned and borrowed values.

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

Creates a new SQL fragment representing a table.

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

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

where V: Default,

Creates a named placeholder without a value - for use in query building. Similar to drizzle-orm’s sql.placeholder(‘name’). The value will be bound later during execution.

pub fn placeholder_with_style( name: &'static str, style: PlaceholderStyle, ) -> Self

where V: Default,

Creates a named placeholder with a specific style.

pub fn from_placeholder(placeholder: Placeholder) -> Self

where V: Default,

Creates SQL from an existing Placeholder struct.

pub fn append_raw(self, sql: impl AsRef<str>) -> Self

Appends a raw string to this SQL fragment.

The string is treated as literal SQL text, not a parameter.

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

Appends another SQL fragment to this one.

Both the SQL text and parameters are merged.

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

Pre-allocates capacity for additional chunks.

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

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

Joins multiple SQL fragments with a separator.

The separator is inserted between each fragment, but not before the first or after the last.

pub fn sql(&self) -> String

Returns the SQL string represented by this SQL fragment, using placeholders for parameters.

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

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

Returns references to parameter values from this SQL fragment in the correct order.

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

Creates an aliased version of this SQL using the Alias chunk

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

Wraps this SQL as a subquery

pub fn parameters<I>(values: I) -> Self

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

Creates a comma-separated list of parameter placeholders with values: “?, ?, ?”

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

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

Creates a comma-separated list of column assignments: “col1 = ?, col2 = ?”

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> IntoIterator for SQL<'a, V>

type Item = SQLChunk<'a, V>

The type of the elements being iterated over.

type IntoIter = FlatMap<IntoIter<[SQLChunk<'a, V>; 3]>, Box<dyn Iterator<Item = SQLChunk<'a, V>> + 'a>, fn(SQLChunk<'a, V>) -> Box<dyn Iterator<Item = SQLChunk<'a, V>> + 'a>>

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>