rroonga 2.0.4-x86-mingw32 → 2.0.7-x86-mingw32

data/test/test-hash.rb

@@ -0,0 +1,367 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2009-2012  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 HashTest < Test::Unit::TestCase
+  include GroongaTestUtils
+
+  setup :setup_database
+
+  def test_support_key?
+    assert_predicate(Groonga::Hash.create(:name => "Users",
+                                          :key_type => "ShortText"),
+                     :support_key?)
+  end
+
+  def test_delete
+    bookmarks_path = @tables_dir + "bookmarks"
+    bookmarks = Groonga::Hash.create(:name => "Bookmarks",
+                                     :path => bookmarks_path.to_s)
+
+    bookmarks.add("groonga")
+    google = bookmarks.add("Google")
+    cutter = bookmarks.add("Cutter")
+
+    assert_equal(["groonga", "Google", "Cutter"],
+                 bookmarks.collect {|bookmark| bookmark.key})
+
+    bookmarks.delete(google.id)
+    assert_equal(["groonga", "Cutter"],
+                 bookmarks.collect {|bookmark| bookmark.key})
+
+    bookmarks.delete(cutter.key)
+    assert_equal(["groonga"],
+                 bookmarks.collect {|bookmark| bookmark.key})
+  end
+
+  def test_value
+    bookmarks_path = @tables_dir + "bookmarks"
+    bookmarks = Groonga::Hash.create(:name => "Bookmarks",
+                                     :path => bookmarks_path.to_s,
+                                     :key_type => "ShortText",
+                                     :value_type => "UInt32")
+    bookmarks.set_value("http://google.com/", 29)
+    assert_equal(29, bookmarks.value("http://google.com/"))
+  end
+
+  def test_column_value
+    bookmarks_path = @tables_dir + "bookmarks"
+    bookmarks = Groonga::Hash.create(:name => "Bookmarks",
+                                     :path => bookmarks_path.to_s,
+                                     :key_type => "ShortText")
+    bookmarks.define_column("uri", "ShortText")
+    bookmarks.set_column_value("google", "uri", "http://google.com/")
+    assert_equal("http://google.com/", bookmarks.column_value("google", "uri"))
+  end
+
+  def test_array_reference
+    bookmarks_path = @tables_dir + "bookmarks"
+    bookmarks = Groonga::Hash.create(:name => "bookmarks",
+                                     :path => bookmarks_path.to_s,
+                                     :key_type => "ShortText")
+    bookmark = bookmarks.add("http://google.com/")
+    assert_equal(bookmark, bookmarks["http://google.com/"])
+  end
+
+  def test_inspect_anonymous
+    path = @tables_dir + "anoymous.groonga"
+    anonymous_table = Groonga::Hash.create(:path => path.to_s)
+    assert_equal("#<Groonga::Hash " +
+                 "id: <#{anonymous_table.id}>, " +
+                 "name: (anonymous), " +
+                 "path: <#{path}>, " +
+                 "domain: <ShortText>, " +
+                 "range: (nil), " +
+                 "flags: <>, " +
+                 "encoding: <#{encoding.inspect}>, " +
+                 "size: <0>>",
+                 anonymous_table.inspect)
+  end
+
+  def test_inspect_anonymous_temporary
+    anonymous_table = Groonga::Hash.create
+    assert_equal("#<Groonga::Hash " +
+                 "id: <#{anonymous_table.id}>, " +
+                 "name: (anonymous), " +
+                 "path: (temporary), " +
+                 "domain: <ShortText>, " +
+                 "range: (nil), " +
+                 "flags: <>, " +
+                 "encoding: <#{encoding.inspect}>, " +
+                 "size: <0>>",
+                 anonymous_table.inspect)
+  end
+
+  def test_inspect_named
+    path = @tables_dir + "named.groonga"
+    named_table = Groonga::Hash.create(:name => "Users", :path => path.to_s)
+    assert_equal("#<Groonga::Hash " +
+                 "id: <#{named_table.id}>, " +
+                 "name: <Users>, " +
+                 "path: <#{path}>, " +
+                 "domain: <ShortText>, " +
+                 "range: (nil), " +
+                 "flags: <>, " +
+                 "encoding: <#{encoding.inspect}>, " +
+                 "size: <0>>",
+                 named_table.inspect)
+  end
+
+  def test_inspect_temporary
+    named_table = Groonga::Hash.create
+    assert_equal("#<Groonga::Hash " +
+                 "id: <#{named_table.id}>, " +
+                 "name: (anonymous), " +
+                 "path: (temporary), " +
+                 "domain: <ShortText>, " +
+                 "range: (nil), " +
+                 "flags: <>, " +
+                 "encoding: <#{encoding.inspect}>, " +
+                 "size: <0>>",
+                 named_table.inspect)
+  end
+
+  def test_encoding
+    assert_equal(Groonga::Encoding.default,
+                 Groonga::Hash.create.encoding)
+  end
+
+  def test_tokenizer
+    hash = Groonga::Hash.create
+    assert_nil(hash.default_tokenizer)
+    hash.default_tokenizer = "TokenBigram"
+    assert_equal(Groonga::Context.default["TokenBigram"],
+                 hash.default_tokenizer)
+  end
+
+  def test_search
+    users = Groonga::Array.create(:name => "Users")
+    users.define_column("name", "ShortText")
+
+    bookmarks = Groonga::Hash.create(:name => "Bookmarks",
+                                     :key_type => "ShortText")
+    bookmarks.define_column("user_id", users)
+
+    daijiro = users.add
+    daijiro["name"] = "daijiro"
+    gunyarakun = users.add
+    gunyarakun["name"] = "gunyarakun"
+
+    groonga = bookmarks.add("http://groonga.org/")
+    groonga["user_id"] = daijiro
+
+    records = bookmarks.search("http://groonga.org/")
+    assert_equal(["daijiro"],
+                 records.records.collect {|record| record["user_id.name"]})
+  end
+
+  def test_add
+    users = Groonga::Hash.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::Hash.create(:name => "Terms",
+                                 :default_tokenizer => "TokenTrigram")
+    assert_equal(context[Groonga::Type::TRIGRAM],
+                 terms.default_tokenizer)
+  end
+
+  def test_duplicated_name
+    Groonga::Hash.create(:name => "Users")
+    assert_raise(Groonga::InvalidArgument) do
+      Groonga::Hash.create(:name => "Users")
+    end
+  end
+
+  def test_define_index_column_implicit_with_position
+    bookmarks = Groonga::Hash.create(:name => "Bookmarks")
+    bookmarks.define_column("comment", "Text")
+    terms = Groonga::Hash.create(:name => "Terms",
+                                 :default_tokenizer => "TokenBigram")
+    index = terms.define_index_column("comment", bookmarks,
+                                      :source => "Bookmarks.comment")
+    bookmarks.add("groonga", :comment => "search engine by Brazil")
+    bookmarks.add("google", :comment => "search engine by Google")
+    bookmarks.add("ruby", :comment => "programing language")
+
+    assert_equal(["groonga", "google"],
+                 index.search("engine").collect {|record| record.key.key})
+  end
+
+  def test_has_key?
+    users = Groonga::Hash.create(:name => "Users")
+    assert_false(users.has_key?("morita"))
+    users.add("morita")
+    assert_true(users.has_key?("morita"))
+  end
+
+  def test_big_key
+    hash = Groonga::Hash.create(:key_type => "UInt64")
+    assert_nothing_raised do
+      hash.add(1 << 63)
+    end
+  end
+
+  def test_value_by_key
+    users = Groonga::Hash.create(:key_type => "ShortText",
+                                 :value_type => "Int32")
+    key = "niku"
+    users.add(key)
+    users.set_value(key, 29)
+    assert_equal(29, users.value(key))
+  end
+
+  def test_value_by_id
+    users = Groonga::Hash.create(:key_type => "ShortText",
+                                 :value_type => "Int32")
+    user_id = users.add("niku").id
+    users.set_value(user_id, 29, :id => true)
+    assert_equal(29, users.value(user_id, :id => true))
+  end
+
+  def test_id
+    users = Groonga::Hash.create(:key_type => "ShortText")
+
+    key = "niku"
+    assert_nil(users.id(key))
+    user_id = users.add(key).id
+    assert_equal(user_id, users.id(key))
+  end
+
+  def test_set_multi_values
+    users = Groonga::Hash.create(:name => "Users",
+                                 :key_type => "ShortText")
+    users.define_column("self_introduction", "ShortText")
+    users.define_column("age", "UInt32")
+
+    key = "niku"
+    niku = users.add(key)
+    assert_equal({
+                   "_id" => niku.id,
+                   "_key" => key,
+                   "self_introduction" => nil,
+                   "age" => 0,
+                 },
+                 niku.attributes)
+    users[key] = {
+      "self_introduction" => "I'm a meet lover.",
+      "age" => 29
+    }
+    assert_equal({
+                   "_id" => niku.id,
+                   "_key" => key,
+                   "self_introduction" => "I'm a meet lover.",
+                   "age" => 29,
+                 },
+                 niku.attributes)
+  end
+
+  def test_set_multi_values_for_nonexistent_record
+    users = Groonga::Hash.create(:name => "Users",
+                                 :key_type => "ShortText")
+    users.define_column("self_introduction", "ShortText")
+    users.define_column("age", "UInt32")
+
+    key = "niku"
+    users[key] = {
+      "self_introduction" => "I'm a meet lover.",
+      "age" => 29
+    }
+
+    assert_equal({
+                   "_id" => users[key].id,
+                   "_key" => key,
+                   "self_introduction" => "I'm a meet lover.",
+                   "age" => 29,
+                 },
+                 users[key].attributes)
+  end
+
+  def test_set_multi_values_with_nonexistent_column
+    users = Groonga::Hash.create(:name => "Users",
+                                 :key_type => "ShortText")
+    users.define_column("self_introduction", "ShortText")
+    users.define_column("age", "UInt32")
+
+    key = "niku"
+    inspected_users = users.inspect.sub(/size: <0>/, "size: <1>")
+    message = "no such column: <\"nonexistent\">: <#{inspected_users}>"
+    assert_raise(Groonga::NoSuchColumn.new(message)) do
+      users[key] = {
+        "nonexistent" => "No!",
+      }
+    end
+  end
+
+  def test_added?
+    users = Groonga::Hash.create(:name => "Users",
+                                 :key_type => "ShortText")
+    bob = users.add("bob")
+    assert_predicate(bob, :added?)
+    bob_again = users.add("bob")
+    assert_not_predicate(bob_again, :added?)
+  end
+
+  def test_defrag
+    users = Groonga::Hash.create(:name => "Users",
+                                 :key_type => "ShortText")
+    users.define_column("name", "ShortText")
+    users.define_column("address", "ShortText")
+    1000.times do |i|
+      users.add("user #{i}",
+                :name => "user #{i}" * 1000,
+                :address => "address #{i}" * 1000)
+    end
+    assert_equal(7, users.defrag)
+  end
+
+  def test_rename
+    users = Groonga::Hash.create(:name => "Users",
+                                 :key_type => "ShortText")
+    name = users.define_column("name", "ShortText")
+    address = users.define_column("address", "ShortText")
+
+    users.rename("People")
+    assert_equal(["People", "People.name", "People.address"],
+                 [users.name, name.name, address.name])
+  end
+
+  def test_each
+    users = Groonga::Hash.create(:name => "Users", :key_type => "ShortText")
+    users.add("Alice")
+    users.add("Bob")
+    users.add("Carl")
+
+    user_names = []
+    users.each do |user|
+      user_names << user.key
+    end
+    assert_equal(["Alice", "Bob", "Carl"], user_names)
+  end
+
+  def test_each_without_block
+    users = Groonga::Hash.create(:name => "Users", :key_type => "ShortText")
+    users.add("Alice")
+    users.add("Bob")
+    users.add("Carl")
+
+    user_names = users.each.collect(&:key)
+    assert_equal(["Alice", "Bob", "Carl"], user_names)
+  end
+end

data/test/test-index-column.rb

@@ -0,0 +1,180 @@
+# -*- coding: utf-8 -*-
+#
+# 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 IndexColumnTest < Test::Unit::TestCase
+  include GroongaTestUtils
+
+  def setup
+    setup_database
+  end
+
+  def test_index?
+    articles = Groonga::Array.create(:name => "Articles")
+    articles.define_column("content", "Text")
+
+    terms = Groonga::Hash.create(:name => "Terms",
+                                 :default_tokenizer => "TokenBigram")
+    content_index = terms.define_index_column("content", articles,
+                                              :with_section => true)
+    assert_predicate(content_index, :index?)
+  end
+
+  def test_vector?
+    articles = Groonga::Array.create(:name => "Articles")
+    articles.define_column("content", "Text")
+
+    terms = Groonga::Hash.create(:name => "Terms",
+                                 :default_tokenizer => "TokenBigram")
+    content_index = terms.define_index_column("content", articles,
+                                              :with_section => true)
+    assert_not_predicate(content_index, :vector?)
+  end
+
+  def test_scalar?
+    articles = Groonga::Array.create(:name => "Articles")
+    articles.define_column("content", "Text")
+
+    terms = Groonga::Hash.create(:name => "Terms",
+                                 :default_tokenizer => "TokenBigram")
+    content_index = terms.define_index_column("content", articles,
+                                              :with_section => true)
+    assert_not_predicate(content_index, :scalar?)
+  end
+
+  def test_array_set_with_record
+    articles = Groonga::Array.create(:name => "Articles")
+    articles.define_column("content", "Text")
+
+    terms = Groonga::Hash.create(:name => "Terms",
+                                 :default_tokenizer => "TokenBigram")
+    content_index = terms.define_index_column("content", articles,
+                                              :with_section => true)
+
+    content = <<-EOC
+    groonga は組み込み型の全文検索エンジンライブラリです。
+    DBMSやスクリプト言語処理系等に組み込むことによって、その
+    全文検索機能を強化することができます。また、リレーショナ
+    ルモデルに基づくデータストア機能を内包しており、groonga
+    単体でも高速なデータストアサーバとして使用することができ
+    ます。
+
+    ■全文検索方式
+    転置索引型の全文検索エンジンです。転置索引は圧縮されてファ
+    イルに格納され、検索時のディスク読み出し量を小さく、かつ
+    局所的に抑えるように設計されています。用途に応じて以下の
+    索引タイプを選択できます。
+    EOC
+
+    groonga = articles.add(:content => content)
+
+    content.split(/\n{2,}/).each_with_index do |sentence, i|
+      content_index[groonga] = {:value => sentence, :section => i + 1}
+    end
+    assert_equal([groonga],
+                 content_index.search("エンジン").collect {|record| record.key})
+  end
+
+  def test_shorter_query_than_ngram
+    articles = Groonga::Array.create(:name => "Articles")
+    articles.define_column("content", "Text")
+
+    terms = Groonga::PatriciaTrie.create(:name => "Terms",
+                                         :default_tokenizer => "TokenBigram")
+    content_index = terms.define_index_column("content", articles,
+                                              :source => "Articles.content")
+    articles.add(:content => 'l')
+    articles.add(:content => 'll')
+    articles.add(:content => 'hello')
+
+    assert_search(["hello"], content_index, "he")
+    assert_search(["ll", "hello"], content_index, "ll")
+    assert_search(["l", "ll", "hello"], content_index, "l")
+  end
+
+  def test_with_section?
+    define_index_column_with_flags
+    assert_equal({
+                   :section => true,
+                   :weight => false,
+                   :position => false,
+                 },
+                 {
+                   :section => context["Tags.section"].with_section?,
+                   :weight => context["Tags.weight"].with_section?,
+                   :position => context["Tags.position"].with_section?,
+                 })
+  end
+
+  def test_with_weight?
+    define_index_column_with_flags
+    assert_equal({
+                   :section => false,
+                   :weight => true,
+                   :position => false,
+                 },
+                 {
+                   :section => context["Tags.section"].with_weight?,
+                   :weight => context["Tags.weight"].with_weight?,
+                   :position => context["Tags.position"].with_weight?,
+                 })
+  end
+
+  def test_with_position?
+    define_index_column_with_flags
+    assert_equal({
+                   :section => false,
+                   :weight => false,
+                   :position => true,
+                 },
+                 {
+                   :section => context["Tags.section"].with_position?,
+                   :weight => context["Tags.weight"].with_position?,
+                   :position => context["Tags.position"].with_position?,
+                 })
+  end
+
+  private
+  def assert_search(expected, content_index, keyword)
+    result = content_index.search(keyword).collect do |entry|
+      entry.key["content"]
+    end
+    assert_equal(expected, result)
+  end
+
+  def define_index_column_with_flags
+    Groonga::Schema.define do |schema|
+      schema.create_table("Articles") do |table|
+        table.text("tags", :type => :vector)
+      end
+
+      schema.create_table("Tags",
+                          :type => :patricia_trie,
+                          :key_type => "ShortText",
+                          :default_tokenizer => "TokenDelimit") do |table|
+        table.index("Articles.tags",
+                    :name => "section",
+                    :with_section => true)
+        table.index("Articles.tags",
+                    :name => "weight",
+                    :with_weight => true)
+        table.index("Articles.tags",
+                    :name => "position",
+                    :with_position => true)
+      end
+    end
+  end
+end

data/test/test-index-cursor.rb

@@ -0,0 +1,149 @@
+# Copyright (C) 2012  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 IndexCursorTest < Test::Unit::TestCase
+  include GroongaTestUtils
+
+  def setup
+    setup_database
+    setup_schema
+    setup_records
+  end
+
+  def test_open_cursor
+    postings = []
+    @terms.open_cursor do |table_cursor|
+      index_cursor = nil
+      @content_index.open_cursor(table_cursor) do |cursor|
+        cursor.each do |posting|
+          postings << posting.to_hash
+        end
+        index_cursor = cursor
+      end
+      assert_predicate(index_cursor, :closed?)
+    end
+
+    assert_equal(expected_postings, postings)
+  end
+
+  def test_enumerable
+    opened = false
+    @terms.open_cursor do |table_cursor|
+      @content_index.open_cursor(table_cursor) do |cursor|
+        postings = cursor.collect do |posting|
+          posting.to_hash
+        end
+        assert_equal(expected_postings, postings)
+        opened = true
+      end
+    end
+
+    assert_true(opened)
+  end
+
+  def test_each_without_block
+    opened = false
+    @terms.open_cursor do |table_cursor|
+      @content_index.open_cursor(table_cursor) do |cursor|
+        postings = cursor.each.collect(&:to_hash)
+        assert_equal(expected_postings, postings)
+        opened = true
+      end
+    end
+
+    assert_true(opened)
+  end
+
+  def test_record
+    record = nil
+    @terms.open_cursor do |table_cursor|
+      @content_index.open_cursor(table_cursor) do |cursor|
+        posting = cursor.next
+        record = posting.record
+      end
+    end
+
+    assert_equal("1", record.key)
+  end
+
+  def test_term
+    term = nil
+    @terms.open_cursor do |table_cursor|
+      @content_index.open_cursor(table_cursor) do |cursor|
+        posting = cursor.next
+        term = posting.term
+      end
+    end
+
+    assert_equal("l", term.key)
+  end
+
+  private
+  def create_hashes(keys, values)
+    hashes = []
+    values.each do |value|
+      hash = {}
+      keys.each_with_index do |key, i|
+        hash[key] = value[i]
+      end
+      hashes << hash
+    end
+    hashes
+  end
+
+  def setup_schema
+    Groonga::Schema.define do |schema|
+      schema.create_table("Articles",
+                          :type => :hash,
+                          :key_type => :short_text) do |table|
+        table.text("content")
+      end
+
+      schema.create_table("Terms",
+                          :type => :hash,
+                          :default_tokenizer => :bigram_split_symbol_alpha) do |table|
+        table.index("Articles.content")
+      end
+    end
+
+    @articles = Groonga["Articles"]
+    @terms = Groonga["Terms"]
+    @content_index = Groonga["Terms.Articles_content"]
+  end
+
+  def setup_records
+    @articles.add("1", :content => "l")
+    @articles.add("2", :content => "ll")
+    @articles.add("3", :content => "hello")
+  end
+
+  def expected_postings
+    parameters = [:record_id, :section_id, :term_id, :position,
+                  :term_frequency, :weight, :n_rest_postings]
+
+    expected = [
+                [1, 1, 1, 0, 1, 0, 1],
+                [2, 1, 1, 0, 1, 0, 1],
+                [2, 1, 2, 0, 1, 0, 1],
+                [3, 1, 2, 0, 1, 0, 1],
+                [3, 1, 3, 0, 1, 0, 0],
+                [3, 1, 4, 1, 1, 0, 0],
+                [3, 1, 5, 3, 1, 0, 0],
+                [3, 1, 6, 4, 1, 0, 0]
+               ]
+
+    create_hashes(parameters, expected)
+  end
+end