sparql 3.1.5 → 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
@@ -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

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
@@ -31,9 +44,18 @@ module SPARQL; module Algebra
       #   enum of evaluated operand
       # @return [RDF::Term] An arbitrary term
       # @raise  [TypeError] If enum is empty
-      def apply(enum)
+      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
@@ -24,10 +33,19 @@ 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::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)))
@@ -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::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)))
@@ -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::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)))
@@ -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::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)))
@@ -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::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)
@@ -23,13 +34,22 @@ module SPARQL; module Algebra
       #   a literal or IRI
       # @return [RDF::Literal] a simple literal
       # @raise  [TypeError] if the operand is not a literal or IRI
-      def apply(term)
+      def apply(term, **options)
         case term
           when RDF::Literal then RDF::Literal(term.value)
           when RDF::URI     then RDF::Literal(term.to_s)
           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
@@ -37,7 +51,7 @@ module SPARQL; module Algebra
       #   a literal
       # @return [RDF::Literal]
       # @raise  [TypeError] if operands are not compatible
-      def apply(left, right)
+      def apply(left, right, **options)
         case
         when !left.compatible?(right)
           raise TypeError, "expected two RDF::Literal operands, but got #{left.inspect} and #{right.inspect}"
@@ -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
@@ -37,7 +51,7 @@ module SPARQL; module Algebra
       #   a literal
       # @return [RDF::Literal]
       # @raise  [TypeError] if operands are not compatible
-      def apply(left, right)
+      def apply(left, right, **options)
         case
         when !left.plain? || !right.plain?
           raise TypeError, "expected two RDF::Literal operands, but got #{left.inspect} and #{right.inspect}"
@@ -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