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; }
grn_obj * rb_grn_context_get_backward_compatibility (grn_ctx *context, const char *name, unsigned int name_size) { grn_obj *object; object = grn_ctx_get(context, name, name_size); if (!object) { const char *new_type_name; new_type_name = grn_type_name_old_to_new(name, name_size); if (new_type_name) { object = grn_ctx_get(context, new_type_name, strlen(new_type_name)); #if 0 if (object) { rb_warn("deprecated old data type name <%s> is used. " "Use new data type name <%s> instead.", name, new_type_name); } #endif } } return object; }
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 void create_uint32_table(void) { const char *table_name = "UInt32Pat"; assert_send_commands( cut_take_printf("table_create %s TABLE_PAT_KEY UInt32", table_name)); assert_send_commands( cut_take_printf("load --table %s\n" "[\n" " [\"_key\"],\n" " [%u]," " [%u]," " [%u]," " [%u]," " [%u]" "]", table_name, 0x00000000U, 0x00000004U, 0x00000080U, 0xdeadbeefU, 0xffffffffU)); table = grn_ctx_get(context, table_name, strlen(table_name)); }
static void create_short_text_table(const GList *texts) { const gchar *table_name = "ShortTextPat"; GString *command; const GList *node; assert_send_commands( cut_take_printf("table_create %s TABLE_PAT_KEY ShortText", table_name)); command = g_string_new(NULL); g_string_append_printf(command, "load --table %s\n", table_name); g_string_append(command, "[\n"); g_string_append(command, " [\"_key\"],\n"); for (node = texts; node; node = g_list_next(node)) { const gchar *text = node->data; g_string_append_printf(command, " [\"%s\"]", text); if (g_list_next(node)) { g_string_append(command, ","); } g_string_append(command, "\n"); } g_string_append(command, "]"); assert_send_commands(cut_take_string(g_string_free(command, FALSE))); table = grn_ctx_get(context, table_name, strlen(table_name)); }
grn_obj * grn_string_open_(grn_ctx *ctx, const char *str, unsigned int str_len, grn_obj *normalizer, int flags, grn_encoding encoding) { grn_string *string; grn_obj *obj; grn_bool is_normalizer_auto; if (!str || !str_len) { return NULL; } is_normalizer_auto = (normalizer == GRN_NORMALIZER_AUTO); if (is_normalizer_auto) { normalizer = grn_ctx_get(ctx, GRN_NORMALIZER_AUTO_NAME, -1); if (!normalizer) { ERR(GRN_INVALID_ARGUMENT, "[string][open] NormalizerAuto normalizer isn't available"); return NULL; } } string = GRN_MALLOCN(grn_string, 1); if (!string) { if (is_normalizer_auto) { grn_obj_unlink(ctx, normalizer); } GRN_LOG(ctx, GRN_LOG_ALERT, "[string][open] failed to allocate memory"); return NULL; } obj = (grn_obj *)string; GRN_OBJ_INIT(obj, GRN_STRING, GRN_OBJ_ALLOCATED, GRN_ID_NIL); string->original = str; string->original_length_in_bytes = str_len; string->normalized = NULL; string->normalized_length_in_bytes = 0; string->n_characters = 0; string->checks = NULL; string->ctypes = NULL; string->encoding = encoding; string->flags = flags; if (!normalizer) { return (grn_obj *)grn_fake_string_open(ctx, string); } grn_normalizer_normalize(ctx, normalizer, (grn_obj *)string); if (ctx->rc) { grn_obj_close(ctx, obj); obj = NULL; } if (is_normalizer_auto) { grn_obj_unlink(ctx, normalizer); } return obj; }
// <cmd> {<len> <column id>} <type> <#keys> [{<len> <key>}]... void hog_del(server_t *s, grn_ctx *ctx) { uint32_t len; receive(s->socket, &len, sizeof(len)); len = ntohl(len); char *buf = malloc(len); receive(s->socket, buf, len); grn_obj *col, *table; col = grn_ctx_get(ctx, buf, len); if(grn_obj_is_table(ctx, col)) table = col; else table = grn_column_table(ctx, col); // get key type char type; receive(s->socket, &type, 1); // submit values for each keys uint32_t nkeys; receive(s->socket, &nkeys, sizeof(nkeys)); nkeys = ntohl(nkeys); for(uint32_t i = 0; i < nkeys; ++i){ receive(s->socket, &len, sizeof(len)); len = ntohl(len); buf = realloc(buf, len); receive(s->socket, buf, len); ntoh_buf(buf, len, type); grn_table_delete(ctx, table, buf, len); } cleanup: free(buf); }
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; }
void test_get_persistent_object_from_opened_database(void) { const gchar table_name[] = "Users"; const gchar *path; path = cut_build_path(tmp_directory, "database.groonga", NULL); database = grn_db_create(context, path, NULL); grn_test_assert_not_null(context, database); grn_test_assert_not_null(context, grn_table_create(context, table_name, strlen(table_name), NULL, GRN_OBJ_TABLE_HASH_KEY | GRN_OBJ_PERSISTENT, grn_ctx_at(context, GRN_DB_UINT32), NULL)); database2 = grn_db_open(context2, path); grn_test_assert_not_null(context2, database2); grn_test_assert_not_null(context2, grn_ctx_get(context2, table_name, strlen(table_name))); }
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; }
void test_recreate_temporary_object_on_opened_database(void) { const gchar table_name[] = "<users>"; const gchar *path; path = cut_build_path(tmp_directory, "database.groonga", NULL); database = grn_db_create(context, path, NULL); grn_test_assert_not_null(context, database); grn_test_assert_null(context, grn_table_create(context, table_name, strlen(table_name), NULL, GRN_OBJ_TABLE_HASH_KEY, grn_ctx_at(context, GRN_DB_UINT32), NULL)); database2 = grn_db_open(context2, path); grn_test_assert_not_null(context2, database2); grn_test_assert_null(context2, grn_ctx_get(context2, table_name, strlen(table_name))); grn_test_assert_null(context2, grn_table_create(context, table_name, strlen(table_name), NULL, GRN_OBJ_TABLE_HASH_KEY, grn_ctx_at(context, GRN_DB_UINT32), NULL)); }
static mrb_value ctx_array_reference(mrb_state *mrb, mrb_value self) { grn_ctx *ctx = (grn_ctx *)mrb->ud; mrb_value mrb_id_or_name; grn_obj *object; mrb_get_args(mrb, "o", &mrb_id_or_name); if (mrb_nil_p(mrb_id_or_name)) { return mrb_nil_value(); } if (mrb_fixnum_p(mrb_id_or_name)) { grn_id id = mrb_fixnum(mrb_id_or_name); object = grn_ctx_at(ctx, id); } else { mrb_value mrb_name; mrb_name = mrb_convert_type(mrb, mrb_id_or_name, MRB_TT_STRING, "String", "to_str"); object = grn_ctx_get(ctx, RSTRING_PTR(mrb_name), RSTRING_LEN(mrb_name)); } return grn_mrb_value_from_grn_obj(mrb, object); }
static void create_geo_table(const gchar *load_data) { const char *table_name = "Data"; const char *column_name = "location"; assert_send_commands( cut_take_printf("table_create %s TABLE_NO_KEY", table_name)); assert_send_commands( cut_take_printf("column_create %s %s COLUMN_SCALAR WGS84GeoPoint", table_name, column_name)); assert_send_commands("table_create Index TABLE_PAT_KEY WGS84GeoPoint"); assert_send_commands( cut_take_printf("column_create Index %s_%s COLUMN_INDEX %s %s", table_name, column_name, table_name, column_name)); assert_send_commands( cut_take_printf("load --table %s\n" "[\n" " [\"%s\"],\n" "%s\n" "]", table_name, column_name, load_data)); table = grn_ctx_get(context, table_name, strlen(table_name)); column = grn_obj_column(context, table, column_name, strlen(column_name)); }
SmartGrnObj::SmartGrnObj(grn_ctx *ctx, const char *name, int name_size) : ctx_(ctx), obj_(NULL) { if (name_size < 0) { name_size = strlen(name); } obj_ = grn_ctx_get(ctx_, name, name_size); }
void FieldNormalizer::find_grn_normalizer(grn_obj *normalizer) { MRN_DBUG_ENTER_METHOD(); const CHARSET_INFO *charset_info = field_->charset(); const char *normalizer_name = NULL; const char *normalizer_spec = NULL; const char *default_normalizer_name = "NormalizerAuto"; if ((strcmp(charset_info->name, "utf8_general_ci") == 0) || (strcmp(charset_info->name, "utf8mb4_general_ci") == 0)) { normalizer_name = normalizer_spec = "NormalizerMySQLGeneralCI"; } else if ((strcmp(charset_info->name, "utf8_unicode_ci") == 0) || (strcmp(charset_info->name, "utf8mb4_unicode_ci") == 0)) { normalizer_name = normalizer_spec = "NormalizerMySQLUnicodeCI"; } else if ((strcmp(charset_info->name, "utf8_unicode_520_ci") == 0) || (strcmp(charset_info->name, "utf8mb4_unicode_520_ci") == 0)) { normalizer_name = normalizer_spec = "NormalizerMySQLUnicode520CI"; } else if ((strcmp(charset_info->name, "utf8mb4_0900_ai_ci") == 0)) { normalizer_name = "NormalizerMySQLUnicode900"; normalizer_spec = "NormalizerMySQLUnicode900('weight_level', 1)"; } else if ((strcmp(charset_info->name, "utf8mb4_0900_as_ci") == 0)) { normalizer_name = "NormalizerMySQLUnicode900"; normalizer_spec = "NormalizerMySQLUnicode900('weight_level', 2)"; } else if ((strcmp(charset_info->name, "utf8mb4_0900_as_cs") == 0)) { normalizer_name = "NormalizerMySQLUnicode900"; normalizer_spec = "NormalizerMySQLUnicode900('weight_level', 3)"; } else if ((strcmp(charset_info->name, "utf8mb4_ja_0900_as_cs") == 0)) { normalizer_name = "NormalizerMySQLUnicode900"; normalizer_spec = "NormalizerMySQLUnicode900('locale', 'ja', 'weight_level', 3)"; } else if ((strcmp(charset_info->name, "utf8mb4_ja_0900_as_cs_ks") == 0)) { normalizer_name = "NormalizerMySQLUnicode900"; normalizer_spec = "NormalizerMySQLUnicode900('locale', 'ja', 'weight_level', 4)"; } if (normalizer_name) { if (!grn_ctx_get(ctx_, normalizer_name, -1)) { char error_message[MRN_MESSAGE_BUFFER_SIZE]; snprintf(error_message, MRN_MESSAGE_BUFFER_SIZE, "%s normalizer isn't found for %s. " "Install groonga-normalizer-mysql normalizer. " "%s is used as fallback.", normalizer_name, charset_info->name, default_normalizer_name); push_warning(thread_, MRN_SEVERITY_WARNING, HA_ERR_UNSUPPORTED, error_message); normalizer_name = NULL; } } if (!normalizer_name) { normalizer_name = normalizer_spec = default_normalizer_name; } GRN_TEXT_PUTS(ctx_, normalizer, normalizer_spec); DBUG_VOID_RETURN; }
int column_get(void) { int i, s = 0; grn_obj buf; grn_obj *table = grn_ctx_get(&ctx, "<t1>", 4); grn_obj *column = grn_ctx_get(&ctx, "<t1>.c1", 7); if (!table || !column) { 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\n"); } else { grn_obj obj, *p; unsigned int v = key % value_size; GRN_TEXT_INIT(&obj, 0); p = grn_obj_get_value(&ctx, column, rid, &obj); if (!p) { fprintf(stderr, "grn_obj_get_value failed\n"); } else { if (GRN_BULK_VSIZE(p) != v) { fprintf(stderr, "value_size unmatch %d (%ld:%u)\n", i, GRN_BULK_VSIZE(p), v); } else { if (v && GRN_BULK_HEAD(p)[v-1] != GRN_BULK_HEAD(&buf)[0]) { fprintf(stderr, "value unmatch\n"); } else { s++; } } grn_obj_close(&ctx, p); } } } } grn_obj_close(&ctx, &buf); if (i != s) { printf("successed: %d\n", s); } return 0; }
void test_path(gconstpointer data) { const gchar *expected; const gchar *name; expected = gcut_data_get_string(data, "expected"); name = gcut_data_get_string(data, "name"); proc = grn_ctx_get(context, name, -1); cut_assert_equal_string(expected, grn_obj_path(context, proc)); }
static grn_bool exec_text_operator_raw_text_raw_text(grn_ctx *ctx, grn_operator op, const char *target, unsigned int target_len, const char *query, unsigned int query_len) { grn_obj *normalizer; grn_obj *norm_target; grn_obj *norm_query; const char *norm_target_raw; const char *norm_query_raw; unsigned int norm_target_raw_length_in_bytes; unsigned int norm_query_raw_length_in_bytes; grn_bool matched = GRN_FALSE; if (target_len == 0 || query_len == 0) { return GRN_FALSE; } normalizer = grn_ctx_get(ctx, GRN_NORMALIZER_AUTO_NAME, -1); norm_target = grn_string_open(ctx, target, target_len, normalizer, 0); grn_string_get_normalized(ctx, norm_target, &norm_target_raw, &norm_target_raw_length_in_bytes, NULL); if (op == GRN_OP_REGEXP) { norm_query = NULL; norm_query_raw = query; norm_query_raw_length_in_bytes = query_len; } else { norm_query = grn_string_open(ctx, query, query_len, normalizer, 0); grn_string_get_normalized(ctx, norm_query, &norm_query_raw, &norm_query_raw_length_in_bytes, NULL); } matched = exec_text_operator(ctx, op, norm_target_raw, norm_target_raw_length_in_bytes, norm_query_raw, norm_query_raw_length_in_bytes); grn_obj_close(ctx, norm_target); if (norm_query) { grn_obj_close(ctx, norm_query); } grn_obj_unlink(ctx, normalizer); return matched; }
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_id add_record(const gchar *table_name, const gchar *key) { grn_obj *table; grn_id record_id; table = grn_ctx_get(&context, table_name, strlen(table_name)); record_id = grn_table_add(&context, table, key, key ? strlen(key) : 0, NULL); grn_obj_unlink(&context, table); grn_test_assert_not_nil(record_id); return record_id; }
void test_normalizer_accessor(void) { grn_obj *normalizer; cut_assert_open_snip(); cut_assert_null(grn_snip_get_normalizer(&context, snip)); normalizer = grn_ctx_get(&context, "NormalizerNFKC51", -1); cut_assert_not_null(normalizer); grn_snip_set_normalizer(&context, snip, normalizer); cut_assert_equal_pointer(normalizer, grn_snip_get_normalizer(&context, snip)); }
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 * grn_table_factory_make(grn_table_factory *factory) { grn_obj *value_type = grn_ctx_get(factory->context, VALUE_TYPE_NAME, strlen(VALUE_TYPE_NAME)); if (!value_type) { value_type = grn_type_create(factory->context, VALUE_TYPE_NAME, strlen(VALUE_TYPE_NAME), 0, factory->value_size); } GRN_CTX_SET_ENCODING(factory->context, factory->encoding); return grn_table_create(factory->context, factory->name, factory->name_size, factory->path, factory->flags, factory->key_type, value_type); }
void test_is_scorer_proc(gconstpointer data) { const gchar *name; grn_obj *object; name = gcut_data_get_string(data, "name"); object = grn_ctx_get(context, name, strlen(name)); if (gcut_data_get_string(data, "expected")) { cut_assert_true(grn_obj_is_scorer_proc(context, object)); } else { cut_assert_false(grn_obj_is_scorer_proc(context, object)); } }
grn_obj *FieldNormalizer::find_grn_normalizer() { MRN_DBUG_ENTER_METHOD(); const CHARSET_INFO *charset_info = field_->charset(); const char *normalizer_name = NULL; const char *default_normalizer_name = "NormalizerAuto"; if ((strcmp(charset_info->name, "utf8_general_ci") == 0) || (strcmp(charset_info->name, "utf8mb4_general_ci") == 0)) { normalizer_name = "NormalizerMySQLGeneralCI"; } else if ((strcmp(charset_info->name, "utf8_unicode_ci") == 0) || (strcmp(charset_info->name, "utf8mb4_unicode_ci") == 0)) { normalizer_name = "NormalizerMySQLUnicodeCI"; } grn_obj *normalizer = NULL; if (normalizer_name) { normalizer = grn_ctx_get(ctx_, normalizer_name, -1); if (!normalizer) { char error_message[MRN_MESSAGE_BUFFER_SIZE]; snprintf(error_message, MRN_MESSAGE_BUFFER_SIZE, "%s normalizer isn't found for %s. " "Install groonga-normalizer-mysql normalizer. " "%s is used as fallback.", normalizer_name, charset_info->name, default_normalizer_name); push_warning(thread_, Sql_condition::WARN_LEVEL_WARN, HA_ERR_UNSUPPORTED, error_message); } } if (!normalizer) { normalizer = grn_ctx_get(ctx_, default_normalizer_name, -1); } DBUG_RETURN(normalizer); }
// <cmd> {<len> <column id>} <types> <#kvs> [{<len> <key>} {<len> <value>}]... void put_or_set(server_t *s, grn_ctx *ctx, int set) { uint32_t len; HOG_RECV(s, &len, sizeof(len), return); len = ntohl(len); char *buf = hog_alloc(NULL, len); HOG_RECV(s, buf, len, goto cleanup); grn_obj *col, *table; col = grn_ctx_get(ctx, buf, len); if(grn_obj_is_table(ctx, col)) table = col; else table = grn_column_table(ctx, col); // get key and value types char types[2]; HOG_RECV(s, types, 2, goto cleanup); // receive keys and values uint32_t nkeys; HOG_RECV(s, &nkeys, sizeof(nkeys), goto cleanup); nkeys = ntohl(nkeys); grn_obj value; GRN_OBJ_INIT(&value, GRN_BULK, 0, types[1]); for(uint32_t i = 0; i < nkeys; ++i){ HOG_RECV(s, &len, sizeof(len), goto value_fin); len = ntohl(len); buf = hog_alloc(buf, len); HOG_RECV(s, buf, len, goto value_fin); ntoh_buf(buf, len, types[0]); grn_id id; if(set){ id = grn_table_get(ctx, table, buf, len); }else{ id = grn_table_add(ctx, table, buf, len, NULL); } HOG_RECV(s, &len, sizeof(len), goto value_fin); len = ntohl(len); buf = hog_alloc(buf, len); HOG_RECV(s, buf, len, goto value_fin); if(id == GRN_ID_NIL) continue; ntoh_buf(buf, len, types[1]); GRN_BULK_REWIND(&value); grn_bulk_write(ctx, &value, buf, len); grn_obj_set_value(ctx, col, id, &value, GRN_OBJ_SET); } submit_one(s->socket); value_fin: GRN_OBJ_FIN(ctx, &value); cleanup: free(buf); }
void test_id_is_text_family(gconstpointer data) { const gchar *name; grn_obj *object; grn_id id; name = gcut_data_get_string(data, "name"); object = grn_ctx_get(context, name, strlen(name)); id = grn_obj_id(context, object); if (gcut_data_get_string(data, "expected")) { cut_assert_true(grn_type_id_is_text_family(context, id)); } else { cut_assert_false(grn_type_id_is_text_family(context, id)); } }
void test_is_proc(gconstpointer data) { const gchar *name; grn_obj *object; assert_send_command("table_create Users TABLE_HASH_KEY ShortText"); name = gcut_data_get_string(data, "name"); object = grn_ctx_get(context, name, strlen(name)); if (gcut_data_get_string(data, "expected")) { cut_assert_true(grn_obj_is_proc(context, object)); } else { cut_assert_false(grn_obj_is_proc(context, object)); } }
static void bench_normal(gpointer user_data) { BenchmarkData *data = user_data; grn_obj *table; grn_obj *value_type = grn_ctx_get(data->context, VALUE_TYPE_NAME, strlen(VALUE_TYPE_NAME)); if (!value_type) { value_type = grn_type_create(data->context, VALUE_TYPE_NAME, strlen(VALUE_TYPE_NAME), 0, data->value_size); } table = grn_table_create(data->context, data->name, data->name_size, data->path, data->flags, data->key_type, value_type); grn_obj_close(data->context, table); }
void test_is_token_filter_proc(gconstpointer data) { const gchar *name; grn_obj *object; assert_send_command("plugin_register token_filters/stop_word"); name = gcut_data_get_string(data, "name"); object = grn_ctx_get(context, name, strlen(name)); if (gcut_data_get_string(data, "expected")) { cut_assert_true(grn_obj_is_token_filter_proc(context, object)); } else { cut_assert_false(grn_obj_is_token_filter_proc(context, object)); } }