sparql 3.1.6 → 3.2.1

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

@@ -3,7 +3,15 @@ module SPARQL; module Algebra
     ##
     # The SPARQL ascending sort operator.
     #
-    # @example
+    # [24]  OrderCondition          ::= ( ( 'ASC' | 'DESC' ) BrackettedExpression ) | ( Constraint | Var )
+    #
+    # @example SPARQL Query
+    #   PREFIX foaf:    <http://xmlns.com/foaf/0.1/>
+    #   SELECT ?name
+    #   WHERE { ?x foaf:name ?name }
+    #   ORDER BY ASC(?name)
+    #
+    # @example SSE
     #   (prefix ((foaf: <http://xmlns.com/foaf/0.1/>))
     #     (project (?name)
     #       (order ((asc ?name))
@@ -27,6 +35,17 @@ module SPARQL; module Algebra
       def evaluate(bindings, **options)
         operand(0).evaluate(bindings, depth: options[:depth].to_i + 1, **options)
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # Provides order to descendant query.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "ASC(#{operands.last.to_sparql(**options)})"
+      end
     end # Asc
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -5,7 +5,13 @@ module SPARQL; module Algebra
     #
     # Applications can use the ASK form to test whether or not a query pattern has a solution. No information is returned about the possible query solutions, just whether or not a solution exists.
     #
-    # @example
+    # [12]  AskQuery                ::= 'ASK' DatasetClause* WhereClause ValuesClause
+    #
+    # @example SPARQL Query
+    #   PREFIX :    <http://example/>
+    #   ASK  { :x :p  ?x }
+    #
+    # @example SSE
     #   (prefix ((: <http://example/>))
     #     (ask
     #       (bgp (triple :x :p ?x))))
@@ -41,6 +47,16 @@ module SPARQL; module Algebra
       def query_yields_boolean?
         true
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this term.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "ASK\n" +
+        operands.first.to_sparql(top_level: true, project: nil, **options)
+      end
     end # Ask
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,7 +3,14 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `avg` set function.
     #
-    # @example
+    # [127] Aggregate::= ... | 'AVG' '(' 'DISTINCT'? Expression ')' 
+    #
+    # @example SPARQL Query
+    #   PREFIX : <http://www.example.org/>
+    #   SELECT (AVG(?o) AS ?avg)
+    #   WHERE { ?s :dec ?o }
+    #
+    # @example SSE
     #    (prefix ((: <http://www.example.org/>))
     #      (project (?avg)
     #        (extend ((?avg ??.0))
@@ -29,7 +36,7 @@ module SPARQL; module Algebra
       # @param  [Enumerable<Array<RDF::Term>>] enum
       #   enum of evaluated operand
       # @return [RDF::Literal::Numeric] The numeric average of the terms
-      def apply(enum)
+      def apply(enum, **options)
         # FIXME: we don't actually do anything with distinct
         operands.shift if distinct = (operands.first == :distinct)
         if enum.empty?
@@ -40,6 +47,17 @@ module SPARQL; module Algebra
           raise TypeError, "Averaging non-numeric types: #{enum.flatten}"
         end
       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
+        "AVG(#{'DISTINCT ' if distinct}#{args.to_sparql(**options)})"
+      end
     end # Avg
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,7 +3,13 @@ module SPARQL; module Algebra
     ##
     # The SPARQL GraphPattern `base` operator.
     #
-    # @example
+    # [5]   BaseDecl                ::= 'BASE' IRIREF
+    #
+    # @example SPARQL Grammar
+    #   BASE <http://example.org/>
+    #   SELECT * { <a> <b> 123.0 }
+    #
+    # @example SSE
     #   (base <http://example.org/>
     #     (bgp (triple <a> <b> 123.0)))
     #
@@ -56,6 +62,17 @@ 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)
+        str = "BASE #{operands.first.to_sparql}\n"
+
+        str << operands.last.to_sparql(base_uri: operands.first, **options)
+      end
     end # Base
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -5,10 +5,22 @@ module SPARQL; module Algebra
     #
     # Query with `graph_name` set to false.
     #
-    # @example
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example/>
+    #   SELECT * { ?s ?p ?o }
+    #
+    # @example SSE
     #   (prefix ((: <http://example/>))
     #     (bgp (triple ?s ?p ?o)))
     #
+    # @example SPARQL Grammar (sparql-star)
+    #   PREFIX : <http://example.com/ns#>
+    #   SELECT * {<< :a :b :c >> :p1 :o1.}
+    #
+    # @example SSE (sparql-star)
+    #   (prefix ((: <http://example.com/ns#>))
+    #    (bgp (triple (triple :a :b :c) :p1 :o1)))
+    #
     # @see https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
     class BGP < Operator
       NAME = [:bgp]

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

@@ -5,16 +5,30 @@ module SPARQL; module Algebra
     #
     # The BNODE function constructs a blank node that is distinct from all blank nodes in the dataset being queried and distinct from all blank nodes created by calls to this constructor for other query solutions. If the no argument form is used, every call results in a distinct blank node. If the form with a simple literal is used, every call results in distinct blank nodes for different simple literals, and the same blank node for calls with the same simple literal within expressions for one solution mapping.
     #
-    # @example
-    #     (prefix ((: <http://example.org/>)
-    #              (xsd: <http://www.w3.org/2001/XMLSchema#>))
-    #       (project (?s1 ?s2 ?b1 ?b2)
-    #         (extend ((?b1 (bnode ?s1)) (?b2 (bnode ?s2)))
-    #           (filter (exprlist (|| (= ?a :s1) (= ?a :s3)) (|| (= ?b :s1) (= ?b :s3)))
-    #             (bgp
-    #               (triple ?a :str ?s1)
-    #               (triple ?b :str ?s2)
-    #             )))))
+    # [121] BuiltInCall ::= ... | 'BNODE' ( '(' Expression ')' | NIL ) 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   SELECT ?s1 ?s2 (BNODE(?s1) AS ?b1) (BNODE(?s2) AS ?b2)
+    #   WHERE {
+    #     ?a :str ?s1 .
+    #     ?b :str ?s2 .
+    #     FILTER (?a = :s1 || ?a = :s3)
+    #     FILTER (?b = :s1 || ?b = :s3)
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/>) (xsd: <http://www.w3.org/2001/XMLSchema#>))
+    #    (project (?s1 ?s2 ?b1 ?b2)
+    #     (extend
+    #      ((?b1 (bnode ?s1)) (?b2 (bnode ?s2)))
+    #      (filter
+    #       (exprlist
+    #        (|| (= ?a :s1) (= ?a :s3))
+    #        (|| (= ?b :s1) (= ?b :s3)))
+    #       (bgp (triple ?a :str ?s1) (triple ?b :str ?s2))) )) )
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-bnode
     class BNode < Operator::Unary
@@ -57,7 +71,7 @@ module SPARQL; module Algebra
       #   a query solution containing zero or more variable bindings
       # @return [RDF::Node] 
       # @raise  [TypeError] if the operand is not a simple literal or nil
-      def apply(literal, bindings)
+      def apply(literal, bindings, **options)
         @@bnode_base ||= "b0"
         @@bindings ||= bindings
         @@bnodes ||= {}
@@ -86,6 +100,15 @@ module SPARQL; module Algebra
       def to_sxp_bin
         [NAME] + operands.reject {|o| o == false}
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "BNODE(#{operands.last.to_sparql(**options)})"
+      end
     end # BNode
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,7 +3,19 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `bound` operator.
     #
-    # @example
+    # [121] BuiltInCall ::= ... | 'BOUND' '(' Var ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX  : <http://example.org/ns#>
+    #   SELECT  ?a ?c
+    #   WHERE
+    #       { ?a :b ?c . 
+    #         OPTIONAL
+    #           { ?c :d ?e } . 
+    #         FILTER (! bound(?e)) 
+    #       }
+    #
+    # @example SSE
     #   (prefix ((: <http://example.org/ns#>))
     #     (project (?a ?c)
     #       (filter (! (bound ?e))
@@ -46,6 +58,15 @@ module SPARQL; module Algebra
           else raise TypeError, "expected an RDF::Query::Variable, but got #{var.inspect}"
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "bound(" + operands.first.to_sparql(**options) + ")"
+      end
     end # Bound
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,8 +3,22 @@ module SPARQL; module Algebra
     ##
     # The SPARQL logical `ceil` operator.
     #
-    # @example
-    #   (ceil ?x)
+    # [121] BuiltInCall ::= ... 'CEIL' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   SELECT ?s ?num (CEIL(?num) AS ?ceil) WHERE {
+    #    ?s :num ?num
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/>)
+    #     (xsd: <http://www.w3.org/2001/XMLSchema#>))
+    #    (project (?s ?num ?ceil)
+    #     (extend ((?ceil (ceil ?num)))
+    #      (bgp (triple ?s :num ?num)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-ceil
     # @see https://www.w3.org/TR/xpath-functions/#func-ceil
@@ -20,12 +34,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.ceil
           else raise TypeError, "expected an RDF::Literal::Numeric, but got #{operand.inspect}"
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "CEIL(#{operands.to_sparql(**options)})"
+      end
     end # Ceil
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -6,8 +6,19 @@ module SPARQL; module Algebra
     #
     # The CLEAR operation removes all the triples in the specified graph(s) in the Graph Store.
     #
-    # @example
-    #   (clear silent default)
+    # [32]  Clear                   ::= 'CLEAR' 'SILENT'? GraphRefAll
+    #
+    # @example SPARQL Grammar (SILENT DEFAULT)
+    #   CLEAR SILENT DEFAULT
+    #
+    # @example SSE (SILENT DEFAULT)
+    #   (update (clear silent default))
+    #
+    # @example SPARQL Grammar (IRI)
+    #   CLEAR GRAPH <http://example.com/>
+    #
+    # @example SSE (IRI)
+    #   (update (clear <http://example.com/>))
     #
     # @see https://www.w3.org/TR/sparql11-update/#clear
     class Clear < Operator
@@ -58,6 +69,19 @@ module SPARQL; module Algebra
 
         queryable
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        silent = operands.first == :silent
+        str = "CLEAR "
+        str << "SILENT " if operands.first == :silent
+        str << "GRAPH " if operands.last.is_a?(RDF::URI)
+        str << operands.last.to_sparql(**options)
+      end
     end # Clear
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,17 +3,30 @@ module SPARQL; module Algebra
     ##
     # The SPARQL `coalesce` function.
     #
-    # @example
-    #     (prefix ((: <http://example.org/>)
-    #              (xsd: <http://www.w3.org/2001/XMLSchema#>))
-    #       (project (?cx ?div ?def ?err)
-    #         (extend ((?cx (coalesce ?x -1))
-    #                  (?div (coalesce (/ ?o ?x) -2))
-    #                  (?def (coalesce ?z -3))
-    #                  (?err (coalesce ?z)))
-    #           (leftjoin
-    #             (bgp (triple ?s :p ?o))
-    #             (bgp (triple ?s :q ?x))))))
+    # [121] BuiltInCall ::= ... | 'COALESCE' ExpressionList 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX :        <http://example/>
+    #   PREFIX xsd:     <http://www.w3.org/2001/XMLSchema#>
+    #   
+    #   SELECT ?X (SAMPLE(?v) AS ?S)
+    #   {
+    #     ?s :p ?v .
+    #     OPTIONAL { ?s :q ?w }
+    #   }
+    #   GROUP BY (COALESCE(?w, "1605-11-05"^^xsd:date) AS ?X) 
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example/>) (xsd: <http://www.w3.org/2001/XMLSchema#>))
+    #    (project (?X ?S)
+    #     (extend ((?S ??.0))
+    #      (group
+    #       ((?X (coalesce ?w "1605-11-05"^^xsd:date)))
+    #       ((??.0 (sample ?v)))
+    #       (leftjoin
+    #        (bgp (triple ?s :p ?v))
+    #        (bgp (triple ?s :q ?w)))))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-coalesce
     class Coalesce < Operator
@@ -50,6 +63,15 @@ module SPARQL; module Algebra
         end
         raise TypeError, "None of the operands evaluated"
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "COALESCE(#{operands.to_sparql(delimiter: ', ', **options)})"
+      end
     end # Coalesce
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -30,69 +30,77 @@ module SPARQL; module Algebra
       # @param  [RDF::Literal] right
       #   a literal
       # @return [RDF::Literal::Integer] `-1`, `0`, or `1`
-      # @raise  [TypeError] if either operand is not a literal
-      def apply(left, right)
+      # @raise  [TypeError] if either operand is not a term
+      def apply(left, right, **options)
+        RDF::Literal(spaceship(left, right, **options))
+      end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "(#{operands.first.to_sparql(**options)} #{self.class.const_get(:NAME)} #{operands.last.to_sparql(**options)})"
+      end
+
+    private
+      # Define <=> as private for recursive statements
+      def spaceship(left, right, **options)
         case
         # @see https://www.w3.org/TR/sparql11-query/#OperatorMapping
         # @see https://www.w3.org/TR/sparql11-query/#modOrderBy
         when left.is_a?(RDF::Literal) && right.is_a?(RDF::Literal)
-          case
           # @see https://www.w3.org/TR/xpath-functions/#string-compare
           # @see https://www.w3.org/TR/xpath-functions/#comp.numeric
           # @see https://www.w3.org/TR/xpath-functions/#op.boolean
           # @see https://www.w3.org/TR/xpath-functions/#comp.duration.datetime
-          when (left.simple? && right.simple?) ||
-               (left.is_a?(RDF::Literal::Numeric) && right.is_a?(RDF::Literal::Numeric)) ||
-               (left.datatype == right.datatype && left.language == right.language)
-            RDF::Literal(left.send(self.class.const_get(:NAME), right))
-
-          # A plain literal is lower than an RDF literal with type xsd:string of the same lexical form.
-          when left.simple? && right.datatype == RDF::XSD.string && left.value == right.value
-            RDF::Literal(-1)
-          when right.simple? && left.datatype == RDF::XSD.string && right.value == left.value
-            RDF::Literal(-1)
-
-          else
-            left <=> right
-          end
-          
+          left <=> right
         when left.is_a?(RDF::URI) && right.is_a?(RDF::URI)
+          raise TypeError, "Comparing IRIs not supported" unless options[:order_by] || left == right
           # Pairs of IRIs are ordered by comparing them as simple literals.
-          RDF::Literal(RDF::Literal(left.to_s).send(self.class.const_get(:NAME), RDF::Literal(right.to_s)))
+          left.to_s <=> right.to_s
         when left.is_a?(RDF::Node) && right.is_a?(RDF::Node)
+          raise TypeError, "Comparing Blank nodes not supported" unless options[:order_by] || left == right
           # BNode comparison is undefined.
-          RDF::Literal(0)
-        when left.is_a?(RDF::Statement) && right.is_a?(RDF::Statement)
-          RDF::Literal(RDF::Literal(left.to_s).send(self.class.const_get(:NAME), RDF::Literal(right.to_s)))
+          left == right ? 0 : 1
         when left.nil? && right.nil?
-          RDF::Literal(0)
-        
+          0
+
+        when left.is_a?(RDF::Statement) && right.is_a?(RDF::Statement)
+          v = spaceship(left.subject, right.subject, **options)
+          v = spaceship(left.predicate, right.predicate, **options) if v == 0
+          v = spaceship(left.object, right.object, **options) if v == 0
+          v
+        when left.is_a?(RDF::Statement) && right.is_a?(RDF::Term)
+          raise TypeError, "Comparing statement with #{right.inspect}" unless options[:order_by]
+          1
+        when right.is_a?(RDF::Statement) && left.is_a?(RDF::Term)
+          raise TypeError, "Comparing statement with #{left.inspect}" unless options[:order_by]
+          -1
+
         # SPARQL also fixes an order between some kinds of RDF terms that would not otherwise be ordered:
 
         when left.nil? && !right.nil?
-          RDF::Literal(-1)
+          -1
         when right.nil?
-          RDF::Literal(1)
+          1
 
         when left.is_a?(RDF::Node) && right.is_a?(RDF::Term)
-          RDF::Literal(-1)
+          raise TypeError, "Comparing Blank nodes not supported" unless options[:order_by]
+          # Nodes lower than other terms
+          -1
         when right.is_a?(RDF::Node) && left.is_a?(RDF::Term)
-          RDF::Literal(1)
-
-        when left.is_a?(RDF::Statement) && right.is_a?(RDF::Term)
-          RDF::Literal(-1)
-        when right.is_a?(RDF::Statement) && left.is_a?(RDF::Term)
-          RDF::Literal(1)
-
-        when left.is_a?(RDF::Node) && right.is_a?(RDF::URI)
-          RDF::Literal(-1)
-        when right.is_a?(RDF::Node) && left.is_a?(RDF::URI)
-          RDF::Literal(1)
+          raise TypeError, "Comparing Blank nodes not supported" unless options[:order_by]
+          1
 
         when left.is_a?(RDF::URI) && right.is_a?(RDF::Term)
-          RDF::Literal(-1)
+          raise TypeError, "Comparing IRIs not supported" unless options[:order_by]
+          # IRIs lower than terms other than nodes
+          -1
         when right.is_a?(RDF::URI) && left.is_a?(RDF::Term)
-          RDF::Literal(1)
+          raise TypeError, "Comparing IRIs not supported" unless options[:order_by]
+          1
         else raise TypeError, "expected two RDF::Term operands, but got #{left.inspect} and #{right.inspect}"
         end
       end

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

@@ -5,8 +5,23 @@ module SPARQL; module Algebra
     #
     # The CONCAT function corresponds to the XPath fn:concat function. The function accepts string literals as arguments.
     #
-    # @example
-    #   (concat ?a ?b ...)
+    # [121] BuiltInCall ::= ... 'CONCAT' ExpressionList 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   SELECT (CONCAT(?str1,?str2) AS ?str) WHERE {
+    #     :s6 :str ?str1 .
+    #     :s7 :str ?str2 .
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/>))
+    #    (project (?str)
+    #     (extend ((?str (concat ?str1 ?str2)))
+    #      (bgp
+    #       (triple :s6 :str ?str1)
+    #       (triple :s7 :str ?str2)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-concat
     # @see https://www.w3.org/TR/xpath-functions/#func-concat
@@ -48,6 +63,15 @@ module SPARQL; module Algebra
           end
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "CONCAT(#{operands.to_sparql(delimiter: ', ', **options)})"
+      end
     end # Concat
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -5,12 +5,22 @@ module SPARQL; module Algebra
     #
     # The CONSTRUCT query form returns a single RDF graph specified by a graph template. The result is an RDF graph formed by taking each query solution in the solution sequence, substituting for the variables in the graph template, and combining the triples into a single RDF graph by set union.
     #
-    # @example
-    #   (prefix ((rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>)
-    #            (foaf: <http://xmlns.com/foaf/0.1/>))
-    #     (construct ((triple ?s ?p ?o))
-    #       (project (?s ?p ?o)
-    #         (bgp (triple ?s ?p ?o)))))
+    # [10]  ConstructQuery          ::= 'CONSTRUCT' ( ConstructTemplate DatasetClause* WhereClause SolutionModifier | DatasetClause* 'WHERE' '{' TriplesTemplate? '}' SolutionModifier ) ValuesClause
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example/> 
+    #   CONSTRUCT { ?x :p2 ?v }
+    #   WHERE {
+    #     ?x :p ?o .
+    #     OPTIONAL {?o :q ?v }
+    #   }
+    #
+    # @example SSE
+    #   (prefix ((: <http://example/>))
+    #    (construct ((triple ?x :p2 ?v))
+    #     (leftjoin
+    #      (bgp (triple ?x :p ?o))
+    #      (bgp (triple ?o :q ?v)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#construct
     class Construct < Operator::Binary
@@ -81,6 +91,19 @@ module SPARQL; module Algebra
       def query_yields_statements?
         true
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this term.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        str = "CONSTRUCT {\n" +
+        operands[0].map { |e| e.to_sparql(as_statement: true, top_level: false, **options) }.join(". \n") +
+        "\n}\n"
+
+        str << operands[1].to_sparql(top_level: true, project: nil, **options)
+      end
     end # Construct
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,8 +3,21 @@ module SPARQL; module Algebra
     ##
     # A SPARQL `contains` operator.
     #
-    # @example
-    #   (contains ?x ?y)
+    # [121] BuiltInCall ::= ... | 'CONTAINS' '(' Expression ',' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   SELECT ?s ?str WHERE {
+    #     ?s :str ?str
+    #     FILTER CONTAINS(?str, "a")
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/>))
+    #    (project (?s ?str)
+    #     (filter (contains ?str "a")
+    #      (bgp (triple ?s :str ?str)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-contains
     # @see https://www.w3.org/TR/xpath-functions/#func-contains
@@ -31,7 +44,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}"
@@ -39,6 +52,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)
+        "contains(" + operands.to_sparql(delimiter: ', ', **options) + ")"
+      end
     end # Contains
   end # Operator
 end; end # SPARQL::Algebra