groonga 0.0.2 → 0.0.3

data/ext/rb-grn-type.c

@@ -85,7 +85,7 @@ rb_grn_type_initialize (int argc, VALUE *argv, VALUE self)
     }
 
     type = grn_type_create(context, name, name_size, flags, size);
-    rb_grn_object_assign(self, rb_context, context, type, RB_GRN_TRUE);
+    rb_grn_object_assign(Qnil, self, rb_context, context, type);
     rb_grn_context_check(context, rb_ary_new4(argc, argv));
 
     return Qnil;
@@ -98,15 +98,22 @@ rb_grn_init_type (VALUE mGrn)
 
     rb_define_method(rb_cGrnType, "initialize", rb_grn_type_initialize, -1);
 
+    rb_define_const(rb_cGrnType, "OBJECT", INT2NUM(GRN_DB_OBJECT));
+    rb_define_const(rb_cGrnType, "BOOLEAN", INT2NUM(GRN_DB_BOOL));
+    rb_define_const(rb_cGrnType, "BOOL", INT2NUM(GRN_DB_BOOL));
+    rb_define_const(rb_cGrnType, "INT8", INT2NUM(GRN_DB_INT8));
+    rb_define_const(rb_cGrnType, "UINT8", INT2NUM(GRN_DB_UINT8));
+    rb_define_const(rb_cGrnType, "INT16", INT2NUM(GRN_DB_INT16));
+    rb_define_const(rb_cGrnType, "UINT16", INT2NUM(GRN_DB_UINT16));
     rb_define_const(rb_cGrnType, "INT32", INT2NUM(GRN_DB_INT32));
     rb_define_const(rb_cGrnType, "UINT32", INT2NUM(GRN_DB_UINT32));
     rb_define_const(rb_cGrnType, "INT64", INT2NUM(GRN_DB_INT64));
     rb_define_const(rb_cGrnType, "UINT64", INT2NUM(GRN_DB_UINT64));
     rb_define_const(rb_cGrnType, "FLOAT", INT2NUM(GRN_DB_FLOAT));
     rb_define_const(rb_cGrnType, "TIME", INT2NUM(GRN_DB_TIME));
-    rb_define_const(rb_cGrnType, "SHORT_TEXT", INT2NUM(GRN_DB_SHORTTEXT));
+    rb_define_const(rb_cGrnType, "SHORT_TEXT", INT2NUM(GRN_DB_SHORT_TEXT));
     rb_define_const(rb_cGrnType, "TEXT", INT2NUM(GRN_DB_TEXT));
-    rb_define_const(rb_cGrnType, "LONG_TEXT", INT2NUM(GRN_DB_LONGTEXT));
+    rb_define_const(rb_cGrnType, "LONG_TEXT", INT2NUM(GRN_DB_LONG_TEXT));
     rb_define_const(rb_cGrnType, "DELIMIT", INT2NUM(GRN_DB_DELIMIT));
     rb_define_const(rb_cGrnType, "UNIGRAM", INT2NUM(GRN_DB_UNIGRAM));
     rb_define_const(rb_cGrnType, "BIGRAM", INT2NUM(GRN_DB_BIGRAM));

data/ext/rb-grn-utils.c

@@ -116,9 +116,9 @@ rb_grn_bulk_to_ruby_object_by_range_id (grn_ctx *context, grn_obj *bulk,
 				   INT2NUM(time_value->tv_usec));
 	}
 	break;
-      case GRN_DB_SHORTTEXT:
+      case GRN_DB_SHORT_TEXT:
       case GRN_DB_TEXT:
-      case GRN_DB_LONGTEXT:
+      case GRN_DB_LONG_TEXT:
 	*rb_value = rb_str_new(GRN_BULK_HEAD(bulk), GRN_BULK_VSIZE(bulk));
 	break;
       default:
@@ -307,9 +307,9 @@ rb_grn_bulk_from_ruby_object_with_type (VALUE object, grn_ctx *context,
 	string = (const char *)&time_value;
 	size = sizeof(time_value);
 	break;
-      case GRN_DB_SHORTTEXT:
+      case GRN_DB_SHORT_TEXT:
       case GRN_DB_TEXT:
-      case GRN_DB_LONGTEXT:
+      case GRN_DB_LONG_TEXT:
 	string = StringValuePtr(object);
 	size = RSTRING_LEN(object);
 	range = grn_obj_get_range(context, type);
@@ -571,6 +571,133 @@ rb_grn_key_from_ruby_object (VALUE rb_key, grn_ctx *context,
     return key;
 }
 
+grn_obj *
+rb_grn_obj_from_ruby_object (VALUE rb_object, grn_ctx *context, grn_obj **_obj)
+{
+    grn_obj *obj;
+
+    if (*_obj) {
+	obj = *_obj;
+	grn_obj_close(context, obj); /* FIXME: grn_obj_reinit() */
+    } else {
+	*_obj = grn_obj_open(context, GRN_VOID, 0, GRN_ID_NIL);
+	obj = *_obj;
+    }
+
+    switch (TYPE(rb_object)) {
+      case T_NIL:
+	GRN_VOID_INIT(obj);
+	break;
+      case T_STRING:
+	GRN_TEXT_INIT(obj, 0);
+	GRN_TEXT_SET(context, obj,
+		     RSTRING_PTR(rb_object), RSTRING_LEN(rb_object));
+	break;
+      case T_FIXNUM:
+	GRN_INT32_INIT(obj, 0);
+	GRN_INT32_SET(context, obj, NUM2INT(rb_object));
+	break;
+      case T_BIGNUM:
+	GRN_INT64_INIT(obj, 0);
+	GRN_INT64_SET(context, obj, NUM2LL(rb_object));
+	break;
+      case T_FLOAT:
+	GRN_FLOAT_INIT(obj, 0);
+	GRN_FLOAT_SET(context, obj, NUM2DBL(rb_object));
+	break;
+      default:
+	if (RVAL2CBOOL(rb_obj_is_kind_of(rb_object, rb_cTime))) {
+	    VALUE sec, usec;
+	    unsigned long long time_value;
+
+	    sec = rb_funcall(rb_object, rb_intern("to_i"), 0);
+	    usec = rb_funcall(rb_object, rb_intern("usec"), 0);
+	    time_value = NUM2INT(sec);
+	    time_value <<= 32;
+	    time_value += NUM2INT(usec);
+	    GRN_TIME_INIT(obj, 0);
+	    GRN_TIME_SET(context, obj, time_value);
+	} else if (RVAL2CBOOL(rb_obj_is_kind_of(rb_object, rb_cGrnObject))) {
+	    grn_obj_close(context, obj); /* TODO: reduce memory allocation */
+	    *_obj = RVAL2GRNOBJECT(rb_object, &context);
+	    obj = *_obj;
+	} else if (RVAL2CBOOL(rb_obj_is_kind_of(rb_object, rb_cGrnRecord))) {
+	    grn_id id, table_id;
+	    VALUE rb_table;
+	    grn_obj *table = NULL;
+
+	    id = NUM2UINT(rb_funcall(rb_object, rb_intern("id"), 0));
+	    rb_table = rb_funcall(rb_object, rb_intern("table"), 0);
+	    rb_grn_table_deconstruct(RB_GRN_TABLE(DATA_PTR(rb_table)),
+				     &table, NULL,
+				     NULL, NULL, NULL, NULL, NULL);
+	    table_id = grn_obj_id(context, table);
+	    GRN_RECORD_INIT(obj, 0, table_id);
+	    GRN_RECORD_SET(context, obj, id);
+	} else {
+	    rb_raise(rb_eTypeError,
+		     "should be one of "
+		     "[nil, String, Integer, Float, Time, Groonga::Object, "
+		     "Groonga::Record]: <%s>",
+		     rb_grn_inspect(rb_object));
+	}
+	break;
+    }
+
+    return obj;
+}
+
+VALUE
+rb_grn_obj_to_ruby_object (VALUE klass, grn_ctx *context,
+			   grn_obj *obj, VALUE related_object)
+{
+    if (!obj)
+	return Qnil;
+
+/*     if (NIL_P(klass)) */
+/* 	klass = GRNOBJECT2RCLASS(obj); */
+
+    switch (obj->header.type) {
+      case GRN_VOID:
+	return Qnil;
+	break;
+      case GRN_BULK:
+	return GRNBULK2RVAL(context, obj, related_object);
+	break;
+      /* case GRN_PTR: */
+      /* case GRN_UVECTOR: */
+      /* case GRN_PVECTOR: */
+      /* case GRN_VECTOR: */
+      /* case GRN_MSG: */
+      /* case GRN_QUERY: */
+      /* case GRN_ACCESSOR: */
+      /* case GRN_SNIP: */
+      /* case GRN_PATSNIP: */
+      /* case GRN_CURSOR_TABLE_HASH_KEY: */
+      /* case GRN_CURSOR_TABLE_PAT_KEY: */
+      /* case GRN_CURSOR_TABLE_NO_KEY: */
+      /* case GRN_CURSOR_COLUMN_INDEX: */
+      /* case GRN_TYPE: */
+      /* case GRN_PROC: */
+      /* case GRN_EXPR: */
+      /* case GRN_TABLE_HASH_KEY: */
+      /* case GRN_TABLE_PAT_KEY: */
+      /* case GRN_TABLE_NO_KEY: */
+      /* case GRN_DB: */
+      /* case GRN_COLUMN_FIX_SIZE: */
+      /* case GRN_COLUMN_VAR_SIZE: */
+      /* case GRN_COLUMN_INDEX: */
+      default:
+	rb_raise(rb_eTypeError,
+		 "unsupported groonga object: 0x%x: <%s>",
+		 obj->header.type,
+		 rb_grn_inspect(related_object));
+	break;
+    }
+
+    return Qnil;
+}
+
 void
 rb_grn_init_utils (VALUE mGrn)
 {

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

@@ -0,0 +1,36 @@
+/* -*- 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) ((RbGrnVariableSizeColumn *)DATA_PTR(object))
+
+VALUE rb_cGrnVariableSizeColumn;
+
+/*
+ * Document-class: Groonga::FixSizeColumn < Groonga::Column
+ *
+ * 可変長データ用のカラム。
+ */
+
+void
+rb_grn_init_variable_size_column (VALUE mGrn)
+{
+    rb_cGrnVariableSizeColumn =
+	rb_define_class_under(mGrn, "VariableSizeColumn", rb_cGrnColumn);
+}

data/ext/rb-grn-variable.c

@@ -0,0 +1,90 @@
+/* -*- 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) ((RbGrnVariable *)DATA_PTR(object))
+
+VALUE rb_cGrnVariable;
+
+grn_obj *
+rb_grn_variable_from_ruby_object (VALUE variable, grn_ctx **context)
+{
+    return rb_grn_object_from_ruby_object(variable, context);
+}
+
+VALUE
+rb_grn_variable_to_ruby_object (grn_ctx *context, grn_obj *variable)
+{
+    return rb_grn_object_to_ruby_object(rb_cGrnVariable, context, variable,
+                                        RB_GRN_TRUE);
+}
+
+void
+rb_grn_variable_deconstruct (RbGrnVariable *rb_grn_variable,
+                             grn_obj **variable,
+                             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_variable);
+    rb_grn_object_deconstruct(rb_grn_object, variable, context,
+			      domain_id, domain,
+			      range_id, range);
+}
+
+static VALUE
+rb_grn_variable_get_value (VALUE self)
+{
+    grn_ctx *context = NULL;
+    grn_obj *variable;
+
+    rb_grn_variable_deconstruct(SELF(self), &variable, &context,
+                                NULL, NULL,
+                                NULL, NULL);
+
+    return GRNOBJ2RVAL(Qnil, context, variable, self);
+}
+
+static VALUE
+rb_grn_variable_set_value (VALUE self, VALUE value)
+{
+    grn_ctx *context = NULL;
+    grn_obj *variable;
+
+    rb_grn_variable_deconstruct(SELF(self), &variable, &context,
+                                NULL, NULL,
+                                NULL, NULL);
+    RVAL2GRNOBJ(value, context, &variable);
+    return Qnil;
+}
+
+void
+rb_grn_init_variable (VALUE mGrn)
+{
+    rb_cGrnVariable = rb_define_class_under(mGrn, "Variable", rb_cGrnObject);
+
+    rb_define_method(rb_cGrnVariable, "value",
+                     rb_grn_variable_get_value, 0);
+    rb_define_method(rb_cGrnVariable, "value=",
+                     rb_grn_variable_set_value, 1);
+}

data/ext/rb-grn.h

@@ -57,9 +57,15 @@ RB_GRN_BEGIN_DECLS
 #  define RB_GRN_VAR extern
 #endif
 
+#ifdef RB_GRN_DEBUG
+#  define debug(...) printf(__VA_ARGS__)
+#else
+#  define debug(...)
+#endif
+
 #define RB_GRN_MAJOR_VERSION 0
 #define RB_GRN_MINOR_VERSION 0
-#define RB_GRN_MICRO_VERSION 2
+#define RB_GRN_MICRO_VERSION 3
 
 typedef int rb_grn_boolean;
 #define RB_GRN_FALSE (0)
@@ -76,8 +82,11 @@ typedef struct {
 
 #define RB_GRN_OBJECT(object) ((RbGrnObject *)(object))
 #define RB_GRN_TABLE(object) ((RbGrnTable *)(object))
+#define RB_GRN_TABLE_KEY_SUPPORT(object) ((RbGrnTableKeySupport *)(object))
 #define RB_GRN_TABLE_CURSOR(object) ((RbGrnTableCursort *)(object))
+#define RB_GRN_COLUMN(object) ((RbGrnColumn *)(object))
 #define RB_GRN_INDEX_COLUMN(object) ((RbGrnIndexColumn *)(object))
+#define RB_GRN_EXPRESSION(object) ((RbGrnExpression *)(object))
 #define RB_GRN_UNBIND_FUNCTION(function) ((RbGrnUnbindFunction)(function))
 
 typedef void (*RbGrnUnbindFunction) (void *object);
@@ -85,14 +94,14 @@ typedef void (*RbGrnUnbindFunction) (void *object);
 typedef struct _RbGrnObject RbGrnObject;
 struct _RbGrnObject
 {
+    VALUE self;
     grn_ctx *context;
     grn_obj *object;
     grn_obj *domain;
     grn_id domain_id;
     grn_obj *range;
     grn_id range_id;
-    rb_grn_boolean owner;
-    RbGrnUnbindFunction unbind;
+    rb_grn_boolean need_close;
 };
 
 typedef struct _RbGrnTable RbGrnTable;
@@ -116,18 +125,10 @@ struct _RbGrnColumn
     grn_obj *value;
 };
 
-typedef struct _RbGrnFixSizeColumn RbGrnFixSizeColumn;
-struct _RbGrnFixSizeColumn
-{
-    RbGrnObject parent;
-    grn_obj *value;
-};
-
 typedef struct _RbGrnIndexColumn RbGrnIndexColumn;
 struct _RbGrnIndexColumn
 {
-    RbGrnObject parent;
-    grn_obj *value;
+    RbGrnColumn parent;
     grn_obj *old_value;
     grn_obj *id_query;
     grn_obj *string_query;
@@ -139,6 +140,19 @@ struct _RbGrnTableCursor
     RbGrnObject parent;
 };
 
+typedef struct _RbGrnVariable RbGrnVariable;
+struct _RbGrnVariable
+{
+    RbGrnObject parent;
+};
+
+typedef struct _RbGrnExpression RbGrnExpression;
+struct _RbGrnExpression
+{
+    RbGrnObject parent;
+    grn_obj *value;
+};
+
 RB_GRN_VAR VALUE rb_eGrnError;
 RB_GRN_VAR VALUE rb_cGrnObject;
 RB_GRN_VAR VALUE rb_mGrnEncodingSupport;
@@ -157,13 +171,18 @@ RB_GRN_VAR VALUE rb_cGrnType;
 RB_GRN_VAR VALUE rb_cGrnProcedure;
 RB_GRN_VAR VALUE rb_cGrnColumn;
 RB_GRN_VAR VALUE rb_cGrnFixSizeColumn;
-RB_GRN_VAR VALUE rb_cGrnVarSizeColumn;
+RB_GRN_VAR VALUE rb_cGrnVariableSizeColumn;
 RB_GRN_VAR VALUE rb_cGrnIndexColumn;
 RB_GRN_VAR VALUE rb_cGrnAccessor;
 RB_GRN_VAR VALUE rb_cGrnRecord;
 RB_GRN_VAR VALUE rb_cGrnQuery;
 RB_GRN_VAR VALUE rb_cGrnLogger;
 RB_GRN_VAR VALUE rb_cGrnSnippet;
+RB_GRN_VAR VALUE rb_cGrnVariable;
+RB_GRN_VAR VALUE rb_cGrnOperation;
+RB_GRN_VAR VALUE rb_cGrnExpression;
+RB_GRN_VAR VALUE rb_cGrnRecordExpressionBuilder;
+RB_GRN_VAR VALUE rb_cGrnColumnExpressionBuilder;
 
 void           rb_grn_init_utils                    (VALUE mGrn);
 void           rb_grn_init_exception                (VALUE mGrn);
@@ -186,10 +205,15 @@ void           rb_grn_init_type                     (VALUE mGrn);
 void           rb_grn_init_procedure                (VALUE mGrn);
 void           rb_grn_init_column                   (VALUE mGrn);
 void           rb_grn_init_fix_size_column          (VALUE mGrn);
+void           rb_grn_init_variable_size_column     (VALUE mGrn);
 void           rb_grn_init_index_column             (VALUE mGrn);
 void           rb_grn_init_accessor                 (VALUE mGrn);
 void           rb_grn_init_record                   (VALUE mGrn);
 void           rb_grn_init_query                    (VALUE mGrn);
+void           rb_grn_init_variable                 (VALUE mGrn);
+void           rb_grn_init_operation                (VALUE mGrn);
+void           rb_grn_init_expression               (VALUE mGrn);
+void           rb_grn_init_expression_builder       (VALUE mGrn);
 void           rb_grn_init_logger                   (VALUE mGrn);
 void           rb_grn_init_snippet                  (VALUE mGrn);
 
@@ -210,6 +234,10 @@ VALUE          rb_grn_context_to_exception          (grn_ctx *context,
 						     VALUE related_object);
 void           rb_grn_context_check                 (grn_ctx *context,
 						     VALUE related_object);
+grn_obj       *rb_grn_context_get_backward_compatibility
+                                                    (grn_ctx *context,
+						     const char *name,
+						     unsigned int name_size);
 
 const char    *rb_grn_inspect                       (VALUE object);
 void           rb_grn_scan_options                  (VALUE options, ...)
@@ -218,16 +246,17 @@ rb_grn_boolean rb_grn_equal_option                  (VALUE option,
 						     const char *key);
 
 VALUE          rb_grn_object_alloc                  (VALUE klass);
-void           rb_grn_object_bind                   (RbGrnObject *rb_grn_object,
+void           rb_grn_object_bind                   (VALUE self,
+						     VALUE rb_context,
+						     RbGrnObject *rb_grn_object,
 						     grn_ctx *context,
-						     grn_obj *object,
-						     rb_grn_boolean owner);
-void           rb_grn_object_unbind                 (RbGrnObject *rb_grn_object);
-void           rb_grn_object_assign                 (VALUE self,
+						     grn_obj *object);
+void           rb_grn_object_free                   (RbGrnObject *rb_grn_object);
+void           rb_grn_object_assign                 (VALUE klass,
+						     VALUE self,
 						     VALUE rb_context,
 						     grn_ctx *context,
-						     grn_obj *object,
-						     rb_grn_boolean owner);
+						     grn_obj *object);
 void           rb_grn_object_deconstruct            (RbGrnObject *rb_grn_object,
 						     grn_obj **object,
 						     grn_ctx **context,
@@ -252,12 +281,12 @@ VALUE          rb_grn_object_inspect_content        (VALUE object,
 VALUE          rb_grn_object_inspect_footer         (VALUE object,
 						     VALUE inspected);
 
-VALUE          rb_grn_table_alloc                   (VALUE klass);
 void           rb_grn_table_bind                    (RbGrnTable *rb_grn_table,
 						     grn_ctx *context,
-						     grn_obj *table_key_support,
-						     rb_grn_boolean owner);
-void           rb_grn_table_unbind                  (RbGrnTable *rb_grn_table);
+						     grn_obj *table_key_support);
+void           rb_grn_table_finalizer               (grn_ctx *context,
+						     grn_obj *grn_object,
+						     RbGrnTable *rb_grn_table);
 void           rb_grn_table_assign                  (VALUE self,
 						     VALUE rb_context,
 						     grn_ctx *context,
@@ -293,17 +322,12 @@ grn_ctx       *rb_grn_table_cursor_ensure_context   (VALUE cursor,
 						     VALUE *rb_context);
 VALUE          rb_grn_table_cursor_close            (VALUE object);
 
-VALUE          rb_grn_table_key_support_alloc       (VALUE klass);
 void           rb_grn_table_key_support_bind        (RbGrnTableKeySupport *rb_grn_table_key_support,
 						     grn_ctx *context,
-						     grn_obj *table_key_support,
-						     rb_grn_boolean owner);
-void           rb_grn_table_key_support_unbind      (RbGrnTableKeySupport *rb_grn_table_key_support);
-void           rb_grn_table_key_support_assign      (VALUE self,
-						     VALUE rb_context,
-						     grn_ctx *context,
-						     grn_obj *table_key_support,
-						     rb_grn_boolean owner);
+						     grn_obj *table_key_support);
+void           rb_grn_table_key_support_finalizer   (grn_ctx *context,
+						     grn_obj *grn_object,
+						     RbGrnTableKeySupport *rb_grn_table_key_support);
 void           rb_grn_table_key_support_deconstruct (RbGrnTableKeySupport *rb_grn_table_key_support,
 						     grn_obj **table_key_support,
 						     grn_ctx **context,
@@ -316,18 +340,13 @@ void           rb_grn_table_key_support_deconstruct (RbGrnTableKeySupport *rb_gr
 grn_id         rb_grn_table_key_support_get         (VALUE self,
 						     VALUE rb_key);
 
-VALUE          rb_grn_fix_size_column_alloc         (VALUE klass);
-void           rb_grn_fix_size_column_bind          (RbGrnFixSizeColumn *rb_grn_fix_size_column,
-						     grn_ctx *context,
-						     grn_obj *column_key_support,
-						     rb_grn_boolean owner);
-void           rb_grn_fix_size_column_unbind        (RbGrnFixSizeColumn *rb_grn_fix_size_column);
-void           rb_grn_fix_size_column_assign        (VALUE self,
-						     VALUE rb_context,
+void           rb_grn_column_bind                   (RbGrnColumn *rb_grn_column,
 						     grn_ctx *context,
+						     grn_obj *column);
+void           rb_grn_column_finalizer              (grn_ctx *context,
 						     grn_obj *column,
-						     rb_grn_boolean owner);
-void           rb_grn_fix_size_column_deconstruct   (RbGrnFixSizeColumn *rb_grn_fix_size_column,
+						     RbGrnColumn *rb_grn_column);
+void           rb_grn_column_deconstruct            (RbGrnColumn *rb_grn_column,
 						     grn_obj **column,
 						     grn_ctx **context,
 						     grn_id *domain_id,
@@ -336,17 +355,12 @@ void           rb_grn_fix_size_column_deconstruct   (RbGrnFixSizeColumn *rb_grn_
 						     grn_id *range_id,
 						     grn_obj **range);
 
-VALUE          rb_grn_index_column_alloc            (VALUE klass);
 void           rb_grn_index_column_bind             (RbGrnIndexColumn *rb_grn_index_column,
 						     grn_ctx *context,
-						     grn_obj *column_key_support,
-						     rb_grn_boolean owner);
-void           rb_grn_index_column_unbind           (RbGrnIndexColumn *rb_grn_index_column);
-void           rb_grn_index_column_assign           (VALUE self,
-						     VALUE rb_context,
-						     grn_ctx *context,
-						     grn_obj *column,
-						     rb_grn_boolean owner);
+						     grn_obj *object);
+void           rb_grn_index_column_finalizer        (grn_ctx *context,
+						     grn_obj *grn_object,
+						     RbGrnIndexColumn *rb_grn_index_column);
 void           rb_grn_index_column_deconstruct      (RbGrnIndexColumn *rb_grn_index_column,
 						     grn_obj **column,
 						     grn_ctx **context,
@@ -359,10 +373,27 @@ void           rb_grn_index_column_deconstruct      (RbGrnIndexColumn *rb_grn_in
 						     grn_obj **id_query,
 						     grn_obj **string_query);
 
+void           rb_grn_expression_bind               (RbGrnExpression *rb_grn_expression,
+						     grn_ctx *context,
+						     grn_obj *expression);
+void           rb_grn_expression_finalizer          (grn_ctx *context,
+						     grn_obj *grn_object,
+						     RbGrnExpression *rb_grn_expression);
+
 VALUE          rb_grn_record_new                    (VALUE table,
 						     grn_id id,
 						     VALUE values);
 
+VALUE          rb_grn_record_expression_builder_new (VALUE table,
+						     VALUE name);
+VALUE          rb_grn_record_expression_builder_build
+                                                    (VALUE self);
+VALUE          rb_grn_column_expression_builder_new (VALUE column,
+						     VALUE name,
+						     VALUE query);
+VALUE          rb_grn_column_expression_builder_build
+                                                    (VALUE self);
+
 
 #define RB_GRN_INTERN(string)         (ID2SYM(rb_intern(string)))
 
@@ -382,6 +413,12 @@ VALUE          rb_grn_record_new                    (VALUE table,
     (rb_grn_object_to_ruby_object(klass, context, object, owner))
 #define GRNOBJECT2RCLASS(object)      (rb_grn_object_to_ruby_class(object))
 
+/* TODO: MORE BETTER NAME!!! PLEASE!!! */
+#define RVAL2GRNOBJ(rb_object, context, object)	\
+    (rb_grn_obj_from_ruby_object(rb_object, context, object))
+#define GRNOBJ2RVAL(klass, context, object, related_object)	\
+    (rb_grn_obj_to_ruby_object(klass, context, object, related_object))
+
 #define RVAL2GRNDB(object)            (rb_grn_database_from_ruby_object(object))
 #define GRNDB2RVAL(context, db, owner) \
     (rb_grn_database_to_ruby_object(context, db, owner))
@@ -403,7 +440,7 @@ VALUE          rb_grn_record_new                    (VALUE table,
 #define RVAL2GRNQUERY(object)         (rb_grn_query_from_ruby_object(object))
 #define GRNQUERY2RVAL(context, column)(rb_grn_query_to_ruby_object(context, column))
 
-#define RVAL2GRNSELECTOPERATOR(object)(rb_grn_select_operator_from_ruby_object(object))
+#define RVAL2GRNOPERATOR(object)      (rb_grn_operator_from_ruby_object(object))
 
 #define RVAL2GRNLOGGER(object)        (rb_grn_logger_from_ruby_object(object))
 
@@ -436,6 +473,11 @@ VALUE          rb_grn_record_new                    (VALUE table,
     (rb_grn_key_from_ruby_object(object, context, key, domain_id,	\
 				 domain, related_object))
 
+#define GRNVARIABLE2RVAL(context, variable) \
+    (rb_grn_variable_to_ruby_object(context, variable))
+#define RVAL2GRNVARIABLE(object, context) \
+    (rb_grn_variable_from_ruby_object(object, context))
+
 
 grn_encoding   rb_grn_encoding_from_ruby_object     (VALUE object,
 						     grn_ctx *context);
@@ -490,9 +532,7 @@ grn_query     *rb_grn_query_from_ruby_object        (VALUE object);
 VALUE          rb_grn_query_to_ruby_object          (grn_ctx *context,
 						     grn_query *query);
 
-grn_sel_operator
-               rb_grn_select_operator_from_ruby_object
-                                                    (VALUE object);
+grn_operator   rb_grn_operator_from_ruby_object     (VALUE object);
 
 grn_logger_info *
                rb_grn_logger_from_ruby_object       (VALUE object);
@@ -542,6 +582,19 @@ grn_obj       *rb_grn_key_from_ruby_object          (VALUE rb_key,
 						     grn_obj *domain,
 						     VALUE related_object);
 
+VALUE          rb_grn_variable_to_ruby_object       (grn_ctx *context,
+						     grn_obj *variable);
+grn_obj       *rb_grn_variable_from_ruby_object     (VALUE rb_variable,
+						     grn_ctx **context);
+
+grn_obj       *rb_grn_obj_from_ruby_object          (VALUE rb_object,
+						     grn_ctx *context,
+						     grn_obj **obj);
+VALUE          rb_grn_obj_to_ruby_object            (VALUE klass,
+						     grn_ctx *context,
+						     grn_obj *obj,
+						     VALUE related_object);
+
 RB_GRN_END_DECLS
 
 #endif