groonga 0.0.1

data/ext/rb-grn-column.c

@@ -0,0 +1,273 @@
+/* -*- 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) (RVAL2GRNCOLUMN(object, context))
+
+VALUE rb_cGrnColumn;
+VALUE rb_cGrnFixSizeColumn;
+VALUE rb_cGrnVarSizeColumn;
+VALUE rb_cGrnIndexColumn;
+
+grn_obj *
+rb_grn_column_from_ruby_object (VALUE object, grn_ctx **context)
+{
+    if (!RVAL2CBOOL(rb_obj_is_kind_of(object, rb_cGrnColumn))) {
+	rb_raise(rb_eTypeError, "not a groonga column");
+    }
+
+    return RVAL2GRNOBJECT(object, context);
+}
+
+VALUE
+rb_grn_column_to_ruby_object (VALUE klass, grn_ctx *context, grn_obj *column,
+			      rb_grn_boolean owner)
+{
+    return GRNOBJECT2RVAL(klass, context, column, owner);
+}
+
+static VALUE
+rb_grn_fix_size_column_array_set (VALUE self, VALUE rb_id, VALUE rb_value)
+{
+    grn_ctx *context = NULL;
+    grn_obj *column;
+    grn_id range;
+    grn_obj *range_object = NULL;
+    grn_rc rc;
+    grn_id id;
+    grn_obj value;
+
+    column = SELF(self, &context);
+    id = NUM2UINT(rb_id);
+
+    range = grn_obj_get_range(context, column);
+    if (range != GRN_ID_NIL)
+	range_object = grn_ctx_get(context, range);
+
+    if (RVAL2CBOOL(rb_obj_is_kind_of(rb_value, rb_cGrnRecord))) {
+	VALUE rb_id, rb_table;
+	grn_obj *table;
+
+	if (!range_object)
+	    rb_raise(rb_eArgError,
+		     "%s isn't associated with any table: %s",
+		     rb_grn_inspect(self), rb_grn_inspect(rb_value));
+
+	rb_id = rb_funcall(rb_value, rb_intern("id"), 0);
+	rb_table = rb_funcall(rb_value, rb_intern("table"), 0);
+	table = RVAL2GRNTABLE(rb_table, &context);
+	if (grn_obj_id(context, table) != range)
+	    rb_raise(rb_eArgError,
+		     "%s isn't associated with passed record's table: %s",
+		     rb_grn_inspect(self),
+		     rb_grn_inspect(rb_value));
+
+	RVAL2GRNUVECTOR(rb_ary_new3(1, rb_id), context, &value);
+    } else if (range_object &&
+	       RVAL2CBOOL(rb_obj_is_kind_of(rb_value, rb_cInteger))) {
+	switch (range_object->header.type) {
+	  case GRN_TABLE_PAT_KEY:
+	  case GRN_TABLE_HASH_KEY:
+	  case GRN_TABLE_NO_KEY:
+	    RVAL2GRNUVECTOR(rb_ary_new3(1, rb_value), context, &value);
+	    break;
+	  default:
+	    RVAL2GRNBULK(rb_value, context, &value);
+	    break;
+	}
+    } else {
+	RVAL2GRNBULK(rb_value, context, &value);
+    }
+
+    rc = grn_obj_set_value(context, column, id, &value, GRN_OBJ_SET);
+    grn_obj_close(context, &value);
+    rb_grn_rc_check(rc, self);
+
+    return Qnil;
+}
+
+static VALUE
+rb_grn_index_column_array_set (VALUE self, VALUE rb_id, VALUE rb_value)
+{
+    grn_ctx *context = NULL;
+    grn_obj *column;
+    grn_rc rc;
+    grn_id id;
+    unsigned int section;
+    grn_obj old_value, new_value;
+    VALUE rb_section, rb_old_value, rb_new_value;
+
+    column = SELF(self, &context);
+
+    id = NUM2UINT(rb_id);
+
+    if (!RVAL2CBOOL(rb_obj_is_kind_of(rb_value, rb_cHash))) {
+	VALUE hash_value;
+	hash_value = rb_hash_new();
+	rb_hash_aset(hash_value, RB_GRN_INTERN("value"), rb_value);
+	rb_value = hash_value;
+    }
+
+    rb_grn_scan_options(rb_value,
+			"section", &rb_section,
+			"old_value", &rb_old_value,
+			"value", &rb_new_value,
+			NULL);
+
+    if (NIL_P(rb_section))
+	section = 1;
+    else
+	section = NUM2UINT(rb_section);
+
+    RVAL2GRNBULK(rb_old_value, context, &old_value);
+    RVAL2GRNBULK(rb_new_value, context, &new_value);
+
+    rc = grn_column_index_update(context, column,
+				 id, section, &old_value, &new_value);
+    grn_obj_close(context, &old_value);
+    grn_obj_close(context, &new_value);
+
+    rb_grn_rc_check(rc, self);
+
+    return Qnil;
+}
+
+static VALUE
+rb_grn_column_get_table (VALUE self)
+{
+    grn_ctx *context = NULL;
+    grn_obj *column;
+    grn_obj *table;
+
+    column = SELF(self, &context);
+    table = grn_column_table(context, column);
+    rb_grn_context_check(context, self);
+
+    return GRNOBJECT2RVAL(Qnil, context, table, RB_GRN_FALSE);
+}
+
+static VALUE
+rb_grn_index_column_get_sources (VALUE self)
+{
+    grn_ctx *context = NULL;
+    grn_obj *column;
+    grn_obj sources;
+    grn_id *source_ids;
+    VALUE rb_sources;
+    int i, n;
+
+    column = SELF(self, &context);
+
+    grn_obj_get_info(context, column, GRN_INFO_SOURCE, &sources);
+    rb_grn_context_check(context, self);
+
+    n = GRN_BULK_VSIZE(&sources) / sizeof(grn_id);
+    source_ids = (grn_id *)GRN_BULK_HEAD(&sources);
+    rb_sources = rb_ary_new2(n);
+    for (i = 0; i < n; i++) {
+	grn_obj *source;
+	VALUE rb_source;
+
+	source = grn_ctx_get(context, *source_ids);
+	rb_source = GRNOBJECT2RVAL(Qnil, context, source, RB_GRN_FALSE);
+	rb_ary_push(rb_sources, rb_source);
+	source_ids++;
+    }
+
+    return rb_sources;
+}
+
+static VALUE
+rb_grn_index_column_set_sources (VALUE self, VALUE rb_sources)
+{
+    grn_ctx *context = NULL;
+    grn_obj *column;
+    int i, n;
+    VALUE *rb_source_values;
+    grn_id *sources;
+    grn_rc rc;
+
+    column = SELF(self, &context);
+
+    n = RARRAY_LEN(rb_sources);
+    rb_source_values = RARRAY_PTR(rb_sources);
+    sources = ALLOCA_N(grn_id, n);
+    for (i = 0; i < n; i++) {
+	VALUE rb_source_id;
+	grn_obj *source;
+	grn_id source_id;
+
+	rb_source_id = rb_source_values[i];
+	if (CBOOL2RVAL(rb_obj_is_kind_of(rb_source_id, rb_cInteger))) {
+	    source_id = NUM2UINT(rb_source_id);
+	} else {
+	    source = RVAL2GRNOBJECT(rb_source_id, &context);
+	    rb_grn_context_check(context, rb_source_id);
+	    source_id = grn_obj_id(context, source);
+	}
+	sources[i] = source_id;
+    }
+
+    {
+	grn_obj source;
+	GRN_OBJ_INIT(&source, GRN_BULK, GRN_OBJ_DO_SHALLOW_COPY);
+	GRN_BULK_SET(context, &source, sources, n * sizeof(grn_id));
+	rc = grn_obj_set_info(context, column, GRN_INFO_SOURCE, &source);
+    }
+
+    rb_grn_context_check(context, self);
+    rb_grn_rc_check(rc, self);
+
+    return Qnil;
+}
+
+static VALUE
+rb_grn_index_column_set_source (VALUE self, VALUE rb_source)
+{
+    if (!RVAL2CBOOL(rb_obj_is_kind_of(rb_source, rb_cArray)))
+	rb_source = rb_ary_new3(1, rb_source);
+
+    return rb_grn_index_column_set_sources(self, rb_source);
+}
+
+void
+rb_grn_init_column (VALUE mGrn)
+{
+    rb_cGrnColumn = rb_define_class_under(mGrn, "Column", rb_cGrnObject);
+    rb_cGrnFixSizeColumn =
+	rb_define_class_under(mGrn, "FixSizeColumn", rb_cGrnColumn);
+    rb_cGrnVarSizeColumn =
+	rb_define_class_under(mGrn, "VarSizeColumn", rb_cGrnColumn);
+    rb_cGrnIndexColumn =
+	rb_define_class_under(mGrn, "IndexColumn", rb_cGrnColumn);
+
+    rb_define_method(rb_cGrnFixSizeColumn, "[]=",
+		     rb_grn_fix_size_column_array_set, 2);
+    rb_define_method(rb_cGrnIndexColumn, "[]=",
+		     rb_grn_index_column_array_set, 2);
+
+    rb_define_method(rb_cGrnColumn, "table", rb_grn_column_get_table, 0);
+
+    rb_define_method(rb_cGrnIndexColumn, "sources",
+		     rb_grn_index_column_get_sources, 0);
+    rb_define_method(rb_cGrnIndexColumn, "sources=",
+		     rb_grn_index_column_set_sources, 1);
+    rb_define_method(rb_cGrnIndexColumn, "source=",
+		     rb_grn_index_column_set_source, 1);
+}

data/ext/rb-grn-context.c

@@ -0,0 +1,333 @@
+/* -*- 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) (RVAL2GRNCONTEXT(object))
+
+static VALUE cGrnContext;
+
+grn_ctx *
+rb_grn_context_from_ruby_object (VALUE object)
+{
+    grn_ctx *context;
+
+    if (!RVAL2CBOOL(rb_obj_is_kind_of(object, cGrnContext))) {
+	rb_raise(rb_eTypeError, "not a groonga context");
+    }
+
+    Data_Get_Struct(object, grn_ctx, context);
+    if (!context)
+	rb_raise(rb_eGrnError, "groonga context is NULL");
+    return context;
+}
+
+static void
+rb_grn_context_free (void *pointer)
+{
+    grn_ctx *context = pointer;
+
+    if (context->stat != GRN_CTX_FIN)
+	grn_ctx_fin(context);
+    xfree(context);
+}
+
+static VALUE
+rb_grn_context_alloc (VALUE klass)
+{
+    return Data_Wrap_Struct(klass, NULL, rb_grn_context_free, NULL);
+}
+
+VALUE
+rb_grn_context_to_exception (grn_ctx *context, VALUE related_object)
+{
+    VALUE exception, exception_class;
+    const char *message;
+    grn_obj bulk;
+
+    if (context->rc == GRN_SUCCESS)
+	return Qnil;
+
+    exception_class = rb_grn_rc_to_exception(context->rc);
+    message = rb_grn_rc_to_message(context->rc);
+
+    grn_bulk_init(context, &bulk, 0);
+    GRN_BULK_PUTS(context, &bulk, message);
+    GRN_BULK_PUTS(context, &bulk, ": ");
+    GRN_BULK_PUTS(context, &bulk, context->errbuf);
+    if (!NIL_P(related_object)) {
+	GRN_BULK_PUTS(context, &bulk, ": ");
+	GRN_BULK_PUTS(context, &bulk, rb_grn_inspect(related_object));
+    }
+    GRN_BULK_PUTS(context, &bulk, "\n");
+    GRN_BULK_PUTS(context, &bulk, context->errfile);
+    GRN_BULK_PUTS(context, &bulk, ":");
+    grn_bulk_itoa(context, &bulk, context->errline);
+    GRN_BULK_PUTS(context, &bulk, ": ");
+    GRN_BULK_PUTS(context, &bulk, context->errfunc);
+    GRN_BULK_PUTS(context, &bulk, "()");
+    exception = rb_funcall(exception_class, rb_intern("new"), 1,
+			   rb_str_new(GRN_BULK_HEAD(&bulk),
+				      GRN_BULK_VSIZE(&bulk)));
+    grn_obj_close(context, &bulk);
+
+    return exception;
+}
+
+void
+rb_grn_context_check (grn_ctx *context, VALUE related_object)
+{
+    VALUE exception;
+
+    exception = rb_grn_context_to_exception(context, related_object);
+    if (NIL_P(exception))
+	return;
+
+    rb_exc_raise(exception);
+}
+
+grn_ctx *
+rb_grn_context_ensure (VALUE context)
+{
+    if (NIL_P(context))
+	context = rb_grn_context_get_default();
+    return SELF(context);
+}
+
+static VALUE
+rb_grn_context_s_get_default (VALUE self)
+{
+    VALUE context;
+
+    context = rb_cv_get(self, "@@default");
+    if (NIL_P(context)) {
+	context = rb_funcall(cGrnContext, rb_intern("new"), 0);
+	rb_cv_set(self, "@@default", context);
+    }
+    return context;
+}
+
+VALUE
+rb_grn_context_get_default (void)
+{
+    return rb_grn_context_s_get_default(cGrnContext);
+}
+
+static VALUE
+rb_grn_context_s_set_default (VALUE self, VALUE context)
+{
+    rb_cv_set(self, "@@default", context);
+    return Qnil;
+}
+
+static VALUE
+rb_grn_context_s_get_default_options (VALUE self)
+{
+    return rb_cv_get(self, "@@default_options");
+}
+
+static VALUE
+rb_grn_context_s_set_default_options (VALUE self, VALUE options)
+{
+    rb_cv_set(self, "@@default_options", options);
+    return Qnil;
+}
+
+static VALUE
+rb_grn_context_initialize (int argc, VALUE *argv, VALUE self)
+{
+    grn_ctx *context;
+    int flags = 0;
+    grn_rc rc;
+    VALUE options, default_options;
+    VALUE use_ql, batch_mode, rb_encoding;
+
+    rb_scan_args(argc, argv, "01", &options);
+    default_options = rb_grn_context_s_get_default_options(rb_obj_class(self));
+    if (NIL_P(default_options))
+	default_options = rb_hash_new();
+
+    if (NIL_P(options))
+	options = rb_hash_new();
+    options = rb_funcall(default_options, rb_intern("merge"), 1, options);
+
+    rb_grn_scan_options(options,
+			"use_ql", &use_ql,
+			"batch_mode", &batch_mode,
+			"encoding", &rb_encoding,
+			NULL);
+
+    if (RVAL2CBOOL(use_ql))
+	flags |= GRN_CTX_USE_QL;
+    if (RVAL2CBOOL(batch_mode))
+	flags |= GRN_CTX_BATCH_MODE;
+
+    context = ALLOC(grn_ctx);
+    DATA_PTR(self) = context;
+    rc = grn_ctx_init(context, flags);
+    rb_grn_context_check(context, self);
+
+    if (!NIL_P(rb_encoding)) {
+	grn_encoding encoding;
+
+	encoding = RVAL2GRNENCODING(rb_encoding, NULL);
+	GRN_CTX_SET_ENCODING(context, encoding);
+    }
+
+    return Qnil;
+}
+
+static VALUE
+rb_grn_context_inspect (VALUE self)
+{
+    VALUE inspected;
+    grn_ctx *context;
+    grn_obj *database;
+    VALUE rb_database;
+
+    context = SELF(self);
+
+    inspected = rb_str_new2("#<");
+    rb_str_concat(inspected, rb_inspect(rb_obj_class(self)));
+    rb_str_cat2(inspected, " ");
+
+    rb_str_cat2(inspected, "use_ql: <");
+    if (context->flags & GRN_CTX_USE_QL)
+	rb_str_cat2(inspected, "true");
+    else
+	rb_str_cat2(inspected, "false");
+    rb_str_cat2(inspected, ">, ");
+
+    rb_str_cat2(inspected, "batch_mode: <");
+    if (context->flags & GRN_CTX_BATCH_MODE)
+	rb_str_cat2(inspected, "true");
+    else
+	rb_str_cat2(inspected, "false");
+    rb_str_cat2(inspected, ">, ");
+
+    rb_str_cat2(inspected, "encoding: <");
+    rb_str_concat(inspected, rb_inspect(GRNENCODING2RVAL(context->encoding)));
+    rb_str_cat2(inspected, ">, ");
+
+    rb_str_cat2(inspected, "database: <");
+    database = grn_ctx_db(context);
+    rb_database = GRNDB2RVAL(context, database, RB_GRN_FALSE);
+    rb_str_concat(inspected, rb_inspect(rb_database));
+    rb_str_cat2(inspected, ">");
+
+    rb_str_cat2(inspected, ">");
+    return inspected;
+}
+
+static VALUE
+rb_grn_context_use_ql_p (VALUE self)
+{
+    return CBOOL2RVAL(SELF(self)->flags & GRN_CTX_USE_QL);
+}
+
+static VALUE
+rb_grn_context_batch_mode_p (VALUE self)
+{
+    return CBOOL2RVAL(SELF(self)->flags & GRN_CTX_BATCH_MODE);
+}
+
+static VALUE
+rb_grn_context_get_encoding (VALUE self)
+{
+    return GRNENCODING2RVAL(GRN_CTX_GET_ENCODING(SELF(self)));
+}
+
+static VALUE
+rb_grn_context_set_encoding (VALUE self, VALUE rb_encoding)
+{
+    grn_ctx *context;
+    grn_encoding encoding;
+
+    context = SELF(self);
+    encoding = RVAL2GRNENCODING(rb_encoding, NULL);
+    GRN_CTX_SET_ENCODING(context, encoding);
+
+    return rb_encoding;
+}
+
+static VALUE
+rb_grn_context_get_database (VALUE self)
+{
+    grn_ctx *context;
+
+    context = SELF(self);
+    return GRNDB2RVAL(context, grn_ctx_db(context), RB_GRN_FALSE);
+}
+
+static VALUE
+rb_grn_context_array_reference (VALUE self, VALUE name_or_id)
+{
+    grn_ctx *context;
+    grn_obj *object;
+
+    context = SELF(self);
+    if (RVAL2CBOOL(rb_obj_is_kind_of(name_or_id, rb_cString))) {
+	const char *name;
+	unsigned name_size;
+
+	name = StringValuePtr(name_or_id);
+	name_size = RSTRING_LEN(name_or_id);
+	object = grn_ctx_lookup(context, name, name_size);
+    } else if (RVAL2CBOOL(rb_obj_is_kind_of(name_or_id, rb_cInteger))) {
+	unsigned id;
+	id = NUM2UINT(name_or_id);
+	object = grn_ctx_get(context, id);
+    } else {
+	rb_raise(rb_eArgError, "should be string or unsigned integer: %s",
+		 rb_grn_inspect(name_or_id));
+    }
+
+    return GRNOBJECT2RVAL(Qnil, context, object, RB_GRN_FALSE);
+}
+
+void
+rb_grn_init_context (VALUE mGrn)
+{
+    cGrnContext = rb_define_class_under(mGrn, "Context", rb_cObject);
+    rb_define_alloc_func(cGrnContext, rb_grn_context_alloc);
+
+    rb_cv_set(cGrnContext, "@@default", Qnil);
+    rb_cv_set(cGrnContext, "@@default_options", Qnil);
+
+    rb_define_singleton_method(cGrnContext, "default",
+			       rb_grn_context_s_get_default, 0);
+    rb_define_singleton_method(cGrnContext, "default=",
+			       rb_grn_context_s_set_default, 1);
+    rb_define_singleton_method(cGrnContext, "default_options",
+			       rb_grn_context_s_get_default_options, 0);
+    rb_define_singleton_method(cGrnContext, "default_options=",
+			       rb_grn_context_s_set_default_options, 1);
+
+    rb_define_method(cGrnContext, "initialize", rb_grn_context_initialize, -1);
+
+    rb_define_method(cGrnContext, "inspect", rb_grn_context_inspect, 0);
+
+    rb_define_method(cGrnContext, "use_ql?", rb_grn_context_use_ql_p, 0);
+    rb_define_method(cGrnContext, "batch_mode?", rb_grn_context_batch_mode_p, 0);
+    rb_define_method(cGrnContext, "encoding", rb_grn_context_get_encoding, 0);
+    rb_define_method(cGrnContext, "encoding=", rb_grn_context_set_encoding, 1);
+
+    rb_define_method(cGrnContext, "database", rb_grn_context_get_database, 0);
+
+    rb_define_method(cGrnContext, "[]", rb_grn_context_array_reference, 1);
+}