sparql 1.99.1 → 2.0.0.beta1

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

@@ -3,6 +3,8 @@ module SPARQL; module Algebra
     ##
     # The SPARQL logical `exists` operator.
     #
+    # There is a filter operator EXISTS that takes a graph pattern. EXISTS returns `true`/`false` depending on whether the pattern matches the dataset given the bindings in the current group graph pattern, the dataset and the active graph at this point in the query evaluation. No additional binding of variables occurs. The `NOT EXISTS` form translates into `fn:not(EXISTS{...})`.
+    #
     # @example
     #    (prefix ((ex: <http://www.example.org/>))
     #      (filter (exists

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

@@ -30,7 +30,7 @@ module SPARQL; module Algebra
       #   each matching solution
       # @yieldparam  [RDF::Query::Solution] solution
       # @yieldreturn [void] ignored
-      # @see    http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
+      # @see    http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
       def execute(queryable, options = {}, &block)
         debug(options) {"NotOneOf #{operands.to_sse}"}
         subject, object = options[:subject], options[:object]

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

@@ -5,6 +5,8 @@ module SPARQL; module Algebra
     ##
     # The SPARQL logical `now` operator.
     #
+    # Returns an XSD dateTime value for the current query execution. All calls to this function in any one query execution must return the same value. The exact moment returned is not specified.
+    #
     # @example
     #     (prefix ((xsd: <http://www.w3.org/2001/XMLSchema#>))
     #       (ask (filter (= (datatype ?n) xsd:dateTime)

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

@@ -7,8 +7,8 @@ module SPARQL; module Algebra
     #   (|| ?x ?y)
     #   (or ?x ?y)
     #
-    # @see http://www.w3.org/TR/rdf-sparql-query/#func-logical-or
-    # @see http://www.w3.org/TR/rdf-sparql-query/#evaluation
+    # @see http://www.w3.org/TR/sparql11-query/#func-logical-or
+    # @see http://www.w3.org/TR/sparql11-query/#evaluation
     class Or < Operator::Binary
       include Evaluatable
 
@@ -53,7 +53,7 @@ module SPARQL; module Algebra
           right = nil
         end
 
-        # From http://www.w3.org/TR/rdf-sparql-query/#evaluation
+        # From http://www.w3.org/TR/sparql11-query/#evaluation
         # A logical-or that encounters an error on only one branch will return TRUE if the other branch is TRUE
         # and an error if the other branch is FALSE.
         case

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

@@ -9,7 +9,7 @@ module SPARQL; module Algebra
     #       (order ((asc ?name))
     #         (bgp (triple ?x foaf:name ?name)))))
     #
-    # @see http://www.w3.org/TR/rdf-sparql-query/#modOrderBy
+    # @see http://www.w3.org/TR/sparql11-query/#modOrderBy
     class Order < Operator::Binary
       include Query
       
@@ -30,7 +30,7 @@ module SPARQL; module Algebra
       # @yieldreturn [void] ignored
       # @return [RDF::Query::Solutions]
       #   the resulting solution sequence
-      # @see    http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
+      # @see    http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
       def execute(queryable, options = {}, &block)
 
         debug(options) {"Order"}

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

@@ -25,7 +25,7 @@ module SPARQL; module Algebra
       # @yieldreturn [void] ignored
       # @return [RDF::Query::Solutions]
       #   the resulting solution sequence
-      # @see    http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
+      # @see    http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
       def execute(queryable, options = {}, &block)
         debug(options) {"Path #{operands.to_sse}"}
         subject, path_op, object = operands

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

@@ -29,7 +29,7 @@ module SPARQL; module Algebra
       #   each matching solution
       # @yieldparam  [RDF::Query::Solution] solution
       # @yieldreturn [void] ignored
-      # @see    http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
+      # @see    http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
       def execute(queryable, options = {}, &block)
         subject, object = options[:subject], options[:object]
         debug(options) {"Path? #{[subject, operands, object].to_sse}"}

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

@@ -25,7 +25,7 @@ module SPARQL; module Algebra
       #   each matching solution
       # @yieldparam  [RDF::Query::Solution] solution
       # @yieldreturn [void] ignored
-      # @see    http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
+      # @see    http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
       def execute(queryable, options = {}, &block)
         subject, object = options[:subject], options[:object]
         debug(options) {"Path+ #{[subject, operands, object].to_sse}"}

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

@@ -28,7 +28,7 @@ module SPARQL; module Algebra
       #   each matching solution
       # @yieldparam  [RDF::Query::Solution] solution
       # @yieldreturn [void] ignored
-      # @see    http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
+      # @see    http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
       def execute(queryable, options = {}, &block)
         subject, object = options[:subject], options[:object]
         debug(options) {"Path* #{[subject, operands, object].to_sse}"}

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

@@ -8,7 +8,7 @@ module SPARQL; module Algebra
     #     (graph ?g
     #       (bgp (triple ?s ?p ?o))))
     #
-    # @see http://www.w3.org/TR/rdf-sparql-query/#QSynIRI
+    # @see http://www.w3.org/TR/sparql11-query/#QSynIRI
     class Prefix < Binary
       include Query
       
@@ -29,7 +29,7 @@ module SPARQL; module Algebra
       # @yieldreturn [void] ignored
       # @return [RDF::Query::Solutions]
       #   the resulting solution sequence
-      # @see    http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
+      # @see    http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
       def execute(queryable, options = {}, &block)
         debug(options) {"Prefix"}
         @solutions = queryable.query(operands.last, options.merge(depth: options[:depth].to_i + 1), &block)

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

@@ -9,7 +9,7 @@ module SPARQL; module Algebra
     #       (filter (= ?v 2)
     #         (bgp (triple ?s <http://example/p> ?v)))))
     #
-    # @see http://www.w3.org/TR/rdf-sparql-query/#modProjection
+    # @see http://www.w3.org/TR/sparql11-query/#modProjection
     class Project < Operator::Binary
       include Query
       
@@ -29,7 +29,7 @@ module SPARQL; module Algebra
       # @yieldreturn [void] ignored
       # @return [RDF::Query::Solutions]
       #   the resulting solution sequence
-      # @see    http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
+      # @see    http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
       def execute(queryable, options = {}, &block)
         @solutions = queryable.query(operands.last, options.merge(depth: options[:depth].to_i + 1))
         @solutions = @solutions.project(*(operands.first))

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

@@ -3,6 +3,8 @@ module SPARQL; module Algebra
     ##
     # The SPARQL logical `rand` operator.
     #
+    # Returns a pseudo-random number between 0 (inclusive) and 1.0e0 (exclusive). Different numbers can be produced every time this function is invoked. Numbers should be produced with approximately equal probability.
+    #
     # @example
     #   (rand)
     #

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

@@ -10,7 +10,7 @@ module SPARQL; module Algebra
     #       (project (?v)
     #         (bgp (triple ?x ?p ?v)))))
     #
-    # @see http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
+    # @see http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
     class Reduced < Operator::Unary
       include Query
       
@@ -30,7 +30,7 @@ module SPARQL; module Algebra
       # @yieldreturn [void] ignored
       # @return [RDF::Query::Solutions]
       #   the resulting solution sequence
-      # @see    http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
+      # @see    http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
       def execute(queryable, options = {}, &block)
         @solutions = operands.last.
           execute(queryable, options.merge(depth: options[:depth].to_i + 1)).reduced

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

@@ -10,7 +10,7 @@ module SPARQL; module Algebra
     #       (filter (regex ?val "GHI")
     #         (bgp (triple ex:foo rdf:value ?val)))))
     #
-    # @see http://www.w3.org/TR/rdf-sparql-query/#funcex-regex
+    # @see http://www.w3.org/TR/sparql11-query/#funcex-regex
     # @see http://www.w3.org/TR/xpath-functions/#func-matches
     class Regex < Operator::Ternary
       include Evaluatable

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

@@ -10,7 +10,7 @@ module SPARQL; module Algebra
     #         (extend ((?new (replace ?str "[^a-z0-9]" "-")))
     #           (bgp (triple ?s :str ?str)))))
     #
-    # @see http://www.w3.org/TR/rdf-sparql-query/#funcex-replace
+    # @see http://www.w3.org/TR/sparql11-query/#funcex-replace
     # @see http://www.w3.org/TR/xpath-functions/#func-replace
     class Replace < Operator::Quaternary
       include Evaluatable

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

@@ -29,7 +29,7 @@ module SPARQL; module Algebra
       #   each matching solution
       # @yieldparam  [RDF::Query::Solution] solution
       # @yieldreturn [void] ignored
-      # @see    http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
+      # @see    http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
       def execute(queryable, options = {}, &block)
         debug(options) {"Reverse #{operands.to_sse}"}
         subject, object = options[:subject], options[:object]

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

@@ -3,6 +3,8 @@ module SPARQL; module Algebra
     ##
     # The SPARQL logical `round` operator.
     #
+    # Returns the number with no fractional part that is closest to the argument. If there are two such numbers, then the one that is closest to positive infinity is returned. An error is raised if `arg` is not a numeric value.
+    # 
     # @example
     #   (round ?x)
     #

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

@@ -10,7 +10,7 @@ module SPARQL; module Algebra
     #       (filter (sameTerm ?v)
     #         (bgp (triple ?x :p ?v)))))
     #
-    # @see http://www.w3.org/TR/rdf-sparql-query/#func-sameTerm
+    # @see http://www.w3.org/TR/sparql11-query/#func-sameTerm
     class SameTerm < Operator::Binary
       include Evaluatable
 

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

@@ -3,6 +3,8 @@ module SPARQL; module Algebra
     ##
     # The SPARQL logical `seconds` operator.
     #
+    # Returns the seconds part of the lexical form of `arg`.
+    #
     # @example
     #     (prefix ((: <http://example.org/>))
     #       (project (?s ?x)

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

@@ -28,7 +28,7 @@ module SPARQL; module Algebra
       #   each matching solution
       # @yieldparam  [RDF::Query::Solution] solution
       # @yieldreturn [void] ignored
-      # @see    http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
+      # @see    http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
       def execute(queryable, options = {}, &block)
         subject, object = options[:subject], options[:object]
         debug(options) {"Seq #{[subject, operands, object].to_sse}"}

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

@@ -34,7 +34,7 @@ module SPARQL; module Algebra
       #   each matching solution
       # @yieldparam  [RDF::Query::Solution] solution
       # @yieldreturn [void] ignored
-      # @see    http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
+      # @see    http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
       def execute(queryable, options = {})
         debug(options) {"Sequence #{operands.to_sse}"}
 

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

@@ -5,6 +5,8 @@ module SPARQL; module Algebra
     ##
     # The SPARQL logical `sha1` operator.
     #
+    # Returns the SHA1 checksum, as a hex digit string, calculated on the UTF-8 representation of the simple literal or lexical form of the `xsd:string`. Hex digits `SHOULD` be in lower case.
+    #
     # @example
     #     (prefix ((: <http://example.org/>))
     #       (project (?hash)

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

@@ -5,6 +5,8 @@ module SPARQL; module Algebra
     ##
     # The SPARQL logical `sha256` operator.
     #
+    # Returns the SHA256 checksum, as a hex digit string, calculated on the UTF-8 representation of the simple literal or lexical form of the `xsd:string`. Hex digits `SHOULD` be in lower case.
+    #
     # @example
     #     (prefix ((: <http://example.org/>))
     #       (project (?hash)

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

@@ -5,6 +5,8 @@ module SPARQL; module Algebra
     ##
     # The SPARQL logical `sha1` operator.
     #
+    # Returns the SHA384 checksum, as a hex digit string, calculated on the UTF-8 representation of the simple literal or lexical form of the `xsd:string`. Hex digits `SHOULD` be in lower case.
+    #
     # @example
     #     (prefix ((: <http://example.org/>))
     #       (project (?hash)

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

@@ -5,6 +5,8 @@ module SPARQL; module Algebra
     ##
     # The SPARQL logical `sha512` operator.
     #
+    # Returns the SHA512 checksum, as a hex digit string, calculated on the UTF-8 representation of the simple literal or lexical form of the `xsd:string`. Hex digits `SHOULD` be in lower case.
+    #
     # @example
     #     (prefix ((: <http://example.org/>))
     #       (project (?hash)

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

@@ -10,7 +10,7 @@ module SPARQL; module Algebra
     #         (order (?v)
     #           (bgp (triple ??0 :num ?v))))))
     #
-    # @see http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
+    # @see http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
     class Slice < Operator::Ternary
       include Query
       
@@ -42,7 +42,7 @@ module SPARQL; module Algebra
       # @yieldreturn [void] ignored
       # @return [RDF::Query::Solutions]
       #   the resulting solution sequence
-      # @see    http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
+      # @see    http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
       def execute(queryable, options = {}, &block)
         offset = operands[0] == :_ ? 0 : operands[0].to_i
         limit = operands[1] == :_ ? -1 : operands[1].to_i

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

@@ -10,7 +10,7 @@ module SPARQL; module Algebra
     #       (filter (= (str ?v) "1")
     #         (bgp (triple ?x :p ?v)))))
     #
-    # @see http://www.w3.org/TR/rdf-sparql-query/#func-str
+    # @see http://www.w3.org/TR/sparql11-query/#func-str
     class Str < Operator::Unary
       include Evaluatable
 

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

@@ -30,7 +30,7 @@ module SPARQL; module Algebra
       # @yieldreturn [void] ignored
       # @return [RDF::Query::Solutions]
       #   the resulting solution sequence
-      # @see    http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
+      # @see    http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
       def execute(queryable, options = {}, &block)
         @solutions = RDF::Query::Solutions()
         operands[1..-1].each do |row|

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

@@ -3,6 +3,8 @@ module SPARQL; module Algebra
     ##
     # The SPARQL logical `timezone` operator.
     #
+    # Returns the timezone part of `arg` as an xsd:dayTimeDuration. Raises an error if there is no timezone.
+    #
     # @example
     #     (prefix ((: <http://example.org/>))
     #       (project (?s ?x)

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

@@ -3,6 +3,8 @@ module SPARQL; module Algebra
     ##
     # The SPARQL logical `tz` operator.
     #
+    # Returns the timezone part of `arg` as a simple literal. Returns the empty string if there is no timezone.
+    #
     # @example
     #     (prefix ((: <http://example.org/>))
     #       (project (?s ?x)

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

@@ -10,7 +10,7 @@ module SPARQL; module Algebra
     #       (graph ?g
     #         (bgp (triple ?s ?p ?o)))))
     #
-    # @see http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
+    # @see http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
     class Union < Operator::Binary
       include Query
       
@@ -30,7 +30,7 @@ module SPARQL; module Algebra
       # @yieldreturn [void] ignored
       # @return [RDF::Query::Solutions]
       #   the resulting solution sequence
-      # @see    http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
+      # @see    http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
       def execute(queryable, options = {}, &block)
         debug(options) {"Union"}
         @solutions = RDF::Query::Solutions(operands.inject([]) do |memo, op|

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

@@ -3,6 +3,8 @@ module SPARQL; module Algebra
     ##
     # The SPARQL logical `year` operator.
     #
+    # Returns the year part of `arg` as an integer.
+    #
     # @example
     #     (prefix ((: <http://example.org/>))
     #       (project (?s ?x)

data/lib/sparql/algebra/query.rb

@@ -49,7 +49,7 @@ module SPARQL; module Algebra
     #   Note, results may be used with {SPARQL.serialize_results} to obtain appropriate output encoding.
     # @raise [NotImplementedError]
     #   If an attempt is made to perform an unsupported operation
-    # @see    http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
+    # @see    http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
     def execute(queryable, options = {}, &block)
       raise NotImplementedError, "#{self.class}#execute(#{queryable})"
     end

data/lib/sparql/grammar.rb

@@ -154,7 +154,7 @@ module SPARQL
   #       --output lib/sparql/grammar/meta.rb \
   #       etc/sparql11.bnf
   # 
-  # @see http://www.w3.org/TR/rdf-sparql-query/#grammar
+  # @see http://www.w3.org/TR/sparql11-query/#grammar
   # @see http://rubygems.org/gems/ebnf
   module Grammar
     autoload :Parser,     'sparql/grammar/parser11'

data/lib/sparql/grammar/parser11.rb

@@ -6,7 +6,7 @@ module SPARQL::Grammar
   ##
   # A parser for the SPARQL 1.1 grammar.
   #
-  # @see http://www.w3.org/TR/rdf-sparql-query/#grammar
+  # @see http://www.w3.org/TR/sparql11-query/#grammar
   # @see http://en.wikipedia.org/wiki/LR_parser
   class Parser
     include SPARQL::Grammar::Meta
@@ -490,8 +490,8 @@ module SPARQL::Grammar
       self.gen_bnodes
     end
     production(:DeleteData) do |input, data, callback|
-      raise Error, "DeleteData contains BNode operands: #{data[:pattern].to_sse}" if data[:pattern].first.node?
-      input[:update_op] = SPARQL::Algebra::Expression(:deleteData, data[:pattern])
+      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
@@ -500,9 +500,9 @@ module SPARQL::Grammar
       self.gen_bnodes
     end
     production(:DeleteWhere) do |input, data, callback|
-      raise Error, "DeleteWhere contains BNode operands: #{data[:pattern].to_sse}" if data[:pattern].first.node?
+      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, data[:pattern])
+      input[:update_op] = SPARQL::Algebra::Expression(:deleteWhere, Array(data[:pattern]))
     end
 
     # [41]	Modify	::=	("WITH" iri)? ( DeleteClause InsertClause? | InsertClause) UsingClause* "WHERE" GroupGraphPattern
@@ -523,9 +523,9 @@ module SPARQL::Grammar
       self.gen_bnodes
     end
     production(:DeleteClause) do |input, data, callback|
-      raise Error, "DeleteClause contains BNode operands: #{data[:pattern].to_sse}" if data[:pattern].first.node?
+      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, data[:pattern])
+      input[:delete] = SPARQL::Algebra::Expression(:delete, Array(data[:pattern]))
     end
 
     # [43]	InsertClause	::=	"INSERT" QuadPattern
@@ -535,7 +535,7 @@ module SPARQL::Grammar
     end
     production(:InsertClause) do |input, data, callback|
       self.gen_bnodes(false)
-      input[:insert] = SPARQL::Algebra::Expression(:insert, data[:pattern])
+      input[:insert] = SPARQL::Algebra::Expression(:insert, Array(data[:pattern]))
     end
 
     # [44]	UsingClause	::=	"USING" ( iri | "NAMED" iri)
@@ -568,20 +568,19 @@ module SPARQL::Grammar
     end
     production(:QuadData) do |input, data, callback|
       # Transform using statements instead of patterns, and verify there are no variables
-      raise Error, "QuadData empty" unless data[:pattern]
-      raise Error, "QuadData contains variable operands: #{data[:pattern].to_sse}" if data[:pattern].first.variable?
+      raise Error, "QuadData contains variable operands: #{Array(data[:pattern]).to_sse}" if Array(data[:pattern]).any?(&:variable?)
       self.gen_bnodes(false)
-      input[:pattern] = data[:pattern]
+      input[:pattern] = Array(data[:pattern])
     end
 
     # [51] QuadsNotTriples	::=	"GRAPH" VarOrIri "{" TriplesTemplate? "}"
     production(:QuadsNotTriples) do |input, data, callback|
-      add_prod_datum(:pattern, [SPARQL::Algebra::Expression.for(:graph, data[:VarOrIri].last, data[:pattern])])
+      add_prod_datum(:pattern, [SPARQL::Algebra::Expression.for(:graph, data[:VarOrIri].last, Array(data[:pattern]))])
     end
 
     # [52]	TriplesTemplate	::=	TriplesSameSubject ("." TriplesTemplate? )?
     production(:TriplesTemplate) do |input, data, callback|
-      add_prod_datum(:pattern, data[:pattern])
+      add_prod_datum(:pattern, Array(data[:pattern]))
     end
 
     # [54]	GroupGraphPatternSub	::=	TriplesBlock? (GraphPatternNotTriples "."? TriplesBlock? )*
@@ -603,7 +602,7 @@ module SPARQL::Grammar
     # [55]  	TriplesBlock	  ::=  	TriplesSameSubjectPath
     #                               ( '.' TriplesBlock? )?
     production(:TriplesBlock) do |input, data, callback|
-      if data[:pattern]
+      if !Array(data[:pattern]).empty?
         query = SPARQL::Algebra::Operator::BGP.new
         Array(data[:pattern]).each {|p| query << p}
 
@@ -804,7 +803,7 @@ module SPARQL::Grammar
     production(:ConstructTemplate) do |input, data, callback|
       # Generate BNodes instead of non-distinguished variables
       self.gen_bnodes(false)
-      add_prod_datum(:ConstructTemplate, data[:pattern])
+      add_prod_datum(:ConstructTemplate, Array(data[:pattern]))
       add_prod_datum(:ConstructTemplate, data[:ConstructTemplate])
     end