grn_rc grn_tokenizer_query_set_raw_string(grn_ctx *ctx, grn_tokenizer_query *query, const char *string, size_t string_length) { GRN_API_ENTER; if (query->query_buf) { GRN_PLUGIN_FREE(ctx, query->query_buf); } if (string_length == 0) { query->query_buf = NULL; query->ptr = NULL; query->length = 0; query->need_normalize = GRN_TRUE; } else { query->query_buf = (char *)GRN_PLUGIN_MALLOC(ctx, string_length + 1); if (!query->query_buf) { GRN_PLUGIN_ERROR(ctx, GRN_TOKENIZER_ERROR, "[tokenizer][query] failed to duplicate query"); GRN_API_RETURN(ctx->rc); } grn_memcpy(query->query_buf, string, string_length); query->query_buf[string_length] = '\0'; query->ptr = query->query_buf; query->length = string_length; } GRN_API_RETURN(ctx->rc); }
grn_obj * grn_type_create(grn_ctx *ctx, const char *name, unsigned int name_size, grn_obj_flags flags, unsigned int size) { grn_id id; struct _grn_type *res = NULL; grn_obj *db; if (!ctx || !ctx->impl || !(db = ctx->impl->db)) { ERR(GRN_INVALID_ARGUMENT, "db not initialized"); return NULL; } GRN_API_ENTER; if (grn_db_check_name(ctx, name, name_size)) { GRN_DB_CHECK_NAME_ERR("[type][create]", name, name_size); GRN_API_RETURN(NULL); } if (!GRN_DB_P(db)) { ERR(GRN_INVALID_ARGUMENT, "invalid db assigned"); GRN_API_RETURN(NULL); } id = grn_obj_register(ctx, db, name, name_size); if (id && (res = GRN_MALLOC(sizeof(grn_db_obj)))) { GRN_DB_OBJ_SET_TYPE(res, GRN_TYPE); res->obj.header.flags = flags; res->obj.header.domain = GRN_ID_NIL; GRN_TYPE_SIZE(&res->obj) = size; if (grn_db_obj_init(ctx, db, id, DB_OBJ(res))) { // grn_obj_delete(ctx, db, id); GRN_FREE(res); GRN_API_RETURN(NULL); } } GRN_API_RETURN((grn_obj *)res); }
grn_obj * grn_token_get_data(grn_ctx *ctx, grn_token *token) { GRN_API_ENTER; if (!token) { ERR(GRN_INVALID_ARGUMENT, "token must not be NULL"); GRN_API_RETURN(NULL); } GRN_API_RETURN(&(token->data)); }
grn_token_status grn_token_get_status(grn_ctx *ctx, grn_token *token) { GRN_API_ENTER; if (!token) { ERR(GRN_INVALID_ARGUMENT, "token must not be NULL"); GRN_API_RETURN(GRN_TOKEN_CONTINUE); } GRN_API_RETURN(token->status); }
uint64_t grn_token_get_source_offset(grn_ctx *ctx, grn_token *token) { GRN_API_ENTER; if (!token) { ERR(GRN_INVALID_ARGUMENT, "[token][source-offset][get] token must not be NULL"); GRN_API_RETURN(0); } GRN_API_RETURN(token->source_offset); }
grn_bool grn_token_have_overlap(grn_ctx *ctx, grn_token *token) { GRN_API_ENTER; if (!token) { ERR(GRN_INVALID_ARGUMENT, "[token][overlap][have] token must not be NULL"); GRN_API_RETURN(0); } GRN_API_RETURN(token->have_overlap); }
grn_bool grn_token_get_force_prefix_search(grn_ctx *ctx, grn_token *token) { GRN_API_ENTER; if (!token) { ERR(GRN_INVALID_ARGUMENT, "[token][force-prefix-search][get] token must not be NULL"); GRN_API_RETURN(GRN_FALSE); } GRN_API_RETURN(token->force_prefix_search); }
uint32_t grn_token_get_position(grn_ctx *ctx, grn_token *token) { GRN_API_ENTER; if (!token) { ERR(GRN_INVALID_ARGUMENT, "[token][position][get] token must not be NULL"); GRN_API_RETURN(0); } GRN_API_RETURN(token->position); }
uint32_t grn_token_get_source_first_character_length(grn_ctx *ctx, grn_token *token) { GRN_API_ENTER; if (!token) { ERR(GRN_INVALID_ARGUMENT, "[token][source-first-character-length][get] token must not be NULL"); GRN_API_RETURN(0); } GRN_API_RETURN(token->source_first_character_length); }
grn_tokenizer_query * grn_tokenizer_query_open(grn_ctx *ctx, int num_args, grn_obj **args, unsigned int normalize_flags) { grn_obj *flags; grn_obj *query_str; grn_obj *tokenize_mode; GRN_API_ENTER; flags = grn_ctx_pop(ctx); query_str = grn_ctx_pop(ctx); tokenize_mode = grn_ctx_pop(ctx); if (query_str == NULL) { GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT, "missing argument"); GRN_API_RETURN(NULL); } if ((num_args < 1) || (args == NULL) || (args[0] == NULL)) { GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT, "invalid NULL pointer"); GRN_API_RETURN(NULL); } { grn_tokenizer_query * const query = GRN_PLUGIN_MALLOC(ctx, sizeof(grn_tokenizer_query)); if (!query) { GRN_API_RETURN(NULL); } grn_tokenizer_query_init(ctx, query); grn_tokenizer_query_set_raw_string(ctx, query, GRN_TEXT_VALUE(query_str), GRN_TEXT_LEN(query_str)); if (ctx->rc != GRN_SUCCESS) { GRN_PLUGIN_FREE(ctx, query); GRN_API_RETURN(NULL); } if (flags) { grn_tokenizer_query_set_flags(ctx, query, GRN_UINT32_VALUE(flags)); } if (tokenize_mode) { grn_tokenizer_query_set_mode(ctx, query, GRN_UINT32_VALUE(tokenize_mode)); } grn_tokenizer_query_set_normalize_flags(ctx, query, normalize_flags); grn_tokenizer_query_set_lexicon(ctx, query, args[0]); grn_tokenizer_query_ensure_have_tokenized_delimiter(ctx, query); GRN_API_RETURN(query); } }
grn_rc grn_token_set_position(grn_ctx *ctx, grn_token *token, uint32_t position) { GRN_API_ENTER; if (!token) { ERR(GRN_INVALID_ARGUMENT, "[token][position][set] token must not be NULL"); GRN_API_RETURN(ctx->rc); } token->position = position; GRN_API_RETURN(ctx->rc); }
grn_rc grn_token_set_force_prefix_search(grn_ctx *ctx, grn_token *token, grn_bool force) { GRN_API_ENTER; if (!token) { ERR(GRN_INVALID_ARGUMENT, "[token][force-prefix-search][set] token must not be NULL"); GRN_API_RETURN(ctx->rc); } token->force_prefix_search = force; GRN_API_RETURN(ctx->rc); }
uint32_t grn_type_size(grn_ctx *ctx, grn_obj *type) { uint32_t size; GRN_API_ENTER; if (!type) { ERR(GRN_INVALID_ARGUMENT, "[type][size] type is NULL"); GRN_API_RETURN(0); } size = GRN_TYPE_SIZE(DB_OBJ(type)); GRN_API_RETURN(size); }
grn_rc grn_windows_event_logger_set(grn_ctx *ctx, const char *event_source_name) { #ifdef WIN32 grn_rc rc; grn_logger windows_event_logger; grn_windows_event_logger_data *data; if (ctx) { GRN_API_ENTER; } data = malloc(sizeof(grn_windows_event_logger_data)); if (!data) { if (ctx) { ERR(GRN_NO_MEMORY_AVAILABLE, "failed to allocate user data for Windows event logger"); GRN_API_RETURN(ctx->rc); } else { return GRN_NO_MEMORY_AVAILABLE; } } if (event_source_name) { data->event_source_name = grn_strdup_raw(event_source_name); } else { data->event_source_name = grn_strdup_raw("libgroonga"); } data->event_source = INVALID_HANDLE_VALUE; windows_event_logger.max_level = GRN_LOG_DEFAULT_LEVEL; windows_event_logger.flags = GRN_LOG_TIME | GRN_LOG_MESSAGE; windows_event_logger.user_data = data; windows_event_logger.log = windows_event_logger_log; windows_event_logger.reopen = windows_event_logger_reopen; windows_event_logger.fin = windows_event_logger_fin; rc = grn_logger_set(ctx, &windows_event_logger); if (rc != GRN_SUCCESS) { windows_event_logger.fin(ctx, windows_event_logger.user_data); } if (ctx) { GRN_API_RETURN(rc); } else { return rc; } #else /* WIN32 */ return GRN_FUNCTION_NOT_IMPLEMENTED; #endif /* WIN32 */ }
grn_obj * grn_command_input_get_arguments(grn_ctx *ctx, grn_command_input *input) { GRN_API_ENTER; GRN_API_RETURN((grn_obj *)(input->arguments)); }
unsigned int grn_tokenizer_query_get_normalize_flags(grn_ctx *ctx, grn_tokenizer_query *query) { GRN_API_ENTER; GRN_API_RETURN(query->normalize_flags); }
grn_rc grn_tokenizer_query_set_lexicon(grn_ctx *ctx, grn_tokenizer_query *query, grn_obj *lexicon) { GRN_API_ENTER; if (query->lexicon != lexicon) { query->lexicon = lexicon; if (query->lexicon) { grn_table_get_info(ctx, query->lexicon, NULL, &(query->encoding), NULL, NULL, NULL); } else { query->encoding = ctx->encoding; } query->need_normalize = GRN_TRUE; } GRN_API_RETURN(ctx->rc); }
unsigned int grn_tokenizer_query_get_token_filter_index(grn_ctx *ctx, grn_tokenizer_query *query) { GRN_API_ENTER; GRN_API_RETURN(query->token_filter_index); }
grn_obj * grn_tokenizer_create(grn_ctx *ctx, const char *name, int name_length) { grn_obj *tokenizer; GRN_API_ENTER; tokenizer = grn_proc_create(ctx, name, name_length, GRN_PROC_TOKENIZER, NULL, NULL, NULL, 0, NULL); if (!tokenizer) { if (name_length < 0) { name_length = strlen(name); } GRN_PLUGIN_ERROR(ctx, GRN_TOKENIZER_ERROR, "[tokenizer][create] failed to create: <%.*s>", name_length, name); } GRN_API_RETURN(tokenizer); }
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); }
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); }
/* It should be renamed to grn_snip_close() and marked as internal. * TODO: 3.0 */ grn_rc grn_snip_close_real(grn_ctx *ctx, grn_snip *snip) { snip_cond *cond, *cond_end; if (!snip) { return GRN_INVALID_ARGUMENT; } GRN_API_ENTER; if (snip->flags & GRN_SNIP_COPY_TAG) { int i; snip_cond *sc; const char *dot = snip->defaultopentag, *dct = snip->defaultclosetag; for (i = snip->cond_len, sc = snip->cond; i; i--, sc++) { if (sc->opentag != dot) { GRN_FREE((void *)sc->opentag); } if (sc->closetag != dct) { GRN_FREE((void *)sc->closetag); } } if (dot) { GRN_FREE((void *)dot); } if (dct) { GRN_FREE((void *)dct); } } if (snip->nstr) { grn_obj_close(ctx, snip->nstr); } for (cond = snip->cond, cond_end = cond + snip->cond_len; cond < cond_end; cond++) { grn_snip_cond_close(ctx, cond); } GRN_FREE(snip); GRN_API_RETURN(GRN_SUCCESS); }
grn_bool grn_tokenizer_query_have_tokenized_delimiter(grn_ctx *ctx, grn_tokenizer_query *query) { GRN_API_ENTER; grn_tokenizer_query_ensure_have_tokenized_delimiter(ctx, query); GRN_API_RETURN(query->have_tokenized_delimiter); }
grn_bool grn_operator_exec_equal(grn_ctx *ctx, grn_obj *x, grn_obj *y) { grn_bool r = GRN_FALSE; GRN_API_ENTER; DO_EQ(x, y, r); GRN_API_RETURN(r); }
grn_bool grn_operator_exec_greater_equal(grn_ctx *ctx, grn_obj *x, grn_obj *y) { grn_bool r = GRN_FALSE; GRN_API_ENTER; DO_COMPARE(x, y, r, >=); GRN_API_RETURN(r); }
grn_bool grn_operator_exec_less(grn_ctx *ctx, grn_obj *x, grn_obj *y) { grn_bool r = GRN_FALSE; GRN_API_ENTER; DO_COMPARE(x, y, r, <); GRN_API_RETURN(r); }
grn_bool grn_operator_exec_not_equal(grn_ctx *ctx, grn_obj *x, grn_obj *y) { grn_bool r = GRN_FALSE; GRN_API_ENTER; r = exec_equal(ctx, x, y); GRN_API_RETURN(!r); }
grn_bool grn_operator_exec_prefix(grn_ctx *ctx, grn_obj *target, grn_obj *prefix) { grn_bool matched; GRN_API_ENTER; matched = exec_text_operator_bulk_bulk(ctx, GRN_OP_PREFIX, target, prefix); GRN_API_RETURN(matched); }
grn_rc grn_token_fin(grn_ctx *ctx, grn_token *token) { GRN_API_ENTER; grn_token_metadata_fin(ctx, &(token->metadata)); GRN_OBJ_FIN(ctx, &(token->data)); GRN_API_RETURN(ctx->rc); }
const char * grn_token_get_data_raw(grn_ctx *ctx, grn_token *token, size_t *length) { GRN_API_ENTER; if (!token) { ERR(GRN_INVALID_ARGUMENT, "[token][data][get][raw] token must not be NULL"); if (length) { *length = 0; } GRN_API_RETURN(NULL); } if (length) { *length = GRN_TEXT_LEN(&(token->data)); } GRN_API_RETURN(GRN_TEXT_VALUE(&(token->data))); }