hotdog 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4a7e366b9cd85e46e711e2ca82472a2d278db17a
-  data.tar.gz: 502752fef200c4abf66772c31dc0b8f6e19a3538
+  metadata.gz: b2649bee0b66f057008d4276174d397b21ac87dd
+  data.tar.gz: 29d8d1620fab0110ac684b0059fc42e095c8c7bc
 SHA512:
-  metadata.gz: 28f25b9273cf877a5c7ee381733f5645eec06e8c40ddb743c6e07becca306bcf270fc4f85a1bc4eba691316cc7d11aac67a77dbab8ed421c11137042f3f03bfa
-  data.tar.gz: 587039692f3cc6cb5f7c7436487e8d1300dc54457468e6d19f2075bd9f1b0b6a3af21774ef6be44bf3bcb528749756531b5a490c17cb52f521b449a62fcb0373
+  metadata.gz: c7024f0e5e985792bd9fe1105b8fab9c65291a7bea66c6cd22f0e33fb7c838873649ae8ee3dc3b889f51882c68c3641ad75da37ff857cc3fc5e898d100abbb07
+  data.tar.gz: acf1ba39e5aecf2df6a9e2c7312c38ae3cea71a818d82dc681c68f6068a4cf5ab4f40f3ad8e33ccd69aac8b30f143faf0382ce52afb2264ae292a3cc39183965

data/lib/hotdog/commands/pssh.rb

@@ -50,7 +50,7 @@ module Hotdog
           exit(1)
         end
 
-        result = evaluate(node, self).sort
+        result = evaluate(node, self)
         result, fields = get_hosts(result)
 
         if result.empty?

data/lib/hotdog/commands/search.rb

@@ -26,7 +26,7 @@ module Hotdog
           exit(1)
         end
 
-        result = evaluate(node, self).sort
+        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))
@@ -73,7 +73,10 @@ module Hotdog
 
       def evaluate(data, environment)
         node = ExpressionTransformer.new.apply(data)
-        node.optimize.evaluate(environment)
+        optimized = node.optimize.tap do |optimized|
+          logger.debug(JSON.pretty_generate(optimized.dump))
+        end
+        optimized.evaluate(environment)
       end
 
       class ExpressionParser < Parslet::Parser
@@ -101,6 +104,7 @@ module Hotdog
           ( expression4.as(:left) >> spacing.maybe >> str('&&').as(:binary_op) >> spacing.maybe >> expression.as(:right) \
           | expression4.as(:left) >> spacing.maybe >> str('||').as(:binary_op) >> spacing.maybe >> expression.as(:right) \
           | expression4.as(:left) >> spacing.maybe >> str('&').as(:binary_op) >> spacing.maybe >> expression.as(:right) \
+          | expression4.as(:left) >> spacing.maybe >> str('^').as(:binary_op) >> spacing.maybe >> expression.as(:right) \
           | expression4.as(:left) >> spacing.maybe >> str('|').as(:binary_op) >> spacing.maybe >> expression.as(:right) \
           | expression4 \
           )
@@ -116,8 +120,10 @@ module Hotdog
         rule(:binary_op) {
           ( str('AND') \
           | str('OR') \
+          | str('XOR') \
           | str('and') \
           | str('or') \
+          | str('xor') \
           )
         }
         rule(:unary_op) {
@@ -127,20 +133,20 @@ module Hotdog
         }
         rule(:atom) {
           ( spacing.maybe >> str('(') >> expression >> str(')') >> spacing.maybe \
-          | spacing.maybe >> identifier_regexp.as(:identifier_regexp) >> separator >> attribute_regexp.as(:attribute_regexp) >> spacing.maybe \
-          | spacing.maybe >> identifier_regexp.as(:identifier_regexp) >> separator >> 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 >> identifier_glob.as(:identifier_glob) >> separator >> attribute_glob.as(:attribute_glob) >> spacing.maybe \
-          | spacing.maybe >> identifier_glob.as(:identifier_glob) >> separator >> attribute.as(:attribute) >> spacing.maybe \
-          | spacing.maybe >> identifier_glob.as(:identifier_glob) >> separator >> 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 \
           | spacing.maybe >> identifier_glob.as(:identifier_glob) >> spacing.maybe \
-          | spacing.maybe >> identifier.as(:identifier) >> separator >> attribute_glob.as(:attribute_glob) >> spacing.maybe \
-          | spacing.maybe >> identifier.as(:identifier) >> separator >> attribute.as(:attribute) >> spacing.maybe \
-          | spacing.maybe >> identifier.as(:identifier) >> separator >> spacing.maybe \
+          | spacing.maybe >> identifier.as(:identifier) >> separator.as(:separator) >> attribute_glob.as(:attribute_glob) >> spacing.maybe \
+          | 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 >> attribute_regexp.as(:attribute_regexp) >> spacing.maybe \
-          | spacing.maybe >> separator >> attribute_glob.as(:attribute_glob) >> spacing.maybe \
-          | spacing.maybe >> separator >> attribute.as(:attribute) >> spacing.maybe \
+          | spacing.maybe >> separator.as(:separator) >> attribute_regexp.as(:attribute_regexp) >> 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 >> attribute_glob.as(:attribute_glob) >> spacing.maybe \
           | spacing.maybe >> attribute.as(:attribute) >> spacing.maybe \
@@ -185,44 +191,62 @@ module Hotdog
       end
 
       class ExpressionTransformer < Parslet::Transform
-        rule(:binary_op => simple(:binary_op), :left => simple(:left), :right => simple(:right)) {
+        rule(binary_op: simple(:binary_op), left: simple(:left), right: simple(:right)) {
           BinaryExpressionNode.new(binary_op, left, right)
         }
-        rule(:unary_op => simple(:unary_op), :expression => simple(:expression)) {
+        rule(unary_op: simple(:unary_op), expression: simple(:expression)) {
           UnaryExpressionNode.new(unary_op, expression)
         }
-        rule(:identifier_regexp => simple(:identifier_regexp), :attribute_regexp => simple(:attribute_regexp)) {
-          TagRegexpExpressionNode.new(identifier_regexp.to_s, attribute_regexp.to_s)
+        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)
+        }
+        rule(identifier_regexp: simple(:identifier_regexp), separator: simple(:separator)) {
+          TagRegexpExpressionNode.new(identifier_regexp.to_s, nil, nil)
+        }
+        rule(identifier_regexp: simple(:identifier_regexp)) {
+          TagRegexpExpressionNode.new(identifier_regexp.to_s, nil, nil)
+        }
+        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)
         }
-        rule(:identifier_regexp => simple(:identifier_regexp)) {
-          TagRegexpExpressionNode.new(identifier_regexp.to_s, nil)
+        rule(identifier_glob: simple(:identifier_glob), separator: simple(:separator), attribute: simple(:attribute)) {
+          TagGlobExpressionNode.new(identifier_glob.to_s, attribute.to_s, separator)
         }
-        rule(:identifier_glob => simple(:identifier_glob), :attribute_glob => simple(:attribute_glob)) {
-          TagGlobExpressionNode.new(identifier_glob.to_s, attribute_glob.to_s)
+        rule(identifier_glob: simple(:identifier_glob), separator: simple(:separator)) {
+          TagGlobExpressionNode.new(identifier_glob.to_s, nil, separator)
         }
-        rule(:identifier_glob => simple(:identifier_glob), :attribute => simple(:attribute)) {
-          TagGlobExpressionNode.new(identifier_glob.to_s, attribute.to_s)
+        rule(identifier_glob: simple(:identifier_glob)) {
+          TagGlobExpressionNode.new(identifier_glob.to_s, nil, nil)
         }
-        rule(:identifier_glob => simple(:identifier_glob)) {
-          TagGlobExpressionNode.new(identifier_glob.to_s, nil)
+        rule(identifier: simple(:identifier), separator: simple(:separator), attribute_glob: simple(:attribute_glob)) {
+          TagGlobExpressionNode.new(identifier.to_s, attribute_glob.to_s, separator)
         }
-        rule(:identifier => simple(:identifier), :attribute_glob => simple(:attribute_glob)) {
-          TagGlobExpressionNode.new(identifier.to_s, attribute_glob.to_s)
+        rule(identifier: simple(:identifier), separator: simple(:separator), attribute: simple(:attribute)) {
+          TagExpressionNode.new(identifier.to_s, attribute.to_s, separator)
         }
-        rule(:identifier => simple(:identifier), :attribute => simple(:attribute)) {
-          TagExpressionNode.new(identifier.to_s, attribute.to_s)
+        rule(identifier: simple(:identifier), separator: simple(:separator)) {
+          TagExpressionNode.new(identifier.to_s, nil, separator)
         }
-        rule(:identifier => simple(:identifier)) {
-          TagExpressionNode.new(identifier.to_s, nil)
+        rule(identifier: simple(:identifier)) {
+          TagExpressionNode.new(identifier.to_s, nil, nil)
         }
-        rule(:attribute_regexp => simple(:attribute_regexp)) {
-          TagRegexpExpressionNode.new(nil, attribute_regexp.to_s)
+        rule(separator: simple(:separator), attribute_regexp: simple(:attribute_regexp)) {
+          TagRegexpExpressionNode.new(nil, attribute_regexp.to_s, separator)
         }
-        rule(:attribute_glob => simple(:attribute_glob)) {
-          TagGlobExpressionNode.new(nil, attribute_glob.to_s)
+        rule(attribute_regexp: simple(:attribute_regexp)) {
+          TagRegexpExpressionNode.new(nil, attribute_regexp.to_s, nil)
         }
-        rule(:attribute => simple(:attribute)) {
-          TagExpressionNode.new(nil, attribute.to_s)
+        rule(separator: simple(:separator), attribute_glob: simple(:attribute_glob)) {
+          TagGlobExpressionNode.new(nil, attribute_glob.to_s, separator)
+        }
+        rule(attribute_glob: simple(:attribute_glob)) {
+          TagGlobExpressionNode.new(nil, attribute_glob.to_s, nil)
+        }
+        rule(separator: simple(:separator), attribute: simple(:attribute)) {
+          TagExpressionNode.new(nil, attribute.to_s, separator)
+        }
+        rule(attribute: simple(:attribute)) {
+          TagExpressionNode.new(nil, attribute.to_s, nil)
         }
       end
 
@@ -234,6 +258,10 @@ module Hotdog
         def optimize(options={})
           self
         end
+
+        def dump(options={})
+          {}
+        end
       end
 
       class BinaryExpressionNode < ExpressionNode
@@ -245,6 +273,8 @@ module Hotdog
             @op = :AND
           when "||", "|", /\Aor\z/i
             @op = :OR
+          when "^", /\Axor\z/i
+            @op = :XOR
           else
             raise(SyntaxError.new("unknown binary operator: #{op.inspect}"))
           end
@@ -255,24 +285,87 @@ module Hotdog
         def evaluate(environment, options={})
           case @op
           when :AND
-            left_values = @left.evaluate(environment)
-            environment.logger.debug("lhs: #{left_values.length} value(s)")
+            left_values = @left.evaluate(environment, options).tap do |values|
+              environment.logger.debug("lhs: #{values.length} value(s)")
+            end
             if left_values.empty?
               []
             else
-              right_values = @right.evaluate(environment)
-              environment.logger.debug("rhs: #{right_values.length} value(s)")
-              (left_values & right_values).tap do |values|
-                environment.logger.debug("lhs AND rhs: #{values.length} value(s)")
+              right_values = @right.evaluate(environment, options).tap do |values|
+                environment.logger.debug("rhs: #{values.length} value(s)")
+              end
+              if right_values.empty?
+                []
+              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) / 2)).upto(max / ((SQLITE_LIMIT_COMPOUND_SELECT - 2) / 2)).flat_map { |i|
+                  range = (((SQLITE_LIMIT_COMPOUND_SELECT - 2) / 2) * i)...(((SQLITE_LIMIT_COMPOUND_SELECT - 2) / 2) * (i + 1))
+                  left_selected = left_values.select { |n| range === n }
+                  right_selected = right_values.select { |n| range === n }
+                  q = "SELECT id FROM hosts " \
+                        "WHERE ? <= id AND id < ? AND ( id IN (%s) AND id IN (%s) );"
+                  environment.execute(q % [left_selected.map { "?" }.join(", "), right_selected.map { "?" }.join(", ")], [range.first, range.last] + left_selected + right_selected).map { |row| row.first }
+                }.tap do |values|
+                  environment.logger.debug("lhs AND rhs: #{values.length} value(s)")
+                end
               end
             end
           when :OR
-            left_values = @left.evaluate(environment)
-            environment.logger.debug("lhs: #{left_values.length} value(s)")
-            right_values = @right.evaluate(environment)
-            environment.logger.debug("rhs: #{right_values.length} value(s)")
-            (left_values | right_values).uniq.tap do |values|
-              environment.logger.debug("lhs OR rhs: #{values.length} value(s)")
+            left_values = @left.evaluate(environment, options).tap do |values|
+              environment.logger.debug("lhs: #{values.length} value(s)")
+            end
+            right_values = @right.evaluate(environment, options).tap do |values|
+              environment.logger.debug("rhs: #{values.length} value(s)")
+            end
+            if left_values.empty?
+              right_values
+            else
+              if right_values.empty?
+                []
+              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) / 2)).upto(max / ((SQLITE_LIMIT_COMPOUND_SELECT - 2) / 2)).flat_map { |i|
+                  range = (((SQLITE_LIMIT_COMPOUND_SELECT - 2) / 2) * i)...(((SQLITE_LIMIT_COMPOUND_SELECT - 2) / 2) * (i + 1))
+                  left_selected = left_values.select { |n| range === n }
+                  right_selected = right_values.select { |n| range === n }
+                  q = "SELECT id FROM hosts " \
+                        "WHERE ? <= id AND id < ? AND ( id IN (%s) OR id IN (%s) );"
+                  environment.execute(q % [left_selected.map { "?" }.join(", "), right_selected.map { "?" }.join(", ")], [range.first, range.last] + left_selected + right_selected).map { |row| row.first }
+                }.tap do |values|
+                  environment.logger.debug("lhs OR rhs: #{values.length} value(s)")
+                end
+              end
+            end
+          when :XOR
+            left_values = @left.evaluate(environment, options).tap do |values|
+              environment.logger.debug("lhs: #{values.length} value(s)")
+            end
+            right_values = @right.evaluate(environment, options).tap do |values|
+              environment.logger.debug("rhs: #{values.length} value(s)")
+            end
+            if left_values.empty?
+              right_values
+            else
+              if right_values.empty?
+                []
+              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) / 4)).upto(max / ((SQLITE_LIMIT_COMPOUND_SELECT - 2) / 4)).flat_map { |i|
+                  range = (((SQLITE_LIMIT_COMPOUND_SELECT - 2) / 4) * i)...(((SQLITE_LIMIT_COMPOUND_SELECT - 2) / 4) * (i + 1))
+                  left_selected = left_values.select { |n| range === n }
+                  right_selected = right_values.select { |n| range === n }
+                  q = "SELECT id FROM hosts " \
+                        "WHERE ? <= id AND id < ? AND NOT (id IN (%s) AND id IN (%s)) AND ( id IN (%s) OR id IN (%s) );"
+                  lq = left_selected.map { "?" }.join(", ")
+                  rq = right_selected.map { "?" }.join(", ")
+                  environment.execute(q % [lq, rq, lq, rq], [range.first, range.last] + left_selected + right_selected + left_selected + right_selected).map { |row| row.first }
+                }.tap do |values|
+                  environment.logger.debug("lhs XOR rhs: #{values.length} value(s)")
+                end
+              end
             end
           else
             []
@@ -282,8 +375,21 @@ module Hotdog
         def optimize(options={})
           @left = @left.optimize(options)
           @right = @right.optimize(options)
-          if @left == @right
-            @left
+          case op
+          when :AND
+            if left == right
+              left
+            else
+              optimize1(options)
+            end
+          when :OR
+            if left == right
+              left
+            else
+              optimize1(options)
+            end
+          when :XOR
+            optimize1(options)
           else
             self
           end
@@ -292,6 +398,42 @@ module Hotdog
         def ==(other)
           self.class === other and @op == other.op and @left == other.left and @right == other.right
         end
+
+        def dump(options={})
+          {left: @left.dump(options), op: @op.to_s, right: @right.dump(options)}
+        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
+              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)
+              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)
+              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)
+              else
+                self
+              end
+            else
+              self
+            end
+          else
+            self
+          end
+        end
       end
 
       class UnaryExpressionNode < ExpressionNode
@@ -310,8 +452,9 @@ module Hotdog
         def evaluate(environment, options={})
           case @op
           when :NOT
-            values = @expression.evaluate(environment).sort
-            environment.logger.debug("expr: #{values.length} value(s)")
+            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)")
@@ -319,8 +462,8 @@ module Hotdog
             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).upto(max / SQLITE_LIMIT_COMPOUND_SELECT).flat_map { |i|
-                range = (SQLITE_LIMIT_COMPOUND_SELECT*i)...(SQLITE_LIMIT_COMPOUND_SELECT*(i+1))
+              (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);"
@@ -336,12 +479,9 @@ module Hotdog
 
         def optimize(options={})
           @expression = @expression.optimize(options)
-          if UnaryExpressionNode === @expression
-            if @op == :NOT and @expression.op == :NOT
-              @expression.expression
-            else
-              self
-            end
+          case op
+          when :NOT
+            optimize1(options)
           else
             self
           end
@@ -350,15 +490,69 @@ module Hotdog
         def ==(other)
           self.class === other and @op == other.op and @expression == other.expression
         end
+
+        def dump(options={})
+          {op: @op.to_s, expression: @expression.dump(options)}
+        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
+        end
+      end
+
+      class QueryExpressionNode < ExpressionNode
+        def initialize(query, args=[], options={})
+          @query = query
+          @args = args
+          @fallback = options[:fallback]
+        end
+
+        def evaluate(environment, options={})
+          values = environment.execute(@query, @args).map { |row| row.first }
+          if values.empty? and @fallback
+            @fallback.evaluate(environment, options)
+          else
+            values
+          end
+        end
+
+        def dump(options={})
+          data = {query: @query, arguments: @args}
+          data[:fallback] = @fallback.dump(options) if @fallback
+          data
+        end
       end
 
       class TagExpressionNode < ExpressionNode
-        def initialize(identifier, attribute)
+        def initialize(identifier, attribute, separator=nil)
           @identifier = identifier
           @attribute = attribute
+          @separator = separator
         end
         attr_reader :identifier
         attr_reader :attribute
+        attr_reader :separator
 
         def identifier?
           !(identifier.nil? or identifier.to_s.empty?)
@@ -368,41 +562,60 @@ module Hotdog
           !(attribute.nil? or attribute.to_s.empty?)
         end
 
-        def evaluate(environment, options={})
+        def separator?
+          !(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 FROM hosts " \
+                q = "SELECT hosts.id AS host_id FROM hosts " \
                       "WHERE hosts.name = ?;"
-                values = environment.execute(q, [attribute]).map { |row| row.first }
+                [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 = ?;"
-                values = environment.execute(q, [identifier, attribute]).map { |row| row.first }
+                [q, [identifier, attribute]]
               end
             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 = ?;"
-              values = environment.execute(q, [identifier, identifier, identifier]).map { |row| row.first }
+              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
           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 = ?;"
-              values = environment.execute(q, [attribute]).map { |row| row.first }
+              [q, [attribute]]
             else
-              return []
+              nil
             end
           end
-          if values.empty?
-            fallback(environment, options)
+        end
+
+        def evaluate(environment, options={})
+          if q = plan(options)
+            values = environment.execute(*q).map { |row| row.first }
+            if values.empty?
+              fallback(environment, options)
+            else
+              values
+            end
           else
-            values
+            return []
           end
         end
 
@@ -415,11 +628,11 @@ module Hotdog
             []
           else
             # fallback to glob expression
-            identifier_glob = identifier.gsub(/[-.\/_]/, "?") if identifier?
-            attribute_glob = attribute.gsub(/[-.\/_]/, "?") if attribute?
+            identifier_glob = "*#{identifier.gsub(/[-.\/_]/, "?")}*" if identifier?
+            attribute_glob = "*#{attribute.gsub(/[-.\/_]/, "?")}*" if attribute?
             if (identifier? and identifier != identifier_glob) or (attribute? and attribute != attribute_glob)
               environment.logger.info("fallback to glob expression: %s:%s" % [identifier_glob, attribute_glob])
-              values = TagGlobExpressionNode.new(identifier_glob, attribute_glob).evaluate(environment, options)
+              values = TagGlobExpressionNode.new(identifier_glob, attribute_glob, separator).evaluate(environment, options)
               if values.empty?
                 reload(environment, options)
               else
@@ -436,97 +649,138 @@ module Hotdog
           if 0 < ttl
             environment.logger.info("force reloading all hosts and tags.")
             environment.reload(force: true)
-            self.class.new(identifier, attribute).evaluate(environment, options.merge(ttl: ttl-1))
+            self.class.new(identifier, attribute, separator).evaluate(environment, options.merge(ttl: ttl-1))
           else
             []
           end
         end
+
+        def dump(options={})
+          data = {}
+          data[:identifier] = @identifier if @identifier
+          data[:separator] = @separator if @separator
+          data[:attribute] = @attribute if @attribute
+          data
+        end
       end
 
       class TagGlobExpressionNode < TagExpressionNode
-        def evaluate(environment, options={})
+        def plan(options={})
           if identifier?
             if attribute?
               case identifier
               when /\Ahost\z/i
-                q = "SELECT hosts.id FROM hosts " \
+                q = "SELECT hosts.id AS host_id FROM hosts " \
                       "WHERE hosts.name GLOB ?;"
-                values = environment.execute(q, [attribute]).map { |row| row.first }
+                [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 GLOB ? AND tags.value GLOB ?;"
-                values = environment.execute(q, [identifier, attribute]).map { |row| row.first }
+                [q, [identifier, attribute]]
               end
             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 GLOB ? OR tags.name GLOB ? OR tags.value GLOB ?;"
-              values = environment.execute(q, [identifier, identifier, identifier]).map { |row| row.first }
+              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 GLOB ?;"
+                [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 GLOB ? OR tags.name GLOB ? OR tags.value GLOB ?;"
+                [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 GLOB ?;"
-              values = environment.execute(q, [attribute]).map { |row| row.first }
+              [q, [attribute]]
             else
-              return []
+              nil
             end
           end
-          if values.empty?
-            fallback(environment, options)
-          else
-            values
-          end
+        end
+
+        def dump(options={})
+          data = {}
+          data[:identifier_glob] = @identifier if @identifier
+          data[:separator] = @separator if @separator
+          data[:attribute_glob] = @attribute if @attribute
+          data
         end
       end
 
       class TagRegexpExpressionNode < TagExpressionNode
-        def initialize(identifier, attribute)
+        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)
+          super(identifier, attribute, separator)
         end
 
-        def evaluate(environment, options={})
+        def plan(options={})
           if identifier?
             if attribute?
               case identifier
               when /\Ahost\z/i
-                q = "SELECT hosts.id FROM hosts " \
+                q = "SELECT hosts.id AS host_id FROM hosts " \
                       "WHERE hosts.name REGEXP ?;"
-                values = environment.execute(q, [attribute]).map { |row| row.first }
+                [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 ?;"
-                values = environment.execute(q, [identifier, attribute]).map { |row| row.first }
+                [q, [identifier, attribute]]
               end
             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 ?;"
-              values = environment.execute(q, [identifier, identifier, identifier]).map { |row| row.first }
+              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 ?;"
-              values = environment.execute(q, [attribute]).map { |row| row.first }
+              [q, [attribute]]
             else
-              return []
+              nil
             end
           end
-          if values.empty?
-            reload(environment)
+        end
+
+        def evaluate(environment, options={})
+          if q = plan(options)
+            values = environment.execute(*q).map { |row| row.first }
+            if values.empty?
+              reload(environment)
+            else
+              values
+            end
           else
-            values
+            return []
           end
         end
+
+        def dump(options={})
+          data = {}
+          data[:identifier_regexp] = @identifier if @identifier
+          data[:separator] = @separator if @separator
+          data[:attribute_regexp] = @attribute if @attribute
+          data
+        end
       end
     end
   end

data/lib/hotdog/commands/ssh.rb

@@ -51,7 +51,7 @@ module Hotdog
           exit(1)
         end
 
-        result = evaluate(node, self).sort
+        result = evaluate(node, self)
 
         if result.length == 1
           host = result[0]

data/lib/hotdog/version.rb

@@ -1,3 +1,3 @@
 module Hotdog
-  VERSION = "0.3.1"
+  VERSION = "0.4.0"
 end

data/spec/parser/parser_spec.rb

@@ -15,15 +15,15 @@ describe "parser" do
   end
 
   it "parses ':foo'" do
-    expect(cmd.parse(":foo")).to eq({attribute: "foo"})
+    expect(cmd.parse(":foo")).to eq({separator: ":", attribute: "foo"})
   end
 
   it "parses ':foo*'" do
-    expect(cmd.parse(":foo*")).to eq({attribute_glob: "foo*"})
+    expect(cmd.parse(":foo*")).to eq({separator: ":", attribute_glob: "foo*"})
   end
 
   it "parses ':/foo/'" do
-    expect(cmd.parse(":/foo/")).to eq({attribute_regexp: "/foo/"})
+    expect(cmd.parse(":/foo/")).to eq({separator: ":", attribute_regexp: "/foo/"})
   end
 
   it "parses 'foo'" do
@@ -31,23 +31,23 @@ describe "parser" do
   end
 
   it "parses 'foo:bar'" do
-    expect(cmd.parse("foo:bar")).to eq({identifier: "foo", attribute: "bar"})
+    expect(cmd.parse("foo:bar")).to eq({identifier: "foo", separator: ":", attribute: "bar"})
   end
 
   it "parses 'foo: bar'" do
-    expect(cmd.parse("foo:bar")).to eq({identifier: "foo", attribute: "bar"})
+    expect(cmd.parse("foo:bar")).to eq({identifier: "foo", separator: ":", attribute: "bar"})
   end
 
   it "parses 'foo :bar'" do
-    expect(cmd.parse("foo:bar")).to eq({identifier: "foo", attribute: "bar"})
+    expect(cmd.parse("foo:bar")).to eq({identifier: "foo", separator: ":", attribute: "bar"})
   end
 
   it "parses 'foo : bar'" do
-    expect(cmd.parse("foo:bar")).to eq({identifier: "foo", attribute: "bar"})
+    expect(cmd.parse("foo:bar")).to eq({identifier: "foo", separator: ":", attribute: "bar"})
   end
 
   it "parses 'foo:bar*'" do
-    expect(cmd.parse("foo:bar*")).to eq({identifier: "foo", attribute_glob: "bar*"})
+    expect(cmd.parse("foo:bar*")).to eq({identifier: "foo", separator: ":", attribute_glob: "bar*"})
   end
 
   it "parses 'foo*'" do
@@ -55,11 +55,11 @@ describe "parser" do
   end
 
   it "parses 'foo*:bar'" do
-    expect(cmd.parse("foo*:bar")).to eq({identifier_glob: "foo*", attribute: "bar"})
+    expect(cmd.parse("foo*:bar")).to eq({identifier_glob: "foo*", separator: ":", attribute: "bar"})
   end
 
   it "parses 'foo*:bar*'" do
-    expect(cmd.parse("foo*:bar*")).to eq({identifier_glob: "foo*", attribute_glob: "bar*"})
+    expect(cmd.parse("foo*:bar*")).to eq({identifier_glob: "foo*", separator: ":", attribute_glob: "bar*"})
   end
 
   it "parses '/foo/'" do
@@ -67,7 +67,7 @@ describe "parser" do
   end
 
   it "parses '/foo/:/bar/'" do
-    expect(cmd.parse("/foo/:/bar/")).to eq({identifier_regexp: "/foo/", attribute_regexp: "/bar/"})
+    expect(cmd.parse("/foo/:/bar/")).to eq({identifier_regexp: "/foo/", separator: ":", attribute_regexp: "/bar/"})
   end
 
   it "parses '(foo)'" do

data/spec/parser/tag_expression_spec.rb

@@ -10,19 +10,20 @@ describe "tag expression" do
   }
 
   it "interprets tag with host" do
-    expr = Hotdog::Commands::Search::TagExpressionNode.new("host", "foo")
+    expr = Hotdog::Commands::Search::TagExpressionNode.new("host", "foo", ":")
     q = [
-      "SELECT hosts.id FROM hosts",
+      "SELECT hosts.id AS host_id FROM hosts",
         "WHERE hosts.name = ?;",
     ]
     allow(cmd).to receive(:execute).with(q.join(" "), ["foo"]) {
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
+    expect(expr.dump).to eq({identifier: "host", separator: ":", attribute: "foo"})
   end
 
   it "interprets tag with identifier and attribute" do
-    expr = Hotdog::Commands::Search::TagExpressionNode.new("foo", "bar")
+    expr = Hotdog::Commands::Search::TagExpressionNode.new("foo", "bar", ":")
     q = [
       "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
         "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
@@ -32,10 +33,25 @@ describe "tag expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
+    expect(expr.dump).to eq({identifier: "foo", separator: ":", attribute: "bar"})
   end
 
-  it "interprets tag with identifier" do
-    expr = Hotdog::Commands::Search::TagExpressionNode.new("foo", nil)
+  it "interprets tag with identifier with separator" do
+    expr = Hotdog::Commands::Search::TagExpressionNode.new("foo", nil, ":")
+    q = [
+      "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
+        "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
+          "WHERE tags.name = ?;",
+    ]
+    allow(cmd).to receive(:execute).with(q.join(" "), ["foo"]) {
+      [[1], [2], [3]]
+    }
+    expect(expr.evaluate(cmd)).to eq([1, 2, 3])
+    expect(expr.dump).to eq({identifier: "foo", separator: ":"})
+  end
+
+  it "interprets tag with identifier without separator" do
+    expr = Hotdog::Commands::Search::TagExpressionNode.new("foo", nil, nil)
     q = [
       "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
         "INNER JOIN hosts ON hosts_tags.host_id = hosts.id",
@@ -46,10 +62,11 @@ describe "tag expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
+    expect(expr.dump).to eq({identifier: "foo"})
   end
 
-  it "interprets tag with attribute" do
-    expr = Hotdog::Commands::Search::TagExpressionNode.new(nil, "foo")
+  it "interprets tag with attribute with separator" do
+    expr = Hotdog::Commands::Search::TagExpressionNode.new(nil, "foo", ":")
     q = [
       "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
         "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
@@ -59,5 +76,26 @@ describe "tag expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
+    expect(expr.dump).to eq({separator: ":", attribute: "foo"})
+  end
+
+  it "interprets tag with attribute without separator" do
+    expr = Hotdog::Commands::Search::TagExpressionNode.new(nil, "foo", nil)
+    q = [
+      "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
+        "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
+          "WHERE tags.value = ?;",
+    ]
+    allow(cmd).to receive(:execute).with(q.join(" "), ["foo"]) {
+      [[1], [2], [3]]
+    }
+    expect(expr.evaluate(cmd)).to eq([1, 2, 3])
+    expect(expr.dump).to eq({attribute: "foo"})
+  end
+
+  it "empty tag" do
+    expr = Hotdog::Commands::Search::TagExpressionNode.new(nil, nil, nil)
+    expect(expr.evaluate(cmd)).to eq([])
+    expect(expr.dump).to eq({})
   end
 end

data/spec/parser/tag_glob_expression_spec.rb

@@ -10,19 +10,20 @@ describe "tag glob expression" do
   }
 
   it "interprets tag glob with host" do
-    expr = Hotdog::Commands::Search::TagGlobExpressionNode.new("host", "foo*")
+    expr = Hotdog::Commands::Search::TagGlobExpressionNode.new("host", "foo*", ":")
     q = [
-      "SELECT hosts.id FROM hosts",
+      "SELECT hosts.id AS host_id FROM hosts",
         "WHERE hosts.name GLOB ?;",
     ]
     allow(cmd).to receive(:execute).with(q.join(" "), ["foo*"]) {
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
+    expect(expr.dump).to eq({identifier_glob: "host", separator: ":", attribute_glob: "foo*"})
   end
 
   it "interprets tag glob with identifier and attribute" do
-    expr = Hotdog::Commands::Search::TagGlobExpressionNode.new("foo*", "bar*")
+    expr = Hotdog::Commands::Search::TagGlobExpressionNode.new("foo*", "bar*", ":")
     q = [
       "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
         "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
@@ -32,10 +33,25 @@ describe "tag glob expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
+    expect(expr.dump).to eq({identifier_glob: "foo*", separator: ":", attribute_glob: "bar*"})
   end
 
-  it "interprets tag glob with identifier" do
-    expr = Hotdog::Commands::Search::TagGlobExpressionNode.new("foo*", nil)
+  it "interprets tag glob with identifier with separator" do
+    expr = Hotdog::Commands::Search::TagGlobExpressionNode.new("foo*", nil, ":")
+    q = [
+      "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
+        "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
+          "WHERE tags.name GLOB ?;",
+    ]
+    allow(cmd).to receive(:execute).with(q.join(" "), ["foo*"]) {
+      [[1], [2], [3]]
+    }
+    expect(expr.evaluate(cmd)).to eq([1, 2, 3])
+    expect(expr.dump).to eq({identifier_glob: "foo*", separator: ":"})
+  end
+
+  it "interprets tag glob with identifier without separator" do
+    expr = Hotdog::Commands::Search::TagGlobExpressionNode.new("foo*", nil, nil)
     q = [
       "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
         "INNER JOIN hosts ON hosts_tags.host_id = hosts.id",
@@ -46,10 +62,11 @@ describe "tag glob expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
+    expect(expr.dump).to eq({identifier_glob: "foo*"})
   end
 
-  it "interprets tag glob with attribute" do
-    expr = Hotdog::Commands::Search::TagGlobExpressionNode.new(nil, "foo*")
+  it "interprets tag glob with attribute with separator" do
+    expr = Hotdog::Commands::Search::TagGlobExpressionNode.new(nil, "foo*", ":")
     q = [
       "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
         "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
@@ -59,5 +76,26 @@ describe "tag glob expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
+    expect(expr.dump).to eq({separator: ":", attribute_glob: "foo*"})
+  end
+
+  it "interprets tag glob with attribute without separator" do
+    expr = Hotdog::Commands::Search::TagGlobExpressionNode.new(nil, "foo*", nil)
+    q = [
+      "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
+        "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
+          "WHERE tags.value GLOB ?;",
+    ]
+    allow(cmd).to receive(:execute).with(q.join(" "), ["foo*"]) {
+      [[1], [2], [3]]
+    }
+    expect(expr.evaluate(cmd)).to eq([1, 2, 3])
+    expect(expr.dump).to eq({attribute_glob: "foo*"})
+  end
+
+  it "empty tag glob" do
+    expr = Hotdog::Commands::Search::TagGlobExpressionNode.new(nil, nil, nil)
+    expect(expr.evaluate(cmd)).to eq([])
+    expect(expr.dump).to eq({})
   end
 end

data/spec/parser/tag_regexp_expression_spec.rb

@@ -10,19 +10,20 @@ describe "tag regexp expression" do
   }
 
   it "interprets tag regexp with host" do
-    expr = Hotdog::Commands::Search::TagRegexpExpressionNode.new("host", "/foo/")
+    expr = Hotdog::Commands::Search::TagRegexpExpressionNode.new("host", "/foo/", ":")
     q = [
-      "SELECT hosts.id FROM hosts",
+      "SELECT hosts.id AS host_id FROM hosts",
         "WHERE hosts.name REGEXP ?;",
     ]
     allow(cmd).to receive(:execute).with(q.join(" "), ["foo"]) {
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
+    expect(expr.dump).to eq({identifier_regexp: "host", separator: ":", attribute_regexp: "foo"})
   end
 
   it "interprets tag regexp with identifier and attribute" do
-    expr = Hotdog::Commands::Search::TagRegexpExpressionNode.new("/foo/", "/bar/")
+    expr = Hotdog::Commands::Search::TagRegexpExpressionNode.new("/foo/", "/bar/", ":")
     q = [
       "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
         "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
@@ -32,10 +33,25 @@ describe "tag regexp expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
+    expect(expr.dump).to eq({identifier_regexp: "foo", separator: ":", attribute_regexp: "bar"})
   end
 
-  it "interprets tag regexp with identifier" do
-    expr = Hotdog::Commands::Search::TagRegexpExpressionNode.new("/foo/", nil)
+  it "interprets tag regexp with identifier with separator" do
+    expr = Hotdog::Commands::Search::TagRegexpExpressionNode.new("/foo/", nil, ":")
+    q = [
+      "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
+        "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
+          "WHERE tags.name REGEXP ?;",
+    ]
+    allow(cmd).to receive(:execute).with(q.join(" "), ["foo"]) {
+      [[1], [2], [3]]
+    }
+    expect(expr.evaluate(cmd)).to eq([1, 2, 3])
+    expect(expr.dump).to eq({identifier_regexp: "foo", separator: ":"})
+  end
+
+  it "interprets tag regexp with identifier without separator" do
+    expr = Hotdog::Commands::Search::TagRegexpExpressionNode.new("/foo/", nil, nil)
     q = [
       "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
         "INNER JOIN hosts ON hosts_tags.host_id = hosts.id",
@@ -46,10 +62,11 @@ describe "tag regexp expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
+    expect(expr.dump).to eq({identifier_regexp: "foo"})
   end
 
-  it "interprets tag regexp with attribute" do
-    expr = Hotdog::Commands::Search::TagRegexpExpressionNode.new(nil, "/foo/")
+  it "interprets tag regexp with attribute with separator" do
+    expr = Hotdog::Commands::Search::TagRegexpExpressionNode.new(nil, "/foo/", ":")
     q = [
       "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
         "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
@@ -59,5 +76,26 @@ describe "tag regexp expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
+    expect(expr.dump).to eq({separator: ":", attribute_regexp: "foo"})
+  end
+
+  it "interprets tag regexp with attribute without separator" do
+    expr = Hotdog::Commands::Search::TagRegexpExpressionNode.new(nil, "/foo/", nil)
+    q = [
+      "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
+        "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
+          "WHERE tags.value REGEXP ?;",
+    ]
+    allow(cmd).to receive(:execute).with(q.join(" "), ["foo"]) {
+      [[1], [2], [3]]
+    }
+    expect(expr.evaluate(cmd)).to eq([1, 2, 3])
+    expect(expr.dump).to eq({attribute_regexp: "foo"})
+  end
+
+  it "empty tag regexp" do
+    expr = Hotdog::Commands::Search::TagRegexpExpressionNode.new(nil, nil, nil)
+    expect(expr.evaluate(cmd)).to eq([])
+    expect(expr.dump).to eq({})
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hotdog
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Yamashita Yuu
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-16 00:00:00.000000000 Z
+date: 2015-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler