sparql 1.0.8 → 1.1.0p0

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

@@ -21,7 +21,7 @@ module SPARQL; module Algebra
       #
       # @param  [RDF::Literal] value
       #   a literal
-      # @param  [RDF::Literal] datatypeIRI
+      # @param  [RDF::Literal] langTag
       #   datatype
       # @return [RDF::Literal] a datatyped literal
       # @see http://www.w3.org/TR/sparql11-query/#func-strlang

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

@@ -0,0 +1,36 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL `sum` set function.
+    #
+    # @example
+    #    (prefix ((: <http://www.example.org/>))
+    #      (project (?sum)
+    #        (extend ((?sum ?.0))
+    #          (group () ((?.0 (sum ?o)))
+    #            (bgp (triple ?s :dec ?o))))))
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#defn_aggSum
+    class Sum < Operator::Unary
+      include Aggregate
+
+      NAME = :sum
+
+      ##
+      # Sum is a SPARQL set function that will return the numeric value obtained by summing the values within the aggregate group. Type promotion happens as per the op:numeric-add function, applied transitively, (see definition below) so the value of SUM(?x), in an aggregate group where ?x has values 1 (integer), 2.0e0 (float), and 3.0 (decimal) will be 6.0 (float).
+      #
+      # @param  [Enumerable<Array<RDF::Term>>] enum
+      #   enum of evaluated operand
+      # @return [RDF::Literal::Numeric] The sum of the terms
+      def apply(enum)
+        if enum.empty?
+          RDF::Literal(0)
+        elsif enum.flatten.all? {|n| n.is_a?(RDF::Literal::Numeric)}
+          enum.flatten.reduce(:+)
+        else
+          raise TypeError, "Averaging non-numeric types: #{enum.flatten}"
+        end
+      end
+    end # Sum
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -0,0 +1,44 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL Table operator.
+    #
+    # This is used to provide inline values. Each row becomes
+    # a solution.
+    #
+    # @example
+    #    (table (vars ?book ?title)
+    #      (row (?title "SPARQL Tutorial"))
+    #      (row (?book :book2)))
+    #
+    # @see http://www.w3.org/TR/2013/REC-sparql11-query-20130321/#inline-data
+    class Table < Operator
+      include Query
+      
+      NAME = [:table]
+
+      ##
+      # Returns solutions for each row
+      #
+      # @param  [RDF::Queryable] queryable
+      #   the graph or repository to query
+      # @param  [Hash{Symbol => Object}] options
+      #   any additional keyword options
+      # @return [RDF::Query::Solutions]
+      #   the resulting solution sequence
+      # @see    http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
+      def execute(queryable, options = {})
+        @solutions = RDF::Query::Solutions.new
+        operands[1..-1].each do |row|
+          next unless row.is_a?(Array)
+          bindings = row[1..-1].inject({}) do |memo, (var, value)|
+            memo[var.to_sym] = value
+            memo
+          end
+          @solutions << RDF::Query::Solution.new(bindings)
+        end
+        @solutions
+      end
+    end # Table
+  end # Operator
+end; end # SPARQL::Algebra

data/lib/sparql/algebra/operator.rb

@@ -14,12 +14,15 @@ module SPARQL; module Algebra
 
     # Unary operators
     autoload :Abs,                'sparql/algebra/operator/abs'
+    autoload :Avg,                'sparql/algebra/operator/avg'
     autoload :BNode,              'sparql/algebra/operator/bnode'
     autoload :Bound,              'sparql/algebra/operator/bound'
     autoload :Ceil,               'sparql/algebra/operator/ceil'
+    autoload :Count,              'sparql/algebra/operator/count'
     autoload :Datatype,           'sparql/algebra/operator/datatype'
     autoload :Day,                'sparql/algebra/operator/day'
     autoload :EncodeForURI,       'sparql/algebra/operator/encode_for_uri'
+    autoload :Exists,             'sparql/algebra/operator/exists'
     autoload :Floor,              'sparql/algebra/operator/floor'
     autoload :Hours,              'sparql/algebra/operator/hours'
     autoload :IsBlank,            'sparql/algebra/operator/is_blank'
@@ -30,14 +33,20 @@ module SPARQL; module Algebra
     autoload :IRI,                'sparql/algebra/operator/iri'
     autoload :Lang,               'sparql/algebra/operator/lang'
     autoload :LCase,              'sparql/algebra/operator/lcase'
+    autoload :Max,                'sparql/algebra/operator/max'
     autoload :MD5,                'sparql/algebra/operator/md5'
+    autoload :Min,                'sparql/algebra/operator/min'
     autoload :Minus,              'sparql/algebra/operator/minus'
     autoload :Minutes,            'sparql/algebra/operator/minutes'
     autoload :Month,              'sparql/algebra/operator/month'
+    autoload :Negate,             'sparql/algebra/operator/negate'
     autoload :Not,                'sparql/algebra/operator/not'
+    autoload :NotExists,          'sparql/algebra/operator/notexists'
     autoload :Plus,               'sparql/algebra/operator/plus'
     autoload :Round,              'sparql/algebra/operator/round'
+    autoload :Sample,             'sparql/algebra/operator/sample'
     autoload :Seconds,            'sparql/algebra/operator/seconds'
+    autoload :Sum,                'sparql/algebra/operator/sum'
     autoload :SHA1,               'sparql/algebra/operator/sha1'
     autoload :SHA256,             'sparql/algebra/operator/sha256'
     autoload :SHA512,             'sparql/algebra/operator/sha512'
@@ -82,6 +91,7 @@ module SPARQL; module Algebra
     autoload :Coalesce,           'sparql/algebra/operator/coalesce'
     autoload :Desc,               'sparql/algebra/operator/desc'
     autoload :Exprlist,           'sparql/algebra/operator/exprlist'
+    autoload :GroupConcat,        'sparql/algebra/operator/group_concat'
     autoload :In,                 'sparql/algebra/operator/in'
     autoload :NotIn,              'sparql/algebra/operator/notin'
 
@@ -96,13 +106,16 @@ module SPARQL; module Algebra
     autoload :Extend,             'sparql/algebra/operator/extend'
     autoload :Filter,             'sparql/algebra/operator/filter'
     autoload :Graph,              'sparql/algebra/operator/graph'
+    autoload :Group,              'sparql/algebra/operator/group'
     autoload :Join,               'sparql/algebra/operator/join'
     autoload :LeftJoin,           'sparql/algebra/operator/left_join'
+    autoload :Minus,              'sparql/algebra/operator/minus'
     autoload :Order,              'sparql/algebra/operator/order'
     autoload :Prefix,             'sparql/algebra/operator/prefix'
     autoload :Project,            'sparql/algebra/operator/project'
     autoload :Reduced,            'sparql/algebra/operator/reduced'
     autoload :Slice,              'sparql/algebra/operator/slice'
+    autoload :Table,              'sparql/algebra/operator/table'
     autoload :Union,              'sparql/algebra/operator/union'
 
     ##
@@ -119,7 +132,7 @@ module SPARQL; module Algebra
         when :'='             then Equal
         when :*               then Multiply
         when :+               then arity.eql?(1) ? Plus  : Add
-        when :-               then arity.eql?(1) ? Minus : Subtract
+        when :-               then arity.eql?(1) ? Negate : Subtract
         when :<               then LessThan
         when :<=              then LessThanOrEqual
         when :<=>             then Compare # non-standard
@@ -128,17 +141,21 @@ module SPARQL; module Algebra
         when :abs             then Abs
         when :add             then Add
         when :and, :'&&'      then And
+        when :avg             then Avg
         when :bnode           then BNode
         when :bound           then Bound
         when :coalesce        then Coalesce
         when :ceil            then Ceil
         when :concat          then Concat
         when :contains        then Contains
+        when :count           then Count
         when :datatype        then Datatype
         when :day             then Day
         when :encode_for_uri  then EncodeForURI
         when :divide          then Divide
+        when :exists          then Exists
         when :floor           then Floor
+        when :group_concat    then GroupConcat
         when :hours           then Hours
         when :if              then If
         when :in              then In
@@ -152,11 +169,14 @@ module SPARQL; module Algebra
         when :langmatches     then LangMatches
         when :lcase           then LCase
         when :md5             then MD5
+        when :max             then Max
+        when :min             then Min
         when :minus           then Minus
         when :minutes         then Minutes
         when :month           then Month
         when :multiply        then Multiply
         when :not, :'!'       then Not
+        when :notexists      then NotExists
         when :notin           then NotIn
         when :now             then Now
         when :or, :'||'       then Or
@@ -166,6 +186,7 @@ module SPARQL; module Algebra
         when :replace         then Replace
         when :round           then Round
         when :sameterm        then SameTerm
+        when :sample          then Sample
         when :seconds         then Seconds
         when :sha1            then SHA1
         when :sha256          then SHA256
@@ -181,6 +202,7 @@ module SPARQL; module Algebra
         when :struuid         then StrUUID
         when :substr          then SubStr
         when :subtract        then Subtract
+        when :sum             then Sum
         when :timezone        then Timezone
         when :tz              then TZ
         when :ucase           then UCase
@@ -205,13 +227,16 @@ module SPARQL; module Algebra
         when :extend          then Extend
         when :filter          then Filter
         when :graph           then Graph
+        when :group           then Group
         when :join            then Join
         when :leftjoin        then LeftJoin
         when :order           then Order
+        when :minus           then Minus
         when :prefix          then Prefix
         when :project         then Project
         when :reduced         then Reduced
         when :slice           then Slice
+        when :table           then Table
         when :triple          then RDF::Query::Pattern
         when :union           then Union
         else                       nil # not found
@@ -386,6 +411,16 @@ module SPARQL; module Algebra
       !(variable?)
     end
 
+    ##
+    # Returns `true` if this is an aggregate
+    #
+    # Overridden in evaluatables which are aggregates
+    #
+    # @return [Boolean] `true` or `false`
+    def aggregate?
+      respond_to?(:aggregate)
+    end
+
     ##
     # Returns an optimized version of this expression.
     #
@@ -402,7 +437,7 @@ module SPARQL; module Algebra
       if constant?
         # Note that if evaluation results in a `TypeError` or other error,
         # we must return `self` so that the error is conserved at runtime:
-        evaluate rescue self
+        evaluate(RDF::Query::Solution.new) rescue self
       else
         super # returns `self`
       end

data/lib/sparql/algebra.rb

@@ -283,6 +283,7 @@ module SPARQL
   module Algebra
     include RDF
 
+    autoload :Aggregate,   'sparql/algebra/aggregate'
     autoload :Evaluatable, 'sparql/algebra/evaluatable'
     autoload :Expression,  'sparql/algebra/expression'
     autoload :Operator,    'sparql/algebra/operator'