groonga 0.0.6 → 0.0.7

data/ext/rb-grn-object.c

@@ -78,11 +78,15 @@ rb_grn_object_from_ruby_object (VALUE object, grn_ctx **context)
     return rb_grn_object->object;
 }
 
-grn_rc
-rb_grn_object_finalizer (grn_ctx *context, grn_obj *grn_object,
+static grn_obj *
+rb_grn_object_finalizer (grn_ctx *context, int n_args, grn_obj **grn_objects,
 			 grn_user_data *user_data)
 {
     RbGrnObject *rb_grn_object;
+    grn_obj *grn_object = *grn_objects;
+
+    if (rb_grn_exited)
+	return NULL;
 
     rb_grn_object = user_data->ptr;
 
@@ -137,7 +141,7 @@ rb_grn_object_finalizer (grn_ctx *context, grn_obj *grn_object,
 	break;
     }
 
-    return GRN_SUCCESS;
+    return NULL;
 }
 
 void
@@ -149,12 +153,12 @@ rb_grn_object_free (RbGrnObject *rb_grn_object)
     context = rb_grn_object->context;
     grn_object = rb_grn_object->object;
     debug("rb-free: %p:%p:%p\n", context, grn_object, rb_grn_object);
-    if (context && grn_object) {
+    if (!rb_grn_exited && context && grn_object) {
 	rb_grn_object->context = NULL;
 	rb_grn_object->object = NULL;
 	debug("type: %x\n", grn_object->header.type);
 	if (rb_grn_object->need_close) {
-	    grn_obj_close(context, grn_object);
+	    grn_obj_unlink(context, grn_object);
 	}
     }
     xfree(rb_grn_object);
@@ -599,8 +603,8 @@ rb_grn_object_inspect_content_flags (VALUE inspected,
 	    rb_ary_push(inspected_flags, rb_str_new2("TABLE_PAT_KEY"));
 	if (flags & GRN_OBJ_TABLE_NO_KEY)
 	    rb_ary_push(inspected_flags, rb_str_new2("TABLE_NO_KEY"));
-	if (flags & GRN_OBJ_TABLE_ALIAS)
-	    rb_ary_push(inspected_flags, rb_str_new2("TABLE_ALIAS"));
+	if (flags & GRN_OBJ_TABLE_VIEW)
+	    rb_ary_push(inspected_flags, rb_str_new2("TABLE_VIEW"));
     }
 
     switch (object->header.type) {
@@ -1048,7 +1052,7 @@ rb_grn_object_array_set (VALUE self, VALUE rb_id, VALUE rb_value)
  * call-seq:
  *   object.append(id, value)
  *
- * _object_の_id_に対応する値に_value_を追加する。
+ * _object_の_id_に対応する値の最後に_value_を追加する。
  */
 static VALUE
 rb_grn_object_append_value (VALUE self, VALUE rb_id, VALUE rb_value)
@@ -1056,6 +1060,20 @@ rb_grn_object_append_value (VALUE self, VALUE rb_id, VALUE rb_value)
     return rb_grn_object_set(self, rb_id, rb_value, GRN_OBJ_APPEND);
 }
 
+/*
+ * Document-method: prepend
+ *
+ * call-seq:
+ *   object.prepend(id, value)
+ *
+ * _object_の_id_に対応する値の最初に_value_を追加する。
+ */
+static VALUE
+rb_grn_object_prepend_value (VALUE self, VALUE rb_id, VALUE rb_value)
+{
+    return rb_grn_object_set(self, rb_id, rb_value, GRN_OBJ_PREPEND);
+}
+
 static VALUE
 rb_grn_object_remove (VALUE self)
 {
@@ -1097,6 +1115,7 @@ rb_grn_init_object (VALUE mGrn)
     rb_define_method(rb_cGrnObject, "[]", rb_grn_object_array_reference, 1);
     rb_define_method(rb_cGrnObject, "[]=", rb_grn_object_array_set, 2);
     rb_define_method(rb_cGrnObject, "append", rb_grn_object_append_value, 2);
+    rb_define_method(rb_cGrnObject, "prepend", rb_grn_object_prepend_value, 2);
 
     rb_define_method(rb_cGrnObject, "remove", rb_grn_object_remove, 0);
 }

data/ext/rb-grn-operation.c

@@ -25,40 +25,64 @@ rb_grn_init_operation (VALUE mGrn)
 {
     rb_mGrnOperation = rb_define_module_under(mGrn, "Operation");
 
-    rb_define_const(rb_mGrnOperation, "NO_OPERATION",
-                    UINT2NUM(GRN_OP_NOP));
     rb_define_const(rb_mGrnOperation, "PUSH",
                     UINT2NUM(GRN_OP_PUSH));
     rb_define_const(rb_mGrnOperation, "POP",
                     UINT2NUM(GRN_OP_POP));
+    rb_define_const(rb_mGrnOperation, "NO_OPERATION",
+                    UINT2NUM(GRN_OP_NOP));
     rb_define_const(rb_mGrnOperation, "CALL",
                     UINT2NUM(GRN_OP_CALL));
     rb_define_const(rb_mGrnOperation, "INTERN",
                     UINT2NUM(GRN_OP_INTERN));
-    rb_define_const(rb_mGrnOperation, "TABLE_CREATE",
-                    UINT2NUM(GRN_OP_TABLE_CREATE));
-    rb_define_const(rb_mGrnOperation, "EXPRESSION_GET_VARIABLE",
-                    UINT2NUM(GRN_OP_EXPR_GET_VAR));
-    rb_define_const(rb_mGrnOperation, "VARIABLE_SET_VALUE",
-                    UINT2NUM(GRN_OP_VAR_SET_VALUE));
-    rb_define_const(rb_mGrnOperation, "OBJECT_GET_VALUE",
-                    UINT2NUM(GRN_OP_OBJ_GET_VALUE));
-    rb_define_const(rb_mGrnOperation, "OBJECT_SET_VALUE",
-                    UINT2NUM(GRN_OP_OBJ_SET_VALUE));
-    rb_define_const(rb_mGrnOperation, "OBJECT_SEARCH",
-                    UINT2NUM(GRN_OP_OBJ_SEARCH));
-    rb_define_const(rb_mGrnOperation, "TABLE_SELECT",
-                    UINT2NUM(GRN_OP_TABLE_SELECT));
-    rb_define_const(rb_mGrnOperation, "TABLE_SORT",
-                    UINT2NUM(GRN_OP_TABLE_SORT));
-    rb_define_const(rb_mGrnOperation, "TABLE_GROUP",
-                    UINT2NUM(GRN_OP_TABLE_GROUP));
-    rb_define_const(rb_mGrnOperation, "JSON_PUT",
-                    UINT2NUM(GRN_OP_JSON_PUT));
+    rb_define_const(rb_mGrnOperation, "GET_REFERENCE",
+                    UINT2NUM(GRN_OP_GET_REF));
+    rb_define_const(rb_mGrnOperation, "GET_VALUE",
+                    UINT2NUM(GRN_OP_GET_VALUE));
     rb_define_const(rb_mGrnOperation, "AND",
                     UINT2NUM(GRN_OP_AND));
+    rb_define_const(rb_mGrnOperation, "BUT",
+                    UINT2NUM(GRN_OP_BUT));
     rb_define_const(rb_mGrnOperation, "OR",
                     UINT2NUM(GRN_OP_OR));
+    rb_define_const(rb_mGrnOperation, "ASSIGN",
+                    UINT2NUM(GRN_OP_ASSIGN));
+    rb_define_const(rb_mGrnOperation, "STAR_ASSIGN",
+                    UINT2NUM(GRN_OP_STAR_ASSIGN));
+    rb_define_const(rb_mGrnOperation, "SLASH_ASSIGN",
+                    UINT2NUM(GRN_OP_SLASH_ASSIGN));
+    rb_define_const(rb_mGrnOperation, "MODULO_ASSIGN",
+                    UINT2NUM(GRN_OP_MOD_ASSIGN));
+    rb_define_const(rb_mGrnOperation, "PLUS_ASSIGN",
+                    UINT2NUM(GRN_OP_PLUS_ASSIGN));
+    rb_define_const(rb_mGrnOperation, "MINUS_ASSIGN",
+                    UINT2NUM(GRN_OP_MINUS_ASSIGN));
+    rb_define_const(rb_mGrnOperation, "SHIFTL_ASSIGN",
+                    UINT2NUM(GRN_OP_SHIFTL_ASSIGN));
+    rb_define_const(rb_mGrnOperation, "SHIRTR_ASSIGN",
+                    UINT2NUM(GRN_OP_SHIRTR_ASSIGN));
+    rb_define_const(rb_mGrnOperation, "SHIFTRR_ASSIGN",
+                    UINT2NUM(GRN_OP_SHIFTRR_ASSIGN));
+    rb_define_const(rb_mGrnOperation, "AND_ASSIGN",
+                    UINT2NUM(GRN_OP_AND_ASSIGN));
+    rb_define_const(rb_mGrnOperation, "XOR_ASSIGN",
+                    UINT2NUM(GRN_OP_XOR_ASSIGN));
+    rb_define_const(rb_mGrnOperation, "OR_ASSIGN",
+                    UINT2NUM(GRN_OP_OR_ASSIGN));
+    rb_define_const(rb_mGrnOperation, "JUMP",
+                    UINT2NUM(GRN_OP_JUMP));
+    rb_define_const(rb_mGrnOperation, "CJUMP",
+                    UINT2NUM(GRN_OP_CJUMP));
+    rb_define_const(rb_mGrnOperation, "COMMA",
+                    UINT2NUM(GRN_OP_COMMA));
+    rb_define_const(rb_mGrnOperation, "BITWISE_OR",
+                    UINT2NUM(GRN_OP_BITWISE_OR));
+    rb_define_const(rb_mGrnOperation, "BITWISE_XOR",
+                    UINT2NUM(GRN_OP_BITWISE_XOR));
+    rb_define_const(rb_mGrnOperation, "BITWISE_AND",
+                    UINT2NUM(GRN_OP_BITWISE_AND));
+    rb_define_const(rb_mGrnOperation, "BITWISE_NOT",
+                    UINT2NUM(GRN_OP_BITWISE_NOT));
     rb_define_const(rb_mGrnOperation, "EQUAL",
                     UINT2NUM(GRN_OP_EQUAL));
     rb_define_const(rb_mGrnOperation, "NOT_EQUAL",
@@ -71,8 +95,90 @@ rb_grn_init_operation (VALUE mGrn)
                     UINT2NUM(GRN_OP_LESS_EQUAL));
     rb_define_const(rb_mGrnOperation, "GREATER_EQUAL",
                     UINT2NUM(GRN_OP_GREATER_EQUAL));
+    rb_define_const(rb_mGrnOperation, "IN",
+                    UINT2NUM(GRN_OP_IN));
     rb_define_const(rb_mGrnOperation, "MATCH",
                     UINT2NUM(GRN_OP_MATCH));
+    rb_define_const(rb_mGrnOperation, "NEAR",
+                    UINT2NUM(GRN_OP_NEAR));
+    rb_define_const(rb_mGrnOperation, "NEAR2",
+                    UINT2NUM(GRN_OP_NEAR2));
+    rb_define_const(rb_mGrnOperation, "SIMILAR",
+                    UINT2NUM(GRN_OP_SIMILAR));
+    rb_define_const(rb_mGrnOperation, "TERM_EXTRACT",
+                    UINT2NUM(GRN_OP_TERM_EXTRACT));
+    rb_define_const(rb_mGrnOperation, "SHIFTL",
+                    UINT2NUM(GRN_OP_SHIFTL));
+    rb_define_const(rb_mGrnOperation, "SHIFTR",
+                    UINT2NUM(GRN_OP_SHIFTR));
+    rb_define_const(rb_mGrnOperation, "SHIFTRR",
+                    UINT2NUM(GRN_OP_SHIFTRR));
+    rb_define_const(rb_mGrnOperation, "PLUS",
+                    UINT2NUM(GRN_OP_PLUS));
+    rb_define_const(rb_mGrnOperation, "MINUS",
+                    UINT2NUM(GRN_OP_MINUS));
+    rb_define_const(rb_mGrnOperation, "STAR",
+                    UINT2NUM(GRN_OP_STAR));
+    rb_define_const(rb_mGrnOperation, "SLASH",
+                    UINT2NUM(GRN_OP_SLASH));
+    rb_define_const(rb_mGrnOperation, "MODULO",
+                    UINT2NUM(GRN_OP_MOD));
+    rb_define_const(rb_mGrnOperation, "DELETE",
+                    UINT2NUM(GRN_OP_DELETE));
+    rb_define_const(rb_mGrnOperation, "INCREMENT",
+                    UINT2NUM(GRN_OP_INCR));
+    rb_define_const(rb_mGrnOperation, "DECREMENT",
+                    UINT2NUM(GRN_OP_DECR));
+    rb_define_const(rb_mGrnOperation, "INCREMENT_POST",
+                    UINT2NUM(GRN_OP_INCR_POST));
+    rb_define_const(rb_mGrnOperation, "DECREMENT_POST",
+                    UINT2NUM(GRN_OP_DECR_POST));
+    rb_define_const(rb_mGrnOperation, "NOT",
+                    UINT2NUM(GRN_OP_NOT));
+    rb_define_const(rb_mGrnOperation, "ADJUST",
+                    UINT2NUM(GRN_OP_ADJUST));
+    rb_define_const(rb_mGrnOperation, "EXACT",
+                    UINT2NUM(GRN_OP_EXACT));
+    rb_define_const(rb_mGrnOperation, "LONGEST_COMMON_PREFIX",
+                    UINT2NUM(GRN_OP_LCP));
+    rb_define_const(rb_mGrnOperation, "PARTIAL",
+                    UINT2NUM(GRN_OP_PARTIAL));
+    rb_define_const(rb_mGrnOperation, "UNSPLIT",
+                    UINT2NUM(GRN_OP_UNSPLIT));
+    rb_define_const(rb_mGrnOperation, "PREFIX",
+                    UINT2NUM(GRN_OP_PREFIX));
+    rb_define_const(rb_mGrnOperation, "SUFFIX",
+                    UINT2NUM(GRN_OP_SUFFIX));
+    rb_define_const(rb_mGrnOperation, "GEO_DISTANCE1",
+                    UINT2NUM(GRN_OP_GEO_DISTANCE1));
+    rb_define_const(rb_mGrnOperation, "GEO_DISTANCE2",
+                    UINT2NUM(GRN_OP_GEO_DISTANCE2));
+    rb_define_const(rb_mGrnOperation, "GEO_DISTANCE3",
+                    UINT2NUM(GRN_OP_GEO_DISTANCE3));
+    rb_define_const(rb_mGrnOperation, "GEO_DISTANCE4",
+                    UINT2NUM(GRN_OP_GEO_DISTANCE4));
+    rb_define_const(rb_mGrnOperation, "GEO_WITHINP5",
+                    UINT2NUM(GRN_OP_GEO_WITHINP5));
+    rb_define_const(rb_mGrnOperation, "GEO_WITHINP6",
+                    UINT2NUM(GRN_OP_GEO_WITHINP6));
+    rb_define_const(rb_mGrnOperation, "GEO_WITHINP8",
+                    UINT2NUM(GRN_OP_GEO_WITHINP8));
+    rb_define_const(rb_mGrnOperation, "OBJECT_SEARCH",
+                    UINT2NUM(GRN_OP_OBJ_SEARCH));
+    rb_define_const(rb_mGrnOperation, "EXPRESSION_GET_VARIABLE",
+                    UINT2NUM(GRN_OP_EXPR_GET_VAR));
+    rb_define_const(rb_mGrnOperation, "TABLE_CREATE",
+                    UINT2NUM(GRN_OP_TABLE_CREATE));
+    rb_define_const(rb_mGrnOperation, "TABLE_SELECT",
+                    UINT2NUM(GRN_OP_TABLE_SELECT));
+    rb_define_const(rb_mGrnOperation, "TABLE_SORT",
+                    UINT2NUM(GRN_OP_TABLE_SORT));
+    rb_define_const(rb_mGrnOperation, "TABLE_GROUP",
+                    UINT2NUM(GRN_OP_TABLE_GROUP));
+    rb_define_const(rb_mGrnOperation, "JSON_PUT",
+                    UINT2NUM(GRN_OP_JSON_PUT));
+
+
 /*
     rb_define_const(rb_mGrnOperation, "GEO_DISTANCE1",
                     UINT2NUM(GRN_OP_GEO_DISTANCE1));

data/ext/rb-grn-patricia-trie.c

@@ -150,6 +150,66 @@ rb_grn_patricia_trie_search (int argc, VALUE *argv, VALUE self)
     return rb_result;
 }
 
+static VALUE
+rb_grn_patricia_trie_scan (VALUE self, VALUE rb_string)
+{
+    grn_ctx *context;
+    grn_obj *table;
+    VALUE rb_result = Qnil;
+    grn_pat_scan_hit hits[1024];
+    const char *string;
+    long string_length;
+    rb_grn_boolean block_given;
+
+    string = StringValuePtr(rb_string);
+    string_length = RSTRING_LEN(rb_string);
+
+    rb_grn_table_key_support_deconstruct(SELF(self), &table, &context,
+					 NULL, NULL, NULL,
+					 NULL, NULL, NULL);
+
+    block_given = rb_block_given_p();
+    if (!block_given)
+	rb_result = rb_ary_new();
+
+    while (string_length > 0) {
+	const char *rest;
+	int i, n_hits;
+	long previous_offset = 0;
+
+	n_hits = grn_pat_scan(context, (grn_pat *)table,
+			      string, string_length,
+			      hits, sizeof(hits) / sizeof(*hits),
+			      &rest);
+	for (i = 0; i < n_hits; i++) {
+	    VALUE record, term, matched_info;
+
+	    if (hits[i].offset < previous_offset)
+		continue;
+
+	    record = rb_grn_record_new(self, hits[i].id, Qnil);
+	    term = rb_grn_context_rb_string_new(context,
+						string + hits[i].offset,
+						hits[i].length);
+	    matched_info = rb_ary_new3(4,
+				       record,
+				       term,
+				       UINT2NUM(hits[i].offset),
+				       UINT2NUM(hits[i].length));
+	    if (block_given) {
+		rb_yield(matched_info);
+	    } else {
+		rb_ary_push(rb_result, matched_info);
+	    }
+	    previous_offset = hits[i].offset;
+	}
+	string_length -= rest - string;
+	string = rest;
+    }
+
+    return rb_result;
+}
+
 void
 rb_grn_init_patricia_trie (VALUE mGrn)
 {
@@ -162,4 +222,6 @@ rb_grn_init_patricia_trie (VALUE mGrn)
 
     rb_define_method(rb_cGrnPatriciaTrie, "search",
 		     rb_grn_patricia_trie_search, -1);
+    rb_define_method(rb_cGrnPatriciaTrie, "scan",
+		     rb_grn_patricia_trie_scan, 1);
 }

data/ext/rb-grn-snippet.c

@@ -18,10 +18,6 @@
 
 #include "rb-grn.h"
 
-#ifdef HAVE_RUBY_ENCODING_H
-#  include <ruby/encoding.h>
-#endif
-
 #define SELF(object) (rb_rb_grn_snippet_from_ruby_object(object))
 
 typedef struct _RbGrnSnippet RbGrnSnippet;
@@ -73,7 +69,8 @@ rb_rb_grn_snippet_free (void *object)
 }
 
 VALUE
-rb_grn_snippet_to_ruby_object (grn_ctx *context, grn_snip *snippet)
+rb_grn_snippet_to_ruby_object (grn_ctx *context, grn_snip *snippet,
+			       rb_grn_boolean owner)
 {
     RbGrnSnippet *rb_grn_snippet;
 
@@ -83,7 +80,7 @@ rb_grn_snippet_to_ruby_object (grn_ctx *context, grn_snip *snippet)
     rb_grn_snippet = ALLOC(RbGrnSnippet);
     rb_grn_snippet->context = context;
     rb_grn_snippet->snippet = snippet;
-    rb_grn_snippet->owner = RB_GRN_FALSE;
+    rb_grn_snippet->owner = owner;
 
     return Data_Wrap_Struct(rb_cGrnSnippet, NULL,
                             rb_rb_grn_snippet_free, rb_grn_snippet);
@@ -224,19 +221,16 @@ rb_grn_snippet_execute (VALUE self, VALUE rb_string)
     unsigned int i, n_results, max_tagged_length;
     VALUE rb_results;
     char *result;
-#ifdef HAVE_RUBY_ENCODING_H
-    rb_encoding *encoding;
-#endif
 
     rb_grn_snippet = SELF(self);
     context = rb_grn_snippet->context;
     snippet = rb_grn_snippet->snippet;
 
-    string = StringValuePtr(rb_string);
-    string_length = RSTRING_LEN(rb_string);
 #ifdef HAVE_RUBY_ENCODING_H
-    encoding = rb_enc_get(rb_string);
+    rb_string = rb_grn_context_rb_string_encode(context, rb_string);
 #endif
+    string = StringValuePtr(rb_string);
+    string_length = RSTRING_LEN(rb_string);
 
     rc = grn_snip_exec(context, snippet, string, string_length,
                        &n_results, &max_tagged_length);
@@ -250,11 +244,7 @@ rb_grn_snippet_execute (VALUE self, VALUE rb_string)
 
         rc = grn_snip_get_result(context, snippet, i, result, &result_length);
         rb_grn_rc_check(rc, self);
-#ifdef HAVE_RUBY_ENCODING_H
-        rb_result = rb_enc_str_new(result, result_length, encoding);
-#else
-        rb_result = rb_str_new(result, result_length);
-#endif
+        rb_result = rb_grn_context_rb_string_new(context, result, result_length);
         rb_ary_push(rb_results, rb_result);
     }
 

data/ext/rb-grn-table.c

@@ -813,9 +813,9 @@ rb_grn_table_sort (int argc, VALUE *argv, VALUE self)
     grn_obj *result;
     grn_table_sort_key *keys;
     int i, n_keys;
-    int n_records, limit = 0;
+    int n_records, offset = 0, limit = -1;
     VALUE rb_keys, options;
-    VALUE rb_limit;
+    VALUE rb_offset, rb_limit;
     VALUE *rb_sort_keys;
     grn_table_cursor *cursor;
     VALUE rb_result;
@@ -876,15 +876,19 @@ rb_grn_table_sort (int argc, VALUE *argv, VALUE self)
     }
 
     rb_grn_scan_options(options,
+			"offset", &rb_offset,
 			"limit", &rb_limit,
 			NULL);
 
+    if (!NIL_P(rb_offset))
+	offset = NUM2INT(rb_offset);
     if (!NIL_P(rb_limit))
 	limit = NUM2INT(rb_limit);
 
     result = grn_table_create(context, NULL, 0, NULL, GRN_TABLE_NO_KEY,
 			      NULL, table);
-    n_records = grn_table_sort(context, table, limit, result, keys, n_keys);
+    n_records = grn_table_sort(context, table, offset, limit,
+			       result, keys, n_keys);
 
     rb_result = rb_ary_new();
     cursor = grn_table_cursor_open(context, result, NULL, 0, NULL, 0,
@@ -1240,13 +1244,93 @@ rb_grn_table_is_locked (int argc, VALUE *argv, VALUE self)
     return CBOOL2RVAL(grn_obj_is_locked(context, table));
 }
 
+/*
+ * call-seq:
+ *   table.select(options) {|record| ...} -> Groonga::Hash
+ *   table.select(query, options) -> Groonga::Hash
+ *
+ * _table_からブロックまたは文字列で指定した条件にマッチする
+ * レコードを返す。返されたテーブルには+expression+という特
+ * 異メソッドがあり、指定した条件を表している
+ * Groonga::Expressionを取得できる。
+ * Groonga::Expression#snippetを使うことにより、指定した条件
+ * 用のスニペットを簡単に生成できる。
+ *
+ *   results = table.select do |record|
+ *     result["description"] =~ "groonga"
+ *   end
+ *   snippet = results.expression.snippet([["<em>", "</em>"]])
+ *   results.each do |record|
+ *     puts "#{record['name']}の説明文の中で「groonga」が含まれる部分"
+ *     snippet.execute(record["description"].each do |snippet|
+ *       puts "---"
+ *       puts "#{snippet}..."
+ *       puts "---"
+ *     end
+ *   end
+ *
+ * 出力例
+ *   Ruby/groongaの説明文の中で「groonga」が含まれる部分
+ *   ---
+ *   Ruby/<em>groonga</em>は<em>groonga</em>のいわゆるDB-APIの層の...
+ *   ---
+ *
+ * _query_には「[カラム名]:[演算子][値]」という書式で条件を
+ * 指定する。演算子は以下の通り。
+ *
+ * [なし]
+ *   [カラム値] == [値]
+ * [+!+]
+ *   [カラム値] != [値]
+ * [+<+]
+ *   [カラム値] < [値]
+ * [+>+]
+ *   [カラム値] > [値]
+ * [+<=+]
+ *   [カラム値] <= [値]
+ * [+>=+]
+ *   [カラム値] >= [値]
+ * [+@+]
+ *   [カラム値]が[値]を含んでいるかどうか
+ *
+ * 例:
+ *   "name:daijiro" # "name"カラムの値が"daijiro"のレコードにマッチ
+ *   "description:@groonga" # "description"カラムに
+ *                          # "groonga"を含んでいるレコードにマッチ
+ *
+ * ブロックで条件を指定する場合はGroonga::ExpressionBuilder
+ * を参照。
+ *
+ * _options_に指定可能な値は以下の通り。
+ *
+ * [+:operator+]
+ *   マッチしたレコードをどのように扱うか。指定可能な値は以
+ *   下の通り。省略した場合はGroonga::Operation::OR。
+ *
+ *   [Groonga::Operation::OR]
+ *     マッチしたレコードを追加。すでにレコードが追加され
+ *     ている場合は何もしない。
+ *   [Groonga::Operation::AND]
+ *     マッチしたレコードのスコアを増加。マッチしなかった
+ *     レコードを削除。
+ *   [Groonga::Operation::BUT]
+ *     マッチしたレコードを削除。
+ *   [Groonga::Operation::ADJUST]
+ *     マッチしたレコードのスコアを増加。
+ *
+ * [+:result+]
+ *   検索結果を格納するテーブル。マッチしたレコードが追加さ
+ *   れていく。省略した場合は新しくテーブルを作成して返す。
+ *
+ * [+:name+]
+ *   条件の名前。省略した場合は名前を付けない。
+ */
 static VALUE
 rb_grn_table_select (int argc, VALUE *argv, VALUE self)
 {
     grn_ctx *context;
     grn_obj *table, *result, *expression;
     grn_operator operator = GRN_OP_OR;
-    grn_rc rc;
     VALUE rb_query = Qnil, query_or_options, options;
     VALUE rb_name, rb_operator, rb_result;
     VALUE rb_expression, builder;
@@ -1258,11 +1342,6 @@ rb_grn_table_select (int argc, VALUE *argv, VALUE self)
 			     NULL, NULL, NULL);
 
     if (RVAL2CBOOL(rb_obj_is_kind_of(query_or_options, rb_cString))) {
-	if (rb_block_given_p())
-	    rb_raise(rb_eArgError,
-		     "should not specify both of query string and "
-		     "expression block: %s",
-		     rb_grn_inspect(rb_ary_new4(argc, argv)));
 	rb_query = query_or_options;
     } else {
 	if (!NIL_P(options))
@@ -1292,31 +1371,22 @@ rb_grn_table_select (int argc, VALUE *argv, VALUE self)
 	result = RVAL2GRNTABLE(rb_result, &context);
     }
 
-    if (NIL_P(rb_query)) {
-	builder = rb_grn_record_expression_builder_new(self, rb_name);
-	rb_expression = rb_grn_record_expression_builder_build(builder);
-	rb_grn_object_deconstruct(RB_GRN_OBJECT(DATA_PTR(rb_expression)),
-				  &expression, NULL,
-				  NULL, NULL, NULL, NULL);
-    } else {
-	const char *name = NULL, *query;
-	unsigned name_size = 0, query_size;
-
-	query = StringValueCStr(rb_query);
-	query_size = RSTRING_LEN(rb_query);
-	if (!NIL_P(rb_name)) {
-	    name = StringValueCStr(rb_name);
-	    name_size = RSTRING_LEN(rb_name);
-	}
-	expression = grn_expr_create_from_str(context, name, name_size,
-					      query, query_size,
-					      table, NULL);
+    builder = rb_grn_record_expression_builder_new(self, rb_name);
+    if (!NIL_P(rb_query)) {
+        rb_funcall(builder, rb_intern("query="), 1, rb_query);
     }
+    rb_expression = rb_grn_record_expression_builder_build(builder);
+    rb_grn_object_deconstruct(RB_GRN_OBJECT(DATA_PTR(rb_expression)),
+                              &expression, NULL,
+			      NULL, NULL, NULL, NULL);
 
-
-    rc = grn_table_select(context, table, expression, result, operator);
+    grn_table_select(context, table, expression, result, operator);
     rb_grn_context_check(context, self);
-    rb_grn_rc_check(rc, self);
+
+    rb_attr(rb_singleton_class(rb_result),
+	    rb_intern("expression"),
+	    RB_GRN_TRUE, RB_GRN_FALSE, RB_GRN_FALSE);
+    rb_iv_set(rb_result, "@expression", rb_expression);
 
     return rb_result;
 }