sparql 3.1.8 → 3.2.3

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

@@ -5,11 +5,52 @@ module SPARQL; module Algebra
     #
     # Extends a solution
     #
-    # @example
-    #   (select (?z)
-    #     (project (?z)
-    #       (extend ((?z (+ ?o 10)))
-    #         (bgp (triple ?s <http://example/p> ?o)))))
+    # [60]  Bind ::= 'BIND' '(' Expression 'AS' Var ')'
+    #
+    # @example SPARQL Grammar
+    #   SELECT ?z
+    #   { 
+    #     ?x <http://example.org/p> ?o
+    #     BIND(?o+10 AS ?z)
+    #   }
+    #
+    # @example SSE
+    #   (project (?z)
+    #     (extend ((?z (+ ?o 10)))
+    #       (bgp (triple ?x <http://example.org/p> ?o))))
+    #
+    # @example SPARQL Grammar (cast as boolean)
+    #   PREFIX : <http://example.org/>
+    #   PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+    #   PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   SELECT ?a ?v (xsd:boolean(?v) AS ?boolean)
+    #   WHERE { ?a :p ?v . }
+    #
+    # @example SSE (cast as boolean)
+    #   (prefix ((: <http://example.org/>)
+    #            (rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>)
+    #            (xsd: <http://www.w3.org/2001/XMLSchema#>))
+    #    (project (?a ?v ?boolean)
+    #     (extend ((?boolean (xsd:boolean ?v)))
+    #      (bgp (triple ?a :p ?v)))))
+    #
+    # @example SPARQL Grammar (inner bind)
+    #   PREFIX : <http://example.org/> 
+    #   
+    #   SELECT ?z ?s1
+    #   {
+    #     ?s ?p ?o .
+    #     BIND(?o+1 AS ?z)
+    #     ?s1 ?p1 ?z
+    #   }
+    #
+    # @example SSE (inner bind)
+    #   (prefix ((: <http://example.org/>))
+    #    (project (?z ?s1)
+    #     (join
+    #      (extend ((?z (+ ?o 1)))
+    #       (bgp (triple ?s ?p ?o)))
+    #     (bgp (triple ?s1 ?p1 ?z)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#evaluation
     class Extend < Operator::Binary
@@ -63,16 +104,63 @@ module SPARQL; module Algebra
       end
 
       # The variable introduced by the BIND clause must not have been used in the group graph pattern up to the point of use in BIND
+      #
+      # Also, variables used in a binding expression must be projected by the query.
       def validate!
         bind_vars = operand(0).map(&:first).map(&:name)
-        query_vars = operand(1).vars.map(&:name)
+        query_vars = operand(1).variables.keys
         
         unless (bind_vars.compact & query_vars.compact).empty?
           raise ArgumentError,
                "bound variable used in query: #{(bind_vars.compact & query_vars.compact).to_sse}"
         end
+
+        # Special case for group variables
+        if operands.last.is_a?(Group)
+          bind_expr_vars = operand(0).map(&:last).variables.keys
+          group_vars = operands.last.variables.keys
+          group_internal_vars = operands.last.internal_variables.keys
+
+          bind_expr_vars.each do |v|
+            raise ArgumentError,
+                 "extension expression uses variable not in scope: #{v}" if
+                 group_internal_vars.include?(v) &&
+                 !group_vars.include?(v)
+          end
+        end
+
         super
       end
-    end # Filter
+
+      ##
+      # The variables used in the extension.
+      # Includes extended variables.
+      #
+      # @return [Hash{Symbol => RDF::Query::Variable}]
+      def variables
+        operands.first.
+          map(&:first).
+          map(&:variables).
+          inject(operands.last.variables) {|memo, h| memo.merge(h)}
+      end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # Extracts bindings.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        extensions = operands.first.inject({}) do |memo, (as, expression)|
+          # Use string/name of variable "as" to aid in later matching
+          memo.merge(as.to_s => expression)
+        end
+
+        # Merge any inherited extensions from options
+        extensions = options.delete(:extensions).merge(extensions) if options.key?(:extensions)
+        operands.last.to_sparql(extensions: extensions, **options)
+      end
+    end # Extend
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,11 +3,19 @@ module SPARQL; module Algebra
     ##
     # The SPARQL GraphPattern `filter` operator.
     #
-    # @example
-    #   (select (?v)
-    #     (project (?v)
-    #       (filter (= ?v 2)
-    #         (bgp (triple ?s <http://example/p> ?v)))))
+    # [68]  Filter ::= 'FILTER' Constraint
+    #
+    # @example SPARQL Grammar
+    #   SELECT ?v
+    #   { 
+    #     ?s <http://example/p> ?v
+    #     FILTER(?v = 2)
+    #   }
+    #
+    # @example SSE
+    #    (project (?v)
+    #      (filter (= ?v 2)
+    #        (bgp (triple ?s <http://example/p> ?v))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#evaluation
     class Filter < Operator::Binary
@@ -69,6 +77,20 @@ module SPARQL; module Algebra
         end
         self
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # Provides filters to descendant query.
+      #
+      # If filter operation is an Exprlist, then separate into multiple filter ops.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        filter_ops = operands.first.is_a?(Operator::Exprlist) ? operands.first.operands : [operands.first]
+        str = operands.last.to_sparql(filter_ops: filter_ops, **options)
+      end
     end # Filter
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,8 +3,22 @@ module SPARQL; module Algebra
     ##
     # The SPARQL logical `floor` operator.
     #
-    # @example
-    #   (floor ?x)
+    # [121] BuiltInCall ::= ... 'FLOOR' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   SELECT ?s ?num (FLOOR(?num) AS ?floor) WHERE {
+    #    ?s :num ?num
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/>)
+    #     (xsd: <http://www.w3.org/2001/XMLSchema#>))
+    #    (project (?s ?num ?floor)
+    #     (extend ((?floor (floor ?num)))
+    #      (bgp (triple ?s :num ?num)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-floor
     # @see https://www.w3.org/TR/xpath-functions/#func-floor
@@ -30,6 +44,15 @@ module SPARQL; module Algebra
           else raise TypeError, "expected an RDF::Literal::Numeric, but got #{operand.inspect}"
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "FLOOR(#{operands.to_sparql(**options)})"
+      end
     end # Floor
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -0,0 +1,64 @@
+
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL `function_call` operator.
+    #
+    # [70]  FunctionCall ::= iri ArgList
+    #
+    # @example SPARQL Grammar
+    #   PREFIX xsd:   <http://www.w3.org/2001/XMLSchema#>
+    #   SELECT *
+    #   WHERE { ?s ?p ?o . FILTER xsd:integer(?o) }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((xsd: <http://www.w3.org/2001/XMLSchema#>))
+    #    (filter (xsd:integer ?o)
+    #     (bgp (triple ?s ?p ?o))))
+    #
+    # @see https://www.w3.org/TR/sparql11-query/#funcex-regex
+    # @see https://www.w3.org/TR/xpath-functions/#func-matches
+    class FunctionCall < Operator
+      include Evaluatable
+
+      NAME = :function_call
+
+      ##
+      # Invokes the function with the passed arguments.
+      #
+      # @param  [RDF::IRI] iri
+      #   Identifies the function
+      # @param  [Array<RDF::Term>] args
+      # @return [RDF::Term]
+      def apply(iri, *args, **options)
+        args = RDF.nil == args.last ? args[0..-2] : args
+        SPARQL::Algebra::Expression.extension(iri, *args, **options)
+      end
+
+      ##
+      # Returns the SPARQL S-Expression (SSE) representation of this expression.
+      #
+      # Remove the optional argument.
+      #
+      # @return [Array] `self`
+      # @see    https://openjena.org/wiki/SSE
+      def to_sxp_bin
+        @operands.map(&:to_sxp_bin)
+      end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        iri, args = operands
+        iri.to_sparql(**options) +
+          '(' +
+          args.to_sparql(delimiter: ', ', **options) +
+          ')'
+      end
+    end # FunctionCall
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -5,15 +5,63 @@ module SPARQL; module Algebra
     #
     # This is a wrapper to add a `graph_name` to the query, or an array of statements.
     #
-    # @example of a query
+    # [58]  GraphGraphPattern       ::= 'GRAPH' VarOrIri GroupGraphPattern
+    #
+    # @example SPARQL Grammar (query)
+    #   PREFIX : <http://example/> 
+    #   SELECT * { 
+    #       GRAPH ?g { ?s ?p ?o }
+    #   }
+    #
+    # @example SSE
     #   (prefix ((: <http://example/>))
-    #     (graph ?g
-    #       (bgp (triple ?s ?p ?o))))
+    #    (graph ?g
+    #     (bgp (triple ?s ?p ?o))))
+    #
+    # @example SPARQL Grammar (named set of statements)
+    #   PREFIX : <http://example/> 
+    #   SELECT * { 
+    #       GRAPH :g { :s :p :o }
+    #   }
     #
-    # @example named set of statements
+    # @example SSE (named set of statements)
     #   (prefix ((: <http://example/>))
-    #     (graph :g
-    #       ((triple :s :p :o))))
+    #    (graph :g
+    #     (bgp (triple :s :p :o))))
+    #
+    # @example SPARQL Grammar (syntax-graph-05.rq)
+    #   PREFIX : <http://example.org/>
+    #   SELECT *
+    #   WHERE
+    #   {
+    #     :x :p :z
+    #     GRAPH ?g { :x :b ?a . GRAPH ?g2 { :x :p ?x } }
+    #   }
+    #
+    # @example SSE (syntax-graph-05.rq)
+    #   (prefix ((: <http://example.org/>))
+    #    (join
+    #     (bgp (triple :x :p :z))
+    #     (graph ?g
+    #      (join
+    #       (bgp (triple :x :b ?a))
+    #       (graph ?g2
+    #        (bgp (triple :x :p ?x)))))))
+    #
+    # @example SPARQL Grammar (pp06.rq)
+    #   prefix ex:	<http://www.example.org/schema#>
+    #   prefix in:	<http://www.example.org/instance#>
+    #   
+    #   select ?x where {
+    #     graph ?g {in:a ex:p1/ex:p2 ?x}
+    #   }
+    #
+    # @example SSE (syntax-graph-05.rq)
+    #   (prefix ((ex: <http://www.example.org/schema#>)
+    #            (in: <http://www.example.org/instance#>))
+    #    (project (?x)
+    #     (graph ?g
+    #      (path in:a (seq ex:p1 ex:p2) ?x))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
     class Graph < Operator::Binary
@@ -76,6 +124,21 @@ module SPARQL; module Algebra
       def rewrite(&block)
         self
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @param [Boolean] top_level (true)
+      #   Treat this as a top-level, generating SELECT ... WHERE {}
+      # @return [String]
+      def to_sparql(top_level: true, **options)
+        query = operands.last.to_sparql(top_level: false, **options)
+        # Paths don't automatically get braces.
+        query = "{\n#{query}\n}" unless query.start_with?('{')
+        str = "GRAPH #{operands.first.to_sparql(**options)} " + query
+        top_level ? Operator.to_sparql(str, **options) : str
+      end
     end # Graph
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,8 +3,18 @@ module SPARQL; module Algebra
     ##
     # The SPARQL relational `>` (greater than) comparison operator.
     #
-    # @example
-    #   (> ?x ?y)
+    # [114] RelationalExpression    ::= NumericExpression ('>' NumericExpression)?
+    #
+    # @example SPARQL Grammar
+    #   PREFIX  xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   PREFIX  : <http://example.org/things#>
+    #   SELECT  ?x
+    #   WHERE { ?x :p ?v . FILTER ( ?v > 1 ) }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((xsd: <http://www.w3.org/2001/XMLSchema#>) (: <http://example.org/things#>))
+    #    (project (?x) (filter (> ?v 1) (bgp (triple ?x :p ?v)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#OperatorMapping
     # @see https://www.w3.org/TR/xpath-functions/#func-compare
@@ -25,7 +35,6 @@ module SPARQL; module Algebra
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if either operand is not a literal
       def apply(left, right, **options)
-        #require 'byebug'; byebug if super == RDF::Literal(1)
         RDF::Literal(super == RDF::Literal(1))
       end
     end # GreaterThan

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

@@ -4,8 +4,18 @@ module SPARQL; module Algebra
     # The SPARQL relational `>=` (greater than or equal) comparison
     # operator.
     #
-    # @example
-    #   (>= ?x ?y)
+    # [114] RelationalExpression    ::= NumericExpression ('>=' NumericExpression)?
+    #
+    # @example SPARQL Grammar
+    #   PREFIX  xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   PREFIX  : <http://example.org/things#>
+    #   SELECT  ?x
+    #   WHERE { ?x :p ?v . FILTER ( ?v >= 1 ) }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((xsd: <http://www.w3.org/2001/XMLSchema#>) (: <http://example.org/things#>))
+    #    (project (?x) (filter (>= ?v 1) (bgp (triple ?x :p ?v)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#OperatorMapping
     # @see https://www.w3.org/TR/xpath-functions/#func-compare

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

@@ -8,14 +8,53 @@ module SPARQL; module Algebra
     # query to be grouped. If three operands are provided,
     # the second is an array of temporary bindings.
     #
-    # @example
-    #     (prefix ((: <http://example/>))
-    #       (project (?w ?S)
-    #         (extend ((?S ??.0))
-    #           (group (?w) ((??.0 (sample ?v)))
-    #             (leftjoin
-    #               (bgp (triple ?s :p ?v))
-    #               (bgp (triple ?s :q ?w)))))))
+    # [19]  GroupClause             ::= 'GROUP' 'BY' GroupCondition+
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://www.example.org>
+    #   
+    #   SELECT ?P (COUNT(?O) AS ?C)
+    #   WHERE { ?S ?P ?O }
+    #   GROUP BY ?P
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://www.example.org>))
+    #    (project (?P ?C)
+    #     (extend ((?C ??.0))
+    #      (group (?P) ((??.0 (count ?O)))
+    #       (bgp (triple ?S ?P ?O))))))
+    #
+    # @example SPARQL Grammar (HAVING aggregate)
+    #   PREFIX : <http://www.example.org/>
+    #   SELECT ?s (AVG(?o) AS ?avg)
+    #   WHERE { ?s ?p ?o }
+    #   GROUP BY ?s
+    #   HAVING (AVG(?o) <= 2.0)
+    #
+    # @example SSE (HAVING aggregate)
+    #   (prefix ((: <http://www.example.org/>))
+    #    (project (?s ?avg)
+    #     (filter (<= ??.0 2.0)
+    #      (extend ((?avg ??.0))
+    #       (group (?s) ((??.0 (avg ?o)))
+    #        (bgp (triple ?s ?p ?o)))))) )
+    #
+    # @example SPARQL Grammar (non-trivial filters)
+    #   PREFIX : <http://example.com/data/#>
+    #   SELECT ?g (AVG(?p) AS ?avg) ((MIN(?p) + MAX(?p)) / 2 AS ?c)
+    #   WHERE { ?g :p ?p . }
+    #   GROUP BY ?g
+    #
+    # @example SSE (non-trivial filters)
+    #   (prefix ((: <http://example.com/data/#>))
+    #    (project (?g ?avg ?c)
+    #     (extend ((?avg ??.0) (?c (/ (+ ??.1 ??.2) 2)))
+    #      (group (?g)
+    #             ((??.0 (avg ?p))
+    #              (??.1 (min ?p))
+    #              (??.2 (max ?p)))
+    #       (bgp (triple ?g :p ?p)))) ))
     #
     # @see https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
     class Group < Operator
@@ -122,6 +161,92 @@ module SPARQL; module Algebra
         end
         super
       end
+
+      ##
+      # The variables used in the extension.
+      # Includes grouped variables and temporary, but not those in the query, itself
+      #
+      # @return [Hash{Symbol => RDF::Query::Variable}]
+      def variables
+        group_vars = operands.first
+
+        aggregate_vars = (operands.length == 3 ? operand(1) : [])
+
+        # Extract first element of each and merge it's variables
+        (group_vars + aggregate_vars).
+          map do  |o|
+            v = Array(o).first
+            v if v.is_a?(RDF::Query::Variable)
+          end.compact.
+          map(&:variables).
+          inject({}) {|memo, h| memo.merge(h)}
+      end
+
+      ##
+      # The variables used within the query
+      #
+      # @return [Hash{Symbol => RDF::Query::Variable}]
+      def internal_variables
+        operands.last.variables
+      end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @param [Hash{String => Operator}] extensions
+      #   Variable bindings
+      # @param [Array<Operator>] filter_ops ([])
+      #   Filter Operations
+      # @return [String]
+      def to_sparql(extensions: {}, filter_ops: [], **options)
+        having_ops = []
+        if operands.length > 2
+          temp_bindings = operands[1].inject({}) {|memo, (var, op)| memo.merge(var => op)}
+          # Replace extensions from temporary bindings
+          temp_bindings.each do |var, op|
+            # Update extensions using a temporarily bound variable with its binding
+            extensions = extensions.inject({}) do |memo, (ext_var, ext_op)|
+              if ext_op.is_a?(Operator)
+                # Try to recursivley replace variable within operator
+                new_op = ext_op.deep_dup.rewrite do |operand|
+                  if operand.is_a?(Variable) && operand.to_sym == var.to_sym
+                    op.dup
+                  else
+                    operand
+                  end
+                end
+                memo.merge(ext_var.to_s => new_op)
+              elsif ext_op.is_a?(Variable) && ext_op.to_sym == var.to_sym
+                memo.merge(ext_var.to_s => op)
+              else
+                # Doesn't match this variable, so don't change
+                memo.merge(ext_var.to_s => ext_op)
+              end
+            end
+
+            # Filter ops using temporary bindinds are used for HAVING clauses
+            filter_ops.each do |fop|
+              having_ops << fop if fop.descendants.include?(var) && !having_ops.include?(fop)
+            end
+          end
+
+          # If used in a HAVING clause, it's not also a filter
+          filter_ops -= having_ops
+
+          # Replace each operand in having using var with it's corresponding operation
+          having_ops = having_ops.map do |op|
+            op.dup.rewrite do |operand|
+              # Rewrite based on temporary bindings
+              temp_bindings.fetch(operand, operand)
+            end
+          end
+        end
+        operands.last.to_sparql(extensions: extensions,
+                                group_ops: operands.first,
+                                having_ops: having_ops,
+                                **options)
+      end
     end # Group
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -5,13 +5,34 @@ module SPARQL; module Algebra
     #
     # GroupConcat is a set function which performs a string concatenation across the values of an expression with a group. The order of the strings is not specified. The separator character used in the concatenation may be given with the scalar argument SEPARATOR.
     #
-    # @example
-    #    (prefix ((: <http://www.example.org/>))
-    #      (filter (|| (= ?g "1 22") (= ?g "22 1"))
-    #        (project (?g)
-    #          (extend ((?g ??.0))
-    #            (group () ((??.0 (group_concat ?o)))
-    #              (bgp (triple ??.0 :p1 ?o)))))))
+    # [127] Aggregate::= ... | 'GROUP_CONCAT' '(' 'DISTINCT'? Expression ( ';' 'SEPARATOR' '=' String )? ')'
+    #
+    # @example SPARQL Grammar
+    #   SELECT (GROUP_CONCAT(?x) AS ?y) {}
+    #
+    # @example SSE
+    #   (project (?y)
+    #    (extend ((?y ??.0))
+    #     (group () ((??.0 (group_concat ?x)))
+    #      (bgp))))
+    #
+    # @example SPARQL Grammar (DISTINCT)
+    #   SELECT (GROUP_CONCAT(DISTINCT ?x) AS ?y) {}
+    #
+    # @example SSE (DISTINCT)
+    #   (project (?y)
+    #    (extend ((?y ??.0))
+    #     (group () ((??.0 (group_concat distinct ?x)))
+    #      (bgp))))
+    #
+    # @example SPARQL Grammar (SEPARATOR)
+    #   SELECT (GROUP_CONCAT(?x; SEPARATOR=';') AS ?y) {}
+    #
+    # @example SSE (SEPARATOR)
+    #   (project (?y)
+    #    (extend ((?y ??.0))
+    #     (group () ((??.0 (group_concat (separator ";") ?x)))
+    #      (bgp))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#defn_aggGroupConcat
     class GroupConcat < Operator
@@ -53,6 +74,21 @@ module SPARQL; module Algebra
       def apply(enum, separator, **options)
         RDF::Literal(enum.flatten.map(&:to_s).join(separator.to_s))
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        distinct = operands.first == :distinct
+        args = distinct ? operands[1..-1] : operands
+        separator = args.first.last if args.first.is_a?(Array) && args.first.first == :separator
+        args = args[1..-1] if separator
+        str = "GROUP_CONCAT(#{'DISTINCT ' if distinct}#{args.to_sparql(delimiter: ', ', **options)}"
+        str << "; SEPARATOR=#{separator.to_sparql}" if separator
+        str << ")"
+      end
     end # GroupConcat
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,11 +3,20 @@ module SPARQL; module Algebra
     ##
     # The SPARQL logical `hours` operator.
     #
-    # @example
-    #     (prefix ((: <http://example.org/>))
-    #       (project (?s ?x)
-    #         (extend ((?x (hours ?date)))
-    #           (bgp (triple ?s :date ?date)))))
+    # [121] BuiltInCall ::= ... | 'HOURS' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   SELECT ?s (HOURS(?date) AS ?x) WHERE {
+    #     ?s :date ?date
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/>))
+    #    (project (?s ?x)
+    #     (extend ((?x (hours ?date)))
+    #      (bgp (triple ?s :date ?date)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-hours
     class Hours < Operator::Unary
@@ -20,12 +29,21 @@ module SPARQL; module Algebra
       #
       # @param  [RDF::Literal] operand
       #   the operand
-      # @return [RDF::Literal]
+      # @return [RDF::Literal::Temporal]
       # @raise  [TypeError] if the operand is not a simple literal
       def apply(operand, **options)
-        raise TypeError, "expected an RDF::Literal::DateTime, but got #{operand.inspect}" unless operand.is_a?(RDF::Literal::DateTime)
+        raise TypeError, "expected an RDF::Literal::Temporal, but got #{operand.inspect}" unless operand.is_a?(RDF::Literal::Temporal)
         RDF::Literal(operand.object.hour)
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "HOURS(#{operands.last.to_sparql(**options)})"
+      end
     end # Hours
   end # Operator
 end; end # SPARQL::Algebra