Enum Expression 

pub enum Expression {
    Column {
        column: ColumnRef,
    },
    Literal {
        value: TypedValue,
    },
    Star {
        relation: Option<String>,
    },
    Unary {
        operator: UnaryOperator,
        expression: Box<Expression>,
    },
    Binary {
        left: Box<Expression>,
        operator: BinaryOperator,
        right: Box<Expression>,
    },
    Function {
        name: String,
        arguments: Vec<Expression>,
    },
    Aggregate {
        name: String,
        arguments: Vec<Expression>,
        distinct: bool,
        filter: Option<Box<Expression>>,
        order_by: Vec<OrderBy>,
    },
    Window {
        function: Box<Expression>,
        specification: WindowSpecification,
    },
    Cast {
        expression: Box<Expression>,
        data_type: DataTypeDescriptor,
    },
    Case {
        operand: Option<Box<Expression>>,
        branches: Vec<CaseBranch>,
        otherwise: Option<Box<Expression>>,
    },
    IsNull {
        expression: Box<Expression>,
        negated: bool,
    },
    Between {
        expression: Box<Expression>,
        lower: Box<Expression>,
        upper: Box<Expression>,
        negated: bool,
    },
    InList {
        expression: Box<Expression>,
        values: Vec<Expression>,
        negated: bool,
    },
    InSubquery {
        expression: Box<Expression>,
        query: Box<Select>,
        negated: bool,
    },
    Exists {
        query: Box<Select>,
        negated: bool,
    },
    ScalarSubquery {
        query: Box<Select>,
    },
    Tuple {
        values: Vec<Expression>,
    },
    Navigation {
        root: String,
        path: Vec<String>,
    },
    Grouping {
        expressions: Vec<Expression>,
    },
}

Variants

Column

Fields

column: ColumnRef

Literal

Fields

value: TypedValue

Star

Fields

relation: Option<String>

Unary

Fields

operator: UnaryOperator

expression: Box<Expression>

Binary

Fields

left: Box<Expression>

operator: BinaryOperator

right: Box<Expression>

Function

Fields

name: String

arguments: Vec<Expression>

Aggregate

Fields

name: String

arguments: Vec<Expression>

distinct: bool

filter: Option<Box<Expression>>

order_by: Vec<OrderBy>

Window

Fields

function: Box<Expression>

specification: WindowSpecification

Cast

Fields

expression: Box<Expression>

data_type: DataTypeDescriptor

Case

Fields

operand: Option<Box<Expression>>

branches: Vec<CaseBranch>

otherwise: Option<Box<Expression>>

IsNull

Fields

expression: Box<Expression>

negated: bool

Between

Fields

expression: Box<Expression>

lower: Box<Expression>

upper: Box<Expression>

negated: bool

InList

Fields

expression: Box<Expression>

values: Vec<Expression>

negated: bool

InSubquery

Fields

expression: Box<Expression>

query: Box<Select>

negated: bool

Exists

Fields

query: Box<Select>

negated: bool

ScalarSubquery

Fields

query: Box<Select>

Tuple

Fields

values: Vec<Expression>

Navigation

Read-only RadixDB navigation path. root is a table alias and every path segment is an authoritative reference/column identifier.

Fields

root: String

path: Vec<String>

Grouping

Fields

expressions: Vec<Expression>

Implementations

impl Expression

pub fn column(name: impl Into<String>) -> Self

pub fn literal(value: TypedValue) -> Self

Trait Implementations

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 From<Expression> for Expr

fn from(value: Expression) -> Self

Converts to this type from the input type.

impl PartialEq for Expression

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

Equality operator ==.

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

Inequality operator !=.

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 StructuralPartialEq for Expression