sparql 3.1.6 → 3.2.1

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

@@ -5,13 +5,34 @@ module SPARQL; module Algebra
     #
     # GroupConcat is a set function which performs a string concatenation across the values of an expression with a group. The order of the strings is not specified. The separator character used in the concatenation may be given with the scalar argument SEPARATOR.
     #
-    # @example
-    #    (prefix ((: <http://www.example.org/>))
-    #      (filter (|| (= ?g "1 22") (= ?g "22 1"))
-    #        (project (?g)
-    #          (extend ((?g ??.0))
-    #            (group () ((??.0 (group_concat ?o)))
-    #              (bgp (triple ??.0 :p1 ?o)))))))
+    # [127] Aggregate::= ... | 'GROUP_CONCAT' '(' 'DISTINCT'? Expression ( ';' 'SEPARATOR' '=' String )? ')'
+    #
+    # @example SPARQL Grammar
+    #   SELECT (GROUP_CONCAT(?x) AS ?y) {}
+    #
+    # @example SSE
+    #   (project (?y)
+    #    (extend ((?y ??.0))
+    #     (group () ((??.0 (group_concat ?x)))
+    #      (bgp))))
+    #
+    # @example SPARQL Grammar (DISTINCT)
+    #   SELECT (GROUP_CONCAT(DISTINCT ?x) AS ?y) {}
+    #
+    # @example SSE (DISTINCT)
+    #   (project (?y)
+    #    (extend ((?y ??.0))
+    #     (group () ((??.0 (group_concat distinct ?x)))
+    #      (bgp))))
+    #
+    # @example SPARQL Grammar (SEPARATOR)
+    #   SELECT (GROUP_CONCAT(?x; SEPARATOR=';') AS ?y) {}
+    #
+    # @example SSE (SEPARATOR)
+    #   (project (?y)
+    #    (extend ((?y ??.0))
+    #     (group () ((??.0 (group_concat (separator ";") ?x)))
+    #      (bgp))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#defn_aggGroupConcat
     class GroupConcat < Operator
@@ -50,9 +71,24 @@ module SPARQL; module Algebra
       #   enum of evaluated operand
       # @return [RDF::Term] An arbitrary term
       # @raise  [TypeError] If enum is empty
-      def apply(enum, separator)
+      def apply(enum, separator, **options)
         RDF::Literal(enum.flatten.map(&:to_s).join(separator.to_s))
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        distinct = operands.first == :distinct
+        args = distinct ? operands[1..-1] : operands
+        separator = args.first.last if args.first.is_a?(Array) && args.first.first == :separator
+        args = args[1..-1] if separator
+        str = "GROUP_CONCAT(#{'DISTINCT ' if distinct}#{args.to_sparql(delimiter: ', ', **options)}"
+        str << "; SEPARATOR=#{separator.to_sparql}" if separator
+        str << ")"
+      end
     end # GroupConcat
   end # Operator
 end; end # SPARQL::Algebra

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
@@ -22,10 +31,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.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,8 +45,17 @@ 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
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "IF(" + operands.to_sparql(delimiter: ', ', **options) + ")"
       end
     end # If
   end # Operator

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,17 @@ 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, delimiter: " .\n", **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
@@ -29,12 +37,21 @@ module SPARQL; module Algebra
       #   a simple literal
       # @return [RDF::URI]
       # @raise  [TypeError] if the operand is not a simple literal
-      def apply(literal)
+      def apply(literal, **options)
         raise TypeError, "expected an simple literal, but got #{literal.inspect}" unless literal.literal? && literal.simple?
         base = Operator.base_uri || RDF::URI("")
         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,9 +3,17 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `isBlank` operator.
     #
-    # @example
-    #   (prefix ((xsd: <http://www.w3.org/2001/XMLSchema#>)
-    #            (: <http://example.org/things#>))
+    # [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 ((: <http://example.org/things#>))
     #     (project (?x ?v)
     #       (filter (isBlank ?v)
     #         (bgp (triple ?x :p ?v)))))
@@ -23,13 +31,22 @@ module SPARQL; module Algebra
       #   an RDF term
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if the operand is not an RDF term
-      def apply(term)
+      def apply(term, **options)
         case term
           when RDF::Node then RDF::Literal::TRUE
           when RDF::Term then RDF::Literal::FALSE
           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,9 +3,17 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `isIRI`/`isURI` operator.
     #
-    # @example
-    #   (prefix ((xsd: <http://www.w3.org/2001/XMLSchema#>)
-    #            (: <http://example.org/things#>))
+    # [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 ((: <http://example.org/things#>))
     #     (project (?x ?v)
     #       (filter (isIRI ?v)
     #         (bgp (triple ?x :p ?v)))))
@@ -23,7 +31,7 @@ module SPARQL; module Algebra
       #   an RDF term
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if the operand is not an RDF term
-      def apply(term)
+      def apply(term, **options)
         case term
           when RDF::URI  then RDF::Literal::TRUE
           when RDF::Term then RDF::Literal::FALSE
@@ -32,6 +40,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,9 +3,17 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `isLiteral` operator.
     #
-    # @example
-    #   (prefix ((xsd: <http://www.w3.org/2001/XMLSchema#>)
-    #            (: <http://example.org/things#>))
+    # [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 ((: <http://example.org/things#>))
     #     (project (?x ?v)
     #       (filter (isLiteral ?v)
     #         (bgp (triple ?x :p ?v)))))
@@ -24,13 +32,22 @@ module SPARQL; module Algebra
       #   an RDF term
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if the operand is not an RDF term
-      def apply(term)
+      def apply(term, **options)
         case term
           when RDF::Literal then RDF::Literal::TRUE
           when RDF::Term    then RDF::Literal::FALSE
           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,11 +3,19 @@ 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
-    #   (prefix ((xsd: <http://www.w3.org/2001/XMLSchema#>)
-    #            (: <http://example.org/things#>))
+    # [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 ((: <http://example.org/things#>))
     #     (project (?x ?v)
     #       (filter (isNumeric ?v)
     #         (bgp (triple ?x :p ?v)))))
@@ -16,7 +24,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`
@@ -26,7 +34,7 @@ module SPARQL; module Algebra
       #   an RDF term
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if the operand is not an RDF term
-      def apply(term)
+      def apply(term, **options)
         case term
           when RDF::Literal::NonPositiveInteger then RDF::Literal::FALSE
           when RDF::Literal::NonNegativeInteger then RDF::Literal::FALSE
@@ -36,6 +44,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
@@ -18,13 +41,22 @@ module SPARQL; module Algebra
       #   an RDF term
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if the operand is not an RDF term
-      def apply(term)
+      def apply(term, **options)
         case term
           when RDF::Statement  then RDF::Literal::TRUE
           when RDF::Term then RDF::Literal::FALSE
           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,13 +3,38 @@ 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))
     #       (graph ?g
     #         (bgp (triple ?s ?q ?v)))))
     #
+    # @example SPARQL Grammar (inline filter)
+    #   PREFIX : <http://xmlns.com/foaf/0.1/>
+    #   ASK {
+    #     :who :homepage ?homepage 
+    #     FILTER REGEX(?homepage, "^http://example.org/") 
+    #     :who :schoolHomepage ?schoolPage
+    #   }
+    # 
+    # @example SSE (inline filter)
+    #   (prefix ((: <http://xmlns.com/foaf/0.1/>))
+    #    (ask
+    #     (filter (regex ?homepage "^http://example.org/")
+    #      (join
+    #       (bgp (triple :who :homepage ?homepage))
+    #       (bgp (triple :who :schoolHomepage ?schoolPage))))))
+    #
     # @see https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
     class Join < Operator::Binary
       include Query
@@ -82,6 +107,36 @@ 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 {}
+      # @param [Hash{Symbol => Operator}] extensions
+      #   Variable bindings
+      # @param [Array<Operator>] filter_ops ([])
+      #   Filter Operations
+      # @return [String]
+      def to_sparql(top_level: true, filter_ops: [], extensions: {}, **options)
+        # If this is top-level, and the last operand is a Table (values), put the values at the outer-level
+        str = "{\n" + operands.first.to_sparql(top_level: false, extensions: {}, **options)
+
+        # Any accrued filters go here.
+        filter_ops.each do |op|
+          str << "\nFILTER (#{op.to_sparql(**options)}) ."
+        end
+
+        if top_level && operands.last.is_a?(Table)
+          str << "\n}"
+          options = options.merge(values_clause: operands.last)
+        else
+          str << "\n{\n" + operands.last.to_sparql(top_level: false, extensions: {}, **options) + "\n}\n}"
+        end
+
+        top_level ? Operator.to_sparql(str, extensions: extensions, **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
@@ -18,12 +34,21 @@ module SPARQL; module Algebra
       #   a literal
       # @return [RDF::Literal] a simple literal
       # @raise  [TypeError] if the operand is not a literal
-      def apply(literal)
+      def apply(literal, **options)
         case literal
           when RDF::Literal then RDF::Literal(literal.language.to_s)
           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