sparql 3.0.2 → 3.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (91) hide show
  1. checksums.yaml +4 -4
  2. data/README.md +2 -2
  3. data/VERSION +1 -1
  4. data/bin/sparql +8 -8
  5. data/lib/rack/sparql.rb +1 -1
  6. data/lib/rack/sparql/conneg.rb +1 -1
  7. data/lib/sinatra/sparql.rb +1 -1
  8. data/lib/sparql.rb +4 -4
  9. data/lib/sparql/algebra.rb +4 -4
  10. data/lib/sparql/algebra/aggregate.rb +2 -2
  11. data/lib/sparql/algebra/evaluatable.rb +2 -2
  12. data/lib/sparql/algebra/expression.rb +7 -7
  13. data/lib/sparql/algebra/extensions.rb +9 -14
  14. data/lib/sparql/algebra/operator.rb +1 -1
  15. data/lib/sparql/algebra/operator/add.rb +1 -1
  16. data/lib/sparql/algebra/operator/alt.rb +2 -2
  17. data/lib/sparql/algebra/operator/and.rb +4 -4
  18. data/lib/sparql/algebra/operator/asc.rb +2 -2
  19. data/lib/sparql/algebra/operator/ask.rb +2 -2
  20. data/lib/sparql/algebra/operator/avg.rb +5 -3
  21. data/lib/sparql/algebra/operator/base.rb +2 -2
  22. data/lib/sparql/algebra/operator/bnode.rb +3 -3
  23. data/lib/sparql/algebra/operator/bound.rb +2 -2
  24. data/lib/sparql/algebra/operator/clear.rb +1 -1
  25. data/lib/sparql/algebra/operator/coalesce.rb +2 -2
  26. data/lib/sparql/algebra/operator/concat.rb +2 -2
  27. data/lib/sparql/algebra/operator/construct.rb +2 -2
  28. data/lib/sparql/algebra/operator/copy.rb +1 -1
  29. data/lib/sparql/algebra/operator/count.rb +2 -2
  30. data/lib/sparql/algebra/operator/create.rb +1 -1
  31. data/lib/sparql/algebra/operator/dataset.rb +3 -3
  32. data/lib/sparql/algebra/operator/delete.rb +4 -2
  33. data/lib/sparql/algebra/operator/delete_data.rb +1 -1
  34. data/lib/sparql/algebra/operator/delete_where.rb +3 -3
  35. data/lib/sparql/algebra/operator/describe.rb +1 -1
  36. data/lib/sparql/algebra/operator/distinct.rb +2 -2
  37. data/lib/sparql/algebra/operator/drop.rb +1 -1
  38. data/lib/sparql/algebra/operator/encode_for_uri.rb +1 -1
  39. data/lib/sparql/algebra/operator/exists.rb +4 -4
  40. data/lib/sparql/algebra/operator/exprlist.rb +2 -2
  41. data/lib/sparql/algebra/operator/extend.rb +5 -5
  42. data/lib/sparql/algebra/operator/filter.rb +3 -3
  43. data/lib/sparql/algebra/operator/graph.rb +2 -2
  44. data/lib/sparql/algebra/operator/group.rb +11 -11
  45. data/lib/sparql/algebra/operator/group_concat.rb +5 -5
  46. data/lib/sparql/algebra/operator/if.rb +4 -4
  47. data/lib/sparql/algebra/operator/in.rb +3 -3
  48. data/lib/sparql/algebra/operator/insert.rb +4 -2
  49. data/lib/sparql/algebra/operator/insert_data.rb +1 -1
  50. data/lib/sparql/algebra/operator/join.rb +3 -3
  51. data/lib/sparql/algebra/operator/left_join.rb +3 -3
  52. data/lib/sparql/algebra/operator/load.rb +1 -1
  53. data/lib/sparql/algebra/operator/max.rb +5 -3
  54. data/lib/sparql/algebra/operator/min.rb +5 -3
  55. data/lib/sparql/algebra/operator/minus.rb +3 -3
  56. data/lib/sparql/algebra/operator/modify.rb +3 -3
  57. data/lib/sparql/algebra/operator/move.rb +1 -1
  58. data/lib/sparql/algebra/operator/notexists.rb +2 -2
  59. data/lib/sparql/algebra/operator/notin.rb +3 -3
  60. data/lib/sparql/algebra/operator/notoneof.rb +3 -4
  61. data/lib/sparql/algebra/operator/or.rb +4 -4
  62. data/lib/sparql/algebra/operator/order.rb +4 -4
  63. data/lib/sparql/algebra/operator/path.rb +4 -3
  64. data/lib/sparql/algebra/operator/path_opt.rb +14 -14
  65. data/lib/sparql/algebra/operator/path_plus.rb +6 -6
  66. data/lib/sparql/algebra/operator/path_star.rb +2 -2
  67. data/lib/sparql/algebra/operator/plus.rb +1 -1
  68. data/lib/sparql/algebra/operator/prefix.rb +2 -2
  69. data/lib/sparql/algebra/operator/project.rb +2 -2
  70. data/lib/sparql/algebra/operator/reduced.rb +2 -2
  71. data/lib/sparql/algebra/operator/regex.rb +1 -1
  72. data/lib/sparql/algebra/operator/replace.rb +1 -1
  73. data/lib/sparql/algebra/operator/reverse.rb +2 -2
  74. data/lib/sparql/algebra/operator/sample.rb +2 -2
  75. data/lib/sparql/algebra/operator/seq.rb +4 -5
  76. data/lib/sparql/algebra/operator/sequence.rb +3 -3
  77. data/lib/sparql/algebra/operator/slice.rb +2 -2
  78. data/lib/sparql/algebra/operator/substr.rb +1 -1
  79. data/lib/sparql/algebra/operator/sum.rb +5 -3
  80. data/lib/sparql/algebra/operator/table.rb +1 -1
  81. data/lib/sparql/algebra/operator/union.rb +2 -2
  82. data/lib/sparql/algebra/operator/update.rb +2 -2
  83. data/lib/sparql/algebra/operator/using.rb +2 -2
  84. data/lib/sparql/algebra/operator/with.rb +4 -4
  85. data/lib/sparql/algebra/query.rb +1 -1
  86. data/lib/sparql/algebra/update.rb +1 -1
  87. data/lib/sparql/extensions.rb +4 -4
  88. data/lib/sparql/grammar.rb +7 -7
  89. data/lib/sparql/grammar/parser11.rb +15 -17
  90. data/lib/sparql/results.rb +3 -3
  91. metadata +26 -33
@@ -30,7 +30,7 @@ module SPARQL; module Algebra
30
30
  # @param [Hash{Symbol => Object}] options
31
31
  # any additional options (see {Operator#initialize})
32
32
  # @raise [TypeError] if any operand is invalid
33
- def initialize(literal = false, options = {})
33
+ def initialize(literal = false, **options)
34
34
  super
35
35
  end
36
36
 
@@ -42,8 +42,8 @@ module SPARQL; module Algebra
42
42
  # @param [Hash{Symbol => Object}] options ({})
43
43
  # options passed from query
44
44
  # @return [RDF::Term]
45
- def evaluate(bindings, options = {})
46
- args = operands.map { |operand| operand.evaluate(bindings, options.merge(depth: options[:depth].to_i + 1)) }
45
+ def evaluate(bindings, **options)
46
+ args = operands.map { |operand| operand.evaluate(bindings, depth: options[:depth].to_i + 1, **options) }
47
47
  apply(args.first, bindings)
48
48
  end
49
49
 
@@ -25,7 +25,7 @@ module SPARQL; module Algebra
25
25
  # @param [Hash{Symbol => Object}] options
26
26
  # any additional options (see {Operator#initialize})
27
27
  # @raise [TypeError] if any operand is invalid
28
- def initialize(var, options = {})
28
+ def initialize(var, **options)
29
29
  super
30
30
  end
31
31
 
@@ -38,7 +38,7 @@ module SPARQL; module Algebra
38
38
  # options passed from query
39
39
  # @return [RDF::Literal::Boolean] `true` or `false`
40
40
  # @raise [TypeError] if the operand is not a variable
41
- def evaluate(bindings, options = {})
41
+ def evaluate(bindings, **options)
42
42
  case var = operand
43
43
  when Variable
44
44
  bindings.respond_to?(:bound?) && bindings.bound?(var) ?
@@ -29,7 +29,7 @@ module SPARQL; module Algebra
29
29
  # @raise [IOError]
30
30
  # If `from` does not exist, unless the `silent` operator is present
31
31
  # @see http://www.w3.org/TR/sparql11-update/
32
- def execute(queryable, options = {})
32
+ def execute(queryable, **options)
33
33
  debug(options) {"Clear"}
34
34
  silent = operands.first == :silent
35
35
  operands.shift if silent
@@ -41,10 +41,10 @@ module SPARQL; module Algebra
41
41
  # options passed from query
42
42
  # @return [RDF::Term]
43
43
  # @raise [TypeError] if none of the operands succeeds
44
- def evaluate(bindings, options = {})
44
+ def evaluate(bindings, **options)
45
45
  operands.each do |op|
46
46
  begin
47
- return op.evaluate(bindings, options.merge(depth: options[:depth].to_i + 1))
47
+ return op.evaluate(bindings, depth: options[:depth].to_i + 1, **options)
48
48
  rescue
49
49
  end
50
50
  end
@@ -32,8 +32,8 @@ module SPARQL; module Algebra
32
32
  # options passed from query
33
33
  # @return [RDF::Term]
34
34
  # @raise [TypeError] if any operand is not a literal
35
- def evaluate(bindings, options = {})
36
- ops = operands.map {|op| op.evaluate(bindings, options.merge(depth: options[:depth].to_i + 1))}
35
+ def evaluate(bindings, **options)
36
+ ops = operands.map {|op| op.evaluate(bindings, depth: options[:depth].to_i + 1, **options)}
37
37
 
38
38
  raise TypeError, "expected all plain literal operands" unless ops.all? {|op| op.literal? && op.plain?}
39
39
 
@@ -35,13 +35,13 @@ module SPARQL; module Algebra
35
35
  # @return [RDF::Queryable]
36
36
  # A Queryable with constructed triples
37
37
  # @see http://www.w3.org/TR/sparql11-query/#construct
38
- def execute(queryable, options = {}, &block)
38
+ def execute(queryable, **options, &block)
39
39
  debug(options) {"Construct #{operands.first}, #{options.inspect}"}
40
40
  graph = RDF::Graph.new
41
41
  patterns = operands.first
42
42
  query = operands.last
43
43
 
44
- queryable.query(query, options.merge(depth: options[:depth].to_i + 1)).each do |solution|
44
+ queryable.query(query, depth: options[:depth].to_i + 1, **options).each do |solution|
45
45
  debug(options) {"(construct apply) #{solution.inspect} to BGP"}
46
46
 
47
47
  # Create a mapping from BNodes within the pattern list to newly constructed BNodes
@@ -29,7 +29,7 @@ module SPARQL; module Algebra
29
29
  # @raise [IOError]
30
30
  # If `from` does not exist, unless the `silent` operator is present
31
31
  # @see http://www.w3.org/TR/sparql11-update/
32
- def execute(queryable, options = {})
32
+ def execute(queryable, **options)
33
33
  debug(options) {"Copy"}
34
34
  silent = operands.first == :silent
35
35
  operands.shift if silent
@@ -6,8 +6,8 @@ module SPARQL; module Algebra
6
6
  # @example
7
7
  # (prefix ((: <http://www.example.org>))
8
8
  # (project (?C)
9
- # (extend ((?C ?.0))
10
- # (group () ((?.0 (count ?O)))
9
+ # (extend ((?C ??.0))
10
+ # (group () ((??.0 (count ?O)))
11
11
  # (bgp (triple ?S ?P ?O))))))
12
12
  #
13
13
  # @see http://www.w3.org/TR/sparql11-query/#defn_aggCount
@@ -31,7 +31,7 @@ module SPARQL; module Algebra
31
31
  # @raise [IOError]
32
32
  # If `from` does not exist, unless the `silent` operator is present
33
33
  # @see http://www.w3.org/TR/sparql11-update/
34
- def execute(queryable, options = {})
34
+ def execute(queryable, **options)
35
35
  debug(options) {"Create"}
36
36
  silent = operands.first == :silent
37
37
  operands.shift if silent
@@ -126,7 +126,7 @@ module SPARQL; module Algebra
126
126
  # @return [RDF::Query::Solutions]
127
127
  # the resulting solution sequence
128
128
  # @see http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
129
- def execute(queryable, options = {}, &base)
129
+ def execute(queryable, **options, &base)
130
130
  debug(options) {"Dataset"}
131
131
  default_datasets = []
132
132
  named_datasets = []
@@ -144,7 +144,7 @@ module SPARQL; module Algebra
144
144
  load_opts = {debug: options.fetch(:debug, nil), graph_name: uri, base_uri: uri}
145
145
  unless queryable.has_graph?(uri)
146
146
  debug(options) {"=> load #{uri}"}
147
- queryable.load(uri.to_s, load_opts)
147
+ queryable.load(uri.to_s, **load_opts)
148
148
  end
149
149
  end
150
150
  debug(options) {
@@ -156,7 +156,7 @@ module SPARQL; module Algebra
156
156
  aggregate = RDF::AggregateRepo.new(queryable)
157
157
  named_datasets.each {|name| aggregate.named(name) if queryable.has_graph?(name)}
158
158
  aggregate.default(*default_datasets.select {|name| queryable.has_graph?(name)})
159
- aggregate.query(operands.last, options.merge(depth: options[:depth].to_i + 1), &base)
159
+ aggregate.query(operands.last, depth: options[:depth].to_i + 1, **options, &base)
160
160
  end
161
161
 
162
162
  ##
@@ -20,7 +20,7 @@ module SPARQL; module Algebra
20
20
  #
21
21
  # @param [RDF::Queryable] queryable
22
22
  # the graph or repository to write
23
- # @param [RDF::Query::Solution] solution
23
+ # @param [RDF::Query::Solution] :solution
24
24
  # Solution to map to patterns for this operation
25
25
  # @param [Hash{Symbol => Object}] options
26
26
  # any additional keyword options
@@ -31,8 +31,10 @@ module SPARQL; module Algebra
31
31
  # @raise [IOError]
32
32
  # If `from` does not exist, unless the `silent` operator is present
33
33
  # @see http://www.w3.org/TR/sparql11-update/
34
- def execute(queryable, solution, options = {})
34
+ def execute(queryable, solutions: nil, **options)
35
35
  debug(options) {"Delete: #{solution} against #{operands.to_sse}"}
36
+ # Only binds the first solution
37
+ solution = solutions.is_a?(RDF::Query::Solutions) ? solutions.first : solutions
36
38
  # Operands are an array of patterns and Queries (when named).
37
39
  # Create a new query made up all patterns
38
40
  patterns = operand.inject([]) do |memo, op|
@@ -29,7 +29,7 @@ module SPARQL; module Algebra
29
29
  # @raise [IOError]
30
30
  # If `from` does not exist, unless the `silent` operator is present
31
31
  # @see http://www.w3.org/TR/sparql11-update/
32
- def execute(queryable, options = {})
32
+ def execute(queryable, **options)
33
33
  operand.each do |op|
34
34
  debug(options) {"DeleteData #{op.to_sxp}"}
35
35
  queryable.delete(op)
@@ -29,7 +29,7 @@ module SPARQL; module Algebra
29
29
  # @raise [IOError]
30
30
  # If `from` does not exist, unless the `silent` operator is present
31
31
  # @see http://www.w3.org/TR/sparql11-update/
32
- def execute(queryable, options = {})
32
+ def execute(queryable, **options)
33
33
  # Operands are an array of patterns and Queries (when named).
34
34
  # Create a new query made up all patterns
35
35
  patterns = operand.inject([]) do |memo, op|
@@ -40,9 +40,9 @@ module SPARQL; module Algebra
40
40
  end
41
41
  memo
42
42
  end
43
- query = RDF::Query.new(*patterns, {}) # FIXME: added hash argument needed until Statement#to_hash removed.
43
+ query = RDF::Query.new(*patterns, **{}) # FIXME: added hash argument needed until Statement#to_hash removed.
44
44
  debug(options) {"DeleteWhere query #{query.to_sse}"}
45
- query.execute(queryable, options.merge(depth: options[:depth].to_i + 1)) do |solution|
45
+ query.execute(queryable, depth: options[:depth].to_i + 1, **options) do |solution|
46
46
  debug(options) {"DeleteWhere solution #{solution.to_sse}"}
47
47
  query.each_statement do |pattern|
48
48
  pattern = pattern.dup.bind(solution)
@@ -40,7 +40,7 @@ module SPARQL; module Algebra
40
40
  # @return [RDF::Graph]
41
41
  # containing the constructed triples
42
42
  # @see http://www.w3.org/TR/sparql11-query/#describe
43
- def execute(queryable, options = {}, &block)
43
+ def execute(queryable, **options, &block)
44
44
  debug(options) {"Describe #{operands.first}, #{options.inspect}"}
45
45
 
46
46
  # Describe any constand URIs
@@ -31,8 +31,8 @@ module SPARQL; module Algebra
31
31
  # @return [RDF::Query::Solutions]
32
32
  # the resulting solution sequence
33
33
  # @see http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
34
- def execute(queryable, options = {}, &block)
35
- @solutions = queryable.query(operands.last, options.merge(depth: options[:depth].to_i + 1)).distinct
34
+ def execute(queryable, **options, &block)
35
+ @solutions = queryable.query(operands.last, depth: options[:depth].to_i + 1, **options).distinct
36
36
  @solutions.each(&block) if block_given?
37
37
  @solutions
38
38
  end
@@ -31,7 +31,7 @@ module SPARQL; module Algebra
31
31
  # @raise [IOError]
32
32
  # If `from` does not exist, unless the `silent` operator is present
33
33
  # @see http://www.w3.org/TR/sparql11-update/
34
- def execute(queryable, options = {})
34
+ def execute(queryable, **options)
35
35
  debug(options) {"Drop"}
36
36
  silent = operands.first == :silent
37
37
  silent = operands.first == :silent
@@ -29,7 +29,7 @@ module SPARQL; module Algebra
29
29
  # @raise [TypeError] if the operand is not a literal value
30
30
  def apply(operand)
31
31
  case operand
32
- when RDF::Literal then RDF::Literal(::URI.encode(operand.to_s))
32
+ when RDF::Literal then RDF::Literal(CGI.escape(operand.to_s))
33
33
  else raise TypeError, "expected an RDF::Literal, but got #{operand.inspect}"
34
34
  end
35
35
  end
@@ -26,11 +26,11 @@ module SPARQL; module Algebra
26
26
  # @option options[RDF::Queryable] queryable
27
27
  # queryable to execute, using bindings as an initial solution.
28
28
  # @return [RDF::Literal::Boolean] `true` or `false`
29
- def evaluate(bindings, options = {})
29
+ def evaluate(bindings, **options)
30
30
  queryable = options[:queryable]
31
- !operand(0).execute(queryable, options.merge(
32
- solutions: RDF::Query::Solutions(bindings),
33
- depth: options[:depth].to_i + 1)).empty?
31
+ !operand(0).execute(queryable, solutions: RDF::Query::Solutions(bindings),
32
+ depth: options[:depth].to_i + 1,
33
+ **options).empty?
34
34
  end
35
35
  end # Exists
36
36
  end # Operator
@@ -36,8 +36,8 @@ module SPARQL; module Algebra
36
36
  # options passed from query
37
37
  # @return [RDF::Literal::Boolean] `true` or `false`
38
38
  # @raise [TypeError] if the operands could not be coerced to a boolean literal
39
- def evaluate(bindings, options = {})
40
- res = operands.all? {|op| boolean(op.evaluate(bindings, options.merge(depth: options[:depth].to_i + 1))).true? }
39
+ def evaluate(bindings, **options)
40
+ res = operands.all? {|op| boolean(op.evaluate(bindings, depth: options[:depth].to_i + 1, **options)).true? }
41
41
  RDF::Literal(res) # FIXME: error handling
42
42
  end
43
43
 
@@ -39,16 +39,16 @@ module SPARQL; module Algebra
39
39
  # @return [RDF::Query::Solutions]
40
40
  # the resulting solution sequence
41
41
  # @see http://www.w3.org/TR/sparql11-query/#evaluation
42
- def execute(queryable, options = {}, &block)
42
+ def execute(queryable, **options, &block)
43
43
  debug(options) {"Extend"}
44
- @solutions = operand(1).execute(queryable, options.merge(depth: options[:depth].to_i + 1))
44
+ @solutions = operand(1).execute(queryable, depth: options[:depth].to_i + 1, **options)
45
45
  @solutions.each do |solution|
46
46
  debug(options) {"===> soln #{solution.to_h.inspect}"}
47
47
  operand(0).each do |(var, expr)|
48
48
  begin
49
- val = expr.evaluate(solution, options.merge(
50
- queryable: queryable,
51
- depth: options[:depth].to_i + 1))
49
+ val = expr.evaluate(solution, queryable: queryable,
50
+ depth: options[:depth].to_i + 1,
51
+ **options)
52
52
  debug(options) {"===> + #{var} => #{val.inspect}"}
53
53
  solution.bindings[var.to_sym] = val
54
54
  rescue TypeError => e
@@ -36,13 +36,13 @@ module SPARQL; module Algebra
36
36
  # the resulting solution sequence
37
37
  # @see http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
38
38
  # @see http://www.w3.org/TR/sparql11-query/#ebv
39
- def execute(queryable, options = {}, &block)
39
+ def execute(queryable, **options, &block)
40
40
  debug(options) {"Filter #{operands.first.to_sxp}"}
41
41
  opts = options.merge(queryable: queryable, depth: options[:depth].to_i + 1)
42
42
  @solutions = RDF::Query::Solutions()
43
- queryable.query(operands.last, options.merge(depth: options[:depth].to_i + 1)) do |solution|
43
+ queryable.query(operands.last, depth: options[:depth].to_i + 1, **options) do |solution|
44
44
  begin
45
- pass = boolean(operands.first.evaluate(solution, opts)).true?
45
+ pass = boolean(operands.first.evaluate(solution, **opts)).true?
46
46
  debug(options) {"(filter) #{pass.inspect} #{solution.to_h.inspect}"}
47
47
  @solutions << solution if pass
48
48
  rescue
@@ -64,10 +64,10 @@ module SPARQL; module Algebra
64
64
  # @return [RDF::Query::Solutions]
65
65
  # the resulting solution sequence
66
66
  # @see http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
67
- def execute(queryable, options = {}, &block)
67
+ def execute(queryable, **options, &block)
68
68
  debug(options) {"Graph #{operands.first}"}
69
69
  graph_name, query = operands.first, operands.last
70
- @solutions = queryable.query(query, options.merge(graph_name: graph_name), &block)
70
+ @solutions = queryable.query(query, graph_name: graph_name, **options, &block)
71
71
  end
72
72
 
73
73
  ##
@@ -11,8 +11,8 @@ module SPARQL; module Algebra
11
11
  # @example
12
12
  # (prefix ((: <http://example/>))
13
13
  # (project (?w ?S)
14
- # (extend ((?S ?.0))
15
- # (group (?w) ((?.0 (sample ?v)))
14
+ # (extend ((?S ??.0))
15
+ # (group (?w) ((??.0 (sample ?v)))
16
16
  # (leftjoin
17
17
  # (bgp (triple ?s :p ?v))
18
18
  # (bgp (triple ?s :q ?w)))))))
@@ -38,12 +38,12 @@ module SPARQL; module Algebra
38
38
  # @return [RDF::Query::Solutions]
39
39
  # the resulting solution sequence
40
40
  # @see http://www.w3.org/TR/sparql11-query/#sparqlGroupAggregate
41
- def execute(queryable, options = {}, &block)
41
+ def execute(queryable, **options, &block)
42
42
  debug(options) {"Group"}
43
43
  exprlist = operands.first
44
44
  query = operands.last
45
45
  aggregates = operands.length == 3 ? operand(1) : []
46
- solutions = queryable.query(query, options.merge(depth: options[:depth].to_i + 1))
46
+ solutions = queryable.query(query, depth: options[:depth].to_i + 1, **options)
47
47
 
48
48
  groups = solutions.group_by do |solution|
49
49
  # Evaluate each exprlist operand to get groups where each key is a new solution
@@ -54,14 +54,14 @@ module SPARQL; module Algebra
54
54
  if operand.is_a?(Array)
55
55
  # Form is [variable, expression]
56
56
  soln[operand.first] = operand.last.evaluate(solution,
57
- options.merge(
58
- queryable: queryable,
59
- depth: options[:depth].to_i + 1))
57
+ queryable: queryable,
58
+ depth: options[:depth].to_i + 1,
59
+ **options)
60
60
  else
61
61
  # Form is variable
62
- soln[operand] = operand.evaluate(solution, options.merge(
63
- queryable: queryable,
64
- depth: options[:depth].to_i + 1))
62
+ soln[operand] = operand.evaluate(solution, queryable: queryable,
63
+ depth: options[:depth].to_i + 1,
64
+ **options)
65
65
  end
66
66
  rescue TypeError
67
67
  # Ignore expression
@@ -76,7 +76,7 @@ module SPARQL; module Algebra
76
76
  @solutions = RDF::Query::Solutions(groups.map do |group_soln, solns|
77
77
  aggregates.each do |(var, aggregate)|
78
78
  begin
79
- group_soln[var] = aggregate.aggregate(solns, options)
79
+ group_soln[var] = aggregate.aggregate(solns, **options)
80
80
  rescue TypeError
81
81
  # Ignored in output
82
82
  end
@@ -9,9 +9,9 @@ module SPARQL; module Algebra
9
9
  # (prefix ((: <http://www.example.org/>))
10
10
  # (filter (|| (= ?g "1 22") (= ?g "22 1"))
11
11
  # (project (?g)
12
- # (extend ((?g ?.0))
13
- # (group () ((?.0 (group_concat ?o)))
14
- # (bgp (triple ??0 :p1 ?o)))))))
12
+ # (extend ((?g ??.0))
13
+ # (group () ((??.0 (group_concat ?o)))
14
+ # (bgp (triple ??.0 :p1 ?o)))))))
15
15
  #
16
16
  # @see http://www.w3.org/TR/sparql11-query/#defn_aggGroupConcat
17
17
  class GroupConcat < Operator
@@ -29,12 +29,12 @@ module SPARQL; module Algebra
29
29
  # @return [RDF::Term]
30
30
  # @raise [TypeError]
31
31
  # @abstract
32
- def aggregate(solutions = [], options = {})
32
+ def aggregate(solutions = [], **options)
33
33
  operands.shift if distinct = (operands.first == :distinct)
34
34
  sep = operands.length == 2 ? operand(0).last : RDF::Literal(' ')
35
35
  args_enum = solutions.map do |solution|
36
36
  begin
37
- operands.last.evaluate(solution, options.merge(depth: options[:depth].to_i + 1))
37
+ operands.last.evaluate(solution, depth: options[:depth].to_i + 1, **options)
38
38
  rescue TypeError
39
39
  # Ignore errors
40
40
  nil
@@ -33,10 +33,10 @@ module SPARQL; module Algebra
33
33
  # a query solution containing zero or more variable bindings
34
34
  # @return [RDF::Term]
35
35
  # @raise [TypeError]
36
- def evaluate(bindings, options = {})
37
- operand(0).evaluate(bindings, options.merge(depth: options[:depth].to_i + 1)) == RDF::Literal::TRUE ?
38
- operand(1).evaluate(bindings, options.merge(depth: options[:depth].to_i + 1).merge(depth: options[:depth].to_i + 1)) :
39
- operand(2).evaluate(bindings, options.merge(depth: options[:depth].to_i + 1))
36
+ def evaluate(bindings, **options)
37
+ operand(0).evaluate(bindings, depth: options[:depth].to_i + 1, **options) == RDF::Literal::TRUE ?
38
+ operand(1).evaluate(bindings, depth: options[:depth].to_i + 1, **options) :
39
+ operand(2).evaluate(bindings, depth: options[:depth].to_i + 1, **options)
40
40
  rescue
41
41
  raise TypeError
42
42
  end
@@ -38,12 +38,12 @@ module SPARQL; module Algebra
38
38
  # options passed from query
39
39
  # @return [RDF::Literal::Boolean] `true` or `false`
40
40
  # @raise [TypeError] if term is not found and any operand raises an error
41
- def evaluate(bindings, options = {})
42
- lhs = operands.first.evaluate(bindings, options)
41
+ def evaluate(bindings, **options)
42
+ lhs = operands.first.evaluate(bindings, **options)
43
43
  error_found = false
44
44
  found = operands[1..-1].any? do |op|
45
45
  begin
46
- lhs == op.evaluate(bindings, options.merge(depth: options[:depth].to_i + 1))
46
+ lhs == op.evaluate(bindings, depth: options[:depth].to_i + 1, **options)
47
47
  rescue TypeError
48
48
  error_found = true
49
49
  end
@@ -20,7 +20,7 @@ module SPARQL; module Algebra
20
20
  #
21
21
  # @param [RDF::Queryable] queryable
22
22
  # the graph or repository to write
23
- # @param [RDF::Query::Solution] solution
23
+ # @param [RDF::Query::Solution] :solutions
24
24
  # Solution to map to patterns for this operation
25
25
  # @param [Hash{Symbol => Object}] options
26
26
  # any additional keyword options
@@ -31,7 +31,9 @@ module SPARQL; module Algebra
31
31
  # @raise [IOError]
32
32
  # If `from` does not exist, unless the `silent` operator is present
33
33
  # @see http://www.w3.org/TR/sparql11-update/
34
- def execute(queryable, solution, options = {})
34
+ def execute(queryable, solutions: nil, **options)
35
+ # Only binds the first solution
36
+ solution = solutions.is_a?(RDF::Query::Solutions) ? solutions.first : solutions
35
37
  debug(options) {"Insert"}
36
38
  patterns = operand.inject([]) do |memo, op|
37
39
  if op.respond_to?(:statements)