static void update_data(grn_id record_id, unsigned int section, const gchar *old_name, const gchar *new_name) { grn_obj old_value, new_value; const gchar *old_data, *new_data; GRN_TEXT_INIT(&old_value, GRN_OBJ_DO_SHALLOW_COPY); GRN_TEXT_INIT(&new_value, GRN_OBJ_DO_SHALLOW_COPY); if (old_name) { old_data = cut_get_fixture_data_string(old_name, NULL); GRN_TEXT_SET_REF(&old_value, old_data, strlen(old_data)); } if (new_name) { new_data = cut_get_fixture_data_string(new_name, NULL); GRN_TEXT_SET_REF(&new_value, new_data, strlen(new_data)); } grn_ii_column_update(context, inverted_index, record_id, section, &old_value, &new_value, NULL); grn_obj_close(context, &old_value); grn_obj_close(context, &new_value); }
const GList * grn_test_view_collect_string(grn_ctx *context, grn_obj *view, const gchar *text_column_name) { GList *records = NULL; grn_table_cursor *cursor; grn_obj id, value; grn_obj *text_column; cursor = grn_table_cursor_open(context, view, NULL, 0, NULL, 0, 0, -1, GRN_CURSOR_ASCENDING); cut_assert_not_null(cursor); GRN_TEXT_INIT(&id, 0); GRN_TEXT_INIT(&value, 0); text_column = grn_obj_column(context, view, text_column_name, strlen(text_column_name)); while (grn_table_cursor_next_o(context, cursor, &id) == GRN_SUCCESS) { GRN_BULK_REWIND(&value); grn_obj_get_value_o(context, text_column, &id, &value); records = g_list_append(records, g_strndup(GRN_TEXT_VALUE(&value), GRN_TEXT_LEN(&value))); } grn_obj_unlink(context, &id); grn_obj_unlink(context, &value); grn_obj_unlink(context, text_column); gcut_take_list(records, g_free); grn_test_assert(grn_table_cursor_close(context, cursor)); grn_test_assert_context(context); return records; }
int table_put2(void) { int i; grn_obj keybuf, valbuf; grn_obj *key_type = grn_ctx_at(&ctx, GRN_DB_SHORT_TEXT); grn_obj *table = grn_table_create(&ctx, "<t1>", 4, NULL, GRN_OBJ_TABLE_HASH_KEY|GRN_OBJ_PERSISTENT, key_type, value_type); if (!table) { return -1; } for (i = 0; i < nloops; i++) { int key = GENKEY(i); GRN_TEXT_INIT(&keybuf, 0); grn_text_itoh(&ctx, &keybuf, key, key_size); { grn_id rid = grn_table_add(&ctx, table, GRN_BULK_HEAD(&keybuf), key_size, NULL); if (!rid) { fprintf(stderr, "table_lookup failed"); } else { GRN_TEXT_INIT(&valbuf, 0); grn_text_itoh(&ctx, &valbuf, key, key_size); if (grn_obj_set_value(&ctx, table, rid, &valbuf, GRN_OBJ_SET)) { fprintf(stderr, "grn_obj_set_value failed"); } grn_obj_close(&ctx, &valbuf); } } grn_obj_close(&ctx, &keybuf); } return 0; }
int table_get(void) { int i; grn_obj buf; grn_obj *table = grn_ctx_get(&ctx, "<t1>", 4); if (!table) { return -1; } GRN_TEXT_INIT(&buf, 0); for (i = 0; i < nloops; i++) { int key = GENKEY(i); GRN_BULK_REWIND(&buf); grn_text_itoh(&ctx, &buf, key, key_size); { grn_id rid = grn_table_get(&ctx, table, GRN_BULK_HEAD(&buf), key_size); if (!rid) { fprintf(stderr, "table_lookup failed"); } else { grn_obj obj, *p; GRN_TEXT_INIT(&obj, 0); p = grn_obj_get_value(&ctx, table, rid, &obj); if (!p) { fprintf(stderr, "grn_obj_get_value failed\n"); } else { if (memcmp(GRN_BULK_HEAD(p), GRN_BULK_HEAD(&buf), value_size)) { fprintf(stderr, "value unmatch\n"); } grn_obj_close(&ctx, p); } } } } grn_obj_close(&ctx, &buf); return 0; }
static void report_set_column_value_failure(grn_ctx *ctx, grn_obj *key, const char *column_name, unsigned int column_name_size, grn_obj *column_value) { grn_obj key_inspected, column_value_inspected; GRN_TEXT_INIT(&key_inspected, 0); GRN_TEXT_INIT(&column_value_inspected, 0); grn_inspect_limited(ctx, &key_inspected, key); grn_inspect_limited(ctx, &column_value_inspected, column_value); GRN_LOG(ctx, GRN_LOG_ERROR, "[table][load] failed to set column value: %s: " "key: <%.*s>, column: <%.*s>, value: <%.*s>", ctx->errbuf, (int)GRN_TEXT_LEN(&key_inspected), GRN_TEXT_VALUE(&key_inspected), column_name_size, column_name, (int)GRN_TEXT_LEN(&column_value_inspected), GRN_TEXT_VALUE(&column_value_inspected)); GRN_OBJ_FIN(ctx, &key_inspected); GRN_OBJ_FIN(ctx, &column_value_inspected); }
grn_rc grn_tokenizer_register(grn_ctx *ctx, const char *plugin_name_ptr, unsigned int plugin_name_length, grn_proc_func *init, grn_proc_func *next, grn_proc_func *fin) { grn_expr_var vars[] = { { NULL, 0 }, { NULL, 0 }, { NULL, 0 } }; GRN_TEXT_INIT(&vars[0].value, 0); GRN_TEXT_INIT(&vars[1].value, 0); GRN_UINT32_INIT(&vars[2].value, 0); { /* grn_proc_create() registers a plugin to the database which is associated with `ctx'. A returned object must not be finalized here. */ grn_obj * const obj = grn_proc_create(ctx, plugin_name_ptr, plugin_name_length, GRN_PROC_TOKENIZER, init, next, fin, 3, vars); if (obj == NULL) { GRN_PLUGIN_ERROR(ctx, GRN_TOKENIZER_ERROR, "grn_proc_create() failed"); return ctx->rc; } } return GRN_SUCCESS; }
static void load_synonyms(grn_ctx *ctx) { static char path_env[GRN_ENV_BUFFER_SIZE]; const char *path; grn_file_reader *file_reader; int number_of_lines; grn_encoding encoding; grn_obj line, key, value; grn_getenv("GRN_QUERY_EXPANDER_TSV_SYNONYMS_FILE", path_env, GRN_ENV_BUFFER_SIZE); if (path_env[0]) { path = path_env; } else { path = get_system_synonyms_file(); } file_reader = grn_file_reader_open(ctx, path); if (!file_reader) { GRN_LOG(ctx, GRN_LOG_WARNING, "[plugin][query-expander][tsv] " "synonyms file doesn't exist: <%s>", path); return; } GRN_TEXT_INIT(&line, 0); GRN_TEXT_INIT(&key, 0); GRN_TEXT_INIT(&value, 0); grn_bulk_reserve(ctx, &value, MAX_SYNONYM_BYTES); number_of_lines = 0; while (grn_file_reader_read_line(ctx, file_reader, &line) == GRN_SUCCESS) { const char *line_value = GRN_TEXT_VALUE(&line); size_t line_length = GRN_TEXT_LEN(&line); if (line_length > 0 && line_value[line_length - 1] == '\n') { if (line_length > 1 && line_value[line_length - 2] == '\r') { line_length -= 2; } else { line_length -= 1; } } number_of_lines++; if (number_of_lines == 1) { encoding = guess_encoding(ctx, &line_value, &line_length); } GRN_BULK_REWIND(&key); GRN_BULK_REWIND(&value); parse_synonyms_file_line(ctx, line_value, line_length, &key, &value); GRN_BULK_REWIND(&line); } GRN_OBJ_FIN(ctx, &line); GRN_OBJ_FIN(ctx, &key); GRN_OBJ_FIN(ctx, &value); grn_file_reader_close(ctx, file_reader); }
static int grn_token_cursor_next_apply_token_filters(grn_ctx *ctx, grn_token_cursor *token_cursor, grn_obj *current_token_data, grn_obj *status) { grn_obj *token_filters = token_cursor->token_filter.objects; unsigned int i, n_token_filters; grn_token current_token; grn_token next_token; if (token_filters) { n_token_filters = GRN_BULK_VSIZE(token_filters) / sizeof(grn_obj *); } else { n_token_filters = 0; } GRN_TEXT_INIT(&(current_token.data), GRN_OBJ_DO_SHALLOW_COPY); GRN_TEXT_SET(ctx, &(current_token.data), GRN_TEXT_VALUE(current_token_data), GRN_TEXT_LEN(current_token_data)); current_token.status = GRN_INT32_VALUE(status); GRN_TEXT_INIT(&(next_token.data), GRN_OBJ_DO_SHALLOW_COPY); GRN_TEXT_SET(ctx, &(next_token.data), GRN_TEXT_VALUE(&(current_token.data)), GRN_TEXT_LEN(&(current_token.data))); next_token.status = current_token.status; for (i = 0; i < n_token_filters; i++) { grn_obj *token_filter_object = GRN_PTR_VALUE_AT(token_filters, i); grn_proc *token_filter = (grn_proc *)token_filter_object; void *data = token_cursor->token_filter.data[i]; #define SKIP_FLAGS\ (GRN_TOKEN_SKIP |\ GRN_TOKEN_SKIP_WITH_POSITION) if (current_token.status & SKIP_FLAGS) { break; } #undef SKIP_FLAGS token_filter->callbacks.token_filter.filter(ctx, ¤t_token, &next_token, data); GRN_TEXT_SET(ctx, &(current_token.data), GRN_TEXT_VALUE(&(next_token.data)), GRN_TEXT_LEN(&(next_token.data))); current_token.status = next_token.status; } token_cursor->curr = (const unsigned char *)GRN_TEXT_VALUE(&(current_token.data)); token_cursor->curr_size = GRN_TEXT_LEN(&(current_token.data)); return current_token.status; }
static grn_obj * command_tag_synonym_delete(grn_ctx *ctx, GNUC_UNUSED int nargs, GNUC_UNUSED grn_obj **args, grn_user_data *user_data) { grn_obj *var, *table, *column; unsigned int nhooks = 0; char *table_name = NULL; unsigned int table_len = 0; char *column_name = NULL; unsigned int column_len = 0; var = grn_plugin_proc_get_var(ctx, user_data, "table", -1); if (GRN_TEXT_LEN(var) != 0) { table_name = GRN_TEXT_VALUE(var); table_len = GRN_TEXT_LEN(var); } var = grn_plugin_proc_get_var(ctx, user_data, "column", -1); if (GRN_TEXT_LEN(var) != 0) { column_name = GRN_TEXT_VALUE(var); column_len = GRN_TEXT_LEN(var); } table = grn_ctx_get(ctx, table_name, table_len); column = grn_obj_column(ctx, table, column_name, column_len); nhooks = grn_obj_get_nhooks(ctx, column, GRN_HOOK_SET); if (nhooks) { grn_obj *hook; unsigned int i; grn_obj data; grn_obj buf; GRN_TEXT_INIT(&buf, 0); GRN_TEXT_INIT(&data, 0); for (i=0; i < nhooks; i++) { GRN_BULK_REWIND(&buf); GRN_BULK_REWIND(&data); hook = grn_obj_get_hook(ctx, column, GRN_HOOK_SET, i, &data); grn_inspect_name(ctx, &buf, hook); if (GRN_TEXT_LEN(&buf) == strlen("tag_synonym") && strncmp(GRN_TEXT_VALUE(&buf), "tag_synonym", GRN_TEXT_LEN(&buf)) == 0) { grn_obj_delete_hook(ctx, column, GRN_HOOK_SET, i); break; } } grn_obj_unlink(ctx, &data); grn_obj_unlink(ctx, &buf); } nhooks = grn_obj_get_nhooks(ctx, column, GRN_HOOK_SET); //grn_ctx_output_array_open(ctx, "RESULT", 1); grn_ctx_output_int32(ctx, nhooks); //grn_ctx_output_array_close(ctx); return NULL; }
static ngx_int_t ngx_http_groonga_handler_create_data(ngx_http_request_t *r, ngx_http_groonga_handler_data_t **data_return) { ngx_int_t rc; ngx_http_groonga_loc_conf_t *location_conf; ngx_http_cleanup_t *cleanup; ngx_http_groonga_handler_data_t *data; grn_ctx *context; location_conf = ngx_http_get_module_loc_conf(r, ngx_http_groonga_module); cleanup = ngx_http_cleanup_add(r, sizeof(ngx_http_groonga_handler_data_t)); cleanup->handler = ngx_http_groonga_handler_cleanup; data = cleanup->data; *data_return = data; context = &(data->context); rc = ngx_http_groonga_context_init(context, location_conf, r->pool, r->connection->log); if (rc != NGX_OK) { return rc; } data->initialized = GRN_TRUE; data->raw.processed = GRN_FALSE; data->raw.header_sent = GRN_FALSE; data->raw.r = r; data->raw.rc = NGX_OK; data->raw.free_chain = NULL; data->raw.busy_chain = NULL; GRN_TEXT_INIT(&(data->typed.head), GRN_NO_FLAGS); GRN_TEXT_INIT(&(data->typed.body), GRN_NO_FLAGS); GRN_TEXT_INIT(&(data->typed.foot), GRN_NO_FLAGS); grn_ctx_use(context, grn_ctx_db(&(location_conf->context))); rc = ngx_http_groonga_context_check_error(r->connection->log, context); if (rc != NGX_OK) { return rc; } grn_ctx_recv_handler_set(context, ngx_http_groonga_context_receive_handler, data); return NGX_OK; }
MRN_API my_bool mroonga_escape_init(UDF_INIT *initid, UDF_ARGS *args, char *message) { EscapeInfo *info = NULL; initid->ptr = NULL; if (!(1 <= args->arg_count && args->arg_count <= 2)) { sprintf(message, "mroonga_escape(): Incorrect number of arguments: %u for 1..2", args->arg_count); goto error; } if (args->arg_type[0] != STRING_RESULT) { strcpy(message, "mroonga_escape(): The 1st argument must be query as string"); goto error; } if (args->arg_count == 2) { if (args->arg_type[1] != STRING_RESULT) { strcpy(message, "mroonga_escape(): " "The 2st argument must be escape target characters as string"); goto error; } } initid->maybe_null = 1; initid->const_item = 0; info = (EscapeInfo *)mrn_my_malloc(sizeof(EscapeInfo), MYF(MY_WME | MY_ZEROFILL)); if (!info) { strcpy(message, "mroonga_escape(): out of memory"); goto error; } grn_ctx_init(&(info->ctx), 0); GRN_TEXT_INIT(&(info->target_characters), 0); GRN_TEXT_INIT(&(info->escaped_query), 0); initid->ptr = (char *)info; return FALSE; error: if (info) { grn_ctx_fin(&(info->ctx)); my_free(info); } return TRUE; }
grn_obj * grn_command_input_add(grn_ctx *ctx, grn_command_input *input, const char *name, int name_size, grn_bool *added) { grn_obj *argument = NULL; /* TODO: Use grn_bool */ int internal_added = GRN_FALSE; GRN_API_ENTER; if (name_size == -1) { name_size = strlen(name); } if (input->arguments) { grn_hash_add(ctx, input->arguments, name, name_size, (void **)&argument, &internal_added); if (internal_added) { GRN_TEXT_INIT(argument, 0); } } if (added) { *added = internal_added; } GRN_API_RETURN(argument); }
static grn_obj * delimited_init(grn_ctx *ctx, grn_obj *table, grn_user_data *user_data, uint8_t *delimiter, uint32_t delimiter_len) { grn_obj *str; int nflags = 0; grn_delimited_tokenizer *token; grn_obj_flags table_flags; if (!(str = grn_ctx_pop(ctx))) { ERR(GRN_INVALID_ARGUMENT, "missing argument"); return NULL; } if (!(token = GRN_MALLOC(sizeof(grn_delimited_tokenizer)))) { return NULL; } user_data->ptr = token; token->delimiter = delimiter; token->delimiter_len = delimiter_len; token->pos = 0; grn_table_get_info(ctx, table, &table_flags, &token->encoding, NULL); nflags |= (table_flags & GRN_OBJ_KEY_NORMALIZE); if (!(token->nstr = grn_str_open_(ctx, GRN_TEXT_VALUE(str), GRN_TEXT_LEN(str), nflags, token->encoding))) { GRN_FREE(token); ERR(GRN_TOKENIZER_ERROR, "grn_str_open failed at grn_token_open"); return NULL; } token->next = (unsigned char *)token->nstr->norm; token->end = token->next + token->nstr->norm_blen; token->len = token->nstr->length; GRN_TEXT_INIT(&token->curr_, GRN_OBJ_DO_SHALLOW_COPY); GRN_UINT32_INIT(&token->stat_, 0); return NULL; }
static grn_obj * command_query_expand(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data) { const char *expander; size_t expander_size; const char *query; size_t query_size; const char *flags_raw; size_t flags_raw_size; grn_expr_flags flags = GRN_EXPR_SYNTAX_QUERY; grn_obj expanded_query; expander = grn_plugin_proc_get_var_string(ctx, user_data, "expander", -1, &expander_size); query = grn_plugin_proc_get_var_string(ctx, user_data, "query", -1, &query_size); flags_raw = grn_plugin_proc_get_var_string(ctx, user_data, "flags", -1, &flags_raw_size); if (flags_raw_size > 0) { flags |= grn_proc_expr_query_flags_parse(ctx, flags_raw, flags_raw_size, "[query][expand]"); } else { flags |= GRN_EXPR_ALLOW_PRAGMA | GRN_EXPR_ALLOW_COLUMN; } if (ctx->rc != GRN_SUCCESS) { return NULL; } GRN_TEXT_INIT(&expanded_query, 0); grn_proc_syntax_expand_query(ctx, query, query_size, flags, expander, expander_size, &expanded_query, "[query][expand]"); if (ctx->rc == GRN_SUCCESS) { grn_ctx_output_str(ctx, GRN_TEXT_VALUE(&expanded_query), GRN_TEXT_LEN(&expanded_query)); } GRN_OBJ_FIN(ctx, &expanded_query); return NULL; }
const GList * grn_test_table_collect_string(grn_ctx *context, grn_obj *table, const gchar *text_column_name) { GList *records = NULL; grn_table_cursor *cursor; grn_id id; grn_obj *text_column; grn_obj value; cursor = grn_table_cursor_open(context, table, NULL, 0, NULL, 0, 0, -1, GRN_CURSOR_ASCENDING); grn_test_assert_context(context); text_column = grn_obj_column(context, table, text_column_name, strlen(text_column_name)); GRN_TEXT_INIT(&value, 0); while ((id = grn_table_cursor_next(context, cursor)) != GRN_ID_NIL) { GRN_BULK_REWIND(&value); grn_obj_get_value(context, text_column, id, &value); records = g_list_append(records, g_strndup(GRN_TEXT_VALUE(&value), GRN_TEXT_LEN(&value))); } grn_obj_unlink(context, &value); grn_obj_unlink(context, text_column); gcut_take_list(records, g_free); grn_test_assert(grn_table_cursor_close(context, cursor)); grn_test_assert_context(context); return records; }
static void command_schema_output_plugins(grn_ctx *ctx) { grn_obj plugin_names; unsigned int i, n; GRN_TEXT_INIT(&plugin_names, GRN_OBJ_VECTOR); grn_plugin_get_names(ctx, &plugin_names); grn_ctx_output_cstr(ctx, "plugins"); n = grn_vector_size(ctx, &plugin_names); grn_ctx_output_map_open(ctx, "plugins", n); for (i = 0; i < n; i++) { const char *name; unsigned int name_size; name_size = grn_vector_get_element(ctx, &plugin_names, i, &name, NULL, NULL); grn_ctx_output_str(ctx, name, name_size); grn_ctx_output_map_open(ctx, "plugin", 1); grn_ctx_output_cstr(ctx, "name"); grn_ctx_output_str(ctx, name, name_size); grn_ctx_output_map_close(ctx); } grn_ctx_output_map_close(ctx); GRN_OBJ_FIN(ctx, &plugin_names); }
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); }
grn_rc grn_db_init_builtin_tokenizers(grn_ctx *ctx) { grn_obj *obj, results[2]; GRN_UINT32_INIT(&results[0], 0); GRN_TEXT_INIT(&results[1], 0); obj = grn_proc_create(ctx, "<token:delimit>", 15, NULL, delimit_init, delimited_next, delimited_fin, 1, 2, results); if (!obj || ((grn_db_obj *)obj)->id != GRN_DB_DELIMIT) { return GRN_FILE_CORRUPT; } obj = grn_proc_create(ctx, "<token:unigram>", 15, NULL, unigram_init, ngram_next, ngram_fin, 1, 2, results); if (!obj || ((grn_db_obj *)obj)->id != GRN_DB_UNIGRAM) { return GRN_FILE_CORRUPT; } obj = grn_proc_create(ctx, "<token:bigram>", 14, NULL, bigram_init, ngram_next, ngram_fin, 1, 2, results); if (!obj || ((grn_db_obj *)obj)->id != GRN_DB_BIGRAM) { return GRN_FILE_CORRUPT; } obj = grn_proc_create(ctx, "<token:trigram>", 15, NULL, trigram_init, ngram_next, ngram_fin, 1, 2, results); if (!obj || ((grn_db_obj *)obj)->id != GRN_DB_TRIGRAM) { return GRN_FILE_CORRUPT; } #ifndef NO_MECAB obj = grn_proc_create(ctx, "<token:mecab>", 13, NULL, mecab_init, mecab_next, mecab_fin, 1, 2, results); #endif /* NO_MECAB */ if (!obj || ((grn_db_obj *)obj)->id != GRN_DB_MECAB) { return GRN_FILE_CORRUPT; } return GRN_SUCCESS; }
int pat_get(const char *path) { int i; grn_obj buf; grn_pat *pat = grn_pat_open(&ctx, path); if (!pat) { return -1; } GRN_TEXT_INIT(&buf, 0); for (i = 0; i < nloops; i++) { int key = GENKEY(i); GRN_BULK_REWIND(&buf); grn_text_itoh(&ctx, &buf, key, key_size); { void *value; grn_id rid = grn_pat_get(&ctx, pat, GRN_BULK_HEAD(&buf), key_size, &value); if (!rid) { fprintf(stderr, "table_lookup failed"); } else { if (memcmp(value, GRN_BULK_HEAD(&buf), value_size)) { fprintf(stderr, "value unmatch %d: %d != %d\n", i, *((int *)value), key); } } } } grn_obj_close(&ctx, &buf); grn_pat_close(&ctx, pat); return 0; }
static grn_id parse_id_value(grn_ctx *ctx, grn_obj *value) { switch (value->header.type) { case GRN_DB_UINT32 : return GRN_UINT32_VALUE(value); case GRN_DB_INT32 : return GRN_INT32_VALUE(value); default : { grn_id id = GRN_ID_NIL; grn_obj casted_value; GRN_UINT32_INIT(&casted_value, 0); if (grn_obj_cast(ctx, value, &casted_value, GRN_FALSE) != GRN_SUCCESS) { grn_obj inspected; GRN_TEXT_INIT(&inspected, 0); grn_inspect(ctx, &inspected, value); ERR(GRN_INVALID_ARGUMENT, "<%s>: failed to cast to <UInt32>: <%.*s>", GRN_COLUMN_NAME_ID, (int)GRN_TEXT_LEN(&inspected), GRN_TEXT_VALUE(&inspected)); GRN_OBJ_FIN(ctx, &inspected); } else { id = GRN_UINT32_VALUE(&casted_value); } GRN_OBJ_FIN(ctx, &casted_value); return id; } } }
static mrb_value mrb_grn_cache_fetch(mrb_state *mrb, mrb_value self) { grn_ctx *ctx = (grn_ctx *)mrb->ud; grn_cache *cache; char *key; mrb_int key_size; grn_rc rc; grn_obj cache_value; mrb_value mrb_cache_value; cache = DATA_PTR(self); mrb_get_args(mrb, "s", &key, &key_size); GRN_TEXT_INIT(&cache_value, 0); rc = grn_cache_fetch(ctx, cache, key, key_size, &cache_value); if (rc == GRN_SUCCESS) { mrb_cache_value = grn_mrb_value_from_bulk(mrb, &cache_value); } else { mrb_cache_value = mrb_nil_value(); } GRN_OBJ_FIN(ctx, &cache_value); return mrb_cache_value; }
void grn_output_geo_point(grn_ctx *ctx, grn_obj *outbuf, grn_content_type output_type, grn_geo_point *value) { put_delimiter(ctx, outbuf, output_type); switch (output_type) { case GRN_CONTENT_JSON: if (value) { GRN_TEXT_PUTC(ctx, outbuf, '"'); grn_text_itoa(ctx, outbuf, value->latitude); GRN_TEXT_PUTC(ctx, outbuf, 'x'); grn_text_itoa(ctx, outbuf, value->longitude); GRN_TEXT_PUTC(ctx, outbuf, '"'); } else { GRN_TEXT_PUTS(ctx, outbuf, "null"); } break; case GRN_CONTENT_TSV: if (value) { GRN_TEXT_PUTC(ctx, outbuf, '"'); grn_text_itoa(ctx, outbuf, value->latitude); GRN_TEXT_PUTC(ctx, outbuf, 'x'); grn_text_itoa(ctx, outbuf, value->longitude); GRN_TEXT_PUTC(ctx, outbuf, '"'); } else { GRN_TEXT_PUTS(ctx, outbuf, "\"\""); } break; case GRN_CONTENT_XML: GRN_TEXT_PUTS(ctx, outbuf, "<GEO_POINT>"); if (value) { grn_text_itoa(ctx, outbuf, value->latitude); GRN_TEXT_PUTC(ctx, outbuf, 'x'); grn_text_itoa(ctx, outbuf, value->longitude); } GRN_TEXT_PUTS(ctx, outbuf, "</GEO_POINT>"); break; case GRN_CONTENT_MSGPACK : #ifdef HAVE_MESSAGE_PACK if (value) { grn_obj buf; GRN_TEXT_INIT(&buf, 0); grn_text_itoa(ctx, &buf, value->latitude); GRN_TEXT_PUTC(ctx, &buf, 'x'); grn_text_itoa(ctx, &buf, value->longitude); msgpack_pack_raw(&ctx->impl->msgpacker, GRN_TEXT_LEN(&buf)); msgpack_pack_raw_body(&ctx->impl->msgpacker, GRN_TEXT_VALUE(&buf), GRN_TEXT_LEN(&buf)); grn_obj_close(ctx, &buf); } else { msgpack_pack_nil(&ctx->impl->msgpacker); } #endif break; case GRN_CONTENT_NONE: break; } INCR_LENGTH; }
static grn_obj * command_ruby_eval(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data) { grn_obj *script; mrb_value result; script = VAR(0); switch (script->header.domain) { case GRN_DB_SHORT_TEXT : case GRN_DB_TEXT : case GRN_DB_LONG_TEXT : break; default : { grn_obj inspected; GRN_TEXT_INIT(&inspected, 0); grn_inspect(ctx, &inspected, script); ERR(GRN_INVALID_ARGUMENT, "script must be a string: <%.*s>", (int)GRN_TEXT_LEN(&inspected), GRN_TEXT_VALUE(&inspected)); GRN_OBJ_FIN(ctx, &inspected); return NULL; } break; } result = grn_mrb_eval(ctx, GRN_TEXT_VALUE(script), GRN_TEXT_LEN(script)); output_result(ctx, result); return NULL; }
int pat_put(const char *path) { int i; grn_obj buf; grn_pat *pat = grn_pat_create(&ctx, path, key_size, value_size, GRN_OBJ_PERSISTENT|GRN_OBJ_KEY_VAR_SIZE); if (!pat) { return -1; } GRN_TEXT_INIT(&buf, 0); for (i = 0; i < nloops; i++) { int key = GENKEY(i); GRN_BULK_REWIND(&buf); grn_text_itoh(&ctx, &buf, key, key_size); { void *value; grn_id rid = grn_pat_add(&ctx, pat, GRN_BULK_HEAD(&buf), key_size, &value, NULL); if (!rid) { fprintf(stderr, "table_lookup failed"); } else { memcpy(value, GRN_BULK_HEAD(&buf), value_size); } } } grn_obj_close(&ctx, &buf); grn_pat_close(&ctx, pat); return 0; }
void ConditionConverter::convert_between(const Item_func *func_item, grn_obj *expression) { MRN_DBUG_ENTER_METHOD(); Item **arguments = func_item->arguments(); Item *target_item = arguments[0]; Item *min_item = arguments[1]; Item *max_item = arguments[2]; grn_obj *between_func = grn_ctx_get(ctx_, "between", strlen("between")); grn_expr_append_obj(ctx_, expression, between_func, GRN_OP_PUSH, 1); const Item_field *field_item = static_cast<const Item_field *>(target_item); append_field_value(field_item, expression); grn_obj include; mrn::SmartGrnObj smart_include(ctx_, &include); GRN_TEXT_INIT(&include, 0); GRN_TEXT_PUTS(ctx_, &include, "include"); append_const_item(field_item, min_item, expression); grn_expr_append_const(ctx_, expression, &include, GRN_OP_PUSH, 1); append_const_item(field_item, max_item, expression); grn_expr_append_const(ctx_, expression, &include, GRN_OP_PUSH, 1); grn_expr_append_op(ctx_, expression, GRN_OP_CALL, 5); grn_expr_append_op(ctx_, expression, GRN_OP_AND, 2); DBUG_VOID_RETURN; }
/* * call-seq: * _expression_.inspect -> String * * _expression_の中身を人に見やすい文字列で返す。 */ static VALUE rb_grn_expression_inspect (VALUE self) { grn_ctx *context = NULL; grn_obj inspected; grn_obj *expression; VALUE rb_inspected; rb_grn_expression_deconstruct(SELF(self), &expression, &context, NULL, NULL, NULL, NULL, NULL); GRN_TEXT_INIT(&inspected, 0); GRN_TEXT_PUTS(context, &inspected, "#<Groonga::Expression "); #ifdef WIN32 GRN_TEXT_PUTS(context, &inspected, "(not supported on Windows)"); #else grn_expr_inspect(context, &inspected, expression); #endif GRN_TEXT_PUTS(context, &inspected, ">"); rb_inspected = rb_grn_context_rb_string_new(context, GRN_TEXT_VALUE(&inspected), GRN_TEXT_LEN(&inspected)); GRN_OBJ_FIN(context, &inspected); return rb_inspected; }
static grn_rc ngram_init(grn_ctx *ctx, grn_obj *table, grn_proc_data *user_data, uint8_t ngram_unit) { grn_obj *str; int nflags = GRN_STR_REMOVEBLANK|GRN_STR_WITH_CTYPES; grn_ngram_tokenizer *token; grn_obj_flags table_flags; if (!(str = grn_ctx_pop(ctx))) { return GRN_INVALID_ARGUMENT; } if (!(token = GRN_MALLOC(sizeof(grn_ngram_tokenizer)))) { return ctx->rc; } user_data->ptr = token; token->uni_alpha = 1; token->uni_digit = 1; token->uni_symbol = 1; token->ngram_unit = ngram_unit; token->overlap = 0; token->pos = 0; token->skip = 0; grn_table_get_info(ctx, table, &table_flags, &token->encoding, NULL); nflags |= (table_flags & GRN_OBJ_KEY_NORMALIZE); if (!(token->nstr = grn_str_open_(ctx, GRN_TEXT_VALUE(str), GRN_TEXT_LEN(str), nflags, token->encoding))) { GRN_LOG(ctx, GRN_LOG_ALERT, "grn_str_open failed at grn_token_open"); return GRN_TOKENIZER_ERROR; } token->next = (unsigned char *)token->nstr->norm; token->end = token->next + token->nstr->norm_blen; token->ctypes = token->nstr->ctypes; token->len = token->nstr->length; GRN_TEXT_INIT(&token->curr_, GRN_OBJ_DO_SHALLOW_COPY); GRN_UINT32_INIT(&token->stat_, 0); return GRN_SUCCESS; }
/* * Document-method: column_value * * call-seq: * view.column_value(id, name) -> 値 * * _view_の_id_に対応するカラム_name_の値を返す。 */ static VALUE rb_grn_view_get_column_value (VALUE self, VALUE rb_id, VALUE rb_name) { VALUE rb_value = Qnil; #ifdef WIN32 rb_raise(rb_eNotImpError, "grn_obj_get_value_o() isn't available on Windows."); #else RbGrnTable *rb_view; grn_ctx *context = NULL; grn_obj *view, *value, *accessor; grn_obj id; rb_view = SELF(self); rb_grn_table_deconstruct(rb_view, &view, &context, NULL, NULL, &value, NULL, NULL, NULL); GRN_BULK_REWIND(value); GRN_TEXT_INIT(&id, 0); GRN_TEXT_PUT(context, &id, RSTRING_PTR(rb_id), RSTRING_LEN(rb_id)); accessor = grn_obj_column(context, view, RSTRING_PTR(rb_name), RSTRING_LEN(rb_name)); grn_obj_get_value_o(context, accessor, &id, value); grn_obj_unlink(context, accessor); rb_value = GRNOBJ2RVAL(Qnil, context, value, self); GRN_OBJ_FIN(context, &id); #endif return rb_value; }
void test_table_scan(void) { grn_obj *cond, *v, *res, textbuf, intbuf; GRN_TEXT_INIT(&textbuf, 0); GRN_UINT32_INIT(&intbuf, 0); prepare_data(&textbuf, &intbuf); cut_assert_not_null((cond = grn_expr_create(&context, NULL, 0))); v = grn_expr_add_var(&context, cond, NULL, 0); GRN_RECORD_INIT(v, 0, grn_obj_id(&context, docs)); grn_expr_append_obj(&context, cond, v); GRN_TEXT_SETS(&context, &textbuf, "size"); grn_expr_append_const(&context, cond, &textbuf); grn_expr_append_op(&context, cond, GRN_OP_OBJ_GET_VALUE, 2); GRN_UINT32_SET(&context, &intbuf, 14); grn_expr_append_const(&context, cond, &intbuf); grn_expr_append_op(&context, cond, GRN_OP_EQUAL, 2); grn_expr_compile(&context, cond); res = grn_table_create(&context, NULL, 0, NULL, GRN_TABLE_HASH_KEY|GRN_OBJ_WITH_SUBREC, docs, 0); cut_assert_not_null(res); grn_test_assert(grn_table_scan(&context, docs, cond, res, GRN_SEL_OR)); cut_assert_equal_uint(3, grn_table_size(&context, res)); grn_test_assert(grn_obj_close(&context, res)); grn_test_assert(grn_obj_close(&context, cond)); grn_test_assert(grn_obj_close(&context, &textbuf)); grn_test_assert(grn_obj_close(&context, &intbuf)); }
static grn_obj * snippet_exec(grn_ctx *ctx, grn_obj *snip, grn_obj *text, grn_user_data *user_data, const char *prefix, int prefix_length, const char *suffix, int suffix_length) { grn_rc rc; unsigned int i, n_results, max_tagged_length; grn_obj snippet_buffer; grn_obj *snippets; if (GRN_TEXT_LEN(text) == 0) { return NULL; } rc = grn_snip_exec(ctx, snip, GRN_TEXT_VALUE(text), GRN_TEXT_LEN(text), &n_results, &max_tagged_length); if (rc != GRN_SUCCESS) { return NULL; } if (n_results == 0) { return grn_plugin_proc_alloc(ctx, user_data, GRN_DB_VOID, 0); } snippets = grn_plugin_proc_alloc(ctx, user_data, GRN_DB_SHORT_TEXT, GRN_OBJ_VECTOR); if (!snippets) { return NULL; } GRN_TEXT_INIT(&snippet_buffer, 0); grn_bulk_space(ctx, &snippet_buffer, prefix_length + max_tagged_length + suffix_length); for (i = 0; i < n_results; i++) { unsigned int snippet_length; GRN_BULK_REWIND(&snippet_buffer); if (prefix_length) { GRN_TEXT_PUT(ctx, &snippet_buffer, prefix, prefix_length); } rc = grn_snip_get_result(ctx, snip, i, GRN_TEXT_VALUE(&snippet_buffer) + prefix_length, &snippet_length); if (rc == GRN_SUCCESS) { grn_strncat(GRN_TEXT_VALUE(&snippet_buffer), GRN_BULK_WSIZE(&snippet_buffer), suffix, suffix_length); grn_vector_add_element(ctx, snippets, GRN_TEXT_VALUE(&snippet_buffer), prefix_length + snippet_length + suffix_length, 0, GRN_DB_SHORT_TEXT); } } GRN_OBJ_FIN(ctx, &snippet_buffer); return snippets; }