Class: SPARQL::Algebra::Operator::Seq

Inherits:
Binary show all
Includes:
Query
Defined in:
lib/sparql/algebra/operator/seq.rb

Overview

The SPARQL Property Path sequence (SequencePath) operator.

[90] PathSequence ::= PathEltOrInverse ( '/' PathEltOrInverse )*

Examples:

SPARQL Grammar

PREFIX ex:  <http://www.example.org/schema#>
PREFIX in:  <http://www.example.org/instance#>
SELECT * WHERE {  in:a ex:p1/ex:p2 ?x }

SSE

(prefix ((ex: <http://www.example.org/schema#>)
         (in: <http://www.example.org/instance#>))
 (path in:a (seq ex:p1 ex:p2) ?x))

See Also:

Constant Summary collapse

NAME = 
:seq

Constants inherited from Binary

Binary::ARITY

Constants inherited from SPARQL::Algebra::Operator

ARITY, IsURI, URI

Constants included from Expression

Expression::PATTERN_PARENTS

Instance Attribute Summary

Attributes included from Query

#solutions

Attributes inherited from SPARQL::Algebra::Operator

#operands

Instance Method Summary collapse

Methods included from Query

#each_solution, #empty?, #failed?, #graph_name=, #matched?, #query_yields_boolean?, #query_yields_solutions?, #query_yields_statements?, #unshift, #variables

Methods inherited from Binary

#initialize

Methods inherited from SPARQL::Algebra::Operator

#aggregate?, arity, #base_uri, base_uri, base_uri=, #bind, #boolean, #constant?, #deep_dup, #each_descendant, #eql?, #evaluatable?, evaluate, #executable?, #first_ancestor, for, #initialize, #inspect, #mergable?, #ndvars, #node?, #operand, #optimize, #optimize!, #parent, #parent=, #prefixes, prefixes, prefixes=, #rewrite, #to_binary, to_sparql, #to_sxp, #to_sxp_bin, #validate!, #variable?, #variables, #vars

Methods included from Expression

cast, #constant?, debug, #evaluate, extension, extension?, extensions, for, #invalid?, new, #node?, open, #optimize, #optimize!, parse, register_extension, #to_sxp_bin, #valid?, #validate!, #variable?

Constructor Details

This class inherits a constructor from SPARQL::Algebra::Operator::Binary

Instance Method Details

#execute(queryable, **options) {|solution| ... } ⇒ Object

Join solution sets

(path :x (seq :p :q) :y) => (join (bgp (:x :p ??1)) (bgp (??1 :q :y)))

Options Hash (**options):

Yields:

  • (solution) —

    each matching solution

Yield Parameters:

Yield Returns:

  • (void) —

    ignored

See Also:

Parameters:

  • the graph or repository to query

  • any additional keyword options



41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/sparql/algebra/operator/seq.rb', line 41

def execute(queryable, **options, &block)
  subject, object = options[:subject], options[:object]
  debug(options) {"Seq #{[subject, operands, object].to_sse}"}

  v = RDF::Query::Variable.new(distinguished: false)
  q1 = if operand(0).is_a?(RDF::Term)
    RDF::Query.new do |q|
      q.pattern [subject, operand(0), v]
    end
  else
    operand(0)
  end
  q2 = if operand(1).is_a?(RDF::Term)
    RDF::Query.new do |q|
      q.pattern [v, operand(1), object]
    end
  else
    operand(1)
  end

  left = queryable.query(q1, **options.merge(object: v, depth: options[:depth].to_i + 1))
  #debug(options) {"(seq)=>(left) #{left.map(&:to_h).to_sse}"}

  right = queryable.query(q2, **options.merge(subject: v, depth: options[:depth].to_i + 1))
  #debug(options) {"(seq)=>(right) #{right.map(&:to_h).to_sse}"}

  @solutions = RDF::Query::Solutions(left.map do |s1|
    right.map do |s2|
      s2.merge(s1) if s2.compatible?(s1)
    end
  end.flatten.compact).map do |solution|
    solution.bindings.delete(v.to_sym)
    solution
  end
  debug(options) {"(seq)=> #{@solutions.to_sxp}"}
  @solutions.each(&block) if block_given?
  @solutions
end

#to_sparql(**options) ⇒ String

Returns a partial SPARQL grammar for this operator.

Returns:



85
86
87
 
# File 'lib/sparql/algebra/operator/seq.rb', line 85

def to_sparql(**options)
  '(' + operands.to_sparql(delimiter: '/', **options) + ')'
end