Enum SQLChunk 

pub enum SQLChunk<'a, V: SQLParam> {
    Token(Token),
    Ident(Cow<'a, str>),
    Raw(Cow<'a, str>),
    Number(usize),
    Param(Param<'a, V>),
    Table(TableSqlRef),
    Column(ColumnSqlRef),
}

A SQL chunk represents a part of an SQL statement.

Each variant has 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 via TableSqlRef
• Column - Column reference via ColumnSqlRef

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

Number(usize)

Unsigned integer SQL literal rendered directly without heap allocation.

Primarily used for clauses like LIMIT/OFFSET where numeric literals are embedded directly in SQL text rather than parameterized.

Param(Param<'a, V>)

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

Table(TableSqlRef)

Table reference with static name and column names. Renders as: “table_name” Column names used for SELECT * expansion.

Column(ColumnSqlRef)

Column reference with static table and column names. Renders as: “table_name"."column_name”

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

Creates a table chunk - const

pub const fn column(column: ColumnRef) -> 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 const fn number(value: usize) -> Self

Creates an unsigned integer SQL literal chunk.

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

Creates a parameter chunk with owned value

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<V: SQLParam + Debug> Debug for SQLChunk<'_, V>

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

Formats the value using the given formatter.

impl<V: SQLParam> From<ColumnRef> for SQLChunk<'_, V>

fn from(value: ColumnRef) -> 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<V: SQLParam> From<TableRef> for SQLChunk<'_, V>

fn from(value: TableRef) -> Self

Converts to this type from the input type.

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

fn from(value: Token) -> Self

Converts to this type from the input type.