groonga 0.0.1 → 0.0.2

data/ext/rb-grn-encoding.c

@@ -22,7 +22,51 @@
  * Document-module: Groonga::Encoding
  *
  * groongaがサポートしてるエンコーディングが定義されてい
- * るモジュールです。
+ * るモジュール。
+ *
+ * エンコーディングの指定方法は以下の通り。
+ *
+ * [+nil+]
+ *   コンテキストと関連付けられているオブジェクトの場合（多
+ *   くの場合）はコンテキストのエンコーディングを使用。
+ *
+ *   それ以外のオブジェクトの場合（コンテキスト自身など）は
+ *   groongaのビルド時に指定したエンコーディング
+ *   （Groonga::Encoding::DEFAULT）を使用
+ *
+ * [+:default+]
+ *   groongaのビルド時に指定したエンコーディングを使用。
+ *   Groonga::Encoding::DEFAULT
+ *
+ * [+:none+]
+ *   エンコーディングを指定しない。Groonga::Encoding::NONE
+ *
+ * [+:euc_jp+]
+ *   EUC-JPを使用。Groonga::Encoding::EUC_JP
+ *
+ * [<tt>"euc-jp"</tt>]
+ *   +:euc_jp+と同じ。
+ *
+ * [+:utf8+]
+ *   UTF-8を使用。Groonga::Encoding::UTF8
+ *
+ * [<tt>"utf-8"</tt>]
+ *   +:utf8+と同じ。
+ *
+ * [+:sjis+]
+ *   Shift_JISを使用。Groonga::Encoding::SJIS
+ *
+ * [+:shift_jis+]
+ *   +:sjis+と同じ。
+ *
+ * [<tt>"shift-jis"</tt>]
+ *   +:sjis+と同じ。
+ *
+ * [+:latin1+]
+ *   Latin-1を使用。Groonga::Encoding::LATIN1
+ *
+ * [+:koi8r+]
+ *   KOI8-Rを使用。Groonga::Encoding::KOI8R
  */
 
 static VALUE mGrnEncoding;
@@ -104,12 +148,25 @@ rb_grn_encoding_to_ruby_object (grn_encoding encoding)
     return rb_encoding;
 }
 
+/*
+ * call-seq:
+ *   Groonga::Encoding.default -> エンコーディング
+ *
+ * デフォルトのエンコーディングを返す。
+ */
 static VALUE
 rb_grn_encoding_s_get_default (VALUE self)
 {
     return GRNENCODING2RVAL(grn_get_default_encoding());
 }
 
+/*
+ * call-seq:
+ *   Groonga::Encoding.default(encoding)
+ *
+ * デフォルトのエンコーディングを設定する。エンコーディング
+ * の指定方法はGroonga::Encodingを参照。
+ */
 static VALUE
 rb_grn_encoding_s_set_default (VALUE self, VALUE rb_encoding)
 {

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

@@ -0,0 +1,220 @@
+/* -*- 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) ((RbGrnFixSizeColumn *)DATA_PTR(object))
+
+VALUE rb_cGrnFixSizeColumn;
+
+/*
+ * Document-class: Groonga::FixSizeColumn < Groonga::Column
+ *
+ * 固定長データ用のカラム。
+ */
+
+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] -> 値
+ *
+ * _column_の_id_に対応する値を返す。
+ */
+VALUE
+rb_grn_fix_size_column_array_reference (VALUE self, VALUE rb_id)
+{
+    grn_id id;
+    grn_ctx *context;
+    grn_obj *fix_size_column;
+    grn_obj *range;
+    grn_obj *value;
+
+    rb_grn_fix_size_column_deconstruct(SELF(self), &fix_size_column, &context,
+				       NULL, NULL,
+				       &value, NULL, &range);
+
+    id = NUM2UINT(rb_id);
+    GRN_BULK_REWIND(value);
+    grn_obj_get_value(context, fix_size_column, id, value);
+    rb_grn_context_check(context, self);
+
+    return GRNVALUE2RVAL(context, value, range, self);
+}
+
+/*
+ * call-seq:
+ *   column[id] = value
+ *
+ * _column_の_id_に対応する値を設定する。
+ */
+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 domain_id, range_id;
+    grn_obj *domain, *range;
+    grn_obj *value;
+    grn_rc rc;
+    grn_id id;
+
+    rb_grn_fix_size_column_deconstruct(SELF(self), &column, &context,
+				       &domain_id, &domain,
+				       &value, &range_id, &range);
+
+    id = NUM2UINT(rb_id);
+
+    if (RVAL2CBOOL(rb_obj_is_kind_of(rb_value, rb_cGrnRecord))) {
+	VALUE rb_id, rb_table;
+	grn_obj *table;
+
+	if (!range)
+	    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_id)
+	    rb_raise(rb_eArgError,
+		     "%s isn't associated with passed record's table: %s",
+		     rb_grn_inspect(self),
+		     rb_grn_inspect(rb_value));
+
+	rb_value = rb_id;
+    } else if (range) {
+	switch (range->header.type) {
+	  case GRN_TABLE_HASH_KEY:
+	  case GRN_TABLE_PAT_KEY:
+	    if (!RVAL2CBOOL(rb_obj_is_kind_of(rb_value, rb_cFixnum))) {
+		VALUE rb_range;
+		grn_id id;
+
+		rb_range = GRNOBJECT2RVAL(Qnil, context, range, RB_GRN_FALSE);
+		id = rb_grn_table_key_support_get(rb_range, rb_value);
+		rb_value = UINT2NUM(id);
+	    }
+	    break;
+	  default:
+	    break;
+	}
+    }
+
+    GRN_BULK_REWIND(value);
+    RVAL2GRNBULK(rb_value, context, value);
+
+    rc = grn_obj_set_value(context, column, id, value, GRN_OBJ_SET);
+    rb_grn_context_check(context, self);
+    rb_grn_rc_check(rc, self);
+
+    return Qnil;
+}
+
+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);
+}

data/ext/rb-grn-hash-cursor.c

@@ -20,6 +20,14 @@
 
 VALUE rb_cGrnHashCursor;
 
+/*
+ * Document-class: Groonga::HashCursor < Groonga::TableCursor
+ *
+ * Groonga::Hashに登録されているレコードを順番に取り出すため
+ * のオブジェクト。利用できるメソッドはGroonga::TableCursor
+ * とGroonga::TableCursorKeySupportを参照。
+ */
+
 void
 rb_grn_init_hash_cursor (VALUE mGrn)
 {

data/ext/rb-grn-hash.c

@@ -18,23 +18,265 @@
 
 #include "rb-grn.h"
 
-#define SELF(object) (RVAL2GRNTABLE(object))
+#define SELF(object) ((RbGrnTableKeySupport *)DATA_PTR(object))
 
 VALUE rb_cGrnHash;
 
+/*
+ * Document-class: Groonga::Hash < Groonga::Table
+ *
+ * 各レコードをキーで管理するテーブル。キーと完全一致するレ
+ * コードを非常に高速に検索できる。
+ */
+
+/*
+ * call-seq:
+ *   Groonga::Hash.create(options={})                -> Groonga::Hash
+ *   Groonga::Hash.create(options={}) {|table| ... }
+ *
+ * 各レコードをキーで管理するテーブルを生成する。ブロックを指
+ * 定すると、そのブロックに生成したテーブルが渡され、ブロック
+ * を抜けると自動的にテーブルが破棄される。
+ *
+ * _options_に指定可能な値は以下の通り。
+ *
+ * [+:context+]
+ *   テーブルが利用するGroonga::Context。省略すると
+ *   Groonga::Context.defaultを用いる。
+ *
+ * [+:name+]
+ *   テーブルの名前。名前をつけると、Groonga::Context#[]に名
+ *   前を指定してテーブルを取得することができる。省略すると
+ *   無名テーブルになり、テーブルIDでのみ取得できる。
+ *
+ * [+:path+]
+ *   テーブルを保存するパス。パスを指定すると永続テーブルとな
+ *   り、プロセス終了後もレコードは保持される。次回起動時に
+ *   Groonga::Hash.openで保存されたレコードを利用することが
+ *   できる。省略すると一時テーブルになり、プロセスが終了する
+ *   とレコードは破棄される。
+ *
+ * [+:persistent+]
+ *   +true+を指定すると永続テーブルとなる。+path+を省略した
+ *   場合は自動的にパスが付加される。+:context+で指定した
+ *   Groonga::Contextに結びついているデータベースが一時デー
+ *   タベースの場合は例外が発生する。
+ *
+ * [+:key_type+]
+ *   キーの種類を示すオブジェクトを指定する。キーの種類には
+ *   Groonga::Typeまたはテーブル（Groonga::Array、
+ *   Groonga::Hash、Groonga::PatriciaTrieのどれか）を指定する。
+ *
+ *   Groonga::Typeを指定した場合は、その型が示す範囲の値をキー
+ *   として使用する。ただし、キーの最大サイズは4096バイトで
+ *   あるため、Groonga::Type::TEXTやGroonga::Type::LONG_TEXT
+ *   は使用できない。
+ *
+ *   テーブルを指定した場合はレコードIDをキーとして使用する。
+ *   指定したテーブルのGroonga::Recordをキーとして使用するこ
+ *   ともでき、その場合は自動的にGroonga::Recordからレコード
+ *   IDを取得する。
+ *
+ *   省略した場合は文字列をキーとして使用する。この場合、
+ *   4096バイトまで使用可能である。
+ *
+ * [+:value_size+]
+ *   値の大きさを指定する。省略すると0になる。
+ *
+ * [+:default_tokenizer+]
+ *   Groonga::IndexColumnで使用するトークナイザを指定する。
+ *   デフォルトでは何も設定されていないので、テーブルに
+ *   Groonga::IndexColumnを定義する場合は
+ *   <tt>"<token:bigram>"</tt>などを指定する必要がある。
+ *
+ * 使用例:
+ *
+ * 無名一時テーブルを生成する。
+ *   Groonga::Hash.create
+ *
+ * 無名永続テーブルを生成する。
+ *   Groonga::Hash.create(:path => "/tmp/hash.grn")
+ *
+ * 名前付き永続テーブルを生成する。ただし、ファイル名は気に
+ * しない。
+ *   Groonga::Hash.create(:name => "<bookmarks>",
+ *                        :persistent => true)
+ *
+ * それぞれのレコードに512バイトの値を格納できる無名一時テー
+ * ブルを生成する。
+ *   Groonga::Hash.create(:value => 512)
+ *
+ * キーとして文字列を使用する無名一時テーブルを生成する。
+ *   Groonga::Hash.create(:key_type => Groonga::Type::TEXT)
+ *
+ * キーとして文字列を使用する無名一時テーブルを生成する。
+ * （キーの種類を表すオブジェクトは文字列で指定。）
+ *   Groonga::Hash.create(:key_type => "<shorttext>")
+ *
+ * キーとして<tt><bookmarks></tt>テーブルのレコードを使用す
+ * る無名一時テーブルを生成する。
+ *   bookmarks = Groonga::Hash.create(:name => "<bookmarks>")
+ *   Groonga::Hash.create(:key_type => bookmarks)
+ *
+ * キーとして<tt><bookmarks></tt>テーブルのレコードを使用す
+ * る無名一時テーブルを生成する。
+ * （テーブルは文字列で指定。）
+ *   Groonga::Hash.create(:name => "<bookmarks>")
+ *   Groonga::Hash.create(:key_type => "<bookmarks>")
+ *
+ * 全文検索用のトークンをバイグラムで切り出す無名一時テーブ
+ * ルを生成する。
+ *   bookmarks = Groonga::Hash.create(:name => "<bookmarks>")
+ *   bookmarks.define_column("comment", "<text>")
+ *   terms = Groonga::Hash.create(:name => "<terms>",
+ *                                :default_tokenizer => "<token:bigram>")
+ *   terms.define_index_column("content", bookmarks,
+ *                             :source => "<bookmarks>.comment")
+ */
 static VALUE
 rb_grn_hash_s_create (int argc, VALUE *argv, VALUE self)
 {
-    return rb_grn_table_s_create(argc, argv, self, GRN_TABLE_HASH_KEY);
+    grn_ctx *context;
+    grn_obj *key_type = NULL, *table;
+    const char *name = NULL, *path = NULL;
+    unsigned name_size = 0, value_size = 0;
+    grn_obj_flags flags = GRN_TABLE_HASH_KEY;
+    VALUE rb_table;
+    VALUE options, rb_context, rb_name, rb_path, rb_persistent;
+    VALUE rb_key_type, rb_value_size, rb_default_tokenizer;
+
+    rb_scan_args(argc, argv, "01", &options);
+
+    rb_grn_scan_options(options,
+			"context", &rb_context,
+			"name", &rb_name,
+                        "path", &rb_path,
+			"persistent", &rb_persistent,
+			"key_type", &rb_key_type,
+			"value_size", &rb_value_size,
+			"default_tokenizer", &rb_default_tokenizer,
+			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_path)) {
+        path = StringValueCStr(rb_path);
+	flags |= GRN_OBJ_PERSISTENT;
+    }
+
+    if (RVAL2CBOOL(rb_persistent))
+	flags |= GRN_OBJ_PERSISTENT;
+
+    if (NIL_P(rb_key_type)) {
+	flags |= GRN_OBJ_KEY_VAR_SIZE;
+    } else {
+	key_type = RVAL2GRNOBJECT(rb_key_type, &context);
+    }
+
+    if (!NIL_P(rb_value_size))
+	value_size = NUM2UINT(rb_value_size);
+
+    table = grn_table_create(context, name, name_size, path,
+			     flags, key_type, value_size);
+    if (!table)
+	rb_grn_context_check(context, rb_ary_new4(argc, argv));
+    rb_table = rb_grn_table_key_support_alloc(self);
+    rb_grn_table_key_support_assign(rb_table, rb_context, context, table,
+				    RB_GRN_TRUE);
+    rb_grn_context_check(context, rb_table);
+
+    if (!NIL_P(rb_default_tokenizer))
+	rb_funcall(rb_table, rb_intern("default_tokenizer="), 1,
+		   rb_default_tokenizer);
+
+    if (rb_block_given_p())
+        return rb_ensure(rb_yield, rb_table, rb_grn_object_close, rb_table);
+    else
+        return rb_table;
+}
+
+/*
+ * call-seq:
+ *   hash.search(key, options=nil) -> Groonga::Hash
+ *
+ * _key_にマッチするレコードのIDがキーに入っている
+ * Groonga::Hashを返す。マッチするレコードがない場合は空の
+ * Groonga::Hashが返。
+ *
+ * _options_で+:result+を指定することにより、そのテーブルにマッ
+ * チしたレコードIDがキーのレコードを追加することができる。
+ * +:result+にテーブルを指定した場合は、そのテーブルが返る。
+ *
+ * _options_に指定可能な値は以下の通り。
+ *
+ * [+:result+]
+ *   結果を格納するテーブル。
+ *
+ * 複数のキーで検索し、結果を1つのテーブルに集める。
+ *   result = nil
+ *   keys = ["morita", "gunyara-kun", "yu"]
+ *   keys.each do |key|
+ *     result = users.search(key, :result => result)
+ *   end
+ *   result.each do |record|
+ *     user = record.key
+ *     p user.key # -> "morita"または"gunyara-kun"または"yu"
+ *   end
+ */
+static VALUE
+rb_grn_hash_search (int argc, VALUE *argv, VALUE self)
+{
+    grn_rc rc;
+    grn_ctx *context;
+    grn_obj *table;
+    grn_id domain_id;
+    grn_obj *key, *domain, *result;
+    VALUE rb_key, options, rb_result;
+
+    rb_grn_table_key_support_deconstruct(SELF(self), &table, &context,
+					 &key, &domain_id, &domain,
+					 NULL, NULL, NULL);
+
+    rb_scan_args(argc, argv, "11", &rb_key, &options);
+
+    RVAL2GRNKEY(rb_key, context, key, domain_id, domain, self);
+
+    rb_grn_scan_options(options,
+			"result", &rb_result,
+			NULL);
+
+    if (NIL_P(rb_result)) {
+	result = grn_table_create(context, NULL, 0, NULL,
+				  GRN_OBJ_TABLE_HASH_KEY | GRN_OBJ_WITH_SUBREC,
+				  table, 0);
+	rb_grn_context_check(context, self);
+	rb_result = GRNOBJECT2RVAL(Qnil, context, result, RB_GRN_TRUE);
+    } else {
+	result = RVAL2GRNOBJECT(rb_result, &context);
+    }
+
+    rc = grn_obj_search(context, table, key,
+			result, GRN_SEL_OR, NULL);
+    rb_grn_rc_check(rc, self);
+
+    return rb_result;
 }
 
 void
 rb_grn_init_hash (VALUE mGrn)
 {
     rb_cGrnHash = rb_define_class_under(mGrn, "Hash", rb_cGrnTable);
+    rb_define_alloc_func(rb_cGrnHash, rb_grn_table_key_support_alloc);
 
     rb_include_module(rb_cGrnHash, rb_mGrnTableKeySupport);
 
     rb_define_singleton_method(rb_cGrnHash, "create",
 			       rb_grn_hash_s_create, -1);
+
+    rb_define_method(rb_cGrnHash, "search", rb_grn_hash_search, -1);
 }