rroonga 2.0.4 → 2.0.5

data/test/test-table-traverse.rb

@@ -0,0 +1,304 @@
+# Copyright (C) 2009-2010  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
+
+class TableTraverseTest < Test::Unit::TestCase
+  include GroongaTestUtils
+
+  def setup
+    setup_database
+
+    @bookmarks_path = @tables_dir + "table"
+    @bookmarks = Groonga::PatriciaTrie.create(:name => "Bookmarks",
+                                              :path => @bookmarks_path.to_s)
+    @groonga_bookmark = @bookmarks.add("groonga")
+    @cutter_bookmark = @bookmarks.add("Cutter")
+    @ruby_bookmark = @bookmarks.add("Ruby")
+  end
+
+  class CursorTest < self
+    def test_default
+      keys = []
+      @bookmarks.open_cursor do |cursor|
+        while cursor.next
+          keys << cursor.key
+        end
+      end
+      assert_equal(["Cutter", "Ruby", "groonga"],
+                   keys)
+    end
+
+    def test_order_ascending
+      record_and_key_list = []
+      @bookmarks.open_cursor(:order => :ascending) do |cursor|
+        record_and_key_list = cursor.collect {|record| [record, cursor.key]}
+      end
+      assert_equal([[@cutter_bookmark, "Cutter"],
+                    [@ruby_bookmark, "Ruby"],
+                    [@groonga_bookmark, "groonga"]],
+                   record_and_key_list)
+    end
+
+    def test_without_limit_and_offset
+      users = create_users
+      add_users(users)
+      results = []
+      users.open_cursor do |cursor|
+        cursor.each do |record|
+          results << record["name"]
+        end
+      end
+
+      assert_equal((100..199).collect {|i| "user#{i}"},
+                   results)
+    end
+
+    def test_with_limit
+      users = create_users
+      add_users(users)
+      results = []
+      users.open_cursor(:limit => 20) do |cursor|
+        cursor.each do |record|
+          results << record["name"]
+        end
+      end
+
+      assert_equal((100...120).collect {|i| "user#{i}"},
+                   results)
+    end
+
+    def test_with_offset
+      users = create_users
+      add_users(users)
+      results = []
+      users.open_cursor(:offset => 20) do |cursor|
+        cursor.each do |record|
+          results << record["name"]
+        end
+      end
+
+      assert_equal((120...200).collect {|i| "user#{i}"},
+                   results)
+    end
+
+    def test_with_limit_and_offset
+      users = create_users
+      add_users(users)
+      results = []
+      users.open_cursor(:limit => 20, :offset => 20) do |cursor|
+        cursor.each do |record|
+          results << record["name"]
+        end
+      end
+
+      assert_equal((120...140).collect {|i| "user#{i}"},
+                   results)
+    end
+
+    def test_delete
+      users = create_users
+      add_users(users)
+
+      users.open_cursor(:limit => 20) do |cursor|
+        20.times do
+          cursor.next
+          cursor.delete
+        end
+      end
+
+      results = []
+      users.open_cursor do |cursor|
+        cursor.each do |record|
+          results << record["name"]
+        end
+      end
+
+      assert_equal((120...200).collect {|i| "user#{i}"},
+                   results)
+    end
+
+    def test_patricia_trie_cursor_key
+      sites = Groonga::PatriciaTrie.create(:name => "Sites")
+      sites.add("http://groonga.org/")
+      sites.open_cursor do |cursor|
+        cursor.next
+        assert_equal("http://groonga.org/", cursor.key)
+      end
+    end
+
+    def test_order_by_id
+      sites = Groonga::PatriciaTrie.create(:name => "Sites")
+      sites.add("http://qwik.jp/senna/")
+      sites.add("http://www.ruby-lang.org/")
+      sites.add("http://groonga.org/")
+      keys = []
+      sites.open_cursor(:order_by => :id) do |cursor|
+        while cursor.next
+          keys << cursor.key
+        end
+      end
+      assert_equal(["http://qwik.jp/senna/",
+                    "http://www.ruby-lang.org/",
+                    "http://groonga.org/"],
+                   keys)
+    end
+
+    def test_order_by_key
+      sites = Groonga::PatriciaTrie.create(:name => "Sites")
+      sites.add("http://www.ruby-lang.org/")
+      sites.add("http://qwik.jp/senna/")
+      sites.add("http://groonga.org/")
+      keys = []
+      sites.open_cursor(:order_by => :key) do |cursor|
+        while cursor.next
+          keys << cursor.key
+        end
+      end
+      assert_equal(["http://groonga.org/",
+                    "http://qwik.jp/senna/",
+                    "http://www.ruby-lang.org/"],
+                   keys)
+    end
+
+    def test_each_without_block
+      @bookmarks.open_cursor do |cursor|
+        keys = cursor.each.collect(&:key)
+        assert_equal(["Cutter", "Ruby", "groonga"], keys)
+      end
+    end
+  end
+
+  class EachTest < self
+    def test_default
+      keys = []
+      @bookmarks.each do |record|
+        keys << record.key
+      end
+      assert_equal(["Cutter", "Ruby", "groonga"],
+                   keys)
+    end
+
+    def test_order_ascending
+      record_and_key_list = []
+      @bookmarks.each(:order => :ascending) do |record|
+        record_and_key_list << [record, record.key]
+      end
+      assert_equal([[@cutter_bookmark, "Cutter"],
+                    [@ruby_bookmark, "Ruby"],
+                    [@groonga_bookmark, "groonga"]],
+                   record_and_key_list)
+    end
+
+    def test_without_limit_and_offset
+      users = create_users
+      add_users(users)
+      results = []
+      users.each do |record|
+        results << record["name"]
+      end
+
+      assert_equal((100..199).collect {|i| "user#{i}"},
+                   results)
+    end
+
+    def test_with_limit
+      users = create_users
+      add_users(users)
+      results = []
+      users.each(:limit => 20) do |record|
+        results << record["name"]
+      end
+
+      assert_equal((100...120).collect {|i| "user#{i}"},
+                   results)
+    end
+
+    def test_with_offset
+      users = create_users
+      add_users(users)
+      results = []
+      users.each(:offset => 20) do |record|
+        results << record["name"]
+      end
+
+      assert_equal((120...200).collect {|i| "user#{i}"},
+                   results)
+    end
+
+    def test_with_limit_and_offset
+      users = create_users
+      add_users(users)
+      results = []
+      users.each(:limit => 20, :offset => 20) do |record|
+        results << record["name"]
+      end
+
+      assert_equal((120...140).collect {|i| "user#{i}"},
+                   results)
+    end
+
+    def test_patricia_trie_cursor_key
+      sites = Groonga::PatriciaTrie.create(:name => "Sites")
+      sites.add("http://groonga.org/")
+      sites.each do |record|
+        assert_equal("http://groonga.org/", record.key)
+      end
+    end
+
+    def test_order_by_id
+      sites = Groonga::PatriciaTrie.create(:name => "Sites")
+      sites.add("http://qwik.jp/senna/")
+      sites.add("http://www.ruby-lang.org/")
+      sites.add("http://groonga.org/")
+      keys = []
+      sites.each(:order_by => :id) do |record|
+        keys << record.key
+      end
+      assert_equal(["http://qwik.jp/senna/",
+                    "http://www.ruby-lang.org/",
+                    "http://groonga.org/"],
+                   keys)
+    end
+
+    def test_order_by_key
+      sites = Groonga::PatriciaTrie.create(:name => "Sites")
+      sites.add("http://www.ruby-lang.org/")
+      sites.add("http://qwik.jp/senna/")
+      sites.add("http://groonga.org/")
+      keys = []
+      sites.each(:order_by => :key) do |record|
+        keys << record.key
+      end
+      assert_equal(["http://groonga.org/",
+                    "http://qwik.jp/senna/",
+                    "http://www.ruby-lang.org/"],
+                   keys)
+    end
+  end
+
+  private
+  def create_users
+    users = Groonga::Array.create(:name => "Users")
+    users.define_column("name", "ShortText")
+    users
+  end
+
+  def add_users(users)
+    (0...100).to_a.each do |i|
+      user = users.add
+      user["name"] = "user#{i + 100}"
+    end
+    users
+  end
+end

data/test/test-table.rb

@@ -0,0 +1,711 @@
+# 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
+# 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
+
+class TableTest < Test::Unit::TestCase
+  include GroongaTestUtils
+
+  setup :setup_database
+
+  def test_create
+    table_path = @tables_dir + "bookmarks"
+    assert_not_predicate(table_path, :exist?)
+    table = Groonga::PatriciaTrie.create(:name => "Bookmarks",
+                                         :path => table_path.to_s)
+    assert_equal("Bookmarks", table.name)
+    assert_predicate(table_path, :exist?)
+  end
+
+  def test_temporary
+    table = Groonga::PatriciaTrie.create
+    assert_nil(table.name)
+    assert_predicate(table, :temporary?)
+    assert_not_predicate(table, :persistent?)
+    assert_equal([], @tables_dir.children)
+  end
+
+  def test_define_column
+    table_path = @tables_dir + "bookmarks"
+    table = Groonga::Hash.create(:name => "Bookmarks",
+                                 :path => table_path.to_s)
+    column = table.define_column("name", "Text")
+    assert_equal("Bookmarks.name", column.name)
+    assert_equal(column, table.column("name"))
+  end
+
+  def test_temporary_table_define_column_default_persistent
+    table = Groonga::Hash.create
+    assert_raise(Groonga::InvalidArgument) do
+      table.define_column("name", "ShortText")
+    end
+  end
+
+  def test_temporary_table_define_index_column_default_persistent
+    bookmarks = Groonga::Hash.create(:name => "Bookmarks")
+    terms = Groonga::Hash.create
+    assert_raise(Groonga::InvalidArgument) do
+      terms.define_index_column("url", bookmarks)
+    end
+  end
+
+  def test_define_column_default_persistent
+    bookmarks = Groonga::Hash.create(:name => "Bookmarks")
+    real_name = bookmarks.define_column("real_name", "ShortText")
+    assert_predicate(real_name, :persistent?)
+  end
+
+  def test_define_column_not_persistent
+    bookmarks = Groonga::Hash.create(:name => "Bookmarks")
+    real_name = bookmarks.define_column("real_name", "ShortText",
+                                        :persistent => false)
+    assert_predicate(real_name, :temporary?)
+  end
+
+  def test_define_column_not_persistent_and_path
+    column_path = @tables_dir + "bookmakrs.real_name.column"
+
+    bookmarks = Groonga::Hash.create(:name => "Bookmarks")
+    message = "should not pass :path if :persistent is false: <#{column_path}>"
+    assert_raise(ArgumentError.new(message)) do
+      bookmarks.define_column("real_name", "ShortText",
+                              :path => column_path.to_s,
+                              :persistent => false)
+    end
+  end
+
+  def test_define_index_column_default_persistent
+    bookmarks = Groonga::Hash.create(:name => "Bookmarks")
+    terms = Groonga::Hash.create(:name => "Terms")
+    real_name = terms.define_index_column("real_name", bookmarks)
+    assert_predicate(real_name, :persistent?)
+  end
+
+  def test_define_index_column_not_persistent
+    bookmarks = Groonga::Hash.create(:name => "Bookmarks")
+    terms = Groonga::Hash.create(:name => "Terms")
+    real_name = terms.define_index_column("real_name", bookmarks,
+                                          :persistent => false)
+    assert_predicate(real_name, :temporary?)
+  end
+
+  def test_define_index_column_not_persistent_and_path
+    column_path = @tables_dir + "bookmakrs.real_name.column"
+
+    bookmarks = Groonga::Hash.create(:name => "Bookmarks")
+    terms = Groonga::Hash.create(:name => "Terms")
+    message = "should not pass :path if :persistent is false: <#{column_path}>"
+    assert_raise(ArgumentError.new(message)) do
+      terms.define_index_column("real_name", bookmarks,
+                                :path => column_path.to_s,
+                                :persistent => false)
+    end
+  end
+
+  def test_define_index_column
+    bookmarks = Groonga::Hash.create(:name => "Bookmarks")
+    bookmarks.define_column("content", "Text")
+    terms = Groonga::Hash.create(:name => "Terms")
+    terms.default_tokenizer = "TokenBigram"
+    index = terms.define_index_column("content_index", bookmarks,
+                                      :with_section => true,
+                                      :source => "Bookmarks.content")
+    bookmarks.add("google", :content => "Search engine")
+    assert_equal(["google"],
+                 index.search("engine").collect {|record| record.key.key})
+  end
+
+  def test_column_nonexistent
+    table_path = @tables_dir + "bookmarks"
+    table = Groonga::Hash.create(:name => "Bookmarks",
+                                 :path => table_path.to_s)
+    assert_nil(table.column("nonexistent"))
+  end
+
+  def test_set_value
+    table_path = @tables_dir + "bookmarks"
+    bookmarks = Groonga::Hash.create(:name => "Bookmarks",
+                                     :value_type => "Int32",
+                                     :path => table_path.to_s)
+    comment_column_path = @columns_dir + "comment"
+    bookmarks_comment =
+      bookmarks.define_column("comment", "ShortText",
+                              :type => "scalar",
+                              :path => comment_column_path.to_s)
+    groonga = bookmarks.add("groonga")
+    groonga.value = 29
+    bookmarks_comment[groonga.id] = "fulltext search engine"
+
+    assert_equal([29, "fulltext search engine"],
+                 [groonga.value, bookmarks_comment[groonga.id]])
+  end
+
+  def test_array_set
+    bookmarks = Groonga::Hash.create(:name => "Bookmarks",
+                                     :value_type => "Int32")
+    bookmarks.set_value("groonga", 29)
+
+    values = bookmarks.records.collect do |record|
+      record.value
+    end
+    assert_equal([29], values)
+  end
+
+  def test_add_without_name
+    users_path = @tables_dir + "users"
+    users = Groonga::Array.create(:name => "Users",
+                                  :path => users_path.to_s)
+    name_column_path = @columns_dir + "name"
+    users_name = users.define_column("name", "ShortText",
+                                     :path => name_column_path.to_s)
+    morita = users.add
+    users_name[morita.id] = "morita"
+    assert_equal("morita", users_name[morita.id])
+  end
+
+  def test_add_by_id
+    users_path = @tables_dir + "users"
+    users = Groonga::Hash.create(:name => "Users",
+                                 :path => users_path.to_s)
+
+    bookmarks_path = @tables_dir + "bookmarks"
+    bookmarks = Groonga::Hash.create(:name => "Bookmarks",
+                                     :key_type => users,
+                                     :value_type => "Int32",
+                                     :path => bookmarks_path.to_s)
+    morita = users.add("morita")
+    groonga = bookmarks.add(morita.id)
+    groonga.value = 29
+    assert_equal(29, groonga.value)
+  end
+
+  def test_add_vector_column_referencing_to_normalized_table_indexed_via_column_value
+    people = Groonga::Hash.create(:name => "People", :key_normalize => true)
+    movies = Groonga::Hash.create(:name => "Movies")
+    movies.define_column("casts", people, :type => :vector)
+    people.define_index_column("index", movies)
+
+    movies.add("DOCUMENTARY of AKB48", :casts => ["AKB48"])
+
+    people_records = people.records.collect(&:key)
+    assert_equal(["akb48"], people_records)
+  end
+
+  def test_add_vector_column_referencing_to_normalized_table_indexed_via_source
+    people = Groonga::Hash.create(:name => "People", :key_normalize => true)
+    movies = Groonga::Hash.create(:name => "Movies")
+    movies.define_column("casts", people, :type => :vector)
+    people.define_index_column("index", movies, :source => "casts")
+
+    movies.add("DOCUMENTARY of AKB48", :casts => ["AKB48"])
+
+    people_records = people.records.collect(&:key)
+    assert_equal(["akb48"], people_records)
+  end
+
+  def test_columns
+    bookmarks_path = @tables_dir + "bookmarks"
+    bookmarks = Groonga::Array.create(:name => "Bookmarks",
+                                      :path => bookmarks_path.to_s)
+
+    uri_column = bookmarks.define_column("uri", "ShortText")
+    comment_column = bookmarks.define_column("comment", "Text")
+    assert_equal([uri_column.name, comment_column.name].sort,
+                 bookmarks.columns.collect {|column| column.name}.sort)
+  end
+
+  def test_column_by_symbol
+    bookmarks_path = @tables_dir + "bookmarks"
+    bookmarks = Groonga::Array.create(:name => "Bookmarks",
+                                      :path => bookmarks_path.to_s)
+
+    uri_column = bookmarks.define_column("uri", "Text")
+    assert_equal(uri_column, bookmarks.column(:uri))
+  end
+
+  def test_size
+    bookmarks_path = @tables_dir + "bookmarks"
+    bookmarks = Groonga::Array.create(:name => "Bookmarks",
+                                      :path => bookmarks_path.to_s)
+
+    assert_equal(0, bookmarks.size)
+
+    bookmarks.add
+    bookmarks.add
+    bookmarks.add
+
+    assert_equal(3, bookmarks.size)
+  end
+
+  def test_empty?
+    bookmarks_path = @tables_dir + "bookmarks"
+    bookmarks = Groonga::Array.create(:name => "Bookmarks",
+                                      :path => bookmarks_path.to_s)
+
+    assert_predicate(bookmarks, :empty?)
+    bookmarks.add
+    assert_not_predicate(bookmarks, :empty?)
+  end
+
+  def test_path
+    bookmarks_path = @tables_dir + "bookmarks"
+    bookmarks = Groonga::Array.create(:name => "Bookmarks",
+                                      :path => bookmarks_path.to_s)
+    assert_equal(bookmarks_path.to_s, bookmarks.path)
+  end
+
+  def test_time_column
+    bookmarks_path = @tables_dir + "bookmarks"
+    bookmarks = Groonga::Array.create(:name => "Bookmarks",
+                                      :path => bookmarks_path.to_s)
+    bookmarks.define_column("created_at", "Time")
+
+    bookmark = bookmarks.add
+    now = Time.now
+    bookmark["created_at"] = now
+    assert_equal(now.to_a,
+                 bookmark["created_at"].to_a)
+  end
+
+  def test_delete
+    bookmarks_path = @tables_dir + "bookmarks"
+    bookmarks = Groonga::Array.create(:name => "Bookmarks",
+                                      :path => bookmarks_path.to_s)
+
+    bookmark_records = []
+    bookmark_records << bookmarks.add
+    bookmark_records << bookmarks.add
+    bookmark_records << bookmarks.add
+
+    assert_equal(3, bookmarks.size)
+    bookmarks.delete(bookmark_records[1].id)
+    assert_equal(2, bookmarks.size)
+  end
+
+  def test_remove
+    bookmarks_path = @tables_dir + "bookmarks"
+    bookmarks = Groonga::Array.create(:name => "Bookmarks",
+                                      :path => bookmarks_path.to_s)
+    assert_predicate(bookmarks_path, :exist?)
+    bookmarks.remove
+    assert_not_predicate(bookmarks_path, :exist?)
+  end
+
+  def test_temporary_add
+    table = Groonga::Hash.create(:key_type => "ShortText")
+    assert_equal(0, table.size)
+    table.add("key")
+    assert_equal(1, table.size)
+  end
+
+  def test_truncate
+    users = Groonga::Array.create(:name => "Users")
+    users.add
+    users.add
+    users.add
+    assert_equal(3, users.size)
+    assert_nothing_raised do
+      users.truncate
+    end
+    assert_equal(0, users.size)
+  end
+
+  def test_sort
+    bookmarks = create_bookmarks
+    add_shuffled_ids(bookmarks)
+
+    results = bookmarks.sort([
+                              {
+                                :key => "id",
+                                :order => :descending,
+                              },
+                             ],
+                             :limit => 20)
+    assert_equal((180..199).to_a.reverse,
+                 results.collect {|record| record["id"]})
+  end
+
+  def test_sort_simple
+    bookmarks = create_bookmarks
+    add_shuffled_ids(bookmarks)
+
+    results = bookmarks.sort(["id"], :limit => 20)
+    assert_equal((100..119).to_a,
+                 results.collect {|record| record["id"]})
+  end
+
+  def test_sort_by_array
+    bookmarks = create_bookmarks
+    add_shuffled_ids(bookmarks)
+
+    results = bookmarks.sort([["id", "descending"]], :limit => 20)
+    assert_equal((180..199).to_a.reverse,
+                 results.collect {|record| record["id"]})
+  end
+
+  def test_sort_without_limit_and_offset
+    bookmarks = create_bookmarks
+    add_shuffled_ids(bookmarks)
+
+    results = bookmarks.sort([{:key => "id", :order => :descending}])
+    assert_equal((100..199).to_a.reverse,
+                 results.collect {|record| record["id"]})
+  end
+
+  def test_sort_with_limit
+    bookmarks = create_bookmarks
+    add_shuffled_ids(bookmarks)
+
+    results = bookmarks.sort([{:key => "id", :order => :descending}],
+                             :limit => 20)
+    assert_equal((180..199).to_a.reverse,
+                 results.collect {|record| record["id"]})
+  end
+
+  def test_sort_with_offset
+    bookmarks = create_bookmarks
+    add_shuffled_ids(bookmarks)
+
+    results = bookmarks.sort([{:key => "id", :order => :descending}],
+                             :offset => 20)
+    assert_equal((100..179).to_a.reverse,
+                 results.collect {|record| record["id"]})
+  end
+
+  def test_sort_with_limit_and_offset
+    bookmarks = create_bookmarks
+    add_shuffled_ids(bookmarks)
+
+    results = bookmarks.sort([{:key => "id", :order => :descending}],
+                             :limit => 20, :offset => 20)
+    assert_equal((160..179).to_a.reverse,
+                 results.collect {|record| record["id"]})
+  end
+
+  def test_sort_with_nonexistent_key
+    bookmarks = create_bookmarks
+    add_shuffled_ids(bookmarks)
+    message = "no such column: <\"nonexistent\">: <#{bookmarks.inspect}>"
+    assert_raise(Groonga::NoSuchColumn.new(message)) do
+      bookmarks.sort([{:key => "nonexistent", :order => :descending}])
+    end
+  end
+
+  def test_sort_with_nonexistent_value
+    bookmarks = create_bookmarks
+    bookmarks.define_column("uri", "ShortText")
+    empty1 = bookmarks.add
+    groonga = bookmarks.add(:uri => "http://groonga.org/")
+    empty2 = bookmarks.add
+    assert_equal([groonga, empty1, empty2],
+                 bookmarks.sort([{:key => "uri", :order => :descending}]))
+  end
+
+  def test_group
+    bookmarks = Groonga::Hash.create(:name => "Bookmarks")
+    bookmarks.define_column("title", "Text")
+    comments = Groonga::Array.create(:name => "Comments")
+    comments.define_column("bookmark", bookmarks)
+    comments.define_column("content", "Text")
+    comments.define_column("issued", "Int32")
+
+    groonga = bookmarks.add("http://groonga.org/", :title => "groonga")
+    ruby = bookmarks.add("http://ruby-lang.org/", :title => "Ruby")
+
+    now = Time.now.to_i
+    comments.add(:bookmark => groonga,
+                 :content => "full-text search",
+                 :issued => now)
+    comments.add(:bookmark => groonga,
+                 :content => "column store",
+                 :issued => now)
+    comments.add(:bookmark => ruby,
+                 :content => "object oriented script language",
+                 :issued => now)
+
+    records = comments.select do |record|
+      record["issued"] > 0
+    end
+    assert_equal([[2, "groonga", "http://groonga.org/"],
+                  [1, "Ruby", "http://ruby-lang.org/"]],
+                 records.group(".bookmark").collect do |record|
+                   bookmark = record.key
+                   [record.n_sub_records,
+                    bookmark["title"],
+                    bookmark.key]
+                 end)
+    assert_equal([[2, "groonga", "http://groonga.org/"],
+                  [1, "Ruby", "http://ruby-lang.org/"]],
+                 records.group(%w".bookmark").collect do |record|
+                   bookmark = record.key
+                   [record.n_sub_records,
+                    bookmark["title"],
+                    bookmark.key]
+                 end)
+  end
+
+  def test_group_with_unknown_key
+    bookmarks = Groonga::Hash.create(:name => "Bookmarks")
+    message = "unknown group key: <\"nonexistent\">: <#{bookmarks.inspect}>"
+    assert_raise(ArgumentError.new(message)) do
+      bookmarks.group("nonexistent")
+    end
+  end
+
+  def test_union!
+    bookmarks = Groonga::Hash.create(:name => "Bookmarks")
+    bookmarks.define_column("title", "ShortText")
+
+    bookmarks.add("http://groonga.org/", :title => "groonga")
+    bookmarks.add("http://ruby-lang.org/", :title => "Ruby")
+
+    ruby_bookmarks = bookmarks.select {|record| record["title"] == "Ruby"}
+    groonga_bookmarks = bookmarks.select {|record| record["title"] == "groonga"}
+    assert_equal(["Ruby", "groonga"],
+                 ruby_bookmarks.union!(groonga_bookmarks).collect do |record|
+                   record[".title"]
+                 end)
+  end
+
+  def test_intersection!
+    bookmarks = Groonga::Hash.create(:name => "bookmarks")
+    bookmarks.define_column("title", "ShortText")
+
+    bookmarks.add("http://groonga.org/", :title => "groonga")
+    bookmarks.add("http://ruby-lang.org/", :title => "Ruby")
+
+    ruby_bookmarks = bookmarks.select {|record| record["title"] == "Ruby"}
+    all_bookmarks = bookmarks.select
+    assert_equal(["Ruby"],
+                 ruby_bookmarks.intersection!(all_bookmarks).collect do |record|
+                   record[".title"]
+                 end)
+  end
+
+  def test_difference!
+    bookmarks = Groonga::Hash.create(:name => "Bookmarks")
+    bookmarks.define_column("title", "ShortText")
+
+    bookmarks.add("http://groonga.org/", :title => "groonga")
+    bookmarks.add("http://ruby-lang.org/", :title => "Ruby")
+
+    ruby_bookmarks = bookmarks.select {|record| record["title"] == "Ruby"}
+    all_bookmarks = bookmarks.select
+    assert_equal(["groonga"],
+                 all_bookmarks.difference!(ruby_bookmarks).collect do |record|
+                   record[".title"]
+                 end)
+  end
+
+  def test_merge!
+    bookmarks = Groonga::Hash.create(:name => "Bookmarks")
+    bookmarks.define_column("title", "ShortText")
+
+    bookmarks.add("http://groonga.org/", :title => "groonga")
+    bookmarks.add("http://ruby-lang.org/", :title => "Ruby")
+
+    ruby_bookmarks = bookmarks.select {|record| (record["title"] == "Ruby") &
+                                                (record["title"] == "Ruby") }
+    all_bookmarks = bookmarks.select
+    assert_equal([["groonga", 1], ["Ruby", 2]],
+                 all_bookmarks.merge!(ruby_bookmarks).collect do |record|
+                   [record[".title"], record.score]
+                 end)
+  end
+
+  def test_lock
+    bookmarks = Groonga::Array.create(:name => "Bookmarks")
+    assert_not_predicate(bookmarks, :locked?)
+    bookmarks.lock
+    assert_predicate(bookmarks, :locked?)
+    bookmarks.unlock
+    assert_not_predicate(bookmarks, :locked?)
+  end
+
+  def test_lock_failed
+    bookmarks = Groonga::Array.create(:name => "Bookmarks")
+    bookmarks.lock
+    assert_raise(Groonga::ResourceDeadlockAvoided) do
+      bookmarks.lock
+    end
+  end
+
+  def test_lock_block
+    bookmarks = Groonga::Array.create(:name => "Bookmarks")
+    assert_not_predicate(bookmarks, :locked?)
+    bookmarks.lock do
+      assert_predicate(bookmarks, :locked?)
+    end
+    assert_not_predicate(bookmarks, :locked?)
+  end
+
+  def test_clear_lock
+    bookmarks = Groonga::Array.create(:name => "Bookmarks")
+    assert_not_predicate(bookmarks, :locked?)
+    bookmarks.lock
+    assert_predicate(bookmarks, :locked?)
+    bookmarks.clear_lock
+    assert_not_predicate(bookmarks, :locked?)
+  end
+
+  def test_auto_record_register
+    users = Groonga::Hash.create(:name => "Users",
+                                 :key_type => "ShortText")
+    books = Groonga::Hash.create(:name => "Books",
+                                 :key_type => "ShortText")
+    users.define_column("book", "Books")
+
+    assert_equal([], books.select.collect {|book| book.key})
+    users.add("ryoqun", :book => "XP")
+    assert_equal([books["XP"]],
+                 books.select.collect {|book| book.key})
+  end
+
+  def test_get_common_prefix_column
+    users = Groonga::Array.create(:name => "Users")
+    users.define_column("name_kana", "ShortText")
+    name = users.define_column("name", "ShortText")
+
+    assert_equal(name, users.column("name"))
+  end
+
+  def test_empty_reference_column_value
+    users = Groonga::Hash.create(:name => "Users",
+                                 :key_type => "ShortText")
+    books = Groonga::Hash.create(:name => "Books",
+                                 :key_type => "ShortText")
+    users.define_column("book", books)
+    users.add("morita", :book => "")
+    assert_equal({"_id" => 1, "_key" => "morita", "book" => nil},
+                 users["morita"].attributes)
+  end
+
+  def test_have_column
+    users = Groonga::Hash.create(:name => "Users",
+                                 :key_type => "ShortText")
+    users.define_column("name", "ShortText")
+    assert_true(users.have_column?("name"), "name")
+    assert_false(users.have_column?("description"), "description")
+  end
+
+  def test_have_column_id
+    users = Groonga::Array.create(:name => "Users")
+    assert_true(users.have_column?(:_id))
+  end
+
+  def test_have_column_key_hash
+    users = Groonga::Hash.create(:name => "Users",
+                                 :key_type => "ShortText")
+    assert_true(users.have_column?(:_key))
+  end
+
+  def test_have_column_key_array
+    users = Groonga::Array.create(:name => "Users")
+    assert_false(users.have_column?(:_key))
+  end
+
+  def test_have_column_value_hash_with_value_type
+    users = Groonga::Hash.create(:name => "Users",
+                                 :key_type => "ShortText",
+                                 :value_type => "Int32")
+    assert_true(users.have_column?(:_value))
+  end
+
+  def test_have_column_value_hash_without_value_type
+    users = Groonga::Hash.create(:name => "Users",
+                                 :key_type => "ShortText")
+    assert_false(users.have_column?(:_value))
+  end
+
+  def test_have_column_value_array
+    users = Groonga::Array.create(:name => "Users")
+    assert_false(users.have_column?(:_value))
+  end
+
+  def test_have_column_nsubrecs_existent
+    users = Groonga::Hash.create(:name => "Users",
+                                 :key_type => "ShortText")
+    assert_true(users.select.have_column?(:_nsubrecs))
+  end
+
+  def test_have_column_nsubrecs_nonexistent
+    users = Groonga::Hash.create(:name => "Users",
+                                 :key_type => "ShortText")
+    assert_false(users.have_column?(:_nsubrecs))
+  end
+
+  def test_have_column_score_existent
+    users = Groonga::Hash.create(:name => "Users",
+                                 :key_type => "ShortText")
+    assert_true(users.select.have_column?(:_score))
+  end
+
+  def test_have_column_score_nonexistent
+    users = Groonga::Hash.create(:name => "Users",
+                                 :key_type => "ShortText")
+    assert_false(users.have_column?(:_score))
+  end
+
+  def test_exist?
+    users = Groonga::Hash.create(:name => "Users")
+    morita = users.add("morita")
+    assert_true(users.exist?(morita.id))
+    assert_false(users.exist?(morita.id + 1))
+  end
+
+  def test_builtin?
+    bookmarks = Groonga::PatriciaTrie.create(:name => "Bookmarks")
+    assert_not_predicate(bookmarks, :builtin?)
+  end
+
+  class OtherProcessTest < self
+    def test_create
+      by_other_process do
+        Groonga::PatriciaTrie.create(:name => "Bookmarks")
+      end
+      assert_not_nil(Groonga["Bookmarks"])
+    end
+
+    def test_define_column
+      bookmarks = Groonga::Hash.create(:name => "Bookmarks")
+      by_other_process do
+        bookmarks.define_column("name", "Text")
+      end
+      assert_not_nil(bookmarks.column("name"))
+    end
+
+    private
+    def by_other_process
+      pid = Process.fork do
+        yield
+      end
+      Process.waitpid(pid)
+    end
+  end
+
+  private
+  def create_bookmarks
+    bookmarks = Groonga::Array.create(:name => "Bookmarks")
+    bookmarks.define_column("id", "Int32")
+    bookmarks
+  end
+
+  def add_shuffled_ids(bookmarks)
+    srand(Time.now.to_i)
+    (0...100).to_a.shuffle.each do |i|
+      bookmark = bookmarks.add
+      bookmark["id"] = i + 100
+    end
+    bookmarks
+  end
+end