Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://docs.rs/datafusion/latest/datafusion/logical_expr/trait.UserDefinedLogicalNode.html below:

UserDefinedLogicalNode in datafusion::logical_expr - Rust

pub trait UserDefinedLogicalNode:
    Debug
    + Send
    + Sync {
Show 14 methods    // Required methods
    fn as_any(&self) -> &(dyn Any + 'static);
    fn name(&self) -> &str;
    fn inputs(&self) -> Vec<&LogicalPlan>;
    fn schema(&self) -> &Arc<DFSchema>;
    fn check_invariants(
        &self,
        check: InvariantLevel,
        plan: &LogicalPlan,
    ) -> Result<(), DataFusionError>;
    fn expressions(&self) -> Vec<Expr>;
    fn fmt_for_explain(&self, f: &mut Formatter<'_>) -> Result<(), Error>;
    fn with_exprs_and_inputs(
        &self,
        exprs: Vec<Expr>,
        inputs: Vec<LogicalPlan>,
    ) -> Result<Arc<dyn UserDefinedLogicalNode>, DataFusionError>;
    fn dyn_hash(&self, state: &mut dyn Hasher);
    fn dyn_eq(&self, other: &dyn UserDefinedLogicalNode) -> bool;
    fn dyn_ord(&self, other: &dyn UserDefinedLogicalNode) -> Option<Ordering>;

    // Provided methods
    fn prevent_predicate_push_down_columns(&self) -> HashSet<String> { ... }
    fn necessary_children_exprs(
        &self,
        _output_columns: &[usize],
    ) -> Option<Vec<Vec<usize>>> { ... }
    fn supports_limit_pushdown(&self) -> bool { ... }
}

This defines the interface for LogicalPlan nodes that can be used to extend DataFusion with custom relational operators.

The UserDefinedLogicalNodeCore trait is the recommended way to implement this trait and avoids having implementing some required boiler plate code.

Return a reference to self as Any, to support dynamic downcasting

Typically this will look like:

  fn as_any(&self) -> &dyn Any {
     self
  }

Return the plan’s name.

Return the logical plan’s inputs.

Return the output schema of this logical plan node.

Perform check of invariants for the extension node.

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. See LogicalPlan::expressions for more details.

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

For example: TopK: k=10

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.

Note that exprs and inputs are in the same order as the result of self.inputs and self.exprs.

So, `self.with_exprs_and_inputs(exprs, ..).expressions() == exprs

Update the hash state with this node requirements from Hash.

Note: consider using UserDefinedLogicalNodeCore instead of UserDefinedLogicalNode directly.

This method is required to support hashing LogicalPlans. To implement it, typically the type implementing UserDefinedLogicalNode typically implements Hash and then the following boiler plate is used:

#[derive(Hash, Debug, PartialEq, Eq)]
struct MyNode {
  val: u64
}

fn dyn_hash(&self, state: &mut dyn std::hash::Hasher) {
    use std::hash::Hash;
    let mut s = state;
    self.hash(&mut s);
  }

Note: UserDefinedLogicalNode is not constrained by Hash directly because it must remain object safe.

Compare other, respecting requirements from std::cmp::Eq.

Note: consider using UserDefinedLogicalNodeCore instead of UserDefinedLogicalNode directly.

When other has an another type than self, then the values are not equal.

This method is required to support Eq on LogicalPlans. To implement it, typically the type implementing UserDefinedLogicalNode typically implements Eq and then the following boiler plate is used:

#[derive(Hash, Debug, PartialEq, Eq)]
struct MyNode {
  val: u64
}

fn dyn_eq(&self, other: &dyn UserDefinedLogicalNode) -> bool {
    match other.as_any().downcast_ref::<Self>() {
      Some(o) => self == o,
      None => false,
    }
  }

Note: UserDefinedLogicalNode is not constrained by Eq directly because it must remain object safe.

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.

By default, this returns all columns and thus prevents any predicates from being pushed below this node.

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

This is used for projection push-down when DataFusion has determined that only a subset of the output columns of this node are needed by its parents. This API is used to tell DataFusion which, if any, of the input columns are no longer needed.

Return None, the default, if this information can not be determined. Returns Some(_) with the column indices for each child of this node that are needed to compute output_columns

Returns true if a limit can be safely pushed down through this UserDefinedLogicalNode node.

If this method returns true, and the query plan contains a limit at the output of this node, DataFusion will push the limit to the input of this node.

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

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

This method returns an ordering between

and

values if one exists.

Tests less than (for

and

) and is used by the

operator.

Tests less than or equal to (for

and

) and is used by the

operator.

Tests greater than (for

and

) and is used by the

operator.

Tests greater than or equal to (for

and

) and is used by the

operator.

Automatically derive UserDefinedLogicalNode to UserDefinedLogicalNode to avoid boiler plate for implementing as_any, Hash and PartialEq

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4