Struct GraphAlgorithmNode 

pub struct GraphAlgorithmNode {
    pub graph: String,
    pub input: Arc<LogicalPlan>,
    pub weighted: Option<Arc<LogicalPlan>>,
    pub vertices: Option<Arc<LogicalPlan>>,
    pub values: Option<Arc<LogicalPlan>>,
    pub source: Expr,
    pub destination: Expr,
    pub weights: Vec<String>,
    pub outputs: Vec<Output>,
    pub per_node: bool,
    pub id_type: DataType,
    /* private fields */
}

Run graph functions over the edges its input produces.

Fields

graph: String

The graph’s name, for plans and messages. The index is keyed by the edges, not by this.

input: Arc<LogicalPlan>

The edge rows, projected to the endpoints.

weighted: Option<Arc<LogicalPlan>>

The edge rows projected to the endpoints and the weights, when an output reads a weight (see the module docs).

vertices: Option<Arc<LogicalPlan>>

The graph’s vertex table projected to its key, one column, when it has one: its keys are the graph’s nodes (see the module docs).

values: Option<Arc<LogicalPlan>>

The node values a neighbour aggregation reads: a plan of two columns, node ids then values.

source: Expr

The source and destination of each edge: column references into input.

destination: Expr

weights: Vec<String>

The distinct weight expressions, as written, for EXPLAIN.

outputs: Vec<Output>

What the node computes, one value column each.

per_node: bool

One row per node with an id column, or one row for the whole graph.

id_type: DataType

The node id type: the endpoints’ type, with every integer type read as Int64 and every string type as Utf8, as the Python library reads them.

Implementations

impl GraphAlgorithmNode

pub fn try_new( graph: String, input: Arc<LogicalPlan>, weighted: Option<Arc<LogicalPlan>>, vertices: Option<Arc<LogicalPlan>>, values: Option<Arc<LogicalPlan>>, source: Expr, destination: Expr, weights: Vec<String>, outputs: Vec<Output>, per_node: bool, ) -> Result<Self>

pub fn endpoint_indices(&self) -> Result<(usize, usize)>

The positions of the source and destination columns in the input.

Trait Implementations

impl Clone for GraphAlgorithmNode

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GraphAlgorithmNode

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

Formats the value using the given formatter.

impl Eq for GraphAlgorithmNode

impl Hash for GraphAlgorithmNode

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 GraphAlgorithmNode

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for GraphAlgorithmNode

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl UserDefinedLogicalNodeCore for GraphAlgorithmNode

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

The endpoint columns, so DataFusion keeps them in the input.

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

Every output needs both endpoints and nothing else of the first input, every column of the weighted input, the vertex key, and both columns of the values.

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

Filters on the output are about nodes, not edges: none moves below.

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 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>, ) -> Result<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 check_invariants( &self, _check: InvariantLevel, ) -> Result<(), DataFusionError>

Perform check of invariants for the extension node.

fn supports_limit_pushdown(&self) -> bool

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