Enum ParseErrorKind 

pub enum ParseErrorKind {
    Lex(LexErrorKind),
    Unexpected {
        found: String,
        expected: Vec<&'static str>,
    },
    UnexpectedEnd {
        expected: Vec<&'static str>,
    },
    Unsupported(&'static str),
    Refused(String),
    RefusedNotBuilt {
        said: String,
        feature: &'static str,
    },
    LimitExceeded(&'static str),
}

Why a parse failed.

Variants

Lex(LexErrorKind)

The lexer refused a byte sequence.

Unexpected

A token appeared where the grammar did not allow it.

Fields

found: String

What was found, as source text.

expected: Vec<&'static str>

The smallest useful set of things that would have been accepted.

UnexpectedEnd

The statement ended before the production did.

Fields

expected: Vec<&'static str>

What would have continued it.

Unsupported(&'static str)

A construct the grammar has but this phase does not implement.

Refused(String)

A statement the schema refuses, in the reference’s own wording.

It is not a syntax error and does not read as one: the statement parsed and the schema will not have it, which is what foreign key mismatch says.

RefusedNotBuilt

SQLite’s own sentence for a statement that SQLite refuses in this form but accepts in another one this build cannot run.

The words are SQLite’s and the status is unsupported. A write to a view is cannot modify v because it is a view when the view has no INSTEAD OF trigger, and runs the trigger when it has one. A view that was reopened has lost its triggers in this build, and the writes the triggers would have run are ones the matrix in tests/matrix still marks as not built, so the sentence is SQLite’s and the caller is still told the construct is not built.

Fields

said: String

What the message says.

feature: &'static str

The construct, for the unsupported status.

LimitExceeded(&'static str)

A hard limit was exceeded.

Trait Implementations

impl Clone for ParseErrorKind

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ParseErrorKind

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

Formats the value using the given formatter.

impl Eq for ParseErrorKind

impl PartialEq for ParseErrorKind

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ParseErrorKind