sparql 1.1.5 → 1.1.6

data/lib/sparql/algebra/extensions.rb

@@ -78,12 +78,17 @@ class Array
   # @return [Boolean] `true` or `false`
   # @see    #constant?
   def variable?
-    any? do |operand|
-      operand.is_a?(Variable) ||
-        (operand.respond_to?(:variable?) && operand.variable?)
-    end
+    any?(&:variable?)
   end
   def constant?; !(variable?); end
+
+  ##
+  # Does this contain any nodes?
+  #
+  # @return [Boolean]
+  def has_blank_nodes?
+    any?(&:has_blank_nodes?)
+  end
   def evaluatable?; true; end
   def executable?; false; end
   def aggregate?; false; end
@@ -207,7 +212,7 @@ module RDF::Queryable
   #
   # @example
   #     queryable.query([nil, RDF::DOAP.developer, nil])
-  #     queryable.query(:predicate => RDF::DOAP.developer)
+  #     queryable.query(predicate: RDF::DOAP.developer)
   #
   #     op = SPARQL::Algebra::Expression.parse(%q((bgp (triple ?a doap:developer ?b))))
   #     queryable.query(op)
@@ -245,6 +250,18 @@ module RDF::Queryable
   
 end
 
+class RDF::Statement
+  # Transform Statement Pattern into an SXP
+  # @return [Array]
+  def to_sxp_bin
+    if has_context?
+      [:quad, subject, predicate, object, context]
+    else
+      [:triple, subject, predicate, object]
+    end
+  end
+end
+
 class RDF::Query
   # Equivalence for Queries:
   #   Same Patterns
@@ -263,13 +280,20 @@ class RDF::Query
 
   # Transform Query into an Array form of an SSE
   #
-  # If Query is named, it's treated as a GroupGraphPattern, otherwise, a BGP
+  # If Query has the `as_container` option set, serialize as Quads
+  # Otherwise, If Query is named, serialize as a GroupGraphPattern.
+  # Otherise, serialize as a BGP
   #
   # @return [Array]
   def to_sxp_bin
-    res = [:bgp] + patterns.map(&:to_sxp_bin)
-    (context ? [:graph, context, res] : res)
+    if options[:as_container]
+      [:graph, context] + [patterns.map(&:to_sxp_bin)]
+    else
+      res = [:bgp] + patterns.map(&:to_sxp_bin)
+      (context ? [:graph, context, res] : res)
+    end
   end
+
   # Query results in a boolean result (e.g., ASK)
   # @return [Boolean]
   def query_yields_boolean?
@@ -293,7 +317,11 @@ class RDF::Query::Pattern
   # Transform Query Pattern into an SXP
   # @return [Array]
   def to_sxp_bin
-    [:triple, subject, predicate, object]
+    if has_context?
+      [:quad, subject, predicate, object, context]
+    else
+      [:triple, subject, predicate, object]
+    end
   end
 end
 

data/lib/sparql/algebra/operator.rb

@@ -56,7 +56,6 @@ module SPARQL; module Algebra
     autoload :Year,               'sparql/algebra/operator/year'
 
     # Binary operators
-    autoload :Add,                'sparql/algebra/operator/add'
     autoload :And,                'sparql/algebra/operator/and'
     autoload :Compare,            'sparql/algebra/operator/compare'
     autoload :Concat,             'sparql/algebra/operator/concat'
@@ -118,6 +117,26 @@ module SPARQL; module Algebra
     autoload :Table,              'sparql/algebra/operator/table'
     autoload :Union,              'sparql/algebra/operator/union'
 
+    # Update operators
+    autoload :Add,                'sparql/algebra/operator/add'
+    autoload :Clear,              'sparql/algebra/operator/clear'
+    autoload :Copy,               'sparql/algebra/operator/copy'
+    autoload :Create,             'sparql/algebra/operator/create'
+    autoload :Delete,             'sparql/algebra/operator/delete'
+    autoload :DeleteData,         'sparql/algebra/operator/delete_data'
+    autoload :DeleteWhere,        'sparql/algebra/operator/delete_where'
+    autoload :Drop,               'sparql/algebra/operator/drop'
+    autoload :Insert,             'sparql/algebra/operator/insert'
+    autoload :InsertData,         'sparql/algebra/operator/insert_data'
+    autoload :Load,               'sparql/algebra/operator/load'
+    autoload :Modify,             'sparql/algebra/operator/modify'
+    autoload :Move,               'sparql/algebra/operator/move'
+    autoload :Update,             'sparql/algebra/operator/update'
+    autoload :Using,              'sparql/algebra/operator/using'
+    autoload :With,               'sparql/algebra/operator/with'
+
+
+
     ##
     # Returns an operator class for the given operator `name`.
     #
@@ -131,7 +150,7 @@ module SPARQL; module Algebra
         when :'/'             then Divide
         when :'='             then Equal
         when :*               then Multiply
-        when :+               then arity.eql?(1) ? Plus  : Add
+        when :+               then Plus
         when :-               then arity.eql?(1) ? Negate : Subtract
         when :<               then LessThan
         when :<=              then LessThanOrEqual
@@ -216,7 +235,7 @@ module SPARQL; module Algebra
 
         # Datasets
         when :dataset         then Dataset
-        
+
         # Query forms
         when :ask             then Ask
         when :base            then Base
@@ -239,6 +258,24 @@ module SPARQL; module Algebra
         when :table           then Table
         when :triple          then RDF::Query::Pattern
         when :union           then Union
+
+        # Update forms
+        when :add             then Add
+        when :clear           then Clear
+        when :copy            then Copy
+        when :create          then Create
+        when :delete          then Delete
+        when :deletedata      then DeleteData
+        when :deletewhere     then DeleteWhere
+        when :drop            then Drop
+        when :insert          then Insert
+        when :insertdata      then InsertData
+        when :load            then Load
+        when :modify          then Modify
+        when :move            then Move
+        when :update          then Update
+        when :using           then Using
+        when :with            then With
         else                       nil # not found
       end
     end
@@ -303,7 +340,7 @@ module SPARQL; module Algebra
     def base_uri
       Operator.base_uri
     end
-    
+
     ##
     # Base URI used for reading data sources with relative URIs
     #
@@ -311,7 +348,7 @@ module SPARQL; module Algebra
     def self.base_uri
       @base_uri
     end
-    
+
     ##
     # Set Base URI associated with SPARQL document, typically done
     # when reading SPARQL from a URI
@@ -321,7 +358,7 @@ module SPARQL; module Algebra
     def self.base_uri=(uri)
       @base_uri = RDF::URI(uri)
     end
-    
+
     ##
     # Prefixes useful for future serialization
     #
@@ -330,7 +367,7 @@ module SPARQL; module Algebra
     def prefixes
       Operator.prefixes
     end
-    
+
     ##
     # Prefixes useful for future serialization
     #
@@ -339,7 +376,7 @@ module SPARQL; module Algebra
     def self.prefixes
       @prefixes
     end
-    
+
     ##
     # Prefixes useful for future serialization
     #
@@ -349,7 +386,7 @@ module SPARQL; module Algebra
     def self.prefixes=(hash)
       @prefixes = hash
     end
-    
+
     ##
     # Any additional options for this operator.
     #
@@ -379,9 +416,17 @@ module SPARQL; module Algebra
     # @return [Boolean] `true` or `false`
     # @see    #constant?
     def variable?
+      operands.any?(&:variable?)
+    end
+
+    ##
+    # Returns `true` if any of the operands are nodes, `false`
+    # otherwise.
+    #
+    # @return [Boolean]
+    def has_blank_nodes?
       operands.any? do |operand|
-        operand.is_a?(Variable) ||
-          (operand.respond_to?(:variable?) && operand.variable?)
+        operand.respond_to?(:has_blank_nodes?) ? operand.has_blank_nodes? : operand.node?
       end
     end
 
@@ -486,7 +531,7 @@ module SPARQL; module Algebra
         abort "SPARQL::Algebra::Operator#to_sxp requires the SXP gem (hint: `gem install sxp')."
       end
       require 'sparql/algebra/sxp_extensions'
-      
+
       to_sxp_bin.to_sxp
     end
 
@@ -506,6 +551,24 @@ module SPARQL; module Algebra
     end
     alias_method :==, :eql?
 
+    ##
+    # Iterate via deapth-first recursive descent over operands, yielding each operator
+    # @yield operator
+    # @yieldparam [Object] operator
+    def descendants(&block)
+      operands.each do |operand|
+        case operand
+        when Operator
+          operand.descendants(&block)
+        when Array
+          operand.each do |op|
+            op.descendants(&block) if op.is_a?(Operator)
+            block.call(op)
+          end
+        end
+        block.call(operand)
+      end
+    end
   protected
 
     ##

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

@@ -1,33 +1,55 @@
 module SPARQL; module Algebra
   class Operator
-    include Evaluatable
 
     ##
-    # The SPARQL numeric `add` operator.
+    # The SPARQL UPDATE `add` operator.
+    #
+    # The ADD operation is a shortcut for inserting all data from an input graph into a destination graph. Data from the input graph is not affected, and initial data from the destination graph, if any, is kept intact.
     #
     # @example
-    #   (+ 1 ?x)
-    #   (add 1 ?x)
+    #   (add default <a>)
     #
-    # @see http://www.w3.org/TR/xpath-functions/#func-numeric-add
-    class Add < Operator::Binary
-      NAME = [:+, :add]
+    # @see http://www.w3.org/TR/sparql11-update/#add
+    class Add < Operator
+      include SPARQL::Algebra::Update
+
+      NAME = [:add]
 
       ##
-      # Returns the arithmetic sum of the operands.
+      # Executes this upate on the given `writable` graph or repository.
       #
-      # @param  [RDF::Literal::Numeric] left
-      #   a numeric literal
-      # @param  [RDF::Literal::Numeric] right
-      #   a numeric literal
-      # @return [RDF::Literal::Numeric]
-      # @raise  [TypeError] if either operand is not a numeric literal
-      def apply(left, right)
-        case
-          when left.is_a?(RDF::Literal::Numeric) && right.is_a?(RDF::Literal::Numeric)
-            left + right
-          else raise TypeError, "expected two RDF::Literal::Numeric operands, but got #{left.inspect} and #{right.inspect}"
+      # @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) {"Add"}
+        silent = operands.first == :silent
+        operands.shift if silent
+
+        src_name, dest_name = operands[-2..-1]
+        raise ArgumentError, "add expected two operands, got #{operands.length}" unless operands.length == 2
+        raise ArgumentError, "add from must be IRI or :default" unless src_name == :default || src_name.is_a?(RDF::URI)
+        raise ArgumentError, "add 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, "add operation source does not exist" unless silent
+        else
+          src.each do |statement|
+            statement = statement.dup
+            statement.context = (dest_name unless dest_name == :default)
+            queryable << statement
+          end
         end
+        queryable
       end
     end # Add
   end # Operator

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

@@ -42,13 +42,13 @@ module SPARQL; module Algebra
       # @raise  [TypeError] if the operands could not be coerced to boolean literals
       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/asc.rb

@@ -25,7 +25,7 @@ module SPARQL; module Algebra
       #   options passed from query
       # @return [RDF::Term]
       def evaluate(bindings, options = {})
-        operand(0).evaluate(bindings, options.merge(:depth => options[:depth].to_i + 1))
+        operand(0).evaluate(bindings, options.merge(depth: options[:depth].to_i + 1))
       end
     end # Asc
   end # Operator

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

@@ -29,7 +29,7 @@ module SPARQL; module Algebra
       # @see    http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
       def execute(queryable, options = {})
         debug(options) {"Ask #{operands.first}"}
-        res = boolean(!queryable.query(operands.last, options.merge(:depth => options[:depth].to_i + 1)).empty?)
+        res = boolean(!queryable.query(operands.last, options.merge(depth: options[:depth].to_i + 1)).empty?)
         yield res if block_given?
         res
       end

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

@@ -32,7 +32,7 @@ module SPARQL; module Algebra
       def execute(queryable, options = {}, &block)
         debug(options) {"Base #{operands.first}"}
         Operator.base_uri = operands.first
-        queryable.query(operands.last, options.merge(:depth => options[:depth].to_i + 1), &block)
+        queryable.query(operands.last, options.merge(depth: options[:depth].to_i + 1), &block)
       end
       
       ##

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

@@ -23,7 +23,7 @@ module SPARQL; module Algebra
       # @yieldreturn [void] ignored
       # @return [RDF::Query]
       def self.new(*patterns, &block)
-        RDF::Query.new(*(patterns + [{:context => false}]), &block)
+        RDF::Query.new(*(patterns + [{context: false}]), &block)
       end
     end # BGP
   end # Operator

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

@@ -41,7 +41,7 @@ module SPARQL; module Algebra
       #   options passed from query
       # @return [RDF::Term]
       def evaluate(bindings, options = {})
-        args = operands.map { |operand| operand.evaluate(bindings, options.merge(:depth => options[:depth].to_i + 1)) }
+        args = operands.map { |operand| operand.evaluate(bindings, options.merge(depth: options[:depth].to_i + 1)) }
         apply(args.first, bindings)
       end
 

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

@@ -0,0 +1,63 @@
+module SPARQL; module Algebra
+  class Operator
+
+    ##
+    # The SPARQL UPDATE `clear` operator.
+    #
+    # The CLEAR operation removes all the triples in the specified graph(s) in the Graph Store.
+    #
+    # @example
+    #   (clear silent default)
+    #
+    # @see http://www.w3.org/TR/sparql11-update/#clear
+    class Clear < Operator
+      include SPARQL::Algebra::Update
+
+      NAME = [:clear]
+
+      ##
+      # 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) {"Clear"}
+        silent = operands.first == :silent
+        operands.shift if silent
+
+        raise ArgumentError, "clear expected operand to be 'default', 'named', 'all', or an IRI" unless operands.length == 1
+        case operands.last
+        when :default
+          queryable.each_graph do |g|
+            g.clear! unless g.context
+          end
+        when :named
+          queryable.each_graph do |g|
+            g.clear! if g.context
+          end
+        when :all
+          queryable.clear!
+        when RDF::URI
+          if g = queryable.each_graph.detect {|c| c.context == operands.last}
+            g.clear!
+          else
+            raise IOError, "clear operation graph does not exist" unless silent
+          end
+        else
+          raise ArgumentError, "clear expected operand to be 'default', 'named', 'all', or an IRI" 
+        end
+
+        queryable
+      end
+    end # Clear
+  end # Operator
+end; end # SPARQL::Algebra