static mrb_value
mrb_grn_index_cursor_class_open_raw(mrb_state *mrb, mrb_value klass)
{
grn_ctx *ctx = (grn_ctx *)mrb->ud;
mrb_value mrb_table_cursor;
mrb_value mrb_index;
mrb_value mrb_options = mrb_nil_value();
grn_obj *index_cursor;
grn_table_cursor *table_cursor;
grn_obj *index;
grn_id rid_min = GRN_ID_NIL;
grn_id rid_max = GRN_ID_MAX;
int flags = 0;
mrb_value mrb_index_cursor;
mrb_get_args(mrb, "oo|H", &mrb_table_cursor, &mrb_index, &mrb_options);
table_cursor = DATA_PTR(mrb_table_cursor);
index = DATA_PTR(mrb_index);
if (!mrb_nil_p(mrb_options)) {
/* TODO */
}
index_cursor = grn_index_cursor_open(ctx, table_cursor, index,
rid_min, rid_max, flags);
grn_mrb_ctx_check(mrb);
mrb_index_cursor = mrb_funcall(mrb, klass, "new", 1,
mrb_cptr_value(mrb, index_cursor));
mrb_iv_set(mrb, mrb_index_cursor, mrb_intern_lit(mrb, "@index"), mrb_index);
return mrb_index_cursor;
}
static mrb_value
mrb_grn_expression_parse(mrb_state *mrb, mrb_value self)
{
grn_ctx *ctx = (grn_ctx *)mrb->ud;
grn_obj *expr;
char *query;
mrb_int query_size;
grn_obj *default_column = NULL;
grn_operator default_mode = GRN_OP_MATCH;
grn_operator default_operator = GRN_OP_AND;
grn_expr_flags flags = GRN_EXPR_SYNTAX_SCRIPT;
mrb_value mrb_options = mrb_nil_value();
expr = DATA_PTR(self);
mrb_get_args(mrb, "s|H", &query, &query_size, &mrb_options);
if (!mrb_nil_p(mrb_options)) {
mrb_value mrb_flags;
mrb_flags = grn_mrb_options_get_lit(mrb, mrb_options, "flags");
if (!mrb_nil_p(mrb_flags)) {
flags = mrb_fixnum(mrb_flags);
}
}
grn_expr_parse(ctx, expr, query, query_size, default_column,
default_mode, default_operator, flags);
grn_mrb_ctx_check(mrb);
return mrb_nil_value();
}
static mrb_value
writer_write_table_columns(mrb_state *mrb, mrb_value self)
{
grn_ctx *ctx = (grn_ctx *)mrb->ud;
mrb_value mrb_table;
char *columns;
mrb_int columns_size;
grn_obj *table;
grn_obj_format format;
int n_hits = 0;
int offset = 0;
int limit = 0;
int hits_offset = 0;
mrb_get_args(mrb, "os", &mrb_table, &columns, &columns_size);
table = DATA_PTR(mrb_table);
GRN_OBJ_FORMAT_INIT(&format, n_hits, offset, limit, hits_offset);
format.flags |= GRN_OBJ_FORMAT_WITH_COLUMN_NAMES;
{
grn_rc rc;
rc = grn_output_format_set_columns(ctx, &format,
table, columns, columns_size);
if (rc != GRN_SUCCESS) {
GRN_OBJ_FORMAT_FIN(ctx, &format);
grn_mrb_ctx_check(mrb);
}
}
GRN_OUTPUT_TABLE_COLUMNS(table, &format);
GRN_OBJ_FORMAT_FIN(ctx, &format);
return mrb_nil_value();
}
static mrb_value
mrb_grn_table_get_column_ids(mrb_state *mrb, mrb_value self)
{
grn_ctx *ctx = (grn_ctx *)mrb->ud;
grn_obj *table;
grn_hash *columns;
int n_columns;
mrb_value mrb_column_ids;
table = DATA_PTR(self);
columns = grn_hash_create(ctx, NULL, sizeof(grn_id), 0,
GRN_OBJ_TABLE_HASH_KEY | GRN_HASH_TINY);
if (!columns) {
grn_mrb_ctx_check(mrb);
return mrb_ary_new(mrb);
}
n_columns = grn_table_columns(ctx, table, "", 0, (grn_obj *)columns);
mrb_column_ids = mrb_ary_new_capa(mrb, n_columns);
{
grn_id *key;
GRN_HASH_EACH(ctx, columns, id, &key, NULL, NULL, {
mrb_ary_push(mrb, mrb_column_ids, mrb_fixnum_value(*key));
});
}
static mrb_value
mrb_grn_table_group_raw(mrb_state *mrb, mrb_value self)
{
grn_ctx *ctx = (grn_ctx *)mrb->ud;
grn_obj *table;
mrb_value mrb_keys;
grn_table_sort_key *keys;
int i, n_keys;
mrb_value mrb_result;
grn_table_group_result *result;
table = DATA_PTR(self);
mrb_get_args(mrb, "oo", &mrb_keys, &mrb_result);
mrb_keys = mrb_convert_type(mrb, mrb_keys,
MRB_TT_ARRAY, "Array", "to_ary");
n_keys = RARRAY_LEN(mrb_keys);
keys = GRN_MALLOCN(grn_table_sort_key, n_keys);
for (i = 0; i < n_keys; i++) {
memcpy(&(keys[i]),
DATA_PTR(RARRAY_PTR(mrb_keys)[i]),
sizeof(grn_table_sort_key));
}
result = DATA_PTR(mrb_result);
grn_table_group(ctx, table, keys, n_keys, result, 1);
GRN_FREE(keys);
grn_mrb_ctx_check(mrb);
return mrb_result;
}
static mrb_value
mrb_grn_expression_singleton_create(mrb_state *mrb, mrb_value klass)
{
grn_ctx *ctx = (grn_ctx *)mrb->ud;
mrb_value mrb_expr;
mrb_value mrb_table;
mrb_value mrb_new_arguments[1];
grn_obj *expr, *variable = NULL;
mrb_get_args(mrb, "o", &mrb_table);
if (mrb_nil_p(mrb_table)) {
expr = grn_expr_create(ctx, NULL, 0);
} else {
grn_obj *table = DATA_PTR(mrb_table);
GRN_EXPR_CREATE_FOR_QUERY(ctx, table, expr, variable);
}
if (!expr) {
grn_mrb_ctx_check(mrb);
return mrb_nil_value();
}
mrb_new_arguments[0] = mrb_cptr_value(mrb, expr);
mrb_expr = mrb_obj_new(mrb, mrb_class_ptr(klass), 1, mrb_new_arguments);
{
mrb_value mrb_variable = mrb_nil_value();
if (variable) {
mrb_variable = grn_mrb_value_from_grn_obj(mrb, variable);
}
mrb_iv_set(mrb, mrb_expr, mrb_intern_lit(mrb, "@variable"), mrb_variable);
}
return mrb_expr;
}
static mrb_value
mrb_grn_expression_allocate_constant(mrb_state *mrb, mrb_value self)
{
grn_ctx *ctx = (grn_ctx *)mrb->ud;
grn_obj *expr;
mrb_value mrb_object;
grn_obj *grn_object;
mrb_get_args(mrb, "o", &mrb_object);
expr = DATA_PTR(self);
switch (mrb_type(mrb_object)) {
case MRB_TT_STRING:
grn_object = grn_expr_alloc_const(ctx, expr);
if (!grn_object) {
grn_mrb_ctx_check(mrb);
}
GRN_TEXT_INIT(grn_object, 0);
GRN_TEXT_SET(ctx, grn_object,
RSTRING_PTR(mrb_object), RSTRING_LEN(mrb_object));
break;
default:
mrb_raisef(mrb, E_ARGUMENT_ERROR, "unsupported type: %S", mrb_object);
break;
}
return grn_mrb_value_from_grn_obj(mrb, grn_object);
}
static mrb_value
mrb_grn_table_get_size(mrb_state *mrb, mrb_value self)
{
grn_ctx *ctx = (grn_ctx *)mrb->ud;
unsigned int size;
size = grn_table_size(ctx, DATA_PTR(self));
grn_mrb_ctx_check(mrb);
return mrb_fixnum_value(size);
}
static mrb_value
mrb_grn_table_cursor_next(mrb_state *mrb, mrb_value self)
{
grn_ctx *ctx = (grn_ctx *)mrb->ud;
grn_id id;
id = grn_table_cursor_next(ctx, DATA_PTR(self));
grn_mrb_ctx_check(mrb);
return mrb_fixnum_value(id);
}
static mrb_value
mrb_grn_table_is_locked(mrb_state *mrb, mrb_value self)
{
grn_ctx *ctx = (grn_ctx *)mrb->ud;
unsigned int is_locked;
is_locked = grn_obj_is_locked(ctx, DATA_PTR(self));
grn_mrb_ctx_check(mrb);
return mrb_bool_value(is_locked != 0);
}
static mrb_value
mrb_grn_table_is_empty(mrb_state *mrb, mrb_value self)
{
grn_ctx *ctx = (grn_ctx *)mrb->ud;
unsigned int size;
size = grn_table_size(ctx, DATA_PTR(self));
grn_mrb_ctx_check(mrb);
return mrb_bool_value(size == 0);
}
static mrb_value
writer_write_table_records(mrb_state *mrb, mrb_value self)
{
grn_ctx *ctx = (grn_ctx *)mrb->ud;
mrb_value mrb_table;
mrb_value mrb_options = mrb_nil_value();
char *columns;
mrb_int columns_size;
grn_obj *table;
grn_obj_format format;
int n_hits = 0;
int offset = 0;
int limit = -1;
int hits_offset = 0;
mrb_get_args(mrb, "os|H", &mrb_table, &columns, &columns_size, &mrb_options);
table = DATA_PTR(mrb_table);
if (!mrb_nil_p(mrb_options)) {
mrb_value mrb_offset;
mrb_value mrb_limit;
mrb_offset = grn_mrb_options_get_lit(mrb, mrb_options, "offset");
if (!mrb_nil_p(mrb_offset)) {
offset = mrb_fixnum(mrb_offset);
}
mrb_limit = grn_mrb_options_get_lit(mrb, mrb_options, "limit");
if (!mrb_nil_p(mrb_limit)) {
limit = mrb_fixnum(mrb_limit);
}
}
if (limit < 0) {
limit = grn_table_size(ctx, table) + limit + 1;
}
GRN_OBJ_FORMAT_INIT(&format, n_hits, offset, limit, hits_offset);
{
grn_rc rc;
rc = grn_output_format_set_columns(ctx, &format,
table, columns, columns_size);
if (rc != GRN_SUCCESS) {
GRN_OBJ_FORMAT_FIN(ctx, &format);
grn_mrb_ctx_check(mrb);
}
}
GRN_OUTPUT_TABLE_RECORDS(table, &format);
GRN_OBJ_FORMAT_FIN(ctx, &format);
return mrb_nil_value();
}
static mrb_value
mrb_grn_table_cursor_close(mrb_state *mrb, mrb_value self)
{
grn_ctx *ctx = (grn_ctx *)mrb->ud;
grn_table_cursor *table_cursor;
table_cursor = DATA_PTR(self);
if (table_cursor) {
DATA_PTR(self) = NULL;
grn_table_cursor_close(ctx, table_cursor);
grn_mrb_ctx_check(mrb);
}
return mrb_nil_value();
}
static mrb_value
mrb_grn_index_cursor_close(mrb_state *mrb, mrb_value self)
{
grn_ctx *ctx = (grn_ctx *)mrb->ud;
grn_obj *index_cursor;
index_cursor = DATA_PTR(self);
if (index_cursor) {
DATA_PTR(self) = NULL;
grn_obj_close(ctx, index_cursor);
grn_mrb_ctx_check(mrb);
}
return mrb_nil_value();
}
static mrb_value
mrb_kernel_load(mrb_state *mrb, mrb_value self)
{
grn_ctx *ctx = (grn_ctx *)mrb->ud;
char *path;
mrb_get_args(mrb, "z", &path);
grn_mrb_load(ctx, path);
if (mrb->exc) {
mrb_exc_raise(mrb, mrb_obj_value(mrb->exc));
}
grn_mrb_ctx_check(mrb);
return mrb_true_value();
}
static mrb_value
mrb_grn_table_find_column(mrb_state *mrb, mrb_value self)
{
grn_ctx *ctx = (grn_ctx *)mrb->ud;
grn_obj *table;
mrb_value mrb_column_name;
grn_obj *column;
mrb_get_args(mrb, "o", &mrb_column_name);
table = DATA_PTR(self);
column = grn_obj_column(ctx, table,
RSTRING_PTR(mrb_column_name),
RSTRING_LEN(mrb_column_name));
grn_mrb_ctx_check(mrb);
return grn_mrb_value_from_grn_obj(mrb, column);
}
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
conf_array_set(mrb_state *mrb, mrb_value self)
{
grn_ctx *ctx = (grn_ctx *)mrb->ud;
char *key;
mrb_int key_size;
mrb_value mrb_value_;
grn_rc rc;
mrb_get_args(mrb, "sS", &key, &key_size, &mrb_value_);
rc = grn_conf_set(ctx,
key, key_size,
RSTRING_PTR(mrb_value_), RSTRING_LEN(mrb_value_));
if (rc != GRN_SUCCESS) {
grn_mrb_ctx_check(mrb);
}
return mrb_value_;
}
static mrb_value
conf_array_reference(mrb_state *mrb, mrb_value self)
{
grn_ctx *ctx = (grn_ctx *)mrb->ud;
char *key;
mrb_int key_size;
const char *value;
uint32_t value_size;
grn_rc rc;
mrb_get_args(mrb, "s", &key, &key_size);
rc = grn_conf_get(ctx, key, key_size, &value, &value_size);
if (rc != GRN_SUCCESS) {
grn_mrb_ctx_check(mrb);
}
if (!value) {
return mrb_nil_value();
} else {
return mrb_str_new(mrb, value, value_size);
}
}
static mrb_value
mrb_grn_table_select(mrb_state *mrb, mrb_value self)
{
grn_ctx *ctx = (grn_ctx *)mrb->ud;
grn_obj *table;
grn_obj *expr;
grn_obj *result = NULL;
grn_operator operator = GRN_OP_OR;
mrb_value mrb_expr;
mrb_value mrb_options = mrb_nil_value();
table = DATA_PTR(self);
mrb_get_args(mrb, "o|H", &mrb_expr, &mrb_options);
expr = DATA_PTR(mrb_expr);
if (!mrb_nil_p(mrb_options)) {
mrb_value mrb_result;
mrb_value mrb_operator;
mrb_result = grn_mrb_options_get_lit(mrb, mrb_options, "result");
if (!mrb_nil_p(mrb_result)) {
result = DATA_PTR(mrb_result);
}
mrb_operator = grn_mrb_options_get_lit(mrb, mrb_options, "operator");
if (!mrb_nil_p(mrb_operator)) {
operator = mrb_fixnum(mrb_operator);
}
}
result = grn_table_select(ctx, table, expr, result, operator);
grn_mrb_ctx_check(mrb);
return grn_mrb_value_from_grn_obj(mrb, result);
}
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();
}
static mrb_value
mrb_grn_table_cursor_class_open_raw(mrb_state *mrb, mrb_value klass)
{
grn_ctx *ctx = (grn_ctx *)mrb->ud;
mrb_value mrb_table;
mrb_value mrb_options = mrb_nil_value();
grn_table_cursor *table_cursor;
grn_obj *table;
void *min = NULL;
unsigned int min_size = 0;
grn_mrb_value_to_raw_data_buffer min_buffer;
void *max = NULL;
unsigned int max_size = 0;
grn_mrb_value_to_raw_data_buffer max_buffer;
int offset = 0;
int limit = -1;
int flags = 0;
mrb_get_args(mrb, "o|H", &mrb_table, &mrb_options);
table = DATA_PTR(mrb_table);
grn_mrb_value_to_raw_data_buffer_init(mrb, &min_buffer);
grn_mrb_value_to_raw_data_buffer_init(mrb, &max_buffer);
if (!mrb_nil_p(mrb_options)) {
grn_id key_domain_id;
mrb_value mrb_min;
mrb_value mrb_max;
mrb_value mrb_flags;
if (table->header.type == GRN_DB) {
key_domain_id = GRN_DB_SHORT_TEXT;
} else {
key_domain_id = table->header.domain;
}
mrb_min = grn_mrb_options_get_lit(mrb, mrb_options, "min");
grn_mrb_value_to_raw_data(mrb, "min", mrb_min,
key_domain_id, &min_buffer, &min, &min_size);
mrb_max = grn_mrb_options_get_lit(mrb, mrb_options, "max");
grn_mrb_value_to_raw_data(mrb, "max", mrb_max,
key_domain_id, &max_buffer, &max, &max_size);
mrb_flags = grn_mrb_options_get_lit(mrb, mrb_options, "flags");
if (!mrb_nil_p(mrb_flags)) {
flags = mrb_fixnum(mrb_flags);
}
}
table_cursor = grn_table_cursor_open(ctx, table,
min, min_size,
max, max_size,
offset, limit, flags);
grn_mrb_value_to_raw_data_buffer_fin(mrb, &min_buffer);
grn_mrb_value_to_raw_data_buffer_fin(mrb, &max_buffer);
grn_mrb_ctx_check(mrb);
{
mrb_value mrb_table_cursor;
mrb_table_cursor = mrb_funcall(mrb, klass,
"new", 1, mrb_cptr_value(mrb, table_cursor));
mrb_iv_set(mrb, mrb_table_cursor, mrb_intern_lit(mrb, "@table"), mrb_table);
return mrb_table_cursor;
}
}
/* TODO: Fix memory leak on error */
static mrb_value
mrb_grn_table_sort(mrb_state *mrb, mrb_value self)
{
grn_ctx *ctx = (grn_ctx *)mrb->ud;
grn_obj *table;
grn_obj *result = NULL;
grn_table_sort_key *keys;
int i, n_keys;
int offset = 0;
int limit = -1;
mrb_value mrb_keys;
mrb_value mrb_options = mrb_nil_value();
table = DATA_PTR(self);
mrb_get_args(mrb, "o|H", &mrb_keys, &mrb_options);
mrb_keys = mrb_convert_type(mrb, mrb_keys,
MRB_TT_ARRAY, "Array", "to_ary");
n_keys = RARRAY_LEN(mrb_keys);
keys = GRN_MALLOCN(grn_table_sort_key, n_keys);
for (i = 0; i < n_keys; i++) {
mrb_value mrb_sort_options;
mrb_value mrb_sort_key;
mrb_value mrb_sort_order;
mrb_sort_options = RARRAY_PTR(mrb_keys)[i];
mrb_sort_key = grn_mrb_options_get_lit(mrb, mrb_sort_options, "key");
switch (mrb_type(mrb_sort_key)) {
case MRB_TT_STRING :
keys[i].key = grn_obj_column(ctx, table,
RSTRING_PTR(mrb_sort_key),
RSTRING_LEN(mrb_sort_key));
break;
case MRB_TT_SYMBOL :
{
const char *name;
mrb_int name_length;
name = mrb_sym2name_len(mrb, mrb_symbol(mrb_sort_key), &name_length);
keys[i].key = grn_obj_column(ctx, table, name, name_length);
}
break;
default :
/* TODO: free */
mrb_raisef(mrb, E_ARGUMENT_ERROR,
"sort key must be string or symbol: %S",
mrb_sort_key);
break;
}
keys[i].flags = 0;
mrb_sort_order = grn_mrb_options_get_lit(mrb, mrb_sort_options, "order");
if (mrb_nil_p(mrb_sort_order) ||
(mrb_symbol(mrb_sort_order) == mrb_intern_lit(mrb, "ascending"))) {
keys[i].flags |= GRN_TABLE_SORT_ASC;
} else {
keys[i].flags |= GRN_TABLE_SORT_DESC;
}
}
if (!mrb_nil_p(mrb_options)) {
mrb_value mrb_offset;
mrb_value mrb_limit;
mrb_offset = grn_mrb_options_get_lit(mrb, mrb_options, "offset");
if (!mrb_nil_p(mrb_offset)) {
offset = mrb_fixnum(mrb_offset);
}
mrb_limit = grn_mrb_options_get_lit(mrb, mrb_options, "limit");
if (!mrb_nil_p(mrb_limit)) {
limit = mrb_fixnum(mrb_limit);
}
}
result = grn_table_create(ctx, NULL, 0, NULL, GRN_TABLE_NO_KEY,
NULL, table);
grn_table_sort(ctx, table, offset, limit, result, keys, n_keys);
for (i = 0; i < n_keys; i++) {
grn_obj_unlink(ctx, keys[i].key);
}
GRN_FREE(keys);
grn_mrb_ctx_check(mrb);
return grn_mrb_value_from_grn_obj(mrb, result);
}
static mrb_value
mrb_grn_index_cursor_select(mrb_state *mrb, mrb_value self)
{
grn_ctx *ctx = (grn_ctx *)mrb->ud;
mrb_value mrb_result_set;
mrb_value mrb_options;
grn_obj *index_cursor;
grn_obj *expr = NULL;
grn_obj *expr_variable = NULL;
int offset = 0;
int limit = 10;
int n_matched_records = 0;
mrb_value mrb_index;
grn_obj *index;
grn_obj *lexicon;
grn_obj *data_table;
grn_hash *result_set;
grn_posting *posting;
grn_id term_id;
grn_operator op = GRN_OP_OR;
mrb_get_args(mrb, "o|H", &mrb_result_set, &mrb_options);
index_cursor = DATA_PTR(self);
result_set = DATA_PTR(mrb_result_set);
if (!mrb_nil_p(mrb_options)) {
mrb_value mrb_expr;
mrb_value mrb_offset;
mrb_value mrb_limit;
mrb_expr = grn_mrb_options_get_lit(mrb, mrb_options, "expression");
if (!mrb_nil_p(mrb_expr)) {
expr = DATA_PTR(mrb_expr);
expr_variable = grn_expr_get_var_by_offset(ctx, expr, 0);
}
mrb_offset = grn_mrb_options_get_lit(mrb, mrb_options, "offset");
if (!mrb_nil_p(mrb_offset)) {
offset = mrb_fixnum(mrb_offset);
}
mrb_limit = grn_mrb_options_get_lit(mrb, mrb_options, "limit");
if (!mrb_nil_p(mrb_limit)) {
limit = mrb_fixnum(mrb_limit);
}
}
if (limit <= 0) {
return mrb_fixnum_value(n_matched_records);
}
mrb_index = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@index"));
index = DATA_PTR(mrb_index);
lexicon = ((grn_ii *)index)->lexicon;
data_table = grn_ctx_at(ctx, grn_obj_get_range(ctx, index));
while ((posting = grn_index_cursor_next(ctx, index_cursor, &term_id))) {
if (expr) {
grn_bool matched_raw;
grn_obj *matched;
GRN_RECORD_SET(ctx, expr_variable, posting->rid);
matched = grn_expr_exec(ctx, expr, 0);
if (!matched) {
grn_mrb_ctx_check(mrb);
continue;
}
GRN_TRUEP(ctx, matched, matched_raw);
if (!matched_raw) {
continue;
}
}
n_matched_records++;
if (offset > 0) {
offset--;
continue;
}
grn_ii_posting_add(ctx, (grn_ii_posting *)posting, result_set, op);
limit--;
if (limit == 0) {
break;
}
}
grn_ii_resolve_sel_and(ctx, result_set, op);
return mrb_fixnum_value(n_matched_records);
}
static mrb_value
mrb_grn_table_delete(mrb_state *mrb, mrb_value self)
{
grn_ctx *ctx = (grn_ctx *)mrb->ud;
grn_obj *table;
mrb_value mrb_options;
mrb_value mrb_id;
mrb_value mrb_key;
mrb_value mrb_expression;
table = DATA_PTR(self);
mrb_get_args(mrb, "H", &mrb_options);
mrb_id = grn_mrb_options_get_lit(mrb, mrb_options, "id");
if (!mrb_nil_p(mrb_id)) {
grn_table_delete_by_id(ctx, table, mrb_fixnum(mrb_id));
grn_mrb_ctx_check(mrb);
return mrb_nil_value();
}
mrb_key = grn_mrb_options_get_lit(mrb, mrb_options, "key");
if (!mrb_nil_p(mrb_key)) {
grn_id key_domain_id;
void *key;
unsigned int key_size;
grn_mrb_value_to_raw_data_buffer buffer;
key_domain_id = table->header.domain;
grn_mrb_value_to_raw_data_buffer_init(mrb, &buffer);
grn_mrb_value_to_raw_data(mrb, "key", mrb_key, key_domain_id,
&buffer, &key, &key_size);
grn_table_delete(ctx, table, key, key_size);
grn_mrb_value_to_raw_data_buffer_fin(mrb, &buffer);
grn_mrb_ctx_check(mrb);
return mrb_nil_value();
}
mrb_expression = grn_mrb_options_get_lit(mrb, mrb_options, "expression");
if (!mrb_nil_p(mrb_expression)) {
grn_obj *expression;
grn_obj *selected_records;
grn_table_cursor *cursor;
expression = DATA_PTR(mrb_expression);
selected_records = grn_table_select(ctx, table, expression, NULL, GRN_OP_OR);
grn_mrb_ctx_check(mrb);
cursor = grn_table_cursor_open(ctx, selected_records,
NULL, 0,
NULL, 0,
0, -1, 0);
if (cursor) {
while (grn_table_cursor_next(ctx, cursor) != GRN_ID_NIL) {
grn_id *id;
grn_table_cursor_get_key(ctx, cursor, (void **)&id);
grn_table_delete_by_id(ctx, table, *id);
}
grn_table_cursor_close(ctx, cursor);
}
grn_mrb_ctx_check(mrb);
return mrb_nil_value();
}
mrb_raisef(mrb, E_ARGUMENT_ERROR,
"must have :id, :key or :expression: %S",
mrb_options);
return mrb_nil_value();
}
