Enum SqlTransform

pub enum SqlTransform<Rel = RIId, Super = Transform> {
    Super(Super),
    From(Rel),
    Select(Vec<CId>),
    Filter(Expr),
    Aggregate {
        partition: Vec<CId>,
        compute: Vec<CId>,
    },
    Sort(Vec<ColumnSort<CId>>),
    Take(Take),
    Join {
        side: JoinSide,
        with: Rel,
        filter: Expr,
    },
    Distinct,
    DistinctOn(Vec<CId>),
    Except {
        bottom: Rel,
        distinct: bool,
    },
    Intersect {
        bottom: Rel,
        distinct: bool,
    },
    Union {
        bottom: Rel,
        distinct: bool,
    },
}

Similar to rq::Transform, but closer to a SQL clause.

Uses two generic args that allows the compiler to work in multiple stages:

• the first converts RQ to SqlTransform<RIId, rq::Transform>,
• the second compiles that to [SqlTransform<RelationExpr, ()>].

Variants

Super(Super)

Contains rq::Transform during compilation. After finishing, this is emptied.

For example, initial an RQ Append transform is wrapped as such:

rq::Transform::Append(x) -> srq::SqlTransform::Super(rq::Transform::Append(x))

During preprocessing it is compiled to:

srq::SqlTransform::Super(rq::Transform::Append(_)) -> srq::SqlTransform::Union { .. }

At the end of SRQ compilation, all Super() are either discarded or converted to their SRQ equivalents.

From(Rel)

Select(Vec<CId>)

Filter(Expr)

Aggregate

Fields

partition: Vec<CId>

compute: Vec<CId>

Sort(Vec<ColumnSort<CId>>)

Take(Take)

Join

Fields

side: JoinSide

with: Rel

filter: Expr

Distinct

DistinctOn(Vec<CId>)

Except

Fields

bottom: Rel

distinct: bool

Intersect

Fields

bottom: Rel

distinct: bool

Union

Fields

bottom: Rel

distinct: bool

Implementations

impl<Rel, Super> SqlTransform<Rel, Super>

pub fn is_super(&self) -> bool

Returns true if this is a SqlTransform::Super, otherwise false

pub fn as_super_mut(&mut self) -> Option<&mut Super>

Optionally returns mutable references to the inner fields if this is a SqlTransform::Super, otherwise None

pub fn as_super(&self) -> Option<&Super>

Optionally returns references to the inner fields if this is a SqlTransform::Super, otherwise None

pub fn into_super(self) -> Result<Super, SqlTransform<Rel, Super>>

Returns the inner fields if this is a SqlTransform::Super, otherwise returns back the enum in the Err case of the result

pub fn is_from(&self) -> bool

Returns true if this is a SqlTransform::From, otherwise false

pub fn as_from_mut(&mut self) -> Option<&mut Rel>

Optionally returns mutable references to the inner fields if this is a SqlTransform::From, otherwise None

pub fn as_from(&self) -> Option<&Rel>

Optionally returns references to the inner fields if this is a SqlTransform::From, otherwise None

pub fn into_from(self) -> Result<Rel, SqlTransform<Rel, Super>>

Returns the inner fields if this is a SqlTransform::From, otherwise returns back the enum in the Err case of the result

pub fn is_select(&self) -> bool

Returns true if this is a SqlTransform::Select, otherwise false

pub fn as_select_mut(&mut self) -> Option<&mut Vec<CId>>

Optionally returns mutable references to the inner fields if this is a SqlTransform::Select, otherwise None

pub fn as_select(&self) -> Option<&Vec<CId>>

Optionally returns references to the inner fields if this is a SqlTransform::Select, otherwise None

pub fn into_select(self) -> Result<Vec<CId>, SqlTransform<Rel, Super>>

Returns the inner fields if this is a SqlTransform::Select, otherwise returns back the enum in the Err case of the result

pub fn is_filter(&self) -> bool

Returns true if this is a SqlTransform::Filter, otherwise false

pub fn as_filter_mut(&mut self) -> Option<&mut Expr>

Optionally returns mutable references to the inner fields if this is a SqlTransform::Filter, otherwise None

pub fn as_filter(&self) -> Option<&Expr>

Optionally returns references to the inner fields if this is a SqlTransform::Filter, otherwise None

pub fn into_filter(self) -> Result<Expr, SqlTransform<Rel, Super>>

Returns the inner fields if this is a SqlTransform::Filter, otherwise returns back the enum in the Err case of the result

pub fn is_aggregate(&self) -> bool

Returns true if this is a SqlTransform::Aggregate, otherwise false

pub fn as_aggregate_mut(&mut self) -> Option<(&mut Vec<CId>, &mut Vec<CId>)>

Optionally returns mutable references to the inner fields if this is a SqlTransform::Aggregate, otherwise None

pub fn as_aggregate(&self) -> Option<(&Vec<CId>, &Vec<CId>)>

Optionally returns references to the inner fields if this is a SqlTransform::Aggregate, otherwise None

pub fn into_aggregate( self, ) -> Result<(Vec<CId>, Vec<CId>), SqlTransform<Rel, Super>>

Returns the inner fields if this is a SqlTransform::Aggregate, otherwise returns back the enum in the Err case of the result

pub fn is_sort(&self) -> bool

Returns true if this is a SqlTransform::Sort, otherwise false

pub fn as_sort_mut(&mut self) -> Option<&mut Vec<ColumnSort<CId>>>

Optionally returns mutable references to the inner fields if this is a SqlTransform::Sort, otherwise None

pub fn as_sort(&self) -> Option<&Vec<ColumnSort<CId>>>

Optionally returns references to the inner fields if this is a SqlTransform::Sort, otherwise None

pub fn into_sort(self) -> Result<Vec<ColumnSort<CId>>, SqlTransform<Rel, Super>>

Returns the inner fields if this is a SqlTransform::Sort, otherwise returns back the enum in the Err case of the result

pub fn is_take(&self) -> bool

Returns true if this is a SqlTransform::Take, otherwise false

pub fn as_take_mut(&mut self) -> Option<&mut Take>

Optionally returns mutable references to the inner fields if this is a SqlTransform::Take, otherwise None

pub fn as_take(&self) -> Option<&Take>

Optionally returns references to the inner fields if this is a SqlTransform::Take, otherwise None

pub fn into_take(self) -> Result<Take, SqlTransform<Rel, Super>>

Returns the inner fields if this is a SqlTransform::Take, otherwise returns back the enum in the Err case of the result

pub fn is_join(&self) -> bool

Returns true if this is a SqlTransform::Join, otherwise false

pub fn as_join_mut(&mut self) -> Option<(&mut JoinSide, &mut Rel, &mut Expr)>

Optionally returns mutable references to the inner fields if this is a SqlTransform::Join, otherwise None

pub fn as_join(&self) -> Option<(&JoinSide, &Rel, &Expr)>

Optionally returns references to the inner fields if this is a SqlTransform::Join, otherwise None

pub fn into_join( self, ) -> Result<(JoinSide, Rel, Expr), SqlTransform<Rel, Super>>

Returns the inner fields if this is a SqlTransform::Join, otherwise returns back the enum in the Err case of the result

pub fn is_distinct(&self) -> bool

Returns true if this is a SqlTransform::Distinct, otherwise false

pub fn is_distinct_on(&self) -> bool

Returns true if this is a SqlTransform::DistinctOn, otherwise false

pub fn as_distinct_on_mut(&mut self) -> Option<&mut Vec<CId>>

Optionally returns mutable references to the inner fields if this is a SqlTransform::DistinctOn, otherwise None

pub fn as_distinct_on(&self) -> Option<&Vec<CId>>

Optionally returns references to the inner fields if this is a SqlTransform::DistinctOn, otherwise None

pub fn into_distinct_on(self) -> Result<Vec<CId>, SqlTransform<Rel, Super>>

Returns the inner fields if this is a SqlTransform::DistinctOn, otherwise returns back the enum in the Err case of the result

pub fn is_except(&self) -> bool

Returns true if this is a SqlTransform::Except, otherwise false

pub fn as_except_mut(&mut self) -> Option<(&mut Rel, &mut bool)>

Optionally returns mutable references to the inner fields if this is a SqlTransform::Except, otherwise None

pub fn as_except(&self) -> Option<(&Rel, &bool)>

Optionally returns references to the inner fields if this is a SqlTransform::Except, otherwise None

pub fn into_except(self) -> Result<(Rel, bool), SqlTransform<Rel, Super>>

Returns the inner fields if this is a SqlTransform::Except, otherwise returns back the enum in the Err case of the result

pub fn is_intersect(&self) -> bool

Returns true if this is a SqlTransform::Intersect, otherwise false

pub fn as_intersect_mut(&mut self) -> Option<(&mut Rel, &mut bool)>

Optionally returns mutable references to the inner fields if this is a SqlTransform::Intersect, otherwise None

pub fn as_intersect(&self) -> Option<(&Rel, &bool)>

Optionally returns references to the inner fields if this is a SqlTransform::Intersect, otherwise None

pub fn into_intersect(self) -> Result<(Rel, bool), SqlTransform<Rel, Super>>

Returns the inner fields if this is a SqlTransform::Intersect, otherwise returns back the enum in the Err case of the result

pub fn is_union(&self) -> bool

Returns true if this is a SqlTransform::Union, otherwise false

pub fn as_union_mut(&mut self) -> Option<(&mut Rel, &mut bool)>

Optionally returns mutable references to the inner fields if this is a SqlTransform::Union, otherwise None

pub fn as_union(&self) -> Option<(&Rel, &bool)>

Optionally returns references to the inner fields if this is a SqlTransform::Union, otherwise None

pub fn into_union(self) -> Result<(Rel, bool), SqlTransform<Rel, Super>>

Returns the inner fields if this is a SqlTransform::Union, otherwise returns back the enum in the Err case of the result

impl<Rel> SqlTransform<Rel>

pub fn as_str(&self) -> &str

pub fn into_super_and<T, F>(self, f: F) -> Result<T, SqlTransform<Rel>>

where F: FnOnce(Transform) -> Result<T, Transform>,

Trait Implementations

impl<Rel, Super> AsRef<str> for SqlTransform<Rel, Super>

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl<Rel, Super> Clone for SqlTransform<Rel, Super>

where Rel: Clone, Super: Clone,

fn clone(&self) -> SqlTransform<Rel, Super>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Rel, Super> Debug for SqlTransform<Rel, Super>

where Rel: Debug, Super: Debug,

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

Formats the value using the given formatter.

impl<Rel, Super> Serialize for SqlTransform<Rel, Super>

where Rel: Serialize, Super: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.