groonga 0.9.1 → 1.0.0

data/ext/rb-grn-type.c

@@ -1,181 +0,0 @@
-/* -*- c-file-style: "ruby" -*- */
-/*
-  Copyright (C) 2009  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*/
-
-#include "rb-grn.h"
-
-#define SELF(object) (RVAL2GRNTYPE(object))
-
-VALUE rb_cGrnType;
-
-/*
- * Document-class: Groonga::Type
- *
- * groongaのテーブルの主キーや、カラムの値の型のためのオブジェ
- * クト。型として使用可能なものはgroongaで予め定義済みの型、ユ
- * ーザが定義する型、またはユーザが定義したテーブル。
- */
-
-
-grn_obj *
-rb_grn_type_from_ruby_object (VALUE object)
-{
-    if (!RVAL2CBOOL(rb_obj_is_kind_of(object, rb_cGrnType))) {
-	rb_raise(rb_eTypeError, "not a groonga type");
-    }
-
-    return RVAL2GRNOBJECT(object, NULL);
-}
-
-VALUE
-rb_grn_type_to_ruby_object (grn_ctx *context, grn_obj *type,
-			    rb_grn_boolean owner)
-{
-    return GRNOBJECT2RVAL(rb_cGrnType, context, type, owner);
-}
-
-/*
- * call-seq:
- *   Groonga::Type.new(name, options={})
- *
- * 名前が_name_の型を作成する。_options_に指定可能な値は以下の通
- * り。
- *
- * [+:type+]
- *   :integer（符号付き整数）、:int（:integerの省略
- *   形）、:unsigned_integer（符号なし整
- *   数）、:uint（:unsigned_integerの省略形）、:float（浮動小
- *   数点数）、:variable（可変長文字列）のいずれかを指定する。
- *   省略した場合は:variableを指定したものと扱う。
- *
- *   :variableを指定した場合は必ず+:size+を指定しなければいけない。
- *
- * [+:context+]
- *   型の作成時に利用するGroonga::Contextを指定する。省略すると
- *   Groonga::Context.defaultを用いる。
- *
- * [+:size+]
- *   +:option+が:variableの場合は最大長、それ以外の場合は長さを
- *   指定する(単位:byte)。
- */
-static VALUE
-rb_grn_type_initialize (int argc, VALUE *argv, VALUE self)
-{
-    grn_ctx *context;
-    grn_obj *type;
-    const char *name = NULL;
-    unsigned name_size, size = 0;
-    grn_obj_flags flags = 0;
-    VALUE rb_name, options, rb_context, rb_type, rb_size;
-
-    rb_scan_args(argc, argv, "11", &rb_name, &options);
-
-    rb_grn_scan_options(options,
-			"context", &rb_context,
-			"type", &rb_type,
-			"size", &rb_size,
-			NULL);
-
-    name = StringValuePtr(rb_name);
-    name_size = RSTRING_LEN(rb_name);
-
-    context = rb_grn_context_ensure(&rb_context);
-
-    if (NIL_P(rb_type) ||
-	rb_grn_equal_option(rb_type, "variable")) {
-        flags = GRN_OBJ_KEY_VAR_SIZE;
-    } else if (rb_grn_equal_option(rb_type, "integer") ||
-               rb_grn_equal_option(rb_type, "int")) {
-	flags = GRN_OBJ_KEY_INT;
-        size = sizeof(int);
-    } else if (rb_grn_equal_option(rb_type, "unsigned_integer") ||
-	       rb_grn_equal_option(rb_type, "uint")) {
-	flags = GRN_OBJ_KEY_UINT;
-        size = sizeof(unsigned int);
-    } else if (rb_grn_equal_option(rb_type, "float")) {
-	flags = GRN_OBJ_KEY_FLOAT;
-        size = sizeof(double);
-    } else {
-	rb_raise(rb_eArgError,
-		 ":type should be one of "
-		 "[:integer, :int, :unsigned_integer, :uint, "
-		 ":float, :variable]: %s",
-		 rb_grn_inspect(options));
-    }
-
-    if (NIL_P(rb_size)) {
-        if (size == 0)
-            rb_raise(rb_eArgError, "size is missing: %s",
-                     rb_grn_inspect(options));
-    } else {
-        size = NUM2UINT(rb_size);
-    }
-
-    type = grn_type_create(context, name, name_size, flags, size);
-    rb_grn_object_assign(Qnil, self, rb_context, context, type);
-    rb_grn_context_check(context, rb_ary_new4(argc, argv));
-
-    return Qnil;
-}
-
-void
-rb_grn_init_type (VALUE mGrn)
-{
-    rb_cGrnType = rb_define_class_under(mGrn, "Type", rb_cGrnObject);
-
-    rb_define_method(rb_cGrnType, "initialize", rb_grn_type_initialize, -1);
-
-    /* 任意のテーブルに属する全てのレコード(Object型はv1.2で
-       サポートされます)。 */
-    rb_define_const(rb_cGrnType, "OBJECT", INT2NUM(GRN_DB_OBJECT));
-    /* bool型。trueとfalse。 */
-    rb_define_const(rb_cGrnType, "BOOLEAN", INT2NUM(GRN_DB_BOOL));
-    /* bool型。trueとfalse。 */
-    rb_define_const(rb_cGrnType, "BOOL", INT2NUM(GRN_DB_BOOL));
-    /* 8bit符号付き整数。 */
-    rb_define_const(rb_cGrnType, "INT8", INT2NUM(GRN_DB_INT8));
-    /* 8bit符号なし整数。 */
-    rb_define_const(rb_cGrnType, "UINT8", INT2NUM(GRN_DB_UINT8));
-    /* 16bit符号付き整数。 */
-    rb_define_const(rb_cGrnType, "INT16", INT2NUM(GRN_DB_INT16));
-    /* 16bit符号なし整数。 */
-    rb_define_const(rb_cGrnType, "UINT16", INT2NUM(GRN_DB_UINT16));
-    /* 32bit符号付き整数。 */
-    rb_define_const(rb_cGrnType, "INT32", INT2NUM(GRN_DB_INT32));
-    /* 32bit符号なし整数。 */
-    rb_define_const(rb_cGrnType, "UINT32", INT2NUM(GRN_DB_UINT32));
-    /* 64bit符号付き整数。 */
-    rb_define_const(rb_cGrnType, "INT64", INT2NUM(GRN_DB_INT64));
-    /* 64bit符号なし整数。 */
-    rb_define_const(rb_cGrnType, "UINT64", INT2NUM(GRN_DB_UINT64));
-    /* ieee754形式の64bit浮動小数点数。 */
-    rb_define_const(rb_cGrnType, "FLOAT", INT2NUM(GRN_DB_FLOAT));
-    /* 1970年1月1日0時0分0秒からの経過マイクロ秒数を64bit符
-       号付き整数で表現した値。 */
-    rb_define_const(rb_cGrnType, "TIME", INT2NUM(GRN_DB_TIME));
-    /* 4Kbyte以下の文字列。 */
-    rb_define_const(rb_cGrnType, "SHORT_TEXT", INT2NUM(GRN_DB_SHORT_TEXT));
-    /* 64Kbyte以下の文字列。 */
-    rb_define_const(rb_cGrnType, "TEXT", INT2NUM(GRN_DB_TEXT));
-    /* 2Gbyte以下の文字列。 */
-    rb_define_const(rb_cGrnType, "LONG_TEXT", INT2NUM(GRN_DB_LONG_TEXT));
-    rb_define_const(rb_cGrnType, "DELIMIT", INT2NUM(GRN_DB_DELIMIT));
-    rb_define_const(rb_cGrnType, "UNIGRAM", INT2NUM(GRN_DB_UNIGRAM));
-    rb_define_const(rb_cGrnType, "BIGRAM", INT2NUM(GRN_DB_BIGRAM));
-    rb_define_const(rb_cGrnType, "TRIGRAM", INT2NUM(GRN_DB_TRIGRAM));
-    rb_define_const(rb_cGrnType, "MECAB", INT2NUM(GRN_DB_MECAB));
-}

data/ext/rb-grn-utils.c

@@ -1,769 +0,0 @@
-/* -*- c-file-style: "ruby" -*- */
-/* vim: set sts=4 sw=4 ts=8 noet: */
-/*
-  Copyright (C) 2009-2010  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*/
-
-#include "rb-grn.h"
-
-#include <stdarg.h>
-
-const char *
-rb_grn_inspect (VALUE object)
-{
-    VALUE inspected;
-
-    inspected = rb_funcall(object, rb_intern("inspect"), 0);
-    return StringValueCStr(inspected);
-}
-
-void
-rb_grn_scan_options (VALUE options, ...)
-{
-    VALUE available_keys;
-    const char *key;
-    VALUE *value;
-    va_list args;
-
-    if (NIL_P(options))
-        options = rb_hash_new();
-    else
-        options = rb_funcall(options, rb_intern("dup"), 0);
-
-    Check_Type(options, T_HASH);
-
-    available_keys = rb_ary_new();
-    va_start(args, options);
-    key = va_arg(args, const char *);
-    while (key) {
-        VALUE rb_key;
-        value = va_arg(args, VALUE *);
-
-        rb_key = RB_GRN_INTERN(key);
-        rb_ary_push(available_keys, rb_key);
-        *value = rb_funcall(options, rb_intern("delete"), 1, rb_key);
-
-        key = va_arg(args, const char *);
-    }
-    va_end(args);
-
-    if (RVAL2CBOOL(rb_funcall(options, rb_intern("empty?"), 0)))
-        return;
-
-    rb_raise(rb_eArgError,
-             "unexpected key(s) exist: %s: available keys: %s",
-             rb_grn_inspect(rb_funcall(options, rb_intern("keys"), 0)),
-             rb_grn_inspect(available_keys));
-}
-
-rb_grn_boolean
-rb_grn_equal_option (VALUE option, const char *key)
-{
-    VALUE key_string, key_symbol;
-
-    key_string = rb_str_new2(key);
-    if (RVAL2CBOOL(rb_funcall(option, rb_intern("=="), 1, key_string)))
-	return RB_GRN_TRUE;
-
-    key_symbol = rb_str_intern(key_string);
-    if (RVAL2CBOOL(rb_funcall(option, rb_intern("=="), 1, key_symbol)))
-	return RB_GRN_TRUE;
-
-    return RB_GRN_FALSE;
-}
-
-static VALUE
-rb_grn_bulk_to_ruby_object_by_range_id (grn_ctx *context, grn_obj *bulk,
-					grn_id range_id,
-					VALUE related_object, VALUE *rb_value)
-{
-    rb_grn_boolean success = RB_GRN_TRUE;
-
-    switch (range_id) {
-      case GRN_DB_VOID:
-	*rb_value = rb_str_new(GRN_TEXT_VALUE(bulk), GRN_TEXT_LEN(bulk));
-	break;
-      case GRN_DB_BOOL:
-	*rb_value = GRN_BOOL_VALUE(bulk) ? Qtrue : Qfalse;
-	break;
-      case GRN_DB_INT32:
-	*rb_value = INT2NUM(GRN_INT32_VALUE(bulk));
-	break;
-      case GRN_DB_UINT32:
-	*rb_value = UINT2NUM(GRN_UINT32_VALUE(bulk));
-	break;
-      case GRN_DB_INT64:
-	*rb_value = LL2NUM(GRN_INT64_VALUE(bulk));
-	break;
-      case GRN_DB_UINT64:
-	*rb_value = ULL2NUM(GRN_UINT64_VALUE(bulk));
-	break;
-      case GRN_DB_FLOAT:
-	*rb_value = rb_float_new(GRN_FLOAT_VALUE(bulk));
-	break;
-      case GRN_DB_TIME:
-	{
-	    int64_t time_value, sec, usec;
-
-	    time_value = GRN_TIME_VALUE(bulk);
-	    GRN_TIME_UNPACK(time_value, sec, usec);
-	    *rb_value = rb_funcall(rb_cTime, rb_intern("at"), 2,
-				   LL2NUM(sec), LL2NUM(usec));
-	}
-	break;
-      case GRN_DB_SHORT_TEXT:
-      case GRN_DB_TEXT:
-      case GRN_DB_LONG_TEXT:
-	*rb_value = rb_grn_context_rb_string_new(context,
-						 GRN_TEXT_VALUE(bulk),
-						 GRN_TEXT_LEN(bulk));
-	break;
-      default:
-	success = RB_GRN_FALSE;
-	break;
-    }
-
-    return success;
-}
-
-static VALUE
-rb_grn_bulk_to_ruby_object_by_range_type (grn_ctx *context, grn_obj *bulk,
-					  grn_obj *range, grn_id range_id,
-					  VALUE related_object, VALUE *rb_value)
-{
-    rb_grn_boolean success = RB_GRN_TRUE;
-
-    if (!range && range_id != GRN_ID_NIL) {
-	range = grn_ctx_at(context, range_id);
-    }
-
-    if (!range)
-	return RB_GRN_FALSE;
-
-    switch (range->header.type) {
-      case GRN_TABLE_HASH_KEY:
-      case GRN_TABLE_PAT_KEY:
-      case GRN_TABLE_NO_KEY:
-	{
-	    grn_id id;
-
-	    id = *((grn_id *)GRN_BULK_HEAD(bulk));
-	    if (id == GRN_ID_NIL) {
-		*rb_value = Qnil;
-	    } else {
-		VALUE rb_range;
-
-		rb_range = GRNOBJECT2RVAL(Qnil, context, range, RB_GRN_FALSE);
-		*rb_value = rb_grn_record_new(rb_range, id, Qnil);
-	    }
-	}
-	break;
-      case GRN_TYPE:
-	if (range->header.flags & GRN_OBJ_KEY_VAR_SIZE) {
-	    *rb_value = rb_grn_context_rb_string_new(context,
-						     GRN_BULK_HEAD(bulk),
-						     GRN_BULK_VSIZE(bulk));
-	} else {
-	    switch (range->header.flags & GRN_OBJ_KEY_MASK) {
-	      case GRN_OBJ_KEY_UINT:
-		*rb_value = INT2NUM(GRN_UINT32_VALUE(bulk));
-		break;
-	      case GRN_OBJ_KEY_INT:
-		*rb_value = INT2NUM(GRN_INT32_VALUE(bulk));
-		break;
-	      case GRN_OBJ_KEY_FLOAT:
-		*rb_value = rb_float_new(GRN_FLOAT_VALUE(bulk));
-		break;
-	      default:
-		success = RB_GRN_FALSE;
-	    }
-	    break;
-	}
-	break;
-      default:
-	success = RB_GRN_FALSE;
-	break;
-    }
-
-    return success;
-}
-
-VALUE
-rb_grn_bulk_to_ruby_object (grn_ctx *context, grn_obj *bulk,
-			    grn_obj *range, VALUE related_object)
-{
-    grn_id range_id;
-    VALUE rb_value = Qnil;
-
-    if (GRN_BULK_EMPTYP(bulk))
-	return Qnil;
-
-    range_id = bulk->header.domain;
-    if (rb_grn_bulk_to_ruby_object_by_range_id(context, bulk, range_id,
-    					       related_object, &rb_value))
-    	return rb_value;
-
-    if (rb_grn_bulk_to_ruby_object_by_range_type(context, bulk,
-    						 range, range_id,
-    						 related_object, &rb_value))
-    	return rb_value;
-
-    return rb_grn_context_rb_string_new(context,
-					GRN_BULK_HEAD(bulk),
-					GRN_BULK_VSIZE(bulk));
-}
-
-grn_obj *
-rb_grn_bulk_from_ruby_object (VALUE object, grn_ctx *context, grn_obj *bulk)
-{
-    if (bulk && bulk->header.domain == GRN_DB_TIME)
-        return rb_grn_bulk_from_ruby_object_with_type(
-            object, context, bulk, bulk->header.domain,
-            grn_ctx_at(context, bulk->header.domain));
-
-    if (!bulk) {
-	bulk = grn_obj_open(context, GRN_BULK, 0, GRN_ID_NIL);
-	rb_grn_context_check(context, object);
-    }
-
-    switch (TYPE(object)) {
-      case T_NIL:
-	grn_obj_reinit(context, bulk, GRN_DB_VOID, 0);
-	break;
-      case T_STRING:
-	grn_obj_reinit(context, bulk, GRN_DB_TEXT, 0);
-	GRN_TEXT_SET(context, bulk, RSTRING_PTR(object), RSTRING_LEN(object));
-	break;
-      case T_FIXNUM:
-	grn_obj_reinit(context, bulk, GRN_DB_INT32, 0);
-	GRN_INT32_SET(context, bulk, NUM2INT(object));
-	break;
-      case T_BIGNUM:
-	{
-	    int64_t int64_value;
-	    int64_value = NUM2LL(object);
-	    if (int64_value <= INT32_MAX) {
-		grn_obj_reinit(context, bulk, GRN_DB_INT32, 0);
-		GRN_INT32_SET(context, bulk, int64_value);
-	    } else {
-		grn_obj_reinit(context, bulk, GRN_DB_INT64, 0);
-		GRN_INT64_SET(context, bulk, int64_value);
-	    }
-	}
-	break;
-      case T_FLOAT:
-	grn_obj_reinit(context, bulk, GRN_DB_FLOAT, 0);
-	GRN_FLOAT_SET(context, bulk, NUM2DBL(object));
-	break;
-      case T_TRUE:
-	grn_obj_reinit(context, bulk, GRN_DB_BOOL, 0);
-	GRN_BOOL_SET(context, bulk, GRN_TRUE);
-	break;
-      case T_FALSE:
-	grn_obj_reinit(context, bulk, GRN_DB_BOOL, 0);
-	GRN_BOOL_SET(context, bulk, GRN_FALSE);
-	break;
-      default:
-	if (RVAL2CBOOL(rb_obj_is_kind_of(object, rb_cTime))) {
-	    VALUE sec, usec;
-	    int64_t time_value;
-
-	    sec = rb_funcall(object, rb_intern("to_i"), 0);
-	    usec = rb_funcall(object, rb_intern("usec"), 0);
-	    time_value = GRN_TIME_PACK(NUM2LL(sec), NUM2LL(usec));
-	    grn_obj_reinit(context, bulk, GRN_DB_TIME, 0);
-	    GRN_TIME_SET(context, bulk, time_value);
-	} else if (RVAL2CBOOL(rb_obj_is_kind_of(object, rb_cGrnObject))) {
-	    grn_obj *grn_object;
-	    grn_id id_value;
-
-	    grn_object = RVAL2GRNOBJECT(object, &context);
-	    grn_obj_reinit(context, bulk, grn_object->header.domain, 0);
-	    id_value = grn_obj_id(context, grn_object);
-	    GRN_RECORD_SET(context, bulk, id_value);
-	} else if (RVAL2CBOOL(rb_obj_is_kind_of(object, rb_cGrnRecord))) {
-	    grn_obj *table;
-	    grn_id id_value;
-
-	    table = RVAL2GRNOBJECT(rb_funcall(object, rb_intern("table"), 0),
-				   &context);
-	    id_value = NUM2UINT(rb_funcall(object, rb_intern("id"), 0));
-	    grn_obj_reinit(context, bulk, grn_obj_id(context, table), 0);
-	    GRN_RECORD_SET(context, bulk, id_value);
-	} else {
-	    rb_raise(rb_eTypeError,
-		     "bulked object should be one of "
-		     "[nil, true, false, String, Integer, Float, Time, "
-		     "Groonga::Object, Groonga::Record]: %s",
-		     rb_grn_inspect(object));
-	}
-	break;
-    }
-
-    return bulk;
-}
-
-grn_obj *
-rb_grn_bulk_from_ruby_object_with_type (VALUE object, grn_ctx *context,
-					grn_obj *bulk,
-					grn_id type_id, grn_obj *type)
-{
-    const char *string;
-    unsigned int size;
-    int32_t int32_value;
-    uint32_t uint32_value;
-    int64_t int64_value;
-    uint64_t uint64_value;
-    int64_t time_value;
-    double double_value;
-    grn_id range;
-    VALUE rb_type_object;
-    grn_obj_flags flags = 0;
-
-    switch (type_id) {
-      case GRN_DB_INT32:
-	int32_value = NUM2INT(object);
-	string = (const char *)&int32_value;
-	size = sizeof(int32_value);
-	break;
-      case GRN_DB_UINT32:
-	uint32_value = NUM2UINT(object);
-	string = (const char *)&uint32_value;
-	size = sizeof(uint32_value);
-	break;
-      case GRN_DB_INT64:
-	int64_value = NUM2LL(object);
-	string = (const char *)&int64_value;
-	size = sizeof(int64_value);
-	break;
-      case GRN_DB_UINT64:
-	uint64_value = NUM2ULL(object);
-	string = (const char *)&uint64_value;
-	size = sizeof(uint64_value);
-	break;
-      case GRN_DB_FLOAT:
-	double_value = NUM2DBL(object);
-	string = (const char *)&double_value;
-	size = sizeof(double_value);
-	break;
-      case GRN_DB_TIME:
-	{
-	    VALUE rb_sec, rb_usec;
-            int64_t sec;
-            int32_t usec;
-
-            switch (TYPE(object)) {
-            case T_FIXNUM:
-            case T_BIGNUM:
-                sec = NUM2LL(object);
-                usec = 0;
-                break;
-            case T_FLOAT:
-                rb_sec = rb_funcall(object, rb_intern("to_i"), 0);
-                rb_usec = rb_funcall(object, rb_intern("remainder"), 1,
-				     INT2NUM(1));
-
-                sec = NUM2LL(rb_sec);
-                usec = (int32_t)(NUM2DBL(rb_usec) * 1000000);
-                break;
-	    case T_NIL:
-	        sec = 0;
-	        usec = 0;
-	        break;
-            default:
-                sec = NUM2LL(rb_funcall(object, rb_intern("to_i"), 0));
-                usec = NUM2INT(rb_funcall(object, rb_intern("usec"), 0));
-                break;
-            }
-
-	    time_value = GRN_TIME_PACK(sec, usec);
-	}
-	string = (const char *)&time_value;
-	size = sizeof(time_value);
-	break;
-      case GRN_DB_SHORT_TEXT:
-      case GRN_DB_TEXT:
-      case GRN_DB_LONG_TEXT:
-	string = StringValuePtr(object);
-	size = RSTRING_LEN(object);
-	range = grn_obj_get_range(context, type);
-	if (size > range)
-	    rb_raise(rb_eArgError,
-		     "string is too large: expected: %u <= %u",
-		     size, range);
-	flags |= GRN_OBJ_DO_SHALLOW_COPY;
-	break;
-      case GRN_DB_VOID:
-      case GRN_DB_DELIMIT:
-      case GRN_DB_UNIGRAM:
-      case GRN_DB_BIGRAM:
-      case GRN_DB_TRIGRAM:
-      case GRN_DB_MECAB:
-	rb_type_object = GRNOBJECT2RVAL(Qnil, context, type, RB_GRN_FALSE);
-	rb_raise(rb_eArgError,
-		 "unbulkable type: %s",
-		 rb_grn_inspect(rb_type_object));
-	break;
-      default:
-	return RVAL2GRNBULK(object, context, bulk);
-	break;
-    }
-
-    if (!bulk) {
-	bulk = grn_obj_open(context, GRN_BULK, flags, GRN_ID_NIL);
-	rb_grn_context_check(context, object);
-    }
-    GRN_TEXT_SET(context, bulk, string, size);
-
-    return bulk;
-}
-
-
-VALUE
-rb_grn_vector_to_ruby_object (grn_ctx *context, grn_obj *vector)
-{
-    VALUE array;
-    grn_obj value;
-    unsigned int i, n;
-
-    if (!vector)
-	return Qnil;
-
-    GRN_VOID_INIT(&value);
-    n = grn_vector_size(context, vector);
-    array = rb_ary_new2(n);
-    for (i = 0; i < n; i++) {
-	const char *_value;
-	unsigned int weight, length;
-	grn_id domain;
-
-	length = grn_vector_get_element(context, vector, i,
-					&_value, &weight, &domain);
-	grn_obj_reinit(context, &value, domain, 0);
-	grn_bulk_write(context, &value, _value, length);
-	rb_ary_push(array, GRNOBJ2RVAL(Qnil, context, &value, Qnil));
-	/* UINT2NUM(weight); */ /* TODO: How handle weight? */
-    }
-    GRN_OBJ_FIN(context, &value);
-
-    return array;
-}
-
-grn_obj *
-rb_grn_vector_from_ruby_object (VALUE object, grn_ctx *context, grn_obj *vector)
-{
-    VALUE *values;
-    grn_obj value;
-    int i, n;
-
-    if (vector)
-	GRN_OBJ_INIT(vector, GRN_VECTOR, 0, GRN_ID_NIL);
-    else
-	vector = grn_obj_open(context, GRN_VECTOR, 0, 0);
-
-    if (NIL_P(object))
-	return vector;
-
-    GRN_VOID_INIT(&value);
-    n = RARRAY_LEN(object);
-    values = RARRAY_PTR(object);
-    for (i = 0; i < n; i++) {
-	grn_obj *_value = &value;
-	RVAL2GRNOBJ(values[i], context, &_value);
-	grn_vector_add_element(context, vector,
-			       GRN_BULK_HEAD(&value),
-			       GRN_BULK_VSIZE(&value),
-			       0,
-			       value.header.domain);
-    }
-    GRN_OBJ_FIN(context, &value);
-
-    return vector;
-}
-
-VALUE
-rb_grn_uvector_to_ruby_object (grn_ctx *context, grn_obj *uvector)
-{
-    VALUE array;
-    grn_id *current, *end;
-
-    if (!uvector)
-	return Qnil;
-
-    array = rb_ary_new();
-    current = (grn_id *)GRN_BULK_HEAD(uvector);
-    end = (grn_id *)GRN_BULK_CURR(uvector);
-    while (current < end) {
-	rb_ary_push(array, UINT2NUM(*current));
-	current++;
-    }
-
-    return array;
-}
-
-grn_obj *
-rb_grn_uvector_from_ruby_object (VALUE object, grn_ctx *context,
-				 grn_obj *uvector, VALUE related_object)
-{
-    VALUE *values;
-    int i, n;
-
-    if (NIL_P(object))
-	return NULL;
-
-    n = RARRAY_LEN(object);
-    values = RARRAY_PTR(object);
-    for (i = 0; i < n; i++) {
-	VALUE value;
-	grn_id id;
-	void *grn_value;
-
-	value = values[i];
-	switch (TYPE(value)) {
-	  case T_FIXNUM:
-	    id = NUM2UINT(value);
-	    break;
-	  default:
-	    if (RVAL2CBOOL(rb_obj_is_kind_of(value, rb_cGrnRecord))) {
-		id = NUM2UINT(rb_funcall(value, rb_intern("id"), 0));
-	    } else {
-		grn_obj_close(context, uvector);
-		rb_raise(rb_eArgError,
-			 "uvector value should be one of "
-			 "[Fixnum, Groonga::Record]: %s (%s): %s",
-			 rb_grn_inspect(value),
-			 rb_grn_inspect(object),
-			 rb_grn_inspect(related_object));
-	    }
-	    break;
-	}
-	grn_value = &id;
-	grn_bulk_write(context, uvector, grn_value, sizeof(grn_id));
-    }
-
-    return uvector;
-}
-
-VALUE
-rb_grn_value_to_ruby_object (grn_ctx *context,
-			     grn_obj *value,
-			     grn_obj *range,
-			     VALUE related_object)
-{
-    if (!value)
-	return Qnil;
-
-    switch (value->header.type) {
-      case GRN_VOID:
-	return Qnil;
-	break;
-      case GRN_BULK:
-	if (GRN_BULK_EMPTYP(value))
-	    return Qnil;
-	if (value->header.domain == GRN_ID_NIL && range)
-	    value->header.domain = grn_obj_id(context, range);
-	return GRNBULK2RVAL(context, value, range, related_object);
-	break;
-      case GRN_UVECTOR:
-	{
-	    VALUE rb_value, rb_range = Qnil;
-	    grn_id *uvector, *uvector_end;
-
-	    rb_value = rb_ary_new();
-	    if (range)
-		rb_range = GRNTABLE2RVAL(context, range, RB_GRN_FALSE);
-	    uvector = (grn_id *)GRN_BULK_HEAD(value);
-	    uvector_end = (grn_id *)GRN_BULK_CURR(value);
-	    for (; uvector < uvector_end; uvector++) {
-		VALUE record = Qnil;
-		if (*uvector != GRN_ID_NIL)
-		    record = rb_grn_record_new(rb_range, *uvector, Qnil);
-		rb_ary_push(rb_value, record);
-	    }
-	    return rb_value;
-	}
-	break;
-      case GRN_VECTOR:
-	return GRNVECTOR2RVAL(context, value);
-	break;
-      default:
-	rb_raise(rb_eGrnError,
-		 "unsupported value type: 0x%0x: %s",
-		 value->header.type, rb_grn_inspect(related_object));
-	break;
-    }
-
-    if (!range)
-	return GRNOBJECT2RVAL(Qnil, context, value, RB_GRN_FALSE);
-
-    return Qnil;
-}
-
-grn_id
-rb_grn_id_from_ruby_object (VALUE object, grn_ctx *context, grn_obj *table,
-			    VALUE related_object)
-{
-    VALUE rb_id;
-
-    if (NIL_P(object))
-	return Qnil;
-
-    if (RVAL2CBOOL(rb_obj_is_kind_of(object, rb_cGrnRecord))) {
-	VALUE rb_table;
-	rb_table = rb_funcall(object, rb_intern("table"), 0);
-	if (table && RVAL2GRNOBJECT(rb_table, &context) != table) {
-	    VALUE rb_expected_table;
-
-	    rb_expected_table =
-		GRNOBJECT2RVAL(Qnil, context, table, RB_GRN_FALSE);
-	    rb_raise(rb_eGrnError,
-		     "wrong table: expected <%s>: actual <%s>",
-		     rb_grn_inspect(rb_expected_table),
-		     rb_grn_inspect(rb_table));
-	}
-	rb_id = rb_funcall(object, rb_intern("id"), 0);
-    } else {
-	rb_id = object;
-    }
-
-    if (!RVAL2CBOOL(rb_obj_is_kind_of(rb_id, rb_cInteger)))
-	rb_raise(rb_eGrnError,
-		 "should be unsigned integer or Groogna::Record: <%s>: <%s>",
-		 rb_grn_inspect(object),
-		 rb_grn_inspect(related_object));
-
-    return NUM2UINT(rb_id);
-}
-
-VALUE
-rb_grn_key_to_ruby_object (grn_ctx *context, const void *key, int key_size,
-			   grn_obj *table, VALUE related_object)
-{
-    grn_obj bulk;
-
-    GRN_OBJ_INIT(&bulk, GRN_BULK, GRN_OBJ_DO_SHALLOW_COPY, table->header.domain);
-    GRN_TEXT_SET(context, &bulk, key, key_size);
-
-    return GRNBULK2RVAL(context, &bulk, NULL, related_object);
-}
-
-grn_obj *
-rb_grn_key_from_ruby_object (VALUE rb_key, grn_ctx *context,
-			     grn_obj *key, grn_id domain_id, grn_obj *domain,
-			     VALUE related_object)
-{
-    grn_id id;
-
-    if (!domain)
-	return RVAL2GRNBULK(rb_key, context, key);
-
-    switch (domain->header.type) {
-      case GRN_TYPE:
-	return RVAL2GRNBULK_WITH_TYPE(rb_key, context, key, domain_id, domain);
-	break;
-      case GRN_TABLE_HASH_KEY:
-      case GRN_TABLE_PAT_KEY:
-      case GRN_TABLE_NO_KEY:
-	id = RVAL2GRNID(rb_key, context, domain, related_object);
-	break;
-      default:
-	if (!RVAL2CBOOL(rb_obj_is_kind_of(rb_key, rb_cInteger)))
-	    rb_raise(rb_eGrnError,
-		     "should be unsigned integer: <%s>: <%s>",
-		     rb_grn_inspect(rb_key),
-		     rb_grn_inspect(related_object));
-
-	id = NUM2UINT(rb_key);
-	break;
-    }
-
-    GRN_TEXT_SET(context, key, &id, sizeof(id));
-    return key;
-}
-
-grn_obj *
-rb_grn_obj_from_ruby_object (VALUE rb_object, grn_ctx *context, grn_obj **_obj)
-{
-    if (RVAL2CBOOL(rb_obj_is_kind_of(rb_object, rb_cGrnObject))) {
-	if (*_obj) {
-	    grn_obj_close(context, *_obj); /* TODO: reduce memory allocation */
-	}
-	*_obj = RVAL2GRNOBJECT(rb_object, &context);
-    } else {
-	*_obj = RVAL2GRNBULK(rb_object, context, *_obj);
-    }
-
-    return *_obj;
-}
-
-VALUE
-rb_grn_obj_to_ruby_object (VALUE klass, grn_ctx *context,
-			   grn_obj *obj, VALUE related_object)
-{
-    if (!obj)
-	return Qnil;
-
-/*     if (NIL_P(klass)) */
-/* 	klass = GRNOBJECT2RCLASS(obj); */
-
-    switch (obj->header.type) {
-      case GRN_VOID:
-	if (GRN_BULK_VSIZE(obj) > 0)
-	    return rb_str_new(GRN_BULK_HEAD(obj), GRN_BULK_VSIZE(obj));
-	else
-	    return Qnil;
-	break;
-      case GRN_BULK:
-	return GRNBULK2RVAL(context, obj, NULL, related_object);
-	break;
-      /* case GRN_PTR: */
-      /* case GRN_UVECTOR: */
-      /* case GRN_PVECTOR: */
-      /* case GRN_VECTOR: */
-      /* case GRN_MSG: */
-      /* case GRN_QUERY: */
-      /* case GRN_ACCESSOR: */
-      /* case GRN_SNIP: */
-      /* case GRN_PATSNIP: */
-      /* case GRN_CURSOR_TABLE_HASH_KEY: */
-      /* case GRN_CURSOR_TABLE_PAT_KEY: */
-      /* case GRN_CURSOR_TABLE_NO_KEY: */
-      /* case GRN_CURSOR_COLUMN_INDEX: */
-      /* case GRN_TYPE: */
-      /* case GRN_PROC: */
-      /* case GRN_EXPR: */
-      /* case GRN_TABLE_HASH_KEY: */
-      /* case GRN_TABLE_PAT_KEY: */
-      /* case GRN_TABLE_NO_KEY: */
-      /* case GRN_DB: */
-      /* case GRN_COLUMN_FIX_SIZE: */
-      /* case GRN_COLUMN_VAR_SIZE: */
-      /* case GRN_COLUMN_INDEX: */
-      default:
-	rb_raise(rb_eTypeError,
-		 "unsupported groonga object: 0x%x: <%s>",
-		 obj->header.type,
-		 rb_grn_inspect(related_object));
-	break;
-    }
-
-    return Qnil;
-}
-
-void
-rb_grn_init_utils (VALUE mGrn)
-{
-}