Enum Expression 

pub enum Expression {
    Identifier(Identifier),
    Literal(Literal),
    Binary {
        left: Box<Expression>,
        op: BinaryOperator,
        right: Box<Expression>,
        span: Range<usize>,
    },
    Unary {
        op: UnaryOperator,
        expr: Box<Expression>,
        span: Range<usize>,
    },
    FunctionCall {
        name: Identifier,
        args: Vec<Expression>,
        span: Range<usize>,
    },
    InList {
        expr: Box<Expression>,
        list: Vec<Expression>,
        negated: bool,
        span: Range<usize>,
    },
    Between {
        expr: Box<Expression>,
        low: Box<Expression>,
        high: Box<Expression>,
        negated: bool,
        span: Range<usize>,
    },
    Subquery {
        query: Box<SelectStatement>,
        span: Range<usize>,
    },
    InSubquery {
        expr: Box<Expression>,
        query: Box<SelectStatement>,
        negated: bool,
        span: Range<usize>,
    },
    Error {
        message: Arc<str>,
        span: Range<usize>,
    },
}

Represents an SQL expression.

Variants

Identifier(Identifier)

An identifier expression.

Literal(Literal)

A literal value expression.

Binary

A binary operation expression.

Fields

left: Box<Expression>

The left-hand side of the binary operation.

op: BinaryOperator

The binary operator.

right: Box<Expression>

The right-hand side of the binary operation.

span: Range<usize>

The span of the binary operation.

Unary

A unary operation expression.

Fields

op: UnaryOperator

The unary operator.

expr: Box<Expression>

The expression being operated on.

span: Range<usize>

The span of the unary operation.

FunctionCall

A function call expression.

Fields

name: Identifier

The name of the function being called.

args: Vec<Expression>

The arguments passed to the function.

span: Range<usize>

The span of the function call.

InList

An IN expression.

Fields

expr: Box<Expression>

The expression being checked.

list: Vec<Expression>

The list of values to check against.

negated: bool

Whether the IN condition is negated (NOT IN).

span: Range<usize>

The span of the IN expression.

Between

A BETWEEN expression.

Fields

expr: Box<Expression>

The expression being checked.

low: Box<Expression>

The lower bound of the range.

high: Box<Expression>

The upper bound of the range.

negated: bool

Whether the BETWEEN condition is negated (NOT BETWEEN).

span: Range<usize>

The span of the BETWEEN expression.

Subquery

A subquery expression.

Fields

query: Box<SelectStatement>

The subquery SELECT statement.

span: Range<usize>

The span of the subquery.

InSubquery

An IN expression with a subquery.

Fields

expr: Box<Expression>

The expression being checked.

query: Box<SelectStatement>

The subquery to check against.

negated: bool

Whether the IN condition is negated (NOT IN).

span: Range<usize>

The span of the IN expression.

Error

An error occurred during expression parsing or building.

Fields

message: Arc<str>

The error message.

span: Range<usize>

The span where the error occurred.

Implementations

impl Expression

pub fn span(&self) -> Range<usize>

Trait Implementations

impl AsDocument for Expression

Available on crate feature oak-pretty-print only.

fn as_document(&self) -> Document<'_>

Converts this type to a document for pretty printing.

impl Clone for Expression

fn clone(&self) -> Expression

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expression

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Expression

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Expression

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl ToSource for Expression

fn to_source(&self, buffer: &mut SourceBuffer)

Writes the source code representation of this type to the provided buffer.

fn to_source_string(&self) -> String

Converts this type to a source code string.