static grn_bool
exec_match_uvector_bulk(grn_ctx *ctx, grn_obj *uvector, grn_obj *query)
{
grn_bool matched = GRN_FALSE;
unsigned int i, size;
grn_obj element;
unsigned int element_size;
size = grn_uvector_size(ctx, uvector);
element_size = grn_uvector_element_size(ctx, uvector);
GRN_VALUE_FIX_SIZE_INIT(&element, 0, uvector->header.domain);
for (i = 0; i < size; i++) {
GRN_BULK_REWIND(&element);
grn_bulk_write(ctx, &element,
GRN_BULK_HEAD(uvector) + (element_size * i),
element_size);
if (grn_operator_exec_equal(ctx, &element, query)) {
matched = GRN_TRUE;
break;
}
}
GRN_OBJ_FIN(ctx, &element);
return matched;
}
/*
* @overload initialize(column)
* @param column [Groonga::Column] The column to be cached.
*
* @return [Groonga::ColumnCache] Create a new column cache.
*/
static VALUE
rb_grn_column_cache_initialize (VALUE self, VALUE rb_column)
{
RbGrnColumnCache *rb_grn_column_cache;
grn_ctx *context;
grn_obj *column;
grn_id range_id;
rb_grn_column_cache = ALLOC(RbGrnColumnCache);
rb_grn_column_cache->self = self;
rb_grn_column_cache->context = NULL;
rb_grn_column_cache->rb_column = rb_column;
rb_grn_column_cache->column_cache = NULL;
DATA_PTR(self) = rb_grn_column_cache;
column = RVAL2GRNCOLUMN(rb_column, &(rb_grn_column_cache->context));
context = rb_grn_column_cache->context;
rb_grn_column_cache->column_cache = grn_column_cache_open(context, column);
if (!rb_grn_column_cache->column_cache) {
rb_raise(rb_eArgError,
"failed to create column cache: %s%s%" PRIsVALUE,
context->rc == GRN_SUCCESS ? "" : context->errbuf,
context->rc == GRN_SUCCESS ? "" : ": ",
rb_column);
}
range_id = grn_obj_get_range(context, column);
GRN_VALUE_FIX_SIZE_INIT(&(rb_grn_column_cache->buffer),
GRN_OBJ_DO_SHALLOW_COPY,
range_id);
rb_grn_column_cache->range = grn_ctx_at(context, range_id);
rb_grn_column_cache->table = grn_ctx_at(context, column->header.domain);
return Qnil;
}
static grn_obj *
func_time_classify_raw(grn_ctx *ctx,
int n_args,
grn_obj **args,
grn_user_data *user_data,
const char *function_name,
grn_time_classify_unit unit)
{
grn_obj *time;
uint32_t interval_raw = 1;
grn_obj *classed_time;
grn_bool accept_interval = GRN_TRUE;
switch (unit) {
case GRN_TIME_CLASSIFY_UNIT_SECOND :
case GRN_TIME_CLASSIFY_UNIT_MINUTE :
case GRN_TIME_CLASSIFY_UNIT_HOUR :
accept_interval = GRN_TRUE;
break;
case GRN_TIME_CLASSIFY_UNIT_DAY :
case GRN_TIME_CLASSIFY_UNIT_WEEK :
accept_interval = GRN_FALSE;
break;
case GRN_TIME_CLASSIFY_UNIT_MONTH :
case GRN_TIME_CLASSIFY_UNIT_YEAR :
accept_interval = GRN_TRUE;
break;
}
if (accept_interval) {
if (!(n_args == 1 || n_args == 2)) {
GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT,
"%s(): "
"wrong number of arguments (%d for 1..2)",
function_name,
n_args);
return NULL;
}
} else {
if (n_args != 1) {
GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT,
"%s(): "
"wrong number of arguments (%d for 1)",
function_name,
n_args);
return NULL;
}
}
time = args[0];
if (!(time->header.type == GRN_BULK &&
time->header.domain == GRN_DB_TIME)) {
grn_obj inspected;
GRN_TEXT_INIT(&inspected, 0);
grn_inspect(ctx, &inspected, time);
GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT,
"%s(): "
"the first argument must be a time: "
"<%.*s>",
function_name,
(int)GRN_TEXT_LEN(&inspected),
GRN_TEXT_VALUE(&inspected));
GRN_OBJ_FIN(ctx, &inspected);
return NULL;
}
if (n_args == 2) {
grn_obj *interval;
grn_obj casted_interval;
interval = args[1];
if (!(interval->header.type == GRN_BULK &&
grn_type_id_is_number_family(ctx, interval->header.domain))) {
grn_obj inspected;
GRN_TEXT_INIT(&inspected, 0);
grn_inspect(ctx, &inspected, interval);
GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT,
"%s(): "
"the second argument must be a number: "
"<%.*s>",
function_name,
(int)GRN_TEXT_LEN(&inspected),
GRN_TEXT_VALUE(&inspected));
GRN_OBJ_FIN(ctx, &inspected);
return NULL;
}
GRN_VALUE_FIX_SIZE_INIT(&casted_interval, 0, GRN_DB_UINT32);
grn_obj_cast(ctx, interval, &casted_interval, GRN_FALSE);
interval_raw = GRN_UINT32_VALUE(&casted_interval);
GRN_OBJ_FIN(ctx, &casted_interval);
}
{
int64_t time_raw;
struct tm tm;
int64_t classed_time_raw;
time_raw = GRN_TIME_VALUE(time);
if (!grn_time_to_tm(ctx, time_raw, &tm)) {
return NULL;
}
switch (unit) {
case GRN_TIME_CLASSIFY_UNIT_SECOND :
tm.tm_sec = (tm.tm_sec / interval_raw) * interval_raw;
break;
case GRN_TIME_CLASSIFY_UNIT_MINUTE :
tm.tm_min = (tm.tm_min / interval_raw) * interval_raw;
tm.tm_sec = 0;
break;
case GRN_TIME_CLASSIFY_UNIT_HOUR :
tm.tm_hour = (tm.tm_hour / interval_raw) * interval_raw;
tm.tm_min = 0;
tm.tm_sec = 0;
break;
case GRN_TIME_CLASSIFY_UNIT_DAY :
tm.tm_hour = 0;
tm.tm_min = 0;
tm.tm_sec = 0;
break;
case GRN_TIME_CLASSIFY_UNIT_WEEK :
if ((tm.tm_mday - tm.tm_wday) >= 0) {
tm.tm_mday -= tm.tm_wday;
} else {
int n_underflowed_mday = -(tm.tm_mday - tm.tm_wday);
int mday;
int max_mday = 31;
if (tm.tm_mon == 0) {
tm.tm_year--;
tm.tm_mon = 11;
} else {
tm.tm_mon--;
}
for (mday = max_mday; mday > n_underflowed_mday; mday--) {
int64_t unused;
tm.tm_mday = mday;
if (grn_time_from_tm(ctx, &unused, &tm)) {
break;
}
}
tm.tm_mday -= n_underflowed_mday;
}
tm.tm_hour = 0;
tm.tm_min = 0;
tm.tm_sec = 0;
break;
case GRN_TIME_CLASSIFY_UNIT_MONTH :
tm.tm_mon = (tm.tm_mon / interval_raw) * interval_raw;
tm.tm_mday = 1;
tm.tm_hour = 0;
tm.tm_min = 0;
tm.tm_sec = 0;
break;
case GRN_TIME_CLASSIFY_UNIT_YEAR :
tm.tm_year = (((1900 + tm.tm_year) / interval_raw) * interval_raw) - 1900;
tm.tm_mon = 0;
tm.tm_mday = 1;
tm.tm_hour = 0;
tm.tm_min = 0;
tm.tm_sec = 0;
break;
}
if (!grn_time_from_tm(ctx, &classed_time_raw, &tm)) {
return NULL;
}
classed_time = grn_plugin_proc_alloc(ctx,
user_data,
time->header.domain,
0);
if (!classed_time) {
return NULL;
}
GRN_TIME_SET(ctx, classed_time, classed_time_raw);
return classed_time;
}
}
static void
set_vector(grn_ctx *ctx, grn_obj *column, grn_id id, grn_obj *vector)
{
int n = GRN_UINT32_VALUE(vector);
grn_obj buf, *v = vector + 1;
grn_id range_id;
grn_obj *range;
range_id = DB_OBJ(column)->range;
range = grn_ctx_at(ctx, range_id);
if (grn_obj_is_table(ctx, range)) {
GRN_RECORD_INIT(&buf, GRN_OBJ_VECTOR, range_id);
while (n--) {
grn_bool cast_failed = GRN_FALSE;
grn_obj record, *element = v;
if (range_id != element->header.domain) {
GRN_RECORD_INIT(&record, 0, range_id);
if (grn_obj_cast(ctx, element, &record, GRN_TRUE)) {
cast_failed = GRN_TRUE;
ERR_CAST(column, range, element);
}
element = &record;
}
if (!cast_failed) {
GRN_UINT32_PUT(ctx, &buf, GRN_RECORD_VALUE(element));
}
if (element == &record) { GRN_OBJ_FIN(ctx, element); }
v = values_next(ctx, v);
}
} else {
if (((struct _grn_type *)range)->obj.header.flags & GRN_OBJ_KEY_VAR_SIZE) {
GRN_TEXT_INIT(&buf, GRN_OBJ_VECTOR);
while (n--) {
switch (v->header.domain) {
case GRN_DB_TEXT :
{
grn_bool cast_failed = GRN_FALSE;
grn_obj casted_element, *element = v;
if (range_id != element->header.domain) {
GRN_OBJ_INIT(&casted_element, GRN_BULK, 0, range_id);
if (grn_obj_cast(ctx, element, &casted_element, GRN_TRUE)) {
cast_failed = GRN_TRUE;
ERR_CAST(column, range, element);
}
element = &casted_element;
}
if (!cast_failed) {
grn_vector_add_element(ctx, &buf,
GRN_TEXT_VALUE(element),
GRN_TEXT_LEN(element),
0,
element->header.domain);
}
if (element == &casted_element) { GRN_OBJ_FIN(ctx, element); }
break;
}
case GRN_JSON_LOAD_OPEN_BRACE :
add_weight_vector(ctx, column, v, &buf);
n -= GRN_UINT32_VALUE(v);
break;
default :
ERR(GRN_INVALID_ARGUMENT, "array must contain string or object");
break;
}
v = values_next(ctx, v);
}
} else {
grn_id value_size = ((grn_db_obj *)range)->range;
GRN_VALUE_FIX_SIZE_INIT(&buf, GRN_OBJ_VECTOR, range_id);
while (n--) {
grn_bool cast_failed = GRN_FALSE;
grn_obj casted_element, *element = v;
if (range_id != element->header.domain) {
GRN_OBJ_INIT(&casted_element, GRN_BULK, 0, range_id);
if (grn_obj_cast(ctx, element, &casted_element, GRN_TRUE)) {
cast_failed = GRN_TRUE;
ERR_CAST(column, range, element);
}
element = &casted_element;
}
if (!cast_failed) {
grn_bulk_write(ctx, &buf, GRN_TEXT_VALUE(element), value_size);
}
if (element == &casted_element) { GRN_OBJ_FIN(ctx, element); }
v = values_next(ctx, v);
}
}
}
grn_obj_set_value(ctx, column, id, &buf, GRN_OBJ_SET);
GRN_OBJ_FIN(ctx, &buf);
}
static grn_obj *
command_tokenize(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data)
{
grn_obj *tokenizer_name;
grn_obj *string;
grn_obj *normalizer_name;
grn_obj *flag_names;
grn_obj *mode_name;
grn_obj *token_filter_names;
tokenizer_name = grn_plugin_proc_get_var(ctx, user_data, "tokenizer", -1);
string = grn_plugin_proc_get_var(ctx, user_data, "string", -1);
normalizer_name = grn_plugin_proc_get_var(ctx, user_data, "normalizer", -1);
flag_names = grn_plugin_proc_get_var(ctx, user_data, "flags", -1);
mode_name = grn_plugin_proc_get_var(ctx, user_data, "mode", -1);
token_filter_names = grn_plugin_proc_get_var(ctx, user_data, "token_filters", -1);
if (GRN_TEXT_LEN(tokenizer_name) == 0) {
GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT, "[tokenize] tokenizer name is missing");
return NULL;
}
if (GRN_TEXT_LEN(string) == 0) {
GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT, "[tokenize] string is missing");
return NULL;
}
{
unsigned int flags;
grn_obj *lexicon;
flags = parse_tokenize_flags(ctx, flag_names);
if (ctx->rc != GRN_SUCCESS) {
return NULL;
}
lexicon = create_lexicon_for_tokenize(ctx,
tokenizer_name,
normalizer_name,
token_filter_names);
if (!lexicon) {
return NULL;
}
#define MODE_NAME_EQUAL(name)\
(GRN_TEXT_LEN(mode_name) == strlen(name) &&\
memcmp(GRN_TEXT_VALUE(mode_name), name, strlen(name)) == 0)
{
grn_obj tokens;
GRN_VALUE_FIX_SIZE_INIT(&tokens, GRN_OBJ_VECTOR, GRN_ID_NIL);
if (GRN_TEXT_LEN(mode_name) == 0 || MODE_NAME_EQUAL("ADD")) {
tokenize(ctx, lexicon, string, GRN_TOKEN_ADD, flags, &tokens);
output_tokens(ctx, &tokens, lexicon, NULL);
} else if (MODE_NAME_EQUAL("GET")) {
tokenize(ctx, lexicon, string, GRN_TOKEN_ADD, flags, &tokens);
GRN_BULK_REWIND(&tokens);
tokenize(ctx, lexicon, string, GRN_TOKEN_GET, flags, &tokens);
output_tokens(ctx, &tokens, lexicon, NULL);
} else {
GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT,
"[tokenize] invalid mode: <%.*s>",
(int)GRN_TEXT_LEN(mode_name), GRN_TEXT_VALUE(mode_name));
}
GRN_OBJ_FIN(ctx, &tokens);
}
#undef MODE_NAME_EQUAL
grn_obj_unlink(ctx, lexicon);
}
return NULL;
}
static grn_obj *
command_table_tokenize(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data)
{
grn_obj *table_name;
grn_obj *string;
grn_obj *flag_names;
grn_obj *mode_name;
grn_obj *index_column_name;
table_name = grn_plugin_proc_get_var(ctx, user_data, "table", -1);
string = grn_plugin_proc_get_var(ctx, user_data, "string", -1);
flag_names = grn_plugin_proc_get_var(ctx, user_data, "flags", -1);
mode_name = grn_plugin_proc_get_var(ctx, user_data, "mode", -1);
index_column_name = grn_plugin_proc_get_var(ctx, user_data, "index_column", -1);
if (GRN_TEXT_LEN(table_name) == 0) {
GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT, "[table_tokenize] table name is missing");
return NULL;
}
if (GRN_TEXT_LEN(string) == 0) {
GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT, "[table_tokenize] string is missing");
return NULL;
}
{
unsigned int flags;
grn_obj *lexicon;
grn_obj *index_column = NULL;
flags = parse_tokenize_flags(ctx, flag_names);
if (ctx->rc != GRN_SUCCESS) {
return NULL;
}
lexicon = grn_ctx_get(ctx, GRN_TEXT_VALUE(table_name), GRN_TEXT_LEN(table_name));
if (!lexicon) {
return NULL;
}
#define MODE_NAME_EQUAL(name)\
(GRN_TEXT_LEN(mode_name) == strlen(name) &&\
memcmp(GRN_TEXT_VALUE(mode_name), name, strlen(name)) == 0)
if (GRN_TEXT_LEN(index_column_name) > 0) {
index_column = grn_obj_column(ctx, lexicon,
GRN_TEXT_VALUE(index_column_name),
GRN_TEXT_LEN(index_column_name));
if (!index_column) {
GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT,
"[table_tokenize] nonexistent index column: <%.*s>",
(int)GRN_TEXT_LEN(index_column_name),
GRN_TEXT_VALUE(index_column_name));
goto exit;
}
if (index_column->header.type != GRN_COLUMN_INDEX) {
GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT,
"[table_tokenize] index column must be COLUMN_INDEX: <%.*s>",
(int)GRN_TEXT_LEN(index_column_name),
GRN_TEXT_VALUE(index_column_name));
goto exit;
}
}
{
grn_obj tokens;
GRN_VALUE_FIX_SIZE_INIT(&tokens, GRN_OBJ_VECTOR, GRN_ID_NIL);
if (GRN_TEXT_LEN(mode_name) == 0 || MODE_NAME_EQUAL("GET")) {
tokenize(ctx, lexicon, string, GRN_TOKEN_GET, flags, &tokens);
output_tokens(ctx, &tokens, lexicon, index_column);
} else if (MODE_NAME_EQUAL("ADD")) {
tokenize(ctx, lexicon, string, GRN_TOKEN_ADD, flags, &tokens);
output_tokens(ctx, &tokens, lexicon, index_column);
} else {
GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT,
"[table_tokenize] invalid mode: <%.*s>",
(int)GRN_TEXT_LEN(mode_name), GRN_TEXT_VALUE(mode_name));
}
GRN_OBJ_FIN(ctx, &tokens);
}
#undef MODE_NAME_EQUAL
exit:
grn_obj_unlink(ctx, lexicon);
if (index_column) {
grn_obj_unlink(ctx, index_column);
}
}
return NULL;
}
static grn_obj *
command_tokenize(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data)
{
grn_raw_string tokenizer_raw;
grn_raw_string string_raw;
grn_raw_string normalizer_raw;
grn_raw_string flags_raw;
grn_raw_string mode_raw;
grn_raw_string token_filters_raw;
#define GET_VALUE(name) \
name ## _raw.value = \
grn_plugin_proc_get_var_string(ctx, \
user_data, \
#name, \
strlen(#name), \
&(name ## _raw.length))
GET_VALUE(tokenizer);
GET_VALUE(string);
GET_VALUE(normalizer);
GET_VALUE(flags);
GET_VALUE(mode);
GET_VALUE(token_filters);
#undef GET_VALUE
if (tokenizer_raw.length == 0) {
GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT, "[tokenize] tokenizer name is missing");
return NULL;
}
if (string_raw.length == 0) {
GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT, "[tokenize] string is missing");
return NULL;
}
{
unsigned int flags;
grn_obj *lexicon;
flags = parse_tokenize_flags(ctx, &flags_raw);
if (ctx->rc != GRN_SUCCESS) {
return NULL;
}
lexicon = create_lexicon_for_tokenize(ctx,
&tokenizer_raw,
&normalizer_raw,
&token_filters_raw);
if (!lexicon) {
return NULL;
}
{
grn_obj tokens;
GRN_VALUE_FIX_SIZE_INIT(&tokens, GRN_OBJ_VECTOR, GRN_ID_NIL);
if (mode_raw.length == 0 ||
GRN_RAW_STRING_EQUAL_CSTRING(mode_raw, "ADD")) {
tokenize(ctx, lexicon, &string_raw, GRN_TOKEN_ADD, flags, &tokens);
output_tokens(ctx, &tokens, lexicon, NULL);
} else if (GRN_RAW_STRING_EQUAL_CSTRING(mode_raw, "GET")) {
tokenize(ctx, lexicon, &string_raw, GRN_TOKEN_ADD, flags, &tokens);
GRN_BULK_REWIND(&tokens);
tokenize(ctx, lexicon, &string_raw, GRN_TOKEN_GET, flags, &tokens);
output_tokens(ctx, &tokens, lexicon, NULL);
} else {
GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT,
"[tokenize] invalid mode: <%.*s>",
(int)mode_raw.length,
mode_raw.value);
}
GRN_OBJ_FIN(ctx, &tokens);
}
#undef MODE_NAME_EQUAL
grn_obj_unlink(ctx, lexicon);
}
return NULL;
}
static grn_obj *
command_table_tokenize(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data)
{
grn_raw_string table_raw;
grn_raw_string string_raw;
grn_raw_string flags_raw;
grn_raw_string mode_raw;
grn_raw_string index_column_raw;
#define GET_VALUE(name) \
name ## _raw.value = \
grn_plugin_proc_get_var_string(ctx, \
user_data, \
#name, \
strlen(#name), \
&(name ## _raw.length))
GET_VALUE(table);
GET_VALUE(string);
GET_VALUE(flags);
GET_VALUE(mode);
GET_VALUE(index_column);
#undef GET_VALUE
if (table_raw.length == 0) {
GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT,
"[table_tokenize] table name is missing");
return NULL;
}
if (string_raw.length == 0) {
GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT,
"[table_tokenize] string is missing");
return NULL;
}
{
unsigned int flags;
grn_obj *lexicon;
grn_obj *index_column = NULL;
flags = parse_tokenize_flags(ctx, &flags_raw);
if (ctx->rc != GRN_SUCCESS) {
return NULL;
}
lexicon = grn_ctx_get(ctx,
table_raw.value,
table_raw.length);
if (!lexicon) {
GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT,
"[table_tokenize] nonexistent lexicon: <%.*s>",
(int)table_raw.length,
table_raw.value);
return NULL;
}
if (index_column_raw.length > 0) {
index_column = grn_obj_column(ctx, lexicon,
index_column_raw.value,
index_column_raw.length);
if (!index_column) {
GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT,
"[table_tokenize] nonexistent index column: <%.*s>",
(int)index_column_raw.length,
index_column_raw.value);
goto exit;
}
if (index_column->header.type != GRN_COLUMN_INDEX) {
GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT,
"[table_tokenize] "
"index column must be COLUMN_INDEX: <%.*s>",
(int)index_column_raw.length,
index_column_raw.value);
goto exit;
}
}
{
grn_obj tokens;
GRN_VALUE_FIX_SIZE_INIT(&tokens, GRN_OBJ_VECTOR, GRN_ID_NIL);
if (mode_raw.length == 0 ||
GRN_RAW_STRING_EQUAL_CSTRING(mode_raw, "GET")) {
tokenize(ctx, lexicon, &string_raw, GRN_TOKEN_GET, flags, &tokens);
output_tokens(ctx, &tokens, lexicon, index_column);
} else if (GRN_RAW_STRING_EQUAL_CSTRING(mode_raw, "ADD")) {
tokenize(ctx, lexicon, &string_raw, GRN_TOKEN_ADD, flags, &tokens);
output_tokens(ctx, &tokens, lexicon, index_column);
} else {
GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT,
"[table_tokenize] invalid mode: <%.*s>",
(int)mode_raw.length,
mode_raw.value);
}
GRN_OBJ_FIN(ctx, &tokens);
}
#undef MODE_NAME_EQUAL
exit:
grn_obj_unlink(ctx, lexicon);
if (index_column) {
grn_obj_unlink(ctx, index_column);
}
}
return NULL;
}
static void
grn_text_atoj(grn_ctx *ctx, grn_obj *outbuf, grn_content_type output_type,
grn_obj *obj, grn_id id)
{
int vs;
grn_obj buf;
if (obj->header.type == GRN_ACCESSOR) {
grn_accessor *a = (grn_accessor *)obj;
GRN_TEXT_INIT(&buf, 0);
for (;;) {
buf.header.domain = grn_obj_get_range(ctx, obj);
GRN_BULK_REWIND(&buf);
switch (a->action) {
case GRN_ACCESSOR_GET_ID :
GRN_UINT32_PUT(ctx, &buf, id);
buf.header.domain = GRN_DB_UINT32;
break;
case GRN_ACCESSOR_GET_KEY :
grn_table_get_key2(ctx, a->obj, id, &buf);
buf.header.domain = DB_OBJ(a->obj)->header.domain;
break;
case GRN_ACCESSOR_GET_VALUE :
grn_obj_get_value(ctx, a->obj, id, &buf);
buf.header.domain = GRN_DB_INT32; /* fix me */
break;
case GRN_ACCESSOR_GET_SCORE :
grn_obj_get_value(ctx, a->obj, id, &buf);
{
grn_rset_recinfo *ri = (grn_rset_recinfo *)grn_obj_get_value_(ctx, a->obj, id, &vs);
GRN_INT32_PUT(ctx, &buf, ri->score);
}
buf.header.domain = GRN_DB_INT32;
break;
case GRN_ACCESSOR_GET_NSUBRECS :
{
grn_rset_recinfo *ri = (grn_rset_recinfo *)grn_obj_get_value_(ctx, a->obj, id, &vs);
GRN_INT32_PUT(ctx, &buf, ri->n_subrecs);
}
buf.header.domain = GRN_DB_INT32;
break;
case GRN_ACCESSOR_GET_COLUMN_VALUE :
if ((a->obj->header.flags & GRN_OBJ_COLUMN_TYPE_MASK) == GRN_OBJ_COLUMN_VECTOR) {
if (a->next) {
grn_id *idp;
grn_obj_get_value(ctx, a->obj, id, &buf);
idp = (grn_id *)GRN_BULK_HEAD(&buf);
vs = GRN_BULK_VSIZE(&buf) / sizeof(grn_id);
grn_output_array_open(ctx, outbuf, output_type, "COLUMN", vs);
for (; vs--; idp++) {
grn_text_atoj(ctx, outbuf, output_type, (grn_obj *)a->next, *idp);
}
grn_output_array_close(ctx, outbuf, output_type);
} else {
grn_text_atoj(ctx, outbuf, output_type, a->obj, id);
}
goto exit;
} else {
grn_obj_get_value(ctx, a->obj, id, &buf);
}
break;
case GRN_ACCESSOR_GET_DB_OBJ :
/* todo */
break;
case GRN_ACCESSOR_LOOKUP :
/* todo */
break;
case GRN_ACCESSOR_FUNCALL :
/* todo */
break;
}
if (a->next) {
a = a->next;
if (GRN_BULK_VSIZE(&buf) >= sizeof(grn_id)) {
id = *((grn_id *)GRN_BULK_HEAD(&buf));
} else {
id = GRN_ID_NIL;
}
} else {
break;
}
}
} else {
switch (obj->header.type) {
case GRN_COLUMN_FIX_SIZE :
GRN_VALUE_FIX_SIZE_INIT(&buf, 0, DB_OBJ(obj)->range);
break;
case GRN_COLUMN_VAR_SIZE :
if ((obj->header.flags & GRN_OBJ_COLUMN_TYPE_MASK) == GRN_OBJ_COLUMN_VECTOR) {
grn_obj *range = grn_ctx_at(ctx, DB_OBJ(obj)->range);
if (range->header.flags & GRN_OBJ_KEY_VAR_SIZE) {
GRN_VALUE_VAR_SIZE_INIT(&buf, GRN_OBJ_VECTOR, DB_OBJ(obj)->range);
} else {
GRN_VALUE_FIX_SIZE_INIT(&buf, GRN_OBJ_VECTOR, DB_OBJ(obj)->range);
}
} else {
GRN_VALUE_VAR_SIZE_INIT(&buf, 0, DB_OBJ(obj)->range);
}
break;
case GRN_COLUMN_INDEX :
GRN_UINT32_INIT(&buf, 0);
break;
default:
GRN_TEXT_INIT(&buf, 0);
break;
}
grn_obj_get_value(ctx, obj, id, &buf);
}
grn_output_obj(ctx, outbuf, output_type, &buf, NULL);
exit :
grn_obj_close(ctx, &buf);
}