grn_rc
grn_ts_expr_parse(grn_ctx *ctx, grn_obj *table, grn_ts_str str,
grn_ts_expr **expr)
{
grn_rc rc;
grn_ts_expr *new_expr;
grn_ts_expr_parser *parser;
if (!ctx) {
return GRN_INVALID_ARGUMENT;
}
if (!table || !grn_ts_obj_is_table(ctx, table) ||
(!str.ptr && str.size) || !expr) {
GRN_TS_ERR_RETURN(GRN_INVALID_ARGUMENT, "invalid argument");
}
rc = grn_ts_expr_parser_open(ctx, table, &parser);
if (rc != GRN_SUCCESS) {
return rc;
}
rc = grn_ts_expr_parser_parse(ctx, parser, str, &new_expr);
grn_ts_expr_parser_close(ctx, parser);
if (rc != GRN_SUCCESS) {
return rc;
}
*expr = new_expr;
return GRN_SUCCESS;
}
grn_rc
grn_ts_select(grn_ctx *ctx, grn_obj *table,
const char *filter_ptr, size_t filter_len,
const char *scorer_ptr, size_t scorer_len,
const char *sortby_ptr, size_t sortby_len,
const char *output_columns_ptr, size_t output_columns_len,
size_t offset, size_t limit)
{
grn_rc rc;
grn_ts_str filter = { filter_ptr, filter_len };
grn_ts_str scorer = { scorer_ptr, scorer_len };
grn_ts_str sortby = { sortby_ptr, sortby_len };
grn_ts_str output_columns = { output_columns_ptr, output_columns_len };
if (!ctx) {
return GRN_INVALID_ARGUMENT;
}
if (!table || !grn_ts_obj_is_table(ctx, table) ||
(!filter_ptr && filter_len) || (!scorer_ptr && scorer_len) ||
(!sortby_ptr && sortby_len) ||
(!output_columns_ptr && output_columns_len)) {
GRN_TS_ERR_RETURN(GRN_INVALID_ARGUMENT, "invalid argument");
}
if (sortby_len) {
rc = grn_ts_select_with_sortby(ctx, table, filter, scorer, sortby,
output_columns, offset, limit);
} else {
rc = grn_ts_select_without_sortby(ctx, table, filter, scorer,
output_columns, offset, limit);
}
if (rc != GRN_SUCCESS) {
GRN_BULK_REWIND(ctx->impl->output.buf);
if ((ctx->rc == GRN_SUCCESS) || !ctx->errbuf[0]) {
ERR(rc, "error message is missing");
} else if (ctx->errlvl < GRN_LOG_ERROR) {
ctx->errlvl = GRN_LOG_ERROR;
}
}
return rc;
}
grn_rc
grn_ts_expr_open(grn_ctx *ctx, grn_obj *table, grn_ts_expr_node *root,
grn_ts_expr **expr)
{
grn_rc rc;
grn_ts_expr *new_expr;
grn_ts_expr_type type;
if (!ctx) {
return GRN_INVALID_ARGUMENT;
}
if (!table || !grn_ts_obj_is_table(ctx, table) || !root || !expr) {
GRN_TS_ERR_RETURN(GRN_INVALID_ARGUMENT, "invalid argument");
}
switch (root->type) {
case GRN_TS_EXPR_ID_NODE: {
type = GRN_TS_EXPR_ID;
break;
}
case GRN_TS_EXPR_SCORE_NODE: {
type = GRN_TS_EXPR_SCORE;
break;
}
case GRN_TS_EXPR_KEY_NODE:
case GRN_TS_EXPR_VALUE_NODE: {
type = GRN_TS_EXPR_VARIABLE;
break;
}
case GRN_TS_EXPR_CONST_NODE: {
type = GRN_TS_EXPR_CONST;
break;
}
case GRN_TS_EXPR_COLUMN_NODE:
case GRN_TS_EXPR_OP_NODE:
case GRN_TS_EXPR_BRIDGE_NODE: {
type = GRN_TS_EXPR_VARIABLE;
break;
}
default: {
GRN_TS_ERR_RETURN(GRN_INVALID_ARGUMENT, "invalid argument");
}
}
new_expr = GRN_MALLOCN(grn_ts_expr, 1);
if (!new_expr) {
GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE,
"GRN_MALLOCN failed: %" GRN_FMT_SIZE,
sizeof(grn_ts_expr));
}
rc = grn_ts_obj_increment_ref_count(ctx, table);
if (rc != GRN_SUCCESS) {
GRN_FREE(new_expr);
return rc;
}
grn_ts_expr_init(ctx, new_expr);
new_expr->table = table;
new_expr->type = type;
new_expr->data_kind = root->data_kind;
new_expr->data_type = root->data_type;
new_expr->root = root;
*expr = new_expr;
return GRN_SUCCESS;
}
/* grn_ts_writer_output_header() outputs names and data types. */
static grn_rc
grn_ts_writer_output_header(grn_ctx *ctx, grn_ts_writer *writer)
{
grn_rc rc;
GRN_OUTPUT_ARRAY_OPEN("COLUMNS", writer->n_exprs);
for (size_t i = 0; i < writer->n_exprs; ++i) {
GRN_OUTPUT_ARRAY_OPEN("COLUMN", 2);
rc = grn_text_esc(ctx, ctx->impl->output.buf,
writer->names[i].ptr, writer->names[i].size);
if (rc != GRN_SUCCESS) {
return rc;
}
GRN_TEXT_PUT(ctx, ctx->impl->output.buf, ",\"", 2);
switch (writer->exprs[i]->data_type) {
case GRN_DB_VOID: {
if (writer->exprs[i]->data_kind == GRN_TS_GEO) {
GRN_TEXT_PUTS(ctx, ctx->impl->output.buf, "GeoPoint");
} else {
GRN_TEXT_PUTS(ctx, ctx->impl->output.buf, "Void");
}
break;
}
GRN_TS_WRITER_OUTPUT_HEADER_CASE(BOOL, "Bool")
GRN_TS_WRITER_OUTPUT_HEADER_CASE(INT8, "Int8")
GRN_TS_WRITER_OUTPUT_HEADER_CASE(INT16, "Int16")
GRN_TS_WRITER_OUTPUT_HEADER_CASE(INT32, "Int32")
GRN_TS_WRITER_OUTPUT_HEADER_CASE(INT64, "Int64")
GRN_TS_WRITER_OUTPUT_HEADER_CASE(UINT8, "UInt8")
GRN_TS_WRITER_OUTPUT_HEADER_CASE(UINT16, "UInt16")
GRN_TS_WRITER_OUTPUT_HEADER_CASE(UINT32, "UInt32")
GRN_TS_WRITER_OUTPUT_HEADER_CASE(UINT64, "UInt64")
GRN_TS_WRITER_OUTPUT_HEADER_CASE(FLOAT, "Float")
GRN_TS_WRITER_OUTPUT_HEADER_CASE(TIME, "Time")
GRN_TS_WRITER_OUTPUT_HEADER_CASE(SHORT_TEXT, "ShortText")
GRN_TS_WRITER_OUTPUT_HEADER_CASE(TEXT, "Text")
GRN_TS_WRITER_OUTPUT_HEADER_CASE(LONG_TEXT, "LongText")
GRN_TS_WRITER_OUTPUT_HEADER_CASE(TOKYO_GEO_POINT, "TokyoGeoPoint")
GRN_TS_WRITER_OUTPUT_HEADER_CASE(WGS84_GEO_POINT, "WGS84GeoPoint")
default: {
char name_buf[GRN_TABLE_MAX_KEY_SIZE];
size_t name_size;
grn_obj *obj = grn_ctx_at(ctx, writer->exprs[i]->data_type);
if (!obj) {
GRN_TS_ERR_RETURN(GRN_UNKNOWN_ERROR, "grn_ctx_at failed: %d",
writer->exprs[i]->data_type);
}
if (!grn_ts_obj_is_table(ctx, obj)) {
grn_obj_unlink(ctx, obj);
GRN_TS_ERR_RETURN(GRN_UNKNOWN_ERROR, "not table: %d",
writer->exprs[i]->data_type);
}
name_size = grn_obj_name(ctx, obj, name_buf, sizeof(name_buf));
GRN_TEXT_PUT(ctx, ctx->impl->output.buf, name_buf, name_size);
grn_obj_unlink(ctx, obj);
break;
}
}
GRN_TEXT_PUTC(ctx, ctx->impl->output.buf, '"');
GRN_OUTPUT_ARRAY_CLOSE();
}
GRN_OUTPUT_ARRAY_CLOSE(); /* COLUMNS. */
return GRN_SUCCESS;
}
