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
brace_close(grn_ctx *ctx, grn_loader *loader)
{
grn_id id = GRN_ID_NIL;
grn_obj *value, *value_begin, *value_end;
grn_obj *id_value = NULL, *key_value = NULL;
uint32_t begin;
GRN_UINT32_POP(&loader->level, begin);
value_begin = (grn_obj *)GRN_TEXT_VALUE(&loader->values) + begin;
value_end = (grn_obj *)GRN_TEXT_VALUE(&loader->values) + loader->values_size;
GRN_ASSERT(value->header.domain == GRN_JSON_LOAD_OPEN_BRACE);
GRN_UINT32_SET(ctx, value_begin, loader->values_size - begin - 1);
value_begin++;
if (GRN_BULK_VSIZE(&loader->level) > sizeof(uint32_t) * loader->emit_level) {
return;
}
if (!loader->table) {
goto exit;
}
/* Scan values to find _id or _key. */
for (value = value_begin; value + 1 < value_end;
value = values_next(ctx, value)) {
const char *name = GRN_TEXT_VALUE(value);
unsigned int name_size = GRN_TEXT_LEN(value);
if (value->header.domain != GRN_DB_TEXT) {
grn_obj buffer;
GRN_TEXT_INIT(&buffer, 0);
grn_inspect(ctx, &buffer, value);
GRN_LOG(ctx, GRN_LOG_ERROR,
"column name must be string: <%.*s>",
(int)GRN_TEXT_LEN(&buffer), GRN_TEXT_VALUE(&buffer));
GRN_OBJ_FIN(ctx, &buffer);
goto exit;
}
value++;
if (name_equal(name, name_size, GRN_COLUMN_NAME_ID)) {
if (id_value || key_value) {
if (loader->table->header.type == GRN_TABLE_NO_KEY) {
GRN_LOG(ctx, GRN_LOG_ERROR, "duplicated '_id' column");
goto exit;
} else {
GRN_LOG(ctx, GRN_LOG_ERROR,
"duplicated key columns: %s and %s",
id_value ? GRN_COLUMN_NAME_ID : GRN_COLUMN_NAME_KEY,
GRN_COLUMN_NAME_ID);
goto exit;
}
}
id_value = value;
} else if (name_equal(name, name_size, GRN_COLUMN_NAME_KEY)) {
if (id_value || key_value) {
GRN_LOG(ctx, GRN_LOG_ERROR,
"duplicated key columns: %s and %s",
id_value ? GRN_COLUMN_NAME_ID : GRN_COLUMN_NAME_KEY,
GRN_COLUMN_NAME_KEY);
goto exit;
}
key_value = value;
}
}
switch (loader->table->header.type) {
case GRN_TABLE_HASH_KEY :
case GRN_TABLE_PAT_KEY :
case GRN_TABLE_DAT_KEY :
/* The target table requires _id or _key. */
if (!id_value && !key_value) {
GRN_LOG(ctx, GRN_LOG_ERROR, "neither _key nor _id is assigned");
goto exit;
}
break;
default :
/* The target table does not have _key. */
if (key_value) {
GRN_LOG(ctx, GRN_LOG_ERROR, "nonexistent key value");
goto exit;
}
break;
}
if (id_value) {
id = parse_id_value(ctx, id_value);
if (grn_table_at(ctx, loader->table, id) == GRN_ID_NIL) {
if (ctx->rc == GRN_SUCCESS) {
id = grn_table_add(ctx, loader->table, NULL, 0, NULL);
}
}
} else if (key_value) {
id = loader_add(ctx, key_value);
} else {
id = grn_table_add(ctx, loader->table, NULL, 0, NULL);
}
if (id == GRN_ID_NIL) {
/* Target record is not available. */
goto exit;
}
for (value = value_begin; value + 1 < value_end;
value = values_next(ctx, value)) {
grn_obj *col;
const char *name = GRN_TEXT_VALUE(value);
unsigned int name_size = GRN_TEXT_LEN(value);
value++;
if (value == id_value || value == key_value) {
/* Skip _id and _key, because it's already used to get id. */
continue;
}
col = grn_obj_column(ctx, loader->table, name, name_size);
if (!col) {
GRN_LOG(ctx, GRN_LOG_ERROR, "invalid column('%.*s')",
(int)name_size, name);
/* Automatic column creation is disabled. */
/*
if (value->header.domain == GRN_JSON_LOAD_OPEN_BRACKET) {
grn_obj *v = value + 1;
col = grn_column_create(ctx, loader->table, name, name_size,
NULL, GRN_OBJ_PERSISTENT|GRN_OBJ_COLUMN_VECTOR,
grn_ctx_at(ctx, v->header.domain));
} else {
col = grn_column_create(ctx, loader->table, name, name_size,
NULL, GRN_OBJ_PERSISTENT,
grn_ctx_at(ctx, value->header.domain));
}
*/
} else {
if (value->header.domain == GRN_JSON_LOAD_OPEN_BRACKET) {
set_vector(ctx, col, id, value);
} else if (value->header.domain == GRN_JSON_LOAD_OPEN_BRACE) {
set_weight_vector(ctx, col, id, value);
} else {
grn_obj_set_value(ctx, col, id, value, GRN_OBJ_SET);
}
if (ctx->rc != GRN_SUCCESS) {
grn_loader_save_error(ctx, loader);
report_set_column_value_failure(ctx, key_value,
name, name_size, value);
loader->n_column_errors++;
ERRCLR(ctx);
}
grn_obj_unlink(ctx, col);
}
}
if (loader->each) {
value = grn_expr_get_var_by_offset(ctx, loader->each, 0);
GRN_RECORD_SET(ctx, value, id);
grn_expr_exec(ctx, loader->each, 0);
}
loader->nrecords++;
exit:
if (ctx->rc != GRN_SUCCESS) {
loader->n_record_errors++;
}
if (loader->output_ids) {
GRN_UINT32_PUT(ctx, &(loader->ids), id);
}
if (loader->output_errors) {
GRN_INT32_PUT(ctx, &(loader->return_codes), ctx->rc);
grn_vector_add_element(ctx,
&(loader->error_messages),
ctx->errbuf,
strlen(ctx->errbuf),
0,
GRN_DB_TEXT);
}
loader->values_size = begin;
ERRCLR(ctx);
}
static void
bracket_close(grn_ctx *ctx, grn_loader *loader)
{
grn_id id = GRN_ID_NIL;
grn_obj *value, *value_end, *id_value = NULL, *key_value = NULL;
grn_obj *col, **cols; /* Columns except _id and _key. */
uint32_t i, begin;
uint32_t ncols; /* Number of columns except _id and _key. */
uint32_t nvalues; /* Number of values in brackets. */
uint32_t depth;
grn_bool is_record_load = GRN_FALSE;
cols = (grn_obj **)GRN_BULK_HEAD(&loader->columns);
ncols = GRN_BULK_VSIZE(&loader->columns) / sizeof(grn_obj *);
GRN_UINT32_POP(&loader->level, begin);
value = (grn_obj *)GRN_TEXT_VALUE(&loader->values) + begin;
value_end = (grn_obj *)GRN_TEXT_VALUE(&loader->values) + loader->values_size;
GRN_ASSERT(value->header.domain == GRN_JSON_LOAD_OPEN_BRACKET);
GRN_UINT32_SET(ctx, value, loader->values_size - begin - 1);
value++;
depth = GRN_BULK_VSIZE(&loader->level);
if (depth > sizeof(uint32_t) * loader->emit_level) {
return;
}
if (depth == 0 || !loader->table ||
loader->columns_status == GRN_LOADER_COLUMNS_BROKEN) {
goto exit;
}
nvalues = values_len(ctx, value, value_end);
if (loader->columns_status == GRN_LOADER_COLUMNS_UNSET) {
/*
* Target columns and _id or _key are not specified yet and values are
* handled as column names and "_id" or "_key".
*/
for (i = 0; i < nvalues; i++) {
const char *col_name;
unsigned int col_name_size;
if (value->header.domain != GRN_DB_TEXT) {
grn_obj buffer;
GRN_TEXT_INIT(&buffer, 0);
grn_inspect(ctx, &buffer, value);
ERR(GRN_INVALID_ARGUMENT,
"column name must be string: <%.*s>",
(int)GRN_TEXT_LEN(&buffer), GRN_TEXT_VALUE(&buffer));
grn_loader_save_error(ctx, loader);
GRN_OBJ_FIN(ctx, &buffer);
loader->columns_status = GRN_LOADER_COLUMNS_BROKEN;
goto exit;
}
col_name = GRN_TEXT_VALUE(value);
col_name_size = GRN_TEXT_LEN(value);
col = grn_obj_column(ctx, loader->table, col_name, col_name_size);
if (!col) {
ERR(GRN_INVALID_ARGUMENT, "nonexistent column: <%.*s>",
col_name_size, col_name);
grn_loader_save_error(ctx, loader);
loader->columns_status = GRN_LOADER_COLUMNS_BROKEN;
goto exit;
}
if (name_equal(col_name, col_name_size, GRN_COLUMN_NAME_ID)) {
grn_obj_unlink(ctx, col);
if (loader->id_offset != -1 || loader->key_offset != -1) {
/* _id and _key must not appear more than once. */
if (loader->id_offset != -1) {
ERR(GRN_INVALID_ARGUMENT,
"duplicated id and key columns: <%s> at %d and <%s> at %d",
GRN_COLUMN_NAME_ID, i,
GRN_COLUMN_NAME_ID, loader->id_offset);
} else {
ERR(GRN_INVALID_ARGUMENT,
"duplicated id and key columns: <%s> at %d and <%s> at %d",
GRN_COLUMN_NAME_ID, i,
GRN_COLUMN_NAME_KEY, loader->key_offset);
}
grn_loader_save_error(ctx, loader);
loader->columns_status = GRN_LOADER_COLUMNS_BROKEN;
goto exit;
}
loader->id_offset = i;
} else if (name_equal(col_name, col_name_size, GRN_COLUMN_NAME_KEY)) {
grn_obj_unlink(ctx, col);
if (loader->id_offset != -1 || loader->key_offset != -1) {
/* _id and _key must not appear more than once. */
if (loader->id_offset != -1) {
ERR(GRN_INVALID_ARGUMENT,
"duplicated id and key columns: <%s> at %d and <%s> at %d",
GRN_COLUMN_NAME_KEY, i,
GRN_COLUMN_NAME_ID, loader->id_offset);
} else {
ERR(GRN_INVALID_ARGUMENT,
"duplicated id and key columns: <%s> at %d and <%s> at %d",
GRN_COLUMN_NAME_KEY, i,
GRN_COLUMN_NAME_KEY, loader->key_offset);
}
grn_loader_save_error(ctx, loader);
loader->columns_status = GRN_LOADER_COLUMNS_BROKEN;
goto exit;
}
loader->key_offset = i;
} else {
GRN_PTR_PUT(ctx, &loader->columns, col);
}
value++;
}
switch (loader->table->header.type) {
case GRN_TABLE_HASH_KEY :
case GRN_TABLE_PAT_KEY :
case GRN_TABLE_DAT_KEY :
if (loader->id_offset == -1 && loader->key_offset == -1) {
ERR(GRN_INVALID_ARGUMENT, "missing id or key column");
grn_loader_save_error(ctx, loader);
loader->columns_status = GRN_LOADER_COLUMNS_BROKEN;
goto exit;
}
break;
}
loader->columns_status = GRN_LOADER_COLUMNS_SET;
goto exit;
}
is_record_load = GRN_TRUE;
/* Target columns and _id or _key are already specified. */
if (!nvalues) {
/*
* Accept empty arrays because a dump command may output a load command
* which contains empty arrays for a table with deleted records.
*/
id = grn_table_add(ctx, loader->table, NULL, 0, NULL);
} else {
uint32_t expected_nvalues = ncols;
if (loader->id_offset != -1 || loader->key_offset != -1) {
expected_nvalues++;
}
if (nvalues != expected_nvalues) {
ERR(GRN_INVALID_ARGUMENT,
"unexpected #values: expected:%u, actual:%u",
expected_nvalues, nvalues);
grn_loader_save_error(ctx, loader);
goto exit;
}
if (loader->id_offset != -1) {
id_value = value + loader->id_offset;
id = parse_id_value(ctx, id_value);
if (grn_table_at(ctx, loader->table, id) == GRN_ID_NIL) {
id = grn_table_add(ctx, loader->table, NULL, 0, NULL);
}
} else if (loader->key_offset != -1) {
key_value = value + loader->key_offset;
id = loader_add(ctx, key_value);
} else {
id = grn_table_add(ctx, loader->table, NULL, 0, NULL);
}
}
if (id == GRN_ID_NIL) {
/* Target record is not available. */
goto exit;
}
for (i = 0; i < nvalues; i++, value = values_next(ctx, value)) {
if (i == loader->id_offset || i == loader->key_offset) {
/* Skip _id and _key, because it's already used to get id. */
continue;
}
col = *cols;
if (value->header.domain == GRN_JSON_LOAD_OPEN_BRACKET) {
set_vector(ctx, col, id, value);
} else if (value->header.domain == GRN_JSON_LOAD_OPEN_BRACE) {
set_weight_vector(ctx, col, id, value);
} else {
grn_obj_set_value(ctx, col, id, value, GRN_OBJ_SET);
}
if (ctx->rc != GRN_SUCCESS) {
char column_name[GRN_TABLE_MAX_KEY_SIZE];
unsigned int column_name_size;
grn_loader_save_error(ctx, loader);
column_name_size = grn_obj_name(ctx, col, column_name,
GRN_TABLE_MAX_KEY_SIZE);
report_set_column_value_failure(ctx, key_value,
column_name, column_name_size,
value);
loader->n_column_errors++;
ERRCLR(ctx);
}
cols++;
}
if (loader->each) {
grn_obj *v = grn_expr_get_var_by_offset(ctx, loader->each, 0);
GRN_RECORD_SET(ctx, v, id);
grn_expr_exec(ctx, loader->each, 0);
}
loader->nrecords++;
exit:
if (is_record_load) {
if (ctx->rc != GRN_SUCCESS) {
loader->n_record_errors++;
}
if (loader->output_ids) {
GRN_UINT32_PUT(ctx, &(loader->ids), id);
}
if (loader->output_errors) {
GRN_INT32_PUT(ctx, &(loader->return_codes), ctx->rc);
grn_vector_add_element(ctx,
&(loader->error_messages),
ctx->errbuf,
strlen(ctx->errbuf),
0,
GRN_DB_TEXT);
}
}
loader->values_size = begin;
ERRCLR(ctx);
}
static void
set_vector(grn_ctx *ctx, grn_obj *column, grn_id id, grn_obj *vector)
{
int n = GRN_UINT32_VALUE(vector);
grn_obj buf, *v = vector + 1;
grn_id range_id;
grn_obj *range;
range_id = DB_OBJ(column)->range;
range = grn_ctx_at(ctx, range_id);
if (grn_obj_is_table(ctx, range)) {
GRN_RECORD_INIT(&buf, GRN_OBJ_VECTOR, range_id);
while (n--) {
grn_bool cast_failed = GRN_FALSE;
grn_obj record, *element = v;
if (range_id != element->header.domain) {
GRN_RECORD_INIT(&record, 0, range_id);
if (grn_obj_cast(ctx, element, &record, GRN_TRUE)) {
cast_failed = GRN_TRUE;
ERR_CAST(column, range, element);
}
element = &record;
}
if (!cast_failed) {
GRN_UINT32_PUT(ctx, &buf, GRN_RECORD_VALUE(element));
}
if (element == &record) { GRN_OBJ_FIN(ctx, element); }
v = values_next(ctx, v);
}
} else {
if (((struct _grn_type *)range)->obj.header.flags & GRN_OBJ_KEY_VAR_SIZE) {
GRN_TEXT_INIT(&buf, GRN_OBJ_VECTOR);
while (n--) {
switch (v->header.domain) {
case GRN_DB_TEXT :
{
grn_bool cast_failed = GRN_FALSE;
grn_obj casted_element, *element = v;
if (range_id != element->header.domain) {
GRN_OBJ_INIT(&casted_element, GRN_BULK, 0, range_id);
if (grn_obj_cast(ctx, element, &casted_element, GRN_TRUE)) {
cast_failed = GRN_TRUE;
ERR_CAST(column, range, element);
}
element = &casted_element;
}
if (!cast_failed) {
grn_vector_add_element(ctx, &buf,
GRN_TEXT_VALUE(element),
GRN_TEXT_LEN(element),
0,
element->header.domain);
}
if (element == &casted_element) { GRN_OBJ_FIN(ctx, element); }
break;
}
case GRN_JSON_LOAD_OPEN_BRACE :
add_weight_vector(ctx, column, v, &buf);
n -= GRN_UINT32_VALUE(v);
break;
default :
ERR(GRN_INVALID_ARGUMENT, "array must contain string or object");
break;
}
v = values_next(ctx, v);
}
} else {
grn_id value_size = ((grn_db_obj *)range)->range;
GRN_VALUE_FIX_SIZE_INIT(&buf, GRN_OBJ_VECTOR, range_id);
while (n--) {
grn_bool cast_failed = GRN_FALSE;
grn_obj casted_element, *element = v;
if (range_id != element->header.domain) {
GRN_OBJ_INIT(&casted_element, GRN_BULK, 0, range_id);
if (grn_obj_cast(ctx, element, &casted_element, GRN_TRUE)) {
cast_failed = GRN_TRUE;
ERR_CAST(column, range, element);
}
element = &casted_element;
}
if (!cast_failed) {
grn_bulk_write(ctx, &buf, GRN_TEXT_VALUE(element), value_size);
}
if (element == &casted_element) { GRN_OBJ_FIN(ctx, element); }
v = values_next(ctx, v);
}
}
}
grn_obj_set_value(ctx, column, id, &buf, GRN_OBJ_SET);
GRN_OBJ_FIN(ctx, &buf);
}
static void
grn_text_atoj(grn_ctx *ctx, grn_obj *outbuf, grn_content_type output_type,
grn_obj *obj, grn_id id)
{
int vs;
grn_obj buf;
if (obj->header.type == GRN_ACCESSOR) {
grn_accessor *a = (grn_accessor *)obj;
GRN_TEXT_INIT(&buf, 0);
for (;;) {
buf.header.domain = grn_obj_get_range(ctx, obj);
GRN_BULK_REWIND(&buf);
switch (a->action) {
case GRN_ACCESSOR_GET_ID :
GRN_UINT32_PUT(ctx, &buf, id);
buf.header.domain = GRN_DB_UINT32;
break;
case GRN_ACCESSOR_GET_KEY :
grn_table_get_key2(ctx, a->obj, id, &buf);
buf.header.domain = DB_OBJ(a->obj)->header.domain;
break;
case GRN_ACCESSOR_GET_VALUE :
grn_obj_get_value(ctx, a->obj, id, &buf);
buf.header.domain = GRN_DB_INT32; /* fix me */
break;
case GRN_ACCESSOR_GET_SCORE :
grn_obj_get_value(ctx, a->obj, id, &buf);
{
grn_rset_recinfo *ri = (grn_rset_recinfo *)grn_obj_get_value_(ctx, a->obj, id, &vs);
GRN_INT32_PUT(ctx, &buf, ri->score);
}
buf.header.domain = GRN_DB_INT32;
break;
case GRN_ACCESSOR_GET_NSUBRECS :
{
grn_rset_recinfo *ri = (grn_rset_recinfo *)grn_obj_get_value_(ctx, a->obj, id, &vs);
GRN_INT32_PUT(ctx, &buf, ri->n_subrecs);
}
buf.header.domain = GRN_DB_INT32;
break;
case GRN_ACCESSOR_GET_COLUMN_VALUE :
if ((a->obj->header.flags & GRN_OBJ_COLUMN_TYPE_MASK) == GRN_OBJ_COLUMN_VECTOR) {
if (a->next) {
grn_id *idp;
grn_obj_get_value(ctx, a->obj, id, &buf);
idp = (grn_id *)GRN_BULK_HEAD(&buf);
vs = GRN_BULK_VSIZE(&buf) / sizeof(grn_id);
grn_output_array_open(ctx, outbuf, output_type, "COLUMN", vs);
for (; vs--; idp++) {
grn_text_atoj(ctx, outbuf, output_type, (grn_obj *)a->next, *idp);
}
grn_output_array_close(ctx, outbuf, output_type);
} else {
grn_text_atoj(ctx, outbuf, output_type, a->obj, id);
}
goto exit;
} else {
grn_obj_get_value(ctx, a->obj, id, &buf);
}
break;
case GRN_ACCESSOR_GET_DB_OBJ :
/* todo */
break;
case GRN_ACCESSOR_LOOKUP :
/* todo */
break;
case GRN_ACCESSOR_FUNCALL :
/* todo */
break;
}
if (a->next) {
a = a->next;
if (GRN_BULK_VSIZE(&buf) >= sizeof(grn_id)) {
id = *((grn_id *)GRN_BULK_HEAD(&buf));
} else {
id = GRN_ID_NIL;
}
} else {
break;
}
}
} else {
switch (obj->header.type) {
case GRN_COLUMN_FIX_SIZE :
GRN_VALUE_FIX_SIZE_INIT(&buf, 0, DB_OBJ(obj)->range);
break;
case GRN_COLUMN_VAR_SIZE :
if ((obj->header.flags & GRN_OBJ_COLUMN_TYPE_MASK) == GRN_OBJ_COLUMN_VECTOR) {
grn_obj *range = grn_ctx_at(ctx, DB_OBJ(obj)->range);
if (range->header.flags & GRN_OBJ_KEY_VAR_SIZE) {
GRN_VALUE_VAR_SIZE_INIT(&buf, GRN_OBJ_VECTOR, DB_OBJ(obj)->range);
} else {
GRN_VALUE_FIX_SIZE_INIT(&buf, GRN_OBJ_VECTOR, DB_OBJ(obj)->range);
}
} else {
GRN_VALUE_VAR_SIZE_INIT(&buf, 0, DB_OBJ(obj)->range);
}
break;
case GRN_COLUMN_INDEX :
GRN_UINT32_INIT(&buf, 0);
break;
default:
GRN_TEXT_INIT(&buf, 0);
break;
}
grn_obj_get_value(ctx, obj, id, &buf);
}
grn_output_obj(ctx, outbuf, output_type, &buf, NULL);
exit :
grn_obj_close(ctx, &buf);
}