Enum prql_compiler::ast::query::Transform

pub enum Transform {
    From(TableRef),
    Select(Vec<Node>),
    Filter(Box<Node>),
    Derive(Vec<Node>),
    Aggregate {
        assigns: Vec<Node>,
        by: Vec<Node>,
    },
    Sort(Vec<ColumnSort<Node>>),
    Take {
        range: Range,
        by: Vec<Node>,
        sort: Vec<ColumnSort<Node>>,
    },
    Join {
        side: JoinSide,
        with: TableRef,
        filter: JoinFilter,
    },
    Group {
        by: Vec<Node>,
        pipeline: Box<Node>,
    },
    Window {
        kind: WindowKind,
        range: Range,
        pipeline: Box<Node>,
    },
    Unique,
}

Transform is a stage of a pipeline. It is created from a FuncCall during parsing.

Variants

From(TableRef)

Select(Vec<Node>)

Filter(Box<Node>)

Derive(Vec<Node>)

Aggregate

Fields

assigns: Vec<Node>

by: Vec<Node>

Sort(Vec<ColumnSort<Node>>)

Take

Fields

range: Range

by: Vec<Node>

sort: Vec<ColumnSort<Node>>

Join

Fields

side: JoinSide

with: TableRef

filter: JoinFilter

Group

Fields

by: Vec<Node>

pipeline: Box<Node>

Window

Fields

kind: WindowKind

range: Range

pipeline: Box<Node>

Unique

Trait Implementations

impl AsRef<str> for Transform

fn as_ref(&self) -> &str

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

impl Clone for Transform

fn clone(&self) -> Transform

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Transform

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Transform

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq<Transform> for Transform

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Transform

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 Transform