rroonga 4.0.8-x64-mingw32 → 5.0.0-x64-mingw32

data/rroonga-build.rb

@@ -1,5 +1,6 @@
 #!/usr/bin/env ruby
 #
+# Copyright (C) 2015  Masafumi Yokoyama <yokoyama@clear-code.com>
 # Copyright (C) 2009-2014  Kouhei Sutou <kou@clear-code.com>
 #
 # This library is free software; you can redistribute it and/or
@@ -17,17 +18,17 @@
 
 module RroongaBuild
   module RequiredGroongaVersion
-    MAJOR = 4
+    MAJOR = 5
     MINOR = 0
-    MICRO = 9
+    MICRO = 0
     VERSION = [MAJOR, MINOR, MICRO]
-    RELEASED_DATE = Time.utc(2014, 12, 29)
+    RELEASED_DATE = Time.utc(2015, 2, 9)
   end
 
   module LatestGroongaVersion
-    MAJOR = 4
+    MAJOR = 5
     MINOR = 0
-    MICRO = 9
+    MICRO = 0
     VERSION = [MAJOR, MINOR, MICRO]
   end
 

data/test/groonga-test-utils.rb

@@ -1,3 +1,4 @@
+# Copyright (C) 2015  Masafumi Yokoyama <yokoyama@clear-code.com>
 # Copyright (C) 2009-2014  Kouhei Sutou <kou@clear-code.com>
 #
 # This library is free software; you can redistribute it and/or
@@ -165,6 +166,14 @@ module GroongaTestUtils
     omit("Ruby 1.9 is needed.") unless ruby19?
   end
 
+  def linux?
+    /linux/ =~ RUBY_PLATFORM
+  end
+
+  def only_linux
+    omit("This test is only for Linux system.") unless linux?
+  end
+
   def support_self_recursive_equal?
     self_recursive_hash1 = {}
     self_recursive_hash1["next"] = self_recursive_hash1

data/test/test-array.rb

@@ -242,6 +242,17 @@ EXPECTED_OUTPUT
 $stdout.sync = true
 
 base_dir = #{base_dir.dump}
+
+groonga_command_dir = File.join(base_dir, "..", "groonga-command")
+if File.exist?(groonga_command_dir)
+  $LOAD_PATH.unshift(File.join(groonga_command_dir, "lib"))
+end
+
+groonga_client_dir = File.join(base_dir, "..", "groonga-client")
+if File.exist?(groonga_client_dir)
+  $LOAD_PATH.unshift(File.join(groonga_client_dir, "lib"))
+end
+
 ext_dir = File.join(base_dir, "ext", "groonga")
 lib_dir = File.join(base_dir, "lib")
 

data/test/test-exception.rb

@@ -1,5 +1,5 @@
+# Copyright (C) 2014-2015  Masafumi Yokoyama <yokoyama@clear-code.com>
 # Copyright (C) 2009-2014  Kouhei Sutou <kou@clear-code.com>
-# Copyright (C) 2014  Masafumi Yokoyama <myokoym@gmail.com>
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -97,6 +97,8 @@ class ExceptionTest < Test::Unit::TestCase
     assert_const_defined(Groonga, :UnsupportedCommandVersion)
     assert_const_defined(Groonga, :NormalizerError)
     assert_const_defined(Groonga, :TokenFilterError)
+    assert_const_defined(Groonga, :CommandError)
+    assert_const_defined(Groonga, :PluginError)
   end
 end
 

data/test/test-normalizer.rb

@@ -1,3 +1,5 @@
+# -*- coding: utf-8 -*-
+#
 # Copyright (C) 2012  Kouhei Sutou <kou@clear-code.com>
 #
 # This library is free software; you can redistribute it and/or
@@ -21,4 +23,30 @@ class NormalizerTest < Test::Unit::TestCase
   def test_normalize
     assert_equal("abc", Groonga::Normalizer.normalize("AbC"))
   end
+
+  def test_normalize_with_space
+    assert_equal("abcdefgh", Groonga::Normalizer.normalize("AbC Def　gh"))
+  end
+
+  def test_normalize_with_space_explicitly
+    assert_equal("abcdefgh",
+                 Groonga::Normalizer.normalize("AbC Def　gh",
+                                               :remove_blank => true))
+  end
+
+  def test_normalize_group_text
+    assert_equal("キロメートルキロメートルキロメートルキロメートル",
+                 Groonga::Normalizer.normalize("㌖㌖㌖㌖"));
+  end
+
+  def test_normalize_keep_space
+    # full width space => half width space
+    assert_equal("abc def gh",
+                 Groonga::Normalizer.normalize("AbC Def　gh",
+                                               :remove_blank => false))
+  end
+
+  def test_normalize_tilda
+    assert_equal("~~~", Groonga::Normalizer.normalize("~～〜"))
+  end
 end

data/test/test-record.rb

@@ -619,6 +619,11 @@ class RecordTest < Test::Unit::TestCase
     def setup
       setup_database
       setup_schema
+      setup_tz
+    end
+
+    def teardown
+      teardown_tz
     end
 
     def setup_schema
@@ -633,6 +638,14 @@ class RecordTest < Test::Unit::TestCase
       @bookmarks = Groonga["Bookmarks"]
     end
 
+    def setup_tz
+      @tz_original = ENV["TZ"]
+    end
+
+    def teardown_tz
+      ENV["TZ"] = @tz_original
+    end
+
     def test_to_json
       ENV["TZ"] = "Japan"
       created_at = Time.parse("2013-05-16T16:57:34+09:00")
@@ -652,5 +665,26 @@ class RecordTest < Test::Unit::TestCase
       }.to_json
       assert_equal(expected, groonga.to_json)
     end
+
+    def test_to_json_with_leap_second
+      only_linux
+      ENV["TZ"] = "right/Japan"
+      created_at = Time.parse("2012-07-01T08:59:60+09:00")
+      values = {
+        "uri"        => "http://groonga.org/",
+        "rate"       => 5,
+        "comment"    => "Great!",
+        "created_at" => created_at,
+      }
+      groonga = @bookmarks.add(values)
+      expected = {
+        "_id"        => groonga.id,
+        "comment"    => values["comment"],
+        "created_at" => created_at.iso8601,
+        "rate"       => values["rate"],
+        "uri"        => values["uri"],
+      }.to_json
+      assert_equal(expected, groonga.to_json)
+    end
   end
 end

data/test/test-table-group.rb

@@ -0,0 +1,366 @@
+# Copyright (C) 2015  Masafumi Yokoyama <yokoyama@clear-code.com>
+# Copyright (C) 2009-2013  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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+class TableGroupTest < Test::Unit::TestCase
+  include GroongaTestUtils
+
+  setup :setup_database
+
+  class MaxNSubRecordsTest < self
+    setup
+    def setup_schema
+      Groonga::Schema.define do |schema|
+        schema.create_table("Bookmarks", :type => :hash) do |table|
+          table.text("title")
+        end
+
+        schema.create_table("Comments", :type => :array) do |table|
+          table.reference("bookmark")
+          table.text("content")
+          table.int32("rank")
+        end
+      end
+    end
+
+    setup
+    def setup_data
+      setup_bookmarks
+      setup_comments
+    end
+
+    def setup_bookmarks
+      @bookmarks = Groonga["Bookmarks"]
+      @groonga = @bookmarks.add("http://groonga.org/", :title => "groonga")
+      @ruby = @bookmarks.add("http://ruby-lang.org/", :title => "Ruby")
+    end
+
+    def setup_comments
+      @comments = Groonga["Comments"]
+      @comments.add(:bookmark => @groonga,
+                    :content => "garbage comment1",
+                    :rank => 0)
+      @comments.add(:bookmark => @groonga,
+                    :content => "garbage comment2",
+                    :rank => 0)
+      @comments.add(:bookmark => @groonga,
+                    :content => "full-text search",
+                    :rank => 1)
+      @comments.add(:bookmark => @groonga,
+                    :content => "column store",
+                    :rank => 5)
+      @comments.add(:bookmark => @ruby,
+                    :content => "object oriented script language",
+                    :rank => 100)
+      @comments.add(:bookmark => @ruby,
+                    :content => "multi paradigm programming language",
+                    :rank => 80)
+    end
+
+    setup
+    def setup_searched
+      @records = @comments.select do |record|
+        record.rank > 0
+      end
+    end
+
+    def test_upper_limit
+      grouped_records = @records.group("bookmark", :max_n_sub_records => 2)
+      groups = grouped_records.collect do |record|
+        sub_record_contents = record.sub_records.collect do |sub_record|
+          sub_record.content
+        end
+        [record.title, sub_record_contents]
+      end
+      assert_equal([
+                     [
+                       "groonga",
+                       [
+                         "full-text search",
+                         "column store",
+                       ],
+                     ],
+                     [
+                       "Ruby",
+                       [
+                         "object oriented script language",
+                         "multi paradigm programming language",
+                       ],
+                     ],
+                   ],
+                   groups)
+    end
+
+    def test_less_than_limit
+      sorted = @records.sort([{:key => "rank", :order => :descending}],
+                             :limit => 3, :offset => 0)
+      grouped_records = sorted.group("bookmark", :max_n_sub_records => 2)
+      groups = grouped_records.collect do |record|
+        sub_record_ranks = record.sub_records.collect do |sub_record|
+          sub_record.rank
+        end
+        [record.title, sub_record_ranks]
+      end
+      assert_equal([
+                     ["Ruby", [100, 80]],
+                     ["groonga", [5]]
+                   ],
+                   groups)
+    end
+  end
+
+  class KeyTest < self
+    setup
+    def setup_schema
+      Groonga::Schema.define do |schema|
+        schema.create_table("Bookmarks", :type => :hash) do |table|
+          table.text("title")
+        end
+
+        schema.create_table("Comments", :type => :array) do |table|
+          table.reference("bookmark")
+          table.text("content")
+          table.int32("rank")
+        end
+      end
+    end
+
+    setup
+    def setup_data
+      setup_bookmarks
+      setup_comments
+    end
+
+    def setup_bookmarks
+      @bookmarks = Groonga["Bookmarks"]
+      @groonga = @bookmarks.add("http://groonga.org/", :title => "groonga")
+      @ruby = @bookmarks.add("http://ruby-lang.org/", :title => "Ruby")
+    end
+
+    def setup_comments
+      @comments = Groonga["Comments"]
+      @comments.add(:bookmark => @groonga,
+                    :content => "full-text search")
+      @comments.add(:bookmark => @groonga,
+                    :content => "column store")
+      @comments.add(:bookmark => @ruby,
+                    :content => "object oriented script language")
+    end
+
+    def test_string
+      grouped_records = @comments.group("bookmark").collect do |record|
+        bookmark = record.key
+        [
+          record.n_sub_records,
+          bookmark["title"],
+          bookmark.key,
+        ]
+      end
+      assert_equal([
+                     [2, "groonga", "http://groonga.org/"],
+                     [1, "Ruby", "http://ruby-lang.org/"],
+                   ],
+                   grouped_records)
+    end
+
+    def test_array
+      grouped_records = @comments.group(["bookmark"]).collect do |record|
+        bookmark = record.key
+        [
+          record.n_sub_records,
+          bookmark["title"],
+          bookmark.key,
+        ]
+      end
+      assert_equal([
+                     [2, "groonga", "http://groonga.org/"],
+                     [1, "Ruby", "http://ruby-lang.org/"],
+                   ],
+                   grouped_records)
+    end
+
+    def test_accessor
+      grouped_records = @comments.group("bookmark._key").collect do |record|
+        [
+          record.n_sub_records,
+          record.key
+        ]
+      end
+      assert_equal([
+                     [2, "http://groonga.org/"],
+                     [1, "http://ruby-lang.org/"],
+                   ],
+                   grouped_records)
+    end
+
+    def test_nonexistent
+      message = "unknown group key: <\"nonexistent\">: <#{@comments.inspect}>"
+      assert_raise(ArgumentError.new(message)) do
+        @comments.group("nonexistent")
+      end
+    end
+  end
+
+  class MultipleKeyTest < self
+    setup
+    def setup_schema
+      Groonga::Schema.define do |schema|
+        schema.create_table("Memos", :type => :hash) do |table|
+          table.short_text("tag")
+          table.int64("priority")
+        end
+      end
+    end
+
+    setup
+    def setup_data
+      setup_memos
+    end
+
+    def setup_memos
+      @memos = Groonga["Memos"]
+      @memos.add("Groonga1",
+                 :tag => "Groonga",
+                 :priority => 10)
+      @memos.add("Groonga2",
+                 :tag => "Groonga",
+                 :priority => 20)
+      @memos.add("Mroonga1",
+                 :tag => "Mroonga",
+                 :priority => 10)
+      @memos.add("Mroonga2",
+                 :tag => "Mroonga",
+                 :priority => 10)
+    end
+
+    def test_two_keys
+      keys = ["tag", "priority"]
+      grouped_records = @memos.group(keys).collect do |record|
+        sub_record = record.sub_records.first
+        [
+          record.n_sub_records,
+          sub_record.tag,
+          sub_record.priority,
+        ]
+      end
+
+      assert_equal([
+                     [1, "Groonga", 10],
+                     [1, "Groonga", 20],
+                     [2, "Mroonga", 10],
+                   ],
+                   grouped_records)
+    end
+  end
+
+  class CalculationTest < self
+    setup
+    def setup_schema
+      Groonga::Schema.define do |schema|
+        schema.create_table("Tags", :type => :hash)
+
+        schema.create_table("Memos", :type => :hash) do |table|
+          table.reference("tag")
+          table.int64("priority")
+        end
+      end
+    end
+
+    setup
+    def setup_data
+      setup_tags
+      setup_memos
+    end
+
+    def setup_tags
+      @tags = Groonga["Tags"]
+      @groonga = @tags.add("Groonga")
+      @mroonga = @tags.add("Mroonga")
+      @rroonga = @tags.add("Rroonga")
+    end
+
+    def setup_memos
+      @memos = Groonga["Memos"]
+      @memos.add("Groonga1",
+                 :tag => @groonga,
+                 :priority => 10)
+      @memos.add("Groonga2",
+                 :tag => @groonga,
+                 :priority => 20)
+      @memos.add("Groonga3",
+                 :tag => @groonga,
+                 :priority => 40)
+      @memos.add("Mroonga1",
+                 :tag => @mroonga,
+                 :priority => 50)
+      @memos.add("Mroonga2",
+                 :tag => @mroonga,
+                 :priority => 25)
+      @memos.add("Mroonga3",
+                 :tag => @mroonga,
+                 :priority => 10)
+      @memos.add("Rroonga1",
+                 :tag => @rroonga,
+                 :priority => 25)
+      @memos.add("Rroonga2",
+                 :tag => @rroonga,
+                 :priority => -25)
+      @memos.add("Rroonga3",
+                 :tag => @rroonga,
+                 :priority => 0)
+    end
+
+    def test_max
+      grouped_records = @memos.group("tag",
+                                     :calc_target => "priority",
+                                     :calc_types => [:max]).collect do |group|
+        tag = group.key
+        [
+          tag.key,
+          group.max,
+        ]
+      end
+
+      assert_equal([
+                     ["Groonga", 40],
+                     ["Mroonga", 50],
+                     ["Rroonga", 25],
+                   ],
+                   grouped_records)
+    end
+
+    def test_all_types
+      grouped_records = @memos.group("tag",
+                                     :calc_target => "priority",
+                                     :calc_types => [:max, :min, :sum, :average]).collect do |group|
+        tag = group.key
+        [
+          tag.key,
+          group.max,
+          group.min,
+          group.sum,
+          group.average.round(3),
+        ]
+      end
+
+      assert_equal([
+                     ["Groonga", 40, 10, 70, 23.333],
+                     ["Mroonga", 50, 10, 85, 28.333],
+                     ["Rroonga", 25, -25, 0, 0.0],
+                   ],
+                   grouped_records)
+    end
+  end
+end