Enum SQLChunk 

pub enum SQLChunk<'a, V: SQLParam> {
    Token(Token),
    Ident(Cow<'a, str>),
    Raw(Cow<'a, str>),
    Param(Param<'a, V>),
    Table(&'static dyn SQLTableInfo),
    Column(&'static dyn SQLColumnInfo),
    Alias {
        inner: Box<SQLChunk<'a, V>>,
        alias: Cow<'a, str>,
    },
}

A SQL chunk represents a part of an SQL statement.

This enum has 7 variants, each with a clear semantic purpose:

• Token - SQL keywords and operators (SELECT, FROM, =, etc.)
• Ident - Quoted identifiers (“table_name”, “column_name”)
• Raw - Unquoted raw SQL text (function names, expressions)
• Param - Parameter placeholders with values
• Table - Table reference with metadata access
• Column - Column reference with metadata access
• Alias - Alias wrapper (expr AS “name”)

Variants

Token(Token)

SQL keywords and operators: SELECT, FROM, WHERE, =, AND, etc. Renders as: keyword with automatic spacing rules

Ident(Cow<'a, str>)

Quoted identifier for user-provided names Renders as: “name” (with quotes) Use for: table names, column names, alias names

Raw(Cow<'a, str>)

Raw SQL text (unquoted) for expressions, function names Renders as: text (no quotes, as-is) Use for: function names like COUNT, expressions, numeric literals

Param(Param<'a, V>)

Parameter with value and placeholder Renders as: ? or $1 or :name depending on placeholder style

Table(&'static dyn SQLTableInfo)

Table reference with full metadata access Renders as: “table_name” Provides: columns() for SELECT *, dependencies() for FK tracking

Column(&'static dyn SQLColumnInfo)

Column reference with full metadata access Renders as: “table”.“column” Provides: table(), is_primary_key(), foreign_key(), etc.

Alias

Alias wrapper: renders inner chunk followed by AS “alias” Renders as: {inner} AS “alias”

Fields

inner: Box<SQLChunk<'a, V>>

alias: Cow<'a, str>

Implementations

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

pub const fn token(t: Token) -> Self

Creates a token chunk - const

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

Creates a quoted identifier from a static string - const

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

Creates raw SQL text from a static string - const

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

Creates a table chunk - const

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

Creates a column chunk - const

pub const fn param_borrowed(value: &'a V, placeholder: Placeholder) -> Self

Creates a parameter chunk with borrowed value - const

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

Creates a quoted identifier from a runtime string

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

Creates raw SQL text from a runtime string

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

Creates a parameter chunk with owned value

pub fn alias(inner: SQLChunk<'a, V>, alias: impl Into<Cow<'a, str>>) -> Self

Creates an alias chunk wrapping any SQLChunk

Trait Implementations

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

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, V: SQLParam + Debug> Debug for SQLChunk<'a, V>

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

Formats the value using the given formatter.

impl<'a, V: SQLParam> From<&'static dyn SQLColumnInfo> for SQLChunk<'a, V>

fn from(value: &'static dyn SQLColumnInfo) -> Self

Converts to this type from the input type.

impl<'a, V: SQLParam> From<&'static dyn SQLTableInfo> for SQLChunk<'a, V>

fn from(value: &'static dyn SQLTableInfo) -> Self

Converts to this type from the input type.

impl<V: SQLParam> From<OwnedSQLChunk<V>> for SQLChunk<'static, V>

fn from(value: OwnedSQLChunk<V>) -> Self

Converts to this type from the input type.

impl<'a, V: SQLParam> From<Param<'a, V>> for SQLChunk<'a, V>

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

Converts to this type from the input type.

impl<'a, V: SQLParam> From<SQLChunk<'a, V>> for OwnedSQLChunk<V>

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

Converts to this type from the input type.

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

fn from(value: Token) -> Self

Converts to this type from the input type.