sparql 1.1.5 → 1.1.6

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

@@ -0,0 +1,67 @@
+module SPARQL; module Algebra
+  class Operator
+
+    ##
+    # The SPARQL UPDATE `move` operator.
+    #
+    # The MOVE operation is a shortcut for moving all data from an input graph into a destination graph. The input graph is removed after insertion and data from the destination graph, if any, is removed before insertion.
+    #
+    # @example
+    #   (move silent <iri> to default)
+    #
+    # @see http://www.w3.org/TR/sparql11-update/#move
+    class Move < Operator
+      include SPARQL::Algebra::Update
+
+      NAME = [:move]
+
+      ##
+      # 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) {"Move"}
+        silent = operands.first == :silent
+        operands.shift if silent
+
+        src_name, dest_name = operands[-2..-1]
+        raise ArgumentError, "move expected two operands, got #{operands.length}" unless operands.length == 2
+        raise ArgumentError, "move from must be IRI or :default" unless src_name == :default || src_name.is_a?(RDF::URI)
+        raise ArgumentError, "move to must be IRI or :default" unless dest_name == :default || dest_name.is_a?(RDF::URI)
+        src = queryable.enum_graph.detect {|g| g.to_s == src_name.to_s}
+
+        if src.nil?
+          raise IOError, "move operation source does not exist" unless silent
+        elsif dest_name == src_name
+          # No operation
+        else
+          dest = queryable.enum_graph.detect {|g| g.to_s == dest_name.to_s}
+          
+          # Clear destination first
+          dest.clear! if dest
+
+          # Copy statements using destination context
+          src.each do |statement|
+            statement = statement.dup
+            statement.context = (dest_name unless dest_name == :default)
+            queryable << statement
+          end
+
+          # Clear source
+          src.clear!
+        end
+        queryable
+      end
+    end # Move
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -30,7 +30,7 @@ module SPARQL; module Algebra
       def evaluate(bindings, options = {})
         solutions = RDF::Query::Solutions(bindings)
         queryable = options[:queryable]
-        operand(0).execute(queryable, options.merge(:solutions => solutions)).empty?
+        operand(0).execute(queryable, options.merge(solutions: solutions)).empty?
       end
     end # NotExists
   end # Operator

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

@@ -43,11 +43,11 @@ module SPARQL; module Algebra
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if term is not found and any operand raises an error
       def evaluate(bindings, options = {})
-        lhs = operands.first.evaluate(bindings, options.merge(:depth => options[:depth].to_i + 1))
+        lhs = operands.first.evaluate(bindings, options.merge(depth: options[:depth].to_i + 1))
         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/or.rb

@@ -42,13 +42,13 @@ module SPARQL; module Algebra
       # @raise  [TypeError] if the operands could not be coerced to a boolean literal
       def evaluate(bindings, options = {})
         begin
-          left = boolean(operand(0).evaluate(bindings, options.merge(:depth => options[:depth].to_i + 1))).true?
+          left = boolean(operand(0).evaluate(bindings, options.merge(depth: options[:depth].to_i + 1))).true?
         rescue TypeError
           left = nil
         end
         
         begin
-          right = boolean(operand(1).evaluate(bindings, options.merge(:depth => options[:depth].to_i + 1))).true?
+          right = boolean(operand(1).evaluate(bindings, options.merge(depth: options[:depth].to_i + 1))).true?
         rescue TypeError
           right = nil
         end

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

@@ -34,12 +34,12 @@ module SPARQL; module Algebra
       def execute(queryable, options = {}, &block)
 
         debug(options) {"Order"}
-        @solutions = queryable.query(operands.last, options.merge(:depth => options[:depth].to_i + 1)).order do |a, b|
+        @solutions = queryable.query(operands.last, options.merge(depth: options[:depth].to_i + 1)).order do |a, b|
           operand(0).inject(0) do |memo, op|
             debug(options) {"(order) #{op.inspect}"}
             memo = begin
-              a_eval = op.evaluate(a, options.merge(:queryable => queryable, :depth => options[:depth].to_i + 1)) rescue nil
-              b_eval = op.evaluate(b, options.merge(:queryable => queryable, :depth => options[:depth].to_i + 1)) rescue nil
+              a_eval = op.evaluate(a, options.merge(queryable: queryable, depth: options[:depth].to_i + 1)) rescue nil
+              b_eval = op.evaluate(b, options.merge(queryable: queryable, depth: options[:depth].to_i + 1)) rescue nil
               comp = Operator::Compare.evaluate(a_eval, b_eval).to_i
               comp = -comp if op.is_a?(Operator::Desc)
               comp

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

@@ -1,29 +1,35 @@
 module SPARQL; module Algebra
   class Operator
     ##
-    # The SPARQL numeric unary `+` operator.
+    # The SPARQL numeric binary/unary `+` operator.
     #
     # @example
     #   (+ ?x ?y)
     #   (plus ?x ?y)
     #
     # @see http://www.w3.org/TR/xpath-functions/#func-numeric-unary-plus
+    # @see http://www.w3.org/TR/xpath-functions/#func-numeric-add
     class Plus < Operator::Unary
       include Evaluatable
 
       NAME = [:+, :plus]
 
       ##
-      # Returns the operand with its sign unchanged.
+      # Returns the arithmetic sum of the operands, unless there is no `right`.
       #
-      # @param  [RDF::Literal::Numeric] term
+      # @param  [RDF::Literal::Numeric] left
+      #   a numeric literal
+      # @param  [RDF::Literal::Numeric] right
       #   a numeric literal
       # @return [RDF::Literal::Numeric]
-      # @raise  [TypeError] if the operand is not a numeric literal
-      def apply(term)
-        case term
-          when RDF::Literal::Numeric then term
-          else raise TypeError, "expected an RDF::Literal::Numeric, but got #{term.inspect}"
+      # @raise  [TypeError] if either operand is not a numeric literal
+      def apply(left, right = nil)
+        case
+        when left.is_a?(RDF::Literal::Numeric) && right.is_a?(RDF::Literal::Numeric)
+          left + right
+        when left.is_a?(RDF::Literal::Numeric) && right.nil?
+          left
+        else raise TypeError, "expected two RDF::Literal::Numeric operands, but got #{left.inspect} and #{right.inspect}"
         end
       end
     end # Plus

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

@@ -32,7 +32,7 @@ module SPARQL; module Algebra
       # @see    http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
       def execute(queryable, options = {}, &block)
         debug(options) {"Prefix"}
-        @solutions = queryable.query(operands.last, options.merge(:depth => options[:depth].to_i + 1), &block)
+        @solutions = queryable.query(operands.last, options.merge(depth: options[:depth].to_i + 1), &block)
       end
       
       ##

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

@@ -31,7 +31,7 @@ module SPARQL; module Algebra
       #   the resulting solution sequence
       # @see    http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
       def execute(queryable, options = {}, &block)
-        @solutions = queryable.query(operands.last, options.merge(:depth => options[:depth].to_i + 1))
+        @solutions = queryable.query(operands.last, options.merge(depth: options[:depth].to_i + 1))
         @solutions = @solutions.project(*(operands.first))
         @solutions.each(&block) if block_given?
         @solutions

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

@@ -33,7 +33,7 @@ module SPARQL; module Algebra
       # @see    http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
       def execute(queryable, options = {}, &block)
         @solutions = operands.last.
-          execute(queryable, options.merge(:depth => options[:depth].to_i + 1)).reduced
+          execute(queryable, options.merge(depth: options[:depth].to_i + 1)).reduced
         @solutions.each(&block) if block_given?
         @solutions
       end

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

@@ -63,7 +63,7 @@ module SPARQL; module Algebra
         options |= Regexp::MULTILINE  if flags.include?(?m)
         options |= Regexp::IGNORECASE if flags.include?(?i)
         options |= Regexp::EXTENDED   if flags.include?(?x)
-        RDF::Literal(text.to_s.gsub(Regexp.new(pattern, options), replacement), :datatype => text.datatype, :language => text.language)
+        RDF::Literal(text.to_s.gsub(Regexp.new(pattern, options), replacement), datatype: text.datatype, language: text.language)
       end
 
       ##

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

@@ -46,7 +46,7 @@ module SPARQL; module Algebra
       def execute(queryable, options = {}, &block)
         offset = operands[0] == :_ ? 0 : operands[0].to_i
         limit = operands[1] == :_ ? -1 : operands[1].to_i
-        @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.offset(operands[0]) unless operands[0] == :_
         @solutions.limit(operands[1]) unless operands[1] == :_
         @solutions.each(&block) if block_given?

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

@@ -49,7 +49,7 @@ module SPARQL; module Algebra
           RDF::Literal("")
         else
           parts = left.to_s.split(right.to_s)
-          RDF::Literal(parts.last, :datatype => left.datatype, :language => left.language)
+          RDF::Literal(parts.last, datatype: left.datatype, language: left.language)
         end
       end
     end # StrAfter

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

@@ -45,13 +45,13 @@ module SPARQL; module Algebra
           raise TypeError, "expected two RDF::Literal operands, but got #{left.inspect} and #{right.inspect}"
         when right.to_s.empty?
           # If the lexical form of arg2 is the empty string, this is considered to be a match and the lexical form of the result is is the empty string. 
-          RDF::Literal("", :language => left.language, :datatype => left.datatype)
+          RDF::Literal("", language: left.language, datatype: left.datatype)
         when !left.to_s.include?(right.to_s)
           # If the lexical form of arg2 is the empty string, this is considered to be a match and the lexical form of the result is is the empty string. 
           RDF::Literal("")
         else
           parts = left.to_s.split(right.to_s)
-          RDF::Literal(parts.first, :language => left.language, :datatype => left.datatype)
+          RDF::Literal(parts.first, language: left.language, datatype: left.datatype)
         end
       end
     end # StrBefore

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

@@ -26,7 +26,7 @@ module SPARQL; module Algebra
       # @see http://www.w3.org/TR/sparql11-query/#func-strdt
       def apply(value, datatypeIRI)
         raise TypeError, "Literal #{value.inspect} is not simple" unless value.simple?
-        RDF::Literal.new(value.to_s, :datatype => datatypeIRI)
+        RDF::Literal.new(value.to_s, datatype: datatypeIRI)
       end
     end # StrDT
   end # Operator

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

@@ -27,7 +27,7 @@ module SPARQL; module Algebra
       # @see http://www.w3.org/TR/sparql11-query/#func-strlang
       def apply(value, langTag)
         raise TypeError, "Literal #{value.inspect} is not simple" unless value.simple?
-        RDF::Literal.new(value.to_s, :language => langTag.to_s)
+        RDF::Literal.new(value.to_s, language: langTag.to_s)
       end
     end # StrLang
   end # Operator

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

@@ -57,11 +57,11 @@ module SPARQL; module Algebra
         startingLoc = startingLoc.to_i
 
         if length == RDF::Literal("")
-          RDF::Literal(source.to_s[(startingLoc-1)..-1], :datatype => source.datatype, :language => source.language)
+          RDF::Literal(source.to_s[(startingLoc-1)..-1], datatype: source.datatype, language: source.language)
         else
           raise TypeError, "expected an integer, but got #{length.inspect}" unless length.is_a?(RDF::Literal::Integer)
           length = length.to_i
-          RDF::Literal(source.to_s[(startingLoc-1), length], :datatype => source.datatype, :language => source.language)
+          RDF::Literal(source.to_s[(startingLoc-1), length], datatype: source.datatype, language: source.language)
         end
       end
 

data/lib/sparql/algebra/operator/ucase.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.upcase, :datatype => operand.datatype, :language => operand.language)
+          when RDF::Literal then RDF::Literal(operand.to_s.upcase, 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/union.rb

@@ -34,7 +34,7 @@ module SPARQL; module Algebra
       def execute(queryable, options = {}, &block)
         debug(options) {"Union"}
         @solutions = RDF::Query::Solutions(operands.inject([]) do |memo, op|
-          solns = op.execute(queryable, options.merge(:depth => options[:depth].to_i + 1))
+          solns = op.execute(queryable, options.merge(depth: options[:depth].to_i + 1))
           debug(options) {"=> (op) #{solns.inspect}"}
           memo + solns
         end)

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

@@ -0,0 +1,44 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL GraphPattern `prefix` operator.
+    #
+    # @example
+    #   (update
+    #     (modify
+    #       (bgp (triple ?s ?p ?o))
+    #       (insert ((triple ?s ?p "q")))))
+    #
+    # @see http://www.w3.org/TR/sparql11-update/#graphUpdate
+    class Update < Operator
+      include SPARQL::Algebra::Update
+      
+      NAME = [:update]
+
+      ##
+      # Executes this upate on the given `queryable` 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 the dataset.
+      # @raise [NotImplementedError]
+      #   If an attempt is made to perform an unsupported operation
+      # @raise [IOError]
+      #   If `queryable` is immutable
+      # @see    http://www.w3.org/TR/sparql11-update/
+      def execute(queryable, options = {})
+        debug(options) {"Update"}
+        raise IOError, "queryable is not mutable" unless queryable.mutable?
+        operands.each do |op|
+          op.execute(queryable, options.merge(depth: options[:depth].to_i + 1))
+        end
+        queryable
+      end
+    end # Update
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -0,0 +1,40 @@
+module SPARQL; module Algebra
+  class Operator
+
+    ##
+    # The SPARQL UPDATE `using` operator.
+    #
+    # The USING and USING NAMED clauses affect the RDF Dataset used while evaluating the WHERE clause. This describes a dataset in the same way as FROM and FROM NAMED clauses describe RDF Datasets in the SPARQL 1.1 Query Language
+    #
+    # @example
+    #   (using (:g1) (bgp (triple ?s ?p ?o)))
+    #
+    # @see http://www.w3.org/TR/sparql11-update/#add
+    class Using < Operator
+      include SPARQL::Algebra::Query
+
+      NAME = :using
+
+      ##
+      # Executes this upate on the given `writable` graph or repository.
+      #
+      # Delegates to Dataset
+      #
+      # @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 = {}, &block)
+        debug(options) {"Using"}
+        Dataset.new(*operands).execute(queryable, options.merge(depth: options[:depth].to_i + 1), &block)
+      end
+    end # Using
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -0,0 +1,72 @@
+module SPARQL; module Algebra
+  class Operator
+
+    ##
+    # The SPARQL UPDATE `with` operator.
+    #
+    # The WITH clause provides a convenience for when an operation primarily refers to a single graph.
+    #
+    # @example
+    #   (with :g1
+    #     (bgp (triple ?s ?p ?o))
+    #     (insert ((triple ?s ?p "z"))))
+    #
+    # @see http://www.w3.org/TR/sparql11-update/#deleteInsert
+    class With < Operator
+      include SPARQL::Algebra::Update
+
+      NAME = :with
+
+      ##
+      # Executes this upate on the given `writable` graph or repository.
+      #
+      # Effectively filters results by setting a default `__context__` variable so that it is used when binding to perform update operations on the appropriate triples.
+      #
+      # @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) {"With: #{operand.to_sse}"}
+        # Bound variable
+        name = operands.shift
+
+        unless queryable.has_context?(name)
+          debug(options) {"=> default data source #{name}"}
+          load_opts = {debug: options.fetch(:debug, nil), base_uri: name}
+          debug(options) {"=> load #{name}"}
+          queryable.load(name.to_s, load_opts)
+        end
+
+        # Set name for RDF::Graph descendants having no context to the name variable
+        descendants do |op|
+          case op
+          when RDF::Query, RDF::Query::Pattern
+            unless op.context
+              debug(options) {"set context on #{op.to_sse}"}
+              op.context = RDF::Query::Variable.new(:__context__, name)
+            end
+          end
+        end
+        query = operands.shift
+
+        # Restrict query portion to this graph
+        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
+      end
+    end # With
+  end # Operator
+end; end # SPARQL::Algebra