groonga 0.0.1 → 0.0.2

data/ext/rb-grn-object.c

@@ -30,14 +30,6 @@
 
 VALUE rb_cGrnObject;
 
-typedef struct _RbGrnObject RbGrnObject;
-struct _RbGrnObject
-{
-    grn_ctx *context;
-    grn_obj *object;
-    rb_grn_boolean owner;
-};
-
 grn_obj *
 rb_grn_object_from_ruby_object (VALUE object, grn_ctx **context)
 {
@@ -49,16 +41,16 @@ 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_lookup(*context,
-					StringValuePtr(object),
-					RSTRING_LEN(object));
+	    grn_object = grn_ctx_get(*context,
+                                     StringValuePtr(object),
+                                     RSTRING_LEN(object));
 	    if (!grn_object)
 		rb_raise(rb_eArgError,
 			 "unregistered groonga object: name: <%s>",
 			 rb_grn_inspect(object));
 	    return grn_object;
 	} else if (RVAL2CBOOL(rb_obj_is_kind_of(object, rb_cInteger))) {
-	    grn_object = grn_ctx_get(*context, NUM2UINT(object));
+	    grn_object = grn_ctx_at(*context, NUM2UINT(object));
 	    if (!grn_object)
 		rb_raise(rb_eArgError,
 			 "unregistered groonga object: ID: <%s>",
@@ -81,17 +73,44 @@ rb_grn_object_from_ruby_object (VALUE object, grn_ctx **context)
     return rb_grn_object->object;
 }
 
-static void
-rb_rb_grn_object_free (void *object)
+void
+rb_grn_object_unbind (RbGrnObject *rb_grn_object)
 {
-    RbGrnObject *rb_grn_object = object;
+    grn_ctx *context;
+    grn_obj *grn_object;
 
-    if (rb_grn_object->context && rb_grn_object->object &&
-	rb_grn_object->owner) {
-	/* FIXME */
-	/* grn_obj_close(rb_grn_object->context, rb_grn_object->object); */
+    context = rb_grn_object->context;
+    grn_object = rb_grn_object->object;
+
+    if (context)
+	rb_grn_context_unregister(context, rb_grn_object);
+
+    if (rb_grn_object->owner && context && grn_object) {
+	const char *path;
+	grn_obj *db = NULL;
+
+	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);
+	    }
+	}
     }
 
+    rb_grn_object->context = NULL;
+    rb_grn_object->object = NULL;
+    rb_grn_object->owner = RB_GRN_FALSE;
+}
+
+static void
+rb_grn_object_free (void *object)
+{
+    RbGrnObject *rb_grn_object = object;
+
+    rb_grn_object->unbind(rb_grn_object);
     xfree(rb_grn_object);
 }
 
@@ -145,38 +164,110 @@ VALUE
 rb_grn_object_to_ruby_object (VALUE klass, grn_ctx *context, grn_obj *object,
 			      rb_grn_boolean owner)
 {
-    RbGrnObject *rb_grn_object;
+    VALUE rb_object;
 
     if (!object)
         return Qnil;
 
-    rb_grn_object = ALLOC(RbGrnObject);
-    rb_grn_object->context = context;
-    rb_grn_object->object = object;
-    rb_grn_object->owner = owner;
-
     if (NIL_P(klass))
         klass = GRNOBJECT2RCLASS(object);
 
-    return Data_Wrap_Struct(klass, NULL, rb_rb_grn_object_free, rb_grn_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);
+    }
+
+    return rb_object;
 }
 
 VALUE
 rb_grn_object_alloc (VALUE klass)
 {
-    return Data_Wrap_Struct(klass, NULL, rb_rb_grn_object_free, NULL);
+    return Data_Wrap_Struct(klass, NULL, rb_grn_object_free, NULL);
 }
 
 void
-rb_grn_object_initialize (VALUE self, grn_ctx *context, grn_obj *object)
+rb_grn_object_bind (RbGrnObject *rb_grn_object,
+		    grn_ctx *context, grn_obj *object, rb_grn_boolean owner)
+{
+    rb_grn_object->context = context;
+    rb_grn_object->object = object;
+
+    rb_grn_object->domain_id = GRN_ID_NIL;
+    if (object)
+	rb_grn_object->domain_id = object->header.domain;
+    if (rb_grn_object->domain_id == GRN_ID_NIL)
+	rb_grn_object->domain = NULL;
+    else
+	rb_grn_object->domain = grn_ctx_at(context, rb_grn_object->domain_id);
+
+    rb_grn_object->range_id = GRN_ID_NIL;
+    if (object && object->header.type != GRN_TYPE)
+	rb_grn_object->range_id = grn_obj_get_range(context, object);
+    if (rb_grn_object->range_id == GRN_ID_NIL)
+	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)
 {
     RbGrnObject *rb_grn_object;
 
     rb_grn_object = ALLOC(RbGrnObject);
     DATA_PTR(self) = rb_grn_object;
-    rb_grn_object->context = context;
-    rb_grn_object->object = object;
-    rb_grn_object->owner = RB_GRN_TRUE;
+    rb_grn_object_bind(rb_grn_object, context, object, owner);
+
+    rb_iv_set(self, "context", rb_context);
+}
+
+void
+rb_grn_object_deconstruct (RbGrnObject *rb_grn_object,
+			   grn_obj **object,
+			   grn_ctx **context,
+			   grn_id *domain_id,
+			   grn_obj **domain,
+			   grn_id *range_id,
+			   grn_obj **range)
+{
+    if (!rb_grn_object)
+	return;
+
+    if (object)
+	*object = rb_grn_object->object;
+    if (context)
+	*context = rb_grn_object->context;
+    if (domain_id)
+	*domain_id = rb_grn_object->domain_id;
+    if (domain)
+	*domain = rb_grn_object->domain;
+    if (range_id)
+	*range_id = rb_grn_object->range_id;
+    if (range)
+	*range = rb_grn_object->range;
 }
 
 /*
@@ -191,16 +282,7 @@ rb_grn_object_initialize (VALUE self, grn_ctx *context, grn_obj *object)
 VALUE
 rb_grn_object_close (VALUE self)
 {
-    RbGrnObject *rb_grn_object;
-
-    rb_grn_object = SELF(self);
-    if (rb_grn_object->context && rb_grn_object->object) {
-	if (rb_grn_object->owner)
-	    grn_obj_close(rb_grn_object->context, rb_grn_object->object);
-        rb_grn_object->context = NULL;
-        rb_grn_object->object = NULL;
-        rb_grn_object->owner = RB_GRN_FALSE;
-    }
+    rb_grn_object_unbind(SELF(self));
     return Qnil;
 }
 
@@ -276,13 +358,14 @@ rb_grn_object_inspect_content_name (VALUE inspected,
     } else {
 	grn_obj name;
 
-	GRN_OBJ_INIT(&name, GRN_BULK, 0);
+	GRN_OBJ_INIT(&name, GRN_BULK, 0, GRN_ID_NIL);
 	grn_bulk_space(context, &name, name_size);
 	grn_obj_name(context, object, GRN_BULK_HEAD(&name), name_size);
-	GRN_BULK_PUTC(context, &name, '\0');
+	GRN_TEXT_PUTC(context, &name, '\0');
 	rb_str_cat2(inspected, "<");
 	rb_str_cat2(inspected, GRN_BULK_HEAD(&name));
 	rb_str_cat2(inspected, ">");
+	grn_obj_close(context, &name);
     }
 
     return inspected;
@@ -321,7 +404,7 @@ rb_grn_object_inspect_content_domain (VALUE inspected,
     } else {
 	grn_obj *domain_object;
 
-	domain_object = grn_ctx_get(context, domain);
+	domain_object = grn_ctx_at(context, domain);
 	if (domain_object) {
 	    rb_grn_object_inspect_object(inspected, context, domain_object);
 	} else {
@@ -353,7 +436,7 @@ rb_grn_object_inspect_content_range (VALUE inspected,
 	} else {
 	    grn_obj *range_object;
 
-	    range_object = grn_ctx_get(context, range);
+	    range_object = grn_ctx_at(context, range);
 	    if (range_object) {
 		rb_grn_object_inspect_object(inspected, context, range_object);
 	    } else {
@@ -391,6 +474,9 @@ rb_grn_object_inspect_content (VALUE self, VALUE inspected)
     grn_obj *object;
 
     rb_grn_object = SELF(self);
+    if (!rb_grn_object)
+	return inspected;
+
     context = rb_grn_object->context;
     object = rb_grn_object->object;
 
@@ -487,7 +573,7 @@ rb_grn_object_get_domain (VALUE self)
     } else {
 	grn_obj *domain_object;
 
-	domain_object = grn_ctx_get(context, domain);
+	domain_object = grn_ctx_at(context, domain);
 	if (domain_object)
 	    return GRNOBJECT2RVAL(Qnil, context, domain_object, RB_GRN_FALSE);
 	else
@@ -558,7 +644,7 @@ rb_grn_object_get_range (VALUE self)
     } else {
 	grn_obj *range_object;
 
-	range_object = grn_ctx_get(context, range);
+	range_object = grn_ctx_at(context, range);
 	if (range_object)
 	    return GRNOBJECT2RVAL(Qnil, context, range_object, RB_GRN_FALSE);
 	else
@@ -622,30 +708,27 @@ rb_grn_object_array_reference (VALUE self, VALUE rb_id)
 
     id = NUM2UINT(rb_id);
     range_id = grn_obj_get_range(context, object);
-    range = grn_ctx_get(context, range_id);
+    range = grn_ctx_at(context, range_id);
     range_type = range ? range->header.type : GRN_VOID;
     switch (object->header.type) {
       case GRN_TABLE_HASH_KEY:
       case GRN_TABLE_PAT_KEY:
       case GRN_TABLE_NO_KEY:
-	GRN_OBJ_INIT(&value, GRN_BULK, 0);
+	GRN_OBJ_INIT(&value, GRN_BULK, 0, GRN_ID_NIL);
 	break;
       case GRN_TYPE:
       case GRN_ACCESSOR: /* FIXME */
-	GRN_OBJ_INIT(&value, GRN_BULK, 0);
-	value.header.domain = range_id;
+	GRN_OBJ_INIT(&value, GRN_BULK, 0, range_id);
 	break;
       case GRN_COLUMN_VAR_SIZE:
       case GRN_COLUMN_FIX_SIZE:
 	switch (object->header.flags & GRN_OBJ_COLUMN_TYPE_MASK) {
 	  case GRN_OBJ_COLUMN_VECTOR:
-	    GRN_OBJ_INIT(&value, GRN_VECTOR, 0);
-	    value.header.domain = range_id;
+	    GRN_OBJ_INIT(&value, GRN_VECTOR, 0, range_id);
 	    break;
 	  case GRN_OBJ_COLUMN_INDEX:
 	  case GRN_OBJ_COLUMN_SCALAR:
-	    GRN_OBJ_INIT(&value, GRN_BULK, 0);
-	    value.header.domain = range_id;
+	    GRN_OBJ_INIT(&value, GRN_BULK, 0, range_id);
 	    break;
 	  default:
 	    rb_raise(rb_eGrnError, "unsupported column type: %u: %s",
@@ -687,8 +770,10 @@ rb_grn_object_set (VALUE self, VALUE rb_id, VALUE rb_value, int flags)
     context = rb_grn_object->context;
     id = NUM2UINT(rb_id);
     if (RVAL2CBOOL(rb_obj_is_kind_of(rb_value, rb_cArray))) {
+	GRN_OBJ_INIT(&value, GRN_VECTOR, 0, GRN_ID_NIL);
 	RVAL2GRNVECTOR(rb_value, context, &value);
     } else {
+	GRN_OBJ_INIT(&value, GRN_BULK, 0, GRN_ID_NIL);
 	RVAL2GRNBULK(rb_value, context, &value);
     }
     rc = grn_obj_set_value(context, rb_grn_object->object, id,
@@ -731,214 +816,6 @@ rb_grn_object_append_value (VALUE self, VALUE rb_id, VALUE rb_value)
     return rb_grn_object_set(self, rb_id, rb_value, GRN_OBJ_APPEND);
 }
 
-/*
- * Document-method: search
- *
- * call-seq:
- *   object.search(query, options={}) -> Groonga::Table
- *
- * _object_から_query_に対応するオブジェクトを検索し、見つかっ
- * たオブジェクトのIDがキーになっているGroonga::Tableを返す。
- *
- * 利用可能なオプションは以下の通り。
- *
- * [_:result_]
- *   結果を格納するGroonga::Hash。指定しない場合は新しく
- *   Groonga::Hashを生成し、それに結果を格納して返す。
- * [_:operator_]
- *   以下のどれかの値を指定する。+nil+, <tt>"or"</tt>, <tt>"||"</tt>,
- *   <tt>"and"</tt>, <tt>"+"</tt>, <tt>"&&"</tt>, <tt>"but"</tt>,
- *   <tt>"not"</tt>, <tt>"-"</tt>, <tt>"adjust"</tt>, <tt>">"</tt>。
- *   それぞれ以下のようになる。（FIXME: 「以下」）
- * [_:exact_]
- *   +true+を指定すると完全一致で検索する
- * [_:longest_common_prefix_]
- *   +true+を指定すると_query_と同じ接頭辞をもつエントリのう
- *   ち、もっとも長いエントリを検索する
- * [_:suffix_]
- *   +true+を指定すると_query_が後方一致するエントリを検索す
- *   る
- * [_:prefix_]
- *   +true+を指定すると_query_が前方一致するレコードを検索す
- *   る
- * [_:near_]
- *   +true+を指定すると_query_に指定した複数の語が近傍に含ま
- *   れるレコードを検索する
- * [...]
- *   ...
- */
-static VALUE
-rb_grn_object_search (int argc, VALUE *argv, VALUE self)
-{
-    RbGrnObject *rb_grn_object;
-    grn_ctx *context;
-    grn_obj *object;
-    grn_obj *query;
-    grn_obj *result;
-    grn_sel_operator operator;
-    grn_search_optarg search_options;
-    rb_grn_boolean search_options_is_set = RB_GRN_FALSE;
-    rb_grn_boolean query_is_created = RB_GRN_FALSE;
-    grn_rc rc;
-    VALUE rb_query, options, rb_result, rb_operator;
-    VALUE rb_exact, rb_longest_common_prefix, rb_suffix, rb_prefix, rb_partial;
-    VALUE rb_near, rb_near2, rb_similar, rb_term_extract;
-    VALUE rb_similarity_threshold, rb_max_interval, rb_weight_vector;
-    VALUE rb_procedure, rb_max_size;
-
-    rb_grn_object = SELF(self);
-    if (!rb_grn_object->object)
-	return Qnil;
-
-    context = rb_grn_object->context;
-    object = rb_grn_object->object;
-
-    rb_scan_args(argc, argv, "11", &rb_query, &options);
-
-    if (CBOOL2RVAL(rb_obj_is_kind_of(rb_query, rb_cGrnQuery))) {
-	grn_query *_query;
-	_query = RVAL2GRNQUERY(rb_query);
-	query = (grn_obj *)_query;
-    } else {
-	query_is_created = RB_GRN_TRUE;
-	query = RVAL2GRNBULK(rb_query, context, NULL);
-    }
-
-    rb_grn_scan_options(options,
-			"result", &rb_result,
-			"operator", &rb_operator,
-			"exact", &rb_exact,
-			"longest_common_prefix", &rb_longest_common_prefix,
-			"suffix", &rb_suffix,
-			"prefix", &rb_prefix,
-			"partial", &rb_partial,
-			"near", &rb_near,
-			"near2", &rb_near2,
-			"similar", &rb_similar,
-			"term_extract", &rb_term_extract,
-			"similarity_threshold", &rb_similarity_threshold,
-			"max_interval", &rb_max_interval,
-			"weight_vector", &rb_weight_vector,
-			"procedure", &rb_procedure,
-			"max_size", &rb_max_size,
-			NULL);
-
-    if (NIL_P(rb_result)) {
-	grn_obj *domain = NULL;
-
-	switch (object->header.type) {
-	  case GRN_TABLE_PAT_KEY:
-	  case GRN_TABLE_HASH_KEY:
-	    domain = object;
-	    break;
-	  default:
-	    domain = grn_ctx_get(context, grn_obj_get_range(context, object));
-	    break;
-	}
-	result = grn_table_create(context, NULL, 0, NULL,
-				  GRN_OBJ_TABLE_HASH_KEY | GRN_OBJ_WITH_SUBREC,
-				  domain, 0);
-	rb_grn_context_check(context, self);
-    } else {
-	result = RVAL2GRNOBJECT(rb_result, &context);
-    }
-
-    operator = RVAL2GRNSELECTOPERATOR(rb_operator);
-
-    search_options.flags = 0;
-    if (!NIL_P(rb_exact)) {
-	search_options_is_set = RB_GRN_TRUE;
-	if (RVAL2CBOOL(rb_exact))
-	    search_options.flags |= GRN_SEARCH_EXACT;
-    }
-    if (!NIL_P(rb_longest_common_prefix)) {
-	search_options_is_set = RB_GRN_TRUE;
-	if (RVAL2CBOOL(rb_longest_common_prefix))
-	    search_options.flags |= GRN_SEARCH_LCP;
-    }
-    if (!NIL_P(rb_suffix)) {
-	search_options_is_set = RB_GRN_TRUE;
-	if (RVAL2CBOOL(rb_suffix))
-	    search_options.flags |= GRN_SEARCH_SUFFIX;
-    }
-    if (!NIL_P(rb_prefix)) {
-	search_options_is_set = RB_GRN_TRUE;
-	if (RVAL2CBOOL(rb_prefix))
-	    search_options.flags |= GRN_SEARCH_PREFIX;
-    }
-    if (!NIL_P(rb_partial)) {
-	search_options_is_set = RB_GRN_TRUE;
-	if (RVAL2CBOOL(rb_partial))
-	    search_options.flags |= GRN_SEARCH_PARTIAL;
-    }
-    if (!NIL_P(rb_near)) {
-	search_options_is_set = RB_GRN_TRUE;
-	if (RVAL2CBOOL(rb_near))
-	    search_options.flags |= GRN_SEARCH_NEAR;
-    }
-    if (!NIL_P(rb_near2)) {
-	search_options_is_set = RB_GRN_TRUE;
-	if (RVAL2CBOOL(rb_near2))
-	    search_options.flags |= GRN_SEARCH_NEAR2;
-    }
-    if (!NIL_P(rb_similar)) {
-	search_options_is_set = RB_GRN_TRUE;
-	if (RVAL2CBOOL(rb_similar))
-	    search_options.flags |= GRN_SEARCH_SIMILAR;
-    }
-    if (!NIL_P(rb_term_extract)) {
-	search_options_is_set = RB_GRN_TRUE;
-	if (RVAL2CBOOL(rb_term_extract))
-	    search_options.flags |= GRN_SEARCH_TERM_EXTRACT;
-    }
-
-    search_options.similarity_threshold = 30; /* FIXME */
-    if (!NIL_P(rb_similarity_threshold)) {
-	search_options_is_set = RB_GRN_TRUE;
-	search_options.similarity_threshold = NUM2INT(rb_similarity_threshold);
-    }
-
-    search_options.max_interval = 5; /* FIXME */
-    if (!NIL_P(rb_max_interval)) {
-	search_options_is_set = RB_GRN_TRUE;
-	search_options.max_interval = NUM2INT(rb_max_interval);
-    }
-
-    search_options.weight_vector = NULL; /* FIXME */
-    if (!NIL_P(rb_weight_vector)) {
-	search_options_is_set = RB_GRN_TRUE;
-	/* FIXME */
-	/* search_options.weight_vector = RVAL2INTVECTOR(rb_weight_vector); */
-    }
-
-    search_options.proc = NULL;
-    if (!NIL_P(rb_procedure)) {
-	search_options_is_set = RB_GRN_TRUE;
-	search_options.proc = RVAL2GRNOBJECT(rb_procedure, &context);
-    }
-
-    search_options.max_size = 100; /* FIXME */
-    if (!NIL_P(rb_max_size)) {
-	search_options_is_set = RB_GRN_TRUE;
-	search_options.max_size = INT2NUM(rb_max_size);
-    }
-
-    rc = grn_obj_search(context,
-			object,
-			query,
-			result,
-			operator,
-			search_options_is_set ? &search_options : NULL);
-    if (query_is_created)
-	grn_obj_close(context, query);
-    rb_grn_rc_check(rc, self);
-
-    if (NIL_P(rb_result))
-	return GRNOBJECT2RVAL(Qnil, context, result, RB_GRN_TRUE);
-    else
-	return rb_result;
-}
-
 static VALUE
 rb_grn_object_remove (VALUE self)
 {
@@ -954,6 +831,9 @@ 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;
 }
 
@@ -979,7 +859,5 @@ rb_grn_init_object (VALUE mGrn)
     rb_define_method(rb_cGrnObject, "[]=", rb_grn_object_array_set, 2);
     rb_define_method(rb_cGrnObject, "append", rb_grn_object_append_value, 2);
 
-    rb_define_method(rb_cGrnObject, "search", rb_grn_object_search, -1);
-
     rb_define_method(rb_cGrnObject, "remove", rb_grn_object_remove, 0);
 }