static mrb_value
indexable_find_index(mrb_state *mrb, mrb_value self)
{
grn_ctx *ctx = (grn_ctx *)mrb->ud;
grn_obj *object;
mrb_value mrb_operator;
grn_operator operator;
grn_index_datum index_datum;
int n_index_data;
mrb_get_args(mrb, "o", &mrb_operator);
object = DATA_PTR(self);
operator = grn_mrb_value_to_operator(mrb, mrb_operator);
n_index_data = grn_column_find_index_data(ctx,
object,
operator,
&index_datum,
1);
if (n_index_data == 0) {
return mrb_nil_value();
} else {
grn_mrb_data *data;
struct RClass *klass;
mrb_value args[2];
data = &(ctx->impl->mrb);
klass = mrb_class_get_under(mrb, data->module, "IndexInfo");
args[0] = grn_mrb_value_from_grn_obj(mrb, index_datum.index);
args[1] = mrb_fixnum_value(index_datum.section);
return mrb_obj_new(mrb, klass, 2, args);
}
}
static mrb_value
mrb_grn_scan_info_set_logical_op(mrb_state *mrb, mrb_value self)
{
scan_info *si;
mrb_value mrb_logical_op;
grn_operator logical_op;
mrb_get_args(mrb, "o", &mrb_logical_op);
si = DATA_PTR(self);
logical_op = grn_mrb_value_to_operator(mrb, mrb_logical_op);
grn_scan_info_set_logical_op(si, logical_op);
return self;
}
static mrb_value
mrb_grn_expression_append_operator(mrb_state *mrb, mrb_value self)
{
grn_ctx *ctx = (grn_ctx *)mrb->ud;
grn_obj *expr;
mrb_value mrb_op;
int n_args;
grn_operator op;
expr = DATA_PTR(self);
mrb_get_args(mrb, "oi", &mrb_op, &n_args);
op = grn_mrb_value_to_operator(mrb, mrb_op);
grn_expr_append_op(ctx, expr, op, n_args);
grn_mrb_ctx_check(mrb);
return mrb_nil_value();
}
static mrb_value
mrb_grn_index_column_estimate_size_for_query(mrb_state *mrb, mrb_value self)
{
grn_ctx *ctx = (grn_ctx *)mrb->ud;
grn_obj *index_column;
grn_obj *lexicon;
mrb_value mrb_query;
void *query;
unsigned int query_size;
grn_mrb_value_to_raw_data_buffer buffer;
mrb_value mrb_options = mrb_nil_value();
grn_search_optarg optarg;
unsigned int size;
index_column = DATA_PTR(self);
mrb_get_args(mrb, "o|H", &mrb_query, &mrb_options);
lexicon = grn_ctx_at(ctx, index_column->header.domain);
grn_mrb_value_to_raw_data_buffer_init(mrb, &buffer);
grn_mrb_value_to_raw_data(mrb, "query", mrb_query, lexicon->header.domain,
&buffer, &query, &query_size);
memset(&optarg, 0, sizeof(grn_search_optarg));
optarg.mode = GRN_OP_EXACT;
if (!mrb_nil_p(mrb_options)) {
mrb_value mrb_mode;
mrb_mode = grn_mrb_options_get_lit(mrb, mrb_options, "mode");
if (!mrb_nil_p(mrb_mode)) {
optarg.mode = grn_mrb_value_to_operator(mrb, mrb_mode);
}
}
size = grn_ii_estimate_size_for_query(ctx, (grn_ii *)index_column,
query, query_size, &optarg);
grn_mrb_value_to_raw_data_buffer_fin(mrb, &buffer);
grn_mrb_ctx_check(mrb);
return mrb_fixnum_value(size);
}
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();
}
