Enum Expr 

pub enum Expr {
    Literal(Literal),
    Param(Param),
    Idiom(Idiom),
    Table(TableName),
    Mock(Mock),
    Block(Box<Block>),
    Constant(Constant),
    Prefix {
        op: PrefixOperator,
        expr: Box<Expr>,
    },
    Postfix {
        expr: Box<Expr>,
        op: PostfixOperator,
    },
    Binary {
        left: Box<Expr>,
        op: BinaryOperator,
        right: Box<Expr>,
    },
    FunctionCall(Box<FunctionCall>),
    Closure(Box<ClosureExpr>),
    Break,
    Continue,
    Return(Box<OutputStatement>),
    Throw(Box<Expr>),
    IfElse(Box<IfelseStatement>),
    Select(Box<SelectStatement>),
    Create(Box<CreateStatement>),
    Update(Box<UpdateStatement>),
    Upsert(Box<UpsertStatement>),
    Delete(Box<DeleteStatement>),
    Relate(Box<RelateStatement>),
    Insert(Box<InsertStatement>),
    Define(Box<DefineStatement>),
    Remove(Box<RemoveStatement>),
    Rebuild(Box<RebuildStatement>),
    Alter(Box<AlterStatement>),
    Info(Box<InfoStatement>),
    Foreach(Box<ForeachStatement>),
    Let(Box<SetStatement>),
    Sleep(Box<SleepStatement>),
    Explain {
        format: ExplainFormat,
        analyze: bool,
        statement: Box<Expr>,
    },
    Match(Box<MatchPlan>),
}

Variants

Literal(Literal)

Param(Param)

Idiom(Idiom)

Table(TableName)

Mock(Mock)

Block(Box<Block>)

Constant(Constant)

Prefix

Fields

op: PrefixOperator

expr: Box<Expr>

Postfix

Fields

expr: Box<Expr>

op: PostfixOperator

Binary

Fields

left: Box<Expr>

op: BinaryOperator

right: Box<Expr>

FunctionCall(Box<FunctionCall>)

Closure(Box<ClosureExpr>)

Break

Continue

Return(Box<OutputStatement>)

Throw(Box<Expr>)

IfElse(Box<IfelseStatement>)

Select(Box<SelectStatement>)

Create(Box<CreateStatement>)

Update(Box<UpdateStatement>)

Upsert(Box<UpsertStatement>)

Delete(Box<DeleteStatement>)

Relate(Box<RelateStatement>)

Insert(Box<InsertStatement>)

Define(Box<DefineStatement>)

Remove(Box<RemoveStatement>)

Rebuild(Box<RebuildStatement>)

Alter(Box<AlterStatement>)

Info(Box<InfoStatement>)

Foreach(Box<ForeachStatement>)

Let(Box<SetStatement>)

Sleep(Box<SleepStatement>)

Explain

Fields

format: ExplainFormat

analyze: bool

statement: Box<Expr>

Match(Box<MatchPlan>)

An GQL MATCH query, lowered to its declarative binding-table plan.

Only constructed by the GQL lowering at top level. It runs exclusively under the streaming execution planner; see the compute and From<expr::Expr> for sql::Expr arms for the invariants it relies on.

Implementations

impl Expr

pub fn read_only(&self) -> bool

Check if this expression does only reads.

pub fn from_public_value(value: PublicValue) -> Self

impl Expr

pub fn as_static_value(&self) -> Option<Value>

The value this expression denotes, when it denotes one without being evaluated.

Only a literal can answer this; every other form either reads the environment or needs the evaluator, so it answers None. See Literal::as_static_value for the contract the result upholds.

Narrower than Self::is_static, which is also true of expressions that are computable without the environment but still need evaluating (arithmetic on literals, say).

pub fn is_static(&self) -> bool

Checks if a expression is ‘pure’ i.e. does not rely on the environment.

pub fn to_idiom(&self) -> Idiom

pub fn to_raw_string(&self) -> String

impl Expr

pub fn to_stored_sql(&self) -> String

Renders the canonical SurrealQL text a catalog definition stores for this expression (e.g. a StoredFieldDefinition.value), matching exactly what the old sql::Expr-embedding definition used to render when nested after a clause keyword (VALUE, ASSERT, WHEN, …) — including the parenthesization CoverStmts applies to statement-shaped sub-expressions (e.g. a nested SELECT), so the stored text is safe to splice back in after that keyword with no further wrapping.

Expr::Match never reaches a stored definition (see ToSql’s carve-out above), so unlike ToSql::fmt_sql this does not special-case it.

impl Expr

pub fn function_facts(&self) -> FunctionFacts

Extract this tree’s FunctionFacts.

impl Expr

pub fn contains_mutation(&self) -> bool

Whether this expression’s own tree contains a data-modifying statement, looking through subqueries, idiom parts, blocks and closure bodies.

A call to a user-defined function, script, module or silo is opaque: its body lives outside this expression, and is left to the runtime write refusal. Arguments to such a call are walked, since they are evaluated at the call site.

Trait Implementations

impl Clone for Expr

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 Expr

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

Formats the value using the given formatter.

impl DeserializeRevisioned for Expr

fn deserialize_revisioned<R: Read>(reader: &mut R) -> Result<Self, Error>

Deserializes a new instance of the struct from the specified reader.

impl Eq for Expr

impl From<Expr> for Expr

fn from(v: Expr) -> Self

Converts to this type from the input type.

impl From<Expr> for Expr

fn from(v: Expr) -> Self

Converts to this type from the input type.

impl From<Range> for Expr

fn from(r: Range) -> Self

Converts to this type from the input type.

impl Hash for Expr

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 InfoStructure for Expr

fn structure(self) -> Value

impl LengthPrefixedBytes for Expr

impl PartialEq for Expr

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

Equality operator ==.

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

Inequality operator !=.

impl Revisioned for Expr

fn revision() -> u16

Returns the current revision of this type.

fn type_id() -> TypeId

where Self: 'static,

Returns the type id of this type.

impl SerializeRevisioned for Expr

fn serialize_revisioned<W: Write>(&self, writer: &mut W) -> Result<(), Error>

Serializes the struct using the specified writer.

impl SkipRevisioned for Expr

fn skip_revisioned<R: Read>(reader: &mut R) -> Result<(), Error>

fn skip_revisioned_slice(r: &mut SliceReader<'_>) -> Result<(), Error>

Consume through bytes backed by SliceReader without allocating a buffer for bulk segments.

impl StructuralPartialEq for Expr

impl ToSql for Expr

fn fmt_sql(&self, f: &mut String, fmt: SqlFormat)

Format the type to a SQL string.

fn to_sql(&self) -> String

Convert the type to a SQL string.

fn to_sql_pretty(&self) -> String

Convert the type to a pretty-printed SQL string with indentation.

impl<V: Visitor> Visit<V> for Expr

fn visit(&self, this: &mut V) -> Result<(), V::Error>

impl<V: MutVisitor> VisitMut<V> for Expr

fn visit_mut(&mut self, this: &mut V) -> Result<(), V::Error>

impl WalkRevisioned for Expr

type Walker<'r, R: BorrowedReader + 'r> = LeafWalker<'r, Expr, R>

Walker produced by walk_revisioned.

fn walk_revisioned<'r, R: BorrowedReader>( reader: &'r mut R, ) -> Result<Self::Walker<'r, R>, Error>

Read the type’s revision-level prefix and return a walker positioned at the start of the body.