groonga 0.0.2 → 0.0.3

data/ext/rb-grn-expression-builder.c

@@ -0,0 +1,69 @@
+/* -*- 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"
+
+VALUE rb_cGrnRecordExpressionBuilder;
+VALUE rb_cGrnColumnExpressionBuilder;
+
+VALUE
+rb_grn_record_expression_builder_new (VALUE table, VALUE name)
+{
+    return rb_funcall(rb_cGrnRecordExpressionBuilder,
+		      rb_intern("new"), 2, table, name);
+}
+
+VALUE
+rb_grn_column_expression_builder_new (VALUE column, VALUE name, VALUE query)
+{
+    return rb_funcall(rb_cGrnColumnExpressionBuilder,
+		      rb_intern("new"), 3, column, name, query);
+}
+
+static VALUE
+build (VALUE self)
+{
+    return rb_funcall(self, rb_intern("build"), 0);
+}
+
+static VALUE
+build_block (VALUE self)
+{
+    return rb_funcall(rb_block_proc(), rb_intern("call"), 1, self);
+}
+
+VALUE
+rb_grn_record_expression_builder_build (VALUE self)
+{
+    return rb_iterate(build, self, build_block, self);
+}
+
+VALUE
+rb_grn_column_expression_builder_build (VALUE self)
+{
+    return rb_iterate(build, self, build_block, self);
+}
+
+void
+rb_grn_init_expression_builder (VALUE mGrn)
+{
+    rb_cGrnRecordExpressionBuilder =
+        rb_const_get(mGrn, rb_intern("RecordExpressionBuilder"));
+    rb_cGrnColumnExpressionBuilder =
+        rb_const_get(mGrn, rb_intern("ColumnExpressionBuilder"));
+}

data/ext/rb-grn-expression.c

@@ -0,0 +1,314 @@
+/* -*- 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) ((RbGrnExpression *)DATA_PTR(object))
+
+VALUE rb_cGrnExpression;
+
+void
+rb_grn_expression_finalizer (grn_ctx *context, grn_obj *object,
+			     RbGrnExpression *rb_grn_expression)
+{
+    if (!context)
+	return;
+
+    grn_obj_close(context, rb_grn_expression->value);
+}
+
+void
+rb_grn_expression_bind (RbGrnExpression *rb_grn_expression,
+                        grn_ctx *context, grn_obj *expression)
+{
+    RbGrnObject *rb_grn_object;
+
+    rb_grn_object = RB_GRN_OBJECT(rb_grn_expression);
+
+    rb_grn_expression->value = grn_obj_open(context, GRN_BULK, 0,
+                                            rb_grn_object->range_id);
+}
+
+void
+rb_grn_expression_deconstruct (RbGrnExpression *rb_grn_expression,
+                               grn_obj **expression,
+                               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_grn_expression);
+    rb_grn_object_deconstruct(rb_grn_object, expression, context,
+			      domain_id, domain,
+			      range_id, range);
+
+    if (value)
+	*value = rb_grn_expression->value;
+}
+
+static VALUE
+rb_grn_expression_initialize (int argc, VALUE *argv, VALUE self)
+{
+    grn_ctx *context = NULL;
+    grn_obj *expression;
+    VALUE options, rb_context, rb_name, rb_query, rb_table, rb_default_column;
+    char *name = NULL, *query = NULL;
+    unsigned name_size = 0, query_size = 0;
+
+    rb_scan_args(argc, argv, "01", &options);
+    rb_grn_scan_options(options,
+                        "context", &rb_context,
+                        "name", &rb_name,
+                        "query", &rb_query,
+                        "table", &rb_table,
+                        "default_column", &rb_default_column,
+                        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_query)) {
+	query = StringValuePtr(rb_query);
+	query_size = RSTRING_LEN(rb_query);
+    }
+
+    if (query) {
+	grn_obj *table;
+	grn_obj *default_column = NULL;
+
+	table = RVAL2GRNOBJECT(rb_table, &context);
+	default_column = RVAL2GRNBULK(rb_default_column, context, default_column);
+	expression = grn_expr_create_from_str(context, name, name_size,
+					      query, query_size,
+					      table, default_column);
+    } else {
+	expression = grn_expr_create(context, name, name_size);
+    }
+    rb_grn_object_assign(Qnil, self, rb_context, context, expression);
+    rb_grn_context_check(context, self);
+
+    return Qnil;
+}
+
+static VALUE
+rb_grn_expression_define_variable (int argc, VALUE *argv, VALUE self)
+{
+    grn_ctx *context = NULL;
+    grn_obj *expression, *variable;
+    char *name = NULL;
+    unsigned name_size = 0;
+    VALUE options, rb_name, rb_domain, rb_variable;
+
+    rb_scan_args(argc, argv, "01", &options);
+
+    rb_grn_expression_deconstruct(SELF(self), &expression, &context,
+                                  NULL, NULL,
+                                  NULL, NULL, NULL);
+
+    rb_grn_scan_options(options,
+			"name", &rb_name,
+			"domain", &rb_domain,
+			NULL);
+
+    if (!NIL_P(rb_name)) {
+	name = StringValuePtr(rb_name);
+	name_size = RSTRING_LEN(rb_name);
+    }
+
+    variable = grn_expr_add_var(context, expression, name, name_size);
+    rb_variable = GRNVARIABLE2RVAL(context, variable);
+
+    if (RVAL2CBOOL(rb_obj_is_kind_of(rb_domain, rb_cGrnTable))) {
+	grn_id domain_id;
+	domain_id = NUM2UINT(rb_funcall(rb_domain, rb_intern("id"), 0));
+	GRN_RECORD_INIT(variable, 0, domain_id);
+    }
+
+    return rb_variable;
+}
+
+static VALUE
+rb_grn_expression_get_value (VALUE self, VALUE rb_offset)
+{
+    grn_ctx *context = NULL;
+    grn_obj *value, *expression;
+    int offset;
+
+    rb_grn_expression_deconstruct(SELF(self), &expression, &context,
+                                  NULL, NULL,
+                                  NULL, NULL, NULL);
+
+    offset = NUM2INT(rb_offset);
+    value = grn_expr_get_value(context, expression, offset);
+    return GRNBULK2RVAL(context, value, self);
+}
+
+static VALUE
+rb_grn_expression_append_object (VALUE self, VALUE rb_object)
+{
+    grn_ctx *context = NULL;
+    grn_obj *expression, *object;
+
+    rb_grn_expression_deconstruct(SELF(self), &expression, &context,
+                                  NULL, NULL,
+                                  NULL, NULL, NULL);
+
+    object = RVAL2GRNOBJECT(rb_object, &context);
+    grn_expr_append_obj(context, expression, object);
+    rb_grn_context_check(context, self);
+    return self;
+}
+
+static VALUE
+rb_grn_expression_append_constant (VALUE self, VALUE rb_constant)
+{
+    grn_ctx *context = NULL;
+    grn_obj *expression, *constant = NULL;
+
+    rb_grn_expression_deconstruct(SELF(self), &expression, &context,
+                                  NULL, NULL, NULL,
+				  NULL, NULL);
+
+    RVAL2GRNOBJ(rb_constant, context, &constant);
+    grn_expr_append_const(context, expression, constant);
+    grn_obj_close(context, constant);
+    rb_grn_context_check(context, self);
+    return self;
+}
+
+static VALUE
+rb_grn_expression_append_operation (VALUE self, VALUE rb_operation,
+				    VALUE rb_n_arguments)
+{
+    grn_ctx *context = NULL;
+    grn_obj *expression;
+    grn_operator operation;
+    int n_arguments = 0;
+
+    rb_grn_expression_deconstruct(SELF(self), &expression, &context,
+                                  NULL, NULL,
+                                  NULL, NULL, NULL);
+
+    operation = NUM2INT(rb_operation);
+    n_arguments = NUM2INT(rb_n_arguments);
+    grn_expr_append_op(context, expression, operation, n_arguments);
+    rb_grn_context_check(context, self);
+    return Qnil;
+}
+
+static VALUE
+rb_grn_expression_execute (VALUE self)
+{
+    grn_ctx *context = NULL;
+    grn_obj *expression, *result;
+
+    rb_grn_expression_deconstruct(SELF(self), &expression, &context,
+                                  NULL, NULL,
+                                  NULL, NULL, NULL);
+
+    result = grn_expr_exec(context, expression);
+    return GRNOBJ2RVAL(Qnil, context, result, self);
+}
+
+static VALUE
+rb_grn_expression_compile (VALUE self)
+{
+    grn_ctx *context = NULL;
+    grn_obj *expression;
+    grn_rc rc;
+
+    rb_grn_expression_deconstruct(SELF(self), &expression, &context,
+                                  NULL, NULL,
+                                  NULL, NULL, NULL);
+
+    rc = grn_expr_compile(context, expression);
+    rb_grn_context_check(context, self);
+    rb_grn_rc_check(rc, self);
+
+    return Qnil;
+}
+
+static VALUE
+rb_grn_expression_array_reference (VALUE self, VALUE rb_name_or_offset)
+{
+    grn_ctx *context = NULL;
+    grn_obj *expression, *variable, *value;
+    char *name = NULL;
+    unsigned name_size = 0;
+    int offset;
+
+    rb_grn_expression_deconstruct(SELF(self), &expression, &context,
+                                  NULL, NULL,
+                                  NULL, NULL, NULL);
+
+    switch (TYPE(rb_name_or_offset)) {
+    case T_STRING:
+        name = RSTRING_PTR(rb_name_or_offset);
+        name_size = RSTRING_LEN(rb_name_or_offset);
+        variable = grn_expr_get_var(context, expression, name, name_size);
+        return GRNBULK2RVAL(context, variable, self);
+        break;
+    case T_FIXNUM:
+        offset = NUM2INT(rb_name_or_offset);
+        value = grn_expr_get_var_by_offset(context, expression, offset);
+        return GRNBULK2RVAL(context, value, self);
+        break;
+    default:
+        rb_raise(rb_eArgError, "xxx");
+        break;
+    }
+
+    return Qnil;
+}
+
+void
+rb_grn_init_expression (VALUE mGrn)
+{
+    rb_cGrnExpression = rb_define_class_under(mGrn, "Expression", rb_cGrnObject);
+
+    rb_define_method(rb_cGrnExpression, "initialize",
+                     rb_grn_expression_initialize, -1);
+
+    rb_define_method(rb_cGrnExpression, "define_variable",
+                     rb_grn_expression_define_variable, -1);
+    rb_define_method(rb_cGrnExpression, "append_object",
+                     rb_grn_expression_append_object, 1);
+    rb_define_method(rb_cGrnExpression, "append_constant",
+                     rb_grn_expression_append_constant, 1);
+    rb_define_method(rb_cGrnExpression, "append_operation",
+                     rb_grn_expression_append_operation, 2);
+
+    rb_define_method(rb_cGrnExpression, "execute",
+                     rb_grn_expression_execute, 0);
+    rb_define_method(rb_cGrnExpression, "compile",
+                     rb_grn_expression_compile, 0);
+
+    rb_define_method(rb_cGrnExpression, "value",
+                     rb_grn_expression_get_value, 1);
+
+    rb_define_method(rb_cGrnExpression, "[]",
+                     rb_grn_expression_array_reference, 1);
+}

data/ext/rb-grn-fix-size-column.c

@@ -18,7 +18,7 @@
 
 #include "rb-grn.h"
 
-#define SELF(object) ((RbGrnFixSizeColumn *)DATA_PTR(object))
+#define SELF(object) ((RbGrnColumn *)DATA_PTR(object))
 
 VALUE rb_cGrnFixSizeColumn;
 
@@ -28,87 +28,6 @@ VALUE rb_cGrnFixSizeColumn;
  * 固定長データ用のカラム。
  */
 
-void
-rb_grn_fix_size_column_unbind (RbGrnFixSizeColumn *rb_grn_fix_size_column)
-{
-    RbGrnObject *rb_grn_object;
-    grn_ctx *context;
-
-    rb_grn_object = RB_GRN_OBJECT(rb_grn_fix_size_column);
-    context = rb_grn_object->context;
-
-    if (context)
-	grn_obj_close(context, rb_grn_fix_size_column->value);
-
-    rb_grn_object_unbind(rb_grn_object);
-}
-
-static void
-rb_grn_fix_size_column_free (void *object)
-{
-    RbGrnFixSizeColumn *rb_grn_fix_size_column = object;
-
-    rb_grn_fix_size_column_unbind(rb_grn_fix_size_column);
-    xfree(rb_grn_fix_size_column);
-}
-
-VALUE
-rb_grn_fix_size_column_alloc (VALUE klass)
-{
-    return Data_Wrap_Struct(klass, NULL, rb_grn_fix_size_column_free, NULL);
-}
-
-void
-rb_grn_fix_size_column_bind (RbGrnFixSizeColumn *rb_grn_fix_size_column,
-			     grn_ctx *context, grn_obj *column,
-			     rb_grn_boolean owner)
-{
-    RbGrnObject *rb_grn_object;
-
-    rb_grn_object = RB_GRN_OBJECT(rb_grn_fix_size_column);
-    rb_grn_object_bind(rb_grn_object, context, column, owner);
-    rb_grn_object->unbind =
-	RB_GRN_UNBIND_FUNCTION(rb_grn_fix_size_column_unbind);
-
-    rb_grn_fix_size_column->value = grn_obj_open(context, GRN_BULK, 0,
-						 rb_grn_object->range_id);
-}
-
-void
-rb_grn_fix_size_column_assign (VALUE self, VALUE rb_context,
-		      grn_ctx *context, grn_obj *column,
-		      rb_grn_boolean owner)
-{
-    RbGrnFixSizeColumn *rb_grn_fix_size_column;
-
-    rb_grn_fix_size_column = ALLOC(RbGrnFixSizeColumn);
-    DATA_PTR(self) = rb_grn_fix_size_column;
-    rb_grn_fix_size_column_bind(rb_grn_fix_size_column, context, column, owner);
-
-    rb_iv_set(self, "context", rb_context);
-}
-
-void
-rb_grn_fix_size_column_deconstruct (RbGrnFixSizeColumn *rb_grn_fix_size_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_grn_fix_size_column);
-    rb_grn_object_deconstruct(rb_grn_object, column, context,
-			      domain_id, domain,
-			      range_id, range);
-
-    if (value)
-	*value = rb_grn_fix_size_column->value;
-}
-
 /*
  * call-seq:
  *   column[id] -> 値
@@ -124,9 +43,9 @@ rb_grn_fix_size_column_array_reference (VALUE self, VALUE rb_id)
     grn_obj *range;
     grn_obj *value;
 
-    rb_grn_fix_size_column_deconstruct(SELF(self), &fix_size_column, &context,
-				       NULL, NULL,
-				       &value, NULL, &range);
+    rb_grn_column_deconstruct(SELF(self), &fix_size_column, &context,
+			      NULL, NULL,
+			      &value, NULL, &range);
 
     id = NUM2UINT(rb_id);
     GRN_BULK_REWIND(value);
@@ -153,9 +72,9 @@ rb_grn_fix_size_column_array_set (VALUE self, VALUE rb_id, VALUE rb_value)
     grn_rc rc;
     grn_id id;
 
-    rb_grn_fix_size_column_deconstruct(SELF(self), &column, &context,
-				       &domain_id, &domain,
-				       &value, &range_id, &range);
+    rb_grn_column_deconstruct(SELF(self), &column, &context,
+			      &domain_id, &domain,
+			      &value, &range_id, &range);
 
     id = NUM2UINT(rb_id);
 
@@ -206,15 +125,75 @@ rb_grn_fix_size_column_array_set (VALUE self, VALUE rb_id, VALUE rb_value)
     return Qnil;
 }
 
+static VALUE
+rb_grn_fix_size_column_integer_set (int argc, VALUE *argv, VALUE self, int flags)
+{
+    grn_ctx *context = NULL;
+    grn_obj *column;
+    grn_obj *value;
+    grn_rc rc;
+    grn_id id;
+    VALUE rb_id, rb_delta;
+
+    rb_scan_args(argc, argv, "11", &rb_id, &rb_delta);
+
+    rb_grn_column_deconstruct(SELF(self), &column, &context,
+			      NULL, NULL,
+			      &value, NULL, NULL);
+
+    id = NUM2UINT(rb_id);
+    if (NIL_P(rb_delta))
+	rb_delta = INT2NUM(1);
+
+    GRN_BULK_REWIND(value);
+    RVAL2GRNBULK(rb_delta, context, value);
+
+    rc = grn_obj_set_value(context, column, id, value, flags);
+    rb_grn_context_check(context, self);
+    rb_grn_rc_check(rc, self);
+
+    return Qnil;
+}
+
+/*
+ * call-seq:
+ *   column.increment!(id, delta=nil)
+ *
+ * _column_の_id_に対応する値を_delta_だけ増加する。_delta_
+ * が+nil+の場合は1増加する。
+ */
+static VALUE
+rb_grn_fix_size_column_increment (int argc, VALUE *argv, VALUE self)
+{
+    return rb_grn_fix_size_column_integer_set(argc, argv, self, GRN_OBJ_INCR);
+}
+
+/*
+ * call-seq:
+ *   column.decrement!(id, delta=nil)
+ *
+ * _column_の_id_に対応する値を_delta_だけ減少する。_delta_
+ * が+nil+の場合は1減少する。
+ */
+static VALUE
+rb_grn_fix_size_column_decrement (int argc, VALUE *argv, VALUE self)
+{
+    return rb_grn_fix_size_column_integer_set(argc, argv, self, GRN_OBJ_DECR);
+}
+
 void
 rb_grn_init_fix_size_column (VALUE mGrn)
 {
     rb_cGrnFixSizeColumn =
 	rb_define_class_under(mGrn, "FixSizeColumn", rb_cGrnColumn);
-    rb_define_alloc_func(rb_cGrnFixSizeColumn, rb_grn_fix_size_column_alloc);
 
     rb_define_method(rb_cGrnFixSizeColumn, "[]",
 		     rb_grn_fix_size_column_array_reference, 1);
     rb_define_method(rb_cGrnFixSizeColumn, "[]=",
 		     rb_grn_fix_size_column_array_set, 2);
+
+    rb_define_method(rb_cGrnFixSizeColumn, "increment!",
+		     rb_grn_fix_size_column_increment, -1);
+    rb_define_method(rb_cGrnFixSizeColumn, "decrement!",
+		     rb_grn_fix_size_column_decrement, -1);
 }