Enum StringFunc 

pub enum StringFunc<X: Extension = NoExt> {
    Substring {
        expr: Box<Expr<X>>,
        start: Option<Box<Expr<X>>>,
        count: Option<Box<Expr<X>>>,
        meta: Meta,
    },
    SubstringSimilar {
        expr: Box<Expr<X>>,
        pattern: Box<Expr<X>>,
        escape: Box<Expr<X>>,
        meta: Meta,
    },
    Position {
        substr: Box<Expr<X>>,
        string: Box<Expr<X>>,
        meta: Meta,
    },
    Overlay {
        target: Box<Expr<X>>,
        replacement: Box<Expr<X>>,
        start: Box<Expr<X>>,
        count: Option<Box<Expr<X>>>,
        meta: Meta,
    },
    Trim {
        side: Option<TrimSide>,
        trim_chars: Option<Box<Expr<X>>>,
        from: bool,
        sources: ThinVec<Expr<X>>,
        meta: Meta,
    },
    CollationFor {
        expr: Box<Expr<X>>,
        meta: Meta,
    },
    ConvertUsing {
        expr: Box<Expr<X>>,
        charset: Ident,
        meta: Meta,
    },
    MatchAgainst {
        columns: ThinVec<Expr<X>>,
        against: Box<Expr<X>>,
        modifier: Option<MatchSearchModifier>,
        meta: Meta,
    },
    CeilTo {
        expr: Box<Expr<X>>,
        field: Ident,
        spelling: CeilSpelling,
        meta: Meta,
    },
    FloorTo {
        expr: Box<Expr<X>>,
        field: Ident,
        meta: Meta,
    },
}

A standard-SQL string special form (SQL-92 E021-06/-09/-11 + SQL:1999 T312; PostgreSQL’s func_expr_common_subexpr string productions).

One kind-tagged enum for the keyword-argument string functions: each variant carries exactly its form’s typed fields, and every operand keyword (FROM, FOR, SIMILAR, ESCAPE, PLACING, IN, LEADING/TRAILING/BOTH) is grammar, not data. The comma plain-call spellings (substring(x, 1, 2), trim(x, y), overlay(a, b, c)) are not here — they stay ordinary FunctionCalls, so the plain-call surface every engine also accepts is unaffected by the special forms.

Variants

Substring

SUBSTRING(<expr> FROM <start> [FOR <count>]) and its variants: PostgreSQL admits FOR <count> alone and the reversed FOR <count> FROM <start> spelling (both orders fold onto the same fields and render canonically FROM-first), so at least one of start/count is always present. The string-pattern form SUBSTRING(x FROM 'pat')/… FOR '#' is this same production (the regex reading is runtime semantics, not grammar).

Fields

expr: Box<Expr<X>>

Expression evaluated by this syntax.

start: Option<Box<Expr<X>>>

The FROM <start> operand, None for the FOR-only form.

count: Option<Box<Expr<X>>>

The FOR <count> operand, None for the FROM-only form.

meta: Meta

Source location and node identity.

SubstringSimilar

PostgreSQL’s SUBSTRING(<expr> SIMILAR <pattern> ESCAPE <escape>) regex form (SQL:1999 <regular expression substring function>). All three operands are mandatory (SUBSTRING(x SIMILAR p) without ESCAPE rejects, engine-verified).

Fields

expr: Box<Expr<X>>

Expression evaluated by this syntax.

pattern: Box<Expr<X>>

The SQL-regex pattern.

escape: Box<Expr<X>>

The escape-character expression.

meta: Meta

Source location and node identity.

Position

POSITION(<substr> IN <string>) (SQL-92 E021-11). The operands are the restricted b_expr in PostgreSQL/DuckDB (POSITION(1 IN 2 OR 3) rejects) and MySQL’s asymmetric bit_expr IN expr under StringFuncForms::position_asymmetric_operands. There is no plain-call spelling: every keyword-form engine parse-rejects position(a, b).

Fields

substr: Box<Expr<X>>

The substring to search for.

string: Box<Expr<X>>

The string searched within.

meta: Meta

Source location and node identity.

Overlay

OVERLAY(<target> PLACING <replacement> FROM <start> [FOR <count>]) (SQL:1999 T312). FROM <start> is mandatory — OVERLAY(x PLACING y) and the FOR-without-FROM form parse-reject on every keyword-form engine.

Fields

target: Box<Expr<X>>

Object targeted by this syntax.

replacement: Box<Expr<X>>

The replacement string spliced in.

start: Box<Expr<X>>

The 1-based start position.

count: Option<Box<Expr<X>>>

Optional count for this syntax.

meta: Meta

Source location and node identity.

Trim

TRIM([{BOTH | LEADING | TRAILING}] [<chars>] FROM <sources>…) (SQL-92 E021-09) plus PostgreSQL’s loose trim_list tails under StringFuncForms::trim_list_syntax: a bare FROM <list>, a side without FROM (TRIM(TRAILING ' foo ')), and a multi-expression list (TRIM('a' FROM 'b', 'c')). At least one of side/from is present — a bare TRIM(x)/TRIM(x, y) is an ordinary call, never this node.

Fields

side: Option<TrimSide>

The written BOTH/LEADING/TRAILING side, None when omitted.

trim_chars: Option<Box<Expr<X>>>

The trim-character expression written before FROM; None for the bare-FROM and side-without-FROM forms.

from: bool

Whether FROM was written (distinguishes TRIM(TRAILING ' foo ') from TRIM(TRAILING FROM ' foo ') — both are valid PostgreSQL with different meanings, so the bit is load-bearing for round-trips).

sources: ThinVec<Expr<X>>

The source expression list after FROM (or the bare list when a side is written without FROM). PostgreSQL’s trim_list is an expr_list, so more than one source parses there; the restricted dialects hold this to exactly one at parse.

meta: Meta

Source location and node identity.

CollationFor

PostgreSQL’s COLLATION FOR (<expr>) — the common-subexpr that reports the collation name derived for its operand. PostgreSQL gives it a dedicated COLLATION FOR '(' a_expr ')' production that lowers to a pg_catalog.pg_collation_for(<expr>) call, but the surface keyword form is kept here (not folded to a FunctionCall) so it round-trips as written. The parentheses and single a_expr operand are mandatory — COLLATION FOR 'x', COLLATION FOR (), and a two-argument list all parse-reject (engine-verified).

Fields

expr: Box<Expr<X>>

Expression evaluated by this syntax.

meta: Meta

Source location and node identity.

ConvertUsing

MySQL’s CONVERT(<expr> USING <charset>) transcoding form — reinterprets its string operand in another character set (the grammar’s CONVERT '(' expr USING charset_name ')'). Distinct from the comma-form cast CastSyntax::Convert: this changes the charset, not the type, so it is a string special form rather than a cast. The operand is a full a_expr (CONVERT(1+2 USING utf8mb4) parses, engine-verified); charset is a MySQL charset_name — an ident_or_text (a bare or backtick identifier, or a quoted string, round-tripping by the Ident’s quote style) or the BINARY transcoding name (CONVERT(x USING binary)), which reaches here as a bare Ident. Recognized only under CallSyntax::convert_function; MySQL-only.

Fields

expr: Box<Expr<X>>

Expression evaluated by this syntax.

charset: Ident

The target character set name.

meta: Meta

Source location and node identity.

MatchAgainst

MySQL’s full-text search MATCH (<col>, …) AGAINST (<expr> [<modifier>]) (simple_expr: MATCH ident_list_arg AGAINST '(' bit_expr fulltext_options ')'). The columns are a comma list of column references (bare or 1–3-part dotted Expr::Columns — an arbitrary expression, literal, function call, or empty list all parse-reject, engine-verified); against is a MySQL bit_expr (below the comparison level, so a trailing IN/WITH opens the modifier rather than an IN predicate). The optional MatchSearchModifier is exactly one of the four documented combinations; None is the default (no modifier words) and round-trips as written rather than as an explicit IN NATURAL LANGUAGE MODE. Recognized only under StringFuncForms::match_against; MySQL-only, and distinct from SQLite’s infix <expr> MATCH <expr> operator. Semantic constraints (a full-text index must cover the columns, the operand must be constant) are a server binding concern, not grammar.

Fields

columns: ThinVec<Expr<X>>

Columns in source order.

against: Box<Expr<X>>

The full-text search expression.

modifier: Option<MatchSearchModifier>

Optional modifier for this syntax.

meta: Meta

Source location and node identity.

CeilTo

CEIL(<expr> TO <field>) / CEILING(<expr> TO <field>) — a rounding-field keyword form distinct from the ordinary CEIL(<expr>) call and the comma-form scale spelling CEIL(<expr>, <scale>) (which stays an ordinary FunctionCall: no probed oracle grammar admits the TO tail, engine-verified against pg_query, DuckDB, and mysql:8.4). The field (DAY, HOUR, …) is stored as written and validated, if at all, by the consuming engine at analysis time, not parse. Recognized only under StringFuncForms::ceil_to_field.

Fields

expr: Box<Expr<X>>

Expression evaluated by this syntax.

field: Ident

The rounding field (DAY, HOUR, …).

spelling: CeilSpelling

Exact source spelling retained for faithful rendering.

meta: Meta

Source location and node identity.

FloorTo

FLOOR(<expr> TO <field>) — a rounding-field keyword form distinct from the ordinary FLOOR(<expr>) call and the comma-form scale spelling FLOOR(<expr>, <scale>) (which stays an ordinary FunctionCall: no probed oracle grammar admits the TO tail, engine-verified against pg_query, DuckDB, and mysql:8.4). Unlike StringFunc::CeilTo, FLOOR has no FLOORING synonym, so there is no spelling field to track. The field (DAY, HOUR, …) is stored as written and validated, if at all, by the consuming engine at analysis time, not parse. Recognized only under StringFuncForms::floor_to_field.

Fields

expr: Box<Expr<X>>

Expression evaluated by this syntax.

field: Ident

The rounding field (DAY, HOUR, …).

meta: Meta

Source location and node identity.

Trait Implementations

impl<X: Clone + Extension> Clone for StringFunc<X>

fn clone(&self) -> StringFunc<X>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<X: Debug + Extension> Debug for StringFunc<X>

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

Formats the value using the given formatter.

impl<'de, X> Deserialize<'de> for StringFunc<X>

where X: Deserialize<'de> + Extension,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<X: Eq + Extension> Eq for StringFunc<X>

impl<X: Hash + Extension> Hash for StringFunc<X>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<X: PartialEq + Extension> PartialEq for StringFunc<X>

fn eq(&self, other: &StringFunc<X>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<X: Extension + Render> Render for StringFunc<X>

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

Return the render for this value.

fn operand_binding_power(&self) -> Option<BindingPower>

The binding power this node contributes when it appears as an operand, or None (the default) for a self-delimiting node — an atom, call, or constructor — that never needs parentheses.

impl<X> Serialize for StringFunc<X>

where X: Serialize + Extension,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<X: Extension> Spanned for StringFunc<X>

fn span(&self) -> Span

Return the span for this value.

impl<X: PartialEq + Extension> StructuralPartialEq for StringFunc<X>