Struct GraphTraversalNode 

pub struct GraphTraversalNode {
    pub graph: String,
    pub traversal: Traversal,
    pub input: Arc<LogicalPlan>,
    pub weighted: Option<Arc<LogicalPlan>>,
    pub vertices: Option<Arc<LogicalPlan>>,
    pub weight: Option<String>,
    pub nodes: Vec<Arc<LogicalPlan>>,
    pub written: Vec<String>,
    pub source: Expr,
    pub destination: Expr,
    pub id_type: DataType,
    /* private fields */
}

Run a traversal (hop, shortest_path, random_walk) over the edges its first input produces.

Its inputs, in order:

1. the edge rows projected to the endpoints, exactly as a GraphAlgorithmNode’s first input, so the two share one index;
2. for a weighted shortest_path, the weighted edge plan, as a GraphAlgorithmNode’s second input (with one weight column);
3. for a graph with a vertex table, its keys, as a GraphAlgorithmNode’s;
4. one plan per node-id parameter (seeds; source and target; start), each of one column: a VALUES list for a literal, or the planned subquery. They run when the node runs, never while the query is planned, and their values are cast to the graph’s id type then.

The output is the traversal’s own rows (see super::traversal).

Fields

graph: String

The graph’s name, for plans and messages.

traversal: Traversal

input: Arc<LogicalPlan>

The edge rows, projected to the endpoints.

weighted: Option<Arc<LogicalPlan>>

The edge rows projected to the endpoints and the weight, for a weighted shortest path.

vertices: Option<Arc<LogicalPlan>>

The graph’s vertex keys (see GraphAlgorithmNode::vertices).

weight: Option<String>

The weight expression, as written, for EXPLAIN.

nodes: Vec<Arc<LogicalPlan>>

One plan per node-id parameter, in the spec’s order.

written: Vec<String>

Each node-id argument as written, for EXPLAIN.

source: Expr

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

destination: Expr

id_type: DataType

The node id type (see GraphAlgorithmNode::id_type).

Implementations

impl GraphTraversalNode

pub fn try_new( graph: String, traversal: Traversal, input: Arc<LogicalPlan>, weighted: Option<Arc<LogicalPlan>>, vertices: Option<Arc<LogicalPlan>>, weight: Option<String>, nodes: Vec<Arc<LogicalPlan>>, written: Vec<String>, source: Expr, destination: Expr, ) -> 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 GraphTraversalNode

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 GraphTraversalNode

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

Formats the value using the given formatter.

impl Eq for GraphTraversalNode

impl Hash for GraphTraversalNode

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 GraphTraversalNode

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for GraphTraversalNode

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 GraphTraversalNode

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>>>

Both endpoints of the first input, every column of the weighted input, the vertex key, and the one column of each node-id input.

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

Filters on the output are about the traversal’s rows, not the edges or the node ids: 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.