Class: LD::Patch::Algebra::Path

Inherits:
SPARQL::Algebra::Operator
  • Object
show all
Includes:
SPARQL::Algebra::Evaluatable, SPARQL::Algebra::Query
Defined in:
lib/ld/patch/algebra/path.rb

Overview

The LD Patch path operator.

The Path creates a closure over path operands querying queryable for terms having a relationship with the input terms based on each operand. The terms extracted from the first operand are used as inputs for the next operand until a final set of terms is found. These terms are returned as RDF:Query::Solution bound the the variable ?path

Returns input terms

Queries queryable for objects where the input terms are subjects and the predicate is :p

Queries queryable for subjects where input terms are objects and the predicate is :p, by executing the reverse operand using input terms to get a set of output terms.

Returns the input terms satisfying the constrant.

Maps terms using (path :p), using them as terms for (path :q), then subsets these based on the constraint.

Examples:

empty path

(path)

forward path

(path :p)

reverse path

(path (reverse :p))

constraint

(path (constraint (path) :c, 1))

chained path elements

(path :p :q (constraint (path) :c, 1))

Constant Summary collapse

NAME = 
:path

Instance Method Summary collapse

Instance Method Details

#execute(queryable, options = {}) ⇒ RDF::Query::Solutions

Executes this operator using the given variable bindings and a starting term, returning zero or more terms at the end of the path.

Parameters:

  • queryable (RDF::Queryable) —

    the graph or repository to query

  • options (Hash{Symbol => Object}) (defaults to: {}) —

    ({}) options passed from query

Options Hash (options):

  • starting (Array<RDF::Term>) —

    terms

Returns:

  • (RDF::Query::Solutions) —

    solutions with :term mapping



47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
 
# File 'lib/ld/patch/algebra/path.rb', line 47

def execute(queryable, options = {})
  solutions = RDF::Query::Solutions.new

  # Iterate updating terms, then create solutions from matched terms
  operands.inject(Array(options.fetch(:terms))) do |terms, op|
    case op
    when RDF::URI
      terms.map do |subject|
        queryable.query({subject: subject, predicate: op}).map(&:object)
      end.flatten
    when SPARQL::Algebra::Query
      # Get path solutions for each term for op
      op.execute(queryable, **options.merge(terms: terms)).map do |soln|
        soln.path
      end.flatten
    else
      raise NotImplementedError, "Unknown path operand #{op.inspect}"
    end
  end.each do |term|
    solutions << RDF::Query::Solution.new(path: term)
  end
  solutions
end