groonga 0.0.5 → 0.0.6

data/ext/rb-grn-table.c

@@ -98,6 +98,9 @@ rb_grn_table_mark (void *data)
     if (!grn_obj_path(context, table))
 	return;
 
+    if (grn_obj_name(context, table, NULL, 0) == 0)
+	return;
+
     column_ids = grn_table_create(context, NULL, 0, NULL,
 				  GRN_TABLE_HASH_KEY, NULL, 0);
     n = grn_table_columns(context, table, NULL, 0, column_ids);
@@ -107,7 +110,7 @@ rb_grn_table_mark (void *data)
     }
 
     cursor = grn_table_cursor_open(context, column_ids, NULL, 0, NULL, 0,
-				   GRN_CURSOR_ASCENDING);
+				   0, 0, GRN_CURSOR_ASCENDING);
     while (grn_table_cursor_next(context, cursor) != GRN_ID_NIL) {
 	void *key;
 	grn_id *column_id;
@@ -136,14 +139,14 @@ rb_grn_table_s_create (int argc, VALUE *argv, VALUE klass,
 		       grn_obj_flags key_store)
 {
     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 = key_store;
     VALUE rb_table;
     VALUE options, rb_context, rb_name, rb_path, rb_persistent;
     VALUE rb_key_normalize, rb_key_with_sis, rb_key_type;
-    VALUE rb_value_size;
+    VALUE rb_value_type;
 
     rb_scan_args(argc, argv, "01", &options);
 
@@ -155,7 +158,7 @@ rb_grn_table_s_create (int argc, VALUE *argv, VALUE klass,
 			"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,
 			NULL);
 
     context = rb_grn_context_ensure(&rb_context);
@@ -186,11 +189,11 @@ rb_grn_table_s_create (int argc, VALUE *argv, VALUE klass,
 	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);
 
     table = grn_table_create(context, name, name_size, path,
-			     flags, key_type, value_size);
+			     flags, key_type, value_type);
     rb_table = rb_grn_object_alloc(klass);
     rb_grn_table_assign(rb_table, rb_context, context, table, RB_GRN_TRUE);
     rb_grn_context_check(context, rb_table);
@@ -362,7 +365,7 @@ rb_grn_table_define_column (int argc, VALUE *argv, VALUE self)
     unsigned name_size = 0;
     grn_obj_flags flags = 0;
     VALUE rb_name, rb_value_type;
-    VALUE options, rb_path, rb_persistent, rb_type;
+    VALUE options, rb_path, rb_persistent, rb_compress, rb_type;
 
     rb_grn_table_deconstruct(SELF(self), &table, &context,
 			     NULL, NULL,
@@ -377,6 +380,7 @@ rb_grn_table_define_column (int argc, VALUE *argv, VALUE self)
 			"path", &rb_path,
 			"persistent", &rb_persistent,
 			"type", &rb_type,
+			"compress", &rb_compress,
 			NULL);
 
     value_type = RVAL2GRNOBJECT(rb_value_type, &context);
@@ -401,6 +405,18 @@ rb_grn_table_define_column (int argc, VALUE *argv, VALUE self)
 		 rb_grn_inspect(rb_type));
     }
 
+    if (NIL_P(rb_compress)) {
+    } else if (rb_grn_equal_option(rb_compress, "zlib")) {
+	flags |= GRN_OBJ_COMPRESS_ZLIB;
+    } else if (rb_grn_equal_option(rb_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));
+    }
+
     column = grn_column_create(context, table, name, name_size,
 			       path, flags, value_type);
     rb_grn_context_check(context, self);
@@ -419,7 +435,7 @@ rb_grn_table_define_index_column (int argc, VALUE *argv, VALUE self)
     grn_obj_flags flags = GRN_OBJ_COLUMN_INDEX;
     VALUE rb_name, rb_value_type;
     VALUE options, rb_path, rb_persistent;
-    VALUE rb_compress, rb_with_section, rb_with_weight, rb_with_position;
+    VALUE rb_with_section, rb_with_weight, rb_with_position;
     VALUE rb_column, rb_source, rb_sources;
 
     rb_grn_table_deconstruct(SELF(self), &table, &context,
@@ -434,7 +450,6 @@ rb_grn_table_define_index_column (int argc, VALUE *argv, VALUE self)
     rb_grn_scan_options(options,
 			"path", &rb_path,
 			"persistent", &rb_persistent,
-			"compress", &rb_compress,
 			"with_section", &rb_with_section,
 			"with_weight", &rb_with_weight,
 			"with_position", &rb_with_position,
@@ -452,18 +467,6 @@ rb_grn_table_define_index_column (int argc, VALUE *argv, VALUE self)
     if (RVAL2CBOOL(rb_persistent))
 	flags |= GRN_OBJ_PERSISTENT;
 
-    if (NIL_P(rb_compress)) {
-    } else if (rb_grn_equal_option(rb_compress, "zlib")) {
-	flags |= GRN_OBJ_COMPRESS_ZLIB;
-    } else if (rb_grn_equal_option(rb_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));
-    }
-
     if (RVAL2CBOOL(rb_with_section))
 	flags |= GRN_OBJ_WITH_SECTION;
 
@@ -551,6 +554,18 @@ rb_grn_table_get_column (VALUE self, VALUE rb_name)
 			     NULL, NULL,
 			     NULL, NULL, NULL);
 
+    switch (TYPE(rb_name)) {
+      case T_SYMBOL:
+	rb_name = rb_str_new2(rb_id2name(SYM2ID(rb_name)));
+	break;
+      case T_STRING:
+	break;
+      default:
+	rb_raise(rb_eArgError,
+		 "column name should be String or Symbol: %s",
+		 rb_grn_inspect(rb_name));
+	break;
+    }
     name = StringValuePtr(rb_name);
     name_size = RSTRING_LEN(rb_name);
 
@@ -598,7 +613,7 @@ rb_grn_table_get_columns (int argc, VALUE *argv, VALUE self)
 	return rb_columns;
 
     cursor = grn_table_cursor_open(context, columns, NULL, 0, NULL, 0,
-				   GRN_CURSOR_ASCENDING);
+				   0, 0, GRN_CURSOR_ASCENDING);
     rb_grn_context_check(context, self);
     while (grn_table_cursor_next(context, cursor) != GRN_ID_NIL) {
 	void *key;
@@ -674,10 +689,11 @@ rb_grn_table_open_grn_cursor (int argc, VALUE *argv, VALUE self,
     if (RVAL2CBOOL(rb_less_than))
 	flags |= GRN_CURSOR_LT;
 
+    /* FIXME: should support offset and limit */
     cursor = grn_table_cursor_open(*context, table,
 				   min_key, min_key_size,
 				   max_key, max_key_size,
-				   flags);
+				   0, 0, flags);
     rb_grn_context_check(*context, self);
 
     return cursor;
@@ -694,8 +710,7 @@ 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_table_cursor_close, rb_cursor);
+	return rb_ensure(rb_yield, rb_cursor, rb_grn_object_close, rb_cursor);
     else
 	return rb_cursor;
 }
@@ -760,14 +775,13 @@ rb_grn_table_each (VALUE self)
     rb_grn_table_deconstruct(SELF(self), &table, &context,
 			     NULL, NULL,
 			     NULL, NULL, NULL);
-    cursor = grn_table_cursor_open(context, table, NULL, 0, NULL, 0, 0);
+    cursor = grn_table_cursor_open(context, table, 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) {
 	rb_yield(rb_grn_record_new(self, id, Qnil));
     }
-    rb_grn_table_cursor_close(rb_cursor);
-    rb_iv_set(self, "cursor", Qnil);
+    rb_grn_object_close(rb_cursor);
 
     return Qnil;
 }
@@ -824,6 +838,14 @@ rb_grn_table_sort (int argc, VALUE *argv, VALUE self)
 
 	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,
@@ -842,9 +864,14 @@ rb_grn_table_sort (int argc, VALUE *argv, VALUE self)
 	} else if (rb_grn_equal_option(rb_order, "desc") ||
 		   rb_grn_equal_option(rb_order, "descending")) {
 	    keys[i].flags = GRN_TABLE_SORT_DESC;
-	} else {
-	    /* FIXME: validation */
+	} else if (rb_grn_equal_option(rb_order, "asc") ||
+		   rb_grn_equal_option(rb_order, "ascending")) {
 	    keys[i].flags = GRN_TABLE_SORT_ASC;
+	} else {
+	    rb_raise(rb_eArgError,
+		     "order should be one of "
+		     "[nil, :desc, :descending, :asc, :ascending]: %s",
+		     rb_grn_inspect(rb_order));
 	}
     }
 
@@ -856,12 +883,12 @@ rb_grn_table_sort (int argc, VALUE *argv, VALUE self)
 	limit = NUM2INT(rb_limit);
 
     result = grn_table_create(context, NULL, 0, NULL, GRN_TABLE_NO_KEY,
-			      table, sizeof(grn_id));
+			      NULL, table);
     n_records = grn_table_sort(context, table, limit, result, keys, n_keys);
 
     rb_result = rb_ary_new();
     cursor = grn_table_cursor_open(context, result, NULL, 0, NULL, 0,
-				   GRN_CURSOR_ASCENDING);
+				   0, 0, GRN_CURSOR_ASCENDING);
     while (grn_table_cursor_next(context, cursor) != GRN_ID_NIL) {
 	void *value;
 	grn_id *id;
@@ -1220,16 +1247,32 @@ rb_grn_table_select (int argc, VALUE *argv, VALUE self)
     grn_obj *table, *result, *expression;
     grn_operator operator = GRN_OP_OR;
     grn_rc rc;
-    VALUE options;
+    VALUE rb_query = Qnil, query_or_options, options;
     VALUE rb_name, rb_operator, rb_result;
     VALUE rb_expression, builder;
 
-    rb_scan_args(argc, argv, "01", &options);
+    rb_scan_args(argc, argv, "02", &query_or_options, &options);
 
     rb_grn_table_deconstruct(SELF(self), &table, &context,
 			     NULL, NULL,
 			     NULL, NULL, NULL);
 
+    if (RVAL2CBOOL(rb_obj_is_kind_of(query_or_options, rb_cString))) {
+	if (rb_block_given_p())
+	    rb_raise(rb_eArgError,
+		     "should not specify both of query string and "
+		     "expression block: %s",
+		     rb_grn_inspect(rb_ary_new4(argc, argv)));
+	rb_query = query_or_options;
+    } else {
+	if (!NIL_P(options))
+	    rb_raise(rb_eArgError,
+		     "should be [query_string, option_hash] "
+		     "or [option_hash]: %s",
+		     rb_grn_inspect(rb_ary_new4(argc, argv)));
+	options = query_or_options;
+    }
+
     rb_grn_scan_options(options,
 			"operator", &rb_operator,
 			"result", &rb_result,
@@ -1249,12 +1292,27 @@ rb_grn_table_select (int argc, VALUE *argv, VALUE self)
 	result = RVAL2GRNTABLE(rb_result, &context);
     }
 
-    builder = rb_grn_record_expression_builder_new(self, rb_name);
-    rb_expression = rb_grn_record_expression_builder_build(builder);
+    if (NIL_P(rb_query)) {
+	builder = rb_grn_record_expression_builder_new(self, rb_name);
+	rb_expression = rb_grn_record_expression_builder_build(builder);
+	rb_grn_object_deconstruct(RB_GRN_OBJECT(DATA_PTR(rb_expression)),
+				  &expression, NULL,
+				  NULL, NULL, NULL, NULL);
+    } else {
+	const char *name = NULL, *query;
+	unsigned name_size = 0, query_size;
+
+	query = StringValueCStr(rb_query);
+	query_size = RSTRING_LEN(rb_query);
+	if (!NIL_P(rb_name)) {
+	    name = StringValueCStr(rb_name);
+	    name_size = RSTRING_LEN(rb_name);
+	}
+	expression = grn_expr_create_from_str(context, name, name_size,
+					      query, query_size,
+					      table, NULL);
+    }
 
-    rb_grn_object_deconstruct(RB_GRN_OBJECT(DATA_PTR(rb_expression)),
-			      &expression, NULL,
-			      NULL, NULL, NULL, NULL);
 
     rc = grn_table_select(context, table, expression, result, operator);
     rb_grn_context_check(context, self);
@@ -1263,6 +1321,52 @@ rb_grn_table_select (int argc, VALUE *argv, VALUE self)
     return rb_result;
 }
 
+static VALUE
+rb_grn_table_set_operation_bang (VALUE self, VALUE rb_other,
+				 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);
+    rb_grn_table_deconstruct(SELF(rb_other), &other, NULL,
+			     NULL, NULL,
+			     NULL, NULL, NULL);
+
+    rc = grn_table_setoperation(context, table, other, table, operator);
+    rb_grn_context_check(context, self);
+    rb_grn_rc_check(rc, self);
+
+    return self;
+}
+
+static VALUE
+rb_grn_table_union_bang (VALUE self, VALUE rb_other)
+{
+    return rb_grn_table_set_operation_bang(self ,rb_other, GRN_OP_OR);
+}
+
+static VALUE
+rb_grn_table_intersection_bang (VALUE self, VALUE rb_other)
+{
+    return rb_grn_table_set_operation_bang(self ,rb_other, GRN_OP_AND);
+}
+
+static VALUE
+rb_grn_table_difference_bang (VALUE self, VALUE rb_other)
+{
+    return rb_grn_table_set_operation_bang(self ,rb_other, GRN_OP_BUT);
+}
+
+static VALUE
+rb_grn_table_merge_bang (VALUE self, VALUE rb_other)
+{
+    return rb_grn_table_set_operation_bang(self ,rb_other, GRN_OP_ADJUST);
+}
+
 void
 rb_grn_init_table (VALUE mGrn)
 {
@@ -1312,6 +1416,14 @@ rb_grn_init_table (VALUE mGrn)
 
     rb_define_method(rb_cGrnTable, "select", rb_grn_table_select, -1);
 
+    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_define_method(rb_cGrnTable, "difference!",
+		     rb_grn_table_difference_bang, 1);
+    rb_define_method(rb_cGrnTable, "merge!",
+		     rb_grn_table_merge_bang, 1);
+
     rb_grn_init_table_key_support(mGrn);
     rb_grn_init_array(mGrn);
     rb_grn_init_hash(mGrn);

data/ext/rb-grn-type.c

@@ -45,15 +45,15 @@ rb_grn_type_initialize (int argc, VALUE *argv, VALUE self)
     grn_ctx *context;
     grn_obj *type;
     const char *name = NULL;
-    unsigned name_size, size = sizeof(grn_id);
+    unsigned name_size, size = 0;
     grn_obj_flags flags = 0;
-    VALUE rb_name, options, rb_context, rb_key_type, rb_size;
+    VALUE rb_name, options, rb_context, rb_option, rb_size;
 
     rb_scan_args(argc, argv, "11", &rb_name, &options);
 
     rb_grn_scan_options(options,
 			"context", &rb_context,
-			"type", &rb_key_type,
+			"option", &rb_option,
 			"size", &rb_size,
 			NULL);
 
@@ -62,22 +62,30 @@ rb_grn_type_initialize (int argc, VALUE *argv, VALUE self)
 
     context = rb_grn_context_ensure(&rb_context);
 
-    if (NIL_P(rb_key_type)) {
-        flags = GRN_OBJ_KEY_VAR_SIZE;
-    } else if (rb_grn_equal_option(rb_key_type, "integer") ||
-               rb_grn_equal_option(rb_key_type, "int")) {
+    if (NIL_P(rb_option)) {
+    } else if (rb_grn_equal_option(rb_option, "integer") ||
+               rb_grn_equal_option(rb_option, "int")) {
 	flags = GRN_OBJ_KEY_INT;
         size = sizeof(int);
-    } else if (rb_grn_equal_option(rb_key_type, "uint")) {
+    } else if (rb_grn_equal_option(rb_option, "unsigned_integer") ||
+	       rb_grn_equal_option(rb_option, "uint")) {
 	flags = GRN_OBJ_KEY_UINT;
         size = sizeof(unsigned int);
-    } else if (rb_grn_equal_option(rb_key_type, "float")) {
+    } else if (rb_grn_equal_option(rb_option, "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, "
+		 ":float, :variable]: %s",
+		 rb_grn_inspect(options));
     }
 
     if (NIL_P(rb_size)) {
-        if (flags == GRN_OBJ_KEY_VAR_SIZE)
+        if (size == 0)
             rb_raise(rb_eArgError, "size is missing: %s",
                      rb_grn_inspect(options));
     } else {

data/ext/rb-grn-utils.c

@@ -110,10 +110,10 @@ rb_grn_bulk_to_ruby_object_by_range_id (grn_ctx *context, grn_obj *bulk,
 	break;
       case GRN_DB_TIME:
 	{
-	    grn_timeval *time_value = (grn_timeval *)GRN_BULK_HEAD(bulk);
+	    int64_t time_value = GRN_TIME_VALUE(bulk);
 	    *rb_value = rb_funcall(rb_cTime, rb_intern("at"), 2,
-				   INT2NUM(time_value->tv_sec),
-				   INT2NUM(time_value->tv_usec));
+				   LL2NUM(time_value / RB_GRN_USEC_PER_SEC),
+				   LL2NUM(time_value % RB_GRN_USEC_PER_SEC));
 	}
 	break;
       case GRN_DB_SHORT_TEXT:
@@ -195,7 +195,7 @@ rb_grn_bulk_from_ruby_object (VALUE object, grn_ctx *context, grn_obj *bulk)
     unsigned int size;
     int32_t int32_value;
     int64_t int64_value;
-    grn_timeval time_value;
+    int64_t time_value;
     double double_value;
     grn_id id_value;
     grn_obj_flags flags = 0;
@@ -231,8 +231,7 @@ rb_grn_bulk_from_ruby_object (VALUE object, grn_ctx *context, grn_obj *bulk)
 
 	    sec = rb_funcall(object, rb_intern("to_i"), 0);
 	    usec = rb_funcall(object, rb_intern("usec"), 0);
-	    time_value.tv_sec = NUM2INT(sec);
-	    time_value.tv_usec = NUM2INT(usec);
+	    time_value = NUM2LL(sec) * RB_GRN_USEC_PER_SEC + NUM2LL(usec);
 	    string = (const char *)&time_value;
 	    size = sizeof(time_value);
 	} else if (RVAL2CBOOL(rb_obj_is_kind_of(object, rb_cGrnObject))) {
@@ -274,7 +273,7 @@ rb_grn_bulk_from_ruby_object_with_type (VALUE object, grn_ctx *context,
     int32_t int32_value;
     uint32_t uint32_value;
     int64_t int64_value;
-    grn_timeval time_value;
+    int64_t time_value;
     double double_value;
     grn_id range;
     VALUE rb_type;
@@ -302,8 +301,13 @@ rb_grn_bulk_from_ruby_object_with_type (VALUE object, grn_ctx *context,
 	size = sizeof(double_value);
 	break;
       case GRN_DB_TIME:
-	time_value.tv_sec = NUM2INT(rb_funcall(object, rb_intern("tv_sec"), 0));
-	time_value.tv_usec = NUM2INT(rb_funcall(object, rb_intern("tv_usec"), 0));
+	{
+	    VALUE sec, usec;
+
+	    sec = rb_funcall(object, rb_intern("to_i"), 0);
+	    usec = rb_funcall(object, rb_intern("usec"), 0);
+	    time_value = NUM2LL(sec) * RB_GRN_USEC_PER_SEC + NUM2LL(usec);
+	}
 	string = (const char *)&time_value;
 	size = sizeof(time_value);
 	break;
@@ -586,36 +590,34 @@ rb_grn_obj_from_ruby_object (VALUE rb_object, grn_ctx *context, grn_obj **_obj)
 
     switch (TYPE(rb_object)) {
       case T_NIL:
-	GRN_VOID_INIT(obj);
+	grn_obj_reinit(context, obj, GRN_DB_VOID, 0);
 	break;
       case T_STRING:
-	GRN_TEXT_INIT(obj, 0);
+	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_INT32_INIT(obj, 0);
+	grn_obj_reinit(context, obj, GRN_DB_INT32, 0);
 	GRN_INT32_SET(context, obj, NUM2INT(rb_object));
 	break;
       case T_BIGNUM:
-	GRN_INT64_INIT(obj, 0);
+	grn_obj_reinit(context, obj, GRN_DB_INT64, 0);
 	GRN_INT64_SET(context, obj, NUM2LL(rb_object));
 	break;
       case T_FLOAT:
-	GRN_FLOAT_INIT(obj, 0);
+	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;
-	    unsigned long long time_value;
+	    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 = NUM2INT(sec);
-	    time_value <<= 32;
-	    time_value += NUM2INT(usec);
-	    GRN_TIME_INIT(obj, 0);
+	    time_value = NUM2LL(sec) * RB_GRN_USEC_PER_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 */
@@ -632,7 +634,7 @@ rb_grn_obj_from_ruby_object (VALUE rb_object, grn_ctx *context, grn_obj **_obj)
 				     &table, NULL,
 				     NULL, NULL, NULL, NULL, NULL);
 	    table_id = grn_obj_id(context, table);
-	    GRN_RECORD_INIT(obj, 0, table_id);
+	    grn_obj_reinit(context, obj, table_id, 0);
 	    GRN_RECORD_SET(context, obj, id);
 	} else {
 	    rb_raise(rb_eTypeError,

data/ext/rb-grn.h

@@ -65,7 +65,7 @@ RB_GRN_BEGIN_DECLS
 
 #define RB_GRN_MAJOR_VERSION 0
 #define RB_GRN_MINOR_VERSION 0
-#define RB_GRN_MICRO_VERSION 5
+#define RB_GRN_MICRO_VERSION 6
 
 typedef int rb_grn_boolean;
 #define RB_GRN_FALSE (0)
@@ -75,10 +75,7 @@ typedef int rb_grn_boolean;
 
 #include <stdint.h>
 
-typedef struct {
-  int32_t tv_sec;
-  int32_t tv_usec;
-} grn_timeval;
+#define RB_GRN_USEC_PER_SEC 1000000
 
 #define RB_GRN_OBJECT(object) ((RbGrnObject *)(object))
 #define RB_GRN_TABLE(object) ((RbGrnTable *)(object))
@@ -91,6 +88,12 @@ typedef struct {
 
 typedef void (*RbGrnUnbindFunction) (void *object);
 
+typedef struct _RbGrnContext RbGrnContext;
+struct _RbGrnContext
+{
+    grn_ctx context;
+};
+
 typedef struct _RbGrnObject RbGrnObject;
 struct _RbGrnObject
 {
@@ -222,12 +225,6 @@ const char    *rb_grn_rc_to_message                 (grn_rc rc);
 void           rb_grn_rc_check                      (grn_rc rc,
 						     VALUE related_object);
 
-void           rb_grn_context_register              (grn_ctx *context,
-						     RbGrnObject *object);
-void           rb_grn_context_unregister            (grn_ctx *context,
-						     RbGrnObject *object);
-void           rb_grn_context_unbind                (grn_ctx *context);
-
 grn_ctx       *rb_grn_context_ensure                (VALUE *context);
 VALUE          rb_grn_context_get_default           (void);
 VALUE          rb_grn_context_to_exception          (grn_ctx *context,
@@ -268,6 +265,7 @@ void           rb_grn_object_deconstruct            (RbGrnObject *rb_grn_object,
 VALUE          rb_grn_object_array_reference        (VALUE object,
 						     VALUE rb_id);
 VALUE          rb_grn_object_close                  (VALUE object);
+VALUE          rb_grn_object_closed_p               (VALUE object);
 VALUE          rb_grn_object_inspect_object         (VALUE inspected,
 						     grn_ctx *context,
 						     grn_obj *object);
@@ -320,7 +318,6 @@ VALUE          rb_grn_table_array_set               (VALUE self,
 
 grn_ctx       *rb_grn_table_cursor_ensure_context   (VALUE cursor,
 						     VALUE *rb_context);
-VALUE          rb_grn_table_cursor_close            (VALUE object);
 
 void           rb_grn_table_key_support_bind        (RbGrnTableKeySupport *rb_grn_table_key_support,
 						     grn_ctx *context,

data/extconf.rb

@@ -36,7 +36,7 @@ package_name = "groonga"
 module_name = "groonga"
 ext_dir_name = "ext"
 src_dir = File.join(File.expand_path(File.dirname(__FILE__)), ext_dir_name)
-major, minor, micro = 0, 1, 0
+major, minor, micro = 0, 1, 1
 
 def local_groonga_base_dir
   File.join(File.dirname(__FILE__), "vendor")

data/html/developer.html

@@ -51,7 +51,7 @@
           Ruby/groongaおよびActiveGroongaを利用したサンプルプログラムもリポジトリにあります。
           サンプルプログラムは以下のようにチェックアウトできます。
         </p>
-        <pre class="command">% svn co http://groonga.rubyforge.org/svn/examples/trunk groonga-examples</pre>
+        <pre class="command">% svn co http://groonga.rubyforge.org/svn/examples groonga-examples</pre>
 
 	<h2>バグ報告・メーリングリスト</h2>
 	<p>

data/html/index.html

@@ -42,7 +42,7 @@
 
 	<h3>Ruby/groongaの最新リリース</h3>
 	<p>
-	  2009-07-19にリリースされた0.0.5が最新です。
+	  2009-07-31にリリースされた0.0.6が最新です。
         </p>
 
 	<h3 id="install-ruby-groonga">Ruby/groongaのインストール</h3>
@@ -79,7 +79,7 @@
 
 	<h3>ActiveGroongaの最新リリース</h3>
 	<p>
-	  2009-06-05にリリースされた0.0.2が最新です。
+	  2009-07-31にリリースされた0.0.6が最新です。
         </p>
 
 	<h3 id="install-active-groonga">ActiveGroongaのインストール</h3>