rroonga 3.0.9 → 3.1.0

data/lib/groonga/column.rb

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2013  Kouhei Sutou <kou@clear-code.com>
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License version 2.1 as published by the Free Software Foundation.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+module Groonga
+  class Column
+    def disk_usage
+      measurer = StatisticMeasurer.new
+      measurer.measure_disk_usage(path)
+    end
+  end
+end

data/lib/groonga/database-inspector.rb

@@ -0,0 +1,279 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2013  Kouhei Sutou <kou@clear-code.com>
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License version 2.1 as published by the Free Software Foundation.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+module Groonga
+  # It is a class that inspects database. You can know details metadata
+  # of the database.
+  class DatabaseInspector
+    # @param database [Database] The database to be inspected.
+    def initialize(database)
+      @database = database
+    end
+
+    # Report inspected result of the database.
+    #
+    # @param output [#write] (nil) The output of inspected result.
+    #   If it is @nil@, @$stdout@ is used.
+    def report(output=nil)
+      output ||= $stdout
+      reporter = Reporter.new(@database, output)
+      reporter.report
+    end
+
+    # @private
+    class Reporter
+      def initialize(database, output)
+        @database = database
+        @context = @database.context
+        @output = output
+        @indent_width = 0
+      end
+
+      def report
+        write("Database\n")
+        indent do
+          write("Path:             #{inspect_path(@database.path)}\n")
+          write("Total disk usage: " +
+                "#{inspect_disk_usage(total_disk_usage)}\n")
+          write("Disk usage:       " +
+                "#{inspect_sub_disk_usage(@database.disk_usage)}\n")
+          write("N records:        #{count_total_n_records}\n")
+          write("N tables:         #{count_n_tables}\n")
+          write("N columns:        #{count_total_n_columns}\n")
+          report_plugins
+          report_tables
+        end
+      end
+
+      private
+      def report_plugins
+        write("Plugins:\n")
+        indent do
+          plugin_paths = @database.plugin_paths
+          if plugin_paths.empty?
+            write("None\n")
+            return
+          end
+          plugin_paths.each do |path|
+            write("* #{path}\n")
+          end
+        end
+      end
+
+      def report_tables
+        write("Tables:\n")
+        indent do
+          tables = @database.tables
+          if tables.empty?
+            write("None\n")
+            return
+          end
+          tables.each do |table|
+            report_table(table)
+          end
+        end
+      end
+
+      def report_table(table)
+        write("#{table.name}:\n")
+        indent do
+          write("ID:               #{table.id}\n")
+          write("Type:             #{inspect_table_type(table)}\n")
+          write("Key type:         #{inspect_key_type(table)}\n")
+          write("Tokenizer:        #{inspect_tokenizer(table)}\n")
+          write("Normalizer:       #{inspect_normalizer(table)}\n")
+          write("Path:             #{inspect_path(table.path)}\n")
+          total_table_disk_usage = count_total_table_disk_usage(table)
+          write("Total disk usage: " +
+                "#{inspect_sub_disk_usage(total_table_disk_usage)}\n")
+          write("Disk usage:       " +
+                "#{inspect_sub_disk_usage(table.disk_usage)}\n")
+          write("N records:        #{table.size}\n")
+          write("N columns:        #{table.columns.size}\n")
+          report_columns(table)
+        end
+      end
+
+      def report_columns(table)
+        write("Columns:\n")
+        indent do
+          columns = table.columns
+          if columns.empty?
+            write("None\n")
+            return
+          end
+          columns.each do |column|
+            report_column(column)
+          end
+        end
+      end
+
+      def report_column(column)
+        write("#{column.local_name}:\n")
+        indent do
+          write("ID:         #{column.id}\n")
+          write("Type:       #{inspect_column_type(column)}\n")
+          write("Value type: #{inspect_column_value_type(column)}\n")
+          write("Path:       #{inspect_path(column.path)}\n")
+          write("Disk usage: #{inspect_sub_disk_usage(column.disk_usage)}\n")
+        end
+      end
+
+      def indent
+        indent_width = @indent_width
+        @indent_width += 2
+        yield
+      ensure
+        @indent_width = indent_width
+      end
+
+      def write(message)
+        indent = " " * @indent_width
+        @output.write("#{indent}#{message}")
+      end
+
+      def inspect_path(path)
+        if path.nil?
+          "(null)"
+        else
+          "<#{path}>"
+        end
+      end
+
+      KiB = (2 ** 10).to_f
+      MiB = (2 ** 20).to_f
+      GiB = (2 ** 30).to_f
+      TiB = (2 ** 40).to_f
+      PiB = (2 ** 50).to_f
+      def inspect_disk_usage(disk_usage)
+        if disk_usage < KiB
+          "%dB" % disk_usage
+        elsif disk_usage < MiB
+          "%.3fKiB" % (disk_usage / KiB)
+        elsif disk_usage < GiB
+          "%.3fMiB" % (disk_usage / MiB)
+        elsif disk_usage < TiB
+          "%.3fGiB" % (disk_usage / GiB)
+        elsif disk_usage < PiB
+          "%.3fTiB" % (disk_usage / TiB)
+        else
+          "%.3fPiB" % (disk_usage / PiB)
+        end
+      end
+
+      def inspect_sub_disk_usage(disk_usage)
+        percent = disk_usage / total_disk_usage.to_f * 100
+        "%s (%.3f%%)" % [inspect_disk_usage(disk_usage), percent]
+      end
+
+      def count_total_n_records
+        @database.tables.inject(0) do |previous, table|
+          previous + table.size
+        end
+      end
+
+      def count_n_tables
+        @database.tables.size
+      end
+
+      def count_total_n_columns
+        @database.tables.inject(0) do |previous, table|
+          previous + table.columns.size
+        end
+      end
+
+      def total_disk_usage
+        @total_disk_usage ||= count_total_disk_usage
+      end
+
+      def count_total_disk_usage
+        @database.tables.inject(@database.disk_usage) do |previous, table|
+          previous + count_total_table_disk_usage(table)
+        end
+      end
+
+      def count_total_table_disk_usage(table)
+        table.columns.inject(table.disk_usage) do |previous, column|
+          previous + column.disk_usage
+        end
+      end
+
+      def inspect_table_type(table)
+        case table
+        when Groonga::Array
+          "array"
+        when Groonga::Hash
+          "hash"
+        when Groonga::PatriciaTrie
+          "patricia trie"
+        when Groonga::DoubleArrayTrie
+          "double array trie"
+        else
+          "unknown (#{table.class})"
+        end
+      end
+
+      def inspect_key_type(table)
+        if table.support_key?
+          table.domain.name
+        else
+          "(no key)"
+        end
+      end
+
+      def inspect_tokenizer(table)
+        if table.support_key?
+          tokenizer = table.default_tokenizer
+          if tokenizer
+            tokenizer.name
+          else
+            "(no tokenizer)"
+          end
+        else
+          "(no key)"
+        end
+      end
+
+      def inspect_normalizer(table)
+        if table.support_key?
+          normalizer = table.normalizer
+          if normalizer
+            normalizer.name
+          else
+            "(no normalizer)"
+          end
+        else
+          "(no key)"
+        end
+      end
+
+      def inspect_column_type(column)
+        if column.index?
+          "index"
+        elsif column.vector?
+          "vector"
+        else
+          "scalar"
+        end
+      end
+
+      def inspect_column_value_type(column)
+        column.domain.name
+      end
+    end
+  end
+end

data/lib/groonga/database.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2012  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2012-2013  Kouhei Sutou <kou@clear-code.com>
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -19,11 +19,41 @@ module Groonga
   class Database
     # @return [Array<Groonga::Table>] tables defined in the database.
     def tables
-      find_all do |object|
+      options = {
+        :ignore_missing_object => true,
+        :order_by => :key,
+      }
+      each(options).find_all do |object|
         object.is_a?(Groonga::Table)
       end
     end
 
+    # @return [Array<String>] registered plugin paths.
+    def plugin_paths
+      processed_paths = {}
+      paths = []
+      each(:ignore_missing_object => true, :order_by => :id) do |object|
+        next unless object.is_a?(Groonga::Procedure)
+        next if object.builtin?
+        path = object.path
+        next if path.nil?
+        next if processed_paths.has_key?(path)
+        processed_paths[path] = true
+        paths << path
+      end
+      paths
+    end
+
+    def disk_usage
+      return 0 if path.nil?
+
+      usage = 0
+      measurer = StatisticMeasurer.new
+      usage += measurer.measure_disk_usage(path)
+      usage += measurer.measure_disk_usage("%s.%07X" % [path, 0])
+      usage
+    end
+
     def dump_index(output_directory)
       each do |object|
         next unless object.is_a?(Groonga::IndexColumn)

data/lib/groonga/dumper.rb

@@ -81,15 +81,9 @@ module Groonga
 
     private
     def dump_plugins(options)
-      plugin_paths = {}
-      options[:database].each(each_options(:order_by => :id)) do |object|
-        next unless object.is_a?(Groonga::Procedure)
-        next if object.builtin?
-        path = object.path
-        next if path.nil?
-        next if plugin_paths.has_key?(path)
-        plugin_paths[path] = true
-        dump_plugin(object, options)
+      plugin_paths = options[:database].plugin_paths
+      plugin_paths.each do |path|
+        dump_plugin(path, options)
       end
       options[:output].write("\n") unless plugin_paths.empty?
     end
@@ -112,13 +106,13 @@ module Groonga
       TableDumper.new(table, options).dump
     end
 
-    def dump_plugin(plugin, options)
+    def dump_plugin(path, options)
       output = options[:output]
       plugins_dir_re = Regexp.escape(Groonga::Plugin.system_plugins_dir)
       suffix_re = Regexp.escape(Groonga::Plugin.suffix)
-      plugin_name = plugin.path.gsub(/(?:\A#{plugins_dir_re}\/|
-                                         #{suffix_re}\z)/x,
-                                     '')
+      plugin_name = path.gsub(/(?:\A#{plugins_dir_re}\/|
+                                  #{suffix_re}\z)/x,
+                              '')
       output.write("register #{plugin_name}\n")
     end
 

data/lib/groonga/index-column.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2012  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2012-2013  Kouhei Sutou <kou@clear-code.com>
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -24,6 +24,16 @@ module Groonga
       dumper = IndexColumnDumper.new(self, output_directory)
       dumper.dump
     end
+
+    def disk_usage
+      return 0 if path.nil?
+
+      usage = super
+      chunk_path = "#{path}.c"
+      measurer = StatisticMeasurer.new
+      usage += measurer.measure_disk_usage(chunk_path)
+      usage
+    end
   end
 
   class IndexColumnDumper

data/lib/groonga/statistic-measurer.rb

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2013  Kouhei Sutou <kou@clear-code.com>
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License version 2.1 as published by the Free Software Foundation.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+module Groonga
+  # Measures statistic.
+  class StatisticMeasurer
+    MAX_N_ADDITIONAL_PATHS = 4096
+
+    # @param path [String, nil] Measures disk usage of the path.
+    # @return [Integer] 0 if path is @nil@, disk usage of the path otherwise.
+    def measure_disk_usage(path)
+      return 0 if path.nil?
+
+      usage = File.size(path)
+      1.step(MAX_N_ADDITIONAL_PATHS) do |i|
+        additional_path = "%s.%03X" % [path, i]
+        break unless File.exist?(additional_path)
+        usage += File.size(additional_path)
+      end
+      usage
+    end
+  end
+end