sparql 1.1.5 → 1.1.6

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

@@ -47,7 +47,7 @@ module SPARQL; module Algebra
       def evaluate(bindings, options = {})
         operands.each do |op|
           begin
-            return op.evaluate(bindings, options.merge(:depth => options[:depth].to_i + 1))
+            return op.evaluate(bindings, options.merge(depth: options[:depth].to_i + 1))
           rescue
           end
         end

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

@@ -31,16 +31,16 @@ module SPARQL; module Algebra
       # @return [RDF::Term]
       # @raise  [TypeError] if any operand is not a literal
       def evaluate(bindings, options = {})
-        ops = operands.map {|op| op.evaluate(bindings, options.merge(:depth => options[:depth].to_i + 1))}
+        ops = operands.map {|op| op.evaluate(bindings, options.merge(depth: options[:depth].to_i + 1))}
 
         raise TypeError, "expected all plain literal operands" unless ops.all? {|op| op.literal? && op.plain?}
 
         ops.inject do |memo, op|
           case
           when memo.datatype == RDF::XSD.string && op.datatype == RDF::XSD.string
-            RDF::Literal.new("#{memo}#{op}", :datatype => RDF::XSD.string)
+            RDF::Literal.new("#{memo}#{op}", datatype: RDF::XSD.string)
           when memo.has_language? && memo.language == op.language
-            RDF::Literal.new("#{memo}#{op}", :language => memo.language)
+            RDF::Literal.new("#{memo}#{op}", language: memo.language)
           else
             RDF::Literal.new("#{memo}#{op}")
           end

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

@@ -42,7 +42,7 @@ module SPARQL; module Algebra
         patterns = operands.first
         query = operands.last
 
-        queryable.query(query, options.merge(:depth => options[:depth].to_i + 1)).each do |solution|
+        queryable.query(query, options.merge(depth: options[:depth].to_i + 1)).each do |solution|
           debug(options) {"(construct apply) #{solution.inspect} to BGP"}
           
           # Create a mapping from BNodes within the pattern list to newly constructed BNodes
@@ -71,7 +71,7 @@ module SPARQL; module Algebra
           end
         end
 
-        debug(options) {"=>\n#{graph.dump(:ttl, :standard_prefixes => true)}"}
+        debug(options) {"=>\n#{graph.dump(:ttl, standard_prefixes: true)}"}
         graph.each(&block) if block_given?
         graph
       end

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

@@ -0,0 +1,64 @@
+module SPARQL; module Algebra
+  class Operator
+
+    ##
+    # The SPARQL UPDATE `copy` operator.
+    #
+    # The COPY operation is a shortcut for inserting all data from an input graph into a destination graph. Data from the input graph is not affected, but data from the destination graph, if any, is removed before insertion.
+    #
+    # @example
+    #   (copy silent <iri> to default)
+    #
+    # @see hhttp://www.w3.org/TR/sparql11-update/#copy
+    class Copy < Operator
+      include SPARQL::Algebra::Update
+
+      NAME = [:copy]
+
+      ##
+      # 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) {"Copy"}
+        silent = operands.first == :silent
+        operands.shift if silent
+
+        src_name, dest_name = operands[-2..-1]
+        raise ArgumentError, "copy expected two operands, got #{operands.length}" unless operands.length == 2
+        raise ArgumentError, "copy from must be IRI or :default" unless src_name == :default || src_name.is_a?(RDF::URI)
+        raise ArgumentError, "copy 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, "copy 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
+        end
+        queryable
+      end
+    end # Copy
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -0,0 +1,49 @@
+module SPARQL; module Algebra
+  class Operator
+
+    ##
+    # The SPARQL UPDATE `create` operator.
+    #
+    # This operation creates a graph in the Graph Store
+    #
+    # This is a no-op for RDF.rb implementations, unless the graph exists
+    #
+    # @example
+    #   (create silent <graph>)
+    #
+    # @see http://www.w3.org/TR/sparql11-update/#create
+    class Create < Operator
+      include SPARQL::Algebra::Update
+
+      NAME = [:create]
+
+      ##
+      # 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) {"Create"}
+        silent = operands.first == :silent
+        operands.shift if silent
+
+        iri = operands.first
+        #require 'byebug'; byebug
+        raise ArgumentError, "clear expected a single IRI" if operands.length != 1 || !iri.is_a?(RDF::URI)
+        if queryable.has_context?(iri)
+          raise IOError, "create operation graph #{iri.to_ntriples} exists" unless silent
+        end
+        queryable
+      end
+    end # Create
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -106,19 +106,7 @@ module SPARQL; module Algebra
     class Dataset < Binary
       include Query
 
-      NAME = [:dataset]
-      # Selected accept headers, from those available
-      ACCEPTS = (%w(
-        application/turtle
-        text/turtle;q=0.9
-        application/rdf+xml;q=0.8
-        application/n-triples;q=0.4
-        text/plain;q=0.1
-      ).
-        select do |content_type|
-          # Add other content types
-          RDF::Format.content_types.include?(content_type.split(';').first)
-        end << ' */*;q=0.2').join(', ').freeze
+      NAME = :dataset
 
       ##
       # Executes this query on the given `queryable` graph or repository.
@@ -142,31 +130,18 @@ module SPARQL; module Algebra
         debug(options) {"Dataset"}
         default_datasets = []
         named_datasets = []
-        operand(0).each do |ds|
-          load_opts = {
-            :headers => {"Accept" => ACCEPTS}
-          }
-          load_opts[:debug] = options.fetch(:debug, nil)
-          case ds
+        operand(0).each do |uri|
+          case uri
           when Array
             # Format is (named <uri>), only need the URI part
-            uri = if self.base_uri
-              u = self.base_uri.join(ds.last)
-              u.lexical = "<#{ds.last}>" unless u.to_s == ds.last.to_s
-              u
-            else
-              ds.last
-            end
-            uri = self.base_uri ? self.base_uri.join(ds.last) : ds.last
-            uri.lexical = ds.last
+            uri = uri.last
             debug(options) {"=> named data source #{uri}"}
             named_datasets << uri
           else
-            uri = self.base_uri ? self.base_uri.join(ds) : ds
             debug(options) {"=> default data source #{uri}"}
             default_datasets << uri
           end
-          load_opts[:context] = load_opts[:base_uri] = uri
+          load_opts = {debug: options.fetch(:debug, nil), context: uri, base_uri: uri}
           unless queryable.has_context?(uri)
             debug(options) {"=> load #{uri}"}
             queryable.load(uri.to_s, load_opts)
@@ -181,7 +156,7 @@ module SPARQL; module Algebra
         aggregate = RDF::AggregateRepo.new(queryable)
         named_datasets.each {|name| aggregate.named(name) if queryable.has_context?(name)}
         aggregate.default(*default_datasets.select {|name| queryable.has_context?(name)})
-        aggregate.query(operands.last, options.merge(:depth => options[:depth].to_i + 1), &base)
+        aggregate.query(operands.last, options.merge(depth: options[:depth].to_i + 1), &base)
       end
       
       ##

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

@@ -0,0 +1,55 @@
+module SPARQL; module Algebra
+  class Operator
+
+    ##
+    # The SPARQL UPDATE `delete` operator.
+    #
+    # The DELETE operation is a form of the DELETE/INSERT operation having no INSERT section
+    #
+    # @example
+    #   (delete ((triple ?s ?p ?o))))
+    #
+    # @see http://www.w3.org/TR/sparql11-update/#delete
+    class Delete < Operator::Unary
+      include SPARQL::Algebra::Update
+
+      NAME = [:delete]
+
+      ##
+      # 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) {"Delete: #{solution} against #{operands.to_sse}"}
+        # Operands are an array of patterns and Queries (when named).
+        # Create a new query made up all patterns
+        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) {"Delete statement #{statement.to_sse}"}
+          queryable.delete(RDF::Statement.from(pattern)) if pattern.bound? || pattern.constant?
+        end
+        queryable
+      end
+    end # Delete
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -0,0 +1,41 @@
+module SPARQL; module Algebra
+  class Operator
+
+    ##
+    # The SPARQL UPDATE `deleteData` operator.
+    #
+    # The DELETE DATA operation removes some triples, given inline in the request, if the respective graphs in the Graph Store contain those
+    #
+    # @example
+    #   (deleteData ((triple :a foaf:knows :c)))
+    #
+    # @see http://www.w3.org/TR/sparql11-update/#deleteData
+    class DeleteData < Operator::Unary
+      include SPARQL::Algebra::Update
+
+      NAME = [:deleteData]
+
+      ##
+      # 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) {"DeleteData #{op.to_sxp}"}
+          queryable.delete(op)
+        end
+        queryable
+      end
+    end # DeleteData
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -0,0 +1,57 @@
+module SPARQL; module Algebra
+  class Operator
+
+    ##
+    # The SPARQL UPDATE `deleteWhere` operator.
+    #
+    # The DELETE WHERE operation is a shortcut form for the DELETE/INSERT operation where bindings matched by the WHERE clause are used to define the triples in a graph that will be deleted.
+    #
+    # @example
+    #   (deleteWhere ((triple :a foaf:knows ?b))
+    #
+    # @see http://www.w3.org/TR/sparql11-update/#deleteWhere
+    class DeleteWhere < Operator::Unary
+      include SPARQL::Algebra::Update
+
+      NAME = [:deleteWhere]
+
+      ##
+      # Query the operand, and delete all statements created by binding each solution to the patterns
+      #
+      # @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 = {})
+        # Operands are an array of patterns and Queries (when named).
+        # Create a new query made up all patterns
+        patterns = operand.inject([]) do |memo, op|
+          if op.respond_to?(:statements)
+            memo += op.statements.to_a
+          else
+            memo << op
+          end
+          memo
+        end
+        query = RDF::Query.new(*patterns)
+        debug(options) {"DeleteWhere query #{query.to_sse}"}
+        query.execute(queryable, options.merge(depth: options[:depth].to_i + 1)) 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}"}
+            queryable.delete(RDF::Statement.from(pattern)) if pattern.bound? || pattern.constant?
+          end
+        end
+        queryable
+      end
+    end # DeleteWhere
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -32,7 +32,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)).distinct
+        @solutions = queryable.query(operands.last, options.merge(depth: options[:depth].to_i + 1)).distinct
         @solutions.each(&block) if block_given?
         @solutions
       end

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

@@ -0,0 +1,66 @@
+module SPARQL; module Algebra
+  class Operator
+
+    ##
+    # The SPARQL UPDATE `drop` operator.
+    #
+    # The DROP operation removes the specified graph(s) from the Graph Store
+    #
+    # Equivalent to `clear` in this implementation
+    #
+    # @example
+    #   (drop default)
+    #
+    # @see http://www.w3.org/TR/sparql11-update/#drop
+    class Drop < Operator
+      include SPARQL::Algebra::Update
+
+      NAME = [:drop]
+
+      ##
+      # 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) {"Drop"}
+        silent = operands.first == :silent
+        silent = operands.first == :silent
+        operands.shift if silent
+
+        raise ArgumentError, "drop 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, "drop operation graph does not exist" unless silent
+          end
+        else
+          raise ArgumentError, "drop expected operand to be 'default', 'named', 'all', or an IRI" 
+        end
+
+        queryable
+      end
+    end # Drop
+  end # Operator
+end; end # SPARQL::Algebra