groonga 0.0.7 → 0.9.0

data/test/test-array.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
@@ -28,8 +28,8 @@ class ArrayTest < Test::Unit::TestCase
                  "id: <#{contain_table.id}>, " +
                  "name: <name>, " +
                  "path: <#{path}>, " +
-                 "domain: <nil>, " +
-                 "range: <nil>, " +
+                 "domain: (nil), " +
+                 "range: (nil), " +
                  "flags: <>, " +
                  "size: <3>>",
                  contain_table.inspect)
@@ -41,21 +41,21 @@ class ArrayTest < Test::Unit::TestCase
   end
 
   def test_add
-    users = Groonga::Array.create(:name => "<users>")
-    users.define_column("name", "<text>")
+    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>")
+    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")
+                                      :source => "Bookmarks.user")
     morita = users.add(:name => "morita")
     gunyara_kun = users.add(:name => "gunyara-kun")
     groonga = bookmarks.add(:title => "groonga", :user => morita)
@@ -67,16 +67,31 @@ class ArrayTest < Test::Unit::TestCase
   end
 
   def test_create_duplicated_name
-    Groonga::Array.create(:name => "<users>")
+    Groonga::Array.create(:name => "Users")
     assert_raise(Groonga::InvalidArgument) do
-      Groonga::Array.create(:name => "<users>")
+      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_created = Groonga::Array.create(:name => "Users")
+    users_opened = Groonga::Array.open(:name => "Users")
     users_opened.add
     assert_equal(1, users_created.size)
   end
+
+  def test_value
+    users = Groonga::Array.create(:value_type => "Int32")
+    user_id = users.add.id
+    users.set_value(user_id, 29)
+    assert_equal(29, users.value(user_id))
+  end
+
+  def test_column_value
+    users = Groonga::Array.create(:name => "Users")
+    name = users.define_column("name", "ShortText")
+    morita_id = users.add.id
+    users.set_column_value(morita_id, "name", "morita")
+    assert_equal("morita", users.column_value(morita_id, "name"))
+  end
 end

data/test/test-column.rb

@@ -26,31 +26,31 @@ class ColumnTest < Test::Unit::TestCase
 
   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)
   end
 
   def setup_bookmarks_table
     @bookmarks_path = @tables_dir + "bookmarks"
-    @bookmarks = Groonga::Array.create(:name => "bookmarks",
+    @bookmarks = Groonga::Array.create(:name => "Bookmarks",
                                        :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)
 
     @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)
@@ -117,16 +117,16 @@ class ColumnTest < Test::Unit::TestCase
   end
 
   def test_accessor
-    posts = Groonga::Hash.create(:name => "<posts>", :key_type => "<shorttext>")
-    posts.define_column("body", "<text>")
-    comments = Groonga::Hash.create(:name => "<comments>",
-                                    :key_type => "<shorttext>")
-    content = comments.define_column("content", "<shorttext>")
+    posts = Groonga::Hash.create(:name => "Posts", :key_type => "ShortText")
+    posts.define_column("body", "Text")
+    comments = Groonga::Hash.create(:name => "Comments",
+                                    :key_type => "ShortText")
+    content = comments.define_column("content", "ShortText")
     comments.define_column("post", posts)
 
-    index = Groonga::PatriciaTrie.create(:name => "<terms>",
-                                         :key_type => "<shorttext>")
-    index.default_tokenizer = "<token:bigram>"
+    index = Groonga::PatriciaTrie.create(:name => "Terms",
+                                         :key_type => "ShortText")
+    index.default_tokenizer = "TokenBigram"
     content_index = index.define_index_column("content_index", comments,
                                               :with_position => true)
     content_index.source = content
@@ -143,7 +143,7 @@ class ColumnTest < Test::Unit::TestCase
     result = content_index.search("drive")
     assert_equal([["I'm also like drive", "My Hobby"]],
                  result.records.collect do |record|
-                   [record[".content"], record[".post.:key"]]
+                   [record[".content"], record[".post._key"]]
                  end)
   end
 
@@ -158,71 +158,85 @@ class ColumnTest < Test::Unit::TestCase
   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)
+    languages = Groonga::Hash.create(:name => "Languages",
+                                     :key_type => "ShortText")
+    sites = Groonga::Hash.create(:name => "Sites")
+    sites.define_column("language", languages)
+
+    languages.add("Ruby")
+    taiyaki_ru = sites.add("http://taiyaki.ru/", :language => "Ruby")
+    assert_equal("Ruby", taiyaki_ru[:language].key)
   end
 
   def test_local_name
-    items = Groonga::Array.create(:name => "<items>")
-    title = items.define_column("title", "<shorttext>")
-    assert_equal("<items>.title", title.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
 
-  def test_select
-    posts = Groonga::Hash.create(:name => "<posts>", :key_type => "<shorttext>")
-    body = posts.define_column("body", "<text>")
+  def test_select_query
+    populate_table_for_select
 
-    index = Groonga::PatriciaTrie.create(:name => "<terms>",
-                                         :key_type => "<shorttext>",
-                                         :key_normalize => true)
-    index.default_tokenizer = "<token:bigram>"
-    body_index = index.define_index_column("body_index", posts,
-                                           :with_position => true,
-                                           :source => body)
+    result = @body.select("drive")
+    assert_equal(["Drive and Eat"],
+                 result.records.collect do |record|
+                   record["body"]
+                 end)
+    assert_equal("#<Groonga::Expression noname(?0:\"\")" +
+                 "{body GET_VALUE \"drive\" MATCH}>",
+                 result.expression.inspect)
+  end
+
+  def test_select_query_with_parser
+    populate_table_for_select
 
-    first_post = posts.add("Hello!", :body => "World")
-    hobby = posts.add("My Hobby", :body => "Drive and Eat")
-    
-    result = body.select("drive")
+    result = @body.select("body @ \"drive\"", :syntax => :script)
     assert_equal(["Drive and Eat"],
                  result.records.collect do |record|
                    record["body"]
                  end)
+    assert_equal("#<Groonga::Expression noname(?0:\"\")" +
+                 "{body GET_VALUE \"drive\" MATCH}>",
+                 result.expression.inspect)
   end
 
-  def test_select_with_block
-    posts = Groonga::Hash.create(:name => "<posts>", :key_type => "<shorttext>")
-    body = posts.define_column("body", "<text>")
+  def test_select_expression
+    populate_table_for_select
 
-    index = Groonga::PatriciaTrie.create(:name => "<terms>",
-                                         :key_type => "<shorttext>",
-                                         :key_normalize => true)
-    index.default_tokenizer = "<token:bigram>"
-    body_index = index.define_index_column("body_index", posts,
-                                           :with_position => true,
-                                           :source => body)
+    expression = Groonga::Expression.new
+    variable = expression.define_variable(:domain => @posts)
+    expression.append_object(variable)
+    expression.parse("body:%drive", :syntax => :query)
+    expression.compile
+    result = @body.select(expression)
+    assert_equal(["Drive and Eat"],
+                 result.records.collect do |record|
+                   record["body"]
+                 end)
+    assert_equal("#<Groonga::Expression noname(?0:\"\")" +
+                 "{?0 body GET_VALUE \"drive\" MATCH}>",
+                 result.expression.inspect)
+  end
 
-    first_post = posts.add("Hello!", :body => "World")
-    hobby = posts.add("My Hobby", :body => "Drive and Eat")
-    
-    result = body.select do |column|
+  def test_select_with_block
+    populate_table_for_select
+
+    result = @body.select do |column|
       column =~ "drive"
     end
     assert_equal(["Drive and Eat"],
                  result.records.collect do |record|
                    record["body"]
                  end)
+    assert_equal("#<Groonga::Expression noname(?0:\"\")" +
+                 "{?0 body GET_VALUE \"drive\" MATCH}>",
+                 result.expression.inspect)
   end
 
   def test_set_time
-    posts = Groonga::Hash.create(:name => "<posts>", :key_type => "<shorttext>")
-    body = posts.define_column("issued", "<time>")
+    posts = Groonga::Hash.create(:name => "Posts", :key_type => "ShortText")
+    body = posts.define_column("issued", "Time")
 
     post = posts.add("hello", :issued => 123456)
     assert_equal(Time.at(123456), post[".issued"])
@@ -232,6 +246,28 @@ class ColumnTest < Test::Unit::TestCase
     assert_in_delta(Time.at(1251380635.1234567).usec, post[".issued"].usec, 10)
   end
 
+  def test_set_nil_to_time
+    posts = Groonga::Hash.create(:name => "Posts", :key_type => "ShortText")
+    body = posts.define_column("issued", "Time")
+
+    post = posts.add("hello", :issued => nil)
+    assert_equal(Time.at(0), post["issued"])
+  end
+
+  def test_bool
+    posts = Groonga::Hash.create(:name => "Posts", :key_type => "ShortText")
+    hidden = posts.define_column("hidden", "Bool")
+
+    post = posts.add("hello")
+    assert_false(post["hidden"])
+
+    post["hidden"] = true
+    assert_true(post["hidden"])
+
+    post["hidden"] = false
+    assert_false(post["hidden"])
+  end
+
   private
   def assert_content_search(expected_records, term)
     records = @bookmarks_index_content.search(term).records
@@ -243,4 +279,20 @@ class ColumnTest < Test::Unit::TestCase
     end
     assert_equal(expected_contents, actual_contents)
   end
+
+  def populate_table_for_select
+    @posts = Groonga::Hash.create(:name => "Posts", :key_type => "ShortText")
+    @body = @posts.define_column("body", "Text")
+
+    index = Groonga::PatriciaTrie.create(:name => "Terms",
+                                         :key_type => "ShortText",
+                                         :key_normalize => true)
+    index.default_tokenizer = "TokenBigram"
+    body_index = index.define_index_column("body_index", @posts,
+                                           :with_position => true,
+                                           :source => @body)
+
+    first_post = @posts.add("Hello!", :body => "World")
+    hobby = @posts.add("My Hobby", :body => "Drive and Eat")
+  end
 end

data/test/test-context.rb

@@ -65,4 +65,9 @@ class ContextTest < Test::Unit::TestCase
     context = Groonga::Context.default
     assert_equal("Bool", context[:Bool].name)
   end
+
+  def test_shortcut_access
+    Groonga::Database.create
+    assert_equal("ShortText", Groonga["ShortText"].name)
+  end
 end

data/test/test-database.rb

@@ -63,43 +63,8 @@ class DatabaseTest < Test::Unit::TestCase
   def test_each
     db_path = @tmp_dir + "db"
     database = Groonga::Database.create(:path => db_path.to_s)
-    assert_equal(["Bool",
-                  "Float",
-                  "Int16",
-                  "Int32",
-                  "Int64",
-                  "Int8",
-                  "LongText",
-                  "Object",
-                  "ShortText",
-                  "Text",
-                  "Time",
-                  "TokenBigram",
-                  "TokenDelimit",
-                  "TokenMecab",
-                  "TokenTrigram",
-                  "TokenUnigram",
-                  "TokyoGeoPoint",
-                  "UInt16",
-                  "UInt32",
-                  "UInt64",
-                  "UInt8",
-                  "WGS84GeoPoint",
-                  "column_create",
-                  "column_list",
-                  "define_selector",
-                  "expr_missing",
-                  "load",
-                  "now",
-                  "quit",
-                  "rand",
-                  "select",
-                  "shutdown",
-                  "status",
-                  "table_create",
-                  "table_list",
-                  "view_add"],
-                 database.collect {|object| object.name}.sort)
+    default_object_names = database.collect {|object| object.name}.sort
+    assert_send([default_object_names, :include?, "Bool"])
   end
 
   def test_encoding

data/test/test-exception.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
@@ -19,6 +19,9 @@ class ExceptionTest < Test::Unit::TestCase
   def test_defined
     assert_not_const_defined(Groonga, :Success)
 
+    assert_const_defined(Groonga, :Error)
+    assert_const_defined(Groonga, :ObjectClosed)
+
     assert_const_defined(Groonga, :EndOfData)
     assert_const_defined(Groonga, :UnknownError)
     assert_const_defined(Groonga, :OperationNotPermitted)
@@ -81,5 +84,10 @@ class ExceptionTest < Test::Unit::TestCase
     assert_const_defined(Groonga, :AddressIsInUse)
     assert_const_defined(Groonga, :ZLibError)
     assert_const_defined(Groonga, :LZOError)
+    assert_const_defined(Groonga, :StackOverFlow)
+    assert_const_defined(Groonga, :SyntaxError)
+    assert_const_defined(Groonga, :RetryMax)
+    assert_const_defined(Groonga, :IncompatibleFileFormat)
+    assert_const_defined(Groonga, :UpdateNotAllowed)
   end
 end

data/test/test-expression-builder.rb

@@ -21,15 +21,15 @@ class ExpressionBuilderTest < Test::Unit::TestCase
   setup :setup_data
 
   def setup_tables
-    @users = Groonga::Hash.create(:name => "<users>")
-    @name = @users.define_column("name", "<shorttext>")
-    @hp = @users.define_column("hp", "<uint>")
+    @users = Groonga::Hash.create(:name => "Users")
+    @name = @users.define_column("name", "ShortText")
+    @hp = @users.define_column("hp", "UInt32")
 
-    @terms = Groonga::PatriciaTrie.create(:name => "<terms>",
+    @terms = Groonga::PatriciaTrie.create(:name => "Terms",
                                           :default_tokenizer => "TokenBigram")
     @terms.define_index_column("user-name", @users, :source => @name)
 
-    @bookmarks = Groonga::Array.create(:name => "bookmarks")
+    @bookmarks = Groonga::Array.create(:name => "Bookmarks")
     @bookmarks.define_column("user", @users)
     @bookmarks.define_column("uri", "ShortText")
   end
@@ -135,4 +135,22 @@ class ExpressionBuilderTest < Test::Unit::TestCase
     assert_equal(["http://groonga.org/", "http://ruby-lang.org/"],
                  result.collect {|record| record.key["uri"]})
   end
+
+  def test_nested_column
+    result = @bookmarks.select do |record|
+      record[".user.name"] == @morita["name"]
+    end
+    assert_equal(["http://groonga.org/", "http://ruby-lang.org/"],
+                 result.collect {|record| record.key["uri"]})
+  end
+
+  def test_nil_match
+    @users.select do |record|
+      exception = ArgumentError.new("match word should not be nil: Users.name")
+      assert_raise(exception) do
+        record["name"] =~ nil
+      end
+      record["name"] == "dummy"
+    end
+  end
 end