groonga 0.0.1 → 0.0.2

data/lib/groonga/record.rb

@@ -18,9 +18,14 @@
 module Groonga
   class Record
     attr_reader :table, :id
-    def initialize(table, id)
+    def initialize(table, id, values=nil)
       @table = table
       @id = id
+      if values
+        values.each do |name, value|
+          self[name] = value
+        end
+      end
     end
 
     def ==(other)

data/test/groonga-test-utils.rb

@@ -80,6 +80,7 @@ module GroongaTestUtils
   end
 
   def teardown_sandbox
+    @database = nil
     teardown_tmp_directory
     GC.start
   end

data/test/test-array.rb

@@ -0,0 +1,81 @@
+# 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
+
+class ArrayTest < Test::Unit::TestCase
+  include GroongaTestUtils
+
+  setup :setup_database
+
+  def test_inspect_size
+    path = @tables_dir + "named.groonga"
+    contain_table = Groonga::Array.create(:name => "name", :path => path.to_s)
+    3.times do
+      contain_table.add
+    end
+    assert_equal("#<Groonga::Array " +
+                 "id: <#{contain_table.id}>, " +
+                 "name: <name>, " +
+                 "path: <#{path}>, " +
+                 "domain: <nil>, " +
+                 "range: <nil>, " +
+                 "size: <3>>",
+                 contain_table.inspect)
+  end
+
+  def test_encoding
+    array = Groonga::Array.create
+    assert_false(array.respond_to?(:encoding))
+  end
+
+  def test_add
+    users = Groonga::Array.create(:name => "<users>")
+    users.define_column("name", "<text>")
+    me = users.add(:name => "me")
+    assert_equal("me", me[:name])
+  end
+
+  def test_define_index_column
+    users = Groonga::Array.create(:name => "<users>")
+    users.define_column("name", "<text>")
+    bookmarks = Groonga::Array.create(:name => "<bookmarks>")
+    bookmarks.define_column("title", "<text>")
+    bookmarks.define_column("user", users)
+
+    index = users.define_index_column("bookmarks", bookmarks,
+                                      :source => "<bookmarks>.user")
+    morita = users.add(:name => "morita")
+    gunyara_kun = users.add(:name => "gunyara-kun")
+    groonga = bookmarks.add(:title => "groonga", :user => morita)
+    google = bookmarks.add(:title => "google", :user => morita)
+    python = bookmarks.add(:title => "Python", :user => gunyara_kun)
+
+    assert_equal(["groonga", "google"],
+                 index.search(morita.id).collect {|record| record.key["title"]})
+  end
+
+  def test_create_duplicated_name
+    Groonga::Array.create(:name => "<users>")
+    assert_raise(Groonga::InvalidArgument) do
+      Groonga::Array.create(:name => "<users>")
+    end
+  end
+
+  def test_open_same_name
+    users_created = Groonga::Array.create(:name => "<users>")
+    users_opened = Groonga::Array.open(:name => "<users>")
+    users_opened.add
+    assert_equal(1, users_created.size)
+  end
+end

data/test/test-column.rb

@@ -62,20 +62,20 @@ class ColumnTest < Test::Unit::TestCase
       Groonga::PatriciaTrie.create(:name => "bookmarks-index",
                                    :path => @bookmarks_index_path.to_s,
                                    :key_type => "<shorttext>")
+    @bookmarks_index.default_tokenizer = "<token:bigram>"
+
     @content_index_column_path = @columns_dir + "content-index"
     @bookmarks_index_content =
-      @bookmarks_index.define_column("<index:content>", @bookmarks,
-                                     :type => "index",
-                                     :with_section => true,
-                                     :with_weight => true,
-                                     :with_position => true,
-                                     :path => @content_index_column_path.to_s)
+      @bookmarks_index.define_index_column("<index:content>", @bookmarks,
+                                           :with_section => true,
+                                           :with_weight => true,
+                                           :with_position => true,
+                                           :path => @content_index_column_path.to_s)
 
     @uri_index_column_path = @columns_dir + "uri-index"
     @bookmarks_index_uri =
-      @bookmarks_index.define_column("<index:uri>", @bookmarks,
-                                     :type => "index",
-                                     :path => @uri_index_column_path.to_s)
+      @bookmarks_index.define_index_column("<index:uri>", @bookmarks,
+                                           :path => @uri_index_column_path.to_s)
   end
 
   def test_source_info
@@ -126,9 +126,9 @@ class ColumnTest < Test::Unit::TestCase
 
     index = Groonga::PatriciaTrie.create(:name => "<terms>",
                                          :key_type => "<shorttext>")
-    content_index = index.define_column("content_index", comments,
-                                        :type => "index",
-                                        :with_position => true)
+    index.default_tokenizer = "<token:bigram>"
+    content_index = index.define_index_column("content_index", comments,
+                                              :with_position => true)
     content_index.source = content
 
     first_post = posts.add("Hello!")
@@ -176,6 +176,16 @@ class ColumnTest < Test::Unit::TestCase
     assert_equal(@users, @users_name_column.table)
   end
 
+  def test_array_set_with_key_of_table
+    users = Groonga::Hash.create(:name => "<users>")
+    bookmarks = Groonga::Hash.create(:name => "<bookmarks>")
+    bookmarks.define_column("user", users)
+
+    users.add("morita")
+    groonga = bookmarks.add("http://groonga.org/", :user => "morita")
+    assert_equal("morita", groonga[:user].key)
+  end
+
   private
   def assert_content_search(expected_records, term)
     records = @bookmarks_index_content.search(term).records

data/test/test-context.rb

@@ -18,39 +18,17 @@ class ContextTest < Test::Unit::TestCase
 
   def test_default
     context = Groonga::Context.default
-    assert_not_predicate(context, :use_ql?)
-    assert_not_predicate(context, :batch_mode?)
     assert_equal(Groonga::Encoding.default, context.encoding)
   end
 
   def test_default_options
     Groonga::Context.default_options = {
-      :use_ql => true,
-      :batch_mode => true,
       :encoding => :utf8,
     }
     context = Groonga::Context.default
-    assert_predicate(context, :use_ql?)
-    assert_predicate(context, :batch_mode?)
     assert_equal(Groonga::Encoding::UTF8, context.encoding)
   end
 
-  def test_use_ql?
-    context = Groonga::Context.new
-    assert_not_predicate(context, :use_ql?)
-
-    context = Groonga::Context.new(:use_ql => true)
-    assert_predicate(context, :use_ql?)
-  end
-
-  def test_batch_mode?
-    context = Groonga::Context.new
-    assert_not_predicate(context, :batch_mode?)
-
-    context = Groonga::Context.new(:batch_mode => true)
-    assert_predicate(context, :batch_mode?)
-  end
-
   def test_encoding
     context = Groonga::Context.new
     assert_equal(Groonga::Encoding.default, context.encoding)
@@ -60,12 +38,8 @@ class ContextTest < Test::Unit::TestCase
   end
 
   def test_inspect
-    context = Groonga::Context.new(:use_ql => true,
-                                   :batch_mode => true,
-                                   :encoding => Groonga::Encoding::UTF8)
+    context = Groonga::Context.new(:encoding => Groonga::Encoding::UTF8)
     assert_equal("#<Groonga::Context " +
-                 "use_ql: <true>, " +
-                 "batch_mode: <true>, " +
                  "encoding: <:utf8>, " +
                  "database: <nil>>",
                  context.inspect)
@@ -75,8 +49,6 @@ class ContextTest < Test::Unit::TestCase
     db = Groonga::Database.create
     context = Groonga::Context.default
     assert_equal("#<Groonga::Context " +
-                 "use_ql: <false>, " +
-                 "batch_mode: <false>, " +
                  "encoding: <#{Groonga::Encoding.default.inspect}>, " +
                  "database: <#{db.inspect}>>",
                  context.inspect)

data/test/test-database.rb

@@ -59,4 +59,34 @@ class DatabaseTest < Test::Unit::TestCase
 
     assert_not_predicate(Groonga::Database.new(db_path.to_s), :closed?)
   end
+
+  def test_each
+    db_path = @tmp_dir + "db"
+    database = Groonga::Database.create(:path => db_path.to_s)
+    assert_equal(["<float>",
+                  "<int64>",
+                  "<int>",
+                  "<longtext>",
+                  "<proc:disp>",
+                  "<proc:init>",
+                  "<proc:scan>",
+                  "<proc:search>",
+                  "<ranguba:objects>",
+                  "<shorttext>",
+                  "<text>",
+                  "<time>",
+                  "<token:bigram>",
+                  "<token:delimit>",
+                  "<token:mecab>",
+                  "<token:trigram>",
+                  "<token:unigram>",
+                  "<uint64>",
+                  "<uint>"],
+                 database.collect {|object| object.name}.sort)
+  end
+
+  def test_encoding
+    assert_equal(Groonga::Encoding.default,
+                 Groonga::Database.create.encoding)
+  end
 end

data/test/test-hash.rb

@@ -0,0 +1,194 @@
+# -*- coding: utf-8 -*-
+# 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
+
+class HashTest < Test::Unit::TestCase
+  include GroongaTestUtils
+
+  setup :setup_database
+
+  def test_delete
+    bookmarks_path = @tables_dir + "bookmarks"
+    bookmarks = Groonga::Hash.create(:name => "bookmarks",
+                                     :path => bookmarks_path.to_s)
+
+    groonga = 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_array_reference
+    value = "groonga"
+    bookmarks_path = @tables_dir + "bookmarks"
+    bookmarks = Groonga::Hash.create(:name => "bookmarks",
+                                     :path => bookmarks_path.to_s,
+                                     :key_type => "<shorttext>",
+                                     :value_size => value.size)
+    bookmarks["http://google.com/"] = value
+    assert_equal(value, bookmarks["http://google.com/"])
+  end
+
+  def test_find
+    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.find("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: <nil>, " +
+                 "range: <nil>, " +
+                 "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: <nil>, " +
+                 "range: <nil>, " +
+                 "encoding: <#{encoding.inspect}>, " +
+                 "size: <0>>",
+                 anonymous_table.inspect)
+  end
+
+  def test_inspect_named
+    path = @tables_dir + "named.groonga"
+    named_table = Groonga::Hash.create(:name => "name", :path => path.to_s)
+    assert_equal("#<Groonga::Hash " +
+                 "id: <#{named_table.id}>, " +
+                 "name: <name>, " +
+                 "path: <#{path}>, " +
+                 "domain: <nil>, " +
+                 "range: <nil>, " +
+                 "encoding: <#{encoding.inspect}>, " +
+                 "size: <0>>",
+                 named_table.inspect)
+  end
+
+  def test_inspect_named_temporary
+    named_table = Groonga::Hash.create(:name => "name")
+    assert_equal("#<Groonga::Hash " +
+                 "id: <#{named_table.id}>, " +
+                 "name: <name>, " +
+                 "path: (temporary), " +
+                 "domain: <nil>, " +
+                 "range: <nil>, " +
+                 "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 = "<token:bigram>"
+    assert_equal(Groonga::Context.default["<token:bigram>"],
+                 hash.default_tokenizer)
+  end
+
+  def test_search
+    users = Groonga::Array.create(:name => "<users>")
+    user_name = users.define_column("name", "<shorttext>")
+
+    bookmarks = Groonga::Hash.create(:name => "<bookmarks>",
+                                     :key_type => "<shorttext>")
+    bookmark_user_id = 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 => "<token:trigram>")
+    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 => "<token:bigram>")
+    index = terms.define_index_column("comment", bookmarks,
+                                      :source => "<bookmarks>.comment")
+    groonga = bookmarks.add("groonga", :comment => "search engine by Brazil")
+    google = bookmarks.add("google", :comment => "search engine by Google")
+    ruby = bookmarks.add("ruby", :comment => "programing language")
+
+    assert_equal(["groonga", "google"],
+                 index.search("engine").collect {|record| record.key.key})
+  end
+
+  def test_open_same_name
+    users_created = Groonga::Hash.create(:name => "<users>")
+    users_opened = Groonga::Hash.open(:name => "<users>")
+    users_opened.add("morita")
+    assert_equal(1, users_created.size)
+  end
+end

data/test/test-index-column.rb

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+#
+# 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
+
+class IndexColumnTest < Test::Unit::TestCase
+  include GroongaTestUtils
+
+  def setup
+    setup_database
+  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 => "<token:bigram>")
+    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
+end

data/test/test-patricia-trie.rb

@@ -0,0 +1,82 @@
+# 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
+
+class PatriciaTrieTest < Test::Unit::TestCase
+  include GroongaTestUtils
+
+  setup :setup_database
+
+  def test_encoding
+    assert_equal(Groonga::Encoding.default,
+                 Groonga::PatriciaTrie.create.encoding)
+  end
+
+  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)
+  end
+
+  def test_search
+    users = Groonga::Array.create(:name => "<users>")
+    user_name = users.define_column("name", "<shorttext>")
+
+    bookmarks = Groonga::PatriciaTrie.create(:name => "<bookmarks>",
+                                             :key_type => "<shorttext>")
+    bookmark_user_id = 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::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>")
+    assert_equal(context[Groonga::Type::UNIGRAM],
+                 terms.default_tokenizer)
+  end
+
+  def test_duplicated_name
+    Groonga::PatriciaTrie.create(:name => "<users>")
+    assert_raise(Groonga::InvalidArgument) do
+      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_opened.add("morita")
+    assert_equal(1, users_created.size)
+  end
+end

data/test/test-record.rb

@@ -80,22 +80,22 @@ class RecordTest < Test::Unit::TestCase
     @bookmarks_index =
       Groonga::PatriciaTrie.create(:name => "bookmarks-index",
                                    :path => @bookmarks_index_path.to_s)
+    @bookmarks_index.default_tokenizer = "<token:bigram>"
+
     @content_index_column_path = @columns_dir + "content-index"
     @bookmarks_content_index =
-      @bookmarks_index.define_column("<index:content>", @bookmarks,
-                                     :type => "index",
-                                     :with_section => true,
-                                     :with_weight => true,
-                                     :with_position => true,
-                                     :path => @content_index_column_path.to_s)
+      @bookmarks_index.define_index_column("<index:content>", @bookmarks,
+                                           :with_section => true,
+                                           :with_weight => true,
+                                           :with_position => true,
+                                           :path => @content_index_column_path.to_s)
     @bookmarks_content_index.source = @bookmarks_content
 
     @uri_index_column_path = @columns_dir + "uri-index"
     @bookmarks_uri_index =
-      @bookmarks_index.define_column("<index:uri>", @bookmarks,
-                                     :type => "index",
-                                     :with_position => true,
-                                     :path => @uri_index_column_path.to_s)
+      @bookmarks_index.define_index_column("<index:uri>", @bookmarks,
+                                           :with_position => true,
+                                           :path => @uri_index_column_path.to_s)
     @bookmarks_uri_index.source = @bookmarks_uri
   end