rroonga 5.0.0 → 5.0.1

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

@@ -0,0 +1,88 @@
+/* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+  Copyright (C) 2015  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_cGrnLessEqualOperator;
+
+/*
+ * Executes a less-or-equal operation.
+ *
+ * @example Executes less-or-equal operations with the default context
+ *   Groonga::Operator::LESS_EQUAL.exec(1, 1) # => true
+ *   Groonga::Operator::LESS_EQUAL.exec(1, 2) # => true
+ *   Groonga::Operator::LESS_EQUAL.exec(2, 1) # => false
+ *
+ * @example Executes less-or-equal operations with the specified context
+ *   context = Groonga::Context.new
+ *   Groonga::Operator::LESS_EQUAL.exec(1, 1,
+ *                                      :context => context) # => true
+ *   Groonga::Operator::LESS_EQUAL.exec(1, 2,
+ *                                      :context => context) # => true
+ *   Groonga::Operator::LESS_EQUAL.exec(2, 1,
+ *                                      :context => context) # => false
+ *
+ * @overload exec(x, y, options={})
+ *   @param x [::Object] The left hand side value.
+ *   @param y [::Object] The right hand side value.
+ *   @param options [::Hash] The options.
+ *   @option options [Groonga::Context] (Groonga::Context.default)
+ *      The context to executes the operation.
+ *   @return [Boolean] `true` if `x` is less than or equal to`y`,
+ *      `false` otherwise.
+ */
+static VALUE
+rb_grn_less_equal_operator_exec (int argc, VALUE *argv, VALUE self)
+{
+    grn_bool less_equal;
+    VALUE rb_x;
+    VALUE rb_y;
+    VALUE rb_options;
+    VALUE rb_context;
+    grn_ctx *context;
+    grn_obj x;
+    grn_obj y;
+
+    rb_scan_args(argc, argv, "21", &rb_x, &rb_y, &rb_options);
+
+    rb_grn_scan_options(rb_options,
+                        "context", &rb_context,
+                        NULL);
+    context = rb_grn_context_ensure(&rb_context);
+
+    GRN_VOID_INIT(&x);
+    GRN_VOID_INIT(&y);
+    RVAL2GRNBULK(rb_x, context, &x);
+    RVAL2GRNBULK(rb_y, context, &y);
+    less_equal = grn_operator_exec_less_equal(context, &x, &y);
+    GRN_OBJ_FIN(context, &x);
+    GRN_OBJ_FIN(context, &y);
+
+    return CBOOL2RVAL(less_equal);
+}
+
+void
+rb_grn_init_less_equal_operator (VALUE mGrn)
+{
+    rb_cGrnLessEqualOperator = rb_define_class_under(mGrn,
+                                                     "LessEqualOperator",
+                                                     rb_cGrnOperator);
+
+    rb_define_method(rb_cGrnLessEqualOperator, "exec",
+                     rb_grn_less_equal_operator_exec, -1);
+}

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

@@ -0,0 +1,85 @@
+/* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+  Copyright (C) 2015  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_cGrnLessOperator;
+
+/*
+ * Executes a less operation.
+ *
+ * @example Executes less operations with the default context
+ *   Groonga::Operator::LESS.exec(1, 2) # => true
+ *   Groonga::Operator::LESS.exec(2, 1) # => false
+ *
+ * @example Executes less operations with the specified context
+ *   context = Groonga::Context.new
+ *   Groonga::Operator::LESS.exec(1, 2,
+ *                                :context => context) # => true
+ *   Groonga::Operator::LESS.exec(2, 1,
+ *                                :context => context) # => false
+ *
+ * @overload exec(x, y, options={})
+ *   @param x [::Object] The left hand side value.
+ *   @param y [::Object] The right hand side value.
+ *   @param options [::Hash] The options.
+ *   @option options [Groonga::Context] (Groonga::Context.default)
+ *      The context to executes the operation.
+ *   @return [Boolean] `true` if `x` is less than `y`, `false`
+ *      otherwise.
+ */
+static VALUE
+rb_grn_less_operator_exec (int argc, VALUE *argv, VALUE self)
+{
+    grn_bool less;
+    VALUE rb_x;
+    VALUE rb_y;
+    VALUE rb_options;
+    VALUE rb_context;
+    grn_ctx *context;
+    grn_obj x;
+    grn_obj y;
+
+    rb_scan_args(argc, argv, "21", &rb_x, &rb_y, &rb_options);
+
+    rb_grn_scan_options(rb_options,
+                        "context", &rb_context,
+                        NULL);
+    context = rb_grn_context_ensure(&rb_context);
+
+    GRN_VOID_INIT(&x);
+    GRN_VOID_INIT(&y);
+    RVAL2GRNBULK(rb_x, context, &x);
+    RVAL2GRNBULK(rb_y, context, &y);
+    less = grn_operator_exec_less(context, &x, &y);
+    GRN_OBJ_FIN(context, &x);
+    GRN_OBJ_FIN(context, &y);
+
+    return CBOOL2RVAL(less);
+}
+
+void
+rb_grn_init_less_operator (VALUE mGrn)
+{
+    rb_cGrnLessOperator = rb_define_class_under(mGrn,
+                                                 "LessOperator",
+                                                 rb_cGrnOperator);
+
+    rb_define_method(rb_cGrnLessOperator, "exec",
+                     rb_grn_less_operator_exec, -1);
+}

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

@@ -159,10 +159,10 @@ rb_grn_logger_log (grn_ctx *ctx, grn_log_level level,
     /* TODO: use rb_protect(). */
     rb_funcall(handler, id_log, 5,
                GRNLOGLEVEL2RVAL(level),
-               rb_str_new2(timestamp),
-               rb_str_new2(title),
-               rb_str_new2(message),
-               rb_str_new2(location));
+               rb_str_new_cstr(timestamp),
+               rb_str_new_cstr(title),
+               rb_str_new_cstr(message),
+               rb_str_new_cstr(location));
 }
 
 static void
@@ -359,7 +359,7 @@ rb_grn_logger_s_get_path (VALUE klass)
 
     path = grn_default_logger_get_path();
     if (path) {
-        rb_path = rb_str_new2(path);
+        rb_path = rb_str_new_cstr(path);
     }
     return rb_path;
 }

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

@@ -0,0 +1,86 @@
+/* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+  Copyright (C) 2015  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_cGrnMatchOperator;
+
+/*
+ * Executes a match operation. Match operation checks whether `text`
+ * contains `sub_text` or not.
+ *
+ * @example Executes match operations with the default context
+ *   Groonga::Operator::MATCH.exec("Hello Rroonga", "Rroonga") # => true
+ *   Groonga::Operator::MATCH.exec("Hello Rroonga", "Groonga") # => false
+ *
+ * @example Executes match operations with the specified context
+ *   context = Groonga::Context.new
+ *   Groonga::Operator::MATCH.exec("Hello Rroonga", "Rroonga",
+ *                                :context => context) # => true
+ *   Groonga::Operator::MATCH.exec("Hello Rroonga", "Groonga",
+ *                                :context => context) # => false
+ *
+ * @overload exec(text, sub_text, options={})
+ *   @param text [String] The text to be matched.
+ *   @param sub_text [String] The sub text to be contained.
+ *   @param options [::Hash] The options.
+ *   @option options [Groonga::Context] (Groonga::Context.default)
+ *      The context to executes the operation.
+ *   @return [Boolean] `true` if `text` contains `sub_text`, `false`
+ *      otherwise.
+ */
+static VALUE
+rb_grn_match_operator_exec (int argc, VALUE *argv, VALUE self)
+{
+    grn_bool matched;
+    VALUE rb_text;
+    VALUE rb_sub_text;
+    VALUE rb_options;
+    VALUE rb_context;
+    grn_ctx *context;
+    grn_obj text;
+    grn_obj sub_text;
+
+    rb_scan_args(argc, argv, "21", &rb_text, &rb_sub_text, &rb_options);
+
+    rb_grn_scan_options(rb_options,
+                        "context", &rb_context,
+                        NULL);
+    context = rb_grn_context_ensure(&rb_context);
+
+    GRN_VOID_INIT(&text);
+    GRN_VOID_INIT(&sub_text);
+    RVAL2GRNBULK(rb_text, context, &text);
+    RVAL2GRNBULK(rb_sub_text, context, &sub_text);
+    matched = grn_operator_exec_match(context, &text, &sub_text);
+    GRN_OBJ_FIN(context, &text);
+    GRN_OBJ_FIN(context, &sub_text);
+
+    return CBOOL2RVAL(matched);
+}
+
+void
+rb_grn_init_match_operator (VALUE mGrn)
+{
+    rb_cGrnMatchOperator = rb_define_class_under(mGrn,
+                                                 "MatchOperator",
+                                                 rb_cGrnOperator);
+
+    rb_define_method(rb_cGrnMatchOperator, "exec",
+                     rb_grn_match_operator_exec, -1);
+}

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

@@ -1,6 +1,6 @@
 /* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /*
-  Copyright (C) 2012  Kouhei Sutou <kou@clear-code.com>
+  Copyright (C) 2012-2015  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
@@ -73,6 +73,10 @@ rb_grn_normalizer_s_normalize (int argc, VALUE *argv, VALUE klass)
 
     context = rb_grn_context_ensure(&rb_context);
     rb_encoded_string = rb_grn_context_rb_string_encode(context, rb_string);
+    if (RSTRING_LEN(rb_encoded_string) == 0) {
+        return rb_grn_context_rb_string_new(context, "", 0);
+    }
+
     if (NIL_P(rb_remove_blank_p)) {
         rb_remove_blank_p = Qtrue;
     }
@@ -91,6 +95,9 @@ rb_grn_normalizer_s_normalize (int argc, VALUE *argv, VALUE klass)
                                  normalizer,
                                  flags);
     rb_grn_context_check(context, argv[0]);
+    if (!grn_string) {
+        return Qnil;
+    }
     grn_string_get_normalized(context, grn_string,
                               &normalized_string, &normalized_string_length,
                               NULL);

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

@@ -0,0 +1,85 @@
+/* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+  Copyright (C) 2015  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_cGrnNotEqualOperator;
+
+/*
+ * Executes a not-equal operation.
+ *
+ * @example Executes not-equal operations with the default context
+ *   Groonga::Operator::NOT_EQUAL.exec("hello", "Hello") # => true
+ *   Groonga::Operator::NOT_EQUAL.exec("hello", "hello") # => false
+ *
+ * @example Executes not-equal operations with the specified context
+ *   context = Groonga::Context.new
+ *   Groonga::Operator::NOT_EQUAL.exec("hello", "Hello",
+ *                                     :context => context) # => true
+ *   Groonga::Operator::NOT_EQUAL.exec("hello", "hello",
+ *                                     :context => context) # => false
+ *
+ * @overload exec(x, y, options={})
+ *   @param x [::Object] The left hand side value.
+ *   @param y [::Object] The right hand side value.
+ *   @param options [::Hash] The options.
+ *   @option options [Groonga::Context] (Groonga::Context.default)
+ *      The context to executes the operation.
+ *   @return [Boolean] `true` if `x` does not equal to `y`, `false`
+ *      otherwise.
+ */
+static VALUE
+rb_grn_not_equal_operator_exec (int argc, VALUE *argv, VALUE self)
+{
+    grn_bool not_equal;
+    VALUE rb_x;
+    VALUE rb_y;
+    VALUE rb_options;
+    VALUE rb_context;
+    grn_ctx *context;
+    grn_obj x;
+    grn_obj y;
+
+    rb_scan_args(argc, argv, "21", &rb_x, &rb_y, &rb_options);
+
+    rb_grn_scan_options(rb_options,
+                        "context", &rb_context,
+                        NULL);
+    context = rb_grn_context_ensure(&rb_context);
+
+    GRN_VOID_INIT(&x);
+    GRN_VOID_INIT(&y);
+    RVAL2GRNBULK(rb_x, context, &x);
+    RVAL2GRNBULK(rb_y, context, &y);
+    not_equal = grn_operator_exec_not_equal(context, &x, &y);
+    GRN_OBJ_FIN(context, &x);
+    GRN_OBJ_FIN(context, &y);
+
+    return CBOOL2RVAL(not_equal);
+}
+
+void
+rb_grn_init_not_equal_operator (VALUE mGrn)
+{
+    rb_cGrnNotEqualOperator = rb_define_class_under(mGrn,
+                                                    "NotEqualOperator",
+                                                    rb_cGrnOperator);
+
+    rb_define_method(rb_cGrnNotEqualOperator, "exec",
+                     rb_grn_not_equal_operator_exec, -1);
+}

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

@@ -538,17 +538,15 @@ rb_grn_named_object_set_name (RbGrnNamedObject *rb_grn_named_object,
         rb_grn_named_object->name = NULL;
     }
     if (name_size > 0) {
-        RbGrnObject *rb_grn_object;
         rb_grn_named_object->name = ALLOC_N(char, name_size + 1);
         memcpy(rb_grn_named_object->name, name, name_size);
         rb_grn_named_object->name[name_size] = '\0';
-        rb_grn_object = RB_GRN_OBJECT(rb_grn_named_object);
         debug("set-name: %p:%p:%p %s(%#x): <%.*s>\n",
-              rb_grn_object->context,
-              rb_grn_object->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->object->header.type),
-              rb_grn_object->object->header.type,
+              rb_grn_inspect_type(RB_GRN_OBJECT(rb_grn_named_object)->header.type),
+              RB_GRN_OBJECT(rb_grn_named_object)->object->header.type,
               name_size, name);
     }
     rb_grn_named_object->name_size = name_size;
@@ -837,13 +835,13 @@ rb_grn_object_inspect_content_flags_with_label (VALUE inspected,
 
     if (0) {
         if (flags & GRN_OBJ_TABLE_HASH_KEY)
-            rb_ary_push(inspected_flags, rb_str_new2("TABLE_HASH_KEY"));
+            rb_ary_push(inspected_flags, rb_str_new_cstr("TABLE_HASH_KEY"));
         if (flags & GRN_OBJ_TABLE_PAT_KEY)
-            rb_ary_push(inspected_flags, rb_str_new2("TABLE_PAT_KEY"));
+            rb_ary_push(inspected_flags, rb_str_new_cstr("TABLE_PAT_KEY"));
         if (flags & GRN_OBJ_TABLE_DAT_KEY)
-            rb_ary_push(inspected_flags, rb_str_new2("TABLE_DAT_KEY"));
+            rb_ary_push(inspected_flags, rb_str_new_cstr("TABLE_DAT_KEY"));
         if (flags & GRN_OBJ_TABLE_NO_KEY)
-            rb_ary_push(inspected_flags, rb_str_new2("TABLE_NO_KEY"));
+            rb_ary_push(inspected_flags, rb_str_new_cstr("TABLE_NO_KEY"));
     }
 
     switch (object->header.type) {
@@ -851,20 +849,20 @@ rb_grn_object_inspect_content_flags_with_label (VALUE inspected,
       case GRN_COLUMN_VAR_SIZE:
       case GRN_TYPE:
         if (flags & GRN_OBJ_KEY_VAR_SIZE) {
-            rb_ary_push(inspected_flags, rb_str_new2("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:
-                rb_ary_push(inspected_flags, rb_str_new2("KEY_UINT"));
+                rb_ary_push(inspected_flags, rb_str_new_cstr("KEY_UINT"));
                 break;
               case GRN_OBJ_KEY_INT:
-                rb_ary_push(inspected_flags, rb_str_new2("KEY_INT"));
+                rb_ary_push(inspected_flags, rb_str_new_cstr("KEY_INT"));
                 break;
               case GRN_OBJ_KEY_FLOAT:
-                rb_ary_push(inspected_flags, rb_str_new2("KEY_FLOAT"));
+                rb_ary_push(inspected_flags, rb_str_new_cstr("KEY_FLOAT"));
                 break;
               case GRN_OBJ_KEY_GEO_POINT:
-                rb_ary_push(inspected_flags, rb_str_new2("KEY_GEO_POINT"));
+                rb_ary_push(inspected_flags, rb_str_new_cstr("KEY_GEO_POINT"));
                 break;
               default:
                 break;
@@ -880,9 +878,9 @@ rb_grn_object_inspect_content_flags_with_label (VALUE inspected,
       case GRN_TABLE_PAT_KEY:
       case GRN_TABLE_DAT_KEY:
         if (flags & GRN_OBJ_KEY_WITH_SIS)
-            rb_ary_push(inspected_flags, rb_str_new2("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_new2("KEY_NORMALIZE"));
+            rb_ary_push(inspected_flags, rb_str_new_cstr("KEY_NORMALIZE"));
         break;
       default:
         break;
@@ -890,57 +888,57 @@ rb_grn_object_inspect_content_flags_with_label (VALUE inspected,
 
     if (0) {
         if (flags & GRN_OBJ_COLUMN_SCALAR)
-            rb_ary_push(inspected_flags, rb_str_new2("COLUMN_SCALAR"));
+            rb_ary_push(inspected_flags, rb_str_new_cstr("COLUMN_SCALAR"));
         if (flags & GRN_OBJ_COLUMN_VECTOR)
-            rb_ary_push(inspected_flags, rb_str_new2("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_new2("COLUMN_INDEX"));
+            rb_ary_push(inspected_flags, rb_str_new_cstr("COLUMN_INDEX"));
     }
 
     switch (object->header.type) {
       case GRN_COLUMN_FIX_SIZE:
       case GRN_COLUMN_VAR_SIZE:
         if (flags & GRN_OBJ_COMPRESS_ZLIB)
-            rb_ary_push(inspected_flags, rb_str_new2("COMPRESS_ZLIB"));
+            rb_ary_push(inspected_flags, rb_str_new_cstr("COMPRESS_ZLIB"));
         if (flags & GRN_OBJ_COMPRESS_LZ4)
-            rb_ary_push(inspected_flags, rb_str_new2("COMPRESS_LZ4"));
+            rb_ary_push(inspected_flags, rb_str_new_cstr("COMPRESS_LZ4"));
         break;
       case GRN_COLUMN_INDEX:
         if (flags & GRN_OBJ_WITH_SECTION)
-            rb_ary_push(inspected_flags, rb_str_new2("WITH_SECTION"));
+            rb_ary_push(inspected_flags, rb_str_new_cstr("WITH_SECTION"));
         if (flags & GRN_OBJ_WITH_WEIGHT)
-            rb_ary_push(inspected_flags, rb_str_new2("WITH_WEIGHT"));
+            rb_ary_push(inspected_flags, rb_str_new_cstr("WITH_WEIGHT"));
         if (flags & GRN_OBJ_WITH_POSITION)
-            rb_ary_push(inspected_flags, rb_str_new2("WITH_POSITION"));
+            rb_ary_push(inspected_flags, rb_str_new_cstr("WITH_POSITION"));
         break;
       default:
         break;
     }
 
     if (flags & GRN_OBJ_RING_BUFFER)
-        rb_ary_push(inspected_flags, rb_str_new2("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_new2("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_new2("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_new2("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_new2("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_new2("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_new2("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_new2("UNIT_USERDEF_POSITION"));
+            rb_ary_push(inspected_flags, rb_str_new_cstr("UNIT_USERDEF_POSITION"));
     }
 
     rb_str_cat2(inspected, "<");
-    rb_str_concat(inspected, rb_ary_join(inspected_flags, rb_str_new2("|")));
+    rb_str_concat(inspected, rb_ary_join(inspected_flags, rb_str_new_cstr("|")));
     rb_str_cat2(inspected, ">");
 
     return inspected;
@@ -1010,7 +1008,7 @@ rb_grn_object_inspect (VALUE self)
 {
     VALUE inspected;
 
-    inspected = rb_str_new2("");
+    inspected = rb_str_new_cstr("");
     rb_grn_object_inspect_header(self, inspected);
     rb_grn_object_inspect_content(self, inspected);
     rb_grn_object_inspect_footer(self, inspected);
@@ -1064,7 +1062,7 @@ rb_grn_object_get_path (VALUE self)
     if (!path)
         return Qnil;
     else
-        return rb_str_new2(path);
+        return rb_str_new_cstr(path);
 }
 
 /*
@@ -1504,6 +1502,134 @@ rb_grn_object_builtin_p (VALUE self)
     return CBOOL2RVAL(builtin);
 }
 
+/*
+ * Checks whether the object is table or not.
+ *
+ * @overload table?
+ *   @return [Boolean] `true` if the object is table, `false` otherwise.
+ *
+ * @since 5.0.1
+ */
+static VALUE
+rb_grn_object_table_p (VALUE self)
+{
+    grn_ctx *context;
+    grn_obj *object;
+    grn_bool table_p = GRN_FALSE;
+
+    rb_grn_object_deconstruct(SELF(self), &object, &context,
+                              NULL, NULL, NULL, NULL);
+
+    if (context && object) {
+        table_p = grn_obj_is_table(context, object);
+    }
+
+    return CBOOL2RVAL(table_p);
+}
+
+/*
+ * Checks whether the object is procedure or not.
+ *
+ * @overload procedure?
+ *   @return [Boolean] `true` if the object is procedure, `false` otherwise.
+ *
+ * @since 5.0.1
+ */
+static VALUE
+rb_grn_object_procedure_p (VALUE self)
+{
+    grn_ctx *context;
+    grn_obj *object;
+    grn_bool procedure_p = GRN_FALSE;
+
+    rb_grn_object_deconstruct(SELF(self), &object, &context,
+                              NULL, NULL, NULL, NULL);
+
+    if (context && object) {
+        procedure_p = grn_obj_is_proc(context, object);
+    }
+
+    return CBOOL2RVAL(procedure_p);
+}
+
+/*
+ * Checks whether the object is function procedure or not.
+ *
+ * @overload function_procedure?
+ *   @return [Boolean] `true` if the object is function procedure,
+ *     `false` otherwise.
+ *
+ * @since 5.0.1
+ */
+static VALUE
+rb_grn_object_function_procedure_p (VALUE self)
+{
+    grn_ctx *context;
+    grn_obj *object;
+    grn_bool function_procedure_p = GRN_FALSE;
+
+    rb_grn_object_deconstruct(SELF(self), &object, &context,
+                              NULL, NULL, NULL, NULL);
+
+    if (context && object) {
+        function_procedure_p = grn_obj_is_function_proc(context, object);
+    }
+
+    return CBOOL2RVAL(function_procedure_p);
+}
+
+/*
+ * Checks whether the object is selector procedure or not.
+ *
+ * @overload selector_procedure?
+ *   @return [Boolean] `true` if the object is selector procedure,
+ *     `false` otherwise.
+ *
+ * @since 5.0.1
+ */
+static VALUE
+rb_grn_object_selector_procedure_p (VALUE self)
+{
+    grn_ctx *context;
+    grn_obj *object;
+    grn_bool selector_procedure_p = GRN_FALSE;
+
+    rb_grn_object_deconstruct(SELF(self), &object, &context,
+                              NULL, NULL, NULL, NULL);
+
+    if (context && object) {
+        selector_procedure_p = grn_obj_is_selector_proc(context, object);
+    }
+
+    return CBOOL2RVAL(selector_procedure_p);
+}
+
+/*
+ * Checks whether the object is scorer procedure or not.
+ *
+ * @overload scorer_procedure?
+ *   @return [Boolean] `true` if the object is scorer procedure,
+ *     `false` otherwise.
+ *
+ * @since 5.0.1
+ */
+static VALUE
+rb_grn_object_scorer_procedure_p (VALUE self)
+{
+    grn_ctx *context;
+    grn_obj *object;
+    grn_bool scorer_procedure_p = GRN_FALSE;
+
+    rb_grn_object_deconstruct(SELF(self), &object, &context,
+                              NULL, NULL, NULL, NULL);
+
+    if (context && object) {
+        scorer_procedure_p = grn_obj_is_scorer_proc(context, object);
+    }
+
+    return CBOOL2RVAL(scorer_procedure_p);
+}
+
 void
 rb_grn_init_object (VALUE mGrn)
 {
@@ -1539,4 +1665,12 @@ rb_grn_init_object (VALUE mGrn)
     rb_define_method(rb_cGrnObject, "remove", rb_grn_object_remove, 0);
 
     rb_define_method(rb_cGrnObject, "builtin?", rb_grn_object_builtin_p, 0);
+    rb_define_method(rb_cGrnObject, "table?", rb_grn_object_table_p, 0);
+    rb_define_method(rb_cGrnObject, "procedure?", rb_grn_object_procedure_p, 0);
+    rb_define_method(rb_cGrnObject, "function_procedure?",
+                     rb_grn_object_function_procedure_p, 0);
+    rb_define_method(rb_cGrnObject, "selector_procedure?",
+                     rb_grn_object_selector_procedure_p, 0);
+    rb_define_method(rb_cGrnObject, "scorer_procedure?",
+                     rb_grn_object_scorer_procedure_p, 0);
 }