groonga 0.0.7 → 0.9.0

data/ext/rb-grn-type.c

@@ -22,6 +22,15 @@
 
 VALUE rb_cGrnType;
 
+/*
+ * Document-class: Groonga::Type
+ *
+ * groongaのテーブルの主キーや、カラムの値の型のためのオブジェ
+ * クト。型として使用可能なものはgroongaで予め定義済みの型、ユ
+ * ーザが定義する型、またはユーザが定義したテーブル。
+ */
+
+
 grn_obj *
 rb_grn_type_from_ruby_object (VALUE object)
 {
@@ -39,6 +48,30 @@ rb_grn_type_to_ruby_object (grn_ctx *context, grn_obj *type,
     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)
 {
@@ -47,13 +80,13 @@ rb_grn_type_initialize (int argc, VALUE *argv, VALUE self)
     const char *name = NULL;
     unsigned name_size, size = 0;
     grn_obj_flags flags = 0;
-    VALUE rb_name, options, rb_context, rb_option, rb_size;
+    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,
-			"option", &rb_option,
+			"type", &rb_type,
 			"size", &rb_size,
 			NULL);
 
@@ -62,24 +95,24 @@ rb_grn_type_initialize (int argc, VALUE *argv, VALUE self)
 
     context = rb_grn_context_ensure(&rb_context);
 
-    if (NIL_P(rb_option)) {
-    } else if (rb_grn_equal_option(rb_option, "integer") ||
-               rb_grn_equal_option(rb_option, "int")) {
+    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_option, "unsigned_integer") ||
-	       rb_grn_equal_option(rb_option, "uint")) {
+    } 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_option, "float")) {
+    } else if (rb_grn_equal_option(rb_type, "float")) {
 	flags = GRN_OBJ_KEY_FLOAT;
         size = sizeof(double);
-    } else if (rb_grn_equal_option(rb_option, "variable")) {
-        flags = GRN_OBJ_KEY_VAR_SIZE;
     } else {
 	rb_raise(rb_eArgError,
-		 ":option should be one of "
-		 "[:int, :integer, :uint, :unsigned_integer, "
+		 ":type should be one of "
+		 "[:integer, :int, :unsigned_integer, :uint, "
 		 ":float, :variable]: %s",
 		 rb_grn_inspect(options));
     }
@@ -106,21 +139,39 @@ rb_grn_init_type (VALUE mGrn)
 
     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));

data/ext/rb-grn-utils.c

@@ -1,6 +1,7 @@
 /* -*- c-file-style: "ruby" -*- */
+/* vim: set sts=4 sw=4 ts=8 noet: */
 /*
-  Copyright (C) 2009  Kouhei Sutou <kou@clear-code.com>
+  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
@@ -86,8 +87,7 @@ rb_grn_equal_option (VALUE option, const char *key)
 
 static VALUE
 rb_grn_bulk_to_ruby_object_by_range_id (grn_ctx *context, grn_obj *bulk,
-					grn_obj *range, grn_id range_id,
-					VALUE rb_range,
+					grn_id range_id,
 					VALUE related_object, VALUE *rb_value)
 {
     rb_grn_boolean success = RB_GRN_TRUE;
@@ -96,6 +96,9 @@ rb_grn_bulk_to_ruby_object_by_range_id (grn_ctx *context, grn_obj *bulk,
       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;
@@ -139,11 +142,17 @@ rb_grn_bulk_to_ruby_object_by_range_id (grn_ctx *context, grn_obj *bulk,
 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 rb_range,
 					  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:
@@ -152,10 +161,36 @@ rb_grn_bulk_to_ruby_object_by_range_type (grn_ctx *context, grn_obj *bulk,
 	    grn_id id;
 
 	    id = *((grn_id *)GRN_BULK_HEAD(bulk));
-	    if (id == GRN_ID_NIL)
+	    if (id == GRN_ID_NIL) {
 		*rb_value = Qnil;
-	    else
+	    } 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:
@@ -168,29 +203,23 @@ rb_grn_bulk_to_ruby_object_by_range_type (grn_ctx *context, grn_obj *bulk,
 
 VALUE
 rb_grn_bulk_to_ruby_object (grn_ctx *context, grn_obj *bulk,
-			    VALUE related_object)
+			    grn_obj *range, VALUE related_object)
 {
     grn_id range_id;
-    grn_obj *range;
-    VALUE rb_range;
     VALUE rb_value = Qnil;
 
     if (GRN_BULK_EMPTYP(bulk))
 	return Qnil;
 
     range_id = bulk->header.domain;
-    range = grn_ctx_at(context, range_id);
-    rb_range = GRNOBJECT2RVAL(Qnil, context, range, RB_GRN_FALSE);
-
-    if (rb_grn_bulk_to_ruby_object_by_range_id(context, bulk,
-					       range, range_id, rb_range,
-					       related_object, &rb_value))
-	return rb_value;
+    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, rb_range,
-						 related_object, &rb_value))
-	return rb_value;
+    						 range, range_id,
+    						 related_object, &rb_value))
+    	return rb_value;
 
     return rb_grn_context_rb_string_new(context,
 					GRN_BULK_HEAD(bulk),
@@ -200,86 +229,90 @@ rb_grn_bulk_to_ruby_object (grn_ctx *context, grn_obj *bulk,
 grn_obj *
 rb_grn_bulk_from_ruby_object (VALUE object, grn_ctx *context, grn_obj *bulk)
 {
-    const char *string;
-    unsigned int size;
-    int32_t int32_value;
-    int64_t int64_value;
-    int64_t time_value;
-    double double_value;
-    grn_id id_value;
-    grn_obj_flags flags = 0;
-
     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:
-	string = NULL;
-	size = 0;
+	grn_obj_reinit(context, bulk, GRN_DB_VOID, 0);
 	break;
       case T_STRING:
-	string = RSTRING_PTR(object);
-	size = RSTRING_LEN(object);
-	flags |= GRN_OBJ_DO_SHALLOW_COPY;
+	grn_obj_reinit(context, bulk, GRN_DB_TEXT, 0);
+	GRN_TEXT_SET(context, bulk, RSTRING_PTR(object), RSTRING_LEN(object));
 	break;
       case T_FIXNUM:
-	int32_value = NUM2INT(object);
-	string = (const char *)&int32_value;
-	size = sizeof(int32_value);
+	grn_obj_reinit(context, bulk, GRN_DB_INT32, 0);
+	GRN_INT32_SET(context, bulk, NUM2INT(object));
 	break;
       case T_BIGNUM:
-	int64_value = NUM2LL(object);
-        if (int64_value <= INT32_MAX) {
-            int32_value = int64_value;
-            string = (const char *)&int32_value;
-            size = sizeof(int32_value);
-        } else {
-            string = (const char *)&int64_value;
-            size = sizeof(int64_value);
-        }
+	{
+	    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:
-	double_value = NUM2DBL(object);
-	string = (const char *)&double_value;
-	size = sizeof(double_value);
+	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));
-	    string = (const char *)&time_value;
-	    size = sizeof(time_value);
+	    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);
-	    string = (const char *)&id_value;
-	    size = sizeof(id_value);
+	    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));
-	    string = (const char *)&id_value;
-	    size = sizeof(id_value);
+	    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, String, Integer, Float, Time, Groonga::Object]: %s",
+		     "[nil, true, false, String, Integer, Float, Time, "
+		     "Groonga::Object, Groonga::Record]: %s",
 		     rb_grn_inspect(object));
 	}
 	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;
 }
 
@@ -346,6 +379,10 @@ rb_grn_bulk_from_ruby_object_with_type (VALUE object, grn_ctx *context,
                 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));
@@ -395,30 +432,32 @@ rb_grn_bulk_from_ruby_object_with_type (VALUE object, grn_ctx *context,
 }
 
 
-/* FIXME: maybe not work */
 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;
+	const char *_value;
 	unsigned int weight, length;
 	grn_id domain;
 
 	length = grn_vector_get_element(context, vector, i,
-					&value, &weight, &domain);
-	rb_ary_push(array,
-		    rb_ary_new3(2,
-				rb_str_new(value, length), /* FIXME */
-				UINT2NUM(weight)));
+					&_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;
 }
@@ -427,6 +466,7 @@ 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)
@@ -437,19 +477,19 @@ rb_grn_vector_from_ruby_object (VALUE object, grn_ctx *context, grn_obj *vector)
     if (NIL_P(object))
 	return vector;
 
+    GRN_VOID_INIT(&value);
     n = RARRAY_LEN(object);
     values = RARRAY_PTR(object);
     for (i = 0; i < n; i++) {
-	VALUE rb_value;
-	grn_id id;
-	void *grn_value;
-
-	rb_value = values[i];
-	id = NUM2UINT(rb_value);
-	grn_value = &id;
-	grn_vector_add_element(context, vector, grn_value, sizeof(id),
-			       0, GRN_ID_NIL);
+	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;
 }
@@ -476,18 +516,13 @@ rb_grn_uvector_to_ruby_object (grn_ctx *context, grn_obj *uvector)
 
 grn_obj *
 rb_grn_uvector_from_ruby_object (VALUE object, grn_ctx *context,
-				 grn_obj *uvector)
+				 grn_obj *uvector, VALUE related_object)
 {
     VALUE *values;
     int i, n;
 
-    if (uvector)
-	GRN_OBJ_INIT(uvector, GRN_UVECTOR, 0, GRN_ID_NIL);
-    else
-	uvector = grn_obj_open(context, GRN_UVECTOR, 0, 0);
-
     if (NIL_P(object))
-	return uvector;
+	return NULL;
 
     n = RARRAY_LEN(object);
     values = RARRAY_PTR(object);
@@ -497,9 +532,26 @@ rb_grn_uvector_from_ruby_object (VALUE object, grn_ctx *context,
 	void *grn_value;
 
 	value = values[i];
-	id = NUM2UINT(value);
+	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(id));
+	grn_bulk_write(context, uvector, grn_value, sizeof(grn_id));
     }
 
     return uvector;
@@ -523,7 +575,7 @@ rb_grn_value_to_ruby_object (grn_ctx *context,
 	    return Qnil;
 	if (value->header.domain == GRN_ID_NIL && range)
 	    value->header.domain = grn_obj_id(context, range);
-	return GRNBULK2RVAL(context, value, related_object);
+	return GRNBULK2RVAL(context, value, range, related_object);
 	break;
       case GRN_UVECTOR:
 	{
@@ -544,6 +596,9 @@ rb_grn_value_to_ruby_object (grn_ctx *context,
 	    return rb_value;
 	}
 	break;
+      case GRN_VECTOR:
+	return GRNVECTOR2RVAL(context, value);
+	break;
       default:
 	rb_raise(rb_eGrnError,
 		 "unsupported value type: 0x%0x: %s",
@@ -599,11 +654,10 @@ rb_grn_key_to_ruby_object (grn_ctx *context, const void *key, int key_size,
 {
     grn_obj bulk;
 
-    GRN_OBJ_INIT(&bulk, GRN_BULK, GRN_OBJ_DO_SHALLOW_COPY, GRN_ID_NIL);
+    GRN_OBJ_INIT(&bulk, GRN_BULK, GRN_OBJ_DO_SHALLOW_COPY, table->header.domain);
     GRN_TEXT_SET(context, &bulk, key, key_size);
-    bulk.header.domain = table->header.domain;
 
-    return GRNBULK2RVAL(context, &bulk, related_object);
+    return GRNBULK2RVAL(context, &bulk, NULL, related_object);
 }
 
 grn_obj *
@@ -643,75 +697,16 @@ rb_grn_key_from_ruby_object (VALUE rb_key, grn_ctx *context,
 grn_obj *
 rb_grn_obj_from_ruby_object (VALUE rb_object, grn_ctx *context, grn_obj **_obj)
 {
-    grn_obj *obj;
-
-    if (*_obj) {
-	obj = *_obj;
-	grn_obj_close(context, obj); /* FIXME: grn_obj_reinit() */
-    } else {
-	*_obj = grn_obj_open(context, GRN_VOID, 0, GRN_ID_NIL);
-	obj = *_obj;
-    }
-
-    switch (TYPE(rb_object)) {
-      case T_NIL:
-	grn_obj_reinit(context, obj, GRN_DB_VOID, 0);
-	break;
-      case T_STRING:
-	grn_obj_reinit(context, obj, GRN_DB_TEXT, 0);
-	GRN_TEXT_SET(context, obj,
-		     RSTRING_PTR(rb_object), RSTRING_LEN(rb_object));
-	break;
-      case T_FIXNUM:
-	grn_obj_reinit(context, obj, GRN_DB_INT32, 0);
-	GRN_INT32_SET(context, obj, NUM2INT(rb_object));
-	break;
-      case T_BIGNUM:
-	grn_obj_reinit(context, obj, GRN_DB_INT64, 0);
-	GRN_INT64_SET(context, obj, NUM2LL(rb_object));
-	break;
-      case T_FLOAT:
-	grn_obj_reinit(context, obj, GRN_DB_FLOAT, 0);
-	GRN_FLOAT_SET(context, obj, NUM2DBL(rb_object));
-	break;
-      default:
-	if (RVAL2CBOOL(rb_obj_is_kind_of(rb_object, rb_cTime))) {
-	    VALUE sec, usec;
-	    int64_t time_value;
-
-	    sec = rb_funcall(rb_object, rb_intern("to_i"), 0);
-	    usec = rb_funcall(rb_object, rb_intern("usec"), 0);
-	    time_value = GRN_TIME_PACK(NUM2LL(sec), NUM2LL(usec));
-	    grn_obj_reinit(context, obj, GRN_DB_TIME, 0);
-	    GRN_TIME_SET(context, obj, time_value);
-	} else if (RVAL2CBOOL(rb_obj_is_kind_of(rb_object, rb_cGrnObject))) {
-	    grn_obj_close(context, obj); /* TODO: reduce memory allocation */
-	    *_obj = RVAL2GRNOBJECT(rb_object, &context);
-	    obj = *_obj;
-	} else if (RVAL2CBOOL(rb_obj_is_kind_of(rb_object, rb_cGrnRecord))) {
-	    grn_id id, table_id;
-	    VALUE rb_table;
-	    grn_obj *table = NULL;
-
-	    id = NUM2UINT(rb_funcall(rb_object, rb_intern("id"), 0));
-	    rb_table = rb_funcall(rb_object, rb_intern("table"), 0);
-	    rb_grn_table_deconstruct(RB_GRN_TABLE(DATA_PTR(rb_table)),
-				     &table, NULL,
-				     NULL, NULL, NULL, NULL, NULL);
-	    table_id = grn_obj_id(context, table);
-	    grn_obj_reinit(context, obj, table_id, 0);
-	    GRN_RECORD_SET(context, obj, id);
-	} else {
-	    rb_raise(rb_eTypeError,
-		     "should be one of "
-		     "[nil, String, Integer, Float, Time, Groonga::Object, "
-		     "Groonga::Record]: <%s>",
-		     rb_grn_inspect(rb_object));
+    if (RVAL2CBOOL(rb_obj_is_kind_of(rb_object, rb_cGrnObject))) {
+	if (*_obj) {
+	    grn_obj_close(context, *_obj); /* TODO: reduce memory allocation */
 	}
-	break;
+	*_obj = RVAL2GRNOBJECT(rb_object, &context);
+    } else {
+	*_obj = RVAL2GRNBULK(rb_object, context, *_obj);
     }
 
-    return obj;
+    return *_obj;
 }
 
 VALUE
@@ -726,10 +721,13 @@ rb_grn_obj_to_ruby_object (VALUE klass, grn_ctx *context,
 
     switch (obj->header.type) {
       case GRN_VOID:
-	return Qnil;
+	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, related_object);
+	return GRNBULK2RVAL(context, obj, NULL, related_object);
 	break;
       /* case GRN_PTR: */
       /* case GRN_UVECTOR: */