sparql 1.1.5 → 1.1.6

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

@@ -28,8 +28,8 @@ module SPARQL; module Algebra
       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?
+                                        solutions: RDF::Query::Solutions(bindings),
+                                        depth: options[:depth].to_i + 1)).empty?
       end
     end # Exists
   end # Operator

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

@@ -37,7 +37,7 @@ module SPARQL; module Algebra
       # @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? }
+        res = operands.all? {|op| boolean(op.evaluate(bindings, options.merge(depth: options[:depth].to_i + 1))).true? }
         RDF::Literal(res) # FIXME: error handling
       end
 

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

@@ -41,14 +41,14 @@ module SPARQL; module Algebra
       # @see http://www.w3.org/TR/rdf-sparql-query/#evaluation
       def execute(queryable, options = {}, &block)
         debug(options) {"Extend"}
-        @solutions = operands.last.execute(queryable, options.merge(:depth => options[:depth].to_i + 1))
+        @solutions = operands.last.execute(queryable, options.merge(depth: options[:depth].to_i + 1))
         @solutions.each do |solution|
           debug(options) {"===> soln #{solution.to_hash.inspect}"}
           operands.first.each do |(var, expr)|
             begin
               val = expr.evaluate(solution, options.merge(
-                                              :queryable => queryable,
-                                              :depth => options[:depth].to_i + 1))
+                                              queryable: queryable,
+                                              depth: options[:depth].to_i + 1))
               debug(options) {"===> + #{var} => #{val.inspect}"}
               solution.bindings[var.to_sym] = val
             rescue TypeError => e

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

@@ -38,9 +38,9 @@ module SPARQL; module Algebra
       # @see    http://www.w3.org/TR/rdf-sparql-query/#ebv
       def execute(queryable, options = {}, &block)
         debug(options) {"Filter #{operands.first.to_sxp}"}
-        opts = options.merge(:queryable => queryable, :depth => options[:depth].to_i + 1)
+        opts = options.merge(queryable: queryable, depth: options[:depth].to_i + 1)
         @solutions = RDF::Query::Solutions()
-        queryable.query(operands.last, options.merge(:depth => options[:depth].to_i + 1)) do |solution|
+        queryable.query(operands.last, options.merge(depth: options[:depth].to_i + 1)) do |solution|
           begin
             pass = boolean(operands.first.evaluate(solution, opts)).true?
             debug(options) {"(filter) #{pass.inspect} #{solution.to_hash.inspect}"}

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

@@ -4,22 +4,55 @@ module SPARQL; module Algebra
     ##
     # The SPARQL GraphPattern `graph` operator.
     #
-    # This is a wrapper to add a `context` to the query.
+    # This is a wrapper to add a `context` to the query, or an array of statements.
     #
-    # @example
+    # @example of a query
     #   (prefix ((: <http://example/>))
     #     (graph ?g
     #       (bgp (triple ?s ?p ?o))))
     #
+    # @example named set of statements
+    #   (prefix ((: <http://example/>))
+    #     (graph :g
+    #       ((triple :s :p :o))))
+    #
     # @see http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
     class Graph < Operator::Binary
       include Query
       
       NAME = [:graph]
+      ##
+      # A `graph` is an RDF::Query with a context. It can also be used as a container of statements or patterns, or other queryable operators (see GraphGraphPattern)
+      #
+      # @overload self.new(name, bgp)
+      #   @param [RDF::Resource] name
+      #   @param [RDF::Query] patterns
+      #     A sub-query (bgp)
+      # @overload self.new(name, bgp)
+      #   @param [RDF::Resource] name
+      #   @param [Operator] patterns
+      #     A sub-query (GraphGraphPattern)
+      # @overload self.new(name, patterns)
+      #   @param [RDF::Resource] name
+      #   @param [Array<RDF::Query::Pattern>] patterns
+      #     Quads
+      # @return [RDF::Query]
+      def self.new(name, patterns, &block)
+        case patterns
+        when RDF::Query
+          # Record that the argument as a (bgp) for re-serialization back to SSE
+          RDF::Query.new(*(patterns.patterns + [{context: name,}]), &block)
+        when Operator
+          super
+        else
+          RDF::Query.new(*(patterns + [{context: name, as_container: true}]), &block)
+        end
+      end
 
       ##
-      # Executes this query on the given `queryable` graph or repository.
-      # Applies the given `context` to the query, limiting the scope of the query to the specified `context`, which may be an `RDF::URI` or `RDF::Query::Variable`.
+      # If the second operand is a Query operator:
+      #   Executes this query on the given `queryable` graph or repository.
+      #   Applies the given `context` to the query, limiting the scope of the query to the specified `context`, which may be an `RDF::URI` or `RDF::Query::Variable`.
       #
       # @param  [RDF::Queryable] queryable
       #   the graph or repository to query
@@ -35,7 +68,7 @@ module SPARQL; module Algebra
       def execute(queryable, options = {}, &block)
         debug(options) {"Graph #{operands.first}"}
         context, query = operands.first, operands.last
-        @solutions = queryable.query(query, options.merge(:context => context), &block)
+        @solutions = queryable.query(query, options.merge(context: context), &block)
       end
       
       ##
@@ -50,6 +83,7 @@ module SPARQL; module Algebra
       
       ##
       # Don't do any more rewriting
+      # FIXME: if ooperator is JOIN, and rewritten sub-operators are queries, can do simple merge of sub-graphs
       # @return [SPARQL::Algebra::Expression] `self`
       def rewrite(&block)
         self

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

@@ -43,7 +43,7 @@ module SPARQL; module Algebra
         exprlist = operands.first
         query = operands.last
         aggregates = operands.length == 3 ? operand(1) : []
-        solutions = queryable.query(query, options.merge(:depth => options[:depth].to_i + 1))
+        solutions = queryable.query(query, options.merge(depth: options[:depth].to_i + 1))
 
         groups = solutions.group_by do |solution|
           # Evaluate each exprlist operand to get groups where each key is a new solution
@@ -55,13 +55,13 @@ module SPARQL; module Algebra
                 # Form is [variable, expression]
                 soln[operand.first] = operand.last.evaluate(solution,
                                                             options.merge(
-                                                             :queryable => queryable,
-                                                             :depth => options[:depth].to_i + 1))
+                                                             queryable: queryable,
+                                                             depth: options[:depth].to_i + 1))
               else
                 # Form is variable
                 soln[operand] = operand.evaluate(solution, options.merge(
-                                                            :queryable => queryable,
-                                                            :depth => options[:depth].to_i + 1))
+                                                            queryable: queryable,
+                                                            depth: options[:depth].to_i + 1))
               end
             rescue TypeError
               # Ignore expression

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

@@ -30,7 +30,7 @@ module SPARQL; module Algebra
         sep = operands.length == 2 ? operand(0).last : RDF::Literal(' ')
         args_enum = solutions.map do |solution|
           begin
-            operands.last.evaluate(solution, options.merge(:depth => options[:depth].to_i + 1))
+            operands.last.evaluate(solution, options.merge(depth: options[:depth].to_i + 1))
           rescue TypeError
             # Ignore errors
             nil

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

@@ -34,9 +34,9 @@ module SPARQL; module Algebra
       # @return [RDF::Term]
       # @raise [TypeError]
       def evaluate(bindings, options = {})
-        operand(0).evaluate(bindings, options.merge(:depth => options[:depth].to_i + 1)) == RDF::Literal::TRUE ?
-          operand(1).evaluate(bindings, options.merge(:depth => options[:depth].to_i + 1).merge(:depth => options[:depth].to_i + 1)) :
-          operand(2).evaluate(bindings, options.merge(:depth => options[:depth].to_i + 1))
+        operand(0).evaluate(bindings, options.merge(depth: options[:depth].to_i + 1)) == RDF::Literal::TRUE ?
+          operand(1).evaluate(bindings, options.merge(depth: options[:depth].to_i + 1).merge(depth: options[:depth].to_i + 1)) :
+          operand(2).evaluate(bindings, options.merge(depth: options[:depth].to_i + 1))
         rescue
           raise TypeError
       end

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

@@ -45,7 +45,7 @@ module SPARQL; module Algebra
         error_found = false
         found = operands[1..-1].any? do |op|
           begin
-            lhs == op.evaluate(bindings, options.merge(:depth => options[:depth].to_i + 1))
+            lhs == op.evaluate(bindings, options.merge(depth: options[:depth].to_i + 1))
           rescue TypeError
             error_found = true
           end

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

@@ -0,0 +1,54 @@
+module SPARQL; module Algebra
+  class Operator
+
+    ##
+    # The SPARQL UPDATE `insertData` operator.
+    #
+    # The INSERT operation is a form of the DELETE/INSERT operation having no DELETE section
+    #
+    # @example
+    #   (insert ((triple ?s ?p "q")))
+    #
+    # @see http://www.w3.org/TR/sparql11-update/#insert
+    class Insert < Operator::Unary
+      include SPARQL::Algebra::Update
+
+      NAME = [:insert]
+
+      ##
+      # Executes this upate on the given `writable` graph or repository.
+      #
+      # @param  [RDF::Queryable] queryable
+      #   the graph or repository to write
+      # @param  [RDF::Query::Solution] solution
+      #   Solution to map to patterns for this operation
+      # @param  [Hash{Symbol => Object}] options
+      #   any additional keyword options
+      # @option options [Boolean] debug
+      #   Query execution debugging
+      # @return [RDF::Queryable]
+      #   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) {"Insert"}
+        patterns = operand.inject([]) do |memo, op|
+          if op.respond_to?(:statements)
+            memo += op.statements.to_a
+          else
+            memo << op
+          end
+          memo
+        end
+        patterns.each do |pattern|
+          pattern = pattern.dup.bind(solution)
+          debug(options) {"Insert statement #{statement.to_sse}"}
+          # Only insert bound or constant patterns
+          queryable.insert(RDF::Statement.from(pattern)) if pattern.bound? || pattern.constant?
+        end
+        queryable
+      end
+    end # Insert
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -0,0 +1,41 @@
+module SPARQL; module Algebra
+  class Operator
+
+    ##
+    # The SPARQL UPDATE `insertData` operator.
+    #
+    # The INSERT DATA operation adds some triples, given inline in the request, into the Graph Store
+    #
+    # @example
+    #   (insertData ((graph <http://example.org/g1> ((triple :s :p :o)))))
+    #
+    # @see http://www.w3.org/TR/sparql11-update/#insertData
+    class InsertData < Operator::Unary
+      include SPARQL::Algebra::Update
+
+      NAME = [:insertData]
+
+      ##
+      # Executes this upate on the given `writable` graph or repository.
+      #
+      # @param  [RDF::Queryable] queryable
+      #   the graph or repository to write
+      # @param  [Hash{Symbol => Object}] options
+      #   any additional keyword options
+      # @option options [Boolean] debug
+      #   Query execution debugging
+      # @return [RDF::Queryable]
+      #   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 = {})
+        operand.each do |op|
+          debug(options) {"InsertData #{op.to_sxp}"}
+          queryable.insert(op)
+        end
+        queryable
+      end
+    end # InsertData
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -41,10 +41,10 @@ module SPARQL; module Algebra
         # Generate solutions independently, merge based on solution compatibility
         debug(options) {"Join"}
  
-        left = queryable.query(operand(0), options.merge(:depth => options[:depth].to_i + 1))
+        left = queryable.query(operand(0), options.merge(depth: options[:depth].to_i + 1))
         debug(options) {"(join)=>(left) #{left.inspect}"}
 
-        right = queryable.query(operand(1), options.merge(:depth => options[:depth].to_i + 1))
+        right = queryable.query(operand(1), options.merge(depth: options[:depth].to_i + 1))
         debug(options) {"(join)=>(right) #{right.inspect}"}
 
         @solutions = RDF::Query::Solutions(left.map do |s1|

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

@@ -22,7 +22,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(operand.to_s.downcase, :datatype => operand.datatype, :language => operand.language)
+          when RDF::Literal then RDF::Literal(operand.to_s.downcase, datatype: operand.datatype, language: operand.language)
           else raise TypeError, "expected an RDF::Literal::Numeric, but got #{operand.inspect}"
         end
       end

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

@@ -38,10 +38,10 @@ module SPARQL; module Algebra
         filter = operand(2)
 
         debug(options) {"LeftJoin"}
-        left = queryable.query(operand(0), options.merge(:depth => options[:depth].to_i + 1))
+        left = queryable.query(operand(0), options.merge(depth: options[:depth].to_i + 1))
         debug(options) {"=>(leftjoin left) #{left.inspect}"}
 
-        right = queryable.query(operand(1), options.merge(:depth => options[:depth].to_i + 1))
+        right = queryable.query(operand(1), options.merge(depth: options[:depth].to_i + 1))
         debug(options) {"=>(leftjoin right) #{right.inspect}"}
 
         # LeftJoin(Ω1, Ω2, expr) =

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

@@ -0,0 +1,48 @@
+module SPARQL; module Algebra
+  class Operator
+
+    ##
+    # The SPARQL UPDATE `load` operator.
+    #
+    # The LOAD operation reads an RDF document from a IRI and inserts its triples into the specified graph in the Graph Store. The specified destination graph should be created if required; again, implementations providing an update service over a fixed set of graphs must return with failure for a request that would create a disallowed graph. If the destination graph already exists, then no data in that graph will be removed.
+    #
+    # @example
+    #   (load <remote> <g>)
+    #
+    # @see http://www.w3.org/TR/sparql11-update/#load
+    class Load < Operator
+      include SPARQL::Algebra::Update
+
+      NAME = [:load]
+
+      ##
+      # Executes this upate on the given `writable` graph or repository.
+      #
+      # @param  [RDF::Queryable] queryable
+      #   the graph or repository to write
+      # @param  [Hash{Symbol => Object}] options
+      #   any additional keyword options
+      # @option options [Boolean] debug
+      #   Query execution debugging
+      # @return [RDF::Queryable]
+      #   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 = {})
+        debug(options) {"Load"}
+        silent = operands.first == :silent
+        operands.shift if silent
+
+        raise ArgumentError, "load expected one or two operands, got #{operands.length}" unless [1,2].include?(operands.length)
+
+        location, name = operands
+        queryable.load(location, context: name)
+      rescue IOError, Errno::ENOENT
+        raise unless silent
+      ensure
+        queryable
+      end
+    end # Load
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -42,9 +42,9 @@ module SPARQL; module Algebra
         # 
         # card[Minus(Ω1, Ω2)](μ) = card[Ω1](μ)
         debug(options) {"Minus"}
-        left = queryable.query(operand(0), options.merge(:depth => options[:depth].to_i + 1))
+        left = queryable.query(operand(0), options.merge(depth: options[:depth].to_i + 1))
         debug(options) {"(minus left) #{left.inspect}"}
-        right = queryable.query(operand(1), options.merge(:depth => options[:depth].to_i + 1))
+        right = queryable.query(operand(1), options.merge(depth: options[:depth].to_i + 1))
         debug(options) {"(minus right) #{right.inspect}"}
         @solutions = left.minus(right)
         @solutions.each(&block) if block_given?

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

@@ -0,0 +1,53 @@
+module SPARQL; module Algebra
+  class Operator
+
+    ##
+    # The SPARQL UPDATE `modify` operator.
+    #
+    # Wraps delete/insert
+    #
+    # @example
+    #   (modify
+    #     (bgp (triple ?a foaf:knows ?b))
+    #     (delete ((triple ?a foaf:knows ?b)))
+    #     (insert ((triple ?b foaf:knows ?a)))
+    #
+    # @see XXX
+    class Modify < Operator
+      include SPARQL::Algebra::Update
+
+      NAME = [:modify]
+
+      ##
+      # Executes this upate on the given `writable` graph or repository.
+      #
+      # Execute the first operand to get solutions, and apply those solutions to the subsequent operators.
+      #
+      # @param  [RDF::Queryable] queryable
+      #   the graph or repository to write
+      # @param  [Hash{Symbol => Object}] options
+      #   any additional keyword options
+      # @option options [Boolean] debug
+      #   Query execution debugging
+      # @return [RDF::Queryable]
+      #   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 = {})
+        debug(options) {"Modify"}
+        query = operands.shift
+
+        queryable.query(query, options.merge(depth: options[:depth].to_i + 1)) do |solution|
+          debug(options) {"(solution)=>#{solution.inspect}"}
+
+          # Execute each operand with queryable and solution
+          operands.each do |op|
+            op.execute(queryable, solution, options.merge(depth: options[:depth].to_i + 1))
+          end
+        end
+        queryable
+      end
+    end # Modify
+  end # Operator
+end; end # SPARQL::Algebra