rroonga 3.0.0 → 3.0.1

data/doc/text/news.textile

@@ -1,6 +1,27 @@
 h1. NEWS
 
-h2(#2-1-4). 2.1.4: 2013-03-29
+h2(#3-0-1). 3.0.1: 2013-05-01
+
+h3. Improvements
+
+* Required groonga >= 3.0.3.
+* Supported assigning weight to value. See {Groonga::Table#set_column_value},
+  {Groonga::Record#initialize} and {Groonga::Record#[]=} for details.
+* Renamed to {Groonga::QueryLogger.path} from {Groonga::Logger.query_log_path}.
+* Renamed to {Groonga::QueryLogger.path=} from {Groonga::Logger.query_log_path=}.
+* Renamed to {Groonga::Logger.path} from {Groonga::Logger.log_path}.
+* Renamed to {Groonga::Logger.path=} from {Groonga::Logger.log_path=}.
+* Added missing "Packnga >= 0.9.7" requirement. [Reported by takkanm]
+
+h3. Fixes
+
+* Fixed a memory leak on error.
+
+h3. Thanks
+
+* takkanm
+
+h2(#3-0-0). 3.0.0: 2013-03-29
 
 h3. Improvements
 

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

@@ -353,7 +353,7 @@ rb_grn_array_push (VALUE self)
  *     p pulled_record.nil? # => true
  *   end
  *
- * @see {Groonga::Array#push} Examples exist in the push documentation.
+ * @see Groonga::Array#push Examples exist in the push documentation.
  *
  * @overload pull(options={})
  *   @param [::Hash] options The option parameters.

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

@@ -239,7 +239,7 @@ rb_grn_logger_s_register (int argc, VALUE *argv, VALUE klass)
 
     rb_grn_scan_options(rb_options,
                         "max_level", &rb_max_level,
-                        "time",	     &rb_time,
+                        "time",      &rb_time,
                         "title",     &rb_title,
                         "message",   &rb_message,
                         "location",  &rb_location,
@@ -340,107 +340,65 @@ rb_grn_logger_s_reopen (VALUE klass)
 }
 
 /*
- * groongaのデフォルトロガーがログを出力するファイルのパスを返す。
+ * Gets the current log path that is used the default logger.
  *
- * @overload log_path
- *   @return [String]
+ * @overload path
+ *   @return [String or nil] The current log path
+ *
+ * @since 3.0.1
  */
 static VALUE
-rb_grn_logger_s_get_log_path (VALUE klass)
+rb_grn_logger_s_get_path (VALUE klass)
 {
     const char *path;
+    VALUE rb_path = Qnil;
 
     path = grn_default_logger_get_path();
     if (path) {
-	return rb_str_new2(path);
-    } else {
-	return Qnil;
+	rb_path = rb_str_new2(path);
     }
+    return rb_path;
 }
 
 /*
- * groongaのデフォルトロガーがログを出力するファイルのパスを
- * 指定する。
+ * Sets the log path that is used the default logger. If you're using
+ * custom logger by {.register}, the log path isn't used. Because it
+ * is for the default logger.
  *
- * {Groonga::Logger.register} で独自のロガーを設定している場合、
- * 設定している独自ロガーは無効になる。
+ * If you specify nil as path, logging by the default logger is
+ * disabled.
  *
- * @overload log_path=(path)
- */
-static VALUE
-rb_grn_logger_s_set_log_path (VALUE klass, VALUE rb_path)
-{
-    grn_bool need_reopen = GRN_FALSE;
-    const char *current_path;
-
-    current_path = grn_default_logger_get_path();
-    if (NIL_P(rb_path)) {
-	need_reopen = current_path != NULL;
-	grn_default_logger_set_path(NULL);
-    } else {
-	const char *new_path;
-	new_path = RSTRING_PTR(rb_path);
-	if (!current_path || strcmp(new_path, current_path) != 0) {
-	    need_reopen = GRN_TRUE;
-	}
-	grn_default_logger_set_path(new_path);
-    }
-    rb_cv_set(klass, "@@log_path", rb_path);
-
-    if (need_reopen) {
-	rb_grn_logger_s_reopen_with_related_object(klass, rb_path);
-    }
-
-    return Qnil;
-}
-
-/*
- * groongaのデフォルトロガーがクエリログを出力するファイルのパスを返す。
+ * @example Changes the log path for the default logger
+ *   Groonga::Logger.path = "/tmp/groonga.log"
  *
- * @overload query_log_path
- *   @return [String]
- */
-static VALUE
-rb_grn_logger_s_get_query_log_path (VALUE klass)
-{
-    const char *path;
-
-    path = grn_default_query_logger_get_path();
-    if (path) {
-	return rb_str_new2(path);
-    } else {
-	return Qnil;
-    }
-}
-
-/*
- * groongaのデフォルトロガーがクエリログを出力するファイルの
- * パスを指定する。
+ * @example Disables log by the default logger
+ *   Groonga::Logger.path = nil
  *
- * {Groonga::Logger.register} で独自のロガーを設定している場合、
- * 設定している独自ロガーは無効になる。
+ * @overload path=(path)
+ *   @param path [String or nil] The log path for the default logger.
+ *     If nil is specified, logging by the default logger is disabled.
+ *   @return void
  *
- * @overload query_log_path=(path)
+ * @since 3.0.1
  */
 static VALUE
-rb_grn_logger_s_set_query_log_path (VALUE klass, VALUE rb_path)
+rb_grn_logger_s_set_path (VALUE klass, VALUE rb_path)
 {
     grn_bool need_reopen = GRN_FALSE;
-    const char *current_path;
+    const char *old_path = NULL;
+    const char *path = NULL;
 
-    current_path = grn_default_query_logger_get_path();
-    if (NIL_P(rb_path)) {
-	need_reopen = current_path != NULL;
-	grn_default_query_logger_set_path(NULL);
-    } else {
-	const char *new_path;
-	new_path = RSTRING_PTR(rb_path);
-	if (!current_path || strcmp(new_path, current_path) != 0) {
-	    need_reopen = GRN_TRUE;
-	}
-	grn_default_query_logger_set_path(new_path);
+    rb_path = rb_grn_check_convert_to_string(rb_path);
+    if (!NIL_P(rb_path)) {
+        path = StringValuePtr(rb_path);
+    }
+
+    old_path = grn_default_logger_get_path();
+    if (!rb_grn_equal_string(old_path, path)) {
+        need_reopen = GRN_TRUE;
     }
-    rb_cv_set(klass, "@@query_log_path", rb_path);
+
+    grn_default_logger_set_path(path);
 
     if (need_reopen) {
 	rb_grn_logger_s_reopen_with_related_object(klass, rb_path);
@@ -467,22 +425,16 @@ rb_grn_init_logger (VALUE mGrn)
     cGrnLogger = rb_define_class_under(mGrn, "Logger", rb_cObject);
 
     rb_cv_set(cGrnLogger, "@@current_logger", Qnil);
-    rb_cv_set(cGrnLogger, "@@log_path", Qnil);
-    rb_cv_set(cGrnLogger, "@@query_log_path", Qnil);
     rb_define_singleton_method(cGrnLogger, "register",
                                rb_grn_logger_s_register, -1);
     rb_define_singleton_method(cGrnLogger, "unregister",
                                rb_grn_logger_s_unregister, 0);
     rb_define_singleton_method(cGrnLogger, "reopen",
                                rb_grn_logger_s_reopen, 0);
-    rb_define_singleton_method(cGrnLogger, "log_path",
-                               rb_grn_logger_s_get_log_path, 0);
-    rb_define_singleton_method(cGrnLogger, "log_path=",
-                               rb_grn_logger_s_set_log_path, 1);
-    rb_define_singleton_method(cGrnLogger, "query_log_path",
-                               rb_grn_logger_s_get_query_log_path, 0);
-    rb_define_singleton_method(cGrnLogger, "query_log_path=",
-                               rb_grn_logger_s_set_query_log_path, 1);
+    rb_define_singleton_method(cGrnLogger, "path",
+                               rb_grn_logger_s_get_path, 0);
+    rb_define_singleton_method(cGrnLogger, "path=",
+                               rb_grn_logger_s_set_path, 1);
     rb_set_end_proc(rb_grn_logger_reset, cGrnLogger);
 
     mGrnLoggerFlags = rb_define_module_under(cGrnLogger, "Flags");

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

@@ -1302,7 +1302,7 @@ rb_grn_object_set_raw (RbGrnObject *rb_grn_object, grn_id id,
     VALUE exception, rb_values;
 
     context = rb_grn_object->context;
-    rb_values = rb_check_array_type(rb_value);
+    rb_values = rb_grn_check_convert_to_array(rb_value);
     if (NIL_P(rb_values)) {
 	if (NIL_P(rb_value)) {
 	    GRN_OBJ_INIT(&value, GRN_BULK, 0, GRN_ID_NIL);

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

@@ -88,7 +88,7 @@ rb_grn_plugin_s_register (int argc, VALUE *argv, VALUE klass)
     grn_ctx *context;
 
     if (argc >= 1) {
-        rb_name = rb_check_string_type(argv[0]);
+        rb_name = rb_grn_check_convert_to_string(argv[0]);
     }
 
     if (NIL_P(rb_name)) {

data/ext/groonga/rb-grn-query-logger.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-2013  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
@@ -100,7 +100,7 @@ rb_grn_query_logger_fin (grn_ctx *ctx, void *user_data)
  *     @option options [Symbol, String, Integer or nil] :flags (:default)
  *       Flags describe what query log should be logged.
  *
- *       @see {QueryLogger::Flags.parse}
+ *       If @flags@ is String, it is parsed by {QueryLogger::Flags.parse}.
  *
  *   @return void
  *
@@ -218,6 +218,75 @@ rb_grn_query_logger_s_reopen (VALUE klass)
     return Qnil;
 }
 
+/*
+ * Gets the current query log path that is used the default query logger.
+ *
+ * @overload path
+ *   @return [String or nil] The current query log path
+ *
+ * @since 3.0.1
+ */
+static VALUE
+rb_grn_query_logger_s_get_path (VALUE klass)
+{
+    const char *path;
+    VALUE rb_path = Qnil;
+
+    path = grn_default_query_logger_get_path();
+    if (path) {
+	rb_path = rb_str_new2(path);
+    }
+    return rb_path;
+}
+
+/*
+ * Sets the query log path that is used the default query logger. If
+ * you're using custom query logger by {.register}, the query log path
+ * isn't used. Because it is for the default query logger.
+ *
+ * If you specify nil as path, query logging by the default query
+ * logger is disabled.
+ *
+ * @example Changes the query log path for the default query logger
+ *   Groonga::QueryLogger.path = "/tmp/query.log"
+ *
+ * @example Disables query log by the default query logger
+ *   Groonga::QueryLogger.path = nil
+ *
+ * @overload path=(path)
+ *   @param path [String or nil] The query log path for the default query
+ *     logger. If nil is specified, query logging by the default query logger
+ *     is disabled.
+ *   @return void
+ *
+ * @since 3.0.1
+ */
+static VALUE
+rb_grn_query_logger_s_set_path (VALUE klass, VALUE rb_path)
+{
+    grn_bool need_reopen = GRN_FALSE;
+    const char *old_path = NULL;
+    const char *path = NULL;
+
+    rb_path = rb_grn_check_convert_to_string(rb_path);
+    if (!NIL_P(rb_path)) {
+        path = StringValuePtr(rb_path);
+    }
+
+    old_path = grn_default_query_logger_get_path();
+    if (!rb_grn_equal_string(old_path, path)) {
+        need_reopen = GRN_TRUE;
+    }
+
+    grn_default_query_logger_set_path(path);
+
+    if (need_reopen) {
+        rb_grn_query_logger_s_reopen(klass);
+    }
+
+    return Qnil;
+}
+
 void
 rb_grn_init_query_logger (VALUE mGrn)
 {
@@ -242,6 +311,10 @@ rb_grn_init_query_logger (VALUE mGrn)
                                rb_grn_query_logger_s_unregister, 0);
     rb_define_singleton_method(cGrnQueryLogger, "reopen",
                                rb_grn_query_logger_s_reopen, 0);
+    rb_define_singleton_method(cGrnQueryLogger, "path",
+                               rb_grn_query_logger_s_get_path, 0);
+    rb_define_singleton_method(cGrnQueryLogger, "path=",
+                               rb_grn_query_logger_s_set_path, 1);
 
     mGrnQueryLoggerFlags = rb_define_module_under(cGrnQueryLogger, "Flags");
 #define DEFINE_FLAG(NAME)                                       \

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

@@ -43,9 +43,9 @@ grn_obj *
 rb_grn_table_from_ruby_object (VALUE object, grn_ctx **context)
 {
     if (!RVAL2CBOOL(rb_obj_is_kind_of(object, rb_cGrnTable))) {
-	rb_raise(rb_eTypeError,
-		 "not a groonga table: <%s>",
-		 rb_grn_inspect(object));
+        rb_raise(rb_eTypeError,
+                 "not a groonga table: <%s>",
+                 rb_grn_inspect(object));
     }
 
     return RVAL2GRNOBJECT(object, context);
@@ -53,7 +53,7 @@ rb_grn_table_from_ruby_object (VALUE object, grn_ctx **context)
 
 VALUE
 rb_grn_table_to_ruby_object (grn_ctx *context, grn_obj *table,
-			     grn_bool owner)
+                             grn_bool owner)
 {
     return GRNOBJECT2RVAL(Qnil, context, table, owner);
 }
@@ -70,39 +70,39 @@ rb_grn_table_finalizer (grn_ctx *context, grn_obj *object,
 
 void
 rb_grn_table_bind (RbGrnTable *rb_grn_table,
-		   grn_ctx *context, grn_obj *table)
+                   grn_ctx *context, grn_obj *table)
 {
     RbGrnObject *rb_grn_object;
 
     rb_grn_object = RB_GRN_OBJECT(rb_grn_table);
     rb_grn_table->value = grn_obj_open(context, GRN_BULK, 0,
-				       rb_grn_object->range_id);
+                                       rb_grn_object->range_id);
     rb_grn_table->columns = Qnil;
     rb_grn_table->columns = rb_ary_new();
 }
 
 void
 rb_grn_table_deconstruct (RbGrnTable *rb_grn_table,
-			  grn_obj **table,
-			  grn_ctx **context,
-			  grn_id *domain_id,
-			  grn_obj **domain,
-			  grn_obj **value,
-			  grn_id *range_id,
-			  grn_obj **range,
-			  VALUE *columns)
+                          grn_obj **table,
+                          grn_ctx **context,
+                          grn_id *domain_id,
+                          grn_obj **domain,
+                          grn_obj **value,
+                          grn_id *range_id,
+                          grn_obj **range,
+                          VALUE *columns)
 {
     RbGrnObject *rb_grn_object;
 
     rb_grn_object = RB_GRN_OBJECT(rb_grn_table);
     rb_grn_object_deconstruct(rb_grn_object, table, context,
-			      domain_id, domain,
-			      range_id, range);
+                              domain_id, domain,
+                              range_id, range);
 
     if (value)
-	*value = rb_grn_table->value;
+        *value = rb_grn_table->value;
     if (columns)
-	*columns = rb_grn_table->columns;
+        *columns = rb_grn_table->columns;
 }
 
 static void
@@ -114,23 +114,23 @@ rb_grn_table_mark (void *data)
     grn_obj *table;
 
     if (!rb_grn_object)
-	return;
+        return;
 
     rb_gc_mark(rb_grn_table->columns);
 
     context = rb_grn_object->context;
     table = rb_grn_object->object;
     if (!context || !table)
-	return;
+        return;
 
     rb_grn_context_mark_grn_id(context, table->header.domain);
     rb_grn_context_mark_grn_id(context, grn_obj_get_range(context, table));
 
     if (!grn_obj_path(context, table))
-	return;
+        return;
 
     if (grn_obj_name(context, table, NULL, 0) == 0)
-	return;
+        return;
 }
 
 static VALUE
@@ -156,24 +156,24 @@ rb_grn_table_inspect_content (VALUE self, VALUE inspected)
 
     rb_grn_table = SELF(self);
     if (!rb_grn_table)
-	return inspected;
+        return inspected;
 
     rb_grn_table_deconstruct(rb_grn_table, &table, &context,
-			     NULL, NULL,
-			     NULL, NULL, NULL,
-			     &columns);
+                             NULL, NULL,
+                             NULL, NULL, NULL,
+                             &columns);
 
     if (!table)
-	return inspected;
+        return inspected;
     if (!context)
-	return inspected;
+        return inspected;
 
     rb_str_cat2(inspected, ", ");
     rb_str_cat2(inspected, "size: <");
     {
-	char buf[21]; /* ceil(log10(2 ** 64)) + 1('\0') == 21 */
-	snprintf(buf, sizeof(buf), "%u", grn_table_size(context, table));
-	rb_str_cat2(inspected, buf);
+        char buf[21]; /* ceil(log10(2 ** 64)) + 1('\0') == 21 */
+        snprintf(buf, sizeof(buf), "%u", grn_table_size(context, table));
+        rb_str_cat2(inspected, buf);
     }
     rb_str_cat2(inspected, ">");
 
@@ -249,9 +249,9 @@ rb_grn_table_define_column (int argc, VALUE *argv, VALUE self)
     VALUE rb_column;
 
     rb_grn_table_deconstruct(SELF(self), &table, &context,
-			     NULL, NULL,
-			     NULL, NULL, NULL,
-			     &columns);
+                             NULL, NULL,
+                             NULL, NULL, NULL,
+                             &columns);
 
     rb_scan_args(argc, argv, "21", &rb_name, &rb_value_type, &options);
 
@@ -259,64 +259,64 @@ rb_grn_table_define_column (int argc, VALUE *argv, VALUE self)
     name_size = RSTRING_LEN(rb_name);
 
     rb_grn_scan_options(options,
-			"path", &rb_path,
-			"persistent", &rb_persistent,
-			"type", &rb_type,
-			"compress", &rb_compress,
-			NULL);
+                        "path", &rb_path,
+                        "persistent", &rb_persistent,
+                        "type", &rb_type,
+                        "compress", &rb_compress,
+                        NULL);
 
     value_type = RVAL2GRNOBJECT(rb_value_type, &context);
 
     if ((NIL_P(rb_persistent) && grn_obj_path(context, table)) ||
-	RVAL2CBOOL(rb_persistent)) {
-	flags |= GRN_OBJ_PERSISTENT;
+        RVAL2CBOOL(rb_persistent)) {
+        flags |= GRN_OBJ_PERSISTENT;
     }
 
     if (!NIL_P(rb_path)) {
-	path = StringValueCStr(rb_path);
-	if ((flags & GRN_OBJ_PERSISTENT) != GRN_OBJ_PERSISTENT) {
-	    rb_raise(rb_eArgError,
-		     "should not pass :path if :persistent is false: <%s>",
-		     path);
-	}
-	flags |= GRN_OBJ_PERSISTENT;
+        path = StringValueCStr(rb_path);
+        if ((flags & GRN_OBJ_PERSISTENT) != GRN_OBJ_PERSISTENT) {
+            rb_raise(rb_eArgError,
+                     "should not pass :path if :persistent is false: <%s>",
+                     path);
+        }
+        flags |= GRN_OBJ_PERSISTENT;
     }
 
     if (NIL_P(rb_type) ||
-	(rb_grn_equal_option(rb_type, "scalar"))) {
-	flags |= GRN_OBJ_COLUMN_SCALAR;
+        (rb_grn_equal_option(rb_type, "scalar"))) {
+        flags |= GRN_OBJ_COLUMN_SCALAR;
     } else if (rb_grn_equal_option(rb_type, "vector")) {
-	flags |= GRN_OBJ_COLUMN_VECTOR;
+        flags |= GRN_OBJ_COLUMN_VECTOR;
     } else {
-	rb_raise(rb_eArgError,
-		 "invalid column type: %s: "
-		 "available types: [:scalar, :vector, nil]",
-		 rb_grn_inspect(rb_type));
+        rb_raise(rb_eArgError,
+                 "invalid column type: %s: "
+                 "available types: [:scalar, :vector, nil]",
+                 rb_grn_inspect(rb_type));
     }
 
     if (NIL_P(rb_compress)) {
     } else if (rb_grn_equal_option(rb_compress, "zlib")) {
-	flags |= GRN_OBJ_COMPRESS_ZLIB;
+        flags |= GRN_OBJ_COMPRESS_ZLIB;
     } else if (rb_grn_equal_option(rb_compress, "lzo")) {
-	flags |= GRN_OBJ_COMPRESS_LZO;
+        flags |= GRN_OBJ_COMPRESS_LZO;
     } else {
-	rb_raise(rb_eArgError,
-		 "invalid compress type: %s: "
-		 "available types: [:zlib, :lzo, nil]",
-		 rb_grn_inspect(rb_compress));
+        rb_raise(rb_eArgError,
+                 "invalid compress type: %s: "
+                 "available types: [:zlib, :lzo, nil]",
+                 rb_grn_inspect(rb_compress));
     }
 
     column = grn_column_create(context, table, name, name_size,
-			       path, flags, value_type);
+                               path, flags, value_type);
     if (context->rc) {
-	rb_grn_context_check(context,
-			     rb_ary_new3(2, self, rb_ary_new4(argc, argv)));
+        rb_grn_context_check(context,
+                             rb_ary_new3(2, self, rb_ary_new4(argc, argv)));
     }
 
     rb_column = GRNCOLUMN2RVAL(Qnil, context, column, GRN_TRUE);
     rb_ary_push(columns, rb_column);
     rb_grn_named_object_set_name(RB_GRN_NAMED_OBJECT(DATA_PTR(rb_column)),
-				 name, name_size);
+                                 name, name_size);
 
     return rb_column;
 }
@@ -328,17 +328,17 @@ n_gram_tokenizer_p(grn_ctx *context, grn_obj *tokenizer)
     int name_size;
 
     name_size = grn_obj_name(context, tokenizer,
-			     tokenizer_name, sizeof(tokenizer_name) - 1);
+                             tokenizer_name, sizeof(tokenizer_name) - 1);
     if (name_size == 0)
-	return GRN_FALSE;
+        return GRN_FALSE;
 
     tokenizer_name[name_size] = '\0';
 
 #define HAVE_PREFIX_P(prefix) \
     (strncmp(tokenizer_name, prefix, strlen(prefix)) == 0)
     return (HAVE_PREFIX_P("TokenUnigram") ||
-	    HAVE_PREFIX_P("TokenBigram") ||
-	    HAVE_PREFIX_P("TokenTrigram"));
+            HAVE_PREFIX_P("TokenBigram") ||
+            HAVE_PREFIX_P("TokenTrigram"));
 #undef HAVE_PREFIX_P
 }
 
@@ -384,9 +384,9 @@ rb_grn_table_define_index_column (int argc, VALUE *argv, VALUE self)
     VALUE columns;
 
     rb_grn_table_deconstruct(SELF(self), &table, &context,
-			     NULL, NULL,
-			     NULL, NULL, NULL,
-			     &columns);
+                             NULL, NULL,
+                             NULL, NULL, NULL,
+                             &columns);
 
     rb_scan_args(argc, argv, "21", &rb_name, &rb_value_type, &options);
 
@@ -394,100 +394,100 @@ rb_grn_table_define_index_column (int argc, VALUE *argv, VALUE self)
     name_size = RSTRING_LEN(rb_name);
 
     rb_grn_scan_options(options,
-			"path", &rb_path,
-			"persistent", &rb_persistent,
-			"with_section", &rb_with_section,
-			"with_weight", &rb_with_weight,
-			"with_position", &rb_with_position,
-			"source", &rb_source,
-			"sources", &rb_sources,
-			NULL);
+                        "path", &rb_path,
+                        "persistent", &rb_persistent,
+                        "with_section", &rb_with_section,
+                        "with_weight", &rb_with_weight,
+                        "with_position", &rb_with_position,
+                        "source", &rb_source,
+                        "sources", &rb_sources,
+                        NULL);
 
     value_type = RVAL2GRNOBJECT(rb_value_type, &context);
 
     if ((NIL_P(rb_persistent) && grn_obj_path(context, table)) ||
-	RVAL2CBOOL(rb_persistent)) {
-	flags |= GRN_OBJ_PERSISTENT;
+        RVAL2CBOOL(rb_persistent)) {
+        flags |= GRN_OBJ_PERSISTENT;
     }
 
     if (!NIL_P(rb_path)) {
-	path = StringValueCStr(rb_path);
-	if ((flags & GRN_OBJ_PERSISTENT) != GRN_OBJ_PERSISTENT) {
-	    rb_raise(rb_eArgError,
-		     "should not pass :path if :persistent is false: <%s>",
-		     path);
-	}
-	flags |= GRN_OBJ_PERSISTENT;
+        path = StringValueCStr(rb_path);
+        if ((flags & GRN_OBJ_PERSISTENT) != GRN_OBJ_PERSISTENT) {
+            rb_raise(rb_eArgError,
+                     "should not pass :path if :persistent is false: <%s>",
+                     path);
+        }
+        flags |= GRN_OBJ_PERSISTENT;
     }
 
     if (NIL_P(rb_with_section)) {
-	if (TYPE(rb_sources) == T_ARRAY && RARRAY_LEN(rb_sources) > 1) {
-	    flags |= GRN_OBJ_WITH_SECTION;
-	}
+        if (TYPE(rb_sources) == T_ARRAY && RARRAY_LEN(rb_sources) > 1) {
+            flags |= GRN_OBJ_WITH_SECTION;
+        }
     } else if (RVAL2CBOOL(rb_with_section)) {
-	flags |= GRN_OBJ_WITH_SECTION;
+        flags |= GRN_OBJ_WITH_SECTION;
     }
 
 
     if (RVAL2CBOOL(rb_with_weight))
-	flags |= GRN_OBJ_WITH_WEIGHT;
+        flags |= GRN_OBJ_WITH_WEIGHT;
 
     if (NIL_P(rb_with_position) &&
-	(table->header.type == GRN_TABLE_HASH_KEY ||
-	 table->header.type == GRN_TABLE_PAT_KEY)) {
-	grn_obj *tokenizer;
-
-	tokenizer = grn_obj_get_info(context, table,
-				     GRN_INFO_DEFAULT_TOKENIZER,
-				     NULL);
-	if (tokenizer && n_gram_tokenizer_p(context, tokenizer)) {
-	    rb_with_position = Qtrue;
-	}
+        (table->header.type == GRN_TABLE_HASH_KEY ||
+         table->header.type == GRN_TABLE_PAT_KEY)) {
+        grn_obj *tokenizer;
+
+        tokenizer = grn_obj_get_info(context, table,
+                                     GRN_INFO_DEFAULT_TOKENIZER,
+                                     NULL);
+        if (tokenizer && n_gram_tokenizer_p(context, tokenizer)) {
+            rb_with_position = Qtrue;
+        }
     }
     if (RVAL2CBOOL(rb_with_position))
-	flags |= GRN_OBJ_WITH_POSITION;
+        flags |= GRN_OBJ_WITH_POSITION;
 
     if (!NIL_P(rb_source) && !NIL_P(rb_sources))
-	rb_raise(rb_eArgError, "should not pass both of :source and :sources.");
+        rb_raise(rb_eArgError, "should not pass both of :source and :sources.");
 
     column = grn_column_create(context, table, name, name_size,
-			       path, flags, value_type);
+                               path, flags, value_type);
     if (context->rc) {
-	rb_grn_context_check(context,
-			     rb_ary_new3(2, self, rb_ary_new4(argc, argv)));
+        rb_grn_context_check(context,
+                             rb_ary_new3(2, self, rb_ary_new4(argc, argv)));
     }
 
     rb_column = GRNCOLUMN2RVAL(Qnil, context, column, GRN_TRUE);
     if (!NIL_P(rb_source))
-	rb_funcall(rb_column, rb_intern("source="), 1, rb_source);
+        rb_funcall(rb_column, rb_intern("source="), 1, rb_source);
     if (!NIL_P(rb_sources))
-	rb_funcall(rb_column, rb_intern("sources="), 1, rb_sources);
+        rb_funcall(rb_column, rb_intern("sources="), 1, rb_sources);
 
     rb_ary_push(columns, rb_column);
     rb_grn_named_object_set_name(RB_GRN_NAMED_OBJECT(DATA_PTR(rb_column)),
-				 name, name_size);
+                                 name, name_size);
 
     return rb_column;
 }
 
 static void
 ruby_object_to_column_name (VALUE rb_name,
-			    const char **name, unsigned *name_size)
+                            const char **name, unsigned *name_size)
 {
     switch (TYPE(rb_name)) {
       case T_SYMBOL:
-	*name = rb_id2name(SYM2ID(rb_name));
-	*name_size = strlen(*name);
-	break;
+        *name = rb_id2name(SYM2ID(rb_name));
+        *name_size = strlen(*name);
+        break;
       case T_STRING:
-	*name = StringValuePtr(rb_name);
-	*name_size = RSTRING_LEN(rb_name);
-	break;
+        *name = StringValuePtr(rb_name);
+        *name_size = RSTRING_LEN(rb_name);
+        break;
       default:
-	rb_raise(rb_eArgError,
-		 "column name should be String or Symbol: %s",
-		 rb_grn_inspect(rb_name));
-	break;
+        rb_raise(rb_eArgError,
+                 "column name should be String or Symbol: %s",
+                 rb_grn_inspect(rb_name));
+        break;
     }
 }
 
@@ -514,46 +514,46 @@ rb_grn_table_get_column (VALUE self, VALUE rb_name)
     long i, n;
 
     rb_grn_table_deconstruct(SELF(self), &table, &context,
-			     NULL, NULL,
-			     NULL, NULL, NULL,
-			     &columns);
+                             NULL, NULL,
+                             NULL, NULL, NULL,
+                             &columns);
 
     ruby_object_to_column_name(rb_name, &name, &name_size);
     raw_columns = RARRAY_PTR(columns);
     n = RARRAY_LEN(columns);
     for (i = 0; i < n; i++) {
-	VALUE rb_column = raw_columns[i];
-	RbGrnNamedObject *rb_grn_named_object;
-
-	rb_grn_named_object = RB_GRN_NAMED_OBJECT(DATA_PTR(rb_column));
-	if (name_size == rb_grn_named_object->name_size &&
-	    memcmp(name, rb_grn_named_object->name, name_size) == 0) {
-	    return rb_column;
-	}
+        VALUE rb_column = raw_columns[i];
+        RbGrnNamedObject *rb_grn_named_object;
+
+        rb_grn_named_object = RB_GRN_NAMED_OBJECT(DATA_PTR(rb_column));
+        if (name_size == rb_grn_named_object->name_size &&
+            memcmp(name, rb_grn_named_object->name, name_size) == 0) {
+            return rb_column;
+        }
     }
 
     column = grn_obj_column(context, table, name, name_size);
     rb_grn_context_check(context, self);
     if (!column)
-	return Qnil;
+        return Qnil;
 
     user_data = grn_obj_user_data(context, column);
     if (user_data) {
-	RbGrnObject *rb_grn_object;
-	rb_grn_object = user_data->ptr;
-	if (rb_grn_object) {
-	    rb_ary_push(columns, rb_grn_object->self);
-	    return rb_grn_object->self;
-	}
+        RbGrnObject *rb_grn_object;
+        rb_grn_object = user_data->ptr;
+        if (rb_grn_object) {
+            rb_ary_push(columns, rb_grn_object->self);
+            return rb_grn_object->self;
+        }
     }
 
     owner = column->header.type == GRN_ACCESSOR;
     rb_column = GRNCOLUMN2RVAL(Qnil, context, column, owner);
     if (owner) {
-	rb_iv_set(rb_column, "table", self);
+        rb_iv_set(rb_column, "table", self);
     }
     rb_grn_named_object_set_name(RB_GRN_NAMED_OBJECT(DATA_PTR(rb_column)),
-				 name, name_size);
+                                 name, name_size);
 
     return rb_column;
 }
@@ -565,9 +565,9 @@ rb_grn_table_get_column_surely (VALUE self, VALUE rb_name)
 
     rb_column = rb_grn_table_get_column(self, rb_name);
     if (NIL_P(rb_column)) {
-	rb_raise(rb_eGrnNoSuchColumn,
-		 "no such column: <%s>: <%s>",
-		 rb_grn_inspect(rb_name), rb_grn_inspect(self));
+        rb_raise(rb_eGrnNoSuchColumn,
+                 "no such column: <%s>: <%s>",
+                 rb_grn_inspect(rb_name), rb_grn_inspect(self));
     }
     return rb_column;
 }
@@ -594,55 +594,55 @@ rb_grn_table_get_columns (int argc, VALUE *argv, VALUE self)
     VALUE exception;
 
     rb_grn_table_deconstruct(SELF(self), &table, &context,
-			     NULL, NULL,
-			     NULL, NULL, NULL,
-			     NULL);
+                             NULL, NULL,
+                             NULL, NULL, NULL,
+                             NULL);
 
     rb_scan_args(argc, argv, "01", &rb_name);
 
     if (!NIL_P(rb_name)) {
-	name = StringValuePtr(rb_name);
-	name_size = RSTRING_LEN(rb_name);
+        name = StringValuePtr(rb_name);
+        name_size = RSTRING_LEN(rb_name);
     }
 
     columns = grn_table_create(context, NULL, 0, NULL, GRN_TABLE_HASH_KEY,
-			       NULL, 0);
+                               NULL, 0);
     n = grn_table_columns(context, table, name, name_size, columns);
     rb_grn_context_check(context, self);
 
     rb_columns = rb_ary_new2(n);
     if (n == 0) {
-	grn_obj_unlink(context, columns);
-	return rb_columns;
+        grn_obj_unlink(context, columns);
+        return rb_columns;
     }
 
     cursor = grn_table_cursor_open(context, columns, NULL, 0, NULL, 0,
-				   0, -1, GRN_CURSOR_ASCENDING);
+                                   0, -1, GRN_CURSOR_ASCENDING);
     rb_grn_context_check(context, self);
     while (grn_table_cursor_next(context, cursor) != GRN_ID_NIL) {
-	void *key;
-	grn_id *column_id;
-	grn_obj *column;
-	VALUE rb_column;
-
-	grn_table_cursor_get_key(context, cursor, &key);
-	column_id = key;
-	column = grn_ctx_at(context, *column_id);
-	exception = rb_grn_context_to_exception(context, self);
-	if (!NIL_P(exception)) {
-	    grn_table_cursor_close(context, cursor);
-	    grn_obj_unlink(context, columns);
-	    rb_exc_raise(exception);
-	}
-
-	rb_column = GRNOBJECT2RVAL(Qnil, context, column, GRN_FALSE);
-	rb_ary_push(rb_columns, rb_column);
+        void *key;
+        grn_id *column_id;
+        grn_obj *column;
+        VALUE rb_column;
+
+        grn_table_cursor_get_key(context, cursor, &key);
+        column_id = key;
+        column = grn_ctx_at(context, *column_id);
+        exception = rb_grn_context_to_exception(context, self);
+        if (!NIL_P(exception)) {
+            grn_table_cursor_close(context, cursor);
+            grn_obj_unlink(context, columns);
+            rb_exc_raise(exception);
+        }
+
+        rb_column = GRNOBJECT2RVAL(Qnil, context, column, GRN_FALSE);
+        rb_ary_push(rb_columns, rb_column);
     }
     rc = grn_table_cursor_close(context, cursor);
     grn_obj_unlink(context, columns);
     if (rc != GRN_SUCCESS) {
-	rb_grn_context_check(context, self);
-	rb_grn_rc_check(rc, self);
+        rb_grn_context_check(context, self);
+        rb_grn_rc_check(rc, self);
     }
 
     return rb_columns;
@@ -663,23 +663,23 @@ rb_grn_table_have_column (VALUE self, VALUE rb_name)
     unsigned name_size = 0;
 
     rb_grn_table_deconstruct(SELF(self), &table, &context,
-			     NULL, NULL,
-			     NULL, NULL, NULL,
-			     NULL);
+                             NULL, NULL,
+                             NULL, NULL, NULL,
+                             NULL);
 
     ruby_object_to_column_name(rb_name, &name, &name_size);
     column = grn_obj_column(context, table, name, name_size);
     if (column) {
-	grn_obj_unlink(context, column);
-	return Qtrue;
+        grn_obj_unlink(context, column);
+        return Qtrue;
     } else {
-	return Qfalse;
+        return Qfalse;
     }
 }
 
 static grn_table_cursor *
 rb_grn_table_open_grn_cursor (int argc, VALUE *argv, VALUE self,
-			      grn_ctx **context)
+                              grn_ctx **context)
 {
     grn_obj *table;
     grn_table_cursor *cursor;
@@ -691,50 +691,50 @@ rb_grn_table_open_grn_cursor (int argc, VALUE *argv, VALUE self,
     VALUE rb_greater_than, rb_less_than, rb_offset, rb_limit;
 
     rb_grn_table_deconstruct(SELF(self), &table, context,
-			     NULL, NULL,
-			     NULL, NULL, NULL,
-			     NULL);
+                             NULL, NULL,
+                             NULL, NULL, NULL,
+                             NULL);
 
     rb_scan_args(argc, argv, "01", &options);
 
     rb_grn_scan_options(options,
-			"min", &rb_min,
+                        "min", &rb_min,
                         "max", &rb_max,
                         "offset", &rb_offset,
                         "limit", &rb_limit,
-			"order", &rb_order,
-			"order_by", &rb_order_by,
-			"greater_than", &rb_greater_than,
-			"less_than", &rb_less_than,
-			NULL);
+                        "order", &rb_order,
+                        "order_by", &rb_order_by,
+                        "greater_than", &rb_greater_than,
+                        "less_than", &rb_less_than,
+                        NULL);
 
     if (!NIL_P(rb_min)) {
-	min_key = StringValuePtr(rb_min);
-	min_key_size = RSTRING_LEN(rb_min);
+        min_key = StringValuePtr(rb_min);
+        min_key_size = RSTRING_LEN(rb_min);
     }
     if (!NIL_P(rb_max)) {
-	max_key = StringValuePtr(rb_max);
-	max_key_size = RSTRING_LEN(rb_max);
+        max_key = StringValuePtr(rb_max);
+        max_key_size = RSTRING_LEN(rb_max);
     }
     if (!NIL_P(rb_offset))
-	offset = NUM2INT(rb_offset);
+        offset = NUM2INT(rb_offset);
     if (!NIL_P(rb_limit))
-	limit = NUM2INT(rb_limit);
+        limit = NUM2INT(rb_limit);
 
     flags |= rb_grn_table_cursor_order_to_flag(rb_order);
     flags |= rb_grn_table_cursor_order_by_to_flag(table->header.type,
-						  self,
-						  rb_order_by);
+                                                  self,
+                                                  rb_order_by);
 
     if (RVAL2CBOOL(rb_greater_than))
-	flags |= GRN_CURSOR_GT;
+        flags |= GRN_CURSOR_GT;
     if (RVAL2CBOOL(rb_less_than))
-	flags |= GRN_CURSOR_LT;
+        flags |= GRN_CURSOR_LT;
 
     cursor = grn_table_cursor_open(*context, table,
-				   min_key, min_key_size,
-				   max_key, max_key_size,
-				   offset, limit, flags);
+                                   min_key, min_key_size,
+                                   max_key, max_key_size,
+                                   offset, limit, flags);
     rb_grn_context_check(*context, self);
 
     return cursor;
@@ -821,9 +821,9 @@ rb_grn_table_open_cursor (int argc, VALUE *argv, VALUE self)
     rb_cursor = GRNTABLECURSOR2RVAL(Qnil, context, cursor);
     rb_iv_set(rb_cursor, "@table", self); /* FIXME: cursor should mark table */
     if (rb_block_given_p())
-	return rb_ensure(rb_yield, rb_cursor, rb_grn_object_close, rb_cursor);
+        return rb_ensure(rb_yield, rb_cursor, rb_grn_object_close, rb_cursor);
     else
-	return rb_cursor;
+        return rb_cursor;
 }
 
 /*
@@ -844,7 +844,7 @@ rb_grn_table_get_records (int argc, VALUE *argv, VALUE self)
     cursor = rb_grn_table_open_grn_cursor(argc, argv, self, &context);
     records = rb_ary_new();
     while ((record_id = grn_table_cursor_next(context, cursor))) {
-	rb_ary_push(records, rb_grn_record_new(self, record_id, Qnil));
+        rb_ary_push(records, rb_grn_record_new(self, record_id, Qnil));
     }
     grn_table_cursor_close(context, cursor);
 
@@ -865,9 +865,9 @@ rb_grn_table_get_size (VALUE self)
     unsigned int size;
 
     rb_grn_table_deconstruct(SELF(self), &table, &context,
-			     NULL, NULL,
-			     NULL, NULL, NULL,
-			     NULL);
+                             NULL, NULL,
+                             NULL, NULL, NULL,
+                             NULL);
     size = grn_table_size(context, table);
     return UINT2NUM(size);
 }
@@ -885,9 +885,9 @@ rb_grn_table_empty_p (VALUE self)
     unsigned int size;
 
     rb_grn_table_deconstruct(SELF(self), &table, &context,
-			     NULL, NULL,
-			     NULL, NULL, NULL,
-			     NULL);
+                             NULL, NULL,
+                             NULL, NULL, NULL,
+                             NULL);
     size = grn_table_size(context, table);
     return CBOOL2RVAL(size == 0);
 }
@@ -905,9 +905,9 @@ rb_grn_table_truncate (VALUE self)
     grn_rc rc;
 
     rb_grn_table_deconstruct(SELF(self), &table, &context,
-			     NULL, NULL,
-			     NULL, NULL, NULL,
-			     NULL);
+                             NULL, NULL,
+                             NULL, NULL, NULL,
+                             NULL);
     rc = grn_table_truncate(context, table);
     rb_grn_rc_check(rc, self);
 
@@ -944,8 +944,8 @@ rb_grn_table_each (int argc, VALUE *argv, VALUE self)
     rb_table = SELF(self);
     rb_grn_object = RB_GRN_OBJECT(rb_table);
     while (rb_grn_object->object &&
-	   (id = grn_table_cursor_next(context, cursor)) != GRN_ID_NIL) {
-	rb_yield(rb_grn_record_new(self, id, Qnil));
+           (id = grn_table_cursor_next(context, cursor)) != GRN_ID_NIL) {
+        rb_yield(rb_grn_record_new(self, id, Qnil));
     }
     rb_grn_object_close(rb_cursor);
 
@@ -961,9 +961,9 @@ rb_grn_table_delete_by_id (VALUE self, VALUE rb_id)
     grn_rc rc;
 
     rb_grn_table_deconstruct(SELF(self), &table, &context,
-			     NULL, NULL,
-			     NULL, NULL, NULL,
-			     NULL);
+                             NULL, NULL,
+                             NULL, NULL, NULL,
+                             NULL);
 
     id = NUM2UINT(rb_id);
     rc = grn_table_delete_by_id(context, table, id);
@@ -983,38 +983,38 @@ rb_grn_table_delete_by_expression (VALUE self)
     grn_table_cursor *cursor;
 
     rb_grn_table_deconstruct(SELF(self), &table, &context,
-			     NULL, NULL,
-			     NULL, NULL, NULL,
-			     NULL);
+                             NULL, NULL,
+                             NULL, NULL, NULL,
+                             NULL);
 
     rb_builder = rb_grn_record_expression_builder_new(self, Qnil);
     rb_expression = rb_grn_record_expression_builder_build(rb_builder);
     rb_grn_object_deconstruct(RB_GRN_OBJECT(DATA_PTR(rb_expression)),
                               &expression, NULL,
-			      NULL, NULL, NULL, NULL);
+                              NULL, NULL, NULL, NULL);
 
     needless_records =
-	grn_table_create(context, NULL, 0, NULL,
-			 GRN_TABLE_HASH_KEY | GRN_OBJ_WITH_SUBREC,
-			 table,
-			 NULL);
+        grn_table_create(context, NULL, 0, NULL,
+                         GRN_TABLE_HASH_KEY | GRN_OBJ_WITH_SUBREC,
+                         table,
+                         NULL);
     if (!needless_records) {
-	rb_grn_context_check(context, self);
-	rb_grn_rc_check(GRN_NO_MEMORY_AVAILABLE, self);
+        rb_grn_context_check(context, self);
+        rb_grn_rc_check(GRN_NO_MEMORY_AVAILABLE, self);
     }
 
     grn_table_select(context, table, expression, needless_records, operator);
     cursor = grn_table_cursor_open(context, needless_records,
-				   NULL, 0,
-				   NULL, 0,
-				   0, -1, 0);
+                                   NULL, 0,
+                                   NULL, 0,
+                                   0, -1, 0);
     if (cursor) {
-	while (grn_table_cursor_next(context, cursor)) {
-	    grn_id *id;
-	    grn_table_cursor_get_key(context, cursor, (void **)&id);
-	    grn_table_delete_by_id(context, table, *id);
-	}
-	grn_table_cursor_close(context, cursor);
+        while (grn_table_cursor_next(context, cursor)) {
+            grn_id *id;
+            grn_table_cursor_get_key(context, cursor, (void **)&id);
+            grn_table_delete_by_id(context, table, *id);
+        }
+        grn_table_cursor_close(context, cursor);
     }
     grn_obj_unlink(context, needless_records);
 
@@ -1055,9 +1055,9 @@ rb_grn_table_delete (int argc, VALUE *argv, VALUE self)
     rb_scan_args(argc, argv, "01", &rb_id);
 
     if (rb_block_given_p()) {
-	rb_grn_table_delete_by_expression(self);
+        rb_grn_table_delete_by_expression(self);
     } else {
-	rb_grn_table_delete_by_id(self, rb_id);
+        rb_grn_table_delete_by_id(self, rb_id);
     }
 
     return Qnil;
@@ -1140,11 +1140,11 @@ rb_grn_table_delete (int argc, VALUE *argv, VALUE self)
  *   {::Array} since 2.1.0. If you want to get before 2.1.0 style
  *   result, use the following code:
  *
- *   @example Describe incompatible API change
- *     result_since_2_1_0 = table.sort(["sort_key"])
- *     result_before_2_1_0 = result_since_2_1_0.collect do |record|
- *       record.value
- *     end
+ * @example Describe incompatible API change
+ *   result_since_2_1_0 = table.sort(["sort_key"])
+ *   result_before_2_1_0 = result_since_2_1_0.collect do |record|
+ *     record.value
+ *   end
  */
 static VALUE
 rb_grn_table_sort (int argc, VALUE *argv, VALUE self)
@@ -1161,80 +1161,80 @@ rb_grn_table_sort (int argc, VALUE *argv, VALUE self)
     VALUE exception;
 
     rb_grn_table_deconstruct(SELF(self), &table, &context,
-			     NULL, NULL,
-			     NULL, NULL, NULL,
-			     NULL);
+                             NULL, NULL,
+                             NULL, NULL, NULL,
+                             NULL);
 
     rb_scan_args(argc, argv, "11", &rb_keys, &options);
 
     if (!RVAL2CBOOL(rb_obj_is_kind_of(rb_keys, rb_cArray)))
-	rb_raise(rb_eArgError, "keys should be an array of key: <%s>",
-		 rb_grn_inspect(rb_keys));
+        rb_raise(rb_eArgError, "keys should be an array of key: <%s>",
+                 rb_grn_inspect(rb_keys));
 
     n_keys = RARRAY_LEN(rb_keys);
     rb_sort_keys = RARRAY_PTR(rb_keys);
     keys = ALLOCA_N(grn_table_sort_key, n_keys);
     for (i = 0; i < n_keys; i++) {
-	VALUE rb_sort_options, rb_key, rb_resolved_key, rb_order;
-
-	if (RVAL2CBOOL(rb_obj_is_kind_of(rb_sort_keys[i], rb_cHash))) {
-	    rb_sort_options = rb_sort_keys[i];
-	} else if (RVAL2CBOOL(rb_obj_is_kind_of(rb_sort_keys[i], rb_cArray))) {
-	    rb_sort_options = rb_hash_new();
-	    rb_hash_aset(rb_sort_options,
-			 RB_GRN_INTERN("key"),
-			 rb_ary_entry(rb_sort_keys[i], 0));
-	    rb_hash_aset(rb_sort_options,
-			 RB_GRN_INTERN("order"),
-			 rb_ary_entry(rb_sort_keys[i], 1));
-	} else {
-	    rb_sort_options = rb_hash_new();
-	    rb_hash_aset(rb_sort_options,
-			 RB_GRN_INTERN("key"),
-			 rb_sort_keys[i]);
-	}
-	rb_grn_scan_options(rb_sort_options,
-			    "key", &rb_key,
-			    "order", &rb_order,
-			    NULL);
-	if (RVAL2CBOOL(rb_obj_is_kind_of(rb_key, rb_cString))) {
-	    rb_resolved_key = rb_grn_table_get_column(self, rb_key);
-	} else {
-	    rb_resolved_key = rb_key;
-	}
-	keys[i].key = RVAL2GRNOBJECT(rb_resolved_key, &context);
-	if (!keys[i].key) {
-	    rb_raise(rb_eGrnNoSuchColumn,
-		     "no such column: <%s>: <%s>",
-		     rb_grn_inspect(rb_key), rb_grn_inspect(self));
-	}
-	if (NIL_P(rb_order) ||
-	    rb_grn_equal_option(rb_order, "asc") ||
-	    rb_grn_equal_option(rb_order, "ascending")) {
-	    keys[i].flags = GRN_TABLE_SORT_ASC;
-	} else if (rb_grn_equal_option(rb_order, "desc") ||
-		   rb_grn_equal_option(rb_order, "descending")) {
-	    keys[i].flags = GRN_TABLE_SORT_DESC;
-	} else {
-	    rb_raise(rb_eArgError,
-		     "order should be one of "
-		     "[nil, :desc, :descending, :asc, :ascending]: %s",
-		     rb_grn_inspect(rb_order));
-	}
+        VALUE rb_sort_options, rb_key, rb_resolved_key, rb_order;
+
+        if (RVAL2CBOOL(rb_obj_is_kind_of(rb_sort_keys[i], rb_cHash))) {
+            rb_sort_options = rb_sort_keys[i];
+        } else if (RVAL2CBOOL(rb_obj_is_kind_of(rb_sort_keys[i], rb_cArray))) {
+            rb_sort_options = rb_hash_new();
+            rb_hash_aset(rb_sort_options,
+                         RB_GRN_INTERN("key"),
+                         rb_ary_entry(rb_sort_keys[i], 0));
+            rb_hash_aset(rb_sort_options,
+                         RB_GRN_INTERN("order"),
+                         rb_ary_entry(rb_sort_keys[i], 1));
+        } else {
+            rb_sort_options = rb_hash_new();
+            rb_hash_aset(rb_sort_options,
+                         RB_GRN_INTERN("key"),
+                         rb_sort_keys[i]);
+        }
+        rb_grn_scan_options(rb_sort_options,
+                            "key", &rb_key,
+                            "order", &rb_order,
+                            NULL);
+        if (RVAL2CBOOL(rb_obj_is_kind_of(rb_key, rb_cString))) {
+            rb_resolved_key = rb_grn_table_get_column(self, rb_key);
+        } else {
+            rb_resolved_key = rb_key;
+        }
+        keys[i].key = RVAL2GRNOBJECT(rb_resolved_key, &context);
+        if (!keys[i].key) {
+            rb_raise(rb_eGrnNoSuchColumn,
+                     "no such column: <%s>: <%s>",
+                     rb_grn_inspect(rb_key), rb_grn_inspect(self));
+        }
+        if (NIL_P(rb_order) ||
+            rb_grn_equal_option(rb_order, "asc") ||
+            rb_grn_equal_option(rb_order, "ascending")) {
+            keys[i].flags = GRN_TABLE_SORT_ASC;
+        } else if (rb_grn_equal_option(rb_order, "desc") ||
+                   rb_grn_equal_option(rb_order, "descending")) {
+            keys[i].flags = GRN_TABLE_SORT_DESC;
+        } else {
+            rb_raise(rb_eArgError,
+                     "order should be one of "
+                     "[nil, :desc, :descending, :asc, :ascending]: %s",
+                     rb_grn_inspect(rb_order));
+        }
     }
 
     rb_grn_scan_options(options,
-			"offset", &rb_offset,
-			"limit", &rb_limit,
-			NULL);
+                        "offset", &rb_offset,
+                        "limit", &rb_limit,
+                        NULL);
 
     if (!NIL_P(rb_offset))
-	offset = NUM2INT(rb_offset);
+        offset = NUM2INT(rb_offset);
     if (!NIL_P(rb_limit))
-	limit = NUM2INT(rb_limit);
+        limit = NUM2INT(rb_limit);
 
     result = grn_table_create(context, NULL, 0, NULL, GRN_TABLE_NO_KEY,
-			      NULL, table);
+                              NULL, table);
     /* use n_records that is return value from
        grn_table_sort() when rroonga user become specifying
        output table. */
@@ -1272,71 +1272,71 @@ rb_grn_table_group (int argc, VALUE *argv, VALUE self)
     VALUE rb_results;
 
     rb_grn_table_deconstruct(SELF(self), &table, &context,
-			     NULL, NULL,
-			     NULL, NULL, NULL,
-			     NULL);
+                             NULL, NULL,
+                             NULL, NULL, NULL,
+                             NULL);
 
     rb_scan_args(argc, argv, "11", &rb_keys, &rb_options);
 
     if (TYPE(rb_keys) == T_ARRAY) {
-	n_keys = RARRAY_LEN(rb_keys);
-	rb_group_keys = RARRAY_PTR(rb_keys);
+        n_keys = RARRAY_LEN(rb_keys);
+        rb_group_keys = RARRAY_PTR(rb_keys);
     } else {
-	n_keys = 1;
-	rb_group_keys = &rb_keys;
+        n_keys = 1;
+        rb_group_keys = &rb_keys;
     }
 
     keys = ALLOCA_N(grn_table_sort_key, n_keys);
     for (i = 0; i < n_keys; i++) {
-	VALUE rb_sort_options, rb_key;
-
-	if (RVAL2CBOOL(rb_obj_is_kind_of(rb_group_keys[i], rb_cHash))) {
-	    rb_sort_options = rb_group_keys[i];
-	} else {
-	    rb_sort_options = rb_hash_new();
-	    rb_hash_aset(rb_sort_options,
-			 RB_GRN_INTERN("key"),
-			 rb_group_keys[i]);
-	}
-	rb_grn_scan_options(rb_sort_options,
-			    "key", &rb_key,
-			    NULL);
-	if (RVAL2CBOOL(rb_obj_is_kind_of(rb_key, rb_cString))) {
-	    VALUE resolved_rb_key;
-	    resolved_rb_key = rb_grn_table_get_column(self, rb_key);
-	    if (NIL_P(resolved_rb_key)) {
-		rb_raise(rb_eArgError,
-			 "unknown group key: <%s>: <%s>",
-			 rb_grn_inspect(rb_key),
-			 rb_grn_inspect(self));
-	    }
-	    rb_key = resolved_rb_key;
-	}
-	keys[i].key = RVAL2GRNOBJECT(rb_key, &context);
-	keys[i].flags = 0;
+        VALUE rb_sort_options, rb_key;
+
+        if (RVAL2CBOOL(rb_obj_is_kind_of(rb_group_keys[i], rb_cHash))) {
+            rb_sort_options = rb_group_keys[i];
+        } else {
+            rb_sort_options = rb_hash_new();
+            rb_hash_aset(rb_sort_options,
+                         RB_GRN_INTERN("key"),
+                         rb_group_keys[i]);
+        }
+        rb_grn_scan_options(rb_sort_options,
+                            "key", &rb_key,
+                            NULL);
+        if (RVAL2CBOOL(rb_obj_is_kind_of(rb_key, rb_cString))) {
+            VALUE resolved_rb_key;
+            resolved_rb_key = rb_grn_table_get_column(self, rb_key);
+            if (NIL_P(resolved_rb_key)) {
+                rb_raise(rb_eArgError,
+                         "unknown group key: <%s>: <%s>",
+                         rb_grn_inspect(rb_key),
+                         rb_grn_inspect(self));
+            }
+            rb_key = resolved_rb_key;
+        }
+        keys[i].key = RVAL2GRNOBJECT(rb_key, &context);
+        keys[i].flags = 0;
     }
 
     n_results = n_keys;
     results = ALLOCA_N(grn_table_group_result, n_results);
     rb_results = rb_ary_new();
     for (i = 0; i < n_results; i++) {
-	grn_obj *result;
-	grn_id range_id;
-	VALUE rb_result;
-
-	range_id = grn_obj_get_range(context, keys[i].key);
-	result = grn_table_create(context, NULL, 0, NULL,
-				  GRN_TABLE_HASH_KEY | GRN_OBJ_WITH_SUBREC,
-				  grn_ctx_at(context, range_id), 0);
-	results[i].table = result;
-	results[i].key_begin = 0;
-	results[i].key_end = 0;
-	results[i].limit = 0;
-	results[i].flags = 0;
-	results[i].op = GRN_OP_OR;
-
-	rb_result = GRNOBJECT2RVAL(Qnil, context, result, GRN_TRUE);
-	rb_ary_push(rb_results, rb_result);
+        grn_obj *result;
+        grn_id range_id;
+        VALUE rb_result;
+
+        range_id = grn_obj_get_range(context, keys[i].key);
+        result = grn_table_create(context, NULL, 0, NULL,
+                                  GRN_TABLE_HASH_KEY | GRN_OBJ_WITH_SUBREC,
+                                  grn_ctx_at(context, range_id), 0);
+        results[i].table = result;
+        results[i].key_begin = 0;
+        results[i].key_end = 0;
+        results[i].limit = 0;
+        results[i].flags = 0;
+        results[i].op = GRN_OP_OR;
+
+        rb_result = GRNOBJECT2RVAL(Qnil, context, result, GRN_TRUE);
+        rb_ary_push(rb_results, rb_result);
     }
 
     rc = grn_table_group(context, table, keys, n_keys, results, n_results);
@@ -1344,9 +1344,9 @@ rb_grn_table_group (int argc, VALUE *argv, VALUE self)
     rb_grn_rc_check(rc, self);
 
     if (n_results == 1)
-	return rb_ary_pop(rb_results);
+        return rb_ary_pop(rb_results);
     else
-	return rb_results;
+        return rb_results;
 }
 
 /*
@@ -1361,9 +1361,9 @@ VALUE
 rb_grn_table_array_reference (VALUE self, VALUE rb_id)
 {
     if (FIXNUM_P(rb_id)) {
-	return rb_grn_record_new_raw(self, rb_id, Qnil);
+        return rb_grn_record_new_raw(self, rb_id, Qnil);
     } else {
-	return Qnil;
+        return Qnil;
     }
 }
 
@@ -1377,9 +1377,9 @@ rb_grn_table_get_value (VALUE self, VALUE rb_id)
     grn_obj *value;
 
     rb_grn_table_deconstruct(SELF(self), &table, &context,
-			     NULL, NULL,
-			     &value, NULL, &range,
-			     NULL);
+                             NULL, NULL,
+                             &value, NULL, &range,
+                             NULL);
 
     id = NUM2UINT(rb_id);
     GRN_BULK_REWIND(value);
@@ -1408,16 +1408,16 @@ rb_grn_table_get_value_convenience (int argc, VALUE *argv, VALUE self)
 
     rb_scan_args(argc, argv, "11", &rb_id, &rb_options);
     if (!NIL_P(rb_options)) {
-	VALUE rb_option_id;
-	rb_grn_scan_options(rb_options,
-			    "id", &rb_option_id,
-			    NULL);
-	if (!(NIL_P(rb_option_id) || RVAL2CBOOL(rb_option_id))) {
-	    rb_raise(rb_eArgError, ":id options must be true or nil: %s: %s",
-		     rb_grn_inspect(rb_option_id),
-		     rb_grn_inspect(rb_ary_new3(2,
-						self, rb_ary_new4(argc, argv))));
-	}
+        VALUE rb_option_id;
+        rb_grn_scan_options(rb_options,
+                            "id", &rb_option_id,
+                            NULL);
+        if (!(NIL_P(rb_option_id) || RVAL2CBOOL(rb_option_id))) {
+            rb_raise(rb_eArgError, ":id options must be true or nil: %s: %s",
+                     rb_grn_inspect(rb_option_id),
+                     rb_grn_inspect(rb_ary_new3(2,
+                                                self, rb_ary_new4(argc, argv))));
+        }
     }
 
     return rb_grn_table_get_value(self, rb_id);
@@ -1434,9 +1434,9 @@ rb_grn_table_set_value (VALUE self, VALUE rb_id, VALUE rb_value)
     grn_rc rc;
 
     rb_grn_table_deconstruct(SELF(self), &table, &context,
-			     NULL, NULL,
-			     &value, NULL, &range,
-			     NULL);
+                             NULL, NULL,
+                             &value, NULL, &range,
+                             NULL);
 
     id = NUM2UINT(rb_id);
     GRN_BULK_REWIND(value);
@@ -1466,16 +1466,16 @@ rb_grn_table_set_value_convenience (int argc, VALUE *argv, VALUE self)
 
     rb_scan_args(argc, argv, "21", &rb_id, &rb_value, &rb_options);
     if (!NIL_P(rb_options)) {
-	VALUE rb_option_id;
-	rb_grn_scan_options(rb_options,
-			    "id", &rb_option_id,
-			    NULL);
-	if (!(NIL_P(rb_option_id) || RVAL2CBOOL(rb_option_id))) {
-	    rb_raise(rb_eArgError, ":id options must be true or nil: %s: %s",
-		     rb_grn_inspect(rb_option_id),
-		     rb_grn_inspect(rb_ary_new3(2,
-						self, rb_ary_new4(argc, argv))));
-	}
+        VALUE rb_option_id;
+        rb_grn_scan_options(rb_options,
+                            "id", &rb_option_id,
+                            NULL);
+        if (!(NIL_P(rb_option_id) || RVAL2CBOOL(rb_option_id))) {
+            rb_raise(rb_eArgError, ":id options must be true or nil: %s: %s",
+                     rb_grn_inspect(rb_option_id),
+                     rb_grn_inspect(rb_ary_new3(2,
+                                                self, rb_ary_new4(argc, argv))));
+        }
     }
 
     return rb_grn_table_set_value(self, rb_id, rb_value);
@@ -1517,17 +1517,17 @@ rb_grn_table_get_column_value_convenience (int argc, VALUE *argv, VALUE self)
 
     rb_scan_args(argc, argv, "21", &rb_id, &rb_name, &rb_options);
     if (!NIL_P(rb_options)) {
-	VALUE rb_option_id;
-	rb_grn_scan_options(rb_options,
-			    "id", &rb_option_id,
-			    NULL);
-	if (!(NIL_P(rb_option_id) || RVAL2CBOOL(rb_option_id))) {
-	    rb_raise(rb_eArgError, ":id options must be true or nil: %s: %s",
-		     rb_grn_inspect(rb_option_id),
-		     rb_grn_inspect(rb_ary_new3(2,
-						self,
-						rb_ary_new4(argc, argv))));
-	}
+        VALUE rb_option_id;
+        rb_grn_scan_options(rb_options,
+                            "id", &rb_option_id,
+                            NULL);
+        if (!(NIL_P(rb_option_id) || RVAL2CBOOL(rb_option_id))) {
+            rb_raise(rb_eArgError, ":id options must be true or nil: %s: %s",
+                     rb_grn_inspect(rb_option_id),
+                     rb_grn_inspect(rb_ary_new3(2,
+                                                self,
+                                                rb_ary_new4(argc, argv))));
+        }
     }
 
     return rb_grn_table_get_column_value(self, rb_id, rb_name);
@@ -1535,7 +1535,7 @@ rb_grn_table_get_column_value_convenience (int argc, VALUE *argv, VALUE self)
 
 VALUE
 rb_grn_table_set_column_value_raw (VALUE self, grn_id id,
-				   VALUE rb_name, VALUE rb_value)
+                                   VALUE rb_name, VALUE rb_value)
 {
     VALUE rb_column;
 
@@ -1547,22 +1547,169 @@ rb_grn_table_set_column_value_raw (VALUE self, grn_id id,
 
 VALUE
 rb_grn_table_set_column_value (VALUE self, VALUE rb_id,
-			       VALUE rb_name, VALUE rb_value)
+                               VALUE rb_name, VALUE rb_value)
 {
     return rb_grn_table_set_column_value_raw(self, NUM2INT(rb_id),
-					     rb_name, rb_value);
+                                             rb_name, rb_value);
 }
 
 /*
- * _table_ の _id_ に対応するカラム _name_ の値として _value_ 設定す
- * る。既存の値は上書きされる。
+ * Sets @value@ as the value of column @name@ of the record that has
+ * @id@ ID. It overwrites the previous value.
  *
- * @:id => true@ が指定できるのは利便性のため。
- * {Groonga::Array} でも {Groonga::Hash} や {Groonga::PatriciaTrie} と
- * 同じ引数で動くようになる。
+ * @return [void]
  *
  * @overload set_column_value(id, name, value)
- * @overload set_column_value(id, name, valuf, :id => true)
+ *   @!macro [new] table.set_column_value.base_arguments
+ *     @param id [Integer] The ID of the target record.
+ *     @param name [String or Symbol] The name of the target column.
+ *   @!macro [new] table.set_column_value.value
+ *     @param value [::Object] The new value.
+ *
+ *   @!macro table.set_column_value.base_arguments
+ *   @!macro table.set_column_value.value
+ *
+ * @overload set_column_value(id, name, vector_value_with_weight)
+ *   Sets the vector column value and its weight. Weight is used when fulltext
+ *   search. In fulltext search, score @1@ is added when a record is matched
+ *   against a query. If weight is set, score @1 + weight@ is added when
+ *   a record is matched against a query.
+ *
+ *   @note To use weight, there are two requirements. They are using vector
+ *     column and using index column with weight support. Weight supported
+ *     index column can be created with @:with_weight => true@ option.
+ *     See {#define_index_column}.
+ *
+ *   @example Sets vector value with weight
+ *     Groonga::Schema.define do |schema|
+ *       schema.create_table("Sites") do |table|
+ *         table.short_text("name")
+ *         table.short_text("tags", :type => :vector) # It must be vector
+ *       end
+ *
+ *       schema.create_table("Tags",
+ *                           :type     => :patricia_trie,
+ *                           :key_type => :short_text) do |table|
+ *         table.index("Sites.tags",
+ *                     :with_weight => true) # Don't forget :with_weight => true!
+ *       end
+ *     end
+ *
+ *     sites = Groonga["Sites"]
+ *
+ *     groonga_org_id = sites.add.id
+ *     sites.set_column_value(groonga_org_id,
+ *                            "name",
+ *                            "groonga.org")
+ *     sites.set_column_value(groonga_org_id,
+ *                            "tags",
+ *                            [
+ *                              # 10 weight is set
+ *                              {
+ *                                :value => "groonga",
+ *                                :weight => 10,
+ *                              },
+ *                              # No :weight. The default weight is used.
+ *                              {
+ *                                :value => "search engine",
+ *                              },
+ *                              # Value only. The default weight is used.
+ *                              "fulltext search",
+ *                            ])
+ *
+ *     # "groonga" tag has 10 weight.
+ *     records = sites.select do |record|
+ *       record.tags =~ "groonga"
+ *     end
+ *     p records.collect(&:score) # => [11] (1 + 10 weight)
+ *
+ *     # "search engine" tag has the default weight. (0 weight)
+ *     records = sites.select do |record|
+ *       record.tags =~ "search engine"
+ *     end
+ *     p records.collect(&:score) # => [1] (1 + 0 weight)
+ *
+ *     # "fulltext search" tag has the default weight. (0 weight)
+ *     records = sites.select do |record|
+ *       record.tags =~ "fulltext search"
+ *     end
+ *     p records.collect(&:score) # => [1] (1 + 0 weight)
+ *
+ *   @!macro [new] table.set_column_value.vector_value_with_weight
+ *     @param vector_value_with_weight
+ *       [::Array<::Hash{:value => ::Object, :weight => Integer}, ::Object>]
+ *       The new vector value with weight. The vector value can contain both
+ *       ::Hash and value. If a contained element uses ::Hash style, it can
+ *       specify its weight. If a contained element doesn't use ::Hash style,
+ *       it can't specify its weight.
+ *
+ *       If ::Hash contains @:weight@ key, its value is used as weight for
+ *       @:value@ key's value. If ::Hash contains only @:value@ or @:weight@
+ *       value is nil, the default weight is used. The default weight is 0.
+ *
+ *   @!macro table.set_column_value.base_arguments
+ *   @!macro table.set_column_value.vector_value_with_weight
+ *
+ * @overload set_column_value(id, name, value, options)
+ *   This usage is just for convenience. #set_column_value is overrided
+ *   by {Groonga::Table::KeySupport#set_column_value}.
+ *   {Groonga::Table::KeySupport#set_column_value} accepts not only ID
+ *   but also key value as the first argument. If you specify
+ *   @:id => true@ as @options, you can use both this
+ *   {#set_column_value} method and {Groonga::Table::KeySupport#set_column_value}
+ *   with the same way.
+ *
+ *   @example Uses @:id => true@ for polymorphic usage
+ *     Groonga::Schema.define do |schema|
+ *       schema.create_table("Sites",
+ *                           :type     => :hash,
+ *                           :key_type => :short_text) do |table|
+ *         table.short_text("name")
+ *       end
+ *
+ *       schema.create_table("Logs") do |table|
+ *         table.short_text("content")
+ *       end
+ *     end
+ *
+ *     sites = Groonga["Sites"]
+ *     logs = Groonga["Logs"]
+ *
+ *     groonga_org_key = "http://groonga.org/"
+ *     groonga_org_id = sites.add(groonga_org_key).id
+ *     p sites.class # => Groonga::Hash
+ *     # :id => true is required!
+ *     sites.set_column_value(groonga_org_id,
+ *                            "name",
+ *                            "The official groonga site",
+ *                            :id => true)
+ *     p sites[groonga_org_key].name # => "The official groonga site"
+ *
+ *     log_id = logs.add.id
+ *     p logs.class # => Groonga::Array
+ *     # :id => true is optional. It is just ignored.
+ *     logs.set_column_value(log_id,
+ *                           "content",
+ *                           "127.0.0.1 - - [...]",
+ *                           :id => true)
+ *     p logs[log_id].content # => "127.0.0.1 - - [...]"
+ *
+ *   @!macro [new] table.set_column_value.options
+ *     @param options [::Hash] The options
+ *     @option options [Boolean] :id It is just for convenience.
+ *       Specify @true@ for polymorphic usage.
+ *
+ *   @!macro table.set_column_value.base_arguments
+ *   @!macro table.set_column_value.value
+ *   @!macro table.set_column_value.options
+ *
+ * @overload set_column_value(id, name, vector_value_with_weight, options)
+ *   It is weight supported vector value variable of @:id => true@ option.
+ *   See other signature for usage.
+ *
+ *   @!macro table.set_column_value.base_arguments
+ *   @!macro table.set_column_value.vector_value_with_weight
+ *   @!macro table.set_column_value.options
  */
 static VALUE
 rb_grn_table_set_column_value_convenience (int argc, VALUE *argv, VALUE self)
@@ -1571,17 +1718,17 @@ rb_grn_table_set_column_value_convenience (int argc, VALUE *argv, VALUE self)
 
     rb_scan_args(argc, argv, "31", &rb_id, &rb_name, &rb_value, &rb_options);
     if (!NIL_P(rb_options)) {
-	VALUE rb_option_id;
-	rb_grn_scan_options(rb_options,
-			    "id", &rb_option_id,
-			    NULL);
-	if (!(NIL_P(rb_option_id) || RVAL2CBOOL(rb_option_id))) {
-	    rb_raise(rb_eArgError, ":id options must be true or nil: %s: %s",
-		     rb_grn_inspect(rb_option_id),
-		     rb_grn_inspect(rb_ary_new3(2,
-						self,
-						rb_ary_new4(argc, argv))));
-	}
+        VALUE rb_option_id;
+        rb_grn_scan_options(rb_options,
+                            "id", &rb_option_id,
+                            NULL);
+        if (!(NIL_P(rb_option_id) || RVAL2CBOOL(rb_option_id))) {
+            rb_raise(rb_eArgError, ":id options must be true or nil: %s: %s",
+                     rb_grn_inspect(rb_option_id),
+                     rb_grn_inspect(rb_ary_new3(2,
+                                                self,
+                                                rb_ary_new4(argc, argv))));
+        }
     }
 
     return rb_grn_table_set_column_value(self, rb_id, rb_name, rb_value);
@@ -1609,16 +1756,16 @@ rb_grn_table_unlock (int argc, VALUE *argv, VALUE self)
     rb_scan_args(argc, argv, "01",  &options);
 
     rb_grn_table_deconstruct(SELF(self), &table, &context,
-			     NULL, NULL,
-			     NULL, NULL, NULL,
-			     NULL);
+                             NULL, NULL,
+                             NULL, NULL, NULL,
+                             NULL);
 
     rb_grn_scan_options(options,
-			"id", &rb_id,
-			NULL);
+                        "id", &rb_id,
+                        NULL);
 
     if (!NIL_P(rb_id))
-	id = NUM2UINT(rb_id);
+        id = NUM2UINT(rb_id);
 
     rc = grn_obj_unlock(context, table, id);
     rb_grn_context_check(context, self);
@@ -1674,29 +1821,29 @@ rb_grn_table_lock (int argc, VALUE *argv, VALUE self)
     rb_scan_args(argc, argv, "01",  &options);
 
     rb_grn_table_deconstruct(SELF(self), &table, &context,
-			     NULL, NULL,
-			     NULL, NULL, NULL,
-			     NULL);
+                             NULL, NULL,
+                             NULL, NULL, NULL,
+                             NULL);
 
     rb_grn_scan_options(options,
-			"timeout", &rb_timeout,
-			"id", &rb_id,
-			NULL);
+                        "timeout", &rb_timeout,
+                        "id", &rb_id,
+                        NULL);
 
     if (!NIL_P(rb_timeout))
-	timeout = NUM2UINT(rb_timeout);
+        timeout = NUM2UINT(rb_timeout);
 
     if (!NIL_P(rb_id))
-	id = NUM2UINT(rb_id);
+        id = NUM2UINT(rb_id);
 
     rc = grn_obj_lock(context, table, id, timeout);
     rb_grn_context_check(context, self);
     rb_grn_rc_check(rc, self);
 
     if (rb_block_given_p()) {
-	return rb_ensure(rb_yield, Qnil, rb_grn_table_unlock_ensure, self);
+        return rb_ensure(rb_yield, Qnil, rb_grn_table_unlock_ensure, self);
     } else {
-	return Qnil;
+        return Qnil;
     }
 }
 
@@ -1723,16 +1870,16 @@ rb_grn_table_clear_lock (int argc, VALUE *argv, VALUE self)
     rb_scan_args(argc, argv, "01",  &options);
 
     rb_grn_table_deconstruct(SELF(self), &table, &context,
-			     NULL, NULL,
-			     NULL, NULL, NULL,
-			     NULL);
+                             NULL, NULL,
+                             NULL, NULL, NULL,
+                             NULL);
 
     rb_grn_scan_options(options,
-			"id", &rb_id,
-			NULL);
+                        "id", &rb_id,
+                        NULL);
 
     if (!NIL_P(rb_id))
-	id = NUM2UINT(rb_id);
+        id = NUM2UINT(rb_id);
 
     grn_obj_clear_lock(context, table);
 
@@ -1762,16 +1909,16 @@ rb_grn_table_is_locked (int argc, VALUE *argv, VALUE self)
     rb_scan_args(argc, argv, "01",  &options);
 
     rb_grn_table_deconstruct(SELF(self), &table, &context,
-			     NULL, NULL,
-			     NULL, NULL, NULL,
-			     NULL);
+                             NULL, NULL,
+                             NULL, NULL, NULL,
+                             NULL);
 
     rb_grn_scan_options(options,
-			"id", &rb_id,
-			NULL);
+                        "id", &rb_id,
+                        NULL);
 
     if (!NIL_P(rb_id))
-	id = NUM2UINT(rb_id);
+        id = NUM2UINT(rb_id);
 
     return CBOOL2RVAL(grn_obj_is_locked(context, table));
 }
@@ -1924,48 +2071,48 @@ rb_grn_table_select (int argc, VALUE *argv, VALUE self)
     rb_scan_args(argc, argv, "02", &condition_or_options, &options);
 
     rb_grn_table_deconstruct(SELF(self), &table, &context,
-			     NULL, NULL,
-			     NULL, NULL, NULL,
-			     NULL);
+                             NULL, NULL,
+                             NULL, NULL, NULL,
+                             NULL);
 
     if (RVAL2CBOOL(rb_obj_is_kind_of(condition_or_options, rb_cString))) {
-	rb_query = condition_or_options;
+        rb_query = condition_or_options;
     } else if (RVAL2CBOOL(rb_obj_is_kind_of(condition_or_options,
-					    rb_cGrnExpression))) {
-	rb_expression = condition_or_options;
+                                            rb_cGrnExpression))) {
+        rb_expression = condition_or_options;
     } else {
-	if (!NIL_P(options))
-	    rb_raise(rb_eArgError,
-		     "should be [query_string, option_hash], "
-		     "[expression, opion_hash] "
-		     "or [option_hash]: %s",
-		     rb_grn_inspect(rb_ary_new4(argc, argv)));
-	options = condition_or_options;
+        if (!NIL_P(options))
+            rb_raise(rb_eArgError,
+                     "should be [query_string, option_hash], "
+                     "[expression, opion_hash] "
+                     "or [option_hash]: %s",
+                     rb_grn_inspect(rb_ary_new4(argc, argv)));
+        options = condition_or_options;
     }
 
     rb_grn_scan_options(options,
-			"operator", &rb_operator,
-			"result", &rb_result,
-			"name", &rb_name,
-			"syntax", &rb_syntax,
-			"allow_pragma", &rb_allow_pragma,
-			"allow_column", &rb_allow_column,
-			"allow_update", &rb_allow_update,
-			"allow_leading_not", &rb_allow_leading_not,
-			"default_column", &rb_default_column,
-			NULL);
+                        "operator", &rb_operator,
+                        "result", &rb_result,
+                        "name", &rb_name,
+                        "syntax", &rb_syntax,
+                        "allow_pragma", &rb_allow_pragma,
+                        "allow_column", &rb_allow_column,
+                        "allow_update", &rb_allow_update,
+                        "allow_leading_not", &rb_allow_leading_not,
+                        "default_column", &rb_default_column,
+                        NULL);
 
     if (!NIL_P(rb_operator))
-	operator = NUM2INT(rb_operator);
+        operator = NUM2INT(rb_operator);
 
     if (NIL_P(rb_result)) {
-	result = grn_table_create(context, NULL, 0, NULL,
-				  GRN_TABLE_HASH_KEY | GRN_OBJ_WITH_SUBREC,
-				  table,
-				  NULL);
-	rb_result = GRNTABLE2RVAL(context, result, GRN_TRUE);
+        result = grn_table_create(context, NULL, 0, NULL,
+                                  GRN_TABLE_HASH_KEY | GRN_OBJ_WITH_SUBREC,
+                                  table,
+                                  NULL);
+        rb_result = GRNTABLE2RVAL(context, result, GRN_TRUE);
     } else {
-	result = RVAL2GRNTABLE(rb_result, &context);
+        result = RVAL2GRNTABLE(rb_result, &context);
     }
 
     if (NIL_P(rb_expression)) {
@@ -1981,14 +2128,14 @@ rb_grn_table_select (int argc, VALUE *argv, VALUE self)
     }
     rb_grn_object_deconstruct(RB_GRN_OBJECT(DATA_PTR(rb_expression)),
                               &expression, NULL,
-			      NULL, NULL, NULL, NULL);
+                              NULL, NULL, NULL, NULL);
 
     grn_table_select(context, table, expression, result, operator);
     rb_grn_context_check(context, self);
 
     rb_attr(rb_singleton_class(rb_result),
-	    rb_intern("expression"),
-	    GRN_TRUE, GRN_FALSE, GRN_FALSE);
+            rb_intern("expression"),
+            GRN_TRUE, GRN_FALSE, GRN_FALSE);
     rb_iv_set(rb_result, "@expression", rb_expression);
 
     return rb_result;
@@ -1996,20 +2143,20 @@ rb_grn_table_select (int argc, VALUE *argv, VALUE self)
 
 static VALUE
 rb_grn_table_set_operation_bang (VALUE self, VALUE rb_other,
-				 grn_operator operator)
+                                 grn_operator operator)
 {
     grn_ctx *context;
     grn_obj *table, *other;
     grn_rc rc;
 
     rb_grn_table_deconstruct(SELF(self), &table, &context,
-			     NULL, NULL,
-			     NULL, NULL, NULL,
-			     NULL);
+                             NULL, NULL,
+                             NULL, NULL, NULL,
+                             NULL);
     rb_grn_table_deconstruct(SELF(rb_other), &other, NULL,
-			     NULL, NULL,
-			     NULL, NULL, NULL,
-			     NULL);
+                             NULL, NULL,
+                             NULL, NULL, NULL,
+                             NULL);
 
     rc = grn_table_setoperation(context, table, other, table, operator);
     rb_grn_context_check(context, self);
@@ -2096,9 +2243,9 @@ rb_grn_table_support_sub_records_p (VALUE self)
     grn_obj *table;
 
     rb_grn_table_deconstruct(SELF(self), &table, NULL,
-			     NULL, NULL,
-			     NULL, NULL, NULL,
-			     NULL);
+                             NULL, NULL,
+                             NULL, NULL, NULL,
+                             NULL);
     return CBOOL2RVAL(table->header.flags & GRN_OBJ_WITH_SUBREC);
 }
 
@@ -2118,9 +2265,9 @@ rb_grn_table_exist_p (VALUE self, VALUE id)
     grn_obj *table;
 
     rb_grn_table_deconstruct(SELF(self), &table, &context,
-			     NULL, NULL,
-			     NULL, NULL, NULL,
-			     NULL);
+                             NULL, NULL,
+                             NULL, NULL, NULL,
+                             NULL);
     return CBOOL2RVAL(grn_table_at(context, table, NUM2UINT(id)));
 }
 
@@ -2148,16 +2295,16 @@ rb_grn_table_defrag (int argc, VALUE *argv, VALUE self)
 
     rb_scan_args(argc, argv, "01", &options);
     rb_grn_scan_options(options,
-			"threshold", &rb_threshold,
-			NULL);
+                        "threshold", &rb_threshold,
+                        NULL);
     if (!NIL_P(rb_threshold)) {
-	threshold = NUM2INT(rb_threshold);
+        threshold = NUM2INT(rb_threshold);
     }
 
     rb_grn_table_deconstruct(SELF(self), &table, &context,
-			     NULL, NULL, NULL,
-			     NULL, NULL,
-			     NULL);
+                             NULL, NULL, NULL,
+                             NULL, NULL,
+                             NULL);
     n_segments = grn_obj_defrag(context, table, threshold);
     rb_grn_context_check(context, self);
 
@@ -2181,9 +2328,9 @@ rb_grn_table_rename (VALUE self, VALUE rb_name)
     int name_size;
 
     rb_grn_table_deconstruct(SELF(self), &table, &context,
-			     NULL, NULL, NULL,
-			     NULL, NULL,
-			     NULL);
+                             NULL, NULL, NULL,
+                             NULL, NULL,
+                             NULL);
 
     name = StringValueCStr(rb_name);
     name_size = RSTRING_LEN(rb_name);
@@ -2211,15 +2358,15 @@ rb_grn_init_table (VALUE mGrn)
     rb_define_method(rb_cGrnTable, "inspect", rb_grn_table_inspect, 0);
 
     rb_define_method(rb_cGrnTable, "define_column",
-		     rb_grn_table_define_column, -1);
+                     rb_grn_table_define_column, -1);
     rb_define_method(rb_cGrnTable, "define_index_column",
-		     rb_grn_table_define_index_column, -1);
+                     rb_grn_table_define_index_column, -1);
     rb_define_method(rb_cGrnTable, "column",
-		     rb_grn_table_get_column, 1);
+                     rb_grn_table_get_column, 1);
     rb_define_method(rb_cGrnTable, "columns",
-		     rb_grn_table_get_columns, -1);
+                     rb_grn_table_get_columns, -1);
     rb_define_method(rb_cGrnTable, "have_column?",
-		     rb_grn_table_have_column, 1);
+                     rb_grn_table_have_column, 1);
 
     rb_define_method(rb_cGrnTable, "open_cursor", rb_grn_table_open_cursor, -1);
     rb_define_method(rb_cGrnTable, "records", rb_grn_table_get_records, -1);
@@ -2239,13 +2386,13 @@ rb_grn_init_table (VALUE mGrn)
     rb_undef_method(rb_cGrnTable, "[]=");
 
     rb_define_method(rb_cGrnTable, "value",
-		     rb_grn_table_get_value_convenience, -1);
+                     rb_grn_table_get_value_convenience, -1);
     rb_define_method(rb_cGrnTable, "set_value",
-		     rb_grn_table_set_value_convenience, -1);
+                     rb_grn_table_set_value_convenience, -1);
     rb_define_method(rb_cGrnTable, "column_value",
-		     rb_grn_table_get_column_value_convenience, -1);
+                     rb_grn_table_get_column_value_convenience, -1);
     rb_define_method(rb_cGrnTable, "set_column_value",
-		     rb_grn_table_set_column_value_convenience, -1);
+                     rb_grn_table_set_column_value_convenience, -1);
 
     rb_define_method(rb_cGrnTable, "lock", rb_grn_table_lock, -1);
     rb_define_method(rb_cGrnTable, "unlock", rb_grn_table_unlock, -1);
@@ -2256,16 +2403,16 @@ rb_grn_init_table (VALUE mGrn)
 
     rb_define_method(rb_cGrnTable, "union!", rb_grn_table_union_bang, 1);
     rb_define_method(rb_cGrnTable, "intersection!",
-		     rb_grn_table_intersection_bang, 1);
+                     rb_grn_table_intersection_bang, 1);
     rb_define_method(rb_cGrnTable, "difference!",
-		     rb_grn_table_difference_bang, 1);
+                     rb_grn_table_difference_bang, 1);
     rb_define_method(rb_cGrnTable, "merge!",
-		     rb_grn_table_merge_bang, 1);
+                     rb_grn_table_merge_bang, 1);
 
     rb_define_method(rb_cGrnTable, "support_key?",
-		     rb_grn_table_support_key_p, 0);
+                     rb_grn_table_support_key_p, 0);
     rb_define_method(rb_cGrnTable, "support_sub_records?",
-		     rb_grn_table_support_sub_records_p, 0);
+                     rb_grn_table_support_sub_records_p, 0);
 
     rb_define_method(rb_cGrnTable, "exist?", rb_grn_table_exist_p, 1);