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(); }