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