hotdog 0.4.1 → 0.5.0

data/lib/hotdog/commands/search.rb

@@ -6,13 +6,15 @@ require "parslet"
 module Hotdog
   module Commands
     class Search < BaseCommand
-      def run(args=[])
-        search_options = {
-        }
+      def define_options(optparse)
+        @search_options = @options.merge({
+        })
         optparse.on("-n", "--limit LIMIT", "Limit result set to specified size at most", Integer) do |limit|
-          search_options[:limit] = limit
+          @search_options[:limit] = limit
         end
-        args = optparse.parse(args)
+      end
+
+      def run(args=[])
         expression = args.join(" ").strip
         if expression.empty?
           # return everything if given expression is empty
@@ -29,7 +31,7 @@ module Hotdog
         result = evaluate(node, self)
         if 0 < result.length
           _result, fields = get_hosts_with_search_tags(result, node)
-          result = _result.take(search_options.fetch(:limit, _result.size))
+          result = _result.take(@search_options.fetch(:limit, _result.size))
           STDOUT.print(format(result, fields: fields))
           if _result.length == result.length
             logger.info("found %d host(s)." % result.length)
@@ -67,14 +69,22 @@ module Hotdog
       def parse(expression)
         parser = ExpressionParser.new
         parser.parse(expression).tap do |parsed|
-          logger.debug(JSON.pretty_generate(JSON.load(parsed.to_json)))
+          logger.debug {
+            begin
+              JSON.pretty_generate(JSON.load(parsed.to_json))
+            rescue JSON::NestingError => error
+              error.message
+            end
+          }
         end
       end
 
       def evaluate(data, environment)
         node = ExpressionTransformer.new.apply(data)
         optimized = node.optimize.tap do |optimized|
-          logger.debug(JSON.pretty_generate(optimized.dump))
+          logger.debug {
+            JSON.pretty_generate(optimized.dump)
+          }
         end
         optimized.evaluate(environment)
       end
@@ -133,9 +143,9 @@ module Hotdog
         }
         rule(:atom) {
           ( spacing.maybe >> str('(') >> expression >> str(')') >> spacing.maybe \
-          | spacing.maybe >> identifier_regexp.as(:identifier_regexp) >> separator.as(:separator) >> attribute_regexp.as(:attribute_regexp) >> spacing.maybe \
-          | spacing.maybe >> identifier_regexp.as(:identifier_regexp) >> separator.as(:separator) >> spacing.maybe \
-          | spacing.maybe >> identifier_regexp.as(:identifier_regexp) >> spacing.maybe \
+          | spacing.maybe >> str('/') >> identifier_regexp.as(:identifier_regexp) >> str('/') >> separator.as(:separator) >> str('/') >> attribute_regexp.as(:attribute_regexp) >> str('/') >> spacing.maybe \
+          | spacing.maybe >> str('/') >> identifier_regexp.as(:identifier_regexp) >> str('/') >> separator.as(:separator) >> spacing.maybe \
+          | spacing.maybe >> str('/') >> identifier_regexp.as(:identifier_regexp) >> str('/') >> spacing.maybe \
           | spacing.maybe >> identifier_glob.as(:identifier_glob) >> separator.as(:separator) >> attribute_glob.as(:attribute_glob) >> spacing.maybe \
           | spacing.maybe >> identifier_glob.as(:identifier_glob) >> separator.as(:separator) >> attribute.as(:attribute) >> spacing.maybe \
           | spacing.maybe >> identifier_glob.as(:identifier_glob) >> separator.as(:separator) >> spacing.maybe \
@@ -144,16 +154,16 @@ module Hotdog
           | spacing.maybe >> identifier.as(:identifier) >> separator.as(:separator) >> attribute.as(:attribute) >> spacing.maybe \
           | spacing.maybe >> identifier.as(:identifier) >> separator.as(:separator) >> spacing.maybe \
           | spacing.maybe >> identifier.as(:identifier) >> spacing.maybe \
-          | spacing.maybe >> separator.as(:separator) >> attribute_regexp.as(:attribute_regexp) >> spacing.maybe \
+          | spacing.maybe >> separator.as(:separator) >> str('/') >> attribute_regexp.as(:attribute_regexp) >> str('/') >> spacing.maybe \
           | spacing.maybe >> separator.as(:separator) >> attribute_glob.as(:attribute_glob) >> spacing.maybe \
           | spacing.maybe >> separator.as(:separator) >> attribute.as(:attribute) >> spacing.maybe \
-          | spacing.maybe >> attribute_regexp.as(:attribute_regexp) >> spacing.maybe \
+          | spacing.maybe >> str('/') >> attribute_regexp.as(:attribute_regexp) >> str('/') >> spacing.maybe \
           | spacing.maybe >> attribute_glob.as(:attribute_glob) >> spacing.maybe \
           | spacing.maybe >> attribute.as(:attribute) >> spacing.maybe \
           )
         }
         rule(:identifier_regexp) {
-          ( str('/') >> (str('/').absent? >> any).repeat(0) >> str('/') \
+          ( (str('/').absent? >> any).repeat(0) \
           )
         }
         rule(:identifier_glob) {
@@ -170,7 +180,7 @@ module Hotdog
           )
         }
         rule(:attribute_regexp) {
-          ( str('/') >> (str('/').absent? >> any).repeat(0) >> str('/') \
+          ( (str('/').absent? >> any).repeat(0) \
           )
         }
         rule(:attribute_glob) {
@@ -198,55 +208,75 @@ module Hotdog
           UnaryExpressionNode.new(unary_op, expression)
         }
         rule(identifier_regexp: simple(:identifier_regexp), separator: simple(:separator), attribute_regexp: simple(:attribute_regexp)) {
-          TagRegexpExpressionNode.new(identifier_regexp.to_s, attribute_regexp.to_s, separator)
+          if "host" == identifier_regexp
+            RegexpHostNode.new(attribute_regexp.to_s, separator)
+          else
+            RegexpTagNode.new(identifier_regexp.to_s, attribute_regexp.to_s, separator)
+          end
         }
         rule(identifier_regexp: simple(:identifier_regexp), separator: simple(:separator)) {
-          TagRegexpExpressionNode.new(identifier_regexp.to_s, nil, nil)
+          RegexpTagNameNode.new(identifier_regexp.to_s, separator)
         }
         rule(identifier_regexp: simple(:identifier_regexp)) {
-          TagRegexpExpressionNode.new(identifier_regexp.to_s, nil, nil)
+          RegexpNode.new(identifier_regexp.to_s)
         }
         rule(identifier_glob: simple(:identifier_glob), separator: simple(:separator), attribute_glob: simple(:attribute_glob)) {
-          TagGlobExpressionNode.new(identifier_glob.to_s, attribute_glob.to_s, separator)
+          if "host" == identifier_glob
+            GlobHostNode.new(attribute_glob.to_s, separator)
+          else
+            GlobTagNode.new(identifier_glob.to_s, attribute_glob.to_s, separator)
+          end
         }
         rule(identifier_glob: simple(:identifier_glob), separator: simple(:separator), attribute: simple(:attribute)) {
-          TagGlobExpressionNode.new(identifier_glob.to_s, attribute.to_s, separator)
+          if "host" == identifier_glob
+            GlobHostNode.new(attribute.to_s, separator)
+          else
+            GlobTagNode.new(identifier.to_s, attribute.to_s, separator)
+          end
         }
         rule(identifier_glob: simple(:identifier_glob), separator: simple(:separator)) {
-          TagGlobExpressionNode.new(identifier_glob.to_s, nil, separator)
+          GlobTagNameNode.new(identifier_glob.to_s, separator)
         }
         rule(identifier_glob: simple(:identifier_glob)) {
-          TagGlobExpressionNode.new(identifier_glob.to_s, nil, nil)
+          GlobNode.new(identifier_glob.to_s)
         }
         rule(identifier: simple(:identifier), separator: simple(:separator), attribute_glob: simple(:attribute_glob)) {
-          TagGlobExpressionNode.new(identifier.to_s, attribute_glob.to_s, separator)
+          if "host" == identifier
+            GlobHostNode.new(attribute_glob.to_s, separator)
+          else
+            GlobTagNode.new(identifier.to_s, attribute_glob.to_s, separator)
+          end
         }
         rule(identifier: simple(:identifier), separator: simple(:separator), attribute: simple(:attribute)) {
-          TagExpressionNode.new(identifier.to_s, attribute.to_s, separator)
+          if "host" == identifier
+            StringHostNode.new(attribute.to_s, separator)
+          else
+            StringTagNode.new(identifier.to_s, attribute.to_s, separator)
+          end
         }
         rule(identifier: simple(:identifier), separator: simple(:separator)) {
-          TagExpressionNode.new(identifier.to_s, nil, separator)
+          StringTagNameNode.new(identifier.to_s, separator)
         }
         rule(identifier: simple(:identifier)) {
-          TagExpressionNode.new(identifier.to_s, nil, nil)
+          StringNode.new(identifier.to_s)
         }
         rule(separator: simple(:separator), attribute_regexp: simple(:attribute_regexp)) {
-          TagRegexpExpressionNode.new(nil, attribute_regexp.to_s, separator)
+          RegexpTagValueNode.new(attribute_regexp.to_s, separator)
         }
         rule(attribute_regexp: simple(:attribute_regexp)) {
-          TagRegexpExpressionNode.new(nil, attribute_regexp.to_s, nil)
+          RegexpTagValueNode.new(attribute_regexp.to_s)
         }
         rule(separator: simple(:separator), attribute_glob: simple(:attribute_glob)) {
-          TagGlobExpressionNode.new(nil, attribute_glob.to_s, separator)
+          GlobTagValueNode.new(attribute_glob.to_s, separator)
         }
         rule(attribute_glob: simple(:attribute_glob)) {
-          TagGlobExpressionNode.new(nil, attribute_glob.to_s, nil)
+          GlobTagValueNode.new(attribute_glob.to_s)
         }
         rule(separator: simple(:separator), attribute: simple(:attribute)) {
-          TagExpressionNode.new(nil, attribute.to_s, separator)
+          StringTagValueNode.new(attribute.to_s, separator)
         }
         rule(attribute: simple(:attribute)) {
-          TagExpressionNode.new(nil, attribute.to_s, nil)
+          StringTagValueNode.new(attribute.to_s)
         }
       end
 
@@ -262,6 +292,106 @@ module Hotdog
         def dump(options={})
           {}
         end
+
+        def intermediates()
+          []
+        end
+
+        def leafs()
+          [self]
+        end
+      end
+
+      class UnaryExpressionNode < ExpressionNode
+        attr_reader :op, :expression
+
+        def initialize(op, expression)
+          case op
+          when "!", "~", /\Anot\z/i
+            @op = :NOT
+          else
+            raise(SyntaxError.new("unknown unary operator: #{@op.inspect}"))
+          end
+          @expression = expression
+        end
+
+        def evaluate(environment, options={})
+          case @op
+          when :NOT
+            values = @expression.evaluate(environment, options).tap do |values|
+              environment.logger.debug("expr: #{values.length} value(s)")
+            end
+            if values.empty?
+              environment.execute("SELECT id FROM hosts").map { |row| row.first }.tap do |values|
+                environment.logger.debug("NOT expr: #{values.length} value(s)")
+              end
+            else
+              # workaround for "too many terms in compound SELECT"
+              min, max = environment.execute("SELECT MIN(id), MAX(id) FROM hosts ORDER BY id LIMIT 1").first.to_a
+              (min / (SQLITE_LIMIT_COMPOUND_SELECT - 2)).upto(max / (SQLITE_LIMIT_COMPOUND_SELECT - 2)).flat_map { |i|
+                range = ((SQLITE_LIMIT_COMPOUND_SELECT - 2) * i)...((SQLITE_LIMIT_COMPOUND_SELECT - 2) * (i + 1))
+                selected = values.select { |n| range === n }
+                q = "SELECT id FROM hosts " \
+                      "WHERE ? <= id AND id < ? AND id NOT IN (%s);"
+                environment.execute(q % selected.map { "?" }.join(", "), [range.first, range.last] + selected).map { |row| row.first }
+              }.tap do |values|
+                environment.logger.debug("NOT expr: #{values.length} value(s)")
+              end
+            end
+          else
+            []
+          end
+        end
+
+        def optimize(options={})
+          @expression = @expression.optimize(options)
+          case op
+          when :NOT
+            optimize1(options)
+          else
+            self
+          end
+        end
+
+        def ==(other)
+          self.class === other and @op == other.op and @expression == other.expression
+        end
+
+        def dump(options={})
+          {unary_op: @op.to_s, expression: @expression.dump(options)}
+        end
+
+        def intermediates()
+          [self] + @expression.intermediates
+        end
+
+        def leafs()
+          @expression.leafs
+        end
+
+        private
+        def optimize1(options={})
+          case op
+          when :NOT
+            if UnaryExpressionNode === expression and expression.op == :NOT
+              expression.expression
+            else
+              if TagExpressionNode === expression
+                q = expression.maybe_query(options)
+                v = expression.condition_values(options)
+                if q and v.length <= SQLITE_LIMIT_COMPOUND_SELECT
+                  QueryExpressionNode.new("SELECT id AS host_id FROM hosts EXCEPT #{q.sub(/\s*;\s*\z/, "")};", v)
+                else
+                  self
+                end
+              else
+                self
+              end
+            end
+          else
+            self
+          end
+        end
       end
 
       class BinaryExpressionNode < ExpressionNode
@@ -386,10 +516,30 @@ module Hotdog
             if left == right
               left
             else
-              optimize1(options)
+              if MultinaryExpressionNode === left
+                if left.op == op
+                  left.merge(right, fallback: self)
+                else
+                  optimize1(options)
+                end
+              else
+                if MultinaryExpressionNode === right
+                  if right.op == op
+                    right.merge(left, fallback: self)
+                  else
+                    optimize1(options)
+                  end
+                else
+                  MultinaryExpressionNode.new(op, [left, right], fallback: self)
+                end
+              end
             end
           when :XOR
-            optimize1(options)
+            if left == right
+              []
+            else
+              optimize1(options)
+            end
           else
             self
           end
@@ -400,30 +550,37 @@ module Hotdog
         end
 
         def dump(options={})
-          {left: @left.dump(options), op: @op.to_s, right: @right.dump(options)}
+          {left: @left.dump(options), binary_op: @op.to_s, right: @right.dump(options)}
+        end
+
+        def intermediates()
+          [self] + @left.intermediates + @right.intermediates
+        end
+
+        def leafs()
+          @left.leafs + @right.leafs
         end
 
         private
         def optimize1(options)
           if TagExpressionNode === left and TagExpressionNode === right
-            lhs = left.plan(options)
-            rhs = right.plan(options)
-            if lhs and rhs and lhs[1].length + rhs[1].length <= SQLITE_LIMIT_COMPOUND_SELECT
+            lq = left.maybe_query(options)
+            lv = left.condition_values(options)
+            rq = right.maybe_query(options)
+            rv = right.condition_values(options)
+            if lq and rq and lv.length + rv.length <= SQLITE_LIMIT_COMPOUND_SELECT
               case op
               when :AND
-                q = "SELECT host_id FROM ( #{lhs[0].sub(/\s*;\s*\z/, "")} ) " \
-                      "INTERSECT #{rhs[0].sub(/\s*;\s*\z/, "")};"
-                QueryExpressionNode.new(q, lhs[1] + rhs[1], fallback: self)
+                q = "#{lq.sub(/\s*;\s*\z/, "")} INTERSECT #{rq.sub(/\s*;\s*\z/, "")};"
+                QueryExpressionNode.new(q, lv + rv, fallback: self)
               when :OR
-                q = "SELECT host_id FROM ( #{lhs[0].sub(/\s*;\s*\z/, "")} ) " \
-                      "UNION #{rhs[0].sub(/\s*;\s*\z/, "")};"
-                QueryExpressionNode.new(q, lhs[1] + rhs[1], fallback: self)
+                q = "#{lq.sub(/\s*;\s*\z/, "")} UNION #{rq.sub(/\s*;\s*\z/, "")};"
+                QueryExpressionNode.new(q, lv + rv, fallback: self)
               when :XOR
-                q = "SELECT host_id FROM ( #{lhs[0].sub(/\s*;\s*\z/, "")} ) " \
-                      "UNION #{rhs[0].sub(/\s*;\s*\z/, "")} " \
-                      "EXCEPT SELECT host_id FROM ( #{lhs[0].sub(/\s*;\s*\z/, "")} ) " \
-                        "INTERSECT #{rhs[0].sub(/\s*;\s*\z/, "")};"
-                QueryExpressionNode.new(q, lhs[1] + rhs[1], fallback: self)
+                q = "#{lq.sub(/\s*;\s*\z/, "")} UNION #{rq.sub(/\s*;\s*\z/, "")} " \
+                      "EXCEPT #{lq.sub(/\s*;\s*\z/, "")} " \
+                        "INTERSECT #{rq.sub(/\s*;\s*\z/, "")};"
+                QueryExpressionNode.new(q, lv + rv, fallback: self)
               else
                 self
               end
@@ -436,88 +593,71 @@ module Hotdog
         end
       end
 
-      class UnaryExpressionNode < ExpressionNode
-        attr_reader :op, :expression
+      class MultinaryExpressionNode < ExpressionNode
+        attr_reader :op, :expressions
 
-        def initialize(op, expression)
+        def initialize(op, expressions, options={})
           case op
-          when "!", "~", /\Anot\z/i
-            @op = :NOT
+          when :OR
+            @op = :OR
           else
-            raise(SyntaxError.new("unknown unary operator: #{@op.inspect}"))
+            raise(SyntaxError.new("unknown multinary operator: #{op.inspect}"))
+          end
+          if SQLITE_LIMIT_COMPOUND_SELECT < expressions.length
+            raise(ArgumentError.new("expressions limit exceeded: #{expressions.length} for #{SQLITE_LIMIT_COMPOUND_SELECT}"))
+          end
+          @expressions = expressions
+          @fallback = options[:fallback]
+        end
+
+        def merge(other, options={})
+          if MultinaryExpressionNode === other and op == other.op
+            MultinaryExpressionNode.new(op, expressions + other.expressions, options)
+          else
+            MultinaryExpressionNode.new(op, expressions + [other], options)
           end
-          @expression = expression
         end
 
         def evaluate(environment, options={})
           case @op
-          when :NOT
-            values = @expression.evaluate(environment, options).tap do |values|
-              environment.logger.debug("expr: #{values.length} value(s)")
-            end
-            if values.empty?
-              environment.execute("SELECT id FROM hosts").map { |row| row.first }.tap do |values|
-                environment.logger.debug("NOT expr: #{values.length} value(s)")
+          when :OR
+            if expressions.all? { |expression| TagExpressionNode === expression }
+              if query_without_condition = expressions.first.maybe_query_without_condition(options)
+                q = query_without_condition.sub(/\s*;\s*\z/, "") + " WHERE " + expressions.map { |expression| "( %s )" % expression.condition(options) }.join(" OR ") + ";"
+                condition_length = expressions.first.condition_values(options).length
+                values = expressions.each_slice(SQLITE_LIMIT_COMPOUND_SELECT / condition_length).flat_map { |expressions|
+                  environment.execute(q, expressions.flat_map { |expression| expression.condition_values(options) }).map { |row| row.first }
+                }
+              else
+                values = []
               end
             else
-              # workaround for "too many terms in compound SELECT"
-              min, max = environment.execute("SELECT MIN(id), MAX(id) FROM hosts ORDER BY id LIMIT 1").first.to_a
-              (min / (SQLITE_LIMIT_COMPOUND_SELECT - 2)).upto(max / (SQLITE_LIMIT_COMPOUND_SELECT - 2)).flat_map { |i|
-                range = ((SQLITE_LIMIT_COMPOUND_SELECT - 2) * i)...((SQLITE_LIMIT_COMPOUND_SELECT - 2) * (i + 1))
-                selected = values.select { |n| range === n }
-                q = "SELECT id FROM hosts " \
-                      "WHERE ? <= id AND id < ? AND id NOT IN (%s);"
-                environment.execute(q % selected.map { "?" }.join(", "), [range.first, range.last] + selected).map { |row| row.first }
-              }.tap do |values|
-                environment.logger.debug("NOT expr: #{values.length} value(s)")
-              end
+              values = []
             end
           else
-            []
+            values = []
           end
-        end
-
-        def optimize(options={})
-          @expression = @expression.optimize(options)
-          case op
-          when :NOT
-            optimize1(options)
+          if values.empty?
+            if @fallback
+              @fallback.evaluate(environment, options={})
+            else
+              []
+            end
           else
-            self
+            values
           end
         end
 
-        def ==(other)
-          self.class === other and @op == other.op and @expression == other.expression
+        def dump(optinos={})
+          {multinary_op: @op.to_s, expressions: expressions.map { |expression| expression.dump }}
         end
 
-        def dump(options={})
-          {op: @op.to_s, expression: @expression.dump(options)}
+        def intermediates()
+          [self] + @expression.flat_map { |expression| expression.intermediates }
         end
 
-        private
-        def optimize1(options={})
-          case op
-          when :NOT
-            if UnaryExpressionNode === expression and expression.op == :NOT
-              expression.expression
-            else
-              if TagExpressionNode === expression
-                expr = expression.plan(options)
-                if expr and expr[1].length <= SQLITE_LIMIT_COMPOUND_SELECT
-                  q = "SELECT id AS host_id FROM hosts " \
-                        "EXCEPT #{expr[0].sub(/\s*;\s*\z/, "")};"
-                  QueryExpressionNode.new(q, expr[1])
-                else
-                  self
-                end
-              else
-                self
-              end
-            end
-          else
-            self
-          end
+        def leafs()
+          @expressions.flat_map { |expression| expression.leafs }
         end
       end
 
@@ -531,7 +671,11 @@ module Hotdog
         def evaluate(environment, options={})
           values = environment.execute(@query, @args).map { |row| row.first }
           if values.empty? and @fallback
-            @fallback.evaluate(environment, options)
+            @fallback.evaluate(environment, options).tap do |values|
+              if values.empty?
+                environment.logger.info("no result: #{self.dump.inspect}")
+              end
+            end
           else
             values
           end
@@ -567,49 +711,47 @@ module Hotdog
           !(separator.nil? or separator.to_s.empty?)
         end
 
-        def plan(options={})
-          if identifier?
-            if attribute?
-              case identifier
-              when /\Ahost\z/i
-                q = "SELECT hosts.id AS host_id FROM hosts " \
-                      "WHERE hosts.name = ?;"
-                [q, [attribute]]
-              else
-                q = "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags " \
-                      "INNER JOIN tags ON hosts_tags.tag_id = tags.id " \
-                        "WHERE tags.name = ? AND tags.value = ?;"
-                [q, [identifier, attribute]]
-              end
-            else
-              if separator?
-                q = "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags " \
-                      "INNER JOIN tags ON hosts_tags.tag_id = tags.id " \
-                        "WHERE tags.name = ?;"
-                [q, [identifier]]
-              else
-                q = "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags " \
-                      "INNER JOIN hosts ON hosts_tags.host_id = hosts.id " \
-                      "INNER JOIN tags ON hosts_tags.tag_id = tags.id " \
-                        "WHERE hosts.name = ? OR tags.name = ? OR tags.value = ?;"
-                [q, [identifier, identifier, identifier]]
-              end
-            end
+        def maybe_query(options={})
+          if query_without_condition = maybe_query_without_condition(options)
+            query_without_condition.sub(/\s*;\s*\z/, "") + " WHERE " + condition(options) + ";"
           else
-            if attribute?
-               q = "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags " \
-                     "INNER JOIN tags ON hosts_tags.tag_id = tags.id " \
-                       "WHERE tags.value = ?;"
-              [q, [attribute]]
+            nil
+          end
+        end
+
+        def maybe_query_without_condition(options={})
+          tables = condition_tables(options)
+          if tables.empty?
+            nil
+          else
+            case tables.sort
+            when [:hosts]
+              "SELECT hosts.id AS host_id FROM hosts;"
+            when [:hosts, :tags]
+              "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags INNER JOIN hosts ON hosts_tags.host_id = hosts.id INNER JOIN tags ON hosts_tags.tag_id = tags.id;"
+            when [:tags]
+              "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags INNER JOIN tags ON hosts_tags.tag_id = tags.id;"
             else
-              nil
+              raise(NotImplementedError.new("unknown tables: #{tables.join(", ")}"))
             end
           end
         end
 
+        def condition(options={})
+          raise NotImplementedError
+        end
+
+        def condition_tables(options={})
+          raise NotImplementedError
+        end
+
+        def condition_values(options={})
+          raise NotImplementedError
+        end
+
         def evaluate(environment, options={})
-          if q = plan(options)
-            values = environment.execute(*q).map { |row| row.first }
+          if q = maybe_query(options)
+            values = environment.execute(q, condition_values(options)).map { |row| row.first }
             if values.empty?
               if options[:did_fallback]
                 []
@@ -618,12 +760,28 @@ module Hotdog
                   # avoid optimizing @fallback to prevent infinite recursion
                   values = @fallback.evaluate(environment, options.merge(did_fallback: true))
                   if values.empty?
-                    reload(environment, options)
+                    if reload(environment, options)
+                      evaluate(environment, options).tap do |values|
+                        if values.empty?
+                          environment.logger.info("no result: #{self.dump.inspect}")
+                        end
+                      end
+                    else
+                      []
+                    end
                   else
                     values
                   end
                 else
-                  reload(environment, options)
+                  if reload(environment, options)
+                    evaluate(environment, options).tap do |values|
+                      if values.empty?
+                        environment.logger.info("no result: #{self.dump.inspect}")
+                      end
+                    end
+                  else
+                    []
+                  end
                 end
               end
             else
@@ -640,158 +798,378 @@ module Hotdog
 
         def optimize(options={})
           # fallback to glob expression
-          if identifier?
-            prefix = (identifier.start_with?("*")) ? "" : "*"
-            suffix = (identifier.end_with?("*")) ? "" : "*"
-            identifier_glob = prefix + identifier.gsub(/[-.\/_]/, "?") + suffix
-          else
-            identifier_glob = nil
-          end
-          if attribute?
-            prefix = (attribute.start_with?("*")) ? "" : "*"
-            suffix = (attribute.end_with?("*")) ? "" : "*"
-            attribute_glob = prefix + attribute.gsub(/[-.\/_]/, "?") + suffix
-          else
-            attribute_glob = nil
-          end
-          if (identifier? and identifier != identifier_glob) or (attribute? and attribute != attribute_glob)
-            @fallback = TagGlobExpressionNode.new(identifier_glob, attribute_glob, separator)
-          end
+          @fallback = maybe_fallback(options)
           self
         end
 
+        def to_glob(s)
+          (s.start_with?("*") ? "" : "*") + s.gsub(/[-.\/_]/, "?") + (s.end_with?("*") ? "" : "*")
+        end
+
+        def maybe_glob(s)
+          s ? to_glob(s.to_s) : nil
+        end
+
         def reload(environment, options={})
-          ttl = options.fetch(:ttl, 1)
-          if 0 < ttl
+          $did_reload ||= false
+          if $did_reload
+            false
+          else
+            $did_reload = true
             environment.logger.info("force reloading all hosts and tags.")
             environment.reload(force: true)
-            self.class.new(identifier, attribute, separator).optimize(options).evaluate(environment, options.merge(ttl: ttl-1))
-          else
-            []
+            true
           end
         end
 
         def dump(options={})
           data = {}
-          data[:identifier] = @identifier.to_s if @identifier
-          data[:separator] = @separator.to_s if @separator
-          data[:attribute] = @attribute.to_s if @attribute
+          data[:identifier] = identifier.to_s if identifier
+          data[:separator] = separator.to_s if separator
+          data[:attribute] = attribute.to_s if attribute
           data[:fallback ] = @fallback.dump(options) if @fallback
           data
         end
+
+        def maybe_fallback(options={})
+          nil
+        end
       end
 
-      class TagGlobExpressionNode < TagExpressionNode
-        def plan(options={})
-          if identifier?
-            if attribute?
-              case identifier
-              when /\Ahost\z/i
-                q = "SELECT hosts.id AS host_id FROM hosts " \
-                      "WHERE LOWER(hosts.name) GLOB LOWER(?);"
-                [q, [attribute]]
-              else
-                q = "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags " \
-                      "INNER JOIN tags ON hosts_tags.tag_id = tags.id " \
-                        "WHERE LOWER(tags.name) GLOB LOWER(?) AND LOWER(tags.value) GLOB LOWER(?);"
-                [q, [identifier, attribute]]
-              end
-            else
-              if separator?
-                q = "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags " \
-                      "INNER JOIN tags ON hosts_tags.tag_id = tags.id " \
-                        "WHERE LOWER(tags.name) GLOB LOWER(?);"
-                [q, [identifier]]
-              else
-                q = "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags " \
-                      "INNER JOIN hosts ON hosts_tags.host_id = hosts.id " \
-                      "INNER JOIN tags ON hosts_tags.tag_id = tags.id " \
-                        "WHERE LOWER(hosts.name) GLOB LOWER(?) OR LOWER(tags.name) GLOB LOWER(?) OR LOWER(tags.value) GLOB LOWER(?);"
-                [q, [identifier, identifier, identifier]]
-              end
-            end
-          else
-            if attribute?
-              q = "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags " \
-                    "INNER JOIN tags ON hosts_tags.tag_id = tags.id " \
-                      "WHERE LOWER(tags.value) GLOB LOWER(?);"
-              [q, [attribute]]
-            else
-              nil
-            end
-          end
+      class StringExpressionNode < TagExpressionNode
+      end
+
+      class StringHostNode < StringExpressionNode
+        def initialize(attribute, separator=nil)
+          super("host", attribute, separator)
+        end
+
+        def condition(options={})
+          "hosts.name = ?"
+        end
+
+        def condition_tables(options={})
+          [:hosts]
+        end
+
+        def condition_values(options={})
+          [attribute]
+        end
+
+        def maybe_fallback(options={})
+          GlobHostNode.new(maybe_glob(attribute), separator)
+        end
+      end
+
+      class StringTagNode < StringExpressionNode
+        def initialize(identifier, attribute, separator=nil)
+          super(identifier, attribute, separator)
         end
 
+        def condition(options={})
+          "tags.name = ? AND tags.value = ?"
+        end
+
+        def condition_tables(options={})
+          [:tags]
+        end
+
+        def condition_values(options={})
+          [identifier, attribute]
+        end
+
+        def maybe_fallback(options={})
+          GlobTagNode.new(maybe_glob(identifier), maybe_glob(attribute), separator)
+        end
+      end
+
+      class StringTagNameNode < StringExpressionNode
+        def initialize(identifier, separator=nil)
+          super(identifier, nil, separator)
+        end
+
+        def condition(options={})
+          "tags.name = ?"
+        end
+
+        def condition_tables(options={})
+          [:tags]
+        end
+
+        def condition_values(options={})
+          [identifier]
+        end
+
+        def maybe_fallback(options={})
+          GlobTagNameNode.new(maybe_glob(identifier), separator)
+        end
+      end
+
+      class StringTagValueNode < StringExpressionNode
+        def initialize(attribute, separator=nil)
+          super(nil, attribute, separator)
+        end
+
+        def condition(options={})
+          "tags.value = ?"
+        end
+
+        def condition_tables(options={})
+          [:tags]
+        end
+
+        def condition_values(options={})
+          [attribute]
+        end
+
+        def maybe_fallback(options={})
+          GlobTagValueNode.new(maybe_glob(attribute), separator)
+        end
+      end
+
+      class StringNode < StringExpressionNode
+        def initialize(identifier, separator=nil)
+          super(identifier, nil, separator)
+        end
+
+        def condition(options={})
+          "hosts.name = ? OR tags.name = ? OR tags.value = ?"
+        end
+
+        def condition_tables(options={})
+          [:hosts, :tags]
+        end
+
+        def condition_values(options={})
+          [identifier, identifier, identifier]
+        end
+
+        def maybe_fallback(options={})
+          GlobNode.new(maybe_glob(identifier), separator)
+        end
+      end
+
+      class GlobExpressionNode < TagExpressionNode
         def dump(options={})
           data = {}
-          data[:identifier_glob] = @identifier.to_s if @identifier
-          data[:separator] = @separator.to_s if @separator
-          data[:attribute_glob] = @attribute.to_s if @attribute
+          data[:identifier_glob] = identifier.to_s if identifier
+          data[:separator] = separator.to_s if separator
+          data[:attribute_glob] = attribute.to_s if attribute
           data[:fallback] = @fallback.dump(options) if @fallback
           data
         end
       end
 
-      class TagRegexpExpressionNode < TagExpressionNode
+      class GlobHostNode < GlobExpressionNode
+        def initialize(attribute, separator=nil)
+          super("host", attribute, separator)
+        end
+
+        def condition(options={})
+          "LOWER(hosts.name) GLOB LOWER(?)"
+        end
+
+        def condition_tables(options={})
+          [:hosts]
+        end
+
+        def condition_values(options={})
+          [attribute]
+        end
+
+        def maybe_fallback(options={})
+          GlobHostNode.new(maybe_glob(attribute), separator)
+        end
+      end
+
+      class GlobTagNode < GlobExpressionNode
         def initialize(identifier, attribute, separator=nil)
-          identifier = identifier.sub(%r{\A/(.*)/\z}) { $1 } if identifier
-          attribute = attribute.sub(%r{\A/(.*)/\z}) { $1 } if attribute
           super(identifier, attribute, separator)
         end
 
-        def plan(options={})
-          if identifier?
-            if attribute?
-              case identifier
-              when /\Ahost\z/i
-                q = "SELECT hosts.id AS host_id FROM hosts " \
-                      "WHERE hosts.name REGEXP ?;"
-                [q, [attribute]]
-              else
-                q = "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags " \
-                      "INNER JOIN tags ON hosts_tags.tag_id = tags.id " \
-                        "WHERE tags.name REGEXP ? AND tags.value REGEXP ?;"
-                [q, [identifier, attribute]]
-              end
-            else
-              if separator?
-                q = "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags " \
-                      "INNER JOIN tags ON hosts_tags.tag_id = tags.id " \
-                        "WHERE tags.name REGEXP ?;"
-                [q, [identifier]]
-              else
-                q = "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags " \
-                      "INNER JOIN hosts ON hosts_tags.host_id = hosts.id " \
-                      "INNER JOIN tags ON hosts_tags.tag_id = tags.id " \
-                        "WHERE hosts.name REGEXP ? OR tags.name REGEXP ? OR tags.value REGEXP ?;"
-                [q, [identifier, identifier, identifier]]
-              end
-            end
-          else
-            if attribute?
-              q = "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags " \
-                    "INNER JOIN tags ON hosts_tags.tag_id = tags.id " \
-                      "WHERE tags.value REGEXP ?;"
-              [q, [attribute]]
-            else
-              nil
-            end
-          end
+        def condition(options={})
+          "LOWER(tags.name) GLOB LOWER(?) AND LOWER(tags.value) GLOB LOWER(?)"
         end
 
-        def optimize(options={})
-          self # disable fallback
+        def condition_tables(options={})
+          [:tags]
+        end
+
+        def condition_values(options={})
+          [identifier, attribute]
+        end
+
+        def maybe_fallback(options={})
+          GlobTagNode.new(maybe_glob(identifier), maybe_glob(attribute), separator)
+        end
+      end
+
+      class GlobTagNameNode < GlobExpressionNode
+        def initialize(identifier, separator=nil)
+          super(identifier, nil, separator)
+        end
+
+        def condition(options={})
+          "LOWER(tags.name) GLOB LOWER(?)"
+        end
+
+        def condition_tables(options={})
+          [:tags]
         end
 
+        def condition_values(options={})
+          [identifier]
+        end
+
+        def maybe_fallback(options={})
+          GlobTagNameNode.new(maybe_glob(identifier), separator)
+        end
+      end
+
+      class GlobTagValueNode < GlobExpressionNode
+        def initialize(attribute, separator=nil)
+          super(nil, attribute, separator)
+        end
+
+        def condition(options={})
+          "LOWER(tags.value) GLOB LOWER(?)"
+        end
+
+        def condition_tables(options={})
+          [:tags]
+        end
+
+        def condition_values(options={})
+          [attribute]
+        end
+
+        def maybe_fallback(options={})
+          GlobTagValueNode.new(maybe_glob(attribute), separator)
+        end
+      end
+
+      class GlobNode < GlobExpressionNode
+        def initialize(identifier, separator=nil)
+          super(identifier, nil, separator)
+        end
+
+        def condition(options={})
+          "LOWER(hosts.name) GLOB LOWER(?) OR LOWER(tags.name) GLOB LOWER(?) OR LOWER(tags.value) GLOB LOWER(?)"
+        end
+
+        def condition_tables(options={})
+          [:hosts, :tags]
+        end
+
+        def condition_values(options={})
+          [identifier, identifier, identifier]
+        end
+
+        def maybe_fallback(options={})
+          GlobNode.new(maybe_glob(identifier), separator)
+        end
+      end
+
+      class RegexpExpressionNode < TagExpressionNode
         def dump(options={})
           data = {}
-          data[:identifier_regexp] = @identifier.to_s if @identifier
-          data[:separator] = @separator.to_s if @separator
-          data[:attribute_regexp] = @attribute.to_s if @attribute
+          data[:identifier_regexp] = identifier.to_s if identifier
+          data[:separator] = separator.to_s if separator
+          data[:attribute_regexp] = attribute.to_s if attribute
           data[:fallback] = @fallback.dump(options) if @fallback
           data
         end
       end
+
+      class RegexpHostNode < RegexpExpressionNode
+        def initialize(attribute, separator=nil)
+          super("host", attribute, separator)
+        end
+
+        def condition(options={})
+          "hosts.name REGEXP ?"
+        end
+
+        def condition_tables(options={})
+          [:hosts]
+        end
+
+        def condition_values(options={})
+          [attribute]
+        end
+      end
+
+      class RegexpTagNode < RegexpExpressionNode
+        def initialize(identifier, attribute, separator=nil)
+          super(identifier, attribute, separator)
+        end
+
+        def condition(options={})
+          "tags.name REGEXP ? AND tags.value REGEXP ?"
+        end
+
+        def condition_tables(options={})
+          [:tags]
+        end
+
+        def condition_values(options={})
+          [identifier, attribute]
+        end
+      end
+
+      class RegexpTagNameNode < RegexpExpressionNode
+        def initialize(identifier, separator=nil)
+          super(identifier, nil, separator)
+        end
+
+        def condition(options={})
+          "tags.name REGEXP ?"
+        end
+
+        def condition_tables(options={})
+          [:tags]
+        end
+
+        def condition_values(options={})
+          [identifier]
+        end
+      end
+
+      class RegexpTagValueNode < RegexpExpressionNode
+        def initialize(attribute, separator=nil)
+          super(nil, attribute, separator)
+        end
+
+        def condition(options={})
+          "tags.value REGEXP ?"
+        end
+
+        def condition_tables(options={})
+          [:tags]
+        end
+
+        def condition_values(options={})
+          [attribute]
+        end
+      end
+
+      class RegexpNode < RegexpExpressionNode
+        def initialize(identifier, separator=nil)
+          super(identifier, separator)
+        end
+
+        def condition(options={})
+          "hosts.name REGEXP ? OR tags.name REGEXP ? OR tags.value REGEXP ?"
+        end
+
+        def condition_tables(options={})
+          [:hosts, :tags]
+        end
+
+        def condition_values(options={})
+          [identifier, identifier, identifier]
+        end
+      end
     end
   end
 end