hotdog 0.24.0 → 0.25.0

data/lib/hotdog/expression/syntax.rb

@@ -106,52 +106,52 @@ module Hotdog
         )
       }
       rule(:tag) {
-        ( regexp.as(:tag_name_regexp) >> separator.as(:separator) >> regexp.as(:tag_value_regexp) \
-        | regexp.as(:tag_name_regexp) >> separator.as(:separator) \
-        | regexp.as(:tag_name_regexp) \
-        | tag_name_glob.as(:tag_name_glob) >> separator.as(:separator) >> tag_value_glob.as(:tag_value_glob) \
-        | tag_name_glob.as(:tag_name_glob) >> separator.as(:separator) >> tag_value.as(:tag_value) \
-        | tag_name_glob.as(:tag_name_glob) >> separator.as(:separator) \
-        | tag_name_glob.as(:tag_name_glob) \
-        | tag_name.as(:tag_name) >> separator.as(:separator) >> tag_value_glob.as(:tag_value_glob) \
-        | tag_name.as(:tag_name) >> separator.as(:separator) >> tag_value.as(:tag_value) \
-        | tag_name.as(:tag_name) >> separator.as(:separator) \
-        | tag_name.as(:tag_name) \
-        | separator.as(:separator) >> regexp.as(:tag_value_regexp) \
-        | separator.as(:separator) >> tag_value_glob.as(:tag_value_glob) \
-        | separator.as(:separator) >> tag_value.as(:tag_value) \
-        | tag_value_regexp.as(:tag_value_regexp) \
-        | tag_value_glob.as(:tag_value_glob) \
-        | tag_value.as(:tag_value) \
-        )
-      }
-      rule(:tag_name_regexp) {
+        ( regexp.as(:tagname_regexp) >> separator.as(:separator) >> regexp.as(:tagvalue_regexp) \
+        | regexp.as(:tagname_regexp) >> separator.as(:separator) \
+        | regexp.as(:tagname_regexp) \
+        | tagname_glob.as(:tagname_glob) >> separator.as(:separator) >> tagvalue_glob.as(:tagvalue_glob) \
+        | tagname_glob.as(:tagname_glob) >> separator.as(:separator) >> tagvalue.as(:tagvalue) \
+        | tagname_glob.as(:tagname_glob) >> separator.as(:separator) \
+        | tagname_glob.as(:tagname_glob) \
+        | tagname.as(:tagname) >> separator.as(:separator) >> tagvalue_glob.as(:tagvalue_glob) \
+        | tagname.as(:tagname) >> separator.as(:separator) >> tagvalue.as(:tagvalue) \
+        | tagname.as(:tagname) >> separator.as(:separator) \
+        | tagname.as(:tagname) \
+        | separator.as(:separator) >> regexp.as(:tagvalue_regexp) \
+        | separator.as(:separator) >> tagvalue_glob.as(:tagvalue_glob) \
+        | separator.as(:separator) >> tagvalue.as(:tagvalue) \
+        | tagvalue_regexp.as(:tagvalue_regexp) \
+        | tagvalue_glob.as(:tagvalue_glob) \
+        | tagvalue.as(:tagvalue) \
+        )
+      }
+      rule(:tagname_regexp) {
         ( regexp \
         )
       }
-      rule(:tag_value_regexp) {
+      rule(:tagvalue_regexp) {
         ( regexp \
         )
       }
-      rule(:tag_name_glob) {
-        ( binary_op.absent? >> unary_op.absent? >> tag_name.repeat(0) >> (glob_char >> tag_name.maybe).repeat(1) \
-        | binary_op >> (glob_char >> tag_name.maybe).repeat(1) \
-        | unary_op >> (glob_char >> tag_name.maybe).repeat(1) \
+      rule(:tagname_glob) {
+        ( binary_op.absent? >> unary_op.absent? >> tagname.repeat(0) >> (glob_char >> tagname.maybe).repeat(1) \
+        | binary_op >> (glob_char >> tagname.maybe).repeat(1) \
+        | unary_op >> (glob_char >> tagname.maybe).repeat(1) \
         )
       }
-      rule(:tag_value_glob) {
-        ( binary_op.absent? >> unary_op.absent? >> tag_value.repeat(0) >> (glob_char >> tag_value.maybe).repeat(1) \
-        | binary_op >> (glob_char >> tag_value.maybe).repeat(1) \
-        | unary_op >> (glob_char >> tag_value.maybe).repeat(1) \
+      rule(:tagvalue_glob) {
+        ( binary_op.absent? >> unary_op.absent? >> tagvalue.repeat(0) >> (glob_char >> tagvalue.maybe).repeat(1) \
+        | binary_op >> (glob_char >> tagvalue.maybe).repeat(1) \
+        | unary_op >> (glob_char >> tagvalue.maybe).repeat(1) \
         )
       }
-      rule(:tag_name) {
+      rule(:tagname) {
         ( binary_op.absent? >> unary_op.absent? >> match('[A-Z_a-z]') >> match('[-./0-9A-Z_a-z]').repeat(0) \
         | binary_op >> match('[-./0-9A-Z_a-z]').repeat(1) \
         | unary_op >> match('[-./0-9A-Z_a-z]').repeat(1) \
         )
       }
-      rule(:tag_value) {
+      rule(:tagvalue) {
         ( binary_op.absent? >> unary_op.absent? >> match('[-./0-9:A-Z_a-z]').repeat(1) \
         | binary_op >> match('[-./0-9:A-Z_a-z]').repeat(1) \
         | unary_op >> match('[-./0-9:A-Z_a-z]').repeat(1) \

data/lib/hotdog/version.rb

@@ -1,3 +1,3 @@
 module Hotdog
-  VERSION = "0.24.0"
+  VERSION = "0.25.0"
 end

data/spec/{parser → evaluator}/glob_expression_spec.rb

@@ -9,6 +9,11 @@ describe "tag glob expression" do
     Hotdog::Commands::Search.new(Hotdog::Application.new)
   }
 
+  before(:each) do
+    ENV["DATADOG_API_KEY"] = "DATADOG_API_KEY"
+    ENV["DATADOG_APPLICATION_KEY"] = "DATADOG_APPLICATION_KEY"
+  end
+
   it "interprets tag glob with host" do
     expr = Hotdog::Expression::GlobHostNode.new("foo*", ":")
     q = [
@@ -19,10 +24,10 @@ describe "tag glob expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
-    expect(expr.dump).to eq({tag_name_glob: "host", separator: ":", tag_value_glob: "foo*"})
+    expect(expr.dump).to eq({tagname_glob: "host", separator: ":", tagvalue_glob: "foo*"})
   end
 
-  it "interprets tag glob with tag_name and tag_value" do
+  it "interprets tag glob with tagname and tagvalue" do
     expr = Hotdog::Expression::GlobTagNode.new("foo*", "bar*", ":")
     q = [
       "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
@@ -33,11 +38,11 @@ describe "tag glob expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
-    expect(expr.dump).to eq({tag_name_glob: "foo*", separator: ":", tag_value_glob: "bar*"})
+    expect(expr.dump).to eq({tagname_glob: "foo*", separator: ":", tagvalue_glob: "bar*"})
   end
 
-  it "interprets tag glob with tag_name with separator" do
-    expr = Hotdog::Expression::GlobTagNameNode.new("foo*", ":")
+  it "interprets tag glob with tagname with separator" do
+    expr = Hotdog::Expression::GlobTagnameNode.new("foo*", ":")
     q = [
       "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
         "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
@@ -47,10 +52,10 @@ describe "tag glob expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
-    expect(expr.dump).to eq({tag_name_glob: "foo*", separator: ":"})
+    expect(expr.dump).to eq({tagname_glob: "foo*", separator: ":"})
   end
 
-  it "interprets tag glob with tag_name without separator" do
+  it "interprets tag glob with tagname without separator" do
     expr = Hotdog::Expression::GlobHostOrTagNode.new("foo*", nil)
     q = [
       "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
@@ -62,11 +67,11 @@ describe "tag glob expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
-    expect(expr.dump).to eq({tag_name_glob: "foo*"})
+    expect(expr.dump).to eq({tagname_glob: "foo*"})
   end
 
-  it "interprets tag glob with tag_value with separator" do
-    expr = Hotdog::Expression::GlobTagValueNode.new("foo*", ":")
+  it "interprets tag glob with tagvalue with separator" do
+    expr = Hotdog::Expression::GlobTagvalueNode.new("foo*", ":")
     q = [
       "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
         "INNER JOIN hosts ON hosts_tags.host_id = hosts.id",
@@ -77,11 +82,11 @@ describe "tag glob expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
-    expect(expr.dump).to eq({separator: ":", tag_value_glob: "foo*"})
+    expect(expr.dump).to eq({separator: ":", tagvalue_glob: "foo*"})
   end
 
-  it "interprets tag glob with tag_value without separator" do
-    expr = Hotdog::Expression::GlobTagValueNode.new("foo*", nil)
+  it "interprets tag glob with tagvalue without separator" do
+    expr = Hotdog::Expression::GlobTagvalueNode.new("foo*", nil)
     q = [
       "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
         "INNER JOIN hosts ON hosts_tags.host_id = hosts.id",
@@ -92,7 +97,7 @@ describe "tag glob expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
-    expect(expr.dump).to eq({tag_value_glob: "foo*"})
+    expect(expr.dump).to eq({tagvalue_glob: "foo*"})
   end
 
   it "empty tag glob" do

data/spec/{parser → evaluator}/regexp_expression_spec.rb

@@ -9,6 +9,11 @@ describe "tag regexp expression" do
     Hotdog::Commands::Search.new(Hotdog::Application.new)
   }
 
+  before(:each) do
+    ENV["DATADOG_API_KEY"] = "DATADOG_API_KEY"
+    ENV["DATADOG_APPLICATION_KEY"] = "DATADOG_APPLICATION_KEY"
+  end
+
   it "interprets tag regexp with host" do
     expr = Hotdog::Expression::RegexpHostNode.new("foo", ":")
     q = [
@@ -19,10 +24,10 @@ describe "tag regexp expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
-    expect(expr.dump).to eq({tag_name_regexp: "host", separator: ":", tag_value_regexp: "foo"})
+    expect(expr.dump).to eq({tagname_regexp: "host", separator: ":", tagvalue_regexp: "foo"})
   end
 
-  it "interprets tag regexp with tag_name and tag_value" do
+  it "interprets tag regexp with tagname and tagvalue" do
     expr = Hotdog::Expression::RegexpTagNode.new("foo", "bar", ":")
     q = [
       "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
@@ -33,11 +38,11 @@ describe "tag regexp expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
-    expect(expr.dump).to eq({tag_name_regexp: "foo", separator: ":", tag_value_regexp: "bar"})
+    expect(expr.dump).to eq({tagname_regexp: "foo", separator: ":", tagvalue_regexp: "bar"})
   end
 
-  it "interprets tag regexp with tag_name with separator" do
-    expr = Hotdog::Expression::RegexpTagNameNode.new("foo", ":")
+  it "interprets tag regexp with tagname with separator" do
+    expr = Hotdog::Expression::RegexpTagnameNode.new("foo", ":")
     q = [
       "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
         "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
@@ -47,10 +52,10 @@ describe "tag regexp expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
-    expect(expr.dump).to eq({tag_name_regexp: "foo", separator: ":"})
+    expect(expr.dump).to eq({tagname_regexp: "foo", separator: ":"})
   end
 
-  it "interprets tag regexp with tag_name without separator" do
+  it "interprets tag regexp with tagname without separator" do
     expr = Hotdog::Expression::RegexpHostOrTagNode.new("foo", nil)
     q = [
       "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
@@ -62,11 +67,11 @@ describe "tag regexp expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
-    expect(expr.dump).to eq({tag_name_regexp: "foo"})
+    expect(expr.dump).to eq({tagname_regexp: "foo"})
   end
 
-  it "interprets tag regexp with tag_value with separator" do
-    expr = Hotdog::Expression::RegexpTagValueNode.new("foo", ":")
+  it "interprets tag regexp with tagvalue with separator" do
+    expr = Hotdog::Expression::RegexpTagvalueNode.new("foo", ":")
     q = [
       "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
         "INNER JOIN hosts ON hosts_tags.host_id = hosts.id",
@@ -77,11 +82,11 @@ describe "tag regexp expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
-    expect(expr.dump).to eq({separator: ":", tag_value_regexp: "foo"})
+    expect(expr.dump).to eq({separator: ":", tagvalue_regexp: "foo"})
   end
 
-  it "interprets tag regexp with tag_value without separator" do
-    expr = Hotdog::Expression::RegexpTagValueNode.new("foo", nil)
+  it "interprets tag regexp with tagvalue without separator" do
+    expr = Hotdog::Expression::RegexpTagvalueNode.new("foo", nil)
     q = [
       "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
         "INNER JOIN hosts ON hosts_tags.host_id = hosts.id",
@@ -92,7 +97,7 @@ describe "tag regexp expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
-    expect(expr.dump).to eq({tag_value_regexp: "foo"})
+    expect(expr.dump).to eq({tagvalue_regexp: "foo"})
   end
 
   it "empty tag regexp" do

data/spec/{parser → evaluator}/string_expression_spec.rb

@@ -9,6 +9,11 @@ describe "tag expression" do
     Hotdog::Commands::Search.new(Hotdog::Application.new)
   }
 
+  before(:each) do
+    ENV["DATADOG_API_KEY"] = "DATADOG_API_KEY"
+    ENV["DATADOG_APPLICATION_KEY"] = "DATADOG_APPLICATION_KEY"
+  end
+
   it "interprets tag with host" do
     expr = Hotdog::Expression::StringHostNode.new("foo", ":")
     q = [
@@ -19,10 +24,10 @@ describe "tag expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
-    expect(expr.dump).to eq({tag_name: "host", separator: ":", tag_value: "foo"})
+    expect(expr.dump).to eq({tagname: "host", separator: ":", tagvalue: "foo"})
   end
 
-  it "interprets tag with tag_name and tag_value" do
+  it "interprets tag with tagname and tagvalue" do
     expr = Hotdog::Expression::StringTagNode.new("foo", "bar", ":")
     q = [
       "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
@@ -33,11 +38,11 @@ describe "tag expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
-    expect(expr.dump).to eq({tag_name: "foo", separator: ":", tag_value: "bar"})
+    expect(expr.dump).to eq({tagname: "foo", separator: ":", tagvalue: "bar"})
   end
 
-  it "interprets tag with tag_name with separator" do
-    expr = Hotdog::Expression::StringTagNameNode.new("foo", ":")
+  it "interprets tag with tagname with separator" do
+    expr = Hotdog::Expression::StringTagnameNode.new("foo", ":")
     q = [
       "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
         "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
@@ -47,10 +52,10 @@ describe "tag expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
-    expect(expr.dump).to eq({tag_name: "foo", separator: ":"})
+    expect(expr.dump).to eq({tagname: "foo", separator: ":"})
   end
 
-  it "interprets tag with tag_name without separator" do
+  it "interprets tag with tagname without separator" do
     expr = Hotdog::Expression::StringHostOrTagNode.new("foo", nil)
     q = [
       "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
@@ -62,11 +67,11 @@ describe "tag expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
-    expect(expr.dump).to eq({tag_name: "foo"})
+    expect(expr.dump).to eq({tagname: "foo"})
   end
 
-  it "interprets tag with tag_value with separator" do
-    expr = Hotdog::Expression::StringTagValueNode.new("foo", ":")
+  it "interprets tag with tagvalue with separator" do
+    expr = Hotdog::Expression::StringTagvalueNode.new("foo", ":")
     q = [
       "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
         "INNER JOIN hosts ON hosts_tags.host_id = hosts.id",
@@ -77,11 +82,11 @@ describe "tag expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
-    expect(expr.dump).to eq({separator: ":", tag_value: "foo"})
+    expect(expr.dump).to eq({separator: ":", tagvalue: "foo"})
   end
 
-  it "interprets tag with tag_value without separator" do
-    expr = Hotdog::Expression::StringTagValueNode.new("foo", nil)
+  it "interprets tag with tagvalue without separator" do
+    expr = Hotdog::Expression::StringTagvalueNode.new("foo", nil)
     q = [
       "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
         "INNER JOIN hosts ON hosts_tags.host_id = hosts.id",
@@ -92,7 +97,7 @@ describe "tag expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
-    expect(expr.dump).to eq({tag_value: "foo"})
+    expect(expr.dump).to eq({tagvalue: "foo"})
   end
 
   it "empty tag" do

data/spec/optimizer/binary_expression_spec.rb

@@ -0,0 +1,47 @@
+require "spec_helper"
+require "hotdog/application"
+require "hotdog/commands"
+require "hotdog/commands/search"
+require "parslet"
+
+describe "binary expression" do
+  it "everything AND x should return x" do
+    expr = Hotdog::Expression::BinaryExpressionNode.new("AND", Hotdog::Expression::EverythingNode.new(), Hotdog::Expression::NothingNode.new())
+    expect(expr.optimize.dump).to eq({
+      query: "SELECT NULL AS host_id WHERE host_id NOT NULL;",
+      values: [],
+    })
+  end
+
+  it "nothing AND x should return nothing" do
+    expr = Hotdog::Expression::BinaryExpressionNode.new("AND", Hotdog::Expression::NothingNode.new(), Hotdog::Expression::EverythingNode.new())
+    expect(expr.optimize.dump).to eq({
+      query: "SELECT NULL AS host_id WHERE host_id NOT NULL;",
+      values: [],
+    })
+  end
+
+  it "everything OR x should return everything" do
+    expr = Hotdog::Expression::BinaryExpressionNode.new("OR", Hotdog::Expression::EverythingNode.new(), Hotdog::Expression::NothingNode.new())
+    expect(expr.optimize.dump).to eq({
+      query: "SELECT id AS host_id FROM hosts;",
+      values: [],
+    })
+  end
+
+  it "nothing OR x should return x" do
+    expr = Hotdog::Expression::BinaryExpressionNode.new("OR", Hotdog::Expression::NothingNode.new(), Hotdog::Expression::EverythingNode.new())
+    expect(expr.optimize.dump).to eq({
+      query: "SELECT id AS host_id FROM hosts;",
+      values: [],
+    })
+  end
+
+  it "everything XOR everything should return nothing" do
+    expr = Hotdog::Expression::BinaryExpressionNode.new("XOR", Hotdog::Expression::EverythingNode.new(), Hotdog::Expression::EverythingNode.new())
+    expect(expr.optimize.dump).to eq({
+      query: "SELECT NULL AS host_id WHERE host_id NOT NULL;",
+      values: [],
+    })
+  end
+end

data/spec/optimizer/glob_expression_spec.rb

@@ -0,0 +1,105 @@
+require "spec_helper"
+require "hotdog/application"
+require "hotdog/commands"
+require "hotdog/commands/search"
+require "parslet"
+
+describe "tag glob expression" do
+  it "interprets tag glob with host" do
+    expr = Hotdog::Expression::GlobHostNode.new("foo*", ":")
+    expect(expr.optimize.dump).to eq({
+      tagname_glob: "host",
+      separator: ":",
+      tagvalue_glob: "foo*",
+      fallback: {
+        query: [
+          "SELECT hosts.id AS host_id FROM hosts",
+          "WHERE LOWER(hosts.name) GLOB LOWER(?);",
+        ].join(" "),
+        values: ["*foo*"],
+      },
+    })
+  end
+
+  it "interprets tag glob with tagname and tagvalue" do
+    expr = Hotdog::Expression::GlobTagNode.new("foo*", "bar*", ":")
+    expect(expr.optimize.dump).to eq({
+      tagname_glob: "foo*",
+      separator: ":",
+      tagvalue_glob: "bar*",
+      fallback: {
+        query: [
+          "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(?);",
+        ].join(" "),
+        values: ["*foo*", "*bar*"],
+      },
+    })
+  end
+
+  it "interprets tag glob with tagname with separator" do
+    expr = Hotdog::Expression::GlobTagnameNode.new("foo*", ":")
+    expect(expr.optimize.dump).to eq({
+      tagname_glob: "foo*",
+      separator: ":",
+      fallback: {
+        query: [
+          "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(?);",
+        ].join(" "),
+        values: ["*foo*"],
+      },
+    })
+  end
+
+  it "interprets tag glob with tagname without separator" do
+    expr = Hotdog::Expression::GlobHostOrTagNode.new("foo*", nil)
+    expect(expr.optimize.dump).to eq({
+      tagname_glob: "foo*",
+      fallback: {
+        query: [
+          "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(?);",
+        ].join(" "),
+        values: ["*foo*", "*foo*", "*foo*"],
+      },
+    })
+  end
+
+  it "interprets tag glob with tagvalue with separator" do
+    expr = Hotdog::Expression::GlobTagvalueNode.new("foo*", ":")
+    expect(expr.optimize.dump).to eq({
+      separator: ":",
+      tagvalue_glob: "foo*",
+      fallback: {
+        query: [
+          "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.value) GLOB LOWER(?);",
+        ].join(" "),
+        values: ["*foo*", "*foo*"],
+      },
+    })
+  end
+
+  it "interprets tag glob with tagvalue without separator" do
+    expr = Hotdog::Expression::GlobTagvalueNode.new("foo*", nil)
+    expect(expr.optimize.dump).to eq({
+      tagvalue_glob: "foo*",
+      fallback: {
+        query: [
+          "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.value) GLOB LOWER(?);",
+        ].join(" "),
+        values: ["*foo*", "*foo*"],
+      }
+    })
+  end
+end