/*
* IDが _id_ であるレコードを高速に全文検索するため転置索引を作
* 成する。多くの場合、 {Groonga::Table#define_index_column} で
* +:source+ オプションを指定することにより、自動的に全文検索
* 用の索引は更新されるので、明示的にこのメソッドを使うこと
* は少ない。
*
* @example 記事の段落毎に索引を作成する。
* articles = Groonga::Array.create(:name => "<articles>")
* articles.define_column("title", "ShortText")
* articles.define_column("content", "Text")
*
* terms = Groonga::Hash.create(:name => "<terms>",
* :default_tokenizer => "TokenBigram")
* content_index = terms.define_index_column("content", articles,
* :with_section => true)
*
* content = <<-EOC
* groonga は組み込み型の全文検索エンジンライブラリです。
* DBMSやスクリプト言語処理系等に組み込むことによって、その
* 全文検索機能を強化することができます。また、リレーショナ
* ルモデルに基づくデータストア機能を内包しており、groonga
* 単体でも高速なデータストアサーバとして使用することができ
* ます。
*
* ■全文検索方式
* 転置索引型の全文検索エンジンです。転置索引は圧縮されてファ
* イルに格納され、検索時のディスク読み出し量を小さく、かつ
* 局所的に抑えるように設計されています。用途に応じて以下の
* 索引タイプを選択できます。
* EOC
*
* groonga = articles.add(:title => "groonga", :content => content)
*
* content.split(/\n{2,}/).each_with_index do |sentence, i|
* content_index[groonga] = {:value => sentence, :section => i + 1}
* end
*
* content_index.search("エンジン").collect do |record|
* p record.key["title"] # -> "groonga"
* end
*
* @overload []=(id, value)
* @param [String] value 新しい値
* @overload []=(id, options)
* _options_ を指定することにより、 _value_ を指定したときよりも索引の作
* 成を制御できる。
* @param [::Hash] options The name and value
* pairs. Omitted names are initialized as the default value
* @option options :section
* 段落番号を指定する。省略した場合は1を指定したとみなされ
* る。
* {Groonga::Table#define_index_column} で
* @{:with_section => true}@ を指定していなければい
* けない。
* @option options :old_value
* 以前の値を指定する。省略した場合は現在の値が用いられる。
* 通常は指定する必要はない。
* @option options :value
* 新しい値を指定する。 _value_ を指定した場合と _options_ で
* @{:value => value}@ を指定した場合は同じ動作とな
* る。
*
* @deprecated Since 3.0.2. Use {#add}, {#delete} or {#update} instead.
*/
static VALUE
rb_grn_index_column_array_set (VALUE self, VALUE rb_id, VALUE rb_value)
{
grn_ctx *context = NULL;
grn_obj *column, *range;
grn_rc rc;
grn_id id;
unsigned int section;
grn_obj *old_value, *new_value;
VALUE original_rb_value, rb_section, rb_old_value, rb_new_value;
original_rb_value = rb_value;
rb_grn_index_column_deconstruct(SELF(self), &column, &context,
NULL, NULL,
&new_value, &old_value,
NULL, &range,
NULL, NULL);
id = RVAL2GRNID(rb_id, context, range, self);
if (!RVAL2CBOOL(rb_obj_is_kind_of(rb_value, rb_cHash))) {
VALUE hash_value;
hash_value = rb_hash_new();
rb_hash_aset(hash_value, RB_GRN_INTERN("value"), rb_value);
rb_value = hash_value;
}
rb_grn_scan_options(rb_value,
"section", &rb_section,
"old_value", &rb_old_value,
"value", &rb_new_value,
NULL);
if (NIL_P(rb_section))
section = 1;
else
section = NUM2UINT(rb_section);
if (NIL_P(rb_old_value)) {
old_value = NULL;
} else {
GRN_BULK_REWIND(old_value);
RVAL2GRNBULK(rb_old_value, context, old_value);
}
if (NIL_P(rb_new_value)) {
new_value = NULL;
} else {
GRN_BULK_REWIND(new_value);
RVAL2GRNBULK(rb_new_value, context, new_value);
}
rc = grn_column_index_update(context, column,
id, section, old_value, new_value);
rb_grn_context_check(context, self);
rb_grn_rc_check(rc, self);
return original_rb_value;
}
static VALUE
rb_grn_log_level_to_ruby_object (grn_log_level level)
{
VALUE rb_level = Qnil;
switch (level) {
case GRN_LOG_NONE:
rb_level = RB_GRN_INTERN("none");
break;
case GRN_LOG_EMERG:
rb_level = RB_GRN_INTERN("emergency");
break;
case GRN_LOG_ALERT:
rb_level = RB_GRN_INTERN("alert");
break;
case GRN_LOG_CRIT:
rb_level = RB_GRN_INTERN("critical");
break;
case GRN_LOG_ERROR:
rb_level = RB_GRN_INTERN("error");
break;
case GRN_LOG_WARNING:
rb_level = RB_GRN_INTERN("warning");
break;
case GRN_LOG_NOTICE:
rb_level = RB_GRN_INTERN("notice");
break;
case GRN_LOG_INFO:
rb_level = RB_GRN_INTERN("info");
break;
case GRN_LOG_DEBUG:
rb_level = RB_GRN_INTERN("debug");
break;
case GRN_LOG_DUMP:
rb_level = RB_GRN_INTERN("dump");
break;
default:
rb_level = INT2NUM(level);
break;
}
return rb_level;
}
void
rb_grn_scan_options (VALUE options, ...)
{
VALUE original_options = options;
VALUE available_keys;
const char *key;
VALUE *value;
va_list args;
options = rb_grn_check_convert_to_hash(options);
if (NIL_P(options)) {
if (NIL_P(original_options)) {
options = rb_hash_new();
} else {
rb_raise(rb_eArgError,
"options must be Hash: %s",
rb_grn_inspect(original_options));
}
} else if (options == original_options) {
options = rb_funcall(options, rb_intern("dup"), 0);
}
available_keys = rb_ary_new();
va_start(args, options);
key = va_arg(args, const char *);
while (key) {
VALUE rb_key;
value = va_arg(args, VALUE *);
rb_key = RB_GRN_INTERN(key);
rb_ary_push(available_keys, rb_key);
*value = rb_funcall(options, rb_intern("delete"), 1, rb_key);
if (NIL_P(*value)) {
rb_key = rb_str_new_cstr(key);
*value = rb_funcall(options, rb_intern("delete"), 1, rb_key);
}
key = va_arg(args, const char *);
}
va_end(args);
if (RVAL2CBOOL(rb_funcall(options, rb_intern("empty?"), 0)))
return;
rb_raise(rb_eArgError,
"unexpected key(s) exist: %s: available keys: %s",
rb_grn_inspect(rb_funcall(options, rb_intern("keys"), 0)),
rb_grn_inspect(available_keys));
}
void
rb_grn_scan_options (VALUE options, ...)
{
VALUE available_keys;
const char *key;
VALUE *value;
va_list args;
if (NIL_P(options))
options = rb_hash_new();
else
options = rb_funcall(options, rb_intern("dup"), 0);
Check_Type(options, T_HASH);
available_keys = rb_ary_new();
va_start(args, options);
key = va_arg(args, const char *);
while (key) {
VALUE rb_key;
value = va_arg(args, VALUE *);
rb_key = RB_GRN_INTERN(key);
rb_ary_push(available_keys, rb_key);
*value = rb_funcall(options, rb_intern("delete"), 1, rb_key);
key = va_arg(args, const char *);
}
va_end(args);
if (RVAL2CBOOL(rb_funcall(options, rb_intern("empty?"), 0)))
return;
rb_raise(rb_eArgError,
"unexpected key(s) exist: %s: available keys: %s",
rb_grn_inspect(rb_funcall(options, rb_intern("keys"), 0)),
rb_grn_inspect(available_keys));
}
/* FIXME: DON'T WORK!!! */
static VALUE
rb_grn_view_sort (int argc, VALUE *argv, VALUE self)
{
VALUE rb_result = Qnil;
#ifdef WIN32
rb_raise(rb_eNotImpError, "grn_view_add() isn't available on Windows.");
#else
grn_ctx *context = NULL;
grn_obj *view;
grn_obj *result;
grn_table_sort_key *keys;
int i, n_keys;
int n_records, offset = 0, limit = -1;
VALUE rb_keys, options;
VALUE rb_offset, rb_limit;
VALUE *rb_sort_keys;
grn_table_cursor *cursor;
VALUE exception;
grn_obj id;
rb_grn_table_deconstruct(SELF(self), &view, &context,
NULL, NULL,
NULL, NULL, NULL,
NULL);
rb_scan_args(argc, argv, "11", &rb_keys, &options);
if (!RVAL2CBOOL(rb_obj_is_kind_of(rb_keys, rb_cArray)))
rb_raise(rb_eArgError, "keys should be an array of key: <%s>",
rb_grn_inspect(rb_keys));
n_keys = RARRAY_LEN(rb_keys);
rb_sort_keys = RARRAY_PTR(rb_keys);
keys = ALLOCA_N(grn_table_sort_key, n_keys);
for (i = 0; i < n_keys; i++) {
VALUE rb_sort_options, rb_key, rb_resolved_key, rb_order;
if (RVAL2CBOOL(rb_obj_is_kind_of(rb_sort_keys[i], rb_cHash))) {
rb_sort_options = rb_sort_keys[i];
} else if (RVAL2CBOOL(rb_obj_is_kind_of(rb_sort_keys[i], rb_cArray))) {
rb_sort_options = rb_hash_new();
rb_hash_aset(rb_sort_options,
RB_GRN_INTERN("key"),
rb_ary_entry(rb_sort_keys[i], 0));
rb_hash_aset(rb_sort_options,
RB_GRN_INTERN("order"),
rb_ary_entry(rb_sort_keys[i], 1));
} else {
rb_sort_options = rb_hash_new();
rb_hash_aset(rb_sort_options,
RB_GRN_INTERN("key"),
rb_sort_keys[i]);
}
rb_grn_scan_options(rb_sort_options,
"key", &rb_key,
"order", &rb_order,
NULL);
if (RVAL2CBOOL(rb_obj_is_kind_of(rb_key, rb_cString))) {
rb_resolved_key = rb_grn_table_get_column(self, rb_key);
} else {
rb_resolved_key = rb_key;
}
keys[i].key = RVAL2GRNOBJECT(rb_resolved_key, &context);
if (!keys[i].key) {
rb_raise(rb_eGrnNoSuchColumn,
"no such column: <%s>: <%s>",
rb_grn_inspect(rb_key), rb_grn_inspect(self));
}
if (NIL_P(rb_order)) {
keys[i].flags = 0;
} else if (rb_grn_equal_option(rb_order, "desc") ||
rb_grn_equal_option(rb_order, "descending")) {
keys[i].flags = GRN_TABLE_SORT_DESC;
} else if (rb_grn_equal_option(rb_order, "asc") ||
rb_grn_equal_option(rb_order, "ascending")) {
keys[i].flags = GRN_TABLE_SORT_ASC;
} else {
rb_raise(rb_eArgError,
"order should be one of "
"[nil, :desc, :descending, :asc, :ascending]: %s",
rb_grn_inspect(rb_order));
}
}
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_VIEW,
NULL, NULL);
grn_view_add(context, result,
grn_table_create(context, NULL, 0, NULL, GRN_TABLE_NO_KEY,
NULL, grn_ctx_get(context, "People", strlen("People"))));
grn_view_add(context, result,
grn_table_create(context, NULL, 0, NULL, GRN_TABLE_NO_KEY,
NULL, grn_ctx_get(context, "People", strlen("People"))));
n_records = grn_table_sort(context, view, offset, limit,
result, keys, n_keys);
exception = rb_grn_context_to_exception(context, self);
if (!NIL_P(exception)) {
grn_obj_unlink(context, result);
rb_exc_raise(exception);
}
rb_result = rb_ary_new();
cursor = grn_table_cursor_open(context, result, NULL, 0, NULL, 0,
0, -1, GRN_CURSOR_ASCENDING);
GRN_TEXT_INIT(&id, 0);
while (grn_table_cursor_next_o(context, cursor, &id) == GRN_SUCCESS) {
rb_ary_push(rb_result, rb_grn_view_record_new(self, &id));
}
GRN_OBJ_FIN(context, &id);
grn_table_cursor_close(context, cursor);
grn_obj_unlink(context, result);
#endif
return rb_result;
}
void
rb_grn_table_sort_keys_fill (grn_ctx *context,
grn_table_sort_key *sort_keys,
size_t n_sort_keys,
VALUE rb_sort_keys,
VALUE rb_table)
{
size_t i;
for (i = 0; i < n_sort_keys; i++) {
VALUE rb_sort_key;
VALUE rb_sort_options;
VALUE rb_key;
VALUE rb_resolved_key;
VALUE rb_order;
rb_sort_key = RARRAY_PTR(rb_sort_keys)[i];
if (RVAL2CBOOL(rb_obj_is_kind_of(rb_sort_key, rb_cHash))) {
rb_sort_options = rb_sort_key;
} else if (RVAL2CBOOL(rb_obj_is_kind_of(rb_sort_key, rb_cArray))) {
rb_sort_options = rb_hash_new();
rb_hash_aset(rb_sort_options,
RB_GRN_INTERN("key"),
rb_ary_entry(rb_sort_key, 0));
rb_hash_aset(rb_sort_options,
RB_GRN_INTERN("order"),
rb_ary_entry(rb_sort_key, 1));
} else {
rb_sort_options = rb_hash_new();
rb_hash_aset(rb_sort_options,
RB_GRN_INTERN("key"),
rb_sort_key);
}
rb_grn_scan_options(rb_sort_options,
"key", &rb_key,
"order", &rb_order,
NULL);
if (RVAL2CBOOL(rb_obj_is_kind_of(rb_key, rb_cString))) {
rb_resolved_key = rb_grn_table_get_column(rb_table, rb_key);
} else {
rb_resolved_key = rb_key;
}
sort_keys[i].key = RVAL2GRNOBJECT(rb_resolved_key, &context);
if (!sort_keys[i].key) {
rb_raise(rb_eGrnNoSuchColumn,
"no such column: <%s>: <%s>",
rb_grn_inspect(rb_key),
rb_grn_inspect(rb_table));
}
if (NIL_P(rb_order) ||
rb_grn_equal_option(rb_order, "asc") ||
rb_grn_equal_option(rb_order, "ascending")) {
sort_keys[i].flags = GRN_TABLE_SORT_ASC;
} else if (rb_grn_equal_option(rb_order, "desc") ||
rb_grn_equal_option(rb_order, "descending")) {
sort_keys[i].flags = GRN_TABLE_SORT_DESC;
} else {
rb_raise(rb_eArgError,
"order should be one of "
"[nil, :desc, :descending, :asc, :ascending]: %s",
rb_grn_inspect(rb_order));
}
}
}
/*
* It gets a value of variable size column value for the record that
* ID is _id_.
*
* @example Gets weight vector value
* Groonga::Schema.define do |schema|
* schema.create_table("Products",
* :type => :patricia_trie,
* :key_type => "ShortText") do |table|
* # This is weight vector.
* # ":with_weight => true" is important to store weight value.
* table.short_text("tags",
* :type => :vector,
* :with_weight => true)
* end
* end
*
* products = Groonga["Products"]
* rroonga = products.add("Rroonga")
* rroonga.tags = [
* {
* :value => "ruby",
* :weight => 100,
* },
* {
* :value => "groonga",
* :weight => 10,
* },
* ]
*
* p rroonga.tags
* # => [
* # {:value => "ruby", :weight => 100},
* # {:value => "groonga", :weight => 10}
* # ]
*
* @overload [](id)
* @param [Integer, Record] id The record ID.
* @return [Array<Hash<Symbol, String>>] An array of value if the column
* is a weight vector column.
* Each value is a Hash like the following form:
*
* <pre>
* {
* :value => [KEY],
* :weight => [WEIGHT],
* }
* </pre>
*
* @[KEY]@ is the key of the table that is specified as range on
* creating the weight vector.
*
* @[WEIGHT]@ is a positive integer.
*
* @return [::Object] See {Groonga::Object#[]} for columns except
* weight vector column.
*
* @since 4.0.1.
*/
static VALUE
rb_grn_variable_size_column_array_reference (VALUE self, VALUE rb_id)
{
grn_ctx *context = NULL;
grn_obj *column, *range;
grn_id id;
grn_obj *value;
VALUE rb_value;
VALUE rb_range;
unsigned int i, n;
rb_grn_variable_size_column_deconstruct(SELF(self), &column, &context,
NULL, NULL, &value, NULL,
NULL, &range);
if (!(column->header.flags & GRN_OBJ_WITH_WEIGHT)) {
return rb_call_super(1, &rb_id);
}
id = RVAL2GRNID(rb_id, context, range, self);
grn_obj_reinit(context, value,
value->header.domain,
value->header.flags | GRN_OBJ_VECTOR);
grn_obj_get_value(context, column, id, value);
rb_grn_context_check(context, self);
rb_range = GRNTABLE2RVAL(context, range, GRN_FALSE);
n = grn_vector_size(context, value);
rb_value = rb_ary_new2(n);
for (i = 0; i < n; i++) {
VALUE rb_element_value;
unsigned int weight = 0;
grn_id domain;
VALUE rb_element;
if (value->header.type == GRN_UVECTOR) {
grn_id id;
id = grn_uvector_get_element(context, value, i, &weight);
rb_element_value = rb_grn_record_new(rb_range, id, Qnil);
} else {
const char *element_value;
unsigned int element_value_length;
element_value_length = grn_vector_get_element(context,
value,
i,
&element_value,
&weight,
&domain);
rb_element_value = rb_str_new(element_value, element_value_length);
}
rb_element = rb_hash_new();
rb_hash_aset(rb_element,
RB_GRN_INTERN("value"),
rb_element_value);
rb_hash_aset(rb_element,
RB_GRN_INTERN("weight"),
UINT2NUM(weight));
rb_ary_push(rb_value, rb_element);
}
return rb_value;
}