groonga 0.0.2 → 0.0.3

data/ext/rb-grn-array.c

@@ -65,6 +65,11 @@ VALUE rb_cGrnArray;
  * [+:value_size+]
  *   値の大きさを指定する。省略すると0になる。
  *
+ * [+:sub_records+]
+ *   +true+を指定すると#groupでグループ化したときに、
+ *   <tt>record[".:nsubrecs"]</tt>でグループに含まれるレコー
+ *   ドの件数を取得できる。
+ *
  * 使用例:
  *
  * 無名一時テーブルを生成する。
@@ -92,7 +97,7 @@ rb_grn_array_s_create (int argc, VALUE *argv, VALUE klass)
     grn_obj_flags flags = GRN_TABLE_NO_KEY;
     VALUE rb_table;
     VALUE options, rb_context, rb_name, rb_path, rb_persistent;
-    VALUE rb_value_size;
+    VALUE rb_value_size, rb_sub_records;
 
     rb_scan_args(argc, argv, "01", &options);
 
@@ -102,6 +107,7 @@ rb_grn_array_s_create (int argc, VALUE *argv, VALUE klass)
                         "path", &rb_path,
 			"persistent", &rb_persistent,
 			"value_size", &rb_value_size,
+			"sub_records", &rb_sub_records,
 			NULL);
 
     context = rb_grn_context_ensure(&rb_context);
@@ -109,6 +115,7 @@ rb_grn_array_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)) {
@@ -122,6 +129,9 @@ rb_grn_array_s_create (int argc, VALUE *argv, VALUE klass)
     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, NULL, value_size);
     if (!table)

data/ext/rb-grn-column.c

@@ -21,7 +21,6 @@
 #define SELF(object) ((RbGrnColumn *)DATA_PTR(object))
 
 VALUE rb_cGrnColumn;
-VALUE rb_cGrnVarSizeColumn;
 
 /*
  * Document-class: Groonga::Column < Groonga::Object
@@ -33,7 +32,7 @@ VALUE rb_cGrnVarSizeColumn;
  * カラムには大きく分けて3種類ある。
  * [Groonga::FixSizeColumn]
  *   固定長のデータを格納するカラム。
- * [Groonga::VarSizeColumn]
+ * [Groonga::VariableSizeColumn]
  *   可変長のデータを格納するカラム。
  * [Groonga::IndexColumn]
  *   転置インデックスを格納するカラム。全文検索や参照元レコー
@@ -65,6 +64,49 @@ rb_grn_column_to_ruby_object (VALUE klass, grn_ctx *context, grn_obj *column,
     return GRNOBJECT2RVAL(klass, context, column, owner);
 }
 
+void
+rb_grn_column_bind (RbGrnColumn *rb_column,
+		    grn_ctx *context, grn_obj *column)
+{
+    RbGrnObject *rb_grn_object;
+
+    rb_grn_object = RB_GRN_OBJECT(rb_column);
+
+    rb_column->value = grn_obj_open(context, GRN_BULK, 0,
+                                    rb_grn_object->range_id);
+}
+
+void
+rb_grn_column_finalizer (grn_ctx *context, grn_obj *grn_object,
+			 RbGrnColumn *rb_column)
+{
+    if (context && rb_column->value)
+	grn_obj_close(context, rb_column->value);
+    rb_column->value = NULL;
+}
+
+void
+rb_grn_column_deconstruct (RbGrnColumn *rb_column,
+			   grn_obj **column,
+			   grn_ctx **context,
+			   grn_id *domain_id,
+			   grn_obj **domain,
+			   grn_obj **value,
+			   grn_id *range_id,
+			   grn_obj **range)
+{
+    RbGrnObject *rb_grn_object;
+
+    rb_grn_object = RB_GRN_OBJECT(rb_column);
+    rb_grn_object_deconstruct(rb_grn_object, column, context,
+			      domain_id, domain,
+			      range_id, range);
+
+    if (value)
+	*value = rb_column->value;
+}
+
+
 /*
  * call-seq:
  *   column.table -> Groonga::Table
@@ -87,16 +129,101 @@ rb_grn_column_get_table (VALUE self)
     return GRNOBJECT2RVAL(Qnil, context, table, RB_GRN_FALSE);
 }
 
+/*
+ * call-seq:
+ *   column.local_name
+ *
+ * テーブル名を除いたカラム名を返す。
+ *
+ *   items = Groonga::Array.create(:name => "<items>")
+ *   title = items.define_column("title", "<shorttext>")
+ *   title.name # => "<items>.title"
+ *   title.local_name # => "title"
+ */
+static VALUE
+rb_grn_column_get_local_name (VALUE self)
+{
+    grn_ctx *context = NULL;
+    grn_obj *column;
+    int name_size;
+    VALUE rb_name;
+
+    rb_grn_object_deconstruct((RbGrnObject *)(SELF(self)), &column, &context,
+			      NULL, NULL,
+			      NULL, NULL);
+    name_size = grn_column_name(context, column, NULL, 0);
+    if (name_size == 0)
+	return Qnil;
+
+    rb_name = rb_str_buf_new(name_size);
+    rb_str_set_len(rb_name, name_size);
+    grn_column_name(context, column, RSTRING_PTR(rb_name), name_size);
+    return rb_name;
+}
+
+static VALUE
+rb_grn_column_select (int argc, VALUE *argv, VALUE self)
+{
+    grn_ctx *context;
+    grn_obj *table, *column, *result, *expression;
+    grn_operator operator = GRN_OP_OR;
+    grn_rc rc;
+    VALUE options;
+    VALUE rb_query, rb_name, rb_operator, rb_result;
+    VALUE rb_expression, builder;
+
+    rb_scan_args(argc, argv, "11", &rb_query, &options);
+
+    rb_grn_column_deconstruct(SELF(self), &column, &context,
+			      NULL, NULL,
+			      NULL, NULL, NULL);
+    table = grn_column_table(context, column);
+
+    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_column_expression_builder_new(self, rb_name, rb_query);
+    rb_expression = rb_grn_column_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_column (VALUE mGrn)
 {
     rb_cGrnColumn = rb_define_class_under(mGrn, "Column", rb_cGrnObject);
 
-    rb_cGrnVarSizeColumn =
-	rb_define_class_under(mGrn, "VarSizeColumn", rb_cGrnColumn);
-
     rb_define_method(rb_cGrnColumn, "table", rb_grn_column_get_table, 0);
+    rb_define_method(rb_cGrnColumn, "local_name",
+		     rb_grn_column_get_local_name, 0);
+
+    rb_define_method(rb_cGrnColumn, "select", rb_grn_column_select, -1);
 
     rb_grn_init_fix_size_column(mGrn);
+    rb_grn_init_variable_size_column(mGrn);
     rb_grn_init_index_column(mGrn);
 }

data/ext/rb-grn-context.c

@@ -20,8 +20,6 @@
 
 #define SELF(object) (RVAL2GRNCONTEXT(object))
 
-#define OBJECTS_TABLE_NAME "<ranguba:objects>"
-
 static VALUE cGrnContext;
 
 /*
@@ -58,90 +56,23 @@ rb_grn_context_from_ruby_object (VALUE object)
     return context;
 }
 
-void
-rb_grn_context_register (grn_ctx *context, RbGrnObject *object)
-{
-    grn_obj *objects;
-
-    if (!grn_ctx_db(context))
-	return;
-
-    objects = grn_ctx_get(context,
-			  OBJECTS_TABLE_NAME,
-			  strlen(OBJECTS_TABLE_NAME));
-    if (!objects)
-	objects = grn_table_create(context,
-				   OBJECTS_TABLE_NAME,
-				   strlen(OBJECTS_TABLE_NAME),
-				   NULL,
-				   GRN_OBJ_TABLE_HASH_KEY,
-				   grn_ctx_at(context, GRN_DB_UINT64),
-				   0);
-
-    grn_table_add(context, objects,
-		  &object, sizeof(RbGrnObject *),
-		  NULL);
-}
-
-void
-rb_grn_context_unregister (grn_ctx *context, RbGrnObject *object)
-{
-    grn_obj *objects;
-
-    if (!grn_ctx_db(context))
-	return;
-
-    objects = grn_ctx_get(context,
-			  OBJECTS_TABLE_NAME,
-			  strlen(OBJECTS_TABLE_NAME));
-    if (!objects)
-	return;
-
-    grn_table_delete(context, objects, &object, sizeof(RbGrnObject *));
-}
-
-void
-rb_grn_context_unbind (grn_ctx *context)
-{
-    grn_obj *database;
-    grn_obj *objects;
-
-    database = grn_ctx_db(context);
-    if (!database)
-	return;
-
-    objects = grn_ctx_get(context,
-			  OBJECTS_TABLE_NAME,
-			  strlen(OBJECTS_TABLE_NAME));
-    if (objects) {
-	grn_table_cursor *cursor;
-
-	cursor = grn_table_cursor_open(context, objects, NULL, 0, NULL, 0, 0);
-	while (grn_table_cursor_next(context, cursor) != GRN_ID_NIL) {
-	    void *value;
-	    RbGrnObject *object = NULL;
-	    grn_table_cursor_get_key(context, cursor, &value);
-	    memcpy(&object, value, sizeof(RbGrnObject *));
-	    object->object = NULL;
-	    object->unbind(object);
-	}
-	grn_table_cursor_close(context, cursor);
-	grn_obj_close(context, objects);
-    }
-
-    grn_obj_close(context, database);
-    grn_ctx_use(context, NULL);
-}
-
 static void
 rb_grn_context_free (void *pointer)
 {
     grn_ctx *context = pointer;
 
+    debug("context-free: %p\n", context);
     if (context->stat != GRN_CTX_FIN) {
-	rb_grn_context_unbind (context);
+	grn_obj *database;
+
+	database = grn_ctx_db(context);
+	debug("context:database: %p:%p\n", context, database);
+	if (database && database->header.type == GRN_DB) {
+	    grn_obj_close(context, database);
+	}
 	grn_ctx_fin(context);
     }
+    debug("context-free: %p: done\n", context);
     xfree(context);
 }
 
@@ -326,6 +257,8 @@ rb_grn_context_initialize (int argc, VALUE *argv, VALUE self)
 	GRN_CTX_SET_ENCODING(context, encoding);
     }
 
+    debug("context new: %p\n", context);
+
     return Qnil;
 }
 
@@ -410,6 +343,77 @@ rb_grn_context_get_database (VALUE self)
     return GRNDB2RVAL(context, grn_ctx_db(context), RB_GRN_FALSE);
 }
 
+static const char *
+grn_type_name_old_to_new (const char *name, unsigned int name_size)
+{
+    unsigned int i;
+
+    for (i = 0; i < name_size; i++) {
+	if (name[i] == '\0')
+	    return NULL;
+    }
+
+    if (strcmp(name, "<int>") == 0) {
+	return "Int32";
+    } else if (strcmp(name, "<uint>") == 0) {
+	return "UInt32";
+    } else if (strcmp(name, "<int64>") == 0) {
+	return "Int64";
+    } else if (strcmp(name, "<uint64>") == 0) {
+	return "UInt64";
+    } else if (strcmp(name, "<float>") == 0) {
+	return "Float";
+    } else if (strcmp(name, "<time>") == 0) {
+	return "Time";
+    } else if (strcmp(name, "<shorttext>") == 0) {
+	return "ShortText";
+    } else if (strcmp(name, "<text>") == 0) {
+	return "Text";
+    } else if (strcmp(name, "<longtext>") == 0) {
+	return "LongText";
+    } else if (strcmp(name, "<token:delimit>") == 0) {
+	return "TokenDelimit";
+    } else if (strcmp(name, "<token:unigram>") == 0) {
+	return "TokenUnigram";
+    } else if (strcmp(name, "<token:bigram>") == 0) {
+	return "TokenBigram";
+    } else if (strcmp(name, "<token:trigram>") == 0) {
+	return "TokenTrigram";
+    } else if (strcmp(name, "<token:mecab>") == 0) {
+	return "TokenMecab";
+    }
+
+    return NULL;
+}
+
+grn_obj *
+rb_grn_context_get_backward_compatibility (grn_ctx *context,
+					   const char *name,
+					   unsigned int name_size)
+{
+    grn_obj *object;
+
+    object = grn_ctx_get(context, name, name_size);
+    if (!object) {
+	const char *new_type_name;
+
+	new_type_name = grn_type_name_old_to_new(name, name_size);
+	if (new_type_name) {
+	    object = grn_ctx_get(context, new_type_name, strlen(new_type_name));
+#if 0
+	    if (object) {
+		rb_warn("deprecated old data type name <%s> is used. "
+			"Use new data type name <%s> instead.",
+			name, new_type_name);
+	    }
+#endif
+	}
+    }
+
+    return object;
+}
+
+
 /*
  * call-seq:
  *   context[name] -> Groonga::Object or nil
@@ -432,11 +436,12 @@ rb_grn_context_array_reference (VALUE self, VALUE name_or_id)
     context = SELF(self);
     if (RVAL2CBOOL(rb_obj_is_kind_of(name_or_id, rb_cString))) {
 	const char *name;
-	unsigned name_size;
+	unsigned int name_size;
 
 	name = StringValuePtr(name_or_id);
 	name_size = RSTRING_LEN(name_or_id);
-	object = grn_ctx_get(context, name, name_size);
+	object = rb_grn_context_get_backward_compatibility(context,
+							   name, name_size);
     } else if (RVAL2CBOOL(rb_obj_is_kind_of(name_or_id, rb_cInteger))) {
 	unsigned id;
 	id = NUM2UINT(name_or_id);

data/ext/rb-grn-database.c

@@ -50,6 +50,41 @@ rb_grn_database_to_ruby_object (grn_ctx *context, grn_obj *database,
     return GRNOBJECT2RVAL(rb_cGrnDatabase, context, database, owner);
 }
 
+static void
+rb_grn_database_deconstruct (RbGrnObject *rb_grn_database,
+			     grn_obj **database,
+			     grn_ctx **context,
+			     grn_id *domain_id,
+			     grn_obj **domain,
+			     grn_id *range_id,
+			     grn_obj **range)
+{
+    rb_grn_object_deconstruct(rb_grn_database, database, context,
+			      domain_id, domain,
+			      range_id, range);
+}
+
+/*
+ * Document-method: close
+ *
+ * call-seq:
+ *   database.close
+ *
+ * _database_が使用しているリソースを開放する。これ以降_database_を
+ * 使うことはできない。
+ */
+static VALUE
+rb_grn_database_close (VALUE self)
+{
+    VALUE rb_context;
+
+    rb_context = rb_iv_get(self, "context");
+    if (!NIL_P(rb_context))
+	rb_iv_set(rb_context, "database", Qnil);
+
+    return rb_grn_object_close(self);
+}
+
 /*
  * call-seq:
  *   Groonga::Database.create(options=nil) -> Groonga::Database
@@ -79,7 +114,7 @@ static VALUE
 rb_grn_database_s_create (int argc, VALUE *argv, VALUE klass)
 {
     grn_ctx *context;
-    grn_obj *database;
+    grn_obj *old_database, *database;
     grn_db_create_optarg create_args;
     const char *path = NULL;
     VALUE rb_database;
@@ -100,17 +135,21 @@ rb_grn_database_s_create (int argc, VALUE *argv, VALUE klass)
     create_args.builtin_type_names = NULL;
     create_args.n_builtin_type_names = 0;
 
+    old_database = grn_ctx_db(context);
+    if (old_database)
+	grn_obj_close(context, old_database);
     database = grn_db_create(context, path, &create_args);
     rb_grn_context_check(context, rb_ary_new4(argc, argv));
     rb_database = rb_grn_object_alloc(klass);
-    rb_grn_object_assign(rb_database, rb_context, context,
-			 database, RB_GRN_TRUE);
+    rb_grn_object_assign(Qnil, rb_database, rb_context, context, database);
     rb_iv_set(rb_database, "context", rb_context);
+    if (!NIL_P(rb_context))
+	rb_iv_set(rb_context, "database", rb_database);
     rb_grn_context_check(context, rb_ary_new4(argc, argv));
 
     if (rb_block_given_p())
         return rb_ensure(rb_yield, rb_database,
-			 rb_grn_object_close, rb_database);
+			 rb_grn_database_close, rb_database);
     else
         return rb_database;
 }
@@ -135,7 +174,7 @@ static VALUE
 rb_grn_database_initialize (int argc, VALUE *argv, VALUE self)
 {
     grn_ctx *context;
-    grn_obj *database;
+    grn_obj *old_database, *database;
     const char *path;
     VALUE rb_path, options, rb_context;
 
@@ -148,10 +187,17 @@ rb_grn_database_initialize (int argc, VALUE *argv, VALUE self)
 
     context = rb_grn_context_ensure(&rb_context);
 
+    old_database = grn_ctx_db(context);
+    if (old_database)
+	grn_obj_close(context, old_database);
     database = grn_db_open(context, path);
-    rb_grn_object_assign(self, rb_context, context, database, RB_GRN_TRUE);
+    rb_grn_object_assign(Qnil, self, rb_context, context, database);
     rb_grn_context_check(context, self);
 
+    rb_iv_set(self, "context", rb_context);
+    if (!NIL_P(rb_context))
+	rb_iv_set(rb_context, "database", self);
+
     return Qnil;
 }
 
@@ -179,7 +225,7 @@ rb_grn_database_s_open (int argc, VALUE *argv, VALUE klass)
     database = rb_grn_object_alloc(klass);
     rb_grn_database_initialize(argc, argv, database);
     if (rb_block_given_p())
-        return rb_ensure(rb_yield, database, rb_grn_object_close, database);
+        return rb_ensure(rb_yield, database, rb_grn_database_close, database);
     else
         return database;
 }
@@ -204,8 +250,8 @@ rb_grn_database_each (VALUE self)
     VALUE rb_cursor;
     grn_id id;
 
-    rb_grn_object_deconstruct((RbGrnObject *)SELF(self), &database, &context,
-			      NULL, NULL, NULL, NULL);
+    rb_grn_database_deconstruct(SELF(self), &database, &context,
+				NULL, NULL, NULL, NULL);
     cursor = grn_table_cursor_open(context, database, NULL, 0, NULL, 0, 0);
     rb_cursor = GRNTABLECURSOR2RVAL(Qnil, context, cursor);
     rb_iv_set(self, "cursor", rb_cursor);
@@ -222,6 +268,124 @@ rb_grn_database_each (VALUE self)
     return Qnil;
 }
 
+/*
+ * Document-method: unlock
+ *
+ * call-seq:
+ *   database.unlock
+ *
+ * _database_のロックを解除する。
+ */
+static VALUE
+rb_grn_database_unlock (VALUE self)
+{
+    grn_ctx *context;
+    grn_obj *database;
+    grn_rc rc;
+
+    rb_grn_database_deconstruct(SELF(self), &database, &context,
+				NULL, NULL, NULL, NULL);
+
+    rc = grn_obj_unlock(context, database, GRN_ID_NIL);
+    rb_grn_context_check(context, self);
+    rb_grn_rc_check(rc, self);
+
+    return Qnil;
+}
+
+/*
+ * Document-method: lock
+ *
+ * call-seq:
+ *   database.lock(options={})
+ *   database.lock(options={}) {...}
+ *
+ * _database_をロックする。ロックに失敗した場合は
+ * Groonga::ResourceDeadlockAvoided例外が発生する。
+ *
+ * ブロックを指定した場合はブロックを抜けたときにunlockする。
+ *
+ * 利用可能なオプションは以下の通り。
+ *
+ * [_:timeout_]
+ *   ロックを獲得できなかった場合は_:timeout_秒間ロックの獲
+ *   得を試みる。_:timeout_秒以内にロックを獲得できなかった
+ *   場合は例外が発生する。
+ */
+static VALUE
+rb_grn_database_lock (int argc, VALUE *argv, VALUE self)
+{
+    grn_ctx *context;
+    grn_obj *database;
+    int timeout = 0;
+    grn_rc rc;
+    VALUE options, rb_timeout;
+
+    rb_scan_args(argc, argv, "01",  &options);
+
+    rb_grn_database_deconstruct(SELF(self), &database, &context,
+				NULL, NULL, NULL, NULL);
+
+    rb_grn_scan_options(options,
+			"timeout", &rb_timeout,
+			NULL);
+
+    if (!NIL_P(rb_timeout))
+	timeout = NUM2UINT(rb_timeout);
+
+    rc = grn_obj_lock(context, database, GRN_ID_NIL, 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_database_unlock, self);
+    } else {
+	return Qnil;
+    }
+}
+
+/*
+ * Document-method: clear_lock
+ *
+ * call-seq:
+ *   database.clear_lock
+ *
+ * _database_のロックを強制的に解除する。
+ */
+static VALUE
+rb_grn_database_clear_lock (VALUE self)
+{
+    grn_ctx *context;
+    grn_obj *database;
+
+    rb_grn_database_deconstruct(SELF(self), &database, &context,
+				NULL, NULL, NULL, NULL);
+
+    grn_obj_clear_lock(context, database);
+
+    return Qnil;
+}
+
+/*
+ * Document-method: locked?
+ *
+ * call-seq:
+ *   database.locked?
+ *
+ * _database_がロックされていれば+true+を返す。
+ */
+static VALUE
+rb_grn_database_is_locked (VALUE self)
+{
+    grn_ctx *context;
+    grn_obj *database;
+
+    rb_grn_database_deconstruct(SELF(self), &database, &context,
+				NULL, NULL, NULL, NULL);
+
+    return CBOOL2RVAL(grn_obj_is_locked(context, database));
+}
+
 void
 rb_grn_init_database (VALUE mGrn)
 {
@@ -239,4 +403,13 @@ rb_grn_init_database (VALUE mGrn)
 
     rb_define_method(rb_cGrnDatabase, "each",
 		     rb_grn_database_each, 0);
+
+    rb_define_method(rb_cGrnDatabase, "close",
+		     rb_grn_database_close, 0);
+
+    rb_define_method(rb_cGrnDatabase, "lock", rb_grn_database_lock, -1);
+    rb_define_method(rb_cGrnDatabase, "unlock", rb_grn_database_unlock, 0);
+    rb_define_method(rb_cGrnDatabase, "clear_lock",
+		     rb_grn_database_clear_lock, 0);
+    rb_define_method(rb_cGrnDatabase, "locked?", rb_grn_database_is_locked, 0);
 }