rroonga 1.2.9 → 1.3.0

data/test/test-patricia-trie.rb

@@ -42,11 +42,11 @@ class PatriciaTrieTest < Test::Unit::TestCase
 
   def test_search
     users = Groonga::Array.create(:name => "Users")
-    user_name = users.define_column("name", "ShortText")
+    users.define_column("name", "ShortText")
 
     bookmarks = Groonga::PatriciaTrie.create(:name => "Bookmarks",
                                              :key_type => "ShortText")
-    bookmark_user_id = bookmarks.define_column("user_id", users)
+    bookmarks.define_column("user_id", users)
 
     daijiro = users.add
     daijiro["name"] = "daijiro"
@@ -187,10 +187,10 @@ class PatriciaTrieTest < Test::Unit::TestCase
   def test_prefix_search
     paths = Groonga::PatriciaTrie.create(:name => "Paths",
                                          :key_type => 'ShortText')
-    root_path = paths.add('/')
-    tmp_path = paths.add('/tmp')
-    usr_bin_path = paths.add('/usr/bin')
-    usr_local_bin_path = paths.add('/usr/local/bin')
+    paths.add('/')
+    paths.add('/tmp')
+    paths.add('/usr/bin')
+    paths.add('/usr/local/bin')
 
     records = paths.prefix_search('/')
     assert_equal(["/usr/local/bin", "/usr/bin", "/tmp", "/"],
@@ -213,10 +213,10 @@ class PatriciaTrieTest < Test::Unit::TestCase
   def test_prefix_cursor
     paths = Groonga::PatriciaTrie.create(:name => "Paths",
                                          :key_type => 'ShortText')
-    root_path = paths.add('/')
-    tmp_path = paths.add('/tmp')
-    usr_bin_path = paths.add('/usr/bin')
-    usr_local_bin_path = paths.add('/usr/local/bin')
+    paths.add('/')
+    paths.add('/tmp')
+    paths.add('/usr/bin')
+    paths.add('/usr/local/bin')
 
     assert_prefix_cursor(["/usr/local/bin", "/usr/bin", "/tmp", "/"],
                          paths, "/", {:order => :desc})
@@ -388,4 +388,28 @@ class PatriciaTrieTest < Test::Unit::TestCase
     bob_again = users.add("bob")
     assert_not_predicate(bob_again, :added?)
   end
+
+  def test_defrag
+    users = Groonga::PatriciaTrie.create(:name => "Users",
+                                         :key_type => "ShortText")
+    users.define_column("name", "ShortText")
+    users.define_column("address", "ShortText")
+    1000.times do |i|
+      users.add("user #{i}",
+                :name => "user #{i}" * 1000,
+                :address => "address #{i}" * 1000)
+    end
+    assert_equal(7, users.defrag)
+  end
+
+  def test_rename
+    users = Groonga::PatriciaTrie.create(:name => "Users",
+                                         :key_type => "ShortText")
+    name = users.define_column("name", "ShortText")
+    address = users.define_column("address", "ShortText")
+
+    users.rename("People")
+    assert_equal(["People", "People.name", "People.address"],
+                 [users.name, name.name, address.name])
+  end
 end

data/test/test-query-log.rb

@@ -0,0 +1,258 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 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
+# 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
+
+require "cgi"
+
+module QueryLogTest
+  module CommandParseTestUtils
+    private
+    def command(name, parameters)
+      Groonga::QueryLog::Command.new(name, parameters)
+    end
+
+    def parse_http_path(command, parameters)
+      path = "/d/#{command}.json"
+      unless parameters.empty?
+        uri_parameters = parameters.collect do |key, value|
+          [CGI.escape(key.to_s), CGI.escape(value.to_s)].join("=")
+        end
+        path << "?"
+        path << uri_parameters.join("&")
+      end
+      Groonga::QueryLog::Command.parse(path)
+    end
+
+    def parse_command_line(command, parameters)
+      command_line = "#{command} --output_type json"
+      parameters.each do |key, value|
+        if /"| / =~ value
+          escaped_value = '"' + value.gsub(/"/, '\"') + '"'
+        else
+          escaped_value = value
+        end
+        command_line << " --#{key} #{escaped_value}"
+      end
+      Groonga::QueryLog::Command.parse(command_line)
+    end
+  end
+
+  module HTTPCommandParseTestUtils
+    private
+    def parse(command, parameters={})
+      parse_http_path(command, parameters)
+    end
+  end
+
+  module CommandLineCommandParseTestUtils
+    private
+    def parse(command, parameters={})
+      parse_command_line(command, parameters)
+    end
+  end
+
+  module SelectCommandParseTests
+    include CommandParseTestUtils
+
+    def test_parameters
+      select = parse("select",
+                     :table => "Users",
+                     :filter => "age<=30")
+      assert_equal(command("select",
+                           "table" => "Users",
+                           "filter" => "age<=30",
+                           "output_type" => "json"),
+                   select)
+    end
+
+    def test_scorer
+      select = parse("select",
+                     :table => "Users",
+                     :filter => "age<=30",
+                     :scorer => "_score = random()")
+      assert_equal("_score = random()", select.scorer)
+    end
+
+    def test_to_uri_format
+      select = parse("select",
+                     :table => "Users",
+                     :filter => "age<=30")
+      assert_equal("/d/select.json?filter=age%3C%3D30&table=Users",
+                   select.to_uri_format)
+    end
+
+    def test_to_command_format
+      select = parse("select",
+                     :table => "Users",
+                     :filter => "age<=30")
+      assert_equal("select --filter \"age<=30\" " +
+                   "--output_type \"json\" --table \"Users\"",
+                   select.to_command_format)
+    end
+  end
+
+  module SelectCommandParseFilterTests
+    include CommandParseTestUtils
+
+    def test_parenthesis
+      filter = 'geo_in_rectangle(location,' +
+                                '"35.73360x139.7394","62614x139.7714") && ' +
+               '((type == "たいやき" || type == "和菓子")) && ' +
+               'keyword @ "たいやき" &! keyword @ "白" &! keyword @ "養殖"'
+      select = parse("select",
+                     :table => "Users",
+                     :filter => filter)
+      assert_equal(['geo_in_rectangle(location,' +
+                                     '"35.73360x139.7394","62614x139.7714")',
+                     'type == "たいやき"',
+                     'type == "和菓子"',
+                     'keyword @ "たいやき"',
+                     'keyword @ "白"',
+                     'keyword @ "養殖"'],
+                   select.conditions)
+    end
+
+    def test_to_uri_format
+      filter = 'geo_in_rectangle(location,' +
+                                '"35.73360x139.7394","62614x139.7714") && ' +
+               '((type == "たいやき" || type == "和菓子")) && ' +
+               'keyword @ "たいやき" &! keyword @ "白" &! keyword @ "養殖"'
+      select = parse("select",
+                     :table => "Users",
+                     :filter => filter)
+      assert_equal("/d/select.json?filter=geo_in_rectangle%28location%2C" +
+                   "%2235.73360x139.7394%22%2C%2262614x139.7714%22%29+" +
+                   "%26%26+%28%28type+" +
+                   "%3D%3D+%22%E3%81%9F%E3%81%84%E3%82%84%E3%81%8D%22+" +
+                   "%7C%7C+type+%3D%3D+" +
+                   "%22%E5%92%8C%E8%8F%93%E5%AD%90%22%29%29+" +
+                   "%26%26+keyword+%40+" +
+                   "%22%E3%81%9F%E3%81%84%E3%82%84%E3%81%8D%22+%26%21+" +
+                   "keyword+%40+%22%E7%99%BD%22+%26%21+" +
+                   "keyword+%40+%22%E9%A4%8A%E6%AE%96%22&table=Users",
+                   select.to_uri_format)
+    end
+
+    def test_to_command_format
+      filter = 'geo_in_rectangle(location,' +
+                                '"35.73360x139.7394","62614x139.7714") && ' +
+               '((type == "たいやき" || type == "和菓子")) && ' +
+               'keyword @ "たいやき" &! keyword @ "白" &! keyword @ "養殖"'
+      select = parse("select",
+                     :table => "Users",
+                     :filter => filter)
+      assert_equal("select " +
+                   "--filter " +
+                     "\"geo_in_rectangle(location," +
+                     "\\\"35.73360x139.7394\\\",\\\"62614x139.7714\\\") && " +
+                     "((type == \\\"たいやき\\\" || " +
+                       "type == \\\"和菓子\\\")) && " +
+                     "keyword @ \\\"たいやき\\\" &! keyword @ \\\"白\\\" &! " +
+                     "keyword @ \\\"養殖\\\"\" " +
+                   "--output_type \"json\" --table \"Users\"",
+                   select.to_command_format)
+    end
+  end
+
+  class HTTPSelectCommandParseTest < Test::Unit::TestCase
+    include SelectCommandParseTests
+    include SelectCommandParseFilterTests
+    include HTTPCommandParseTestUtils
+
+    def test_uri_format?
+      command = parse("status")
+      assert_predicate(command, :uri_format?)
+    end
+
+    def test_command_format?
+      command = parse("status")
+      assert_not_predicate(command, :command_format?)
+    end
+  end
+
+  class CommandLineSelecCommandParseTest < Test::Unit::TestCase
+    include SelectCommandParseTests
+    include SelectCommandParseFilterTests
+    include CommandLineCommandParseTestUtils
+
+    def test_uri_format?
+      command = parse("status")
+      assert_not_predicate(command, :uri_format?)
+    end
+
+    def test_command_format?
+      command = parse("status")
+      assert_predicate(command, :command_format?)
+    end
+  end
+
+  class StatisticOperationParseTest < Test::Unit::TestCase
+    def test_context
+      operations = statistics.first.operations.collect do |operation|
+        [operation[:name], operation[:context]]
+      end
+      expected = [
+        ["filter", "local_name @ \"gsub\""],
+        ["filter", "description @ \"string\""],
+        ["select", nil],
+        ["sort", "_score"],
+        ["output", "_key"],
+        ["drilldown", "name"],
+        ["drilldown", "class"],
+      ]
+      assert_equal(expected, operations)
+    end
+
+    def test_n_records
+      operations = statistics.first.operations.collect do |operation|
+        [operation[:name], operation[:n_records]]
+      end
+      expected = [
+        ["filter", 15],
+        ["filter", 13],
+        ["select", 13],
+        ["sort", 10],
+        ["output", 10],
+        ["drilldown", 3],
+        ["drilldown", 2],
+      ]
+      assert_equal(expected, operations)
+    end
+
+    private
+    def log
+      <<-EOL
+2011-06-02 16:27:04.731685|5091e5c0|>/d/select.join?table=Entries&filter=local_name+%40+%22gsub%22+%26%26+description+%40+%22string%22&sortby=_score&output_columns=_key&drilldown=name,class
+2011-06-02 16:27:04.733539|5091e5c0|:000000001849451 filter(15)
+2011-06-02 16:27:04.734978|5091e5c0|:000000003293459 filter(13)
+2011-06-02 16:27:04.735012|5091e5c0|:000000003327415 select(13)
+2011-06-02 16:27:04.735096|5091e5c0|:000000003411824 sort(10)
+2011-06-02 16:27:04.735232|5091e5c0|:000000003547265 output(10)
+2011-06-02 16:27:04.735606|5091e5c0|:000000003921419 drilldown(3)
+2011-06-02 16:27:04.735762|5091e5c0|:000000004077552 drilldown(2)
+2011-06-02 16:27:04.735808|5091e5c0|<000000004123726 rc=0
+EOL
+    end
+
+    def statistics
+      statistics = []
+      parser = Groonga::QueryLog::Parser.new
+      parser.parse(StringIO.new(log)) do |statistic|
+        statistics << statistic
+      end
+      statistics
+    end
+  end
+end

data/test/test-record.rb

@@ -168,12 +168,13 @@ class RecordTest < Test::Unit::TestCase
   end
 
   def test_delete
-    bookmark1 = @bookmarks.add
-    bookmark2 = @bookmarks.add
-    bookmark3 = @bookmarks.add
+    bookmark_records = []
+    bookmark_records << @bookmarks.add
+    bookmark_records << @bookmarks.add
+    bookmark_records << @bookmarks.add
 
     assert_equal(3, @bookmarks.size)
-    bookmark2.delete
+    bookmark_records[1].delete
     assert_equal(2, @bookmarks.size)
   end
 
@@ -375,7 +376,7 @@ class RecordTest < Test::Unit::TestCase
   end
 
   def test_select_result_attributes
-    top_page_record = @bookmarks.add(top_page)
+    @bookmarks.add(top_page)
     select_result = @bookmarks.select
     select_result_result = select_result.first
 

data/test/test-schema-create-table.rb

@@ -102,6 +102,14 @@ module SchemaCreateTableTests
   def test_default_path
     Groonga::Schema.create_table("Posts", options) do |table|
     end
+    assert_equal("#{@database_path}.0000100",
+                 context["Posts"].path)
+  end
+
+  def test_default_named_path
+    options_with_named_path = options.merge(:named_path => true)
+    Groonga::Schema.create_table("Posts", options_with_named_path) do |table|
+    end
     assert_equal("#{@database_path}.tables/Posts",
                  context["Posts"].path)
   end

data/test/test-schema.rb

@@ -70,120 +70,277 @@ class SchemaTest < Test::Unit::TestCase
     end
   end
 
-  def test_define_hash
-    Groonga::Schema.create_table("Posts", :type => :hash) do |table|
+  class DefineHashTest < self
+    def test_default
+      Groonga::Schema.create_table("Posts", :type => :hash) do |table|
+      end
+      posts = context["Posts"]
+      assert_kind_of(Groonga::Hash, posts)
+      assert_equal("#{@database_path}.0000100", posts.path)
+    end
+
+    def test_named_path
+      Groonga::Schema.create_table("Posts",
+                                   :type => :hash,
+                                   :named_path => true) do |table|
+      end
+      posts = context["Posts"]
+      assert_kind_of(Groonga::Hash, posts)
+      assert_equal("#{@database_path}.tables/Posts", posts.path)
+    end
+
+    def test_full_option
+      path = @tmp_dir + "hash.groonga"
+      tokenizer = context["TokenTrigram"]
+      Groonga::Schema.create_table("Posts",
+                                   :type => :hash,
+                                   :key_type => "integer",
+                                   :path => path.to_s,
+                                   :value_type => "UInt32",
+                                   :default_tokenizer => tokenizer,
+                                   :named_path => true) do |table|
+      end
+      table = context["Posts"]
+      assert_equal("#<Groonga::Hash " +
+                   "id: <#{table.id}>, " +
+                   "name: <Posts>, " +
+                   "path: <#{path}>, " +
+                   "domain: <Int32>, " +
+                   "range: <UInt32>, " +
+                   "flags: <>, " +
+                   "encoding: <#{Groonga::Encoding.default.inspect}>, " +
+                   "size: <0>>",
+                   table.inspect)
+      assert_equal(tokenizer, table.default_tokenizer)
+    end
+
+    def test_rename
+      Groonga::Schema.create_table("Posts", :type => :hash) do |table|
+      end
+      posts = context["Posts"]
+      assert_kind_of(Groonga::Hash, posts)
+      Groonga::Schema.rename_table("Posts", "Entries") do |table|
+      end
+      entries = context["Entries"]
+      assert_kind_of(Groonga::Hash, entries)
+      assert_equal("Entries", posts.name)
     end
-    posts = context["Posts"]
-    assert_kind_of(Groonga::Hash, posts)
-    assert_equal("#{@database_path}.tables/Posts", posts.path)
   end
 
-  def test_define_hash_with_full_option
-    path = @tmp_dir + "hash.groonga"
-    tokenizer = context["TokenTrigram"]
-    Groonga::Schema.create_table("Posts",
-                                 :type => :hash,
-                                 :key_type => "integer",
-                                 :path => path.to_s,
-                                 :value_type => "UInt32",
-                                 :default_tokenizer => tokenizer) do |table|
-    end
-    table = context["Posts"]
-    assert_equal("#<Groonga::Hash " +
-                 "id: <#{table.id}>, " +
-                 "name: <Posts>, " +
-                 "path: <#{path}>, " +
-                 "domain: <Int32>, " +
-                 "range: <UInt32>, " +
-                 "flags: <>, " +
-                 "encoding: <#{Groonga::Encoding.default.inspect}>, " +
-                 "size: <0>>",
-                 table.inspect)
-    assert_equal(tokenizer, table.default_tokenizer)
-  end
-
-  def test_define_patricia_trie
-    Groonga::Schema.create_table("Posts", :type => :patricia_trie) do |table|
-    end
-    posts = context["Posts"]
-    assert_kind_of(Groonga::PatriciaTrie, posts)
-    assert_equal("#{@database_path}.tables/Posts", posts.path)
-  end
-
-  def test_define_patricia_trie_with_full_option
-    path = @tmp_dir + "patricia-trie.groonga"
-    Groonga::Schema.create_table("Posts",
-                                 :type => :patricia_trie,
-                                 :key_type => "integer",
-                                 :path => path.to_s,
-                                 :value_type => "Float",
-                                 :default_tokenizer => "TokenBigram",
-                                 :key_normalize => true,
-                                 :key_with_sis => true) do |table|
-    end
-    table = context["Posts"]
-    assert_equal("#<Groonga::PatriciaTrie " +
-                 "id: <#{table.id}>, " +
-                 "name: <Posts>, " +
-                 "path: <#{path}>, " +
-                 "domain: <Int32>, " +
-                 "range: <Float>, " +
-                 "flags: <KEY_WITH_SIS|KEY_NORMALIZE|WITH_SECTION>, " +
-                 "encoding: <#{Groonga::Encoding.default.inspect}>, " +
-                 "size: <0>>",
-                 table.inspect)
-    assert_equal(context["TokenBigram"], table.default_tokenizer)
-  end
-
-  def test_define_array
-    Groonga::Schema.create_table("Posts", :type => :array) do |table|
-    end
-    posts = context["Posts"]
-    assert_kind_of(Groonga::Array, posts)
-    assert_equal("#{@database_path}.tables/Posts", posts.path)
-  end
-
-  def test_define_array_with_full_option
-    path = @tmp_dir + "array.groonga"
-    Groonga::Schema.create_table("Posts",
-                                 :type => :array,
-                                 :path => path.to_s,
-                                 :value_type => "Int32") do |table|
-    end
-    table = context["Posts"]
-    assert_equal("#<Groonga::Array " +
-                 "id: <#{table.id}>, " +
-                 "name: <Posts>, " +
-                 "path: <#{path}>, " +
-                 "domain: <Int32>, " +
-                 "range: <Int32>, " +
-                 "flags: <>, " +
-                 "size: <0>>",
-                 table.inspect)
-  end
-
-  def test_column_with_full_option
-    path = @tmp_dir + "column.groonga"
-    type = Groonga::Type.new("Niku", :size => 29)
-    Groonga::Schema.create_table("Posts") do |table|
-      table.column("rate",
-                   type,
-                   :path => path.to_s,
-                   :persistent => true,
-                   :type => :vector,
-                   :compress => :lzo)
-    end
-
-    column_name = "Posts.rate"
-    column = context[column_name]
-    assert_equal("#<Groonga::VariableSizeColumn " +
-                 "id: <#{column.id}>, " +
-                 "name: <#{column_name}>, " +
-                 "path: <#{path}>, " +
-                 "domain: <Posts>, " +
-                 "range: <Niku>, " +
-                 "flags: <COMPRESS_LZO>>",
-                 column.inspect)
+  class DefinePatriciaTrieTest < self
+    def test_default
+      Groonga::Schema.create_table("Posts", :type => :patricia_trie) do |table|
+      end
+      posts = context["Posts"]
+      assert_kind_of(Groonga::PatriciaTrie, posts)
+      assert_equal("#{@database_path}.0000100", posts.path)
+    end
+
+    def test_named_path
+      Groonga::Schema.create_table("Posts",
+                                   :type => :patricia_trie,
+                                   :named_path => true) do |table|
+      end
+      posts = context["Posts"]
+      assert_kind_of(Groonga::PatriciaTrie, posts)
+      assert_equal("#{@database_path}.tables/Posts", posts.path)
+    end
+
+    def test_full_option
+      path = @tmp_dir + "patricia-trie.groonga"
+      Groonga::Schema.create_table("Posts",
+                                   :type => :patricia_trie,
+                                   :key_type => "integer",
+                                   :path => path.to_s,
+                                   :value_type => "Float",
+                                   :default_tokenizer => "TokenBigram",
+                                   :key_normalize => true,
+                                   :key_with_sis => true,
+                                   :named_path => true) do |table|
+      end
+      table = context["Posts"]
+      assert_equal("#<Groonga::PatriciaTrie " +
+                   "id: <#{table.id}>, " +
+                   "name: <Posts>, " +
+                   "path: <#{path}>, " +
+                   "domain: <Int32>, " +
+                   "range: <Float>, " +
+                   "flags: <KEY_WITH_SIS|KEY_NORMALIZE|WITH_SECTION>, " +
+                   "encoding: <#{Groonga::Encoding.default.inspect}>, " +
+                   "size: <0>>",
+                   table.inspect)
+      assert_equal(context["TokenBigram"], table.default_tokenizer)
+    end
+
+    def test_rename
+      Groonga::Schema.create_table("Posts", :type => :patricia_trie) do |table|
+      end
+      posts = context["Posts"]
+      assert_kind_of(Groonga::PatriciaTrie, posts)
+      Groonga::Schema.rename_table("Posts", "Entries") do |table|
+      end
+      entries = context["Entries"]
+      assert_kind_of(Groonga::PatriciaTrie, entries)
+      assert_equal("Entries", posts.name)
+    end
+  end
+
+  class DefineDoubleArrayTrieTest < self
+    def test_default
+      Groonga::Schema.create_table("Posts",
+                                   :type => :double_array_trie) do |table|
+      end
+      posts = context["Posts"]
+      assert_kind_of(Groonga::DoubleArrayTrie, posts)
+      assert_equal("#{@database_path}.0000100", posts.path)
+    end
+
+    def test_named_path
+      Groonga::Schema.create_table("Posts",
+                                   :type => :double_array_trie,
+                                   :named_path => true) do |table|
+      end
+      posts = context["Posts"]
+      assert_kind_of(Groonga::DoubleArrayTrie, posts)
+      assert_equal("#{@database_path}.tables/Posts", posts.path)
+    end
+
+    def test_full_option
+      path = @tmp_dir + "patricia-trie.groonga"
+      Groonga::Schema.create_table("Posts",
+                                   :type => :double_array_trie,
+                                   :key_type => "integer",
+                                   :path => path.to_s,
+                                   :value_type => "Float",
+                                   :default_tokenizer => "TokenBigram",
+                                   :key_normalize => true,
+                                   :named_path => true) do |table|
+      end
+      table = context["Posts"]
+      assert_equal("#<Groonga::DoubleArrayTrie " +
+                   "id: <#{table.id}>, " +
+                   "name: <Posts>, " +
+                   "path: <#{path}>, " +
+                   "domain: <Int32>, " +
+                   "range: <Float>, " +
+                   "flags: <KEY_NORMALIZE|WITH_SECTION>, " +
+                   "encoding: <#{Groonga::Encoding.default.inspect}>, " +
+                   "size: <0>>",
+                   table.inspect)
+      assert_equal(context["TokenBigram"], table.default_tokenizer)
+    end
+
+    def test_rename
+      Groonga::Schema.create_table("Posts", :type => :double_array_trie) do |table|
+      end
+      posts = context["Posts"]
+      assert_kind_of(Groonga::DoubleArrayTrie, posts)
+      Groonga::Schema.rename_table("Posts", "Entries") do |table|
+      end
+      entries = context["Entries"]
+      assert_kind_of(Groonga::DoubleArrayTrie, entries)
+      assert_equal("Entries", posts.name)
+    end
+  end
+
+  class DefineArrayTest < self
+    def test_default
+      Groonga::Schema.create_table("Posts", :type => :array) do |table|
+      end
+      posts = context["Posts"]
+      assert_kind_of(Groonga::Array, posts)
+      assert_equal("#{@database_path}.0000100", posts.path)
+    end
+
+    def test_named_path
+      Groonga::Schema.create_table("Posts",
+                                   :type => :array,
+                                   :named_path => true) do |table|
+      end
+      posts = context["Posts"]
+      assert_kind_of(Groonga::Array, posts)
+      assert_equal("#{@database_path}.tables/Posts", posts.path)
+    end
+
+    def test_full_option
+      path = @tmp_dir + "array.groonga"
+      Groonga::Schema.create_table("Posts",
+                                   :type => :array,
+                                   :path => path.to_s,
+                                   :value_type => "Int32",
+                                   :named_path => true) do |table|
+      end
+      table = context["Posts"]
+      assert_equal("#<Groonga::Array " +
+                   "id: <#{table.id}>, " +
+                   "name: <Posts>, " +
+                   "path: <#{path}>, " +
+                   "domain: <Int32>, " +
+                   "range: <Int32>, " +
+                   "flags: <>, " +
+                   "size: <0>>",
+                   table.inspect)
+    end
+
+    def test_rename
+      Groonga::Schema.create_table("Posts", :type => :array) do |table|
+      end
+      posts = context["Posts"]
+      assert_kind_of(Groonga::Array, posts)
+      Groonga::Schema.rename_table("Posts", "Entries") do |table|
+      end
+      entries = context["Entries"]
+      assert_kind_of(Groonga::Array, entries)
+      assert_equal("Entries", posts.name)
+    end
+  end
+
+  class DefineColumnTest < self
+    def test_default
+      Groonga::Schema.create_table("Posts") do |table|
+        table.column("rate", :int)
+      end
+
+      column_name = "Posts.rate"
+      column = context[column_name]
+      assert_kind_of(Groonga::FixSizeColumn, column)
+      assert_equal("#{@database_path}.0000101", column.path)
+    end
+
+    def test_named_path
+      Groonga::Schema.create_table("Posts") do |table|
+        table.column("rate", :int, :named_path => true)
+      end
+
+      column_name = "Posts.rate"
+      column = context[column_name]
+      assert_kind_of(Groonga::FixSizeColumn, column)
+      assert_equal("#{@database_path}.0000100.columns/rate", column.path)
+    end
+
+    def test_full_option
+      path = @tmp_dir + "column.groonga"
+      type = Groonga::Type.new("Niku", :size => 29)
+      Groonga::Schema.create_table("Posts") do |table|
+        table.column("rate",
+                     type,
+                     :path => path.to_s,
+                     :persistent => true,
+                     :type => :vector,
+                     :compress => :lzo)
+      end
+
+      column_name = "Posts.rate"
+      column = context[column_name]
+      assert_equal("#<Groonga::VariableSizeColumn " +
+                   "id: <#{column.id}>, " +
+                   "name: <#{column_name}>, " +
+                   "path: <#{path}>, " +
+                   "domain: <Posts>, " +
+                   "range: <Niku>, " +
+                   "flags: <COMPRESS_LZO>>",
+                   column.inspect)
+    end
   end
 
   def test_integer32_column
@@ -286,6 +443,19 @@ class SchemaTest < Test::Unit::TestCase
     assert_nil(context["Posts.content"])
   end
 
+  def test_rename_column
+    Groonga::Schema.create_table("Posts") do |table|
+      table.long_text :content
+    end
+    content = context["Posts.content"]
+    assert_equal("Posts.content", content.name)
+
+    Groonga::Schema.rename_column("Posts", "content", "body")
+    body = context["Posts.body"]
+    assert_equal("Posts.body", body.name)
+    assert_equal("Posts.body", content.name)
+  end
+
   def test_column_again
     Groonga::Schema.create_table("Posts") do |table|
       table.text :content
@@ -310,131 +480,167 @@ class SchemaTest < Test::Unit::TestCase
     end
   end
 
-  def test_index
-    assert_nil(context["Terms.content"])
-    Groonga::Schema.create_table("Posts") do |table|
-      table.long_text :content
+  class DefineIndexColumnTest < self
+    def test_default
+      assert_nil(context["Terms.content"])
+      Groonga::Schema.create_table("Posts") do |table|
+        table.long_text :content
+      end
+      Groonga::Schema.create_table("Terms") do |table|
+        table.index "Posts.content"
+      end
+      index_column = context["Terms.Posts_content"]
+      assert_equal([context["Posts.content"]],
+                   index_column.sources)
+      assert_equal("#{@database_path}.0000103", index_column.path)
     end
-    Groonga::Schema.create_table("Terms") do |table|
-      table.index "Posts.content"
+
+    def test_named_path
+      assert_nil(context["Terms.content"])
+      Groonga::Schema.create_table("Posts") do |table|
+        table.long_text :content
+      end
+      Groonga::Schema.create_table("Terms") do |table|
+        table.index "Posts.content", :named_path => true
+      end
+      index_column = context["Terms.Posts_content"]
+      assert_equal([context["Posts.content"]],
+                   index_column.sources)
+      assert_equal("#{@database_path}.0000102.columns/Posts_content",
+                   index_column.path)
     end
-    assert_equal([context["Posts.content"]],
-                 context["Terms.Posts_content"].sources)
-  end
 
-  def test_index_with_full_option
-    path = @tmp_dir + "index-column.groonga"
-    assert_nil(context["Terms.content"])
-    index_column_name = "Posts_index"
+    def test_full_option
+      path = @tmp_dir + "index-column.groonga"
+      assert_nil(context["Terms.content"])
+      index_column_name = "Posts_index"
 
-    Groonga::Schema.create_table("Posts") do |table|
-      table.long_text :content
-    end
-    Groonga::Schema.create_table("Terms") do |table|
-      table.index("Posts.content",
-                  :name => index_column_name,
-                  :path => path.to_s,
-                  :persistent => true,
-                  :with_section => true,
-                  :with_weight => true,
-                  :with_position => true)
-    end
-
-    posts = context["Posts"]
-    terms = context["Terms"]
-    full_index_column_name = "Terms.#{index_column_name}"
-    index_column = context[full_index_column_name]
-    assert_equal("#<Groonga::IndexColumn " +
-                 "id: <#{index_column.id}>, " +
-                 "name: <#{full_index_column_name}>, " +
-                 "path: <#{path}>, " +
-                 "domain: <Terms>, " +
-                 "range: <Posts>, " +
-                 "flags: <WITH_SECTION|WITH_WEIGHT|WITH_POSITION>>",
-                 index_column.inspect)
-  end
-
-  def test_index_again
-    Groonga::Schema.create_table("Posts") do |table|
-      table.long_text :content
-    end
-    Groonga::Schema.create_table("Terms") do |table|
-      table.index "Posts.content"
+      Groonga::Schema.create_table("Posts") do |table|
+        table.long_text :content
+      end
+      Groonga::Schema.create_table("Terms") do |table|
+        table.index("Posts.content",
+                    :name => index_column_name,
+                    :path => path.to_s,
+                    :persistent => true,
+                    :with_section => true,
+                    :with_weight => true,
+                    :with_position => true,
+                    :named_path => true)
+      end
+
+      full_index_column_name = "Terms.#{index_column_name}"
+      index_column = context[full_index_column_name]
+      assert_equal("#<Groonga::IndexColumn " +
+                   "id: <#{index_column.id}>, " +
+                   "name: <#{full_index_column_name}>, " +
+                   "path: <#{path}>, " +
+                   "domain: <Terms>, " +
+                   "range: <Posts>, " +
+                   "flags: <WITH_SECTION|WITH_WEIGHT|WITH_POSITION>>",
+                   index_column.inspect)
     end
 
-    assert_nothing_raised do
+    def test_again
+      Groonga::Schema.create_table("Posts") do |table|
+        table.long_text :content
+      end
       Groonga::Schema.create_table("Terms") do |table|
         table.index "Posts.content"
       end
-    end
-  end
 
-  def test_index_again_with_difference_source
-    Groonga::Schema.create_table("Posts") do |table|
-      table.long_text :content
-      table.short_text :name
-    end
-    Groonga::Schema.create_table("Terms") do |table|
-      table.index "Posts.content"
+      assert_nothing_raised do
+        Groonga::Schema.create_table("Terms") do |table|
+          table.index "Posts.content"
+        end
+      end
     end
 
-    assert_raise(Groonga::Schema::ColumnCreationWithDifferentOptions) do
+    def test_again_with_difference_source
+      Groonga::Schema.create_table("Posts") do |table|
+        table.long_text :content
+        table.short_text :name
+      end
       Groonga::Schema.create_table("Terms") do |table|
-        table.index "Posts.name", :name => "Posts_content"
+        table.index "Posts.content"
       end
-    end
-  end
 
-  def test_index_key
-    Groonga::Schema.create_table("Posts",
-                                 :type => :hash,
-                                 :key_type => "ShortText") do |table|
-    end
-    Groonga::Schema.create_table("Terms") do |table|
-      table.index "Posts._key", :with_position => true
+      assert_raise(Groonga::Schema::ColumnCreationWithDifferentOptions) do
+        Groonga::Schema.create_table("Terms") do |table|
+          table.index "Posts.name", :name => "Posts_content"
+        end
+      end
     end
 
-    full_index_column_name = "Terms.Posts__key"
-    index_column = context[full_index_column_name]
-    assert_equal("#<Groonga::IndexColumn " +
-                 "id: <#{index_column.id}>, " +
-                 "name: <#{full_index_column_name}>, " +
-                 "path: <#{index_column.path}>, " +
-                 "domain: <Terms>, " +
-                 "range: <Posts>, " +
-                 "flags: <WITH_POSITION>>",
-                 index_column.inspect)
-  end
+    def test_key
+      Groonga::Schema.create_table("Posts",
+                                   :type => :hash,
+                                   :key_type => "ShortText") do |table|
+      end
+      Groonga::Schema.create_table("Terms") do |table|
+        table.index "Posts._key", :with_position => true
+      end
 
-  def test_index_key_again
-    Groonga::Schema.create_table("Posts",
-                                 :type => :hash,
-                                 :key_type => "ShortText") do |table|
-    end
-    Groonga::Schema.create_table("Terms") do |table|
-      table.index "Posts._key", :with_position => true
+      full_index_column_name = "Terms.Posts__key"
+      index_column = context[full_index_column_name]
+      assert_equal("#<Groonga::IndexColumn " +
+                   "id: <#{index_column.id}>, " +
+                   "name: <#{full_index_column_name}>, " +
+                   "path: <#{index_column.path}>, " +
+                   "domain: <Terms>, " +
+                   "range: <Posts>, " +
+                   "flags: <WITH_POSITION>>",
+                   index_column.inspect)
     end
 
-    assert_nothing_raised do
+    def test_key_again
+      Groonga::Schema.create_table("Posts",
+                                   :type => :hash,
+                                   :key_type => "ShortText") do |table|
+      end
       Groonga::Schema.create_table("Terms") do |table|
-        table.index "Posts._key"
+        table.index "Posts._key", :with_position => true
       end
-    end
-  end
 
-  def test_remove_index
-    Groonga::Schema.create_table("Posts") do |table|
-      table.long_text :content
+      assert_nothing_raised do
+        Groonga::Schema.create_table("Terms") do |table|
+          table.index "Posts._key"
+        end
+      end
     end
-    Groonga::Schema.create_table("Terms") do |table|
-      table.index "Posts.content"
+
+    def test_remove
+      Groonga::Schema.create_table("Posts") do |table|
+        table.long_text :content
+      end
+      Groonga::Schema.create_table("Terms") do |table|
+        table.index "Posts.content"
+      end
+      assert_equal([context["Posts.content"]],
+                   context["Terms.Posts_content"].sources)
+      Groonga::Schema.change_table("Terms") do |table|
+        table.remove_index("Posts.content")
+      end
+      assert_nil(context["Terms.Posts_content"])
     end
-    assert_equal([context["Posts.content"]],
-                 context["Terms.Posts_content"].sources)
-    Groonga::Schema.change_table("Terms") do |table|
-      table.remove_index("Posts.content")
+
+    def test_rename
+      Groonga::Schema.create_table("Posts") do |table|
+        table.long_text :content
+      end
+      Groonga::Schema.create_table("Terms") do |table|
+        table.index "Posts.content"
+      end
+      index = context["Terms.Posts_content"]
+      assert_equal([context["Posts.content"]], index.sources)
+      Groonga::Schema.change_table("Terms") do |table|
+        table.rename_column("Posts_content", "posts_content_index")
+      end
+      renamed_index = context["Terms.posts_content_index"]
+      assert_equal("Terms.posts_content_index", renamed_index.name)
+      assert_equal("Terms.posts_content_index", index.name)
+      assert_equal([context["Posts.content"]], renamed_index.sources)
     end
-    assert_nil(context["Terms.Posts_content"])
   end
 
   def test_reference_guess
@@ -486,26 +692,6 @@ class SchemaTest < Test::Unit::TestCase
     assert_nil(Groonga::Context.default["TermsText.Items_text"])
   end
 
-  def test_columns_directory_removed
-    table = "Posts"
-    dir = create_table_with_column(table)
-
-    Groonga::Schema.remove_table(table)
-
-    assert_table_removed(table)
-    assert_directory_removed(dir)
-  end
-
-  def test_columns_directory_not_removed
-    table = "Posts"
-    dir = create_table_with_column(table)
-
-    Groonga::Context.default[table].remove
-
-    assert_table_removed(table)
-    assert_directory_not_removed(dir)
-  end
-
   def test_default_tokenizer_name_shortcut
     Groonga::Schema.define do |schema|
       schema.create_table("Terms",
@@ -531,13 +717,84 @@ class SchemaTest < Test::Unit::TestCase
     assert_equal(short_text, Groonga["Users"].domain)
   end
 
+  class RemoveTest < self
+    def test_tables_directory_removed_on_last_table_remove
+      table_name = "Posts"
+      Groonga::Schema.create_table(table_name, :named_path => true)
+      table = Groonga[table_name]
+      tables_directory = Pathname.new(table.path).dirname
+
+      assert_directory_not_removed(tables_directory)
+      Groonga::Schema.remove_table(table_name)
+      assert_directory_removed(tables_directory)
+    end
+
+    def test_tables_directory_not_removed_on_not_last_table_remove
+      table_name = "Posts"
+      Groonga::Schema.define(:named_path => true) do |schema|
+        schema.create_table(table_name)
+        schema.create_table("Users")
+      end
+
+      table = Groonga[table_name]
+      tables_directory = Pathname.new(table.path).dirname
+
+      assert_directory_not_removed(tables_directory)
+      Groonga::Schema.remove_table(table_name)
+      assert_directory_not_removed(tables_directory)
+    end
+
+    def test_columns_directory_removed
+      table = "Posts"
+      dir = create_table_with_column(table, :named_path => true)
+
+      Groonga::Schema.remove_table(table)
+
+      assert_table_removed(table)
+      assert_directory_removed(dir)
+    end
+  end
+
+  class ColumnRemoveTest < self
+    def test_columns_directory_removed_on_last_column_remove
+      Groonga::Schema.define(:named_path => true) do |schema|
+        schema.create_table("Posts") do |table|
+          table.short_text("title")
+        end
+      end
+
+      columns_directory = columns_directory_path(Groonga["Posts"])
+      assert_directory_not_removed(columns_directory)
+      Groonga::Schema.change_table("Posts") do |table|
+        table.remove_column("title")
+      end
+      assert_directory_removed(columns_directory)
+    end
+
+    def test_columns_directory_not_removed_on_not_last_column_remove
+      Groonga::Schema.define(:named_path => true) do |schema|
+        schema.create_table("Posts") do |table|
+          table.short_text("title")
+          table.short_text("body")
+        end
+      end
+
+      columns_directory = columns_directory_path(Groonga["Posts"])
+      assert_directory_not_removed(columns_directory)
+      Groonga::Schema.change_table("Posts") do |table|
+        table.remove_column("title")
+      end
+      assert_directory_not_removed(columns_directory)
+    end
+  end
+
   private
   def columns_directory_path(table)
     "#{table.path}.columns"
   end
 
-  def create_table_with_column(name)
-    Groonga::Schema.create_table(name) do |table|
+  def create_table_with_column(name, options={})
+    Groonga::Schema.create_table(name, options) do |table|
       table.integer64 :rate
     end
     context = Groonga::Context.default
@@ -545,11 +802,11 @@ class SchemaTest < Test::Unit::TestCase
   end
 
   def assert_directory_removed(dir)
-    assert_false(File.exist?(dir))
+    assert_not_predicate(Pathname.new(dir), :exist?)
   end
 
   def assert_directory_not_removed(dir)
-    assert_true(File.exist?(dir))
+    assert_predicate(Pathname.new(dir), :exist?)
   end
 
   def assert_table_removed(name)