Enum Error 

#[non_exhaustive]
pub enum Error {
    NoNamedArgs,
    RawArgCount {
        placeholders: usize,
        args: usize,
        clause: String,
    },
    TypeMismatch {
        expected: &'static str,
        found: &'static str,
    },
    Incomplete(&'static str),
    ConflictingClauses {
        first: &'static str,
        second: &'static str,
    },
    Other(String),
}

Everything that can go wrong while building a query.

Building is pure string work, so the set is small: almost every failure is either “this dialect cannot express that” or “the caller wired the pieces up inconsistently”. Execution errors live in the backend crates.

Rendering itself is infallible — Expression::write_sql returns nothing. The rare failure is recorded on the SqlWriter and surfaced once, by build.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

NoNamedArgs

The dialect has no syntax for named argument placeholders.

bob models this by having a separate DialectWithNamed interface and type-asserting on it; we keep one trait whose default write_named_arg records this instead.

RawArgCount

A raw clause’s ? placeholders and its argument list disagree.

The message is byte-compatible with bob’s rawError so a ported test can compare it directly.

Fields

placeholders: usize

How many ? the clause contains.

args: usize

How many arguments were supplied.

clause: String

The offending clause, for the message.

TypeMismatch

A Value could not be read as the requested Rust type.

Fields

expected: &'static str

The Rust type that was asked for.

found: &'static str

The Value variant that was actually present.

Incomplete(&'static str)

A query is missing a clause it cannot be rendered without.

ConflictingClauses

Two clauses were both set that are alternative spellings of one grammar production — LIMIT and FETCH — so no statement can carry both.

Deliberately not last-write-wins: the order mods are applied must never change what a query means (see the modifier-ordering entry in docs/sql-rendering.md), so the collision is reported instead of resolved.

Fields

first: &'static str

One of the colliding clauses, as its keyword.

second: &'static str

The other.

Other(String)

A dialect-specific or generated-code failure that has no shared shape.

Implementations

impl Error

pub fn type_mismatch(expected: &'static str, found: &'static str) -> Error

Shorthand for Error::TypeMismatch.

pub fn raw_arg_count( placeholders: usize, args: usize, clause: impl Into<String>, ) -> Error

Shorthand for Error::RawArgCount.

pub fn conflicting_clauses(first: &'static str, second: &'static str) -> Error

Shorthand for Error::ConflictingClauses.

pub fn other(msg: impl Into<String>) -> Error

Shorthand for Error::Other.

Trait Implementations

impl Debug for Error

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

Formats the value using the given formatter.

impl Display for Error

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

Formats the value using the given formatter.

impl Error for Error

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.