Add some path optimmization for reverse and first/rest chains involving path*.

Fixes #49.

Author: gkellogg

bin/sparql

@@ -46,6 +46,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]
@@ -70,37 +72,41 @@ rescue LoadError
   $stderr.puts "Running SPARQL server requires Rack 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
@@ -117,6 +123,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

lib/sparql/algebra/operator/join.rb

@@ -103,7 +103,7 @@ def validate!
       # @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

lib/sparql/algebra/operator/left_join.rb

@@ -138,7 +138,7 @@ def validate!
       # FIXME
       def optimize!(**options)
         return self
-        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?}
         expr = ops.pop unless ops.last.executable?
         expr = nil if expr.respond_to?(:true?) && expr.true?
 

lib/sparql/algebra/operator/minus.rb

@@ -91,7 +91,7 @@ def execute(queryable, **options, &block)
       # @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

lib/sparql/algebra/operator/path.rb

@@ -3,6 +3,8 @@ class Operator
     ##
     # 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 @@ def to_sparql(top_level: true, **options)
         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

lib/sparql/algebra/operator/union.rb

@@ -69,7 +69,7 @@ def validate!
       # @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