static void
command_schema_output_token_filters(grn_ctx *ctx)
{
grn_obj token_filters;
int i, n;
GRN_PTR_INIT(&token_filters, GRN_OBJ_VECTOR, GRN_DB_OBJECT);
grn_ctx_get_all_token_filters(ctx, &token_filters);
grn_ctx_output_cstr(ctx, "token_filters");
n = GRN_BULK_VSIZE(&token_filters) / sizeof(grn_obj *);
grn_ctx_output_map_open(ctx, "token_filters", n);
for (i = 0; i < n; i++) {
grn_obj *token_filter;
token_filter = GRN_PTR_VALUE_AT(&token_filters, i);
command_schema_output_name(ctx, token_filter);
grn_ctx_output_map_open(ctx, "token_filter", 1);
grn_ctx_output_cstr(ctx, "name");
command_schema_output_name(ctx, token_filter);
grn_ctx_output_map_close(ctx);
}
grn_ctx_output_map_close(ctx);
GRN_OBJ_FIN(ctx, &token_filters);
}
static void
command_schema_output_normalizers(grn_ctx *ctx)
{
grn_obj normalizers;
unsigned int i, n;
GRN_PTR_INIT(&normalizers, GRN_OBJ_VECTOR, GRN_DB_OBJECT);
grn_ctx_get_all_normalizers(ctx, &normalizers);
grn_ctx_output_cstr(ctx, "normalizers");
n = GRN_BULK_VSIZE(&normalizers) / sizeof(grn_obj *);
grn_ctx_output_map_open(ctx, "normalizers", n);
for (i = 0; i < n; i++) {
grn_obj *normalizer;
normalizer = GRN_PTR_VALUE_AT(&normalizers, i);
command_schema_output_name(ctx, normalizer);
grn_ctx_output_map_open(ctx, "normalizer", 1);
grn_ctx_output_cstr(ctx, "name");
command_schema_output_name(ctx, normalizer);
grn_ctx_output_map_close(ctx);
}
grn_ctx_output_map_close(ctx);
GRN_OBJ_FIN(ctx, &normalizers);
}
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 void
command_schema_column_output_sources(grn_ctx *ctx, grn_obj *column)
{
grn_obj *source_table;
grn_obj source_ids;
unsigned int i, n_ids;
source_table = grn_ctx_at(ctx, grn_obj_get_range(ctx, column));
GRN_RECORD_INIT(&source_ids, GRN_OBJ_VECTOR, GRN_ID_NIL);
if (column->header.type == GRN_COLUMN_INDEX) {
grn_obj_get_info(ctx, column, GRN_INFO_SOURCE, &source_ids);
}
n_ids = GRN_BULK_VSIZE(&source_ids) / sizeof(grn_id);
grn_ctx_output_array_open(ctx, "sources", n_ids);
for (i = 0; i < n_ids; i++) {
grn_id source_id;
grn_obj *source;
source_id = GRN_RECORD_VALUE_AT(&source_ids, i);
source = grn_ctx_at(ctx, source_id);
grn_ctx_output_map_open(ctx, "source", 3);
grn_ctx_output_cstr(ctx, "name");
if (grn_obj_is_table(ctx, source)) {
grn_ctx_output_cstr(ctx, "_key");
} else {
command_schema_output_column_name(ctx, source);
}
grn_ctx_output_cstr(ctx, "table");
command_schema_output_name(ctx, source_table);
grn_ctx_output_cstr(ctx, "full_name");
if (grn_obj_is_table(ctx, source)) {
char name[GRN_TABLE_MAX_KEY_SIZE];
unsigned int name_size;
name_size = grn_obj_name(ctx, source, name, GRN_TABLE_MAX_KEY_SIZE);
name[name_size] = '\0';
grn_strcat(name, GRN_TABLE_MAX_KEY_SIZE, "._key");
grn_ctx_output_cstr(ctx, name);
} else {
command_schema_output_name(ctx, source);
}
grn_ctx_output_map_close(ctx);
}
grn_ctx_output_array_close(ctx);
GRN_OBJ_FIN(ctx, &source_ids);
}
static void
output_tokens(grn_ctx *ctx, grn_obj *tokens, grn_obj *lexicon, grn_obj *index_column)
{
int i, n_tokens, n_elements;
grn_obj estimated_size;
n_tokens = GRN_BULK_VSIZE(tokens) / sizeof(tokenize_token);
n_elements = 3;
if (index_column) {
n_elements++;
GRN_UINT32_INIT(&estimated_size, 0);
}
grn_ctx_output_array_open(ctx, "TOKENS", n_tokens);
for (i = 0; i < n_tokens; i++) {
tokenize_token *token;
char value[GRN_TABLE_MAX_KEY_SIZE];
unsigned int value_size;
token = ((tokenize_token *)(GRN_BULK_HEAD(tokens))) + i;
grn_ctx_output_map_open(ctx, "TOKEN", n_elements);
grn_ctx_output_cstr(ctx, "value");
value_size = grn_table_get_key(ctx, lexicon, token->id,
value, GRN_TABLE_MAX_KEY_SIZE);
grn_ctx_output_str(ctx, value, value_size);
grn_ctx_output_cstr(ctx, "position");
grn_ctx_output_int32(ctx, token->position);
grn_ctx_output_cstr(ctx, "force_prefix");
grn_ctx_output_bool(ctx, token->force_prefix);
if (index_column) {
GRN_BULK_REWIND(&estimated_size);
grn_obj_get_value(ctx, index_column, token->id, &estimated_size);
grn_ctx_output_cstr(ctx, "estimated_size");
grn_ctx_output_int64(ctx, GRN_UINT32_VALUE(&estimated_size));
}
grn_ctx_output_map_close(ctx);
}
if (index_column) {
GRN_OBJ_FIN(ctx, &estimated_size);
}
grn_ctx_output_array_close(ctx);
}
static void
command_schema_column_output_indexes(grn_ctx *ctx, grn_obj *column)
{
uint32_t i;
grn_index_datum *index_data = NULL;
uint32_t n_index_data = 0;
if (column) {
n_index_data = grn_column_get_all_index_data(ctx, column, NULL, 0);
if (n_index_data > 0) {
index_data = GRN_PLUGIN_MALLOC(ctx,
sizeof(grn_index_datum) * n_index_data);
if (!index_data) {
GRN_PLUGIN_ERROR(ctx, GRN_NO_MEMORY_AVAILABLE,
"[schema] failed to allocate memory for indexes");
return;
}
grn_column_get_all_index_data(ctx, column, index_data, n_index_data);
}
}
grn_ctx_output_array_open(ctx, "indexes", n_index_data);
for (i = 0; i < n_index_data; i++) {
grn_obj *lexicon;
grn_ctx_output_map_open(ctx, "index", 4);
grn_ctx_output_cstr(ctx, "full_name");
command_schema_output_name(ctx, index_data[i].index);
grn_ctx_output_cstr(ctx, "table");
lexicon = grn_ctx_at(ctx, index_data[i].index->header.domain);
command_schema_output_name(ctx, lexicon);
grn_ctx_output_cstr(ctx, "name");
command_schema_output_column_name(ctx, index_data[i].index);
grn_ctx_output_cstr(ctx, "section");
grn_ctx_output_uint64(ctx, index_data[i].section);
grn_ctx_output_map_close(ctx);
}
grn_ctx_output_array_close(ctx);
if (index_data) {
GRN_PLUGIN_FREE(ctx, index_data);
}
}
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 void
command_schema_table_output_token_filters(grn_ctx *ctx, grn_obj *table)
{
grn_obj token_filters;
int i, n;
GRN_PTR_INIT(&token_filters, GRN_OBJ_VECTOR, GRN_DB_OBJECT);
if (table->header.type != GRN_TABLE_NO_KEY) {
grn_obj_get_info(ctx, table, GRN_INFO_TOKEN_FILTERS, &token_filters);
}
n = GRN_BULK_VSIZE(&token_filters) / sizeof(grn_obj *);
grn_ctx_output_array_open(ctx, "token_filters", n);
for (i = 0; i < n; i++) {
grn_obj *token_filter;
token_filter = GRN_PTR_VALUE_AT(&token_filters, i);
grn_ctx_output_map_open(ctx, "token_filter", 1);
grn_ctx_output_cstr(ctx, "name");
command_schema_output_name(ctx, token_filter);
grn_ctx_output_map_close(ctx);
}
grn_ctx_output_array_close(ctx);
GRN_OBJ_FIN(ctx, &token_filters);
}
static void
command_schema_column_output_type(grn_ctx *ctx, grn_obj *column)
{
switch (column->header.type) {
case GRN_COLUMN_FIX_SIZE :
case GRN_COLUMN_VAR_SIZE :
switch (column->header.flags & GRN_OBJ_COLUMN_TYPE_MASK) {
case GRN_OBJ_COLUMN_SCALAR :
grn_ctx_output_cstr(ctx, "scalar");
break;
case GRN_OBJ_COLUMN_VECTOR :
grn_ctx_output_cstr(ctx, "vector");
break;
}
break;
case GRN_COLUMN_INDEX :
grn_ctx_output_cstr(ctx, "index");
break;
}
}
static void
command_schema_output_types(grn_ctx *ctx)
{
grn_obj types;
unsigned int i, n;
GRN_PTR_INIT(&types, GRN_OBJ_VECTOR, GRN_DB_OBJECT);
grn_ctx_get_all_types(ctx, &types);
grn_ctx_output_cstr(ctx, "types");
n = GRN_BULK_VSIZE(&types) / sizeof(grn_obj *);
grn_ctx_output_map_open(ctx, "types", n);
for (i = 0; i < n; i++) {
grn_obj *type;
type = GRN_PTR_VALUE_AT(&types, i);
command_schema_output_name(ctx, type);
grn_ctx_output_map_open(ctx, "type", 4);
grn_ctx_output_cstr(ctx, "name");
command_schema_output_name(ctx, type);
grn_ctx_output_cstr(ctx, "size");
grn_ctx_output_int64(ctx, grn_type_size(ctx, type));
grn_ctx_output_cstr(ctx, "can_be_key_type");
grn_ctx_output_bool(ctx, grn_type_size(ctx, type) <= GRN_TABLE_MAX_KEY_SIZE);
grn_ctx_output_cstr(ctx, "can_be_value_type");
grn_ctx_output_bool(ctx, !(type->header.flags & GRN_OBJ_KEY_VAR_SIZE));
grn_ctx_output_map_close(ctx);
}
grn_ctx_output_map_close(ctx);
GRN_OBJ_FIN(ctx, &types);
}
static void
command_schema_output_type(grn_ctx *ctx, const char *type_label, grn_obj *type)
{
if (!type) {
grn_ctx_output_null(ctx);
return;
}
grn_ctx_output_map_open(ctx, type_label, 2);
grn_ctx_output_cstr(ctx, "name");
command_schema_output_name(ctx, type);
grn_ctx_output_cstr(ctx, "type");
if (grn_obj_is_table(ctx, type)) {
grn_ctx_output_cstr(ctx, "reference");
} else {
grn_ctx_output_cstr(ctx, "type");
}
grn_ctx_output_map_close(ctx);
}
static void
command_schema_table_output_normalizer(grn_ctx *ctx, grn_obj *table)
{
grn_obj *normalizer;
normalizer = grn_obj_get_info(ctx, table, GRN_INFO_NORMALIZER, NULL);
if (!normalizer) {
grn_ctx_output_null(ctx);
return;
}
grn_ctx_output_map_open(ctx, "normalizer", 1);
grn_ctx_output_cstr(ctx, "name");
command_schema_output_name(ctx, normalizer);
grn_ctx_output_map_close(ctx);
}
static void
command_schema_table_output_tokenizer(grn_ctx *ctx, grn_obj *table)
{
grn_obj *tokenizer;
tokenizer = grn_obj_get_info(ctx, table, GRN_INFO_DEFAULT_TOKENIZER, NULL);
if (!tokenizer) {
grn_ctx_output_null(ctx);
return;
}
grn_ctx_output_map_open(ctx, "tokenizer", 1);
grn_ctx_output_cstr(ctx, "name");
command_schema_output_name(ctx, tokenizer);
grn_ctx_output_map_close(ctx);
}
static void
command_schema_column_output_compress(grn_ctx *ctx, grn_obj *column)
{
const char *compress = NULL;
if (column->header.type != GRN_COLUMN_INDEX) {
if (column->header.flags & GRN_OBJ_COMPRESS_ZLIB) {
compress = "zlib";
} else if (column->header.flags & GRN_OBJ_COMPRESS_LZ4) {
compress = "lz4";
}
}
if (compress) {
grn_ctx_output_cstr(ctx, compress);
} else {
grn_ctx_output_null(ctx);
}
}
static void
command_schema_column_output(grn_ctx *ctx, grn_obj *table, grn_obj *column)
{
if (!column) {
return;
}
command_schema_output_column_name(ctx, column);
grn_ctx_output_map_open(ctx, "column", 12);
grn_ctx_output_cstr(ctx, "name");
command_schema_output_column_name(ctx, column);
grn_ctx_output_cstr(ctx, "table");
command_schema_output_name(ctx, table);
grn_ctx_output_cstr(ctx, "full_name");
command_schema_output_name(ctx, column);
grn_ctx_output_cstr(ctx, "type");
command_schema_column_output_type(ctx, column);
grn_ctx_output_cstr(ctx, "value_type");
command_schema_column_output_value_type(ctx, column);
grn_ctx_output_cstr(ctx, "compress");
command_schema_column_output_compress(ctx, column);
grn_ctx_output_cstr(ctx, "section");
grn_ctx_output_bool(ctx, (column->header.flags & GRN_OBJ_WITH_SECTION) != 0);
grn_ctx_output_cstr(ctx, "weight");
grn_ctx_output_bool(ctx, (column->header.flags & GRN_OBJ_WITH_WEIGHT) != 0);
grn_ctx_output_cstr(ctx, "position");
grn_ctx_output_bool(ctx, (column->header.flags & GRN_OBJ_WITH_POSITION) != 0);
grn_ctx_output_cstr(ctx, "sources");
command_schema_column_output_sources(ctx, column);
grn_ctx_output_cstr(ctx, "indexes");
command_schema_column_output_indexes(ctx, column);
grn_ctx_output_cstr(ctx, "command");
command_schema_column_output_command(ctx, table, column);
grn_ctx_output_map_close(ctx);
}
static void
command_schema_output_command(grn_ctx *ctx,
const char *command_name,
grn_obj *arguments)
{
grn_ctx_output_map_open(ctx, "command", 3);
grn_ctx_output_cstr(ctx, "name");
grn_ctx_output_cstr(ctx, command_name);
grn_ctx_output_cstr(ctx, "arguments");
{
int i, n;
n = grn_vector_size(ctx, arguments);
grn_ctx_output_map_open(ctx, "arguments", n / 2);
for (i = 0; i < n; i += 2) {
const char *name;
unsigned int name_size;
const char *value;
unsigned int value_size;
name_size = grn_vector_get_element(ctx, arguments, i, &name,
NULL, NULL);
value_size = grn_vector_get_element(ctx, arguments, i + 1, &value,
NULL, NULL);
grn_ctx_output_str(ctx, name, name_size);
grn_ctx_output_str(ctx, value, value_size);
}
grn_ctx_output_map_close(ctx);
}
grn_ctx_output_cstr(ctx, "command_line");
{
int i, n;
grn_obj command_line;
GRN_TEXT_INIT(&command_line, 0);
GRN_TEXT_PUTS(ctx, &command_line, command_name);
n = grn_vector_size(ctx, arguments);
for (i = 0; i < n; i += 2) {
const char *name;
unsigned int name_size;
const char *value;
unsigned int value_size;
name_size = grn_vector_get_element(ctx, arguments, i, &name,
NULL, NULL);
value_size = grn_vector_get_element(ctx, arguments, i + 1, &value,
NULL, NULL);
grn_text_printf(ctx, &command_line,
" --%.*s %.*s",
name_size, name,
value_size, value);
}
grn_ctx_output_str(ctx,
GRN_TEXT_VALUE(&command_line),
GRN_TEXT_LEN(&command_line));
GRN_OBJ_FIN(ctx, &command_line);
}
grn_ctx_output_map_close(ctx);
}
