sparql 3.1.8 → 3.2.0

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

@@ -3,8 +3,17 @@ 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)))
     #
     # @see https://www.w3.org/TR/sparql11-query/#defn_evalPP_inverse
     class Reverse < Operator::Unary
@@ -49,6 +58,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
@@ -29,5 +43,14 @@ module SPARQL; module Algebra
         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
@@ -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

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

@@ -3,13 +3,26 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `sample` set function.
     #
-    # @example
-    #   (prefix ((: <http://www.example.org/>))
-    #     (filter (|| (|| (= ?sample 1.0) (= ?sample 2.2)) (= ?sample 3.5))
-    #       (project (?sample)
-    #         (extend ((?sample ??.0))
-    #           (group () ((??.0 (sample ?o)))
-    #             (bgp (triple ?s :dec ?o)))))))
+    # [127] Aggregate::= ... | 'SAMPLE' '(' 'DISTINCT'? Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example/>
+    #   
+    #   SELECT ?w (SAMPLE(?v) AS ?S)
+    #   {
+    #     ?s :p ?v .
+    #     OPTIONAL { ?s :q ?w }
+    #   }
+    #   GROUP BY ?w
+    #
+    # @example SSE
+    #   (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))))) ))
     #
     # @see https://www.w3.org/TR/sparql11-query/#defn_aggSample
     class Sample < Operator
@@ -34,6 +47,15 @@ module SPARQL; module Algebra
       def apply(enum, **options)
         enum.detect(lambda {raise TypeError, "Sampling an empty multiset"}) {|e| e.first}.first
       end
-    end # LCase
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "SAMPLE(#{operands.to_sparql(**options)})"
+      end
+    end # Sample
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -5,11 +5,20 @@ module SPARQL; module Algebra
     #
     # Returns the seconds part of the lexical form of `arg`.
     #
-    # @example
-    #     (prefix ((: <http://example.org/>))
-    #       (project (?s ?x)
-    #         (extend ((?x (seconds ?date)))
-    #           (bgp (triple ?s :date ?date)))))
+    # [121] BuiltInCall ::= ... | 'SECONDS' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   SELECT ?s (SECONDS(?date) AS ?x) WHERE {
+    #     ?s :date ?date
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/>))
+    #    (project (?s ?x)
+    #     (extend ((?x (seconds ?date)))
+    #      (bgp (triple ?s :date ?date)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-seconds
     class Seconds < Operator::Unary
@@ -28,6 +37,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.second)
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "SECONDS(#{operands.last.to_sparql(**options)})"
+      end
     end # Seconds
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,8 +3,17 @@ module SPARQL; module Algebra
     ##
     # The SPARQL Property Path `sequence` (SequencePath) operator.
     #
-    # @example
-    #   (seq :a :b)
+    # # [90] PathSequence ::= PathEltOrInverse ( '/' PathEltOrInverse )*
+    #
+    # @example SPARQL Grammar
+    #   PREFIX ex:	<http://www.example.org/schema#>
+    #   PREFIX in:	<http://www.example.org/instance#>
+    #   SELECT * WHERE {  in:a ex:p1/ex:p2 ?x }
+    #
+    # @example SSE
+    #   (prefix ((ex: <http://www.example.org/schema#>)
+    #            (in: <http://www.example.org/instance#>))
+    #    (path in:a (seq ex:p1 ex:p2) ?x))
     #
     # @see https://www.w3.org/TR/sparql11-query/#defn_evalPP_sequence
     class Seq < Operator::Binary
@@ -67,6 +76,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.to_sparql(delimiter: '/', **options)
+      end
     end # Seq
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -6,16 +6,6 @@ module SPARQL; module Algebra
     #
     # Sequences through each operand
     #
-    # @example
-    #   (sequence
-    #     (bgp
-    #       (triple ?s ?p ??0)
-    #       (triple ??0 rdf:first ??1)
-    #       (triple ??0 rdf:rest ??2)
-    #       (triple ??2 rdf:first ??3)
-    #       (triple ??2 rdf:rest rdf:nil))
-    #     (path ??1 (seq (path* :p) :q) 123)
-    #     (path ??3 (reverse :r) "hello"))
     class Sequence < Operator
       include SPARQL::Algebra::Update
 

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

@@ -7,7 +7,15 @@ module SPARQL; module Algebra
     #
     # Returns the SHA1 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
+    # [121] BuiltInCall ::= ... | 'SHA1' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   SELECT (SHA1(?l) AS ?hash) WHERE {
+    #    :s1 :str ?l
+    #   }
+    #
+    # @example SSE
     #     (prefix ((: <http://example.org/>))
     #       (project (?hash)
     #         (extend ((?hash (sha1 ?l)))
@@ -31,6 +39,15 @@ module SPARQL; module Algebra
         raise TypeError, "expected simple literal or xsd:string, but got #{operand.inspect}" unless (operand.datatype || RDF::XSD.string) == RDF::XSD.string
         RDF::Literal(Digest::SHA1.new.hexdigest(operand.to_s))
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "SHA1(" + operands.to_sparql(**options) + ")"
+      end
     end # SHA1
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -7,7 +7,15 @@ module SPARQL; module Algebra
     #
     # Returns the SHA256 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
+    # [121] BuiltInCall ::= ... | 'SHA256' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   SELECT (SHA256(?l) AS ?hash) WHERE {
+    #    :s1 :str ?l
+    #   }
+    #
+    # @example SSE
     #     (prefix ((: <http://example.org/>))
     #       (project (?hash)
     #         (extend ((?hash (sha256 ?l)))
@@ -31,6 +39,15 @@ module SPARQL; module Algebra
         raise TypeError, "expected simple literal or xsd:string, but got #{operand.inspect}" unless (operand.datatype || RDF::XSD.string) == RDF::XSD.string
         RDF::Literal(Digest::SHA256.new.hexdigest(operand.to_s))
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "SHA256(" + operands.to_sparql(**options) + ")"
+      end
     end # SHA256
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -7,7 +7,15 @@ module SPARQL; module Algebra
     #
     # Returns the SHA384 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
+    # [121] BuiltInCall ::= ... | 'SHA384' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   SELECT (SHA384(?l) AS ?hash) WHERE {
+    #    :s1 :str ?l
+    #   }
+    #
+    # @example SSE
     #     (prefix ((: <http://example.org/>))
     #       (project (?hash)
     #         (extend ((?hash (sha384 ?l)))
@@ -31,6 +39,15 @@ module SPARQL; module Algebra
         raise TypeError, "expected simple literal or xsd:string, but got #{operand.inspect}" unless (operand.datatype || RDF::XSD.string) == RDF::XSD.string
         RDF::Literal(Digest::SHA384.new.hexdigest(operand.to_s))
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "SHA384(" + operands.to_sparql(**options) + ")"
+      end
     end # SHA384
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -7,7 +7,15 @@ module SPARQL; module Algebra
     #
     # Returns the SHA512 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
+    # [121] BuiltInCall ::= ... | 'SHA512' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   SELECT (SHA512(?l) AS ?hash) WHERE {
+    #    :s1 :str ?l
+    #   }
+    #
+    # @example SSE
     #     (prefix ((: <http://example.org/>))
     #       (project (?hash)
     #         (extend ((?hash (sha512 ?l)))
@@ -31,6 +39,15 @@ module SPARQL; module Algebra
         raise TypeError, "expected simple literal or xsd:string, but got #{operand.inspect}" unless (operand.datatype || RDF::XSD.string) == RDF::XSD.string
         RDF::Literal(Digest::SHA512.new.hexdigest(operand.to_s))
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "SHA512(" + operands.to_sparql(**options) + ")"
+      end
     end # SHA512
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,12 +3,23 @@ module SPARQL; module Algebra
     ##
     # The SPARQL GraphPattern `slice` operator.
     #
-    # @example
+    # [25]  LimitOffsetClauses      ::= LimitClause OffsetClause? | OffsetClause LimitClause?
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/ns#>
+    #   
+    #   SELECT ?v
+    #   WHERE { :a ?p ?v }
+    #   ORDER BY ?v
+    #   OFFSET 100
+    #   LIMIT 1
+    #
+    # @example SSE
     #   (prefix ((: <http://example.org/ns#>))
-    #     (slice 1 1
-    #       (project (?v)
-    #         (order (?v)
-    #           (bgp (triple ??0 :num ?v))))))
+    #    (slice 100 1
+    #     (project (?v)
+    #      (order (?v)
+    #       (bgp (triple :a ?p ?v))))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
     class Slice < Operator::Ternary
@@ -52,6 +63,17 @@ module SPARQL; module Algebra
         @solutions.each(&block) if block_given?
         @solutions
       end
+
+      ##
+      #
+      # Extracts OFFSET and LIMIT.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        offset = operands[0].to_i unless operands[0] == :_
+        limit = operands[1].to_i unless operands[1] == :_
+        operands.last.to_sparql(offset: offset, limit: limit, **options)
+      end
     end # Slice
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,7 +3,18 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `str` operator.
     #
-    # @example
+    # [121] BuiltInCall ::= ... | 'STR' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX  xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   PREFIX  : <http://example.org/things#>
+    #   SELECT  ?x ?v
+    #   WHERE
+    #       { ?x :p ?v . 
+    #         FILTER ( str(?v) = "1" ) .
+    #       }
+    #
+    # @example SSE
     #   (prefix ((xsd: <http://www.w3.org/2001/XMLSchema#>)
     #            (: <http://example.org/things#>))
     #     (project (?x ?v)
@@ -30,6 +41,15 @@ module SPARQL; module Algebra
           else raise TypeError, "expected an RDF::Literal or RDF::URI, but got #{term.inspect}"
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "str(" + operands.first.to_sparql(**options) + ")"
+      end
     end # Str
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,8 +3,22 @@ module SPARQL; module Algebra
     ##
     # A SPARQL `strafter` operator.
     #
-    # @example
-    #   (strafter ?x ?y)
+    # [121] BuiltInCall ::= ... | 'STRAFTER' '(' Expression ',' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   SELECT ?s (STRAFTER(?str,"e") AS ?suffix) WHERE {
+    #     ?s :str ?str
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/>)
+    #     (xsd: <http://www.w3.org/2001/XMLSchema#>))
+    #    (project (?s ?suffix)
+    #     (extend ((?suffix (strafter ?str "e")))
+    #      (bgp (triple ?s :str ?str)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-strafter
     # @see https://www.w3.org/TR/xpath-functions/#func-substring-after
@@ -52,6 +66,15 @@ module SPARQL; module Algebra
           RDF::Literal(parts.last, datatype: left.datatype, language: left.language)
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "STRAFTER(" + operands.to_sparql(delimiter: ', ', **options) + ")"
+      end
     end # StrAfter
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,8 +3,22 @@ module SPARQL; module Algebra
     ##
     # A SPARQL `strbefore` operator.
     #
-    # @example
-    #   (strbefore ?x ?y)
+    # [121] BuiltInCall ::= ... | 'STRBEFORE' '(' Expression ',' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   SELECT ?s (STRBEFORE(?str,"s") AS ?prefix) WHERE {
+    #     ?s :str ?str
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/>)
+    #     (xsd: <http://www.w3.org/2001/XMLSchema#>))
+    #    (project (?s ?prefix)
+    #     (extend ((?prefix (strbefore ?str "s")))
+    #      (bgp (triple ?s :str ?str)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-strbefore
     # @see https://www.w3.org/TR/xpath-functions/#func-substring-before
@@ -54,6 +68,15 @@ module SPARQL; module Algebra
           RDF::Literal(parts.first, language: left.language, datatype: left.datatype)
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "STRBEFORE(" + operands.to_sparql(delimiter: ', ', **options) + ")"
+      end
     end # StrBefore
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,7 +3,19 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `strdt` operator.
     #
-    # @example
+    # [121] BuiltInCall ::= ... | 'STRDT' '(' Expression ',' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   SELECT ?s (STRDT(?str,xsd:string) AS ?str1) WHERE {
+    #     ?s :str ?str
+    #     FILTER(LANGMATCHES(LANG(?str), "en"))
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/>) (xsd: <http://www.w3.org/2001/XMLSchema#>))
     #     (project (?s ?str1)
     #       (extend ((?str1 (strdt ?str xsd:string)))
     #         (filter (langMatches (lang ?str) "en")
@@ -28,6 +40,15 @@ module SPARQL; module Algebra
         raise TypeError, "Literal #{value.inspect} is not simple" unless value.simple?
         RDF::Literal.new(value.to_s, datatype: datatypeIRI)
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "STRDT(" + operands.to_sparql(delimiter: ', ', **options) + ")"
+      end
     end # StrDT
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -1,10 +1,23 @@
 module SPARQL; module Algebra
   class Operator
     ##
-    # A SPARQL `contains` operator.
+    # A SPARQL `strends` operator.
     #
-    # @example
-    #   (strends ?x ?y)
+    # [121] BuiltInCall ::= ... | 'STRENDS' '(' Expression ',' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   SELECT ?s ?str WHERE {
+    #     ?s :str ?str
+    #     FILTER STRENDS(?str, "a")
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/>))
+    #    (project (?s ?str)
+    #     (filter (strends ?str "a")
+    #      (bgp (triple ?s :str ?str)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-strends
     # @see https://wwww.w3.org/TR/xpath-functions/#func-ends-with
@@ -41,6 +54,15 @@ module SPARQL; module Algebra
         else RDF::Literal::FALSE
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "STRENDS(" + operands.to_sparql(delimiter: ', ', **options) + ")"
+      end
     end # StrEnds
   end # Operator
 end; end # SPARQL::Algebra