Struct SparqlJoinNode 

pub struct SparqlJoinNode { /* private fields */ }

Implementations

impl SparqlJoinNode

pub fn try_new( encodings: RdfFusionEncodings, lhs: LogicalPlan, rhs: LogicalPlan, filter: Option<Expr>, join_type: SparqlJoinType, ) -> Result<SparqlJoinNode, DataFusionError>

Creates a new SPARQL join node with the specified inputs, filter, and join type.

This constructor validates that the inputs are compatible for joining according to SPARQL semantics, and that any filter expression is a boolean expression.

Arguments

• lhs - The left-hand side logical plan
• rhs - The right-hand side logical plan
• filter - An optional filter expression to apply to the join
• join_type - The type of join to perform (inner or left)

Returns

A new SparqlJoinNode if the inputs are valid, or an error otherwise

Additional Resources

• SPARQL 1.1 Query Language - Filters

pub fn lhs(&self) -> &LogicalPlan

Returns a reference to the left-hand side logical plan of the join.

This is the first input to the join operation.

pub fn rhs(&self) -> &LogicalPlan

Returns a reference to the right-hand side logical plan of the join.

This is the second input to the join operation.

pub fn filter(&self) -> Option<&Expr>

Returns a reference to the optional filter expression applied to the join.

If present, this filter is applied after the join operation to further restrict the results.

pub fn join_type(&self) -> SparqlJoinType

Returns the type of join operation (inner or left).

This determines how solution mappings are combined and whether unmatched solutions from the left side are preserved.

pub fn destruct( self, ) -> (LogicalPlan, LogicalPlan, Option<Expr>, SparqlJoinType)

Consumes the join node and returns its components.

This method is useful when you need to take ownership of the components of the join node, such as during transformation or optimization of the logical plan.

Returns

A tuple containing the left plan, right plan, optional filter, and join type

Trait Implementations

impl Clone for SparqlJoinNode

fn clone(&self) -> SparqlJoinNode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SparqlJoinNode

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

Formats the value using the given formatter.

impl Hash for SparqlJoinNode

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

where __H: Hasher,

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 SparqlJoinNode

fn eq(&self, other: &SparqlJoinNode) -> 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 PartialOrd for SparqlJoinNode

fn partial_cmp(&self, _other: &SparqlJoinNode) -> 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 SparqlJoinNode

fn name(&self) -> &str

Return the plan’s name.

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

Return the logical plan’s inputs.

fn schema(&self) -> &Arc<DFSchema>

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<(), Error>

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<SparqlJoinNode, DataFusionError>

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

fn supports_limit_pushdown(&self) -> bool

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

impl Eq for SparqlJoinNode

impl StructuralPartialEq for SparqlJoinNode