Enum Token

pub enum Token {
    EOF,
    Word(Word),
    Number(String),
    Char(char),
    SingleQuotedString(String),
    DollarQuotedString(DollarQuotedString),
    CstyleEscapesString(CstyleEscapedString),
    NationalStringLiteral(String),
    HexStringLiteral(String),
    Parameter(String),
    Comma,
    Whitespace(Whitespace),
    DoubleEq,
    Eq,
    Neq,
    Lt,
    Gt,
    LtEq,
    GtEq,
    Spaceship,
    Plus,
    Minus,
    Mul,
    Div,
    Mod,
    Concat,
    LParen,
    RParen,
    Period,
    Colon,
    DoubleColon,
    SemiColon,
    Backslash,
    LBracket,
    RBracket,
    Ampersand,
    Pipe,
    Caret,
    Prefix,
    LBrace,
    RBrace,
    RArrow,
    Sharp,
    Tilde,
    TildeAsterisk,
    ExclamationMarkTilde,
    ExclamationMarkTildeAsterisk,
    DoubleTilde,
    DoubleTildeAsterisk,
    ExclamationMarkDoubleTilde,
    ExclamationMarkDoubleTildeAsterisk,
    ShiftLeft,
    ShiftRight,
    ExclamationMark,
    DoubleExclamationMark,
    AtSign,
    PGSquareRoot,
    PGCubeRoot,
    Arrow,
    LongArrow,
    HashArrow,
    HashLongArrow,
    HashMinus,
    AtArrow,
    ArrowAt,
    QuestionMark,
    QuestionMarkPipe,
    QuestionMarkAmpersand,
    AtQuestionMark,
    AtAt,
}

SQL Token enumeration

Variants

EOF

An end-of-file marker, not a real token

Word(Word)

A keyword (like SELECT) or an optionally quoted SQL identifier

Number(String)

An unsigned numeric literal

Char(char)

A character that could not be tokenized

SingleQuotedString(String)

Single quoted string: i.e: ‘string’

DollarQuotedString(DollarQuotedString)

Dollar quoted string: i.e: $$string$$ or $tag_name$string$tag_name$

CstyleEscapesString(CstyleEscapedString)

Single quoted string with c-style escapes: i.e: E’string’

NationalStringLiteral(String)

“National” string literal: i.e: N’string’

HexStringLiteral(String)

Hexadecimal string literal: i.e.: X’deadbeef’

Parameter(String)

Parameter symbols: i.e: $1, $2

Comma

Comma

Whitespace(Whitespace)

Whitespace (space, tab, etc)

DoubleEq

Double equals sign ==

Eq

Equality operator =

Neq

Not Equals operator <> (or != in some dialects)

Lt

Less Than operator <

Gt

Greater Than operator >

LtEq

Less Than Or Equals operator <=

GtEq

Greater Than Or Equals operator >=

Spaceship

Spaceship operator <=>

Plus

Plus operator +

Minus

Minus operator -

Mul

Multiplication operator *

Div

Division operator /

Mod

Modulo Operator %

Concat

String concatenation ||

LParen

Left parenthesis (

RParen

Right parenthesis )

Period

Period (used for compound identifiers or projections into nested types)

Colon

Colon :

DoubleColon

DoubleColon :: (used for casting in postgresql)

SemiColon

SemiColon ; used as separator for COPY and payload

Backslash

Backslash \ used in terminating the COPY payload with \.

LBracket

Left bracket [

RBracket

Right bracket ]

Ampersand

Ampersand &

Pipe

Pipe |

Caret

Caret ^

Prefix

Prefix ^@

LBrace

Left brace {

RBrace

Right brace }

RArrow

Right Arrow =>

Sharp

Sharp # used for PostgreSQL Bitwise XOR operator

Tilde

Tilde ~ used for PostgreSQL Bitwise NOT operator or case sensitive match regular expression operator

TildeAsterisk

~* , a case insensitive match regular expression operator in PostgreSQL

ExclamationMarkTilde

!~ , a case sensitive not match regular expression operator in PostgreSQL

ExclamationMarkTildeAsterisk

!~* , a case insensitive not match regular expression operator in PostgreSQL

DoubleTilde

~~, a case sensitive LIKE expression operator in PostgreSQL

DoubleTildeAsterisk

~~* , a case insensitive ILIKE regular expression operator in PostgreSQL

ExclamationMarkDoubleTilde

!~~ , a case sensitive NOT LIKE regular expression operator in PostgreSQL

ExclamationMarkDoubleTildeAsterisk

!~~* , a case insensitive NOT ILIKE regular expression operator in PostgreSQL

ShiftLeft

<<, a bitwise shift left operator in PostgreSQL

ShiftRight

>>, a bitwise shift right operator in PostgreSQL

ExclamationMark

Exclamation Mark ! used for PostgreSQL factorial operator

DoubleExclamationMark

Double Exclamation Mark !! used for PostgreSQL prefix factorial operator

AtSign

AtSign @ used for PostgreSQL abs operator

PGSquareRoot

|/, a square root math operator in PostgreSQL

PGCubeRoot

||/ , a cube root math operator in PostgreSQL

Arrow

->, access JSON object field or array element in PostgreSQL

LongArrow

->>, access JSON object field or array element as text in PostgreSQL

HashArrow

#>, extract JSON sub-object at the specified path in PostgreSQL

HashLongArrow

#>>, extract JSON sub-object at the specified path as text in PostgreSQL

HashMinus

#-, delete a key from a JSON object in PostgreSQL

AtArrow

@>, does the left JSON value contain the right JSON path/value entries at the top level

ArrowAt

<@, does the right JSON value contain the left JSON path/value entries at the top level

QuestionMark

?, does the string exist as a top-level key within the JSON value

QuestionMarkPipe

?|, do any of the strings exist as top-level keys or array elements?

QuestionMarkAmpersand

?&, do all of the strings exist as top-level keys or array elements?

AtQuestionMark

@?, does JSON path return any item for the specified JSON value?

AtAt

@@, returns the result of a JSON path predicate check for the specified JSON value.

Implementations

impl Token

pub fn make_keyword(keyword: &str) -> Self

pub fn make_word(word: &str, quote_style: Option<char>) -> Self

pub fn with_location(self, location: Location) -> TokenWithLocation

Trait Implementations

impl Clone for Token

fn clone(&self) -> Token

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Token

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

Formats the value using the given formatter.

impl Display for Token

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

Formats the value using the given formatter.

impl Hash for Token

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<I> Parser<I, TokenWithLocation, ContextError> for Token

where I: TokenStream,

fn parse_next( &mut self, input: &mut I, ) -> PResult<TokenWithLocation, ContextError>

Take tokens from the [Stream], turning it into the output

fn parse_peek(&mut self, input: I) -> Result<(I, O), ErrMode<E>>

Take tokens from the [Stream], turning it into the output

fn by_ref(&mut self) -> ByRef<'_, Self>

where Self: Sized,

Treat &mut Self as a parser

fn value<O2>(self, val: O2) -> Value<Self, I, O, O2, E>

where Self: Sized, O2: Clone,

Produce the provided value

fn default_value<O2>(self) -> DefaultValue<Self, I, O, O2, E>

where Self: Sized, O2: Default,

Produce a type’s default value

fn void(self) -> Void<Self, I, O, E>

where Self: Sized,

Discards the output of the Parser

fn output_into<O2>(self) -> OutputInto<Self, I, O, O2, E>

where Self: Sized, O: Into<O2>,

Convert the parser’s output to another type using std::convert::From

fn recognize(self) -> Recognize<Self, I, O, E>

where Self: Sized, I: Stream,

Produce the consumed input as produced value.

fn with_recognized(self) -> WithRecognized<Self, I, O, E>

where Self: Sized, I: Stream,

Produce the consumed input with the output

fn map<G, O2>(self, map: G) -> Map<Self, G, I, O, O2, E>

where G: FnMut(O) -> O2, Self: Sized,

Maps a function over the output of a parser

fn try_map<G, O2, E2>(self, map: G) -> TryMap<Self, G, I, O, O2, E, E2>

where Self: Sized, G: FnMut(O) -> Result<O2, E2>, I: Stream, E: FromExternalError<I, E2>,

Applies a function returning a Result over the output of a parser.

fn verify_map<G, O2>(self, map: G) -> VerifyMap<Self, G, I, O, O2, E>

where Self: Sized, G: FnMut(O) -> Option<O2>, I: Stream, E: ParserError<I>,

Apply both [Parser::verify] and [Parser::map].

fn flat_map<G, H, O2>(self, map: G) -> FlatMap<Self, G, H, I, O, O2, E>

where Self: Sized, G: FnMut(O) -> H, H: Parser<I, O2, E>,

Creates a parser from the output of this one

fn parse_to<O2>(self) -> ParseTo<Self, I, O, O2, E>

where Self: Sized, I: Stream, O: ParseSlice<O2>, E: ParserError<I>,

Apply std::str::FromStr to the output of the parser

fn verify<G, O2>(self, filter: G) -> Verify<Self, G, I, O, O2, E>

where Self: Sized, G: FnMut(&O2) -> bool, I: Stream, O: Borrow<O2>, E: ParserError<I>, O2: ?Sized,

Returns the output of the child parser if it satisfies a verification function.

fn context<C>(self, context: C) -> Context<Self, I, O, E, C>

where Self: Sized, I: Stream, E: AddContext<I, C>, C: Clone + Debug,

If parsing fails, add context to the error

fn complete_err(self) -> CompleteErr<Self>

where Self: Sized,

Transforms [Incomplete][crate::error::ErrMode::Incomplete] into [Backtrack][crate::error::ErrMode::Backtrack]

fn err_into<E2>(self) -> ErrInto<Self, I, O, E, E2>

where Self: Sized, E: Into<E2>,

Convert the parser’s error to another type using std::convert::From

impl PartialEq<Token> for TokenWithLocation

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<TokenWithLocation> for Token

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq for Token

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Token

impl StructuralPartialEq for Token