Struct RangeSelect

pub struct RangeSelect {
    pub input: Arc<LogicalPlan>,
    pub range_expr: Vec<RangeFn>,
    pub align: Duration,
    pub align_to: i64,
    pub time_index: String,
    pub time_expr: Expr,
    pub by: Vec<Expr>,
    pub schema: DFSchemaRef,
    pub by_schema: DFSchemaRef,
    pub schema_project: Option<Vec<usize>>,
    pub schema_before_project: DFSchemaRef,
}

Fields

input: Arc<LogicalPlan>

The incoming logical plan

range_expr: Vec<RangeFn>

all range expressions

align: Duration

align_to: i64

time_index: String

time_expr: Expr

by: Vec<Expr>

schema: DFSchemaRef

by_schema: DFSchemaRef

schema_project: Option<Vec<usize>>

If the schema of the RangeSelect happens to be the same as the content of the upper-level Projection Plan, the final output needs to be project through schema_project, so that we can omit the upper-level Projection Plan.

schema_before_project: DFSchemaRef

The schema before run projection, follow the order of range expr | time index | by columns schema_before_project ---- schema_project ----> schema if schema_project==None then schema_before_project==schema

Implementations

impl RangeSelect

pub fn try_new( input: Arc<LogicalPlan>, range_expr: Vec<RangeFn>, align: Duration, align_to: i64, time_index: Expr, by: Vec<Expr>, projection_expr: &[Expr], ) -> Result<Self>

impl RangeSelect

fn create_physical_expr_list( &self, is_count_aggr: bool, exprs: &[Expr], df_schema: &Arc<DFSchema>, session_state: &SessionState, ) -> DfResult<Vec<Arc<dyn PhysicalExpr>>>

pub fn to_execution_plan( &self, logical_input: &LogicalPlan, exec_input: Arc<dyn ExecutionPlan>, session_state: &SessionState, ) -> DfResult<Arc<dyn ExecutionPlan>>

Trait Implementations

impl Debug for RangeSelect

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

Formats the value using the given formatter.

impl Hash for RangeSelect

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for RangeSelect

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl UserDefinedLogicalNodeCore for RangeSelect

fn name(&self) -> &str

Return the plan’s name.

fn inputs(&self) -> Vec<&LogicalPlan>

Return the logical plan’s inputs.

fn schema(&self) -> &DFSchemaRef

Return the output schema of this logical plan node.

fn expressions(&self) -> Vec<Expr>

Returns all expressions in the current logical plan node. This should not include expressions of any inputs (aka non-recursively). These expressions are used for optimizer passes and rewrites.

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

Write a single line, human readable string to f for use in explain plan.

fn with_exprs_and_inputs( &self, exprs: Vec<Expr>, inputs: Vec<LogicalPlan>, ) -> DataFusionResult<Self>

Create a new UserDefinedLogicalNode with the specified children and expressions. This function is used during optimization when the plan is being rewritten and a new instance of the UserDefinedLogicalNode must be created.

fn prevent_predicate_push_down_columns(&self) -> HashSet<String>

A list of output columns (e.g. the names of columns in self.schema()) for which predicates can not be pushed below this node without changing the output.

fn from_template(&self, exprs: &[Expr], inputs: &[LogicalPlan]) -> Self

👎Deprecated since 39.0.0: use with_exprs_and_inputs instead

fn necessary_children_exprs( &self, _output_columns: &[usize], ) -> Option<Vec<Vec<usize>>>

Returns the necessary input columns for this node required to compute the columns in the output schema

impl Eq for RangeSelect

impl StructuralPartialEq for RangeSelect