groonga 0.0.2 → 0.0.3

data/test/test-column.rb

@@ -61,12 +61,12 @@ class ColumnTest < Test::Unit::TestCase
     @bookmarks_index =
       Groonga::PatriciaTrie.create(:name => "bookmarks-index",
                                    :path => @bookmarks_index_path.to_s,
-                                   :key_type => "<shorttext>")
-    @bookmarks_index.default_tokenizer = "<token:bigram>"
+                                   :key_type => "ShortText")
+    @bookmarks_index.default_tokenizer = "TokenBigram"
 
     @content_index_column_path = @columns_dir + "content-index"
     @bookmarks_index_content =
-      @bookmarks_index.define_index_column("<index:content>", @bookmarks,
+      @bookmarks_index.define_index_column("content", @bookmarks,
                                            :with_section => true,
                                            :with_weight => true,
                                            :with_position => true,
@@ -74,7 +74,7 @@ class ColumnTest < Test::Unit::TestCase
 
     @uri_index_column_path = @columns_dir + "uri-index"
     @bookmarks_index_uri =
-      @bookmarks_index.define_index_column("<index:uri>", @bookmarks,
+      @bookmarks_index.define_index_column("uri", @bookmarks,
                                            :path => @uri_index_column_path.to_s)
   end
 
@@ -157,25 +157,6 @@ class ColumnTest < Test::Unit::TestCase
     assert_equal(daijiro, @bookmarks_user[bookmark.id])
   end
 
-  def test_inspect
-    assert_equal("#<Groonga::VarSizeColumn " +
-                 "id: <#{@users_name_column.id}>, " +
-                 "name: <users.name>, " +
-                 "path: <#{@users_name_column_path}>, " +
-                 "domain: <#{@users.inspect}>, " +
-                 "range: <#{context['<shorttext>'].inspect}>" +
-                 ">",
-                 @users_name_column.inspect)
-  end
-
-  def test_domain
-    assert_equal(@users, @users_name_column.domain)
-  end
-
-  def test_table
-    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>")
@@ -186,6 +167,13 @@ class ColumnTest < Test::Unit::TestCase
     assert_equal("morita", groonga[:user].key)
   end
 
+  def test_local_name
+    items = Groonga::Array.create(:name => "<items>")
+    title = items.define_column("title", "<shorttext>")
+    assert_equal("<items>.title", title.name)
+    assert_equal("title", title.local_name)
+  end
+
   private
   def assert_content_search(expected_records, term)
     records = @bookmarks_index_content.search(term).records

data/test/test-context.rb

@@ -57,6 +57,6 @@ class ContextTest < Test::Unit::TestCase
   def test_array_reference
     Groonga::Database.create
     context = Groonga::Context.default
-    assert_equal("<int>", context["<int>"].name)
+    assert_equal("Int32", context["<int>"].name)
   end
 end

data/test/test-database.rb

@@ -63,25 +63,27 @@ class DatabaseTest < Test::Unit::TestCase
   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>"],
+    assert_equal(["/q/define_selector",
+                  "Bool",
+                  "Float",
+                  "Int16",
+                  "Int32",
+                  "Int64",
+                  "Int8",
+                  "LongText",
+                  "Object",
+                  "ShortText",
+                  "Text",
+                  "Time",
+                  "TokenBigram",
+                  "TokenDelimit",
+                  "TokenMecab",
+                  "TokenTrigram",
+                  "TokenUnigram",
+                  "UInt16",
+                  "UInt32",
+                  "UInt64",
+                  "UInt8"],
                  database.collect {|object| object.name}.sort)
   end
 
@@ -89,4 +91,43 @@ class DatabaseTest < Test::Unit::TestCase
     assert_equal(Groonga::Encoding.default,
                  Groonga::Database.create.encoding)
   end
+
+  def test_lock
+    database = Groonga::Database.create
+
+    assert_not_predicate(database, :locked?)
+    database.lock
+    assert_predicate(database, :locked?)
+    database.unlock
+    assert_not_predicate(database, :locked?)
+  end
+
+  def test_lock_failed
+    database = Groonga::Database.create
+
+    database.lock
+    assert_raise(Groonga::ResourceDeadlockAvoided) do
+      database.lock
+    end
+  end
+
+  def test_lock_block
+    database = Groonga::Database.create
+
+    assert_not_predicate(database, :locked?)
+    database.lock do
+      assert_predicate(database, :locked?)
+    end
+    assert_not_predicate(database, :locked?)
+  end
+
+  def test_clear_lock
+    database = Groonga::Database.create
+
+    assert_not_predicate(database, :locked?)
+    database.lock
+    assert_predicate(database, :locked?)
+    database.clear_lock
+    assert_not_predicate(database, :locked?)
+  end
 end

data/test/test-expression-builder.rb

@@ -0,0 +1,114 @@
+# 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 ExpressionBuilderTest < Test::Unit::TestCase
+  include GroongaTestUtils
+
+  setup :setup_database
+  setup :setup_tables
+  setup :setup_data
+
+  def setup_tables
+    @users = Groonga::Hash.create(:name => "<users>")
+    @name = @users.define_column("name", "<shorttext>")
+    @hp = @users.define_column("hp", "<uint>")
+
+    @terms = Groonga::PatriciaTrie.create(:name => "<terms>",
+                                          :default_tokenizer => "TokenBigram")
+    @terms.define_index_column("user-name", @users, :source => @name)
+  end
+
+  def setup_data
+    @morita = @users.add("morita",
+                         :name => "mori daijiro",
+                         :hp => 100)
+    @gunyara_kun = @users.add("gunyara-kun",
+                              :name => "Tasuku SUENAGA",
+                              :hp => 150)
+    @yu = @users.add("yu",
+                     :name => "Yutaro Shimamura",
+                     :hp => 200)
+  end
+
+  def test_equal
+    result = @users.select do |record|
+      record["name"] == "mori daijiro"
+    end
+    assert_equal(["morita"],
+                 result.collect {|record| record.key.key})
+  end
+
+  def test_not_equal
+    omit("not supported yet!!!")
+    result = @users.select do |record|
+      record["name"] != "mori daijiro"
+    end
+    assert_equal(["gunyara-kun", "yu"],
+                 result.collect {|record| record.key.key})
+  end
+
+  def test_less
+    result = @users.select do |record|
+      record["hp"] < 150
+    end
+    assert_equal(["morita"], result.collect {|record| record.key.key})
+  end
+
+  def test_less_equal
+    result = @users.select do |record|
+      record["hp"] <= 150
+    end
+    assert_equal(["morita", "gunyara-kun"],
+                 result.collect {|record| record.key.key})
+  end
+
+  def test_greater
+    result = @users.select do |record|
+      record["hp"] > 150
+    end
+    assert_equal(["yu"], result.collect {|record| record.key.key})
+  end
+
+  def test_greater_equal
+    result = @users.select do |record|
+      record["hp"] >= 150
+    end
+    assert_equal(["gunyara-kun", "yu"],
+                 result.collect {|record| record.key.key})
+  end
+
+  def test_and
+    result = @users.select do |record|
+      (record["hp"] > 100) & (record["hp"] <= 200)
+    end
+    assert_equal(["gunyara-kun", "yu"],
+                 result.collect {|record| record.key.key})
+  end
+
+  def test_match
+    result = @users.select do |record|
+      record["name"] =~ "ro"
+    end
+    assert_equal(["morita", "yu"],
+                 result.collect {|record| record.key.key})
+  end
+
+  def test_query_string
+    omit("not supported yet!!!")
+    result = @name.select("ro")
+    assert_equal(["morita", "yu"],
+                 result.collect {|record| record.key.key})
+  end
+end

data/test/test-expression.rb

@@ -0,0 +1,55 @@
+# 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 ExpressionTest < Test::Unit::TestCase
+  include GroongaTestUtils
+
+  setup :setup_database
+
+  def test_get_value
+    users = Groonga::Hash.create(:name => "<users>")
+    name = users.define_column("name", "<shorttext>")
+
+    morita = users.add("morita", :name => "mori daijiro")
+
+    expression = Groonga::Expression.new
+    expression.append_constant(morita)
+    expression.append_constant("name")
+    expression.append_operation(Groonga::Operation::OBJECT_GET_VALUE, 2)
+    expression.compile
+    assert_equal("mori daijiro", expression.execute)
+  end
+
+  def test_get_value_with_variable
+    users = Groonga::Hash.create(:name => "<users>")
+    name = users.define_column("name", "<shorttext>")
+
+    morita = users.add("morita", :name => "mori daijiro")
+    gunyara_kun = users.add("gunyara-kun", :name => "Tasuku SUENAGA")
+
+    expression = Groonga::Expression.new
+    variable = expression.define_variable
+    variable.value = morita
+    expression.append_object(variable)
+    expression.append_constant("name")
+    expression.append_operation(Groonga::Operation::OBJECT_GET_VALUE, 2)
+    expression.compile
+
+    assert_equal("mori daijiro", expression.execute)
+
+    variable.value = gunyara_kun.id
+    assert_equal("Tasuku SUENAGA", expression.execute)
+  end
+end

data/test/test-fix-size-column.rb

@@ -0,0 +1,53 @@
+# 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 FixSizeColumnTest < Test::Unit::TestCase
+  include GroongaTestUtils
+
+  def setup
+    setup_database
+
+    setup_bookmarks_table
+  end
+
+  def setup_bookmarks_table
+    @bookmarks_path = @tables_dir + "bookmarks"
+    @bookmarks = Groonga::Array.create(:name => "bookmarks",
+                                       :path => @bookmarks_path.to_s)
+
+    @viewed_column_path = @columns_dir + "viewed"
+    @viewed = @bookmarks.define_column("viewed", "<int>",
+                                       :path => @viewed_column_path.to_s)
+  end
+
+  def test_inspect
+    assert_equal("#<Groonga::FixSizeColumn " +
+                 "id: <#{@viewed.id}>, " +
+                 "name: <bookmarks.viewed>, " +
+                 "path: <#{@viewed_column_path}>, " +
+                 "domain: <#{@bookmarks.inspect}>, " +
+                 "range: <#{context['<int>'].inspect}>" +
+                 ">",
+                 @viewed.inspect)
+  end
+
+  def test_domain
+    assert_equal(@bookmarks, @viewed.domain)
+  end
+
+  def test_table
+    assert_equal(@bookmarks, @viewed.table)
+  end
+end

data/test/test-hash.rb

@@ -102,11 +102,11 @@ class HashTest < Test::Unit::TestCase
                  named_table.inspect)
   end
 
-  def test_inspect_named_temporary
-    named_table = Groonga::Hash.create(:name => "name")
+  def test_inspect_temporary
+    named_table = Groonga::Hash.create
     assert_equal("#<Groonga::Hash " +
                  "id: <#{named_table.id}>, " +
-                 "name: <name>, " +
+                 "name: (anonymous), " +
                  "path: (temporary), " +
                  "domain: <nil>, " +
                  "range: <nil>, " +
@@ -191,4 +191,11 @@ class HashTest < Test::Unit::TestCase
     users_opened.add("morita")
     assert_equal(1, users_created.size)
   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
 end

data/test/test-index-column.rb

@@ -54,4 +54,28 @@ class IndexColumnTest < Test::Unit::TestCase
     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 => "<token:bigram>")
+    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 assert_search(expected, content_index, keyword)
+    result = content_index.search(keyword).collect do |entry|
+      entry.key["content"]
+    end
+    assert_equal(expected, result)
+  end
 end

data/test/test-patricia-trie.rb

@@ -32,6 +32,8 @@ class PatriciaTrieTest < Test::Unit::TestCase
   end
 
   def test_search
+    omit("creating entry is broken.")
+
     users = Groonga::Array.create(:name => "<users>")
     user_name = users.define_column("name", "<shorttext>")
 
@@ -79,4 +81,11 @@ class PatriciaTrieTest < Test::Unit::TestCase
     users_opened.add("morita")
     assert_equal(1, users_created.size)
   end
+
+  def test_has_key?
+    users = Groonga::PatriciaTrie.create(:name => "<users>")
+    assert_false(users.has_key?("morita"))
+    users.add("morita")
+    assert_true(users.has_key?("morita"))
+  end
 end