sparql 3.3.1 → 3.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 04020d0f2d52ea9619dc58bf25c0660f62469e492cbf32893345cea0f888bc06
-  data.tar.gz: f6f982cfcc78222576f741b77bd4665e58f922641906ee8d66ca370063713752
+  metadata.gz: d98eb5dea7ada1bdeb9335b93088f3a9fcdd3b6556e6665fc87e097f683f8160
+  data.tar.gz: 3ea06346654920eb84518c646ac28eac52ff09ee5f758bf38303ccf528160c0f
 SHA512:
-  metadata.gz: 427b55415d048501faad82f0355b74d40e21732e7e3ed61f44cb6f0db5446a58666989c341276db0afdd093b5b77a0bc335aa52de0620a18fe9b1d59cf32201d
-  data.tar.gz: 775d4e5037ab9d3affaacf71ee7723f6337da9959ce6acf7c5dd24e424706ff681f446a7087ee7af81046cc9b53f9385b38e5e2bc6529164311fa33108fe4742
+  metadata.gz: 58ff08062bc059a8858b324365f4ae36b064da2d6f1f6f133735b29d905c576c474679eb34244d787afe3c40b2496bf12835ab7c1cabe9886ebd4709ad8c2725
+  data.tar.gz: 62c32c0d911b28760ac545720575a1ddd9493b38eae10bbe6fc678df9b0abf06c2da17ee4fa0801f0cc0423115081254304fde091ec7e337dfeefd45c33ce72f

data/README.md

@@ -27,7 +27,7 @@ An implementation of [SPARQL][] for [RDF.rb][].
 * Implementation Report: {file:etc/earl.html EARL}
 * Compatible with Ruby >= 3.0.
 * Supports Unicode query strings both on all versions of Ruby.
-* Provisional support for [SPARQL-star][].
+* Provisional support for [SPARQL 1.2][].
 
 ## Description
 
@@ -68,17 +68,20 @@ Not supported:
 * [Entailment Regimes][SPARQL 1.1 Entailment Regimes], and
 * [Graph Store HTTP Protocol][SPARQL 1.1 Graph Store HTTP Protocol] but the closely related [Linked Data Platform][] implemented in [rdf-ldp](https://github.com/ruby-rdf/rdf-ldp) supports these use cases.
 
+### Optimizations
+Generally, optimizing a query can lead to improved performance, sometimes dramatically (e.g., `?s rdf:rest*/rdf:first ?o`). Optimization can be done when parsing a query using the `:optimize` option, or the `optimize` method on a parsed query.
+
 ### Updates for RDF 1.1
 Starting with version 1.1.2, the SPARQL gem uses the 1.1 version of the [RDF.rb][], which adheres to [RDF 1.1 Concepts](https://www.w3.org/TR/rdf11-concepts/) rather than [RDF 1.0](https://www.w3.org/TR/rdf-concepts/). The main difference is that there is now no difference between a _Simple Literal_ (a literal with no datatype or language) and a Literal with datatype _xsd:string_; this causes some minor differences in the way in which queries are understood, and when expecting different results.
 
 Additionally, queries now take a block, or return an `Enumerator`; this is in keeping with much of the behavior of [RDF.rb][] methods, including `Queryable#query`, and with version 1.1 or [RDF.rb][], Query#execute. As a consequence, all queries which used to be of the form `query.execute(repository)` may equally be called as `repository.query(query)`. Previously, results were returned as a concrete class implementing `RDF::Queryable` or `RDF::Query::Solutions`, these are now `Enumerators`.
 
-### SPARQL 1.2
-The gem supports some of the extensions proposed by the [SPARQL 1.2 Community Group](https://github.com/w3c/sparql-12). In particular, the following extensions are now implemented:
+### SPARQL Dev
+The gem supports some of the extensions proposed by the [SPARQL Dev Community Group](https://github.com/w3c/sparql-dev). In particular, the following extensions are now implemented:
 
-* [SEP-0002: better support for Durations, Dates, and Times](https://github.com/w3c/sparql-12/blob/main/SEP/SEP-0002/sep-0002.md)
+* [SEP-0002: better support for Durations, Dates, and Times](https://github.com/w3c/sparql-dev/blob/main/SEP/SEP-0002/sep-0002.md)
   * This includes full support for `xsd:date`, `xsd:time`, `xsd:duration`, `xsd:dayTimeDuration`, and `xsd:yearMonthDuration` along with associated XPath/XQuery functions including a new `ADJUST` builtin. (**Note: This feature is subject to change or elimination as the standards process progresses.**)
-* [SEP-0003: Property paths with a min/max hop](https://github.com/w3c/sparql-12/blob/main/SEP/SEP-0003/sep-0003.md)
+* [SEP-0003: Property paths with a min/max hop](https://github.com/w3c/sparql-dev/blob/main/SEP/SEP-0003/sep-0003.md)
   * This includes support for non-counting path forms such as `rdf:rest{1,3}` to match the union of paths `rdf:rest`, `rdf:rest/rdf:rest`, and `rdf:rest/rdf:rest/rdf:rest`.  (**Note: This feature is subject to change or elimination as the standards process progresses.**)
 
 ### SPARQL Extension Functions
@@ -107,9 +110,9 @@ See {SPARQL::Algebra::Expression.register_extension} for details.
 
 A call to execute a parsed query can include pre-bound variables, which cause queries to be executed with matching variables bound as defined. Variable pre-binding can be done using a Hash structure, or a Query Solution.  See [Query with Binding example](#query-with-binding) and {SPARQL::Algebra::Query#execute}.
 
-### SPARQLStar (SPARQL-star)
+### SPARQL 1.2
 
-The gem supports [SPARQL-star][] where patterns may include sub-patterns recursively, for a kind of Reification.
+The gem supports [SPARQL 1.2][] where patterns may include sub-patterns recursively, for a kind of Reification.
 
 For example, the following Turtle* file uses a statement as the subject of another statement:
 
@@ -170,7 +173,7 @@ As well as a `CONSTRUCT`:
       <<?bob foaf:age ?age>> ?b ?c .
     }
 
-Note that results can be serialized only when the format supports [RDF-star][].
+Note that results can be serialized only when the format supports [SPARQL 1,2][].
 
 #### SPARQL results
 
@@ -462,8 +465,6 @@ see <https://unlicense.org/> or the accompanying {file:UNLICENSE}.
 
 A copy of the [SPARQL EBNF][] and derived parser files are included in the repository, which are not covered under the UNLICENSE. These files are covered via the [W3C Document License](https://www.w3.org/Consortium/Legal/2002/copyright-documents-20021231).
 
-A copy of the [SPARQL 1.0 tests][] and [SPARQL 1.1 tests][] are also included in the repository, which are not covered under the UNLICENSE; see the references for test copyright information.
-
 [Ruby]:             https://ruby-lang.org/
 [RDF]:              https://www.w3.org/RDF/
 [RDF::DO]:          https://rubygems.org/gems/rdf-do
@@ -474,20 +475,17 @@ A copy of the [SPARQL 1.0 tests][] and [SPARQL 1.1 tests][] are also included in
 [PDD]:              https://unlicense.org/#unlicensing-contributions
 [SPARQL]:           https://en.wikipedia.org/wiki/SPARQL
 [SPARQL 1.0]:       https://www.w3.org/TR/sparql11-query/
-[SPARQL 1.0 tests]:https://www.w3.org/2001/sw/DataAccess/tests/
-[SPARQL 1.1 tests]: https://www.w3.org/2009/sparql/docs/tests/
 [SSE]:              https://jena.apache.org/documentation/notes/sse.html
 [SXP]:              https://dryruby.github.io/sxp
 [grammar]:          https://www.w3.org/TR/sparql11-query/#grammar
 [RDF 1.1]:          https://www.w3.org/TR/rdf11-concepts
 [RDF.rb]:           https://ruby-rdf.github.io/rdf
-[RDF-star]:             https://w3c.github.io/rdf-star/rdf-star-cg-spec.html
-[SPARQL-star]:          https://w3c.github.io/rdf-star/rdf-star-cg-spec.html#sparql-query-language
+[SPARQL 1.2]:          https://www.w3.org/TR/sparql12-query
 [Linked Data]:      https://rubygems.org/gems/linkeddata
 [SPARQL doc]:       https://ruby-rdf.github.io/sparql/frames
 [SPARQL XML]:       https://www.w3.org/TR/rdf-sparql-XMLres/
 [SPARQL JSON]:      https://www.w3.org/TR/rdf-sparql-json-res/
-[SPARQL EBNF]:      https://www.w3.org/TR/sparql11-query/#sparqlGrammar
+[SPARQL EBNF]:      https://www.w3.org/TR/sparql12-query/#sparqlGrammar
 
 [SSD]:              https://www.w3.org/TR/sparql11-service-description/
 [Rack]:             https://rack.github.io

data/VERSION

@@ -1 +1 @@
-3.3.1
+3.3.2

data/bin/sparql

@@ -3,6 +3,8 @@ require 'rubygems'
 $:.unshift("../../lib", __FILE__)
 require 'logger'
 require 'sparql'
+require 'rack'
+require 'rackup'
 begin
   require 'linkeddata'
 rescue LoadError
@@ -45,6 +47,8 @@ def run(input, **options)
     SPARQL::Grammar.parse(input, **options)
   end
 
+  query = query.optimize if options[:optimize]
+
   puts ("\nSSE:\n" + query.to_sse) if options[:debug]
 
   if options[:parse_only]
@@ -64,42 +68,46 @@ end
 
 def server(options)
   app = SPARQL::Server.application(**options)
-  Rack::Server.start(app: app, Port: options.fetch(:port, 9292))
+  Rackup::Server.start(app: app, Port: options.fetch(:port, 9292))
 rescue LoadError
-  $stderr.puts "Running SPARQL server requires Rack and Sinatra to be in environment: #{$!.message}"
+  $stderr.puts "Running SPARQL server requires Rack, Rackup, and Sinatra to be in environment: #{$!.message}"
 end
 
+cmd, input = ARGV.shift, nil
+
+OPT_ARGS = [
+  ["--dataset", GetoptLong::REQUIRED_ARGUMENT, "File containing RDF graph or dataset"],
+  ["--debug", GetoptLong::NO_ARGUMENT, "Debugging output"],
+  ["--execute", "-e", GetoptLong::REQUIRED_ARGUMENT, "Run against source in argument"],
+  ["--format", GetoptLong::REQUIRED_ARGUMENT, "Output format for results (json, xml, csv, tsv, html, sparql, sse, or another RDF format)"],
+  ["--help", "-?", GetoptLong::NO_ARGUMENT, "print this message"],
+  ["--optimize", GetoptLong::NO_ARGUMENT, "Perform query optimizations"],
+  ["--port", "-p", GetoptLong::REQUIRED_ARGUMENT, "Port on which to run server; defaults to 9292"],
+  ["--sse", GetoptLong::NO_ARGUMENT, "Query input is in SSE format"],
+  ["--update", GetoptLong::NO_ARGUMENT, "Process query as a SPARQL Update"],
+  ["--verbose", GetoptLong::NO_ARGUMENT, "Verbose output"],
+]
+
 def usage
   puts "Usage: #{File.basename($0)} execute [options] query-file         Execute a query against the specified dataset"
   puts "       #{File.basename($0)} parse [options] query-file           Parse a query into SPARQL S-Expressions (SSE)"
   puts "       #{File.basename($0)} query [options] end-point query-file Run the query against a remote end-point"
   puts "       #{File.basename($0)} server [options] dataset-file        Start a server initialized from the specified dataset"
   puts "Options:"
-  puts "      --dataset:            File containing RDF graph or dataset"
-  puts "      --debug:              Display detailed debug output"
-  puts "      --execute,-e:         Use option argument as the SPARQL input if no query-file given"
-  puts "      --format:             Output format for results (json, xml, csv, tsv, html, sparql, sse, or another RDF format)"
-  puts "      --port,-p             Port on which to run server; defaults to 9292"
-  puts "      --sse:                Query input is in SSE format"
-  puts "      --update:             Process query as a SPARQL Update"
-  puts "      --verbose:            Display details of processing"
-  puts "      --help,-?:            This message"
+  width = OPT_ARGS.map do |o|
+    l = o.first.length
+    l += o[1].length + 2 if o[1].is_a?(String)
+    l
+  end.max
+  OPT_ARGS.each do |o|
+    s = "  %-*s  " % [width, (o[1].is_a?(String) ? "#{o[0,2].join(', ')}" : o[0])]
+    s += o.last
+    puts s
+  end
   exit(0)
 end
 
-cmd, input = ARGV.shift, nil
-
-opts = GetoptLong.new(
-  ["--dataset", GetoptLong::REQUIRED_ARGUMENT],
-  ["--debug", GetoptLong::NO_ARGUMENT],
-  ["--execute", "-e", GetoptLong::REQUIRED_ARGUMENT],
-  ["--format", GetoptLong::REQUIRED_ARGUMENT],
-  ["--port", "-p", GetoptLong::REQUIRED_ARGUMENT],
-  ["--sse", GetoptLong::NO_ARGUMENT],
-  ["--update", GetoptLong::NO_ARGUMENT],
-  ["--verbose", GetoptLong::NO_ARGUMENT],
-  ["--help", "-?", GetoptLong::NO_ARGUMENT]
-)
+opts = GetoptLong.new(*OPT_ARGS.map {|o| o[0..-2]})
 
 logger = Logger.new(STDERR)
 logger.level = Logger::WARN
@@ -116,6 +124,7 @@ opts.each do |opt, arg|
   when '--debug'         then options[:debug] = true ; logger.level = Logger::DEBUG
   when '--execute'       then input = arg
   when '--format'        then options[:format] = arg.to_sym
+  when '--optimize'      then options[:optimize] = true
   when '--port'          then options[:port] = arg.to_i
   when '--sse'           then options[:sse] = true
   when '--update'        then options[:update] = true

data/lib/sparql/algebra/aggregate.rb

@@ -40,7 +40,7 @@ module SPARQL; module Algebra
     end
 
     ##
-    # @param  [Enumerable<Array<RDF::Term>>] enum
+    # @param  [Enumerable<Array<RDF::Term>] enum
     #   Enumerable yielding evaluated operands
     # @return [RDF::Term]
     # @abstract

data/lib/sparql/algebra/expression.rb

@@ -142,7 +142,7 @@ module SPARQL; module Algebra
       begin
         # Due to confusion over (triple) and special-case for (qtriple)
         if operator == RDF::Query::Pattern
-          options = options.merge(quoted: true) if sse.first == :qtriple
+          options = options.merge(tripleTerm: true) if sse.first == :qtriple
         elsif operator == Operator::Triple && PATTERN_PARENTS.include?(parent_operator)
           operator = RDF::Query::Pattern
         end
@@ -428,7 +428,7 @@ module SPARQL; module Algebra
     # @return [SPARQL::Algebra::Expression] `self`
     # @raise  [ArgumentError] if the value is invalid
     def validate!
-      raise ArgumentError if invalid?
+      raise ArgumentError, "#{self.inspect} is invalid" if invalid?
       self
     end
     alias_method :validate, :validate!

data/lib/sparql/algebra/extensions.rb

@@ -355,7 +355,7 @@ class RDF::Statement
   # Transform Statement Pattern into an SXP
   # @return [Array]
   def to_sxp_bin
-    [ (has_graph? ? :quad : (quoted? ? :qtriple : :triple)),
+    [ (has_graph? ? :quad : (tripleTerm? ? :qtriple : :triple)),
       (:inferred if inferred?),
       subject,
       predicate,
@@ -381,7 +381,7 @@ class RDF::Statement
   # @return [String]
   def to_sparql(**options)
     str = to_triple.map {|term| term.to_sparql(**options)}.join(" ")
-    quoted? ? ('<<' + str + '>>') : str
+    tripleTerm? ? ('<<(' + str + ')>>') : str
   end
 
   ##
@@ -429,6 +429,23 @@ class RDF::Query
     end
   end
 
+  # Two queries can be merged if they share the same graph_name
+  #
+  # @param [RDF::Query] other
+  # @return [Boolean]
+  def mergable?(other)
+    other.is_a?(RDF::Query) && self.graph_name == other.graph_name
+  end
+
+  # Two queries are merged by 
+  #
+  # @param [RDF::Query] other
+  # @return [RDF::Query]
+  def merge(other)
+    raise ArgumentError, "Can't merge with #{other.class}" unless mergable?(other)
+    self.dup.tap {|q| q.instance_variable_set(:@patterns, q.patterns + other.patterns)}
+  end
+
   ##
   #
   # Returns a partial SPARQL grammar for this query.
@@ -552,6 +569,16 @@ class RDF::Query::Pattern
   #
   # @return [Boolean] `true`
   def executable?; true; end
+
+  ##
+  # Returns an S-Expression (SXP) representation
+  #
+  # @param [Hash{Symbol => RDF::URI}] prefixes (nil)
+  # @param [RDF::URI] base_uri (nil)
+  # @return [String]
+  def to_sxp(prefixes: nil, base_uri: nil)
+    to_sxp_bin.to_sxp(prefixes: prefixes, base_uri: base_uri)
+  end
 end
 
 ##

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

@@ -15,11 +15,15 @@ module SPARQL; module Algebra
     #
     # @example SPARQL Grammar (sparql-star)
     #   PREFIX : <http://example.com/ns#>
-    #   SELECT * {<< :a :b :c >> :p1 :o1.}
+    #   SELECT * {<< :a :b :c ~ :r >> :p1 :o1.}
     #
     # @example SSE (sparql-star)
-    #   (prefix ((: <http://example.com/ns#>))
-    #    (bgp (triple (qtriple :a :b :c) :p1 :o1)))
+    #   (prefix
+    #    ((: <http://example.com/ns#>))
+    #    (bgp
+    #     (triple :r <http://www.w3.org/1999/02/22-rdf-syntax-ns#reifies>
+    #      (qtriple :a :b :c))
+    #     (triple :r :p1 :o1)))
     #
     # @see https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
     class BGP < Operator

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

@@ -5,6 +5,8 @@ module SPARQL; module Algebra
     #
     # GroupConcat is a set function which performs a string concatenation across the values of an expression with a group. The order of the strings is not specified. The separator character used in the concatenation may be given with the scalar argument SEPARATOR.
     #
+    # If all operands are language-tagged strings with the same language (and direction), the result shares the language (and direction).
+    #
     # [127] Aggregate::= ... | 'GROUP_CONCAT' '(' 'DISTINCT'? Expression ( ';' 'SEPARATOR' '=' String )? ')'
     #
     # @example SPARQL Grammar
@@ -72,7 +74,9 @@ module SPARQL; module Algebra
       # @return [RDF::Term] An arbitrary term
       # @raise  [TypeError] If enum is empty
       def apply(enum, separator, **options)
-        RDF::Literal(enum.flatten.map(&:to_s).join(separator.to_s))
+        op1_lang = enum.first.language
+        lang = op1_lang if op1_lang && enum.all? {|v| v.language == op1_lang}
+        RDF::Literal(enum.flatten.map(&:to_s).join(separator.to_s), language: lang)
       end
 
       ##

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

@@ -101,11 +101,17 @@ module SPARQL; module Algebra
       #
       # @return [Join, RDF::Query] `self`
       # @return [self]
-      # @see SPARQL::Algebra::Expression#optimize!
-      def optimize!(**options)
-        ops = operands.map {|o| o.optimize(**options) }.select {|o| o.respond_to?(:empty?) && !o.empty?}
-        @operands = ops
-        self
+      # @see SPARQL::Algebra::Expression#optimize
+      def optimize(**options)
+        ops = operands.map {|o| o.optimize(**options) }.reject {|o| o.respond_to?(:empty?) && o.empty?}
+        case ops.length
+        when 0
+          SPARQL::Algebra::Expression[:bgp]
+        when 1
+          ops.first
+        else
+          self.class.new(ops)
+        end
       end
 
       ##

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

@@ -136,21 +136,22 @@ module SPARQL; module Algebra
       # @return [Object] a copy of `self`
       # @see SPARQL::Algebra::Expression#optimize
       # FIXME
-      def optimize!(**options)
-        return self
-        ops = operands.map {|o| o.optimize(**options) }.select {|o| o.respond_to?(:empty?) && !o.empty?}
-        expr = ops.pop unless ops.last.executable?
+      def optimize(**options)
+        lhs, rhs, expr = operands.map {|o| o.optimize(**options) }
         expr = nil if expr.respond_to?(:true?) && expr.true?
-        
-        # ops now is one or two executable operators
-        # expr is a filter expression, which may have been optimized to 'true'
-        case ops.length
-        when 0
+
+        if lhs.empty? && rhs.empty?
           RDF::Query.new  # Empty query, expr doesn't matter
-        when 1
-          expr ? Filter.new(expr, ops.first) : ops.first
+        elsif rhs.empty?
+          # Expression doesn't matter, just use the first operand
+          lhs
+        elsif lhs.empty?
+          # Result is the filter of the second operand if there is an expression
+          # FIXME: doesn't seem to work
+          #expr ? Filter.new(expr, rhs) : rhs
+          self.dup
         else
-          expr ? LeftJoin.new(ops[0], ops[1], expr) : LeftJoin.new(ops[0], ops[1])
+          expr ? LeftJoin.new(rhs, lhs, expr) : LeftJoin.new(lhs, rhs)
         end
       end
 

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

@@ -91,7 +91,7 @@ module SPARQL; module Algebra
       # @return [self]
       # @see SPARQL::Algebra::Expression#optimize!
       def optimize!(**options)
-        ops = operands.map {|o| o.optimize(**options) }.select {|o| o.respond_to?(:empty?) && !o.empty?}
+        ops = operands.map {|o| o.optimize(**options) }.reject {|o| o.respond_to?(:empty?) && o.empty?}
         @operands = ops
         self
       end

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

@@ -3,6 +3,8 @@ module SPARQL; module Algebra
     ##
     # The SPARQL Property Path `path` operator.
     #
+    # The second element represents a set of predicates which ar associated with the first (subject) and last (object) operands.
+    #
     # [88]  Path ::= PathAlternative
     #
     # @example SPARQL Grammar
@@ -71,6 +73,42 @@ module SPARQL; module Algebra
         str = operands.to_sparql(top_level: false, **options) + " ."
         top_level ? Operator.to_sparql(str, **options) : str
       end
+
+      ##
+      # Special cases for optimizing a path based on its operands.
+      #
+      # @param  [Hash{Symbol => Object}] options
+      #   any additional options for optimization
+      # @return [SPARQL::Algebra::Operator]
+      #   May returnn a different operator
+      # @see    RDF::Query#optimize!
+      def optimize(**options)
+        op = super
+        while true
+          decon = op.to_sxp_bin
+          op = case decon
+          # Reverse
+          in [:path, subject, [:reverse, path], object]
+            Path.new(object, path, subject)
+          # Path* (seq (seq p0 (path* p1)) p2)
+          in [:path, subject, [:seq, [:seq, p0, [:'path*', p1]], p2], object]
+            pp1 = Variable.new(nil, distinguished: false)
+            pp2 = Variable.new(nil, distinguished: false)
+            pp3 = Variable.new(nil, distinguished: false)
+            # Bind variables used in Path*
+            bgp = BGP.new(
+              Triple.new(pp2, p2, subject),
+              Triple.new(object, p1, pp3))
+            # New path with pre-bound variables
+            path = Path.new(pp3, PathStar.new(p2), pp2)
+            Sequence.new(bgp, path)
+          else
+            # No matching patterns
+            break
+          end
+        end
+        op
+      end
     end # Path
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -56,11 +56,49 @@ module SPARQL; module Algebra
         flags = flags.to_s
         # TODO: validate flag syntax
 
+        # 's' mode in XPath is like ruby MUTLILINE
+        # 'm' mode in XPath is like ruby /^$/ vs /\A\z/
+        unless flags.include?(?m)
+          pattern = '\A' + pattern[1..-1] if pattern.start_with?('^')
+          pattern = pattern[0..-2] + '\z' if pattern.end_with?('$')
+        end
+
         options = 0
-        raise NotImplementedError, "unsupported regular expression flag: /s" if flags.include?(?s) # FIXME
-        options |= Regexp::MULTILINE  if flags.include?(?m)
+        if flags.include?('x')
+          flags = flags.sub('x', '')
+          # If present, whitespace characters (#x9, #xA, #xD and #x20) in the regular expression are removed prior to matching with one exception: whitespace characters within character class expressions (charClassExpr) are not removed. This flag can be used, for example, to break up long regular expressions into readable lines.
+          # Scan pattern entering a state when scanning `[` that does nto remove whitespace and exit that state when scanning `]`.
+          in_charclass = false
+          pattern = pattern.chars.map do |c|
+            case c
+            when '['
+              in_charclass = true
+              c
+            when ']'
+              in_charclass = false
+              c
+            else
+              c.match?(/\s/) && !in_charclass ? '' : c
+            end
+          end.join('')
+        end
+
+        if flags.include?('q')
+          flags = flags.sub('x', '')
+          # if present, all characters in the regular expression are treated as representing themselves, not as metacharacters. In effect, every character that would normally have a special meaning in a regular expression is implicitly escaped by preceding it with a backslash.
+          # Simply replace every character with an escaped version of that character
+          pattern = pattern.chars.map do |c|
+            case c
+            when '.', '?', '*', '^', '$', '+', '(', ')', '[', ']', '{', '}'
+              "\\#{c}"
+            else
+              c
+            end
+          end.join("")
+        end
+
+        options |= Regexp::MULTILINE  if flags.include?(?s) # dot-all mode
         options |= Regexp::IGNORECASE if flags.include?(?i)
-        options |= Regexp::EXTENDED   if flags.include?(?x)
         RDF::Literal(Regexp.new(pattern, options) === text)
       end
 

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

@@ -31,7 +31,7 @@ module SPARQL; module Algebra
     #    SELECT * { } VALUES () { }
     #
     # @example SSE (empty query no values)
-    #    (join (bgp) (table empty))
+    #    (join (bgp) (table (vars)))
     #
     # [61]  InlineData              ::= 'VALUES' DataBlock
     #

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

@@ -69,7 +69,7 @@ module SPARQL; module Algebra
       # @return [self]
       # @see SPARQL::Algebra::Expression#optimize!
       def optimize!(**options)
-        ops = operands.map {|o| o.optimize(**options) }.select {|o| o.respond_to?(:empty?) && !o.empty?}
+        ops = operands.map {|o| o.optimize(**options) }.reject {|o| o.respond_to?(:empty?) && o.empty?}
         @operands = ops
         self
       end

data/lib/sparql/algebra/operator.rb

@@ -812,6 +812,14 @@ module SPARQL; module Algebra
       operands.inject({}) {|hash, o| o.respond_to?(:variables) ? hash.merge(o.variables) : hash}
     end
 
+    # In generall, two operands cannot be merged
+    #
+    # @param [RDF::Query] other
+    # @return [Boolean]
+    def mergable?(other)
+      false
+    end
+
   protected
 
     ##

data/lib/sparql/algebra.rb

@@ -402,9 +402,13 @@ module SPARQL
     #   a SPARQL S-Expression (SSE) string
     # @param  [Hash{Symbol => Object}] options
     #   any additional options (see {Operator#initialize})
+    # @option options [Boolean] :optimize (false)
+    #   Run query optimizer after parsing.
     # @return [SPARQL::Algebra::Operator]
     def parse(sse, **options)
-      Expression.parse(sse, **options)
+      query = Expression.parse(sse, **options)
+      query = query.optimize if options[:optimize]
+      query
     end
     module_function :parse