groonga 0.0.1 → 0.0.2

data/ext/rb-grn-table.c

@@ -18,7 +18,7 @@
 
 #include "rb-grn.h"
 
-#define SELF(object, context) (RVAL2GRNTABLE(object, context))
+#define SELF(object) ((RbGrnTable *)DATA_PTR(object))
 
 VALUE rb_cGrnTable;
 
@@ -39,6 +39,85 @@ rb_grn_table_to_ruby_object (grn_ctx *context, grn_obj *table,
     return GRNOBJECT2RVAL(rb_cGrnTable, context, table, owner);
 }
 
+void
+rb_grn_table_unbind (RbGrnTable *rb_grn_table)
+{
+    RbGrnObject *rb_grn_object;
+    grn_ctx *context;
+
+    rb_grn_object = RB_GRN_OBJECT(rb_grn_table);
+    context = rb_grn_object->context;
+
+    if (context)
+	grn_obj_close(context, rb_grn_table->value);
+
+    rb_grn_object_unbind(rb_grn_object);
+}
+
+static void
+rb_grn_table_free (void *object)
+{
+    RbGrnTable *rb_grn_table = object;
+
+    rb_grn_table_unbind(rb_grn_table);
+    xfree(rb_grn_table);
+}
+
+VALUE
+rb_grn_table_alloc (VALUE klass)
+{
+    return Data_Wrap_Struct(klass, NULL, rb_grn_table_free, NULL);
+}
+
+void
+rb_grn_table_bind (RbGrnTable *rb_grn_table,
+		   grn_ctx *context, grn_obj *table, rb_grn_boolean owner)
+{
+    RbGrnObject *rb_grn_object;
+
+    rb_grn_object = RB_GRN_OBJECT(rb_grn_table);
+    rb_grn_object_bind(rb_grn_object, context, table, owner);
+    rb_grn_object->unbind = RB_GRN_UNBIND_FUNCTION(rb_grn_table_unbind);
+
+    rb_grn_table->value = grn_obj_open(context, GRN_BULK, 0,
+				       rb_grn_object->range_id);
+}
+
+void
+rb_grn_table_assign (VALUE self, VALUE rb_context,
+		     grn_ctx *context, grn_obj *table,
+		     rb_grn_boolean owner)
+{
+    RbGrnTable *rb_grn_table;
+
+    rb_grn_table = ALLOC(RbGrnTable);
+    DATA_PTR(self) = rb_grn_table;
+    rb_grn_table_bind(rb_grn_table, context, table, owner);
+
+    rb_iv_set(self, "context", rb_context);
+}
+
+void
+rb_grn_table_deconstruct (RbGrnTable *rb_grn_table,
+			  grn_obj **table,
+			  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_table);
+    rb_grn_object_deconstruct(rb_grn_object, table, context,
+			      domain_id, domain,
+			      range_id, range);
+
+    if (value)
+	*value = rb_grn_table->value;
+}
+
 VALUE
 rb_grn_table_s_create (int argc, VALUE *argv, VALUE klass,
 		       grn_obj_flags key_store)
@@ -66,7 +145,7 @@ rb_grn_table_s_create (int argc, VALUE *argv, VALUE klass,
 			"value_size", &rb_value_size,
 			NULL);
 
-    context = rb_grn_context_ensure(rb_context);
+    context = rb_grn_context_ensure(&rb_context);
 
     if (!NIL_P(rb_name)) {
         name = StringValuePtr(rb_name);
@@ -98,7 +177,8 @@ rb_grn_table_s_create (int argc, VALUE *argv, VALUE klass,
 
     table = grn_table_create(context, name, name_size, path,
 			     flags, key_type, value_size);
-    rb_table = GRNOBJECT2RVAL(klass, context, table, RB_GRN_TRUE);
+    rb_table = rb_grn_table_alloc(klass);
+    rb_grn_table_assign(rb_table, rb_context, context, table, RB_GRN_TRUE);
     rb_grn_context_check(context, rb_table);
 
     if (rb_block_given_p())
@@ -107,18 +187,19 @@ rb_grn_table_s_create (int argc, VALUE *argv, VALUE klass,
         return rb_table;
 }
 
-static grn_obj *
-rb_grn_table_open (int argc, VALUE *argv, grn_ctx **context)
+grn_obj *
+rb_grn_table_open_raw (int argc, VALUE *argv,
+		       grn_ctx **context, VALUE *rb_context)
 {
     grn_obj *table;
     char *name = NULL, *path = NULL;
     unsigned name_size = 0;
-    VALUE rb_path, options, rb_context, rb_name;
+    VALUE rb_path, options, rb_name;
 
     rb_scan_args(argc, argv, "01", &options);
 
     rb_grn_scan_options(options,
-			"context", &rb_context,
+			"context", rb_context,
 			"name", &rb_name,
 			"path", &rb_path,
 			NULL);
@@ -142,9 +223,16 @@ rb_grn_table_initialize (int argc, VALUE *argv, VALUE self)
 {
     grn_ctx *context = NULL;
     grn_obj *table;
+    VALUE rb_context;
 
-    table = rb_grn_table_open(argc, argv, &context);
-    rb_grn_object_initialize(self, context, table);
+    table = rb_grn_table_open_raw(argc, argv, &context, &rb_context);
+    /* FIXME!!!! */
+    if (self == rb_cGrnArray) {
+	rb_grn_table_assign(self, rb_context, context, table, RB_GRN_TRUE);
+    } else {
+	rb_grn_table_key_support_assign(self, rb_context, context,
+					table, RB_GRN_TRUE);
+    }
     rb_grn_context_check(context, self);
 
     return Qnil;
@@ -153,23 +241,44 @@ rb_grn_table_initialize (int argc, VALUE *argv, VALUE self)
 static VALUE
 rb_grn_table_s_open (int argc, VALUE *argv, VALUE klass)
 {
-    grn_ctx *context = NULL;
+    VALUE rb_table;
     grn_obj *table;
-    VALUE rb_table, rb_class;
+    grn_ctx *context = NULL;
+    VALUE rb_context;
 
-    table = rb_grn_table_open(argc, argv, &context);
+    table = rb_grn_table_open_raw(argc, argv, &context, &rb_context);
     rb_grn_context_check(context, rb_ary_new4(argc, argv));
-    if (klass != rb_cGrnTable) {
+
+    if (!table)
+	rb_raise(rb_eGrnError,
+		 "unable to open table: %s: %s",
+		 rb_grn_inspect(klass),
+		 rb_grn_inspect(rb_ary_new4(argc, argv)));
+
+    if (klass == rb_cGrnTable) {
+	klass = GRNOBJECT2RCLASS(table);
+    } else {
+	VALUE rb_class;
+
 	rb_class = GRNOBJECT2RCLASS(table);
-	if (klass != rb_class)
+	if (rb_class != klass) {
 	    rb_raise(rb_eTypeError,
 		     "unexpected existing table type: %s: expected %s",
 		     rb_grn_inspect(rb_class),
 		     rb_grn_inspect(klass));
+	}
+    }
+
+    /* FIXME!!!! */
+    if (klass == rb_cGrnArray) {
+	rb_table = rb_grn_table_alloc(klass);
+	rb_grn_table_assign(rb_table, rb_context, context, table, RB_GRN_TRUE);
+    } else {
+	rb_table = rb_grn_table_key_support_alloc(klass);
+	rb_grn_table_key_support_assign(rb_table, rb_context, context,
+					table, RB_GRN_TRUE);
     }
 
-    rb_table = rb_grn_object_alloc(klass);
-    rb_grn_table_initialize(argc, argv, rb_table);
     if (rb_block_given_p())
         return rb_ensure(rb_yield, rb_table, rb_grn_object_close, rb_table);
     else
@@ -182,10 +291,14 @@ rb_grn_table_inspect_content (VALUE self, VALUE inspected)
     grn_ctx *context = NULL;
     grn_obj *table;
 
-    table = SELF(self, &context);
+    rb_grn_table_deconstruct(SELF(self), &table, &context,
+			     NULL, NULL,
+			     NULL, NULL, NULL);
 
     if (!table)
 	return inspected;
+    if (!context)
+	return inspected;
 
     if (table->header.type != GRN_TABLE_NO_KEY) {
 	grn_obj value;
@@ -193,7 +306,7 @@ rb_grn_table_inspect_content (VALUE self, VALUE inspected)
 
 	rb_str_cat2(inspected, ", ");
 	rb_str_cat2(inspected, "encoding: <");
-	GRN_OBJ_INIT(&value, GRN_BULK, 0);
+	GRN_OBJ_INIT(&value, GRN_BULK, 0, GRN_ID_NIL);
 	grn_obj_get_info(context, table, GRN_INFO_ENCODING, &value);
 	encoding = *((grn_encoding *)GRN_BULK_HEAD(&value));
 	grn_obj_close(context, &value);
@@ -241,12 +354,12 @@ rb_grn_table_define_column (int argc, VALUE *argv, VALUE self)
     char *name = NULL, *path = NULL;
     unsigned name_size = 0;
     grn_obj_flags flags = 0;
-    rb_grn_boolean use_default_type = RB_GRN_FALSE;
     VALUE rb_name, rb_value_type;
     VALUE options, rb_path, rb_persistent, rb_type;
-    VALUE rb_compress, rb_with_section, rb_with_weight, rb_with_position;
 
-    table = SELF(self, &context);
+    rb_grn_table_deconstruct(SELF(self), &table, &context,
+			     NULL, NULL,
+			     NULL, NULL, NULL);
 
     rb_scan_args(argc, argv, "21", &rb_name, &rb_value_type, &options);
 
@@ -257,10 +370,6 @@ rb_grn_table_define_column (int argc, VALUE *argv, VALUE self)
 			"path", &rb_path,
 			"persistent", &rb_persistent,
 			"type", &rb_type,
-			"compress", &rb_compress,
-			"with_section", &rb_with_section,
-			"with_weight", &rb_with_weight,
-			"with_position", &rb_with_position,
 			NULL);
 
     value_type = RVAL2GRNOBJECT(rb_value_type, &context);
@@ -273,21 +382,69 @@ rb_grn_table_define_column (int argc, VALUE *argv, VALUE self)
     if (RVAL2CBOOL(rb_persistent))
 	flags |= GRN_OBJ_PERSISTENT;
 
-    if (NIL_P(rb_type)) {
-	use_default_type = RB_GRN_TRUE;
-    } else if (rb_grn_equal_option(rb_type, "index")) {
-	flags |= GRN_OBJ_COLUMN_INDEX;
-    } else if (rb_grn_equal_option(rb_type, "scalar")) {
+    if (NIL_P(rb_type) ||
+	(rb_grn_equal_option(rb_type, "scalar"))) {
 	flags |= GRN_OBJ_COLUMN_SCALAR;
     } else if (rb_grn_equal_option(rb_type, "vector")) {
 	flags |= GRN_OBJ_COLUMN_VECTOR;
     } else {
 	rb_raise(rb_eArgError,
 		 "invalid column type: %s: "
-		 "available types: [:index, :scalar, :vector, nil]",
+		 "available types: [:scalar, :vector, nil]",
 		 rb_grn_inspect(rb_type));
     }
 
+    column = grn_column_create(context, table, name, name_size,
+			       path, flags, value_type);
+    rb_grn_context_check(context, self);
+
+    return GRNCOLUMN2RVAL(Qnil, context, column, RB_GRN_TRUE);
+}
+
+static VALUE
+rb_grn_table_define_index_column (int argc, VALUE *argv, VALUE self)
+{
+    grn_ctx *context = NULL;
+    grn_obj *table;
+    grn_obj *value_type, *column;
+    char *name = NULL, *path = NULL;
+    unsigned name_size = 0;
+    grn_obj_flags flags = GRN_OBJ_COLUMN_INDEX;
+    VALUE rb_name, rb_value_type;
+    VALUE options, rb_path, rb_persistent;
+    VALUE rb_compress, rb_with_section, rb_with_weight, rb_with_position;
+    VALUE rb_column, rb_source, rb_sources;
+
+    rb_grn_table_deconstruct(SELF(self), &table, &context,
+			     NULL, NULL,
+			     NULL, NULL, NULL);
+
+    rb_scan_args(argc, argv, "21", &rb_name, &rb_value_type, &options);
+
+    name = StringValuePtr(rb_name);
+    name_size = RSTRING_LEN(rb_name);
+
+    rb_grn_scan_options(options,
+			"path", &rb_path,
+			"persistent", &rb_persistent,
+			"compress", &rb_compress,
+			"with_section", &rb_with_section,
+			"with_weight", &rb_with_weight,
+			"with_position", &rb_with_position,
+			"source", &rb_source,
+			"sources", &rb_sources,
+			NULL);
+
+    value_type = RVAL2GRNOBJECT(rb_value_type, &context);
+
+    if (!NIL_P(rb_path)) {
+	path = StringValueCStr(rb_path);
+	flags |= GRN_OBJ_PERSISTENT;
+    }
+
+    if (RVAL2CBOOL(rb_persistent))
+	flags |= GRN_OBJ_PERSISTENT;
+
     if (NIL_P(rb_compress)) {
     } else if (rb_grn_equal_option(rb_compress, "zlib")) {
 	flags |= GRN_OBJ_COMPRESS_ZLIB;
@@ -300,44 +457,45 @@ rb_grn_table_define_column (int argc, VALUE *argv, VALUE self)
 		 rb_grn_inspect(rb_compress));
     }
 
-    if (RVAL2CBOOL(rb_with_section)) {
-	if (use_default_type)
-	    flags |= GRN_OBJ_COLUMN_INDEX;
-	if (flags & GRN_OBJ_COLUMN_INDEX)
-	    flags |= GRN_OBJ_WITH_SECTION;
-	else
-	    rb_raise(rb_eArgError,
-		     "{:with_section => true} requires "
-		     "{:type => :index} option.");
-    }
-
-    if (RVAL2CBOOL(rb_with_weight)) {
-	if (use_default_type)
-	    flags |= GRN_OBJ_COLUMN_INDEX;
-	if (flags & GRN_OBJ_COLUMN_INDEX)
-	    flags |= GRN_OBJ_WITH_WEIGHT;
-	else
-	    rb_raise(rb_eArgError,
-		     "{:with_weight => true} requires "
-		     "{:type => :index} option.");
+    if (RVAL2CBOOL(rb_with_section))
+	flags |= GRN_OBJ_WITH_SECTION;
+
+    if (RVAL2CBOOL(rb_with_weight))
+	flags |= GRN_OBJ_WITH_WEIGHT;
+
+    if (NIL_P(rb_with_position) &&
+	(table->header.type == GRN_TABLE_HASH_KEY ||
+	 table->header.type == GRN_TABLE_PAT_KEY)) {
+	grn_id tokenizer_id;
+	grn_obj *tokenizer;
+
+	tokenizer = grn_obj_get_info(context, table,
+				     GRN_INFO_DEFAULT_TOKENIZER,
+				     NULL);
+	tokenizer_id = grn_obj_id(context, tokenizer);
+	if ((tokenizer_id == GRN_DB_UNIGRAM) ||
+	    (tokenizer_id == GRN_DB_BIGRAM) ||
+	    (tokenizer_id == GRN_DB_TRIGRAM)) {
+	    rb_with_position = Qtrue;
+	}
     }
+    if (RVAL2CBOOL(rb_with_position))
+	flags |= GRN_OBJ_WITH_POSITION;
 
-    if (RVAL2CBOOL(rb_with_position)) {
-	if (use_default_type)
-	    flags |= GRN_OBJ_COLUMN_INDEX;
-	if (flags & GRN_OBJ_COLUMN_INDEX)
-	    flags |= GRN_OBJ_WITH_POSITION;
-	else
-	    rb_raise(rb_eArgError,
-		     "{:with_position => true} requires "
-		     "{:type => :index} option.");
-    }
+    if (!NIL_P(rb_source) && !NIL_P(rb_sources))
+	rb_raise(rb_eArgError, "should not pass both of :source and :sources.");
 
     column = grn_column_create(context, table, name, name_size,
 			       path, flags, value_type);
     rb_grn_context_check(context, self);
 
-    return GRNCOLUMN2RVAL(Qnil, context, column, RB_GRN_TRUE);
+    rb_column = GRNCOLUMN2RVAL(Qnil, context, column, RB_GRN_TRUE);
+    if (!NIL_P(rb_source))
+	rb_funcall(rb_column, rb_intern("source="), 1, rb_source);
+    if (!NIL_P(rb_sources))
+	rb_funcall(rb_column, rb_intern("sources="), 1, rb_sources);
+
+    return rb_column;
 }
 
 static VALUE
@@ -349,8 +507,11 @@ rb_grn_table_add_column (VALUE self, VALUE rb_name, VALUE rb_value_type,
     grn_obj *value_type, *column;
     char *name = NULL, *path = NULL;
     unsigned name_size = 0;
+    VALUE rb_column;
 
-    table = SELF(self, &context);
+    rb_grn_table_deconstruct(SELF(self), &table, &context,
+			     NULL, NULL,
+			     NULL, NULL, NULL);
 
     name = StringValuePtr(rb_name);
     name_size = RSTRING_LEN(rb_name);
@@ -363,7 +524,9 @@ rb_grn_table_add_column (VALUE self, VALUE rb_name, VALUE rb_value_type,
 			     path, value_type);
     rb_grn_context_check(context, self);
 
-    return GRNCOLUMN2RVAL(Qnil, context, column, RB_GRN_TRUE);
+    rb_column = GRNCOLUMN2RVAL(Qnil, context, column, RB_GRN_TRUE);
+    rb_iv_set(rb_column, "table", self);
+    return rb_column;
 }
 
 static VALUE
@@ -375,17 +538,23 @@ rb_grn_table_get_column (VALUE self, VALUE rb_name)
     char *name = NULL;
     unsigned name_size = 0;
     rb_grn_boolean owner;
+    VALUE rb_column;
 
-    table = SELF(self, &context);
+    rb_grn_table_deconstruct(SELF(self), &table, &context,
+			     NULL, NULL,
+			     NULL, NULL, NULL);
 
     name = StringValuePtr(rb_name);
     name_size = RSTRING_LEN(rb_name);
 
-    column = grn_table_column(context, table, name, name_size);
+    column = grn_obj_column(context, table, name, name_size);
     rb_grn_context_check(context, self);
 
     owner = (column && column->header.type == GRN_ACCESSOR);
-    return GRNCOLUMN2RVAL(Qnil, context, column, owner);
+    rb_column = GRNCOLUMN2RVAL(Qnil, context, column, owner);
+    if (owner)
+	rb_iv_set(rb_column, "table", self);
+    return rb_column;
 }
 
 static VALUE
@@ -401,7 +570,9 @@ rb_grn_table_get_columns (int argc, VALUE *argv, VALUE self)
     char *name = NULL;
     unsigned name_size = 0;
 
-    table = SELF(self, &context);
+    rb_grn_table_deconstruct(SELF(self), &table, &context,
+			     NULL, NULL,
+			     NULL, NULL, NULL);
 
     rb_scan_args(argc, argv, "01", &rb_name);
 
@@ -430,7 +601,7 @@ rb_grn_table_get_columns (int argc, VALUE *argv, VALUE self)
 
 	grn_table_cursor_get_key(context, cursor, &key);
 	column_id = key;
-	column = grn_ctx_get(context, *column_id);
+	column = grn_ctx_at(context, *column_id);
 	rb_column = GRNOBJECT2RVAL(Qnil, context, column, RB_GRN_FALSE);
 	rb_ary_push(rb_columns, rb_column);
     }
@@ -454,7 +625,9 @@ rb_grn_table_open_grn_cursor (int argc, VALUE *argv, VALUE self,
     int flags = 0;
     VALUE options, rb_min, rb_max, rb_order, rb_greater_than, rb_less_than;
 
-    table = SELF(self, context);
+    rb_grn_table_deconstruct(SELF(self), &table, context,
+			     NULL, NULL,
+			     NULL, NULL, NULL);
 
     rb_scan_args(argc, argv, "01", &options);
 
@@ -531,7 +704,7 @@ rb_grn_table_get_records (int argc, VALUE *argv, VALUE self)
     cursor = rb_grn_table_open_grn_cursor(argc, argv, self, &context);
     records = rb_ary_new();
     while ((record_id = grn_table_cursor_next(context, cursor))) {
-	rb_ary_push(records, rb_grn_record_new(self, record_id));
+	rb_ary_push(records, rb_grn_record_new(self, record_id, Qnil));
     }
     grn_table_cursor_close(context, cursor);
 
@@ -545,7 +718,9 @@ rb_grn_table_get_size (VALUE self)
     grn_obj *table;
     unsigned int size;
 
-    table = SELF(self, &context);
+    rb_grn_table_deconstruct(SELF(self), &table, &context,
+			     NULL, NULL,
+			     NULL, NULL, NULL);
     size = grn_table_size(context, table);
     return UINT2NUM(size);
 }
@@ -557,7 +732,9 @@ rb_grn_table_truncate (VALUE self)
     grn_obj *table;
     grn_rc rc;
 
-    table = SELF(self, &context);
+    rb_grn_table_deconstruct(SELF(self), &table, &context,
+			     NULL, NULL,
+			     NULL, NULL, NULL);
     rc = grn_table_truncate(context, table);
     rb_grn_rc_check(rc, self);
 
@@ -570,21 +747,25 @@ rb_grn_table_each (VALUE self)
     grn_ctx *context = NULL;
     grn_obj *table;
     grn_table_cursor *cursor;
+    VALUE rb_cursor;
     grn_id id;
 
-    table = SELF(self, &context);
+    rb_grn_table_deconstruct(SELF(self), &table, &context,
+			     NULL, NULL,
+			     NULL, NULL, NULL);
     cursor = grn_table_cursor_open(context, table, NULL, 0, NULL, 0, 0);
-    rb_iv_set(self, "cursor", GRNTABLECURSOR2RVAL(Qnil, context, cursor));
+    rb_cursor = GRNTABLECURSOR2RVAL(Qnil, context, cursor);
+    rb_iv_set(self, "cursor", rb_cursor);
     while ((id = grn_table_cursor_next(context, cursor)) != GRN_ID_NIL) {
-	rb_yield(rb_grn_record_new(self, id));
+	rb_yield(rb_grn_record_new(self, id, Qnil));
     }
-    grn_table_cursor_close(context, cursor);
+    rb_grn_table_cursor_close(rb_cursor);
     rb_iv_set(self, "cursor", Qnil);
 
     return Qnil;
 }
 
-static VALUE
+VALUE
 rb_grn_table_delete (VALUE self, VALUE rb_id)
 {
     grn_ctx *context = NULL;
@@ -592,7 +773,9 @@ rb_grn_table_delete (VALUE self, VALUE rb_id)
     grn_id id;
     grn_rc rc;
 
-    table = SELF(self, &context);
+    rb_grn_table_deconstruct(SELF(self), &table, &context,
+			     NULL, NULL,
+			     NULL, NULL, NULL);
 
     id = NUM2UINT(rb_id);
     rc = grn_table_delete_by_id(context, table, id);
@@ -614,7 +797,9 @@ rb_grn_table_sort (int argc, VALUE *argv, VALUE self)
     VALUE rb_limit;
     VALUE *rb_sort_keys;
 
-    table = SELF(self, &context);
+    rb_grn_table_deconstruct(SELF(self), &table, &context,
+			     NULL, NULL,
+			     NULL, NULL, NULL);
 
     rb_scan_args(argc, argv, "11", &rb_keys, &options);
     rb_grn_scan_options(options,
@@ -664,10 +849,76 @@ rb_grn_table_sort (int argc, VALUE *argv, VALUE self)
     return GRNOBJECT2RVAL(Qnil, context, result, RB_GRN_TRUE);
 }
 
+/*
+ * Document-method: []
+ *
+ * call-seq:
+ *   table[id] -> 値
+ *
+ * _table_の_id_に対応する値を返す。
+ */
+VALUE
+rb_grn_table_array_reference (VALUE self, VALUE rb_id)
+{
+    grn_id id;
+    grn_ctx *context;
+    grn_obj *table;
+    grn_obj *range;
+    grn_obj *value;
+
+    rb_grn_table_deconstruct(SELF(self), &table, &context,
+			     NULL, NULL,
+			     &value, NULL, &range);
+
+    id = NUM2UINT(rb_id);
+    GRN_BULK_REWIND(value);
+    grn_obj_get_value(context, table, id, value);
+    rb_grn_context_check(context, self);
+
+    if (GRN_BULK_EMPTYP(value))
+	return Qnil;
+    else
+	return rb_str_new(GRN_BULK_HEAD(value), GRN_BULK_VSIZE(value));
+}
+
+/*
+ * Document-method: []=
+ *
+ * call-seq:
+ *   table[id] = value
+ *
+ * _table_の_id_に対応する値を設定する。既存の値は上書きさ
+ * れる。
+ */
+VALUE
+rb_grn_table_array_set (VALUE self, VALUE rb_id, VALUE rb_value)
+{
+    grn_id id;
+    grn_ctx *context;
+    grn_obj *table;
+    grn_obj *range;
+    grn_obj *value;
+    grn_rc rc;
+
+    rb_grn_table_deconstruct(SELF(self), &table, &context,
+			     NULL, NULL,
+			     &value, NULL, &range);
+
+    id = NUM2UINT(rb_id);
+    GRN_BULK_REWIND(value);
+    RVAL2GRNBULK(rb_value, context, value);
+    rc = grn_obj_set_value(context, table, id, value, GRN_OBJ_SET);
+    rb_grn_context_check(context, self);
+    rb_grn_rc_check(rc, self);
+
+    return Qnil;
+}
+
 void
 rb_grn_init_table (VALUE mGrn)
 {
     rb_cGrnTable = rb_define_class_under(mGrn, "Table", rb_cGrnObject);
+    rb_define_alloc_func(rb_cGrnTable, rb_grn_table_alloc);
 
     rb_include_module(rb_cGrnTable, rb_mEnumerable);
 
@@ -680,6 +931,8 @@ rb_grn_init_table (VALUE mGrn)
 
     rb_define_method(rb_cGrnTable, "define_column",
 		     rb_grn_table_define_column, -1);
+    rb_define_method(rb_cGrnTable, "define_index_column",
+		     rb_grn_table_define_index_column, -1);
     rb_define_method(rb_cGrnTable, "add_column",
 		     rb_grn_table_add_column, 3);
     rb_define_method(rb_cGrnTable, "column",
@@ -699,6 +952,9 @@ rb_grn_init_table (VALUE mGrn)
 
     rb_define_method(rb_cGrnTable, "sort", rb_grn_table_sort, -1);
 
+    rb_define_method(rb_cGrnTable, "[]", rb_grn_table_array_reference, 1);
+    rb_define_method(rb_cGrnTable, "[]=", rb_grn_table_array_set, 2);
+
     rb_grn_init_table_key_support(mGrn);
     rb_grn_init_array(mGrn);
     rb_grn_init_hash(mGrn);

data/ext/rb-grn-type.c

@@ -60,7 +60,7 @@ rb_grn_type_initialize (int argc, VALUE *argv, VALUE self)
     name = StringValuePtr(rb_name);
     name_size = RSTRING_LEN(rb_name);
 
-    context = rb_grn_context_ensure(rb_context);
+    context = rb_grn_context_ensure(&rb_context);
 
     if (NIL_P(rb_key_type)) {
         flags = GRN_OBJ_KEY_VAR_SIZE;
@@ -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_initialize(self, context, type);
+    rb_grn_object_assign(self, rb_context, context, type, RB_GRN_TRUE);
     rb_grn_context_check(context, rb_ary_new4(argc, argv));
 
     return Qnil;
@@ -98,9 +98,10 @@ rb_grn_init_type (VALUE mGrn)
 
     rb_define_method(rb_cGrnType, "initialize", rb_grn_type_initialize, -1);
 
-    rb_define_const(rb_cGrnType, "INT", INT2NUM(GRN_DB_INT));
-    rb_define_const(rb_cGrnType, "UINT", INT2NUM(GRN_DB_UINT));
+    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));