rroonga 5.1.1 → 6.0.0

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

@@ -1,6 +1,7 @@
 /* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /*
   Copyright (C) 2015-2016  Kouhei Sutou <kou@clear-code.com>
+  Copyright (C) 2016  Masafumi Yokoyama <yokoyama@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
@@ -73,11 +74,9 @@ rb_grn_config_get (VALUE self, VALUE rb_key)
 
     {
         grn_rc rc;
-        /* TODO: Replace it with grn_config_get() after Groonga 5.1.2
-         * is released.*/
-        rc = grn_conf_get(context,
-                          key, key_size,
-                          &value, &value_size);
+        rc = grn_config_get(context,
+                            key, key_size,
+                            &value, &value_size);
         rb_grn_context_check(context, self);
         rb_grn_rc_check(rc, self);
     }
@@ -123,11 +122,9 @@ rb_grn_config_set (VALUE self, VALUE rb_key, VALUE rb_value)
 
     {
         grn_rc rc;
-        /* TODO: Replace it with grn_config_set() after Groonga 5.1.2
-         * is released.*/
-        rc = grn_conf_set(context,
-                          key, key_size,
-                          value, value_size);
+        rc = grn_config_set(context,
+                            key, key_size,
+                            value, value_size);
         rb_grn_context_check(context, self);
         rb_grn_rc_check(rc, self);
     }
@@ -135,16 +132,140 @@ rb_grn_config_set (VALUE self, VALUE rb_key, VALUE rb_value)
     return rb_value_original;
 }
 
+/*
+ * Deletes a configuration for key.
+ *
+ * @overload delete(key)
+ *   @param [String] key The key.
+ *
+ * @since 6.0.0
+ */
+static VALUE
+rb_grn_config_delete (VALUE self, VALUE rb_key)
+{
+    VALUE rb_context;
+    grn_ctx *context;
+    const char *key;
+    int key_size;
+
+    rb_context = rb_iv_get(self, "@context");
+    context = rb_grn_context_ensure(&rb_context);
+
+    rb_key = rb_grn_convert_to_string(rb_key);
+    key = RSTRING_PTR(rb_key);
+    key_size = RSTRING_LEN(rb_key);
+
+    {
+        grn_rc rc;
+        rc = grn_config_delete(context,
+                               key, key_size);
+        rb_grn_context_check(context, self);
+        rb_grn_rc_check(rc, self);
+    }
+
+    return Qnil;
+}
+
+typedef struct {
+    grn_ctx *context;
+    grn_obj *cursor;
+} RbGrnConfigEachData;
+
+static VALUE
+rb_grn_config_each_body (VALUE user_data)
+{
+    RbGrnConfigEachData *data = (RbGrnConfigEachData *)user_data;
+    grn_ctx *context;
+    grn_obj *cursor;
+
+    context = data->context;
+    cursor = data->cursor;
+    while (grn_config_cursor_next(context, cursor)) {
+        const char *key;
+        uint32_t key_size;
+        VALUE rb_key;
+        const char *value;
+        uint32_t value_size;
+        VALUE rb_value;
+
+        key_size = grn_config_cursor_get_key(context, cursor, &key);
+        rb_key = rb_grn_context_rb_string_new(context, key, key_size);
+        value_size = grn_config_cursor_get_value(context, cursor, &value);
+        rb_value = rb_grn_context_rb_string_new(context, value, value_size);
+
+        rb_yield_values(2, rb_key, rb_value);
+    }
+
+    return Qnil;
+}
+
+static VALUE
+rb_grn_config_each_ensure (VALUE user_data)
+{
+    RbGrnConfigEachData *data = (RbGrnConfigEachData *)user_data;
+
+    grn_obj_close(data->context, data->cursor);
+
+    return Qnil;
+}
+
+/*
+ * Passes all key/value of the config to block in order.
+ *
+ * @example Shows all keys and all values of the config
+ *   context.config["rroonga.key1"] = "value1"
+ *   context.config["rroonga.key2"] = "value2"
+ *   keys = []
+ *   values = []
+ *   context.config.each do |key, value|
+ *     keys << key
+ *     values << value
+ *   end
+ *   p keys   # => ["rroonga.key1", "rroonga.key2"]
+ *   p values # => ["value1", "value2"]
+ *
+ * @overload each
+ *   @yield [key, value]
+ *   @yieldparam [String] key The configuration key
+ *   @yieldparam [String] value The value which is associated with `key`
+ *
+ * @since 6.0.0
+ */
+static VALUE
+rb_grn_config_each (VALUE self)
+{
+    VALUE rb_context;
+    RbGrnConfigEachData data;
+
+    RETURN_ENUMERATOR(self, 0, NULL);
+
+    rb_context = rb_iv_get(self, "@context");
+    data.context = rb_grn_context_ensure(&rb_context);
+
+    data.cursor = grn_config_cursor_open(data.context);
+    rb_ensure(rb_grn_config_each_body, (VALUE)&data,
+              rb_grn_config_each_ensure, (VALUE)&data);
+
+    return Qnil;
+}
+
 void
 rb_grn_init_config (VALUE mGrn)
 {
     VALUE cGrnConfig;
 
     cGrnConfig = rb_define_class_under(mGrn, "Config", rb_cObject);
+    /* For backward compatibility. */
     rb_define_const(mGrn, "Conf", cGrnConfig);
 
+    rb_include_module(cGrnConfig, rb_mEnumerable);
+
     rb_define_method(cGrnConfig, "initialize", rb_grn_config_initialize, 1);
 
     rb_define_method(cGrnConfig, "[]", rb_grn_config_get, 1);
     rb_define_method(cGrnConfig, "[]=", rb_grn_config_set, 2);
+
+    rb_define_method(cGrnConfig, "delete", rb_grn_config_delete, 1);
+
+    rb_define_method(cGrnConfig, "each", rb_grn_config_each, 0);
 }

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

@@ -302,18 +302,13 @@ rb_grn_context_rb_string_new (grn_ctx *context, const char *string, long length)
 {
     if (length < 0)
         length = strlen(string);
-#ifdef HAVE_RUBY_ENCODING_H
     return rb_enc_str_new(string, length,
                           rb_grn_encoding_to_ruby_encoding(context->encoding));
-#else
-    return rb_str_new(string, length);
-#endif
 }
 
 VALUE
 rb_grn_context_rb_string_encode (grn_ctx *context, VALUE rb_string)
 {
-#ifdef HAVE_RUBY_ENCODING_H
     int index, to_index;
     rb_encoding *encoding, *to_encoding;
     grn_encoding context_encoding;
@@ -339,7 +334,6 @@ rb_grn_context_rb_string_encode (grn_ctx *context, VALUE rb_string)
 
     rb_string = rb_str_encode(rb_string, rb_enc_from_encoding(to_encoding),
                               0, Qnil);
-#endif
     return rb_string;
 }
 
@@ -601,14 +595,10 @@ rb_grn_context_set_encoding (VALUE self, VALUE rb_encoding)
 static VALUE
 rb_grn_context_get_ruby_encoding (VALUE self)
 {
-#ifdef HAVE_RUBY_ENCODING_H
     grn_encoding encoding;
 
     encoding = GRN_CTX_GET_ENCODING(SELF(self));
     return rb_grn_encoding_to_ruby_encoding_object(encoding);
-#else
-    return Qnil;
-#endif
 }
 
 /*

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

@@ -148,7 +148,6 @@ rb_grn_encoding_to_ruby_object (grn_encoding encoding)
     return rb_encoding;
 }
 
-#ifdef HAVE_RUBY_ENCODING_H
 rb_encoding *
 rb_grn_encoding_to_ruby_encoding (grn_encoding encoding)
 {
@@ -190,7 +189,6 @@ rb_grn_encoding_to_ruby_encoding_object (grn_encoding encoding)
     rb_encoding *rb_encoding = rb_grn_encoding_to_ruby_encoding(encoding);
     return rb_enc_from_encoding(rb_encoding);
 }
-#endif
 
 /*
  * デフォルトのエンコーディングを返す。

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

@@ -203,6 +203,43 @@ rb_grn_expression_define_variable (int argc, VALUE *argv, VALUE self)
     return rb_variable;
 }
 
+/* TODO: Enable when Groonga 6.0.1 is released. */
+/*
+typedef struct
+{
+    grn_ctx *context;
+    grn_hash *hash;
+    VALUE rb_hash;
+} RbGrnHashFromRubyHashData;
+
+static int
+rb_grn_hash_from_ruby_hash_body (VALUE rb_key,
+                                 VALUE rb_value,
+                                 VALUE user_data)
+{
+    RbGrnHashFromRubyHashData *data = (RbGrnHashFromRubyHashData *)user_data;
+    grn_obj *value;
+    int added;
+
+    rb_key = rb_grn_convert_to_string(rb_key);
+
+    grn_hash_add(data->context,
+                 data->hash,
+                 RSTRING_PTR(rb_key),
+                 RSTRING_LEN(rb_key),
+                 (void **)&value,
+                 &added);
+    rb_grn_context_check(data->context, data->rb_hash);
+
+    if (added) {
+        GRN_VOID_INIT(value);
+    }
+    RVAL2GRNBULK(rb_value, data->context, value);
+
+    return ST_CONTINUE;
+}
+*/
+
 /*
  * _object_ を追加し、 _n_arguments_ 個の引数を取る _operation_ を追加する。
  *
@@ -232,9 +269,32 @@ rb_grn_expression_append_object (int argc, VALUE *argv, VALUE self)
                                   NULL, NULL,
                                   NULL, NULL, NULL);
 
-    object = RVAL2GRNOBJECT(rb_object, &context);
-    grn_expr_append_obj(context, expression, object,
-                        operation, n_arguments);
+    /* TODO: Enable when Groonga 6.0.1 is released. */
+    /*
+    if (RB_TYPE_P(rb_object, RUBY_T_HASH)) {
+        RbGrnHashFromRubyHashData data;
+        data.context = context;
+        data.hash = grn_hash_create(context, NULL,
+                                    GRN_TABLE_MAX_KEY_SIZE,
+                                    sizeof(grn_obj),
+                                    GRN_OBJ_KEY_VAR_SIZE |
+                                    GRN_OBJ_TEMPORARY |
+                                    GRN_HASH_TINY);
+        grn_expr_take_obj(context, expression, (grn_obj *)(data.hash));
+        data.rb_hash = rb_object;
+        rb_hash_foreach(rb_object,
+                        rb_grn_hash_from_ruby_hash_body,
+                        (VALUE)&data);
+        grn_expr_append_obj(context, expression, (grn_obj *)(data.hash),
+                            operation, n_arguments);
+    } else {
+    */
+        object = RVAL2GRNOBJECT(rb_object, &context);
+        grn_expr_append_obj(context, expression, object,
+                            operation, n_arguments);
+    /*
+    }
+    */
     rb_grn_context_check(context, self);
     rb_ary_push(rb_iv_get(self, "@objects"), rb_object);
 

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

@@ -0,0 +1,34 @@
+/* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+  Copyright (C) 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
+  License version 2.1 as published by the Free Software Foundation.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#include "rb-grn.h"
+
+VALUE rb_cGrnIndex;
+
+VALUE
+rb_grn_index_new (VALUE rb_index_column, VALUE rb_section)
+{
+    return rb_funcall(rb_cGrnIndex, rb_intern("new"), 2,
+                      rb_index_column, rb_section);
+}
+
+void
+rb_grn_init_index (VALUE mGrn)
+{
+    rb_cGrnIndex = rb_const_get(mGrn, rb_intern("Index"));
+}

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

@@ -93,7 +93,7 @@ rb_grn_object_unbind (RbGrnObject *rb_grn_object)
 {
     debug("unbind: %p:%p:%p %s(%#x)\n",
           rb_grn_object->context, rb_grn_object->object, rb_grn_object,
-          rb_grn_inspect_type(rb_grn_object->object->header.type),
+          grn_obj_type_to_string(rb_grn_object->object->header.type),
           rb_grn_object->object->header.type);
 
     rb_grn_object->rb_grn_context = NULL;
@@ -116,7 +116,7 @@ rb_grn_object_run_finalizer (grn_ctx *context, grn_obj *grn_object,
           context, grn_object, rb_grn_object,
           rb_grn_object->context, rb_grn_object->object,
           rb_grn_object->rb_grn_context,
-          rb_grn_inspect_type(grn_object->header.type),
+          grn_obj_type_to_string(grn_object->header.type),
           grn_object->header.type);
 
     rb_grn_context = rb_grn_object->rb_grn_context;
@@ -173,7 +173,7 @@ rb_grn_object_run_finalizer (grn_ctx *context, grn_obj *grn_object,
     default:
         rb_raise(rb_eTypeError,
                  "unsupported Groonga object type for finalizer: %s(%#x)",
-                 rb_grn_inspect_type(grn_object->header.type),
+                 grn_obj_type_to_string(grn_object->header.type),
                  grn_object->header.type);
         break;
     }
@@ -217,7 +217,7 @@ rb_grn_object_free (RbGrnObject *rb_grn_object)
             user_data = grn_obj_user_data(context, grn_object);
         }
         debug("type: %s(%#x); need_close: %d; user_data: %p; ptr: %p\n",
-              rb_grn_inspect_type(grn_object->header.type),
+              grn_obj_type_to_string(grn_object->header.type),
               grn_object->header.type,
               rb_grn_object->need_close,
               user_data,
@@ -362,7 +362,7 @@ rb_grn_object_bind_common (VALUE klass, VALUE self, VALUE rb_context,
 
     debug("bind: %p:%p:%p %s(%#x)\n",
           context, object, rb_grn_object,
-          rb_grn_inspect_type(object->header.type),
+          grn_obj_type_to_string(object->header.type),
           object->header.type);
 
     Data_Get_Struct(rb_context, RbGrnContext, rb_grn_context);
@@ -378,7 +378,7 @@ rb_grn_object_bind_common (VALUE klass, VALUE self, VALUE rb_context,
     if (user_data) {
         debug("set-finalizer: %p:%p:%p %s(%#x)\n",
               context, object, rb_grn_object,
-              rb_grn_inspect_type(object->header.type),
+              grn_obj_type_to_string(object->header.type),
               object->header.type);
         user_data->ptr = rb_grn_object;
         grn_obj_set_finalizer(context, object, rb_grn_object_finalizer);
@@ -386,7 +386,7 @@ rb_grn_object_bind_common (VALUE klass, VALUE self, VALUE rb_context,
     } else if (object->header.type == GRN_ACCESSOR) {
         debug("set-finalizer(implicit): %p:%p:%p %s(%#x)\n",
               context, object, rb_grn_object,
-              rb_grn_inspect_type(object->header.type),
+              grn_obj_type_to_string(object->header.type),
               object->header.type);
         rb_grn_object->have_finalizer = GRN_TRUE;
     }
@@ -500,7 +500,7 @@ rb_grn_object_assign (VALUE klass, VALUE self, VALUE rb_context,
     } else {
         rb_raise(rb_eTypeError,
                  "unsupported Groonga object type for assignment: %s(%#x)",
-                 rb_grn_inspect_type(object->header.type),
+                 grn_obj_type_to_string(object->header.type),
                  object->header.type);
     }
 
@@ -508,7 +508,7 @@ rb_grn_object_assign (VALUE klass, VALUE self, VALUE rb_context,
 
     debug("assign: %p:%p:%p %s(%#x)\n",
           context, object, rb_grn_object,
-          rb_grn_inspect_type(object->header.type), object->header.type);
+          grn_obj_type_to_string(object->header.type), object->header.type);
 }
 
 void
@@ -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,
-              rb_grn_inspect_type(RB_GRN_OBJECT(rb_grn_named_object)->header.type),
+              grn_obj_type_to_string(RB_GRN_OBJECT(rb_grn_named_object)->header.type),
               RB_GRN_OBJECT(rb_grn_named_object)->object->header.type,
               name_size, name);
     }

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

@@ -1,6 +1,7 @@
 /* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /*
   Copyright (C) 2009-2015  Kouhei Sutou <kou@clear-code.com>
+  Copyright (C) 2016  Masafumi Yokoyama <yokoyama@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
@@ -224,6 +225,8 @@ rb_grn_operator_from_ruby_object (VALUE rb_operator)
         operator = GRN_OP_JSON_PUT;
     } else if (rb_grn_equal_option(rb_operator, "regexp")) {
         operator = GRN_OP_REGEXP;
+    } else if (rb_grn_equal_option(rb_operator, "fuzzy")) {
+        operator = GRN_OP_FUZZY;
     } else {
         rb_raise(rb_eArgError,
                  "operator should be one of "
@@ -635,6 +638,10 @@ rb_grn_init_operator (VALUE mGrn)
                     rb_funcall(rb_cGrnRegexpOperator, rb_intern("new"), 2,
                                rb_str_new_cstr("regexp"),
                                UINT2NUM(GRN_OP_REGEXP)));
+    rb_define_const(rb_cGrnOperator, "FUZZY",
+                    rb_funcall(rb_cGrnOperator, rb_intern("new"), 2,
+                               rb_str_new_cstr("fuzzy"),
+                               UINT2NUM(GRN_OP_FUZZY)));
 
 
 /*

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

@@ -1,6 +1,7 @@
 /* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /*
   Copyright (C) 2011-2015  Kouhei Sutou <kou@clear-code.com>
+  Copyright (C) 2016  Masafumi Yokoyama <yokoyama@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
@@ -205,6 +206,42 @@ rb_grn_plugin_s_ruby_suffix (VALUE klass)
     return rb_str_new_cstr(grn_plugin_get_ruby_suffix());
 }
 
+/*
+ * Returns the names of loaded plugins.
+ *
+ * @overload names(options={})
+ *   @return [Array<String>]
+ *   @param options [::Hash] The name and value pairs.
+ *   @option options :context (Groonga::Context.default)
+ *     The context which is bound to database.
+ *
+ * @since 6.0.0
+ */
+static VALUE
+rb_grn_plugin_s_names (int argc, VALUE *argv, VALUE klass)
+{
+    VALUE rb_options, rb_context, rb_names;
+    grn_ctx *context;
+    grn_obj names;
+
+    rb_scan_args(argc, argv, "01", &rb_options);
+    rb_grn_scan_options(rb_options,
+                        "context", &rb_context,
+                        NULL);
+    if (NIL_P(rb_context)) {
+        rb_context = rb_grn_context_get_default();
+    }
+    context = RVAL2GRNCONTEXT(rb_context);
+
+    GRN_TEXT_INIT(&names, GRN_OBJ_VECTOR);
+    grn_plugin_get_names(context, &names);
+    rb_names = GRNVECTOR2RVAL(context, &names);
+    GRN_OBJ_FIN(context, &names);
+
+    rb_grn_context_check(context, rb_ary_new_from_values(argc, argv));
+    return rb_names;
+}
+
 void
 rb_grn_init_plugin (VALUE mGrn)
 {
@@ -221,4 +258,6 @@ rb_grn_init_plugin (VALUE mGrn)
                                rb_grn_plugin_s_suffix, 0);
     rb_define_singleton_method(cGrnPlugin, "ruby_suffix",
                                rb_grn_plugin_s_ruby_suffix, 0);
+    rb_define_singleton_method(cGrnPlugin, "names",
+                               rb_grn_plugin_s_names, -1);
 }

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

@@ -30,67 +30,6 @@ rb_grn_inspect (VALUE object)
     return StringValueCStr(inspected);
 }
 
-const char *
-rb_grn_inspect_type (unsigned char type)
-{
-    switch (type) {
-    case GRN_VOID:
-        return "void";
-    case GRN_BULK:
-        return "bulk";
-    case GRN_PTR:
-        return "ptr";
-    case GRN_UVECTOR:
-        return "uvector";
-    case GRN_PVECTOR:
-        return "pvector";
-    case GRN_MSG:
-        return "msg";
-    case GRN_QUERY:
-        return "query";
-    case GRN_ACCESSOR:
-        return "accessor";
-    case GRN_SNIP:
-        return "snip";
-    case GRN_PATSNIP:
-        return "patsnip";
-    case GRN_CURSOR_TABLE_HASH_KEY:
-        return "cursor-table-hash-key";
-    case GRN_CURSOR_TABLE_PAT_KEY:
-        return "cursor-table-pat-key";
-    case GRN_CURSOR_TABLE_DAT_KEY:
-        return "cursor-table-dat-key";
-    case GRN_CURSOR_TABLE_NO_KEY:
-        return "cursor-table-no-key";
-    case GRN_CURSOR_COLUMN_INDEX:
-        return "cursor-column-index";
-    case GRN_TYPE:
-        return "type";
-    case GRN_PROC:
-        return "proc";
-    case GRN_EXPR:
-        return "expr";
-    case GRN_TABLE_HASH_KEY:
-        return "table-hash-key";
-    case GRN_TABLE_PAT_KEY:
-        return "table-pat-key";
-    case GRN_TABLE_DAT_KEY:
-        return "table-dat-key";
-    case GRN_TABLE_NO_KEY:
-        return "table-no-key";
-    case GRN_DB:
-        return "db";
-    case GRN_COLUMN_FIX_SIZE:
-        return "column-fix-size";
-    case GRN_COLUMN_VAR_SIZE:
-        return "column-var-size";
-    case GRN_COLUMN_INDEX:
-        return "column-index";
-    default:
-        return "unknown";
-    }
-}
-
 void
 rb_grn_scan_options (VALUE options, ...)
 {
@@ -903,7 +842,7 @@ rb_grn_uvector_to_ruby_object (grn_ctx *context, grn_obj *uvector,
     default:
         rb_raise(rb_eTypeError,
                  "unknown range uvector can't be converted: %s(%#x): <%s>",
-                 rb_grn_inspect_type(range->header.type),
+                 grn_obj_type_to_string(range->header.type),
                  range->header.type,
                  rb_grn_inspect(related_object));
         break;
@@ -1023,7 +962,7 @@ rb_grn_uvector_from_ruby_object_body (VALUE user_data)
     default:
         rb_raise(rb_eTypeError,
                  "can't convert to unknown domain uvector: %s(%#x): <%s>",
-                 rb_grn_inspect_type(domain->header.type),
+                 grn_obj_type_to_string(domain->header.type),
                  domain->header.type,
                  rb_grn_inspect(data->related_object));
         break;
@@ -1108,7 +1047,7 @@ rb_grn_value_to_ruby_object (grn_ctx *context,
     default:
         rb_raise(rb_eGrnError,
                  "unsupported value type: %s(%#x): %s",
-                 rb_grn_inspect_type(value->header.type),
+                 grn_obj_type_to_string(value->header.type),
                  value->header.type,
                  rb_grn_inspect(related_object));
         break;
@@ -1284,6 +1223,7 @@ rb_grn_obj_to_ruby_object (VALUE klass, grn_ctx *context,
     /* case GRN_CURSOR_TABLE_PAT_KEY: */
     /* case GRN_CURSOR_TABLE_NO_KEY: */
     /* case GRN_CURSOR_COLUMN_INDEX: */
+    /* case GRN_CURSOR_CONFIG: */
     /* case GRN_TYPE: */
     /* case GRN_PROC: */
     /* case GRN_EXPR: */
@@ -1298,7 +1238,7 @@ rb_grn_obj_to_ruby_object (VALUE klass, grn_ctx *context,
     default:
         rb_raise(rb_eTypeError,
                  "unsupported groonga object: %s(%#x): <%s>",
-                 rb_grn_inspect_type(obj->header.type),
+                 grn_obj_type_to_string(obj->header.type),
                  obj->header.type,
                  rb_grn_inspect(related_object));
         break;