/*
* call-seq:
* column.local_name
*
* テーブル名を除いたカラム名を返す。
*
* items = Groonga::Array.create(:name => "Items")
* title = items.define_column("title", "ShortText")
* title.name # => "Items.title"
* title.local_name # => "title"
*/
static VALUE
rb_grn_column_get_local_name (VALUE self)
{
RbGrnColumn *rb_grn_column;
grn_ctx *context = NULL;
grn_obj *column;
VALUE rb_name;
char *name;
int name_size;
rb_grn_column = SELF(self);
rb_grn_object_deconstruct(RB_GRN_OBJECT(rb_grn_column), &column, &context,
NULL, NULL,
NULL, NULL);
name_size = grn_column_name(context, column, NULL, 0);
if (name_size == 0)
return Qnil;
name = xmalloc(name_size);
grn_column_name(context, column, name, name_size);
rb_name = rb_str_new(name, name_size);
xfree(name);
return rb_name;
}
static void
command_schema_output_column_name(grn_ctx *ctx, grn_obj *column)
{
char name[GRN_TABLE_MAX_KEY_SIZE];
unsigned int name_size;
name_size = grn_column_name(ctx, column, name, GRN_TABLE_MAX_KEY_SIZE);
grn_ctx_output_str(ctx, name, name_size);
}
/* 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_id
resolve_source_id (grn_ctx *context, grn_obj *column, grn_id range_id,
VALUE rb_source)
{
grn_id source_id;
if (CBOOL2RVAL(rb_obj_is_kind_of(rb_source, rb_cInteger))) {
source_id = NUM2UINT(rb_source);
} else {
grn_obj *source;
grn_bool need_source_unlink = GRN_FALSE;
if (TYPE(rb_source) == T_STRING) {
grn_obj *table;
const char *name;
const char *dot_point;
int length;
table = grn_ctx_at(context, grn_obj_get_range(context, column));
name = StringValueCStr(rb_source);
length = RSTRING_LEN(rb_source);
dot_point = strstr(name, ".");
if (dot_point) {
char table_name[4096];
int table_name_length;
table_name_length = grn_obj_name(context, table,
table_name, sizeof(table_name));
table_name[table_name_length] = '\0';
if (strncmp(table_name, name, dot_point - name) != 0) {
rb_raise(rb_eArgError,
"wrong table's column: <%s>: "
"expected table: <%s>",
name, table_name);
}
length -= (dot_point - name) + 1;
name = dot_point + 1;
}
source = grn_obj_column(context, table, name, length);
need_source_unlink = GRN_TRUE;
} else {
source = RVAL2GRNOBJECT(rb_source, &context);
}
rb_grn_context_check(context, rb_source);
if (source->header.type == GRN_ACCESSOR) {
char name[256];
int length;
length = grn_column_name(context, source, name, sizeof(name));
name[length] = '\0';
if (strcmp(name, "_key") != 0) {
rb_raise(rb_eArgError,
"source accessor must be '_key': <%s>", name);
}
source_id = range_id;
} else {
source_id = grn_obj_id(context, source);
}
if (need_source_unlink) {
grn_obj_unlink(context, source);
}
}
return source_id;
}
static int
print_columninfo(grn_ctx *ctx, grn_obj *column, grn_obj *buf, grn_content_type otype)
{
grn_id id;
char *type, name[GRN_TABLE_MAX_KEY_SIZE];
const char *path;
int name_len;
switch (column->header.type) {
case GRN_COLUMN_FIX_SIZE:
type = "\"fix\"";
break;
case GRN_COLUMN_VAR_SIZE:
type = "\"var\"";
break;
case GRN_COLUMN_INDEX:
type = "\"index\"";
break;
default:
GRN_LOG(ctx, GRN_LOG_NOTICE, "invalid header type %d\n", column->header.type);
return 0;
}
id = grn_obj_id(ctx, column);
name_len = grn_column_name(ctx, column, name, GRN_TABLE_MAX_KEY_SIZE);
path = grn_obj_path(ctx, column);
switch (otype) {
case GRN_CONTENT_TSV:
grn_text_itoa(ctx, buf, id);
GRN_TEXT_PUTC(ctx, buf, '\t');
grn_text_esc(ctx, buf, name, name_len);
GRN_TEXT_PUTC(ctx, buf, '\t');
grn_text_esc(ctx, buf, path, GRN_STRLEN(path));
GRN_TEXT_PUTC(ctx, buf, '\t');
GRN_TEXT_PUTS(ctx, buf, type);
GRN_TEXT_PUTC(ctx, buf, '\t');
grn_text_itoa(ctx, buf, column->header.flags);
GRN_TEXT_PUTC(ctx, buf, '\t');
grn_text_itoa(ctx, buf, column->header.domain);
/* TODO: flags to str, domain to str */
break;
case GRN_CONTENT_JSON:
GRN_TEXT_PUTC(ctx, buf, '[');
grn_text_itoa(ctx, buf, id);
GRN_TEXT_PUTC(ctx, buf, ',');
grn_text_esc(ctx, buf, name, name_len);
GRN_TEXT_PUTC(ctx, buf, ',');
grn_text_esc(ctx, buf, path, GRN_STRLEN(path));
GRN_TEXT_PUTC(ctx, buf, ',');
GRN_TEXT_PUTS(ctx, buf, type);
GRN_TEXT_PUTC(ctx, buf, ',');
grn_text_itoa(ctx, buf, column->header.flags);
GRN_TEXT_PUTC(ctx, buf, ',');
grn_text_itoa(ctx, buf, column->header.domain);
/* TODO: flags to str, domain to str */
GRN_TEXT_PUTC(ctx, buf, ']');
break;
}
return 1;
}
static void
command_schema_column_command_collect_arguments(grn_ctx *ctx,
grn_obj *table,
grn_obj *column,
grn_obj *arguments)
{
#define ADD(name_, value_) \
grn_vector_add_element(ctx, arguments, \
name_, strlen(name_), \
0, GRN_DB_TEXT); \
grn_vector_add_element(ctx, arguments, \
value_, strlen(value_), \
0, GRN_DB_TEXT)
#define ADD_OBJECT_NAME(name_, object_) do { \
char object_name[GRN_TABLE_MAX_KEY_SIZE]; \
unsigned int object_name_size; \
object_name_size = grn_obj_name(ctx, object_, \
object_name, \
GRN_TABLE_MAX_KEY_SIZE); \
object_name[object_name_size] = '\0'; \
ADD(name_, object_name); \
} while (GRN_FALSE)
ADD_OBJECT_NAME("table", table);
{
char column_name[GRN_TABLE_MAX_KEY_SIZE];
unsigned int column_name_size;
column_name_size = grn_column_name(ctx, column,
column_name, GRN_TABLE_MAX_KEY_SIZE);
column_name[column_name_size] = '\0';
ADD("name", column_name);
}
{
grn_obj flags;
GRN_TEXT_INIT(&flags, 0);
grn_dump_column_create_flags(ctx,
column->header.flags & ~GRN_OBJ_PERSISTENT,
&flags);
GRN_TEXT_PUTC(ctx, &flags, '\0');
ADD("flags", GRN_TEXT_VALUE(&flags));
GRN_OBJ_FIN(ctx, &flags);
}
{
grn_obj *value_type;
value_type = grn_ctx_at(ctx, grn_obj_get_range(ctx, column));
ADD_OBJECT_NAME("type", value_type);
}
if (column->header.type == GRN_COLUMN_INDEX) {
grn_obj source_ids;
unsigned int n_ids;
GRN_RECORD_INIT(&source_ids, GRN_OBJ_VECTOR, GRN_ID_NIL);
grn_obj_get_info(ctx, column, GRN_INFO_SOURCE, &source_ids);
n_ids = GRN_BULK_VSIZE(&source_ids) / sizeof(grn_id);
if (n_ids > 0) {
grn_obj sources;
unsigned int i;
GRN_TEXT_INIT(&sources, 0);
for (i = 0; i < n_ids; i++) {
grn_id source_id;
grn_obj *source;
char name[GRN_TABLE_MAX_KEY_SIZE];
unsigned int name_size;
source_id = GRN_RECORD_VALUE_AT(&source_ids, i);
source = grn_ctx_at(ctx, source_id);
if (grn_obj_is_table(ctx, source)) {
grn_strcpy(name, GRN_TABLE_MAX_KEY_SIZE, "_key");
name_size = strlen(name);
} else {
name_size = grn_column_name(ctx, source, name, GRN_TABLE_MAX_KEY_SIZE);
}
if (i > 0) {
GRN_TEXT_PUTC(ctx, &sources, ',');
}
GRN_TEXT_PUT(ctx, &sources, name, name_size);
}
GRN_TEXT_PUTC(ctx, &sources, '\0');
ADD("sources", GRN_TEXT_VALUE(&sources));
GRN_OBJ_FIN(ctx, &sources);
}
GRN_OBJ_FIN(ctx, &source_ids);
}
#undef ADD_OBJECT_NAME
#undef ADD
}
