static mrb_value
mrb_grn_table_get_column_ids(mrb_state *mrb, mrb_value self)
{
grn_ctx *ctx = (grn_ctx *)mrb->ud;
grn_obj *table;
grn_hash *columns;
int n_columns;
mrb_value mrb_column_ids;
table = DATA_PTR(self);
columns = grn_hash_create(ctx, NULL, sizeof(grn_id), 0,
GRN_OBJ_TABLE_HASH_KEY | GRN_HASH_TINY);
if (!columns) {
grn_mrb_ctx_check(mrb);
return mrb_ary_new(mrb);
}
n_columns = grn_table_columns(ctx, table, "", 0, (grn_obj *)columns);
mrb_column_ids = mrb_ary_new_capa(mrb, n_columns);
{
grn_id *key;
GRN_HASH_EACH(ctx, columns, id, &key, NULL, NULL, {
mrb_ary_push(mrb, mrb_column_ids, mrb_fixnum_value(*key));
});
}
static grn_rc
grn_table_inspect(grn_ctx *ctx, grn_obj *buf, grn_obj *obj)
{
grn_hash *cols;
grn_id range_id;
grn_obj *range;
GRN_TEXT_PUTS(ctx, buf, "#<table:");
grn_table_type_inspect(ctx, buf, obj);
GRN_TEXT_PUTS(ctx, buf, " ");
grn_inspect_name(ctx, buf, obj);
if (obj->header.type != GRN_TABLE_NO_KEY) {
grn_obj *domain;
grn_id domain_id;
GRN_TEXT_PUTS(ctx, buf, " key:");
domain_id = obj->header.domain;
domain = grn_ctx_at(ctx, domain_id);
if (domain) {
grn_inspect_name(ctx, buf, domain);
grn_obj_unlink(ctx, domain);
} else if (domain_id) {
grn_text_lltoa(ctx, buf, domain_id);
} else {
GRN_TEXT_PUTS(ctx, buf, "(nil)");
}
}
GRN_TEXT_PUTS(ctx, buf, " value:");
range_id = grn_obj_get_range(ctx, obj);
range = grn_ctx_at(ctx, range_id);
if (range) {
grn_inspect_name(ctx, buf, range);
} else if (range_id) {
grn_text_lltoa(ctx, buf, range_id);
} else {
GRN_TEXT_PUTS(ctx, buf, "(nil)");
}
GRN_TEXT_PUTS(ctx, buf, " size:");
grn_text_lltoa(ctx, buf, grn_table_size(ctx, obj));
GRN_TEXT_PUTS(ctx, buf, " columns:[");
if ((cols = grn_hash_create(ctx, NULL, sizeof(grn_id), 0,
GRN_OBJ_TABLE_HASH_KEY|GRN_HASH_TINY))) {
if (grn_table_columns(ctx, obj, "", 0, (grn_obj *)cols)) {
int i = 0;
grn_id *key;
GRN_HASH_EACH(ctx, cols, id, &key, NULL, NULL, {
grn_obj *col = grn_ctx_at(ctx, *key);
if (col) {
if (i++ > 0) { GRN_TEXT_PUTS(ctx, buf, ", "); }
grn_column_name_(ctx, col, buf);
grn_obj_unlink(ctx, col);
}
});
}
static grn_obj *
proc_column_list(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 == 2) {
grn_obj *table;
grn_content_type otype = GET_OTYPE(&vars[1].value);
if ((table = grn_ctx_get(ctx, GRN_TEXT_VALUE(&vars[0].value),
GRN_TEXT_LEN(&vars[0].value)))) {
grn_hash *cols;
if ((cols = grn_hash_create(ctx, NULL, sizeof(grn_id), 0,
GRN_OBJ_TABLE_HASH_KEY|GRN_HASH_TINY))) {
if (grn_table_columns(ctx, table, NULL, 0, (grn_obj *)cols) >= 0) {
grn_id *key;
char line_delimiter, column_delimiter;
switch (otype) {
case GRN_CONTENT_TSV:
line_delimiter = '\n';
column_delimiter = '\t';
GRN_TEXT_PUTS(ctx, buf, "id\tname\tpath\ttype\tflags\tdomain");
break;
case GRN_CONTENT_JSON:
line_delimiter = ',';
column_delimiter = ',';
GRN_TEXT_PUTS(ctx, buf, "[[\"id\",\"name\",\"path\",\"type\",\"flags\",\"domain\"]");
break;
}
GRN_HASH_EACH(ctx, cols, id, &key, NULL, NULL, {
grn_obj *col;
if ((col = grn_ctx_at(ctx, *key))) {
GRN_TEXT_PUTC(ctx, buf, line_delimiter);
if (!print_columninfo(ctx, col, buf, otype)) {
grn_bulk_truncate(ctx, buf, GRN_BULK_VSIZE(buf) - 1);
}
grn_obj_unlink(ctx, col);
}
});
if (otype == GRN_CONTENT_JSON) {
GRN_TEXT_PUTC(ctx, buf, ']');
}
}
/* grn_ts_writer_expand() expands a wildcard. */
static grn_rc
grn_ts_writer_expand(grn_ctx *ctx, grn_ts_writer *writer,
grn_obj *table, grn_ts_str str)
{
grn_rc rc = GRN_SUCCESS;
grn_hash_cursor *cursor;
grn_hash *hash = grn_hash_create(ctx, NULL, sizeof(grn_ts_id), 0,
GRN_OBJ_TABLE_HASH_KEY | GRN_HASH_TINY);
if (!hash) {
return GRN_INVALID_ARGUMENT;
}
grn_table_columns(ctx, table, str.ptr, str.size - 1, (grn_obj *)hash);
if (ctx->rc != GRN_SUCCESS) {
return ctx->rc;
}
cursor = grn_hash_cursor_open(ctx, hash, NULL, 0, NULL, 0, 0, -1, 0);
if (!cursor) {
rc = GRN_INVALID_ARGUMENT;
} else {
while (grn_hash_cursor_next(ctx, cursor) != GRN_ID_NIL) {
char name_buf[GRN_TABLE_MAX_KEY_SIZE];
size_t name_size;
grn_obj *column;
grn_ts_id *column_id;
if (!grn_hash_cursor_get_key(ctx, cursor, (void **)&column_id)) {
rc = GRN_INVALID_ARGUMENT;
break;
}
column = grn_ctx_at(ctx, *column_id);
if (!column) {
rc = GRN_INVALID_ARGUMENT;
break;
}
name_size = grn_column_name(ctx, column, name_buf, sizeof(name_buf));
grn_obj_unlink(ctx, column);
rc = grn_vector_add_element(ctx, &writer->name_buf,
name_buf, name_size, 0, GRN_DB_TEXT);
if (rc != GRN_SUCCESS) {
break;
}
}
grn_hash_cursor_close(ctx, cursor);
}
grn_hash_close(ctx, hash);
return rc;
}
static grn_rc
grn_table_columns_inspect(grn_ctx *ctx, grn_obj *buf, grn_obj *obj)
{
grn_hash *cols;
GRN_TEXT_PUTS(ctx, buf, "columns:[");
if ((cols = grn_hash_create(ctx, NULL, sizeof(grn_id), 0,
GRN_OBJ_TABLE_HASH_KEY|GRN_HASH_TINY))) {
if (grn_table_columns(ctx, obj, "", 0, (grn_obj *)cols)) {
int i = 0;
grn_id *key;
GRN_HASH_EACH(ctx, cols, id, &key, NULL, NULL, {
grn_obj *col = grn_ctx_at(ctx, *key);
if (col) {
if (i++ > 0) { GRN_TEXT_PUTS(ctx, buf, ", "); }
grn_column_name_(ctx, col, buf);
grn_obj_unlink(ctx, col);
}
});
}
static void
grn_table_reindex(grn_ctx *ctx, grn_obj *table)
{
grn_hash *columns;
columns = grn_hash_create(ctx, NULL, sizeof(grn_id), 0,
GRN_OBJ_TABLE_HASH_KEY | GRN_HASH_TINY);
if (!columns) {
ERR(GRN_NO_MEMORY_AVAILABLE,
"[table][reindex] failed to create a table to store columns");
return;
}
if (grn_table_columns(ctx, table, "", 0, (grn_obj *)columns) > 0) {
grn_bool have_data_column = GRN_FALSE;
grn_id *key;
GRN_HASH_EACH(ctx, columns, id, &key, NULL, NULL, {
grn_obj *column = grn_ctx_at(ctx, *key);
if (column && column->header.type != GRN_COLUMN_INDEX) {
have_data_column = GRN_TRUE;
break;
}
});
static void
command_schema_table_output_columns(grn_ctx *ctx, grn_obj *table)
{
grn_hash *columns;
columns = grn_hash_create(ctx, NULL, sizeof(grn_id), 0,
GRN_OBJ_TABLE_HASH_KEY | GRN_HASH_TINY);
if (!columns) {
grn_ctx_output_map_open(ctx, "columns", 0);
grn_ctx_output_map_close(ctx);
return;
}
grn_table_columns(ctx, table, "", 0, (grn_obj *)columns);
grn_ctx_output_map_open(ctx, "columns", grn_hash_size(ctx, columns));
{
grn_id *key;
GRN_HASH_EACH(ctx, columns, id, &key, NULL, NULL, {
grn_obj *column;
column = grn_ctx_at(ctx, *key);
command_schema_column_output(ctx, table, column);
});
}
