Struct SQL 

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

where V: SQLParam,

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

Helper to create const SQL

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

Creates a wildcard SELECT fragment: “*”

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

Creates a NULL SQL fragment

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

Creates a TRUE SQL fragment

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

Creates a FALSE SQL fragment

pub fn raw<T>(sql: T) -> SQL<'a, V>

where T: AsRef<str>,

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

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

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

where V: Default,

Creates a named placeholder with a specific style.

pub fn from_placeholder(placeholder: Placeholder) -> SQL<'a, V>

where V: Default,

Creates SQL from an existing Placeholder struct.

pub fn append_raw(self, sql: impl AsRef<str>) -> SQL<'a, V>

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

Appends another SQL fragment to this one.

Both the SQL text and parameters are merged.

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

Pre-allocates capacity for additional chunks.

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

where T: IntoIterator, <T as IntoIterator>::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) -> SQL<'a, V>

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

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

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

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> 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, 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 From<OwnedSQLiteValue> for SQL<'_, OwnedSQLiteValue>

fn from(value: OwnedSQLiteValue) -> Self

Converts to this type from the input type.

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

fn from(_value: SQL<'a, SQLiteValue<'a>>) -> Self

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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