groonga 0.0.1 → 0.0.2

data/ext/rb-grn-table-key-support.c

@@ -18,95 +18,188 @@
 
 #include "rb-grn.h"
 
-#define SELF(object, context) (RVAL2GRNTABLE(object, context))
+#define SELF(object) ((RbGrnTableKeySupport *)DATA_PTR(object))
 
 VALUE rb_mGrnTableKeySupport;
 
-/* FIXME */
-grn_rc grn_table_get_info(grn_ctx *ctx, grn_obj *table, grn_obj_flags *flags,
-                          grn_encoding *encoding, grn_obj **tokenizer);
+void
+rb_grn_table_key_support_deconstruct (RbGrnTableKeySupport *rb_grn_table_key_support,
+				      grn_obj **table_key_support,
+				      grn_ctx **context,
+				      grn_obj **key,
+				      grn_id *domain_id,
+				      grn_obj **domain,
+				      grn_obj **value,
+				      grn_id *range_id,
+				      grn_obj **range)
+{
+    RbGrnTable *rb_grn_table;
 
-static grn_id
-rb_grn_table_key_support_add_raw (VALUE self, VALUE rb_key,
-				  grn_ctx *context, grn_obj *table)
+    rb_grn_table = RB_GRN_TABLE(rb_grn_table_key_support);
+
+    rb_grn_table_deconstruct(rb_grn_table, table_key_support, context,
+			     domain_id, domain,
+			     value, range_id, range);
+
+    if (key)
+	*key = rb_grn_table_key_support->key;
+}
+
+static void
+rb_grn_table_key_support_free (void *object)
 {
-    VALUE exception;
-    grn_id id;
-    grn_obj key;
-    grn_search_flags flags;
-
-    RVAL2GRNKEY(rb_key, context, &key, table->header.domain, self);
-    flags = GRN_SEARCH_EXACT | GRN_TABLE_ADD;
-    id = grn_table_lookup(context, table,
-			  GRN_BULK_HEAD(&key), GRN_BULK_VSIZE(&key),
-			  &flags);
-    exception = rb_grn_context_to_exception(context, self);
-    grn_obj_close(context, &key);
-    if (!NIL_P(exception))
-	rb_exc_raise(exception);
+    RbGrnObject *rb_grn_object = object;
+    RbGrnTable *rb_grn_table = object;
+    RbGrnTableKeySupport *rb_grn_table_key_support = object;
+    grn_ctx *context;
 
-    return id;
+    context = rb_grn_object->context;
+    if (context)
+	grn_obj_close(context, rb_grn_table_key_support->key);
+
+    rb_grn_table_unbind(rb_grn_table);
+
+    xfree(rb_grn_table_key_support);
+}
+
+VALUE
+rb_grn_table_key_support_alloc (VALUE klass)
+{
+    return Data_Wrap_Struct(klass, NULL, rb_grn_table_key_support_free, NULL);
+}
+
+void
+rb_grn_table_key_support_bind (RbGrnTableKeySupport *rb_grn_table_key_support,
+			       grn_ctx *context,
+			       grn_obj *table_key_support,
+			       rb_grn_boolean owner)
+{
+    RbGrnObject *rb_grn_object;
+    RbGrnTable *rb_grn_table;
+
+    rb_grn_object = RB_GRN_OBJECT(rb_grn_table_key_support);
+
+    rb_grn_table = RB_GRN_TABLE(rb_grn_table_key_support);
+    rb_grn_table_bind(rb_grn_table, context, table_key_support, owner);
+
+    rb_grn_table_key_support->key =
+	grn_obj_open(context, GRN_BULK, 0, rb_grn_object->domain_id);
+}
+
+void
+rb_grn_table_key_support_assign (VALUE self, VALUE rb_context,
+				 grn_ctx *context,
+				 grn_obj *table_key_support,
+				 rb_grn_boolean owner)
+{
+    RbGrnTableKeySupport *rb_grn_table_key_support;
+
+    rb_grn_table_key_support = ALLOC(RbGrnTableKeySupport);
+    DATA_PTR(self) = rb_grn_table_key_support;
+
+    rb_grn_table_key_support_bind(rb_grn_table_key_support,
+				  context, table_key_support, owner);
+
+    rb_iv_set(self, "context", rb_context);
 }
 
 static VALUE
-rb_grn_table_key_support_add (VALUE self, VALUE rb_key)
+rb_grn_table_key_support_initialize (int argc, VALUE *argv, VALUE self)
 {
     grn_ctx *context = NULL;
     grn_obj *table;
-    grn_id id;
+    VALUE rb_context;
+
+    table = rb_grn_table_open_raw(argc, argv, &context, &rb_context);
+    rb_grn_context_check(context, self);
+    rb_grn_table_key_support_assign(self, rb_context, context,
+				    table, RB_GRN_TRUE);
+
+    return Qnil;
+}
+
+static grn_id
+rb_grn_table_key_support_add_raw (VALUE self, VALUE rb_key)
+{
+    grn_ctx *context;
+    grn_obj *table;
+    grn_id id, domain_id;
+    grn_obj *key, *domain;
 
-    table = SELF(self, &context);
+    rb_grn_table_key_support_deconstruct(SELF(self), &table, &context,
+					 &key, &domain_id, &domain,
+					 NULL, NULL, NULL);
 
-    id = rb_grn_table_key_support_add_raw(self, rb_key, context, table);
+    GRN_BULK_REWIND(key);
+    RVAL2GRNKEY(rb_key, context, key, domain_id, domain, self);
+    id = grn_table_add(context, table,
+                       GRN_BULK_HEAD(key), GRN_BULK_VSIZE(key), NULL);
+    rb_grn_context_check(context, self);
+
+    return id;
+}
+
+static VALUE
+rb_grn_table_key_support_add (int argc, VALUE *argv, VALUE self)
+{
+    grn_id id;
+    VALUE key, values;
+
+    rb_scan_args(argc, argv, "11", &key, &values);
+    id = rb_grn_table_key_support_add_raw(self, key);
     if (GRN_ID_NIL == id)
 	return Qnil;
     else
-	return rb_grn_record_new(self, id);
+	return rb_grn_record_new(self, id, values);
 }
 
 static VALUE
 rb_grn_table_key_support_get_key (VALUE self, VALUE rb_id)
 {
-    grn_ctx *context = NULL;
+    grn_ctx *context;
+    grn_obj *table, *key;
     grn_id id;
-    grn_obj *table, key;
-    int key_size = 0;
+    int key_size;
     VALUE rb_key;
 
-    table = SELF(self, &context);
+    rb_grn_table_key_support_deconstruct(SELF(self), &table, &context,
+					 &key, NULL, NULL,
+					 NULL, NULL, NULL);
 
     id = NUM2UINT(rb_id);
-    key_size = grn_table_get_key(context, table, id, NULL, 0);
+    GRN_BULK_REWIND(key);
+    key_size = grn_table_get_key(context, table, id,
+				 GRN_BULK_HEAD(key), GRN_BULK_VSIZE(key));
     if (key_size == 0)
 	return Qnil;
 
-    GRN_OBJ_INIT(&key, GRN_BULK, 0);
-    grn_bulk_space(context, &key, key_size);
-    grn_table_get_key(context, table, id, GRN_BULK_HEAD(&key), key_size);
-    rb_key = GRNKEY2RVAL(context, GRN_BULK_HEAD(&key), key_size, table, self);
-    grn_obj_close(context, &key);
+    if (GRN_BULK_VSIZE(key) < key_size) {
+	grn_bulk_reserve(context, key, key_size);
+	grn_table_get_key(context, table, id, GRN_BULK_HEAD(key), key_size);
+    }
 
+    rb_key = GRNKEY2RVAL(context, GRN_BULK_HEAD(key), key_size, table, self);
     return rb_key;
 }
 
 static VALUE
 rb_grn_table_key_support_delete_by_key (VALUE self, VALUE rb_key)
 {
-    VALUE exception;
-    grn_ctx *context = NULL;
+    grn_ctx *context;
     grn_obj *table;
-    grn_obj key;
+    grn_id domain_id;
+    grn_obj *key, *domain;
     grn_rc rc;
 
-    table = SELF(self, &context);
+    rb_grn_table_key_support_deconstruct(SELF(self), &table, &context,
+					 &key, &domain_id, &domain,
+					 NULL, NULL, NULL);
 
-    RVAL2GRNKEY(rb_key, context, &key, table->header.domain, self);
+    GRN_BULK_REWIND(key);
+    RVAL2GRNKEY(rb_key, context, key, domain_id, domain, self);
     rc = grn_table_delete(context, table,
-			  GRN_BULK_HEAD(&key), GRN_BULK_VSIZE(&key));
-    exception = rb_grn_context_to_exception(context, self);
-    grn_obj_close(context, &key);
-    if (!NIL_P(exception))
-	rb_exc_raise(exception);
+			  GRN_BULK_HEAD(key), GRN_BULK_VSIZE(key));
+    rb_grn_context_check(context, self);
     rb_grn_rc_check(rc, self);
 
     return Qnil;
@@ -116,88 +209,110 @@ static VALUE
 rb_grn_table_key_support_delete (VALUE self, VALUE rb_id_or_key)
 {
     if (FIXNUM_P(rb_id_or_key)) {
-	int argc = 1;
-	VALUE argv[1];
-	argv[0] = rb_id_or_key;
-	return rb_call_super(argc, argv);
+	return rb_grn_table_delete(self, rb_id_or_key);
     } else {
 	return rb_grn_table_key_support_delete_by_key(self, rb_id_or_key);
     }
 }
 
+grn_id
+rb_grn_table_key_support_get (VALUE self, VALUE rb_key)
+{
+    grn_ctx *context;
+    grn_obj *table, *key, *domain;
+    grn_id id, domain_id;
+
+    rb_grn_table_key_support_deconstruct(SELF(self), &table, &context,
+					 &key, &domain_id, &domain,
+					 NULL, NULL, NULL);
+
+    GRN_BULK_REWIND(key);
+    RVAL2GRNKEY(rb_key, context, key, domain_id, domain, self);
+    id = grn_table_get(context, table,
+                       GRN_BULK_HEAD(key), GRN_BULK_VSIZE(key));
+    rb_grn_context_check(context, self);
+
+    return id;
+}
+
 static VALUE
-rb_grn_table_key_support_array_reference_by_key (VALUE self, VALUE rb_key)
+rb_grn_table_key_support_find (VALUE self, VALUE rb_key)
 {
-    VALUE exception;
-    grn_ctx *context = NULL;
-    grn_obj *table;
-    grn_obj key;
     grn_id id;
-    grn_search_flags flags = 0;
 
-    table = SELF(self, &context);
+    id = rb_grn_table_key_support_get(self, rb_key);
 
-    RVAL2GRNKEY(rb_key, context, &key, table->header.domain, self);
-    flags = GRN_SEARCH_EXACT;
-    id = grn_table_lookup(context, table,
-			  GRN_BULK_HEAD(&key), GRN_BULK_VSIZE(&key),
-			  &flags);
-    exception = rb_grn_context_to_exception(context, self);
-    grn_obj_close(context, &key);
-    if (!NIL_P(exception))
-	rb_exc_raise(exception);
+    if (id == GRN_ID_NIL)
+	return Qnil;
+    else
+	return rb_grn_record_new(self, id, Qnil);
+}
+
+static VALUE
+rb_grn_table_key_support_array_reference_by_key (VALUE self, VALUE rb_key)
+{
+    grn_ctx *context;
+    grn_obj *table, *value, *range;
+    grn_id id;
+
+    id = rb_grn_table_key_support_get(self, rb_key);
 
     if (id == GRN_ID_NIL)
 	return Qnil;
+
+    rb_grn_table_key_support_deconstruct(SELF(self), &table, &context,
+					 NULL, NULL, NULL,
+					 &value, NULL, &range);
+    GRN_BULK_REWIND(value);
+    grn_obj_get_value(context, table, id, value);
+    rb_grn_context_check(context, self);
+
+    if (GRN_BULK_EMPTYP(value))
+	return Qnil;
     else
-	return rb_grn_record_new(self, id);
+	return rb_str_new(GRN_BULK_HEAD(value), GRN_BULK_VSIZE(value));
 }
 
 static VALUE
 rb_grn_table_key_support_array_reference (VALUE self, VALUE rb_id_or_key)
 {
     if (FIXNUM_P(rb_id_or_key)) {
-	int argc = 1;
-	VALUE argv[1];
-	argv[0] = rb_id_or_key;
-	return rb_call_super(argc, argv);
+	return rb_grn_table_array_reference(self, rb_id_or_key);
     } else {
 	return rb_grn_table_key_support_array_reference_by_key(self,
 							       rb_id_or_key);
     }
 }
 
-
 static VALUE
 rb_grn_table_key_support_array_set_by_key (VALUE self,
 					   VALUE rb_key, VALUE rb_value)
 {
-    VALUE exception;
-    grn_ctx *context = NULL;
+    grn_ctx *context;
     grn_obj *table;
     grn_id id;
-    grn_obj value;
+    grn_obj *value;
     grn_rc rc;
 
-    table = SELF(self, &context);
-
     if (NIL_P(rb_key))
 	rb_raise(rb_eArgError, "key should not be nil: <%s>",
 		 rb_grn_inspect(self));
 
-    id = rb_grn_table_key_support_add_raw(self, rb_key, context, table);
+    rb_grn_table_key_support_deconstruct(SELF(self), &table, &context,
+					 NULL, NULL, NULL,
+					 &value, NULL, NULL);
+
+    id = rb_grn_table_key_support_add_raw(self, rb_key);
     if (GRN_ID_NIL == id)
 	rb_raise(rb_eGrnError,
 		 "failed to add new record with key: <%s>: <%s>",
 		 rb_grn_inspect(rb_key),
 		 rb_grn_inspect(self));
 
-    RVAL2GRNBULK(rb_value, context, &value);
-    rc = grn_obj_set_value(context, table, id, &value, GRN_OBJ_SET);
-    exception = rb_grn_context_to_exception(context, self);
-    grn_obj_close(context, &value);
-    if (!NIL_P(exception))
-	rb_exc_raise(exception);
+    GRN_BULK_REWIND(value);
+    RVAL2GRNBULK(rb_value, context, value);
+    rc = grn_obj_set_value(context, table, id, value, GRN_OBJ_SET);
+    rb_grn_context_check(context, self);
     rb_grn_rc_check(rc, self);
 
     return rb_value;
@@ -208,11 +323,7 @@ rb_grn_table_key_support_array_set (VALUE self,
 				    VALUE rb_id_or_key, VALUE rb_value)
 {
     if (FIXNUM_P(rb_id_or_key)) {
-	int argc = 2;
-	VALUE argv[2];
-	argv[0] = rb_id_or_key;
-	argv[1] = rb_value;
-	return rb_call_super(argc, argv);
+	return rb_grn_table_array_set(self, rb_id_or_key, rb_value);
     } else {
 	return rb_grn_table_key_support_array_set_by_key(self,
 							 rb_id_or_key,
@@ -220,34 +331,20 @@ rb_grn_table_key_support_array_set (VALUE self,
     }
 }
 
-static VALUE
-rb_grn_table_key_support_get_encoding (VALUE self)
-{
-    grn_ctx *context = NULL;
-    grn_obj *table;
-    grn_encoding encoding;
-    grn_rc rc;
-
-    table = SELF(self, &context);
-    rc = grn_table_get_info(context, table, NULL, &encoding, NULL);
-    rb_grn_context_check(context, self);
-    rb_grn_rc_check(rc, self);
-
-    return GRNENCODING2RVAL(encoding);
-}
-
 static VALUE
 rb_grn_table_key_support_get_default_tokenizer (VALUE self)
 {
     grn_ctx *context = NULL;
     grn_obj *table;
-    grn_obj *tokenizer;
-    grn_rc rc;
+    grn_obj *tokenizer = NULL;
+
+    rb_grn_table_key_support_deconstruct(SELF(self), &table, &context,
+					 NULL, NULL, NULL,
+					 NULL, NULL, NULL);
 
-    table = SELF(self, &context);
-    rc = grn_table_get_info(context, table, NULL, NULL, &tokenizer);
+    tokenizer = grn_obj_get_info(context, table, GRN_INFO_DEFAULT_TOKENIZER,
+				 NULL);
     rb_grn_context_check(context, self);
-    rb_grn_rc_check(rc, self);
 
     return GRNOBJECT2RVAL(Qnil, context, tokenizer, RB_GRN_FALSE);
 }
@@ -255,12 +352,15 @@ rb_grn_table_key_support_get_default_tokenizer (VALUE self)
 static VALUE
 rb_grn_table_key_support_set_default_tokenizer (VALUE self, VALUE rb_tokenizer)
 {
-    grn_ctx *context = NULL;
+    grn_ctx *context;
     grn_obj *table;
     grn_obj *tokenizer;
     grn_rc rc;
 
-    table = SELF(self, &context);
+    rb_grn_table_key_support_deconstruct(SELF(self), &table, &context,
+					 NULL, NULL, NULL,
+					 NULL, NULL, NULL);
+
     tokenizer = RVAL2GRNOBJECT(rb_tokenizer, &context);
     rc = grn_obj_set_info(context, table,
 			  GRN_INFO_DEFAULT_TOKENIZER, tokenizer);
@@ -274,26 +374,28 @@ void
 rb_grn_init_table_key_support (VALUE mGrn)
 {
     rb_mGrnTableKeySupport = rb_define_module_under(rb_cGrnTable, "KeySupport");
+    rb_include_module(rb_mGrnTableKeySupport, rb_mGrnEncodingSupport);
+
+    rb_define_method(rb_mGrnTableKeySupport, "initialize",
+		     rb_grn_table_key_support_initialize, -1);
 
     rb_define_method(rb_mGrnTableKeySupport, "add",
-		     rb_grn_table_key_support_add, 1);
+		     rb_grn_table_key_support_add, -1);
     rb_define_method(rb_mGrnTableKeySupport, "key",
 		     rb_grn_table_key_support_get_key, 1);
 
     rb_define_method(rb_mGrnTableKeySupport, "delete",
 		     rb_grn_table_key_support_delete, 1);
 
+    rb_define_method(rb_mGrnTableKeySupport, "find",
+		     rb_grn_table_key_support_find, 1);
     rb_define_method(rb_mGrnTableKeySupport, "[]",
 		     rb_grn_table_key_support_array_reference, 1);
     rb_define_method(rb_mGrnTableKeySupport, "[]=",
 		     rb_grn_table_key_support_array_set, 2);
 
-    rb_define_method(rb_mGrnTableKeySupport, "encoding",
-		     rb_grn_table_key_support_get_encoding, 0);
-
     rb_define_method(rb_mGrnTableKeySupport, "default_tokenizer",
 		     rb_grn_table_key_support_get_default_tokenizer, 0);
-
     rb_define_method(rb_mGrnTableKeySupport, "default_tokenizer=",
 		     rb_grn_table_key_support_set_default_tokenizer, 1);
 }