groonga 0.0.2 → 0.0.3

data/test/test-procedure.rb

@@ -19,11 +19,11 @@ class ProcedureTest < Test::Unit::TestCase
   setup :setup_database
 
   def test_builtins
-    assert_equal_procedure("<token:delimit>", Groonga::Procedure::DELIMIT)
-    assert_equal_procedure("<token:unigram>", Groonga::Procedure::UNIGRAM)
-    assert_equal_procedure("<token:bigram>", Groonga::Procedure::BIGRAM)
-    assert_equal_procedure("<token:trigram>", Groonga::Procedure::TRIGRAM)
-    assert_equal_procedure("<token:mecab>", Groonga::Procedure::MECAB)
+    assert_equal_procedure("TokenDelimit", Groonga::Procedure::DELIMIT)
+    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)
   end
 
   private

data/test/test-record.rb

@@ -63,6 +63,10 @@ class RecordTest < Test::Unit::TestCase
     @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>",
+                                               :path => @rate_column_path.to_s)
+
     @comment_column_path = @columns_dir + "comment"
     @bookmarks_comment =
       @bookmarks.define_column("comment", "<text>",
@@ -80,11 +84,11 @@ 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>"
+    @bookmarks_index.default_tokenizer = "TokenBigram"
 
     @content_index_column_path = @columns_dir + "content-index"
     @bookmarks_content_index =
-      @bookmarks_index.define_index_column("<index:content>", @bookmarks,
+      @bookmarks_index.define_index_column("content", @bookmarks,
                                            :with_section => true,
                                            :with_weight => true,
                                            :with_position => true,
@@ -93,7 +97,7 @@ class RecordTest < Test::Unit::TestCase
 
     @uri_index_column_path = @columns_dir + "uri-index"
     @bookmarks_uri_index =
-      @bookmarks_index.define_index_column("<index:uri>", @bookmarks,
+      @bookmarks_index.define_index_column("uri", @bookmarks,
                                            :with_position => true,
                                            :path => @uri_index_column_path.to_s)
     @bookmarks_uri_index.source = @bookmarks_uri
@@ -117,7 +121,9 @@ class RecordTest < Test::Unit::TestCase
 
   def test_get_nonexistent_column
     groonga = @bookmarks.add
-    assert_nil(groonga["nonexistent"])
+    assert_raise(Groonga::Error) do
+      groonga["nonexistent"]
+    end
   end
 
   def test_set_nonexistent_column
@@ -185,4 +191,65 @@ class RecordTest < Test::Unit::TestCase
                    [record.id, record.score]
                  end)
   end
+
+  def test_increment!
+    groonga = @bookmarks.add
+    assert_equal(0, groonga["rate"])
+    groonga.increment!("rate")
+    assert_equal(1, groonga["rate"])
+    groonga.increment!("rate", 2)
+    assert_equal(3, groonga["rate"])
+    groonga.increment!("rate", -2)
+    assert_equal(1, groonga["rate"])
+  end
+
+  def test_decrement!
+    groonga = @bookmarks.add
+    assert_equal(0, groonga["rate"])
+    groonga.decrement!("rate")
+    assert_equal(-1, groonga["rate"])
+    groonga.decrement!("rate", 2)
+    assert_equal(-3, groonga["rate"])
+    groonga.decrement!("rate", -2)
+    assert_equal(-1, groonga["rate"])
+  end
+
+  def test_lock
+    groonga = @bookmarks.add
+
+    assert_not_predicate(groonga, :locked?)
+    groonga.lock
+    assert_predicate(groonga, :locked?)
+    groonga.unlock
+    assert_not_predicate(groonga, :locked?)
+  end
+
+  def test_lock_failed
+    groonga = @bookmarks.add
+
+    groonga.lock
+    assert_raise(Groonga::ResourceDeadlockAvoided) do
+      groonga.lock
+    end
+  end
+
+  def test_lock_block
+    groonga = @bookmarks.add
+
+    assert_not_predicate(groonga, :locked?)
+    groonga.lock do
+      assert_predicate(groonga, :locked?)
+    end
+    assert_not_predicate(groonga, :locked?)
+  end
+
+  def test_clear_lock
+    groonga = @bookmarks.add
+
+    assert_not_predicate(groonga, :locked?)
+    groonga.lock
+    assert_predicate(groonga, :locked?)
+    groonga.clear_lock
+    assert_not_predicate(groonga, :locked?)
+  end
 end

data/test/test-schema.rb

@@ -0,0 +1,207 @@
+# 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 SchemaTest < Test::Unit::TestCase
+  include GroongaTestUtils
+
+  setup :setup_database
+
+  def test_create_table
+    assert_nil(context["<posts>"])
+    Groonga::Schema.create_table("<posts>") do |table|
+    end
+    assert_not_nil(context["<posts>"])
+  end
+
+  def test_define_hash
+    Groonga::Schema.create_table("<posts>", :type => :hash) do |table|
+    end
+    assert_kind_of(Groonga::Hash, context["<posts>"])
+  end
+
+  def test_define_hash_with_full_option
+    path = @tmp_dir + "hash.groonga"
+    tokenizer = context["<token:trigram>"]
+    Groonga::Schema.create_table("<posts>",
+                                 :type => :hash,
+                                 :key_type => "integer",
+                                 :path => path.to_s,
+                                 :value_size => 29,
+                                 :default_tokenizer => tokenizer) do |table|
+    end
+    table = context["<posts>"]
+    assert_equal("#<Groonga::Hash " +
+                 "id: <#{table.id}>, " +
+                 "name: <<posts>>, " +
+                 "path: <#{path}>, " +
+                 "domain: <#{context['<int>'].inspect}>, " +
+                 "range: <nil>, " +
+                 "encoding: <#{Groonga::Encoding.default.inspect}>, " +
+                 "size: <0>>",
+                 table.inspect)
+    assert_equal(tokenizer, table.default_tokenizer)
+  end
+
+  def test_define_patricia_trie
+    Groonga::Schema.create_table("<posts>", :type => :patricia_trie) do |table|
+    end
+    assert_kind_of(Groonga::PatriciaTrie, context["<posts>"])
+  end
+
+  def test_define_patricia_trie_with_full_option
+    path = @tmp_dir + "patricia-trie.groonga"
+    Groonga::Schema.create_table("<posts>",
+                                 :type => :patricia_trie,
+                                 :key_type => "integer",
+                                 :path => path.to_s,
+                                 :value_size => 29,
+                                 :default_tokenizer => "<token:bigram>",
+                                 :key_normalize => true,
+                                 :key_with_sis => true) do |table|
+    end
+    table = context["<posts>"]
+    assert_equal("#<Groonga::PatriciaTrie " +
+                 "id: <#{table.id}>, " +
+                 "name: <<posts>>, " +
+                 "path: <#{path}>, " +
+                 "domain: <#{context['<int>'].inspect}>, " +
+                 "range: <nil>, " +
+                 "encoding: <#{Groonga::Encoding.default.inspect}>, " +
+                 "size: <0>>",
+                 table.inspect)
+    assert_equal(context["<token:bigram>"], table.default_tokenizer)
+  end
+
+  def test_define_array
+    Groonga::Schema.create_table("<posts>", :type => :array) do |table|
+    end
+    assert_kind_of(Groonga::Array, context["<posts>"])
+  end
+
+  def test_define_array_with_full_option
+    path = @tmp_dir + "array.groonga"
+    Groonga::Schema.create_table("<posts>",
+                                 :type => :array,
+                                 :path => path.to_s,
+                                 :value_size => 29) do |table|
+    end
+    table = context["<posts>"]
+    assert_equal("#<Groonga::Array " +
+                 "id: <#{table.id}>, " +
+                 "name: <<posts>>, " +
+                 "path: <#{path}>, " +
+                 "domain: <nil>, " +
+                 "range: <nil>, " +
+                 "size: <0>>",
+                 table.inspect)
+  end
+
+  def test_integer32_column
+    assert_nil(context["<posts>.rate"])
+    Groonga::Schema.create_table("<posts>") do |table|
+      table.integer32 :rate
+    end
+    assert_equal(context["<int>"], context["<posts>.rate"].range)
+  end
+
+  def test_integer64_column
+    assert_nil(context["<posts>.rate"])
+    Groonga::Schema.create_table("<posts>") do |table|
+      table.integer64 :rate
+    end
+    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|
+      table.unsigned_integer32 :n_viewed
+    end
+    assert_equal(context["<uint>"], context["<posts>.n_viewed"].range)
+  end
+
+  def test_unsigned_integer64_column
+    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)
+  end
+
+  def test_float_column
+    assert_nil(context["<posts>.rate"])
+    Groonga::Schema.create_table("<posts>") do |table|
+      table.float :rate
+    end
+    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|
+      table.time :last_modified
+    end
+    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|
+      table.short_text :title
+    end
+    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|
+      table.text :comment
+    end
+    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|
+      table.long_text :content
+    end
+    assert_equal(context["<longtext>"], context["<posts>.content"].range)
+  end
+
+  def test_index
+    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, "<posts>.content"
+    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|
+        table.short_text :title
+      end
+    end
+    assert_equal(<<-EOS, Groonga::Schema.dump)
+create_table("<posts>") do |table|
+  table.short_text("title")
+end
+EOS
+  end
+end

data/test/test-table.rb

@@ -326,10 +326,21 @@ class TableTest < Test::Unit::TestCase
                               },
                              ],
                              :limit => 20)
-    results = results.records(:order => :ascending).collect do |record|
-      id_column[record.value.unpack("i")[0]]
+    assert_equal((180..199).to_a.reverse,
+                 results.collect {|record| record["id"]})
+  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
-    assert_equal((180..199).to_a.reverse, results)
+
+    results = bookmarks.sort(["id"], :limit => 20)
+    assert_equal((100..119).to_a,
+                 results.collect {|record| record["id"]})
   end
 
   def test_sort_without_limit
@@ -340,15 +351,86 @@ class TableTest < Test::Unit::TestCase
       bookmark["id"] = i + 100
     end
 
-    results = bookmarks.sort([
-                              {
-                                :key => "id",
-                                :order => :descending,
-                              },
-                             ])
-    results = results.records(:order => :ascending).collect do |record|
-      id_column[record.value.unpack("i")[0]]
+    results = bookmarks.sort([{:key => "id", :order => :descending}])
+    assert_equal((100..199).to_a.reverse,
+                 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>")
+    comments.define_column("bookmark", bookmarks)
+    comments.define_column("content", "Text")
+    comments.define_column("issued", "Int32")
+
+    groonga = bookmarks.add("http://groonga.org/", :title => "groonga")
+    ruby = bookmarks.add("http://ruby-lang.org/", :title => "Ruby")
+
+    now = Time.now.to_i
+    comments.add(:bookmark => groonga,
+                 :content => "full-text search",
+                 :issued => now)
+    comments.add(:bookmark => groonga,
+                 :content => "column store",
+                 :issued => now)
+    comments.add(:bookmark => ruby,
+                 :content => "object oriented script language",
+                 :issued => now)
+
+    records = comments.select do |record|
+      record["issued"] > 0
+    end
+    assert_equal([[2, "groonga", "http://groonga.org/"],
+                  [1, "Ruby", "http://ruby-lang.org/"]],
+                 records.group([".bookmark"]).collect do |record|
+                   bookmark = record.key
+                   [record[".:nsubrecs"],
+                    bookmark["title"],
+                    bookmark.key]
+                 end)
+  end
+
+  def test_lock
+    bookmarks = Groonga::Array.create(:name => "<bookmarks>")
+    bookmark = bookmarks.add
+
+    assert_not_predicate(bookmarks, :locked?)
+    bookmarks.lock
+    assert_predicate(bookmarks, :locked?)
+    bookmarks.unlock
+    assert_not_predicate(bookmarks, :locked?)
+  end
+
+  def test_lock_failed
+    bookmarks = Groonga::Array.create(:name => "<bookmarks>")
+    bookmark = bookmarks.add
+
+    bookmarks.lock
+    assert_raise(Groonga::ResourceDeadlockAvoided) do
+      bookmarks.lock
     end
-    assert_equal((100..199).to_a.reverse, results)
+  end
+
+  def test_lock_block
+    bookmarks = Groonga::Array.create(:name => "<bookmarks>")
+    bookmark = bookmarks.add
+
+    assert_not_predicate(bookmarks, :locked?)
+    bookmarks.lock do
+      assert_predicate(bookmarks, :locked?)
+    end
+    assert_not_predicate(bookmarks, :locked?)
+  end
+
+  def test_clear_lock
+    bookmarks = Groonga::Array.create(:name => "<bookmarks>")
+    bookmark = bookmarks.add
+
+    assert_not_predicate(bookmarks, :locked?)
+    bookmarks.lock
+    assert_predicate(bookmarks, :locked?)
+    bookmarks.clear_lock
+    assert_not_predicate(bookmarks, :locked?)
   end
 end