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 build_plan_root(self) -> Plan

Build the Spark spark::Plan for a Relation

pub fn plan_root(op_type: LogicalPlanBuilder) -> Plan

pub fn plan_cmd(command_type: CommandType) -> Plan

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

pub fn from(rel_type: RelType) -> LogicalPlanBuilder

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

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

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

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: &str, col2: &str) -> LogicalPlanBuilder

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

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

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

where I: IntoIterator<Item = &'a str> + Default,

pub fn distinct(self) -> LogicalPlanBuilder

pub fn drop<T: ToVecExpr>(self, cols: T) -> LogicalPlanBuilder

pub fn drop_duplicates<'a, I>(self, cols: Option<I>) -> LogicalPlanBuilder

where I: IntoIterator<Item = &'a str> + Default,

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

where I: IntoIterator<Item = &'a str> + Default,

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

where I: IntoIterator<Item = &'a 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 freq_items<'a, I>( self, cols: I, support: Option<f64>, ) -> LogicalPlanBuilder

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

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

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

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

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

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

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

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

pub fn select<T: ToVecExpr>(self, cols: T) -> LogicalPlanBuilder

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

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

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

where T: ToExpr, I: IntoIterator<Item = T>,

pub fn with_column<T: ToExpr>( self, col_name: &str, col: T, ) -> LogicalPlanBuilder

pub fn with_columns<I, K, T>(self, col_map: I) -> LogicalPlanBuilder

where T: ToExpr, K: ToString, I: IntoIterator<Item = (K, T)>,

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

where I: IntoIterator<Item = (K, V)>, K: AsRef<str>, V: 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.