Enum QueryError 

pub enum QueryError {
    TableNotFound(String),
    ColumnNotFound {
        table: String,
        column: String,
    },
    TypeError(String),
    JoinLimitExceeded,
    NestedLoopPairLimitExceeded {
        left_rows: usize,
        right_rows: usize,
        limit: usize,
    },
    SortLimitExceeded,
    MemoryLimitExceeded {
        limit_bytes: usize,
        requested_bytes: usize,
    },
    Parse(String),
    IndexError(String),
    ViewError(String),
    StorageError(String),
    Storage {
        kind: StorageErrorKind,
        message: String,
    },
    ReadonlyNeedsWrite,
    ReadonlyMode,
    Timeout {
        timeout_ms: u64,
    },
    Cancelled,
    Execution(String),
}

Typed error enum for query execution failures.

Replaces the previous Result<QueryResult, String> pattern with structured variants that callers can programmatically match on. The From<String> impl enables gradual migration: existing Err(format!(...)) sites continue to compile via ? propagation.

Display strings are wire-visible behavior: the server’s egress sanitization prefix-matches them and clients assert on them. Every message is pinned byte-exact by tests/error_display.rs; do not reword one without updating that suite deliberately.

Variants

TableNotFound(String)

Table does not exist.

ColumnNotFound

Column does not exist on table.

Fields

table: String

column: String

TypeError(String)

Type mismatch in expression.

JoinLimitExceeded

Join result exceeded MAX_JOIN_ROWS.

NestedLoopPairLimitExceeded

A fallback nested-loop join would evaluate more candidate pairs than the measured safety cap.

Fields

left_rows: usize

right_rows: usize

limit: usize

SortLimitExceeded

Sort exceeded MAX_SORT_ROWS.

MemoryLimitExceeded

Per-query memory budget exceeded during materialization (sort buffer, join build side, GROUP BY hash table, or IN-list). Returned cleanly so the server process is never OOM-killed by a crafted query.

Fields

limit_bytes: usize

requested_bytes: usize

Parse(String)

Parse error (wraps parser error).

IndexError(String)

Index-related error.

ViewError(String)

View-related error.

StorageError(String)

WAL or I/O error whose originating variant was already discarded.

Prefer QueryError::Storage: this variant keeps only the rendered text, so anything downstream that needs to know what failed (the server picks a wire error class from it) is left matching substrings.

Storage

A storage-engine refusal that reached the query layer with its kind intact.

message is the storage error rendered exactly as QueryError::StorageError would have rendered it, so this variant is Display-identical to the untyped one and changes nothing a client reads. kind is the part that was previously thrown away, and it is what the server classifies on.

The kind travels beside the message rather than the StorageError itself because that type wraps std::io::Error, which is neither Clone nor PartialEq, and QueryError is both.

Fields

kind: StorageErrorKind

message: String

ReadonlyNeedsWrite

Readonly path needs write lock (internal sentinel). The server intercepts this variant before Display, so the sentinel string must never cross the wire.

ReadonlyMode

The engine was opened read-only (snapshot serving) and the statement requires a writer. Unlike QueryError::ReadonlyNeedsWrite, this is a terminal error with an operator-facing message: there is no writer to escalate to in this mode.

Timeout

The per-query deadline elapsed before execution finished. Returned as a clean early-return from an unbounded executor loop so the query releases its locks instead of running to completion. timeout_ms is the configured per-query timeout.

Fields

timeout_ms: u64

Cancelled

Execution was cancelled cooperatively (e.g. the issuing client disconnected). Like QueryError::Timeout, a clean early-return.

Execution(String)

Generic execution error (catch-all for migration).

Implementations

impl QueryError

pub fn from_storage_io(error: Error) -> Self

Wrap a storage failure that arrived as an std::io::Error, keeping its StorageErrorKind when the storage engine attached one.

Most of the storage engine speaks io::Result, and a typed refusal rides inside the io::Error as its source. Recovering it here is what lets the server pick a wire error class from the error’s type instead of searching its message for a known phrase. A plain I/O failure, or a refusal that was raised as a bare string, has no kind to recover and falls back to QueryError::StorageError with byte-identical text.

Trait Implementations

impl Clone for QueryError

fn clone(&self) -> QueryError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for QueryError

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

Formats the value using the given formatter.

impl Display for QueryError

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

Formats the value using the given formatter.

impl Error for QueryError

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.

impl From<&str> for QueryError

fn from(s: &str) -> Self

Converts to this type from the input type.

impl From<StorageError> for QueryError

fn from(error: StorageError) -> Self

Converts to this type from the input type.

impl From<String> for QueryError

fn from(s: String) -> Self

Converts to this type from the input type.

impl PartialEq for QueryError

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for QueryError