rroonga 4.0.6 → 4.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0e374f62d1dc60540f41658d346241ed699fb853
-  data.tar.gz: a41b8257c7716190ea709d516fd34e4229c36c38
+  metadata.gz: 21a2beefeeeffe25a4ebeecbad4934aa49a64dad
+  data.tar.gz: ff7dda3b86483ab0c6c72d46afb77e3bdb4c1205
 SHA512:
-  metadata.gz: 325d4a719363ba06a78c9e8109926b6312d2f677650f85b242d889c7b2145963323e4c5c347e691c75f0c917bbb32c74513401eae7fc0220050efa0dcaa50515
-  data.tar.gz: aecc0398616ba0b886db0eae9bba0599af1d414f2a70be4c79139a2402aaedae9966b600033559c7509328324637e5ab4642af44e8bab86a6155963caa424123
+  metadata.gz: 22514a54cff330d7efdd782b01864c20eb9f6b04b70ff76ca7cbbf56369afcbc4129ad710fd66308bfbc58011960afc1b9085e737a96c814caff4127427094fb
+  data.tar.gz: de929ed9ed74bdc1fb168ecc7ff4fa69f929ad949f9a5d6f1275c9b66aef6b9932d83a0db54ffb4e633b5dde95b0ed90ccfbc0faff772b2650f9b5bc0b1714f2

data/README.md

@@ -40,7 +40,7 @@ contributed patches.)
 ## Dependencies
 
 * Ruby >= 1.9.3
-* Groonga >= 4.0.4
+* Groonga >= 4.0.7
 
 ## Install
 

data/doc/text/news.textile

@@ -1,5 +1,17 @@
 h1. NEWS
 
+h2(#4-0-7). 4.0.7: 2014-12-12
+
+h3. Improvements
+
+* Supported Groonga 4.0.8. Groonga 4.0.7 or older aren't supported.
+* Added @:reuse_posting_object@ option to
+  {Groonga::IndexCursor#each}. The option improves performance by
+  reducing memory allocation. The option is disabled by default because
+  reusing the same object isn't Rubyish.
+* Added {Groonga::IndexCursor#estimate_size}. [GitHub#38]
+* Accepted string for integer, unsigned integer and float type key.
+
 h2(#4-0-6). 4.0.6: 2014-11-06
 
 h3. Improvements
@@ -11,8 +23,8 @@ h3. Improvements
 ** Supported @:lz4@ in {Groonga::VariableSizeColumn#compressed?} options.
 ** Added {Groonga::LZ4Error}.
 ** [grndump] Supported @COMPRESS_ZLIB@ and @COMPRESS_LZ4@ flags.
-** Added {Groonga::TableKeySupport#token_filters}.
-** Added {Groonga::TableKeySupport#token_filters=}.
+** Added {Groonga::Table::KeySupport#token_filters}.
+** Added {Groonga::Table::KeySupport#token_filters=}.
 ** Supported @:token_filters@ in {Groonga::Hash.create} options.
 ** Supported @:token_filters@ in {Groonga::PatriciaTrie.create} options.
 ** Supported @:token_filters@ in {Groonga::DoubleArrayTrie.create} options.

data/ext/groonga/extconf.rb

@@ -283,9 +283,6 @@ have_func("rb_sym2str", "ruby.h")
 have_func("rb_to_symbol", "ruby.h")
 have_type("enum ruby_value_type", "ruby.h")
 
-# TODO: Remove me after Groogna 4.0.8 is released.
-have_func("grn_expr_dump_plan", "groonga.h")
-
 checking_for(checking_message("--enable-debug-log option")) do
   enable_debug_log = enable_config("debug-log", false)
   if enable_debug_log

data/ext/groonga/rb-grn-expression.c

@@ -498,13 +498,11 @@ rb_grn_expression_compile (VALUE self)
  * Dump execution plan of the `expression` in string.
  *
  * @overload dump_plan
- * @since 4.0.8
+ * @since 4.0.7
  */
 static VALUE
 rb_grn_expression_dump_plan (VALUE self)
 {
-/* TODO: Remove me after Groogna 4.0.8 is released. */
-#ifdef HAVE_GRN_EXPR_DUMP_PLAN
     grn_ctx *context = NULL;
     grn_obj *expression;
     grn_obj dumped_plan;
@@ -520,9 +518,6 @@ rb_grn_expression_dump_plan (VALUE self)
     grn_obj_unlink(context, &dumped_plan);
 
     return rb_dumped_plan;
-#else
-    return rb_str_new2("");
-#endif
 }
 
 /*

data/ext/groonga/rb-grn-index-column.c

@@ -955,6 +955,99 @@ rb_grn_index_column_open_cursor (int argc, VALUE *argv, VALUE self)
         return rb_cursor;
 }
 
+/*
+ * Estimates the number of documents found by the given token ID.
+ *
+ * @example Token ID style
+ *    # Define 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"]
+ *
+ *    # Add data
+ *    articles.add(:content => "Groonga is fast")
+ *    articles.add(:content => "Rroonga is fast")
+ *    articles.add(:content => "Mroonga is fast")
+ *
+ *    # Estimate the number of documents found by token ID
+ *    p @index.estimate_size(@terms["fast"].id)    # => 7
+ *    p @index.estimate_size(@terms["Groonga"].id) # => 1
+ *
+ * @example Token record style
+ *    # Define 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"]
+ *
+ *    # Add data
+ *    articles.add(:content => "Groonga is fast")
+ *    articles.add(:content => "Rroonga is fast")
+ *    articles.add(:content => "Mroonga is fast")
+ *
+ *    # Estimate the number of documents found by token record
+ *    p @index.estimate_size(@terms["fast"])    # => 7
+ *    p @index.estimate_size(@terms["Groonga"]) # => 1
+ *
+ * @overload estimate_size(token_id)
+ *   @param [Integer, Record] token_id The token ID to be estimated.
+ *   @return [Integer] The estimated number of documents found by the
+ *     given token ID.
+ *
+ * @since 4.0.7
+ */
+static VALUE
+rb_grn_index_column_estimate_size (VALUE self, VALUE rb_token_id)
+{
+    grn_ctx *context;
+    grn_obj *column;
+    grn_obj *domain_object;
+    grn_id token_id;
+    unsigned int size;
+
+    rb_grn_index_column_deconstruct(SELF(self), &column, &context,
+                                    NULL, &domain_object,
+                                    NULL, NULL, NULL,
+                                    NULL, NULL,
+                                    NULL, NULL);
+
+    token_id = RVAL2GRNID(rb_token_id, context, domain_object, self);
+    size = grn_ii_estimate_size(context, (grn_ii *)column, token_id);
+
+    return UINT2NUM(size);
+}
+
 void
 rb_grn_init_index_column (VALUE mGrn)
 {
@@ -990,4 +1083,7 @@ rb_grn_init_index_column (VALUE mGrn)
 
     rb_define_method(rb_cGrnIndexColumn, "open_cursor",
                      rb_grn_index_column_open_cursor, -1);
+
+    rb_define_method(rb_cGrnIndexColumn, "estimate_size",
+                     rb_grn_index_column_estimate_size, 1);
 }

data/ext/groonga/rb-grn-index-cursor.c

@@ -57,7 +57,8 @@ rb_grn_index_cursor_deconstruct (RbGrnIndexCursor *rb_grn_index_cursor,
 }
 
 static VALUE
-next_value (grn_ctx *context, grn_obj *cursor, VALUE rb_table, VALUE rb_lexicon)
+next_value (VALUE rb_posting,
+            grn_ctx *context, grn_obj *cursor, VALUE rb_table, VALUE rb_lexicon)
 {
     grn_posting *posting;
     grn_id term_id;
@@ -67,7 +68,12 @@ next_value (grn_ctx *context, grn_obj *cursor, VALUE rb_table, VALUE rb_lexicon)
         return Qnil;
     }
 
-    return rb_grn_posting_new(posting, term_id, rb_table, rb_lexicon);
+    if (NIL_P(rb_posting)) {
+        return rb_grn_posting_new(posting, term_id, rb_table, rb_lexicon);
+    } else {
+        rb_grn_posting_update(rb_posting, posting, term_id);
+        return rb_posting;
+    }
 }
 
 static VALUE
@@ -84,7 +90,7 @@ rb_grn_index_cursor_next (VALUE self)
         VALUE rb_lexicon;
         rb_table = rb_iv_get(self, "@table");
         rb_lexicon = rb_iv_get(self, "@lexicon");
-        rb_posting = next_value(context, cursor, rb_table, rb_lexicon);
+        rb_posting = next_value(Qnil, context, cursor, rb_table, rb_lexicon);
     }
 
     return rb_posting;
@@ -92,14 +98,24 @@ rb_grn_index_cursor_next (VALUE self)
 }
 
 static VALUE
-rb_grn_index_cursor_each (VALUE self)
+rb_grn_index_cursor_each (int argc, VALUE *argv, VALUE self)
 {
     grn_obj *cursor;
     grn_ctx *context;
+    grn_bool reuse_posting_object;
+    VALUE rb_options;
+    VALUE rb_reuse_posting_object;
     VALUE rb_table;
     VALUE rb_lexicon;
+    VALUE rb_posting = Qnil;
+
+    RETURN_ENUMERATOR(self, argc, argv);
+
+    rb_scan_args(argc, argv, "01", &rb_options);
 
-    RETURN_ENUMERATOR(self, 0, NULL);
+    rb_grn_scan_options(rb_options,
+                        "reuse_posting_object", &rb_reuse_posting_object,
+                        NULL);
 
     rb_grn_index_cursor_deconstruct(SELF(self), &cursor, &context,
                                     NULL, NULL, NULL, NULL);
@@ -114,9 +130,17 @@ rb_grn_index_cursor_each (VALUE self)
 
     rb_table = rb_iv_get(self, "@table");
     rb_lexicon = rb_iv_get(self, "@lexicon");
+    reuse_posting_object = RVAL2CBOOL(rb_reuse_posting_object);
+
+    if (reuse_posting_object) {
+        rb_posting = rb_grn_posting_new(NULL, GRN_ID_NIL, rb_table, rb_lexicon);
+    }
     while (GRN_TRUE) {
-        VALUE rb_posting;
-        rb_posting = next_value(context, cursor, rb_table, rb_lexicon);
+        if (!reuse_posting_object) {
+            rb_posting = Qnil;
+        }
+        rb_posting = next_value(rb_posting,
+                                context, cursor, rb_table, rb_lexicon);
         if (NIL_P(rb_posting)) {
             break;
         }
@@ -135,5 +159,5 @@ rb_grn_init_index_cursor (VALUE mGrn)
     rb_include_module(rb_cGrnIndexCursor, rb_mEnumerable);
 
     rb_define_method(rb_cGrnIndexCursor, "next", rb_grn_index_cursor_next, 0);
-    rb_define_method(rb_cGrnIndexCursor, "each", rb_grn_index_cursor_each, 0);
+    rb_define_method(rb_cGrnIndexCursor, "each", rb_grn_index_cursor_each, -1);
 }

data/ext/groonga/rb-grn-posting.c

@@ -32,13 +32,15 @@ rb_grn_posting_new (grn_posting *posting, grn_id term_id,
 #define SET_PARAMETER(key, value) \
     rb_hash_aset(parameters, RB_GRN_INTERN(key), INT2NUM((value)))
 
-    SET_PARAMETER("record_id", posting->rid);
-    SET_PARAMETER("section_id", posting->sid);
+    if (posting) {
+        SET_PARAMETER("record_id", posting->rid);
+        SET_PARAMETER("section_id", posting->sid);
+        SET_PARAMETER("position", posting->pos);
+        SET_PARAMETER("term_frequency", posting->tf);
+        SET_PARAMETER("weight", posting->weight);
+        SET_PARAMETER("n_rest_postings", posting->rest);
+    }
     SET_PARAMETER("term_id", term_id);
-    SET_PARAMETER("position", posting->pos);
-    SET_PARAMETER("term_frequency", posting->tf);
-    SET_PARAMETER("weight", posting->weight);
-    SET_PARAMETER("n_rest_postings", posting->rest);
 
 #undef SET_PARAMETER
 
@@ -49,6 +51,24 @@ rb_grn_posting_new (grn_posting *posting, grn_id term_id,
                       parameters);
 }
 
+void
+rb_grn_posting_update (VALUE self, grn_posting *posting, grn_id term_id)
+{
+#define SET_PARAMETER(key, value) \
+    rb_funcall(self, rb_intern(key "="), 1, INT2NUM(value));
+
+    SET_PARAMETER("record_id",       posting->rid);
+    SET_PARAMETER("section_id",      posting->sid);
+    SET_PARAMETER("position",        posting->pos);
+    SET_PARAMETER("term_frequency",  posting->tf);
+    SET_PARAMETER("weight",          posting->weight);
+    SET_PARAMETER("n_rest_postings", posting->rest);
+
+    SET_PARAMETER("term_id",         term_id);
+
+#undef SET_PARAMETER
+}
+
 void
 rb_grn_init_posting (VALUE mGrn)
 {

data/ext/groonga/rb-grn-utils.c

@@ -481,46 +481,73 @@ rb_grn_bulk_from_ruby_object_with_type (VALUE object, grn_ctx *context,
 
     switch (type_id) {
     case GRN_DB_INT8:
+        if (string_p) {
+            object = rb_Integer(object);
+        }
         value.int8_value = NUM2SHORT(object);
         string = (const char *)&(value.int8_value);
         size = sizeof(value.int8_value);
         break;
     case GRN_DB_UINT8:
+        if (string_p) {
+            object = rb_Integer(object);
+        }
         value.uint8_value = NUM2USHORT(object);
         string = (const char *)&(value.uint8_value);
         size = sizeof(value.uint8_value);
         break;
     case GRN_DB_INT16:
+        if (string_p) {
+            object = rb_Integer(object);
+        }
         value.int16_value = NUM2SHORT(object);
         string = (const char *)&(value.int16_value);
         size = sizeof(value.int16_value);
         break;
     case GRN_DB_UINT16:
+        if (string_p) {
+            object = rb_Integer(object);
+        }
         value.uint16_value = NUM2USHORT(object);
         string = (const char *)&(value.uint16_value);
         size = sizeof(value.uint16_value);
         break;
     case GRN_DB_INT32:
+        if (string_p) {
+            object = rb_Integer(object);
+        }
         value.int32_value = NUM2INT(object);
         string = (const char *)&(value.int32_value);
         size = sizeof(value.int32_value);
         break;
     case GRN_DB_UINT32:
+        if (string_p) {
+            object = rb_Integer(object);
+        }
         value.uint32_value = NUM2UINT(object);
         string = (const char *)&(value.uint32_value);
         size = sizeof(value.uint32_value);
         break;
     case GRN_DB_INT64:
+        if (string_p) {
+            object = rb_Integer(object);
+        }
         value.int64_value = NUM2LL(object);
         string = (const char *)&(value.int64_value);
         size = sizeof(value.int64_value);
         break;
     case GRN_DB_UINT64:
+        if (string_p) {
+            object = rb_Integer(object);
+        }
         value.uint64_value = NUM2ULL(object);
         string = (const char *)&(value.uint64_value);
         size = sizeof(value.uint64_value);
         break;
     case GRN_DB_FLOAT:
+        if (string_p) {
+            object = rb_Float(object);
+        }
         value.double_value = NUM2DBL(object);
         string = (const char *)&(value.double_value);
         size = sizeof(value.double_value);

data/ext/groonga/rb-grn.h

@@ -92,7 +92,7 @@ RB_GRN_BEGIN_DECLS
 
 #define RB_GRN_MAJOR_VERSION 4
 #define RB_GRN_MINOR_VERSION 0
-#define RB_GRN_MICRO_VERSION 6
+#define RB_GRN_MICRO_VERSION 7
 
 #define RB_GRN_QUERY_DEFAULT_MAX_EXPRESSIONS 32
 
@@ -568,6 +568,9 @@ VALUE          rb_grn_posting_new                   (grn_posting *posting,
                                                      grn_id term_id,
                                                      VALUE rb_table,
                                                      VALUE rb_lexicon);
+void           rb_grn_posting_update                (VALUE rb_posting,
+                                                     grn_posting *posting,
+                                                     grn_id term_id);
 
 VALUE          rb_grn_tokyo_geo_point_new           (int   latitude,
                                                      int   longitude);

data/rroonga-build.rb

@@ -19,15 +19,15 @@ module RroongaBuild
   module RequiredGroongaVersion
     MAJOR = 4
     MINOR = 0
-    MICRO = 7
+    MICRO = 8
     VERSION = [MAJOR, MINOR, MICRO]
-    RELEASED_DATE = Time.utc(2014, 10, 29)
+    RELEASED_DATE = Time.utc(2014, 11, 29)
   end
 
   module LatestGroongaVersion
     MAJOR = 4
     MINOR = 0
-    MICRO = 7
+    MICRO = 8
     VERSION = [MAJOR, MINOR, MICRO]
   end
 

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.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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rroonga
 version: !ruby/object:Gem::Version
-  version: 4.0.6
+  version: 4.0.7
 platform: ruby
 authors:
 - Kouhei Sutou
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-06 00:00:00.000000000 Z
+date: 2014-12-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pkg-config
@@ -194,10 +194,10 @@ email:
 - y.hayamizu@gmail.com
 - dara@shidara.net
 executables:
-- groonga-index-dump
+- grntest-log-analyze
 - grndump
 - groonga-database-inspect
-- grntest-log-analyze
+- groonga-index-dump
 extensions:
 - ext/groonga/extconf.rb
 extra_rdoc_files:
@@ -375,57 +375,57 @@ specification_version: 4
 summary: Ruby bindings for Groonga that provide full text search and column store
   features.
 test_files:
-- test/test-schema.rb
+- test/test-schema-create-table.rb
+- test/test-type.rb
+- test/test-table-select.rb
+- test/test-variable-size-column.rb
+- test/test-table-select-normalize.rb
+- test/test-lock-timeout.rb
+- test/test-record.rb
+- test/test-plugin.rb
+- test/groonga-test-utils.rb
+- test/test-logger.rb
 - test/test-snippet.rb
+- test/test-memory-pool.rb
+- test/test-command-select.rb
+- test/test-expression-builder.rb
+- test/test-database-dumper.rb
+- test/test-encoding.rb
 - test/test-variable.rb
-- test/test-geo-point.rb
-- test/test-plugin.rb
-- test/test-accessor.rb
+- test/test-context.rb
+- test/run-test.rb
+- test/test-index-cursor.rb
+- test/test-table-select-mecab.rb
 - test/test-double-array-trie.rb
-- test/test-pagination.rb
-- test/test-memory-pool.rb
+- test/test-sub-records.rb
+- test/test-table-offset-and-limit.rb
+- test/test-table-select-weight.rb
+- test/test-convert.rb
 - test/test-column.rb
+- test/test-table.rb
+- test/test-gqtp.rb
 - test/test-table-traverse.rb
-- test/test-expression.rb
-- test/test-table-select.rb
-- test/test-encoding.rb
-- test/test-logger.rb
-- test/test-schema-create-table.rb
-- test/test-hash.rb
-- test/test-type.rb
-- test/test-table-offset-and-limit.rb
+- test/test-schema.rb
 - test/test-version.rb
-- test/test-lock-timeout.rb
+- test/test-exception.rb
+- test/test-array.rb
+- test/test-patricia-trie.rb
+- test/test-schema-type.rb
+- test/test-database.rb
 - test/test-index-column.rb
-- test/test-table-key-support.rb
-- test/test-vector-column.rb
 - test/test-normalizer.rb
-- test/test-table-select-weight.rb
-- test/test-schema-type.rb
-- test/test-sub-records.rb
-- test/test-procedure.rb
-- test/test-context.rb
-- test/test-gqtp.rb
-- test/test-remote.rb
-- test/test-database-dumper.rb
+- test/test-vector-column.rb
 - test/test-database-inspector.rb
-- test/test-patricia-trie.rb
-- test/run-test.rb
-- test/test-fix-size-column.rb
+- test/test-pagination.rb
+- test/test-procedure.rb
+- test/test-geo-point.rb
+- test/test-table-key-support.rb
 - test/test-statistic-measurer.rb
-- test/test-array.rb
-- test/test-table.rb
-- test/groonga-test-utils.rb
-- test/test-record.rb
-- test/test-exception.rb
-- test/test-table-select-normalize.rb
+- test/test-fix-size-column.rb
+- test/test-accessor.rb
+- test/test-hash.rb
+- test/test-expression.rb
+- test/test-remote.rb
 - test/test-schema-dumper.rb
 - test/test-table-dumper.rb
-- test/test-database.rb
-- test/test-variable-size-column.rb
-- test/test-table-select-mecab.rb
-- test/test-expression-builder.rb
-- test/test-convert.rb
-- test/test-index-cursor.rb
-- test/test-command-select.rb
 has_rdoc: