void
grn_time_now(grn_ctx *ctx, grn_obj *obj)
{
grn_timeval tv;
grn_timeval_now(ctx, &tv);
GRN_TIME_SET(ctx, obj, GRN_TIME_PACK(tv.tv_sec,
GRN_TIME_NSEC_TO_USEC(tv.tv_nsec)));
}
void ConditionConverter::append_const_item(const Item_field *field_item,
Item *const_item,
grn_obj *expression) {
MRN_DBUG_ENTER_METHOD();
enum_field_types field_type = field_item->field_type();
NormalizedType normalized_type = normalize_field_type(field_type);
switch (normalized_type) {
case STRING_TYPE:
grn_obj_reinit(ctx_, &value_, GRN_DB_TEXT, 0);
{
String *string;
string = const_item->val_str(NULL);
GRN_TEXT_SET(ctx_, &value_, string->ptr(), string->length());
}
break;
case INT_TYPE:
grn_obj_reinit(ctx_, &value_, GRN_DB_INT64, 0);
GRN_INT64_SET(ctx_, &value_, const_item->val_int());
break;
case TIME_TYPE:
grn_obj_reinit(ctx_, &value_, GRN_DB_TIME, 0);
{
MYSQL_TIME mysql_time;
get_time_value(field_item, const_item, &mysql_time);
bool truncated = false;
TimeConverter time_converter;
long long int time =
time_converter.mysql_time_to_grn_time(&mysql_time, &truncated);
GRN_TIME_SET(ctx_, &value_, time);
}
break;
case UNSUPPORTED_TYPE:
// Should not be occurred.
DBUG_PRINT("error",
("mroonga: append_const_item: unsupported type: <%d> "
"This case should not be occurred.",
field_type));
grn_obj_reinit(ctx_, &value_, GRN_DB_VOID, 0);
break;
}
grn_expr_append_const(ctx_, expression, &value_, GRN_OP_PUSH, 1);
DBUG_VOID_RETURN;
}
static void
insert_document(const gchar *body_content)
{
uint32_t s = (uint32_t)strlen(body_content);
grn_id docid = grn_table_add(&context, docs, NULL, 0, NULL);
const gchar *size_string;
struct tm time;
GRN_TEXT_SET(&context, &textbuf, body_content, s);
grn_test_assert(grn_obj_set_value(&context, body, docid, &textbuf,
GRN_OBJ_SET));
GRN_UINT32_SET(&context, &intbuf, s);
grn_test_assert(grn_obj_set_value(&context, size, docid, &intbuf,
GRN_OBJ_SET));
size_string = cut_take_printf("%u", s);
GRN_TEXT_SET(&context, &textbuf, size_string, strlen(size_string));
grn_test_assert(grn_obj_set_value(&context, size_in_string, docid, &textbuf,
GRN_OBJ_SET));
GRN_FLOAT_SET(&context, &floatbuf, s);
grn_test_assert(grn_obj_set_value(&context, size_in_float, docid, &floatbuf,
GRN_OBJ_SET));
time.tm_sec = s;
time.tm_min = 16;
time.tm_hour = 15;
time.tm_mday = 2;
time.tm_mon = 11;
time.tm_year = 109;
time.tm_wday = 3;
time.tm_yday = 336;
time.tm_isdst = 0;
GRN_TIME_SET(&context, &timebuf, GRN_TIME_PACK(mktime(&time), 0));
grn_test_assert(grn_obj_set_value(&context, created_at, docid, &timebuf,
GRN_OBJ_SET));
}
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
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;
}
}
grn_obj *
rb_grn_bulk_from_ruby_object (VALUE object, grn_ctx *context, grn_obj *bulk)
{
if (bulk && bulk->header.domain == GRN_DB_TIME)
return RVAL2GRNBULK_WITH_TYPE(object, context, bulk,
bulk->header.domain,
grn_ctx_at(context, bulk->header.domain));
if (!bulk) {
bulk = grn_obj_open(context, GRN_BULK, 0, GRN_ID_NIL);
rb_grn_context_check(context, object);
}
switch (TYPE(object)) {
case T_NIL:
grn_obj_reinit(context, bulk, GRN_DB_VOID, 0);
break;
case T_SYMBOL:
object = rb_funcall(object, rb_intern("to_s"), 0);
case T_STRING:
grn_obj_reinit(context, bulk, GRN_DB_TEXT, 0);
rb_grn_context_text_set(context, bulk, object);
break;
case T_FIXNUM:
case T_BIGNUM: {
int64_t int64_value;
int64_value = NUM2LL(object);
if (int64_value <= INT32_MAX) {
grn_obj_reinit(context, bulk, GRN_DB_INT32, 0);
GRN_INT32_SET(context, bulk, int64_value);
} else {
grn_obj_reinit(context, bulk, GRN_DB_INT64, 0);
GRN_INT64_SET(context, bulk, int64_value);
}
break;
}
case T_FLOAT:
grn_obj_reinit(context, bulk, GRN_DB_FLOAT, 0);
GRN_FLOAT_SET(context, bulk, NUM2DBL(object));
break;
case T_TRUE:
grn_obj_reinit(context, bulk, GRN_DB_BOOL, 0);
GRN_BOOL_SET(context, bulk, GRN_TRUE);
break;
case T_FALSE:
grn_obj_reinit(context, bulk, GRN_DB_BOOL, 0);
GRN_BOOL_SET(context, bulk, GRN_FALSE);
break;
default:
if (RVAL2CBOOL(rb_obj_is_kind_of(object, rb_cTime))) {
VALUE sec, usec;
int64_t time_value;
sec = rb_funcall(object, rb_intern("to_i"), 0);
usec = rb_funcall(object, rb_intern("usec"), 0);
time_value = GRN_TIME_PACK(NUM2LL(sec), NUM2LL(usec));
grn_obj_reinit(context, bulk, GRN_DB_TIME, 0);
GRN_TIME_SET(context, bulk, time_value);
} else if (RVAL2CBOOL(rb_obj_is_kind_of(object, rb_cGrnObject))) {
grn_obj *grn_object;
grn_id id_value;
grn_object = RVAL2GRNOBJECT(object, &context);
grn_obj_reinit(context, bulk, grn_object->header.domain, 0);
id_value = grn_obj_id(context, grn_object);
GRN_RECORD_SET(context, bulk, id_value);
} else if (RVAL2CBOOL(rb_obj_is_kind_of(object, rb_cGrnRecord))) {
grn_obj *table;
grn_id id_value;
table = RVAL2GRNOBJECT(rb_funcall(object, rb_intern("table"), 0),
&context);
id_value = NUM2UINT(rb_funcall(object, rb_intern("id"), 0));
grn_obj_reinit(context, bulk, grn_obj_id(context, table), 0);
GRN_RECORD_SET(context, bulk, id_value);
} else {
rb_raise(rb_eTypeError,
"bulked object should be one of "
"[nil, true, false, String, Symbol, Integer, Float, Time, "
"Groonga::Object, Groonga::Record]: %s",
rb_grn_inspect(object));
}
break;
}
return bulk;
}
static mrb_value
mrb_grn_expression_append_constant(mrb_state *mrb, mrb_value self)
{
grn_ctx *ctx = (grn_ctx *)mrb->ud;
grn_obj *expr;
mrb_value mrb_constant;
mrb_value mrb_op;
grn_operator op;
int n_args;
expr = DATA_PTR(self);
mrb_get_args(mrb, "ooi", &mrb_constant, &mrb_op, &n_args);
op = grn_mrb_value_to_operator(mrb, mrb_op);
switch (mrb_type(mrb_constant)) {
case MRB_TT_FALSE :
if (mrb_nil_p(mrb_constant)) {
grn_obj constant;
GRN_VOID_INIT(&constant);
grn_expr_append_const(ctx, expr, &constant, op, n_args);
GRN_OBJ_FIN(ctx, &constant);
} else {
grn_obj constant;
GRN_BOOL_INIT(&constant, 0);
GRN_BOOL_SET(ctx, &constant, GRN_FALSE);
grn_expr_append_const(ctx, expr, &constant, op, n_args);
GRN_OBJ_FIN(ctx, &constant);
}
break;
case MRB_TT_TRUE :
{
grn_obj constant;
GRN_BOOL_INIT(&constant, 0);
GRN_BOOL_SET(ctx, &constant, GRN_TRUE);
grn_expr_append_const(ctx, expr, &constant, op, n_args);
GRN_OBJ_FIN(ctx, &constant);
}
break;
case MRB_TT_FIXNUM :
grn_expr_append_const_int(ctx, expr, mrb_fixnum(mrb_constant), op, n_args);
break;
case MRB_TT_SYMBOL :
{
const char *value;
mrb_int value_length;
value = mrb_sym2name_len(mrb, mrb_symbol(mrb_constant), &value_length);
grn_expr_append_const_str(ctx, expr, value, value_length, op, n_args);
}
break;
case MRB_TT_FLOAT :
{
grn_obj constant;
GRN_FLOAT_INIT(&constant, 0);
GRN_FLOAT_SET(ctx, &constant, mrb_float(mrb_constant));
grn_expr_append_const(ctx, expr, &constant, op, n_args);
GRN_OBJ_FIN(ctx, &constant);
}
break;
case MRB_TT_STRING :
grn_expr_append_const_str(ctx, expr,
RSTRING_PTR(mrb_constant),
RSTRING_LEN(mrb_constant),
op, n_args);
break;
default :
{
struct RClass *klass;
klass = mrb_class(mrb, mrb_constant);
if (klass == ctx->impl->mrb.builtin.time_class) {
grn_obj constant;
mrb_value mrb_sec;
mrb_value mrb_usec;
mrb_sec = mrb_funcall(mrb, mrb_constant, "to_i", 0);
mrb_usec = mrb_funcall(mrb, mrb_constant, "usec", 0);
GRN_TIME_INIT(&constant, 0);
GRN_TIME_SET(ctx, &constant,
GRN_TIME_PACK(mrb_fixnum(mrb_sec), mrb_fixnum(mrb_usec)));
grn_expr_append_const(ctx, expr, &constant, op, n_args);
GRN_OBJ_FIN(ctx, &constant);
} else {
mrb_raisef(mrb, E_ARGUMENT_ERROR,
"unsupported constant to append to expression: %S",
mrb_constant);
}
}
break;
}
grn_mrb_ctx_check(mrb);
return mrb_nil_value();
}
