rroonga 1.0.1-x86-mingw32 → 1.1.0-x86-mingw32

data/lib/groonga/expression-builder.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2009-2010  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2009-2011  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
@@ -39,7 +39,7 @@ module Groonga
     end
 
     def build(&block)
-      expression = Expression.new(:name => @name)
+      expression = Expression.new(:name => @name, :context => @table.context)
       variable = expression.define_variable(:domain => @table)
       build_expression(expression, variable, &block)
     end
@@ -212,13 +212,25 @@ module Groonga
         SubExpressionBuilder.new(query, options)
       end
 
+      def prefix_search(other)
+        PrefixSearchExpressionBuilder.new(self, normalize(other))
+      end
+
+      def suffix_search(other)
+        SuffixSearchExpressionBuilder.new(self, normalize(other))
+      end
+
       private
       def normalize(other)
-        if @range.is_a?(Groonga::Table) and other.is_a?(Integer)
-          Groonga::Record.new(@range, other)
-        else
-          other
+        if @range.is_a?(Groonga::Table)
+          if other.respond_to?(:record_id)
+            id = other.record_id
+          else
+            id = other
+          end
+          return Groonga::Record.new(@range, id) if id.is_a?(Integer)
         end
+        other
       end
 
       def method_missing(name, *args, &block)
@@ -359,6 +371,18 @@ module Groonga
         expression.parse(@query, @options)
       end
     end
+
+    class PrefixSearchExpressionBuilder < BinaryExpressionBuilder # :nodoc:
+      def initialize(column_value_builder, value)
+        super(Groonga::Operation::PREFIX, column_value_builder, value)
+      end
+    end
+
+    class SuffixSearchExpressionBuilder < BinaryExpressionBuilder # :nodoc:
+      def initialize(column_value_builder, value)
+        super(Groonga::Operation::SUFFIX, column_value_builder, value)
+      end
+    end
   end
 
   class RecordExpressionBuilder # :nodoc:
@@ -414,6 +438,18 @@ module Groonga
       MatchTargetExpressionBuilder.new(build_match_target(&block))
     end
 
+    def index(name)
+      object = @table.context[name]
+      if object.nil?
+        raise ArgumentError, "unknown index column: <#{name}>"
+      end
+      if object.range != @table
+        raise ArgumentError,
+              "differenct index column: <#{name}>: #{object.inspect}"
+      end
+      column_expression_builder(object, name)
+    end
+
     private
     def build_match_target(&block)
       sub_builder = MatchTargetRecordExpressionBuilder.new(@table, nil)

data/lib/groonga/record.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2009-2010  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2009-2011  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
@@ -21,8 +21,6 @@ module Groonga
   class Record
     # レコードが所属するテーブル
     attr_reader :table
-    # レコードのID
-    attr_reader :id
     # _table_の_id_に対応するレコードを作成する。_values_には各
     # カラムに設定する値を以下のような形式で指定する。
     #
@@ -104,15 +102,22 @@ module Groonga
       column(column_name).prepend(@id, value)
     end
 
+    # call-seq:
+    #   record.support_key? -> true/false
+    #
+    # _record_が所属するテーブルで主キーを使える場合は+true+
+    # を返し、使えない場合は+false+を返す。
+    def support_key?
+      @table.support_key?
+    end
+
     # call-seq:
     #   record.have_column?(name) -> true/false
     #
     # 名前が_name_のカラムがレコードの所属するテーブルで定義され
     # ているなら+true+を返す。
     def have_column?(name)
-      column(name).is_a?(Groonga::Column)
-    rescue Groonga::NoSuchColumn
-      false
+      not @table.column(normalize_column_name(name)).nil?
     end
 
     # call-seq:
@@ -120,7 +125,36 @@ module Groonga
     #
     # 名前が_name_のカラムが参照カラムであるなら+true+を返す。
     def reference_column?(name)
-      column(name).range.is_a?(Groonga::Table)
+      column(name).reference?
+    end
+
+    # call-seq:
+    #   record.index_column?(name) -> true/false
+    #
+    # 名前が_name_のカラムが索引カラム
+    # （Groonga::IndexColumn）であるなら+true+を返す。
+    def index_column?(name)
+      column(name).index?
+    end
+
+    # call-seq:
+    #   record.vector_column?(name) -> true/false
+    #
+    # 名前が_name_のカラムの値がベクターであるなら+true+を返す。
+    #
+    # @since: 1.0.5
+    def vector_column?(name)
+      column(name).vector?
+    end
+
+    # call-seq:
+    #   record.scalar_column?(name) -> true/false
+    #
+    # 名前が_name_のカラムの値がスカラーであるなら+true+を返す。
+    #
+    # @since: 1.0.5
+    def scalar_column?(name)
+      column(name).scalar?
     end
 
     # call-seq:
@@ -141,20 +175,44 @@ module Groonga
     # _record_が所属するテーブルがGroonga:::Arrayの場合は常
     # に+nil+を返す。
     def key
-      if @table.is_a?(Groonga::Array)
+      if support_key?
+        @key ||= @table.key(@id)
+      else
         nil
+      end
+    end
+
+    # call-seq:
+    #   record.record_id -> IDまたは主キー
+    #
+    # レコードを一意に識別するための情報を返す。
+    #
+    # _record_が所属するテーブルがGroonga:::Arrayの場合はID
+    # を返し、それ以外の場合は主キーを返す。
+    def record_id
+      if support_key?
+        key
       else
-        @key ||= @table.key(@id)
+        id
       end
     end
 
+    # call-seq:
+    #   record.record_raw_id -> ID
+    #
+    # レコードのIDを返す。
+    def record_raw_id
+      @id
+    end
+    alias_method :id, :record_raw_id
+
     # call-seq:
     #   record.score -> スコア値
     #
     # レコードのスコア値を返す。検索結果として生成されたテーブル
     # のみに定義される。
     def score
-      self["._score"]
+      self["_score"]
     end
 
     # call-seq:
@@ -163,10 +221,10 @@ module Groonga
     # 主キーの値が同一であったレコードの件数を返す。検索結果とし
     # て生成されたテーブルのみに定義される。
     #
-    # Groonga::Record#support_sub_recordsでこの値を利用でき
+    # Groonga::Record#support_sub_records?でこの値を利用でき
     # るかがわかる。
     def n_sub_records
-      self["._nsubrecs"]
+      self["_nsubrecs"]
     end
 
     # call-seq:
@@ -228,8 +286,7 @@ module Groonga
     # たこのレコードのカラムの値のハッシュを返す。
     def attributes
       attributes = {"id" => id}
-      _key = key
-      attributes["key"] = _key if _key
+      attributes["key"] = key if support_key?
       table_name = @table.name
       columns.each do |column|
         next if column.is_a?(Groonga::IndexColumn)
@@ -298,6 +355,14 @@ module Groonga
       @table.locked?(options.merge(:id => @id))
     end
 
+    # call-seq:
+    #   record.valid_id? -> true/false
+    #
+    # レコードが持つIDが有効なIDであれば+true+を返す。
+    def valid_id?
+      @table.exist?(@id)
+    end
+
     def methods(include_inherited=true) # :nodoc:
       _methods = super
       return _methods unless include_inherited
@@ -314,8 +379,12 @@ module Groonga
     end
 
     private
+    def normalize_column_name(name)
+      name.to_s
+    end
+
     def column(name) # :nodoc:
-      _column = @table.column(name.to_s)
+      _column = @table.column(normalize_column_name(name))
       raise NoSuchColumn, "column(#{name.inspect}) is nil" if _column.nil?
       _column
     end

data/lib/groonga/schema.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2009-2010  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2009-2011  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
@@ -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,39 +406,78 @@ 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
 
+      NORMALIZE_TYPE_TABLE = {
+        "short_text" => "ShortText",
+        "string" => "ShortText",
+        "text" => "Text",
+        "binary" => "LongText",
+        "long_text" => "LongText",
+        "int" => "Int32",
+        "integer" => "Int32",
+        "int32" => "Int32",
+        "integer32" => "Int32",
+        "decimal" => "Int64",
+        "int64" => "Int64",
+        "integer64" => "Int64",
+        "uint" => "UInt32",
+        "unsigned_integer" => "UInt32",
+        "uint32" => "UInt32",
+        "unsigned_integer32" => "UInt32",
+        "uint64" => "UInt64",
+        "unsigned_integer64" => "UInt64",
+        "float" => "Float",
+        "datetime" => "Time",
+        "timestamp" => "Time",
+        "time" => "Time",
+        "date" => "Time",
+        "boolean" => "Bool",
+        "unigram" => "TokenUnigram",
+        "token_unigram" => "TokenUnigram",
+        "bigram" => "TokenBigram",
+        "token_bigram" => "TokenBigram",
+        "bigram_split_symbol" => "TokenBigramSplitSymbol",
+        "token_bigram_split_symbol" => "TokenBigramSplitSymbol",
+        "bigram_split_symbol_alpha" => "TokenBigramSplitSymbolAlpha",
+        "token_bigram_split_symbol_alpha" => "TokenBigramSplitSymbolAlpha",
+        "bigram_split_symbol_alpha_digit" => "TokenBigramSplitSymbolAlphaDigit",
+        "token_bigram_split_symbol_alpha_digit" =>
+          "TokenBigramSplitSymbolAlphaDigit",
+        "bigram_ignore_blank" => "TokenBigramIgnoreBlank",
+        "token_bigram_ignore_blank" => "TokenBigramIgnoreBlank",
+        "bigram_ignore_blank_split_symbol" =>
+          "TokenBigramIgnoreBlankSplitSymbol",
+        "token_bigram_ignore_blank_split_symbol" =>
+          "TokenBigramIgnoreBlankSplitSymbol",
+        "bigram_ignore_blank_split_symbol_alpha" =>
+          "TokenBigramIgnoreBlankSplitSymbolAlpha",
+        "token_bigram_ignore_blank_split_symbol_alpha" =>
+          "TokenBigramIgnoreBlankSplitSymbolAlpha",
+        "bigram_ignore_blank_split_symbol_alpha_digit" =>
+          "TokenBigramIgnoreBlankSplitSymbolAlphaDigit",
+        "token_bigram_ignore_blank_split_symbol_alpha_digit" =>
+          "TokenBigramIgnoreBlankSplitSymbolAlphaDigit",
+        "trigram" => "TokenTrigram",
+        "token_trigram" => "TokenTrigram",
+        "mecab" => "TokenMecab",
+        "token_mecab"=> "TokenMecab",
+      }
       def normalize_type(type) # :nodoc:
         return type if type.nil?
         return type if type.is_a?(Groonga::Object)
-        case type.to_s
-        when "string"
-          "ShortText"
-        when "text"
-          "Text"
-        when "int", "integer"
-          "Int32"
-        when "float"
-          "Float"
-        when "decimal"
-          "Int64"
-        when "datetime", "timestamp", "time", "date"
-          "Time"
-        when "binary"
-          "LongText"
-        when "boolean"
-          "Bool"
-        else
-          type
-        end
+        type = type.to_s if type.is_a?(Symbol)
+        NORMALIZE_TYPE_TABLE[type] || type
       end
     end
 
@@ -414,6 +490,7 @@ module Groonga
     #   省略した場合はGroonga::Context.defaultを使用する。
     def initialize(options={})
       @options = (options || {}).dup
+      @options[:context] ||= Groonga::Context.default
       @definitions = []
     end
 
@@ -424,13 +501,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 +603,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,10 +711,47 @@ 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
+
+    module Path # :nodoc:
+      def tables_directory_path(database)
+        "#{database.path}.tables"
+      end
+
+      def columns_directory_path(table)
+        "#{table.path}.columns"
+      end
+
+      def rmdir_if_dir_exists(dir)
+        begin
+          Dir.rmdir(dir)
+        rescue Errno::ENOENT
+        end
+      end
+    end
+
     # スキーマ定義時にGroonga::Schema.create_tableや
     # Groonga::Schema#create_tableからブロックに渡されてくる
     # オブジェクト
     class TableDefinition
+      include Path
+
       # テーブルの名前
       attr_reader :name
 
@@ -708,9 +832,9 @@ module Groonga
         self
       end
 
-      # 名前が_name_のカラムを削除する。
+      # 名前が_name_のカラムを削除します。
       #
-      # _options_に指定可能な値はない(TODO _options_は不要?)。
+      # _options_に指定可能な値はありません(TODO _options_は不要?)。
       #
       def remove_column(name, options={})
         definition = self[name, ColumnRemoveDefinition]
@@ -725,9 +849,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 +879,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 +1002,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 +1041,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 +1072,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 +1112,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 +1136,14 @@ module Groonga
         end
       end
 
+      def path
+        user_path = @options[:path]
+        return user_path if user_path
+        tables_dir = tables_directory_path(context.database)
+        FileUtils.mkdir_p(tables_dir)
+        File.join(tables_dir, @name)
+      end
+
       def column_options # :nodoc:
         {:persistent => persistent?}
       end
@@ -966,19 +1152,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 +1180,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,26 +1205,57 @@ 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:
+      include Path
+
       def initialize(name, options={})
         @name = name
         @options = options
       end
 
       def define
-        context = @options[:context] || Groonga::Context.default
-        context[@name].remove
+        context = @options[:context]
+        table = context[@name]
+        dir = columns_directory_path(table)
+        result = table.remove
+        rmdir_if_dir_exists(dir)
+        result
       end
     end
 
@@ -1119,6 +1346,8 @@ module Groonga
     end
 
     class ColumnDefinition # :nodoc:
+      include Path
+
       attr_accessor :name, :type
       attr_reader :options
 
@@ -1130,26 +1359,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 = columns_directory_path(table)
+        FileUtils.mkdir_p(columns_dir)
+        File.join(columns_dir, @name)
       end
     end
 
@@ -1164,12 +1418,35 @@ 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
+      include Path
+
+      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 +1454,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
+        nonexistent_columns = nonexistent_columns(target_table)
+        unless nonexistent_columns.empty?
+          raise UnknownIndexTarget.new(target_table, nonexistent_columns)
         end
-        index = table.column(@name)
+        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 +1544,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 +1600,80 @@ 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}"
+            if table.normalize_key?
+              parameters << ":key_normalize => true"
+            end
+          end
+          default_tokenizer = table.default_tokenizer
+          if default_tokenizer
+            parameters << ":default_tokenizer => #{default_tokenizer.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