sparql 3.1.8 → 3.2.0

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
@@ -26,6 +35,15 @@ module SPARQL; module Algebra
         raise TypeError, "expected an RDF::Literal::DateTime, but got #{operand.inspect}" unless operand.is_a?(RDF::Literal::DateTime)
         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

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

@@ -3,7 +3,15 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `if` function.
     #
-    # @example
+    # [121] BuiltInCall ::= ... | 'IF' '(' Expression ',' Expression ',' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   BASE <http://example.org/>
+    #   PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   SELECT ?o (IF(lang(?o) = "ja", true, false) AS ?integer)
+    #   WHERE { ?s ?p ?o }
+    #
+    # @example SSE
     #     (base <http://example.org/>
     #       (prefix ((xsd: <http://www.w3.org/2001/XMLSchema#>))
     #         (project (?o ?integer)
@@ -37,9 +45,18 @@ module SPARQL; module Algebra
         operand(0).evaluate(bindings, depth: options[:depth].to_i + 1, **options) == RDF::Literal::TRUE ?
           operand(1).evaluate(bindings, depth: options[:depth].to_i + 1, **options) :
           operand(2).evaluate(bindings, depth: options[:depth].to_i + 1, **options)
-        rescue
-          raise TypeError
+      rescue
+        raise TypeError
       end
     end # If
-  end # Operator
+
+    ##
+    #
+    # Returns a partial SPARQL grammar for this operator.
+    #
+    # @return [String]
+    def to_sparql(**options)
+      "IF(" + operands.to_sparql(delimiter: ', ', **options) + ")"
+    end
+  end # If
 end; end # SPARQL::Algebra

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

@@ -3,7 +3,12 @@ module SPARQL; module Algebra
     ##
     # The SPARQL GraphPattern `in` operator.
     #
-    # @example
+    # [114] RelationalExpression    ::= NumericExpression ('IN' ExpressionList)?
+    #
+    # @example SPARQL Grammar
+    #   ASK { FILTER(2 IN (1, 2, 3)) }
+    #
+    # @example SSE
     #   (ask (filter (in 2 1 2 3) (bgp)))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-in
@@ -54,6 +59,18 @@ module SPARQL; module Algebra
         else RDF::Literal::FALSE
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "(" + operands.first.to_sparql(**options) +
+        " IN (" +
+        operands[1..-1].map {|e| e.to_sparql(**options)}.join(", ") +
+        "))"
+      end
     end # In
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -6,8 +6,19 @@ module SPARQL; module Algebra
     #
     # The INSERT operation is a form of the DELETE/INSERT operation having no DELETE section
     #
-    # @example
-    #   (insert ((triple ?s ?p "q")))
+    # [43]  InsertClause            ::= 'INSERT' QuadPattern
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/> 
+    #   INSERT { ?s ?p "q" }
+    #   WHERE { ?s ?p ?o }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/>))
+    #    (update
+    #     (modify (bgp (triple ?s ?p ?o))
+    #      (insert ((triple ?s ?p "q"))))))
     #
     # @see https://www.w3.org/TR/sparql11-update/#insert
     class Insert < Operator::Unary
@@ -51,6 +62,15 @@ module SPARQL; module Algebra
         end
         queryable
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this term.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "INSERT {\n" + operands.first.to_sparql(as_statement: true, **options) + "\n}"
+      end
     end # Insert
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -6,8 +6,18 @@ module SPARQL; module Algebra
     #
     # The INSERT DATA operation adds some triples, given inline in the request, into the Graph Store
     #
-    # @example
-    #   (insertData ((graph <http://example.org/g1> ((triple :s :p :o)))))
+    # [38]  InsertData              ::= 'INSERT DATA' QuadData
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/ns#>
+    #   INSERT DATA { GRAPH <http://example.org/g1> { :s :p :o } }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/ns#>))
+    #    (update
+    #     (insertData (
+    #      (graph <http://example.org/g1> ((triple :s :p :o)))))))
     #
     # @see https://www.w3.org/TR/sparql11-update/#insertData
     class InsertData < Operator::Unary
@@ -36,6 +46,17 @@ module SPARQL; module Algebra
         end
         queryable
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this term.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "INSERT DATA {\n" +
+          operands.first.to_sparql(as_statement: true, top_level: false, delimiter: "\n", **options) +
+          "\n}"
+      end
     end # InsertData
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,10 +3,18 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `iri` operator.
     #
-    # @example
-    #     (base <http://example.org/> (project (?uri ?iri)
-    #       (extend ((?uri (uri "uri")) (?iri (iri "iri")))
-    #         (bgp))))
+    # [121] BuiltInCall ::= ... | 'IRI' '(' Expression ')' | 'URI' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   BASE <http://example.org/>
+    #   SELECT (URI("uri") AS ?uri) (IRI("iri") AS ?iri)
+    #   WHERE {}
+    #
+    # @example SSE
+    #   (base <http://example.org/>
+    #    (project (?uri ?iri)
+    #     (extend ((?uri (iri "uri")) (?iri (iri "iri")))
+    #      (bgp))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-iri
     class IRI < Operator::Unary
@@ -35,6 +43,15 @@ module SPARQL; module Algebra
         base.join(literal.to_s)
       end
 
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "IRI(" + operands.last.to_sparql(**options) + ")"
+      end
+
       Operator::URI = IRI
     end # IRI
   end # Operator

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

@@ -3,7 +3,16 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `isBlank` operator.
     #
-    # @example
+    # [121] BuiltInCall ::= ... | 'isBlank' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX     :    <http://example.org/things#>
+    #   SELECT ?x ?v WHERE {
+    #     ?x :p ?v .
+    #     FILTER isBlank(?v) .
+    #   }
+    #
+    # @example SSE
     #   (prefix ((xsd: <http://www.w3.org/2001/XMLSchema#>)
     #            (: <http://example.org/things#>))
     #     (project (?x ?v)
@@ -30,6 +39,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)
+        "isBlank(" + operands.first.to_sparql(**options) + ")"
+      end
     end # IsBlank
   end # Operator
 end; end # SPARQL::Algebra

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)
@@ -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)
@@ -31,6 +40,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)
+        "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`
@@ -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

@@ -5,6 +5,29 @@ module SPARQL; module Algebra
     #
     # 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
@@ -25,6 +48,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)
+        "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
@@ -24,6 +40,15 @@ module SPARQL; module Algebra
           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))))
@@ -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
@@ -26,6 +38,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)
+        "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
@@ -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 # LessThan

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