Struct LogicalPlanBuilder

pub struct LogicalPlanBuilder { /* private fields */ }

Implements a struct to hold the current Relation which represents an unresolved Logical Plan

Implementations

impl LogicalPlanBuilder

pub fn new(relation: Relation) -> LogicalPlanBuilder

Create a new Logical Plan from an initial spark::Relation

pub fn relation(self) -> Relation

pub fn plan_id(self) -> i64

pub fn relation_input(self) -> Option<Box<Relation>>

pub fn plan_root(self) -> Plan

Build the Spark spark::Plan for a Relation

pub fn plan_cmd(command_type: CommandType) -> Plan

Build the Spark spark::Plan for a spark::command::CommandType

pub fn alias(self, alias: &str) -> LogicalPlanBuilder

Create a relation from an existing LogicalPlanBuilder this will add additional actions to the Relation

pub fn aggregate<I, S>( input: LogicalPlanBuilder, group_type: GroupType, grouping_cols: Vec<Expression>, agg_expression: I, pivot_col: Option<Expression>, pivot_vals: Option<Vec<Literal>>, ) -> LogicalPlanBuilder

where I: IntoIterator<Item = S>, S: Into<Column>,

pub fn unpivot( self, ids: Vec<Expression>, values: Option<Vec<Expression>>, variable_column_name: &str, value_column_name: &str, ) -> LogicalPlanBuilder

pub fn local_relation( batch: &RecordBatch, ) -> Result<LogicalPlanBuilder, SparkError>

pub fn corr( self, col1: impl AsRef<str>, col2: impl AsRef<str>, ) -> LogicalPlanBuilder

pub fn cov( self, col1: impl AsRef<str>, col2: impl AsRef<str>, ) -> LogicalPlanBuilder

pub fn crosstab(self, col1: &str, col2: &str) -> LogicalPlanBuilder

pub fn describe<I, T>(self, cols: Option<I>) -> LogicalPlanBuilder

where I: IntoIterator<Item = T>, T: AsRef<str>,

pub fn distinct(self) -> LogicalPlanBuilder

pub fn drop<I, S>(self, cols: I) -> LogicalPlanBuilder

where I: IntoIterator<Item = S>, S: Into<Column>,

pub fn drop_duplicates<I, T>( self, cols: Option<I>, within_watermark: bool, ) -> LogicalPlanBuilder

where I: IntoIterator<Item = T>, T: AsRef<str>,

pub fn dropna<I, T>( self, how: &str, threshold: Option<i32>, subset: Option<I>, ) -> LogicalPlanBuilder

where I: IntoIterator<Item = T>, T: AsRef<str>,

pub fn fillna<I, T, L>(self, cols: Option<I>, values: T) -> LogicalPlanBuilder

where I: IntoIterator<Item: AsRef<str>>, T: IntoIterator<Item = L>, L: Into<Literal>,

pub fn to_df<I>(self, cols: I) -> LogicalPlanBuilder

where I: IntoIterator<Item: AsRef<str>>,

pub fn except_all(self, other: LogicalPlanBuilder) -> LogicalPlanBuilder

pub fn union_all(self, other: LogicalPlanBuilder) -> LogicalPlanBuilder

pub fn union(self, other: LogicalPlanBuilder) -> LogicalPlanBuilder

pub fn union_by_name( self, other: LogicalPlanBuilder, allow_missing_columns: Option<bool>, ) -> LogicalPlanBuilder

pub fn substract(self, other: LogicalPlanBuilder) -> LogicalPlanBuilder

pub fn intersect(self, other: LogicalPlanBuilder) -> LogicalPlanBuilder

pub fn intersect_all(self, other: LogicalPlanBuilder) -> LogicalPlanBuilder

pub fn filter<T: ToFilterExpr>(self, condition: T) -> LogicalPlanBuilder

pub fn approx_quantile<I, P>( self, cols: I, probabilities: P, relative_error: f64, ) -> LogicalPlanBuilder

where I: IntoIterator<Item: AsRef<str>>, P: IntoIterator<Item = f64>,

pub fn freq_items<I, S>( self, cols: I, support: Option<f64>, ) -> LogicalPlanBuilder

where I: IntoIterator<Item = S>, S: AsRef<str>,

pub fn hint<I, S>(self, name: &str, parameters: Option<I>) -> LogicalPlanBuilder

where I: IntoIterator<Item = S>, S: Into<Column>,

pub fn join<'a, T, I>( self, right: LogicalPlanBuilder, join_condition: Option<T>, join_type: JoinType, using_columns: I, ) -> LogicalPlanBuilder

where T: Into<Expression>, I: IntoIterator<Item = &'a str>,

pub fn limit(self, limit: i32) -> LogicalPlanBuilder

pub fn offset(self, num: i32) -> LogicalPlanBuilder

pub fn project<I, S>(self, cols: I) -> LogicalPlanBuilder

where I: IntoIterator<Item = S>, S: Into<Column>,

pub fn repartition( self, num_partitions: u32, shuffle: Option<bool>, ) -> LogicalPlanBuilder

pub fn repartition_by_range<I, S>( self, num_partitions: Option<i32>, cols: I, ) -> LogicalPlanBuilder

where I: IntoIterator<Item = S>, S: Into<Column>,

pub fn replace<I, T, L>( self, to_replace: T, value: T, subset: Option<I>, ) -> LogicalPlanBuilder

where I: IntoIterator<Item: AsRef<str>>, T: IntoIterator<Item = L>, L: Into<Literal>,

pub fn sample( self, lower_bound: f64, upper_bound: f64, with_replacement: Option<bool>, seed: Option<i64>, deterministic_order: bool, ) -> LogicalPlanBuilder

pub fn sample_by<K, I, T>( self, col: T, fractions: I, seed: i64, ) -> LogicalPlanBuilder

where K: Into<Literal>, T: Into<Expression>, I: IntoIterator<Item = (K, f64)>,

pub fn select_expr<I>(self, cols: I) -> LogicalPlanBuilder

where I: IntoIterator<Item: AsRef<str>>,

pub fn sort<I, T>(self, cols: I, is_global: bool) -> LogicalPlanBuilder

where T: Into<Column>, I: IntoIterator<Item = T>,

pub fn summary<T, I>(self, statistics: Option<I>) -> LogicalPlanBuilder

where T: AsRef<str>, I: IntoIterator<Item = T>,

pub fn with_column(self, col_name: &str, col: Column) -> LogicalPlanBuilder

pub fn with_columns<K, I, N, M>( self, col_map: I, metadata: Option<M>, ) -> LogicalPlanBuilder

where K: AsRef<str>, I: IntoIterator<Item = (K, Column)>, N: AsRef<str>, M: IntoIterator<Item = N>,

pub fn with_columns_renamed<I, K, V>(self, cols: I) -> LogicalPlanBuilder

where I: IntoIterator<Item = (K, V)>, K: AsRef<str>, V: AsRef<str>,

pub fn with_watermark<T, D>( self, event_time: T, delay_threshold: D, ) -> LogicalPlanBuilder

where T: AsRef<str>, D: AsRef<str>,

Trait Implementations

impl Clone for LogicalPlanBuilder

fn clone(&self) -> LogicalPlanBuilder

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for LogicalPlanBuilder

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

Formats the value using the given formatter.

impl From<RelType> for LogicalPlanBuilder

fn from(rel_type: RelType) -> LogicalPlanBuilder

Converts to this type from the input type.