sparql 3.1.6 → 3.2.1

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                 ::= '*' | '?' | '+'
+    
+    # @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
@@ -37,6 +47,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/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
@@ -23,7 +53,7 @@ module SPARQL; module Algebra
       #   a numeric literal
       # @return [RDF::Literal::Numeric]
       # @raise  [TypeError] if either operand is not a numeric literal
-      def apply(left, right = nil)
+      def apply(left, right = nil, **options)
         case
         when left.is_a?(RDF::Literal::Numeric) && right.is_a?(RDF::Literal::Numeric)
           left + right
@@ -32,6 +62,15 @@ module SPARQL; module Algebra
         else raise TypeError, "expected two RDF::Literal::Numeric operands, 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
@@ -18,10 +41,19 @@ module SPARQL; module Algebra
       #   the operand
       # @return [RDF::Literal]
       # @raise  [TypeError] if the operand is not a statement
-      def apply(operand)
+      def apply(operand, **options)
         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
@@ -36,6 +78,28 @@ module SPARQL; module Algebra
         @solutions.each(&block) if block_given?
         @solutions
       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
@@ -18,9 +35,20 @@ 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.
       #
       # @return [RDF::Literal::Double] random value
-      def apply
+      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

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

@@ -3,9 +3,17 @@ module SPARQL; module Algebra
     ##
     # The SPARQL GraphPattern `reduced` operator.
     #
-    # @example
-    #   (prefix ((xsd: <http://www.w3.org/2001/XMLSchema#>)
-    #            (: <http://example/>))
+    # [9] SelectClause ::= 'SELECT' ( 'DISTINCT' | 'REDUCED' )? ( ( Var | ( '(' Expression 'AS' Var ')' ) )+ | '*' )
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   SELECT REDUCED ?v
+    #   WHERE { ?x ?p ?v }
+    #
+    # @example SSE
+    #   (prefix ((: <http://example.org/>)
+    #            (xsd: <http://www.w3.org/2001/XMLSchema#>))
     #     (reduced
     #       (project (?v)
     #         (bgp (triple ?x ?p ?v)))))
@@ -37,6 +45,15 @@ module SPARQL; module Algebra
         @solutions.each(&block) if block_given?
         @solutions
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        operands.first.to_sparql(reduced: true, **options)
+      end
     end # Reduced
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,33 +3,31 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `regex` operator.
     #
-    # @example
+    # [122] RegexExpression         ::= 'REGEX' '(' Expression ',' Expression ( ',' Expression )? ')'
+    #
+    # @example SPARQL Grammar
+    #   PREFIX  ex: <http://example.com/#>
+    #   PREFIX  rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+    #   SELECT ?val
+    #   WHERE {
+    #     ex:foo rdf:value ?val .
+    #     FILTER regex(?val, "GHI")
+    #   }
+    #
+    # @example SSE
     #   (prefix ((ex: <http://example.com/#>)
     #            (rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>))
-    #     (project (?val)
-    #       (filter (regex ?val "GHI")
-    #         (bgp (triple ex:foo rdf:value ?val)))))
+    #    (project (?val)
+    #     (filter (regex ?val "GHI")
+    #      (bgp (triple ex:foo rdf:value ?val)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#funcex-regex
     # @see https://www.w3.org/TR/xpath-functions/#func-matches
-    class Regex < Operator::Ternary
+    class Regex < Operator
       include Evaluatable
 
       NAME = :regex
 
-      ##
-      # Initializes a new operator instance.
-      #
-      # @param  [RDF::Term] text
-      # @param  [RDF::Term] pattern
-      # @param  [RDF::Term] flags
-      # @param  [Hash{Symbol => Object}] options
-      #   any additional options (see {Operator#initialize})
-      # @raise  [TypeError] if any operand is invalid
-      def initialize(text, pattern, flags = RDF::Literal(''), **options)
-        super
-      end
-
       ##
       # Matches `text` against a regular expression `pattern`.
       #
@@ -42,7 +40,7 @@ module SPARQL; module Algebra
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if any operand is unbound
       # @raise  [TypeError] if any operand is not a simple literal
-      def apply(text, pattern, flags = RDF::Literal(''))
+      def apply(text, pattern, flags = RDF::Literal(''), **options)
         # @see https://www.w3.org/TR/xpath-functions/#regex-syntax
         raise TypeError, "expected a plain RDF::Literal, but got #{text.inspect}" unless text.is_a?(RDF::Literal) && text.plain?
         text = text.to_s
@@ -65,6 +63,16 @@ module SPARQL; module Algebra
         options |= Regexp::EXTENDED   if flags.include?(?x)
         RDF::Literal(Regexp.new(pattern, options) === text)
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        ops = operands.last.to_s.empty? ? operands[0..-2] : operands
+        "regex(" + ops.to_sparql(delimiter: ', ', **options) + ")"
+      end
     end # Regex
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,12 +3,22 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `replace` operator.
     #
-    # @example
-    #     (prefix ((: <http://example.org/>)
-    #              (xsd: <http://www.w3.org/2001/XMLSchema#>))
-    #       (project (?s ?new)
-    #         (extend ((?new (replace ?str "[^a-z0-9]" "-")))
-    #           (bgp (triple ?s :str ?str)))))
+    # [124] StrReplaceExpression ::= 'REPLACE' '(' Expression ',' Expression ',' Expression ( ',' Expression )? ')'
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   SELECT ?s (REPLACE(?str,"[^a-z0-9]", "-") AS ?new)
+    #   WHERE {
+    #     ?s :str ?str
+    #   }
+    #
+    # @example SSE
+    #   (prefix ((: <http://example.org/>)
+    #            (xsd: <http://www.w3.org/2001/XMLSchema#>))
+    #     (project (?s ?new)
+    #       (extend ((?new (replace ?str "[^a-z0-9]" "-")))
+    #         (bgp (triple ?s :str ?str)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#funcex-replace
     # @see https://www.w3.org/TR/xpath-functions/#func-replace
@@ -42,7 +52,7 @@ module SPARQL; module Algebra
       # @return [RDF::Literal] 
       # @raise  [TypeError] if any operand is unbound
       # @raise  [TypeError] if any operand is not a plain literal
-      def apply(text, pattern, replacement, flags = RDF::Literal(''))
+      def apply(text, pattern, replacement, flags = RDF::Literal(''), **options)
         raise TypeError, "expected a plain RDF::Literal, but got #{text.inspect}" unless text.literal? && text.plain?
         # TODO: validate text syntax
 
@@ -76,6 +86,16 @@ module SPARQL; module Algebra
       def to_sxp_bin
         [NAME] + operands.reject {|o| o.to_s == ""}
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        ops = operands.last.to_s.empty? ? operands[0..-2] : operands
+        "REPLACE(" + ops.to_sparql(delimiter: ', ', **options) + ")"
+      end
     end # Replace
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,8 +3,28 @@ module SPARQL; module Algebra
     ##
     # The SPARQL Property Path `reverse` (NegatedPropertySet) operator.
     #
-    # @example
-    #   (reverse :p)
+    # [92]  PathEltOrInverse        ::= PathElt | '^' PathElt
+    #
+    # @example SPARQL Grammar
+    #   PREFIX ex:	<http://www.example.org/schema#>
+    #   PREFIX in:	<http://www.example.org/instance#>
+    #   ASK { in:b ^ex:p in:a }
+    #
+    # @example SSE
+    #   (prefix ((ex: <http://www.example.org/schema#>)
+    #            (in: <http://www.example.org/instance#>))
+    #    (ask (path in:b (reverse ex:p) in:a)))
+    #
+    # @example SPARQL Grammar
+    #   prefix ex:	<http://www.example.org/schema#>
+    #   prefix in:	<http://www.example.org/instance#>
+    #   
+    #   select  * where { in:c ^(ex:p1/ex:p2) ?x }
+    #
+    # @example SSE
+    #   (prefix ((ex: <http://www.example.org/schema#>)
+    #            (in: <http://www.example.org/instance#>))
+    #    (path in:c (reverse (seq ex:p1 ex:p2)) ?x))
     #
     # @see https://www.w3.org/TR/sparql11-query/#defn_evalPP_inverse
     class Reverse < Operator::Unary
@@ -49,6 +69,15 @@ module SPARQL; module Algebra
         ), &block)
 
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "^(" + operands.first.to_sparql(**options) + ')'
+      end
     end # Reverse
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -5,8 +5,22 @@ module SPARQL; module Algebra
     #
     # Returns the number with no fractional part that is closest to the argument. If there are two such numbers, then the one that is closest to positive infinity is returned. An error is raised if `arg` is not a numeric value.
     # 
-    # @example
-    #   (round ?x)
+    # [121] BuiltInCall ::= ... 'ROUND' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   SELECT ?s ?num (ROUND(?num) AS ?round) WHERE {
+    #    ?s :num ?num
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/>)
+    #     (xsd: <http://www.w3.org/2001/XMLSchema#>))
+    #    (project (?s ?num ?round)
+    #     (extend ((?round (round ?num)))
+    #      (bgp (triple ?s :num ?num)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-round
     # @see https://www.w3.org/TR/xpath-functions/#func-round
@@ -22,12 +36,21 @@ module SPARQL; module Algebra
       #   the operand
       # @return [RDF::Literal] literal of same type
       # @raise  [TypeError] if the operand is not a numeric value
-      def apply(operand)
+      def apply(operand, **options)
         case operand
           when RDF::Literal::Numeric then operand.round
           else raise TypeError, "expected an RDF::Literal::Numeric, but got #{operand.inspect}"
         end
       end
     end # Round
+
+    ##
+    #
+    # Returns a partial SPARQL grammar for this operator.
+    #
+    # @return [String]
+    def to_sparql(**options)
+      "ROUND(#{operands.to_sparql(**options)})"
+    end
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,12 +3,21 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `sameTerm` operator.
     #
-    # @example
-    #   (prefix ((xsd: <http://www.w3.org/2001/XMLSchema#>)
-    #            (: <http://example.org/things#>))
-    #     (project (?x ?v)
-    #       (filter (sameTerm ?v)
-    #         (bgp (triple ?x :p ?v)))))
+    # [121] BuiltInCall ::= ... | 'sameTerm' '(' Expression ',' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX     :    <http://example.org/things#>
+    #   SELECT * {
+    #     ?x1 :p ?v1 .
+    #     ?x2 :p ?v2 .
+    #     FILTER sameTerm(?v1, ?v2)
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/things#>))
+    #    (filter (sameTerm ?v1 ?v2)
+    #     (bgp (triple ?x1 :p ?v1) (triple ?x2 :p ?v2))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-sameTerm
     class SameTerm < Operator::Binary
@@ -26,7 +35,7 @@ module SPARQL; module Algebra
       #   an RDF term
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if either operand is unbound
-      def apply(term1, term2)
+      def apply(term1, term2, **options)
         RDF::Literal(term1.eql?(term2))
       end
 
@@ -44,6 +53,15 @@ module SPARQL; module Algebra
           super # @see Operator#optimize!
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "sameTerm(#{operands.to_sparql(delimiter: ', ', **options)})"
+      end
     end # SameTerm
   end # Operator
 end; end # SPARQL::Algebra