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); }
static grn_obj * command_echo(grn_ctx *ctx, GNUC_UNUSED int nargs, GNUC_UNUSED grn_obj **args, grn_user_data *user_data) { grn_obj *var; char *input = NULL; unsigned int input_len = 0; var = grn_plugin_proc_get_var(ctx, user_data, "input", -1); GRN_PLUGIN_LOG(ctx, GRN_LOG_NOTICE, "[echo] input = %.*s", (int)GRN_TEXT_LEN(var), GRN_TEXT_VALUE(var)); if(GRN_TEXT_LEN(var) != 0) { input = GRN_TEXT_VALUE(var); input_len = GRN_TEXT_LEN(var); } grn_ctx_output_array_open(ctx, "RESULT", 2); grn_ctx_output_cstr(ctx, input); grn_ctx_output_int64(ctx, input_len); grn_ctx_output_array_close(ctx); return NULL; }
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; }
static grn_obj * proc_table_create(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data) { uint32_t nvars; grn_obj *buf = args[0]; grn_expr_var *vars; grn_proc_get_info(ctx, user_data, &vars, &nvars, NULL); if (nvars == 6) { grn_obj *table; grn_obj_flags flags = grn_atoi(GRN_TEXT_VALUE(&vars[1].value), GRN_BULK_CURR(&vars[1].value), NULL); if (GRN_TEXT_LEN(&vars[0].value)) { flags |= GRN_OBJ_PERSISTENT; } table = grn_table_create(ctx, GRN_TEXT_VALUE(&vars[0].value), GRN_TEXT_LEN(&vars[0].value), NULL, flags, grn_ctx_get(ctx, GRN_TEXT_VALUE(&vars[2].value), GRN_TEXT_LEN(&vars[2].value)), grn_ctx_get(ctx, GRN_TEXT_VALUE(&vars[3].value), GRN_TEXT_LEN(&vars[3].value))); if (table) { grn_obj_set_info(ctx, table, GRN_INFO_DEFAULT_TOKENIZER, grn_ctx_get(ctx, GRN_TEXT_VALUE(&vars[4].value), GRN_TEXT_LEN(&vars[4].value))); grn_obj_unlink(ctx, table); } GRN_TEXT_PUTS(ctx, buf, ctx->rc ? "false" : "true"); } return buf; }
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; }
static void parse_synonyms_file_line(grn_ctx *ctx, const char *line, size_t line_length, grn_obj *key, grn_obj *value) { size_t i = 0; if (is_comment_mark(line[i])) { return; } while (i < line_length) { char character = line[i]; i++; if (character == '\t') { break; } GRN_TEXT_PUTC(ctx, key, character); } if (i == line_length) { return; } GRN_TEXT_PUTS(ctx, value, "(("); while (i < line_length) { char character = line[i]; i++; if (character == '\t') { GRN_TEXT_PUTS(ctx, value, ") OR ("); } else { GRN_TEXT_PUTC(ctx, value, character); } } GRN_TEXT_PUTS(ctx, value, "))"); { grn_id id; void *value_location = NULL; id = grn_hash_add(ctx, synonyms, GRN_TEXT_VALUE(key), GRN_TEXT_LEN(key), &value_location, NULL); if (id == GRN_ID_NIL) { GRN_PLUGIN_LOG(ctx, GRN_LOG_WARNING, "[plugin][query-expander][tsv] " "failed to register key: <%.*s>", (int)GRN_TEXT_LEN(key), GRN_TEXT_VALUE(key)); return; } if (GRN_TEXT_LEN(value) <= MAX_SYNONYM_BYTES - 1) { GRN_TEXT_PUTC(ctx, value, '\0'); } else { grn_bulk_truncate(ctx, value, MAX_SYNONYM_BYTES - 1); GRN_TEXT_PUTC(ctx, value, '\0'); } grn_memcpy(value_location, GRN_TEXT_VALUE(value), GRN_TEXT_LEN(value)); } }
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 VALUE rb_grn_bulk_to_ruby_object_by_range_id (grn_ctx *context, grn_obj *bulk, grn_id range_id, VALUE related_object, VALUE *rb_value) { grn_bool success = GRN_TRUE; switch (range_id) { case GRN_DB_VOID: *rb_value = rb_str_new(GRN_TEXT_VALUE(bulk), GRN_TEXT_LEN(bulk)); break; case GRN_DB_BOOL: *rb_value = GRN_BOOL_VALUE(bulk) ? Qtrue : Qfalse; break; case GRN_DB_INT32: *rb_value = INT2NUM(GRN_INT32_VALUE(bulk)); break; case GRN_DB_UINT32: *rb_value = UINT2NUM(GRN_UINT32_VALUE(bulk)); break; case GRN_DB_INT64: *rb_value = LL2NUM(GRN_INT64_VALUE(bulk)); break; case GRN_DB_UINT64: *rb_value = ULL2NUM(GRN_UINT64_VALUE(bulk)); break; case GRN_DB_FLOAT: *rb_value = rb_float_new(GRN_FLOAT_VALUE(bulk)); break; case GRN_DB_TIME: { int64_t time_value, sec, usec; time_value = GRN_TIME_VALUE(bulk); GRN_TIME_UNPACK(time_value, sec, usec); *rb_value = rb_funcall(rb_cTime, rb_intern("at"), 2, LL2NUM(sec), LL2NUM(usec)); } break; case GRN_DB_SHORT_TEXT: case GRN_DB_TEXT: case GRN_DB_LONG_TEXT: *rb_value = rb_grn_context_rb_string_new(context, GRN_TEXT_VALUE(bulk), GRN_TEXT_LEN(bulk)); break; default: success = GRN_FALSE; break; } return success; }
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 grn_bool exec_text_operator_text_text(grn_ctx *ctx, grn_operator op, grn_obj *target, grn_obj *query) { return exec_text_operator_raw_text_raw_text(ctx, op, GRN_TEXT_VALUE(target), GRN_TEXT_LEN(target), GRN_TEXT_VALUE(query), GRN_TEXT_LEN(query)); }
static void stem_filter(grn_ctx *ctx, grn_token *current_token, grn_token *next_token, void *user_data) { grn_stem_token_filter *token_filter = user_data; grn_obj *data; if (GRN_CTX_GET_ENCODING(ctx) != GRN_ENC_UTF8) { return; } data = grn_token_get_data(ctx, current_token); if (token_filter->stemmer) { sb_stemmer_delete(token_filter->stemmer); } { /* TODO: Detect algorithm from the current token. */ const char *algorithm = "english"; const char *encoding = "UTF_8"; token_filter->stemmer = sb_stemmer_new(algorithm, encoding); if (!token_filter->stemmer) { GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT, "[token-filter][stem] " "failed to create stemmer: " "algorithm=<%s>, encoding=<%s>", algorithm, encoding); return; } } { const sb_symbol *stemmed; stemmed = sb_stemmer_stem(token_filter->stemmer, GRN_TEXT_VALUE(data), GRN_TEXT_LEN(data)); if (stemmed) { grn_token_set_data(ctx, next_token, stemmed, sb_stemmer_length(token_filter->stemmer)); } else { GRN_PLUGIN_ERROR(ctx, GRN_NO_MEMORY_AVAILABLE, "[token-filter][stem] " "failed to allocate memory for stemmed word: <%.*s>", (int)GRN_TEXT_LEN(data), GRN_TEXT_VALUE(data)); return; } } }
static grn_obj * func_snippet_tritonn(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data) { grn_obj *snippets = NULL; if (nargs > 10) { grn_obj *text = args[0]; grn_obj *snip = NULL; unsigned int width = GRN_UINT64_VALUE(args[1]); unsigned int max_n_results = GRN_UINT64_VALUE(args[2]); grn_snip_mapping *mapping = NULL; int flags = GRN_SNIP_COPY_TAG; if(GRN_UINT64_VALUE(args[4])){ flags |= GRN_SNIP_SKIP_LEADING_SPACES; } if(GRN_UINT64_VALUE(args[5])){ mapping = GRN_SNIP_MAPPING_HTML_ESCAPE; } snip = grn_snip_open(ctx, flags, width, max_n_results, "", 0, "", 0, mapping); if (snip) { grn_rc rc; unsigned int i; if(GRN_TEXT_LEN(args[3])){ grn_obj * normalizer; normalizer = grn_ctx_get(ctx, GRN_TEXT_VALUE(args[3]), GRN_TEXT_LEN(args[3])); grn_snip_set_normalizer(ctx, snip, normalizer); } for(i = 8; i < (unsigned int)nargs; i += 3){ rc = grn_snip_add_cond(ctx, snip, GRN_TEXT_VALUE(args[i]), GRN_TEXT_LEN(args[i]), GRN_TEXT_VALUE(args[i + 1]), GRN_TEXT_LEN(args[i + 1]), GRN_TEXT_VALUE(args[i + 2]), GRN_TEXT_LEN(args[i + 2])); } snippets = snippet_exec(ctx, snip, text, user_data, args); grn_obj_close(ctx, snip); } } if(!snippets){ snippets = grn_plugin_proc_alloc(ctx, user_data, GRN_DB_VOID, 0); } return snippets; }
static grn_obj * proc_column_create(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data) { uint32_t nvars; grn_obj *buf = args[0]; grn_expr_var *vars; grn_proc_get_info(ctx, user_data, &vars, &nvars, NULL); if (nvars == 6) { grn_obj_flags flags = grn_atoi(GRN_TEXT_VALUE(&vars[2].value), GRN_BULK_CURR(&vars[2].value), NULL); grn_obj *column, *table = grn_ctx_get(ctx, GRN_TEXT_VALUE(&vars[0].value), GRN_TEXT_LEN(&vars[0].value)); grn_obj *type = grn_ctx_get(ctx, GRN_TEXT_VALUE(&vars[3].value), GRN_TEXT_LEN(&vars[3].value)); if (GRN_TEXT_LEN(&vars[1].value)) { flags |= GRN_OBJ_PERSISTENT; } column = grn_column_create(ctx, table, GRN_TEXT_VALUE(&vars[1].value), GRN_TEXT_LEN(&vars[1].value), NULL, flags, type); if (column) { if (GRN_TEXT_LEN(&vars[4].value)) { grn_obj sources, source_ids, **p, **pe; GRN_PTR_INIT(&sources, GRN_OBJ_VECTOR, GRN_ID_NIL); GRN_UINT32_INIT(&source_ids, GRN_OBJ_VECTOR); grn_obj_columns(ctx, type, GRN_TEXT_VALUE(&vars[4].value), GRN_TEXT_LEN(&vars[4].value), &sources); p = (grn_obj **)GRN_BULK_HEAD(&sources); pe = (grn_obj **)GRN_BULK_CURR(&sources); while (p < pe) { grn_id source_id = grn_obj_id(ctx, *p++); if (source_id) { GRN_UINT32_PUT(ctx, &source_ids, source_id); } } if (GRN_BULK_VSIZE(&source_ids)) { grn_obj_set_info(ctx, column, GRN_INFO_SOURCE, &source_ids); } GRN_OBJ_FIN(ctx, &source_ids); GRN_OBJ_FIN(ctx, &sources); } grn_obj_unlink(ctx, column); } GRN_TEXT_PUTS(ctx, buf, ctx->rc ? "false" : "true"); } return buf; }
static grn_obj * proc_define_selector(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data) { uint32_t nvars; grn_expr_var *vars; grn_obj *outbuf = args[0]; grn_proc_get_info(ctx, user_data, &vars, &nvars, NULL); if (grn_proc_create(ctx, GRN_TEXT_VALUE(&vars[0].value), GRN_TEXT_LEN(&vars[0].value), NULL, proc_select, NULL, NULL, nvars - 1, vars + 1)) { GRN_TEXT_PUT(ctx, outbuf, GRN_TEXT_VALUE(&vars[0].value), GRN_TEXT_LEN(&vars[0].value)); } return outbuf; }
VALUE rb_grn_view_record_new (VALUE view, grn_obj *id) { return rb_grn_view_record_new_raw(view, rb_str_new(GRN_TEXT_VALUE(id), GRN_TEXT_LEN(id))); }
static ngx_buf_t * ngx_http_groonga_grn_obj_to_ngx_buf(ngx_pool_t *pool, grn_obj *object) { ngx_buf_t *buffer; buffer = ngx_pcalloc(pool, sizeof(ngx_buf_t)); if (buffer == NULL) { return NULL; } /* adjust the pointers of the buffer */ buffer->pos = (u_char *)GRN_TEXT_VALUE(object); buffer->last = (u_char *)GRN_TEXT_VALUE(object) + GRN_TEXT_LEN(object); buffer->memory = 1; /* this buffer is in memory */ return buffer; }
/* * 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_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; }
MRN_API char *mroonga_escape(UDF_INIT *initid, UDF_ARGS *args, char *result, unsigned long *length, char *is_null, char *error) { EscapeInfo *info = (EscapeInfo *)initid->ptr; grn_ctx *ctx = &(info->ctx); if (!args->args[0]) { *is_null = 1; return NULL; } *is_null = 0; escape(info, args); if (ctx->rc) { my_message(ER_ERROR_ON_WRITE, ctx->errbuf, MYF(0)); goto error; } *length = GRN_TEXT_LEN(&(info->escaped_query)); return (char *)(GRN_TEXT_VALUE(&(info->escaped_query))); error: *error = 1; return NULL; }
static int suggest_result(struct evbuffer *res_buf, const char *types, const char *query, const char *target_name, int threshold, int limit, grn_obj *cmd_buf, grn_ctx *ctx) { if (target_name && types && query) { GRN_BULK_REWIND(cmd_buf); GRN_TEXT_PUTS(ctx, cmd_buf, "/d/suggest?table=item_"); grn_text_urlenc(ctx, cmd_buf, target_name, strlen(target_name)); GRN_TEXT_PUTS(ctx, cmd_buf, "&column=kana&types="); grn_text_urlenc(ctx, cmd_buf, types, strlen(types)); GRN_TEXT_PUTS(ctx, cmd_buf, "&query="); grn_text_urlenc(ctx, cmd_buf, query, strlen(query)); GRN_TEXT_PUTS(ctx, cmd_buf, "&threshold="); grn_text_itoa(ctx, cmd_buf, threshold); GRN_TEXT_PUTS(ctx, cmd_buf, "&limit="); grn_text_itoa(ctx, cmd_buf, limit); { char *res; int flags; unsigned int res_len; grn_ctx_send(ctx, GRN_TEXT_VALUE(cmd_buf), GRN_TEXT_LEN(cmd_buf), 0); grn_ctx_recv(ctx, &res, &res_len, &flags); evbuffer_add(res_buf, res, res_len); return res_len; } } else { evbuffer_add(res_buf, "{}", 2); return 2; } }
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 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; }
void test_uint64_to_text(void) { grn_obj_reinit(&context, &dest, GRN_DB_TEXT, 0); cast_uint64(2929); cut_assert_equal_string("2929", GRN_TEXT_VALUE(&dest)); }
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; } } }
grn_rc grn_token_copy(grn_ctx *ctx, grn_token *token, grn_token *source) { GRN_API_ENTER; if (!token) { ERR(GRN_INVALID_ARGUMENT, "[token][copy] token must not be NULL"); goto exit; } GRN_TEXT_SET(ctx, &(token->data), GRN_TEXT_VALUE(&(source->data)), GRN_TEXT_LEN(&(source->data))); token->status = source->status; token->source_offset = source->source_offset; token->source_length = source->source_length; token->source_first_character_length = source->source_first_character_length; token->have_overlap = source->have_overlap; grn_token_metadata_reset(ctx, &(token->metadata)); grn_token_metadata_copy(ctx, &(token->metadata), &(source->metadata)); token->force_prefix_search = source->force_prefix_search; token->position = source->position; exit: GRN_API_RETURN(ctx->rc); }
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_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; }
static grn_obj * highlight_keywords(grn_ctx *ctx, grn_user_data *user_data, grn_obj *string, grn_obj *keywords, grn_bool use_html_escape, const char *default_open_tag, unsigned int default_open_tag_length, const char *default_close_tag, unsigned int default_close_tag_length) { grn_obj *highlighted = NULL; const char *open_tags[1]; unsigned int open_tag_lengths[1]; const char *close_tags[1]; unsigned int close_tag_lengths[1]; unsigned int n_keyword_sets = 1; open_tags[0] = default_open_tag; open_tag_lengths[0] = default_open_tag_length; close_tags[0] = default_close_tag; close_tag_lengths[0] = default_close_tag_length; highlighted = grn_plugin_proc_alloc(ctx, user_data, GRN_DB_TEXT, 0); grn_pat_tag_keys(ctx, keywords, GRN_TEXT_VALUE(string), GRN_TEXT_LEN(string), open_tags, open_tag_lengths, close_tags, close_tag_lengths, n_keyword_sets, highlighted, use_html_escape); return highlighted; }
static grn_obj * uvector_init(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data) { grn_obj *str, *flags, *mode; grn_uvector_tokenizer *tokenizer; if (!(flags = grn_ctx_pop(ctx))) { ERR(GRN_INVALID_ARGUMENT, "[tokenizer][uvector] missing argument: flags"); return NULL; } if (!(str = grn_ctx_pop(ctx))) { ERR(GRN_INVALID_ARGUMENT, "[tokenizer][uvector] missing argument: string"); return NULL; } if (!(mode = grn_ctx_pop(ctx))) { ERR(GRN_INVALID_ARGUMENT, "[tokenizer][uvector] missing argument: mode"); return NULL; } if (!(tokenizer = GRN_MALLOC(sizeof(grn_uvector_tokenizer)))) { ERR(GRN_NO_MEMORY_AVAILABLE, "[tokenizer][uvector] " "memory allocation to grn_uvector_tokenizer failed"); return NULL; } user_data->ptr = tokenizer; grn_tokenizer_token_init(ctx, &(tokenizer->token)); tokenizer->curr = (byte *)GRN_TEXT_VALUE(str); tokenizer->tail = tokenizer->curr + GRN_TEXT_LEN(str); tokenizer->unit = sizeof(grn_id); return NULL; }
static void tokenize(grn_ctx *ctx, grn_obj *lexicon, grn_obj *string, grn_tokenize_mode mode, unsigned int flags, grn_obj *tokens) { grn_token_cursor *token_cursor; token_cursor = grn_token_cursor_open(ctx, lexicon, GRN_TEXT_VALUE(string), GRN_TEXT_LEN(string), mode, flags); if (!token_cursor) { return; } while (token_cursor->status == GRN_TOKEN_CURSOR_DOING) { grn_id token_id = grn_token_cursor_next(ctx, token_cursor); tokenize_token *current_token; if (token_id == GRN_ID_NIL) { continue; } grn_bulk_space(ctx, tokens, sizeof(tokenize_token)); current_token = ((tokenize_token *)(GRN_BULK_CURR(tokens))) - 1; current_token->id = token_id; current_token->position = token_cursor->pos; current_token->force_prefix = token_cursor->force_prefix; } grn_token_cursor_close(ctx, token_cursor); }