groonga 0.0.7 → 0.9.0

data/test/test-expression.rb

@@ -19,9 +19,24 @@ class ExpressionTest < Test::Unit::TestCase
 
   setup :setup_database
 
+  def test_array_reference
+    expression = Groonga::Expression.new
+    ryoqun = expression.define_variable({:name => "user"})
+    ryoqun.value = "ryoqun"
+    mori = expression.define_variable
+    mori.value = "mori"
+
+    expression.append_object(ryoqun)
+    expression.append_object(mori)
+
+    assert_equal("ryoqun", expression["user"])
+    assert_equal("ryoqun", expression[0])
+    assert_equal("mori", expression[1])
+  end
+
   def test_get_value
-    users = Groonga::Hash.create(:name => "<users>")
-    name = users.define_column("name", "<shorttext>")
+    users = Groonga::Hash.create(:name => "Users")
+    name = users.define_column("name", "ShortText")
 
     morita = users.add("morita", :name => "mori daijiro")
 
@@ -35,8 +50,8 @@ class ExpressionTest < Test::Unit::TestCase
   end
 
   def test_get_value_with_variable
-    users = Groonga::Hash.create(:name => "<users>")
-    name = users.define_column("name", "<shorttext>")
+    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")
@@ -63,17 +78,17 @@ class ExpressionTest < Test::Unit::TestCase
     expression.append_operation(Groonga::Operation::PLUS, 2)
     expression.compile
 
-    assert_equal("#<Groonga::Expression noname(){1 1}>", expression.inspect)
+    assert_equal("#<Groonga::Expression noname(){1 1 PLUS}>", expression.inspect)
   end
 
   def test_snippet
-    users = Groonga::Array.create(:name => "users")
+    users = Groonga::Array.create(:name => "Users")
     name = users.define_column("name", "ShortText")
-    terms = Groonga::Hash.create(:name => "terms",
+    terms = Groonga::Hash.create(:name => "Terms",
                                  :key_type => "ShortText",
                                  :default_tokenizer => "TokenBigram")
     users.define_index_column("user_name", users,
-                              :source => "users.name",
+                              :source => "Users.name",
                               :with_position => true)
 
     expression = Groonga::Expression.new
@@ -94,4 +109,25 @@ class ExpressionTest < Test::Unit::TestCase
                                  "Rubyらしい読み書きしやすい構文で利用できる" +
                                  "ことが利点です。"))
   end
+
+  def test_snippet_without_tags
+    users = Groonga::Array.create(:name => "Users")
+    name = users.define_column("name", "ShortText")
+    terms = Groonga::Hash.create(:name => "Terms",
+                                 :key_type => "ShortText",
+                                 :default_tokenizer => "TokenBigram")
+    users.define_index_column("user_name", users,
+                              :source => "Users.name",
+                              :with_position => true)
+
+    expression = Groonga::Expression.new
+    variable = expression.define_variable(:domain => users)
+    expression.append_object(variable)
+    expression.parse("ラングバ", :default_column => name)
+    expression.compile
+
+    snippet = expression.snippet([], :width => 30)
+    assert_equal(["ラングバプロジェクト"],
+                 snippet.execute("ラングバプロジェクトはカラムストア機能も"))
+  end
 end

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

@@ -24,21 +24,21 @@ class FixSizeColumnTest < Test::Unit::TestCase
 
   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)
 
     @viewed_column_path = @columns_dir + "viewed"
-    @viewed = @bookmarks.define_column("viewed", "<int>",
+    @viewed = @bookmarks.define_column("viewed", "Int32",
                                        :path => @viewed_column_path.to_s)
   end
 
   def test_inspect
     assert_equal("#<Groonga::FixSizeColumn " +
                  "id: <#{@viewed.id}>, " +
-                 "name: <bookmarks.viewed>, " +
+                 "name: <Bookmarks.viewed>, " +
                  "path: <#{@viewed_column_path}>, " +
-                 "domain: <#{@bookmarks.inspect}>, " +
-                 "range: <#{context['<int>'].inspect}>, " +
+                 "domain: <Bookmarks>, " +
+                 "range: <Int32>, " +
                  "flags: <KEY_INT>" +
                  ">",
                  @viewed.inspect)
@@ -51,4 +51,15 @@ class FixSizeColumnTest < Test::Unit::TestCase
   def test_table
     assert_equal(@bookmarks, @viewed.table)
   end
+
+  def test_assign_time
+    comments = Groonga::Array.create(:name => "Comments")
+    comments.define_column("title", "ShortText")
+    comments.define_column("issued", "Time")
+    title = "Good"
+    issued = 1187430026
+    record = comments.add(:title => title, :issued => issued)
+    assert_equal([title, Time.at(issued)],
+                 [record["title"], record["issued"]])
+  end
 end

data/test/test-gqtp.rb

@@ -0,0 +1,70 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 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
+# 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 GQTPTest < Test::Unit::TestCase
+  include GroongaTestUtils
+
+  setup :setup_database
+
+  setup
+  def setup_comments
+    @users = Groonga::Hash.create(:name => "Users", :key_type => "ShortText")
+
+    @comments = Groonga::Array.create(:name => "Comments")
+    @comments.define_column("content", "Text")
+    @comments.define_column("created_at", "Time")
+    @comments.define_column("user", "Users")
+
+    terms = Groonga::PatriciaTrie.create(:name => "Terms",
+                                         :default_tokenizer => "TokenBigram")
+    terms.define_index_column("comment_content", @comments,
+                              :with_section => true,
+                              :source => "content")
+    @comment1 = @comments.add(:content => "Hello Good-bye!",
+                              :created_at => Time.parse("2009-08-09"),
+                              :user => "morita")
+    @comment2 = @comments.add(:content => "Hello World",
+                              :created_at => Time.parse("2009-07-09"),
+                              :user => "")
+    @comment3 = @comments.add(:content => "test",
+                              :created_at => Time.parse("2009-06-09"),
+                              :user => "gunyara-kun")
+    @japanese_comment =
+      @comments.add(:content => "うちのボロTVはまだ現役です",
+                    :created_at => Time.parse("2009-06-09"),
+                    :user => "darashi")
+  end
+
+  def test_select_filter_by_existent_user
+    assert_equal([[0], [[1], ["user"], ["darashi"]]],
+                 process("select Comments --output_columns user " +
+                         "--filter 'user == \"darashi\"'"))
+  end
+
+  def test_select_filter_by_nonexistent_user
+    assert_equal([[0], [[0], ["user"]]],
+                 process("select Comments --output_columns user " +
+                         "--filter 'user == \"yu\"'"))
+  end
+
+  private
+  def process(gqtp)
+    context.send(gqtp)
+    id, result = context.receive
+    JSON.parse(result)
+  end
+end

data/test/test-hash.rb

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# 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
@@ -21,7 +21,7 @@ class HashTest < Test::Unit::TestCase
 
   def test_delete
     bookmarks_path = @tables_dir + "bookmarks"
-    bookmarks = Groonga::Hash.create(:name => "bookmarks",
+    bookmarks = Groonga::Hash.create(:name => "Bookmarks",
                                      :path => bookmarks_path.to_s)
 
     groonga = bookmarks.add("groonga")
@@ -40,25 +40,33 @@ class HashTest < Test::Unit::TestCase
                  bookmarks.collect {|bookmark| bookmark.key})
   end
 
-  def test_array_reference
-    value = "groonga"
-    value_type = Groonga::Type.new("Text#{value.size}", :size => value.size)
+  def test_value
     bookmarks_path = @tables_dir + "bookmarks"
-    bookmarks = Groonga::Hash.create(:name => "bookmarks",
+    bookmarks = Groonga::Hash.create(:name => "Bookmarks",
                                      :path => bookmarks_path.to_s,
-                                     :key_type => "<shorttext>",
-                                     :value_type => value_type)
-    bookmarks["http://google.com/"] = value
-    assert_equal(value, bookmarks["http://google.com/"])
+                                     :key_type => "ShortText",
+                                     :value_type => "UInt32")
+    bookmarks.set_value("http://google.com/", 29)
+    assert_equal(29, bookmarks.value("http://google.com/"))
   end
 
-  def test_find
+  def test_column_value
+    bookmarks_path = @tables_dir + "bookmarks"
+    bookmarks = Groonga::Hash.create(:name => "Bookmarks",
+                                     :path => bookmarks_path.to_s,
+                                     :key_type => "ShortText")
+    uri = 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>")
+                                     :key_type => "ShortText")
     bookmark = bookmarks.add("http://google.com/")
-    assert_equal(bookmark, bookmarks.find("http://google.com/"))
+    assert_equal(bookmark, bookmarks["http://google.com/"])
   end
 
 
@@ -69,8 +77,8 @@ class HashTest < Test::Unit::TestCase
                  "id: <#{anonymous_table.id}>, " +
                  "name: (anonymous), " +
                  "path: <#{path}>, " +
-                 "domain: <nil>, " +
-                 "range: <nil>, " +
+                 "domain: (nil), " +
+                 "range: (nil), " +
                  "flags: <>, " +
                  "encoding: <#{encoding.inspect}>, " +
                  "size: <0>>",
@@ -83,8 +91,8 @@ class HashTest < Test::Unit::TestCase
                  "id: <#{anonymous_table.id}>, " +
                  "name: (anonymous), " +
                  "path: (temporary), " +
-                 "domain: <nil>, " +
-                 "range: <nil>, " +
+                 "domain: (nil), " +
+                 "range: (nil), " +
                  "flags: <>, " +
                  "encoding: <#{encoding.inspect}>, " +
                  "size: <0>>",
@@ -93,13 +101,13 @@ class HashTest < Test::Unit::TestCase
 
   def test_inspect_named
     path = @tables_dir + "named.groonga"
-    named_table = Groonga::Hash.create(:name => "name", :path => path.to_s)
+    named_table = Groonga::Hash.create(:name => "Users", :path => path.to_s)
     assert_equal("#<Groonga::Hash " +
                  "id: <#{named_table.id}>, " +
-                 "name: <name>, " +
+                 "name: <Users>, " +
                  "path: <#{path}>, " +
-                 "domain: <nil>, " +
-                 "range: <nil>, " +
+                 "domain: (nil), " +
+                 "range: (nil), " +
                  "flags: <>, " +
                  "encoding: <#{encoding.inspect}>, " +
                  "size: <0>>",
@@ -112,8 +120,8 @@ class HashTest < Test::Unit::TestCase
                  "id: <#{named_table.id}>, " +
                  "name: (anonymous), " +
                  "path: (temporary), " +
-                 "domain: <nil>, " +
-                 "range: <nil>, " +
+                 "domain: (nil), " +
+                 "range: (nil), " +
                  "flags: <>, " +
                  "encoding: <#{encoding.inspect}>, " +
                  "size: <0>>",
@@ -128,17 +136,17 @@ class HashTest < Test::Unit::TestCase
   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 = "TokenBigram"
+    assert_equal(Groonga::Context.default["TokenBigram"],
                  hash.default_tokenizer)
   end
 
   def test_search
-    users = Groonga::Array.create(:name => "<users>")
-    user_name = users.define_column("name", "<shorttext>")
+    users = Groonga::Array.create(:name => "Users")
+    user_name = users.define_column("name", "ShortText")
 
-    bookmarks = Groonga::Hash.create(:name => "<bookmarks>",
-                                     :key_type => "<shorttext>")
+    bookmarks = Groonga::Hash.create(:name => "Bookmarks",
+                                     :key_type => "ShortText")
     bookmark_user_id = bookmarks.define_column("user_id", users)
 
     daijiro = users.add
@@ -155,33 +163,33 @@ class HashTest < Test::Unit::TestCase
   end
 
   def test_add
-    users = Groonga::Hash.create(:name => "<users>")
-    users.define_column("address", "<text>")
+    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>")
+    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>")
+    Groonga::Hash.create(:name => "Users")
     assert_raise(Groonga::InvalidArgument) do
-      Groonga::Hash.create(:name => "<users>")
+      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>")
+    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")
+                                      :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")
@@ -191,14 +199,14 @@ class HashTest < Test::Unit::TestCase
   end
 
   def test_open_same_name
-    users_created = Groonga::Hash.create(:name => "<users>")
-    users_opened = Groonga::Hash.open(:name => "<users>")
+    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
 
   def test_has_key?
-    users = Groonga::Hash.create(:name => "<users>")
+    users = Groonga::Hash.create(:name => "Users")
     assert_false(users.has_key?("morita"))
     users.add("morita")
     assert_true(users.has_key?("morita"))
@@ -210,4 +218,95 @@ class HashTest < Test::Unit::TestCase
       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
 end