groonga 0.0.1

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

@@ -0,0 +1,55 @@
+/* -*- c-file-style: "ruby" -*- */
+/*
+  Copyright (C) 2009  Kouhei Sutou <kou@clear-code.com>
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License version 2.1 as published by the Free Software Foundation.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include "rb-grn.h"
+
+#define SELF(object) (RVAL2GRNTABLECURSOR(object))
+
+VALUE rb_mGrnTableCursorKeySupport;
+
+static VALUE
+rb_grn_table_cursor_get_key (VALUE self)
+{
+    VALUE rb_key = Qnil;
+    grn_ctx *context;
+    grn_table_cursor *cursor;
+
+    context = rb_grn_table_cursor_ensure_context(self, Qnil);
+    cursor = SELF(self);
+    if (context && cursor) {
+        void *key;
+        int key_size;
+	grn_obj *table;
+
+	table = grn_table_cursor_table(context, cursor);
+        key_size = grn_table_cursor_get_key(context, cursor, &key);
+        rb_key = GRNKEY2RVAL(context, key, key_size, table, self);
+    }
+
+    return rb_key;
+}
+
+void
+rb_grn_init_table_cursor_key_support (VALUE mGrn)
+{
+    rb_mGrnTableCursorKeySupport =
+	rb_define_module_under(rb_cGrnTableCursor, "KeySupport");
+
+    rb_define_method(rb_cGrnTableCursor, "key",
+                     rb_grn_table_cursor_get_key, 0);
+}

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

@@ -0,0 +1,294 @@
+/* -*- c-file-style: "ruby" -*- */
+/*
+  Copyright (C) 2009  Kouhei Sutou <kou@clear-code.com>
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License version 2.1 as published by the Free Software Foundation.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#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;
+};
+
+VALUE rb_cGrnTableCursor;
+
+static RbGrnTableCursor *
+rb_rb_grn_table_cursor_from_ruby_object (VALUE object)
+{
+    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);
+}
+
+VALUE
+rb_grn_table_cursor_to_ruby_class (grn_obj *object)
+{
+    VALUE klass = Qnil;
+
+    switch (object->header.type) {
+      case GRN_CURSOR_TABLE_HASH_KEY:
+	klass = rb_cGrnHashCursor;
+	break;
+      case GRN_CURSOR_TABLE_PAT_KEY:
+	klass = rb_cGrnPatriciaTrieCursor;
+	break;
+      case GRN_CURSOR_TABLE_NO_KEY:
+	klass = rb_cGrnArrayCursor;
+	break;
+      default:
+	rb_raise(rb_eTypeError,
+		 "unsupported groonga object type: %d",
+		 object->header.type);
+	break;
+    }
+
+    return klass;
+}
+
+VALUE
+rb_grn_table_cursor_to_ruby_object (VALUE klass, grn_ctx *context,
+                                    grn_table_cursor *cursor)
+{
+    RbGrnTableCursor *rb_grn_table_cursor;
+
+    if (!cursor)
+        return Qnil;
+
+    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 */
+
+    if (NIL_P(klass))
+        klass = GRNTABLECURSOR2RCLASS(cursor);
+
+    return Data_Wrap_Struct(klass, NULL,
+                            rb_rb_grn_table_cursor_free, rb_grn_table_cursor);
+}
+
+static VALUE
+rb_grn_table_cursor_alloc (VALUE klass)
+{
+    return Data_Wrap_Struct(klass, NULL, rb_rb_grn_table_cursor_free, NULL);
+}
+
+grn_ctx *
+rb_grn_table_cursor_ensure_context (VALUE cursor, VALUE rb_context)
+{
+    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;
+    }
+
+    return rb_grn_context_ensure(rb_context);
+}
+
+VALUE
+rb_grn_table_cursor_close (VALUE self)
+{
+    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;
+
+	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);
+    }
+    return Qnil;
+}
+
+static VALUE
+rb_grn_table_cursor_closed_p (VALUE self)
+{
+    RbGrnTableCursor *rb_grn_table_cursor;
+
+    rb_grn_table_cursor = SELF(self);
+    if (rb_grn_table_cursor->context && rb_grn_table_cursor->cursor)
+        return Qfalse;
+    else
+        return Qtrue;
+}
+
+static VALUE
+rb_grn_table_cursor_get_value (VALUE self)
+{
+    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) {
+        int n;
+        void *value;
+
+        n = grn_table_cursor_get_value(rb_grn_table_cursor->context,
+                                       rb_grn_table_cursor->cursor,
+                                       &value);
+        rb_value = rb_str_new(value, n);
+    }
+
+    return rb_value;
+}
+
+static VALUE
+rb_grn_table_cursor_set_value (VALUE self, VALUE value)
+{
+    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;
+
+        rc = grn_table_cursor_set_value(rb_grn_table_cursor->context,
+                                        rb_grn_table_cursor->cursor,
+                                        StringValuePtr(value), GRN_OBJ_SET);
+        rb_grn_rc_check(rc, self);
+    }
+
+    return Qnil;
+}
+
+static VALUE
+rb_grn_table_cursor_delete (VALUE self)
+{
+    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;
+
+        rc = grn_table_cursor_delete(rb_grn_table_cursor->context,
+                                     rb_grn_table_cursor->cursor);
+        rb_grn_rc_check(rc, self);
+    }
+
+    return Qnil;
+}
+
+static VALUE
+rb_grn_table_cursor_next (VALUE self)
+{
+    VALUE rb_record = Qnil;
+    RbGrnTableCursor *rb_grn_table_cursor;
+
+    rb_grn_table_cursor = SELF(self);
+    if (rb_grn_table_cursor->context && rb_grn_table_cursor->cursor) {
+        grn_id record_id;
+
+        record_id = grn_table_cursor_next(rb_grn_table_cursor->context,
+                                          rb_grn_table_cursor->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);
+    }
+
+    return rb_record;
+}
+
+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;
+
+    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));
+    }
+
+    return Qnil;
+}
+
+void
+rb_grn_init_table_cursor (VALUE mGrn)
+{
+    rb_cGrnTableCursor = rb_define_class_under(mGrn, "TableCurosr", rb_cObject);
+    rb_define_alloc_func(rb_cGrnTableCursor, rb_grn_table_cursor_alloc);
+
+    rb_include_module(rb_cGrnTableCursor, rb_mEnumerable);
+
+    rb_define_method(rb_cGrnTableCursor, "close",
+                     rb_grn_table_cursor_close, 0);
+    rb_define_method(rb_cGrnTableCursor, "closed?",
+                     rb_grn_table_cursor_closed_p, 0);
+
+    rb_define_method(rb_cGrnTableCursor, "value",
+                     rb_grn_table_cursor_get_value, 0);
+    rb_define_method(rb_cGrnTableCursor, "value=",
+                     rb_grn_table_cursor_set_value, 1);
+    rb_define_method(rb_cGrnTableCursor, "delete",
+                     rb_grn_table_cursor_delete, 0);
+    rb_define_method(rb_cGrnTableCursor, "next",
+                     rb_grn_table_cursor_next, 0);
+
+    rb_define_method(rb_cGrnTableCursor, "each",
+                     rb_grn_table_cursor_each, 0);
+
+    rb_grn_init_table_cursor_key_support(mGrn);
+    rb_grn_init_array_cursor(mGrn);
+    rb_grn_init_hash_cursor(mGrn);
+    rb_grn_init_patricia_trie_cursor(mGrn);
+}

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

@@ -0,0 +1,299 @@
+/* -*- c-file-style: "ruby" -*- */
+/*
+  Copyright (C) 2009  Kouhei Sutou <kou@clear-code.com>
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License version 2.1 as published by the Free Software Foundation.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include "rb-grn.h"
+
+#define SELF(object, context) (RVAL2GRNTABLE(object, context))
+
+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);
+
+static grn_id
+rb_grn_table_key_support_add_raw (VALUE self, VALUE rb_key,
+				  grn_ctx *context, grn_obj *table)
+{
+    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);
+
+    return id;
+}
+
+static VALUE
+rb_grn_table_key_support_add (VALUE self, VALUE rb_key)
+{
+    grn_ctx *context = NULL;
+    grn_obj *table;
+    grn_id id;
+
+    table = SELF(self, &context);
+
+    id = rb_grn_table_key_support_add_raw(self, rb_key, context, table);
+    if (GRN_ID_NIL == id)
+	return Qnil;
+    else
+	return rb_grn_record_new(self, id);
+}
+
+static VALUE
+rb_grn_table_key_support_get_key (VALUE self, VALUE rb_id)
+{
+    grn_ctx *context = NULL;
+    grn_id id;
+    grn_obj *table, key;
+    int key_size = 0;
+    VALUE rb_key;
+
+    table = SELF(self, &context);
+
+    id = NUM2UINT(rb_id);
+    key_size = grn_table_get_key(context, table, id, NULL, 0);
+    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);
+
+    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_obj *table;
+    grn_obj key;
+    grn_rc rc;
+
+    table = SELF(self, &context);
+
+    RVAL2GRNKEY(rb_key, context, &key, table->header.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);
+    rb_grn_rc_check(rc, self);
+
+    return Qnil;
+}
+
+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);
+    } else {
+	return rb_grn_table_key_support_delete_by_key(self, rb_id_or_key);
+    }
+}
+
+static VALUE
+rb_grn_table_key_support_array_reference_by_key (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);
+
+    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);
+}
+
+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);
+    } 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_obj *table;
+    grn_id id;
+    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);
+    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);
+    rb_grn_rc_check(rc, self);
+
+    return rb_value;
+}
+
+static VALUE
+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);
+    } else {
+	return rb_grn_table_key_support_array_set_by_key(self,
+							 rb_id_or_key,
+							 rb_value);
+    }
+}
+
+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;
+
+    table = SELF(self, &context);
+    rc = grn_table_get_info(context, table, NULL, NULL, &tokenizer);
+    rb_grn_context_check(context, self);
+    rb_grn_rc_check(rc, self);
+
+    return GRNOBJECT2RVAL(Qnil, context, tokenizer, RB_GRN_FALSE);
+}
+
+static VALUE
+rb_grn_table_key_support_set_default_tokenizer (VALUE self, VALUE rb_tokenizer)
+{
+    grn_ctx *context = NULL;
+    grn_obj *table;
+    grn_obj *tokenizer;
+    grn_rc rc;
+
+    table = SELF(self, &context);
+    tokenizer = RVAL2GRNOBJECT(rb_tokenizer, &context);
+    rc = grn_obj_set_info(context, table,
+			  GRN_INFO_DEFAULT_TOKENIZER, tokenizer);
+    rb_grn_context_check(context, self);
+    rb_grn_rc_check(rc, self);
+
+    return Qnil;
+}
+
+void
+rb_grn_init_table_key_support (VALUE mGrn)
+{
+    rb_mGrnTableKeySupport = rb_define_module_under(rb_cGrnTable, "KeySupport");
+
+    rb_define_method(rb_mGrnTableKeySupport, "add",
+		     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, "[]",
+		     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);
+}