sparql 3.1.8 → 3.2.3

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

@@ -0,0 +1,178 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL Property Path `pathRange` (NonCountingPath) operator.
+    #
+    # Property path ranges allow specific path lenghts to be queried. The minimum range describes the minimum path length that will yield solutions, and the maximum range the maximum path that will be returned. A minumum of zero is similar to the `path?` operator. The maximum range of `*` is similar to the `path*` or `path+` operators.
+    #
+    # For example, the two queries are functionally equivalent:
+    #
+    #     SELECT * WHERE {:a :p{1,2} :b}
+    #
+    #     SELECT * WHERE {:a (:p/:p?) :b}
+    #
+    # [91]  PathElt ::= PathPrimary PathMod?
+    # [93]  PathMod ::= '*' | '?' | '+' | '{' INTEGER? (',' INTEGER?)? '}'
+    #
+    # @example SPARQL Grammar range with fixed length
+    #   PREFIX : <http://example/> 
+    #   SELECT * WHERE {
+    #     :a :p{2} ?z
+    #   } 
+    #
+    # @example SSE range with fixed length only
+    #   (prefix ((: <http://example/>))
+    #    (path :a (pathRange 2 2 :p) ?z))
+    #
+    # @example SPARQL Grammar range with min only
+    #   PREFIX : <http://example/> 
+    #   SELECT * WHERE {
+    #     :a :p{1,} ?z
+    #   } 
+    #
+    # @example SSE range with min only
+    #   (prefix ((: <http://example/>))
+    #    (path :a (pathRange 1 * :p) ?z))
+    #
+    # @example SPARQL Grammar range with max only
+    #   PREFIX : <http://example/> 
+    #   SELECT * WHERE {
+    #     :a :p{,2} ?z
+    #   } 
+    #
+    # @example SSE range with max only
+    #   (prefix ((: <http://example/>))
+    #    (path :a (pathRange 0 2 :p) ?z))
+    #
+    # @example SPARQL Grammar range with min and max
+    #   PREFIX : <http://example/> 
+    #   SELECT * WHERE {
+    #     :a :p{1,2} ?z
+    #   } 
+    #
+    # @example SSE range with min and max
+    #   (prefix ((: <http://example/>))
+    #    (path :a (pathRange 1 2 :p) ?z))
+    #
+    class PathRange < Operator::Ternary
+      include Query
+      
+      NAME = :"pathRange"
+
+      ##
+       # Initializes a new operator instance.
+       #
+       # @param  [RDF::Literal::Integer] max
+       #   the range minimum
+       # @param  [RDF::Literal::Integer, Symbol] min
+       #   the range maximum (may be `*`)
+       # @param  [SPARQL::Operator] path
+       #   the query
+       # @param  [Hash{Symbol => Object}] options
+       #   any additional options (see {Operator#initialize})
+       # @raise  [TypeError] if any operand is invalid
+       # @raise  [ArgumentError] range element is invalid
+      def initialize(min, max, path, **options)
+        raise ArgumentError, "expect min <= max {#{min},#{max}}" if
+          max.is_a?(RDF::Literal::Integer) && max < min
+        super
+      end
+
+      ##
+      # Path with lower and upper bounds on lenghts:
+      #
+      #    (path :a (pathRange 1 2 :p) :b)
+      #    => (path)
+      #
+      # @param  [RDF::Queryable] queryable
+      #   the graph or repository to query
+      # @param [RDF::Query::Solutions] accumulator (RDF::Query::Solutions.new)
+      #   For previous solutions to avoid duplicates.
+      # @param  [Hash{Symbol => Object}] options
+      #   any additional keyword options
+      # @option options [RDF::Term, RDF::Variable] :subject
+      # @option options [RDF::Term, RDF::Variable] :object
+      # @yield  [solution]
+      #   each matching solution
+      # @yieldparam  [RDF::Query::Solution] solution
+      # @yieldreturn [void] ignored
+      # @see    https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
+      def execute(queryable,
+                  accumulator: RDF::Query::Solutions.new,
+                  index: RDF::Literal(0),
+                  **options,
+                  &block)
+
+        min, max, op = *operands
+        subject, object = options[:subject], options[:object]
+        debug(options) {"Path{#{min},#{max}} #{[subject, op, object].to_sse}"}
+
+        path_mm = if min.zero? && max.is_a?(RDF::Literal::Integer) && max.zero?
+          PathZero.new(op, **options)
+        else
+          # Build up a sequence
+          path_opt = nil
+          seq_len = min.to_i
+          if max.is_a?(RDF::Literal::Integer)
+            # min to max is a sequence of optional sequences
+            opt_len = (max - min).to_i
+            while opt_len > 0 do
+              path_opt = PathOpt.new(path_opt ? Seq.new(op, path_opt, **options) : op, **options)
+              opt_len -= 1
+            end
+          elsif seq_len > 0
+            path_opt = PathPlus.new(op, **options)
+            seq_len -= 1
+          else
+            path_opt = PathStar.new(op, **options)
+          end
+
+          # sequence ending in op, op+, op*, or path_opt
+          path_seq = nil
+          while seq_len > 0 do
+            path_seq = if path_opt
+              opt, path_opt = path_opt, nil
+              Seq.new(op, opt, **options)
+            elsif path_seq
+              Seq.new(op, path_seq, **options)
+            else
+              op
+            end
+            seq_len -= 1
+          end
+          path_seq || path_opt || op
+        end
+        debug(options) {"=> #{path_mm.to_sse}"}
+
+        # After this, path_mm may just be the original op, which can be a term, not an operator.
+        if path_mm.is_a?(RDF::Term)
+          path_mm = RDF::Query.new do |q|
+            q.pattern [subject, path_mm, object]
+          end
+        end
+
+        solutions = path_mm.execute(queryable, **options.merge(depth: options[:depth].to_i + 1)).uniq
+        debug(options) {"(path{#{min},#{max}})=> #{solutions.to_sxp}"}
+        solutions.each(&block) if block_given?
+        solutions
+      end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        min, max, path = operands
+        "(#{path.to_sparql(**options)})" +
+        if max == :*
+          "{#{min},}"
+        elsif min == max
+          "{#{min}}"
+        else
+          "{#{min},#{max}}"
+        end
+      end
+    end # PathStar
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -3,8 +3,18 @@ module SPARQL; module Algebra
     ##
     # The SPARQL Property Path `path*` (ZeroOrMorePath) operator.
     #
-    # @example
-    #   (path* :p)
+    # [91]  PathElt ::= PathPrimary PathMod?
+    # [93]  PathMod ::= '*' | '?' | '+' | '{' INTEGER? (',' INTEGER?)? '}'
+    
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example/> 
+    #   SELECT * WHERE {
+    #     :a :p* ?z
+    #   } 
+    #
+    # @example SSE
+    #   (prefix ((: <http://example/>))
+    #    (path :a (path* :p) ?z))
     #
     # @see https://www.w3.org/TR/sparql11-query/#defn_evalPP_ZeroOrMorePath
     class PathStar < Operator::Unary
@@ -13,10 +23,13 @@ module SPARQL; module Algebra
       NAME = :"path*"
 
       ##
-      # Path including zero length:
+      # Path including at zero length:
       #
       #    (path :a (path* :p) :b)
-      #    => (path :a (path? (path+ :p)) :b)
+      #
+      # into
+      #
+      #    (path :a (path? (path+ :p)) :b)
       #
       # @param  [RDF::Queryable] queryable
       #   the graph or repository to query
@@ -37,6 +50,14 @@ module SPARQL; module Algebra
         query = PathOpt.new(PathPlus.new(*operands))
         query.execute(queryable, depth: options[:depth].to_i + 1, **options, &block)
       end
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "(#{operands.first.to_sparql(**options)})*"
+      end
     end # PathStar
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -0,0 +1,110 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL Property Path `path0` (ZeroLengthPath) operator.
+    #
+    # A zero length path matches all subjects and objects in the graph, and also any RDF terms explicitly given as endpoints of the path pattern.
+    #
+    # @see https://www.w3.org/TR/sparql11-query/#defn_evalPP_ZeroOrOnePath
+    class PathZero < Operator::Unary
+      include Query
+      
+      NAME = :path0
+
+      ##
+      # Zero length path:
+      #
+      #    (path x (path0 :p) y)
+      #     => (filter (x = y) (solution x y))
+      #
+      # @param  [RDF::Queryable] queryable
+      #   the graph or repository to query
+      # @param  [Hash{Symbol => Object}] options
+      #   any additional keyword options
+      # @option options [RDF::Term, RDF::Variable] :subject
+      # @option options [RDF::Term, RDF::Variable] :object
+      # @yield  [solution]
+      #   each matching solution
+      # @yieldparam  [RDF::Query::Solution] solution
+      # @yieldreturn [void] ignored
+      # @see    https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
+      def execute(queryable, **options, &block)
+        subject, object = options[:subject], options[:object]
+        debug(options) {"PathZero #{[subject, operands, object].to_sse}"}
+
+        solutions = RDF::Query::Solutions.new
+        # The zero-length case implies subject == object.
+        case
+        when subject.variable? && object.variable?
+          # Nodes is the set of all subjects and objects in queryable
+          query = RDF::Query.new {|q| q.pattern({subject: subject})}
+          query.execute(queryable, **options) do |solution|
+            solution.merge!(object.to_sym => solution[subject])
+            unless solutions.include?(solution)
+              #debug(options) {"(solution-s0)-> #{solution.to_h.to_sse}"}
+              solutions << solution
+            end
+          end if query.valid?
+
+          # All objects which are `object`
+          query = RDF::Query.new {|q| q.pattern({object: object})}
+          query.execute(queryable, **options) do |solution|
+            solution.merge!(subject.to_sym => solution[object])
+            unless solutions.include?(solution)
+              #debug(options) {"(solution-o0)-> #{solution.to_h.to_sse}"}
+              solutions << solution
+            end
+          end if query.valid?
+        when subject.variable?
+          # All subjects which are `object`
+          query = RDF::Query.new {|q| q.pattern({subject: object})}
+          query.execute(queryable, **options) do |solution|
+            solution.merge!(subject.to_sym => object)
+            unless solutions.include?(solution)
+              #debug(options) {"(solution-s0)-> #{solution.to_h.to_sse}"}
+              solutions << solution
+            end
+          end if query.valid?
+
+          # All objects which are `object`
+          query = RDF::Query.new {|q| q.pattern({object: object})}
+          query.execute(queryable, **options) do |solution|
+            solution.merge!(subject.to_sym => object)
+            unless solutions.include?(solution)
+              #debug(options) {"(solution-o0)-> #{solution.to_h.to_sse}"}
+              solutions << solution
+            end
+          end if query.valid?
+        when object.variable?
+          # All subjects which are `subject`
+          query = RDF::Query.new {|q| q.pattern({subject: subject})}
+          query.execute(queryable, **options) do |solution|
+            solution.merge!(object.to_sym => subject)
+            unless solutions.include?(solution)
+              #debug(options) {"(solution-s0)-> #{solution.to_h.to_sse}"}
+              solutions << solution
+            end
+          end if query.valid?
+
+          # All objects which are `subject`
+          query = RDF::Query.new {|q| q.pattern({object: subject})}
+          query.execute(queryable, **options) do |solution|
+            solution.merge!(object.to_sym => subject)
+            unless solutions.include?(solution)
+              #debug(options) {"(solution-o0)-> #{solution.to_h.to_sse}"}
+              solutions << solution
+            end
+          end if query.valid?
+        else
+          # Otherwise, if subject == object, an empty solution
+          solutions << RDF::Query::Solution.new if subject == object
+        end
+
+        solutions.uniq!
+        debug(options) {"(path0)=> #{solutions.to_sxp}"}
+        solutions.each(&block) if block_given?
+        solutions
+      end
+    end # PathZero
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -3,9 +3,39 @@ module SPARQL; module Algebra
     ##
     # The SPARQL numeric binary/unary `+` operator.
     #
-    # @example
-    #   (+ ?x ?y)
-    #   (plus ?x ?y)
+    # [118] UnaryExpression ::=	... | '+' PrimaryExpression 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   SELECT ?s WHERE {
+    #     ?s :p ?o .
+    #     FILTER(-?o = +3) .
+    #   }
+    #
+    # @example SSE
+    #   (prefix ((: <http://example.org/>))
+    #    (project (?s)
+    #     (filter (= (- ?o) +3)
+    #      (bgp (triple ?s :p ?o)))))
+    #
+    # [116] AdditiveExpression ::=	MultiplicativeExpression ( '+' MultiplicativeExpression )?
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   SELECT ?s WHERE {
+    #     ?s :p ?o .
+    #     ?s2 :p ?o2 .
+    #     FILTER(?o + ?o2 = 3) .
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/>))
+    #    (project (?s)
+    #     (filter (= (+ ?o ?o2) 3)
+    #      (bgp
+    #       (triple ?s :p ?o)
+    #       (triple ?s2 :p ?o2)))))
     #
     # @see https://www.w3.org/TR/xpath-functions/#func-numeric-unary-plus
     # @see https://www.w3.org/TR/xpath-functions/#func-numeric-add
@@ -17,21 +47,32 @@ module SPARQL; module Algebra
       ##
       # Returns the arithmetic sum of the operands, unless there is no `right`.
       #
-      # @param  [RDF::Literal::Numeric] left
+      # @param  [RDF::Literal::Numeric, RDF::Literal::Temporal] left
       #   a numeric literal
-      # @param  [RDF::Literal::Numeric] right
+      # @param  [RDF::Literal::Numeric, RDF::Literal::Duration] right
       #   a numeric literal
-      # @return [RDF::Literal::Numeric]
-      # @raise  [TypeError] if either operand is not a numeric literal
+      # @return [RDF::Literal::Numeric, RDF::Literal::Temporal]
+      # @raise  [TypeError] if either operand is neither a numeric nor a temporal literal
       def apply(left, right = nil, **options)
         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}"
+        when left.is_a?(RDF::Literal::Temporal) && right.is_a?(RDF::Literal::Duration)
+          left + right
+        else raise TypeError, "expected two RDF::Literal::Numeric operands or a Temporal and a Duration, but got #{left.inspect} and #{right.inspect}"
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "(#{operands.first.to_sparql(**options)} + #{operands.last.to_sparql(**options)})"
+      end
     end # Plus
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -5,6 +5,29 @@ module SPARQL; module Algebra
     #
     # If triple is an RDF-star triple, the function returns the predicate of this triple. Passing anything other than an RDF-star triple is an error.
     #
+    # [121] BuiltInCall ::= ... | 'PREDICATE' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.com/ns#>
+    #   SELECT * {
+    #     ?t :source :g
+    #     FILTER(isTriple(?t))
+    #     FILTER(SUBJECT(?t) = :s)
+    #     FILTER(PREDICATE(?t) = :p)
+    #     FILTER(OBJECT(?t) = :o)
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.com/ns#>))
+    #    (filter
+    #     (exprlist
+    #      (isTRIPLE ?t)
+    #      (= (subject ?t) :s)
+    #      (= (predicate ?t) :p)
+    #      (= (object ?t) :o))
+    #     (bgp (triple ?t :source :g))) )
+    #
     # @see https://w3c.github.io/rdf-star/rdf-star-cg-spec.html#predicate
     class Predicate < Operator::Unary
       include Evaluatable
@@ -22,6 +45,15 @@ module SPARQL; module Algebra
         raise TypeError, "expected an RDF::Statement, but got #{operand.inspect}" unless operand.is_a?(RDF::Statement)
         operand.predicate
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "PREDICATE(" + operands.last.to_sparql(**options) + ")"
+      end
     end # Predicate
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,10 +3,15 @@ module SPARQL; module Algebra
     ##
     # The SPARQL GraphPattern `prefix` operator.
     #
-    # @example
+    # [6]   PrefixDecl              ::= 'PREFIX' PNAME_NS IRIREF
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example/>
+    #   SELECT * { :s :p :o }
+    #
+    # @example SSE
     #   (prefix ((: <http://example/>))
-    #     (graph ?g
-    #       (bgp (triple ?s ?p ?o))))
+    #    (bgp (triple :s :p :o)))
     #
     # @see https://www.w3.org/TR/sparql11-query/#QSynIRI
     class Prefix < Binary
@@ -65,6 +70,22 @@ module SPARQL; module Algebra
       def query_yields_statements?
         operands.last.query_yields_statements?
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this term.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        prefixes = {}
+        str = operands.first.map do |(pfx, sfx)|
+          pfx = pfx.to_s.chomp(':').to_sym
+          prefixes[pfx] = sfx
+          "PREFIX #{pfx}: #{sfx.to_sparql}\n"
+        end.join("")
+
+        str << operands.last.to_sparql(prefixes: prefixes, **options)
+      end
     end # Prefix
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,11 +3,53 @@ module SPARQL; module Algebra
     ##
     # The SPARQL GraphPattern `project` operator.
     #
-    # @example
-    #   (select (?v)
-    #     (project (?v)
-    #       (filter (= ?v 2)
-    #         (bgp (triple ?s <http://example/p> ?v)))))
+    # [9] SelectClause ::= 'SELECT' ( 'DISTINCT' | 'REDUCED' )?  ( ( Var | ( '(' Expression 'AS' Var ')' ) )+ | '*' )
+    #
+    # ## Basic Projection
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example/>
+    #   SELECT ?v  { 
+    #     ?s :p ?v . 
+    #     FILTER (?v = 2)
+    #   }
+    #
+    # @example SSE
+    #   (prefix ((: <http://example/>))
+    #    (project (?v)
+    #     (filter (= ?v 2)
+    #      (bgp (triple ?s :p ?v)))))
+    #
+    # @example SPARQL Grammar (Sub select)
+    #   SELECT (1 AS ?X ) {
+    #     SELECT (2 AS ?Y ) {}
+    #   }
+    #
+    # @example SSE (Sub select)
+    #   (project (?X)
+    #    (extend ((?X 1))
+    #     (project (?Y)
+    #      (extend ((?Y 2))
+    #       (bgp)))))
+    #
+    # @example SPARQL Grammar (filter projection)
+    #   PREFIX : <http://www.example.org/>
+    #   ASK {
+    #     {SELECT (GROUP_CONCAT(?o) AS ?g) WHERE {
+    #      :a :p1 ?o
+    #     }}
+    #     FILTER(?g = "1 22" || ?g = "22 1")
+    #   }
+    #
+    # @example SSE (filter projection)
+    #   (prefix ((: <http://www.example.org/>))
+    #    (ask
+    #     (filter
+    #      (|| (= ?g "1 22") (= ?g "22 1"))
+    #      (project (?g)
+    #       (extend ((?g ??.0))
+    #        (group () ((??.0 (group_concat ?o)))
+    #         (bgp (triple :a :p1 ?o)))))) ))
     #
     # @see https://www.w3.org/TR/sparql11-query/#modProjection
     class Project < Operator::Binary
@@ -15,10 +57,38 @@ module SPARQL; module Algebra
       
       NAME = [:project]
 
+      ##
+      # Can only project in-scope variables.
+      #
+      # @return (see Algebra::Operator#initialize)
+      def validate!
+        if (group = descendants.detect {|o| o.is_a?(Group)})
+          raise ArgumentError, "project * on group is illegal" if operands.first.empty?
+          query_vars = operands.last.variables
+          variables.keys.each do |v|
+            raise ArgumentError,
+              "projecting #{v.to_sse} not projected from group" unless
+              query_vars.key?(v.to_sym)
+          end
+        end
+
+        super
+      end
+
+      ##
+      # The projected variables.
+      #
+      # @return [Hash{Symbol => RDF::Query::Variable}]
+      def variables
+        operands(1).inject({}) {|hash, o| hash.merge(o.variables)}
+      end
+
       ##
       # Executes this query on the given `queryable` graph or repository.
       # Reduces the result set to the variables listed in the first operand
       #
+      # If the first operand is empty, this indicates a `SPARQL *`, and all in-scope variables are projected.
+      #
       # @param  [RDF::Queryable] queryable
       #   the graph or repository to query
       # @param  [Hash{Symbol => Object}] options
@@ -32,10 +102,45 @@ module SPARQL; module Algebra
       # @see    https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
       def execute(queryable, **options, &block)
         @solutions = queryable.query(operands.last, depth: options[:depth].to_i + 1, **options)
-        @solutions = @solutions.project(*(operands.first))
+        @solutions.variable_names = self.variables.keys
+        @solutions = @solutions.project(*(operands.first)) unless operands.first.empty?
         @solutions.each(&block) if block_given?
         @solutions
       end
+    
+      ##
+      # In-scope variables for a select are limited to those projected.
+      #
+      # @return [Hash{Symbol => RDF::Query::Variable}]
+      def variables
+        in_scope = operands.first.empty? ?
+          operands.last.variables.values :
+          operands.first
+
+        in_scope.inject({}) {|memo, v| memo.merge(v.variables)}
+      end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # Extracts projections
+      #
+      # If there are already extensions or filters, then this is a sub-select.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        vars = operands[0].empty? ? [:*] : operands[0]
+        if options[:extensions] || options[:filter_ops] || options[:project]
+          # Any of these options indicates we're in a sub-select
+          opts = options.dup.delete_if {|k,v| %I{extensions filter_ops project}.include?(k)}
+          content = operands.last.to_sparql(project: vars, **opts)
+          content = "{#{content}}" unless content.start_with?('{') && content.end_with?('}')
+          Operator.to_sparql(content, **options)
+        else
+          operands.last.to_sparql(project: vars, **options)
+        end
+      end
     end # Project
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -5,8 +5,25 @@ module SPARQL; module Algebra
     #
     # Returns a pseudo-random number between 0 (inclusive) and 1.0e0 (exclusive). Different numbers can be produced every time this function is invoked. Numbers should be produced with approximately equal probability.
     #
-    # @example
-    #   (rand)
+    # [121] BuiltInCall ::= ... | 'RAND' NIL 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   ASK {
+    #     BIND(RAND() AS ?r)
+    #     FILTER(DATATYPE(?r) = xsd:double && ?r >= 0.0 && ?r < 1.0)
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((xsd: <http://www.w3.org/2001/XMLSchema#>))
+    #    (ask
+    #     (filter
+    #      (&&
+    #       (&& (= (datatype ?r) xsd:double) (>= ?r 0.0))
+    #       (< ?r 1.0))
+    #      (extend ((?r (rand)))
+    #       (bgp)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#idp2130040
     class Rand < Operator::Nullary
@@ -21,6 +38,17 @@ module SPARQL; module Algebra
       def apply(**options)
         RDF::Literal::Double.new(Random.rand)
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # Extracts projections
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "RAND()"
+      end
     end # Rand
   end # Operator
 end; end # SPARQL::Algebra