Struct ParameterSyntax 

pub struct ParameterSyntax {
    pub positional_dollar: bool,
    pub positional_dollar_large: bool,
    pub anonymous_question: bool,
    pub named_colon: bool,
    pub named_at: bool,
    pub named_dollar: bool,
    pub numbered_question: bool,
}

Dialect-owned prepared-statement parameter placeholder syntax.

SQL has no single standard placeholder spelling, so which forms a dialect accepts is explicit dialect data, not a parser-side type check. Each flag is a lexical gate: it decides whether the scanner recognises that sigil as a parameter TokenKind rather than a stray byte.

Fields

positional_dollar: bool

Accept PostgreSQL positional $1, $2, … ($ + ASCII digits). Disjoint from dollar-quoting: $ + digit is a parameter, $ + tag-start/$ opens a dollar-quoted string, so both forms can be enabled together.

positional_dollar_large: bool

Preserve a $ positional parameter whose digit run exceeds u32. PostgreSQL’s scanner accepts these spellings and narrows them into its signed ParamRef.number; dialects that range-check their parameter indices leave this off.

anonymous_question: bool

Accept anonymous positional ? placeholders (ODBC/JDBC).

named_colon: bool

Accept colon-named :name placeholders (Oracle, SQLite, JDBC/psycopg). The sigil must abut an identifier-start byte, which is what keeps :name free of the two other : meanings: :: stays the typecast (its second : is not an identifier byte) and a lone : before a non-identifier byte stays the array-slice separator. (A dialect that also sliced arrays with bare identifier bounds — a[x:y] — or wrote semi-structured paths as a:b would lex :y/:b as a parameter; that pairing is the tracked LexicalConflict::ColonParameterVersusSliceBound, since no real dialect combines :name with those spellings.)

named_at: bool

Accept at-sign-named @name placeholders (T-SQL parameters/local variables). The sigil must abut an identifier-start byte, so the system-variable @@name form is left unclaimed for prod-token-identifier-prefix-tokens (the second @ is not an identifier byte, so this never grabs @@).

Mutually exclusive with SessionVariableSyntax::user_variables: both claim the @name trigger (one as a placeholder, one as a user-variable read), so a feature set enabling both is a LexicalConflict. @name-as-parameter (T-SQL) and @name-as-user-variable (MySQL) are the same surface with different meaning, so a dialect picks one.

named_dollar: bool

Accept dollar-named $name placeholders (SQLite). The sigil must abut an identifier-start byte — $ + a digit stays the PostgreSQL positional $1 (positional_dollar) and $ + a non-identifier byte a stray/money form — so this is follow-set-disjoint from both $-digit forms and can be enabled alongside them.

Contends only with StringLiteralSyntax::dollar_quoted_strings: a $tag$…$tag$ opener also leads with $ + a tag-start byte (the same class as identifier-start), so enabling both is a LexicalConflict::NamedDollarParameterVersusDollarQuotedString. SQLite has no dollar-quoting, so the two never meet in a shipped preset.

numbered_question: bool

Accept SQLite numbered ?NNN positional parameters (?1, ?123) — the ? sigil abutting an ASCII-digit run — on top of the bare anonymous ? (anonymous_question). Follow-set-disjoint from the anonymous form by the digit (a ? with no digit stays anonymous), exactly as PostgreSQL’s $1 splits from $name. The number is a maximal digit run, so a trailing identifier is a separate token (?1abc is ?1 then the alias abc; engine-measured). SQLite range-restricts the index to 1..=32766 (SQLITE_MAX_VARIABLE_NUMBER): ?0, ?32767, and an overflowing run are parse rejects (“variable number must be between ?1 and ?32766”; probed), enforced when the numbered token is materialised. On for SQLite / Lenient, off elsewhere.

Implementations

impl ParameterSyntax

pub const ANSI: Self

The ANSI predefined value.

impl ParameterSyntax

pub const LENIENT: Self

Available on crate feature lenient only.

LENIENT: every placeholder spelling — PostgreSQL $1, ODBC/JDBC ?, Oracle/SQLite :name, and T-SQL @name. The sigils are lookahead-disjoint, so enabling all four is a pure addition. @name keeps its parameter meaning under LENIENT (named_at), so user_variables stays off in SessionVariableSyntax::LENIENT — the two claim the same @name trigger — but the disjoint @@sysvar form is still admitted there.

The SQLite $name form (named_dollar) is the one placeholder left off: it contends with the PostgreSQL $tag$…$tag$ dollar-quote this union already admits (StringLiteralSyntax::LENIENT, both lead with $+identifier), so the union resolves that $ trigger to dollar-quoting — the spelled-out conflict-resolution the LENIENT honesty bar requires.

impl ParameterSyntax

pub const MSSQL: Self

Available on crate feature mssql only.

MSSQL parameter surface: the ANSI baseline plus the @name parameter / local-variable sigil. positional_dollar stays off (ANSI’s value) so $+digit belongs solely to NumericLiteralSyntax::money_literals, and user_variables stays off (in SessionVariableSyntax::ANSI) so @name belongs solely to this — both enforced by the lexical assert below.

impl ParameterSyntax

pub const MYSQL: Self

Available on crate feature mysql only.

The MYSQL preset for parameter syntax.

impl ParameterSyntax

pub const POSTGRES: Self

Available on crate feature postgres only.

The POSTGRES preset for parameter syntax.

impl ParameterSyntax

pub const SQLITE: Self

Available on crate feature sqlite only.

The SQLITE preset for parameter syntax.

Trait Implementations

impl Clone for ParameterSyntax

fn clone(&self) -> ParameterSyntax

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ParameterSyntax

impl Debug for ParameterSyntax

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

Formats the value using the given formatter.

impl Eq for ParameterSyntax

impl PartialEq for ParameterSyntax

fn eq(&self, other: &ParameterSyntax) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for ParameterSyntax