sparql 3.1.5 → 3.2.0

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

@@ -3,7 +3,16 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `isIRI`/`isURI` operator.
     #
-    # @example
+    # [121] BuiltInCall ::= ... | 'isIRI' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX     :    <http://example.org/things#>
+    #   SELECT ?x ?v WHERE {
+    #     ?x :p ?v .
+    #     FILTER isIRI(?v) .
+    #   }
+    #
+    # @example SSE
     #   (prefix ((xsd: <http://www.w3.org/2001/XMLSchema#>)
     #            (: <http://example.org/things#>))
     #     (project (?x ?v)
@@ -23,7 +32,7 @@ module SPARQL; module Algebra
       #   an RDF term
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if the operand is not an RDF term
-      def apply(term)
+      def apply(term, **options)
         case term
           when RDF::URI  then RDF::Literal::TRUE
           when RDF::Term then RDF::Literal::FALSE
@@ -32,6 +41,15 @@ module SPARQL; module Algebra
       end
 
       Operator::IsURI = IsIRI
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "isIRI(" + operands.first.to_sparql(**options) + ")"
+      end
     end # IsIRI
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,7 +3,16 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `isLiteral` operator.
     #
-    # @example
+    # [121] BuiltInCall ::= ... | 'isLiteral' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX     :    <http://example.org/things#>
+    #   SELECT ?x ?v WHERE {
+    #     ?x :p ?v .
+    #     FILTER isLiteral(?v) .
+    #   }
+    #
+    # @example SSE
     #   (prefix ((xsd: <http://www.w3.org/2001/XMLSchema#>)
     #            (: <http://example.org/things#>))
     #     (project (?x ?v)
@@ -24,13 +33,22 @@ module SPARQL; module Algebra
       #   an RDF term
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if the operand is not an RDF term
-      def apply(term)
+      def apply(term, **options)
         case term
           when RDF::Literal then RDF::Literal::TRUE
           when RDF::Term    then RDF::Literal::FALSE
           else raise TypeError, "expected an RDF::Term, but got #{term.inspect}"
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "isLiteral(" + operands.first.to_sparql(**options) + ")"
+      end
     end # IsLiteral
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,9 +3,18 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `isNumeric` operator.
     #
-    # Note numeric denotes typed literals with datatypes xsd:integer, xsd:decimal, xsd:float, and xsd:double, not derived types.
+    # Note numeric denotes typed literals with datatypes `xsd:integer`, `xsd:decimal`, `xsd:float`, and `xsd:double`, not derived types.
     #
-    # @example
+    # [121] BuiltInCall ::= ... | 'isNumeric' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX     :    <http://example.org/things#>
+    #   SELECT ?x ?v WHERE {
+    #     ?x :p ?v .
+    #     FILTER isNumeric(?v) .
+    #   }
+    #
+    # @example SSE
     #   (prefix ((xsd: <http://www.w3.org/2001/XMLSchema#>)
     #            (: <http://example.org/things#>))
     #     (project (?x ?v)
@@ -16,7 +25,7 @@ module SPARQL; module Algebra
     class IsNumeric < Operator::Unary
       include Evaluatable
 
-      NAME = :isnumeric
+      NAME = :isNumeric
 
       ##
       # Returns `true` if the operand is an `RDF::Literal::Numeric`, `false`
@@ -26,7 +35,7 @@ module SPARQL; module Algebra
       #   an RDF term
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if the operand is not an RDF term
-      def apply(term)
+      def apply(term, **options)
         case term
           when RDF::Literal::NonPositiveInteger then RDF::Literal::FALSE
           when RDF::Literal::NonNegativeInteger then RDF::Literal::FALSE
@@ -36,6 +45,15 @@ module SPARQL; module Algebra
           else raise TypeError, "expected an RDF::Term, but got #{term.inspect}"
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "isNumeric(" + operands.first.to_sparql(**options) + ")"
+      end
     end # IsNumeric
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -0,0 +1,62 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL `isTRIPLE` operator.
+    #
+    # Returns true if term is an RDF-star triple. Returns false otherwise.
+    #
+    # [121] BuiltInCall ::= ... | 'isTreiple' '(' 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#istriple
+    class IsTriple < Operator::Unary
+      include Evaluatable
+
+      NAME = :isTRIPLE
+
+      ##
+      # Returns `true` if the operand is an `RDF::Statement`, `false` otherwise.
+      #
+      # @param  [RDF::Term] term
+      #   an RDF term
+      # @return [RDF::Literal::Boolean] `true` or `false`
+      # @raise  [TypeError] if the operand is not an RDF term
+      def apply(term, **options)
+        case term
+          when RDF::Statement  then RDF::Literal::TRUE
+          when RDF::Term then RDF::Literal::FALSE
+          else raise TypeError, "expected an RDF::Term, but got #{term.inspect}"
+        end
+      end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "isTRIPLE(" + operands.first.to_sparql(**options) + ")"
+      end
+    end # IsTriple
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -3,7 +3,16 @@ module SPARQL; module Algebra
     ##
     # The SPARQL GraphPattern `join` operator.
     #
-    # @example
+    # [54]	GroupGraphPatternSub	::=	TriplesBlock? (GraphPatternNotTriples "."? TriplesBlock? )*
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example/> 
+    #   SELECT * { 
+    #      ?s ?p ?o
+    #      GRAPH ?g { ?s ?q ?v }
+    #   }
+    #
+    # @example SSE
     #   (prefix ((: <http://example/>))
     #     (join
     #       (bgp (triple ?s ?p ?o))
@@ -82,6 +91,18 @@ module SPARQL; module Algebra
         @operands = ops
         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)
+        str = operands.to_sparql(top_level: false, delimiter: "\n", **options)
+        top_level ? Operator.to_sparql(str, **options) : str
+      end
     end # Join
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,6 +3,22 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `lang` operator.
     #
+    # [121] BuiltInCall ::= ... | 'LANG' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example/> 
+    #   
+    #   SELECT ?x
+    #   { ?x :p ?v . 
+    #     FILTER ( lang(?v) != '@NotALangTag@' )
+    #   }
+    #
+    # @example SSE
+    #   (prefix ((: <http://example/>))
+    #    (project (?x)
+    #     (filter (!= (lang ?v) "@NotALangTag@")
+    #      (bgp (triple ?x :p ?v)))))
+    #
     # @see https://www.w3.org/TR/sparql11-query/#func-lang
     class Lang < Operator::Unary
       include Evaluatable
@@ -18,12 +34,21 @@ module SPARQL; module Algebra
       #   a literal
       # @return [RDF::Literal] a simple literal
       # @raise  [TypeError] if the operand is not a literal
-      def apply(literal)
+      def apply(literal, **options)
         case literal
           when RDF::Literal then RDF::Literal(literal.language.to_s)
           else raise TypeError, "expected an RDF::Literal, but got #{literal.inspect}"
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "lang(" + operands.first.to_sparql(**options) + ")"
+      end
     end # Lang
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,7 +3,15 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `langMatches` operator.
     #
-    # @example
+    # [121] BuiltInCall ::= ... | 'LANGMATCHES' '(' Expression ',' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/#>
+    #   
+    #   SELECT *
+    #   { :x ?p ?v . FILTER langMatches(lang(?v), "en-GB") . }
+    #
+    # @example SSE
     #   (prefix ((: <http://example.org/#>))
     #     (filter (langMatches (lang ?v) "en-GB")
     #       (bgp (triple :x ?p ?v))))
@@ -27,7 +35,7 @@ module SPARQL; module Algebra
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if either operand is unbound
       # @raise  [TypeError] if either operand is not a simple literal
-      def apply(language_tag, language_range)
+      def apply(language_tag, language_range, **options)
         raise TypeError, "expected a plain RDF::Literal for language_tag, but got #{language_tag.inspect}" unless language_tag.is_a?(RDF::Literal) && language_tag.simple?
         language_tag = language_tag.to_s.downcase
 
@@ -48,6 +56,19 @@ module SPARQL; module Algebra
             RDF::Literal(language_tag.start_with?(language_range + '-'))
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "langMatches(" +
+          operands.first.to_sparql(**options) +
+          ", " +
+          operands.last.to_sparql(**options) +
+          ")"
+      end
     end # LangMatches
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,8 +3,20 @@ module SPARQL; module Algebra
     ##
     # The SPARQL logical `lcase` operator.
     #
-    # @example
-    #   (lcase ?x)
+    # [121] BuiltInCall ::= ... | 'LCASE' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   SELECT ?s (LCASE(?str) AS ?lstr) WHERE {
+    #     ?s :str ?str
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/>))
+    #    (project (?str ?lstr)
+    #     (extend ((?lstr (lcase ?str)))
+    #      (bgp (triple ?s :str ?str)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-lcase
     # @see https://www.w3.org/TR/xpath-functions/#func-lcase
@@ -20,12 +32,21 @@ module SPARQL; module Algebra
       #   the operand
       # @return [RDF::Literal] literal of same type
       # @raise  [TypeError] if the operand is not a literal value
-      def apply(operand)
+      def apply(operand, **options)
         case operand
           when RDF::Literal then RDF::Literal(operand.to_s.downcase, datatype: operand.datatype, language: operand.language)
           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)
+        "LCASE(" + operands.last.to_sparql(**options) + ")"
+      end
     end # LCase
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,7 +3,19 @@ module SPARQL; module Algebra
     ##
     # The SPARQL GraphPattern `leftjoin` operator.
     #
-    # @example
+    # [57]  OptionalGraphPattern    ::= 'OPTIONAL' GroupGraphPattern
+    #
+    # @example SPARQL Grammar
+    #   PREFIX :    <http://example/>
+    #   SELECT * { 
+    #     ?x :p ?v .
+    #     OPTIONAL { 
+    #       ?y :q ?w .
+    #       FILTER(?v=2)
+    #     }
+    #   }
+    #
+    # @example SSE
     #   (prefix ((: <http://example/>))
     #     (leftjoin
     #       (bgp (triple ?x :p ?v))
@@ -112,6 +124,22 @@ module SPARQL; module Algebra
           expr ? LeftJoin.new(ops[0], ops[1], expr) : LeftJoin.new(ops[0], ops[1])
         end
       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)
+        str = operands[0].to_sparql(top_level: false, **options) +
+          "\nOPTIONAL { \n" +
+          operands[1].to_sparql(top_level: false, **options) + "\n"
+        str << 'FILTER (' + operands[2].to_sparql(**options) + ") \n" if operands[2]
+        str << '}'
+        top_level ? Operator.to_sparql(str, **options) : str
+      end
     end # LeftJoin
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,8 +3,18 @@ module SPARQL; module Algebra
     ##
     # The SPARQL relational `<` (less 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
@@ -24,8 +34,8 @@ module SPARQL; module Algebra
       #   a literal
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if either operand is not a literal
-      def apply(left, right)
-        super
+      def apply(left, right, **options)
+        RDF::Literal(super == RDF::Literal(-1))
       end
     end # LessThan
   end # Operator

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

@@ -3,8 +3,18 @@ module SPARQL; module Algebra
     ##
     # The SPARQL relational `<=` (less 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
@@ -24,8 +34,8 @@ module SPARQL; module Algebra
       #   a literal
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if either operand is not a literal
-      def apply(left, right)
-        super
+      def apply(left, right, **options)
+        RDF::Literal(super <= RDF::Literal(0))
       end
     end # LessThanOrEqual
   end # Operator

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

@@ -6,8 +6,14 @@ module SPARQL; module Algebra
     #
     # The LOAD operation reads an RDF document from a IRI and inserts its triples into the specified graph in the Graph Store. The specified destination graph should be created if required; again, implementations providing an update service over a fixed set of graphs must return with failure for a request that would create a disallowed graph. If the destination graph already exists, then no data in that graph will be removed.
     #
-    # @example
-    #   (load <remote> <g>)
+    #
+    # [31]  Load                    ::= 'LOAD' 'SILENT'? iri ( 'INTO' GraphRef )?
+    #
+    # @example SPARQL Grammar
+    #   LOAD <http://example.org/remote> INTO GRAPH <http://example.org/g> ;
+    #
+    # @example SSE
+    #   (update (load <http://example.org/remote> <http://example.org/g>))
     #
     # @see https://www.w3.org/TR/sparql11-update/#load
     class Load < Operator
@@ -43,6 +49,23 @@ module SPARQL; module Algebra
       ensure
         queryable
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        silent = operands.first == :silent
+        ops = silent ? operands[1..-1] : operands
+        location, name = ops
+
+        str = "LOAD "
+        str << "SILENT " if silent
+        str << location.to_sparql(**options)
+        str << " INTO GRAPH " + name.to_sparql(**options) if name
+        str
+      end
     end # Load
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,7 +3,14 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `max` set function.
     #
-    # @example
+    # [127] Aggregate::= ... | 'MAX' '(' 'DISTINCT'? Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://www.example.org/>
+    #   SELECT (MAX(?o) AS ?max)
+    #   WHERE { ?s ?p ?o }
+    #
+    # @example SSE
     #    (prefix ((: <http://www.example.org/>))
     #      (project (?max)
     #        (extend ((?max ??.0))
@@ -31,7 +38,7 @@ module SPARQL; module Algebra
       # @param  [Enumerable<Array<RDF::Term>>] enum
       #   enum of evaluated operand
       # @return [RDF::Literal] The maximum value of the terms
-      def apply(enum)
+      def apply(enum, **options)
         # FIXME: we don't actually do anything with distinct
         operands.shift if distinct = (operands.first == :distinct)
         if enum.empty?
@@ -42,6 +49,15 @@ module SPARQL; module Algebra
           raise TypeError, "Maximum of non-literals: #{enum.flatten}"
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "MAX(" + operands.to_sparql(**options) + ")"
+      end
     end # Max
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -7,11 +7,19 @@ module SPARQL; module Algebra
     #
     # Returns the MD5 checksum, as a hex digit string, calculated on the UTF-8 representation of the simple literal or lexical form of the `xsd:string`. Hex digits `SHOULD` be in lower case.
     #
-    # @example
-    #     (prefix ((: <http://example.org/>))
-    #       (project (?hash)
-    #         (extend ((?hash (md5 ?l)))
-    #           (bgp (triple :s1 :str ?l)))))
+    # [121] BuiltInCall ::= ... | 'MD5' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   SELECT (MD5(?l) AS ?hash) WHERE {
+    #    :s1 :str ?l
+    #   }
+    #
+    # @example SSE
+    #   (prefix ((: <http://example.org/>))
+    #     (project (?hash)
+    #       (extend ((?hash (md5 ?l)))
+    #         (bgp (triple :s1 :str ?l)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-md5
     class MD5 < Operator::Unary
@@ -26,11 +34,20 @@ module SPARQL; module Algebra
       #   the operand
       # @return [RDF::Literal]
       # @raise  [TypeError] if the operand is not a simple literal
-      def apply(operand)
+      def apply(operand, **options)
         raise TypeError, "expected an RDF::Literal, but got #{operand.inspect}" unless operand.literal?
         raise TypeError, "expected simple literal or xsd:string, but got #{operand.inspect}" unless (operand.datatype || RDF::XSD.string) == RDF::XSD.string
         RDF::Literal(Digest::MD5.new.hexdigest(operand.to_s))
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "MD5(" + operands.to_sparql(**options) + ")"
+      end
     end # MD5
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,9 +3,16 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `min` set function.
     #
-    # @example
+    # [127] Aggregate::= ... | 'MIN' '(' 'DISTINCT'? Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://www.example.org/>
+    #   SELECT (MIN(?o) AS ?min)
+    #   WHERE { ?s :dec ?o }
+    #
+    # @example SSE
     #    (prefix ((: <http://www.example.org/>))
-    #      (project (?max)
+    #      (project (?min)
     #        (extend ((?min ??.0))
     #          (group () ((??.0 (min ?o)))
     #            (bgp (triple ?s ?p ?o))))))
@@ -31,7 +38,7 @@ module SPARQL; module Algebra
       # @param  [Enumerable<Array<RDF::Term>>] enum
       #   enum of evaluated operand
       # @return [RDF::Literal] The maximum value of the terms
-      def apply(enum)
+      def apply(enum, **options)
         # FIXME: we don't actually do anything with distinct
         operands.shift if distinct = (operands.first == :distinct)
         if enum.empty?
@@ -42,6 +49,15 @@ module SPARQL; module Algebra
           raise TypeError, "Minumuim of non-literals: #{enum.flatten}"
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "MIN(" + operands.to_sparql(**options) + ")"
+      end
     end # Min
   end # Operator
 end; end # SPARQL::Algebra