static VALUE
rb_grn_double_array_trie_update_by_key (VALUE self,
VALUE rb_current_key,
VALUE rb_new_key)
{
grn_ctx *context;
grn_obj *table;
grn_id domain_id;
grn_obj *current_key, *new_key, *domain;
grn_rc rc;
rb_grn_double_array_trie_deconstruct(SELF(self), &table, &context,
¤t_key, &new_key,
&domain_id, &domain,
NULL, NULL, NULL,
NULL);
RVAL2GRNKEY(rb_current_key, context, current_key, domain_id, domain, self);
RVAL2GRNKEY(rb_new_key, context, new_key, domain_id, domain, self);
rc = grn_table_update(context, table,
GRN_BULK_HEAD(current_key),
GRN_BULK_VSIZE(current_key),
GRN_BULK_HEAD(new_key),
GRN_BULK_VSIZE(new_key));
rb_grn_rc_check(rc, self);
return Qnil;
}
/*
* テーブルの _id_ に対応する主キーを返す。
*
* @overload key(id)
* @return [主キー]
*/
static VALUE
rb_grn_table_key_support_get_key (VALUE self, VALUE rb_id)
{
grn_ctx *context;
grn_obj *table, *key;
grn_id id;
int key_size;
VALUE rb_key;
rb_grn_table_key_support_deconstruct(SELF(self), &table, &context,
&key, NULL, NULL,
NULL, NULL, NULL,
NULL);
id = NUM2UINT(rb_id);
GRN_BULK_REWIND(key);
key_size = grn_table_get_key(context, table, id,
GRN_BULK_HEAD(key), GRN_BULK_VSIZE(key));
if (key_size == 0)
return Qnil;
if (GRN_BULK_VSIZE(key) < key_size) {
grn_bulk_reserve(context, key, key_size);
grn_table_get_key(context, table, id, GRN_BULK_HEAD(key), key_size);
}
rb_key = GRNKEY2RVAL(context, GRN_BULK_HEAD(key), key_size, table, self);
return rb_key;
}
VALUE
rb_grn_obj_to_ruby_object (VALUE klass, grn_ctx *context,
grn_obj *obj, VALUE related_object)
{
if (!obj)
return Qnil;
/* if (NIL_P(klass)) */
/* klass = GRNOBJECT2RCLASS(obj); */
switch (obj->header.type) {
case GRN_VOID:
if (GRN_BULK_VSIZE(obj) > 0)
return rb_str_new(GRN_BULK_HEAD(obj), GRN_BULK_VSIZE(obj));
else
return Qnil;
break;
case GRN_BULK:
return GRNBULK2RVAL(context, obj, NULL, related_object);
break;
/* case GRN_PTR: */
/* case GRN_UVECTOR: */
/* case GRN_PVECTOR: */
case GRN_VECTOR:
return GRNVECTOR2RVAL(context, obj);
break;
/* case GRN_MSG: */
/* case GRN_QUERY: */
/* case GRN_ACCESSOR: */
/* case GRN_SNIP: */
/* case GRN_PATSNIP: */
/* case GRN_CURSOR_TABLE_HASH_KEY: */
/* case GRN_CURSOR_TABLE_PAT_KEY: */
/* case GRN_CURSOR_TABLE_NO_KEY: */
/* case GRN_CURSOR_COLUMN_INDEX: */
/* case GRN_TYPE: */
/* case GRN_PROC: */
/* case GRN_EXPR: */
/* case GRN_TABLE_HASH_KEY: */
/* case GRN_TABLE_PAT_KEY: */
/* case GRN_TABLE_DAT_KEY: */
/* case GRN_TABLE_NO_KEY: */
/* case GRN_DB: */
/* case GRN_COLUMN_FIX_SIZE: */
/* case GRN_COLUMN_VAR_SIZE: */
/* case GRN_COLUMN_INDEX: */
default:
rb_raise(rb_eTypeError,
"unsupported groonga object: %s(%#x): <%s>",
rb_grn_inspect_type(obj->header.type),
obj->header.type,
rb_grn_inspect(related_object));
break;
}
return Qnil;
}
/*
* call-seq:
* patricia_trie.prefix_search(prefix) -> Groonga::Hash
*
* キーが_prefix_に前方一致するレコードのIDがキーに入っている
* Groonga::Hashを返す。マッチするレコードがない場合は空の
* Groonga::Hashが返る。
*
*/
static VALUE
rb_grn_patricia_trie_prefix_search (VALUE self, VALUE rb_prefix)
{
grn_ctx *context;
grn_obj *table, *key, *domain, *result;
grn_id domain_id;
VALUE rb_result;
rb_grn_table_key_support_deconstruct(SELF(self), &table, &context,
&key, &domain_id, &domain,
NULL, NULL, NULL,
NULL);
result = grn_table_create(context, NULL, 0, NULL,
GRN_OBJ_TABLE_HASH_KEY,
table, 0);
rb_grn_context_check(context, self);
rb_result = GRNOBJECT2RVAL(Qnil, context, result, GRN_TRUE);
GRN_BULK_REWIND(key);
RVAL2GRNKEY(rb_prefix, context, key, domain_id, domain, self);
grn_pat_prefix_search(context, (grn_pat *)table,
GRN_BULK_HEAD(key), GRN_BULK_VSIZE(key),
(grn_hash *)result);
rb_grn_context_check(context, self);
return rb_result;
}
/*
* call-seq:
* column.sources -> Groonga::Columnの配列
*
* インデックス対象となっているカラムの配列を返す。
*/
static VALUE
rb_grn_index_column_get_sources (VALUE self)
{
grn_ctx *context = NULL;
grn_obj *column;
grn_obj sources;
grn_id *source_ids;
VALUE rb_sources;
int i, n;
rb_grn_index_column_deconstruct(SELF(self), &column, &context,
NULL, NULL,
NULL, NULL, NULL, NULL,
NULL, NULL);
GRN_OBJ_INIT(&sources, GRN_BULK, 0, GRN_ID_NIL);
grn_obj_get_info(context, column, GRN_INFO_SOURCE, &sources);
rb_grn_context_check(context, self);
n = GRN_BULK_VSIZE(&sources) / sizeof(grn_id);
source_ids = (grn_id *)GRN_BULK_HEAD(&sources);
rb_sources = rb_ary_new2(n);
for (i = 0; i < n; i++) {
grn_obj *source;
VALUE rb_source;
source = grn_ctx_at(context, *source_ids);
rb_source = GRNOBJECT2RVAL(Qnil, context, source, RB_GRN_FALSE);
rb_ary_push(rb_sources, rb_source);
source_ids++;
}
grn_obj_unlink(context, &sources);
return rb_sources;
}
static void
command_schema_table_output_token_filters(grn_ctx *ctx, grn_obj *table)
{
grn_obj token_filters;
int i, n;
GRN_PTR_INIT(&token_filters, GRN_OBJ_VECTOR, GRN_DB_OBJECT);
if (table->header.type != GRN_TABLE_NO_KEY) {
grn_obj_get_info(ctx, table, GRN_INFO_TOKEN_FILTERS, &token_filters);
}
n = GRN_BULK_VSIZE(&token_filters) / sizeof(grn_obj *);
grn_ctx_output_array_open(ctx, "token_filters", n);
for (i = 0; i < n; i++) {
grn_obj *token_filter;
token_filter = GRN_PTR_VALUE_AT(&token_filters, i);
grn_ctx_output_map_open(ctx, "token_filter", 1);
grn_ctx_output_cstr(ctx, "name");
command_schema_output_name(ctx, token_filter);
grn_ctx_output_map_close(ctx);
}
grn_ctx_output_array_close(ctx);
GRN_OBJ_FIN(ctx, &token_filters);
}
static void
command_schema_output_token_filters(grn_ctx *ctx)
{
grn_obj token_filters;
int i, n;
GRN_PTR_INIT(&token_filters, GRN_OBJ_VECTOR, GRN_DB_OBJECT);
grn_ctx_get_all_token_filters(ctx, &token_filters);
grn_ctx_output_cstr(ctx, "token_filters");
n = GRN_BULK_VSIZE(&token_filters) / sizeof(grn_obj *);
grn_ctx_output_map_open(ctx, "token_filters", n);
for (i = 0; i < n; i++) {
grn_obj *token_filter;
token_filter = GRN_PTR_VALUE_AT(&token_filters, i);
command_schema_output_name(ctx, token_filter);
grn_ctx_output_map_open(ctx, "token_filter", 1);
grn_ctx_output_cstr(ctx, "name");
command_schema_output_name(ctx, token_filter);
grn_ctx_output_map_close(ctx);
}
grn_ctx_output_map_close(ctx);
GRN_OBJ_FIN(ctx, &token_filters);
}
static void
command_schema_output_normalizers(grn_ctx *ctx)
{
grn_obj normalizers;
unsigned int i, n;
GRN_PTR_INIT(&normalizers, GRN_OBJ_VECTOR, GRN_DB_OBJECT);
grn_ctx_get_all_normalizers(ctx, &normalizers);
grn_ctx_output_cstr(ctx, "normalizers");
n = GRN_BULK_VSIZE(&normalizers) / sizeof(grn_obj *);
grn_ctx_output_map_open(ctx, "normalizers", n);
for (i = 0; i < n; i++) {
grn_obj *normalizer;
normalizer = GRN_PTR_VALUE_AT(&normalizers, i);
command_schema_output_name(ctx, normalizer);
grn_ctx_output_map_open(ctx, "normalizer", 1);
grn_ctx_output_cstr(ctx, "name");
command_schema_output_name(ctx, normalizer);
grn_ctx_output_map_close(ctx);
}
grn_ctx_output_map_close(ctx);
GRN_OBJ_FIN(ctx, &normalizers);
}
static void
grn_token_cursor_close_token_filters(grn_ctx *ctx,
grn_token_cursor *token_cursor)
{
grn_obj *token_filters = token_cursor->token_filter.objects;
unsigned int i, n_token_filters;
if (token_filters) {
n_token_filters = GRN_BULK_VSIZE(token_filters) / sizeof(grn_obj *);
} else {
n_token_filters = 0;
}
if (n_token_filters == 0) {
return;
}
for (i = 0; i < n_token_filters; i++) {
grn_obj *token_filter_object = GRN_PTR_VALUE_AT(token_filters, i);
grn_proc *token_filter = (grn_proc *)token_filter_object;
void *data = token_cursor->token_filter.data[i];
token_filter->callbacks.token_filter.fin(ctx, data);
}
GRN_FREE(token_cursor->token_filter.data);
}
static void
grn_text_atoj_o(grn_ctx *ctx, grn_obj *outbuf, grn_content_type output_type,
grn_obj *obj, grn_obj *id)
{
grn_id *idp = (grn_id *)GRN_BULK_HEAD(id);
uint32_t ids = GRN_BULK_VSIZE(id);
for (;;) {
if (ids < sizeof(grn_id)) {
ERR(GRN_INVALID_ARGUMENT, "invalid id.");
return;
}
if (obj->header.type == GRN_ACCESSOR_VIEW) {
uint32_t n;
grn_accessor_view *v = (grn_accessor_view *)obj;
n = *idp;
if (n >= v->naccessors) {
ERR(GRN_INVALID_ARGUMENT, "invalid id");
return;
}
if (!(obj = v->accessors[n])) { return ; }
idp++;
ids -= sizeof(grn_id);
} else {
break;
}
}
grn_text_atoj(ctx, outbuf, output_type, obj, *idp);
}
VALUE
rb_grn_context_to_exception (grn_ctx *context, VALUE related_object)
{
VALUE exception, exception_class;
const char *message;
grn_obj bulk;
if (context->rc == GRN_SUCCESS)
return Qnil;
exception_class = rb_grn_rc_to_exception(context->rc);
message = rb_grn_rc_to_message(context->rc);
GRN_OBJ_INIT(&bulk, GRN_BULK, 0, GRN_ID_NIL);
GRN_TEXT_PUTS(context, &bulk, message);
GRN_TEXT_PUTS(context, &bulk, ": ");
GRN_TEXT_PUTS(context, &bulk, context->errbuf);
if (!NIL_P(related_object)) {
GRN_TEXT_PUTS(context, &bulk, ": ");
GRN_TEXT_PUTS(context, &bulk, rb_grn_inspect(related_object));
}
GRN_TEXT_PUTS(context, &bulk, "\n");
GRN_TEXT_PUTS(context, &bulk, context->errfile);
GRN_TEXT_PUTS(context, &bulk, ":");
grn_text_itoa(context, &bulk, context->errline);
GRN_TEXT_PUTS(context, &bulk, ": ");
GRN_TEXT_PUTS(context, &bulk, context->errfunc);
GRN_TEXT_PUTS(context, &bulk, "()");
exception = rb_funcall(exception_class, rb_intern("new"), 1,
rb_str_new(GRN_BULK_HEAD(&bulk),
GRN_BULK_VSIZE(&bulk)));
grn_obj_unlink(context, &bulk);
return exception;
}
grn_obj *
rb_grn_vector_from_ruby_object (VALUE object, grn_ctx *context, grn_obj *vector)
{
VALUE *values;
grn_obj value;
int i, n;
if (vector)
GRN_OBJ_INIT(vector, GRN_VECTOR, 0, GRN_ID_NIL);
else
vector = grn_obj_open(context, GRN_VECTOR, 0, 0);
if (NIL_P(object))
return vector;
GRN_VOID_INIT(&value);
n = RARRAY_LEN(object);
values = RARRAY_PTR(object);
for (i = 0; i < n; i++) {
grn_obj *_value = &value;
RVAL2GRNOBJ(values[i], context, &_value);
grn_vector_add_element(context, vector,
GRN_BULK_HEAD(&value),
GRN_BULK_VSIZE(&value),
0,
value.header.domain);
}
GRN_OBJ_FIN(context, &value);
return vector;
}
static int
hash_element_to_vector_element(VALUE key, VALUE value, VALUE user_data)
{
HashElementToVectorElementData *data =
(HashElementToVectorElementData *)user_data;
unsigned int weight;
weight = NUM2UINT(value);
if (data->vector->header.type == GRN_UVECTOR) {
grn_id id = RVAL2GRNID(key, data->context, data->range, data->self);
grn_uvector_add_element(data->context, data->vector, id, weight);
} else {
GRN_BULK_REWIND(data->element_value);
RVAL2GRNBULK(key, data->context, data->element_value);
grn_vector_add_element(data->context, data->vector,
GRN_BULK_HEAD(data->element_value),
GRN_BULK_VSIZE(data->element_value),
weight,
data->element_value->header.domain);
}
return ST_CONTINUE;
}
static void
grn_token_cursor_open_initialize_token_filters(grn_ctx *ctx,
grn_token_cursor *token_cursor)
{
grn_obj *token_filters = token_cursor->token_filter.objects;
unsigned int i, n_token_filters;
token_cursor->token_filter.data = NULL;
if (token_filters) {
n_token_filters = GRN_BULK_VSIZE(token_filters) / sizeof(grn_obj *);
} else {
n_token_filters = 0;
}
if (n_token_filters == 0) {
return;
}
token_cursor->token_filter.data = GRN_MALLOCN(void *, n_token_filters);
if (!token_cursor->token_filter.data) {
return;
}
for (i = 0; i < n_token_filters; i++) {
grn_obj *token_filter_object = GRN_PTR_VALUE_AT(token_filters, i);
grn_proc *token_filter = (grn_proc *)token_filter_object;
token_cursor->token_filter.data[i] =
token_filter->callbacks.token_filter.init(ctx,
token_cursor->table,
token_cursor->mode);
}
}
static void
rb_grn_add_vector_element (VALUE rb_element, grn_ctx *context, grn_obj *vector,
grn_obj *value_buffer)
{
unsigned int weight = 0;
if (RVAL2CBOOL(rb_obj_is_kind_of(rb_element, rb_cHash))) {
VALUE rb_value;
VALUE rb_weight;
ID id_value;
ID id_weight;
CONST_ID(id_value, "value");
CONST_ID(id_weight, "weight");
rb_value = rb_hash_aref(rb_element, ID2SYM(id_value));
rb_weight = rb_hash_aref(rb_element, ID2SYM(id_weight));
RVAL2GRNOBJ(rb_value, context, &value_buffer);
if (!NIL_P(rb_weight)) {
weight = NUM2UINT(rb_weight);
}
} else {
RVAL2GRNOBJ(rb_element, context, &value_buffer);
}
grn_vector_add_element(context, vector,
GRN_BULK_HEAD(value_buffer),
GRN_BULK_VSIZE(value_buffer),
weight,
value_buffer->header.domain);
}
/*
* Extracts keywords from _expression_. The keywords order isn't
* guaranteed.
*
* @example
* expression.parse("Ruby OR Groonga")
* expression.keywords #=> ["Groonga", "Ruby"]
*
* @overload keywords
* @return [::Array<String>] the extracted keywords
*
* @since 4.0.6
*/
static VALUE
rb_grn_expression_get_keywords (VALUE self)
{
grn_ctx *context = NULL;
grn_obj *expression;
grn_obj keywords;
VALUE rb_keywords = rb_ary_new();
rb_grn_expression_deconstruct(SELF(self), &expression, &context,
NULL, NULL,
NULL, NULL, NULL);
GRN_PTR_INIT(&keywords, GRN_OBJ_VECTOR, GRN_ID_NIL);
grn_expr_get_keywords(context, expression, &keywords);
{
int i, n_keywords;
n_keywords = GRN_BULK_VSIZE(&keywords) / sizeof(grn_obj *);
for (i = 0; i < n_keywords; i++) {
grn_obj *keyword = GRN_PTR_VALUE_AT(&keywords, i);
rb_ary_push(rb_keywords,
GRNBULK2RVAL(context, keyword, NULL, self));
}
}
GRN_OBJ_FIN(context, &keywords);
return rb_keywords;
}
void
test_fix_size_set_value_increment(void)
{
gint32 count = 29;
gint32 increment_count = 5;
gint32 retrieved_count;
grn_obj *record_value;
grn_obj *retrieved_record_value;
record_value = grn_obj_open(context, GRN_BULK, 0, GRN_DB_INT32);
grn_bulk_write(context, record_value, (const char *)&count, sizeof(count));
grn_test_assert(grn_obj_set_value(context, count_column, groonga_bookmark_id,
record_value, GRN_OBJ_SET));
grn_obj_close(context, record_value);
record_value = grn_obj_open(context, GRN_BULK, 0, GRN_DB_INT32);
grn_bulk_write(context, record_value,
(const char *)&increment_count, sizeof(increment_count));
grn_test_assert(grn_obj_set_value(context, count_column, groonga_bookmark_id,
record_value, GRN_OBJ_INCR));
grn_obj_close(context, record_value);
retrieved_record_value = grn_obj_get_value(context, count_column,
groonga_bookmark_id, NULL);
memcpy(&retrieved_count,
GRN_BULK_HEAD(retrieved_record_value),
GRN_BULK_VSIZE(retrieved_record_value));
cut_assert_equal_int(count + increment_count, retrieved_count);
grn_obj_close(context, retrieved_record_value);
}
static grn_table_cursor *
rb_grn_patricia_trie_open_grn_near_cursor (int argc, VALUE *argv, VALUE self,
grn_ctx **context, int flags)
{
grn_obj *table;
grn_obj *key_p = NULL, casted_key;
grn_table_cursor *cursor;
unsigned min_size = 0;
int offset = 0, limit = -1;
VALUE options, rb_key, rb_min_size;
VALUE rb_greater_than, rb_less_than, rb_offset, rb_limit;
flags |= GRN_CURSOR_PREFIX;
rb_grn_table_deconstruct((RbGrnTable *)SELF(self), &table, context,
NULL, NULL,
NULL, NULL, NULL,
NULL);
rb_scan_args(argc, argv, "11", &rb_key, &options);
rb_grn_scan_options(options,
"size", &rb_min_size,
"offset", &rb_offset,
"limit", &rb_limit,
"greater_than", &rb_greater_than,
"less_than", &rb_less_than,
NULL);
key_p = RVAL2GRNBULK_WITH_TYPE(rb_key, *context, key_p,
table->header.domain, grn_ctx_at(*context, table->header.domain));
GRN_OBJ_INIT(&casted_key, GRN_BULK, 0, table->header.domain);
if (key_p->header.domain != table->header.domain) {
grn_obj_cast(*context, key_p, &casted_key, 0);
key_p = &casted_key;
}
if (!NIL_P(rb_min_size))
min_size = NUM2UINT(rb_min_size);
if (!NIL_P(rb_offset))
offset = NUM2INT(rb_offset);
if (!NIL_P(rb_limit))
limit = NUM2INT(rb_limit);
if (RVAL2CBOOL(rb_greater_than))
flags |= GRN_CURSOR_GT;
if (RVAL2CBOOL(rb_less_than))
flags |= GRN_CURSOR_LT;
cursor = grn_table_cursor_open(*context, table,
NULL, min_size,
GRN_BULK_HEAD(key_p), GRN_BULK_VSIZE(key_p),
offset, limit, flags);
GRN_OBJ_FIN(*context, &casted_key);
rb_grn_context_check(*context, self);
return cursor;
}
static int
grn_token_cursor_next_apply_token_filters(grn_ctx *ctx,
grn_token_cursor *token_cursor,
grn_obj *current_token_data,
grn_obj *status)
{
grn_obj *token_filters = token_cursor->token_filter.objects;
unsigned int i, n_token_filters;
grn_token current_token;
grn_token next_token;
if (token_filters) {
n_token_filters = GRN_BULK_VSIZE(token_filters) / sizeof(grn_obj *);
} else {
n_token_filters = 0;
}
GRN_TEXT_INIT(&(current_token.data), GRN_OBJ_DO_SHALLOW_COPY);
GRN_TEXT_SET(ctx, &(current_token.data),
GRN_TEXT_VALUE(current_token_data),
GRN_TEXT_LEN(current_token_data));
current_token.status = GRN_INT32_VALUE(status);
GRN_TEXT_INIT(&(next_token.data), GRN_OBJ_DO_SHALLOW_COPY);
GRN_TEXT_SET(ctx, &(next_token.data),
GRN_TEXT_VALUE(&(current_token.data)),
GRN_TEXT_LEN(&(current_token.data)));
next_token.status = current_token.status;
for (i = 0; i < n_token_filters; i++) {
grn_obj *token_filter_object = GRN_PTR_VALUE_AT(token_filters, i);
grn_proc *token_filter = (grn_proc *)token_filter_object;
void *data = token_cursor->token_filter.data[i];
#define SKIP_FLAGS\
(GRN_TOKEN_SKIP |\
GRN_TOKEN_SKIP_WITH_POSITION)
if (current_token.status & SKIP_FLAGS) {
break;
}
#undef SKIP_FLAGS
token_filter->callbacks.token_filter.filter(ctx,
¤t_token,
&next_token,
data);
GRN_TEXT_SET(ctx, &(current_token.data),
GRN_TEXT_VALUE(&(next_token.data)),
GRN_TEXT_LEN(&(next_token.data)));
current_token.status = next_token.status;
}
token_cursor->curr =
(const unsigned char *)GRN_TEXT_VALUE(&(current_token.data));
token_cursor->curr_size = GRN_TEXT_LEN(&(current_token.data));
return current_token.status;
}
static grn_rc
grn_ii_inspect(grn_ctx *ctx, grn_obj *buf, grn_obj *obj)
{
grn_obj sources;
int i, n, have_flags = 0;
grn_id *source_ids;
GRN_TEXT_PUTS(ctx, buf, "#<column:index ");
grn_column_inspect_common(ctx, buf, obj);
GRN_TEXT_INIT(&sources, 0);
grn_obj_get_info(ctx, obj, GRN_INFO_SOURCE, &sources);
source_ids = (grn_id *)GRN_BULK_HEAD(&sources);
n = GRN_BULK_VSIZE(&sources) / sizeof(grn_id);
GRN_TEXT_PUTS(ctx, buf, " sources:[");
for (i = 0; i < n; i++) {
grn_id source_id;
grn_obj *source;
if (i) { GRN_TEXT_PUTS(ctx, buf, ", "); }
source_id = source_ids[i];
source = grn_ctx_at(ctx, source_id);
if (source) {
grn_inspect_name(ctx, buf, source);
} else {
grn_text_lltoa(ctx, buf, source_id);
}
}
GRN_TEXT_PUTS(ctx, buf, "]");
GRN_OBJ_FIN(ctx, &sources);
GRN_TEXT_PUTS(ctx, buf, " flags:");
if (obj->header.flags & GRN_OBJ_WITH_SECTION) {
GRN_TEXT_PUTS(ctx, buf, "SECTION");
have_flags = 1;
}
if (obj->header.flags & GRN_OBJ_WITH_WEIGHT) {
if (have_flags) { GRN_TEXT_PUTS(ctx, buf, "|"); }
GRN_TEXT_PUTS(ctx, buf, "WEIGHT");
have_flags = 1;
}
if (obj->header.flags & GRN_OBJ_WITH_POSITION) {
if (have_flags) { GRN_TEXT_PUTS(ctx, buf, "|"); }
GRN_TEXT_PUTS(ctx, buf, "POSITION");
have_flags = 1;
}
if (!have_flags) {
GRN_TEXT_PUTS(ctx, buf, "NONE");
}
GRN_TEXT_PUTS(ctx, buf, " elements:");
grn_ii_inspect_elements(ctx, (grn_ii *)obj, buf);
GRN_TEXT_PUTS(ctx, buf, ">");
return GRN_SUCCESS;
}
void
test_uvector_column(gconstpointer data)
{
const gchar *expected;
grn_id id, type_id;
grn_obj uvector;
grn_obj *elements;
grn_obj *table, *column;
const gchar *type_name;
type_name = gcut_data_get_string(data, "type_name");
type_id = grn_obj_id(context, get_object(type_name));
table = table_create("Table", GRN_OBJ_TABLE_NO_KEY, NULL, NULL);
grn_test_assert_context(context);
column = column_create("Table", "Column", GRN_OBJ_COLUMN_VECTOR,
type_name, NULL);
grn_test_assert_context(context);
id = grn_table_add(context, table, NULL, 0, NULL);
grn_test_assert_context(context);
cut_assert_equal_int(1, id);
elements = construct_elements(data);
GRN_OBJ_INIT(&uvector, GRN_UVECTOR, 0, type_id);
grn_bulk_write(context, &uvector,
GRN_BULK_HEAD(&elements[0]), GRN_BULK_VSIZE(&elements[0]));
grn_bulk_write(context, &uvector,
GRN_BULK_HEAD(&elements[1]), GRN_BULK_VSIZE(&elements[1]));
grn_bulk_write(context, &uvector,
GRN_BULK_HEAD(&elements[2]), GRN_BULK_VSIZE(&elements[2]));
grn_obj_set_value(context, column, id, &uvector, GRN_OBJ_SET);
expected = cut_take_printf("table_create Table TABLE_NO_KEY\n"
"column_create Table Column COLUMN_VECTOR %s\n"
"load --table Table\n"
"[\n"
"[\"_id\",\"Column\"],\n"
"[1,%s]\n"
"]",
type_name,
gcut_data_get_string(data, "expected"));
cut_assert_equal_string(expected, send_command("dump"));
GRN_OBJ_FIN(context, &uvector);
}
int
column_get(void)
{
int i, s = 0;
grn_obj buf;
grn_obj *table = grn_ctx_get(&ctx, "<t1>", 4);
grn_obj *column = grn_ctx_get(&ctx, "<t1>.c1", 7);
if (!table || !column) { return -1; }
GRN_TEXT_INIT(&buf, 0);
for (i = 0; i < nloops; i++) {
int key = GENKEY(i);
GRN_BULK_REWIND(&buf);
grn_text_itoh(&ctx, &buf, key, key_size);
{
grn_id rid = grn_table_get(&ctx, table, GRN_BULK_HEAD(&buf), key_size);
if (!rid) {
fprintf(stderr, "table_lookup failed\n");
} else {
grn_obj obj, *p;
unsigned int v = key % value_size;
GRN_TEXT_INIT(&obj, 0);
p = grn_obj_get_value(&ctx, column, rid, &obj);
if (!p) {
fprintf(stderr, "grn_obj_get_value failed\n");
} else {
if (GRN_BULK_VSIZE(p) != v) {
fprintf(stderr, "value_size unmatch %d (%ld:%u)\n", i, GRN_BULK_VSIZE(p), v);
} else {
if (v && GRN_BULK_HEAD(p)[v-1] != GRN_BULK_HEAD(&buf)[0]) {
fprintf(stderr, "value unmatch\n");
} else {
s++;
}
}
grn_obj_close(&ctx, p);
}
}
}
}
grn_obj_close(&ctx, &buf);
if (i != s) { printf("successed: %d\n", s); }
return 0;
}
void
test_text_to_table(gconstpointer data)
{
gsize expected_size;
grn_obj_reinit(&context, &dest, users, 0);
expected_size = gcut_data_get_size(data, "expected-size");
if (expected_size == 0) {
cast_text(GRN_INVALID_ARGUMENT, gcut_data_get_string(data, "text"));
cut_assert_equal_uint(0, GRN_BULK_VSIZE(&dest));
} else {
cast_text(GRN_SUCCESS, gcut_data_get_string(data, "text"));
grn_test_assert_equal_record_id(&context,
grn_ctx_at(&context, users),
gcut_data_get_uint(data, "expected"),
GRN_RECORD_VALUE(&dest));
cut_assert_equal_uint(expected_size, GRN_BULK_VSIZE(&dest));
}
}
static void
command_schema_column_output_sources(grn_ctx *ctx, grn_obj *column)
{
grn_obj *source_table;
grn_obj source_ids;
unsigned int i, n_ids;
source_table = grn_ctx_at(ctx, grn_obj_get_range(ctx, column));
GRN_RECORD_INIT(&source_ids, GRN_OBJ_VECTOR, GRN_ID_NIL);
if (column->header.type == GRN_COLUMN_INDEX) {
grn_obj_get_info(ctx, column, GRN_INFO_SOURCE, &source_ids);
}
n_ids = GRN_BULK_VSIZE(&source_ids) / sizeof(grn_id);
grn_ctx_output_array_open(ctx, "sources", n_ids);
for (i = 0; i < n_ids; i++) {
grn_id source_id;
grn_obj *source;
source_id = GRN_RECORD_VALUE_AT(&source_ids, i);
source = grn_ctx_at(ctx, source_id);
grn_ctx_output_map_open(ctx, "source", 3);
grn_ctx_output_cstr(ctx, "name");
if (grn_obj_is_table(ctx, source)) {
grn_ctx_output_cstr(ctx, "_key");
} else {
command_schema_output_column_name(ctx, source);
}
grn_ctx_output_cstr(ctx, "table");
command_schema_output_name(ctx, source_table);
grn_ctx_output_cstr(ctx, "full_name");
if (grn_obj_is_table(ctx, source)) {
char name[GRN_TABLE_MAX_KEY_SIZE];
unsigned int name_size;
name_size = grn_obj_name(ctx, source, name, GRN_TABLE_MAX_KEY_SIZE);
name[name_size] = '\0';
grn_strcat(name, GRN_TABLE_MAX_KEY_SIZE, "._key");
grn_ctx_output_cstr(ctx, name);
} else {
command_schema_output_name(ctx, source);
}
grn_ctx_output_map_close(ctx);
}
grn_ctx_output_array_close(ctx);
GRN_OBJ_FIN(ctx, &source_ids);
}
static grn_obj *
proc_column_create(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data)
{
uint32_t nvars;
grn_obj *buf = args[0];
grn_expr_var *vars;
grn_proc_get_info(ctx, user_data, &vars, &nvars, NULL);
if (nvars == 6) {
grn_obj_flags flags = grn_atoi(GRN_TEXT_VALUE(&vars[2].value),
GRN_BULK_CURR(&vars[2].value), NULL);
grn_obj *column, *table = grn_ctx_get(ctx, GRN_TEXT_VALUE(&vars[0].value),
GRN_TEXT_LEN(&vars[0].value));
grn_obj *type = grn_ctx_get(ctx, GRN_TEXT_VALUE(&vars[3].value),
GRN_TEXT_LEN(&vars[3].value));
if (GRN_TEXT_LEN(&vars[1].value)) {
flags |= GRN_OBJ_PERSISTENT;
}
column = grn_column_create(ctx, table,
GRN_TEXT_VALUE(&vars[1].value),
GRN_TEXT_LEN(&vars[1].value),
NULL, flags, type);
if (column) {
if (GRN_TEXT_LEN(&vars[4].value)) {
grn_obj sources, source_ids, **p, **pe;
GRN_PTR_INIT(&sources, GRN_OBJ_VECTOR, GRN_ID_NIL);
GRN_UINT32_INIT(&source_ids, GRN_OBJ_VECTOR);
grn_obj_columns(ctx, type,
GRN_TEXT_VALUE(&vars[4].value),
GRN_TEXT_LEN(&vars[4].value),
&sources);
p = (grn_obj **)GRN_BULK_HEAD(&sources);
pe = (grn_obj **)GRN_BULK_CURR(&sources);
while (p < pe) {
grn_id source_id = grn_obj_id(ctx, *p++);
if (source_id) {
GRN_UINT32_PUT(ctx, &source_ids, source_id);
}
}
if (GRN_BULK_VSIZE(&source_ids)) {
grn_obj_set_info(ctx, column, GRN_INFO_SOURCE, &source_ids);
}
GRN_OBJ_FIN(ctx, &source_ids);
GRN_OBJ_FIN(ctx, &sources);
}
grn_obj_unlink(ctx, column);
}
GRN_TEXT_PUTS(ctx, buf, ctx->rc ? "false" : "true");
}
return buf;
}
static void
output_tokens(grn_ctx *ctx, grn_obj *tokens, grn_obj *lexicon, grn_obj *index_column)
{
int i, n_tokens, n_elements;
grn_obj estimated_size;
n_tokens = GRN_BULK_VSIZE(tokens) / sizeof(tokenize_token);
n_elements = 3;
if (index_column) {
n_elements++;
GRN_UINT32_INIT(&estimated_size, 0);
}
grn_ctx_output_array_open(ctx, "TOKENS", n_tokens);
for (i = 0; i < n_tokens; i++) {
tokenize_token *token;
char value[GRN_TABLE_MAX_KEY_SIZE];
unsigned int value_size;
token = ((tokenize_token *)(GRN_BULK_HEAD(tokens))) + i;
grn_ctx_output_map_open(ctx, "TOKEN", n_elements);
grn_ctx_output_cstr(ctx, "value");
value_size = grn_table_get_key(ctx, lexicon, token->id,
value, GRN_TABLE_MAX_KEY_SIZE);
grn_ctx_output_str(ctx, value, value_size);
grn_ctx_output_cstr(ctx, "position");
grn_ctx_output_int32(ctx, token->position);
grn_ctx_output_cstr(ctx, "force_prefix");
grn_ctx_output_bool(ctx, token->force_prefix);
if (index_column) {
GRN_BULK_REWIND(&estimated_size);
grn_obj_get_value(ctx, index_column, token->id, &estimated_size);
grn_ctx_output_cstr(ctx, "estimated_size");
grn_ctx_output_int64(ctx, GRN_UINT32_VALUE(&estimated_size));
}
grn_ctx_output_map_close(ctx);
}
if (index_column) {
GRN_OBJ_FIN(ctx, &estimated_size);
}
grn_ctx_output_array_close(ctx);
}
static void
msg_handler(grn_ctx *ctx, grn_obj *msg)
{
uint32_t etime;
struct timeval tv;
grn_msg *m = (grn_msg *)msg;
grn_com *com = ((grn_msg *)msg)->peer;
session *s = com->opaque;
s->stat = 3;
gettimeofday(&tv, NULL);
etime = (tv.tv_sec - s->tv.tv_sec) * 1000000 + (tv.tv_usec - s->tv.tv_usec);
if (etime > etime_max) {
etime_max = etime;
}
if (etime < etime_min) {
etime_min = etime;
}
if (ctx->rc) {
m->header.proto = 0;
}
switch (m->header.proto) {
case GRN_COM_PROTO_GQTP :
if (GRN_BULK_VSIZE(msg) == 2) {
etime_amount += etime;
} else {
if (verbose) {
GRN_TEXT_PUTC(ctx, msg, '\0');
lprint(ctx, "%8d(%4d) %8d : %s", s->query_id, s->n_sessions, etime, GRN_BULK_HEAD(msg));
}
}
if ((m->header.flags & GRN_CTX_TAIL)) {
grn_com_queue_enque(ctx, &fsessions, (grn_com_queue_entry *)s);
nrecv++;
}
break;
case GRN_COM_PROTO_HTTP :
nrecv++;
/* lprint(ctx, "recv: %d, %d", (int)GRN_BULK_VSIZE(msg), nrecv); */
grn_com_close_(ctx, com);
grn_com_queue_enque(ctx, &fsessions, (grn_com_queue_entry *)s);
break;
default :
grn_com_close_(ctx, com);
grn_com_queue_enque(ctx, &fsessions, (grn_com_queue_entry *)s);
break;
}
grn_msg_close(ctx, msg);
}
static grn_obj *
proc_column_list(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data)
{
uint32_t nvars;
grn_obj *buf = args[0];
grn_expr_var *vars;
grn_proc_get_info(ctx, user_data, &vars, &nvars, NULL);
if (nvars == 2) {
grn_obj *table;
grn_content_type otype = GET_OTYPE(&vars[1].value);
if ((table = grn_ctx_get(ctx, GRN_TEXT_VALUE(&vars[0].value),
GRN_TEXT_LEN(&vars[0].value)))) {
grn_hash *cols;
if ((cols = grn_hash_create(ctx, NULL, sizeof(grn_id), 0,
GRN_OBJ_TABLE_HASH_KEY|GRN_HASH_TINY))) {
if (grn_table_columns(ctx, table, NULL, 0, (grn_obj *)cols) >= 0) {
grn_id *key;
char line_delimiter, column_delimiter;
switch (otype) {
case GRN_CONTENT_TSV:
line_delimiter = '\n';
column_delimiter = '\t';
GRN_TEXT_PUTS(ctx, buf, "id\tname\tpath\ttype\tflags\tdomain");
break;
case GRN_CONTENT_JSON:
line_delimiter = ',';
column_delimiter = ',';
GRN_TEXT_PUTS(ctx, buf, "[[\"id\",\"name\",\"path\",\"type\",\"flags\",\"domain\"]");
break;
}
GRN_HASH_EACH(ctx, cols, id, &key, NULL, NULL, {
grn_obj *col;
if ((col = grn_ctx_at(ctx, *key))) {
GRN_TEXT_PUTC(ctx, buf, line_delimiter);
if (!print_columninfo(ctx, col, buf, otype)) {
grn_bulk_truncate(ctx, buf, GRN_BULK_VSIZE(buf) - 1);
}
grn_obj_unlink(ctx, col);
}
});
if (otype == GRN_CONTENT_JSON) {
GRN_TEXT_PUTC(ctx, buf, ']');
}
}
static grn_obj *
func_highlight_html_create_keywords_table(grn_ctx *ctx, grn_obj *expression)
{
grn_obj *keywords;
grn_obj *condition_ptr = NULL;
grn_obj *condition = NULL;
keywords = grn_table_create(ctx, NULL, 0, NULL,
GRN_OBJ_TABLE_PAT_KEY,
grn_ctx_at(ctx, GRN_DB_SHORT_TEXT),
NULL);
{
grn_obj *normalizer;
normalizer = grn_ctx_get(ctx, "NormalizerAuto", -1);
grn_obj_set_info(ctx, keywords, GRN_INFO_NORMALIZER, normalizer);
grn_obj_unlink(ctx, normalizer);
}
condition_ptr = grn_expr_get_var(ctx, expression,
GRN_SELECT_INTERNAL_VAR_CONDITION,
strlen(GRN_SELECT_INTERNAL_VAR_CONDITION));
if (condition_ptr) {
condition = GRN_PTR_VALUE(condition_ptr);
}
if (condition) {
size_t i, n_keywords;
grn_obj current_keywords;
GRN_PTR_INIT(¤t_keywords, GRN_OBJ_VECTOR, GRN_ID_NIL);
grn_expr_get_keywords(ctx, condition, ¤t_keywords);
n_keywords = GRN_BULK_VSIZE(¤t_keywords) / sizeof(grn_obj *);
for (i = 0; i < n_keywords; i++) {
grn_obj *keyword;
keyword = GRN_PTR_VALUE_AT(¤t_keywords, i);
grn_table_add(ctx, keywords,
GRN_TEXT_VALUE(keyword),
GRN_TEXT_LEN(keyword),
NULL);
}
grn_obj_unlink(ctx, ¤t_keywords);
}
return keywords;
}
void
grn_ctx_loader_clear(grn_ctx *ctx)
{
grn_loader *loader = &ctx->impl->loader;
grn_obj *v = (grn_obj *)(GRN_BULK_HEAD(&loader->values));
grn_obj *ve = (grn_obj *)(GRN_BULK_CURR(&loader->values));
grn_obj **p = (grn_obj **)GRN_BULK_HEAD(&loader->columns);
uint32_t i = GRN_BULK_VSIZE(&loader->columns) / sizeof(grn_obj *);
if (ctx->impl->db) { while (i--) { grn_obj_unlink(ctx, *p++); } }
if (loader->ifexists) { grn_obj_unlink(ctx, loader->ifexists); }
if (loader->each) { grn_obj_unlink(ctx, loader->each); }
while (v < ve) { GRN_OBJ_FIN(ctx, v++); }
GRN_OBJ_FIN(ctx, &loader->values);
GRN_OBJ_FIN(ctx, &loader->level);
GRN_OBJ_FIN(ctx, &loader->columns);
grn_loader_init(loader);
}
