void
grn_rset_recinfo_update_calc_values(grn_ctx *ctx,
grn_rset_recinfo *ri,
grn_obj *table,
grn_obj *value)
{
grn_table_group_flags flags;
byte *values;
grn_obj value_int64;
grn_obj value_float;
flags = DB_OBJ(table)->flags.group;
values = (((byte *)ri->subrecs) +
GRN_RSET_SUBRECS_SIZE(DB_OBJ(table)->subrec_size,
DB_OBJ(table)->max_n_subrecs));
GRN_INT64_INIT(&value_int64, 0);
GRN_FLOAT_INIT(&value_float, 0);
if (flags & (GRN_TABLE_GROUP_CALC_MAX |
GRN_TABLE_GROUP_CALC_MIN |
GRN_TABLE_GROUP_CALC_SUM)) {
grn_obj_cast(ctx, value, &value_int64, GRN_FALSE);
}
if (flags & GRN_TABLE_GROUP_CALC_AVG) {
grn_obj_cast(ctx, value, &value_float, GRN_FALSE);
}
if (flags & GRN_TABLE_GROUP_CALC_MAX) {
int64_t current_max = *((int64_t *)values);
int64_t value_raw = GRN_INT64_VALUE(&value_int64);
if (ri->n_subrecs == 1 || value_raw > current_max) {
*((int64_t *)values) = value_raw;
}
values += GRN_RSET_MAX_SIZE;
}
if (flags & GRN_TABLE_GROUP_CALC_MIN) {
int64_t current_min = *((int64_t *)values);
int64_t value_raw = GRN_INT64_VALUE(&value_int64);
if (ri->n_subrecs == 1 || value_raw < current_min) {
*((int64_t *)values) = value_raw;
}
values += GRN_RSET_MIN_SIZE;
}
if (flags & GRN_TABLE_GROUP_CALC_SUM) {
int64_t value_raw = GRN_INT64_VALUE(&value_int64);
*((int64_t *)values) += value_raw;
values += GRN_RSET_SUM_SIZE;
}
if (flags & GRN_TABLE_GROUP_CALC_AVG) {
double current_average = *((double *)values);
double value_raw = GRN_FLOAT_VALUE(&value_float);
*((double *)values) += (value_raw - current_average) / ri->n_subrecs;
values += GRN_RSET_AVG_SIZE;
}
GRN_OBJ_FIN(ctx, &value_float);
GRN_OBJ_FIN(ctx, &value_int64);
}
static void
construct_object(gconstpointer data, grn_builtin_type type, grn_obj *object)
{
switch (type) {
case GRN_DB_VOID:
GRN_VOID_INIT(object);
break;
case GRN_DB_BOOL:
GRN_BOOL_INIT(object, 0);
GRN_BOOL_SET(&context, object, gcut_data_get_boolean(data, "value"));
break;
case GRN_DB_INT8:
GRN_INT8_INIT(object, 0);
GRN_INT8_SET(&context, object, gcut_data_get_int(data, "value"));
break;
case GRN_DB_UINT8:
GRN_UINT8_INIT(object, 0);
GRN_UINT8_SET(&context, object, gcut_data_get_uint(data, "value"));
break;
case GRN_DB_INT16:
GRN_INT16_INIT(object, 0);
GRN_INT16_SET(&context, object, gcut_data_get_int(data, "value"));
break;
case GRN_DB_UINT16:
GRN_UINT16_INIT(object, 0);
GRN_UINT16_SET(&context, object, gcut_data_get_uint(data, "value"));
break;
case GRN_DB_INT32:
GRN_INT32_INIT(object, 0);
GRN_INT32_SET(&context, object, gcut_data_get_int(data, "value"));
break;
case GRN_DB_UINT32:
GRN_UINT32_INIT(object, 0);
GRN_UINT32_SET(&context, object, gcut_data_get_uint(data, "value"));
break;
case GRN_DB_INT64:
GRN_INT64_INIT(object, 0);
GRN_INT64_SET(&context, object, gcut_data_get_int64(data, "value"));
break;
case GRN_DB_UINT64:
GRN_UINT64_INIT(object, 0);
GRN_UINT64_SET(&context, object, gcut_data_get_uint64(data, "value"));
break;
case GRN_DB_FLOAT:
GRN_FLOAT_INIT(object, 0);
GRN_FLOAT_SET(&context, object, gcut_data_get_double(data, "value"));
break;
case GRN_DB_TIME:
GRN_TIME_INIT(object, 0);
GRN_TIME_SET(&context, object, gcut_data_get_int64(data, "value"));
break;
case GRN_DB_SHORT_TEXT:
GRN_SHORT_TEXT_INIT(object, 0);
GRN_TEXT_SETS(&context, object, gcut_data_get_string(data, "value"));
break;
case GRN_DB_TEXT:
GRN_TEXT_INIT(object, 0);
GRN_TEXT_SETS(&context, object, gcut_data_get_string(data, "value"));
break;
case GRN_DB_LONG_TEXT:
GRN_LONG_TEXT_INIT(object, 0);
GRN_TEXT_SETS(&context, object, gcut_data_get_string(data, "value"));
break;
case GRN_DB_TOKYO_GEO_POINT:
GRN_TOKYO_GEO_POINT_INIT(object, 0);
GRN_GEO_POINT_SET(&context, object,
gcut_data_get_int(data, "latitude"),
gcut_data_get_int(data, "longitude"));
break;
case GRN_DB_WGS84_GEO_POINT:
GRN_WGS84_GEO_POINT_INIT(object, 0);
GRN_GEO_POINT_SET(&context, object,
gcut_data_get_int(data, "latitude"),
gcut_data_get_int(data, "longitude"));
break;
default:
cut_fail("unknown type: %d", type);
break;
}
}
static grn_obj *
func_vector_slice(grn_ctx *ctx, int n_args, grn_obj **args,
grn_user_data *user_data)
{
grn_obj *target;
grn_obj *from_raw = NULL;
grn_obj *length_raw = NULL;
int64_t from = 0;
int64_t length = -1;
uint32_t to = 0;
uint32_t size = 0;
grn_obj *slice;
if (n_args < 2 || n_args > 3) {
GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT,
"vector_slice(): wrong number of arguments (%d for 2..3)",
n_args);
return NULL;
}
target = args[0];
from_raw = args[1];
if (n_args == 3) {
length_raw = args[2];
}
switch (target->header.type) {
case GRN_VECTOR :
case GRN_PVECTOR :
case GRN_UVECTOR :
size = grn_vector_size(ctx, target);
break;
default :
{
grn_obj inspected;
GRN_TEXT_INIT(&inspected, 0);
grn_inspect(ctx, target, &inspected);
GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT,
"vector_slice(): target object must be vector: <%.*s>",
(int)GRN_TEXT_LEN(&inspected),
GRN_TEXT_VALUE(&inspected));
GRN_OBJ_FIN(ctx, &inspected);
return NULL;
}
break;
}
if (!grn_type_id_is_number_family(ctx, from_raw->header.domain)) {
grn_obj inspected;
GRN_TEXT_INIT(&inspected, 0);
grn_inspect(ctx, &inspected, from_raw);
GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT,
"vector_slice(): from must be a number: <%.*s>",
(int)GRN_TEXT_LEN(&inspected),
GRN_TEXT_VALUE(&inspected));
GRN_OBJ_FIN(ctx, &inspected);
return NULL;
}
if (from_raw->header.domain == GRN_DB_INT32) {
from = GRN_INT32_VALUE(from_raw);
} else if (from_raw->header.domain == GRN_DB_INT64) {
from = GRN_INT64_VALUE(from_raw);
} else {
grn_obj buffer;
grn_rc rc;
GRN_INT64_INIT(&buffer, 0);
rc = grn_obj_cast(ctx, from_raw, &buffer, GRN_FALSE);
if (rc == GRN_SUCCESS) {
from = GRN_INT64_VALUE(&buffer);
}
GRN_OBJ_FIN(ctx, &buffer);
if (rc != GRN_SUCCESS) {
grn_obj inspected;
GRN_TEXT_INIT(&inspected, 0);
grn_inspect(ctx, &inspected, from_raw);
GRN_PLUGIN_ERROR(ctx, rc,
"vector_slice(): "
"failed to cast from value to number: <%.*s>",
(int)GRN_TEXT_LEN(&inspected),
GRN_TEXT_VALUE(&inspected));
GRN_OBJ_FIN(ctx, &inspected);
return NULL;
}
}
if (length_raw) {
if (!grn_type_id_is_number_family(ctx, length_raw->header.domain)) {
grn_obj inspected;
GRN_TEXT_INIT(&inspected, 0);
grn_inspect(ctx, &inspected, length_raw);
GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT,
"vector_slice(): length must be a number: <%.*s>",
(int)GRN_TEXT_LEN(&inspected),
GRN_TEXT_VALUE(&inspected));
GRN_OBJ_FIN(ctx, &inspected);
return NULL;
}
if (length_raw->header.domain == GRN_DB_INT32) {
length = GRN_INT32_VALUE(length_raw);
} else if (length_raw->header.domain == GRN_DB_INT64) {
length = GRN_INT64_VALUE(length_raw);
} else {
grn_obj buffer;
grn_rc rc;
GRN_INT64_INIT(&buffer, 0);
rc = grn_obj_cast(ctx, length_raw, &buffer, GRN_FALSE);
if (rc == GRN_SUCCESS) {
length = GRN_INT64_VALUE(&buffer);
}
GRN_OBJ_FIN(ctx, &buffer);
if (rc != GRN_SUCCESS) {
grn_obj inspected;
GRN_TEXT_INIT(&inspected, 0);
grn_inspect(ctx, &inspected, length_raw);
GRN_PLUGIN_ERROR(ctx, rc,
"vector_slice(): "
"failed to cast length value to number: <%.*s>",
(int)GRN_TEXT_LEN(&inspected),
GRN_TEXT_VALUE(&inspected));
GRN_OBJ_FIN(ctx, &inspected);
return NULL;
}
}
}
slice = grn_plugin_proc_alloc(ctx, user_data, target->header.domain, GRN_OBJ_VECTOR);
if (!slice) {
return NULL;
}
if (target->header.flags & GRN_OBJ_WITH_WEIGHT) {
slice->header.flags |= GRN_OBJ_WITH_WEIGHT;
}
if (length < 0) {
length = size + length + 1;
}
if (length > size) {
length = size;
}
if (length <= 0) {
return slice;
}
while (from < 0) {
from += size;
}
to = from + length;
if (to > size) {
to = size;
}
switch (target->header.type) {
case GRN_VECTOR :
{
unsigned int i;
for (i = from; i < to; i++) {
const char *content;
unsigned int content_length;
unsigned int weight;
grn_id domain;
content_length = grn_vector_get_element(ctx, target, i,
&content, &weight, &domain);
grn_vector_add_element(ctx, slice,
content, content_length, weight, domain);
}
}
break;
case GRN_PVECTOR :
{
unsigned int i;
for (i = from; i < to; i++) {
grn_obj *element = GRN_PTR_VALUE_AT(target, i);
GRN_PTR_PUT(ctx, slice, element);
}
}
break;
case GRN_UVECTOR :
{
unsigned int i;
for (i = from; i < to; i++) {
grn_id id;
unsigned int weight;
id = grn_uvector_get_element(ctx, target, i, &weight);
grn_uvector_add_element(ctx, slice, id, weight);
}
}
break;
}
return slice;
}
