sparql 3.2.0 → 3.2.4

data/lib/sparql/grammar/parser11.rb

@@ -15,7 +15,7 @@ module SPARQL::Grammar
 
     # Builtin functions
     BUILTINS = %w{
-      ABS  BNODE CEIL COALESCE CONCAT
+      ABS ADJUST BNODE CEIL COALESCE CONCAT
       CONTAINS DATATYPE DAY ENCODE_FOR_URI
       FLOOR HOURS IF IRI LANGMATCHES LANG LCASE
       MD5 MINUTES MONTH NOW RAND ROUND SECONDS
@@ -119,7 +119,7 @@ module SPARQL::Grammar
       input[:literal] = literal(token.value, datatype: RDF::XSD.integer)
     end
     terminal(:LANGTAG,              LANGTAG) do |prod, token, input|
-      add_prod_datum(:language, token.value[1..-1])
+      input[:language] = token.value[1..-1]
     end
     terminal(:PNAME_LN,             PNAME_LN, unescape: true) do |prod, token, input|
       prefix, suffix = token.value.split(":", 2)
@@ -177,7 +177,7 @@ module SPARQL::Grammar
       when /ASC|DESC/      then input[:OrderDirection] = token.value.downcase.to_sym
       when /DISTINCT|REDUCED/  then input[:DISTINCT_REDUCED] = token.value.downcase.to_sym
       when %r{
-          ABS|ALL|AVG|BNODE|BOUND|CEIL|COALESCE|CONCAT
+          ABS|ADJUST|ALL|AVG|BNODE|BOUND|CEIL|COALESCE|CONCAT
          |CONTAINS|COUNT|DATATYPE|DAY|DEFAULT|ENCODE_FOR_URI|EXISTS
          |FLOOR|HOURS|IF|GRAPH|GROUP_CONCAT|IRI|LANGMATCHES|LANG|LCASE
          |MAX|MD5|MINUTES|MIN|MONTH|NAMED|NOW|RAND|REPLACE|ROUND|SAMPLE|SECONDS|SEPARATOR
@@ -194,10 +194,13 @@ module SPARQL::Grammar
     end
 
     # Productions
-    # [2]  	Query	  ::=  	Prologue
-    #                     ( SelectQuery | ConstructQuery | DescribeQuery | AskQuery )
+
+    # [2] Query ::= Prologue ( SelectQuery | ConstructQuery | DescribeQuery | AskQuery )
+    #
+    # Inputs from `data` are `:query` and potentially `:PrefixDecl`.
+    # Output to prod_data is the Queryable object.
     production(:Query) do |input, data, callback|
-      query = data[:query].first
+      query = data[:query].first if data[:query]
 
       # Add prefix
       if data[:PrefixDecl]
@@ -213,7 +216,10 @@ module SPARQL::Grammar
       add_prod_datum(:query, query)
     end
 
-    # [4]  	Prologue	  ::=  	( BaseDecl | PrefixDecl )*
+    # [4] Prologue ::= ( BaseDecl | PrefixDecl )*
+    #
+    # Inputs from `data` are `:PrefixDecl` and `:BaseDecl`.
+    # Output to prod_data is the same, if `#resolve_iris?` is `false`.
     production(:Prologue) do |input, data, callback|
       unless resolve_iris?
         # Only output if we're not resolving URIs internally
@@ -222,7 +228,10 @@ module SPARQL::Grammar
       end
     end
 
-    # [5]  	BaseDecl	  ::=  	'BASE' IRI_REF
+    # [5] BaseDecl ::= 'BASE' IRI_REF
+    #
+    # Input from `data` is `:BaseDecl`.
+    # Output to prod_data is the same, if `#resolve_iris?` is `false`.
     production(:BaseDecl) do |input, data, callback|
       iri = data[:iri]
       debug("BaseDecl") {"Defined base as #{iri}"}
@@ -230,7 +239,10 @@ module SPARQL::Grammar
       add_prod_datum(:BaseDecl, iri) unless resolve_iris?
     end
 
-    # [6] PrefixDecl	  ::=  	'PREFIX' PNAME_NS IRI_REF
+    # [6] PrefixDecl ::= 'PREFIX' PNAME_NS IRI_REF
+    #
+    # Inputs from `data` are `:iri`, and `:prefix`.
+    # Output to prod_data is the `:PrefixDecl`, and `Operator::Prefix`, unless there is no `:iri`.
     production(:PrefixDecl) do |input, data, callback|
       if data[:iri]
         pfx = data[:prefix]
@@ -240,21 +252,41 @@ module SPARQL::Grammar
       end
     end
 
-    # [7]  	SelectQuery	  ::=  	SelectClause DatasetClause* WhereClause SolutionModifier
+    # [7] SelectQuery ::= SelectClause DatasetClause* WhereClause SolutionModifier
+    #
+    # Inputs from `data` are merged into a Queryable object.
+    # Output to prod_data is `:query`.
     production(:SelectQuery) do |input, data, callback|
       query = merge_modifiers(data)
       add_prod_datum :query, query
     end
 
-    # [8]  	SubSelect	  ::=  	SelectClause WhereClause SolutionModifier
+    # [8] SubSelect ::= SelectClause WhereClause SolutionModifier
+    #
+    # Inputs from `data` are merged into a Queryable object.
+    # Output to prod_data is `:query`.
     production(:SubSelect) do |input, data, callback|
       query = merge_modifiers(data)
       add_prod_datum :query, query
     end
 
-    # [9]  	SelectClause	  ::=  	'SELECT' ( 'DISTINCT' | 'REDUCED' )? ( ( Var | ( '(' Expression 'AS' Var ')' ) )+ | '*' )
-
+    # [9] SelectClause ::= 'SELECT' ( 'DISTINCT' | 'REDUCED' )? ( ( Var | ( '(' Expression 'AS' Var ')' ) )+ | '*' )
+    # [9.2] _SelectClause_2 ::= ( ( Var | ( '(' Expression 'AS' Var ')' ) )+ | '*' )
+    #
+    # Inputs from `data` are `:Expression` and `:Var`.
+    # Output to prod_data is `:Var`.
+    production(:_SelectClause_2) do |input, data, callback|
+      if data[:MultiplicativeExpression]
+        add_prod_datum :Var, %i(*)
+      else
+        add_prod_datum :extend, data[:extend]
+        add_prod_datum :Var, data[:Var]
+      end
+    end
     # [9.8] _SelectClause_8 ::= ( '(' Expression 'AS' Var ')' )
+    #
+    # Inputs from `data` are `:Expression` and `:Var`.
+    # Output to prod_data is `:extend`.
     production(:_SelectClause_8) do |input, data, callback|
       add_prod_datum :extend, [data[:Expression].unshift(data[:Var].first)]
     end
@@ -267,6 +299,10 @@ module SPARQL::Grammar
     #                            'WHERE' '{' TriplesTemplate? '}'
     #                            SolutionModifier
     #                          )
+    #
+    # Inputs from `data` are `:pattern` and optionally `:ConstructTemplate`.
+    # If there is no `:query` in data, one is constructed by creating a BGP from all values of `:pattern`.
+    # Output to prod_data is `:query` made by creating a Operator::Construct using any `:ConstructTemplate` or `:pattern` and the query with merged modifiers.
     production(:ConstructQuery) do |input, data, callback|
       data[:query] ||= [SPARQL::Algebra::Operator::BGP.new(*data[:pattern])]
       query = merge_modifiers(data)
@@ -274,44 +310,64 @@ module SPARQL::Grammar
       add_prod_datum :query, SPARQL::Algebra::Expression[:construct, template, query]
     end
 
-    # [11]  	DescribeQuery	  ::=  	'DESCRIBE' ( VarOrIri+ | '*' )
-    #                             DatasetClause* WhereClause? SolutionModifier
+    # [11] DescribeQuery ::= 'DESCRIBE' ( VarOrIri+ | '*' )
+    #                         DatasetClause* WhereClause? SolutionModifier
+    #
+    # Inputs from `data` are merged into a Queryable object.
+    # Outputs are created using any `:VarOrIri` in data is used as an argument, along with the Queryable object to create an `Operator::Describe` object, which is added to `:query` in prod datea.
     production(:DescribeQuery) do |input, data, callback|
       query = merge_modifiers(data)
       to_describe = Array(data[:VarOrIri])
       add_prod_datum :query, SPARQL::Algebra::Expression[:describe, to_describe, query]
     end
 
-    # [12]  	AskQuery	  ::=  	'ASK' DatasetClause* WhereClause
+    # [12] AskQuery ::= 'ASK' DatasetClause* WhereClause
+    #
+    # Inputs from `data` are merged into a Queryable object.
+    # Output to prod_data is `:query` made by creating a Operator::Ask using the query with merged modifiers.
     production(:AskQuery) do |input, data, callback|
       query = merge_modifiers(data)
       add_prod_datum :query, SPARQL::Algebra::Expression[:ask, query]
     end
 
-    # [14]  	DefaultGraphClause	  ::=  	SourceSelector
+    # [14] DefaultGraphClause ::= SourceSelector
+    #
+    # Input from `data` is `:iri`.
+    # Output to prod_data is `:dataset` taken from `:iri`.
     production(:DefaultGraphClause) do |input, data, callback|
       add_prod_datum :dataset, data[:iri]
     end
 
-    # [15]  	NamedGraphClause	  ::=  	'NAMED' SourceSelector
+    # [15] NamedGraphClause ::= 'NAMED' SourceSelector
+    #
+    # Input from `data` is `:iri`.
+    # Output to prod_data is `:dataset` taken from `:iri`.
     production(:NamedGraphClause) do |input, data, callback|
       add_prod_data :dataset, [:named, data[:iri]]
     end
 
-    # [18]  	SolutionModifier	  ::=  	GroupClause? HavingClause? OrderClause? LimitOffsetClauses?
+    # [18] SolutionModifier ::= GroupClause? HavingClause? OrderClause? LimitOffsetClauses?
 
-    # [19]  	GroupClause	  ::=  	'GROUP' 'BY' GroupCondition+
+    # [19] GroupClause ::= 'GROUP' 'BY' GroupCondition+
+    #
+    # Input from `data` is `:GroupCondition`.
+    # Output to prod_data is `:group` taken from `:GroupCondition`.
     production(:GroupClause) do |input, data, callback|
       add_prod_data :group, data[:GroupCondition]
     end
 
-    # [20]  	GroupCondition	  ::=  	BuiltInCall | FunctionCall
-    #                                | '(' Expression ( 'AS' Var )? ')' | Var
+    # [20] GroupCondition ::= BuiltInCall | FunctionCall
+    #                       | '(' Expression ( 'AS' Var )? ')' | Var
+    #
+    # Output to prod_data is `:GroupCondition` taken from first value in data.
     production(:GroupCondition) do |input, data, callback|
       add_prod_datum :GroupCondition, data.values.first
     end
 
     # _GroupCondition_1 ::= '(' Expression ( 'AS' Var )? ')'
+    #
+    # Input from `data` is `:Expression` and optionally `:Var`.
+    # Output to prod_data is `:GroupCondition` taken from `:Expression` prepended by any value of `:Var`.
     production(:_GroupCondition_1) do |input, data, callback|
       cond = if data[:Var]
         [data[:Expression].unshift(data[:Var].first)]
@@ -321,12 +377,18 @@ module SPARQL::Grammar
       add_prod_datum(:GroupCondition, cond)
     end
 
-    # [21]  	HavingClause	  ::=  	'HAVING' HavingCondition+
+    # [21] HavingClause ::= 'HAVING' HavingCondition+
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:HavingClause) do |input, data, callback|
       add_prod_datum(:having, data[:Constraint])
     end
 
-    # [23]  	OrderClause	  ::=  	'ORDER' 'BY' OrderCondition+
+    # [23] OrderClause ::= 'ORDER' 'BY' OrderCondition+
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:OrderClause) do |input, data, callback|
       if res = data[:OrderCondition]
         res = [res] if [:asc, :desc].include?(res[0]) # Special case when there's only one condition and it's ASC (x) or DESC (x)
@@ -334,9 +396,12 @@ module SPARQL::Grammar
       end
     end
 
-    # [24]  	OrderCondition	  ::=  	 ( ( 'ASC' | 'DESC' )
-    #                                 BrackettedExpression )
-    #                               | ( Constraint | Var )
+    # [24] OrderCondition ::= ( ( 'ASC' | 'DESC' )
+    #                           BrackettedExpression )
+    #                       | ( Constraint | Var )
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:OrderCondition) do |input, data, callback|
       if data[:OrderDirection]
         add_prod_datum(:OrderCondition, SPARQL::Algebra::Expression(data[:OrderDirection], *data[:Expression]))
@@ -345,8 +410,11 @@ module SPARQL::Grammar
       end
     end
 
-    # [25]  	LimitOffsetClauses	  ::=  	LimitClause OffsetClause?
-    #                                 | OffsetClause LimitClause?
+    # [25] LimitOffsetClauses ::= LimitClause OffsetClause?
+    #                           | OffsetClause LimitClause?
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:LimitOffsetClauses) do |input, data, callback|
       if data[:limit] || data[:offset]
         limit = data[:limit] ? data[:limit].last : :_
@@ -355,17 +423,26 @@ module SPARQL::Grammar
       end
     end
 
-    # [26]  	LimitClause	  ::=  	'LIMIT' INTEGER
+    # [26] LimitClause ::= 'LIMIT' INTEGER
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:LimitClause) do |input, data, callback|
       add_prod_datum(:limit, data[:literal])
     end
 
-    # [27]  	OffsetClause	  ::=  	'OFFSET' INTEGER
+    # [27] OffsetClause ::= 'OFFSET' INTEGER
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:OffsetClause) do |input, data, callback|
       add_prod_datum(:offset, data[:literal])
     end
 
-    # [28]  ValuesClause	          ::= ( 'VALUES' DataBlock )?
+    # [28]  ValuesClause ::= ( 'VALUES' DataBlock )?
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:ValuesClause) do |input, data, callback|
       debug("ValuesClause") {"vars: #{data[:Var].inspect}, row: #{data[:row].inspect}"}
       if data[:row]
@@ -378,7 +455,10 @@ module SPARQL::Grammar
       end
     end
 
-    # [29]	Update	::=	Prologue (Update1 (";" Update)? )?
+    # [29] Update ::= Prologue (Update1 (";" Update)? )?
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:Update) do |input, data, callback|
       update = data[:update] || SPARQL::Algebra::Expression(:update)
 
@@ -396,6 +476,10 @@ module SPARQL::Grammar
       # Don't use update operator twice, if we can help it
       input[:update] = update
     end
+
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:_Update_3) do |input, data, callback|
       if data[:update]
         if input[:update].is_a?(SPARQL::Algebra::Operator::Update)
@@ -407,12 +491,19 @@ module SPARQL::Grammar
       end
     end
 
-    # [30]	Update1	::=	Load | Clear | Drop | Add | Move | Copy | Create | InsertData | DeleteData | DeleteWhere | Modify
+    # [30] Update1 ::= Load | Clear | Drop | Add | Move | Copy
+    #                | Create | InsertData | DeleteData | DeleteWhere | Modify
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:Update1) do |input, data, callback|
       input[:update] = SPARQL::Algebra::Expression.for(:update, data[:update_op])
     end
 
-    # [31]	Load	::=	"LOAD" "SILENT"? iri ("INTO" GraphRef)?
+    # [31] Load ::= "LOAD" "SILENT"? iri ("INTO" GraphRef)?
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:Load) do |input, data, callback|
       args = []
       args << :silent if data[:silent]
@@ -420,11 +511,18 @@ module SPARQL::Grammar
       args << data[:into] if data[:into]
       input[:update_op] = SPARQL::Algebra::Expression(:load, *args)
     end
+
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:_Load_2) do |input, data, callback|
       input[:into] = data[:iri]
     end
 
-    # [32]	Clear	::=	"CLEAR" "SILENT"? GraphRefAll
+    # [32] Clear ::= "CLEAR" "SILENT"? GraphRefAll
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:Clear) do |input, data, callback|
       args = []
       %w(silent default named all).map(&:to_sym).each do |s|
@@ -434,7 +532,10 @@ module SPARQL::Grammar
       input[:update_op] = SPARQL::Algebra::Expression(:clear, *args)
     end
 
-    # [33]	Drop	::=	"DROP" "SILENT"? GraphRefAll
+    # [33] Drop ::= "DROP" "SILENT"? GraphRefAll
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:Drop) do |input, data, callback|
       args = []
       %w(silent default named all).map(&:to_sym).each do |s|
@@ -444,7 +545,10 @@ module SPARQL::Grammar
       input[:update_op] = SPARQL::Algebra::Expression(:drop, *args)
     end
 
-    # [34]	Create	::=	"CREATE" "SILENT"? GraphRef
+    # [34] Create ::= "CREATE" "SILENT"? GraphRef
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:Create) do |input, data, callback|
       args = []
       args << :silent if data[:silent]
@@ -452,7 +556,10 @@ module SPARQL::Grammar
       input[:update_op] = SPARQL::Algebra::Expression(:create, *args)
     end
 
-    # [35]	Add	::=	"ADD" "SILENT"? GraphOrDefault "TO" GraphOrDefault
+    # [35] Add ::= "ADD" "SILENT"? GraphOrDefault "TO" GraphOrDefault
+    #
+    # Input from `data` are `GraphOrDefault` and optionally `:silent`.
+    # Output to input is `:update_op` with an `Operator::Add` object.
     production(:Add) do |input, data, callback|
       args = []
       args << :silent if data[:silent]
@@ -460,7 +567,10 @@ module SPARQL::Grammar
       input[:update_op] = SPARQL::Algebra::Expression(:add, *args)
     end
 
-    # [36]	Move	::=	"MOVE" "SILENT"? GraphOrDefault "TO" GraphOrDefault
+    # [36] Move ::= "MOVE" "SILENT"? GraphOrDefault "TO" GraphOrDefault
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:Move) do |input, data, callback|
       args = []
       args << :silent if data[:silent]
@@ -468,7 +578,10 @@ module SPARQL::Grammar
       input[:update_op] = SPARQL::Algebra::Expression(:move, *args)
     end
 
-    # [37]	Copy	::=	"COPY" "SILENT"? GraphOrDefault "TO" GraphOrDefault
+    # [37] Copy ::= "COPY" "SILENT"? GraphOrDefault "TO" GraphOrDefault
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:Copy) do |input, data, callback|
       args = []
       args << :silent if data[:silent]
@@ -476,40 +589,59 @@ module SPARQL::Grammar
       input[:update_op] = SPARQL::Algebra::Expression(:copy, *args)
     end
 
-    # [38]	InsertData	::=	"INSERT DATA" QuadData
+    # [38] InsertData ::= "INSERT DATA" QuadData
     start_production(:InsertData) do |input, data, callback|
       # Freeze existing bnodes, so that if an attempt is made to re-use such a node, and error is raised
       self.freeze_bnodes
     end
+
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:InsertData) do |input, data, callback|
       input[:update_op] = SPARQL::Algebra::Expression(:insertData, data[:pattern])
     end
 
-    # [39]	DeleteData	::=	"DELETE DATA" QuadData
+    # [39] DeleteData ::= "DELETE DATA" QuadData
     start_production(:DeleteData) do |input, data, callback|
       # Generate BNodes instead of non-distinguished variables. BNodes are not legal, but this will generate them rather than non-distinguished variables so they can be detected.
       self.gen_bnodes
     end
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:DeleteData) do |input, data, callback|
       raise Error, "DeleteData contains BNode operands: #{data[:pattern].to_sse}" if Array(data[:pattern]).any?(&:node?)
       input[:update_op] = SPARQL::Algebra::Expression(:deleteData, Array(data[:pattern]))
     end
 
-    # [40]	DeleteWhere	::=	"DELETE WHERE" QuadPattern
+    # [40] DeleteWhere ::= "DELETE WHERE" QuadPattern
     start_production(:DeleteWhere) do |input, data, callback|
       # Generate BNodes instead of non-distinguished variables. BNodes are not legal, but this will generate them rather than non-distinguished variables so they can be detected.
       self.gen_bnodes
     end
+
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:DeleteWhere) do |input, data, callback|
       raise Error, "DeleteWhere contains BNode operands: #{data[:pattern].to_sse}" if Array(data[:pattern]).any?(&:node?)
       self.gen_bnodes(false)
       input[:update_op] = SPARQL::Algebra::Expression(:deleteWhere, Array(data[:pattern]))
     end
 
-    # [41]	Modify	::=	("WITH" iri)? ( DeleteClause InsertClause? | InsertClause) UsingClause* "WHERE" GroupGraphPattern
+    # [41] Modify ::= ("WITH" iri)? ( DeleteClause InsertClause? | InsertClause) UsingClause* "WHERE" GroupGraphPattern
     start_production(:Modify) do |input, data, callback|
       self.clear_bnode_cache
     end
+
+    #
+    # Input from `data` are:
+    #   * `:query` from `GroupGraphPattern`,
+    #   * optionally `:using` from `UsingClause`,
+    #   * either `:delete` or `:insert` or both from `DeleteClause` and `InsertClause`, and
+    #   * optionally `:iri` from `WITH`
+    # Output to input is `:update_op`.
     production(:Modify) do |input, data, callback|
       query = data[:query].first if data[:query]
       query = SPARQL::Algebra::Expression.for(:using, data[:using], query) if data[:using]
@@ -518,36 +650,53 @@ module SPARQL::Grammar
       input[:update_op] = SPARQL::Algebra::Expression(:modify, *operands)
     end
 
-    # [42]	DeleteClause	::=	"DELETE" QuadPattern
+    # [42] DeleteClause ::= "DELETE" QuadPattern
+    #
+    # Generate BNodes instead of non-distinguished variables. BNodes are not legal, but this will generate them rather than non-distinguished variables so they can be detected.
     start_production(:DeleteClause) do |input, data, callback|
-      # Generate BNodes instead of non-distinguished variables. BNodes are not legal, but this will generate them rather than non-distinguished variables so they can be detected.
       self.gen_bnodes
     end
+
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:DeleteClause) do |input, data, callback|
       raise Error, "DeleteClause contains BNode operands: #{Array(data[:pattern]).to_sse}" if Array(data[:pattern]).any?(&:node?)
       self.gen_bnodes(false)
       input[:delete] = SPARQL::Algebra::Expression(:delete, Array(data[:pattern]))
     end
 
-    # [43]	InsertClause	::=	"INSERT" QuadPattern
+    # [43] InsertClause ::= "INSERT" QuadPattern
+    #
+    # Generate BNodes instead of non-distinguished variables.
     start_production(:InsertClause) do |input, data, callback|
-      # Generate BNodes instead of non-distinguished variables.
       self.gen_bnodes
     end
+
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:InsertClause) do |input, data, callback|
       self.gen_bnodes(false)
       input[:insert] = SPARQL::Algebra::Expression(:insert, Array(data[:pattern]))
     end
 
-    # [44]	UsingClause	::=	"USING" ( iri | "NAMED" iri)
+    # [44] UsingClause ::= "USING" ( iri | "NAMED" iri)
     production(:UsingClause) do |input, data, callback|
       add_prod_data(:using, data[:iri])
     end
+
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:_UsingClause_2) do |input, data, callback|
       input[:iri] = [:named, data[:iri]]
     end
 
-    # [45]	GraphOrDefault	::=	"DEFAULT" | "GRAPH"? iri
+    # [45] GraphOrDefault ::= "DEFAULT" | "GRAPH"? iri
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:GraphOrDefault) do |input, data, callback|
       if data[:default]
         add_prod_datum(:GraphOrDefault, :default)
@@ -556,17 +705,24 @@ module SPARQL::Grammar
       end
     end
 
-    # [46]	GraphRef	::=	"GRAPH" iri
+    # [46] GraphRef ::= "GRAPH" iri
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:GraphRef) do |input, data, callback|
       input[:iri] = data[:iri]
     end
 
-    # [49]	QuadData	::=	"{" Quads "}"
+    # [49] QuadData ::= "{" Quads "}"
     # QuadData is like QuadPattern, except without BNodes
     start_production(:QuadData) do |input, data, callback|
       # Generate BNodes instead of non-distinguished variables
       self.gen_bnodes
     end
+
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:QuadData) do |input, data, callback|
       # Transform using statements instead of patterns, and verify there are no variables
       raise Error, "QuadData contains variable operands: #{Array(data[:pattern]).to_sse}" if Array(data[:pattern]).any?(&:variable?)
@@ -574,17 +730,26 @@ module SPARQL::Grammar
       input[:pattern] = Array(data[:pattern])
     end
 
-    # [51] QuadsNotTriples	::=	"GRAPH" VarOrIri "{" TriplesTemplate? "}"
+    # [51] QuadsNotTriples ::= "GRAPH" VarOrIri "{" TriplesTemplate? "}"
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:QuadsNotTriples) do |input, data, callback|
       add_prod_datum(:pattern, [SPARQL::Algebra::Expression.for(:graph, data[:VarOrIri].last, Array(data[:pattern]))])
     end
 
-    # [52]	TriplesTemplate	::=	TriplesSameSubject ("." TriplesTemplate? )?
+    # [52] TriplesTemplate ::= TriplesSameSubject ("." TriplesTemplate? )?
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:TriplesTemplate) do |input, data, callback|
       add_prod_datum(:pattern, Array(data[:pattern]))
     end
 
-    # [54]	GroupGraphPatternSub	::=	TriplesBlock? (GraphPatternNotTriples "."? TriplesBlock? )*
+    # [54] GroupGraphPatternSub ::= TriplesBlock? (GraphPatternNotTriples "."? TriplesBlock? )*
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:GroupGraphPatternSub) do |input, data, callback|
       debug("GroupGraphPatternSub") {"q #{data[:query].inspect}"}
 
@@ -608,48 +773,90 @@ module SPARQL::Grammar
       add_prod_datum(:query, res)
     end
 
-    # [55]  	TriplesBlock	  ::=  	TriplesSameSubjectPath
-    #                               ( '.' TriplesBlock? )?
+    # [55] TriplesBlock ::= TriplesSameSubjectPath
+    #                       ( '.' TriplesBlock? )?
+    #
+    # Input from `data` is `:pattern` and `:query`. Input from input is also `:pattern`
+    # Patterns are sequenced and segmented into RDF::Query::Pattern and Operator::Path.
+    # Output to prod_data is `:query` either a BGP, a Join, a Sequence, or a combination of any of these. Any path element results in a Sequence.
     production(:TriplesBlock) do |input, data, callback|
-      if !Array(data[:pattern]).empty?
-        query = SPARQL::Algebra::Operator::BGP.new
-        Array(data[:pattern]).each {|p| query << p}
-
-        # Append triples from ('.' TriplesBlock? )?
-        Array(data[:query]).each do |q|
-          if q.respond_to?(:patterns)
-            query += q
-          else
-            query = SPARQL::Algebra::Operator::Join.new(query, q)
+      raise "TriplesBlock without pattern" if Array(data[:pattern]).empty?
+
+      lhs = Array(input.delete(:query)).first
+
+      # Sequence is existing patterns, plus new patterns, plus patterns from TriplesBlock?
+      sequence = []
+      unless lhs.nil? || lhs.empty?
+        if lhs.is_a?(SPARQL::Algebra::Operator::Sequence)
+          sequence += lhs.operands
+        else
+          sequence << lhs
+        end
+      end
+
+      sequence += data[:pattern]
+
+      # Append triples from ('.' TriplesBlock? )?
+      Array(data[:query]).each do |q|
+        if q.is_a?(SPARQL::Algebra::Operator::Sequence)
+          q.operands.each do |op|
+            sequence += op.respond_to?(:patterns) ? op.patterns : [op]
           end
+        elsif q.respond_to?(:patterns)
+          sequence += q.patterns
+        else
+          sequence << q
         end
-        if (lhs = (input.delete(:query) || []).first) && !lhs.empty?
-          query = SPARQL::Algebra::Operator::Join.new(lhs, query)
+      end
+
+      # Merge runs of patterns into BGPs
+      patterns = []
+      new_seq = []
+      sequence.each do |element|
+        case element
+        when RDF::Query::Pattern
+          patterns << element
+        when RDF::Queryable
+          patterns += element.patterns
+        else
+          new_seq << SPARQL::Algebra::Expression.for(:bgp, *patterns) unless patterns.empty?
+          patterns = []
+          new_seq << element
         end
-        if data[:path]
-          query = SPARQL::Algebra::Operator::Join.new(query, Array(data[:path]).first)
+      end
+      new_seq << SPARQL::Algebra::Expression.for(:bgp, *patterns) unless patterns.empty?
+
+      # Optionally create a sequence, if there are enough gathered.
+      # FIXME: Join?
+      query = if new_seq.length > 1
+        if new_seq.any? {|e| e.is_a?(SPARQL::Algebra::Operator::Path)}
+          SPARQL::Algebra::Expression.for(:sequence, *new_seq)
+        else
+          SPARQL::Algebra::Expression.for(:join, *new_seq)
         end
-        add_prod_datum(:query, query)
-      elsif !Array(data[:query]).empty?
-        # Join query and path
-        add_prod_datum(:query, SPARQL::Algebra::Operator::Join.new(data[:path].first, data[:query].first))
-      elsif data[:path]
-        add_prod_datum(:query, data[:path])
+      else
+        new_seq.first
       end
+
+      add_prod_datum(:query, query)
     end
 
-    # [56]  	GraphPatternNotTriples	  ::=  	GroupOrUnionGraphPattern
-    #                                       | OptionalGraphPattern
-    #                                       | MinusGraphPattern
-    #                                       | GraphGraphPattern
-    #                                       | ServiceGraphPattern
-    #                                       | Filter | Bind
+    # [56] GraphPatternNotTriples ::= GroupOrUnionGraphPattern
+    #                               | OptionalGraphPattern
+    #                               | MinusGraphPattern
+    #                               | GraphGraphPattern
+    #                               | ServiceGraphPattern
+    #                               | Filter | Bind
     start_production(:GraphPatternNotTriples) do |input, data, callback|
       # Modifies previous graph
-      data[:input_query] = input.delete(:query) || [SPARQL::Algebra::Operator::BGP.new]
+      data[:input_query] = input.delete(:query)
     end
+
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:GraphPatternNotTriples) do |input, data, callback|
-      lhs = Array(data[:input_query]).first
+      lhs = Array(data[:input_query]).first || SPARQL::Algebra::Operator::BGP.new
 
       # Filter trickls up to GroupGraphPatternSub
       add_prod_datum(:filter, data[:filter])
@@ -679,7 +886,10 @@ module SPARQL::Grammar
       end
     end
 
-    # [57]  	OptionalGraphPattern	  ::=  	'OPTIONAL' GroupGraphPattern
+    # [57] OptionalGraphPattern ::= 'OPTIONAL' GroupGraphPattern
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:OptionalGraphPattern) do |input, data, callback|
       expr = nil
       query = data[:query] ? data[:query].first : SPARQL::Algebra::Operator::BGP.new
@@ -692,7 +902,10 @@ module SPARQL::Grammar
       end
     end
 
-    # [58]  	GraphGraphPattern	  ::=  	'GRAPH' VarOrIri GroupGraphPattern
+    # [58] GraphGraphPattern ::= 'GRAPH' VarOrIri GroupGraphPattern
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:GraphGraphPattern) do |input, data, callback|
       name = (data[:VarOrIri]).last
       bgp = data[:query] ? data[:query].first : SPARQL::Algebra::Operator::BGP.new
@@ -703,21 +916,43 @@ module SPARQL::Grammar
       end
     end
 
-    # [60]  Bind                    ::= 'BIND' '(' Expression 'AS' Var ')'
+    # [59]  ServiceGraphPattern ::= 'SERVICE' 'SILENT'? VarOrIri GroupGraphPattern
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
+    production(:ServiceGraphPattern) do |input, data, callback|
+      args = []
+      args << :silent if data[:silent]
+      args << (data[:VarOrIri]).last
+      args << data.fetch(:query, [SPARQL::Algebra::Operator::BGP.new]).first
+      service = SPARQL::Algebra::Expression.for(:service, *args)
+      add_prod_data(:query, service)
+    end
+
+    # [60]  Bind ::= 'BIND' '(' Expression 'AS' Var ')'
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:Bind) do |input, data, callback|
       add_prod_datum :extend, [data[:Expression].unshift(data[:Var].first)]
     end
 
-    # [61]  InlineData	            ::= 'VALUES' DataBlock
+    # [61]  InlineData ::= 'VALUES' DataBlock
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:InlineData) do |input, data, callback|
       debug("InlineData") {"vars: #{data[:Var].inspect}, row: #{data[:row].inspect}"}
       add_prod_datum :query, SPARQL::Algebra::Expression.for(:table,
-        data[:Var].unshift(:vars),
+        Array(data[:Var]).unshift(:vars),
         *data[:row]
       )
     end
 
-    # [63]  InlineDataOneVar	      ::= Var '{' DataBlockValue* '}'
+    # [63]  InlineDataOneVar ::= Var '{' DataBlockValue* '}'
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:InlineDataOneVar) do |input, data, callback|
       add_prod_datum :Var, data[:Var]
 
@@ -726,8 +961,11 @@ module SPARQL::Grammar
       end
     end
 
-    # [64]  InlineDataFull	        ::= ( NIL | '(' Var* ')' )
-    #                                '{' ( '(' DataBlockValue* ')' | NIL )* '}'
+    # [64]  InlineDataFull ::= ( NIL | '(' Var* ')' )
+    #                          '{' ( '(' DataBlockValue* ')' | NIL )* '}'
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:InlineDataFull) do |input, data, callback|
       vars = data[:Var]
       add_prod_datum :Var, vars
@@ -745,7 +983,10 @@ module SPARQL::Grammar
       end
     end
 
-    # _InlineDataFull_6	        ::=  '(' '(' DataBlockValue* ')' | NIL ')'
+    # _InlineDataFull_6 ::=  '(' '(' DataBlockValue* ')' | NIL ')'
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:_InlineDataFull_6) do |input, data, callback|
       if data[:DataBlockValue]
         add_prod_data :rowdata, data[:DataBlockValue].map {|v| v unless v == :undef}
@@ -754,19 +995,28 @@ module SPARQL::Grammar
       end
     end
 
-    # [65]  DataBlockValue	        ::= QuotedTriple | iri | RDFLiteral | NumericLiteral | BooleanLiteral | 'UNDEF'
+    # [65]  DataBlockValue ::= QuotedTriple | iri | RDFLiteral | NumericLiteral | BooleanLiteral | 'UNDEF'
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:DataBlockValue) do |input, data, callback|
       add_prod_datum :DataBlockValue, data.values.first
     end
 
-    # [66]  MinusGraphPattern       ::= 'MINUS' GroupGraphPattern
+    # [66]  MinusGraphPattern ::= 'MINUS' GroupGraphPattern
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:MinusGraphPattern) do |input, data, callback|
       query = data[:query] ? data[:query].first : SPARQL::Algebra::Operator::BGP.new
       add_prod_data(:minus, query)
     end
 
-    # [67]  	GroupOrUnionGraphPattern	  ::=  	GroupGraphPattern
+    # [67] GroupOrUnionGraphPattern ::= GroupGraphPattern
     #                                           ( 'UNION' GroupGraphPattern )*
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:GroupOrUnionGraphPattern) do |input, data, callback|
       res = Array(data[:query]).first
       if data[:union]
@@ -782,17 +1032,26 @@ module SPARQL::Grammar
     end
 
     # ( 'UNION' GroupGraphPattern )*
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:_GroupOrUnionGraphPattern_1) do |input, data, callback|
       input[:union] = Array(data[:union]).unshift(data[:query].first)
     end
 
-    # [68]  	Filter	  ::=  	'FILTER' Constraint
+    # [68] Filter ::= 'FILTER' Constraint
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:Filter) do |input, data, callback|
       add_prod_datum(:filter, data[:Constraint])
     end
 
-    # [69]  	Constraint	  ::=  	BrackettedExpression | BuiltInCall
+    # [69] Constraint ::= BrackettedExpression | BuiltInCall
     #                           | FunctionCall
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:Constraint) do |input, data, callback|
       if data[:Expression]
         # Resolve expression to the point it is either an atom or an s-exp
@@ -804,28 +1063,41 @@ module SPARQL::Grammar
       end
     end
 
-    # [70]  	FunctionCall	  ::=  	iri ArgList
+    # [70] FunctionCall ::= iri ArgList
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     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
+    # [71] ArgList ::= NIL
     #                     | '(' 'DISTINCT'? Expression ( ',' Expression )* ')'
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:ArgList) do |input, data, callback|
       data.values.each {|v| add_prod_datum(:ArgList, v)}
     end
 
-    # [72]  	ExpressionList	  ::=  	NIL
+    # [72] ExpressionList ::= NIL
     #                             | '(' Expression ( ',' Expression )* ')'
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:ExpressionList) do |input, data, callback|
       data.values.each {|v| add_prod_datum(:ExpressionList, v)}
     end
 
-    # [73]  	ConstructTemplate	  ::=  	'{' ConstructTriples? '}'
+    # [73] ConstructTemplate ::= '{' ConstructTriples? '}'
     start_production(:ConstructTemplate) do |input, data, callback|
       # Generate BNodes instead of non-distinguished variables
       self.gen_bnodes
     end
+
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:ConstructTemplate) do |input, data, callback|
       # Generate BNodes instead of non-distinguished variables
       self.gen_bnodes(false)
@@ -833,13 +1105,13 @@ module SPARQL::Grammar
       add_prod_datum(:ConstructTemplate, data[:ConstructTemplate])
     end
 
-    # [75]  	TriplesSameSubject	  ::=  	VarOrTermOrQuotedTP PropertyListNotEmpty
-    #                                 |	TriplesNode PropertyList
+    # [75] TriplesSameSubject ::= VarOrTermOrQuotedTP PropertyListNotEmpty
+    #                                 | TriplesNode PropertyList
     production(:TriplesSameSubject) do |input, data, callback|
       add_prod_datum(:pattern, data[:pattern])
     end
 
-    # [77]  	PropertyListNotEmpty	  ::=  	Verb ObjectList
+    # [77] PropertyListNotEmpty ::= Verb ObjectList
     #                                       ( ';' ( Verb ObjectList )? )*
     start_production(:PropertyListNotEmpty) do |input, data, callback|
       subject = input[:VarOrTermOrQuotedTP] || input[:TriplesNode] || input[:GraphNode]
@@ -850,47 +1122,58 @@ module SPARQL::Grammar
       add_prod_datum(:pattern, data[:pattern])
     end
 
-    # [78]  	Verb	  ::=  	VarOrIri | 'a'
+    # [78] Verb ::= VarOrIri | 'a'
+    #
+    # Output to input is `:Verb`.
     production(:Verb) do |input, data, callback|
       input[:Verb] = data.values.first
     end
 
-    # [79]  	ObjectList	  ::=  	Object ( ',' Object )*
+    # [79] ObjectList ::= Object ( ',' Object )*
+    #
+    # Adds `:Subject`, `:Verb`, and `:VerbPath` from input to data with error checking.
     start_production(:ObjectList) do |input, data, callback|
       # Called after Verb. The prod_data stack should have Subject and Verb elements
-      data[:Subject] = prod_data[:Subject]
-      error(nil, "Expected Subject", production: :ObjectList) if !prod_data[:Subject] && validate?
-      error(nil, "Expected Verb", production: :ObjectList) if !(prod_data[:Verb] || prod_data[:VerbPath]) && validate?
-      data[:Verb] = prod_data[:Verb] if prod_data[:Verb]
-      data[:VerbPath] = prod_data[:VerbPath] if prod_data[:VerbPath]
+      data[:Subject] = input[:Subject]
+      error(nil, "Expected Subject", production: :ObjectList) if !input[:Subject] && validate?
+      error(nil, "Expected Verb", production: :ObjectList) if !(input[:Verb] || input[:VerbPath]) && validate?
+      data[:Verb] = input[:Verb] if input[:Verb]
+      data[:VerbPath] = input[:VerbPath] if input[:VerbPath]
     end
     production(:ObjectList) do |input, data, callback|
       add_prod_datum(:pattern, data[:pattern])
-      add_prod_datum(:path, data[:path])
     end
 
-    # [80]  	Object	  ::=  	GraphNode AnnotationPattern?
+    # [80] Object ::= GraphNode AnnotationPattern?
+    #
+    # Sets `:Subject` and `:Verb` in data from input.
     start_production(:Object) do |input, data, callback|
       data[:Subject] = Array(input[:Subject]).first
       data[:Verb] = Array(input[:Verb]).first
     end
+
+    #
+    # Input from `data` is `:Subject`, `:Verb` or `:VerbPath`, and `GraphNode`.
+    # Output to prod_data is `:pattern`, either from `:Subject`, `:Verb`, and `GraphNode` or a new path if `VerbPath` is present instead of `Verb`.
     production(:Object) do |input, data, callback|
       object = data[:GraphNode]
       add_prod_datum(:pattern, data[:pattern])
       if object
-        if prod_data[:Verb]
-          add_pattern(:Object, subject: prod_data[:Subject], predicate: prod_data[:Verb], object: object)
-        elsif prod_data[:VerbPath]
-          add_prod_datum(:path,
+        if input[:Verb]
+          add_pattern(:Object, subject: input[:Subject], predicate: input[:Verb], object: object)
+        elsif input[:VerbPath]
+          add_prod_datum(:pattern,
             SPARQL::Algebra::Expression(:path,
-                                        prod_data[:Subject].first,
-                                        prod_data[:VerbPath],
+                                        input[:Subject].first,
+                                        input[:VerbPath],
                                         object.first))
         end
       end
     end
+
+    # AnnotationPattern?
     start_production(:_Object_1) do |input, data, callback|
-      pattern = RDF::Query::Pattern.new(input[:Subject], input[:Verb], input[:GraphNode].first)
+      pattern = RDF::Query::Pattern.new(input[:Subject], input[:Verb], input[:GraphNode].first, quoted: true)
       error("ObjectPath", "Expected Verb",
         production: :_Object_1) unless input[:Verb]
       data[:TriplesNode] = [pattern]
@@ -899,13 +1182,17 @@ module SPARQL::Grammar
       add_prod_datum(:pattern, data[:pattern])
     end
 
-    # [81]	TriplesSameSubjectPath	::=	VarOrTermOrQuotedTP PropertyListPathNotEmpty | TriplesNode PropertyListPath
+    # [81] TriplesSameSubjectPath ::= VarOrTermOrQuotedTP PropertyListPathNotEmpty | TriplesNode PropertyListPath
     production(:TriplesSameSubjectPath) do |input, data, callback|
       add_prod_datum(:pattern, data[:pattern])
-      add_prod_datum(:path, data[:path])
     end
 
-    # [83]  	PropertyListPathNotEmpty	  ::=  	( VerbPath | VerbSimple ) ObjectList ( ';' ( ( VerbPath | VerbSimple ) ObjectList )? )*
+    # [83] PropertyListPathNotEmpty ::= ( VerbPath | VerbSimple ) ObjectList
+    #                                   ( ';' ( ( VerbPath | VerbSimple )
+    #                                           ObjectList )? )*
+    #
+    # Sets `:Subject` in data from either `:VarOrTermOrQuotedTP`,
+    # `:TriplesNode`, or `:GraphNode` in input with error checking.
     start_production(:PropertyListPathNotEmpty) do |input, data, callback|
       subject = input[:VarOrTermOrQuotedTP] || input[:TriplesNode] || input[:GraphNode]
       error(nil, "Expected VarOrTermOrQuotedTP, got nothing", production: :PropertyListPathNotEmpty) if validate? && !subject
@@ -913,10 +1200,13 @@ module SPARQL::Grammar
     end
     production(:PropertyListPathNotEmpty) do |input, data, callback|
       add_prod_datum(:pattern, data[:pattern])
-      add_prod_datum(:path, data[:path])
     end
 
-    # [84]  	VerbPath	  ::=  	Path
+    # [84] VerbPath ::= Path
+    #
+    # Input from `data` is `:Path` or `:iri`.
+    # Output to prod_data is either `:VerbPath` or `:Verb`.
+    # If `:VerbPath` is added, then any existing `:Verb` is removed.
     production(:VerbPath) do |input, data, callback|
       if data[:Path]
         input.delete(:Verb)
@@ -926,70 +1216,80 @@ module SPARQL::Grammar
       end
     end
 
-    # [85]  	VerbSimple	  ::=  	Var
+    # [85] VerbSimple ::= Var
     production(:VerbSimple) do |input, data, callback|
       input[:Verb] = data.values.flatten.first
     end
 
-    # [86]	ObjectListPath	::=	ObjectPath ("," ObjectPath)*
+    # [86] ObjectListPath ::= ObjectPath ("," ObjectPath)*
+    #
+    # Addes `:Subject` from input to data with error checking.
+    # Also adds either `:Verb` or `:VerbPath`
     start_production(:ObjectListPath) do |input, data, callback|
       # Called after Verb. The prod_data stack should have Subject and Verb elements
-      data[:Subject] = prod_data[:Subject]
-      error(nil, "Expected Subject", production: :ObjectListPath) if !prod_data[:Subject] && validate?
-      error(nil, "Expected Verb", production: :ObjectListPath) if !(prod_data[:Verb] || prod_data[:VerbPath]) && validate?
-      if prod_data[:Verb]
-        data[:Verb] = Array(prod_data[:Verb]).last
+      data[:Subject] = input[:Subject]
+      error(nil, "Expected Subject", production: :ObjectListPath) if !input[:Subject] && validate?
+      error(nil, "Expected Verb", production: :ObjectListPath) if !(input[:Verb] || input[:VerbPath]) && validate?
+      if input[:Verb]
+        data[:Verb] = Array(input[:Verb]).last
       else
-        data[:VerbPath] = prod_data[:VerbPath]
+        data[:VerbPath] = input[:VerbPath]
       end
     end
+
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:ObjectListPath) do |input, data, callback|
       add_prod_datum(:pattern, data[:pattern])
-      add_prod_datum(:path, data[:path])
     end
 
-    # [87]  	ObjectPath	  ::=  	GraphNodePath AnnotationPatternPath?
+    # [87] ObjectPath ::= GraphNodePath AnnotationPatternPath?
+    #
+    # Adds `:Subject` and `:Verb` to data from input.
     start_production(:ObjectPath) do |input, data, callback|
       data[:Subject] = Array(input[:Subject]).first
       data[:Verb] = Array(input[:Verb]).first
     end
+
+    # Input from `data` `:Subject`, either `:Verb` or `:VerbPath`, `:GraphNode` from GraphNodePath is used as the object, and `:pattern`.
+    # Output to prod_data is either a pattern including `:Subject`, `:Verb` and `:GraphNode`, or an `Object::Path` using `:VerbPath` instead of `:Verb`. Also, any `:pattern` from data is sent to prod_ddata
     production(:ObjectPath) do |input, data, callback|
-      object = data[:VarOrTermOrQuotedTP] || data[:TriplesNode] || data[:GraphNode]
-      if object
-        if prod_data[:Verb]
-          if data[:pattern] && data[:path]
-            # Generate a sequence (for collection of paths)
-            data[:pattern].unshift(RDF::Query::Pattern.new(prod_data[:Subject].first, prod_data[:Verb], object.first))
-            bgp = SPARQL::Algebra::Expression[:bgp, data[:pattern]]
-            add_prod_datum(:path, SPARQL::Algebra::Expression[:sequence, bgp, *data[:path]])
-          elsif data[:path]
-            # AnnotationPatternPath case
-            add_prod_datum(:path, data[:path])
-          else
-            add_pattern(:Object, subject: prod_data[:Subject], predicate: prod_data[:Verb], object: object)
-            add_prod_datum(:pattern, data[:pattern])
-          end
-        else
-          add_prod_datum(:path,
-            SPARQL::Algebra::Expression(:path,
-                                        Array(prod_data[:Subject]).first,
-                                        prod_data[:VerbPath],
-                                        object.first))
-        end
+      subject = data[:Subject]
+      verb = data[:Verb]
+      object = Array(data[:GraphNode]).first
+      if verb
+        add_prod_datum(:pattern, RDF::Query::Pattern.new(subject, verb, object))
+      else
+        add_prod_datum(:pattern, SPARQL::Algebra::Expression(:path,
+                                        subject,
+                                        input[:VerbPath],
+                                        object))
       end
+      add_prod_datum(:pattern, data[:pattern])
     end
+
+    # AnnotationPatternPath?
+    #
+    # Create `:TriplesNode` in data used as the subject of annotations
     start_production(:_ObjectPath_1) do |input, data, callback|
-      pattern = RDF::Query::Pattern.new(input[:Subject], input[:Verb], input[:GraphNode].first)
       error("ObjectPath", "Expected Verb",
         production: :_ObjectPath_1) unless input[:Verb]
+      pattern = RDF::Query::Pattern.new(input[:Subject], input[:Verb], input[:GraphNode].first, quoted: true)
       data[:TriplesNode] = [pattern]
     end
+
+    #
+    # Input from `data` is `:pattern`.
+    # Output to prod_data is `:pattern`.
     production(:_ObjectPath_1) do |input, data, callback|
       add_prod_datum(:pattern, data[:pattern])
     end
 
-    # [88]  	Path	  ::=  	PathAlternative
-    # output is a :Path or :iri
+    # [88] Path ::= PathAlternative
+    #
+    # Input from data is `:Path`
+    # Output to input is either `:iri` or `:Path`, depending on if `:Path` is an IRI or not.
     production(:Path) do |input, data, callback|
       if data[:Path].is_a?(RDF::URI)
         input[:iri] = data[:Path]
@@ -998,7 +1298,10 @@ module SPARQL::Grammar
       end
     end
 
-    # [89]  	PathAlternative	  ::=  	PathSequence ( '|' PathSequence )*
+    # [89] PathAlternative ::= PathSequence ( '|' PathSequence )*
+    #
+    # Input from `data` is `:PathSequence` containing one or more path objects.
+    # Output to prod_data is `:Path`, containing a nested sequence of `Algebra::Alt` connecting the elements from `:PathSequence`, unless there is only one such element, in which case it is added directly.
     production(:PathAlternative) do |input, data, callback|
       lhs = Array(data[:PathSequence]).shift
       while data[:PathSequence] && !data[:PathSequence].empty?
@@ -1009,11 +1312,17 @@ module SPARQL::Grammar
     end
 
     # ( '|' PathSequence )*
+    #
+    # Input from `data` is `:PathSequence`.
+    # Output to prod_data is `:PathSequence` which is accumulated.
     production(:_PathAlternative_1) do |input, data, callback|
       input[:PathSequence] += data[:PathSequence]
     end
 
-    # [90]  	PathSequence	  ::=  	PathEltOrInverse ( '/' PathEltOrInverse )*
+    # [90] PathSequence ::= PathEltOrInverse ( '/' PathEltOrInverse )*
+    #
+    # Input from `data` is `:PathSequence` containing one or more path objects.
+    # Output to prod_data is `:Path`, containing a nested sequence of `Algebra::Seq` connecting the elements from `:PathSequence`, unless there is only one such element, in which case it is added directly.
     production(:PathSequence) do |input, data, callback|
       lhs = data[:PathEltOrInverse].shift
       while data[:PathEltOrInverse] && !data[:PathEltOrInverse].empty?
@@ -1024,22 +1333,39 @@ module SPARQL::Grammar
     end
 
     # ( '/' PathEltOrInverse )*
+    #
+    # Input from `data` is `:PathSequence`.
+    # Output to prod_data is `:PathSequence` which is accumulated.
     production(:_PathSequence_1) do |input, data, callback|
       input[:PathEltOrInverse] += data[:PathEltOrInverse]
     end
 
-    # [91]  	PathElt	  ::=  	PathPrimary PathMod?
+    # [91] PathElt ::= PathPrimary PathMod?
+    #
+    # Input from `data` is `:PathMod` and `:PathPrimary`.
+    # Output to prod_data is `:Path` a possibly modified `:PathPrimary`.
     production(:PathElt) do |input, data, callback|
       path_mod = data.delete(:PathMod) if data.has_key?(:PathMod)
       path_mod ||= data.delete(:MultiplicativeExpression) if data.has_key?(:MultiplicativeExpression)
       path_mod = path_mod.first if path_mod
 
-      res = data[:PathPrimary]
-      res = SPARQL::Algebra::Expression("path#{path_mod}", res) if path_mod
+      res = case path_mod
+      when SPARQL::Algebra::Expression
+        # Path range :p{m,n}
+        path_mod.operands[2] = data[:PathPrimary]
+        path_mod
+      when nil
+        data[:PathPrimary]
+      else
+        SPARQL::Algebra::Expression("path#{path_mod}", data[:PathPrimary])
+      end
       input[:Path] = res
     end
 
-    # [92]  	PathEltOrInverse	  ::=  	PathElt | '^' PathElt
+    # [92] PathEltOrInverse ::= PathElt | '^' PathElt
+    #
+    # Input from `data` is `:reverse` and `:Path`.
+    # Output to prod_data is `:Path` a possibly reversed `:Path`.
     production(:PathEltOrInverse) do |input, data, callback|
       res = if data[:reverse]
         SPARQL::Algebra::Expression(:reverse, data[:Path])
@@ -1049,7 +1375,44 @@ module SPARQL::Grammar
       input[:PathEltOrInverse] = [res]
     end
 
-    # [94]  	PathPrimary	  ::=  	iri | 'a' | '!' PathNegatedPropertySet | '(' Path ')'
+    # [93]  PathMod ::= '*' | '?' | '+' | '{' INTEGER? (',' INTEGER?)? '}'
+    # '{' INTEGER? (',' INTEGER?)? '}'
+    start_production(:_PathMod_1) do |input, data, callback|
+      data[:pathRange] = [nil]
+    end
+    production(:_PathMod_1) do |input, data, callback|
+      raise Error, "expect property range to have integral elements" if data[:pathRange].all?(&:nil?)
+      min, max = data[:pathRange]
+      min ||= 0
+      max = min if data[:pathRange].length == 1
+      max ||= :*
+
+      # Last operand added in :PathElt
+      add_prod_data(:PathMod, SPARQL::Algebra::Expression(:pathRange, min, max, RDF.nil))
+    end
+
+    # INTEGER?
+    production(:_PathMod_2) do |input, data, callback|
+      input[:pathRange][0] = data[:literal].object
+    end
+
+    # (',' INTEGER?)
+    start_production(:_PathMod_4) do |input, data, callback|
+      data[:pathRange] = [nil, nil]
+    end
+    production(:_PathMod_4) do |input, data, callback|
+      input[:pathRange][1] ||= data.fetch(:pathRange, [0, nil])[1]
+    end
+
+    # INTEGER?
+    production(:_PathMod_5) do |input, data, callback|
+      input[:pathRange][1] = data[:literal].object
+    end
+
+    # [94] PathPrimary ::= iri | 'a' | '!' PathNegatedPropertySet | '(' Path ')'
+    #
+    # Input from `data` is one of `:Verb`, `:iri`, `:PathNegatedPropertySet`, or `:Path`.
+    # Output to prod_data is `:PathPrimary`.
     production(:PathPrimary) do |input, data, callback|
       input[:PathPrimary] = case
       when data[:Verb]                   then data[:Verb]
@@ -1059,90 +1422,128 @@ module SPARQL::Grammar
       end
     end
 
-    # [95]  	PathNegatedPropertySet	  ::=  	PathOneInPropertySet | '(' ( PathOneInPropertySet ( '|' PathOneInPropertySet )* )? ')'
+    # [95] PathNegatedPropertySet ::= PathOneInPropertySet | '(' ( PathOneInPropertySet ( '|' PathOneInPropertySet )* )? ')'
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:PathNegatedPropertySet) do |input, data, callback|
       input[:Path] = SPARQL::Algebra::Expression(:notoneof, *Array(data[:Path]))
     end
 
     # ( '|' PathOneInPropertySet )* )?
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:_PathNegatedPropertySet_4) do |input, data, callback|
       add_prod_datum(:Path, data[:Path])
     end
 
-    # [96]  	PathOneInPropertySet	  ::=  	iri | 'a' | '^' ( iri | 'a' )
+    # [96] PathOneInPropertySet ::= iri | 'a' | '^' ( iri | 'a' )
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:PathOneInPropertySet) do |input, data, callback|
       term = (Array(data[:iri]) || data[:Verb]).first
       term = SPARQL::Algebra::Expression(:reverse, term) if data[:reverse]
       input[:Path] = [term]
     end
 
-    # [98]  	TriplesNode	  ::=  	Collection |	BlankNodePropertyList
+    # [98] TriplesNode ::= Collection | BlankNodePropertyList
     start_production(:TriplesNode) do |input, data, callback|
       # Called after Verb. The prod_data stack should have Subject and Verb elements
       data[:TriplesNode] = bnode
     end
+
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:TriplesNode) do |input, data, callback|
       add_prod_datum(:pattern, data[:pattern])
       add_prod_datum(:TriplesNode, data[:TriplesNode])
     end
 
-    # [100]	TriplesNodePath	::=	CollectionPath | BlankNodePropertyListPath
+    # [100] TriplesNodePath ::= CollectionPath | BlankNodePropertyListPath
     start_production(:TriplesNodePath) do |input, data, callback|
       # Called after Verb. The prod_data stack should have Subject and Verb elements
       data[:TriplesNode] = bnode
     end
+
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:TriplesNodePath) do |input, data, callback|
       add_prod_datum(:pattern, data[:pattern])
-      add_prod_datum(:path, data[:path])
       add_prod_datum(:TriplesNode, data[:TriplesNode])
     end
 
-    # [102]  	Collection	  ::=  	'(' GraphNode+ ')'
+    # [102] Collection ::= '(' GraphNode+ ')'
     start_production(:Collection) do |input, data, callback|
       # Tells the TriplesNode production to collect and not generate statements
-      data[:Collection] = prod_data[:TriplesNode]
+      data[:Collection] = input[:TriplesNode]
     end
+
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:Collection) do |input, data, callback|
       expand_collection(data)
     end
 
-    # [103]	CollectionPath	::=	"(" GraphNodePath+ ")"
+    # [103] CollectionPath ::= "(" GraphNodePath+ ")"
     start_production(:CollectionPath) do |input, data, callback|
       # Tells the TriplesNode production to collect and not generate statements
-      data[:Collection] = prod_data[:TriplesNode]
+      data[:Collection] = input[:TriplesNode]
     end
+
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:CollectionPath) do |input, data, callback|
       expand_collection(data)
-      add_prod_datum(:path, data[:path])
     end
 
-    # [104]  	GraphNode	  ::=  	VarOrTermOrQuotedTP |	TriplesNode
+    # [104] GraphNode ::= VarOrTermOrQuotedTP | TriplesNode
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:GraphNode) do |input, data, callback|
       term = data[:VarOrTermOrQuotedTP] || data[:TriplesNode]
       add_prod_datum(:pattern, data[:pattern])
       add_prod_datum(:GraphNode, term)
     end
 
-    # [105]	GraphNodePath	::=	VarOrTermOrQuotedTP | TriplesNodePath
+    # [105] GraphNodePath ::= VarOrTermOrQuotedTP | TriplesNodePath
+    #
+    # Input from `data` is either `:VarOrTermOrQUotedTP` or `:TriplesNode`.
+    # Additionally, `:pattern`. Also, `:pattern` and `:path`.
+    # Output to prod_data is `:GraphNode`, along with any `:path` and `:pattern`.
     production(:GraphNodePath) do |input, data, callback|
       term = data[:VarOrTermOrQuotedTP] || data[:TriplesNode]
       add_prod_datum(:pattern, data[:pattern])
-      add_prod_datum(:path, data[:path])
       add_prod_datum(:GraphNode, term)
     end
 
-    # [106s]  	VarOrTermOrQuotedTP        ::= Var | GraphTerm | EmbTP
+    # [106s] VarOrTermOrQuotedTP ::= Var | GraphTerm | QuotedTP
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:VarOrTermOrQuotedTP) do |input, data, callback|
       data.values.each {|v| add_prod_datum(:VarOrTermOrQuotedTP, v)}
     end
 
-    # [107]  	VarOrIri	  ::=  	Var | iri
+    # [107] VarOrIri ::= Var | iri
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:VarOrIri) do |input, data, callback|
       data.values.each {|v| add_prod_datum(:VarOrIri, v)}
     end
 
-    # [109]  	GraphTerm	  ::=  	iri |	RDFLiteral |	NumericLiteral
-    #                         |	BooleanLiteral |	BlankNode |	NIL
+    # [109] GraphTerm ::= iri | RDFLiteral | NumericLiteral
+    #                         | BooleanLiteral | BlankNode | NIL
+    #
+    # Input from `data` is one of `:iri`, `:literal`, `:BlankNode`, or `:NIL`.
+    # Output to prod_data is `:GraphTerm` created from the data.
     production(:GraphTerm) do |input, data, callback|
       add_prod_datum(:GraphTerm,
                       data[:iri] ||
@@ -1151,42 +1552,60 @@ module SPARQL::Grammar
                       data[:NIL])
     end
 
-    # [110]  	Expression	  ::=  	ConditionalOrExpression
+    # [110] Expression ::= ConditionalOrExpression
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:Expression) do |input, data, callback|
       add_prod_datum(:Expression, data[:Expression])
     end
 
-    # [111]  	ConditionalOrExpression	  ::=  	ConditionalAndExpression
-    #                                         ( '||' ConditionalAndExpression )*
+    # [111] ConditionalOrExpression ::= ConditionalAndExpression
+    #                                   ( '||' ConditionalAndExpression )*
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:ConditionalOrExpression) do |input, data, callback|
       add_operator_expressions(:_OR, data)
     end
 
     # ( '||' ConditionalAndExpression )*
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:_ConditionalOrExpression_1) do |input, data, callback|
       accumulate_operator_expressions(:ConditionalOrExpression, :_OR, data)
     end
 
-    # [112]  	ConditionalAndExpression	  ::=  	ValueLogical ( '&&' ValueLogical )*
+    # [112] ConditionalAndExpression ::= ValueLogical ( '&&' ValueLogical )*
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:ConditionalAndExpression) do |input, data, callback|
       add_operator_expressions(:_AND, data)
     end
 
     # ( '||' ConditionalAndExpression )*
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:_ConditionalAndExpression_1) do |input, data, callback|
       accumulate_operator_expressions(:ConditionalAndExpression, :_AND, data)
     end
 
-    # [114]  	RelationalExpression	  ::=  	NumericExpression
-    #                                       ( '=' NumericExpression
-    #                                        | '!=' NumericExpression
-    #                                        | '<' NumericExpression
-    #                                        | '>' NumericExpression
-    #                                        | '<=' NumericExpression
-    #                                        | '>=' NumericExpression
-    #                                        | 'IN' ExpressionList
-    #                                        | 'NOT' 'IN' ExpressionList
-    #                                        )?
+    # [114] RelationalExpression ::= NumericExpression
+    #                                ( '=' NumericExpression
+    #                                | '!=' NumericExpression
+    #                                | '<' NumericExpression
+    #                                | '>' NumericExpression
+    #                                | '<=' NumericExpression
+    #                                | '>=' NumericExpression
+    #                                | 'IN' ExpressionList
+    #                                | 'NOT' 'IN' ExpressionList
+    #                                )?
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:RelationalExpression) do |input, data, callback|
       if data[:_Compare_Numeric]
         add_prod_datum(:Expression, SPARQL::Algebra::Expression.for(data[:_Compare_Numeric].insert(1, *data[:Expression])))
@@ -1203,6 +1622,9 @@ module SPARQL::Grammar
     end
 
     # ( '=' NumericExpression | '!=' NumericExpression | ... )?
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:_RelationalExpression_1) do |input, data, callback|
       if data[:RelationalExpression]
         add_prod_datum(:_Compare_Numeric, data[:RelationalExpression] + data[:Expression])
@@ -1214,11 +1636,17 @@ module SPARQL::Grammar
     end
 
     # 'IN' ExpressionList
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:_RelationalExpression_9) do |input, data, callback|
       add_prod_datum(:in, data[:ExpressionList])
     end
 
     # 'NOT' 'IN' ExpressionList
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:_RelationalExpression_10) do |input, data, callback|
       add_prod_datum(:notin, data[:ExpressionList])
     end
@@ -1226,10 +1654,14 @@ module SPARQL::Grammar
     # [116] AdditiveExpression ::= MultiplicativeExpression
     #                              ( '+' MultiplicativeExpression
     #                              | '-' MultiplicativeExpression
-    #                              | ( NumericLiteralPositive | NumericLiteralNegative )
+    #                              | ( NumericLiteralPositive
+    #                                | NumericLiteralNegative )
     #                                ( ( '*' UnaryExpression )
     #                              | ( '/' UnaryExpression ) )?
     #                              )*
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:AdditiveExpression) do |input, data, callback|
       add_operator_expressions(:_Add_Sub, data)
     end
@@ -1240,11 +1672,17 @@ module SPARQL::Grammar
     #   ( ( '*' UnaryExpression )
     # | ( '/' UnaryExpression ) )?
     # )*
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:_AdditiveExpression_1) do |input, data, callback|
       accumulate_operator_expressions(:AdditiveExpression, :_Add_Sub, data)
     end
 
     # | ( NumericLiteralPositive | NumericLiteralNegative )
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:_AdditiveExpression_7) do |input, data, callback|
       lit = data[:literal]
       val = lit.to_s
@@ -1253,23 +1691,32 @@ module SPARQL::Grammar
       add_prod_datum(:Expression, [lit.class.new(val)])
     end
 
-    # [117]  	MultiplicativeExpression	  ::=  	UnaryExpression
-    #                                           ( '*' UnaryExpression
-    #                                           | '/' UnaryExpression )*
+    # [117] MultiplicativeExpression ::= UnaryExpression
+    #                                    ( '*' UnaryExpression
+    #                                    | '/' UnaryExpression )*
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:MultiplicativeExpression) do |input, data, callback|
       add_operator_expressions(:_Mul_Div, data)
     end
 
     # ( '*' UnaryExpression
     # | '/' UnaryExpression )*
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:_MultiplicativeExpression_1) do |input, data, callback|
       accumulate_operator_expressions(:MultiplicativeExpression, :_Mul_Div, data)
     end
 
-    # [118]  	UnaryExpression	  ::=  	  '!' PrimaryExpression
-    #                                 |	'+' PrimaryExpression
-    #                                 |	'-' PrimaryExpression
-    #                                 |	PrimaryExpression
+    # [118] UnaryExpression ::= '!' PrimaryExpression
+    #                         | '+' PrimaryExpression
+    #                         | '-' PrimaryExpression
+    #                         | PrimaryExpression
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:UnaryExpression) do |input, data, callback|
       case data[:UnaryExpression]
       when ["!"]
@@ -1286,11 +1733,14 @@ module SPARQL::Grammar
       end
     end
 
-    # [119]  	PrimaryExpression	  ::=  	BrackettedExpression | BuiltInCall
-    #                                 | iriOrFunction | RDFLiteral
-    #                                 | NumericLiteral | BooleanLiteral
-    #                                 | Var
-    #                                 | ExprQuotedTP
+    # [119] PrimaryExpression ::= BrackettedExpression | BuiltInCall
+    #                           | iriOrFunction | RDFLiteral
+    #                           | NumericLiteral | BooleanLiteral
+    #                           | Var
+    #                           | ExprQuotedTP
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:PrimaryExpression) do |input, data, callback|
       if data[:Expression]
         add_prod_datum(:Expression, data[:Expression])
@@ -1312,62 +1762,65 @@ module SPARQL::Grammar
       add_prod_datum(:UnaryExpression, data[:UnaryExpression])
     end
 
-    # [121] BuiltInCall             ::= Aggregate
-    #                                 | 'STR' '(' Expression ')'
-    #                                 | 'LANG' '(' Expression ')'
-    #                                 | 'LANGMATCHES' '(' Expression ',' Expression ')'
-    #                                 | 'DATATYPE' '(' Expression ')'
-    #                                 | 'BOUND' '(' Var ')'
-    #                                 | 'IRI' '(' Expression ')'
-    #                                 | 'URI' '(' Expression ')'
-    #                                 | 'BNODE' ( '(' Expression ')' | NIL )
-    #                                 | 'RAND' NIL
-    #                                 | 'ABS' '(' Expression ')'
-    #                                 | 'CEIL' '(' Expression ')'
-    #                                 | 'FLOOR' '(' Expression ')'
-    #                                 | 'ROUND' '(' Expression ')'
-    #                                 | 'CONCAT' ExpressionList
-    #                                 | SubstringExpression
-    #                                 | 'STRLEN' '(' Expression ')'
-    #                                 | StrReplaceExpression
-    #                                 | 'UCASE' '(' Expression ')'
-    #                                 | 'LCASE' '(' Expression ')'
-    #                                 | 'ENCODE_FOR_URI' '(' Expression ')'
-    #                                 | 'CONTAINS' '(' Expression ',' Expression ')'
-    #                                 | 'STRSTARTS' '(' Expression ',' Expression ')'
-    #                                 | 'STRENDS' '(' Expression ',' Expression ')'
-    #                                 | 'STRBEFORE' '(' Expression ',' Expression ')'
-    #                                 | 'STRAFTER' '(' Expression ',' Expression ')'
-    #                                 | 'YEAR' '(' Expression ')'
-    #                                 | 'MONTH' '(' Expression ')'
-    #                                 | 'DAY' '(' Expression ')'
-    #                                 | 'HOURS' '(' Expression ')'
-    #                                 | 'MINUTES' '(' Expression ')'
-    #                                 | 'SECONDS' '(' Expression ')'
-    #                                 | 'TIMEZONE' '(' Expression ')'
-    #                                 | 'TZ' '(' Expression ')'
-    #                                 | 'NOW' NIL
-    #                                 | 'UUID' NIL
-    #                                 | 'STRUUID' NIL
-    #                                 | 'MD5' '(' Expression ')'
-    #                                 | 'SHA1' '(' Expression ')'
-    #                                 | 'SHA224' '(' Expression ')'
-    #                                 | 'SHA256' '(' Expression ')'
-    #                                 | 'SHA384' '(' Expression ')'
-    #                                 | 'SHA512' '(' Expression ')'
-    #                                 | 'COALESCE' ExpressionList
-    #                                 | 'IF' '(' Expression ',' Expression ',' Expression ')'
-    #                                 | 'STRLANG' '(' Expression ',' Expression ')'
-    #                                 | 'STRDT' '(' Expression ',' Expression ')'
-    #                                 | 'sameTerm' '(' Expression ',' Expression ')'
-    #                                 | 'isIRI' '(' Expression ')'
-    #                                 | 'isURI' '(' Expression ')'
-    #                                 | 'isBLANK' '(' Expression ')'
-    #                                 | 'isLITERAL' '(' Expression ')'
-    #                                 | 'isNUMERIC' '(' Expression ')'
-    #                                 | RegexExpression
-    #                                 | ExistsFunc
-    #                                 | NotExistsFunc
+    # [121] BuiltInCall ::= Aggregate
+    #                     | 'STR' '(' Expression ')'
+    #                     | 'LANG' '(' Expression ')'
+    #                     | 'LANGMATCHES' '(' Expression ',' Expression ')'
+    #                     | 'DATATYPE' '(' Expression ')'
+    #                     | 'BOUND' '(' Var ')'
+    #                     | 'IRI' '(' Expression ')'
+    #                     | 'URI' '(' Expression ')'
+    #                     | 'BNODE' ( '(' Expression ')' | NIL )
+    #                     | 'RAND' NIL
+    #                     | 'ABS' '(' Expression ')'
+    #                     | 'CEIL' '(' Expression ')'
+    #                     | 'FLOOR' '(' Expression ')'
+    #                     | 'ROUND' '(' Expression ')'
+    #                     | 'CONCAT' ExpressionList
+    #                     | SubstringExpression
+    #                     | 'STRLEN' '(' Expression ')'
+    #                     | StrReplaceExpression
+    #                     | 'UCASE' '(' Expression ')'
+    #                     | 'LCASE' '(' Expression ')'
+    #                     | 'ENCODE_FOR_URI' '(' Expression ')'
+    #                     | 'CONTAINS' '(' Expression ',' Expression ')'
+    #                     | 'STRSTARTS' '(' Expression ',' Expression ')'
+    #                     | 'STRENDS' '(' Expression ',' Expression ')'
+    #                     | 'STRBEFORE' '(' Expression ',' Expression ')'
+    #                     | 'STRAFTER' '(' Expression ',' Expression ')'
+    #                     | 'YEAR' '(' Expression ')'
+    #                     | 'MONTH' '(' Expression ')'
+    #                     | 'DAY' '(' Expression ')'
+    #                     | 'HOURS' '(' Expression ')'
+    #                     | 'MINUTES' '(' Expression ')'
+    #                     | 'SECONDS' '(' Expression ')'
+    #                     | 'TIMEZONE' '(' Expression ')'
+    #                     | 'TZ' '(' Expression ')'
+    #                     | 'NOW' NIL
+    #                     | 'UUID' NIL
+    #                     | 'STRUUID' NIL
+    #                     | 'MD5' '(' Expression ')'
+    #                     | 'SHA1' '(' Expression ')'
+    #                     | 'SHA224' '(' Expression ')'
+    #                     | 'SHA256' '(' Expression ')'
+    #                     | 'SHA384' '(' Expression ')'
+    #                     | 'SHA512' '(' Expression ')'
+    #                     | 'COALESCE' ExpressionList
+    #                     | 'IF' '(' Expression ',' Expression ',' Expression ')'
+    #                     | 'STRLANG' '(' Expression ',' Expression ')'
+    #                     | 'STRDT' '(' Expression ',' Expression ')'
+    #                     | 'sameTerm' '(' Expression ',' Expression ')'
+    #                     | 'isIRI' '(' Expression ')'
+    #                     | 'isURI' '(' Expression ')'
+    #                     | 'isBLANK' '(' Expression ')'
+    #                     | 'isLITERAL' '(' Expression ')'
+    #                     | 'isNUMERIC' '(' Expression ')'
+    #                     | RegexExpression
+    #                     | ExistsFunc
+    #                     | NotExistsFunc
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:BuiltInCall) do |input, data, callback|
       input[:BuiltInCall] = if builtin = data.keys.detect {|k| BUILTINS.include?(k)}
         SPARQL::Algebra::Expression.for(
@@ -1384,45 +1837,63 @@ module SPARQL::Grammar
       end
     end
 
-    # [122]  	RegexExpression	  ::=  	'REGEX' '(' Expression ',' Expression
-    #                                 ( ',' Expression )? ')'
+    # [122] RegexExpression ::= 'REGEX' '(' Expression ',' Expression
+    #                           ( ',' Expression )? ')'
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:RegexExpression) do |input, data, callback|
       add_prod_datum(:regex, data[:Expression])
     end
 
-    # [123]  	SubstringExpression	  ::=  	'SUBSTR'
-    #                                     '(' Expression ',' Expression
-    #                                     ( ',' Expression )? ')'
+    # [123] SubstringExpression ::= 'SUBSTR'
+    #                               '(' Expression ',' Expression
+    #                               ( ',' Expression )? ')'
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:SubstringExpression) do |input, data, callback|
       add_prod_datum(:substr, data[:Expression])
     end
 
-    # [124] StrReplaceExpression    ::= 'REPLACE'
-    #                                   '(' Expression ','
-    #                                   Expression ',' Expression
-    #                                   ( ',' Expression )? ')'
+    # [124] StrReplaceExpression ::= 'REPLACE'
+    #                                '(' Expression ','
+    #                                Expression ',' Expression
+    #                                ( ',' Expression )? ')'
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:StrReplaceExpression) do |input, data, callback|
       add_prod_datum(:replace, data[:Expression])
     end
 
-    # [125]  	ExistsFunc	  ::=  	'EXISTS' GroupGraphPattern
+    # [125] ExistsFunc ::= 'EXISTS' GroupGraphPattern
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:ExistsFunc) do |input, data, callback|
       add_prod_datum(:exists, data[:query])
     end
 
-    # [126]  	NotExistsFunc	  ::=  	'NOT' 'EXISTS' GroupGraphPattern
+    # [126] NotExistsFunc ::= 'NOT' 'EXISTS' GroupGraphPattern
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:NotExistsFunc) do |input, data, callback|
       add_prod_datum(:notexists, data[:query])
     end
 
-    # [127] Aggregate               ::= 'COUNT' '(' 'DISTINCT'? ( '*' | Expression ) ')'
-    #                                 | 'SUM' '(' 'DISTINCT'? Expression ')'
-    #                                 | 'MIN' '(' 'DISTINCT'? Expression ')'
-    #                                 | 'MAX' '(' 'DISTINCT'? Expression ')'
-    #                                 | 'AVG' '(' 'DISTINCT'? Expression ')'
-    #                                 | 'SAMPLE' '(' 'DISTINCT'? Expression ')'
-    #                                 | 'GROUP_CONCAT' '(' 'DISTINCT'? Expression
-    #                                   ( ';' 'SEPARATOR' '=' String )? ')'
+    # [127] Aggregate ::= 'COUNT' '(' 'DISTINCT'? ( '*' | Expression ) ')'
+    #                   | 'SUM' '(' 'DISTINCT'? Expression ')'
+    #                   | 'MIN' '(' 'DISTINCT'? Expression ')'
+    #                   | 'MAX' '(' 'DISTINCT'? Expression ')'
+    #                   | 'AVG' '(' 'DISTINCT'? Expression ')'
+    #                   | 'SAMPLE' '(' 'DISTINCT'? Expression ')'
+    #                   | 'GROUP_CONCAT' '(' 'DISTINCT'? Expression
+    #                     ( ';' 'SEPARATOR' '=' String )? ')'
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:Aggregate) do |input, data, callback|
       if aggregate_rule = data.keys.detect {|k| AGGREGATE_RULES.include?(k)}
         parts = [aggregate_rule]
@@ -1433,30 +1904,39 @@ module SPARQL::Grammar
       end
     end
 
-    # [128]  	iriOrFunction	  ::=  	iri ArgList?
+    # [128] iriOrFunction ::= iri ArgList?
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     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
     end
 
-    # [129]  	RDFLiteral	  ::=  	String ( LANGTAG | ( '^^' iri ) )?
+    # [129] RDFLiteral ::= String ( LANGTAG | ( '^^' iri ) )?
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:RDFLiteral) do |input, data, callback|
       if data[:string]
         lit = data.dup
         str = lit.delete(:string)
         lit[:datatype] = lit.delete(:iri) if lit[:iri]
-        lit[:language] = lit.delete(:language).last.downcase if lit[:language]
+        lit[:language] = lit.delete(:language).downcase if lit[:language]
         input[:literal] = RDF::Literal.new(str, **lit) if str
       end
     end
 
-    # [132]  	NumericLiteralPositive	  ::=  	INTEGER_POSITIVE
-    #                                       |	DECIMAL_POSITIVE
-    #                                       |	DOUBLE_POSITIVE
+    # [132] NumericLiteralPositive ::= INTEGER_POSITIVE
+    #                                | DECIMAL_POSITIVE
+    #                                | DOUBLE_POSITIVE
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:NumericLiteralPositive) do |input, data, callback|
       num = data.values.flatten.last
       input[:literal] = num
@@ -1465,9 +1945,12 @@ module SPARQL::Grammar
       add_prod_datum(:UnaryExpression, data[:UnaryExpression])
     end
 
-    # [133]  	NumericLiteralNegative	  ::=  	INTEGER_NEGATIVE
-    #                                       |	DECIMAL_NEGATIVE
-    #                                       |	DOUBLE_NEGATIVE
+    # [133] NumericLiteralNegative ::= INTEGER_NEGATIVE
+    #                                | DECIMAL_NEGATIVE
+    #                                | DOUBLE_NEGATIVE
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:NumericLiteralNegative) do |input, data, callback|
       num = data.values.flatten.last
       input[:literal] = num
@@ -1477,61 +1960,81 @@ module SPARQL::Grammar
     end
 
     # [174] QuotedTP ::= '<<' qtSubjectOrObject Verb qtSubjectOrObject '>>'
+    #
+    # Input from `data` is `:qtSubjectOrObject` from which subject and object are extracted and `:Verb` from which predicate is extracted.
+    # Output to prod_data is `:QuotedTP` containing subject, predicate, and object.
     production(:QuotedTP) do |input, data, callback|
       subject, object = data[:qtSubjectOrObject]
       predicate = data[:Verb]
       add_pattern(:QuotedTP,
                   subject: subject,
                   predicate: predicate,
-                  object: object)
+                  object: object,
+                  quoted: true)
     end
 
     # [175] QuotedTriple ::= '<<' DataValueTerm (iri | 'a') DataValueTerm '>>'
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:QuotedTriple) do |input, data, callback|
       subject, object = data[:DataValueTerm]
       predicate = data[:iri]
       add_pattern(:QuotedTriple,
                   subject: subject,
                   predicate: predicate,
-                  object: object)
+                  object: object,
+                  quoted: true)
     end
 
-    # [176] qtSubjectOrObject ::=	Var | BlankNode | iri | RDFLiteral
-    #                            | NumericLiteral | BooleanLiteral | QuotedTP
+    # [176] qtSubjectOrObject ::= Var | BlankNode | iri | RDFLiteral
+    #                           | NumericLiteral | BooleanLiteral | QuotedTP
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:qtSubjectOrObject) do |input, data, callback|
       data.values.each {|v| add_prod_datum(:qtSubjectOrObject, v)}
     end
 
-    # [177] DataValueTerm           ::= iri | RDFLiteral | NumericLiteral | BooleanLiteral | QuotedTriple
+    # [177] DataValueTerm ::= iri | RDFLiteral | NumericLiteral | BooleanLiteral | QuotedTriple
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:DataValueTerm) do |input, data, callback|
       add_prod_datum :DataValueTerm, data.values.first
     end
 
-    # [180]	AnnotationPatternPath	      ::=	'{|' PropertyListPathNotEmpty '|}'
+    # [180] AnnotationPatternPath ::= '{|' PropertyListPathNotEmpty '|}'
     start_production(:AnnotationPatternPath) do |input, data, callback|
       data[:TriplesNode] = input[:TriplesNode]
     end
+
+    #
+    # Add `:TriplesNode` as subject of collected patterns
+    # Input from `data` is `:pattern`.
+    # Output to prod_data is `:pattern`.
     production(:AnnotationPatternPath) do |input, data, callback|
-      if data[:pattern]
-        add_prod_datum(:pattern, data[:pattern])
-      elsif data[:path]
-        # Replace the subject in the path with the node being annotated.
-        data[:path].first.operands[0] = data[:TriplesNode]
-        add_prod_datum(:path, data[:path])
-      end
+      add_prod_datum(:pattern, data[:pattern])
     end
 
     # [181] ExprQuotedTP ::= '<<' ExprVarOrTerm Verb ExprVarOrTerm '>>'
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:ExprQuotedTP) do |input, data, callback|
       subject, object = data[:ExprVarOrTerm]
       predicate = data[:Verb]
       add_pattern(:ExprQuotedTP,
                   subject: subject,
                   predicate: predicate,
-                  object: object)
+                  object: object,
+                  quoted: true)
     end
 
-    # [182] ExprVarOrTerm ::=	iri | RDFLiteral | NumericLiteral | BooleanLiteral | Var | ExprQuotedTP
+    # [182] ExprVarOrTerm ::= iri | RDFLiteral | NumericLiteral | BooleanLiteral | Var | ExprQuotedTP
+    #
+    # Input from `data` is TODO.
+    # Output to prod_data is TODO.
     production(:ExprVarOrTerm) do |input, data, callback|
       data.values.each {|v| add_prod_datum(:ExprVarOrTerm, v)}
     end
@@ -1541,20 +2044,23 @@ module SPARQL::Grammar
     #
     # @param  [String, IO, StringIO, #to_s]          input
     # @param  [Hash{Symbol => Object}] options
-    # @option options [Hash]     :prefixes     (Hash.new)
-    #   the prefix mappings to use (for acessing intermediate parser productions)
-    # @option options [#to_s]    :base_uri     (nil)
-    #   the base URI to use when resolving relative URIs (for acessing intermediate parser productions)
+    # @option options [Boolean]  :all_vars (false)
+    #   If `true`, emits on empty `project` operator when parsing `SELECT *`, which will emit all in-scope variables, rather than just those used in solutions.
+    #   In the next minor release, the default for this option will change to `true`.
     # @option options [#to_s]    :anon_base     ("b0")
     #   Basis for generating anonymous Nodes
+    # @option options [#to_s]    :base_uri     (nil)
+    #   the base URI to use when resolving relative URIs (for acessing intermediate parser productions)
+    # @option options [Logger, #write, #<<] :logger
+    #   Record error/info/debug output
+    # @option options [Hash]     :prefixes     (Hash.new)
+    #   the prefix mappings to use (for acessing intermediate parser productions)
     # @option options [Boolean] :resolve_iris (false)
     #   Resolve prefix and relative IRIs, otherwise, when serializing the parsed SSE
     #   as S-Expressions, use the original prefixed and relative URIs along with `base` and `prefix`
     #   definitions.
     # @option options [Boolean]  :validate     (false)
     #   whether to validate the parsed statements and values
-    # @option options [Logger, #write, #<<] :logger
-    #   Record error/info/debug output
     # @yield  [parser] `self`
     # @yieldparam  [SPARQL::Grammar::Parser] parser
     # @yieldreturn [void] ignored
@@ -1615,7 +2121,7 @@ module SPARQL::Grammar
     #
     # @param [Symbol, #to_s] prod The starting production for the parser.
     #   It may be a URI from the grammar, or a symbol representing the local_name portion of the grammar URI.
-    # @return [Array]
+    # @return [RDF::Queryable]
     # @see https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
     # @see https://axel.deri.ie/sparqltutorial/ESWC2007_SPARQL_Tutorial_unit2b.pdf
     def parse(prod = START)
@@ -1811,9 +2317,7 @@ module SPARQL::Grammar
       # If we have a base URI, use that when constructing a new URI
       value = RDF::URI(value)
       if base_uri && value.relative?
-        u = base_uri.join(value)
-        #u.lexical = "<#{value}>" unless resolve_iris?
-        #u
+        base_uri.join(value)
       else
         value
       end
@@ -1823,10 +2327,7 @@ module SPARQL::Grammar
       base = prefix(prefix).to_s
       suffix = suffix.to_s.sub(/^\#/, "") if base.index("#")
       debug {"ns(#{prefix.inspect}): base: '#{base}', suffix: '#{suffix}'"}
-      iri = iri(base + suffix.to_s)
-      # Cause URI to be serialized as a lexical
-      #iri.lexical = "#{prefix}:#{suffix}" unless resolve_iris?
-      #iri
+      iri(base + suffix.to_s)
     end
 
     # Create a literal
@@ -1869,10 +2370,12 @@ module SPARQL::Grammar
     # add a pattern
     #
     # @param [String] production Production generating pattern
+    # @param [Boolean] quoted For quoted triple
     # @param [Hash{Symbol => Object}] options
-    def add_pattern(production, **options)
+    def add_pattern(production, quoted: false, **options)
       progress(production, "[:pattern, #{options[:subject]}, #{options[:predicate]}, #{options[:object]}]")
       triple = {}
+      triple[:quoted] = true if quoted
       options.each_pair do |r, v|
         if v.is_a?(Array) && v.flatten.length == 1
           v = v.flatten.first
@@ -1894,6 +2397,7 @@ module SPARQL::Grammar
       [expr, query]
     end
 
+    ##
     # Merge query modifiers, datasets, and projections
     #
     # This includes tranforming aggregates if also used with a GROUP BY
@@ -1988,7 +2492,14 @@ module SPARQL::Grammar
 
       query = SPARQL::Algebra::Expression[:order, data[:order].first, query] unless order.empty?
 
-      query = SPARQL::Algebra::Expression[:project, vars, query] unless vars.empty?
+      # If SELECT * was used, emit a projection with empty variables, vs no projection at all. Only if :all_vars is true
+      query = if vars == %i(*)
+        options[:all_vars] ? SPARQL::Algebra::Expression[:project, [], query] : query
+      elsif !vars.empty?
+        SPARQL::Algebra::Expression[:project, vars, query]
+      else
+        query
+      end
 
       query = SPARQL::Algebra::Expression[data[:DISTINCT_REDUCED], query] if data[:DISTINCT_REDUCED]