rroonga 12.0.0 → 12.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 79bff23494809c1f6cf740acf2151f06889ad139828c4c4baad981d3bf998127
-  data.tar.gz: 04476d31b9221f714880ebb3e36532cbcdca343d715d4202ececac2d3bff7ec8
+  metadata.gz: 9e1afd17d5a479b6e5c472729d3548f3551b15cec0db30bbf46f8a43266d96a1
+  data.tar.gz: 05b218925dfbf29f4deb9d34c5ab6408cbcecdf11de588d2c8d45efaf0e28417
 SHA512:
-  metadata.gz: ca0f800a11f9cb6135d5117d0cbed6d349d590178b8d2f0aafe7766f0a89148defadd77055392e1c556550850faf254299487367a9a1b1bb119d971f285f9058
-  data.tar.gz: a831fc078b87ba358730984240556cc2063bc185e3e00f3a2cb2789ba6d51aa4c543ea167a6f8da7cca086c0daddffa24eb455e18866adf61055cadcfa8927d9
+  metadata.gz: ce775711f0f90338164a3f5c3f5c7731b9f8d06e8563836f0adb7de325f471d43d9be5bb09a428f2598e801dca502564fbea3b9cb285bb38d8f7310cd22a7251
+  data.tar.gz: fe208b1bf0ee5e04fbccbe6220b2b0b44e80e9825c8b9aaab86017d7d87de8185a7a51eea026532b6d13fdcd310cab7e8484702514e5b256d6957f984107f2c2

data/doc/text/news.md

@@ -1,5 +1,17 @@
 # NEWS
 
+## 12.0.2: 2022-04-04 {#version-12-0-2}
+
+### Improvements
+
+  * Added support for `:weight_float32` for vector column. This
+    requires Groonga 12.0.2 or later.
+
+  * Removed needless `Groonga::IndexColumn#with_weight?`.
+
+  * Added support for `:missing_mode` and `:invalid_mode` for scalar
+    column and vector column. This requires Groonga 12.0.2 or later.
+
 ## 12.0.0: 2022-02-09 {#version-12-0-0}
 
 ### Improvements

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

@@ -1,7 +1,7 @@
 /* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /* vim: set sts=4 sw=4 ts=8 noet: */
 /*
-  Copyright (C) 2009-2021  Sutou Kouhei <kou@clear-code.com>
+  Copyright (C) 2009-2022  Sutou Kouhei <kou@clear-code.com>
   Copyright (C) 2016  Masafumi Yokoyama <yokoyama@clear-code.com>
 
   This library is free software; you can redistribute it and/or
@@ -714,7 +714,7 @@ rb_grn_column_data_p (VALUE self)
 
 /*
  * @overload with_weight?
- * @return [Boolean] @true@ if the column is vector and created with
+ * @return [Boolean] @true@ if the column is created with
  *   @:with_weight => true@ flag, @false@ otherwise.
  * @since 4.0.1
  */
@@ -733,6 +733,26 @@ rb_grn_column_with_weight_p(VALUE self)
     return CBOOL2RVAL(flags & GRN_OBJ_WITH_WEIGHT);
 }
 
+/*
+ * @overload weight_float32?
+ * @return [Boolean] @true@ if the column uses 32 bit float for weight.
+ * @since 12.0.2
+ */
+static VALUE
+rb_grn_column_weight_float32_p(VALUE self)
+{
+    grn_obj *column;
+    grn_ctx *context;
+    grn_column_flags flags;
+
+    rb_grn_column_deconstruct(SELF(self), &column, &context,
+                              NULL, NULL,
+                              NULL, NULL, NULL);
+
+    flags = grn_column_get_flags(context, column);
+    return CBOOL2RVAL(flags & GRN_OBJ_WEIGHT_FLOAT32);
+}
+
 /*
  * Return indexes on `column`. If operator is specified, indexes that
  * can executes the operator are only returned. Otherwise, all indexes
@@ -867,6 +887,8 @@ rb_grn_init_column (VALUE mGrn)
 
     rb_define_method(rb_cGrnColumn, "with_weight?",
                      rb_grn_column_with_weight_p, 0);
+    rb_define_method(rb_cGrnColumn, "weight_float32?",
+                     rb_grn_column_weight_float32_p, 0);
 
     rb_define_method(rb_cGrnColumn, "find_indexes",
                      rb_grn_column_find_indexes, -1);

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

@@ -1,7 +1,7 @@
 /* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /* vim: set sts=4 sw=4 ts=8 noet: */
 /*
-  Copyright (C) 2016-2021  Sutou Kouhei <kou@clear-code.com>
+  Copyright (C) 2016-2022  Sutou Kouhei <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
@@ -245,6 +245,180 @@ rb_grn_data_column_apply_expression (VALUE self)
     return self;
 }
 
+/*
+ * @overload missing_mode
+ * @return [:add, :ignore, :nil] The missing mode of the column.
+ * @since 12.0.2
+ */
+static VALUE
+rb_grn_data_column_get_missing_mode(VALUE self)
+{
+    grn_obj *column;
+    grn_ctx *context;
+    grn_column_flags flags;
+
+    rb_grn_column_deconstruct(SELF(self), &column, &context,
+                              NULL, NULL,
+                              NULL, NULL, NULL);
+
+    flags = grn_column_get_flags(context, column);
+    switch ((flags & GRN_OBJ_MISSING_MASK)) {
+    case GRN_OBJ_MISSING_IGNORE:
+        return rb_id2sym(rb_intern("ignore"));
+    case GRN_OBJ_MISSING_NIL:
+        return rb_id2sym(rb_intern("nil"));
+    default:
+        return rb_id2sym(rb_intern("add"));
+    }
+}
+
+/*
+ * @overload missing_add?
+ * @return [Boolean] @true@ if the column uses @:add@ missing mode.
+ * @since 12.0.2
+ */
+static VALUE
+rb_grn_data_column_missing_add_p(VALUE self)
+{
+    grn_obj *column;
+    grn_ctx *context;
+    grn_column_flags flags;
+
+    rb_grn_column_deconstruct(SELF(self), &column, &context,
+                              NULL, NULL,
+                              NULL, NULL, NULL);
+
+    flags = grn_column_get_flags(context, column);
+    return CBOOL2RVAL((flags & GRN_OBJ_MISSING_MASK) == GRN_OBJ_MISSING_ADD);
+}
+
+/*
+ * @overload missing_ignore?
+ * @return [Boolean] @true@ if the column uses @:ignore@ missing mode.
+ * @since 12.0.2
+ */
+static VALUE
+rb_grn_data_column_missing_ignore_p(VALUE self)
+{
+    grn_obj *column;
+    grn_ctx *context;
+    grn_column_flags flags;
+
+    rb_grn_column_deconstruct(SELF(self), &column, &context,
+                              NULL, NULL,
+                              NULL, NULL, NULL);
+
+    flags = grn_column_get_flags(context, column);
+    return CBOOL2RVAL((flags & GRN_OBJ_MISSING_MASK) == GRN_OBJ_MISSING_IGNORE);
+}
+
+/*
+ * @overload missing_nil?
+ * @return [Boolean] @true@ if the column uses @:nil@ missing mode.
+ * @since 12.0.2
+ */
+static VALUE
+rb_grn_data_column_missing_nil_p(VALUE self)
+{
+    grn_obj *column;
+    grn_ctx *context;
+    grn_column_flags flags;
+
+    rb_grn_column_deconstruct(SELF(self), &column, &context,
+                              NULL, NULL,
+                              NULL, NULL, NULL);
+
+    flags = grn_column_get_flags(context, column);
+    return CBOOL2RVAL((flags & GRN_OBJ_MISSING_MASK) == GRN_OBJ_MISSING_NIL);
+}
+
+/*
+ * @overload invalid_mode
+ * @return [:error, :warn, :ignore] The invalid mode of the column.
+ * @since 12.0.2
+ */
+static VALUE
+rb_grn_data_column_get_invalid_mode(VALUE self)
+{
+    grn_obj *column;
+    grn_ctx *context;
+    grn_column_flags flags;
+
+    rb_grn_column_deconstruct(SELF(self), &column, &context,
+                              NULL, NULL,
+                              NULL, NULL, NULL);
+
+    flags = grn_column_get_flags(context, column);
+    switch ((flags & GRN_OBJ_INVALID_MASK)) {
+    case GRN_OBJ_INVALID_WARN:
+        return rb_id2sym(rb_intern("warn"));
+    case GRN_OBJ_INVALID_IGNORE:
+        return rb_id2sym(rb_intern("ignore"));
+    default:
+        return rb_id2sym(rb_intern("error"));
+    }
+}
+
+/*
+ * @overload invalid_error?
+ * @return [Boolean] @true@ if the column uses @:error@ invalid mode.
+ * @since 12.0.2
+ */
+static VALUE
+rb_grn_data_column_invalid_error_p(VALUE self)
+{
+    grn_obj *column;
+    grn_ctx *context;
+    grn_column_flags flags;
+
+    rb_grn_column_deconstruct(SELF(self), &column, &context,
+                              NULL, NULL,
+                              NULL, NULL, NULL);
+
+    flags = grn_column_get_flags(context, column);
+    return CBOOL2RVAL((flags & GRN_OBJ_INVALID_MASK) == GRN_OBJ_INVALID_ERROR);
+}
+
+/*
+ * @overload invalid_warn?
+ * @return [Boolean] @true@ if the column uses @:warn@ invalid mode.
+ * @since 12.0.2
+ */
+static VALUE
+rb_grn_data_column_invalid_warn_p(VALUE self)
+{
+    grn_obj *column;
+    grn_ctx *context;
+    grn_column_flags flags;
+
+    rb_grn_column_deconstruct(SELF(self), &column, &context,
+                              NULL, NULL,
+                              NULL, NULL, NULL);
+
+    flags = grn_column_get_flags(context, column);
+    return CBOOL2RVAL((flags & GRN_OBJ_INVALID_MASK) == GRN_OBJ_INVALID_WARN);
+}
+
+/*
+ * @overload invalid_ignore?
+ * @return [Boolean] @true@ if the column uses @:ignore@ invalid mode.
+ * @since 12.0.2
+ */
+static VALUE
+rb_grn_data_column_invalid_ignore_p(VALUE self)
+{
+    grn_obj *column;
+    grn_ctx *context;
+    grn_column_flags flags;
+
+    rb_grn_column_deconstruct(SELF(self), &column, &context,
+                              NULL, NULL,
+                              NULL, NULL, NULL);
+
+    flags = grn_column_get_flags(context, column);
+    return CBOOL2RVAL((flags & GRN_OBJ_INVALID_MASK) == GRN_OBJ_INVALID_IGNORE);
+}
+
 void
 rb_grn_init_data_column (VALUE mGrn)
 {
@@ -255,6 +429,24 @@ rb_grn_init_data_column (VALUE mGrn)
     rb_define_method(rb_cGrnDataColumn, "apply_expression",
                      rb_grn_data_column_apply_expression, 0);
 
+    rb_define_method(rb_cGrnDataColumn, "missing_mode",
+                     rb_grn_data_column_get_missing_mode, 0);
+    rb_define_method(rb_cGrnDataColumn, "missing_add?",
+                     rb_grn_data_column_missing_add_p, 0);
+    rb_define_method(rb_cGrnDataColumn, "missing_ignore?",
+                     rb_grn_data_column_missing_ignore_p, 0);
+    rb_define_method(rb_cGrnDataColumn, "missing_nil?",
+                     rb_grn_data_column_missing_nil_p, 0);
+
+    rb_define_method(rb_cGrnDataColumn, "invalid_mode",
+                     rb_grn_data_column_get_invalid_mode, 0);
+    rb_define_method(rb_cGrnDataColumn, "invalid_error?",
+                     rb_grn_data_column_invalid_error_p, 0);
+    rb_define_method(rb_cGrnDataColumn, "invalid_warn?",
+                     rb_grn_data_column_invalid_warn_p, 0);
+    rb_define_method(rb_cGrnDataColumn, "invalid_ignore?",
+                     rb_grn_data_column_invalid_ignore_p, 0);
+
     rb_grn_init_fix_size_column(mGrn);
     rb_grn_init_variable_size_column(mGrn);
 }

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

@@ -1,6 +1,6 @@
 /* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /*
-  Copyright (C) 2009-2020  Sutou Kouhei <kou@clear-code.com>
+  Copyright (C) 2009-2022  Sutou Kouhei <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,53 +21,55 @@
 VALUE rb_cGrnRecordExpressionBuilder;
 VALUE rb_cGrnColumnExpressionBuilder;
 
+static ID id_build;
+static ID id_call;
+static ID id_new;
+
 VALUE
 rb_grn_record_expression_builder_new (VALUE table, VALUE name)
 {
     return rb_funcall(rb_cGrnRecordExpressionBuilder,
-                      rb_intern("new"), 2, table, name);
+                      id_new, 2, table, name);
 }
 
 VALUE
 rb_grn_column_expression_builder_new (VALUE column, VALUE name, VALUE query)
 {
     return rb_funcall(rb_cGrnColumnExpressionBuilder,
-                      rb_intern("new"), 3, column, name, query);
-}
-
-static VALUE
-build (VALUE self)
-{
-    return rb_funcall(self, rb_intern("build"), 0);
+                      id_new, 3, column, name, query);
 }
 
 static VALUE
 build_block (RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, callback_arg))
 {
-    return rb_funcall(rb_block_proc(), rb_intern("call"), 1, yielded_arg);
+    return rb_funcall(rb_block_proc(), id_call, 1, yielded_arg);
 }
 
 VALUE
 rb_grn_record_expression_builder_build (VALUE self)
 {
     if (rb_block_given_p())
-        return rb_iterate(build, self, build_block, self);
+        return rb_block_call(self, id_build, 0, NULL, build_block, self);
     else
-        return build(self);
+        return rb_funcall(self, id_build, 0);
 }
 
 VALUE
 rb_grn_column_expression_builder_build (VALUE self)
 {
     if (rb_block_given_p())
-        return rb_iterate(build, self, build_block, self);
+        return rb_block_call(self, id_build, 0, NULL, build_block, self);
     else
-        return build(self);
+        return rb_funcall(self, id_build, 0);
 }
 
 void
 rb_grn_init_expression_builder (VALUE mGrn)
 {
+    id_build = rb_intern("build");
+    id_call = rb_intern("call");
+    id_new = rb_intern("new");
+
     rb_cGrnRecordExpressionBuilder =
         rb_const_get(mGrn, rb_intern("RecordExpressionBuilder"));
     rb_cGrnColumnExpressionBuilder =

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

@@ -1,6 +1,6 @@
 /* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /*
-  Copyright (C) 2009-2021  Sutou Kouhei <kou@clear-code.com>
+  Copyright (C) 2009-2022  Sutou Kouhei <kou@clear-code.com>
   Copyright (C) 2016  Masafumi Yokoyama <yokoyama@clear-code.com>
   Copyright (C) 2019  Horimoto Yasuhiro <horimoto@clear-code.com>
 
@@ -881,27 +881,6 @@ rb_grn_index_column_with_section_p (VALUE self)
     return CBOOL2RVAL(flags & GRN_OBJ_WITH_SECTION);
 }
 
-/*
- * _column_ がウェイト情報も格納する場合は +true+ を返します。
- *
- * @overload with_weight?
- */
-static VALUE
-rb_grn_index_column_with_weight_p (VALUE self)
-{
-    grn_obj *column;
-    grn_ctx *context;
-    grn_column_flags flags;
-
-    rb_grn_index_column_deconstruct(SELF(self), &column, &context,
-                                    NULL, NULL,
-                                    NULL, NULL, NULL, NULL, NULL,
-                                    NULL, NULL);
-
-    flags = grn_column_get_flags(context, column);
-    return CBOOL2RVAL(flags & GRN_OBJ_WITH_WEIGHT);
-}
-
 /*
  * _column_ が位置情報も格納する場合は +true+ を返します。
  *
@@ -1460,8 +1439,6 @@ rb_grn_init_index_column (VALUE mGrn)
 
     rb_define_method(rb_cGrnIndexColumn, "with_section?",
                      rb_grn_index_column_with_section_p, 0);
-    rb_define_method(rb_cGrnIndexColumn, "with_weight?",
-                     rb_grn_index_column_with_weight_p, 0);
     rb_define_method(rb_cGrnIndexColumn, "with_position?",
                      rb_grn_index_column_with_position_p, 0);
     rb_define_method(rb_cGrnIndexColumn, "small?",

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

@@ -1,6 +1,6 @@
 /* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /*
-  Copyright (C) 2017-2021  Sutou Kouhei <kou@clear-code.com>
+  Copyright (C) 2017-2022  Sutou Kouhei <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
@@ -56,6 +56,15 @@ static const rb_data_type_t rb_grn_inverted_index_cursor_type = {
     RUBY_TYPED_FREE_IMMEDIATELY,
 };
 
+static VALUE
+rb_grn_inverted_index_cursor_alloc (VALUE klass)
+{
+    return TypedData_Wrap_Struct(klass,
+                                 &rb_grn_inverted_index_cursor_type,
+                                 NULL);
+}
+
+
 VALUE
 rb_grn_inverted_index_cursor_to_ruby_object (grn_ctx *context,
                                              grn_ii_cursor *cursor,
@@ -256,6 +265,8 @@ rb_grn_init_inverted_index_cursor (VALUE mGrn)
 {
     rb_cGrnInvertedIndexCursor =
       rb_define_class_under(mGrn, "InvertedIndexCursor", rb_cObject);
+    rb_define_alloc_func(rb_cGrnInvertedIndexCursor,
+                         rb_grn_inverted_index_cursor_alloc);
     rb_include_module(rb_cGrnInvertedIndexCursor, rb_mEnumerable);
 
     rb_define_method(rb_cGrnInvertedIndexCursor, "next",

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

@@ -1,6 +1,6 @@
 /* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /*
-  Copyright (C) 2009-2021  Sutou Kouhei <kou@clear-code.com>
+  Copyright (C) 2009-2022  Sutou Kouhei <kou@clear-code.com>
   Copyright (C) 2014-2016  Masafumi Yokoyama <yokoyama@clear-code.com>
   Copyright (C) 2019  Horimoto Yasuhiro <horimoto@clear-code.com>
 
@@ -927,6 +927,30 @@ rb_grn_object_inspect_content_flags_with_label (VALUE inspected,
             rb_ary_push(inspected_flags, rb_str_new_cstr("COLUMN_SCALAR"));
         } else if (column_flags & GRN_OBJ_COLUMN_VECTOR) {
             rb_ary_push(inspected_flags, rb_str_new_cstr("COLUMN_VECTOR"));
+            if (column_flags & GRN_OBJ_WITH_WEIGHT)
+                rb_ary_push(inspected_flags, rb_str_new_cstr("WITH_WEIGHT"));
+            if (column_flags & GRN_OBJ_WEIGHT_FLOAT32)
+                rb_ary_push(inspected_flags, rb_str_new_cstr("WEIGHT_FLOAT32"));
+        }
+        switch (column_flags & GRN_OBJ_MISSING_MASK) {
+        case GRN_OBJ_MISSING_IGNORE:
+            rb_ary_push(inspected_flags, rb_str_new_cstr("MISSING_IGNORE"));
+            break;
+        case GRN_OBJ_MISSING_NIL:
+            rb_ary_push(inspected_flags, rb_str_new_cstr("MISSING_NIL"));
+            break;
+        default:
+            break;
+        }
+        switch (column_flags & GRN_OBJ_INVALID_MASK) {
+        case GRN_OBJ_INVALID_WARN:
+            rb_ary_push(inspected_flags, rb_str_new_cstr("INVALID_WARN"));
+            break;
+        case GRN_OBJ_INVALID_IGNORE:
+            rb_ary_push(inspected_flags, rb_str_new_cstr("INVALID_IGNORE"));
+            break;
+        default:
+            break;
         }
         break;
     default:

data/ext/groonga/rb-grn-request-timer-id.c

@@ -1,6 +1,6 @@
 /* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /*
-  Copyright (C) 2016-2021  Sutou Kouhei <kou@clear-code.com>
+  Copyright (C) 2016-2022  Sutou Kouhei <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
@@ -38,6 +38,12 @@ static rb_data_type_t data_type = {
     0
 };
 
+static VALUE
+rb_grn_request_timer_id_alloc (VALUE klass)
+{
+    return TypedData_Wrap_Struct(klass, &data_type, NULL);
+}
+
 void *
 rb_grn_request_timer_id_from_ruby_object (VALUE rb_id)
 {
@@ -61,4 +67,6 @@ rb_grn_init_request_timer_id (VALUE mGrn)
 {
     rb_cGrnRequestTimerID =
         rb_define_class_under(mGrn, "RequestTimerID", rb_cObject);
+    rb_define_alloc_func(rb_cGrnRequestTimerID,
+                         rb_grn_request_timer_id_alloc);
 }

data/ext/groonga/rb-grn-table-key-support.c

@@ -1,6 +1,6 @@
 /* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /*
-  Copyright (C) 2009-2021  Sutou Kouhei <kou@clear-code.com>
+  Copyright (C) 2009-2022  Sutou Kouhei <kou@clear-code.com>
   Copyright (C) 2014-2016  Masafumi Yokoyama <yokoyama@clear-code.com>
 
   This library is free software; you can redistribute it and/or
@@ -344,7 +344,7 @@ rb_grn_table_key_support_get_key (VALUE self, VALUE rb_id)
     if (key_size == 0)
         return Qnil;
 
-    if (GRN_BULK_VSIZE(key) < key_size) {
+    if (GRN_BULK_VSIZE(key) < (size_t)key_size) {
         grn_bulk_reserve(context, key, key_size);
         grn_table_get_key(context, table, id, GRN_BULK_HEAD(key), key_size);
     }
@@ -540,7 +540,11 @@ rb_grn_table_key_support_array_set (VALUE self, VALUE rb_key, VALUE rb_values)
     data.id = id;
     data.table = table;
     data.rb_grn_object.context = context;
-    rb_iterate(rb_each, rb_values, set_value, (VALUE)&data);
+    {
+        ID id_each;
+        CONST_ID(id_each, "each");
+        rb_block_call(rb_values, id_each, 0, NULL, set_value, (VALUE)&data);
+    }
 
     return Qnil;
 }

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

@@ -1,6 +1,6 @@
 /* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /*
-  Copyright (C) 2009-2021  Sutou Kouhei <kou@clear-code.com>
+  Copyright (C) 2009-2022  Sutou Kouhei <kou@clear-code.com>
   Copyright (C) 2014-2016  Masafumi Yokoyama <yokoyama@clear-code.com>
   Copyright (C) 2019  Horimoto Yasuhiro <horimoto@clear-code.com>
 
@@ -255,6 +255,36 @@ rb_grn_table_inspect (VALUE self)
  *     * `:lz4`: Compressed by LZ4.
  *     * `:zstd`: Compressed by Zstandard.
  *     * `:zstandard`: Compressed by Zstandard.
+ *   @option options :weight_float32 [Boolean] (false)
+ *     It specifies whether weight is stored as 32 bit float or not.
+ *
+ *     You can't use this option for scalar column.
+ *
+ *     @since 12.0.2
+ *   @option options [:add, :ignore, :nil, nil] :missing_mode (nil)
+ *     It specifies how to process missing value.
+ *
+ *     * `:add`, `nil`: Correspond to `MISSING_ADD`
+ *     * `:ignore`: Correspond to `MISSING_IGNORE`
+ *     * `:nil`: Correspond to `MISSING_NIL`
+ *
+ *     See
+ *     https://groonga.org/docs/reference/commands/column_create.html#column-create-missing-mode
+ *     for each `MISSING_*` values.
+ *
+ *     @since 12.0.2
+ *   @option options [:error, :warn, :ignore, nil] :invalid_mode (nil)
+ *     It specifies how to process invalid value.
+ *
+ *     * `:add`, `nil`: Correspond to `INVALID_ERROR`
+ *     * `:warn`: Correspond to `INVALID_WARN`
+ *     * `:ignore`: Correspond to `INVALID_IGNORE`
+ *
+ *     See
+ *     https://groonga.org/docs/reference/commands/column_create.html#column-create-invalid-mode
+ *     for each `INVALID_*` values.
+ *
+ *     @since 12.0.2
  *
  * @return [Groonga::FixSizeColumn, Groonga::VariableSizeColumn]
  */
@@ -269,6 +299,9 @@ rb_grn_table_define_column (int argc, VALUE *argv, VALUE self)
     grn_column_flags flags = 0;
     VALUE rb_name, rb_value_type;
     VALUE options, rb_path, rb_persistent, rb_compress, rb_type, rb_with_weight;
+    VALUE rb_weight_float32;
+    VALUE rb_missing_mode;
+    VALUE rb_invalid_mode;
     VALUE columns;
     VALUE rb_column;
 
@@ -288,6 +321,9 @@ rb_grn_table_define_column (int argc, VALUE *argv, VALUE self)
                         "type", &rb_type,
                         "with_weight", &rb_with_weight,
                         "compress", &rb_compress,
+                        "weight_float32", &rb_weight_float32,
+                        "missing_mode", &rb_missing_mode,
+                        "invalid_mode", &rb_invalid_mode,
                         NULL);
 
     value_type = RVAL2GRNOBJECT(rb_value_type, &context);
@@ -347,6 +383,43 @@ rb_grn_table_define_column (int argc, VALUE *argv, VALUE self)
                  rb_grn_inspect(rb_compress));
     }
 
+    if (RVAL2CBOOL(rb_weight_float32)) {
+        if (flags & GRN_OBJ_COLUMN_VECTOR) {
+            flags |= GRN_OBJ_WEIGHT_FLOAT32;
+        } else {
+            rb_raise(rb_eArgError,
+                     "can't use 32 bit float weight for scalar column");
+        }
+    }
+
+    if (NIL_P(rb_missing_mode) ||
+        rb_grn_equal_option(rb_missing_mode, "add")) {
+        flags |= GRN_OBJ_MISSING_ADD;
+    } else if (rb_grn_equal_option(rb_missing_mode, "ignore")) {
+        flags |= GRN_OBJ_MISSING_IGNORE;
+    } else if (rb_grn_equal_option(rb_missing_mode, "nil")) {
+        flags |= GRN_OBJ_MISSING_NIL;
+    } else {
+        rb_raise(rb_eArgError,
+                 "invalid missing mode: %s: "
+                 "available types: [:add, :ignore, :nil, nil]",
+                 rb_grn_inspect(rb_missing_mode));
+    }
+
+    if (NIL_P(rb_invalid_mode) ||
+        rb_grn_equal_option(rb_invalid_mode, "error")) {
+        flags |= GRN_OBJ_INVALID_ERROR;
+    } else if (rb_grn_equal_option(rb_invalid_mode, "warn")) {
+        flags |= GRN_OBJ_INVALID_WARN;
+    } else if (rb_grn_equal_option(rb_invalid_mode, "ignore")) {
+        flags |= GRN_OBJ_INVALID_IGNORE;
+    } else {
+        rb_raise(rb_eArgError,
+                 "invalid invalid mode: %s: "
+                 "available types: [:add, :warn, :ignore, nil]",
+                 rb_grn_inspect(rb_invalid_mode));
+    }
+
     column = grn_column_create(context, table, name, name_size,
                                path, flags, value_type);
     if (context->rc) {

data/ext/groonga/rb-grn-variable-size-column.c

@@ -1,6 +1,6 @@
 /* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /*
-  Copyright (C) 2009-2021  Sutou Kouhei <kou@clear-code.com>
+  Copyright (C) 2009-2022  Sutou Kouhei <kou@clear-code.com>
   Copyright (C) 2014-2016  Masafumi Yokoyama <yokoyama@clear-code.com>
 
   This library is free software; you can redistribute it and/or
@@ -193,23 +193,24 @@ rb_grn_variable_size_column_array_reference (VALUE self, VALUE rb_id)
     rb_value = rb_ary_new2(n);
     for (i = 0; i < n; i++) {
         VALUE rb_element_value;
-        unsigned int weight = 0;
+        float weight = 0.0;
         grn_id domain;
         VALUE rb_element;
 
         if (value->header.type == GRN_UVECTOR) {
             grn_id id;
-            id = grn_uvector_get_element(context, value, i, &weight);
+            id = grn_uvector_get_element_record(context, value, i, &weight);
             rb_element_value = rb_grn_record_new(rb_range, id, Qnil);
         } else {
             const char *element_value;
             unsigned int element_value_length;
-            element_value_length = grn_vector_get_element(context,
-                                                          value,
-                                                          i,
-                                                          &element_value,
-                                                          &weight,
-                                                          &domain);
+            element_value_length =
+                grn_vector_get_element_float(context,
+                                             value,
+                                             i,
+                                             &element_value,
+                                             &weight,
+                                             &domain);
             rb_element_value = rb_str_new(element_value, element_value_length);
         }
 
@@ -217,9 +218,15 @@ rb_grn_variable_size_column_array_reference (VALUE self, VALUE rb_id)
         rb_hash_aset(rb_element,
                      RB_GRN_INTERN("value"),
                      rb_element_value);
-        rb_hash_aset(rb_element,
-                     RB_GRN_INTERN("weight"),
-                     UINT2NUM(weight));
+        if (flags & GRN_OBJ_WEIGHT_FLOAT32) {
+            rb_hash_aset(rb_element,
+                         RB_GRN_INTERN("weight"),
+                         rb_float_new(weight));
+        } else {
+            rb_hash_aset(rb_element,
+                         RB_GRN_INTERN("weight"),
+                         UINT2NUM((uint32_t)weight));
+        }
 
         rb_ary_push(rb_value, rb_element);
     }
@@ -240,22 +247,22 @@ hash_element_to_vector_element(VALUE key, VALUE value, VALUE user_data)
 {
     HashElementToVectorElementData *data =
         (HashElementToVectorElementData *)user_data;
-    unsigned int weight;
+    float weight;
 
-    weight = NUM2UINT(value);
+    weight = (float)NUM2DBL(value);
 
     if (data->vector->header.type == GRN_UVECTOR) {
         grn_id id = RVAL2GRNID(key, data->context, data->range, data->self);
-        grn_uvector_add_element(data->context, data->vector, id, weight);
+        grn_uvector_add_element_record(data->context, data->vector, id, weight);
     } else {
         GRN_BULK_REWIND(data->element_value);
         RVAL2GRNBULK(key, data->context, data->element_value);
 
-        grn_vector_add_element(data->context, data->vector,
-                               GRN_BULK_HEAD(data->element_value),
-                               GRN_BULK_VSIZE(data->element_value),
-                               weight,
-                               data->element_value->header.domain);
+        grn_vector_add_element_float(data->context, data->vector,
+                                     GRN_BULK_HEAD(data->element_value),
+                                     GRN_BULK_VSIZE(data->element_value),
+                                     weight,
+                                     data->element_value->header.domain);
     }
 
     return ST_CONTINUE;
@@ -405,7 +412,7 @@ rb_grn_variable_size_column_array_set (VALUE self, VALUE rb_id, VALUE rb_value)
         int i, n;
         n = RARRAY_LEN(rb_value);
         for (i = 0; i < n; i++) {
-            unsigned int weight = 0;
+            float weight = 0;
             VALUE rb_element_value, rb_weight;
 
             rb_grn_scan_options(RARRAY_PTR(rb_value)[i],
@@ -414,23 +421,23 @@ rb_grn_variable_size_column_array_set (VALUE self, VALUE rb_id, VALUE rb_value)
                                 NULL);
 
             if (!NIL_P(rb_weight)) {
-                weight = NUM2UINT(rb_weight);
+                weight = (float)NUM2DBL(rb_weight);
             }
 
             if (value->header.type == GRN_UVECTOR) {
                 grn_id id = RVAL2GRNID(rb_element_value, context, range, self);
-                grn_uvector_add_element(context, value, id, weight);
+                grn_uvector_add_element_record(context, value, id, weight);
             } else {
                 GRN_BULK_REWIND(element_value);
                 if (!NIL_P(rb_element_value)) {
                     RVAL2GRNBULK(rb_element_value, context, element_value);
                 }
 
-                grn_vector_add_element(context, value,
-                                       GRN_BULK_HEAD(element_value),
-                                       GRN_BULK_VSIZE(element_value),
-                                       weight,
-                                       element_value->header.domain);
+                grn_vector_add_element_float(context, value,
+                                             GRN_BULK_HEAD(element_value),
+                                             GRN_BULK_VSIZE(element_value),
+                                             weight,
+                                             element_value->header.domain);
             }
         }
     } else if (RVAL2CBOOL(rb_obj_is_kind_of(rb_value, rb_cHash))) {

data/ext/groonga/rb-grn.h

@@ -93,7 +93,7 @@ RB_GRN_BEGIN_DECLS
 
 #define RB_GRN_MAJOR_VERSION 12
 #define RB_GRN_MINOR_VERSION 0
-#define RB_GRN_MICRO_VERSION 0
+#define RB_GRN_MICRO_VERSION 2
 
 #define RB_GRN_OBJECT(object) ((RbGrnObject *)(object))
 #define RB_GRN_NAMED_OBJECT(object) ((RbGrnNamedObject *)(object))

data/lib/groonga/schema.rb

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2009-2016  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2009-2022  Sutou Kouhei <kou@clear-code.com>
 # Copyright (C) 2014-2015  Masafumi Yokoyama <yokoyama@clear-code.com>
 #
 # This library is free software; you can redistribute it and/or
@@ -867,6 +865,36 @@ module Groonga
       #   * `:lz4`: Compzressed by LZ4.
       #   * `:zstd`: Compressed by Zstandard.
       #   * `:zstandard`: Compressed by Zstandard.
+      # @option options [Boolean] :weight_float32 (false)
+      #    It specifies whether the column uses 32 bit float for weight or not.
+      #
+      #    You can't use this option for scalar column.
+      #
+      #   @since 12.0.2
+      # @option options [:add, :ignore, :nil, nil] :missing_mode (nil)
+      #   It specifies how to process missing value.
+      #
+      #   * `:add`, `nil`: Correspond to `MISSING_ADD`
+      #   * `:ignore`: Correspond to `MISSING_IGNORE`
+      #   * `:nil`: Correspond to `MISSING_NIL`
+      #
+      #   See
+      #   https://groonga.org/docs/reference/commands/column_create.html#column-create-missing-mode
+      #   for each `MISSING_*` values.
+      #
+      #   @since 12.0.2
+      # @option options [:error, :warn, :ignore, nil] :invalid_mode (nil)
+      #   It specifies how to process invalid value.
+      #
+      #   * `:add`, `nil`: Correspond to `INVALID_ERROR`
+      #   * `:warn`: Correspond to `INVALID_WARN`
+      #   * `:ignore`: Correspond to `INVALID_IGNORE`
+      #
+      #   See
+      #   https://groonga.org/docs/reference/commands/column_create.html#column-create-invalid-mode
+      #   for each `INVALID_*` values.
+      #
+      #   @since 12.0.2
       def column(name, type, options={})
         definition = self[name, ColumnDefinition]
         if definition.nil?
@@ -1540,6 +1568,9 @@ module Groonga
           :type => @options[:type],
           :with_weight => @options[:with_weight],
           :compress => @options[:compress],
+          :weight_float32 => @options[:weight_float32],
+          :missing_mode => @options[:missing_mode],
+          :invalid_mode => @options[:invalid_mode],
         }
       end
 

data/rroonga-build.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2009-2021  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2009-2022  Sutou Kouhei <kou@clear-code.com>
 # Copyright (C) 2015-2017  Masafumi Yokoyama <yokoyama@clear-code.com>
 #
 # This library is free software; you can redistribute it and/or
@@ -16,12 +16,12 @@
 
 module RroongaBuild
   module RequiredGroongaVersion
-    MAJOR = 11
+    MAJOR = 12
     MINOR = 0
-    MICRO = 0
+    MICRO = 2
     VERSION = [MAJOR, MINOR, MICRO]
     STRING = VERSION.join(".")
-    RELEASED_DATE = Time.utc(2021, 2, 9)
+    RELEASED_DATE = Time.utc(2022, 3, 29)
   end
 
   module_function

data/test/test-column.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2009-2020  Sutou Kouhei <kou@clear-code.com>
+# Copyright (C) 2009-2022  Sutou Kouhei <kou@clear-code.com>
 # Copyright (C) 2016  Masafumi Yokoyama <yokoyama@clear-code.com>
 #
 # This library is free software; you can redistribute it and/or
@@ -431,12 +431,19 @@ class ColumnTest < Test::Unit::TestCase
     def setup_schema
       Groonga::Schema.define do |schema|
         schema.create_table("Shops", :type => :hash) do |table|
-          table.short_text("tags", :type => :vector)
+          table.short_text("tags",
+                           type: :vector,
+                           with_weight: true)
+          table.short_text("tags_float32",
+                           type: :vector,
+                           with_weight: true,
+                           weight_float32: true)
         end
 
         schema.create_table("Tags",
                             :type => :patricia_trie) do |table|
-          table.index("Shops.tags", :with_weight => true)
+          table.index("Shops.tags",
+                      with_weight: true)
         end
       end
 
@@ -453,6 +460,33 @@ class ColumnTest < Test::Unit::TestCase
                    select_by_tag("curry"))
     end
 
+    def test_vector_weight_float32
+      @shops.add("Soul Food India",
+                 :tags_float32 => [
+                   {:value => "curry", :weight => 11.1},
+                   {:value => "hot",   :weight => 33.3},
+                 ])
+      actual = @shops.collect do |shop|
+        attributes = shop.attributes
+        attributes["tags_float32"].each do |tag|
+          tag[:weight] = tag[:weight].round(1)
+        end
+        attributes
+      end
+      assert_equal([
+                     {
+                       "_id" => 1,
+                       "_key" => "Soul Food India",
+                       "tags" => [],
+                       "tags_float32" => [
+                         {:value => "curry", :weight => 11.1},
+                         {:value => "hot",   :weight => 33.3},
+                       ]
+                     },
+                   ],
+                   actual)
+    end
+
     def test_offline_index
       @shops.add("Soul Food India",
                  :tags => [

data/test/test-data-column.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2016-2017  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2016-2022  Sutou Kouhei <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
@@ -119,4 +119,198 @@ class DataColumnTest < Test::Unit::TestCase
                    comments.collect {|comment| [comment.base, comment.plus1]})
     end
   end
+
+  sub_test_case "#missing_mode" do
+    def test_add
+      Groonga::Schema.define do |schema|
+        schema.create_table("Tags",
+                            type: :hash,
+                            key_type: :short_text) do |table|
+        end
+        schema.create_table("Memos") do |table|
+          table.reference("tags",
+                          "Tags",
+                          type: :vector,
+                          missing_mode: :add)
+        end
+      end
+      memos = Groonga["Memos"]
+      memos_tags = Groonga["Memos.tags"]
+      tags = Groonga["Tags"]
+
+      record = memos.add(tags: ["nonexistent"])
+
+      assert_equal({
+                     missing_mode: :add,
+                     missing_add: true,
+                     missing_ignore: false,
+                     missing_nil: false,
+                     values: [tags["nonexistent"]],
+                   },
+                   {
+                     missing_mode: memos_tags.missing_mode,
+                     missing_add: memos_tags.missing_add?,
+                     missing_ignore: memos_tags.missing_ignore?,
+                     missing_nil: memos_tags.missing_nil?,
+                     values: record.tags,
+                   })
+    end
+
+    def test_ignore
+      Groonga::Schema.define do |schema|
+        schema.create_table("Tags",
+                            type: :hash,
+                            key_type: :short_text) do |table|
+        end
+        schema.create_table("Memos") do |table|
+          table.reference("tags",
+                          "Tags",
+                          type: :vector,
+                          missing_mode: :ignore)
+        end
+      end
+      memos = Groonga["Memos"]
+      memos_tags = Groonga["Memos.tags"]
+
+      record = memos.add(tags: ["nonexistent"])
+
+      assert_equal({
+                     missing_mode: :ignore,
+                     missing_add: false,
+                     missing_ignore: true,
+                     missing_nil: false,
+                     values: [],
+                   },
+                   {
+                     missing_mode: memos_tags.missing_mode,
+                     missing_add: memos_tags.missing_add?,
+                     missing_ignore: memos_tags.missing_ignore?,
+                     missing_nil: memos_tags.missing_nil?,
+                     values: record.tags,
+                   })
+    end
+
+    def test_nil
+      Groonga::Schema.define do |schema|
+        schema.create_table("Tags",
+                            type: :hash,
+                            key_type: :short_text) do |table|
+        end
+        schema.create_table("Memos") do |table|
+          table.reference("tags",
+                          "Tags",
+                          type: :vector,
+                          missing_mode: :nil,
+                          invalid_mode: :ignore)
+        end
+      end
+      memos = Groonga["Memos"]
+      memos_tags = Groonga["Memos.tags"]
+
+      record = memos.add(tags: ["nonexistent"])
+
+      assert_equal({
+                     missing_mode: :nil,
+                     missing_add: false,
+                     missing_ignore: false,
+                     missing_nil: true,
+                     values: [nil],
+                   },
+                   {
+                     missing_mode: memos_tags.missing_mode,
+                     missing_add: memos_tags.missing_add?,
+                     missing_ignore: memos_tags.missing_ignore?,
+                     missing_nil: memos_tags.missing_nil?,
+                     values: record.tags,
+                   })
+    end
+  end
+
+  sub_test_case "#invalid_mode" do
+    def test_error
+      Groonga::Schema.define do |schema|
+        schema.create_table("Memos") do |table|
+          table.uint32("count", invalid_mode: :error)
+        end
+      end
+      memos = Groonga["Memos"]
+      memos_count = Groonga["Memos.count"]
+
+      record = memos.add
+      assert_raise(Groonga::InvalidArgument) do
+        record.count = "invalid"
+      end
+
+      assert_equal({
+                     invalid_mode: :error,
+                     invalid_error: true,
+                     invalid_warn: false,
+                     invalid_ignore: false,
+                     value: 0,
+                   },
+                   {
+                     invalid_mode: memos_count.invalid_mode,
+                     invalid_error: memos_count.invalid_error?,
+                     invalid_warn: memos_count.invalid_warn?,
+                     invalid_ignore: memos_count.invalid_ignore?,
+                     value: record.count,
+                   })
+    end
+
+    def test_warn
+      Groonga::Schema.define do |schema|
+        schema.create_table("Memos") do |table|
+          table.uint32("count", invalid_mode: :warn)
+        end
+      end
+      memos = Groonga["Memos"]
+      memos_count = Groonga["Memos.count"]
+
+      record = memos.add
+      record.count = "invalid"
+
+      assert_equal({
+                     invalid_mode: :warn,
+                     invalid_error: false,
+                     invalid_warn: true,
+                     invalid_ignore: false,
+                     value: 0,
+                   },
+                   {
+                     invalid_mode: memos_count.invalid_mode,
+                     invalid_error: memos_count.invalid_error?,
+                     invalid_warn: memos_count.invalid_warn?,
+                     invalid_ignore: memos_count.invalid_ignore?,
+                     value: record.count,
+                   })
+    end
+
+    def test_ignore
+      Groonga::Schema.define do |schema|
+        schema.create_table("Memos") do |table|
+          table.uint32("count", invalid_mode: :ignore)
+        end
+      end
+      memos = Groonga["Memos"]
+      memos_count = Groonga["Memos.count"]
+
+      record = memos.add
+      record.count = "invalid"
+
+      assert_equal({
+                     invalid_mode: :ignore,
+                     invalid_error: false,
+                     invalid_warn: false,
+                     invalid_ignore: true,
+                     value: 0,
+                   },
+                   {
+                     invalid_mode: memos_count.invalid_mode,
+                     invalid_error: memos_count.invalid_error?,
+                     invalid_warn: memos_count.invalid_warn?,
+                     invalid_ignore: memos_count.invalid_ignore?,
+                     value: record.count,
+                   })
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rroonga
 version: !ruby/object:Gem::Version
-  version: 12.0.0
+  version: 12.0.2
 platform: ruby
 authors:
 - Kouhei Sutou
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-02-09 00:00:00.000000000 Z
+date: 2022-04-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: groonga-client
@@ -166,10 +166,10 @@ email:
 - y.hayamizu@gmail.com
 - dara@shidara.net
 executables:
+- grndump
 - grntest-log-analyze
-- groonga-index-dump
 - groonga-database-inspect
-- grndump
+- groonga-index-dump
 extensions:
 - ext/groonga/extconf.rb
 extra_rdoc_files:
@@ -370,7 +370,7 @@ homepage: http://ranguba.org/#about-rroonga
 licenses:
 - LGPL-2.1
 metadata:
-  msys2_mingw_dependencies: groonga>=11.0.0
+  msys2_mingw_dependencies: groonga>=12.0.2
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -387,80 +387,80 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.4.0.dev
 signing_key: 
 specification_version: 4
 summary: Ruby bindings for Groonga that provide full text search and column store
   features.
 test_files:
-- test/test-table-dumper.rb
-- test/test-query-logger.rb
-- test/test-variable-size-column.rb
-- test/test-schema-dumper.rb
-- test/test-double-array-trie.rb
-- test/test-expression-builder.rb
+- test/groonga-test-utils.rb
+- test/run-test.rb
+- test/test-accessor.rb
 - test/test-array.rb
-- test/test-id.rb
-- test/test-table-key-support.rb
+- test/test-column-cache.rb
+- test/test-column.rb
+- test/test-command-select.rb
+- test/test-config.rb
+- test/test-context.rb
+- test/test-convert.rb
+- test/test-data-column.rb
 - test/test-database-dumper.rb
+- test/test-database-inspector.rb
+- test/test-database.rb
+- test/test-default-cache.rb
+- test/test-double-array-trie.rb
+- test/test-encoding.rb
+- test/test-error-message.rb
+- test/test-exception.rb
+- test/test-expression-builder.rb
 - test/test-expression.rb
+- test/test-fix-size-column.rb
+- test/test-flushable.rb
+- test/test-geo-point.rb
+- test/test-gqtp.rb
+- test/test-hash.rb
+- test/test-id.rb
+- test/test-index-column.rb
+- test/test-index-cursor.rb
+- test/test-lock-timeout.rb
 - test/test-logger.rb
-- test/run-test.rb
-- test/test-windows-event-logger.rb
-- test/test-vector-column.rb
+- test/test-memory-pool.rb
+- test/test-name.rb
+- test/test-normalizer.rb
 - test/test-operator.rb
-- test/test-table.rb
-- test/test-table-group.rb
-- test/test-column.rb
+- test/test-package-label.rb
 - test/test-pagination.rb
-- test/test-error-message.rb
-- test/test-fix-size-column.rb
-- test/test-table-arrow.rb
-- test/test-sub-records.rb
-- test/test-table-select-normalize.rb
-- test/test-config.rb
 - test/test-patricia-trie.rb
-- test/test-gqtp.rb
-- test/test-memory-pool.rb
+- test/test-plugin.rb
+- test/test-procedure.rb
+- test/test-query-logger.rb
+- test/test-ractor.rb
+- test/test-record.rb
+- test/test-remote.rb
+- test/test-request-canceler.rb
+- test/test-request-timer.rb
 - test/test-schema-create-table.rb
+- test/test-schema-dumper.rb
+- test/test-schema-type.rb
 - test/test-schema.rb
-- test/test-column-cache.rb
-- test/test-command-select.rb
-- test/test-lock-timeout.rb
-- test/test-request-canceler.rb
-- test/test-default-cache.rb
-- test/test-database.rb
-- test/test-token-regexp.rb
+- test/test-snippet.rb
+- test/test-sub-records.rb
+- test/test-table-arrow.rb
+- test/test-table-dumper.rb
+- test/test-table-group.rb
+- test/test-table-key-support.rb
+- test/test-table-offset-and-limit.rb
+- test/test-table-select-mecab.rb
+- test/test-table-select-normalize.rb
 - test/test-table-select-weight.rb
-- test/test-database-inspector.rb
-- test/test-encoding.rb
-- test/test-hash.rb
-- test/test-schema-type.rb
-- test/test-type.rb
-- test/test-context.rb
-- test/test-flushable.rb
-- test/test-normalizer.rb
 - test/test-table-select.rb
-- test/test-index-cursor.rb
-- test/test-remote.rb
-- test/test-snippet.rb
-- test/test-exception.rb
-- test/groonga-test-utils.rb
 - test/test-table-traverse.rb
-- test/test-convert.rb
+- test/test-table.rb
 - test/test-thread.rb
-- test/test-plugin.rb
-- test/test-accessor.rb
-- test/test-index-column.rb
-- test/test-data-column.rb
-- test/test-ractor.rb
-- test/test-geo-point.rb
-- test/test-request-timer.rb
-- test/test-table-select-mecab.rb
-- test/test-version.rb
-- test/test-package-label.rb
+- test/test-token-regexp.rb
+- test/test-type.rb
+- test/test-variable-size-column.rb
 - test/test-variable.rb
-- test/test-record.rb
-- test/test-table-offset-and-limit.rb
-- test/test-procedure.rb
-- test/test-name.rb
+- test/test-vector-column.rb
+- test/test-version.rb
+- test/test-windows-event-logger.rb