groonga 0.0.1 → 0.0.2

data/ext/rb-grn-patricia-trie.c

@@ -18,14 +18,156 @@
 
 #include "rb-grn.h"
 
-#define SELF(object) (RVAL2GRNTABLE(object))
+#define SELF(object) ((RbGrnTableKeySupport *)DATA_PTR(object))
 
 VALUE rb_cGrnPatriciaTrie;
 
 static VALUE
 rb_grn_patricia_trie_s_create (int argc, VALUE *argv, VALUE self)
 {
-    return rb_grn_table_s_create(argc, argv, self, GRN_TABLE_PAT_KEY);
+    grn_ctx *context;
+    grn_obj *key_type = NULL, *table;
+    const char *name = NULL, *path = NULL;
+    unsigned name_size = 0, value_size = 0;
+    grn_obj_flags flags = GRN_TABLE_PAT_KEY;
+    VALUE rb_table;
+    VALUE options, rb_context, rb_name, rb_path, rb_persistent;
+    VALUE rb_key_normalize, rb_key_with_sis, rb_key_type, rb_value_size;
+    VALUE rb_default_tokenizer;
+
+    rb_scan_args(argc, argv, "01", &options);
+
+    rb_grn_scan_options(options,
+			"context", &rb_context,
+			"name", &rb_name,
+                        "path", &rb_path,
+			"persistent", &rb_persistent,
+			"key_normalize", &rb_key_normalize,
+			"key_with_sis", &rb_key_with_sis,
+			"key_type", &rb_key_type,
+			"value_size", &rb_value_size,
+			"default_tokenizer", &rb_default_tokenizer,
+			NULL);
+
+    context = rb_grn_context_ensure(&rb_context);
+
+    if (!NIL_P(rb_name)) {
+        name = StringValuePtr(rb_name);
+	name_size = RSTRING_LEN(rb_name);
+    }
+
+    if (!NIL_P(rb_path)) {
+        path = StringValueCStr(rb_path);
+	flags |= GRN_OBJ_PERSISTENT;
+    }
+
+    if (RVAL2CBOOL(rb_persistent))
+	flags |= GRN_OBJ_PERSISTENT;
+
+    if (RVAL2CBOOL(rb_key_normalize))
+	flags |= GRN_OBJ_KEY_NORMALIZE;
+
+    if (RVAL2CBOOL(rb_key_with_sis))
+	flags |= GRN_OBJ_KEY_WITH_SIS;
+
+    if (NIL_P(rb_key_type)) {
+	flags |= GRN_OBJ_KEY_VAR_SIZE;
+    } else {
+	key_type = RVAL2GRNOBJECT(rb_key_type, &context);
+    }
+
+    if (!NIL_P(rb_value_size))
+	value_size = NUM2UINT(rb_value_size);
+
+    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_grn_context_check(context, rb_table);
+
+    if (!NIL_P(rb_default_tokenizer))
+	rb_funcall(rb_table, rb_intern("default_tokenizer="), 1,
+		   rb_default_tokenizer);
+
+    if (rb_block_given_p())
+        return rb_ensure(rb_yield, rb_table, rb_grn_object_close, rb_table);
+    else
+        return rb_table;
+}
+
+static VALUE
+rb_grn_patricia_trie_search (int argc, VALUE *argv, VALUE self)
+{
+    grn_rc rc;
+    grn_ctx *context;
+    grn_obj *table;
+    grn_id domain_id;
+    grn_obj *key, *domain, *result;
+    grn_sel_operator operator;
+    grn_search_optarg search_options;
+    rb_grn_boolean search_options_is_set = RB_GRN_TRUE;
+    VALUE rb_key, options, rb_result, rb_operator, rb_type;
+
+    rb_grn_table_key_support_deconstruct(SELF(self), &table, &context,
+					 &key, &domain_id, &domain,
+					 NULL, NULL, NULL);
+
+    rb_scan_args(argc, argv, "11", &rb_key, &options);
+
+    RVAL2GRNKEY(rb_key, context, key, domain_id, domain, self);
+
+    rb_grn_scan_options(options,
+			"result", &rb_result,
+			"operator", &rb_operator,
+			"type", &rb_type,
+			NULL);
+
+    if (NIL_P(rb_result)) {
+	result = grn_table_create(context, NULL, 0, NULL,
+				  GRN_OBJ_TABLE_HASH_KEY | GRN_OBJ_WITH_SUBREC,
+				  table, 0);
+	rb_grn_context_check(context, self);
+	rb_result = GRNOBJECT2RVAL(Qnil, context, result, RB_GRN_TRUE);
+    } else {
+	result = RVAL2GRNOBJECT(rb_result, &context);
+    }
+
+    operator = RVAL2GRNSELECTOPERATOR(rb_operator);
+
+    search_options.flags = 0;
+    if (NIL_P(rb_type)) {
+	search_options_is_set = RB_GRN_FALSE;
+    } else if (rb_grn_equal_option(rb_type, "exact")) {
+	search_options.flags |= GRN_SEARCH_EXACT;
+    } else if (rb_grn_equal_option(rb_type, "longest_common_prefix") ||
+	       rb_grn_equal_option(rb_type, "longest-common-prefix")) {
+	search_options.flags |= GRN_SEARCH_LCP;
+    } else if (rb_grn_equal_option(rb_type, "suffix")) {
+	search_options.flags |= GRN_SEARCH_SUFFIX;
+    } else if (rb_grn_equal_option(rb_type, "prefix")) {
+	search_options.flags |= GRN_SEARCH_PREFIX;
+    } else if (rb_grn_equal_option(rb_type, "term_extract") ||
+	       rb_grn_equal_option(rb_type, "term-extract")) {
+	search_options.flags |= GRN_SEARCH_TERM_EXTRACT;
+    } else if (rb_grn_equal_option(rb_type, "suffix")) {
+	search_options.flags |= GRN_SEARCH_SUFFIX;
+    } else {
+	rb_raise(rb_eArgError,
+		 "search type should be one of "
+		 "[nil, :exact, :longest_common_prefix, :suffix, "
+		 ":prefix, :term_extract]: %s",
+		 rb_grn_inspect(rb_type));
+    }
+
+    rc = grn_obj_search(context, table, key,
+			result, operator,
+			search_options_is_set ? &search_options : NULL);
+    rb_grn_rc_check(rc, self);
+
+    return rb_result;
 }
 
 void
@@ -33,8 +175,12 @@ rb_grn_init_patricia_trie (VALUE mGrn)
 {
     rb_cGrnPatriciaTrie =
 	rb_define_class_under(mGrn, "PatriciaTrie", rb_cGrnTable);
+    rb_define_alloc_func(rb_cGrnPatriciaTrie, rb_grn_table_key_support_alloc);
 
     rb_include_module(rb_cGrnPatriciaTrie, rb_mGrnTableKeySupport);
     rb_define_singleton_method(rb_cGrnPatriciaTrie, "create",
 			       rb_grn_patricia_trie_s_create, -1);
+
+    rb_define_method(rb_cGrnPatriciaTrie, "search",
+		     rb_grn_patricia_trie_search, -1);
 }

data/ext/rb-grn-query.c

@@ -60,8 +60,8 @@ rb_rb_grn_query_free (void *object)
 {
     RbGrnQuery *rb_grn_query = object;
 
-    if (rb_grn_query->context && rb_grn_query->query && rb_grn_query->owner)
-	/* grn_query_close(rb_grn_query->context, rb_grn_query->query) */;
+    if (rb_grn_query->owner && rb_grn_query->context && rb_grn_query->query)
+	grn_query_close(rb_grn_query->context, rb_grn_query->query);
 
     xfree(object);
 }
@@ -143,7 +143,7 @@ rb_grn_query_initialize (int argc, VALUE *argv, VALUE self)
                         "max_expressions", &rb_max_expressions,
                         NULL);
 
-    context = rb_grn_context_ensure(rb_context);
+    context = rb_grn_context_ensure(&rb_context);
 
     default_operator = RVAL2GRNSELECTOPERATOR(rb_default_operator);
 
@@ -160,6 +160,8 @@ rb_grn_query_initialize (int argc, VALUE *argv, VALUE self)
     rb_grn_query->query = query;
     rb_grn_query->owner = RB_GRN_TRUE;
 
+    rb_iv_set(self, "context", rb_context);
+
     return Qnil;
 }
 

data/ext/rb-grn-record.c

@@ -21,9 +21,10 @@
 VALUE rb_cGrnRecord;
 
 VALUE
-rb_grn_record_new (VALUE table, grn_id id)
+rb_grn_record_new (VALUE table, grn_id id, VALUE values)
 {
-    return rb_funcall(rb_cGrnRecord, rb_intern("new"), 2, table, UINT2NUM(id));
+    return rb_funcall(rb_cGrnRecord, rb_intern("new"), 3,
+		      table, UINT2NUM(id), values);
 }
 
 void

data/ext/rb-grn-snippet.c

@@ -64,8 +64,8 @@ rb_rb_grn_snippet_free (void *object)
 {
     RbGrnSnippet *rb_grn_snippet = object;
 
-    if (rb_grn_snippet->context && rb_grn_snippet->snippet &&
-	rb_grn_snippet->owner)
+    if (rb_grn_snippet->owner &&
+	rb_grn_snippet->context && rb_grn_snippet->snippet)
         grn_snip_close(rb_grn_snippet->context,
                        rb_grn_snippet->snippet);
 
@@ -127,7 +127,7 @@ rb_grn_snippet_initialize (int argc, VALUE *argv, VALUE self)
                         "html_escape", &rb_html_escape,
                         NULL);
 
-    context = rb_grn_context_ensure(rb_context);
+    context = rb_grn_context_ensure(&rb_context);
 
     if (RVAL2CBOOL(rb_normalize))
         flags |= GRN_SNIP_NORMALIZE;
@@ -165,6 +165,8 @@ rb_grn_snippet_initialize (int argc, VALUE *argv, VALUE self)
     rb_grn_snippet->snippet = snippet;
     rb_grn_snippet->owner = RB_GRN_TRUE;
 
+    rb_iv_set(self, "context", rb_context);
+
     return Qnil;
 }
 

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

@@ -18,7 +18,7 @@
 
 #include "rb-grn.h"
 
-#define SELF(object) (RVAL2GRNTABLECURSOR(object))
+#define SELF(object) ((RbGrnTableCursor *)DATA_PTR(object))
 
 VALUE rb_mGrnTableCursorKeySupport;
 
@@ -29,8 +29,8 @@ rb_grn_table_cursor_get_key (VALUE self)
     grn_ctx *context;
     grn_table_cursor *cursor;
 
-    context = rb_grn_table_cursor_ensure_context(self, Qnil);
-    cursor = SELF(self);
+    rb_grn_table_cursor_deconstruct(SELF(self), &cursor, &context,
+				    NULL, NULL, NULL, NULL);
     if (context && cursor) {
         void *key;
         int key_size;

data/ext/rb-grn-table-cursor.c

@@ -18,53 +18,18 @@
 
 #include "rb-grn.h"
 
-#define SELF(object) (rb_rb_grn_table_cursor_from_ruby_object(object))
-
-typedef struct _RbGrnTableCursor RbGrnTableCursor;
-struct _RbGrnTableCursor
-{
-    grn_ctx *context;
-    grn_table_cursor *cursor;
-    rb_grn_boolean owner;
-};
+#define SELF(object) ((RbGrnTableCursor *)DATA_PTR(object))
 
 VALUE rb_cGrnTableCursor;
 
-static RbGrnTableCursor *
-rb_rb_grn_table_cursor_from_ruby_object (VALUE object)
+grn_table_cursor *
+rb_grn_table_cursor_from_ruby_object (VALUE object, grn_ctx **context)
 {
-    RbGrnTableCursor *rb_grn_table_cursor;
-
     if (!RVAL2CBOOL(rb_obj_is_kind_of(object, rb_cGrnTableCursor))) {
 	rb_raise(rb_eTypeError, "not a groonga table cursor");
     }
 
-    Data_Get_Struct(object, RbGrnTableCursor, rb_grn_table_cursor);
-    if (!rb_grn_table_cursor)
-	rb_raise(rb_eGrnError, "groonga table cursor is NULL");
-
-    return rb_grn_table_cursor;
-}
-
-grn_table_cursor *
-rb_grn_table_cursor_from_ruby_object (VALUE object)
-{
-    if (NIL_P(object))
-        return NULL;
-
-    return SELF(object)->cursor;
-}
-
-static void
-rb_rb_grn_table_cursor_free (void *object)
-{
-    RbGrnTableCursor *rb_grn_table_cursor = object;
-
-    if (rb_grn_table_cursor->context && rb_grn_table_cursor->cursor &&
-	rb_grn_table_cursor->owner)
-	grn_table_cursor_close(rb_grn_table_cursor->context,
-			       rb_grn_table_cursor->cursor);
-    xfree(object);
+    return RVAL2GRNOBJECT(object, context);
 }
 
 VALUE
@@ -94,72 +59,98 @@ rb_grn_table_cursor_to_ruby_class (grn_obj *object)
 
 VALUE
 rb_grn_table_cursor_to_ruby_object (VALUE klass, grn_ctx *context,
-                                    grn_table_cursor *cursor)
+				    grn_table_cursor *cursor,
+				    rb_grn_boolean owner)
 {
-    RbGrnTableCursor *rb_grn_table_cursor;
+    if (NIL_P(klass))
+	klass = rb_grn_table_cursor_to_ruby_class(cursor);
+    return GRNOBJECT2RVAL(klass, context, cursor, owner);
+}
 
-    if (!cursor)
-        return Qnil;
+void
+rb_grn_table_cursor_unbind (RbGrnTableCursor *rb_grn_table_cursor)
+{
+    RbGrnObject *rb_grn_object;
 
-    rb_grn_table_cursor = ALLOC(RbGrnTableCursor);
-    rb_grn_table_cursor->context = context;
-    rb_grn_table_cursor->cursor = cursor;
-    rb_grn_table_cursor->owner = RB_GRN_TRUE; /* FIXME */
+    rb_grn_object = RB_GRN_OBJECT(rb_grn_table_cursor);
+    rb_grn_object_unbind(rb_grn_object);
+}
 
-    if (NIL_P(klass))
-        klass = GRNTABLECURSOR2RCLASS(cursor);
+static void
+rb_grn_table_cursor_free (void *object)
+{
+    RbGrnTableCursor *rb_grn_table_cursor = object;
 
-    return Data_Wrap_Struct(klass, NULL,
-                            rb_rb_grn_table_cursor_free, rb_grn_table_cursor);
+    rb_grn_table_cursor_unbind(rb_grn_table_cursor);
+    xfree(rb_grn_table_cursor);
 }
 
-static VALUE
+VALUE
 rb_grn_table_cursor_alloc (VALUE klass)
 {
-    return Data_Wrap_Struct(klass, NULL, rb_rb_grn_table_cursor_free, NULL);
+    return Data_Wrap_Struct(klass, NULL, rb_grn_table_cursor_free, NULL);
 }
 
-grn_ctx *
-rb_grn_table_cursor_ensure_context (VALUE cursor, VALUE rb_context)
+void
+rb_grn_table_cursor_bind (RbGrnTableCursor *rb_grn_table_cursor,
+			  grn_ctx *context, grn_table_cursor *cursor,
+			  rb_grn_boolean owner)
 {
-    if (NIL_P(rb_context)) {
-	RbGrnTableCursor *rb_grn_table_cursor;
-
-	rb_grn_table_cursor = SELF(cursor);
-	if (rb_grn_table_cursor && rb_grn_table_cursor->context)
-	    return rb_grn_table_cursor->context;
-    }
+    RbGrnObject *rb_grn_object;
 
-    return rb_grn_context_ensure(rb_context);
+    rb_grn_object = RB_GRN_OBJECT(rb_grn_table_cursor);
+    rb_grn_object_bind(rb_grn_object, context, cursor, owner);
+    rb_grn_object->unbind = RB_GRN_UNBIND_FUNCTION(rb_grn_table_cursor_unbind);
 }
 
-VALUE
-rb_grn_table_cursor_close (VALUE self)
+void
+rb_grn_table_cursor_assign (VALUE self, VALUE rb_context,
+			    grn_ctx *context, grn_table_cursor *cursor,
+			    rb_grn_boolean owner)
 {
     RbGrnTableCursor *rb_grn_table_cursor;
 
-    rb_grn_table_cursor = SELF(self);
-    if (rb_grn_table_cursor->context && rb_grn_table_cursor->cursor) {
-        grn_rc rc = GRN_SUCCESS;
+    rb_grn_table_cursor = ALLOC(RbGrnTableCursor);
+    DATA_PTR(self) = rb_grn_table_cursor;
+    rb_grn_table_cursor_bind(rb_grn_table_cursor, context, cursor, owner);
 
-	if (rb_grn_table_cursor->owner)
-	    rc = grn_table_cursor_close(rb_grn_table_cursor->context,
-					rb_grn_table_cursor->cursor);
-        rb_grn_table_cursor->context = NULL;
-        rb_grn_table_cursor->cursor = NULL;
-	rb_grn_table_cursor->owner = RB_GRN_FALSE;
-        rb_grn_rc_check(rc, self);
-    }
+    rb_iv_set(self, "context", rb_context);
+}
+
+void
+rb_grn_table_cursor_deconstruct (RbGrnTableCursor *rb_grn_table_cursor,
+				 grn_table_cursor **cursor,
+				 grn_ctx **context,
+				 grn_id *domain_id,
+				 grn_obj **domain,
+				 grn_id *range_id,
+				 grn_obj **range)
+{
+    RbGrnObject *rb_grn_object;
+
+    rb_grn_object = RB_GRN_OBJECT(rb_grn_table_cursor);
+    rb_grn_object_deconstruct(rb_grn_object, cursor, context,
+			      domain_id, domain,
+			      range_id, range);
+}
+
+VALUE
+rb_grn_table_cursor_close (VALUE self)
+{
+    rb_grn_table_cursor_unbind(SELF(self));
     return Qnil;
 }
 
 static VALUE
 rb_grn_table_cursor_closed_p (VALUE self)
 {
-    RbGrnTableCursor *rb_grn_table_cursor;
+    grn_table_cursor *cursor;
+    grn_ctx *context;
 
-    rb_grn_table_cursor = SELF(self);
-    if (rb_grn_table_cursor->context && rb_grn_table_cursor->cursor)
+    rb_grn_table_cursor_deconstruct(SELF(self), &cursor, &context,
+				    NULL, NULL, NULL, NULL);
+
+    if (context && cursor)
         return Qfalse;
     else
         return Qtrue;
@@ -168,17 +159,17 @@ rb_grn_table_cursor_closed_p (VALUE self)
 static VALUE
 rb_grn_table_cursor_get_value (VALUE self)
 {
+    grn_ctx *context;
+    grn_table_cursor *cursor;
     VALUE rb_value = Qnil;
-    RbGrnTableCursor *rb_grn_table_cursor;
 
-    rb_grn_table_cursor = SELF(self);
-    if (rb_grn_table_cursor->context && rb_grn_table_cursor->cursor) {
+    rb_grn_table_cursor_deconstruct(SELF(self), &cursor, &context,
+				    NULL, NULL, NULL, NULL);
+    if (context && cursor) {
         int n;
         void *value;
 
-        n = grn_table_cursor_get_value(rb_grn_table_cursor->context,
-                                       rb_grn_table_cursor->cursor,
-                                       &value);
+        n = grn_table_cursor_get_value(context, cursor, &value);
         rb_value = rb_str_new(value, n);
     }
 
@@ -188,15 +179,18 @@ rb_grn_table_cursor_get_value (VALUE self)
 static VALUE
 rb_grn_table_cursor_set_value (VALUE self, VALUE value)
 {
-    RbGrnTableCursor *rb_grn_table_cursor;
+    grn_ctx *context;
+    grn_table_cursor *cursor;
 
-    rb_grn_table_cursor = SELF(self);
-    if (rb_grn_table_cursor->context && rb_grn_table_cursor->cursor) {
+    rb_grn_table_cursor_deconstruct(SELF(self), &cursor, &context,
+				    NULL, NULL, NULL, NULL);
+    if (context && cursor) {
         grn_rc rc;
 
-        rc = grn_table_cursor_set_value(rb_grn_table_cursor->context,
-                                        rb_grn_table_cursor->cursor,
-                                        StringValuePtr(value), GRN_OBJ_SET);
+        rc = grn_table_cursor_set_value(context,
+                                        cursor,
+                                        StringValuePtr(value),
+					GRN_OBJ_SET);
         rb_grn_rc_check(rc, self);
     }
 
@@ -206,14 +200,15 @@ rb_grn_table_cursor_set_value (VALUE self, VALUE value)
 static VALUE
 rb_grn_table_cursor_delete (VALUE self)
 {
-    RbGrnTableCursor *rb_grn_table_cursor;
+    grn_ctx *context;
+    grn_table_cursor *cursor;
 
-    rb_grn_table_cursor = SELF(self);
-    if (rb_grn_table_cursor->context && rb_grn_table_cursor->cursor) {
+    rb_grn_table_cursor_deconstruct(SELF(self), &cursor, &context,
+				    NULL, NULL, NULL, NULL);
+    if (context && cursor) {
         grn_rc rc;
 
-        rc = grn_table_cursor_delete(rb_grn_table_cursor->context,
-                                     rb_grn_table_cursor->cursor);
+        rc = grn_table_cursor_delete(context, cursor);
         rb_grn_rc_check(rc, self);
     }
 
@@ -224,16 +219,18 @@ static VALUE
 rb_grn_table_cursor_next (VALUE self)
 {
     VALUE rb_record = Qnil;
-    RbGrnTableCursor *rb_grn_table_cursor;
+    grn_ctx *context;
+    grn_table_cursor *cursor;
 
-    rb_grn_table_cursor = SELF(self);
-    if (rb_grn_table_cursor->context && rb_grn_table_cursor->cursor) {
+    rb_grn_table_cursor_deconstruct(SELF(self), &cursor, &context,
+				    NULL, NULL, NULL, NULL);
+    if (context && cursor) {
         grn_id record_id;
 
-        record_id = grn_table_cursor_next(rb_grn_table_cursor->context,
-                                          rb_grn_table_cursor->cursor);
+        record_id = grn_table_cursor_next(context, cursor);
         if (record_id != GRN_ID_NIL) /* FIXME: use grn_table_cursor_table */
-            rb_record = rb_grn_record_new(rb_iv_get(self, "@table"), record_id);
+            rb_record = rb_grn_record_new(rb_iv_get(self, "@table"),
+					  record_id, Qnil);
     }
 
     return rb_record;
@@ -243,20 +240,17 @@ static VALUE
 rb_grn_table_cursor_each (VALUE self)
 {
     grn_id record_id;
-    RbGrnTableCursor *rb_grn_table_cursor;
     grn_ctx *context;
     grn_table_cursor *cursor;
 
-    rb_grn_table_cursor = SELF(self);
-    if (!rb_grn_table_cursor->context)
-        return Qnil;
-    if (!rb_grn_table_cursor->cursor)
-        return Qnil;
+    rb_grn_table_cursor_deconstruct(SELF(self), &cursor, &context,
+				    NULL, NULL, NULL, NULL);
 
-    context = rb_grn_table_cursor->context;
-    cursor = rb_grn_table_cursor->cursor;
-    while ((record_id = grn_table_cursor_next(context, cursor))) {
-        rb_yield(rb_grn_record_new(rb_iv_get(self, "@table"), record_id));
+    if (context && cursor) {
+	while ((record_id = grn_table_cursor_next(context, cursor))) {
+	    rb_yield(rb_grn_record_new(rb_iv_get(self, "@table"),
+				       record_id, Qnil));
+	}
     }
 
     return Qnil;