/*
* Recreates all index columns for the column.
*
* This method is useful when you have any broken index columns for
* the column. You don't need to specify each index column. But this
* method spends more time rather than you specify only reindex
* needed index columns.
*
* You can use {Groonga::Database#reindex} to recreate all index
* columns in a database.
*
* You can use {Groonga::TableKeySupport#reindex} to recreate all
* index columns in a table.
*
* You can use {Groonga::IndexColumn#reindex} to specify the reindex
* target index column.
*
* @example How to recreate all index columns for the column
* Groonga::Schema.define do |schema|
* schema.create_table("Memos") do |table|
* table.short_text("title")
* table.text("content")
* end
*
* schema.create_table("BigramTerms",
* :type => :patricia_trie,
* :key_type => :short_text,
* :normalizer => "NormalizerAuto",
* :default_tokenizer => "TokenBigram") do |table|
* table.index("Memos.title")
* table.index("Memos.content")
* end
*
* schema.create_table("MeCabTerms",
* :type => :patricia_trie,
* :key_type => :short_text,
* :normalizer => "NormalizerAuto",
* :default_tokenizer => "TokenMecab") do |table|
* table.index("Memos.title")
* table.index("Memos.content")
* end
* end
*
* Groonga["Memos.content"].reindex
* # They are called:
* # Groonga["BigramTerms.Memos_content"].reindex
* # Groonga["MeCabTerms.Memos_content"].reindex
* #
* # They aren't called:
* # Groonga["BigramTerms.Memos_title"].reindex
* # Groonga["MeCabTerms.Memos_title"].reindex
*
* @overload reindex
* @return [void]
*
* @see Groonga::Database#reindex
* @see Groonga::TableKeySupport#reindex
* @see Groonga::FixSizeColumn#reindex
* @see Groonga::IndexColumn#reindex
*
* @since 5.1.1
*/
static VALUE
rb_grn_variable_size_column_reindex (VALUE self)
{
grn_rc rc;
grn_ctx *context;
grn_obj *column;
rb_grn_variable_size_column_deconstruct(SELF(self), &column, &context,
NULL, NULL, NULL, NULL,
NULL, NULL);
rc = grn_obj_reindex(context, column);
rb_grn_context_check(context, self);
rb_grn_rc_check(rc, self);
return Qnil;
}
/*
* It updates a value of variable size column value for the record
* that ID is _id_.
*
* Weight vector column is a special variable size column. This
* description describes only weight vector column. Other variable
* size column works what you think.
*
* @example Use weight vector as matrix search result weight
* 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 for matrix search result weight.
* table.short_text("tags",
* :type => :vector,
* :with_weight => true)
* end
*
* schema.create_table("Tags",
* :type => :hash,
* :key_type => "ShortText") do |table|
* # This is inverted index. It also needs ":with_weight => true".
* table.index("Products.tags", :with_weight => true)
* end
* end
*
* products = Groonga["Products"]
* groonga = products.add("Groonga")
* groonga.tags = [
* {
* :value => "groonga",
* :weight => 100,
* },
* ]
* rroonga = products.add("Rroonga")
* rroonga.tags = [
* {
* :value => "ruby",
* :weight => 100,
* },
* {
* :value => "groonga",
* :weight => 10,
* },
* ]
*
* result = products.select do |record|
* # Search by "groonga"
* record.match("groonga") do |match_target|
* match_target.tags
* end
* end
*
* result.each do |record|
* p [record.key.key, record.score]
* end
* # Matches all records with weight.
* # => ["Groonga", 101]
* # ["Rroonga", 11]
*
* # Increases score for "ruby" 10 times
* products.select(# The previous search result. Required.
* :result => result,
* # It just adds score to existing records in the result. Required.
* :operator => Groonga::Operator::ADJUST) do |record|
* record.match("ruby") do |target|
* target.tags * 10 # 10 times
* end
* end
*
* result.each do |record|
* p [record.key.key, record.score]
* end
* # Weight is used for increasing score.
* # => ["Groonga", 101] <- Not changed.
* # ["Rroonga", 1021] <- 1021 (= 101 * 10 + 1) increased.
*
* @overload []=(id, elements)
* This description is for weight vector column.
*
* @param [Integer, Record] id The record ID.
* @param [Array<Hash<Symbol, String>>] elements An array of values
* for weight vector.
* Each value is a Hash like the following form:
*
* <pre>
* {
* :value => [KEY],
* :weight => [WEIGHT],
* }
* </pre>
*
* @[KEY]@ must be the same type of the key of the table that is
* specified as range on creating the weight vector.
*
* @[WEIGHT]@ must be an positive integer. Note that search
* becomes @weight + 1@. It means that You want to get 10 as
* score, you should set 9 as weight.
*
* @overload []=(id, value)
* This description is for variable size columns except weight
* vector column.
*
* @param [Integer, Record] id The record ID.
* @param [::Object] value A new value.
* @see Groonga::Object#[]=
*
* @since 4.0.1
*/
static VALUE
rb_grn_variable_size_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;
grn_obj *value, *element_value;
int flags = GRN_OBJ_SET;
rb_grn_variable_size_column_deconstruct(SELF(self), &column, &context,
NULL, NULL, &value, &element_value,
NULL, &range);
if (!(column->header.flags & GRN_OBJ_WITH_WEIGHT)) {
VALUE args[2];
args[0] = rb_id;
args[1] = rb_value;
return rb_call_super(2, args);
}
id = RVAL2GRNID(rb_id, context, range, self);
grn_obj_reinit(context, value,
value->header.domain,
value->header.flags | GRN_OBJ_VECTOR);
value->header.flags |= GRN_OBJ_WITH_WEIGHT;
if (RVAL2CBOOL(rb_obj_is_kind_of(rb_value, rb_cArray))) {
int i, n;
n = RARRAY_LEN(rb_value);
for (i = 0; i < n; i++) {
unsigned int weight = 0;
VALUE rb_element_value, rb_weight;
rb_grn_scan_options(RARRAY_PTR(rb_value)[i],
"value", &rb_element_value,
"weight", &rb_weight,
NULL);
if (!NIL_P(rb_weight)) {
weight = NUM2UINT(rb_weight);
}
if (value->header.type == GRN_UVECTOR) {
grn_id id = RVAL2GRNID(rb_element_value, context, range, self);
grn_uvector_add_element(context, value, id, weight);
} else {
GRN_BULK_REWIND(element_value);
if (!NIL_P(rb_element_value)) {
RVAL2GRNBULK(rb_element_value, context, element_value);
}
grn_vector_add_element(context, value,
GRN_BULK_HEAD(element_value),
GRN_BULK_VSIZE(element_value),
weight,
element_value->header.domain);
}
}
} else if (RVAL2CBOOL(rb_obj_is_kind_of(rb_value, rb_cHash))) {
HashElementToVectorElementData data;
data.self = self;
data.context = context;
data.vector = value;
data.element_value = element_value;
data.range = range;
rb_hash_foreach(rb_value, hash_element_to_vector_element, (VALUE)&data);
} else {
rb_raise(rb_eArgError,
"<%s>: "
"weight vector value must be an array of index value or "
"a hash that key is vector value and value is vector weight: "
"<%s>",
rb_grn_inspect(self),
rb_grn_inspect(rb_value));
}
rc = grn_obj_set_value(context, column, id, value, flags);
rb_grn_context_check(context, self);
rb_grn_rc_check(rc, self);
return rb_value;
}
/*
* 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,
ID2SYM(rb_intern("value")),
rb_element_value);
rb_hash_aset(rb_element,
ID2SYM(rb_intern("weight")),
UINT2NUM(weight));
rb_ary_push(rb_value, rb_element);
}
return rb_value;
}
