sparql 3.1.6 → 3.2.1

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,20 @@ 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)
+        distinct = operands.first == :distinct
+        args = distinct ? operands[1..-1] : operands
+        "SAMPLE(#{'DISTINCT ' if distinct}#{args.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

@@ -4,18 +4,11 @@ module SPARQL; module Algebra
     ##
     # The SPARQL UPDATE `sequence` operator.
     #
-    # Sequences through each operand
+    # 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"))
+    # [103] CollectionPath          ::= '(' GraphNodePath+ ')'
+    #
+    # @see https://www.w3.org/TR/sparql11-query/#collections
     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

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")
@@ -24,10 +36,19 @@ module SPARQL; module Algebra
       #   datatype
       # @return [RDF::Literal] a datatyped literal
       # @see https://www.w3.org/TR/sparql11-query/#func-strdt
-      def apply(value, datatypeIRI)
+      def apply(value, datatypeIRI, **options)
         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
@@ -33,7 +46,7 @@ module SPARQL; module Algebra
       #   a literal
       # @return [RDF::Literal::Boolean]
       # @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}"
@@ -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

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

@@ -3,12 +3,21 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `strlang` operator.
     #
-    # @example
-    #     (prefix ((: <http://example.org/>))
-    #       (project (?s ?s2)
-    #         (extend ((?s2 (strlang ?str "en-US")))
-    #           (filter (langMatches (lang ?str) "en")
-    #             (bgp (triple ?s :str ?str))))))
+    # [121] BuiltInCall ::= ... | 'STRLANG' '(' Expression ',' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   SELECT ?s (STRLANG(?str,"en-US") AS ?s2) WHERE {
+    #     ?s :str ?str
+    #     FILTER(LANGMATCHES(LANG(?str), "en"))
+    #   }
+    #
+    # @example SSE
+    #   (prefix ((: <http://example.org/>))
+    #     (project (?s ?s2)
+    #       (extend ((?s2 (strlang ?str "en-US")))
+    #         (filter (langMatches (lang ?str) "en")
+    #           (bgp (triple ?s :str ?str))))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-strlang
     class StrLang < Operator::Binary
@@ -25,10 +34,19 @@ module SPARQL; module Algebra
       #   datatype
       # @return [RDF::Literal] a datatyped literal
       # @see https://www.w3.org/TR/sparql11-query/#func-strlang
-      def apply(value, langTag)
+      def apply(value, langTag, **options)
         raise TypeError, "Literal #{value.inspect} is not simple" unless value.simple?
         RDF::Literal.new(value.to_s, language: langTag.to_s)
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "STRLANG(" + operands.to_sparql(delimiter: ', ', **options) + ")"
+      end
     end # StrLang
   end # Operator
 end; end # SPARQL::Algebra