groonga 0.0.2 → 0.0.3

data/ext/rb-grn-table.c

@@ -36,67 +36,29 @@ VALUE
 rb_grn_table_to_ruby_object (grn_ctx *context, grn_obj *table,
 			     rb_grn_boolean owner)
 {
-    return GRNOBJECT2RVAL(rb_cGrnTable, context, table, owner);
+    return GRNOBJECT2RVAL(Qnil, context, table, owner);
 }
 
 void
-rb_grn_table_unbind (RbGrnTable *rb_grn_table)
+rb_grn_table_finalizer (grn_ctx *context, grn_obj *object,
+			RbGrnTable *rb_grn_table)
 {
-    RbGrnObject *rb_grn_object;
-    grn_ctx *context;
-
-    rb_grn_object = RB_GRN_OBJECT(rb_grn_table);
-    context = rb_grn_object->context;
-
-    if (context)
+    if (context && rb_grn_table->value)
 	grn_obj_close(context, rb_grn_table->value);
-
-    rb_grn_object_unbind(rb_grn_object);
-}
-
-static void
-rb_grn_table_free (void *object)
-{
-    RbGrnTable *rb_grn_table = object;
-
-    rb_grn_table_unbind(rb_grn_table);
-    xfree(rb_grn_table);
-}
-
-VALUE
-rb_grn_table_alloc (VALUE klass)
-{
-    return Data_Wrap_Struct(klass, NULL, rb_grn_table_free, NULL);
+    rb_grn_table->value = NULL;
 }
 
 void
 rb_grn_table_bind (RbGrnTable *rb_grn_table,
-		   grn_ctx *context, grn_obj *table, rb_grn_boolean owner)
+		   grn_ctx *context, grn_obj *table)
 {
     RbGrnObject *rb_grn_object;
 
     rb_grn_object = RB_GRN_OBJECT(rb_grn_table);
-    rb_grn_object_bind(rb_grn_object, context, table, owner);
-    rb_grn_object->unbind = RB_GRN_UNBIND_FUNCTION(rb_grn_table_unbind);
-
     rb_grn_table->value = grn_obj_open(context, GRN_BULK, 0,
 				       rb_grn_object->range_id);
 }
 
-void
-rb_grn_table_assign (VALUE self, VALUE rb_context,
-		     grn_ctx *context, grn_obj *table,
-		     rb_grn_boolean owner)
-{
-    RbGrnTable *rb_grn_table;
-
-    rb_grn_table = ALLOC(RbGrnTable);
-    DATA_PTR(self) = rb_grn_table;
-    rb_grn_table_bind(rb_grn_table, context, table, owner);
-
-    rb_iv_set(self, "context", rb_context);
-}
-
 void
 rb_grn_table_deconstruct (RbGrnTable *rb_grn_table,
 			  grn_obj **table,
@@ -118,6 +80,57 @@ rb_grn_table_deconstruct (RbGrnTable *rb_grn_table,
 	*value = rb_grn_table->value;
 }
 
+static void
+rb_grn_table_mark (void *data)
+{
+    RbGrnObject *rb_grn_object = data;
+    grn_ctx *context;
+    grn_obj *table;
+    grn_obj *column_ids;
+    int n;
+    grn_table_cursor *cursor;
+
+    context = rb_grn_object->context;
+    table = rb_grn_object->object;
+    if (!context || !table)
+	return;
+
+    if (!grn_obj_path(context, table))
+	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);
+    if (n == 0) {
+	grn_obj_close(context, column_ids);
+	return;
+    }
+
+    cursor = grn_table_cursor_open(context, column_ids, NULL, 0, NULL, 0,
+				   GRN_CURSOR_ASCENDING);
+    while (grn_table_cursor_next(context, cursor) != GRN_ID_NIL) {
+	void *key;
+	grn_id *column_id;
+	grn_obj *column;
+	RbGrnObject *rb_grn_column;
+
+	grn_table_cursor_get_key(context, cursor, &key);
+	column_id = key;
+	column = grn_ctx_at(context, *column_id);
+	rb_grn_column = grn_obj_user_data(context, column)->ptr;
+	if (rb_grn_column)
+	    rb_gc_mark(rb_grn_column->self);
+    }
+    grn_table_cursor_close(context, cursor);
+    grn_obj_close(context, column_ids);
+}
+
+static VALUE
+rb_grn_table_alloc (VALUE klass)
+{
+    return Data_Wrap_Struct(klass, rb_grn_table_mark, rb_grn_object_free, NULL);
+}
+
 VALUE
 rb_grn_table_s_create (int argc, VALUE *argv, VALUE klass,
 		       grn_obj_flags key_store)
@@ -150,6 +163,7 @@ rb_grn_table_s_create (int argc, VALUE *argv, VALUE klass,
     if (!NIL_P(rb_name)) {
         name = StringValuePtr(rb_name);
 	name_size = RSTRING_LEN(rb_name);
+	flags |= GRN_OBJ_PERSISTENT;
     }
 
     if (!NIL_P(rb_path)) {
@@ -177,7 +191,7 @@ rb_grn_table_s_create (int argc, VALUE *argv, VALUE klass,
 
     table = grn_table_create(context, name, name_size, path,
 			     flags, key_type, value_size);
-    rb_table = rb_grn_table_alloc(klass);
+    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);
 
@@ -226,13 +240,7 @@ rb_grn_table_initialize (int argc, VALUE *argv, VALUE self)
     VALUE rb_context;
 
     table = rb_grn_table_open_raw(argc, argv, &context, &rb_context);
-    /* FIXME!!!! */
-    if (self == rb_cGrnArray) {
-	rb_grn_table_assign(self, rb_context, context, table, RB_GRN_TRUE);
-    } else {
-	rb_grn_table_key_support_assign(self, rb_context, context,
-					table, RB_GRN_TRUE);
-    }
+    rb_grn_object_assign(Qnil, self, rb_context, context, table);
     rb_grn_context_check(context, self);
 
     return Qnil;
@@ -241,7 +249,8 @@ rb_grn_table_initialize (int argc, VALUE *argv, VALUE self)
 static VALUE
 rb_grn_table_s_open (int argc, VALUE *argv, VALUE klass)
 {
-    VALUE rb_table;
+    grn_user_data *user_data;
+    VALUE rb_table = Qnil;
     grn_obj *table;
     grn_ctx *context = NULL;
     VALUE rb_context;
@@ -255,28 +264,26 @@ rb_grn_table_s_open (int argc, VALUE *argv, VALUE klass)
 		 rb_grn_inspect(klass),
 		 rb_grn_inspect(rb_ary_new4(argc, argv)));
 
-    if (klass == rb_cGrnTable) {
-	klass = GRNOBJECT2RCLASS(table);
+    user_data = grn_obj_user_data(context, table);
+    if (user_data && user_data->ptr) {
+	rb_table = RB_GRN_OBJECT(user_data->ptr)->self;
     } else {
-	VALUE rb_class;
-
-	rb_class = GRNOBJECT2RCLASS(table);
-	if (rb_class != klass) {
-	    rb_raise(rb_eTypeError,
-		     "unexpected existing table type: %s: expected %s",
-		     rb_grn_inspect(rb_class),
-		     rb_grn_inspect(klass));
+	if (klass == rb_cGrnTable) {
+	    klass = GRNOBJECT2RCLASS(table);
+	} else {
+	    VALUE rb_class;
+
+	    rb_class = GRNOBJECT2RCLASS(table);
+	    if (rb_class != klass) {
+		rb_raise(rb_eTypeError,
+			 "unexpected existing table type: %s: expected %s",
+			 rb_grn_inspect(rb_class),
+			 rb_grn_inspect(klass));
+	    }
 	}
-    }
 
-    /* FIXME!!!! */
-    if (klass == rb_cGrnArray) {
-	rb_table = rb_grn_table_alloc(klass);
-	rb_grn_table_assign(rb_table, rb_context, context, table, RB_GRN_TRUE);
-    } else {
-	rb_table = rb_grn_table_key_support_alloc(klass);
-	rb_grn_table_key_support_assign(rb_table, rb_context, context,
-					table, RB_GRN_TRUE);
+	rb_table = rb_grn_object_alloc(klass);
+	rb_grn_object_assign(klass, rb_table, rb_context, context, table);
     }
 
     if (rb_block_given_p())
@@ -791,20 +798,23 @@ rb_grn_table_sort (int argc, VALUE *argv, VALUE self)
     grn_obj *table;
     grn_obj *result;
     grn_table_sort_key *keys;
-    int n_records, limit = 0;
     int i, n_keys;
+    int n_records, limit = 0;
     VALUE rb_keys, options;
     VALUE rb_limit;
     VALUE *rb_sort_keys;
+    grn_table_cursor *cursor;
+    VALUE rb_result;
 
     rb_grn_table_deconstruct(SELF(self), &table, &context,
 			     NULL, NULL,
 			     NULL, NULL, NULL);
 
     rb_scan_args(argc, argv, "11", &rb_keys, &options);
-    rb_grn_scan_options(options,
-			"limit", &rb_limit,
-			NULL);
+
+    if (!RVAL2CBOOL(rb_obj_is_kind_of(rb_keys, rb_cArray)))
+	rb_raise(rb_eArgError, "keys should be an array of key: <%s>",
+		 rb_grn_inspect(rb_keys));
 
     n_keys = RARRAY_LEN(rb_keys);
     rb_sort_keys = RARRAY_PTR(rb_keys);
@@ -838,15 +848,113 @@ rb_grn_table_sort (int argc, VALUE *argv, VALUE self)
 	}
     }
 
+    rb_grn_scan_options(options,
+			"limit", &rb_limit,
+			NULL);
+
     if (!NIL_P(rb_limit))
 	limit = NUM2INT(rb_limit);
 
     result = grn_table_create(context, NULL, 0, NULL, GRN_TABLE_NO_KEY,
 			      table, sizeof(grn_id));
-    n_records = grn_table_sort(context, table, limit,
-			       result, keys, n_keys);
+    n_records = grn_table_sort(context, table, limit, result, keys, n_keys);
 
-    return GRNOBJECT2RVAL(Qnil, context, result, RB_GRN_TRUE);
+    rb_result = rb_ary_new();
+    cursor = grn_table_cursor_open(context, result, NULL, 0, NULL, 0,
+				   GRN_CURSOR_ASCENDING);
+    while (grn_table_cursor_next(context, cursor) != GRN_ID_NIL) {
+	void *value;
+	grn_id *id;
+
+	grn_table_cursor_get_value(context, cursor, &value);
+	id = value;
+	rb_ary_push(rb_result, rb_grn_record_new(self, *id, Qnil));
+    }
+    grn_table_cursor_close(context, cursor);
+    grn_obj_close(context, result);
+
+    rb_grn_context_check(context, self); /* FIXME: here is too late */
+
+    return rb_result;
+}
+
+static VALUE
+rb_grn_table_group (int argc, VALUE *argv, VALUE self)
+{
+    grn_ctx *context = NULL;
+    grn_obj *table;
+    grn_table_sort_key *keys;
+    grn_table_group_result *results;
+    int i, n_keys, n_results;
+    grn_rc rc;
+    VALUE rb_keys;
+    VALUE *rb_sort_keys;
+    VALUE rb_results;
+
+    rb_grn_table_deconstruct(SELF(self), &table, &context,
+			     NULL, NULL,
+			     NULL, NULL, NULL);
+
+    rb_scan_args(argc, argv, "10", &rb_keys);
+
+    if (!RVAL2CBOOL(rb_obj_is_kind_of(rb_keys, rb_cArray)))
+	rb_raise(rb_eArgError, "keys should be an array of key: <%s>",
+		 rb_grn_inspect(rb_keys));
+
+    n_keys = RARRAY_LEN(rb_keys);
+    rb_sort_keys = RARRAY_PTR(rb_keys);
+    keys = ALLOCA_N(grn_table_sort_key, n_keys);
+    for (i = 0; i < n_keys; i++) {
+	VALUE rb_sort_options, rb_key;
+
+	if (RVAL2CBOOL(rb_obj_is_kind_of(rb_sort_keys[i], rb_cHash))) {
+	    rb_sort_options = rb_sort_keys[i];
+	} else {
+	    rb_sort_options = rb_hash_new();
+	    rb_hash_aset(rb_sort_options,
+			 RB_GRN_INTERN("key"),
+			 rb_sort_keys[i]);
+	}
+	rb_grn_scan_options(rb_sort_options,
+			    "key", &rb_key,
+			    NULL);
+	if (RVAL2CBOOL(rb_obj_is_kind_of(rb_key, rb_cString)))
+	    rb_key = rb_grn_table_get_column(self, rb_key);
+	keys[i].key = RVAL2GRNOBJECT(rb_key, &context);
+	keys[i].flags = 0;
+    }
+
+    n_results = n_keys;
+    results = ALLOCA_N(grn_table_group_result, n_results);
+    rb_results = rb_ary_new();
+    for (i = 0; i < n_results; i++) {
+	grn_obj *result;
+	grn_id range_id;
+	VALUE rb_result;
+
+	range_id = grn_obj_get_range(context, keys[i].key);
+	result = grn_table_create(context, NULL, 0, NULL,
+				  GRN_TABLE_HASH_KEY | GRN_OBJ_WITH_SUBREC,
+				  grn_ctx_at(context, range_id), 0);
+	results[i].table = result;
+	results[i].key_begin = 0;
+	results[i].key_end = 0;
+	results[i].limit = 0;
+	results[i].flags = 0;
+	results[i].op = GRN_OP_OR;
+
+	rb_result = GRNOBJECT2RVAL(Qnil, context, result, RB_GRN_TRUE);
+	rb_ary_push(rb_results, rb_result);
+    }
+
+    rc = grn_table_group(context, table, keys, n_keys, results, n_results);
+    rb_grn_context_check(context, self);
+    rb_grn_rc_check(rc, self);
+
+    if (n_results == 1)
+	return rb_ary_pop(rb_results);
+    else
+	return rb_results;
 }
 
 /*
@@ -914,6 +1022,247 @@ rb_grn_table_array_set (VALUE self, VALUE rb_id, VALUE rb_value)
     return Qnil;
 }
 
+/*
+ * Document-method: unlock
+ *
+ * call-seq:
+ *   table.unlock(options={})
+ *
+ * _table_のロックを解除する。
+ *
+ * 利用可能なオプションは以下の通り。
+ *
+ * [_:id_]
+ *   _:id_で指定したレコードのロックを解除する。（注:
+ *   groonga側が未実装のため、現在は無視される）
+ */
+static VALUE
+rb_grn_table_unlock (int argc, VALUE *argv, VALUE self)
+{
+    grn_id id = GRN_ID_NIL;
+    grn_ctx *context;
+    grn_obj *table;
+    grn_rc rc;
+    VALUE options, rb_id;
+
+    rb_scan_args(argc, argv, "01",  &options);
+
+    rb_grn_table_deconstruct(SELF(self), &table, &context,
+			     NULL, NULL,
+			     NULL, NULL, NULL);
+
+    rb_grn_scan_options(options,
+			"id", &rb_id,
+			NULL);
+
+    if (!NIL_P(rb_id))
+	id = NUM2UINT(rb_id);
+
+    rc = grn_obj_unlock(context, table, id);
+    rb_grn_context_check(context, self);
+    rb_grn_rc_check(rc, self);
+
+    return Qnil;
+}
+
+static VALUE
+rb_grn_table_unlock_ensure (VALUE self)
+{
+    return rb_grn_table_unlock(0, NULL, self);
+}
+
+/*
+ * Document-method: lock
+ *
+ * call-seq:
+ *   table.lock(options={})
+ *   table.lock(options={}) {...}
+ *
+ * _table_をロックする。ロックに失敗した場合は
+ * Groonga::ResourceDeadlockAvoided例外が発生する。
+ *
+ * ブロックを指定した場合はブロックを抜けたときにunlockする。
+ *
+ * 利用可能なオプションは以下の通り。
+ *
+ * [_:timeout_]
+ *   ロックを獲得できなかった場合は_:timeout_秒間ロックの獲
+ *   得を試みる。_:timeout_秒以内にロックを獲得できなかった
+ *   場合は例外が発生する。
+ * [_:id_]
+ *   _:id_で指定したレコードをロックする。（注: groonga側が
+ *   未実装のため、現在は無視される）
+ */
+static VALUE
+rb_grn_table_lock (int argc, VALUE *argv, VALUE self)
+{
+    grn_id id = GRN_ID_NIL;
+    grn_ctx *context;
+    grn_obj *table;
+    int timeout = 0;
+    grn_rc rc;
+    VALUE options, rb_timeout, rb_id;
+
+    rb_scan_args(argc, argv, "01",  &options);
+
+    rb_grn_table_deconstruct(SELF(self), &table, &context,
+			     NULL, NULL,
+			     NULL, NULL, NULL);
+
+    rb_grn_scan_options(options,
+			"timeout", &rb_timeout,
+			"id", &rb_id,
+			NULL);
+
+    if (!NIL_P(rb_timeout))
+	timeout = NUM2UINT(rb_timeout);
+
+    if (!NIL_P(rb_id))
+	id = NUM2UINT(rb_id);
+
+    rc = grn_obj_lock(context, table, id, timeout);
+    rb_grn_context_check(context, self);
+    rb_grn_rc_check(rc, self);
+
+    if (rb_block_given_p()) {
+	return rb_ensure(rb_yield, Qnil, rb_grn_table_unlock_ensure, self);
+    } else {
+	return Qnil;
+    }
+}
+
+/*
+ * Document-method: clear_lock
+ *
+ * call-seq:
+ *   table.clear_lock(options={})
+ *
+ * _table_のロックを強制的に解除する。
+ *
+ * 利用可能なオプションは以下の通り。
+ *
+ * [_:id_]
+ *   _:id_で指定したレコードのロックを強制的に解除する。
+ *   （注: groonga側が未実装のため、現在は無視される。実装さ
+ *   れるのではないかと思っているが、実装されないかもしれな
+ *   い。）
+ */
+static VALUE
+rb_grn_table_clear_lock (int argc, VALUE *argv, VALUE self)
+{
+    grn_id id = GRN_ID_NIL;
+    grn_ctx *context;
+    grn_obj *table;
+    VALUE options, rb_id;
+
+    rb_scan_args(argc, argv, "01",  &options);
+
+    rb_grn_table_deconstruct(SELF(self), &table, &context,
+			     NULL, NULL,
+			     NULL, NULL, NULL);
+
+    rb_grn_scan_options(options,
+			"id", &rb_id,
+			NULL);
+
+    if (!NIL_P(rb_id))
+	id = NUM2UINT(rb_id);
+
+    grn_obj_clear_lock(context, table);
+
+    return Qnil;
+}
+
+/*
+ * Document-method: locked?
+ *
+ * call-seq:
+ *   table.locked?(options={})
+ *
+ * _table_がロックされていれば+true+を返す。
+ *
+ * 利用可能なオプションは以下の通り。
+ *
+ * [_:id_]
+ *   _:id_で指定したレコードがロックされていれば+true+を返す。
+ *   （注: groonga側が未実装のため、現在は無視される。実装さ
+ *   れるのではないかと思っているが、実装されないかもしれな
+ *   い。）
+ */
+static VALUE
+rb_grn_table_is_locked (int argc, VALUE *argv, VALUE self)
+{
+    grn_id id = GRN_ID_NIL;
+    grn_ctx *context;
+    grn_obj *table;
+    VALUE options, rb_id;
+
+    rb_scan_args(argc, argv, "01",  &options);
+
+    rb_grn_table_deconstruct(SELF(self), &table, &context,
+			     NULL, NULL,
+			     NULL, NULL, NULL);
+
+    rb_grn_scan_options(options,
+			"id", &rb_id,
+			NULL);
+
+    if (!NIL_P(rb_id))
+	id = NUM2UINT(rb_id);
+
+    return CBOOL2RVAL(grn_obj_is_locked(context, table));
+}
+
+static VALUE
+rb_grn_table_select (int argc, VALUE *argv, VALUE self)
+{
+    grn_ctx *context;
+    grn_obj *table, *result, *expression;
+    grn_operator operator = GRN_OP_OR;
+    grn_rc rc;
+    VALUE options;
+    VALUE rb_name, rb_operator, rb_result;
+    VALUE rb_expression, builder;
+
+    rb_scan_args(argc, argv, "01", &options);
+
+    rb_grn_table_deconstruct(SELF(self), &table, &context,
+			     NULL, NULL,
+			     NULL, NULL, NULL);
+
+    rb_grn_scan_options(options,
+			"operator", &rb_operator,
+			"result", &rb_result,
+			"name", &rb_name,
+			NULL);
+
+    if (!NIL_P(rb_operator))
+	operator = NUM2INT(rb_operator);
+
+    if (NIL_P(rb_result)) {
+	result = grn_table_create(context, NULL, 0, NULL,
+				  GRN_TABLE_HASH_KEY | GRN_OBJ_WITH_SUBREC,
+				  table,
+				  0);
+	rb_result = GRNTABLE2RVAL(context, result, RB_GRN_TRUE);
+    } else {
+	result = RVAL2GRNTABLE(rb_result, &context);
+    }
+
+    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);
+
+    rc = grn_table_select(context, table, expression, result, operator);
+    rb_grn_context_check(context, self);
+    rb_grn_rc_check(rc, self);
+
+    return rb_result;
+}
+
 void
 rb_grn_init_table (VALUE mGrn)
 {
@@ -951,10 +1300,18 @@ rb_grn_init_table (VALUE mGrn)
     rb_define_method(rb_cGrnTable, "delete", rb_grn_table_delete, 1);
 
     rb_define_method(rb_cGrnTable, "sort", rb_grn_table_sort, -1);
+    rb_define_method(rb_cGrnTable, "group", rb_grn_table_group, -1);
 
     rb_define_method(rb_cGrnTable, "[]", rb_grn_table_array_reference, 1);
     rb_define_method(rb_cGrnTable, "[]=", rb_grn_table_array_set, 2);
 
+    rb_define_method(rb_cGrnTable, "lock", rb_grn_table_lock, -1);
+    rb_define_method(rb_cGrnTable, "unlock", rb_grn_table_unlock, -1);
+    rb_define_method(rb_cGrnTable, "clear_lock", rb_grn_table_clear_lock, -1);
+    rb_define_method(rb_cGrnTable, "locked?", rb_grn_table_is_locked, -1);
+
+    rb_define_method(rb_cGrnTable, "select", rb_grn_table_select, -1);
+
     rb_grn_init_table_key_support(mGrn);
     rb_grn_init_array(mGrn);
     rb_grn_init_hash(mGrn);