groonga 0.0.5 → 0.0.6

data/ext/rb-grn-array.c

@@ -62,8 +62,11 @@ VALUE rb_cGrnArray;
  *   Groonga::Contextに結びついているデータベースが一時デー
  *   タベースの場合は例外が発生する。
  *
- * [+:value_size+]
- *   値の大きさを指定する。省略すると0になる。
+ * [+:value_type+]
+ *   値の型を指定する。省略すると値のための領域を確保しない。
+ *   値を保存したい場合は必ず指定すること。
+ *
+ *   参考: Groonga::Type.new
  *
  * [+:sub_records+]
  *   +true+を指定すると#groupでグループ化したときに、
@@ -91,13 +94,13 @@ static VALUE
 rb_grn_array_s_create (int argc, VALUE *argv, VALUE klass)
 {
     grn_ctx *context = NULL;
-    grn_obj *table;
+    grn_obj *value_type = NULL, *table;
     const char *name = NULL, *path = NULL;
-    unsigned name_size = 0, value_size = 0;
+    unsigned name_size = 0;
     grn_obj_flags flags = GRN_TABLE_NO_KEY;
     VALUE rb_table;
     VALUE options, rb_context, rb_name, rb_path, rb_persistent;
-    VALUE rb_value_size, rb_sub_records;
+    VALUE rb_value_type, rb_sub_records;
 
     rb_scan_args(argc, argv, "01", &options);
 
@@ -106,7 +109,7 @@ rb_grn_array_s_create (int argc, VALUE *argv, VALUE klass)
 			"name", &rb_name,
                         "path", &rb_path,
 			"persistent", &rb_persistent,
-			"value_size", &rb_value_size,
+			"value_type", &rb_value_type,
 			"sub_records", &rb_sub_records,
 			NULL);
 
@@ -126,14 +129,14 @@ rb_grn_array_s_create (int argc, VALUE *argv, VALUE klass)
     if (RVAL2CBOOL(rb_persistent))
 	flags |= GRN_OBJ_PERSISTENT;
 
-    if (!NIL_P(rb_value_size))
-	value_size = NUM2UINT(rb_value_size);
+    if (!NIL_P(rb_value_type))
+	value_type = RVAL2GRNOBJECT(rb_value_type, &context);
 
     if (RVAL2CBOOL(rb_sub_records))
 	flags |= GRN_OBJ_WITH_SUBREC;
 
     table = grn_table_create(context, name, name_size, path,
-			     flags, NULL, value_size);
+			     flags, NULL, value_type);
     if (!table)
 	rb_grn_context_check(context, rb_ary_new4(argc, argv));
     rb_table = GRNOBJECT2RVAL(klass, context, table, RB_GRN_TRUE);

data/ext/rb-grn-column.c

@@ -170,10 +170,14 @@ rb_grn_column_select (int argc, VALUE *argv, VALUE self)
     grn_rc rc;
     VALUE options;
     VALUE rb_query, rb_name, rb_operator, rb_result;
-    VALUE rb_expression, builder;
+    char *name = NULL, *query;
+    unsigned name_size = 0, query_size;
 
     rb_scan_args(argc, argv, "11", &rb_query, &options);
 
+    query = StringValueCStr(rb_query);
+    query_size = RSTRING_LEN(rb_query);
+
     rb_grn_column_deconstruct(SELF(self), &column, &context,
 			      NULL, NULL,
 			      NULL, NULL, NULL);
@@ -185,6 +189,11 @@ rb_grn_column_select (int argc, VALUE *argv, VALUE self)
 			"name", &rb_name,
 			NULL);
 
+    if (!NIL_P(rb_name)) {
+	name = StringValueCStr(rb_name);
+	name_size = RSTRING_LEN(rb_name);
+    }
+
     if (!NIL_P(rb_operator))
 	operator = NUM2INT(rb_operator);
 
@@ -198,13 +207,9 @@ rb_grn_column_select (int argc, VALUE *argv, VALUE self)
 	result = RVAL2GRNTABLE(rb_result, &context);
     }
 
-    builder = rb_grn_column_expression_builder_new(self, rb_name, rb_query);
-    rb_expression = rb_grn_column_expression_builder_build(builder);
-
-    rb_grn_object_deconstruct(RB_GRN_OBJECT(DATA_PTR(rb_expression)),
-			      &expression, NULL,
-			      NULL, NULL, NULL, NULL);
-
+    expression = grn_expr_create_from_str(context, name, name_size,
+					  query, query_size,
+					  table, column);
     rc = grn_table_select(context, table, expression, result, operator);
     rb_grn_context_check(context, self);
     rb_grn_rc_check(rc, self);

data/ext/rb-grn-context.c

@@ -44,23 +44,25 @@ static VALUE cGrnContext;
 grn_ctx *
 rb_grn_context_from_ruby_object (VALUE object)
 {
-    grn_ctx *context;
+    RbGrnContext *rb_grn_context;
 
     if (!RVAL2CBOOL(rb_obj_is_kind_of(object, cGrnContext))) {
 	rb_raise(rb_eTypeError, "not a groonga context");
     }
 
-    Data_Get_Struct(object, grn_ctx, context);
-    if (!context)
+    Data_Get_Struct(object, RbGrnContext, rb_grn_context);
+    if (!rb_grn_context)
 	rb_raise(rb_eGrnError, "groonga context is NULL");
-    return context;
+    return &(rb_grn_context->context);
 }
 
 static void
 rb_grn_context_free (void *pointer)
 {
-    grn_ctx *context = pointer;
+    RbGrnContext *rb_grn_context = pointer;
+    grn_ctx *context;
 
+    context = &(rb_grn_context->context);
     debug("context-free: %p\n", context);
     if (context->stat != GRN_CTX_FIN) {
 	grn_obj *database;
@@ -73,7 +75,9 @@ rb_grn_context_free (void *pointer)
 	grn_ctx_fin(context);
     }
     debug("context-free: %p: done\n", context);
-    xfree(context);
+    xfree(rb_grn_context);
+
+    GRN_CTX_USER_DATA(context)->ptr = NULL;
 }
 
 static VALUE
@@ -226,6 +230,7 @@ rb_grn_context_s_set_default_options (VALUE self, VALUE options)
 static VALUE
 rb_grn_context_initialize (int argc, VALUE *argv, VALUE self)
 {
+    RbGrnContext *rb_grn_context;
     grn_ctx *context;
     int flags = 0;
     grn_rc rc;
@@ -245,11 +250,14 @@ rb_grn_context_initialize (int argc, VALUE *argv, VALUE self)
 			"encoding", &rb_encoding,
 			NULL);
 
-    context = ALLOC(grn_ctx);
-    DATA_PTR(self) = context;
+    rb_grn_context = ALLOC(RbGrnContext);
+    DATA_PTR(self) = rb_grn_context;
+    context = &(rb_grn_context->context);
     rc = grn_ctx_init(context, flags);
     rb_grn_context_check(context, self);
 
+    GRN_CTX_USER_DATA(context)->ptr = rb_grn_context;
+
     if (!NIL_P(rb_encoding)) {
 	grn_encoding encoding;
 
@@ -432,23 +440,33 @@ rb_grn_context_array_reference (VALUE self, VALUE name_or_id)
 {
     grn_ctx *context;
     grn_obj *object;
+    const char *name;
+    unsigned int name_size;
+    grn_id id;
 
     context = SELF(self);
-    if (RVAL2CBOOL(rb_obj_is_kind_of(name_or_id, rb_cString))) {
-	const char *name;
-	unsigned int name_size;
-
+    switch (TYPE(name_or_id)) {
+      case T_SYMBOL:
+	name = rb_id2name(SYM2ID(name_or_id));
+	name_size = strlen(name);
+	object = rb_grn_context_get_backward_compatibility(context,
+							   name, name_size);
+	break;
+      case T_STRING:
 	name = StringValuePtr(name_or_id);
 	name_size = RSTRING_LEN(name_or_id);
 	object = rb_grn_context_get_backward_compatibility(context,
 							   name, name_size);
-    } else if (RVAL2CBOOL(rb_obj_is_kind_of(name_or_id, rb_cInteger))) {
-	unsigned id;
+	break;
+      case T_FIXNUM:
 	id = NUM2UINT(name_or_id);
 	object = grn_ctx_at(context, id);
-    } else {
-	rb_raise(rb_eArgError, "should be string or unsigned integer: %s",
+	break;
+      default:
+	rb_raise(rb_eArgError,
+		 "should be String, Symbol or unsigned integer: %s",
 		 rb_grn_inspect(name_or_id));
+	break;
     }
 
     return GRNOBJECT2RVAL(Qnil, context, object, RB_GRN_FALSE);

data/ext/rb-grn-database.c

@@ -252,7 +252,8 @@ rb_grn_database_each (VALUE self)
 
     rb_grn_database_deconstruct(SELF(self), &database, &context,
 				NULL, NULL, NULL, NULL);
-    cursor = grn_table_cursor_open(context, database, NULL, 0, NULL, 0, 0);
+    cursor = grn_table_cursor_open(context, database, NULL, 0, NULL, 0,
+				   0, 0, GRN_CURSOR_ASCENDING);
     rb_cursor = GRNTABLECURSOR2RVAL(Qnil, context, cursor);
     rb_iv_set(self, "cursor", rb_cursor);
     while ((id = grn_table_cursor_next(context, cursor)) != GRN_ID_NIL) {
@@ -262,7 +263,7 @@ rb_grn_database_each (VALUE self)
 	if (object)
 	    rb_yield(GRNOBJECT2RVAL(Qnil, context, object, RB_GRN_FALSE));
     }
-    rb_grn_table_cursor_close(rb_cursor);
+    rb_grn_object_close(rb_cursor);
     rb_iv_set(self, "cursor", Qnil);
 
     return Qnil;

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

@@ -50,13 +50,19 @@ build_block (VALUE self)
 VALUE
 rb_grn_record_expression_builder_build (VALUE self)
 {
-    return rb_iterate(build, self, build_block, self);
+    if (rb_block_given_p())
+	return rb_iterate(build, self, build_block, self);
+    else
+	return build(self);
 }
 
 VALUE
 rb_grn_column_expression_builder_build (VALUE self)
 {
-    return rb_iterate(build, self, build_block, self);
+    if (rb_block_given_p())
+	return rb_iterate(build, self, build_block, self);
+    else
+	return build(self);
 }
 
 void

data/ext/rb-grn-expression.c

@@ -26,10 +26,10 @@ void
 rb_grn_expression_finalizer (grn_ctx *context, grn_obj *object,
 			     RbGrnExpression *rb_grn_expression)
 {
-    if (!context)
-	return;
+    if (context && rb_grn_expression->value)
+	grn_obj_close(context, rb_grn_expression->value);
 
-    grn_obj_close(context, rb_grn_expression->value);
+    rb_grn_expression->value = NULL;
 }
 
 void

data/ext/rb-grn-hash.c

@@ -80,8 +80,11 @@ VALUE rb_cGrnHash;
  *   省略した場合は文字列をキーとして使用する。この場合、
  *   4096バイトまで使用可能である。
  *
- * [+:value_size+]
- *   値の大きさを指定する。省略すると0になる。
+ * [+:value_type+]
+ *   値の型を指定する。省略すると値のための領域を確保しない。
+ *   値を保存したい場合は必ず指定すること。
+ *
+ *   参考: Groonga::Type.new
  *
  * [+:default_tokenizer+]
  *   Groonga::IndexColumnで使用するトークナイザを指定する。
@@ -142,13 +145,13 @@ static VALUE
 rb_grn_hash_s_create (int argc, VALUE *argv, VALUE self)
 {
     grn_ctx *context;
-    grn_obj *key_type = NULL, *table;
+    grn_obj *key_type = NULL, *value_type = NULL, *table;
     const char *name = NULL, *path = NULL;
-    unsigned name_size = 0, value_size = 0;
+    unsigned name_size = 0;
     grn_obj_flags flags = GRN_TABLE_HASH_KEY;
     VALUE rb_table;
     VALUE options, rb_context, rb_name, rb_path, rb_persistent;
-    VALUE rb_key_type, rb_value_size, rb_default_tokenizer;
+    VALUE rb_key_type, rb_value_type, rb_default_tokenizer;
     VALUE rb_sub_records;
 
     rb_scan_args(argc, argv, "01", &options);
@@ -159,7 +162,7 @@ rb_grn_hash_s_create (int argc, VALUE *argv, VALUE self)
                         "path", &rb_path,
 			"persistent", &rb_persistent,
 			"key_type", &rb_key_type,
-			"value_size", &rb_value_size,
+			"value_type", &rb_value_type,
 			"default_tokenizer", &rb_default_tokenizer,
 			"sub_records", &rb_sub_records,
 			NULL);
@@ -186,14 +189,14 @@ rb_grn_hash_s_create (int argc, VALUE *argv, VALUE self)
 	key_type = RVAL2GRNOBJECT(rb_key_type, &context);
     }
 
-    if (!NIL_P(rb_value_size))
-	value_size = NUM2UINT(rb_value_size);
+    if (!NIL_P(rb_value_type))
+	value_type = RVAL2GRNOBJECT(rb_value_type, &context);
 
-    if (RVAL2CBOOL(rb_sub_records)) 
+    if (RVAL2CBOOL(rb_sub_records))
 	flags |= GRN_OBJ_WITH_SUBREC;
 
     table = grn_table_create(context, name, name_size, path,
-			     flags, key_type, value_size);
+			     flags, key_type, value_type);
     if (!table)
 	rb_grn_context_check(context, rb_ary_new4(argc, argv));
     rb_table = rb_grn_object_alloc(self);

data/ext/rb-grn-object.c

@@ -83,7 +83,6 @@ rb_grn_object_finalizer (grn_ctx *context, grn_obj *grn_object,
 			 grn_user_data *user_data)
 {
     RbGrnObject *rb_grn_object;
-    rb_grn_boolean need_finalize = RB_GRN_TRUE;
 
     rb_grn_object = user_data->ptr;
 
@@ -95,19 +94,9 @@ rb_grn_object_finalizer (grn_ctx *context, grn_obj *grn_object,
 	   rb_grn_object->context, rb_grn_object->object,
 	   grn_object->header.type);
 
-    if (rb_grn_object->context != context ||
-	rb_grn_object->object != grn_object) {
-	if (grn_object->header.type == GRN_DB)
-	    grn_ctx_use(context, NULL);
-	need_finalize = RB_GRN_FALSE;
-    }
-
     rb_grn_object->context = NULL;
     rb_grn_object->object = NULL;
 
-    if (!need_finalize)
-	return GRN_SUCCESS;
-
     switch (grn_object->header.type) {
       case GRN_DB:
 	grn_ctx_use(context, NULL);
@@ -115,6 +104,9 @@ rb_grn_object_finalizer (grn_ctx *context, grn_obj *grn_object,
       case GRN_TYPE:
       case GRN_ACCESSOR:
       case GRN_PROC:
+      case GRN_CURSOR_TABLE_HASH_KEY:
+      case GRN_CURSOR_TABLE_PAT_KEY:
+      case GRN_CURSOR_TABLE_NO_KEY:
 	break;
       case GRN_TABLE_HASH_KEY:
       case GRN_TABLE_PAT_KEY:
@@ -140,7 +132,7 @@ rb_grn_object_finalizer (grn_ctx *context, grn_obj *grn_object,
 	break;
       default:
 	rb_raise(rb_eTypeError,
-		 "unsupported groonga object type: 0x%x",
+		 "unsupported groonga object type for finalizer: 0x%x",
 		 grn_object->header.type);
 	break;
     }
@@ -161,8 +153,9 @@ rb_grn_object_free (RbGrnObject *rb_grn_object)
 	rb_grn_object->context = NULL;
 	rb_grn_object->object = NULL;
 	debug("type: %x\n", grn_object->header.type);
-	if (rb_grn_object->need_close)
+	if (rb_grn_object->need_close) {
 	    grn_obj_close(context, grn_object);
+	}
     }
     xfree(rb_grn_object);
 }
@@ -217,7 +210,7 @@ rb_grn_object_to_ruby_class (grn_obj *object)
 	break;
       default:
 	rb_raise(rb_eTypeError,
-		 "unsupported groonga object type: 0x%x",
+		 "unsupported groonga object type for class detection: 0x%x",
 		 object->header.type);
 	break;
     }
@@ -266,17 +259,20 @@ rb_grn_object_bind_common (VALUE klass, VALUE self, VALUE rb_context,
     rb_grn_object->need_close = RB_GRN_TRUE;
     switch (object->header.type) {
       case GRN_DB:
+      case GRN_CURSOR_TABLE_HASH_KEY:
+      case GRN_CURSOR_TABLE_PAT_KEY:
+      case GRN_CURSOR_TABLE_NO_KEY:
       case GRN_TABLE_HASH_KEY:
       case GRN_TABLE_PAT_KEY:
       case GRN_TABLE_NO_KEY:
       case GRN_COLUMN_FIX_SIZE:
       case GRN_COLUMN_VAR_SIZE:
       case GRN_COLUMN_INDEX:
+      case GRN_EXPR:
 	grn_obj_user_data(context, object)->ptr = rb_grn_object;
 	grn_obj_set_finalizer(context, object, rb_grn_object_finalizer);
 	break;
       case GRN_PROC:
-      case GRN_EXPR:
       case GRN_TYPE:
 	rb_grn_object->need_close = RB_GRN_FALSE;
 	break;
@@ -320,10 +316,10 @@ rb_grn_object_assign (VALUE klass, VALUE self, VALUE rb_context,
 
     if (klass == rb_cGrnDatabase ||
 	(RVAL2CBOOL(rb_obj_is_kind_of(self, rb_cGrnType))) ||
-	klass == rb_cGrnAccessor ||
 	klass == rb_cGrnHashCursor ||
 	klass == rb_cGrnPatriciaTrieCursor ||
 	klass == rb_cGrnArrayCursor ||
+	klass == rb_cGrnAccessor ||
 	klass == rb_cGrnProcedure ||
 	klass == rb_cGrnVariable) {
 	rb_grn_object = ALLOC(RbGrnObject);
@@ -359,7 +355,7 @@ rb_grn_object_assign (VALUE klass, VALUE self, VALUE rb_context,
 			       context, object);
     } else {
 	rb_raise(rb_eTypeError,
-		 "unsupported groonga object type: 0x%x",
+		 "unsupported groonga object type for assignment: 0x%x",
 		 object->header.type);
     }
 
@@ -424,7 +420,7 @@ rb_grn_object_close (VALUE self)
  * _object_が開放済みの場合は+true+を返し、そうでない場合は
  * +false+を返す。
  */
-static VALUE
+VALUE
 rb_grn_object_closed_p (VALUE self)
 {
     grn_obj *object;
@@ -536,7 +532,11 @@ rb_grn_object_inspect_content_domain (VALUE inspected,
 
 	domain_object = grn_ctx_at(context, domain);
 	if (domain_object) {
-	    rb_grn_object_inspect_object(inspected, context, domain_object);
+	    if (domain_object == object) {
+		rb_str_cat2(inspected, "self");
+	    } else {
+		rb_grn_object_inspect_object(inspected, context, domain_object);
+	    }
 	} else {
 	    rb_str_concat(inspected, rb_obj_as_string(UINT2NUM(domain)));
 	}
@@ -579,6 +579,112 @@ rb_grn_object_inspect_content_range (VALUE inspected,
     return inspected;
 }
 
+static VALUE
+rb_grn_object_inspect_content_flags (VALUE inspected,
+				     grn_ctx *context, grn_obj *object)
+{
+    grn_obj_flags flags;
+    VALUE inspected_flags;
+
+    rb_str_cat2(inspected, "flags: ");
+
+    flags = object->header.flags;
+
+    inspected_flags = rb_ary_new();
+
+    if (0) {
+	if (flags & GRN_OBJ_TABLE_HASH_KEY)
+	    rb_ary_push(inspected_flags, rb_str_new2("TABLE_HASH_KEY"));
+	if (flags & GRN_OBJ_TABLE_PAT_KEY)
+	    rb_ary_push(inspected_flags, rb_str_new2("TABLE_PAT_KEY"));
+	if (flags & GRN_OBJ_TABLE_NO_KEY)
+	    rb_ary_push(inspected_flags, rb_str_new2("TABLE_NO_KEY"));
+	if (flags & GRN_OBJ_TABLE_ALIAS)
+	    rb_ary_push(inspected_flags, rb_str_new2("TABLE_ALIAS"));
+    }
+
+    switch (object->header.type) {
+      case GRN_COLUMN_FIX_SIZE:
+      case GRN_COLUMN_VAR_SIZE:
+      case GRN_TYPE:
+	if (flags & GRN_OBJ_KEY_UINT)
+	    rb_ary_push(inspected_flags, rb_str_new2("KEY_UINT"));
+	if (flags & GRN_OBJ_KEY_INT)
+	    rb_ary_push(inspected_flags, rb_str_new2("KEY_INT"));
+	if (flags & GRN_OBJ_KEY_FLOAT)
+	    rb_ary_push(inspected_flags, rb_str_new2("KEY_FLOAT"));
+	break;
+      default:
+	break;
+    }
+
+    switch (object->header.type) {
+      case GRN_TABLE_HASH_KEY:
+      case GRN_TABLE_PAT_KEY:
+	if (flags & GRN_OBJ_KEY_WITH_SIS)
+	    rb_ary_push(inspected_flags, rb_str_new2("KEY_WITH_SIS"));
+	if (flags & GRN_OBJ_KEY_NORMALIZE)
+	    rb_ary_push(inspected_flags, rb_str_new2("KEY_NORMALIZE"));
+	break;
+      default:
+	break;
+    }
+
+    if (0) {
+	if (flags & GRN_OBJ_COLUMN_SCALAR)
+	    rb_ary_push(inspected_flags, rb_str_new2("COLUMN_SCALAR"));
+	if (flags & GRN_OBJ_COLUMN_VECTOR)
+	    rb_ary_push(inspected_flags, rb_str_new2("COLUMN_VECTOR"));
+	if (flags & GRN_OBJ_COLUMN_INDEX)
+	    rb_ary_push(inspected_flags, rb_str_new2("COLUMN_INDEX"));
+    }
+
+    switch (object->header.type) {
+      case GRN_COLUMN_FIX_SIZE:
+      case GRN_COLUMN_VAR_SIZE:
+	if (flags & GRN_OBJ_COMPRESS_ZLIB)
+	    rb_ary_push(inspected_flags, rb_str_new2("COMPRESS_ZLIB"));
+	if (flags & GRN_OBJ_COMPRESS_LZO)
+	    rb_ary_push(inspected_flags, rb_str_new2("COMPRESS_LZO"));
+	break;
+      default:
+	break;
+    }
+
+    if (flags & GRN_OBJ_WITH_SECTION)
+	rb_ary_push(inspected_flags, rb_str_new2("WITH_SECTION"));
+    if (flags & GRN_OBJ_WITH_WEIGHT)
+	rb_ary_push(inspected_flags, rb_str_new2("WITH_WEIGHT"));
+    if (flags & GRN_OBJ_WITH_POSITION)
+	rb_ary_push(inspected_flags, rb_str_new2("WITH_POSITION"));
+    if (flags & GRN_OBJ_WITH_BUFFER)
+	rb_ary_push(inspected_flags, rb_str_new2("WITH_BUFFER"));
+
+    if (flags & GRN_OBJ_UNIT_DOCUMENT_SECTION)
+	rb_ary_push(inspected_flags, rb_str_new2("UNIT_DOCUMENT_SECTION"));
+    if (flags & GRN_OBJ_UNIT_DOCUMENT_POSITION)
+	rb_ary_push(inspected_flags, rb_str_new2("UNIT_DOCUMENT_POSITION"));
+
+    if (flags & GRN_OBJ_UNIT_SECTION_POSITION)
+	rb_ary_push(inspected_flags, rb_str_new2("UNIT_SECTION_POSITION"));
+
+    if (flags & GRN_OBJ_UNIT_USERDEF_DOCUMENT)
+	rb_ary_push(inspected_flags, rb_str_new2("UNIT_USERDEF_DOCUMENT"));
+    if (flags & GRN_OBJ_UNIT_USERDEF_SECTION)
+	rb_ary_push(inspected_flags, rb_str_new2("UNIT_USERDEF_SECTION"));
+    if (flags & GRN_OBJ_UNIT_USERDEF_POSITION)
+	rb_ary_push(inspected_flags, rb_str_new2("UNIT_USERDEF_POSITION"));
+
+    if (flags & GRN_OBJ_WITH_SUBREC)
+	rb_ary_push(inspected_flags, rb_str_new2("WITH_SUBREC"));
+
+    rb_str_cat2(inspected, "<");
+    rb_str_concat(inspected, rb_ary_join(inspected_flags, rb_str_new2("|")));
+    rb_str_cat2(inspected, ">");
+
+    return inspected;
+}
+
 VALUE
 rb_grn_object_inspect_object_content (VALUE inspected,
 				      grn_ctx *context, grn_obj *object)
@@ -592,6 +698,8 @@ rb_grn_object_inspect_object_content (VALUE inspected,
     rb_grn_object_inspect_content_domain(inspected, context, object);
     rb_str_cat2(inspected, ", ");
     rb_grn_object_inspect_content_range(inspected, context, object);
+    rb_str_cat2(inspected, ", ");
+    rb_grn_object_inspect_content_flags(inspected, context, object);
 
     return inspected;
 }

data/ext/rb-grn-patricia-trie.c

@@ -26,13 +26,14 @@ static VALUE
 rb_grn_patricia_trie_s_create (int argc, VALUE *argv, VALUE self)
 {
     grn_ctx *context;
-    grn_obj *key_type = NULL, *table;
+    grn_obj *key_type = NULL, *value_type = NULL, *table;
     const char *name = NULL, *path = NULL;
-    unsigned name_size = 0, value_size = 0;
+    unsigned name_size = 0;
     grn_obj_flags flags = GRN_TABLE_PAT_KEY;
     VALUE rb_table;
     VALUE options, rb_context, rb_name, rb_path, rb_persistent;
-    VALUE rb_key_normalize, rb_key_with_sis, rb_key_type, rb_value_size;
+    VALUE rb_key_normalize, rb_key_with_sis, rb_key_type;
+    VALUE rb_value_type;
     VALUE rb_default_tokenizer, rb_sub_records;
 
     rb_scan_args(argc, argv, "01", &options);
@@ -45,7 +46,7 @@ rb_grn_patricia_trie_s_create (int argc, VALUE *argv, VALUE self)
 			"key_normalize", &rb_key_normalize,
 			"key_with_sis", &rb_key_with_sis,
 			"key_type", &rb_key_type,
-			"value_size", &rb_value_size,
+			"value_type", &rb_value_type,
 			"default_tokenizer", &rb_default_tokenizer,
 			"sub_records", &rb_sub_records,
 			NULL);
@@ -78,14 +79,14 @@ rb_grn_patricia_trie_s_create (int argc, VALUE *argv, VALUE self)
 	key_type = RVAL2GRNOBJECT(rb_key_type, &context);
     }
 
-    if (!NIL_P(rb_value_size))
-	value_size = NUM2UINT(rb_value_size);
+    if (!NIL_P(rb_value_type))
+	value_type = RVAL2GRNOBJECT(rb_value_type, &context);
 
     if (RVAL2CBOOL(rb_sub_records))
 	flags |= GRN_OBJ_WITH_SUBREC;
 
     table = grn_table_create(context, name, name_size, path,
-			     flags, key_type, value_size);
+			     flags, key_type, value_type);
     if (!table)
 	rb_grn_context_check(context, rb_ary_new4(argc, argv));
     rb_table = rb_grn_object_alloc(self);

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

@@ -57,44 +57,6 @@ rb_grn_table_cursor_deconstruct (RbGrnTableCursor *rb_grn_table_cursor,
 			      range_id, range);
 }
 
-VALUE
-rb_grn_table_cursor_close (VALUE self)
-{
-    RbGrnTableCursor *rb_grn_table_cursor;
-    grn_table_cursor *cursor;
-    grn_ctx *context;
-
-    rb_grn_table_cursor = SELF(self);
-    rb_grn_table_cursor_deconstruct(rb_grn_table_cursor, &cursor, &context,
-				    NULL, NULL, NULL, NULL);
-
-    if (context && cursor) {
-	RbGrnObject *rb_grn_object;
-
-	rb_grn_object = RB_GRN_OBJECT(rb_grn_table_cursor);
-        grn_obj_close(context, cursor);
-	rb_grn_object->context = NULL;
-	rb_grn_object->object = NULL;
-    }
-
-    return Qnil;
-}
-
-static VALUE
-rb_grn_table_cursor_closed_p (VALUE self)
-{
-    grn_table_cursor *cursor;
-    grn_ctx *context;
-
-    rb_grn_table_cursor_deconstruct(SELF(self), &cursor, &context,
-				    NULL, NULL, NULL, NULL);
-
-    if (context && cursor)
-        return Qfalse;
-    else
-        return Qtrue;
-}
-
 static VALUE
 rb_grn_table_cursor_get_value (VALUE self)
 {
@@ -204,9 +166,9 @@ rb_grn_init_table_cursor (VALUE mGrn)
     rb_include_module(rb_cGrnTableCursor, rb_mEnumerable);
 
     rb_define_method(rb_cGrnTableCursor, "close",
-                     rb_grn_table_cursor_close, 0);
+                     rb_grn_object_close, 0);
     rb_define_method(rb_cGrnTableCursor, "closed?",
-                     rb_grn_table_cursor_closed_p, 0);
+                     rb_grn_object_closed_p, 0);
 
     rb_define_method(rb_cGrnTableCursor, "value",
                      rb_grn_table_cursor_get_value, 0);