groonga 0.0.7 → 0.9.0

data/test/test-table-cursor.rb

@@ -20,7 +20,7 @@ class TableCursorTest < Test::Unit::TestCase
     setup_database
 
     @bookmarks_path = @tables_dir + "table"
-    @bookmarks = Groonga::PatriciaTrie.create(:name => "bookmarks",
+    @bookmarks = Groonga::PatriciaTrie.create(:name => "Bookmarks",
                                               :path => @bookmarks_path.to_s)
     @groonga_bookmark = @bookmarks.add("groonga")
     @cutter_bookmark = @bookmarks.add("Cutter")
@@ -48,4 +48,106 @@ class TableCursorTest < Test::Unit::TestCase
                   [@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
+
+  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-offset-and-limit.rb

@@ -0,0 +1,102 @@
+# Copyright (C) 2009  Kouhei Sutou <kou@clear-code.com>
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License version 2.1 as published by the Free Software Foundation.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+module TestOffsetAndLimitSupport
+  def test_zero_and_positive_offset
+    assert_equal(((100 + 0)...200).to_a, ids(:offset => 0))
+    assert_equal(((100 + 32)...200).to_a, ids(:offset => 32))
+    assert_equal(((100 + 99)...200).to_a, ids(:offset => 99))
+    assert_raise(Groonga::InvalidArgument) do
+      ids(:offset => 100)
+    end
+  end
+
+  def test_negative_offset
+    assert_equal(((200 - 1)...200).to_a, ids(:offset => -1))
+    assert_equal(((200 - 32)...200).to_a, ids(:offset => -32))
+    assert_equal(((200 - 100)...200).to_a, ids(:offset => -100))
+    assert_raise(Groonga::InvalidArgument) do
+      ids(:offset => -101)
+    end
+  end
+
+  def test_zero_and_positive_limit
+    all_ids = (100...200).to_a
+    assert_equal(all_ids[0, 0], ids(:limit => 0))
+    assert_equal(all_ids[0, 32], ids(:limit => 32))
+    assert_equal(all_ids[0, 100], ids(:limit => 100))
+    assert_nothing_raised do
+      ids(:limit => 101)
+    end
+  end
+
+  def test_negative_limit
+    all_ids = (100...200).to_a
+    assert_equal(all_ids[0..-1], ids(:limit => -1))
+    assert_equal(all_ids[0..-32], ids(:limit => -32))
+    assert_equal(all_ids[0..-100], ids(:limit => -100))
+    assert_raise(Groonga::InvalidArgument) do
+      ids(:offset => -101)
+    end
+  end
+
+  private
+  def create_bookmarks
+    @bookmarks = Groonga::Array.create(:name => "Bookmarks")
+    @bookmarks.define_column("id", "Int32")
+    @bookmarks
+  end
+
+  def add_ids
+    100.times do |i|
+      bookmark = @bookmarks.add
+      bookmark["id"] = i + 100
+    end
+    @bookmarks
+  end
+end
+
+class TestOffsetAndLimit < Test::Unit::TestCase
+  include GroongaTestUtils
+  def setup
+    setup_database
+    @bookmarks = create_bookmarks
+    add_ids
+  end
+end
+
+class TestTableCursorOffsetAndLimit < TestOffsetAndLimit
+  include TestOffsetAndLimitSupport
+
+  private
+  def ids(options={})
+    @bookmarks.open_cursor(options) do |cursor|
+      cursor.collect do |record|
+        record["id"]
+      end
+    end
+  end
+end
+
+class TestTableSortOffsetAndLimit < TestOffsetAndLimit
+  include TestOffsetAndLimitSupport
+
+  private
+  def ids(options={})
+    @bookmarks.sort([:key => "id", :order => :asc], options).collect do |record|
+      record["id"]
+    end
+  end
+end

data/test/test-table-select-normalize.rb

@@ -15,22 +15,22 @@
 # 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 TableTestSelectNormalize < Test::Unit::TestCase
+class TableSelectNormalizeTest < Test::Unit::TestCase
   include GroongaTestUtils
 
   setup :setup_database
 
   setup
   def setup_comments
-    @comments = Groonga::Array.create(:name => "comments")
+    @comments = Groonga::Array.create(:name => "Comments")
     @comments.define_column("content", "Text")
     @comments.define_column("created_at", "Time")
-    terms = Groonga::PatriciaTrie.create(:name => "terms",
+    terms = Groonga::PatriciaTrie.create(:name => "Terms",
                                          :default_tokenizer => "TokenBigram",
                                          :key_normalize => true)
     terms.define_index_column("comment_content", @comments,
                               :with_section => true,
-                              :source => "comments.content")
+                              :source => "Comments.content")
     @japanese_comment =
       @comments.add(:content => "うちのボロTVはまだ現役です",
                     :created_at => Time.parse("2009-06-09"))

data/test/test-table-select.rb

@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2009  Kouhei Sutou <kou@clear-code.com>
+#
+# 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
@@ -14,30 +15,37 @@
 # 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 TableTestSelect < Test::Unit::TestCase
+class TableSelectTest < Test::Unit::TestCase
   include GroongaTestUtils
 
   setup :setup_database
 
   setup
   def setup_comments
-    @comments = Groonga::Array.create(:name => "comments")
+    @users = Groonga::Hash.create(:name => "Users", :key_type => "ShortText")
+
+    @comments = Groonga::Array.create(:name => "Comments")
     @comments.define_column("content", "Text")
     @comments.define_column("created_at", "Time")
-    terms = Groonga::PatriciaTrie.create(:name => "terms",
+    @comments.define_column("user", "Users")
+
+    terms = Groonga::PatriciaTrie.create(:name => "Terms",
                                          :default_tokenizer => "TokenBigram")
     terms.define_index_column("comment_content", @comments,
                               :with_section => true,
-                              :source => "comments.content")
+                              :source => "content")
     @comment1 = @comments.add(:content => "Hello Good-bye!",
-                              :created_at => Time.parse("2009-08-09"))
+                              :created_at => Time.parse("2009-08-09"),
+                              :user => "morita")
     @comment2 = @comments.add(:content => "Hello World",
                               :created_at => Time.parse("2009-07-09"))
     @comment3 = @comments.add(:content => "test",
-                              :created_at => Time.parse("2009-06-09"))
+                              :created_at => Time.parse("2009-06-09"),
+                              :user => "gunyara-kun")
     @japanese_comment =
       @comments.add(:content => "うちのボロTVはまだ現役です",
-                    :created_at => Time.parse("2009-06-09"))
+                    :created_at => Time.parse("2009-06-09"),
+                    :user => "darashi")
   end
 
   def test_select_sub_expression
@@ -53,6 +61,22 @@ class TableTestSelect < Test::Unit::TestCase
     assert_equal_select_result([@comment1, @comment2], result)
   end
 
+  def test_select_query_with_parser
+    result = @comments.select("content @ \"Hello\"", :syntax => :script)
+    assert_equal_select_result([@comment1, @comment2], result)
+  end
+
+  def test_select_expression
+    expression = Groonga::Expression.new
+    variable = expression.define_variable(:domain => @comments)
+    expression.append_object(variable)
+    expression.parse("content:%Hello", :syntax => :query)
+    expression.compile
+    result = @comments.select(expression)
+    assert_equal(expression, result.expression)
+    assert_equal_select_result([@comment1, @comment2], result)
+  end
+
   def test_select_query_with_block
     result = @comments.select("content:%Hello") do |record|
       record["created_at"] < Time.parse("2009-08-01")
@@ -98,4 +122,24 @@ class TableTestSelect < Test::Unit::TestCase
     end
     assert_equal_select_result([], result)
   end
+
+  def test_select_equal_reference_column_by_key
+    result = @comments.select do |record|
+      record["user"] == "darashi"
+    end
+    assert_equal_select_result([@japanese_comment], result)
+  end
+
+  def test_select_not_equal_reference_column_by_key
+    result = @comments.select('user != "darashi"', :syntax => :script)
+    assert_equal_select_result([@comment1, @comment2, @comment3],
+                               result)
+  end
+
+  def test_select_equal_reference_column_by_nonexistent_key
+    result = @comments.select do |record|
+      record["user"] == "nonexistent"
+    end
+    assert_equal_select_result([], result)
+  end
 end

data/test/test-table.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2009  Kouhei Sutou <kou@clear-code.com>
+# 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
@@ -19,31 +19,33 @@ class TableTest < Test::Unit::TestCase
   setup :setup_database
 
   def test_create
-    table_path = @tables_dir + "table"
+    table_path = @tables_dir + "bookmarks"
     assert_not_predicate(table_path, :exist?)
-    table = Groonga::PatriciaTrie.create(:name => "bookmarks",
+    table = Groonga::PatriciaTrie.create(:name => "Bookmarks",
                                          :path => table_path.to_s)
-    assert_equal("bookmarks", table.name)
+    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_open
-    table_path = @tables_dir + "table"
-    table = Groonga::Hash.create(:name => "bookmarks",
+    table_path = @tables_dir + "bookmarks"
+    table = Groonga::Hash.create(:name => "Bookmarks",
                                  :path => table_path.to_s)
-    assert_equal("bookmarks", table.name)
+    assert_equal("Bookmarks", table.name)
 
     called = false
-    Groonga::Table.open(:name => "bookmarks") do |_table|
+    Groonga::Table.open(:name => "Bookmarks") do |_table|
       table = _table
       assert_not_predicate(table, :closed?)
-      assert_equal("bookmarks", _table.name)
+      assert_equal("Bookmarks", _table.name)
       called = true
     end
     assert_true(called)
@@ -51,10 +53,10 @@ class TableTest < Test::Unit::TestCase
   end
 
   def test_open_by_path
-    table_path = @tables_dir + "table"
-    table = Groonga::PatriciaTrie.create(:name => "bookmarks",
+    table_path = @tables_dir + "bookmarks"
+    table = Groonga::PatriciaTrie.create(:name => "Bookmarks",
                                          :path => table_path.to_s)
-    assert_equal("bookmarks", table.name)
+    assert_equal("Bookmarks", table.name)
     table.close
 
     called = false
@@ -69,17 +71,17 @@ class TableTest < Test::Unit::TestCase
   end
 
   def test_open_override_name
-    table_path = @tables_dir + "table"
-    table = Groonga::PatriciaTrie.create(:name => "bookmarks",
+    table_path = @tables_dir + "bookmarks"
+    table = Groonga::PatriciaTrie.create(:name => "Bookmarks",
                                          :path => table_path.to_s)
-    assert_equal("bookmarks", table.name)
+    assert_equal("Bookmarks", table.name)
     table.close
 
     called = false
-    Groonga::Table.open(:name => "no-name", :path => table_path.to_s) do |_table|
+    Groonga::Table.open(:name => "Marks", :path => table_path.to_s) do |_table|
       table = _table
       assert_not_predicate(table, :closed?)
-      assert_equal("no-name", _table.name)
+      assert_equal("Marks", _table.name)
       called = true
     end
     assert_true(called)
@@ -87,19 +89,19 @@ class TableTest < Test::Unit::TestCase
   end
 
   def test_open_wrong_table
-    table_path = @tables_dir + "table"
-    Groonga::Hash.create(:name => "bookmarks",
+    table_path = @tables_dir + "bookmarks"
+    Groonga::Hash.create(:name => "Bookmarks",
                          :path => table_path.to_s) do
     end
 
     assert_raise(TypeError) do
-      Groonga::PatriciaTrie.open(:name => "bookmarks",
+      Groonga::PatriciaTrie.open(:name => "Bookmarks",
                                  :path => table_path.to_s)
     end
   end
 
   def test_new
-    table_path = @tables_dir + "table"
+    table_path = @tables_dir + "no-name"
     assert_raise(Groonga::NoSuchFileOrDirectory) do
       Groonga::Hash.new(:path => table_path.to_s)
     end
@@ -109,42 +111,108 @@ class TableTest < Test::Unit::TestCase
   end
 
   def test_define_column
-    table_path = @tables_dir + "table"
-    table = Groonga::Hash.create(:name => "bookmarks",
+    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)
+    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
+    name = table.define_column("name", "ShortText")
+    assert_predicate(name, :temporary?)
+  end
+
+  def test_temporary_table_define_index_column_default_persistent
+    bookmarks = Groonga::Hash.create(:name => "Bookmarks")
+    terms = Groonga::Hash.create
+    url = terms.define_index_column("url", bookmarks)
+    assert_predicate(url, :temporary?)
+  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
+      real_name = 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
+      real_name = 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 = "<token:bigram>"
+    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")
+                                      :source => "Bookmarks.content")
     bookmarks.add("google", :content => "Search engine")
     assert_equal(["google"],
                  index.search("engine").collect {|record| record.key.key})
   end
 
   def test_add_column
-    bookmarks = Groonga::Hash.create(:name => "bookmarks",
+    bookmarks = Groonga::Hash.create(:name => "Bookmarks",
                                      :path => (@tables_dir + "bookmarks").to_s)
 
     description_column_path = @columns_dir + "description"
     bookmarks_description =
-      bookmarks.define_index_column("description", "<text>",
+      bookmarks.define_index_column("description", "Text",
                                     :path => description_column_path.to_s)
 
-    books = Groonga::Hash.create(:name => "books",
+    books = Groonga::Hash.create(:name => "Books",
                                  :path => (@tables_dir + "books").to_s)
     books_description = books.add_column("description",
-                                         "<longtext>",
+                                         "LongText",
                                          description_column_path.to_s)
-    assert_equal("books.description", books_description.name)
+    assert_equal("Books.description", books_description.name)
     assert_equal(books_description, books.column("description"))
 
     assert_equal(bookmarks_description, bookmarks.column("description"))
@@ -152,51 +220,46 @@ class TableTest < Test::Unit::TestCase
 
   def test_column_nonexistent
     table_path = @tables_dir + "bookmarks"
-    table = Groonga::Hash.create(:name => "bookmarks",
+    table = Groonga::Hash.create(:name => "Bookmarks",
                                  :path => table_path.to_s)
     assert_nil(table.column("nonexistent"))
   end
 
   def test_set_value
-    value_type = Groonga::Type.new("Text512", :size => 512)
     table_path = @tables_dir + "bookmarks"
-    bookmarks = Groonga::Hash.create(:name => "bookmarks",
-                                     :value_type => value_type,
+    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>",
+      bookmarks.define_column("comment", "ShortText",
                               :type => "scalar",
                               :path => comment_column_path.to_s)
     groonga = bookmarks.add("groonga")
-    url = "http://groonga.org/"
-    groonga.value = url
+    groonga.value = 29
     bookmarks_comment[groonga.id] = "fulltext search engine"
 
-    assert_equal([url, "fulltext search engine"],
-                 [groonga.value[0, url.length],
-                  bookmarks_comment[groonga.id]])
+    assert_equal([29, "fulltext search engine"],
+                 [groonga.value, bookmarks_comment[groonga.id]])
   end
 
   def test_array_set
-    value_type = Groonga::Type.new("Text512", :size => 512)
-    bookmarks = Groonga::Hash.create(:name => "bookmarks",
-                                     :value_type => value_type)
-    url = "http://groonga.org/"
-    bookmarks["groonga"] = "#{url}\0"
+    bookmarks = Groonga::Hash.create(:name => "Bookmarks",
+                                     :value_type => "Int32")
+    bookmarks.set_value("groonga", 29)
 
     values = bookmarks.records.collect do |record|
-      record.value.split(/\0/, 2)[0]
+      record.value
     end
-    assert_equal([url], values)
+    assert_equal([29], values)
   end
 
   def test_add_without_name
     users_path = @tables_dir + "users"
-    users = Groonga::Array.create(:name => "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>",
+    users_name = users.define_column("name", "ShortText",
                                      :path => name_column_path.to_s)
     morita = users.add
     users_name[morita.id] = "morita"
@@ -205,37 +268,34 @@ class TableTest < Test::Unit::TestCase
 
   def test_add_by_id
     users_path = @tables_dir + "users"
-    users = Groonga::Hash.create(:name => "users",
+    users = Groonga::Hash.create(:name => "Users",
                                  :path => users_path.to_s)
 
-    value_type = Groonga::Type.new("Text512", :size => 512)
     bookmarks_path = @tables_dir + "bookmarks"
-    bookmarks = Groonga::Hash.create(:name => "bookmarks",
+    bookmarks = Groonga::Hash.create(:name => "Bookmarks",
                                      :key_type => users,
-                                     :value_type => value_type,
+                                     :value_type => "Int32",
                                      :path => bookmarks_path.to_s)
     morita = users.add("morita")
     groonga = bookmarks.add(morita.id)
-    url = "http://groonga.org/"
-    groonga.value = url
-
-    assert_equal(url, groonga.value[0, url.length])
+    groonga.value = 29
+    assert_equal(29, groonga.value)
   end
 
   def test_columns
     bookmarks_path = @tables_dir + "bookmarks"
-    bookmarks = Groonga::Array.create(:name => "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>")
+    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",
+    bookmarks = Groonga::Array.create(:name => "Bookmarks",
                                       :path => bookmarks_path.to_s)
 
     uri_column = bookmarks.define_column("uri", "Text")
@@ -244,7 +304,7 @@ class TableTest < Test::Unit::TestCase
 
   def test_size
     bookmarks_path = @tables_dir + "bookmarks"
-    bookmarks = Groonga::Array.create(:name => "bookmarks",
+    bookmarks = Groonga::Array.create(:name => "Bookmarks",
                                       :path => bookmarks_path.to_s)
 
     assert_equal(0, bookmarks.size)
@@ -256,11 +316,18 @@ class TableTest < Test::Unit::TestCase
     assert_equal(3, bookmarks.size)
   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",
+    bookmarks = Groonga::Array.create(:name => "Bookmarks",
                                       :path => bookmarks_path.to_s)
-    column = bookmarks.define_column("created_at", "<time>")
+    column = bookmarks.define_column("created_at", "Time")
 
     bookmark = bookmarks.add
     now = Time.now
@@ -271,7 +338,7 @@ class TableTest < Test::Unit::TestCase
 
   def test_delete
     bookmarks_path = @tables_dir + "bookmarks"
-    bookmarks = Groonga::Array.create(:name => "bookmarks",
+    bookmarks = Groonga::Array.create(:name => "Bookmarks",
                                       :path => bookmarks_path.to_s)
 
     bookmark1 = bookmarks.add
@@ -285,7 +352,7 @@ class TableTest < Test::Unit::TestCase
 
   def test_remove
     bookmarks_path = @tables_dir + "bookmarks"
-    bookmarks = Groonga::Array.create(:name => "bookmarks",
+    bookmarks = Groonga::Array.create(:name => "Bookmarks",
                                       :path => bookmarks_path.to_s)
     assert_predicate(bookmarks_path, :exist?)
     bookmarks.remove
@@ -293,15 +360,15 @@ class TableTest < Test::Unit::TestCase
   end
 
   def test_temporary_add
-    table = Groonga::Hash.create(:key_type => "<shorttext>")
+    table = Groonga::Hash.create(:key_type => "ShortText")
     assert_equal(0, table.size)
     table.add("key")
     assert_equal(1, table.size)
   end
 
   def test_each
-    users = Groonga::Array.create(:name => "<users>")
-    user_name = users.define_column("name", "<shorttext>")
+    users = Groonga::Array.create(:name => "Users")
+    user_name = users.define_column("name", "ShortText")
 
     names = ["daijiro", "gunyarakun", "yu"]
     names.each do |name|
@@ -313,7 +380,7 @@ class TableTest < Test::Unit::TestCase
   end
 
   def test_truncate
-    users = Groonga::Array.create(:name => "<users>")
+    users = Groonga::Array.create(:name => "Users")
     users.add
     users.add
     users.add
@@ -325,12 +392,8 @@ class TableTest < Test::Unit::TestCase
   end
 
   def test_sort
-    bookmarks = Groonga::Array.create(:name => "<bookmarks>")
-    id_column = bookmarks.define_column("id", "<int>")
-    100.times do |i|
-      bookmark = bookmarks.add
-      bookmark["id"] = i + 100
-    end
+    bookmarks = create_bookmarks
+    add_shuffled_ids(bookmarks)
 
     results = bookmarks.sort([
                               {
@@ -344,12 +407,8 @@ class TableTest < Test::Unit::TestCase
   end
 
   def test_sort_simple
-    bookmarks = Groonga::Array.create(:name => "<bookmarks>")
-    id_column = bookmarks.define_column("id", "<int>")
-    100.times do |i|
-      bookmark = bookmarks.add
-      bookmark["id"] = i + 100
-    end
+    bookmarks = create_bookmarks
+    add_shuffled_ids(bookmarks)
 
     results = bookmarks.sort(["id"], :limit => 20)
     assert_equal((100..119).to_a,
@@ -357,35 +416,66 @@ class TableTest < Test::Unit::TestCase
   end
 
   def test_sort_by_array
-    bookmarks = Groonga::Array.create(:name => "<bookmarks>")
-    id_column = bookmarks.define_column("id", "<int>")
-    100.times do |i|
-      bookmark = bookmarks.add
-      bookmark["id"] = i + 100
-    end
+    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
-    bookmarks = Groonga::Array.create(:name => "<bookmarks>")
-    id_column = bookmarks.define_column("id", "<int>")
-    100.times do |i|
-      bookmark = bookmarks.add
-      bookmark["id"] = i + 100
-    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
+    omit("maybe crash!!!")
+    bookmarks = create_bookmarks
+    add_shuffled_ids(bookmarks)
+    results = bookmarks.sort([{:key => "nonexistent", :order => :descending}])
+    assert_equal("unknown",
+                 results.collect {|record| record["id"]})
+  end
+
   def test_group
-    bookmarks = Groonga::Hash.create(:name => "<bookmarks>")
-    bookmarks.define_column("title", "<text>")
-    comments = Groonga::Array.create(:name => "<comments>")
+    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")
@@ -409,16 +499,16 @@ class TableTest < Test::Unit::TestCase
     end
     assert_equal([[2, "groonga", "http://groonga.org/"],
                   [1, "Ruby", "http://ruby-lang.org/"]],
-                 records.group([".bookmark"]).collect do |record|
+                 records.group(".bookmark").collect do |record|
                    bookmark = record.key
-                   [record[".:nsubrecs"],
+                   [record.n_sub_records,
                     bookmark["title"],
                     bookmark.key]
                  end)
   end
 
   def test_union!
-    bookmarks = Groonga::Hash.create(:name => "bookmarks")
+    bookmarks = Groonga::Hash.create(:name => "Bookmarks")
     bookmarks.define_column("title", "ShortText")
 
     groonga = bookmarks.add("http://groonga.org/", :title => "groonga")
@@ -448,7 +538,7 @@ class TableTest < Test::Unit::TestCase
   end
 
   def test_difference!
-    bookmarks = Groonga::Hash.create(:name => "bookmarks")
+    bookmarks = Groonga::Hash.create(:name => "Bookmarks")
     bookmarks.define_column("title", "ShortText")
 
     bookmarks.add("http://groonga.org/", :title => "groonga")
@@ -463,23 +553,23 @@ class TableTest < Test::Unit::TestCase
   end
 
   def test_merge!
-    omit("should write a test")
-    bookmarks = Groonga::Hash.create(:name => "bookmarks")
+    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"}
+    ruby_bookmarks = bookmarks.select {|record| (record["title"] == "Ruby") &
+                                                (record["title"] == "Ruby") }
     all_bookmarks = bookmarks.select
-    assert_equal(["groonga"],
+    assert_equal([["groonga", 1], ["Ruby", 2]],
                  all_bookmarks.merge!(ruby_bookmarks).collect do |record|
-                   [record[".title"], record[".:score"]]
+                   [record[".title"], record.score]
                  end)
   end
 
   def test_lock
-    bookmarks = Groonga::Array.create(:name => "<bookmarks>")
+    bookmarks = Groonga::Array.create(:name => "Bookmarks")
     bookmark = bookmarks.add
 
     assert_not_predicate(bookmarks, :locked?)
@@ -490,7 +580,7 @@ class TableTest < Test::Unit::TestCase
   end
 
   def test_lock_failed
-    bookmarks = Groonga::Array.create(:name => "<bookmarks>")
+    bookmarks = Groonga::Array.create(:name => "Bookmarks")
     bookmark = bookmarks.add
 
     bookmarks.lock
@@ -500,7 +590,7 @@ class TableTest < Test::Unit::TestCase
   end
 
   def test_lock_block
-    bookmarks = Groonga::Array.create(:name => "<bookmarks>")
+    bookmarks = Groonga::Array.create(:name => "Bookmarks")
     bookmark = bookmarks.add
 
     assert_not_predicate(bookmarks, :locked?)
@@ -511,7 +601,7 @@ class TableTest < Test::Unit::TestCase
   end
 
   def test_clear_lock
-    bookmarks = Groonga::Array.create(:name => "<bookmarks>")
+    bookmarks = Groonga::Array.create(:name => "Bookmarks")
     bookmark = bookmarks.add
 
     assert_not_predicate(bookmarks, :locked?)
@@ -520,4 +610,33 @@ class TableTest < Test::Unit::TestCase
     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
+
+  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