rroonga 6.0.5 → 6.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 21579f26130016f0232888646e9b65d405c0f943
-  data.tar.gz: f6a1817d3951f0b8f2553ca67235a50aef56677c
+  metadata.gz: 266ed1c5524c3ecf7a34caae961511c166f83fdc
+  data.tar.gz: a9bc9f5db05f31e635d521e265a8ea170371ac67
 SHA512:
-  metadata.gz: 170e20bca5a5568bd99b646a3083b944f9b4ae5fc54f1e1322c3c5e8fc8b9423fd8d9e274341b189e192083ea4671b7c2eef40b774e24f6624cf58095de41590
-  data.tar.gz: 7854edb1da626c4120602f8c61b188d11944e1bb0f6d1f4ee4e25fd0b9f810f555e18c570fa927f765f70c452715e444486c0dff562e886a9caccd553d6f95d5
+  metadata.gz: ba0d58609159717163d7cdc66bce45dda47d80a8e4ef27a670569edf8073c12ac5d7da3bcd1efea7ac8ac85fed33e047188728650b34c50a2260e960a0dbe209
+  data.tar.gz: d43410abb91b18bae1fc4da6f39e0dd160b8d02394dc64e6e0d95c54b90c42708dfc6f2482ad054eae5a85b36cb98f2f9b82ceef84e7e8b70faba3c3852e1372

data/doc/text/news.md

@@ -1,5 +1,20 @@
 # NEWS
 
+## 6.0.7: 2016-08-13 {#version-6-0-7}
+
+### Improvements
+
+  * Supported Groonga 6.0.7. Groonga 6.0.5 or older aren't supported.
+
+  * Improved integration with libraries that uses `at_exit` such as
+    test-unit.
+
+### Fixes
+
+  * {Groonga::FixSizeColumn#inspect}: Fixed wrong flags.
+
+  * {Groonga::VariableSizeColumn#inspect}: Fixed wrong flags.
+
 ## 6.0.5: 2016-07-15 {#version-6-0-5}
 
 ### Improvements

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

@@ -72,13 +72,15 @@ rb_grn_column_bind (RbGrnColumn *rb_column,
                     grn_ctx *context, grn_obj *column)
 {
     RbGrnObject *rb_grn_object;
+    grn_column_flags flags;
     int column_type;
     unsigned char value_type;
 
     rb_grn_object = RB_GRN_OBJECT(rb_column);
     rb_grn_named_object_bind(RB_GRN_NAMED_OBJECT(rb_column), context, column);
 
-    column_type = (column->header.flags & GRN_OBJ_COLUMN_TYPE_MASK);
+    flags = grn_column_get_flags(context, column);
+    column_type = (flags & GRN_OBJ_COLUMN_TYPE_MASK);
     if (column_type == GRN_OBJ_COLUMN_VECTOR) {
         switch (rb_grn_object->range->header.type) {
         case GRN_TABLE_HASH_KEY:
@@ -644,18 +646,20 @@ rb_grn_column_vector_p (VALUE self)
 {
     grn_ctx *context;
     grn_obj *column;
+    grn_column_flags flags;
+    grn_column_flags column_type;
 
     rb_grn_column_deconstruct(SELF(self), &column, &context,
                              NULL, NULL,
                              NULL, NULL, NULL);
 
-    if (column->header.type == GRN_COLUMN_VAR_SIZE &&
-        ((column->header.flags & GRN_OBJ_COLUMN_TYPE_MASK) ==
-         GRN_OBJ_COLUMN_VECTOR)) {
-        return Qtrue;
-    } else {
+    if (column->header.type != GRN_COLUMN_VAR_SIZE) {
         return Qfalse;
     }
+
+    flags = grn_column_get_flags(context, column);
+    column_type = (flags & GRN_OBJ_COLUMN_TYPE_MASK);
+    return CBOOL2RVAL(column_type == GRN_OBJ_COLUMN_VECTOR);
 }
 
 /*
@@ -671,22 +675,21 @@ rb_grn_column_scalar_p (VALUE self)
 {
     grn_ctx *context;
     grn_obj *column;
+    grn_column_flags flags;
+    grn_column_flags column_type;
 
     rb_grn_column_deconstruct(SELF(self), &column, &context,
                              NULL, NULL,
                              NULL, NULL, NULL);
 
     switch (column->header.type) {
-      case GRN_COLUMN_FIX_SIZE:
+    case GRN_COLUMN_FIX_SIZE:
         return Qtrue;
-      case GRN_COLUMN_VAR_SIZE:
-        if ((column->header.flags & GRN_OBJ_COLUMN_TYPE_MASK) ==
-            GRN_OBJ_COLUMN_SCALAR) {
-            return Qtrue;
-        } else {
-            return Qfalse;
-        }
-      default:
+    case GRN_COLUMN_VAR_SIZE:
+        flags = grn_column_get_flags(context, column);
+        column_type = (flags & GRN_OBJ_COLUMN_TYPE_MASK);
+        return CBOOL2RVAL(column_type == GRN_OBJ_COLUMN_SCALAR);
+    default:
         return Qfalse;
     }
 }
@@ -701,12 +704,15 @@ static VALUE
 rb_grn_column_with_weight_p(VALUE self)
 {
     grn_obj *column;
+    grn_ctx *context;
+    grn_column_flags flags;
 
-    rb_grn_column_deconstruct(SELF(self), &column, NULL,
+    rb_grn_column_deconstruct(SELF(self), &column, &context,
                               NULL, NULL,
                               NULL, NULL, NULL);
 
-    return CBOOL2RVAL(column->header.flags & GRN_OBJ_WITH_WEIGHT);
+    flags = grn_column_get_flags(context, column);
+    return CBOOL2RVAL(flags & GRN_OBJ_WITH_WEIGHT);
 }
 
 /*

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

@@ -175,29 +175,36 @@ rb_grn_context_unlink_database (grn_ctx *context)
 }
 
 static void
-rb_grn_context_fin (grn_ctx *context)
+rb_grn_context_fin (RbGrnContext *rb_grn_context)
 {
-    if (context->stat == GRN_CTX_FIN)
-        return;
+    grn_ctx *context;
 
-    if (!(context->flags & GRN_CTX_PER_DB)) {
-        rb_grn_context_unlink_database(context);
+    context = rb_grn_context->context;
+
+    debug("context-fin: %p\n", context);
+
+    rb_grn_context_close_floating_objects(rb_grn_context);
+
+    if (context && context->stat != GRN_CTX_FIN && !rb_grn_exited) {
+        if (!(context->flags & GRN_CTX_PER_DB)) {
+            rb_grn_context_unlink_database(context);
+        }
+        grn_ctx_fin(context);
     }
-    grn_ctx_fin(context);
+
+    debug("context-fin: %p: done\n", context);
+
+    rb_grn_context->context = NULL;
 }
 
 static void
 rb_grn_context_free (void *pointer)
 {
     RbGrnContext *rb_grn_context = pointer;
-    grn_ctx *context;
 
-    context = rb_grn_context->context;
-    debug("context-free: %p\n", context);
-    rb_grn_context_close_floating_objects(rb_grn_context);
-    if (context && !rb_grn_exited)
-        rb_grn_context_fin(context);
-    debug("context-free: %p: done\n", context);
+    debug("context-free: %p\n", rb_grn_context);
+    rb_grn_context_fin(rb_grn_context);
+    debug("context-free: %p: done\n", rb_grn_context);
     xfree(rb_grn_context);
 }
 
@@ -248,7 +255,7 @@ rb_grn_context_to_exception (grn_ctx *context, VALUE related_object)
         return Qnil;
 
     exception_class = rb_grn_rc_to_exception(context->rc);
-    message = rb_grn_rc_to_message(context->rc);
+    message = grn_rc_to_string(context->rc);
 
     GRN_OBJ_INIT(&bulk, GRN_BULK, 0, GRN_ID_NIL);
     GRN_TEXT_PUTS(context, &bulk, message);
@@ -482,16 +489,11 @@ rb_grn_context_initialize (int argc, VALUE *argv, VALUE self)
 static VALUE
 rb_grn_context_close (VALUE self)
 {
-    int rc;
-    grn_ctx *context;
     RbGrnContext *rb_grn_context;
 
-    context = SELF(self);
-    if (context) {
-        rc = grn_ctx_fin(context);
-        Data_Get_Struct(self, RbGrnContext, rb_grn_context);
-        rb_grn_context->context = NULL;
-        rb_grn_rc_check(rc, self);
+    Data_Get_Struct(self, RbGrnContext, rb_grn_context);
+    if (rb_grn_context->context) {
+        rb_grn_context_fin(rb_grn_context);
     }
 
     return Qnil;

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

@@ -1,7 +1,7 @@
 /* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /*
   Copyright (C) 2014-2015  Masafumi Yokoyama <yokoyama@clear-code.com>
-  Copyright (C) 2009-2014  Kouhei Sutou <kou@clear-code.com>
+  Copyright (C) 2009-2016  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
@@ -357,260 +357,6 @@ rb_grn_rc_to_exception (grn_rc rc)
     return exception;
 }
 
-const char *
-rb_grn_rc_to_message (grn_rc rc)
-{
-    const char *message = NULL;
-
-    switch (rc) {
-      case GRN_SUCCESS:
-        return NULL;
-        break;
-      case GRN_END_OF_DATA:
-        message = "end of data";
-        break;
-      case GRN_UNKNOWN_ERROR:
-        message = "unknown error";
-        break;
-      case GRN_OPERATION_NOT_PERMITTED:
-        message = "operation not permitted";
-        break;
-      case GRN_NO_SUCH_FILE_OR_DIRECTORY:
-        message = "no such file or directory";
-        break;
-      case GRN_NO_SUCH_PROCESS:
-        message = "no such process";
-        break;
-      case GRN_INTERRUPTED_FUNCTION_CALL:
-        message = "interrupted function call";
-        break;
-      case GRN_INPUT_OUTPUT_ERROR:
-        message = "input output error";
-        break;
-      case GRN_NO_SUCH_DEVICE_OR_ADDRESS:
-        message = "no such device or address";
-        break;
-      case GRN_ARG_LIST_TOO_LONG:
-        message = "argument list too long";
-        break;
-      case GRN_EXEC_FORMAT_ERROR:
-        message = "exec format error";
-        break;
-      case GRN_BAD_FILE_DESCRIPTOR:
-        message = "bad file descriptor";
-        break;
-      case GRN_NO_CHILD_PROCESSES:
-        message = "no child processes";
-        break;
-      case GRN_RESOURCE_TEMPORARILY_UNAVAILABLE:
-        message = "resource temporarily unavailable";
-        break;
-      case GRN_NOT_ENOUGH_SPACE:
-        message = "not enough space";
-        break;
-      case GRN_PERMISSION_DENIED:
-        message = "permission denied";
-        break;
-      case GRN_BAD_ADDRESS:
-        message = "bad address";
-        break;
-      case GRN_RESOURCE_BUSY:
-        message = "resource busy";
-        break;
-      case GRN_FILE_EXISTS:
-        message = "file exists";
-        break;
-      case GRN_IMPROPER_LINK:
-        message = "improper link";
-        break;
-      case GRN_NO_SUCH_DEVICE:
-        message = "no such device";
-        break;
-      case GRN_NOT_A_DIRECTORY:
-        message = "not a directory";
-        break;
-      case GRN_IS_A_DIRECTORY:
-        message = "is a directory";
-        break;
-      case GRN_INVALID_ARGUMENT:
-        message = "invalid argument";
-        break;
-      case GRN_TOO_MANY_OPEN_FILES_IN_SYSTEM:
-        message = "too many open files in system";
-        break;
-      case GRN_TOO_MANY_OPEN_FILES:
-        message = "too many open files";
-        break;
-      case GRN_INAPPROPRIATE_I_O_CONTROL_OPERATION:
-        message = "inappropriate I/O control operation";
-        break;
-      case GRN_FILE_TOO_LARGE:
-        message = "file too large";
-        break;
-      case GRN_NO_SPACE_LEFT_ON_DEVICE:
-        message = "no space left on device";
-        break;
-      case GRN_INVALID_SEEK:
-        message = "invalid seek";
-        break;
-      case GRN_READ_ONLY_FILE_SYSTEM:
-        message = "read only file system";
-        break;
-      case GRN_TOO_MANY_LINKS:
-        message = "too many links";
-        break;
-      case GRN_BROKEN_PIPE:
-        message = "broken pipe";
-        break;
-      case GRN_DOMAIN_ERROR:
-        message = "domain error";
-        break;
-      case GRN_RESULT_TOO_LARGE:
-        message = "result too large";
-        break;
-      case GRN_RESOURCE_DEADLOCK_AVOIDED:
-        message = "resource deadlock avoided";
-        break;
-      case GRN_NO_MEMORY_AVAILABLE:
-        message = "no memory available";
-        break;
-      case GRN_FILENAME_TOO_LONG:
-        message = "filename too long";
-        break;
-      case GRN_NO_LOCKS_AVAILABLE:
-        message = "no locks available";
-        break;
-      case GRN_FUNCTION_NOT_IMPLEMENTED:
-        message = "function not implemented";
-        break;
-      case GRN_DIRECTORY_NOT_EMPTY:
-        message = "directory not empty";
-        break;
-      case GRN_ILLEGAL_BYTE_SEQUENCE:
-        message = "illegal byte sequence";
-        break;
-      case GRN_SOCKET_NOT_INITIALIZED:
-        message = "socket not initialized";
-        break;
-      case GRN_OPERATION_WOULD_BLOCK:
-        message = "operation would block";
-        break;
-      case GRN_ADDRESS_IS_NOT_AVAILABLE:
-        message = "address is not available";
-        break;
-      case GRN_NETWORK_IS_DOWN:
-        message = "network is down";
-        break;
-      case GRN_NO_BUFFER:
-        message = "no buffer";
-        break;
-      case GRN_SOCKET_IS_ALREADY_CONNECTED:
-        message = "socket is already connected";
-        break;
-      case GRN_SOCKET_IS_NOT_CONNECTED:
-        message = "socket is not connected";
-        break;
-      case GRN_SOCKET_IS_ALREADY_SHUTDOWNED:
-        message = "socket is already shutdowned";
-        break;
-      case GRN_OPERATION_TIMEOUT:
-        message = "operation timeout";
-        break;
-      case GRN_CONNECTION_REFUSED:
-        message = "connection refused";
-        break;
-      case GRN_RANGE_ERROR:
-        message = "range error";
-        break;
-      case GRN_TOKENIZER_ERROR:
-        message = "tokenizer error";
-        break;
-      case GRN_FILE_CORRUPT:
-        message = "file corrupt";
-        break;
-      case GRN_INVALID_FORMAT:
-        message = "invalid format";
-        break;
-      case GRN_OBJECT_CORRUPT:
-        message = "object corrupt";
-        break;
-      case GRN_TOO_MANY_SYMBOLIC_LINKS:
-        message = "too many symbolic links";
-        break;
-      case GRN_NOT_SOCKET:
-        message = "not socket";
-        break;
-      case GRN_OPERATION_NOT_SUPPORTED:
-        message = "operation not supported";
-        break;
-      case GRN_ADDRESS_IS_IN_USE:
-        message = "address is in use";
-        break;
-      case GRN_ZLIB_ERROR:
-        message = "ZLib error";
-        break;
-      case GRN_LZ4_ERROR:
-        message = "LZ4 error";
-        break;
-      case GRN_STACK_OVER_FLOW:
-        message = "stack over flow";
-        break;
-      case GRN_SYNTAX_ERROR:
-        message = "syntax error";
-        break;
-      case GRN_RETRY_MAX:
-        message = "retry max";
-        break;
-      case GRN_INCOMPATIBLE_FILE_FORMAT:
-        message = "incompatible file format";
-        break;
-      case GRN_UPDATE_NOT_ALLOWED:
-        message = "update isn't allowed";
-        break;
-      case GRN_TOO_SMALL_OFFSET:
-        message = "too small offset";
-        break;
-      case GRN_TOO_LARGE_OFFSET:
-        message = "too large offset";
-        break;
-      case GRN_TOO_SMALL_LIMIT:
-        message = "too small limit";
-        break;
-      case GRN_CAS_ERROR:
-        message = "CAS error";
-        break;
-      case GRN_UNSUPPORTED_COMMAND_VERSION:
-        message = "unsupported command version";
-        break;
-      case GRN_NORMALIZER_ERROR:
-        message = "normalizer error";
-        break;
-      case GRN_TOKEN_FILTER_ERROR:
-        message = "token filter error";
-        break;
-      case GRN_COMMAND_ERROR:
-        message = "command error";
-        break;
-      case GRN_PLUGIN_ERROR:
-        message = "plugin error";
-        break;
-      case GRN_SCORER_ERROR:
-        message = "scorer error";
-        break;
-      case GRN_CANCEL:
-        message = "cancel";
-        break;
-      case GRN_WINDOW_FUNCTION_ERROR:
-        message = "window function error";
-        break;
-    }
-
-    if (!message)
-        rb_raise(rb_eGrnError, "invalid return code: %d", rc);
-
-    return message;
-}
-
 void
 rb_grn_rc_check (grn_rc rc, VALUE related_object)
 {
@@ -620,7 +366,7 @@ rb_grn_rc_check (grn_rc rc, VALUE related_object)
     exception = rb_grn_rc_to_exception(rc);
     if (NIL_P(exception))
         return;
-    message = rb_grn_rc_to_message(rc);
+    message = grn_rc_to_string(rc);
 
     if (NIL_P(related_object))
         rb_raise(exception, "%s", message);

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

@@ -829,13 +829,16 @@ static VALUE
 rb_grn_index_column_with_section_p (VALUE self)
 {
     grn_obj *column;
+    grn_ctx *context;
+    grn_column_flags flags;
 
-    rb_grn_index_column_deconstruct(SELF(self), &column, NULL,
+    rb_grn_index_column_deconstruct(SELF(self), &column, &context,
                                     NULL, NULL,
                                     NULL, NULL, NULL, NULL, NULL,
                                     NULL, NULL);
 
-    return CBOOL2RVAL(column->header.flags & GRN_OBJ_WITH_SECTION);
+    flags = grn_column_get_flags(context, column);
+    return CBOOL2RVAL(flags & GRN_OBJ_WITH_SECTION);
 }
 
 /*
@@ -847,13 +850,16 @@ 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, NULL,
+    rb_grn_index_column_deconstruct(SELF(self), &column, &context,
                                     NULL, NULL,
                                     NULL, NULL, NULL, NULL, NULL,
                                     NULL, NULL);
 
-    return CBOOL2RVAL(column->header.flags & GRN_OBJ_WITH_WEIGHT);
+    flags = grn_column_get_flags(context, column);
+    return CBOOL2RVAL(flags & GRN_OBJ_WITH_WEIGHT);
 }
 
 /*
@@ -865,13 +871,16 @@ static VALUE
 rb_grn_index_column_with_position_p (VALUE self)
 {
     grn_obj *column;
+    grn_ctx *context;
+    grn_column_flags flags;
 
-    rb_grn_index_column_deconstruct(SELF(self), &column, NULL,
+    rb_grn_index_column_deconstruct(SELF(self), &column, &context,
                                     NULL, NULL,
                                     NULL, NULL, NULL, NULL, NULL,
                                     NULL, NULL);
 
-    return CBOOL2RVAL(column->header.flags & GRN_OBJ_WITH_POSITION);
+    flags = grn_column_get_flags(context, column);
+    return CBOOL2RVAL(flags & GRN_OBJ_WITH_POSITION);
 }
 
 /*
@@ -898,6 +907,7 @@ rb_grn_index_column_open_cursor (int argc, VALUE *argv, VALUE self)
 {
     grn_ctx          *context;
     grn_obj          *column;
+    grn_column_flags  column_flags;
     grn_obj          *range_object;
     grn_table_cursor *table_cursor;
     grn_id            rid_min = GRN_ID_NIL;
@@ -928,20 +938,22 @@ rb_grn_index_column_open_cursor (int argc, VALUE *argv, VALUE self)
     rb_table     = GRNOBJECT2RVAL(Qnil, context, range_object, GRN_FALSE);
     rb_lexicon   = rb_iv_get(rb_table_cursor, "@table");
 
+    column_flags = grn_column_get_flags(context, column);
+
     if (NIL_P(rb_with_section)) {
-        flags |= column->header.flags & GRN_OBJ_WITH_SECTION;
+        flags |= column_flags & GRN_OBJ_WITH_SECTION;
     } else if (RVAL2CBOOL(rb_with_section)) {
         flags |= GRN_OBJ_WITH_SECTION;
     }
 
     if (NIL_P(rb_with_weight)) {
-        flags |= column->header.flags & GRN_OBJ_WITH_WEIGHT;
+        flags |= column_flags & GRN_OBJ_WITH_WEIGHT;
     } else if (RVAL2CBOOL(rb_with_weight)) {
         flags |= GRN_OBJ_WITH_WEIGHT;
     }
 
     if (NIL_P(rb_with_position)) {
-        flags |= column->header.flags & GRN_OBJ_WITH_POSITION;
+        flags |= column_flags & GRN_OBJ_WITH_POSITION;
     } else if (RVAL2CBOOL(rb_with_position)) {
         flags |= GRN_OBJ_WITH_POSITION;
     }

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

@@ -545,7 +545,7 @@ rb_grn_named_object_set_name (RbGrnNamedObject *rb_grn_named_object,
               RB_GRN_OBJECT(rb_grn_named_object)->context,
               RB_GRN_OBJECT(rb_grn_named_object)->object,
               rb_grn_named_object,
-              grn_obj_type_to_string(RB_GRN_OBJECT(rb_grn_named_object)->header.type),
+              grn_obj_type_to_string(RB_GRN_OBJECT(rb_grn_named_object)->object->header.type),
               RB_GRN_OBJECT(rb_grn_named_object)->object->header.type,
               name_size, name);
     }
@@ -587,6 +587,10 @@ rb_grn_object_close_raw (RbGrnObject *rb_grn_object)
 
     rb_grn_object_deconstruct(rb_grn_object, &object, &context,
                               NULL, NULL, NULL, NULL);
+    debug("object:close: %p:%p:%s\n",
+          context,
+          object,
+          object ? grn_obj_type_to_string(object->header.type) : "(null)");
     if (object && context) {
         if (rb_grn_object->have_finalizer) {
             rb_grn_object_run_finalizer(context, object, rb_grn_object);
@@ -595,6 +599,7 @@ rb_grn_object_close_raw (RbGrnObject *rb_grn_object)
         }
         grn_obj_close(context, object);
     }
+    debug("object:close: %p:%p: done\n", context, object);
 }
 
 /*
@@ -825,11 +830,21 @@ rb_grn_object_inspect_content_flags_with_label (VALUE inspected,
                                                 grn_obj *object)
 {
     grn_obj_flags flags;
+    grn_column_flags column_flags = 0;
     VALUE inspected_flags;
 
     rb_str_cat2(inspected, "flags: ");
 
     flags = object->header.flags;
+    switch (object->header.type) {
+    case GRN_COLUMN_FIX_SIZE:
+    case GRN_COLUMN_VAR_SIZE:
+    case GRN_COLUMN_INDEX:
+        column_flags = grn_column_get_flags(context, object);
+        break;
+    default:
+        break;
+    }
 
     inspected_flags = rb_ary_new();
 
@@ -845,96 +860,113 @@ rb_grn_object_inspect_content_flags_with_label (VALUE inspected,
     }
 
     switch (object->header.type) {
-      case GRN_COLUMN_FIX_SIZE:
-      case GRN_COLUMN_VAR_SIZE:
-      case GRN_TYPE:
+    case GRN_TYPE:
         if (flags & GRN_OBJ_KEY_VAR_SIZE) {
             rb_ary_push(inspected_flags, rb_str_new_cstr("KEY_VAR_SIZE"));
         } else {
             switch (flags & GRN_OBJ_KEY_MASK) {
-              case GRN_OBJ_KEY_UINT:
+            case GRN_OBJ_KEY_UINT:
                 rb_ary_push(inspected_flags, rb_str_new_cstr("KEY_UINT"));
                 break;
-              case GRN_OBJ_KEY_INT:
+            case GRN_OBJ_KEY_INT:
                 rb_ary_push(inspected_flags, rb_str_new_cstr("KEY_INT"));
                 break;
-              case GRN_OBJ_KEY_FLOAT:
+            case GRN_OBJ_KEY_FLOAT:
                 rb_ary_push(inspected_flags, rb_str_new_cstr("KEY_FLOAT"));
                 break;
-              case GRN_OBJ_KEY_GEO_POINT:
+            case GRN_OBJ_KEY_GEO_POINT:
                 rb_ary_push(inspected_flags, rb_str_new_cstr("KEY_GEO_POINT"));
                 break;
-              default:
+            default:
                 break;
             }
         }
-        break;
-      default:
+    default:
         break;
     }
 
     switch (object->header.type) {
-      case GRN_TABLE_HASH_KEY:
-      case GRN_TABLE_PAT_KEY:
-      case GRN_TABLE_DAT_KEY:
+    case GRN_TABLE_HASH_KEY:
+    case GRN_TABLE_PAT_KEY:
+    case GRN_TABLE_DAT_KEY:
         if (flags & GRN_OBJ_KEY_WITH_SIS)
             rb_ary_push(inspected_flags, rb_str_new_cstr("KEY_WITH_SIS"));
         if (flags & GRN_OBJ_KEY_NORMALIZE)
             rb_ary_push(inspected_flags, rb_str_new_cstr("KEY_NORMALIZE"));
         break;
-      default:
+    default:
         break;
     }
 
-    if (0) {
-        if (flags & GRN_OBJ_COLUMN_SCALAR)
+    switch (object->header.type) {
+    case GRN_COLUMN_FIX_SIZE:
+    case GRN_COLUMN_VAR_SIZE:
+        if (column_flags & GRN_OBJ_COLUMN_SCALAR) {
             rb_ary_push(inspected_flags, rb_str_new_cstr("COLUMN_SCALAR"));
-        if (flags & GRN_OBJ_COLUMN_VECTOR)
+        } else if (column_flags & GRN_OBJ_COLUMN_VECTOR) {
             rb_ary_push(inspected_flags, rb_str_new_cstr("COLUMN_VECTOR"));
-        if (flags & GRN_OBJ_COLUMN_INDEX)
-            rb_ary_push(inspected_flags, rb_str_new_cstr("COLUMN_INDEX"));
+        }
+        break;
+    default:
+        break;
     }
 
     switch (object->header.type) {
-      case GRN_COLUMN_FIX_SIZE:
-      case GRN_COLUMN_VAR_SIZE:
-        if (flags & GRN_OBJ_COMPRESS_ZLIB)
+    case GRN_COLUMN_FIX_SIZE:
+    case GRN_COLUMN_VAR_SIZE:
+        if (column_flags & GRN_OBJ_COMPRESS_ZLIB) {
             rb_ary_push(inspected_flags, rb_str_new_cstr("COMPRESS_ZLIB"));
-        if (flags & GRN_OBJ_COMPRESS_LZ4)
+        } else if (column_flags & GRN_OBJ_COMPRESS_LZ4) {
             rb_ary_push(inspected_flags, rb_str_new_cstr("COMPRESS_LZ4"));
+        }
         break;
-      case GRN_COLUMN_INDEX:
-        if (flags & GRN_OBJ_WITH_SECTION)
+    case GRN_COLUMN_INDEX:
+        if (column_flags & GRN_OBJ_WITH_SECTION)
             rb_ary_push(inspected_flags, rb_str_new_cstr("WITH_SECTION"));
-        if (flags & GRN_OBJ_WITH_WEIGHT)
+        if (column_flags & GRN_OBJ_WITH_WEIGHT)
             rb_ary_push(inspected_flags, rb_str_new_cstr("WITH_WEIGHT"));
-        if (flags & GRN_OBJ_WITH_POSITION)
+        if (column_flags & GRN_OBJ_WITH_POSITION)
             rb_ary_push(inspected_flags, rb_str_new_cstr("WITH_POSITION"));
         break;
-      default:
+    default:
         break;
     }
 
-    if (flags & GRN_OBJ_RING_BUFFER)
-        rb_ary_push(inspected_flags, rb_str_new_cstr("RING_BUFFER"));
-
-    if (flags & GRN_OBJ_WITH_SUBREC) {
-        rb_ary_push(inspected_flags, rb_str_new_cstr("WITH_SUBREC"));
-
-        if (flags & GRN_OBJ_UNIT_DOCUMENT_SECTION)
-            rb_ary_push(inspected_flags, rb_str_new_cstr("UNIT_DOCUMENT_SECTION"));
-        if (flags & GRN_OBJ_UNIT_DOCUMENT_POSITION)
-            rb_ary_push(inspected_flags, rb_str_new_cstr("UNIT_DOCUMENT_POSITION"));
-
-        if (flags & GRN_OBJ_UNIT_SECTION_POSITION)
-            rb_ary_push(inspected_flags, rb_str_new_cstr("UNIT_SECTION_POSITION"));
-
-        if (flags & GRN_OBJ_UNIT_USERDEF_DOCUMENT)
-            rb_ary_push(inspected_flags, rb_str_new_cstr("UNIT_USERDEF_DOCUMENT"));
-        if (flags & GRN_OBJ_UNIT_USERDEF_SECTION)
-            rb_ary_push(inspected_flags, rb_str_new_cstr("UNIT_USERDEF_SECTION"));
-        if (flags & GRN_OBJ_UNIT_USERDEF_POSITION)
-            rb_ary_push(inspected_flags, rb_str_new_cstr("UNIT_USERDEF_POSITION"));
+    switch (object->header.type) {
+    case GRN_TABLE_NO_KEY:
+    case GRN_TABLE_HASH_KEY:
+    case GRN_TABLE_PAT_KEY:
+    case GRN_TABLE_DAT_KEY:
+        if (flags & GRN_OBJ_RING_BUFFER)
+            rb_ary_push(inspected_flags, rb_str_new_cstr("RING_BUFFER"));
+
+        if (flags & GRN_OBJ_WITH_SUBREC) {
+            rb_ary_push(inspected_flags, rb_str_new_cstr("WITH_SUBREC"));
+
+            if (flags & GRN_OBJ_UNIT_DOCUMENT_SECTION)
+                rb_ary_push(inspected_flags,
+                            rb_str_new_cstr("UNIT_DOCUMENT_SECTION"));
+            if (flags & GRN_OBJ_UNIT_DOCUMENT_POSITION)
+                rb_ary_push(inspected_flags,
+                            rb_str_new_cstr("UNIT_DOCUMENT_POSITION"));
+
+            if (flags & GRN_OBJ_UNIT_SECTION_POSITION)
+                rb_ary_push(inspected_flags,
+                            rb_str_new_cstr("UNIT_SECTION_POSITION"));
+
+            if (flags & GRN_OBJ_UNIT_USERDEF_DOCUMENT)
+                rb_ary_push(inspected_flags,
+                            rb_str_new_cstr("UNIT_USERDEF_DOCUMENT"));
+            if (flags & GRN_OBJ_UNIT_USERDEF_SECTION)
+                rb_ary_push(inspected_flags,
+                            rb_str_new_cstr("UNIT_USERDEF_SECTION"));
+            if (flags & GRN_OBJ_UNIT_USERDEF_POSITION)
+                rb_ary_push(inspected_flags,
+                            rb_str_new_cstr("UNIT_USERDEF_POSITION"));
+        }
+        break;
+    default:
+        break;
     }
 
     rb_str_cat2(inspected, "<");
@@ -1274,19 +1306,23 @@ rb_grn_object_array_reference (VALUE self, VALUE rb_id)
         break;
       case GRN_COLUMN_VAR_SIZE:
       case GRN_COLUMN_FIX_SIZE:
-        switch (object->header.flags & GRN_OBJ_COLUMN_TYPE_MASK) {
-          case GRN_OBJ_COLUMN_VECTOR:
-            GRN_OBJ_INIT(&value, GRN_VECTOR, 0, range_id);
-            break;
-          case GRN_OBJ_COLUMN_SCALAR:
-            GRN_OBJ_INIT(&value, GRN_BULK, 0, range_id);
-            break;
-          default:
-            rb_raise(rb_eGrnError, "unsupported column type: %u: %s",
-                     range_type, rb_grn_inspect(self));
-            break;
-        }
-        break;
+          {
+              grn_column_flags column_flags;
+              column_flags = grn_column_get_flags(context, object);
+              switch (column_flags & GRN_OBJ_COLUMN_TYPE_MASK) {
+              case GRN_OBJ_COLUMN_VECTOR:
+                  GRN_OBJ_INIT(&value, GRN_VECTOR, 0, range_id);
+                  break;
+              case GRN_OBJ_COLUMN_SCALAR:
+                  GRN_OBJ_INIT(&value, GRN_BULK, 0, range_id);
+                  break;
+              default:
+                  rb_raise(rb_eGrnError, "unsupported column type: %u: %s",
+                           range_type, rb_grn_inspect(self));
+                  break;
+              }
+          }
+          break;
       case GRN_COLUMN_INDEX:
         GRN_UINT32_INIT(&value, 0);
         break;

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

@@ -25,7 +25,7 @@ rb_grn_table_sort_keys_fill (grn_ctx *context,
                              VALUE rb_sort_keys,
                              VALUE rb_table)
 {
-    int i;
+    size_t i;
 
     for (i = 0; i < n_sort_keys; i++) {
         VALUE rb_sort_key;

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

@@ -242,7 +242,7 @@ rb_grn_table_define_column (int argc, VALUE *argv, VALUE self)
     grn_obj *value_type, *column;
     char *name = NULL, *path = NULL;
     unsigned name_size = 0;
-    grn_obj_flags flags = 0;
+    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 columns;
@@ -372,7 +372,7 @@ rb_grn_table_define_index_column (int argc, VALUE *argv, VALUE self)
     grn_obj *value_type, *column;
     char *name = NULL, *path = NULL;
     unsigned name_size = 0;
-    grn_obj_flags flags = GRN_OBJ_COLUMN_INDEX;
+    grn_column_flags flags = GRN_OBJ_COLUMN_INDEX;
     VALUE rb_name, rb_value_type;
     VALUE options, rb_path, rb_persistent;
     VALUE rb_with_section, rb_with_weight, rb_with_position;

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

@@ -28,14 +28,16 @@ rb_grn_variable_size_column_bind (RbGrnVariableSizeColumn *rb_column,
                                   grn_ctx *context, grn_obj *column)
 {
     RbGrnObject *rb_grn_object;
-    int column_type;
+    grn_column_flags flags;
+    grn_column_flags column_type;
     unsigned char value_type;
 
     rb_grn_object = RB_GRN_OBJECT(rb_column);
     rb_grn_column_bind(RB_GRN_COLUMN(rb_column), context, column);
 
     rb_column->element_value = NULL;
-    column_type = (column->header.flags & GRN_OBJ_COLUMN_TYPE_MASK);
+    flags = grn_column_get_flags(context, column);
+    column_type = (flags & GRN_OBJ_COLUMN_TYPE_MASK);
     if (column_type != GRN_OBJ_COLUMN_VECTOR) {
         return;
     }
@@ -51,7 +53,7 @@ rb_grn_variable_size_column_bind (RbGrnVariableSizeColumn *rb_column,
         value_type = GRN_VECTOR;
         break;
     }
-    if (column->header.flags & GRN_OBJ_WITH_WEIGHT) {
+    if (flags & GRN_OBJ_WITH_WEIGHT) {
         rb_column->element_value = grn_obj_open(context, value_type, 0,
                                                 rb_grn_object->range_id);
     }
@@ -161,6 +163,7 @@ rb_grn_variable_size_column_array_reference (VALUE self, VALUE rb_id)
 {
     grn_ctx *context = NULL;
     grn_obj *column, *range;
+    grn_column_flags flags;
     grn_id id;
     grn_obj *value;
     VALUE rb_value;
@@ -171,7 +174,8 @@ rb_grn_variable_size_column_array_reference (VALUE self, VALUE rb_id)
                                             NULL, NULL, &value, NULL,
                                             NULL, &range);
 
-    if (!(column->header.flags & GRN_OBJ_WITH_WEIGHT)) {
+    flags = grn_column_get_flags(context, column);
+    if (!(flags & GRN_OBJ_WITH_WEIGHT)) {
         return rb_call_super(1, &rb_id);
     }
 
@@ -373,6 +377,7 @@ rb_grn_variable_size_column_array_set (VALUE self, VALUE rb_id, VALUE rb_value)
 {
     grn_ctx *context = NULL;
     grn_obj *column, *range;
+    grn_column_flags column_flags;
     grn_rc rc;
     grn_id id;
     grn_obj *value, *element_value;
@@ -382,7 +387,8 @@ rb_grn_variable_size_column_array_set (VALUE self, VALUE rb_id, VALUE rb_value)
                                             NULL, NULL, &value, &element_value,
                                             NULL, &range);
 
-    if (!(column->header.flags & GRN_OBJ_WITH_WEIGHT)) {
+    column_flags = grn_column_get_flags(context, column);
+    if (!(column_flags & GRN_OBJ_WITH_WEIGHT)) {
         VALUE args[2];
         args[0] = rb_id;
         args[1] = rb_value;
@@ -469,7 +475,7 @@ rb_grn_variable_size_column_compressed_p (int argc, VALUE *argv, VALUE self)
     RbGrnVariableSizeColumn *rb_grn_column;
     grn_ctx *context = NULL;
     grn_obj *column;
-    grn_obj_flags flags;
+    grn_column_flags flags;
     VALUE type;
     grn_bool compressed_p = GRN_FALSE;
     grn_bool accept_any_type = GRN_FALSE;
@@ -500,7 +506,7 @@ rb_grn_variable_size_column_compressed_p (int argc, VALUE *argv, VALUE self)
                               NULL, NULL,
                               NULL, NULL);
 
-    flags = column->header.flags;
+    flags = grn_column_get_flags(context, column);
     switch (flags & GRN_OBJ_COMPRESS_MASK) {
       case GRN_OBJ_COMPRESS_ZLIB:
         if (accept_any_type || need_zlib_check) {

data/ext/groonga/rb-grn.h

@@ -99,7 +99,7 @@ RB_GRN_BEGIN_DECLS
 
 #define RB_GRN_MAJOR_VERSION 6
 #define RB_GRN_MINOR_VERSION 0
-#define RB_GRN_MICRO_VERSION 5
+#define RB_GRN_MICRO_VERSION 7
 
 #define RB_GRN_OBJECT(object) ((RbGrnObject *)(object))
 #define RB_GRN_NAMED_OBJECT(object) ((RbGrnNamedObject *)(object))
@@ -369,7 +369,6 @@ void           rb_grn_init_id                       (VALUE mGrn);
 void           rb_grn_init_name                     (VALUE mGrn);
 
 VALUE          rb_grn_rc_to_exception               (grn_rc rc);
-const char    *rb_grn_rc_to_message                 (grn_rc rc);
 void           rb_grn_rc_check                      (grn_rc rc,
                                                      VALUE related_object);
 

data/ext/groonga/rb-groonga.c

@@ -21,13 +21,14 @@
 
 grn_bool rb_grn_exited = GRN_FALSE;
 
-static void
+static VALUE
 finish_groonga (VALUE data)
 {
     debug("finish\n");
     grn_fin();
     rb_grn_exited = GRN_TRUE;
     debug("finish: done\n");
+    return Qnil;
 }
 
 /*
@@ -212,7 +213,7 @@ Init_groonga (void)
     rb_grn_init_exception(mGrn);
 
     rb_grn_rc_check(grn_init(), Qnil);
-    rb_set_end_proc(finish_groonga, Qnil);
+    rb_define_finalizer(mGrn, rb_proc_new(finish_groonga, Qnil));
 
     rb_grn_init_version(mGrn);
     rb_grn_init_lock_timeout(mGrn);

data/rroonga-build.rb

@@ -18,15 +18,15 @@ module RroongaBuild
   module RequiredGroongaVersion
     MAJOR = 6
     MINOR = 0
-    MICRO = 5
+    MICRO = 7
     VERSION = [MAJOR, MINOR, MICRO]
-    RELEASED_DATE = Time.utc(2016, 6, 29)
+    RELEASED_DATE = Time.utc(2016, 7, 29)
   end
 
   module LatestGroongaVersion
     MAJOR = 6
     MINOR = 0
-    MICRO = 5
+    MICRO = 7
     VERSION = [MAJOR, MINOR, MICRO]
   end
 

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

@@ -139,7 +139,7 @@ class FixSizeColumnTest < Test::Unit::TestCase
                    "path: <#{@n_viewed_column_path}>, " +
                    "domain: <Bookmarks>, " +
                    "range: <Int32>, " +
-                   "flags: <KEY_INT>" +
+                   "flags: <>" +
                    ">",
                    @n_viewed.inspect)
     end

data/test/test-schema.rb

@@ -371,7 +371,7 @@ class SchemaTest < Test::Unit::TestCase
                    "path: <#{path}>, " +
                    "domain: <Posts>, " +
                    "range: <Niku>, " +
-                   "flags: <KEY_VAR_SIZE|COMPRESS_LZ4>>",
+                   "flags: <COLUMN_VECTOR|COMPRESS_LZ4>>",
                    column.inspect)
     end
   end

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

@@ -103,7 +103,7 @@ class VariableSizeColumnTest < Test::Unit::TestCase
                  "path: <#{@users_name_column_path}>, " +
                  "domain: <Users>, " +
                  "range: <ShortText>, " +
-                 "flags: <KEY_VAR_SIZE>" +
+                 "flags: <>" +
                  ">",
                  @name.inspect)
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rroonga
 version: !ruby/object:Gem::Version
-  version: 6.0.5
+  version: 6.0.7
 platform: ruby
 authors:
 - Kouhei Sutou
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-15 00:00:00.000000000 Z
+date: 2016-08-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pkg-config