hotdog 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 551436c6cb264d187db243f60da58a14f38cb820
-  data.tar.gz: f68bd1dd186fa326af8541b9ea3ae4ae95075d44
+  metadata.gz: 12b1b97f8c77f181a665ba52db0725c613d638a7
+  data.tar.gz: 73be8bb8526df6c4bb95811e6e56de196fae0a73
 SHA512:
-  metadata.gz: f85d09c3f08d2cce6fec0d9d73654e86b2ac6fa8abaa6b2682047f8b4daeeedb6985dc7a0f4613bee2076caf43ecf8e0df129f45023d986b14b306ee971a2a38
-  data.tar.gz: 2e983f2f1508ea69872aa58758ee2a7cfca55e3dcbcba2b612f26e8b543fb8b87a0b849b0d5ef198fb4919c1622c5f2f90bdeb38d73f0ea5ead1e23ad987c11c
+  metadata.gz: 602156cf61f52c8f8c14937dcf324b93516ac16b6f0e61c971bcccb124a7827902e313c400fdcb98eb54d83f8ae2cf7a21783d4f1937df18899c20782380224a
+  data.tar.gz: eb9ab65fad8b6b25e59eec751cc02b4a99cc0d69fc5f2fc61a7c6df2c9fbce5055928ed2ab8f2c85b7af2a8580f9db51e5534c277fac89a100ab7e9b7064eb27

data/lib/hotdog/application.rb

@@ -155,7 +155,7 @@ module Hotdog
 
     def find_library(dirname, name)
       load_path = $LOAD_PATH.map { |path| File.join(path, dirname) }.select { |path| File.directory?(path) }
-      libraries = load_path.map { |path| Dir.glob(File.join(path, "*.rb")) }.reduce(:+).select { |file| File.file?(file) }
+      libraries = load_path.flat_map { |path| Dir.glob(File.join(path, "*.rb")) }.select { |file| File.file?(file) }
       rbname = "#{name}.rb"
       if library = libraries.find { |file| File.basename(file) == rbname }
         library

data/lib/hotdog/commands/hosts.rb

@@ -8,13 +8,13 @@ module Hotdog
         if args.empty?
           result = execute("SELECT id FROM hosts").to_a.reduce(:+)
         else
-          result = args.map { |host_name|
+          result = args.flat_map { |host_name|
             if glob?(host_name)
               execute("SELECT id FROM hosts WHERE name GLOB ?", [host_name]).to_a.reduce(:+)
             else
               execute("SELECT id FROM hosts WHERE name = ?", [host_name]).to_a.reduce(:+)
             end
-          }.reduce(:+)
+          }
         end
         if result && (0 < result.length)
           result, fields = get_hosts(result)

data/lib/hotdog/commands/search.rb

@@ -305,12 +305,13 @@ 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
-              slice = 200
-              (min / slice).upto(max / slice).map { |i|
-                range = (slice*i)...(slice*(i+1))
+              (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))
                 selected = values.select { |n| range === n }
-                environment.execute("SELECT id FROM hosts WHERE ? <= id AND id < ? AND id NOT IN (%s)" % selected.map { "?" }.join(", "), [range.first, range.last] + selected).map { |row| row.first }
-              }.reduce(:+).tap do |values|
+                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
@@ -354,33 +355,32 @@ module Hotdog
         end
 
         def evaluate(environment, options={})
-          q = []
           if identifier?
             if attribute?
               case identifier
               when /\Ahost\z/i
-                q << "SELECT hosts.id FROM hosts"
-                q <<   "WHERE hosts.name = ?;"
-                values = environment.execute(q.join(" "), [attribute]).map { |row| row.first }
+                q = "SELECT hosts.id FROM hosts " \
+                      "WHERE hosts.name = ?;"
+                values = environment.execute(q, [attribute]).map { |row| row.first }
               else
-                q << "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags"
-                q <<   "INNER JOIN tags ON hosts_tags.tag_id = tags.id"
-                q <<     "WHERE tags.name = ? AND tags.value = ?;"
-                values = environment.execute(q.join(" "), [identifier, attribute]).map { |row| row.first }
+                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 }
               end
             else
-              q << "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags"
-              q <<   "INNER JOIN hosts ON hosts_tags.host_id = hosts.id"
-              q <<   "INNER JOIN tags ON hosts_tags.tag_id = tags.id"
-              q <<     "WHERE hosts.name = ? OR tags.name = ? OR tags.value = ?;"
-              values = environment.execute(q.join(" "), [identifier, identifier, identifier]).map { |row| row.first }
+              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 }
             end
           else
             if attribute?
-               q << "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags"
-               q <<   "INNER JOIN tags ON hosts_tags.tag_id = tags.id"
-               q <<     "WHERE tags.value = ?;"
-              values = environment.execute(q.join(" "), [attribute]).map { |row| row.first }
+               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 }
             else
               return []
             end
@@ -431,33 +431,32 @@ module Hotdog
 
       class TagGlobExpressionNode < TagExpressionNode
         def evaluate(environment, options={})
-          q = []
           if identifier?
             if attribute?
               case identifier
               when /\Ahost\z/i
-                q << "SELECT hosts.id FROM hosts"
-                q <<   "WHERE hosts.name GLOB ?;"
-                values = environment.execute(q.join(" "), [attribute]).map { |row| row.first }
+                q = "SELECT hosts.id FROM hosts " \
+                      "WHERE hosts.name GLOB ?;"
+                values = environment.execute(q, [attribute]).map { |row| row.first }
               else
-                q << "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags"
-                q <<   "INNER JOIN tags ON hosts_tags.tag_id = tags.id"
-                q <<     "WHERE tags.name GLOB ? AND tags.value GLOB ?;"
-                values = environment.execute(q.join(" "), [identifier, attribute]).map { |row| row.first }
+                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 }
               end
             else
-              q << "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags"
-              q <<   "INNER JOIN hosts ON hosts_tags.host_id = hosts.id"
-              q <<   "INNER JOIN tags ON hosts_tags.tag_id = tags.id"
-              q <<     "WHERE hosts.name GLOB ? OR tags.name GLOB ? OR tags.value GLOB ?;"
-              values = environment.execute(q.join(" "), [identifier, identifier, identifier]).map { |row| row.first }
+              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 }
             end
           else
             if attribute?
-              q << "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags"
-              q <<   "INNER JOIN tags ON hosts_tags.tag_id = tags.id"
-              q <<     "WHERE tags.value GLOB ?;"
-              values = environment.execute(q.join(" "), [attribute]).map { |row| row.first }
+              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 }
             else
               return []
             end
@@ -478,33 +477,32 @@ module Hotdog
         end
 
         def evaluate(environment, options={})
-          q = []
           if identifier?
             if attribute?
               case identifier
               when /\Ahost\z/i
-                q << "SELECT hosts.id FROM hosts"
-                q <<   "WHERE hosts.name REGEXP ?;"
-                values = environment.execute(q.join(" "), [attribute]).map { |row| row.first }
+                q = "SELECT hosts.id FROM hosts " \
+                      "WHERE hosts.name REGEXP ?;"
+                values = environment.execute(q, [attribute]).map { |row| row.first }
               else
-                q << "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags"
-                q <<   "INNER JOIN tags ON hosts_tags.tag_id = tags.id"
-                q <<     "WHERE tags.name REGEXP ? AND tags.value REGEXP ?;"
-                values = environment.execute(q.join(" "), [identifier, attribute]).map { |row| row.first }
+                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 }
               end
             else
-              q << "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags"
-              q <<   "INNER JOIN hosts ON hosts_tags.host_id = hosts.id"
-              q <<   "INNER JOIN tags ON hosts_tags.tag_id = tags.id"
-              q <<     "WHERE hosts.name REGEXP ? OR tags.name REGEXP ? OR tags.value REGEXP ?;"
-              values = environment.execute(q.join(" "), [identifier, identifier, identifier]).map { |row| row.first }
+              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 }
             end
           else
             if attribute?
-              q << "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags"
-              q <<   "INNER JOIN tags ON hosts_tags.tag_id = tags.id"
-              q <<     "WHERE tags.value REGEXP ?;"
-              values = environment.execute(q.join(" "), [attribute]).map { |row| row.first }
+              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 }
             else
               return []
             end

data/lib/hotdog/commands.rb

@@ -7,11 +7,12 @@ require "sqlite3"
 
 module Hotdog
   module Commands
+    SQLITE_LIMIT_COMPOUND_SELECT = 500 # TODO: get actual value from `sqlite3_limit()`?
+
     class BaseCommand
       PERSISTENT_DB = "persistent.db"
       MASK_DATABASE = 0xffff0000
       MASK_QUERY = 0x0000ffff
-      MAX_TERMS = 200
 
       def initialize(application)
         @application = application
@@ -84,22 +85,21 @@ module Hotdog
               host_names = {}
             else
               host_names = Hash[
-                host_ids.each_slice(MAX_TERMS).map { |host_ids|
+                host_ids.each_slice(SQLITE_LIMIT_COMPOUND_SELECT).flat_map { |host_ids|
                   execute("SELECT id, name FROM hosts WHERE id IN (%s)" % host_ids.map { "?" }.join(", "), host_ids).map { |row| row.to_a }
-                }.reduce(:+)
+                }
               ]
             end
-            q1 = []
-            q1 << "SELECT tags.name, GROUP_CONCAT(tags.value, ',') FROM hosts_tags"
-            q1 <<   "INNER JOIN hosts ON hosts_tags.host_id = hosts.id"
-            q1 <<   "INNER JOIN tags ON hosts_tags.tag_id = tags.id"
-            q1 <<     "WHERE hosts_tags.host_id = ? AND tags.name IN (%s)"
-            q1 <<       "GROUP BY tags.name;"
+            q1 = "SELECT tags.name, GROUP_CONCAT(tags.value, ',') 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_tags.host_id = ? AND tags.name IN (%s) " \
+                       "GROUP BY tags.name;"
             result = host_ids.map { |host_id|
               tag_values = Hash[
-                fields_without_host.each_slice(MAX_TERMS).map { |fields_without_host|
-                  execute(q1.join(" ") % fields_without_host.map { "?" }.join(", "), [host_id] + fields_without_host).map { |row| row.to_a }
-                }.reduce(:+)
+                fields_without_host.each_slice(SQLITE_LIMIT_COMPOUND_SELECT - 1).flat_map { |fields_without_host|
+                  execute(q1 % fields_without_host.map { "?" }.join(", "), [host_id] + fields_without_host).map { |row| row.to_a }
+                }
               ]
               fields.map { |tag_name|
                 if tag_name == "host"
@@ -112,42 +112,40 @@ module Hotdog
             [result, fields]
           else
             if @options[:listing]
-              q1 = []
-              q1 << "SELECT DISTINCT tags.name FROM hosts_tags"
-              q1 <<   "INNER JOIN tags ON hosts_tags.tag_id = tags.id"
-              q1 <<     "WHERE hosts_tags.host_id IN (%s);"
+              q1 = "SELECT DISTINCT tags.name FROM hosts_tags " \
+                     "INNER JOIN tags ON hosts_tags.tag_id = tags.id " \
+                       "WHERE hosts_tags.host_id IN (%s);"
               if @options[:primary_tag]
                 fields = [
                   @options[:primary_tag],
                   "host",
-                ] + host_ids.each_slice(MAX_TERMS).map { |host_ids|
-                  execute(q1.join(" ") % host_ids.map { "?" }.join(", "), host_ids).map { |row| row.first }.reject { |tag_name|
+                ] + host_ids.each_slice(SQLITE_LIMIT_COMPOUND_SELECT).flat_map { |host_ids|
+                  execute(q1 % host_ids.map { "?" }.join(", "), host_ids).map { |row| row.first }.reject { |tag_name|
                     tag_name == @options[:primary_tag]
                   }
-                }.reduce(:+)
+                }
               else
                 fields = [
                   "host",
-                ] + host_ids.each_slice(MAX_TERMS).map { |host_ids|
-                  execute(q1.join(" ") % host_ids.map { "?" }.join(", "), host_ids).map { |row| row.first }
-                }.reduce(:+)
+                ] + host_ids.each_slice(SQLITE_LIMIT_COMPOUND_SELECT).flat_map { |host_ids|
+                  execute(q1 % host_ids.map { "?" }.join(", "), host_ids).map { |row| row.first }
+                }
               end
               host_names = Hash[
-                host_ids.each_slice(MAX_TERMS).map { |host_ids|
+                host_ids.each_slice(SQLITE_LIMIT_COMPOUND_SELECT).flat_map { |host_ids|
                   execute("SELECT id, name FROM hosts WHERE id IN (%s)" % host_ids.map { "?" }.join(", "), host_ids).map { |row| row.to_a }
-                }.reduce(:+)
+                }
               ]
-              q2 = []
-              q2 << "SELECT tags.name, GROUP_CONCAT(tags.value, ',') FROM hosts_tags"
-              q2 <<   "INNER JOIN tags ON hosts_tags.tag_id = tags.id"
-              q2 <<     "WHERE hosts_tags.host_id = ? AND tags.name IN (%s)"
-              q2 <<       "GROUP BY tags.name;"
+              q2 = "SELECT tags.name, GROUP_CONCAT(tags.value, ',') FROM hosts_tags " \
+                     "INNER JOIN tags ON hosts_tags.tag_id = tags.id " \
+                       "WHERE hosts_tags.host_id = ? AND tags.name IN (%s) " \
+                         "GROUP BY tags.name;"
               fields_without_host = fields.reject { |tag_name| tag_name == "host" }
               result = host_ids.map { |host_id|
                 tag_values = Hash[
-                  fields_without_host.each_slice(MAX_TERMS).map { |fields_without_host|
-                    execute(q2.join(" ") % fields_without_host.map { "?" }.join(", "), [host_id] + fields_without_host).map { |row| row.to_a }
-                  }.reduce(:+)
+                  fields_without_host.each_slice(SQLITE_LIMIT_COMPOUND_SELECT - 1).flat_map { |fields_without_host|
+                    execute(q2 % fields_without_host.map { "?" }.join(", "), [host_id] + fields_without_host).map { |row| row.to_a }
+                  }
                 ]
                 fields.map { |tag_name|
                   if tag_name == "host"
@@ -161,20 +159,19 @@ module Hotdog
             else
               if @options[:primary_tag]
                 fields = [@options[:primary_tag]]
-                q1 = []
-                q1 << "SELECT tags.value FROM hosts_tags"
-                q1 <<   "INNER JOIN hosts ON hosts_tags.host_id = hosts.id"
-                q1 <<   "INNER JOIN tags ON hosts_tags.tag_id = tags.id"
-                q1 <<     "WHERE hosts_tags.host_id IN (%s) AND tags.name = ?;"
-                result = host_ids.each_slice(MAX_TERMS).map { |host_ids|
-                  execute(q1.join(" ") % host_ids.map { "?" }.join(", "), host_ids + [@options[:primary_tag]]).map { |row| row.to_a }
-                }.reduce(:+)
+                q1 = "SELECT tags.value 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_tags.host_id IN (%s) AND tags.name = ?;"
+                result = host_ids.each_slice(SQLITE_LIMIT_COMPOUND_SELECT - 1).flat_map { |host_ids|
+                  execute(q1 % host_ids.map { "?" }.join(", "), host_ids + [@options[:primary_tag]]).map { |row| row.to_a }
+                }
                 [result, fields]
               else
                 fields = ["host"]
-                result = host_ids.each_slice(MAX_TERMS).map { |host_ids|
+                result = host_ids.each_slice(SQLITE_LIMIT_COMPOUND_SELECT).flat_map { |host_ids|
                   execute("SELECT name FROM hosts WHERE id IN (%s)" % host_ids.map { "?" }.join(", "), host_ids).map { |row| row.to_a }
-                }.reduce(:+)
+                }
                 [result, fields]
               end
             end
@@ -222,23 +219,22 @@ module Hotdog
 
           memory_db.transaction do
             known_tags = all_tags.keys.map { |tag| split_tag(tag) }.uniq
-            known_tags.each_slice(MAX_TERMS) do |known_tags|
+            known_tags.each_slice(SQLITE_LIMIT_COMPOUND_SELECT / 2) do |known_tags|
               prepare(memory_db, "INSERT OR IGNORE INTO tags (name, value) VALUES %s" % known_tags.map { "(?, ?)" }.join(", ")).execute(known_tags)
             end
 
             known_hosts = all_tags.values.reduce(:+).uniq
-            known_hosts.each_slice(MAX_TERMS) do |known_hosts|
+            known_hosts.each_slice(SQLITE_LIMIT_COMPOUND_SELECT) do |known_hosts|
               prepare(memory_db, "INSERT OR IGNORE INTO hosts (name) VALUES %s" % known_hosts.map { "(?)" }.join(", ")).execute(known_hosts)
             end
 
             all_tags.each do |tag, hosts|
-              q = []
-              q << "INSERT OR REPLACE INTO hosts_tags (host_id, tag_id)"
-              q <<   "SELECT host.id, tag.id FROM"
-              q <<     "( SELECT id FROM hosts WHERE name IN (%s) ) AS host,"
-              q <<     "( SELECT id FROM tags WHERE name = ? AND value = ? LIMIT 1 ) AS tag;"
-              hosts.each_slice(MAX_TERMS) do |hosts|
-                prepare(memory_db, q.join(" ") % hosts.map { "?" }.join(", ")).execute(hosts + split_tag(tag))
+              q = "INSERT OR REPLACE INTO hosts_tags (host_id, tag_id) " \
+                    "SELECT host.id, tag.id FROM " \
+                      "( SELECT id FROM hosts WHERE name IN (%s) ) AS host, " \
+                      "( SELECT id FROM tags WHERE name = ? AND value = ? LIMIT 1 ) AS tag;"
+              hosts.each_slice(SQLITE_LIMIT_COMPOUND_SELECT - 2) do |hosts|
+                prepare(memory_db, q % hosts.map { "?" }.join(", ")).execute(hosts + split_tag(tag))
               end
             end
           end
@@ -269,10 +265,10 @@ module Hotdog
         downtimes = all_downtimes.select { |downtime|
           # active downtimes
           downtime["active"] and ( downtime["start"].nil? or downtime["start"] < now ) and ( downtime["end"].nil? or now <= downtime["end"] )
-        }.map { |downtime|
+        }.flat_map { |downtime|
           # find host scopes
           downtime["scope"].select { |scope| scope.start_with?("host:") }.map { |scope| scope.sub(/\Ahost:/, "") }
-        }.reduce(:+) || []
+        }
         if not downtimes.empty?
           logger.info("ignore host(s) with scheduled downtimes: #{downtimes.inspect}")
         end
@@ -292,17 +288,17 @@ module Hotdog
           create_table_hosts_tags(dst)
 
           hosts = prepare(src, "SELECT id, name FROM hosts").execute().to_a
-          hosts.each_slice(MAX_TERMS) do |hosts|
+          hosts.each_slice(SQLITE_LIMIT_COMPOUND_SELECT / 2) do |hosts|
             prepare(dst, "INSERT INTO hosts (id, name) VALUES %s" % hosts.map { "(?, ?)" }.join(", ")).execute(hosts)
           end
 
           tags = prepare(src, "SELECT id, name, value FROM tags").execute().to_a
-          tags.each_slice(MAX_TERMS) do |tags|
+          tags.each_slice(SQLITE_LIMIT_COMPOUND_SELECT / 3) do |tags|
             prepare(dst, "INSERT INTO tags (id, name, value) VALUES %s" % tags.map { "(?, ?, ?)" }.join(", ")).execute(tags)
           end
 
           hosts_tags = prepare(src, "SELECT host_id, tag_id FROM hosts_tags").to_a
-          hosts_tags.each_slice(MAX_TERMS) do |hosts_tags|
+          hosts_tags.each_slice(SQLITE_LIMIT_COMPOUND_SELECT / 2) do |hosts_tags|
             prepare(dst, "INSERT INTO hosts_tags (host_id, tag_id) VALUES %s" % hosts_tags.map { "(?, ?)" }.join(", ")).execute(hosts_tags)
           end
 
@@ -313,49 +309,49 @@ module Hotdog
       end
 
       def create_table_hosts(db)
-        logger.debug("create_table_hosts()")
-        q = []
-        q << "CREATE TABLE IF NOT EXISTS hosts ("
-        q <<   "id INTEGER PRIMARY KEY AUTOINCREMENT,"
-        q <<   "name VARCHAR(255) NOT NULL COLLATE NOCASE"
-        q << ");"
-        db.execute(q.join(" "))
+        q = "CREATE TABLE IF NOT EXISTS hosts ( " \
+              "id INTEGER PRIMARY KEY AUTOINCREMENT, " \
+              "name VARCHAR(255) NOT NULL COLLATE NOCASE " \
+            ");"
+        logger.debug(q)
+        db.execute(q)
       end
 
       def create_index_hosts(db)
-        logger.debug("create_index_hosts()")
-        db.execute("CREATE UNIQUE INDEX IF NOT EXISTS hosts_name ON hosts ( name )")
+        q = "CREATE UNIQUE INDEX IF NOT EXISTS hosts_name ON hosts ( name );"
+        logger.debug(q)
+        db.execute(q)
       end
 
       def create_table_tags(db)
-        logger.debug("create_table_tags()")
-        q = []
-        q << "CREATE TABLE IF NOT EXISTS tags ("
-        q <<   "id INTEGER PRIMARY KEY AUTOINCREMENT,"
-        q <<   "name VARCHAR(200) NOT NULL COLLATE NOCASE,"
-        q <<   "value VARCHAR(200) NOT NULL COLLATE NOCASE"
-        q << ");"
-        db.execute(q.join(" "))
+        q = "CREATE TABLE IF NOT EXISTS tags ( " \
+              "id INTEGER PRIMARY KEY AUTOINCREMENT, " \
+              "name VARCHAR(200) NOT NULL COLLATE NOCASE, " \
+              "value VARCHAR(200) NOT NULL COLLATE NOCASE " \
+            ");"
+        logger.debug(q)
+        db.execute(q)
       end
 
       def create_index_tags(db)
-        logger.debug("create_index_tags()")
-        db.execute("CREATE UNIQUE INDEX IF NOT EXISTS tags_name_value ON tags ( name, value )")
+        q = "CREATE UNIQUE INDEX IF NOT EXISTS tags_name_value ON tags ( name, value );"
+        logger.debug(q)
+        db.execute(q)
       end
 
       def create_table_hosts_tags(db)
-        logger.debug("create_table_hosts_tags()")
-        q = []
-        q << "CREATE TABLE IF NOT EXISTS hosts_tags ("
-        q <<   "host_id INTEGER NOT NULL,"
-        q <<   "tag_id INTEGER NOT NULL"
-        q << ");"
-        db.execute(q.join(" "))
+        q = "CREATE TABLE IF NOT EXISTS hosts_tags ( " \
+              "host_id INTEGER NOT NULL, " \
+              "tag_id INTEGER NOT NULL " \
+            ");"
+        logger.debug(q)
+        db.execute(q)
       end
 
       def create_index_hosts_tags(db)
-        logger.debug("create_index_hosts_tags()")
-        db.execute("CREATE UNIQUE INDEX IF NOT EXISTS hosts_tags_host_id_tag_id ON hosts_tags ( host_id, tag_id )")
+        q = "CREATE UNIQUE INDEX IF NOT EXISTS hosts_tags_host_id_tag_id ON hosts_tags ( host_id, tag_id );"
+        logger.debug(q)
+        db.execute(q)
       end
     end
   end

data/lib/hotdog/version.rb

@@ -1,3 +1,3 @@
 module Hotdog
-  VERSION = "0.2.1"
+  VERSION = "0.2.2"
 end

metadata

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