Type Alias PragmaValue

pub type PragmaValue = Expr;

PRAGMA value

Aliased Type

pub enum PragmaValue {
    Between {
        lhs: Box<Expr>,
        not: bool,
        start: Box<Expr>,
        end: Box<Expr>,
    },
    Binary(Box<Expr>, Operator, Box<Expr>),
    Case {
        base: Option<Box<Expr>>,
        when_then_pairs: Vec<(Expr, Expr)>,
        else_expr: Option<Box<Expr>>,
    },
    Cast {
        expr: Box<Expr>,
        type_name: Option<Type>,
    },
    Collate(Box<Expr>, Box<str>),
    DoublyQualified(Name, Name, Name),
    Exists(Box<Select>),
    FunctionCall {
        name: Id,
        distinctness: Option<Distinctness>,
        args: Option<Vec<Expr>>,
        order_by: Option<FunctionCallOrder>,
        filter_over: Option<FunctionTail>,
    },
    FunctionCallStar {
        name: Id,
        filter_over: Option<FunctionTail>,
    },
    Id(Id),
    InList {
        lhs: Box<Expr>,
        not: bool,
        rhs: Option<Vec<Expr>>,
    },
    InSelect {
        lhs: Box<Expr>,
        not: bool,
        rhs: Box<Select>,
    },
    InTable {
        lhs: Box<Expr>,
        not: bool,
        rhs: QualifiedName,
        args: Option<Vec<Expr>>,
    },
    IsNull(Box<Expr>),
    Like {
        lhs: Box<Expr>,
        not: bool,
        op: LikeOperator,
        rhs: Box<Expr>,
        escape: Option<Box<Expr>>,
    },
    Literal(Literal),
    Name(Name),
    NotNull(Box<Expr>),
    Parenthesized(Vec<Expr>),
    Qualified(Name, Name),
    Raise(ResolveType, Option<Box<Expr>>),
    Subquery(Box<Select>),
    Unary(UnaryOperator, Box<Expr>),
    Variable(Box<str>),
}

Variants

Between

BETWEEN

Fields

lhs: Box<Expr>

expression

not: bool

NOT

start: Box<Expr>

start

end: Box<Expr>

end

Binary(Box<Expr>, Operator, Box<Expr>)

binary expression

Case

CASE expression

Fields

base: Option<Box<Expr>>

operand

when_then_pairs: Vec<(Expr, Expr)>

WHEN condition THEN result

else_expr: Option<Box<Expr>>

ELSE result

Cast

CAST expression

Fields

expr: Box<Expr>

expression

type_name: Option<Type>

AS type name

Collate(Box<Expr>, Box<str>)

COLLATE: expression

DoublyQualified(Name, Name, Name)

schema-name.table-name.column-name

Exists(Box<Select>)

EXISTS subquery

FunctionCall

call to a built-in function

Fields

name: Id

function name

distinctness: Option<Distinctness>

DISTINCT

args: Option<Vec<Expr>>

arguments

order_by: Option<FunctionCallOrder>

ORDER BY or WITHIN GROUP

filter_over: Option<FunctionTail>

FILTER

FunctionCallStar

Function call expression with ‘*’ as arg

Fields

name: Id

function name

filter_over: Option<FunctionTail>

FILTER

Id(Id)

Identifier

InList

IN

Fields

lhs: Box<Expr>

expression

not: bool

NOT

rhs: Option<Vec<Expr>>

values

InSelect

IN subselect

Fields

lhs: Box<Expr>

expression

not: bool

NOT

rhs: Box<Select>

subquery

InTable

IN table name / function

Fields

lhs: Box<Expr>

expression

not: bool

NOT

rhs: QualifiedName

table name

args: Option<Vec<Expr>>

table function arguments

IsNull(Box<Expr>)

IS NULL

Like

LIKE

Fields

lhs: Box<Expr>

expression

not: bool

NOT

op: LikeOperator

operator

rhs: Box<Expr>

pattern

escape: Option<Box<Expr>>

ESCAPE char

Literal(Literal)

Literal expression

Name(Name)

Name

NotNull(Box<Expr>)

NOT NULL or NOTNULL

Parenthesized(Vec<Expr>)

Parenthesized subexpression

Qualified(Name, Name)

Qualified name

Raise(ResolveType, Option<Box<Expr>>)

RAISE function call

Subquery(Box<Select>)

Subquery expression

Unary(UnaryOperator, Box<Expr>)

Unary expression

Variable(Box<str>)

Parameters