Enum Api

#[non_exhaustive]
pub enum Api {
    Query(String),
    Http(String),
    Ws(String),
    Scheme(String),
    ConnectionUninitialised,
    AlreadyConnected,
    InvalidBindings(Value),
    RangeOnRecordId,
    RangeOnObject,
    RangeOnArray,
    RangeOnEdges,
    RangeOnRange,
    RangeOnUnspecified,
    TableColonId {
        table: String,
    },
    DuplicateRequestId(i64),
    InvalidRequest(String),
    InvalidParams(String),
    InternalError(String),
    ParseError(String),
    InvalidSemanticVersion(String),
    InvalidUrl(String),
    FromValue {
        value: Value,
        error: String,
    },
    ResponseFromBinary {
        binary: Vec<u8>,
        error: Error,
    },
    ToJsonString {
        value: Value,
        error: String,
    },
    FromJsonString {
        string: String,
        error: String,
    },
    InvalidNsName(String),
    InvalidDbName(String),
    FileOpen {
        path: PathBuf,
        error: Error,
    },
    FileRead {
        path: PathBuf,
        error: Error,
    },
    LossyTake(Response),
    BackupsNotSupported,
    VersionMismatch {
        server_version: Version,
        supported_versions: String,
    },
    BuildMetadataMismatch {
        server_metadata: BuildMetadata,
        supported_metadata: BuildMetadata,
    },
    LiveQueriesNotSupported,
    LiveOnObject,
    LiveOnArray,
    LiveOnEdges,
    LiveOnUnspecified,
    NotLiveQuery(usize),
    QueryIndexOutOfBounds(usize),
    ResponseAlreadyTaken,
    InsertOnObject,
    InsertOnArray,
    InsertOnEdges,
    InsertOnRange,
    InsertOnUnspecified,
    InvalidNetTarget(ParseNetTargetError),
    InvalidFuncTarget(ParseFuncTargetError),
    SerializeValue(String),
    DeSerializeValue(String),
    Serializer(String),
    Deserializer(String),
    RecievedInvalidValue,
    VersionsNotSupported(String),
}

An error originating from a remote SurrealDB database

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.

Query(String)

There was an error processing the query

Http(String)

There was an error processing a remote HTTP request

Ws(String)

There was an error processing a remote WS request

Scheme(String)

The specified scheme does not match any supported protocol or storage engine

ConnectionUninitialised

Tried to run database queries without initialising the connection first

AlreadyConnected

Tried to call connect on an instance already connected

InvalidBindings(Value)

Query::bind not called with an object nor a key/value tuple

RangeOnRecordId

Tried to use a range query on a record ID

RangeOnObject

Tried to use a range query on an object

RangeOnArray

Tried to use a range query on an array

RangeOnEdges

Tried to use a range query on an edge or edges

RangeOnRange

Tried to use a range query on an existing range

RangeOnUnspecified

Tried to use a range query on an unspecified resource

TableColonId

Tried to use table:id syntax as a method parameter when (table, id) should be used instead

Fields

table: String

DuplicateRequestId(i64)

Duplicate request ID

InvalidRequest(String)

Invalid request

InvalidParams(String)

Invalid params

InternalError(String)

Internal server error

ParseError(String)

Parse error

InvalidSemanticVersion(String)

Invalid semantic version

InvalidUrl(String)

Invalid URL

FromValue

Failed to convert a sql::Value to T

Fields

value: Value

error: String

ResponseFromBinary

Failed to deserialize a binary response

Fields

binary: Vec<u8>

error: Error

ToJsonString

Failed to serialize sql::Value to JSON string

Fields

value: Value

error: String

FromJsonString

Failed to deserialize from JSON string to sql::Value

Fields

string: String

error: String

InvalidNsName(String)

Invalid namespace name

InvalidDbName(String)

Invalid database name

FileOpen

File open error

Fields

path: PathBuf

error: Error

FileRead

File read error

Fields

path: PathBuf

error: Error

LossyTake(Response)

Tried to take only a single result when the query returned multiple records

BackupsNotSupported

The protocol or storage engine being used does not support backups on the architecture it’s running on

VersionMismatch

The version of the server is not compatible with the versions supported by this SDK

Fields

server_version: Version

supported_versions: String

BuildMetadataMismatch

The build metadata of the server is older than the minimum supported by this SDK

Fields

server_metadata: BuildMetadata

supported_metadata: BuildMetadata

LiveQueriesNotSupported

The protocol or storage engine being used does not support live queries on the architecture it’s running on

LiveOnObject

Tried to use a range query on an object

LiveOnArray

Tried to use a range query on an array

LiveOnEdges

Tried to use a range query on an edge or edges

LiveOnUnspecified

Tried to use a range query on an unspecified resource

NotLiveQuery(usize)

Tried to access a query statement as a live query when it isn’t a live query

QueryIndexOutOfBounds(usize)

Tried to access a query statement falling outside the bounds of the statements supplied

ResponseAlreadyTaken

Called Response::take or Response::stream on a query response more than once

InsertOnObject

Tried to insert on an object

InsertOnArray

Tried to insert on an array

InsertOnEdges

Tried to insert on an edge or edges

InsertOnRange

Tried to insert on an edge or edges

InsertOnUnspecified

Tried to insert on an unspecified resource with no data

InvalidNetTarget(ParseNetTargetError)

InvalidFuncTarget(ParseFuncTargetError)

SerializeValue(String)

DeSerializeValue(String)

Serializer(String)

Deserializer(String)

RecievedInvalidValue

Tried to convert an value which contained something like for example a query or future.

VersionsNotSupported(String)

The engine used does not support data versioning

Trait Implementations

impl Debug for Error

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

Formats the value using the given formatter.

impl Display for Error

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

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.

impl Error for Error

fn custom<T>(msg: T) -> Self

where T: Display,

Used when a Serialize implementation encounters any error while serializing a type.

impl Error for Error

fn custom<T>(msg: T) -> Self

where T: Display,

Raised when there is general error when deserializing a type.

fn invalid_type(unexp: Unexpected<'_>, exp: &dyn Expected) -> Self

Raised when a Deserialize receives a type different from what it was expecting.

fn invalid_value(unexp: Unexpected<'_>, exp: &dyn Expected) -> Self

Raised when a Deserialize receives a value of the right type but that is wrong for some other reason.

fn invalid_length(len: usize, exp: &dyn Expected) -> Self

Raised when deserializing a sequence or map and the input data contains too many or too few elements.

fn unknown_variant(variant: &str, expected: &'static [&'static str]) -> Self

Raised when a Deserialize enum type received a variant with an unrecognized name.

fn unknown_field(field: &str, expected: &'static [&'static str]) -> Self

Raised when a Deserialize struct type received a field with an unrecognized name.

fn missing_field(field: &'static str) -> Self

Raised when a Deserialize struct type expected to receive a required field with a particular name but that field was not present in the input.

fn duplicate_field(field: &'static str) -> Self

Raised when a Deserialize struct type received more than one of the same field.

impl From<Error> for Error

fn from(source: Api) -> Self

Converts to this type from the input type.

impl From<ParseFuncTargetError> for Error

fn from(source: ParseFuncTargetError) -> Self

Converts to this type from the input type.

impl From<ParseNetTargetError> for Error

fn from(source: ParseNetTargetError) -> Self

Converts to this type from the input type.

impl Serialize for Error

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.