susumu.yata
null+****@clear*****
Wed Nov 25 13:54:03 JST 2015
susumu.yata 2015-11-25 13:54:03 +0900 (Wed, 25 Nov 2015) New Revision: d3daaabe068bc96a5a6ad02acd823a16f5beb58f https://github.com/groonga/groonga/commit/d3daaabe068bc96a5a6ad02acd823a16f5beb58f Message: grn_ts: add grn_ts_sorter stubs GitHub: #429 Modified files: lib/ts/ts_log.h lib/ts/ts_sorter.c lib/ts/ts_sorter.h Modified: lib/ts/ts_log.h (+1 -0) =================================================================== --- lib/ts/ts_log.h 2015-11-24 16:17:11 +0900 (ba77d50) +++ lib/ts/ts_log.h 2015-11-25 13:54:03 +0900 (b671a34) @@ -20,6 +20,7 @@ #define GRN_TS_LOG_H #include "../grn.h" +#include "../grn_ctx.h" #ifdef __cplusplus extern "C" { Modified: lib/ts/ts_sorter.c (+278 -1) =================================================================== --- lib/ts/ts_sorter.c 2015-11-24 16:17:11 +0900 (d0117ca) +++ lib/ts/ts_sorter.c 2015-11-25 13:54:03 +0900 (bd3d14b) @@ -18,4 +18,281 @@ #include "ts_sorter.h" -// TODO +#include <string.h> + +#include "ts_log.h" +#include "ts_util.h" + +/*------------------------------------------------------------- + * grn_ts_sorter_node. + */ + +/* grn_ts_sorter_node_init() initializes a sorter node. */ +static void +grn_ts_sorter_node_init(grn_ctx *ctx, grn_ts_sorter_node *node) +{ + memset(node, 0, sizeof(*node)); + node->expr = NULL; + node->next = NULL; +} + +/* grn_ts_sorter_node_fin() finalizes a sorter node. */ +static void +grn_ts_sorter_node_fin(grn_ctx *ctx, grn_ts_sorter_node *node) +{ + if (node->expr) { + grn_ts_expr_close(ctx, node->expr); + } +} + +/* grn_ts_sorter_node_open() creates a sorter nodes. */ +static grn_rc +grn_ts_sorter_node_open(grn_ctx *ctx, grn_ts_expr *expr, grn_ts_bool reverse, + grn_ts_sorter_node **node) +{ + grn_ts_sorter_node *new_node; + new_node = GRN_MALLOCN(grn_ts_sorter_node, 1); + if (!new_node) { + GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE, + "GRN_MALLOCN failed: %" GRN_FMT_SIZE " x 1", + sizeof(grn_ts_sorter_node)); + } + grn_ts_sorter_node_init(ctx, new_node); + new_node->expr = expr; + new_node->reverse = reverse; + *node = new_node; + return GRN_SUCCESS; +} + +/* grn_ts_sorter_node_close() destroys a sorter node. */ +static void +grn_ts_sorter_node_close(grn_ctx *ctx, grn_ts_sorter_node *node) +{ + grn_ts_sorter_node_fin(ctx, node); + GRN_FREE(node); +} + +/* grn_ts_sorter_node_list_close() destroys a linked list of sorter nodes. */ +static void +grn_ts_sorter_node_list_close(grn_ctx *ctx, grn_ts_sorter_node *head) +{ + grn_ts_sorter_node *node = head; + while (node) { + grn_ts_sorter_node *next = node->next; + grn_ts_sorter_node_close(ctx, node); + node = next; + } +} + +/*------------------------------------------------------------- + * grn_ts_sorter. + */ + +static void +grn_ts_sorter_init(grn_ctx *ctx, grn_ts_sorter *sorter) +{ + memset(sorter, 0, sizeof(*sorter)); + sorter->table = NULL; + sorter->head = NULL; +} + +static void +grn_ts_sorter_fin(grn_ctx *ctx, grn_ts_sorter *sorter) +{ + if (sorter->head) { + grn_ts_sorter_node_list_close(ctx, sorter->head); + } + if (sorter->table) { + grn_obj_unlink(ctx, sorter->table); + } +} + +grn_rc +grn_ts_sorter_open(grn_ctx *ctx, grn_obj *table, grn_ts_sorter_node *head, + grn_ts_int offset, grn_ts_int limit, grn_ts_sorter **sorter) +{ + grn_rc rc; + grn_ts_sorter *new_sorter; + if (!ctx) { + return GRN_INVALID_ARGUMENT; + } + if (!table || !grn_ts_obj_is_table(ctx, table) || !head || !sorter) { + GRN_TS_ERR_RETURN(GRN_INVALID_ARGUMENT, "invalid argument"); + } + new_sorter = GRN_MALLOCN(grn_ts_sorter, 1); + if (!new_sorter) { + GRN_TS_ERR_RETURN(GRN_INVALID_ARGUMENT, + "GRN_MALLOCN failed: %" GRN_FMT_SIZE " x 1", + sizeof(grn_ts_sorter)); + } + rc = grn_ts_obj_increment_ref_count(ctx, table); + if (rc != GRN_SUCCESS) { + GRN_FREE(new_sorter); + return rc; + } + grn_ts_sorter_init(ctx, new_sorter); + new_sorter->table = table; + new_sorter->head = head; + new_sorter->offset = offset; + new_sorter->limit = limit; + *sorter = new_sorter; + return GRN_SUCCESS; +} + +grn_rc +grn_ts_sorter_parse(grn_ctx *ctx, grn_obj *table, + grn_ts_str str, grn_ts_int offset, + grn_ts_int limit, grn_ts_sorter **sorter) +{ + // TODO + return GRN_FUNCTION_NOT_IMPLEMENTED; +} + +grn_rc +grn_ts_sorter_close(grn_ctx *ctx, grn_ts_sorter *sorter) +{ + if (!ctx) { + return GRN_INVALID_ARGUMENT; + } + if (!sorter) { + GRN_TS_ERR_RETURN(GRN_INVALID_ARGUMENT, "invalid argument"); + } + grn_ts_sorter_fin(ctx, sorter); + GRN_FREE(sorter); + return GRN_SUCCESS; +} + +grn_rc +grn_ts_sorter_progress(grn_ctx *ctx, grn_ts_sorter *sorter, + grn_ts_record *recs, size_t n_recs) +{ + // TODO + return GRN_FUNCTION_NOT_IMPLEMENTED; +} + +grn_rc +grn_ts_sorter_complete(grn_ctx *ctx, grn_ts_sorter *sorter, + grn_ts_record *recs, size_t n_recs) +{ + // TODO + return GRN_FUNCTION_NOT_IMPLEMENTED; +} + +/*------------------------------------------------------------- + * grn_ts_sorter_builder. + */ + +/* grn_ts_sorter_builder_init() initializes a sorter builder. */ +static void +grn_ts_sorter_builder_init(grn_ctx *ctx, grn_ts_sorter_builder *builder) +{ + memset(builder, 0, sizeof(*builder)); + builder->table = NULL; + builder->head = NULL; + builder->tail = NULL; +} + +/* grn_ts_sorter_builder_fin() finalizes a sorter builder. */ +static void +grn_ts_sorter_builder_fin(grn_ctx *ctx, grn_ts_sorter_builder *builder) +{ + if (builder->head) { + grn_ts_sorter_node_list_close(ctx, builder->head); + } + if (builder->table) { + grn_obj_unlink(ctx, builder->table); + } +} + +grn_rc +grn_ts_sorter_builder_open(grn_ctx *ctx, grn_obj *table, + grn_ts_sorter_builder **builder) +{ + grn_rc rc; + grn_ts_sorter_builder *new_builder; + if (!ctx) { + return GRN_INVALID_ARGUMENT; + } + if (!table || !grn_ts_obj_is_table(ctx, table) || !builder) { + GRN_TS_ERR_RETURN(GRN_INVALID_ARGUMENT, "invalid argument"); + } + new_builder = GRN_MALLOCN(grn_ts_sorter_builder, 1); + if (!new_builder) { + GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE, + "GRN_MALLOCN failed: %" GRN_FMT_SIZE " x 1", + sizeof(grn_ts_sorter_builder)); + } + grn_ts_sorter_builder_init(ctx, new_builder); + rc = grn_ts_obj_increment_ref_count(ctx, table); + if (rc != GRN_SUCCESS) { + grn_ts_sorter_builder_fin(ctx, new_builder); + GRN_FREE(new_builder); + return rc; + } + new_builder->table = table; + *builder = new_builder; + return GRN_SUCCESS; +} + +grn_rc +grn_ts_sorter_builder_close(grn_ctx *ctx, grn_ts_sorter_builder *builder) +{ + if (!ctx) { + return GRN_INVALID_ARGUMENT; + } + if (!builder) { + GRN_TS_ERR_RETURN(GRN_INVALID_ARGUMENT, "invalid argument"); + } + grn_ts_sorter_builder_fin(ctx, builder); + GRN_FREE(builder); + return GRN_SUCCESS; +} + +grn_rc +grn_ts_sorter_builder_complete(grn_ctx *ctx, grn_ts_sorter_builder *builder, + grn_ts_int offset, grn_ts_int limit, + grn_ts_sorter **sorter) +{ + grn_rc rc; + grn_ts_sorter *new_sorter; + if (!ctx) { + return GRN_INVALID_ARGUMENT; + } + if (!builder || !builder->head || !sorter) { + GRN_TS_ERR_RETURN(GRN_INVALID_ARGUMENT, "invalid argument"); + } + rc = grn_ts_sorter_open(ctx, builder->table, builder->head, + offset, limit, &new_sorter); + if (rc != GRN_SUCCESS) { + return rc; + } + builder->head = NULL; + builder->tail = NULL; + *sorter = new_sorter; + return GRN_SUCCESS; +} + +grn_rc +grn_ts_sorter_builder_push(grn_ctx *ctx, grn_ts_sorter_builder *builder, + grn_ts_expr *expr, grn_ts_bool reverse) +{ + grn_rc rc; + grn_ts_sorter_node *new_node; + if (!ctx) { + return GRN_INVALID_ARGUMENT; + } + if (!builder || !expr) { + GRN_TS_ERR_RETURN(GRN_INVALID_ARGUMENT, "invalid argument"); + } + rc = grn_ts_sorter_node_open(ctx, expr, reverse, &new_node); + if (rc != GRN_SUCCESS) { + return rc; + } + if (builder->tail) { + builder->tail->next = new_node; + } else { + builder->head = new_node; + } + builder->tail = new_node; + return GRN_SUCCESS; +} Modified: lib/ts/ts_sorter.h (+22 -5) =================================================================== --- lib/ts/ts_sorter.h 2015-11-24 16:17:11 +0900 (55fe868) +++ lib/ts/ts_sorter.h 2015-11-25 13:54:03 +0900 (e2e1f64) @@ -21,6 +21,7 @@ #include "../grn.h" +#include "ts_expr.h" #include "ts_str.h" #include "ts_types.h" @@ -30,13 +31,17 @@ extern "C" { /* TODO: Sorting should take into account the order of input records. */ -typedef struct { - int REMOVE_ME; +typedef struct grn_ts_sorter_node { + grn_ts_expr *expr; /* Expression. */ + grn_ts_bool reverse; /* Reverse order or not. */ + struct grn_ts_sorter_node *next; /* Next node. */ } grn_ts_sorter_node; typedef struct { - grn_obj *table; - grn_ts_sorter_node *head; + grn_obj *table; /* Table. */ + grn_ts_sorter_node *head; /* First node. */ + grn_ts_int offset; /* Top `offset` records will be discarded. */ + grn_ts_int limit; /* At most `limit` records will be left. */ } grn_ts_sorter; /* grn_ts_sorter_open() creates a sorter. */ @@ -61,7 +66,9 @@ grn_rc grn_ts_sorter_complete(grn_ctx *ctx, grn_ts_sorter *sorter, grn_ts_record *recs, size_t n_recs); typedef struct { - grn_obj *table; + grn_obj *table; /* Table. */ + grn_ts_sorter_node *head; /* First node. */ + grn_ts_sorter_node *tail; /* Last node. */ } grn_ts_sorter_builder; /* grn_ts_sorter_builder_open() creates a sorter builder. */ @@ -72,6 +79,16 @@ grn_rc grn_ts_sorter_builder_open(grn_ctx *ctx, grn_obj *table, grn_rc grn_ts_sorter_builder_close(grn_ctx *ctx, grn_ts_sorter_builder *builder); +/* grn_ts_sorter_builder_complete() completes a sorter. */ +grn_rc grn_ts_sorter_builder_complete(grn_ctx *ctx, + grn_ts_sorter_builder *builder, + grn_ts_int offset, grn_ts_int limit, + grn_ts_sorter **sorter); + +/* grn_ts_sorter_builder_push() pushes a node. */ +grn_rc grn_ts_sorter_builder_push(grn_ctx *ctx, grn_ts_sorter_builder *builder, + grn_ts_expr *expr, grn_ts_bool reverse); + #ifdef __cplusplus } #endif -------------- next part -------------- HTML����������������������������...Download