rroonga 4.0.6-x64-mingw32 → 4.0.7-x64-mingw32

data/test/test-column.rb

@@ -169,9 +169,18 @@ class ColumnTest < Test::Unit::TestCase
                  result.records.collect do |record|
                    record["body"]
                  end)
-    assert_equal("#<Groonga::Expression noname($1:null)" +
-                 "{2body GET_VALUE,0\"drive\",0MATCH}>",
-                 result.expression.inspect)
+    assert_equal(<<-INSPECTED.chomp, result.expression.inspect)
+#<Groonga::Expression #<expr
+  vars:{
+    $1:#<record:hash:Posts id:0(nonexistent)>
+  },
+  codes:{
+    0:<get_value(), modify:2, value:#<column:var_size Posts.body range:Text type:scalar compress:none>>,
+    1:<push(), modify:0, value:"drive">,
+    2:<match(), modify:0, value:(NULL)>
+  }
+>>
+    INSPECTED
   end
 
   def test_select_query_from_ctx
@@ -200,9 +209,18 @@ class ColumnTest < Test::Unit::TestCase
                  result.records.collect do |record|
                    record["body"]
                  end)
-    assert_equal("#<Groonga::Expression noname($1:null)" +
-                 "{2body GET_VALUE,0\"drive\",0MATCH}>",
-                 result.expression.inspect)
+    assert_equal(<<-INSPECTED.chomp, result.expression.inspect)
+#<Groonga::Expression #<expr
+  vars:{
+    $1:#<record:hash:Posts id:0(nonexistent)>
+  },
+  codes:{
+    0:<get_value(), modify:2, value:#<column:var_size Posts.body range:Text type:scalar compress:none>>,
+    1:<push(), modify:0, value:"drive">,
+    2:<match(), modify:0, value:(NULL)>
+  }
+>>
+    INSPECTED
   end
 
   def test_select_expression
@@ -218,9 +236,19 @@ class ColumnTest < Test::Unit::TestCase
                  result.records.collect do |record|
                    record["body"]
                  end)
-    assert_equal("#<Groonga::Expression noname($1:null)" +
-                 "{0null,2body GET_VALUE,0\"drive\",0MATCH}>",
-                 result.expression.inspect)
+    assert_equal(<<-INSPECTED.chomp, result.expression.inspect)
+#<Groonga::Expression #<expr
+  vars:{
+    $1:#<record:hash:Posts id:0(nonexistent)>
+  },
+  codes:{
+    0:<push(), modify:0, value:#<record:hash:Posts id:0(nonexistent)>>,
+    1:<get_value(), modify:2, value:#<column:var_size Posts.body range:Text type:scalar compress:none>>,
+    2:<push(), modify:0, value:"drive">,
+    3:<match(), modify:0, value:(NULL)>
+  }
+>>
+    INSPECTED
   end
 
   def test_select_with_block
@@ -233,9 +261,19 @@ class ColumnTest < Test::Unit::TestCase
                  result.records.collect do |record|
                    record["body"]
                  end)
-    assert_equal("#<Groonga::Expression noname($1:null)" +
-                 "{1null,2body GET_VALUE,0\"drive\",0MATCH}>",
-                 result.expression.inspect)
+    assert_equal(<<-INSPECTED.chomp, result.expression.inspect)
+#<Groonga::Expression #<expr
+  vars:{
+    $1:#<record:hash:Posts id:0(nonexistent)>
+  },
+  codes:{
+    0:<push(), modify:1, value:#<record:hash:Posts id:0(nonexistent)>>,
+    1:<get_value(), modify:2, value:#<column:var_size Posts.body range:Text type:scalar compress:none>>,
+    2:<push(), modify:0, value:"drive">,
+    3:<match(), modify:0, value:(NULL)>
+  }
+>>
+    INSPECTED
   end
 
   def test_set_time

data/test/test-expression-builder.rb

@@ -569,7 +569,7 @@ EOC
       result = @bookmarks.select do |record|
         record.user.pet.name == "morita Bob"
       end
-      assert_equal(["http://groonga.org/", "http://ruby-lang.org/"],
+      assert_equal(["http://groonga.org/", "http://ruby-lang.org/", "http://dic.nicovideo.jp/"],
                    result.collect {|record| record["uri"]})
     end
   end

data/test/test-expression.rb

@@ -77,8 +77,17 @@ class ExpressionTest < Test::Unit::TestCase
     expression.append_operation(Groonga::Operation::PLUS, 2)
     expression.compile
 
-    assert_equal("#<Groonga::Expression noname(){21,01,0PLUS}>",
-                 expression.inspect)
+    assert_equal(<<-INSPECTED.chomp, expression.inspect)
+#<Groonga::Expression #<expr
+  vars:{
+  },
+  codes:{
+    0:<push(), modify:2, value:1>,
+    1:<push(), modify:0, value:1>,
+    2:<plus(), modify:0, value:(NULL)>
+  }
+>>
+    INSPECTED
   end
 
   def test_snippet
@@ -162,14 +171,28 @@ class ExpressionTest < Test::Unit::TestCase
         @expression.append_object(Groonga["TokenBigram"],
                                   Groonga::Operator::PUSH,
                                   1)
-        assert_equal("#<Groonga::Expression noname(){0TokenBigram}>",
-                     @expression.inspect)
+        assert_equal(<<-INSPECTED.chomp, @expression.inspect)
+#<Groonga::Expression #<expr
+  vars:{
+  },
+  codes:{
+    0:<push(), modify:0, value:#<proc:tokenizer TokenBigram arguments:[$1, $2, $3]>>
+  }
+>>
+        INSPECTED
       end
 
       def test_name
         @expression.append_object(Groonga["TokenBigram"], "push", 1)
-        assert_equal("#<Groonga::Expression noname(){0TokenBigram}>",
-                     @expression.inspect)
+        assert_equal(<<-INSPECTED.chomp, @expression.inspect)
+#<Groonga::Expression #<expr
+  vars:{
+  },
+  codes:{
+    0:<push(), modify:0, value:#<proc:tokenizer TokenBigram arguments:[$1, $2, $3]>>
+  }
+>>
+        INSPECTED
       end
     end
   end
@@ -183,14 +206,28 @@ class ExpressionTest < Test::Unit::TestCase
     class OperatorTest < self
       def test_constant
         @expression.append_constant(29, Groonga::Operator::PUSH, 1)
-        assert_equal("#<Groonga::Expression noname(){029}>",
-                     @expression.inspect)
+        assert_equal(<<-INSPECTED.chomp, @expression.inspect)
+#<Groonga::Expression #<expr
+  vars:{
+  },
+  codes:{
+    0:<push(), modify:0, value:29>
+  }
+>>
+        INSPECTED
       end
 
       def test_name
         @expression.append_constant(29, "push", 1)
-        assert_equal("#<Groonga::Expression noname(){029}>",
-                     @expression.inspect)
+        assert_equal(<<-INSPECTED.chomp, @expression.inspect)
+#<Groonga::Expression #<expr
+  vars:{
+  },
+  codes:{
+    0:<push(), modify:0, value:29>
+  }
+>>
+        INSPECTED
       end
     end
   end
@@ -205,14 +242,32 @@ class ExpressionTest < Test::Unit::TestCase
 
     def test_constant
       @expression.append_operation(Groonga::Operator::PLUS, 2)
-      assert_equal("#<Groonga::Expression noname(){229,092,0PLUS}>",
-                   @expression.inspect)
+      assert_equal(<<-INSPECTED.chomp, @expression.inspect)
+#<Groonga::Expression #<expr
+  vars:{
+  },
+  codes:{
+    0:<push(), modify:2, value:29>,
+    1:<push(), modify:0, value:92>,
+    2:<plus(), modify:0, value:(NULL)>
+  }
+>>
+      INSPECTED
     end
 
     def test_name
       @expression.append_operation("plus", 2)
-      assert_equal("#<Groonga::Expression noname(){229,092,0PLUS}>",
-                   @expression.inspect)
+      assert_equal(<<-INSPECTED.chomp, @expression.inspect)
+#<Groonga::Expression #<expr
+  vars:{
+  },
+  codes:{
+    0:<push(), modify:2, value:29>,
+    1:<push(), modify:0, value:92>,
+    2:<plus(), modify:0, value:(NULL)>
+  }
+>>
+      INSPECTED
     end
   end
 
@@ -244,48 +299,48 @@ class ExpressionTest < Test::Unit::TestCase
 
     class DefaultOperatorTest < self
       def test_nil
-        assert_equal("AND", parse(nil))
+        assert_equal("and", parse(nil))
       end
 
       def test_name
-        assert_equal("OR", parse("or"))
+        assert_equal("or", parse("or"))
       end
 
       def test_name_symbol
-        assert_equal("OR", parse(:or))
+        assert_equal("or", parse(:or))
       end
 
       def test_symbol
-        assert_equal("OR", parse("||"))
+        assert_equal("or", parse("||"))
       end
 
       def test_integer
-        assert_equal("ADJUST", parse(Groonga::Operator::ADJUST))
+        assert_equal("adjust", parse(Groonga::Operator::ADJUST))
       end
 
       private
       def parse(default_operator)
         @expression.parse("_id:1 _id:2", :default_operator => default_operator)
-        operator = @expression.inspect[/\d([a-zA-Z_-]+)}/, 1]
+        operator = @expression.inspect[/6:<([a-zA-Z_-]+)/, 1]
         operator
       end
     end
 
     class DefaultModeTest < self
       def test_nil
-        assert_equal("MATCH", parse(nil))
+        assert_equal("match", parse(nil))
       end
 
       def test_name
-        assert_equal("EQUAL", parse("equal"))
+        assert_equal("equal", parse("equal"))
       end
 
       def test_symbol
-        assert_equal("EQUAL", parse(:equal))
+        assert_equal("equal", parse(:equal))
       end
 
       def test_integer
-        assert_equal("EQUAL", parse(Groonga::Operator::EQUAL))
+        assert_equal("equal", parse(Groonga::Operator::EQUAL))
       end
 
       private
@@ -293,7 +348,7 @@ class ExpressionTest < Test::Unit::TestCase
         @expression.parse("query",
                           :default_column => "_id",
                           :default_mode => default_mode)
-        operator = @expression.inspect[/\d([a-zA-Z_-]+)}/, 1]
+        operator = @expression.inspect[/2:<([a-zA-Z_-]+)/, 1]
         operator
       end
     end

data/test/test-index-column.rb

@@ -500,4 +500,45 @@ class IndexColumnTest < Test::Unit::TestCase
       end
     end
   end
+
+  class EstimateSizeTest < self
+    setup
+    def setup_schema
+      Groonga::Schema.define do |schema|
+        schema.create_table("Articles") do |table|
+          table.text("content")
+        end
+
+        schema.create_table("Terms",
+                            :type => :hash,
+                            :key_type => "ShortText",
+                            :default_tokenizer => "TokenBigram",
+                            :normalizer => "NormalizerAuto") do |table|
+          table.index("Articles.content",
+                      :name => "articles_content",
+                      :with_position => true,
+                      :with_section => true)
+        end
+      end
+
+      @articles = Groonga["Articles"]
+      @terms = Groonga["Terms"]
+      @index = Groonga["Terms.articles_content"]
+    end
+
+    setup
+    def setup_data
+      @articles.add(:content => "Groonga is fast")
+      @articles.add(:content => "Rroonga is fast")
+      @articles.add(:content => "Mroonga is fast")
+    end
+
+    def test_id
+      assert_equal(7, @index.estimate_size(@terms["fast"].id))
+    end
+
+    def test_record
+      assert_equal(7, @index.estimate_size(@terms["fast"]))
+    end
+  end
 end

data/test/test-index-cursor.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2012  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2012-2014  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
@@ -66,6 +66,26 @@ class IndexCursorTest < Test::Unit::TestCase
     assert_true(opened)
   end
 
+  def test_each_reuse_posting_object
+    opened = false
+    @terms.open_cursor do |table_cursor|
+      @content_index.open_cursor(table_cursor) do |cursor|
+        posting_object_ids = []
+        postings = []
+        cursor.each(:reuse_posting_object => true) do |posting|
+          posting_object_ids << posting.object_id
+          postings << posting.to_hash
+        end
+        assert_equal([posting_object_ids.first] * posting_object_ids.size,
+                     posting_object_ids)
+        assert_equal(expected_postings, postings)
+        opened = true
+      end
+    end
+
+    assert_true(opened)
+  end
+
   def test_record
     record = nil
     @terms.open_cursor do |table_cursor|

data/test/test-table-key-support.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2013  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2013-2014  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
@@ -76,6 +76,64 @@ class TableKeySupportTest < Test::Unit::TestCase
     end
   end
 
+  class CastTest < self
+    def test_int8
+      key = "-1"
+      ids = Groonga::Hash.create(:name => "IDs", :key_type => "Int8")
+      id = ids.add(key)
+      assert_equal(key.to_i, id.key)
+    end
+
+    def test_uint8
+      key = "1"
+      ids = Groonga::Hash.create(:name => "IDs", :key_type => "UInt8")
+      id = ids.add(key)
+      assert_equal(key.to_i, id.key)
+    end
+
+    def test_int16
+      key = (-(2 ** 8)).to_s
+      ids = Groonga::Hash.create(:name => "IDs", :key_type => "Int16")
+      id = ids.add(key)
+      assert_equal(key.to_i, id.key)
+    end
+
+    def test_uint16
+      key = (2 ** 8).to_s
+      ids = Groonga::Hash.create(:name => "IDs", :key_type => "UInt16")
+      id = ids.add(key)
+      assert_equal(key.to_i, id.key)
+    end
+
+    def test_int32
+      key = (-(2 ** 16)).to_s
+      ids = Groonga::Hash.create(:name => "IDs", :key_type => "Int32")
+      id = ids.add(key)
+      assert_equal(key.to_i, id.key)
+    end
+
+    def test_uint32
+      key = (2 ** 16).to_s
+      ids = Groonga::Hash.create(:name => "IDs", :key_type => "UInt32")
+      id = ids.add(key)
+      assert_equal(key.to_i, id.key)
+    end
+
+    def test_int64
+      key = (-(2 ** 32)).to_s
+      ids = Groonga::Hash.create(:name => "IDs", :key_type => "Int64")
+      id = ids.add(key)
+      assert_equal(key.to_i, id.key)
+    end
+
+    def test_uint64
+      key = (2 ** 32).to_s
+      ids = Groonga::Hash.create(:name => "IDs", :key_type => "UInt64")
+      id = ids.add(key)
+      assert_equal(key.to_i, id.key)
+    end
+  end
+
   class TokenizeTest < self
     class TableTypeTest < self
       def test_hash