sparql 3.1.8 → 3.2.0

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

@@ -6,8 +6,19 @@ module SPARQL; module Algebra
     #
     # The DELETE WHERE operation is a shortcut form for the DELETE/INSERT operation where bindings matched by the WHERE clause are used to define the triples in a graph that will be deleted.
     #
-    # @example
-    #   (deleteWhere ((triple :a foaf:knows ?b))
+    # [40]  DeleteWhere             ::= 'DELETE WHERE' QuadPattern
+    #
+    # @example SPARQL Grammar
+    #   PREFIX     : <http://example.org/> 
+    #   PREFIX foaf: <http://xmlns.com/foaf/0.1/> 
+    #   DELETE WHERE { :a foaf:knows ?b }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/>)
+    #     (foaf: <http://xmlns.com/foaf/0.1/>))
+    #    (update
+    #     (deleteWhere ((triple :a foaf:knows ?b)))))
     #
     # @see https://www.w3.org/TR/sparql11-update/#deleteWhere
     class DeleteWhere < Operator::Unary
@@ -52,6 +63,17 @@ module SPARQL; module Algebra
         end
         queryable
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this term.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "DELETE WHERE {\n" +
+          operands.first.to_sparql(as_statement: true, top_level: false, delimiter: "\n", **options) +
+          "\n}"
+      end
     end # DeleteWhere
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,7 +3,15 @@ module SPARQL; module Algebra
     ##
     # The SPARQL descending sort operator.
     #
-    # @example
+    # [24]  OrderCondition          ::= ( ( 'ASC' | 'DESC' ) BrackettedExpression ) | ( Constraint | Var )
+    #
+    # @example SPARQL Grammar
+    #   PREFIX foaf:    <http://xmlns.com/foaf/0.1/>
+    #   SELECT ?name
+    #   WHERE { ?x foaf:name ?name }
+    #   ORDER BY DESC(?name)
+    #
+    # @example SSE
     #   (prefix ((foaf: <http://xmlns.com/foaf/0.1/>))
     #     (project (?name)
     #       (order ((desc ?name))
@@ -12,6 +20,17 @@ module SPARQL; module Algebra
     # @see https://www.w3.org/TR/sparql11-query/#modOrderBy
     class Desc < Operator::Asc
       NAME = :desc
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # Provides order to descendant query.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "DESC(#{operands.last.to_sparql(**options)})"
+      end
     end # Desc
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -5,10 +5,16 @@ module SPARQL; module Algebra
     #
     # Generages a graph across specified terms using {RDF::Queryable}`#concise_bounded_description`.
     #
-    # @example
-    #   (prefix ((exOrg: <http://org.example.com/employees#>))
-    #     (describe (?x)
-    #       (bgp (triple ?x exOrg:employeeId "1234"))))
+    # [11]  DescribeQuery           ::= 'DESCRIBE' ( VarOrIri+ | '*' ) DatasetClause* WhereClause? SolutionModifier ValuesClause
+    #
+    # @example SPARQL Grammar
+    #   BASE <http://example.org/>
+    #   DESCRIBE <u> ?u WHERE { <x> <q> ?u . }
+    #
+    # @example SSE
+    #   (base <http://example.org/>
+    #    (describe (<u> ?u)
+    #     (bgp (triple <x> <q> ?u))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#describe
     class Describe < Operator::Binary
@@ -66,6 +72,23 @@ 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 = "DESCRIBE "
+        str << if operands[0].empty?
+          "*"
+        else
+          operands[0].map { |e| e.to_sparql(**options) }.join(" ")
+        end
+
+        str << "\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/distinct.rb

@@ -3,7 +3,15 @@ module SPARQL; module Algebra
     ##
     # The SPARQL GraphPattern `distinct` operator.
     #
-    # @example
+    # [9] SelectClause ::= 'SELECT' ( 'DISTINCT' | 'REDUCED' )? ( ( Var | ( '(' Expression 'AS' Var ')' ) )+ | '*' )
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   SELECT DISTINCT ?v
+    #   WHERE { ?x ?p ?v }
+    #
+    # @example SSE
     #   (prefix ((xsd: <http://www.w3.org/2001/XMLSchema#>)
     #            (: <http://example/>))
     #     (distinct
@@ -36,6 +44,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.first.to_sparql(distinct: true, **options)
+      end
     end # Distinct
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,8 +3,23 @@ module SPARQL; module Algebra
     ##
     # The SPARQL numeric `divide` operator.
     #
-    # @example
-    #   (/ 4 2)
+    # [117] MultiplicativeExpression::= UnaryExpression ( '*' UnaryExpression | '/' UnaryExpression )*
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   SELECT ?s WHERE {
+    #     ?s :p ?o .
+    #     ?s2 :p ?o2 .
+    #     FILTER(?o / ?o2 = 4) .
+    #   }
+    #
+    # @example SSE
+    #   (prefix ((: <http://example.org/>))
+    #    (project (?s)
+    #     (filter (= (/ ?o ?o2) 4)
+    #      (bgp
+    #       (triple ?s :p ?o)
+    #       (triple ?s2 :p ?o2)))))
     #
     # @see https://www.w3.org/TR/xpath-functions/#func-numeric-divide
     class Divide < Operator::Binary
@@ -38,6 +53,15 @@ module SPARQL; module Algebra
           else raise TypeError, "expected two RDF::Literal::Numeric operands, but got #{left.inspect} and #{right.inspect}"
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "#{operands.first.to_sparql(**options)} / #{operands.last.to_sparql(**options)}"
+      end
     end # Divide
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -8,8 +8,14 @@ module SPARQL; module Algebra
     #
     # Equivalent to `clear` in this implementation
     #
-    # @example
-    #   (drop default)
+    # [33]  Drop                    ::= 'DROP' 'SILENT'? GraphRefAll
+    #
+    # @example SPARQL Grammar
+    #   DROP DEFAULT
+    #
+    # @example SSE
+    #   (update
+    #    (drop default))
     #
     # @see https://www.w3.org/TR/sparql11-update/#drop
     class Drop < Operator
@@ -61,6 +67,15 @@ module SPARQL; module Algebra
 
         queryable
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "DROP " + operands.to_sparql(**options)
+      end
     end # Drop
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -5,8 +5,21 @@ module SPARQL; module Algebra
     ##
     # The SPARQL logical `abs` operator.
     #
-    # @example
-    #   (encode_for_uri ?x)
+    # [121] BuiltInCall ::= ... | 'ENCODE_FOR_URI' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   SELECT ?s ?str (ENCODE_FOR_URI(?str) AS ?encoded) WHERE {
+    #     ?s :str ?str
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/>))
+    #    (project (?str ?encoded)
+    #     (extend ((?encoded (encode_for_uri ?str)))
+    #      (bgp (triple ?s :str ?str)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-encode
     # @see https://www.w3.org/TR/xpath-functions/#func-abs
@@ -33,6 +46,15 @@ module SPARQL; module Algebra
           else raise TypeError, "expected an RDF::Literal, but got #{operand.inspect}"
         end
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "ENCODE_FOR_URI(#{operands.last.to_sparql(**options)})"
+      end
     end # EncodeForURI
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,8 +3,18 @@ module SPARQL; module Algebra
     ##
     # The SPARQL relational `=` (equal) comparison operator.
     #
-    # @example
-    #   (= ?x ?y)
+    # [114] RelationalExpression    ::= NumericExpression ('=' NumericExpression)?
+    #
+    # @example SPARQL Grammar
+    #   PREFIX  xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   PREFIX  : <http://example.org/things#>
+    #   SELECT  ?x
+    #   WHERE { ?x :p ?v . FILTER ( ?v = 1 ) }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((xsd: <http://www.w3.org/2001/XMLSchema#>) (: <http://example.org/things#>))
+    #    (project (?x) (filter (= ?v 1) (bgp (triple ?x :p ?v)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#OperatorMapping
     # @see https://www.w3.org/TR/sparql11-query/#func-RDFterm-equal

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

@@ -5,10 +5,21 @@ module SPARQL; module Algebra
     #
     # There is a filter operator EXISTS that takes a graph pattern. EXISTS returns `true`/`false` depending on whether the pattern matches the dataset given the bindings in the current group graph pattern, the dataset and the active graph at this point in the query evaluation. No additional binding of variables occurs. The `NOT EXISTS` form translates into `fn:not(EXISTS{...})`.
     #
-    # @example
-    #    (prefix ((ex: <http://www.example.org/>))
-    #      (filter (exists (bgp (triple ?s ?p ex:o)))
-    #      (bgp (triple ?s ?p ?o))))
+    # [125] ExistsFunc              ::= 'EXISTS' GroupGraphPattern
+    #
+    # @example SPARQL Grammar
+    #   PREFIX :    <http://example/>
+    #   SELECT *
+    #   WHERE {
+    #     ?set a :Set .
+    #     FILTER EXISTS { ?set :member 9 }
+    #   }
+    #
+    # @example SSE
+    #   (prefix ((: <http://example/>))
+    #    (filter
+    #     (exists (bgp (triple ?set :member 9)))
+    #     (bgp (triple ?set a :Set))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-filter-exists
     class Exists < Operator::Unary
@@ -32,6 +43,19 @@ module SPARQL; module Algebra
                                        depth: options[:depth].to_i + 1,
                                        **options).empty?
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @param [Boolean] top_level (true)
+      #   Treat this as a top-level, generating SELECT ... WHERE {}
+      # @return [String]
+      def to_sparql(top_level: true, **options)
+        "EXISTS {\n" +
+          operands.last.to_sparql(top_level: false, **options) +
+          "\n}"
+      end
     end # Exists
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -5,7 +5,18 @@ module SPARQL; module Algebra
     #
     # Used for filters with more than one expression.
     #
-    # @example
+    # [72]  ExpressionList ::= NIL | '(' Expression ( ',' Expression )* ')'
+    #
+    # @example SPARQL Grammar
+    #   SELECT ?v ?w
+    #   { 
+    #     FILTER (?v = 2)
+    #     FILTER (?w = 3)
+    #     ?s :p ?v . 
+    #     ?s :q ?w .
+    #   }
+    #
+    # @example SSE
     #   (prefix ((: <http://example/>))
     #     (project (?v ?w)
     #       (filter (exprlist (= ?v 2) (= ?w 3))

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

@@ -5,11 +5,19 @@ module SPARQL; module Algebra
     #
     # Extends a solution
     #
-    # @example
-    #   (select (?z)
-    #     (project (?z)
-    #       (extend ((?z (+ ?o 10)))
-    #         (bgp (triple ?s <http://example/p> ?o)))))
+    # [60]  Bind ::= 'BIND' '(' Expression 'AS' Var ')'
+    #
+    # @example SPARQL Grammar
+    #   SELECT ?z
+    #   { 
+    #     ?x <http://example/p> ?o
+    #     BIND(?o+1 AS ?z)
+    #   }
+    #
+    # @example SSE
+    #   (project (?z)
+    #     (extend ((?z (+ ?o 10)))
+    #       (bgp (triple ?s <http://example/p> ?o))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#evaluation
     class Extend < Operator::Binary
@@ -73,6 +81,23 @@ module SPARQL; module Algebra
         end
         super
       end
-    end # Filter
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # Extracts bindings.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        extensions = operands.first.inject({}) do |memo, (as, expression)|
+          memo.merge(as => expression)
+        end
+
+        # Merge any inherited extensions from options
+        extensions = options.delete(:extensions).merge(extensions) if options.key?(:extensions)
+        operands.last.to_sparql(extensions: extensions, **options)
+      end
+    end # Extend
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,11 +3,19 @@ module SPARQL; module Algebra
     ##
     # The SPARQL GraphPattern `filter` operator.
     #
-    # @example
-    #   (select (?v)
-    #     (project (?v)
-    #       (filter (= ?v 2)
-    #         (bgp (triple ?s <http://example/p> ?v)))))
+    # [68]  Filter ::= 'FILTER' Constraint
+    #
+    # @example SPARQL Grammar
+    #   SELECT ?v
+    #   { 
+    #     ?s <http://example/p> ?v
+    #     FILTER(?v = 2)
+    #   }
+    #
+    # @example SSE
+    #    (project (?v)
+    #      (filter (= ?v 2)
+    #        (bgp (triple ?s <http://example/p> ?v))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#evaluation
     class Filter < Operator::Binary
@@ -69,6 +77,20 @@ module SPARQL; module Algebra
         end
         self
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # Provides filters to descendant query.
+      #
+      # If filter operation is an Exprlist, then separate into multiple filter ops.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        filter_ops = operands.first.is_a?(Operator::Exprlist) ? operands.first.operands : [operands.first]
+        operands.last.to_sparql(filter_ops: filter_ops, **options)
+      end
     end # Filter
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -3,8 +3,22 @@ module SPARQL; module Algebra
     ##
     # The SPARQL logical `floor` operator.
     #
-    # @example
-    #   (floor ?x)
+    # [121] BuiltInCall ::= ... 'FLOOR' '(' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.org/>
+    #   PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   SELECT ?s ?num (FLOOR(?num) AS ?floor) WHERE {
+    #    ?s :num ?num
+    #   }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://example.org/>)
+    #     (xsd: <http://www.w3.org/2001/XMLSchema#>))
+    #    (project (?s ?num ?floor)
+    #     (extend ((?floor (floor ?num)))
+    #      (bgp (triple ?s :num ?num)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#func-floor
     # @see https://www.w3.org/TR/xpath-functions/#func-floor
@@ -30,6 +44,15 @@ module SPARQL; module Algebra
           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)
+        "FLOOR(#{operands.to_sparql(**options)})"
+      end
     end # Floor
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -5,6 +5,19 @@ module SPARQL; module Algebra
     #
     # This is a wrapper to add a `graph_name` to the query, or an array of statements.
     #
+    # [58]  GraphGraphPattern       ::= 'GRAPH' VarOrIri GroupGraphPattern
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example/> 
+    #   SELECT * { 
+    #       GRAPH ?g { ?s ?p ?o }
+    #   }
+    #
+    # @example SSE
+    #   (prefix ((: <http://example/>))
+    #    (graph ?g
+    #     (bgp (triple ?s ?p ?o))))
+    #
     # @example of a query
     #   (prefix ((: <http://example/>))
     #     (graph ?g

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

@@ -3,8 +3,18 @@ module SPARQL; module Algebra
     ##
     # The SPARQL relational `>` (greater than) comparison operator.
     #
-    # @example
-    #   (> ?x ?y)
+    # [114] RelationalExpression    ::= NumericExpression ('>' NumericExpression)?
+    #
+    # @example SPARQL Grammar
+    #   PREFIX  xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   PREFIX  : <http://example.org/things#>
+    #   SELECT  ?x
+    #   WHERE { ?x :p ?v . FILTER ( ?v > 1 ) }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((xsd: <http://www.w3.org/2001/XMLSchema#>) (: <http://example.org/things#>))
+    #    (project (?x) (filter (> ?v 1) (bgp (triple ?x :p ?v)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#OperatorMapping
     # @see https://www.w3.org/TR/xpath-functions/#func-compare
@@ -25,7 +35,6 @@ module SPARQL; module Algebra
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if either operand is not a literal
       def apply(left, right, **options)
-        #require 'byebug'; byebug if super == RDF::Literal(1)
         RDF::Literal(super == RDF::Literal(1))
       end
     end # GreaterThan

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

@@ -4,8 +4,18 @@ module SPARQL; module Algebra
     # The SPARQL relational `>=` (greater than or equal) comparison
     # operator.
     #
-    # @example
-    #   (>= ?x ?y)
+    # [114] RelationalExpression    ::= NumericExpression ('>=' NumericExpression)?
+    #
+    # @example SPARQL Grammar
+    #   PREFIX  xsd: <http://www.w3.org/2001/XMLSchema#>
+    #   PREFIX  : <http://example.org/things#>
+    #   SELECT  ?x
+    #   WHERE { ?x :p ?v . FILTER ( ?v >= 1 ) }
+    #
+    # @example SSE
+    #   (prefix
+    #    ((xsd: <http://www.w3.org/2001/XMLSchema#>) (: <http://example.org/things#>))
+    #    (project (?x) (filter (>= ?v 1) (bgp (triple ?x :p ?v)))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#OperatorMapping
     # @see https://www.w3.org/TR/xpath-functions/#func-compare

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

@@ -8,14 +8,22 @@ module SPARQL; module Algebra
     # query to be grouped. If three operands are provided,
     # the second is an array of temporary bindings.
     #
-    # @example
-    #     (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)))))))
+    # [19]  GroupClause             ::= 'GROUP' 'BY' GroupCondition+
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://www.example.org>
+    #   
+    #   SELECT ?P (COUNT(?O) AS ?C)
+    #   WHERE { ?S ?P ?O }
+    #   GROUP BY ?P
+    #
+    # @example SSE
+    #   (prefix
+    #    ((: <http://www.example.org>))
+    #    (project (?P ?C)
+    #     (extend ((?C ??.0))
+    #      (group (?P) ((??.0 (count ?O)))
+    #       (bgp (triple ?S ?P ?O))))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
     class Group < Operator
@@ -122,6 +130,24 @@ module SPARQL; module Algebra
         end
         super
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @param [Hash{Symbol => Operator}] extensions
+      #   Variable bindings
+      # @return [String]
+      def to_sparql(extensions: {}, **options)
+        if operands.length > 2
+          # Replace extensions from temporary bindings
+          operands[1].each do |var, op|
+            ext_var = extensions.invert.fetch(var)
+            extensions[ext_var] = op
+          end
+        end
+        operands.last.to_sparql(extensions: extensions, group_ops: operands.first, **options)
+      end
     end # Group
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -5,13 +5,16 @@ 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))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#defn_aggGroupConcat
     class GroupConcat < Operator
@@ -53,6 +56,15 @@ module SPARQL; module Algebra
       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)
+        "GROUP_CONCAT(#{operands.to_sparql(delimiter: ', ', **options)})"
+      end
     end # GroupConcat
   end # Operator
 end; end # SPARQL::Algebra