rroonga 1.0.1 → 1.0.2

data/lib/groonga/schema.rb

@@ -15,6 +15,7 @@
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
+require 'fileutils'
 
 module Groonga
 
@@ -80,12 +81,22 @@ module Groonga
       end
     end
 
+    # 未知のインデックス対象テーブルを指定したときに発生する。
+    class UnknownIndexTargetTable < Error
+      attr_reader :table
+      def initialize(table)
+        @table = table
+        super("unknown index target table: <#{@table.inspect}>")
+      end
+    end
+
     # 未知のインデックス対象を指定したときに発生する。
     class UnknownIndexTarget < Error
-      attr_reader :target_name
-      def initialize(target_name)
-        @target_name = target_name
-        super("unknown index target: <#{@target_name}>")
+      attr_reader :table, :targets
+      def initialize(table, targets)
+        @table = table
+        @targets = targets
+        super("unknown index target: <#{@table.inspect}>: <#{@targets.inspect}>")
       end
     end
 
@@ -96,7 +107,7 @@ module Groonga
         @options = options
         @unknown_keys = unknown_keys
         @available_keys = available_keys
-        message = "unknown keys are specified: #{u@nknown_keys.inspect}"
+        message = "unknown keys are specified: #{@unknown_keys.inspect}"
         message << ": available keys: #{@available_keys.inspect}"
         message << ": options: #{@options.inspect}"
         super(message)
@@ -114,6 +125,18 @@ module Groonga
       end
     end
 
+    # 参照先のテーブルを推測できないときに発生する。
+    class UnguessableReferenceTable < Error
+      attr_reader :name, :tried_table_names
+      def initialize(name, tried_table_names)
+        @name = name
+        @tried_table_names = tried_table_names
+        super("failed to guess referenced table name " +
+              "for reference column: #{@name.inspect}: " +
+              "tried table names: #{@tried_table_names.inspect}")
+      end
+    end
+
     class << self
 
       # call-seq:
@@ -349,6 +372,20 @@ module Groonga
         end
       end
 
+      # call-seq:
+      #   Groonga::Schema.remove_column(table_name, column_name)
+      #
+      # 以下と同様:
+      #
+      #   Groonga::Schema.change_table(table_name) do |table|
+      #     table.remove_column(column_name)
+      #   end
+      def remove_column(table_name, column_name)
+        change_table(table_name) do |table|
+          table.remove_column(column_name)
+        end
+      end
+
       # スキーマの内容を文字列で返す。返された値は
       # Groonga::Schema.restoreすることによりスキーマ内に組
       # み込むことができる。
@@ -369,13 +406,15 @@ module Groonga
       #   スキーマ定義時に使用するGroonga::Contextを指定する。
       #   省略した場合はGroonga::Context.defaultを使用する。
       def dump(options={})
-        Dumper.new(options).dump
+        options = options.dup
+        schema = new(:context => options.delete(:context))
+        schema.dump
       end
 
       # Groonga::Schema.dumpで文字列化したスキーマを組み込む。
       def restore(dumped_text, options={})
         define(options) do |schema|
-          schema.load(dumped_text)
+          schema.restore(dumped_text)
 	end
       end
 
@@ -414,6 +453,7 @@ module Groonga
     #   省略した場合はGroonga::Context.defaultを使用する。
     def initialize(options={})
       @options = (options || {}).dup
+      @options[:context] ||= Groonga::Context.default
       @definitions = []
     end
 
@@ -424,13 +464,23 @@ module Groonga
       end
     end
 
-    # Groonga::Schema.dumpで返されたスキーマの内容を読み込む。
+    # Groonga::Schema#dumpで返されたスキーマの内容を読み込む。
     #
     # 読み込まれた内容は#defineを呼び出すまでは実行されない
     # ことに注意すること。
-    def load(dumped_text)
+    def restore(dumped_text)
       instance_eval(dumped_text)
     end
+    # for backward compatibility.
+    # TODO: remove this at the next major release.
+    alias_method :load, :restore
+
+    # スキーマの内容を文字列で返す。返された値は
+    # Groonga::Schema#restoreすることによりスキーマ内に組み込むことができる。
+    def dump
+      dumper = Dumper.new(:context => @options[:context])
+      dumper.dump
+    end
 
     # call-seq:
     #   schema.create_table(name, options={}) {|table| ...}
@@ -516,7 +566,7 @@ module Groonga
     #   登録される。
     def create_table(name, options={})
       definition = TableDefinition.new(name, @options.merge(options || {}))
-      yield(definition)
+      yield(definition) if block_given?
       @definitions << definition
     end
 
@@ -624,6 +674,24 @@ module Groonga
       @definitions << definition
     end
 
+    # call-seq:
+    #   schema.remove_column(table_name, column_name)
+    #
+    # 以下と同様:
+    #
+    #   schema.change_table(table_name) do |table|
+    #     table.remove_column(column_name)
+    #   end
+    def remove_column(table_name, column_name)
+      change_table(table_name) do |table|
+        table.remove_column(column_name)
+      end
+    end
+
+    def context # :nodoc:
+      @options[:context] || Groonga::Context.default
+    end
+
     # スキーマ定義時にGroonga::Schema.create_tableや
     # Groonga::Schema#create_tableからブロックに渡されてくる
     # オブジェクト
@@ -708,9 +776,9 @@ module Groonga
         self
       end
 
-      # 名前が_name_のカラムを削除する。
+      # 名前が_name_のカラムを削除します。
       #
-      # _options_に指定可能な値はない(TODO _options_は不要?)。
+      # _options_に指定可能な値はありません(TODO _options_は不要?)。
       #
       def remove_column(name, options={})
         definition = self[name, ColumnRemoveDefinition]
@@ -725,9 +793,11 @@ module Groonga
       # call-seq:
       #   table.index(target_column_full_name, options={})
       #   table.index(target_table, target_column, options={})
+      #   table.index(target_table, target_column1, target_column2, ..., options={})
       #
-      # _target_table_の_target_column_を対象とするインデッ
-      # クスカラムを作成する。
+      # _target_table_の_target_column_を対象とするインデック
+      # スカラムを作成します。複数のカラムを指定することもで
+      # きます。
       #
       # _target_column_full_name_で指定するときはテーブル名
       # とカラム名を"."でつなげます。例えば、「Users」テーブ
@@ -753,31 +823,71 @@ module Groonga
       #   した場合は自動的にパスが付加される。
       #
       # [+:with_section+]
-      #   転置索引にsection(段落情報)を合わせて格納する。
+      #   +true+を指定すると転置索引にsection(段落情報)を合
+      #   わせて格納する。未指定または+nil+を指定した場合、
+      #   複数のカラムを指定すると自動的に有効になる。
       #
       # [+:with_weight+]
-      #   転置索引にweight情報を合わせて格納する。
+      #   +true+を指定すると転置索引にweight情報を合わせて格
+      #   納する。
       #
       # [+:with_position+]
-      #   転置索引に出現位置情報を合わせて格納する。
+      #   +true+を指定すると転置索引に出現位置情報を合わせて
+      #   格納する。未指定または+nil+を指定した場合、テーブ
+      #   ルがN-gram系のトークナイザーを利用している場合は自
+      #   動的に有効になる。
       def index(target_table_or_target_column_full_name, *args)
-        if args.size > 2
-          n_args = args.size + 1
-          raise ArgumentError, "wrong number of arguments (#{n_args} for 2 or 3)"
+        key, target_table, target_columns, options =
+          parse_index_argument(target_table_or_target_column_full_name, *args)
+
+        name = options.delete(:name)
+        definition = self[key, IndexColumnDefinition]
+        if definition.nil?
+          definition = IndexColumnDefinition.new(name, options)
+          update_definition(key, IndexColumnDefinition, definition)
         end
-        options = nil
-        options = args.pop if args.last.is_a?(::Hash)
-        if args.empty?
-          target_column_full_name = target_table_or_target_column_full_name
-          if target_column_full_name.is_a?(Groonga::Column)
-            target_column_full_name = target_column_full_name.name
-          end
-          target_table, target_column = target_column_full_name.split(/\./, 2)
-        else
-          target_table = target_table_or_target_column_full_name
-          target_column = args.pop
+        definition.target_table = target_table
+        definition.target_columns = target_columns
+        definition.options.merge!(column_options.merge(options))
+        self
+      end
+
+      # call-seq:
+      #   table.remove_index(target_column_full_name, options={})
+      #   table.remove_index(target_table, target_column, options={})
+      #   table.remove_index(target_table, target_column1, target_column2, ..., options={})
+      #
+      # _target_table_の_target_column_を対象とするインデッ
+      # クスカラムを削除します。
+      #
+      # _target_column_full_name_で指定するときはテーブル名
+      # とカラム名を"."でつなげます。例えば、「Users」テーブ
+      # ルの「name」カラムのインデックスカラムを削除する場合
+      # はこうなります。
+      #
+      #   table.remove_index("Users.name")
+      #
+      # _options_に指定可能な値は以下の通り。
+      #
+      # [+:name+]
+      #   インデックスカラムのカラム名を任意に指定する。
+      def remove_index(target_table_or_target_column_full_name, *args)
+        key, target_table, target_columns, options =
+          parse_index_argument(target_table_or_target_column_full_name, *args)
+
+        name = options.delete(:name)
+        name ||= lambda do |context|
+          IndexColumnDefinition.column_name(context,
+                                            target_table,
+                                            target_columns)
+        end
+        definition = self[key, ColumnRemoveDefinition]
+        if definition.nil?
+          definition = ColumnRemoveDefinition.new(name, options)
+          update_definition(key, ColumnRemoveDefinition, definition)
         end
-        define_index(target_table, target_column, options || {})
+        definition.options.merge!(options)
+        self
       end
 
       # 名前が_name_の32bit符号付き整数のカラムを作成する。
@@ -836,6 +946,14 @@ module Groonga
         column(name, "Time", options)
       end
 
+      # 以下と同様:
+      #   table.time("updated_at")
+      #   table.time("created_at")
+      def timestamps(options={})
+        time("created_at", options)
+        time("updated_at", options)
+      end
+
       # 名前が_name_の4Kbyte以下の文字列を格納できるカラムを
       # 作成する。
       #
@@ -867,9 +985,13 @@ module Groonga
       # 名前が_name_で_table_のレコードIDを格納する参照カラ
       # ムを作成する。
       #
+      # _table_が省略された場合は_name_の複数形が使われる。
+      # 例えば、_name_が"user"な場合は_table_は"users"になる。
+      #
       # _options_に指定可能な値は
       # Groonga::Schema::TableDefinition#columnを参照。
-      def reference(name, table, options={})
+      def reference(name, table=nil, options={})
+        table ||= lambda {|context| guess_table_name(context, name)}
         column(name, table, options)
       end
 
@@ -894,8 +1016,8 @@ module Groonga
       end
 
       private
-      def update_definition(name, definition_class, definition) # :nodoc:
-        old_definition = self[name, definition_class]
+      def update_definition(key, definition_class, definition) # :nodoc:
+        old_definition = self[key, definition_class]
         if old_definition
           index = @definitions.index(old_definition)
           @definitions[index] = definition
@@ -934,14 +1056,14 @@ module Groonga
       def create_options # :nodoc:
         common = {
           :name => @name,
-          :path => @options[:path],
+          :path => path,
           :persistent => persistent?,
           :value_type => @options[:value_type],
           :context => context,
           :sub_records => @options[:sub_records],
         }
         key_support_table_common = {
-          :key_type => Schema.normalize_type(@options[:key_type]),
+          :key_type => normalize_key_type(@options[:key_type] || "ShortText"),
           :key_normalize => @options[:key_normalize],
           :default_tokenizer => @options[:default_tokenizer],
         }
@@ -958,6 +1080,14 @@ module Groonga
         end
       end
 
+      def path
+        user_path = @options[:path]
+        return user_path if user_path
+        tables_dir = "#{context.database.path}.tables"
+        FileUtils.mkdir_p(tables_dir)
+        File.join(tables_dir, @name)
+      end
+
       def column_options # :nodoc:
         {:persistent => persistent?}
       end
@@ -966,19 +1096,26 @@ module Groonga
         @options[:persistent].nil? ? true : @options[:persistent]
       end
 
-      def define_index(target_table, target_column, options)
-        name = options.delete(:name)
-        name ||= "#{target_table}_#{target_column}".gsub(/\./, "_")
-
-        definition = self[name, IndexColumnDefinition]
-        if definition.nil?
-          definition = IndexColumnDefinition.new(name, options)
-          update_definition(name, IndexColumnDefinition, definition)
+      def parse_index_argument(target_table_or_target_column_full_name, *args)
+        options = nil
+        options = args.pop if args.last.is_a?(::Hash)
+        if args.empty?
+          target_column_full_name = target_table_or_target_column_full_name
+          if target_column_full_name.is_a?(Groonga::Column)
+            target_column_full_name = target_column_full_name.name
+          end
+          target_table, target_column = target_column_full_name.split(/\./, 2)
+          target_columns = [target_column]
+          key = [target_table, target_columns]
+        else
+          target_table_name = target_table_or_target_column_full_name
+          target_table = lambda do |context|
+            guess_table_name(context, target_table_name)
+          end
+          target_columns = args
+          key = [target_table_name, target_columns]
         end
-        definition.target_table = target_table
-        definition.target_column = target_column
-        definition.options.merge!(column_options.merge(options))
-        self
+        [key, target_table, target_columns, options || {}]
       end
 
       def same_table?(table, options)
@@ -987,12 +1124,15 @@ module Groonga
         sub_records = options[:sub_records]
         sub_records = false if sub_records.nil?
         return false unless table.support_sub_records? == sub_records
+        path = options[:path]
+        return false if path and table.path != path
 
         case table
         when Groonga::Array
           true
         when Groonga::Hash, Groonga::PatriciaTrie
-          return false unless table.domain == resolve_name(options[:key_type])
+          key_type = normalize_key_type(options[:key_type])
+          return false unless table.domain == resolve_name(key_type)
           default_tokenizer = resolve_name(options[:default_tokenizer])
           return false unless table.default_tokenizer == default_tokenizer
           key_normalize = options[:key_normalize]
@@ -1009,15 +1149,40 @@ module Groonga
         end
       end
 
+      def normalize_key_type(key_type)
+        Schema.normalize_type(key_type || "ShortText")
+      end
+
       def resolve_name(type)
-        if type.nil?
-          nil
-        elsif type.is_a?(String)
+        if type.is_a?(String)
           context[type]
         else
           type
         end
       end
+
+      def guess_table_name(context, name)
+        original_name = name
+        name = name.to_s
+        candidate_names = [name]
+        if name.respond_to?(:pluralize)
+          pluralized_name = name.pluralize
+        else
+          pluralized_name = "#{name}s"
+        end
+        candidate_names << pluralized_name
+        if pluralized_name.respond_to?(:camelize)
+          candidate_names << pluralized_name.camelize
+        else
+          candidate_names << pluralized_name.split(/_/).collect do |word|
+            word.capitalize
+          end.join
+        end
+        candidate_names.each do |table_name|
+          return table_name if context[table_name]
+        end
+        raise UnguessableReferenceTable.new(original_name, candidate_names)
+      end
     end
 
     class TableRemoveDefinition # :nodoc:
@@ -1027,7 +1192,7 @@ module Groonga
       end
 
       def define
-        context = @options[:context] || Groonga::Context.default
+        context = @options[:context]
         context[@name].remove
       end
     end
@@ -1130,26 +1295,51 @@ module Groonga
       end
 
       def define(table_definition, table)
+        context = table_definition.context
         column = table.column(@name)
+        options = define_options(context, table)
         if column
-          return column if same_column?(table_definition, column)
-          if @options.delete(:force)
+          return column if same_column?(context, column)
+          if @options[:force]
             column.remove
           else
-            options = @options.merge(:type => @type)
             raise ColumnCreationWithDifferentOptions.new(column, options)
           end
         end
         table.define_column(@name,
-                            Schema.normalize_type(@type),
-                            @options)
+                            normalize_type(context),
+                            options)
       end
 
       private
-      def same_column?(table_definition, column)
-        context = table_definition.context
+      def normalize_type(context)
+        if @type.respond_to?(:call)
+          resolved_type = @type.call(context)
+        else
+          resolved_type = @type
+        end
+        Schema.normalize_type(resolved_type)
+      end
+
+      def same_column?(context, column)
         # TODO: should check column type and other options.
-        column.range == context[Schema.normalize_type(@type)]
+        column.range == context[normalize_type(context)]
+      end
+
+      def define_options(context, table)
+        {
+          :path => path(context, table),
+          :type => @options[:type],
+          :compress => @options[:compress],
+        }
+      end
+
+      def path(context, table)
+        user_path = @options[:path]
+        return user_path if user_path
+        columns_dir = "#{table.path}.columns"
+        FileUtils.mkdir_p(columns_dir)
+        File.join(columns_dir, @name)
       end
     end
 
@@ -1164,12 +1354,33 @@ module Groonga
       end
 
       def define(table_definition, table)
-        table.column(@name).remove
+        if @name.respond_to?(:call)
+          name = @name.call(table_definition.context)
+        else
+          name = @name
+        end
+        table.column(name).remove
       end
     end
 
     class IndexColumnDefinition # :nodoc:
-      attr_accessor :name, :target_table, :target_column
+      class << self
+        def column_name(context, target_table, target_columns)
+          target_table = resolve(context, target_table)
+          "#{target_table.name}_#{target_columns.join('_')}"
+        end
+
+        def resolve(context, object)
+          return object if object.is_a?(Groonga::Object)
+          if object.respond_to?(:call)
+            object = object.call(context)
+          end
+          return nil if object.nil?
+          context[object]
+        end
+      end
+
+      attr_accessor :name, :target_table, :target_columns
       attr_reader :options
 
       def initialize(name, options={})
@@ -1177,48 +1388,83 @@ module Groonga
         @name = @name.to_s if @name.is_a?(Symbol)
         @options = (options || {}).dup
         @target_table = nil
-        @target_column = nil
+        @target_columns = nil
       end
 
       def define(table_definition, table)
-        target_name = "#{@target_table}.#{@target_column}"
-        target_table = table_definition.context[@target_table]
-        if target_table.nil? or
-            !(@target_column == "_key" or
-              target_table.have_column?(@target_column))
-          raise UnknownIndexTarget.new(target_name)
+        context = table_definition.context
+        target_table = resolve_target_table(context)
+        if target_table.nil?
+          raise UnknownIndexTargetTable.new(@target_table)
         end
-        index = table.column(@name)
+        nonexistent_columns = nonexistent_columns(target_table)
+        unless nonexistent_columns.empty?
+          raise UnknownIndexTarget.new(target_table, nonexistent_columns)
+        end
+        name = @name || self.class.column_name(context,
+                                               target_table,
+                                               @target_columns)
+        index = table.column(name)
         if index
-          return index if same_index?(table_definition, index)
-          if @options.delete(:force)
+          return index if same_index?(context, index, target_table)
+          if @options[:force]
             index.remove
           else
             options = @options.merge(:type => :index,
-                                     :target_name => target_name)
+                                     :target_table => target_table,
+                                     :target_columns => @target_columns)
             raise ColumnCreationWithDifferentOptions.new(index, options)
           end
         end
-        index = table.define_index_column(@name,
-                                          @target_table,
-                                          @options)
-        index.source = target_table.column(@target_column)
+        index = table.define_index_column(name,
+                                          target_table,
+                                          define_options(context, table, name))
+        index.sources = @target_columns.collect do |column|
+          target_table.column(column)
+        end
         index
       end
 
       private
-      def same_index?(table_definition, index)
-        context = table_definition.context
+      def same_index?(context, index, target_table)
         # TODO: should check column type and other options.
-        return false if index.range.name != @target_table
+        range = index.range
+        return false if range != target_table
         source_names = index.sources.collect do |source|
-          if source == index
-            "#{index.range.name}._key"
+          if source == range
+            "_key"
           else
-            source.name
+            source.local_name
           end
         end
-        source_names == ["#{@target_table}.#{@target_column}"]
+        source_names.sort == @target_columns.sort
+      end
+
+      def nonexistent_columns(target_table)
+        @target_columns.reject do |column|
+          column == "_key" or target_table.have_column?(column)
+        end
+      end
+
+      def resolve_target_table(context)
+        self.class.resolve(context, @target_table)
+      end
+
+      def define_options(context, table, name)
+        {
+          :path => path(context, table, name),
+          :with_section => @options[:with_section],
+          :with_weight => @options[:with_weight],
+          :with_position => @options[:with_position],
+        }
+      end
+
+      def path(context, table, name)
+        user_path = @options[:path]
+        return user_path if user_path
+        columns_dir = "#{table.path}.columns"
+        FileUtils.mkdir_p(columns_dir)
+        File.join(columns_dir, name)
       end
     end
 
@@ -1232,35 +1478,51 @@ module Groonga
         database = context.database
         return nil if database.nil?
 
+        header + dump_schema(database) + footer
+      end
+
+      def dump_schema(database)
+        index_columns = []
         reference_columns = []
         definitions = []
         database.each do |object|
           next unless object.is_a?(Groonga::Table)
-          schema = "create_table(#{object.name.inspect}) do |table|\n"
-          object.columns.sort_by {|column| column.local_name}.each do |column|
-            if column.range.is_a?(Groonga::Table)
-              reference_columns << column
+          table = object
+          schema = create_table_header(table)
+          table.columns.sort_by {|column| column.local_name}.each do |column|
+            if column.is_a?(Groonga::IndexColumn)
+              index_columns << column
             else
-              type = column_method(column)
-              name = column.local_name
-              schema << "  table.#{type}(#{name.inspect})\n"
+              if column.range.is_a?(Groonga::Table)
+                reference_columns << column
+              else
+                schema << define_column(table, column)
+              end
             end
           end
-          schema << "end"
+          schema << create_table_footer(table)
           definitions << schema
         end
 
         reference_columns.group_by do |column|
           column.table
         end.each do |table, columns|
-          schema = "change_table(#{table.name.inspect}) do |table|\n"
+          schema = change_table_header(table)
           columns.each do |column|
-            name = column.local_name
-            reference = column.range
-            schema << "  table.reference(#{name.inspect}, " +
-                                        "#{reference.name.inspect})\n"
+            schema << define_reference_column(table, column)
           end
-          schema << "end"
+          schema << change_table_footer(table)
+          definitions << schema
+        end
+
+        index_columns.group_by do |column|
+          column.table
+        end.each do |table, columns|
+          schema = change_table_header(table)
+          columns.each do |column|
+            schema << define_index_column(table, column)
+          end
+          schema << change_table_footer(table)
           definitions << schema
         end
 
@@ -1272,6 +1534,73 @@ module Groonga
       end
 
       private
+      def header
+        ""
+      end
+
+      def footer
+        ""
+      end
+
+      def create_table_header(table)
+        parameters = []
+        unless table.is_a?(Groonga::Array)
+          case table
+          when Groonga::Hash
+            parameters << ":type => :hash"
+          when Groonga::PatriciaTrie
+            parameters << ":type => :patricia_trie"
+          end
+          if table.domain
+            parameters << ":key_type => #{table.domain.name.dump}"
+          end
+        end
+        parameters << ":force => true"
+        parameters.unshift("")
+        parameters = parameters.join(",\n             ")
+        "create_table(#{table.name.dump}#{parameters}) do |table|\n"
+      end
+
+      def create_table_footer(table)
+        "end"
+      end
+
+      def change_table_header(table)
+        "change_table(#{table.name.inspect}) do |table|\n"
+      end
+
+      def change_table_footer(table)
+        "end"
+      end
+
+      def define_column(table, column)
+        type = column_method(column)
+        name = column.local_name
+        "  table.#{type}(#{name.inspect})\n"
+      end
+
+      def define_reference_column(table, column)
+        name = column.local_name
+        reference = column.range
+        "  table.reference(#{name.dump}, #{reference.name.dump})\n"
+      end
+
+      def define_index_column(table, column)
+        target_table_name = column.range.name
+        sources = column.sources
+        source_names = sources.collect do |source|
+          if source.is_a?(table.class)
+            "_key".dump
+          else
+            source.local_name.dump
+          end
+        end.join(", ")
+        arguments = [target_table_name.dump,
+                     sources.size == 1 ? source_names : "[#{source_names}]",
+                     ":name => #{column.local_name.dump}"]
+        "  table.index(#{arguments.join(', ')})\n"
+      end
+
       def column_method(column)
         range = column.range
         case range.name