Enum Rel 

pub enum Rel {
    Scan {
        source: SourceName,
        table: TableName,
        bind: BindingName,
    },
    Values {
        bind: BindingName,
        row_type: RowType,
        rows: Vec<Row>,
    },
    Project {
        input: Box<Rel>,
        bind: BindingName,
        fields: Vec<NamedScalar>,
    },
    Filter {
        input: Box<Rel>,
        predicate: Scalar,
    },
    Join {
        left: Box<Rel>,
        right: Box<Rel>,
        kind: JoinKind,
        on: Scalar,
    },
    Group {
        input: Box<Rel>,
        bind: BindingName,
        keys: Vec<NamedScalar>,
        aggregates: Vec<NamedAggregate>,
        having: Option<Scalar>,
    },
    Set {
        op: SetOp,
        inputs: Vec<Rel>,
    },
    Distinct(Box<Rel>),
    Order {
        input: Box<Rel>,
        keys: Vec<OrderKey>,
    },
    Limit {
        input: Box<Rel>,
        count: Option<u64>,
        offset: u64,
    },
}

Complete logical relation algebra.

Variants

Scan

Catalog table scan.

Fields

source: SourceName

Provider source.

table: TableName

Schema table.

bind: BindingName

Introduced binding.

Values

Bounded literal rows.

Fields

bind: BindingName

Introduced binding.

row_type: RowType

Declared row type.

rows: Vec<Row>

Rows.

Project

Projection.

Fields

input: Box<Rel>

Input.

bind: BindingName

Introduced output binding.

fields: Vec<NamedScalar>

Fields.

Filter

Predicate filter.

Fields

input: Box<Rel>

Input.

predicate: Scalar

Boolean predicate.

Join

Binary join.

Fields

left: Box<Rel>

Left relation.

right: Box<Rel>

Right relation.

kind: JoinKind

Kind.

on: Scalar

Boolean condition; ignored only for cross joins.

Group

Grouped projection.

Fields

input: Box<Rel>

Input.

bind: BindingName

Introduced output binding.

keys: Vec<NamedScalar>

Group keys.

aggregates: Vec<NamedAggregate>

Aggregates.

having: Option<Scalar>

Post-aggregate predicate.

Set

Compatible set operation.

Fields

op: SetOp

Operation.

inputs: Vec<Rel>

Two or more inputs.

Distinct(Box<Rel>)

Duplicate elimination.

Order

Stable ordering.

Fields

input: Box<Rel>

Input.

keys: Vec<OrderKey>

Ordering keys.

Limit

Bounded result window.

Fields

input: Box<Rel>

Input.

count: Option<u64>

Optional maximum rows.

offset: u64

Rows skipped.

Trait Implementations

impl Clone for Rel

fn clone(&self) -> Rel

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Rel

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

Formats the value using the given formatter.

impl Eq for Rel

impl PartialEq for Rel

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Rel