sparql 3.2.0 → 3.2.1

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

@@ -17,6 +17,50 @@ module SPARQL; module Algebra
     #       (order ((asc ?name))
     #         (bgp (triple ?x foaf:name ?name)))))
     #
+    # @example SPARQL Grammar (with builtin)
+    #   PREFIX : <http://example.org/>
+    #   SELECT ?s WHERE {
+    #     ?s :p ?o .
+    #   }
+    #   ORDER BY str(?o)
+    #
+    # @example SSE (with builtin)
+    #   (prefix ((: <http://example.org/>))
+    #    (project (?s)
+    #     (order ((str ?o))
+    #      (bgp (triple ?s :p ?o)))))
+    #
+    # @example SPARQL Grammar (with bracketed expression)
+    #   PREFIX : <http://example.org/>
+    #   SELECT ?s WHERE {
+    #     ?s :p ?o1 ; :q ?o2 .
+    #   } ORDER BY (?o1 + ?o2)
+    #
+    # @example SSE (with bracketed expression)
+    #   (prefix
+    #    ((: <http://example.org/>))
+    #    (project (?s)
+    #     (order ((+ ?o1 ?o2))
+    #      (bgp
+    #       (triple ?s :p ?o1)
+    #       (triple ?s :q ?o2)))))
+    #
+    # @example SPARQL Grammar (with function call)
+    #   PREFIX :      <http://example.org/ns#>
+    #   PREFIX xsd:   <http://www.w3.org/2001/XMLSchema#>
+    #   SELECT *
+    #   { ?s ?p ?o }
+    #   ORDER BY 
+    #     DESC(?o+57) xsd:string(?o) ASC(?s)
+    #
+    # @example SSE (with function call)
+    #   (prefix ((: <http://example.org/ns#>)
+    #            (xsd: <http://www.w3.org/2001/XMLSchema#>))
+    #    (order ((desc (+ ?o 57))
+    #            (xsd:string ?o)
+    #            (asc ?s))
+    #     (bgp (triple ?s ?p ?o))))
+    #
     # @see https://www.w3.org/TR/sparql11-query/#modOrderBy
     class Order < Operator::Binary
       include Query

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

@@ -69,7 +69,7 @@ module SPARQL; module Algebra
       #
       # @return [String]
       def to_sparql(**options)
-        "#{operands.first.to_sparql(**options)} + #{operands.last.to_sparql(**options)}"
+        "(#{operands.first.to_sparql(**options)} + #{operands.last.to_sparql(**options)})"
       end
     end # Plus
   end # Operator

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

@@ -20,20 +20,37 @@ module SPARQL; module Algebra
     #     (filter (= ?v 2)
     #      (bgp (triple ?s :p ?v)))))
     #
-    # ## Sub select
-    #
-    # @example SPARQL Grammar
+    # @example SPARQL Grammar (Sub select)
     #   SELECT (1 AS ?X ) {
     #     SELECT (2 AS ?Y ) {}
     #   }
     #
-    # @example SSE
+    # @example SSE (Sub select)
     #   (project (?X)
     #    (extend ((?X 1))
     #     (project (?Y)
     #      (extend ((?Y 2))
     #       (bgp)))))
     #
+    # @example SPARQL Grammar (filter projection)
+    #   PREFIX : <http://www.example.org/>
+    #   ASK {
+    #     {SELECT (GROUP_CONCAT(?o) AS ?g) WHERE {
+    #      :a :p1 ?o
+    #     }}
+    #     FILTER(?g = "1 22" || ?g = "22 1")
+    #   }
+    #
+    # @example SSE (filter projection)
+    #   (prefix ((: <http://www.example.org/>))
+    #    (ask
+    #     (filter
+    #      (|| (= ?g "1 22") (= ?g "22 1"))
+    #      (project (?g)
+    #       (extend ((?g ??.0))
+    #        (group () ((??.0 (group_concat ?o)))
+    #         (bgp (triple :a :p1 ?o)))))) ))
+    #
     # @see https://www.w3.org/TR/sparql11-query/#modProjection
     class Project < Operator::Binary
       include Query
@@ -77,6 +94,7 @@ module SPARQL; module Algebra
           # Any of these options indicates we're in a sub-select
           opts = options.dup.delete_if {|k,v| %I{extensions filter_ops project}.include?(k)}
           content = operands.last.to_sparql(project: vars, **opts)
+          content = "{#{content}}" unless content.start_with?('{') && content.end_with?('}')
           Operator.to_sparql(content, **options)
         else
           operands.last.to_sparql(project: vars, **options)

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

@@ -8,12 +8,12 @@ module SPARQL; module Algebra
     # @example SPARQL Grammar
     #   PREFIX : <http://example.org/>
     #   PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
-    #   SELECT DISTINCT ?v
+    #   SELECT REDUCED ?v
     #   WHERE { ?x ?p ?v }
     #
     # @example SSE
-    #   (prefix ((xsd: <http://www.w3.org/2001/XMLSchema#>)
-    #            (: <http://example/>))
+    #   (prefix ((: <http://example.org/>)
+    #            (xsd: <http://www.w3.org/2001/XMLSchema#>))
     #     (reduced
     #       (project (?v)
     #         (bgp (triple ?x ?p ?v)))))

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

@@ -6,8 +6,8 @@ module SPARQL; module Algebra
     # [122] RegexExpression         ::= 'REGEX' '(' Expression ',' Expression ( ',' Expression )? ')'
     #
     # @example SPARQL Grammar
-    #   PREFIX  rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
     #   PREFIX  ex: <http://example.com/#>
+    #   PREFIX  rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
     #   SELECT ?val
     #   WHERE {
     #     ex:foo rdf:value ?val .

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

@@ -15,6 +15,17 @@ module SPARQL; module Algebra
     #            (in: <http://www.example.org/instance#>))
     #    (ask (path in:b (reverse ex:p) in:a)))
     #
+    # @example SPARQL Grammar
+    #   prefix ex:	<http://www.example.org/schema#>
+    #   prefix in:	<http://www.example.org/instance#>
+    #   
+    #   select  * where { in:c ^(ex:p1/ex:p2) ?x }
+    #
+    # @example SSE
+    #   (prefix ((ex: <http://www.example.org/schema#>)
+    #            (in: <http://www.example.org/instance#>))
+    #    (path in:c (reverse (seq ex:p1 ex:p2)) ?x))
+    #
     # @see https://www.w3.org/TR/sparql11-query/#defn_evalPP_inverse
     class Reverse < Operator::Unary
       include Query
@@ -65,7 +76,7 @@ module SPARQL; module Algebra
       #
       # @return [String]
       def to_sparql(**options)
-        "^" + operands.first.to_sparql(**options)
+        "^(" + operands.first.to_sparql(**options) + ')'
       end
     end # Reverse
   end # Operator

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

@@ -54,7 +54,9 @@ module SPARQL; module Algebra
       #
       # @return [String]
       def to_sparql(**options)
-        "SAMPLE(#{operands.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

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

@@ -83,7 +83,7 @@ module SPARQL; module Algebra
       #
       # @return [String]
       def to_sparql(**options)
-        operands.to_sparql(delimiter: '/', **options)
+        '(' + operands.to_sparql(delimiter: '/', **options) + ')'
       end
     end # Seq
   end # Operator

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

@@ -4,8 +4,11 @@ module SPARQL; module Algebra
     ##
     # The SPARQL UPDATE `sequence` operator.
     #
-    # Sequences through each operand
+    # Sequences through each operand.
     #
+    # [103] CollectionPath          ::= '(' GraphNodePath+ ')'
+    #
+    # @see https://www.w3.org/TR/sparql11-query/#collections
     class Sequence < Operator
       include SPARQL::Algebra::Update
 

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

@@ -13,8 +13,7 @@ module SPARQL; module Algebra
     #   }
     #
     # @example SSE
-    #   (prefix
-    #    ((: <http://example.org/>) (xsd: <http://www.w3.org/2001/XMLSchema#>))
+    #   (prefix ((: <http://example.org/>))
     #     (project (?s ?s2)
     #       (extend ((?s2 (strlang ?str "en-US")))
     #         (filter (langMatches (lang ?str) "en")

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

@@ -51,7 +51,7 @@ module SPARQL; module Algebra
       #
       # @return [String]
       def to_sparql(**options)
-        "#{operands.first.to_sparql(**options)} - #{operands.last.to_sparql(**options)}"
+        "(#{operands.first.to_sparql(**options)} - #{operands.last.to_sparql(**options)})"
       end
     end # Subtract
   end # Operator

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

@@ -7,15 +7,15 @@ module SPARQL; module Algebra
     #
     # @example SPARQL Grammar
     #   PREFIX : <http://www.example.org/>
-    #   SELECT (SUM(?O) AS ?sum)
+    #   SELECT (SUM(?o) AS ?sum)
     #   WHERE { ?s :dec ?o }
     #
     # @example SSE
-    #    (prefix ((: <http://www.example.org/>))
-    #      (project (?sum)
-    #        (extend ((?sum ??.0))
-    #          (group () ((??.0 (sum ?o)))
-    #            (bgp (triple ?s :dec ?o))))))
+    #   (prefix ((: <http://www.example.org/>))
+    #     (project (?sum)
+    #       (extend ((?sum ??.0))
+    #         (group () ((??.0 (sum ?o)))
+    #           (bgp (triple ?s :dec ?o))))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#defn_aggSum
     class Sum < Operator
@@ -47,7 +47,9 @@ module SPARQL; module Algebra
       #
       # @return [String]
       def to_sparql(**options)
-        "SUM(" + operands.to_sparql(**options) + ")"
+        distinct = operands.first == :distinct
+        args = distinct ? operands[1..-1] : operands
+        "SUM(#{'DISTINCT ' if distinct}#{args.to_sparql(**options)})"
       end
     end # Sum
   end # Operator

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

@@ -8,7 +8,7 @@ module SPARQL; module Algebra
     #
     # [28]  ValuesClause            ::= ( 'VALUES' DataBlock )?
     #
-    # @example SPARQL Grammar
+    # @example SPARQL Grammar (ValuesClause)
     #   PREFIX dc:   <http://purl.org/dc/elements/1.1/> 
     #   PREFIX :     <http://example.org/book/> 
     #   PREFIX ns:   <http://example.org/ns#> 
@@ -18,7 +18,7 @@ module SPARQL; module Algebra
     #   }
     #   VALUES ?book { :book1 }
     #
-    # @example SSE
+    # @example SSE (ValuesClause)
     #   (prefix ((dc: <http://purl.org/dc/elements/1.1/>)
     #            (: <http://example.org/book/>)
     #            (ns: <http://example.org/ns#>))
@@ -27,8 +27,38 @@ module SPARQL; module Algebra
     #      (bgp (triple ?book dc:title ?title) (triple ?book ns:price ?price))
     #      (table (vars ?book) (row (?book :book1)))) ))
     #
+    # @example SPARQL Grammar (empty query no values)
+    #    SELECT * { } VALUES () { }
+    #
+    # @example SSE (empty query no values)
+    #    (join (bgp) (table empty))
+    #
+    # [61]  InlineData              ::= 'VALUES' DataBlock
+    #
+    # @example SPARQL Grammar (InlineData)
+    #   PREFIX dc:   <http://purl.org/dc/elements/1.1/> 
+    #   PREFIX :     <http://example.org/book/> 
+    #   PREFIX ns:   <http://example.org/ns#> 
+    #   
+    #   SELECT ?book ?title ?price
+    #   {
+    #      VALUES ?book { :book1 }
+    #      ?book dc:title ?title ;
+    #            ns:price ?price .
+    #   }
+    #
+    # @example SSE (InlineData)
+    #   (prefix ((dc: <http://purl.org/dc/elements/1.1/>)
+    #            (: <http://example.org/book/>)
+    #            (ns: <http://example.org/ns#>))
+    #    (project (?book ?title ?price)
+    #     (join
+    #      (table (vars ?book) (row (?book :book1)))
+    #      (bgp (triple ?book dc:title ?title) (triple ?book ns:price ?price))) ))
+    #
     # @example empty table
     #     (table unit)
+    #
     # @see https://www.w3.org/TR/2013/REC-sparql11-query-20130321/#inline-data
     class Table < Operator
       include Query
@@ -67,22 +97,26 @@ module SPARQL; module Algebra
       #
       # 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(**options)
-        str = "VALUES (#{operands.first[1..-1].map { |e| e.to_sparql(**options) }.join(' ')}) {\n"
+      def to_sparql(top_level: true, **options)
+        str = "VALUES (#{Array(operands.first)[1..-1].map { |e| e.to_sparql(**options) }.join(' ')}) {\n"
         operands[1..-1].each do |row|
           line = '('
           row[1..-1].each do |col|
-            line << "#{col[1].to_sparql(**options)} "
+            v = col[1].to_sparql(as_statement: true, **options)
+            v = "<< #{v} >>" if col[1].is_a?(RDF::Statement)
+            line << v + ' '
           end
-          line = line.chop
+          line = line.chomp(' ')
           line << ")\n"
 
           str << line
         end
 
         str << "}\n"
-        str
+        top_level ? Operator.to_sparql(str, **options) : str
       end
     end # Table
   end # Operator

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

@@ -14,7 +14,7 @@ module SPARQL; module Algebra
     # @example SSE
     #   (prefix
     #    ((: <http://example.org/>))
-    #    (project (?str ?ustr)
+    #    (project (?s ?ustr)
     #     (extend ((?ustr (ucase ?str)))
     #      (bgp (triple ?s :str ?str)))))
     #

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

@@ -21,6 +21,27 @@ module SPARQL; module Algebra
     #      (delete ((triple ?a foaf:knows ?b)))
     #      (insert ((triple ?b foaf:knows ?a)))) ))
     #
+    # @example SPARQL Grammar (update multiple)
+    #   PREFIX     : <http://example.org/> 
+    #   PREFIX foaf: <http://xmlns.com/foaf/0.1/> 
+    #   
+    #   DELETE { ?a foaf:knows ?b . }
+    #   WHERE { ?a foaf:knows ?b . }
+    #   ;
+    #   INSERT { ?b foaf:knows ?a . }
+    #   WHERE { ?a foaf:knows ?b .}
+    #
+    # @example SSE (update multiple)
+    #   (prefix ((: <http://example.org/>)
+    #            (foaf: <http://xmlns.com/foaf/0.1/>))
+    #    (update
+    #     (modify
+    #      (bgp (triple ?a foaf:knows ?b))
+    #      (delete ((triple ?a foaf:knows ?b))))
+    #     (modify
+    #      (bgp (triple ?a foaf:knows ?b))
+    #      (insert ((triple ?b foaf:knows ?a))))))
+    #
     # @see https://www.w3.org/TR/sparql11-update/#graphUpdate
     class Update < Operator
       include SPARQL::Algebra::Update
@@ -58,7 +79,7 @@ module SPARQL; module Algebra
       #
       # @return [String]
       def to_sparql(**options)
-        str = operands.map { |e| e.to_sparql(**options) }.join("\n")
+        str = operands.map { |e| e.to_sparql(**options) }.join(";\n")
       end
     end # Update
   end # Operator

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

@@ -28,6 +28,21 @@ module SPARQL; module Algebra
     #       (bgp (triple :a foaf:knows ?s) (triple ?s ?p ?o)))
     #      (delete ((triple ?s ?p ?o)))) ))
     #
+    # @example SPARQL Grammar (multiple clauses)
+    #   PREFIX     : <http://example.org/> 
+    #   
+    #   INSERT { ?s ?p "q" }
+    #   USING :g1
+    #   USING :g2
+    #   WHERE { ?s ?p ?o }
+    #
+    # @example SSE (multiple clauses)
+    #   (prefix ((: <http://example.org/>))
+    #    (update
+    #     (modify (using (:g1 :g2)
+    #      (bgp (triple ?s ?p ?o)))
+    #      (insert ((triple ?s ?p "q"))))))
+    #
     # @see https://www.w3.org/TR/sparql11-update/#add
     class Using < Operator
       include SPARQL::Algebra::Query
@@ -61,7 +76,9 @@ module SPARQL; module Algebra
       #
       # @return [String]
       def to_sparql(**options)
-        str = "USING #{operands.first.to_sparql(**options)}\n"
+        str = "\n" + operands.first.map do |op|
+          "USING #{op.to_sparql(**options)}\n"
+        end.join("")
         content = operands.last.to_sparql(top_level: false, **options)
         str << Operator.to_sparql(content, project: nil, **options)
       end

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

@@ -85,7 +85,7 @@ module SPARQL; module Algebra
       #
       # @return [String]
       def to_sparql(**options)
-        with, where, ops = operands
+        with, where, *ops = operands
         str = "WITH #{with.to_sparql(**options)}\n"
 
         # The content of the WHERE clause, may be USING

data/lib/sparql/algebra/operator.rb

@@ -106,6 +106,7 @@ module SPARQL; module Algebra
     autoload :Coalesce,           'sparql/algebra/operator/coalesce'
     autoload :Desc,               'sparql/algebra/operator/desc'
     autoload :Exprlist,           'sparql/algebra/operator/exprlist'
+    autoload :FunctionCall,       'sparql/algebra/operator/function_call'
     autoload :GroupConcat,        'sparql/algebra/operator/group_concat'
     autoload :In,                 'sparql/algebra/operator/in'
     autoload :NotIn,              'sparql/algebra/operator/notin'
@@ -254,6 +255,7 @@ module SPARQL; module Algebra
         when :asc             then Asc
         when :desc            then Desc
         when :exprlist        then Exprlist
+        when :function_call   then FunctionCall
 
         # Datasets
         when :dataset         then Dataset
@@ -336,31 +338,41 @@ module SPARQL; module Algebra
     # Generate a top-level Grammar, using collected options
     #
     # @param [String] content
+    # @param [Operator] datasets ([])
+    # @param [Operator] distinct (false)
     # @param [Hash{Symbol => Operator}] extensions
     #   Variable bindings
-    # @param [Operator] distinct (false)
     # @param [Array<Operator>] filter_ops ([])
     #   Filter Operations
     # @param [Integer] limit (nil)
     # @param [Array<Operator>] group_ops ([])
+    # @param [Array<Operator>] having_ops ([])
     # @param [Integer] offset (nil)
     # @param [Array<Operator>] order_ops ([])
     #   Order Operations
     # @param [Array<Symbol,Operator>] project (%i(*))
     #   Terms to project
     # @param [Operator] reduced (false)
+    # @param [Operator] values_clause (nil)
+    #   Top-level Values clause
+    # @param [Operator] where_clause (true)
+    #   Emit 'WHERE' before GroupGraphPattern
     # @param [Hash{Symbol => Object}] options
     # @return [String]
     def self.to_sparql(content,
+                       datasets: [],
                        distinct: false,
                        extensions: {},
                        filter_ops: [],
                        group_ops: [],
+                       having_ops: [],
                        limit: nil,
                        offset: nil,
                        order_ops: [],
                        project: %i(*),
                        reduced: false,
+                       values_clause: nil,
+                       where_clause: true,
                        **options)
       str = ""
 
@@ -372,28 +384,41 @@ module SPARQL; module Algebra
 
         str << project.map do |p|
           if expr = extensions.delete(p)
+            v = expr.to_sparql(as_statement: true, **options)
+            v = "<< #{v} >>" if expr.is_a?(RDF::Statement)
+            pp = p.to_sparql(**options)
             # Replace projected variables with their extension, if any
-            "(" + [expr, :AS, p].to_sparql(**options) + ")"
+            '(' + v + ' AS ' + pp + ')'
           else
             p.to_sparql(**options)
           end
         end.join(" ") + "\n"
       end
 
-      # Extensions
+      # DatasetClause
+      datasets.each do |ds|
+        str << "FROM #{ds.to_sparql(**options)}\n"
+      end
+
+      # Bind
       extensions.each do |as, expression|
-        content << "\nBIND (#{expression.to_sparql(**options)} AS #{as.to_sparql(**options)}) ."
+        v = expression.to_sparql(as_statement: true, **options)
+        v = "<< #{v} >>" if expression.is_a?(RDF::Statement)
+        content << "\nBIND (" << v << " AS " << as.to_sparql(**options) << ") ."
       end
 
-      # Filters
+      # Filter
       filter_ops.each do |f|
-        content << "\nFILTER #{f.to_sparql(**options)} ."
+        content << "\nFILTER (#{f.to_sparql(**options)}) ."
       end
 
-      # Where clause
-      str << "WHERE {\n#{content}\n}\n"
+      # WhereClause / GroupGraphPattern
+      str << (where_clause ? "WHERE {\n#{content}\n}\n" : "{\n#{content}\n}\n")
 
-      # Group
+      ##
+      # SolutionModifier
+      #
+      # GroupClause
       unless group_ops.empty?
         ops = group_ops.map do |o|
           # Replace projected variables with their extension, if any
@@ -404,14 +429,22 @@ module SPARQL; module Algebra
         str << "GROUP BY #{ops.join(' ')}\n"
       end
 
-      # Order
+      # HavingClause
+      unless having_ops.empty?
+        str << "HAVING #{having_ops.to_sparql(**options)}"
+      end
+
+      # OrderClause
       unless order_ops.empty?
         str << "ORDER BY #{order_ops.to_sparql(**options)}\n"
       end
 
-      # Offset and Limmit
+      # LimitOffsetClauses
       str << "OFFSET #{offset}\n" unless offset.nil?
       str << "LIMIT #{limit}\n" unless limit.nil?
+
+      # Values Clause
+      str << values_clause.to_sparql(top_level: false, **options) if values_clause
       str
     end
 
@@ -640,12 +673,8 @@ module SPARQL; module Algebra
     # @return [SPARQL::Algebra::Expression] `self`
     def rewrite(&block)
       @operands = @operands.map do |op|
-        # Rewrite the operand
-        unless new_op = block.call(op)
-          # Not re-written, rewrite
-          new_op = op.respond_to?(:rewrite) ? op.rewrite(&block) : op
-        end
-        new_op
+        new_op = block.call(op)
+        new_op.respond_to?(:rewrite) ? new_op.rewrite(&block) : new_op
       end
       self
     end
@@ -671,7 +700,6 @@ module SPARQL; module Algebra
     end
 
     ##
-    #
     # Returns a partial SPARQL grammar for the operator.
     #
     # @return [String]

data/lib/sparql/algebra.rb

@@ -19,6 +19,24 @@ module SPARQL
   #
   # {RDF::Query} and {RDF::Query::Pattern} are used as primitives for `bgp` and `triple` expressions.
   #
+  # # Background
+  #
+  # The SPARQL Algebra, and the S-Expressions used to represent it, are based on those of [Jena](https://jena.apache.org/documentation/notes/sse.html). Generally, an S-Expression generated by this Gem can be used as an SSE input to Jena, or an SSE output from Jena can also be used as input to this Gem.
+  #
+  # S-Expressions generally follow a standardized nesting resulting from parsing the original SPARQL Grammar. The individual operators map to SPARQL Grammar productions, and in most cases, the SPARQL Grammar can be reproduced by turning the S-Expression back into SPARQL (see {SPARQL::Algebra::Operator#to_sparql}). The order of operations will typically be as follows:
+  #
+  #  * {SPARQL::Algebra::Operator::Base}
+  #  * {SPARQL::Algebra::Operator::Prefix}
+  #  * {SPARQL::Algebra::Operator::Slice}
+  #  * {SPARQL::Algebra::Operator::Distinct}
+  #  * {SPARQL::Algebra::Operator::Reduced}
+  #  * {SPARQL::Algebra::Operator::Project}
+  #  * {SPARQL::Algebra::Operator::Order}
+  #  * {SPARQL::Algebra::Operator::Filter}
+  #  * {SPARQL::Algebra::Operator::Extend}
+  #  * {SPARQL::Algebra::Operator::Group}
+  #  * {SPARQL::Algebra::Query} (many classes implement Query)
+  #
   # # Queries
   # 
   #     require 'sparql/algebra'
@@ -262,6 +280,7 @@ module SPARQL
   #     * {SPARQL::Algebra::Operator::Extend}
   #     * {SPARQL::Algebra::Operator::Filter}
   #     * {SPARQL::Algebra::Operator::Floor}
+  #     * {SPARQL::Algebra::Operator::FunctionCall}
   #     * {SPARQL::Algebra::Operator::Graph}
   #     * {SPARQL::Algebra::Operator::GreaterThan}
   #     * {SPARQL::Algebra::Operator::GreaterThanOrEqual}
@@ -339,11 +358,9 @@ module SPARQL
   #     * {SPARQL::Algebra::Operator::With}
   #     * {SPARQL::Algebra::Operator::Year}
   # 
-  # TODO
-  # ====
-  # * Operator#optimize needs to be completed and tested.
   # 
   # @see http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
+  # @see https://jena.apache.org/documentation/notes/sse.html
   module Algebra
     include RDF
 

data/lib/sparql/grammar/parser11.rb

@@ -197,7 +197,7 @@ module SPARQL::Grammar
     # [2]  	Query	  ::=  	Prologue
     #                     ( SelectQuery | ConstructQuery | DescribeQuery | AskQuery )
     production(:Query) do |input, data, callback|
-      query = data[:query].first
+      query = data[:query].first if data[:query]
 
       # Add prefix
       if data[:PrefixDecl]
@@ -806,7 +806,7 @@ module SPARQL::Grammar
 
     # [70]  	FunctionCall	  ::=  	iri ArgList
     production(:FunctionCall) do |input, data, callback|
-      add_prod_data(:Function, Array(data[:iri]) + data[:ArgList])
+      add_prod_data(:Function, SPARQL::Algebra::Operator::FunctionCall.new(data[:iri], *data[:ArgList]))
     end
 
     # [71]  	ArgList	  ::=  	NIL
@@ -1437,7 +1437,7 @@ module SPARQL::Grammar
     production(:iriOrFunction) do |input, data, callback|
       if data.has_key?(:ArgList)
         # Function is (func arg1 arg2 ...)
-        add_prod_data(:Function, Array(data[:iri]) + data[:ArgList])
+        add_prod_data(:Function, SPARQL::Algebra::Operator::FunctionCall.new(data[:iri], *data[:ArgList]))
       else
         input[:iri] = data[:iri]
       end