groonga 0.0.7 → 0.9.0

data/test/test-index-column.rb

@@ -23,11 +23,11 @@ class IndexColumnTest < Test::Unit::TestCase
   end
 
   def test_array_set_with_record
-    articles = Groonga::Array.create(:name => "<articles>")
-    articles.define_column("content", "<text>")
+    articles = Groonga::Array.create(:name => "Articles")
+    articles.define_column("content", "Text")
 
-    terms = Groonga::Hash.create(:name => "<terms>",
-                                 :default_tokenizer => "<token:bigram>")
+    terms = Groonga::Hash.create(:name => "Terms",
+                                 :default_tokenizer => "TokenBigram")
     content_index = terms.define_index_column("content", articles,
                                               :with_section => true)
 
@@ -56,13 +56,13 @@ class IndexColumnTest < Test::Unit::TestCase
   end
 
   def test_shorter_query_than_ngram
-    articles = Groonga::Array.create(:name => "<articles>")
-    articles.define_column("content", "<text>")
+    articles = Groonga::Array.create(:name => "Articles")
+    articles.define_column("content", "Text")
 
-    terms = Groonga::PatriciaTrie.create(:name => "<terms>",
-                                         :default_tokenizer => "<token:bigram>")
+    terms = Groonga::PatriciaTrie.create(:name => "Terms",
+                                         :default_tokenizer => "TokenBigram")
     content_index = terms.define_index_column("content", articles,
-                                              :source => "<articles>.content")
+                                              :source => "Articles.content")
     articles.add(:content => 'l')
     articles.add(:content => 'll')
     articles.add(:content => 'hello')

data/test/test-patricia-trie.rb

@@ -27,19 +27,17 @@ class PatriciaTrieTest < Test::Unit::TestCase
   def test_tokenizer
     trie = Groonga::PatriciaTrie.create
     assert_nil(trie.default_tokenizer)
-    trie.default_tokenizer = "<token:trigram>"
-    assert_equal(Groonga::Context.default["<token:trigram>"],
+    trie.default_tokenizer = "TokenTrigram"
+    assert_equal(Groonga::Context.default["TokenTrigram"],
                  trie.default_tokenizer)
   end
 
   def test_search
-    omit("creating entry is broken.")
+    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>")
-
-    bookmarks = Groonga::PatriciaTrie.create(:name => "<bookmarks>",
-                                             :key_type => "<shorttext>")
+    bookmarks = Groonga::PatriciaTrie.create(:name => "Bookmarks",
+                                             :key_type => "ShortText")
     bookmark_user_id = bookmarks.define_column("user_id", users)
 
     daijiro = users.add
@@ -56,35 +54,35 @@ class PatriciaTrieTest < Test::Unit::TestCase
   end
 
   def test_add
-    users = Groonga::PatriciaTrie.create(:name => "<users>")
+    users = Groonga::PatriciaTrie.create(:name => "Users")
     users.define_column("address", "<text>")
     me = users.add("me", :address => "me@example.com")
     assert_equal("me@example.com", me[:address])
   end
 
   def test_default_tokenizer_on_create
-    terms = Groonga::PatriciaTrie.create(:name => "<terms>",
-                                         :default_tokenizer => "<token:unigram>")
+    terms = Groonga::PatriciaTrie.create(:name => "Terms",
+                                         :default_tokenizer => "TokenUnigram")
     assert_equal(context[Groonga::Type::UNIGRAM],
                  terms.default_tokenizer)
   end
 
   def test_duplicated_name
-    Groonga::PatriciaTrie.create(:name => "<users>")
+    Groonga::PatriciaTrie.create(:name => "Users")
     assert_raise(Groonga::InvalidArgument) do
-      Groonga::PatriciaTrie.create(:name => "<users>")
+      Groonga::PatriciaTrie.create(:name => "Users")
     end
   end
 
   def test_open_same_name
-    users_created = Groonga::PatriciaTrie.create(:name => "<users>")
-    users_opened = Groonga::PatriciaTrie.open(:name => "<users>")
+    users_created = Groonga::PatriciaTrie.create(:name => "Users")
+    users_opened = Groonga::PatriciaTrie.open(:name => "Users")
     users_opened.add("morita")
     assert_equal(1, users_created.size)
   end
 
   def test_has_key?
-    users = Groonga::PatriciaTrie.create(:name => "<users>")
+    users = Groonga::PatriciaTrie.create(:name => "Users")
     assert_false(users.has_key?("morita"))
     users.add("morita")
     assert_true(users.has_key?("morita"))
@@ -95,28 +93,31 @@ class PatriciaTrieTest < Test::Unit::TestCase
     words = Groonga::PatriciaTrie.create(:key_type => "ShortText",
                                          :key_normalize => true)
     words.add("リンク")
+    arupaka = words.add("アルパカ")
+    words.add("アルパカ(生物)")
     adventure_of_link = words.add('リンクの冒険')
     words.add('冒険')
     gaxtu = words.add('ｶﾞｯ')
     muteki = words.add('ＭＵＴＥＫＩ')
     assert_equal([[muteki, "muTEki", 0, 6],
                   [adventure_of_link, "リンクの冒険", 7, 18],
-                  [gaxtu, "ガッ", 42, 6]],
-                 words.scan('muTEki リンクの冒険 ミリバール ガッ'))
+                  [arupaka, "アルパカ", 42, 12],
+                  [gaxtu, "ガッ", 55, 6]],
+                 words.scan('muTEki リンクの冒険 ミリバール アルパカ ガッ'))
   end
 
   def test_tag_keys
     Groonga::Context.default_options = {:encoding => "utf-8"}
     words = Groonga::PatriciaTrie.create(:key_type => "ShortText",
                                          :key_normalize => true)
-    words.add("リンク")
+    words.add('リンク')
     words.add('リンクの冒険')
     words.add('冒険')
     words.add('㍊')
     words.add('ｶﾞｯ')
     words.add('ＭＵＴＥＫＩ')
 
-    text = 'muTEki リンクの冒険 マッチしない ミリバール ガッ'
+    text = 'muTEki リンクの冒険 マッチしない ミリバール ガッ おわり'
     actual = words.tag_keys(text) do |record, word|
       "<#{word}(#{record.key})>"
     end
@@ -124,7 +125,65 @@ class PatriciaTrieTest < Test::Unit::TestCase
                  "<リンクの冒険(リンクの冒険)> " +
                  "マッチしない " +
                  "<ミリバール(ミリバール)> " +
+                 "<ガッ(ガッ)> " +
+                 "おわり",
+                 actual)
+  end
+
+  def test_tag_keys_with_last_match
+    Groonga::Context.default_options = {:encoding => "utf-8"}
+    words = Groonga::PatriciaTrie.create(:key_type => "ShortText",
+                                         :key_normalize => true)
+    words.add('ｶﾞｯ')
+    words.add('ＭＵＴＥＫＩ')
+
+    text = 'muTEki マッチしない ガッ'
+    actual = words.tag_keys(text) do |record, word|
+      "<#{word}(#{record.key})>"
+    end
+    assert_equal("<muTEki(muteki)> " +
+                 "マッチしない " +
                  "<ガッ(ガッ)>",
                  actual)
   end
+
+  def test_tag_keys_with_no_match
+    Groonga::Context.default_options = {:encoding => "utf-8"}
+    words = Groonga::PatriciaTrie.create(:key_type => "ShortText",
+                                         :key_normalize => true)
+
+    words.add('無敵')
+    words.add('ＢＯＵＫＥＮ')
+
+    text = 'muTEki リンクの冒険'
+    actual = words.tag_keys(text) do |record, word|
+      "<#{word}(#{record.key})>"
+    end
+    assert_equal(text, actual)
+  end
+
+  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')
+
+    records = paths.prefix_search('/')
+    assert_equal(["/usr/local/bin", "/usr/bin", "/tmp", "/"],
+                 records.records.collect {|record| record["._key"]})
+
+    records = paths.prefix_search('/usr')
+    assert_equal(["/usr/local/bin", "/usr/bin"],
+                 records.records.collect {|record| record["._key"]})
+
+    records = paths.prefix_search('/usr/local')
+    assert_equal(["/usr/local/bin"],
+                 records.records.collect {|record| record["._key"]})
+
+    records = paths.prefix_search('nonexistent')
+    assert_equal([],
+                 records.records.collect {|record| record["._key"]})
+  end
 end

data/test/test-procedure.rb

@@ -23,12 +23,14 @@ class ProcedureTest < Test::Unit::TestCase
     assert_equal_procedure("TokenUnigram", Groonga::Procedure::UNIGRAM)
     assert_equal_procedure("TokenBigram", Groonga::Procedure::BIGRAM)
     assert_equal_procedure("TokenTrigram", Groonga::Procedure::TRIGRAM)
-    assert_equal_procedure("TokenMecab", Groonga::Procedure::MECAB)
+    assert_equal_procedure("TokenMecab", Groonga::Procedure::MECAB,
+                           :accept_nil => true)
   end
 
   private
-  def assert_equal_procedure(expected_name, id)
+  def assert_equal_procedure(expected_name, id, options={})
     procedure = Groonga::Context.default[id]
+    expected_name = nil if procedure.nil? and options[:accept_nil]
     assert_equal(expected_name,
                  procedure ? procedure.name : procedure)
   end

data/test/test-record.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
@@ -27,23 +27,23 @@ class RecordTest < Test::Unit::TestCase
 
   def setup_addresses_table
     @addresses_path = @tables_dir + "addresses"
-    @addresses = Groonga::Array.create(:name => "addresses",
+    @addresses = Groonga::Array.create(:name => "Addresses",
                                        :path => @addresses_path.to_s)
 
     @addresses_mail_column_path = @columns_dir + "mail"
     @addresses_mail_column =
-      @addresses.define_column("mail", "<shorttext>",
+      @addresses.define_column("mail", "ShortText",
                                :path => @addresses_mail_column_path.to_s)
   end
 
   def setup_users_table
     @users_path = @tables_dir + "users"
-    @users = Groonga::Array.create(:name => "users",
+    @users = Groonga::Array.create(:name => "Users",
                                    :path => @users_path.to_s)
 
     @users_name_column_path = @columns_dir + "name"
     @users_name_column =
-      @users.define_column("name", "<shorttext>",
+      @users.define_column("name", "ShortText",
                            :path => @users_name_column_path.to_s)
 
     @users_addresses_column_path = @columns_dir + "addresses"
@@ -55,26 +55,25 @@ class RecordTest < Test::Unit::TestCase
 
   def setup_bookmarks_table
     @bookmarks_path = @tables_dir + "bookmarks"
-    value_type = Groonga::Type.new("Text512", :size => 512)
-    @bookmarks = Groonga::Array.create(:name => "bookmarks",
-                                       :value_type => value_type,
+    @bookmarks = Groonga::Array.create(:name => "Bookmarks",
+                                       :value_type => "Int32",
                                        :path => @bookmarks_path.to_s)
 
     @uri_column_path = @columns_dir + "uri"
-    @bookmarks_uri = @bookmarks.define_column("uri", "<shorttext>",
+    @bookmarks_uri = @bookmarks.define_column("uri", "ShortText",
                                               :path => @uri_column_path.to_s)
 
     @rate_column_path = @columns_dir + "rate"
-    @bookmarks_rate = @bookmarks.define_column("rate", "<int>",
+    @bookmarks_rate = @bookmarks.define_column("rate", "Int32",
                                                :path => @rate_column_path.to_s)
 
     @comment_column_path = @columns_dir + "comment"
     @bookmarks_comment =
-      @bookmarks.define_column("comment", "<text>",
+      @bookmarks.define_column("comment", "Text",
                                :path => @comment_column_path.to_s)
 
     @content_column_path = @columns_dir + "content"
-    @bookmarks_content = @bookmarks.define_column("content", "<longtext>")
+    @bookmarks_content = @bookmarks.define_column("content", "LongText")
 
     @user_column_path = @columns_dir + "user"
     @bookmarks_user = @bookmarks.define_column("user", @users)
@@ -83,7 +82,7 @@ class RecordTest < Test::Unit::TestCase
   def setup_indexes
     @bookmarks_index_path = @tables_dir + "bookmarks-index"
     @bookmarks_index =
-      Groonga::PatriciaTrie.create(:name => "bookmarks-index",
+      Groonga::PatriciaTrie.create(:name => "BookmarksIndex",
                                    :path => @bookmarks_index_path.to_s)
     @bookmarks_index.default_tokenizer = "TokenBigram"
 
@@ -122,14 +121,14 @@ class RecordTest < Test::Unit::TestCase
 
   def test_get_nonexistent_column
     groonga = @bookmarks.add
-    assert_raise(Groonga::InvalidArgument) do
+    assert_raise(Groonga::NoSuchColumn) do
       groonga["nonexistent"]
     end
   end
 
   def test_set_nonexistent_column
     groonga = @bookmarks.add
-    assert_raise(Groonga::InvalidArgument) do
+    assert_raise(Groonga::NoSuchColumn) do
       groonga["nonexistent"] = "value"
     end
   end
@@ -160,17 +159,17 @@ class RecordTest < Test::Unit::TestCase
   end
 
   def test_key
-    documents = Groonga::PatriciaTrie.create(:name => "<documents>",
-                                             :key_type => "<shorttext>")
+    documents = Groonga::PatriciaTrie.create(:name => "Documents",
+                                             :key_type => "ShortText")
     reference = documents.add("reference")
     assert_equal("reference", reference.key)
   end
 
   def test_value
     bookmark = @bookmarks.add
-    assert_equal("", bookmark.value.split(/\0/, 2)[0])
-    bookmark.value = "http://groonga.org/\0"
-    assert_equal("http://groonga.org/", bookmark.value.split(/\0/, 2)[0])
+    assert_equal(0, bookmark.value)
+    bookmark.value = 100
+    assert_equal(100, bookmark.value)
   end
 
   def test_reference_column?
@@ -253,4 +252,17 @@ class RecordTest < Test::Unit::TestCase
     groonga.clear_lock
     assert_not_predicate(groonga, :locked?)
   end
+
+  def test_attributes
+    values = {
+      "uri" => "http://groonga.org/",
+      "rate" => 5,
+      "comment" => "Grate!"
+    }
+    groonga = @bookmarks.add(values)
+    assert_equal(values.merge("id" => groonga.id,
+                              "content" => nil,
+                              "user" => nil),
+                 groonga.attributes)
+  end
 end

data/test/test-remote.rb

@@ -46,7 +46,8 @@ class RemoteTest < Test::Unit::TestCase
     assert_equal(0, _context.send("status"))
     id, result = _context.receive
     assert_equal(0, id)
-    assert_equal(["alloc_count", "starttime", "uptime"],
-                 JSON.load(result).keys.sort)
+    return_code, values = JSON.load(result)
+    assert_equal([[0], ["alloc_count", "starttime", "uptime"]],
+                 [return_code, values.keys.sort])
   end
 end

data/test/test-schema.rb

@@ -19,54 +19,57 @@ class SchemaTest < Test::Unit::TestCase
   setup :setup_database
 
   def test_create_table
-    assert_nil(context["<posts>"])
-    Groonga::Schema.create_table("<posts>") do |table|
+    assert_nil(context["Posts"])
+    Groonga::Schema.create_table("Posts") do |table|
     end
-    assert_not_nil(context["<posts>"])
+    assert_not_nil(context["Posts"])
   end
 
   def test_create_table_force
-    Groonga::Schema.create_table("posts") do |table|
+    Groonga::Schema.create_table("Posts") do |table|
+      table.string("name")
     end
-    assert_raise(Groonga::InvalidArgument) do
-      Groonga::Schema.create_table("posts") do |table|
-      end
+    assert_not_nil(context["Posts.name"])
+
+    Groonga::Schema.create_table("Posts") do |table|
     end
-    Groonga::Schema.create_table("posts", :force => true) do |table|
+    assert_not_nil(context["Posts.name"])
+
+    Groonga::Schema.create_table("Posts", :force => true) do |table|
     end
+    assert_nil(context["Posts.name"])
   end
 
   def test_remove_table
-    Groonga::Array.create(:name => "posts")
-    assert_not_nil(context["posts"])
-    Groonga::Schema.remove_table("posts")
-    assert_nil(context["posts"])
+    Groonga::Array.create(:name => "Posts")
+    assert_not_nil(context["Posts"])
+    Groonga::Schema.remove_table("Posts")
+    assert_nil(context["Posts"])
   end
 
   def test_define_hash
-    Groonga::Schema.create_table("<posts>", :type => :hash) do |table|
+    Groonga::Schema.create_table("Posts", :type => :hash) do |table|
     end
-    assert_kind_of(Groonga::Hash, context["<posts>"])
+    assert_kind_of(Groonga::Hash, context["Posts"])
   end
 
   def test_define_hash_with_full_option
     path = @tmp_dir + "hash.groonga"
-    tokenizer = context["<token:trigram>"]
-    type = Groonga::Type.new("Niku", :size => 29)
-    Groonga::Schema.create_table("<posts>",
+    tokenizer = context["TokenTrigram"]
+    Groonga::Schema.create_table("Posts",
                                  :type => :hash,
                                  :key_type => "integer",
                                  :path => path.to_s,
-                                 :value_type => type,
+                                 :value_type => "UInt32",
                                  :default_tokenizer => tokenizer) do |table|
     end
-    table = context["<posts>"]
+    table = context["Posts"]
     assert_equal("#<Groonga::Hash " +
                  "id: <#{table.id}>, " +
-                 "name: <<posts>>, " +
+                 "name: <Posts>, " +
                  "path: <#{path}>, " +
-                 "domain: <#{context['<int>'].inspect}>, " +
-                 "range: <#{type.inspect}>, " +
+                 "domain: <Int32>, " +
+                 "range: <UInt32>, " +
                  "flags: <>, " +
                  "encoding: <#{Groonga::Encoding.default.inspect}>, " +
                  "size: <0>>",
@@ -75,167 +78,278 @@ class SchemaTest < Test::Unit::TestCase
   end
 
   def test_define_patricia_trie
-    Groonga::Schema.create_table("<posts>", :type => :patricia_trie) do |table|
+    Groonga::Schema.create_table("Posts", :type => :patricia_trie) do |table|
     end
-    assert_kind_of(Groonga::PatriciaTrie, context["<posts>"])
+    assert_kind_of(Groonga::PatriciaTrie, context["Posts"])
   end
 
   def test_define_patricia_trie_with_full_option
     path = @tmp_dir + "patricia-trie.groonga"
-    type = Groonga::Type.new("Niku", :size => 29)
-    Groonga::Schema.create_table("<posts>",
+    Groonga::Schema.create_table("Posts",
                                  :type => :patricia_trie,
                                  :key_type => "integer",
                                  :path => path.to_s,
-                                 :value_type => type,
-                                 :default_tokenizer => "<token:bigram>",
+                                 :value_type => "Float",
+                                 :default_tokenizer => "TokenBigram",
                                  :key_normalize => true,
                                  :key_with_sis => true) do |table|
     end
-    table = context["<posts>"]
+    table = context["Posts"]
     assert_equal("#<Groonga::PatriciaTrie " +
                  "id: <#{table.id}>, " +
-                 "name: <<posts>>, " +
+                 "name: <Posts>, " +
                  "path: <#{path}>, " +
-                 "domain: <#{context['<int>'].inspect}>, " +
-                 "range: <#{type.inspect}>, " +
+                 "domain: <Int32>, " +
+                 "range: <Float>, " +
                  "flags: <KEY_WITH_SIS|KEY_NORMALIZE|WITH_SECTION>, " +
                  "encoding: <#{Groonga::Encoding.default.inspect}>, " +
                  "size: <0>>",
                  table.inspect)
-    assert_equal(context["<token:bigram>"], table.default_tokenizer)
+    assert_equal(context["TokenBigram"], table.default_tokenizer)
   end
 
   def test_define_array
-    Groonga::Schema.create_table("<posts>", :type => :array) do |table|
+    Groonga::Schema.create_table("Posts", :type => :array) do |table|
     end
-    assert_kind_of(Groonga::Array, context["<posts>"])
+    assert_kind_of(Groonga::Array, context["Posts"])
   end
 
   def test_define_array_with_full_option
     path = @tmp_dir + "array.groonga"
-    type = Groonga::Type.new("Niku", :size => 29)
-    Groonga::Schema.create_table("<posts>",
+    Groonga::Schema.create_table("Posts",
                                  :type => :array,
                                  :path => path.to_s,
-                                 :value_type => type) do |table|
+                                 :value_type => "Int32") do |table|
     end
-    table = context["<posts>"]
+    table = context["Posts"]
     assert_equal("#<Groonga::Array " +
                  "id: <#{table.id}>, " +
-                 "name: <<posts>>, " +
+                 "name: <Posts>, " +
                  "path: <#{path}>, " +
-                 "domain: <#{type.inspect}>, " +
-                 "range: <#{type.inspect}>, " +
+                 "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)
+  end
+
   def test_integer32_column
-    assert_nil(context["<posts>.rate"])
-    Groonga::Schema.create_table("<posts>") do |table|
+    assert_nil(context["Posts.rate"])
+    Groonga::Schema.create_table("Posts") do |table|
       table.integer32 :rate
     end
-    assert_equal(context["<int>"], context["<posts>.rate"].range)
+    assert_equal(context["Int32"], context["Posts.rate"].range)
   end
 
   def test_integer64_column
-    assert_nil(context["<posts>.rate"])
-    Groonga::Schema.create_table("<posts>") do |table|
+    assert_nil(context["Posts.rate"])
+    Groonga::Schema.create_table("Posts") do |table|
       table.integer64 :rate
     end
-    assert_equal(context["<int64>"], context["<posts>.rate"].range)
+    assert_equal(context["Int64"], context["Posts.rate"].range)
   end
 
   def test_unsigned_integer32_column
-    assert_nil(context["<posts>.n_viewed"])
-    Groonga::Schema.create_table("<posts>") do |table|
+    assert_nil(context["Posts.n_viewed"])
+    Groonga::Schema.create_table("Posts") do |table|
       table.unsigned_integer32 :n_viewed
     end
-    assert_equal(context["<uint>"], context["<posts>.n_viewed"].range)
+    assert_equal(context["UInt32"], context["Posts.n_viewed"].range)
   end
 
   def test_unsigned_integer64_column
-    assert_nil(context["<posts>.n_viewed"])
-    Groonga::Schema.create_table("<posts>") do |table|
+    assert_nil(context["Posts.n_viewed"])
+    Groonga::Schema.create_table("Posts") do |table|
       table.unsigned_integer64 :n_viewed
     end
-    assert_equal(context["<uint64>"], context["<posts>.n_viewed"].range)
+    assert_equal(context["UInt64"], context["Posts.n_viewed"].range)
   end
 
   def test_float_column
-    assert_nil(context["<posts>.rate"])
-    Groonga::Schema.create_table("<posts>") do |table|
+    assert_nil(context["Posts.rate"])
+    Groonga::Schema.create_table("Posts") do |table|
       table.float :rate
     end
-    assert_equal(context["<float>"], context["<posts>.rate"].range)
+    assert_equal(context["Float"], context["Posts.rate"].range)
   end
 
   def test_time_column
-    assert_nil(context["<posts>.last_modified"])
-    Groonga::Schema.create_table("<posts>") do |table|
+    assert_nil(context["Posts.last_modified"])
+    Groonga::Schema.create_table("Posts") do |table|
       table.time :last_modified
     end
-    assert_equal(context["<time>"], context["<posts>.last_modified"].range)
+    assert_equal(context["Time"], context["Posts.last_modified"].range)
   end
 
   def test_short_text_column
-    assert_nil(context["<posts>.title"])
-    Groonga::Schema.create_table("<posts>") do |table|
+    assert_nil(context["Posts.title"])
+    Groonga::Schema.create_table("Posts") do |table|
       table.short_text :title
     end
-    assert_equal(context["<shorttext>"], context["<posts>.title"].range)
+    assert_equal(context["ShortText"], context["Posts.title"].range)
   end
 
   def test_text_column
-    assert_nil(context["<posts>.comment"])
-    Groonga::Schema.create_table("<posts>") do |table|
+    assert_nil(context["Posts.comment"])
+    Groonga::Schema.create_table("Posts") do |table|
       table.text :comment
     end
-    assert_equal(context["<text>"], context["<posts>.comment"].range)
+    assert_equal(context["Text"], context["Posts.comment"].range)
   end
 
   def test_long_text_column
-    assert_nil(context["<posts>.content"])
-    Groonga::Schema.create_table("<posts>") do |table|
+    assert_nil(context["Posts.content"])
+    Groonga::Schema.create_table("Posts") do |table|
       table.long_text :content
     end
-    assert_equal(context["<longtext>"], context["<posts>.content"].range)
+    assert_equal(context["LongText"], context["Posts.content"].range)
   end
 
   def test_remove_column
-    Groonga::Schema.create_table("posts") do |table|
+    Groonga::Schema.create_table("Posts") do |table|
       table.long_text :content
     end
-    assert_not_nil(context["posts.content"])
+    assert_not_nil(context["Posts.content"])
 
-    Groonga::Schema.change_table("posts") do |table|
+    Groonga::Schema.change_table("Posts") do |table|
       table.remove_column("content")
     end
-    assert_nil(context["posts.content"])
+    assert_nil(context["Posts.content"])
+  end
+
+  def test_column_again
+    Groonga::Schema.create_table("Posts") do |table|
+      table.text :content
+    end
+
+    assert_nothing_raised do
+      Groonga::Schema.create_table("Posts") do |table|
+        table.text :content
+      end
+    end
+  end
+
+  def test_column_again_with_difference_type
+    Groonga::Schema.create_table("Posts") do |table|
+      table.text :content
+    end
+
+    assert_raise(ArgumentError) do
+      Groonga::Schema.create_table("Posts") do |table|
+        table.integer :content
+      end
+    end
   end
 
   def test_index
-    assert_nil(context["<terms>.content"])
-    Groonga::Schema.create_table("<posts>") do |table|
+    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"
+    Groonga::Schema.create_table("Terms") do |table|
+      table.index "Posts.content"
+    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"
+
+    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|" +
+                         "UNIT_DOCUMENT_SECTION|UNIT_DOCUMENT_POSITION|" +
+                         "UNIT_USERDEF_DOCUMENT|UNIT_USERDEF_SECTION>>",
+                 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"
+    end
+
+    assert_nothing_raised do
+      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"
+    end
+
+    assert_raise(ArgumentError) do
+      Groonga::Schema.create_table("Terms") do |table|
+        table.index "Posts.name", :name => "Posts_content"
+      end
     end
-    assert_equal([context["<posts>.content"]],
-                 context["<terms>.<posts>_content"].sources)
   end
 
   def test_dump
     Groonga::Schema.define do |schema|
-      schema.create_table("posts") do |table|
+      schema.create_table("Posts") do |table|
         table.short_text :title
       end
     end
     assert_equal(<<-EOS, Groonga::Schema.dump)
-create_table("posts") do |table|
+create_table("Posts") do |table|
   table.short_text("title")
 end
 EOS
@@ -243,40 +357,60 @@ EOS
 
   def test_reference_dump
     Groonga::Schema.define do |schema|
-      schema.create_table("items") do |table|
+      schema.create_table("Items") do |table|
         table.short_text("title")
       end
 
-      schema.create_table("users") do |table|
+      schema.create_table("Users") do |table|
         table.short_text("name")
       end
 
-      schema.create_table("comments") do |table|
-        table.reference("item", "items")
-        table.reference("author", "users")
+      schema.create_table("Comments") do |table|
+        table.reference("item", "Items")
+        table.reference("author", "Users")
         table.text("content")
         table.time("issued")
       end
     end
 
     assert_equal(<<-EOS, Groonga::Schema.dump)
-create_table("comments") do |table|
+create_table("Comments") do |table|
   table.text("content")
   table.time("issued")
 end
 
-create_table("items") do |table|
+create_table("Items") do |table|
   table.short_text("title")
 end
 
-create_table("users") do |table|
+create_table("Users") do |table|
   table.short_text("name")
 end
 
-change_table("comments") do |table|
-  table.reference("author", "users")
-  table.reference("item", "items")
+change_table("Comments") do |table|
+  table.reference("author", "Users")
+  table.reference("item", "Items")
 end
 EOS
   end
+
+  def test_explicit_context_create_table
+    context = Groonga::Context.default
+    Groonga::Context.default = nil
+
+    Groonga::Schema.define(:context => context) do |schema|
+      schema.create_table('Items', :type => :hash) do |table|
+        table.text("text")
+      end
+      schema.create_table("TermsText",
+                          :type => :patricia_trie,
+                          :key_normalize => true,
+                          :default_tokenizer => "TokenBigram") do |table|
+        table.index('Items.text')
+      end
+    end
+
+    assert_not_nil(context["Items.text"])
+    assert_not_nil(context["TermsText.Items_text"])
+  end
 end