groonga 0.0.2 → 0.0.3

data/ext/rb-grn-hash.c

@@ -89,6 +89,11 @@ VALUE rb_cGrnHash;
  *   Groonga::IndexColumnを定義する場合は
  *   <tt>"<token:bigram>"</tt>などを指定する必要がある。
  *
+ * [+:sub_records+]
+ *   +true+を指定すると#groupでグループ化したときに、
+ *   <tt>record[".:nsubrecs"]</tt>でグループに含まれるレコー
+ *   ドの件数を取得できる。
+ *
  * 使用例:
  *
  * 無名一時テーブルを生成する。
@@ -144,6 +149,7 @@ rb_grn_hash_s_create (int argc, VALUE *argv, VALUE self)
     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_sub_records;
 
     rb_scan_args(argc, argv, "01", &options);
 
@@ -155,6 +161,7 @@ rb_grn_hash_s_create (int argc, VALUE *argv, VALUE self)
 			"key_type", &rb_key_type,
 			"value_size", &rb_value_size,
 			"default_tokenizer", &rb_default_tokenizer,
+			"sub_records", &rb_sub_records,
 			NULL);
 
     context = rb_grn_context_ensure(&rb_context);
@@ -162,6 +169,7 @@ rb_grn_hash_s_create (int argc, VALUE *argv, VALUE self)
     if (!NIL_P(rb_name)) {
         name = StringValuePtr(rb_name);
 	name_size = RSTRING_LEN(rb_name);
+	flags |= GRN_OBJ_PERSISTENT;
     }
 
     if (!NIL_P(rb_path)) {
@@ -181,13 +189,15 @@ rb_grn_hash_s_create (int argc, VALUE *argv, VALUE self)
     if (!NIL_P(rb_value_size))
 	value_size = NUM2UINT(rb_value_size);
 
+    if (RVAL2CBOOL(rb_sub_records)) 
+	flags |= GRN_OBJ_WITH_SUBREC;
+
     table = grn_table_create(context, name, name_size, path,
 			     flags, key_type, value_size);
     if (!table)
 	rb_grn_context_check(context, rb_ary_new4(argc, argv));
-    rb_table = rb_grn_table_key_support_alloc(self);
-    rb_grn_table_key_support_assign(rb_table, rb_context, context, table,
-				    RB_GRN_TRUE);
+    rb_table = rb_grn_object_alloc(self);
+    rb_grn_object_assign(Qnil, rb_table, rb_context, context, table);
     rb_grn_context_check(context, rb_table);
 
     if (!NIL_P(rb_default_tokenizer))
@@ -261,7 +271,7 @@ rb_grn_hash_search (int argc, VALUE *argv, VALUE self)
     }
 
     rc = grn_obj_search(context, table, key,
-			result, GRN_SEL_OR, NULL);
+			result, GRN_OP_OR, NULL);
     rb_grn_rc_check(rc, self);
 
     return rb_result;
@@ -271,7 +281,6 @@ void
 rb_grn_init_hash (VALUE mGrn)
 {
     rb_cGrnHash = rb_define_class_under(mGrn, "Hash", rb_cGrnTable);
-    rb_define_alloc_func(rb_cGrnHash, rb_grn_table_key_support_alloc);
 
     rb_include_module(rb_cGrnHash, rb_mGrnTableKeySupport);
 

data/ext/rb-grn-index-column.c

@@ -33,52 +33,28 @@ VALUE rb_cGrnIndexColumn;
  */
 
 void
-rb_grn_index_column_unbind (RbGrnIndexColumn *rb_grn_index_column)
+rb_grn_index_column_finalizer (grn_ctx *context, grn_obj *object,
+			       RbGrnIndexColumn *rb_grn_index_column)
 {
-    RbGrnObject *rb_grn_object;
-    grn_ctx *context;
-
-    rb_grn_object = RB_GRN_OBJECT(rb_grn_index_column);
-    context = rb_grn_object->context;
-
-    if (context) {
-	grn_obj_close(context, rb_grn_index_column->id_query);
-	grn_obj_close(context, rb_grn_index_column->string_query);
-	grn_obj_close(context, rb_grn_index_column->value);
-	grn_obj_close(context, rb_grn_index_column->old_value);
-    }
-
-    rb_grn_object_unbind(rb_grn_object);
-}
-
-static void
-rb_grn_index_column_free (void *object)
-{
-    RbGrnIndexColumn *rb_grn_index_column = object;
+    if (!context)
+	return;
 
-    rb_grn_index_column_unbind(rb_grn_index_column);
-    xfree(rb_grn_index_column);
-}
+    grn_obj_close(context, rb_grn_index_column->id_query);
+    grn_obj_close(context, rb_grn_index_column->string_query);
+    grn_obj_close(context, rb_grn_index_column->old_value);
 
-VALUE
-rb_grn_index_column_alloc (VALUE klass)
-{
-    return Data_Wrap_Struct(klass, NULL, rb_grn_index_column_free, NULL);
+    rb_grn_column_finalizer(context, object, RB_GRN_COLUMN(rb_grn_index_column));
 }
 
 void
 rb_grn_index_column_bind (RbGrnIndexColumn *rb_grn_index_column,
-			  grn_ctx *context, grn_obj *column,
-			  rb_grn_boolean owner)
+			  grn_ctx *context, grn_obj *column)
 {
     RbGrnObject *rb_grn_object;
 
+    rb_grn_column_bind(RB_GRN_COLUMN(rb_grn_index_column), context, column);
     rb_grn_object = RB_GRN_OBJECT(rb_grn_index_column);
-    rb_grn_object_bind(rb_grn_object, context, column, owner);
-    rb_grn_object->unbind = RB_GRN_UNBIND_FUNCTION(rb_grn_index_column_unbind);
 
-    rb_grn_index_column->value = grn_obj_open(context, GRN_BULK, 0,
-					      rb_grn_object->range_id);
     rb_grn_index_column->old_value = grn_obj_open(context, GRN_BULK, 0,
 						  rb_grn_object->range_id);
 
@@ -89,20 +65,6 @@ rb_grn_index_column_bind (RbGrnIndexColumn *rb_grn_index_column,
 						     GRN_ID_NIL);
 }
 
-void
-rb_grn_index_column_assign (VALUE self, VALUE rb_context,
-			    grn_ctx *context, grn_obj *column,
-			    rb_grn_boolean owner)
-{
-    RbGrnIndexColumn *rb_grn_index_column;
-
-    rb_grn_index_column = ALLOC(RbGrnIndexColumn);
-    DATA_PTR(self) = rb_grn_index_column;
-    rb_grn_index_column_bind(rb_grn_index_column, context, column, owner);
-
-    rb_iv_set(self, "context", rb_context);
-}
-
 void
 rb_grn_index_column_deconstruct (RbGrnIndexColumn *rb_grn_index_column,
 				 grn_obj **column,
@@ -119,12 +81,10 @@ rb_grn_index_column_deconstruct (RbGrnIndexColumn *rb_grn_index_column,
     RbGrnObject *rb_grn_object;
 
     rb_grn_object = RB_GRN_OBJECT(rb_grn_index_column);
-    rb_grn_object_deconstruct(rb_grn_object, column, context,
-			      domain_id, domain,
+    rb_grn_column_deconstruct(RB_GRN_COLUMN(rb_grn_object), column, context,
+			      domain_id, domain, value,
 			      range_id, range);
 
-    if (value)
-	*value = rb_grn_index_column->value;
     if (old_value)
 	*old_value = rb_grn_index_column->old_value;
     if (id_query)
@@ -402,7 +362,7 @@ rb_grn_index_column_search (int argc, VALUE *argv, VALUE self)
     grn_obj *range;
     grn_obj *query = NULL, *id_query = NULL, *string_query = NULL;
     grn_obj *result;
-    grn_sel_operator operator;
+    grn_operator operator;
     grn_rc rc;
     VALUE rb_query, options, rb_result, rb_operator;
 
@@ -444,7 +404,7 @@ rb_grn_index_column_search (int argc, VALUE *argv, VALUE self)
 	result = RVAL2GRNOBJECT(rb_result, &context);
     }
 
-    operator = RVAL2GRNSELECTOPERATOR(rb_operator);
+    operator = RVAL2GRNOPERATOR(rb_operator);
 
     rc = grn_obj_search(context, column, query, result, operator, NULL);
     rb_grn_rc_check(rc, self);
@@ -457,7 +417,6 @@ rb_grn_init_index_column (VALUE mGrn)
 {
     rb_cGrnIndexColumn =
 	rb_define_class_under(mGrn, "IndexColumn", rb_cGrnColumn);
-    rb_define_alloc_func(rb_cGrnIndexColumn, rb_grn_index_column_alloc);
 
     rb_define_method(rb_cGrnIndexColumn, "[]=",
 		     rb_grn_index_column_array_set, 2);

data/ext/rb-grn-object.c

@@ -41,9 +41,14 @@ rb_grn_object_from_ruby_object (VALUE object, grn_ctx **context)
     if (context && *context) {
 	grn_obj *grn_object;
 	if (RVAL2CBOOL(rb_obj_is_kind_of(object, rb_cString))) {
-	    grn_object = grn_ctx_get(*context,
-                                     StringValuePtr(object),
-                                     RSTRING_LEN(object));
+	    const char *name;
+	    unsigned int name_size;
+
+	    name = StringValuePtr(object);
+	    name_size = RSTRING_LEN(object);
+	    grn_object = rb_grn_context_get_backward_compatibility(*context,
+								   name,
+								   name_size);
 	    if (!grn_object)
 		rb_raise(rb_eArgError,
 			 "unregistered groonga object: name: <%s>",
@@ -73,44 +78,92 @@ rb_grn_object_from_ruby_object (VALUE object, grn_ctx **context)
     return rb_grn_object->object;
 }
 
-void
-rb_grn_object_unbind (RbGrnObject *rb_grn_object)
+grn_rc
+rb_grn_object_finalizer (grn_ctx *context, grn_obj *grn_object,
+			 grn_user_data *user_data)
 {
-    grn_ctx *context;
-    grn_obj *grn_object;
+    RbGrnObject *rb_grn_object;
+    rb_grn_boolean need_finalize = RB_GRN_TRUE;
 
-    context = rb_grn_object->context;
-    grn_object = rb_grn_object->object;
+    rb_grn_object = user_data->ptr;
 
-    if (context)
-	rb_grn_context_unregister(context, rb_grn_object);
+    grn_obj_user_data(context, grn_object)->ptr = NULL;
+    grn_obj_set_finalizer(context, grn_object, NULL);
 
-    if (rb_grn_object->owner && context && grn_object) {
-	const char *path;
-	grn_obj *db = NULL;
+    debug("finalize %p:%p:%p:%p:%p %x\n",
+	   context, grn_object, rb_grn_object,
+	   rb_grn_object->context, rb_grn_object->object,
+	   grn_object->header.type);
 
-	path = grn_obj_path(context, grn_object);
-	db = grn_ctx_db(context);
-	if (path == NULL || (path && db)) {
-	    if (grn_object == db) {
-		rb_grn_context_unbind(context);
-	    } else {
-		grn_obj_close(context, grn_object);
-	    }
-	}
+    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;
-    rb_grn_object->owner = RB_GRN_FALSE;
+
+    if (!need_finalize)
+	return GRN_SUCCESS;
+
+    switch (grn_object->header.type) {
+      case GRN_DB:
+	grn_ctx_use(context, NULL);
+	break;
+      case GRN_TYPE:
+      case GRN_ACCESSOR:
+      case GRN_PROC:
+	break;
+      case GRN_TABLE_HASH_KEY:
+      case GRN_TABLE_PAT_KEY:
+	rb_grn_table_key_support_finalizer(context, grn_object,
+					   RB_GRN_TABLE_KEY_SUPPORT(rb_grn_object));
+	break;
+      case GRN_TABLE_NO_KEY:
+	rb_grn_table_finalizer(context, grn_object,
+			       RB_GRN_TABLE(rb_grn_object));
+	break;
+      case GRN_COLUMN_FIX_SIZE:
+      case GRN_COLUMN_VAR_SIZE:
+	rb_grn_column_finalizer(context, grn_object,
+				RB_GRN_COLUMN(rb_grn_object));
+	break;
+      case GRN_COLUMN_INDEX:
+	rb_grn_index_column_finalizer(context, grn_object,
+				      RB_GRN_INDEX_COLUMN(rb_grn_object));
+	break;
+      case GRN_EXPR:
+	rb_grn_expression_finalizer(context, grn_object,
+				    RB_GRN_EXPRESSION(rb_grn_object));
+	break;
+      default:
+	rb_raise(rb_eTypeError,
+		 "unsupported groonga object type: 0x%x",
+		 grn_object->header.type);
+	break;
+    }
+
+    return GRN_SUCCESS;
 }
 
-static void
-rb_grn_object_free (void *object)
+void
+rb_grn_object_free (RbGrnObject *rb_grn_object)
 {
-    RbGrnObject *rb_grn_object = object;
+    grn_ctx *context;
+    grn_obj *grn_object;
 
-    rb_grn_object->unbind(rb_grn_object);
+    context = rb_grn_object->context;
+    grn_object = rb_grn_object->object;
+    debug("rb-free: %p:%p:%p\n", context, grn_object, rb_grn_object);
+    if (context && 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)
+	    grn_obj_close(context, grn_object);
+    }
     xfree(rb_grn_object);
 }
 
@@ -145,14 +198,26 @@ rb_grn_object_to_ruby_class (grn_obj *object)
 	klass = rb_cGrnFixSizeColumn;
 	break;
       case GRN_COLUMN_VAR_SIZE:
-	klass = rb_cGrnVarSizeColumn;
+	klass = rb_cGrnVariableSizeColumn;
 	break;
       case GRN_COLUMN_INDEX:
 	klass = rb_cGrnIndexColumn;
 	break;
+      case GRN_EXPR:
+	klass = rb_cGrnExpression;
+	break;
+      case GRN_CURSOR_TABLE_HASH_KEY:
+	klass = rb_cGrnHashCursor;
+	break;
+      case GRN_CURSOR_TABLE_PAT_KEY:
+	klass = rb_cGrnPatriciaTrieCursor;
+	break;
+      case GRN_CURSOR_TABLE_NO_KEY:
+	klass = rb_cGrnArrayCursor;
+	break;
       default:
 	rb_raise(rb_eTypeError,
-		 "unsupported groonga object type: %d",
+		 "unsupported groonga object type: 0x%x",
 		 object->header.type);
 	break;
     }
@@ -165,30 +230,20 @@ rb_grn_object_to_ruby_object (VALUE klass, grn_ctx *context, grn_obj *object,
 			      rb_grn_boolean owner)
 {
     VALUE rb_object;
+    grn_user_data *user_data;
 
     if (!object)
         return Qnil;
 
+    user_data = grn_obj_user_data(context, object);
+    if (user_data && user_data->ptr)
+	return RB_GRN_OBJECT(user_data->ptr)->self;
+
     if (NIL_P(klass))
         klass = GRNOBJECT2RCLASS(object);
 
-    if (klass == rb_cGrnHash ||
-	klass == rb_cGrnPatriciaTrie) {
-	rb_object = rb_grn_table_key_support_alloc(klass);
-	rb_grn_table_key_support_assign(rb_object, Qnil, context, object, owner);
-    } else if (klass == rb_cGrnArray) {
-	rb_object = rb_grn_table_alloc(klass);
-	rb_grn_table_assign(rb_object, Qnil, context, object, owner);
-    } else if (klass == rb_cGrnFixSizeColumn) {
-	rb_object = rb_grn_fix_size_column_alloc(klass);
-	rb_grn_fix_size_column_assign(rb_object, Qnil, context, object, owner);
-    } else if (klass == rb_cGrnIndexColumn) {
-	rb_object = rb_grn_index_column_alloc(klass);
-	rb_grn_index_column_assign(rb_object, Qnil, context, object, owner);
-    } else {
-	rb_object = rb_grn_object_alloc(klass);
-	rb_grn_object_assign(rb_object, Qnil, context, object, owner);
-    }
+    rb_object = rb_obj_alloc(klass);
+    rb_grn_object_assign(klass, rb_object, Qnil, context, object);
 
     return rb_object;
 }
@@ -199,10 +254,38 @@ rb_grn_object_alloc (VALUE klass)
     return Data_Wrap_Struct(klass, NULL, rb_grn_object_free, NULL);
 }
 
-void
-rb_grn_object_bind (RbGrnObject *rb_grn_object,
-		    grn_ctx *context, grn_obj *object, rb_grn_boolean owner)
+static void
+rb_grn_object_bind_common (VALUE klass, VALUE self, VALUE rb_context,
+			   RbGrnObject *rb_grn_object,
+			   grn_ctx *context, grn_obj *object)
 {
+    DATA_PTR(self) = rb_grn_object;
+    rb_iv_set(self, "context", rb_context);
+
+    rb_grn_object->self = self;
+    rb_grn_object->need_close = RB_GRN_TRUE;
+    switch (object->header.type) {
+      case GRN_DB:
+      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:
+	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;
+      default:
+	if (klass == rb_cGrnVariable)
+	    rb_grn_object->need_close = RB_GRN_FALSE;
+	break;
+    }
+
     rb_grn_object->context = context;
     rb_grn_object->object = object;
 
@@ -221,27 +304,67 @@ rb_grn_object_bind (RbGrnObject *rb_grn_object,
 	rb_grn_object->range = NULL;
     else
 	rb_grn_object->range = grn_ctx_at(context, rb_grn_object->range_id);
-
-    rb_grn_object->owner = owner;
-
-    rb_grn_object->unbind = RB_GRN_UNBIND_FUNCTION(rb_grn_object_unbind);
-
-    if (context)
-	rb_grn_context_register(context, rb_grn_object);
 }
 
 void
-rb_grn_object_assign (VALUE self, VALUE rb_context,
-		      grn_ctx *context, grn_obj *object,
-		      rb_grn_boolean owner)
+rb_grn_object_assign (VALUE klass, VALUE self, VALUE rb_context,
+		      grn_ctx *context, grn_obj *object)
 {
-    RbGrnObject *rb_grn_object;
+    void *rb_grn_object;
 
-    rb_grn_object = ALLOC(RbGrnObject);
-    DATA_PTR(self) = rb_grn_object;
-    rb_grn_object_bind(rb_grn_object, context, object, owner);
+    if (!object)
+	return;
 
-    rb_iv_set(self, "context", rb_context);
+    if (NIL_P(klass))
+	klass = rb_obj_class(self);
+
+    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_cGrnProcedure ||
+	klass == rb_cGrnVariable) {
+	rb_grn_object = ALLOC(RbGrnObject);
+	rb_grn_object_bind_common(klass, self, rb_context, rb_grn_object,
+				  context, object);
+    } else if (RVAL2CBOOL(rb_obj_is_kind_of(self, rb_mGrnTableKeySupport))) {
+	rb_grn_object = ALLOC(RbGrnTableKeySupport);
+	rb_grn_object_bind_common(klass, self, rb_context, rb_grn_object,
+				  context, object);
+	rb_grn_table_key_support_bind(RB_GRN_TABLE_KEY_SUPPORT(rb_grn_object),
+				      context, object);
+    } else if (RVAL2CBOOL(rb_obj_is_kind_of(self, rb_cGrnTable))) {
+	rb_grn_object = ALLOC(RbGrnTable);
+	rb_grn_object_bind_common(klass, self, rb_context, rb_grn_object,
+				  context, object);
+	rb_grn_table_bind(RB_GRN_TABLE(rb_grn_object), context, object);
+    } else if (RVAL2CBOOL(rb_obj_is_kind_of(self, rb_cGrnIndexColumn))) {
+	rb_grn_object = ALLOC(RbGrnIndexColumn);
+	rb_grn_object_bind_common(klass, self, rb_context, rb_grn_object,
+				  context, object);
+	rb_grn_index_column_bind(RB_GRN_INDEX_COLUMN(rb_grn_object),
+				 context, object);
+    } else if (RVAL2CBOOL(rb_obj_is_kind_of(self, rb_cGrnColumn))) {
+	rb_grn_object = ALLOC(RbGrnColumn);
+	rb_grn_object_bind_common(klass, self, rb_context, rb_grn_object,
+				  context, object);
+	rb_grn_column_bind(RB_GRN_COLUMN(rb_grn_object), context, object);
+    } else if (klass == rb_cGrnExpression) {
+	rb_grn_object = ALLOC(RbGrnExpression);
+	rb_grn_object_bind_common(klass, self, rb_context, rb_grn_object,
+				  context, object);
+	rb_grn_expression_bind(RB_GRN_EXPRESSION(rb_grn_object),
+			       context, object);
+    } else {
+	rb_raise(rb_eTypeError,
+		 "unsupported groonga object type: 0x%x",
+		 object->header.type);
+    }
+
+    debug("assign: %p:%p:%p 0x%x\n", context, object, rb_grn_object,
+	   object->header.type);
 }
 
 void
@@ -282,7 +405,13 @@ rb_grn_object_deconstruct (RbGrnObject *rb_grn_object,
 VALUE
 rb_grn_object_close (VALUE self)
 {
-    rb_grn_object_unbind(SELF(self));
+    grn_obj *object;
+    grn_ctx *context;
+
+    rb_grn_object_deconstruct(SELF(self), &object, &context,
+			      NULL, NULL, NULL, NULL);
+    if (object && context)
+	grn_obj_close(context, object);
     return Qnil;
 }
 
@@ -298,10 +427,12 @@ rb_grn_object_close (VALUE self)
 static VALUE
 rb_grn_object_closed_p (VALUE self)
 {
-    RbGrnObject *rb_grn_object;
+    grn_obj *object;
+    grn_ctx *context;
 
-    rb_grn_object = SELF(self);
-    if (rb_grn_object->context && rb_grn_object->object)
+    rb_grn_object_deconstruct(SELF(self), &object, &context,
+			      NULL, NULL, NULL, NULL);
+    if (context && object)
         return Qfalse;
     else
         return Qtrue;
@@ -323,7 +454,6 @@ rb_grn_object_inspect_header (VALUE self, VALUE inspected)
 {
     rb_str_cat2(inspected, "#<");
     rb_str_concat(inspected, rb_inspect(rb_obj_class(self)));
-    rb_str_cat2(inspected, " ");
 
     return inspected;
 }
@@ -480,10 +610,12 @@ rb_grn_object_inspect_content (VALUE self, VALUE inspected)
     context = rb_grn_object->context;
     object = rb_grn_object->object;
 
-    if (!object)
-	return inspected;
-
-    rb_grn_object_inspect_object_content(inspected, context, object);
+    rb_str_cat2(inspected, " ");
+    if (object) {
+	rb_grn_object_inspect_object_content(inspected, context, object);
+    } else {
+	rb_str_cat2(inspected, "(closed)");
+    }
 
     return inspected;
 }
@@ -831,7 +963,6 @@ rb_grn_object_remove (VALUE self)
     rc = grn_obj_remove(context, rb_grn_object->object);
     rb_grn_rc_check(rc, self);
 
-    rb_grn_object->unbind(rb_grn_object);
     rb_iv_set(self, "context", Qnil);
 
     return Qnil;