sparql 3.0.1 → 3.1.4

data/lib/sparql/algebra/operator/contains.rb

@@ -6,8 +6,8 @@ module SPARQL; module Algebra
     # @example
     #   (contains ?x ?y)
     #
-    # @see http://www.w3.org/TR/sparql11-query/#func-contains
-    # @see http://www.w3.org/TR/xpath-functions/#func-contains
+    # @see https://www.w3.org/TR/sparql11-query/#func-contains
+    # @see https://www.w3.org/TR/xpath-functions/#func-contains
     class Contains < Operator::Binary
       include Evaluatable
 

data/lib/sparql/algebra/operator/copy.rb

@@ -9,7 +9,7 @@ module SPARQL; module Algebra
     # @example
     #   (copy silent <iri> to default)
     #
-    # @see http://www.w3.org/TR/sparql11-update/#copy
+    # @see https://www.w3.org/TR/sparql11-update/#copy
     class Copy < Operator
       include SPARQL::Algebra::Update
 
@@ -28,8 +28,8 @@ module SPARQL; module Algebra
       #   Returns queryable.
       # @raise [IOError]
       #   If `from` does not exist, unless the `silent` operator is present
-      # @see    http://www.w3.org/TR/sparql11-update/
-      def execute(queryable, options = {})
+      # @see    https://www.w3.org/TR/sparql11-update/
+      def execute(queryable, **options)
         debug(options) {"Copy"}
         silent = operands.first == :silent
         operands.shift if silent

data/lib/sparql/algebra/operator/count.rb

@@ -6,11 +6,11 @@ module SPARQL; module Algebra
     # @example
     #    (prefix ((: <http://www.example.org>))
     #      (project (?C)
-    #        (extend ((?C ?.0))
-    #          (group () ((?.0 (count ?O)))
+    #        (extend ((?C ??.0))
+    #          (group () ((??.0 (count ?O)))
     #            (bgp (triple ?S ?P ?O))))))
     #
-    # @see http://www.w3.org/TR/sparql11-query/#defn_aggCount
+    # @see https://www.w3.org/TR/sparql11-query/#defn_aggCount
     class Count < Operator
       include Aggregate
 

data/lib/sparql/algebra/operator/create.rb

@@ -11,7 +11,7 @@ module SPARQL; module Algebra
     # @example
     #   (create silent <graph>)
     #
-    # @see http://www.w3.org/TR/sparql11-update/#create
+    # @see https://www.w3.org/TR/sparql11-update/#create
     class Create < Operator
       include SPARQL::Algebra::Update
 
@@ -30,8 +30,8 @@ module SPARQL; module Algebra
       #   Returns queryable.
       # @raise [IOError]
       #   If `from` does not exist, unless the `silent` operator is present
-      # @see    http://www.w3.org/TR/sparql11-update/
-      def execute(queryable, options = {})
+      # @see    https://www.w3.org/TR/sparql11-update/
+      def execute(queryable, **options)
         debug(options) {"Create"}
         silent = operands.first == :silent
         operands.shift if silent

data/lib/sparql/algebra/operator/dataset.rb

@@ -102,7 +102,7 @@ module SPARQL; module Algebra
     #         (graph ?g (bgp (triple ?s ?p ?o))))))
     #
     # @example Dataset with multiple named graphs
-    # @see http://www.w3.org/TR/sparql11-query/#specifyingDataset
+    # @see https://www.w3.org/TR/sparql11-query/#specifyingDataset
     class Dataset < Binary
       include Query
 
@@ -125,8 +125,8 @@ module SPARQL; module Algebra
       # @yieldreturn [void] ignored
       # @return [RDF::Query::Solutions]
       #   the resulting solution sequence
-      # @see    http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
-      def execute(queryable, options = {}, &base)
+      # @see    https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
+      def execute(queryable, **options, &base)
         debug(options) {"Dataset"}
         default_datasets = []
         named_datasets = []
@@ -141,10 +141,10 @@ module SPARQL; module Algebra
             debug(options) {"=> default data source #{uri}"}
             default_datasets << uri
           end
-          load_opts = {debug: options.fetch(:debug, nil), graph_name: uri, base_uri: uri}
+          load_opts = {logger: options.fetch(:logger, false), graph_name: uri, base_uri: uri}
           unless queryable.has_graph?(uri)
             debug(options) {"=> load #{uri}"}
-            queryable.load(uri.to_s, load_opts)
+            queryable.load(uri.to_s, **load_opts)
           end
         end
         debug(options) {
@@ -156,18 +156,7 @@ module SPARQL; module Algebra
         aggregate = RDF::AggregateRepo.new(queryable)
         named_datasets.each {|name| aggregate.named(name) if queryable.has_graph?(name)}
         aggregate.default(*default_datasets.select {|name| queryable.has_graph?(name)})
-        aggregate.query(operands.last, options.merge(depth: options[:depth].to_i + 1), &base)
-      end
-      
-      ##
-      # Returns an optimized version of this query.
-      #
-      # If optimize operands, and if the first two operands are both Queries, replace
-      # with the unique sum of the query elements
-      #
-      # @return [Union, RDF::Query] `self`
-      def optimize
-        operands.last.optimize
+        aggregate.query(operands.last, depth: options[:depth].to_i + 1, **options, &base)
       end
     end # Dataset
   end # Operator

data/lib/sparql/algebra/operator/datatype.rb

@@ -11,7 +11,7 @@ module SPARQL; module Algebra
     #       (filter (= (datatype (xsd:double ?v)) xsd:double)
     #         (bgp (triple ?s :p ?v)))))
     #
-    # @see http://www.w3.org/TR/sparql11-query/#func-datatype
+    # @see https://www.w3.org/TR/sparql11-query/#func-datatype
     class Datatype < Operator::Unary
       include Evaluatable
 

data/lib/sparql/algebra/operator/day.rb

@@ -9,7 +9,7 @@ module SPARQL; module Algebra
     #         (extend ((?x (day ?date)))
     #           (bgp (triple ?s :date ?date)))))
     #
-    # @see http://www.w3.org/TR/sparql11-query/#func-day
+    # @see https://www.w3.org/TR/sparql11-query/#func-day
     class Day < Operator::Unary
       include Evaluatable
 

data/lib/sparql/algebra/operator/delete.rb

@@ -9,7 +9,7 @@ module SPARQL; module Algebra
     # @example
     #   (delete ((triple ?s ?p ?o))))
     #
-    # @see http://www.w3.org/TR/sparql11-update/#delete
+    # @see https://www.w3.org/TR/sparql11-update/#delete
     class Delete < Operator::Unary
       include SPARQL::Algebra::Update
 
@@ -20,8 +20,8 @@ module SPARQL; module Algebra
       #
       # @param  [RDF::Queryable] queryable
       #   the graph or repository to write
-      # @param  [RDF::Query::Solution] solution
-      #   Solution to map to patterns for this operation
+      # @param  [RDF::Query::Solutions] solutions
+      #   Solutions to map to patterns for this operation
       # @param  [Hash{Symbol => Object}] options
       #   any additional keyword options
       # @option options [Boolean] debug
@@ -30,9 +30,11 @@ module SPARQL; module Algebra
       #   Returns queryable.
       # @raise [IOError]
       #   If `from` does not exist, unless the `silent` operator is present
-      # @see    http://www.w3.org/TR/sparql11-update/
-      def execute(queryable, solution, options = {})
-        debug(options) {"Delete: #{solution} against #{operands.to_sse}"}
+      # @see    https://www.w3.org/TR/sparql11-update/
+      def execute(queryable, solutions: nil, **options)
+        debug(options) {"Delete: #{solutions} against #{operands.to_sse}"}
+        # Only binds the first solution
+        solution = solutions.is_a?(RDF::Query::Solutions) ? solutions.first : solutions
         # Operands are an array of patterns and Queries (when named).
         # Create a new query made up all patterns
         patterns = operand.inject([]) do |memo, op|
@@ -45,7 +47,7 @@ module SPARQL; module Algebra
         end
         patterns.each do |pattern|
           pattern = pattern.dup.bind(solution)
-          debug(options) {"Delete statement #{statement.to_sse}"}
+          debug(options) {"Delete pattern #{pattern.to_sse}"}
           queryable.delete(RDF::Statement.from(pattern)) if pattern.bound? || pattern.constant?
         end
         queryable

data/lib/sparql/algebra/operator/delete_data.rb

@@ -9,7 +9,7 @@ module SPARQL; module Algebra
     # @example
     #   (deleteData ((triple :a foaf:knows :c)))
     #
-    # @see http://www.w3.org/TR/sparql11-update/#deleteData
+    # @see https://www.w3.org/TR/sparql11-update/#deleteData
     class DeleteData < Operator::Unary
       include SPARQL::Algebra::Update
 
@@ -28,8 +28,8 @@ module SPARQL; module Algebra
       #   Returns queryable.
       # @raise [IOError]
       #   If `from` does not exist, unless the `silent` operator is present
-      # @see    http://www.w3.org/TR/sparql11-update/
-      def execute(queryable, options = {})
+      # @see    https://www.w3.org/TR/sparql11-update/
+      def execute(queryable, **options)
         operand.each do |op|
           debug(options) {"DeleteData #{op.to_sxp}"}
           queryable.delete(op)

data/lib/sparql/algebra/operator/delete_where.rb

@@ -9,7 +9,7 @@ module SPARQL; module Algebra
     # @example
     #   (deleteWhere ((triple :a foaf:knows ?b))
     #
-    # @see http://www.w3.org/TR/sparql11-update/#deleteWhere
+    # @see https://www.w3.org/TR/sparql11-update/#deleteWhere
     class DeleteWhere < Operator::Unary
       include SPARQL::Algebra::Update
 
@@ -28,8 +28,8 @@ module SPARQL; module Algebra
       #   Returns queryable.
       # @raise [IOError]
       #   If `from` does not exist, unless the `silent` operator is present
-      # @see    http://www.w3.org/TR/sparql11-update/
-      def execute(queryable, options = {})
+      # @see    https://www.w3.org/TR/sparql11-update/
+      def execute(queryable, **options)
         # Operands are an array of patterns and Queries (when named).
         # Create a new query made up all patterns
         patterns = operand.inject([]) do |memo, op|
@@ -40,13 +40,13 @@ module SPARQL; module Algebra
           end
           memo
         end
-        query = RDF::Query.new(*patterns, {}) # FIXME: added hash argument needed until Statement#to_hash removed.
+        query = RDF::Query.new(*patterns, **{}) # FIXME: added hash argument needed until Statement#to_hash removed.
         debug(options) {"DeleteWhere query #{query.to_sse}"}
-        query.execute(queryable, options.merge(depth: options[:depth].to_i + 1)) do |solution|
+        query.execute(queryable, depth: options[:depth].to_i + 1, **options) do |solution|
           debug(options) {"DeleteWhere solution #{solution.to_sse}"}
           query.each_statement do |pattern|
             pattern = pattern.dup.bind(solution)
-            debug(options) {"DeleteWhere statement #{statement.to_sse}"}
+            debug(options) {"DeleteWhere pattern #{pattern.to_sse}"}
             queryable.delete(RDF::Statement.from(pattern)) if pattern.bound? || pattern.constant?
           end
         end

data/lib/sparql/algebra/operator/desc.rb

@@ -9,7 +9,7 @@ module SPARQL; module Algebra
     #       (order ((desc ?name))
     #         (bgp (triple ?x foaf:name ?name)))))
     #
-    # @see http://www.w3.org/TR/sparql11-query/#modOrderBy
+    # @see https://www.w3.org/TR/sparql11-query/#modOrderBy
     class Desc < Operator::Asc
       NAME = :desc
     end # Desc

data/lib/sparql/algebra/operator/describe.rb

@@ -10,7 +10,7 @@ module SPARQL; module Algebra
     #     (describe (?x)
     #       (bgp (triple ?x exOrg:employeeId "1234"))))
     #
-    # @see http://www.w3.org/TR/sparql11-query/#describe
+    # @see https://www.w3.org/TR/sparql11-query/#describe
     class Describe < Operator::Binary
       include Query
       
@@ -39,8 +39,8 @@ module SPARQL; module Algebra
       # @yieldreturn [void] ignored
       # @return [RDF::Graph]
       #   containing the constructed triples
-      # @see    http://www.w3.org/TR/sparql11-query/#describe
-      def execute(queryable, options = {}, &block)
+      # @see    https://www.w3.org/TR/sparql11-query/#describe
+      def execute(queryable, **options, &block)
         debug(options) {"Describe #{operands.first}, #{options.inspect}"}
 
         # Describe any constand URIs
@@ -60,16 +60,6 @@ module SPARQL; module Algebra
         # Return Concise Bounded Description
         queryable.concise_bounded_description(*to_describe.uniq, &block)
       end
-      
-      ##
-      # Returns an optimized version of this query.
-      #
-      # Return optimized query
-      #
-      # @return [Union, RDF::Query] `self`
-      def optimize
-        operands = operands.map(&:optimize)
-      end
 
       # Query results statements (e.g., CONSTRUCT, DESCRIBE, CREATE)
       # @return [Boolean]

data/lib/sparql/algebra/operator/distinct.rb

@@ -10,7 +10,7 @@ module SPARQL; module Algebra
     #       (project (?v)
     #         (bgp (triple ?x ?p ?v)))))
     #
-    # @see http://www.w3.org/TR/sparql11-query/#sparqlDistinct
+    # @see https://www.w3.org/TR/sparql11-query/#sparqlDistinct
     class Distinct < Operator::Unary
       include Query
       
@@ -30,22 +30,12 @@ module SPARQL; module Algebra
       # @yieldreturn [void] ignored
       # @return [RDF::Query::Solutions]
       #   the resulting solution sequence
-      # @see    http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
-      def execute(queryable, options = {}, &block)
-        @solutions = queryable.query(operands.last, options.merge(depth: options[:depth].to_i + 1)).distinct
+      # @see    https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
+      def execute(queryable, **options, &block)
+        @solutions = queryable.query(operands.last, depth: options[:depth].to_i + 1, **options).distinct
         @solutions.each(&block) if block_given?
         @solutions
       end
-      
-      ##
-      # Returns an optimized version of this query.
-      #
-      # Return optimized query
-      #
-      # @return [Union, RDF::Query] `self`
-      def optimize
-        operands = operands.map(&:optimize)
-      end
     end # Distinct
   end # Operator
 end; end # SPARQL::Algebra

data/lib/sparql/algebra/operator/divide.rb

@@ -6,7 +6,7 @@ module SPARQL; module Algebra
     # @example
     #   (/ 4 2)
     #
-    # @see http://www.w3.org/TR/xpath-functions/#func-numeric-divide
+    # @see https://www.w3.org/TR/xpath-functions/#func-numeric-divide
     class Divide < Operator::Binary
       include Evaluatable
 

data/lib/sparql/algebra/operator/drop.rb

@@ -11,7 +11,7 @@ module SPARQL; module Algebra
     # @example
     #   (drop default)
     #
-    # @see http://www.w3.org/TR/sparql11-update/#drop
+    # @see https://www.w3.org/TR/sparql11-update/#drop
     class Drop < Operator
       include SPARQL::Algebra::Update
 
@@ -30,8 +30,8 @@ module SPARQL; module Algebra
       #   Returns queryable.
       # @raise [IOError]
       #   If `from` does not exist, unless the `silent` operator is present
-      # @see    http://www.w3.org/TR/sparql11-update/
-      def execute(queryable, options = {})
+      # @see    https://www.w3.org/TR/sparql11-update/
+      def execute(queryable, **options)
         debug(options) {"Drop"}
         silent = operands.first == :silent
         silent = operands.first == :silent

data/lib/sparql/algebra/operator/encode_for_uri.rb

@@ -8,8 +8,8 @@ module SPARQL; module Algebra
     # @example
     #   (encode_for_uri ?x)
     #
-    # @see http://www.w3.org/TR/sparql11-query/#func-encode
-    # @see http://www.w3.org/TR/xpath-functions/#func-abs
+    # @see https://www.w3.org/TR/sparql11-query/#func-encode
+    # @see https://www.w3.org/TR/xpath-functions/#func-abs
     class EncodeForURI < Operator::Unary
       include Evaluatable
 
@@ -29,7 +29,7 @@ module SPARQL; module Algebra
       # @raise  [TypeError] if the operand is not a literal value
       def apply(operand)
         case operand
-          when RDF::Literal then RDF::Literal(::URI.encode(operand.to_s))
+          when RDF::Literal then RDF::Literal(CGI.escape(operand.to_s))
           else raise TypeError, "expected an RDF::Literal, but got #{operand.inspect}"
         end
       end

data/lib/sparql/algebra/operator/equal.rb

@@ -6,8 +6,8 @@ module SPARQL; module Algebra
     # @example
     #   (= ?x ?y)
     #
-    # @see http://www.w3.org/TR/sparql11-query/#OperatorMapping
-    # @see http://www.w3.org/TR/sparql11-query/#func-RDFterm-equal
+    # @see https://www.w3.org/TR/sparql11-query/#OperatorMapping
+    # @see https://www.w3.org/TR/sparql11-query/#func-RDFterm-equal
     class Equal < Compare
       NAME = :'='
 

data/lib/sparql/algebra/operator/exists.rb

@@ -10,7 +10,7 @@ module SPARQL; module Algebra
     #      (filter (exists (bgp (triple ?s ?p ex:o)))
     #      (bgp (triple ?s ?p ?o))))
     #
-    # @see http://www.w3.org/TR/sparql11-query/#func-filter-exists
+    # @see https://www.w3.org/TR/sparql11-query/#func-filter-exists
     class Exists < Operator::Unary
       include Evaluatable
 
@@ -26,11 +26,11 @@ module SPARQL; module Algebra
       # @option options[RDF::Queryable] queryable
       #   queryable to execute, using bindings as an initial solution.
       # @return [RDF::Literal::Boolean] `true` or `false`
-      def evaluate(bindings, options = {})
+      def evaluate(bindings, **options)
         queryable = options[:queryable]
-        !operand(0).execute(queryable, options.merge(
-                                        solutions: RDF::Query::Solutions(bindings),
-                                        depth: options[:depth].to_i + 1)).empty?
+        !operand(0).execute(queryable, solutions: RDF::Query::Solutions(bindings),
+                                       depth: options[:depth].to_i + 1,
+                                       **options).empty?
       end
     end # Exists
   end # Operator

data/lib/sparql/algebra/operator/exprlist.rb

@@ -14,7 +14,7 @@ module SPARQL; module Algebra
     #           (triple ?s :q ?w)
     #         ))))
     #
-    # @see http://www.w3.org/TR/sparql11-query/#evaluation
+    # @see https://www.w3.org/TR/sparql11-query/#evaluation
     class Exprlist < Operator
       include Evaluatable
 
@@ -36,20 +36,10 @@ module SPARQL; module Algebra
       #   options passed from query
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if the operands could not be coerced to a boolean literal
-      def evaluate(bindings, options = {})
-        res = operands.all? {|op| boolean(op.evaluate(bindings, options.merge(depth: options[:depth].to_i + 1))).true? }
+      def evaluate(bindings, **options)
+        res = operands.all? {|op| boolean(op.evaluate(bindings, depth: options[:depth].to_i + 1, **options)).true? }
         RDF::Literal(res) # FIXME: error handling
       end
-
-      ##
-      # Returns an optimized version of this query.
-      #
-      # Return optimized query
-      #
-      # @return [Union, RDF::Query] `self`
-      def optimize
-        operands = operands.map(&:optimize)
-      end
     end # Exprlist
   end # Operator
 end; end # SPARQL::Algebra

data/lib/sparql/algebra/operator/extend.rb

@@ -11,7 +11,7 @@ module SPARQL; module Algebra
     #       (extend ((?z (+ ?o 10)))
     #         (bgp (triple ?s <http://example/p> ?o)))))
     #
-    # @see http://www.w3.org/TR/sparql11-query/#evaluation
+    # @see https://www.w3.org/TR/sparql11-query/#evaluation
     class Extend < Operator::Binary
       include Query
       
@@ -28,6 +28,12 @@ module SPARQL; module Algebra
       # 
       # Extend(Ω, var, expr) = { Extend(μ, var, expr) | μ in Ω }
       #
+      # For SPARQL*, expr may be an embedded tiple pattern
+      #
+      #    (extend
+      #     ((?t (triple ?bob foaf:age ?age)))
+      #     (bgp (triple ?t dct:source ?src)))
+      #
       # @param  [RDF::Queryable] queryable
       #   the graph or repository to query
       # @param  [Hash{Symbol => Object}] options
@@ -38,19 +44,24 @@ module SPARQL; module Algebra
       # @yieldreturn [void] ignored
       # @return [RDF::Query::Solutions]
       #   the resulting solution sequence
-      # @see http://www.w3.org/TR/sparql11-query/#evaluation
-      def execute(queryable, options = {}, &block)
+      # @see https://www.w3.org/TR/sparql11-query/#evaluation
+      def execute(queryable, **options, &block)
         debug(options) {"Extend"}
-        @solutions = operand(1).execute(queryable, options.merge(depth: options[:depth].to_i + 1))
+        @solutions = operand(1).execute(queryable, depth: options[:depth].to_i + 1, **options)
         @solutions.each do |solution|
           debug(options) {"===> soln #{solution.to_h.inspect}"}
           operand(0).each do |(var, expr)|
             begin
-              val = expr.evaluate(solution, options.merge(
-                                              queryable: queryable,
-                                              depth: options[:depth].to_i + 1))
+              val = expr.evaluate(solution, queryable: queryable,
+                                            depth: options[:depth].to_i + 1,
+                                            **options)
               debug(options) {"===> + #{var} => #{val.inspect}"}
-              solution.bindings[var.to_sym] = val
+              solution.bindings[var.to_sym] = if val.is_a?(RDF::Query::Pattern)
+                # Variable is bound to the solution
+                val.bind(solution)
+              else
+                val
+              end
             rescue TypeError => e
               # Evaluates to error, ignore
               debug(options) {"===> #{var} error: #{e.message}"}
@@ -72,16 +83,6 @@ module SPARQL; module Algebra
         end
         super
       end
-
-      ##
-      # Returns an optimized version of this query.
-      #
-      # Return optimized query
-      #
-      # @return FIXME
-      def optimize
-        operands = operands.map(&:optimize)
-      end
     end # Filter
   end # Operator
 end; end # SPARQL::Algebra