X-Git-Url: https://git.tokkee.org/?p=sysdb.git;a=blobdiff_plain;f=src%2Fcore%2Fstore_lookup.c;h=b69e7f994c17186964bfc1823587186dee640c98;hp=eab37b4787bb2ba7e752ab6c06eb4b8bc019a7ea;hb=b54d9fff4bc9e70efe83123403a4c9f935efb74e;hpb=4ad0a6674d457e204d0b4ac59eb87cb195dec0ed diff --git a/src/core/store_lookup.c b/src/core/store_lookup.c index eab37b4..b69e7f9 100644 --- a/src/core/store_lookup.c +++ b/src/core/store_lookup.c @@ -38,6 +38,7 @@ #include "sysdb.h" #include "core/store-private.h" #include "core/object.h" +#include "utils/error.h" #include @@ -49,6 +50,39 @@ #include +static int +expr_eval2(sdb_memstore_expr_t *e1, sdb_data_t *v1, + sdb_memstore_expr_t *e2, sdb_data_t *v2, + sdb_memstore_obj_t *obj, sdb_memstore_matcher_t *filter) +{ + if (e1->type) { + if (sdb_memstore_expr_eval(e1, obj, v1, filter)) + return -1; + } + else + *v1 = e1->data; + if (e2->type) { + if (sdb_memstore_expr_eval(e2, obj, v2, filter)) { + if (e1->type) + sdb_data_free_datum(v1); + return -1; + } + } + else + *v2 = e2->data; + return 0; +} /* expr_eval2 */ + +static void +expr_free_datum2(sdb_memstore_expr_t *e1, sdb_data_t *v1, + sdb_memstore_expr_t *e2, sdb_data_t *v2) +{ + if (e1->type) + sdb_data_free_datum(v1); + if (e2->type) + sdb_data_free_datum(v2); +} /* expr_free_datum2 */ + /* * matcher implementations */ @@ -59,7 +93,7 @@ * is enabled, compare the string values in case of a type mismatch. */ static int -cmp_value(int op, sdb_data_t *v1, sdb_data_t *v2, _Bool strcmp_fallback) +match_cmp_value(int op, sdb_data_t *v1, sdb_data_t *v2, bool strcmp_fallback) { int status; @@ -74,31 +108,61 @@ cmp_value(int op, sdb_data_t *v1, sdb_data_t *v2, _Bool strcmp_fallback) if (status == INT_MAX) return 0; - else if (op == MATCHER_LT) - return status < 0; - else if (op == MATCHER_LE) - return status <= 0; - else if (op == MATCHER_EQ) - return status == 0; - else if (op == MATCHER_NE) - return status != 0; - else if (op == MATCHER_GE) - return status >= 0; - else if (op == MATCHER_GT) - return status > 0; + switch (op) { + case MATCHER_LT: return status < 0; + case MATCHER_LE: return status <= 0; + case MATCHER_EQ: return status == 0; + case MATCHER_NE: return status != 0; + case MATCHER_GE: return status >= 0; + case MATCHER_GT: return status > 0; + } return 0; -} /* cmp_value */ +} /* match_cmp_value */ + +static int +match_regex_value(int op, sdb_data_t *v, sdb_data_t *re) +{ + char value[sdb_data_strlen(v) + 1]; + int status = 0; + + assert((op == MATCHER_REGEX) + || (op == MATCHER_NREGEX)); + + if (sdb_data_isnull(v) || sdb_data_isnull(re)) + return 0; + + if (re->type == SDB_TYPE_STRING) { + sdb_data_t tmp = SDB_DATA_INIT; + + if (sdb_data_parse(re->data.string, SDB_TYPE_REGEX, &tmp)) + return 0; + + sdb_data_free_datum(re); + *re = tmp; + } + else if (re->type != SDB_TYPE_REGEX) + return 0; + + if (! sdb_data_format(v, value, sizeof(value), SDB_UNQUOTED)) + status = 0; + else if (! regexec(&re->data.re.regex, value, 0, NULL, 0)) + status = 1; + + if (op == MATCHER_NREGEX) + return !status; + return status; +} /* match_regex_value */ static int -match_logical(sdb_store_matcher_t *m, sdb_store_obj_t *obj, - sdb_store_matcher_t *filter) +match_logical(sdb_memstore_matcher_t *m, sdb_memstore_obj_t *obj, + sdb_memstore_matcher_t *filter) { int status; assert((m->type == MATCHER_AND) || (m->type == MATCHER_OR)); assert(OP_M(m)->left && OP_M(m)->right); - status = sdb_store_matcher_matches(OP_M(m)->left, obj, filter); + status = sdb_memstore_matcher_matches(OP_M(m)->left, obj, filter); /* lazy evaluation */ if ((! status) && (m->type == MATCHER_AND)) @@ -106,114 +170,49 @@ match_logical(sdb_store_matcher_t *m, sdb_store_obj_t *obj, else if (status && (m->type == MATCHER_OR)) return status; - return sdb_store_matcher_matches(OP_M(m)->right, obj, filter); + return sdb_memstore_matcher_matches(OP_M(m)->right, obj, filter); } /* match_logical */ static int -match_unary(sdb_store_matcher_t *m, sdb_store_obj_t *obj, - sdb_store_matcher_t *filter) +match_uop(sdb_memstore_matcher_t *m, sdb_memstore_obj_t *obj, + sdb_memstore_matcher_t *filter) { assert(m->type == MATCHER_NOT); assert(UOP_M(m)->op); - return !sdb_store_matcher_matches(UOP_M(m)->op, obj, filter); -} /* match_unary */ - -/* iterate arrays: ANY/ALL */ -static int -match_iter_array(sdb_store_matcher_t *m, sdb_store_obj_t *obj, - sdb_store_matcher_t *filter) -{ - sdb_store_expr_t *e1, *e2; - sdb_data_t v1 = SDB_DATA_INIT; - sdb_data_t v2 = SDB_DATA_INIT; - - int status; - - /* TODO: fully support arbitrary operators (?) */ - if ((ITER_M(m)->m->type < MATCHER_LT) || (MATCHER_GT < ITER_M(m)->m->type)) - return 0; - - e1 = CMP_M(ITER_M(m)->m)->left; - e2 = CMP_M(ITER_M(m)->m)->right; - - if (sdb_store_expr_eval(e1, obj, &v1, filter)) - return 0; - if (sdb_store_expr_eval(e2, obj, &v2, filter)) { - sdb_data_free_datum(&v1); - return 0; - } - - if ((! (v1.type & SDB_TYPE_ARRAY)) || (v2.type & SDB_TYPE_ARRAY)) - status = 0; - else if (sdb_data_isnull(&v1) || (sdb_data_isnull(&v2))) - status = 0; - else { - size_t i; - int all = (int)(m->type == MATCHER_ALL); - - status = all; - for (i = 0; i < v1.data.array.length; ++i) { - sdb_data_t v = SDB_DATA_INIT; - if (sdb_data_array_get(&v1, i, &v)) { - status = 0; - break; - } - - if (cmp_value(ITER_M(m)->m->type, &v, &v2, - (e1->data_type) < 0 || (e2->data_type < 0))) { - if (! all) { - status = 1; - break; - } - } - else if (all) { - status = 0; - break; - } - } - } - - sdb_data_free_datum(&v1); - sdb_data_free_datum(&v2); - return status; -} /* match_iter_array */ + return !sdb_memstore_matcher_matches(UOP_M(m)->op, obj, filter); +} /* match_uop */ +/* iterate: ANY/ALL */ static int -match_iter(sdb_store_matcher_t *m, sdb_store_obj_t *obj, - sdb_store_matcher_t *filter) +match_iter(sdb_memstore_matcher_t *m, sdb_memstore_obj_t *obj, + sdb_memstore_matcher_t *filter) { - sdb_avltree_iter_t *iter = NULL; + sdb_memstore_expr_iter_t *iter = NULL; int status; int all = (int)(m->type == MATCHER_ALL); assert((m->type == MATCHER_ANY) || (m->type == MATCHER_ALL)); + assert((! CMP_M(ITER_M(m)->m)->left) && CMP_M(ITER_M(m)->m)->right); - if (ITER_M(m)->type == SDB_FIELD_BACKEND) - return match_iter_array(m, obj, filter); - - if (obj->type == SDB_HOST) { - if (ITER_M(m)->type == SDB_SERVICE) - iter = sdb_avltree_get_iter(HOST(obj)->services); - else if (ITER_M(m)->type == SDB_METRIC) - iter = sdb_avltree_get_iter(HOST(obj)->metrics); - else if (ITER_M(m)->type == SDB_ATTRIBUTE) - iter = sdb_avltree_get_iter(HOST(obj)->attributes); - } else if (obj->type == SDB_SERVICE) { - if (ITER_M(m)->type == SDB_ATTRIBUTE) - iter = sdb_avltree_get_iter(SVC(obj)->attributes); - } else if (obj->type == SDB_METRIC) { - if (ITER_M(m)->type == SDB_ATTRIBUTE) - iter = sdb_avltree_get_iter(METRIC(obj)->attributes); + iter = sdb_memstore_expr_iter(ITER_M(m)->iter, obj, filter); + if (! iter) { + sdb_log(SDB_LOG_WARNING, "store: Invalid iterator"); + return 0; } status = all; - while (sdb_avltree_iter_has_next(iter)) { - sdb_store_obj_t *child = STORE_OBJ(sdb_avltree_iter_get_next(iter)); - if (filter && (! sdb_store_matcher_matches(filter, child, NULL))) - continue; + while (sdb_memstore_expr_iter_has_next(iter)) { + sdb_data_t v = sdb_memstore_expr_iter_get_next(iter); + sdb_memstore_expr_t expr = CONST_EXPR(v); + bool matches; - if (sdb_store_matcher_matches(ITER_M(m)->m, child, filter)) { + CMP_M(ITER_M(m)->m)->left = &expr; + matches = sdb_memstore_matcher_matches(ITER_M(m)->m, obj, filter); + CMP_M(ITER_M(m)->m)->left = NULL; + sdb_data_free_datum(&v); + + if (matches) { if (! all) { status = 1; break; @@ -223,16 +222,16 @@ match_iter(sdb_store_matcher_t *m, sdb_store_obj_t *obj, break; } } - sdb_avltree_iter_destroy(iter); + sdb_memstore_expr_iter_destroy(iter); return status; } /* match_iter */ static int -match_cmp(sdb_store_matcher_t *m, sdb_store_obj_t *obj, - sdb_store_matcher_t *filter) +match_cmp(sdb_memstore_matcher_t *m, sdb_memstore_obj_t *obj, + sdb_memstore_matcher_t *filter) { - sdb_store_expr_t *e1 = CMP_M(m)->left; - sdb_store_expr_t *e2 = CMP_M(m)->right; + sdb_memstore_expr_t *e1 = CMP_M(m)->left; + sdb_memstore_expr_t *e2 = CMP_M(m)->right; sdb_data_t v1 = SDB_DATA_INIT, v2 = SDB_DATA_INIT; int status; @@ -242,130 +241,96 @@ match_cmp(sdb_store_matcher_t *m, sdb_store_obj_t *obj, || (m->type == MATCHER_NE) || (m->type == MATCHER_GE) || (m->type == MATCHER_GT)); + assert(e1 && e2); - if (sdb_store_expr_eval(e1, obj, &v1, filter)) - return 0; - if (sdb_store_expr_eval(e2, obj, &v2, filter)) { - sdb_data_free_datum(&v1); + if (expr_eval2(e1, &v1, e2, &v2, obj, filter)) return 0; - } - status = cmp_value(m->type, &v1, &v2, + status = match_cmp_value(m->type, &v1, &v2, (e1->data_type) < 0 || (e2->data_type < 0)); - sdb_data_free_datum(&v1); - sdb_data_free_datum(&v2); + expr_free_datum2(e1, &v1, e2, &v2); return status; } /* match_cmp */ static int -match_in(sdb_store_matcher_t *m, sdb_store_obj_t *obj, - sdb_store_matcher_t *filter) +match_in(sdb_memstore_matcher_t *m, sdb_memstore_obj_t *obj, + sdb_memstore_matcher_t *filter) { sdb_data_t value = SDB_DATA_INIT, array = SDB_DATA_INIT; int status = 1; assert(m->type == MATCHER_IN); + assert(CMP_M(m)->left && CMP_M(m)->right); - if ((sdb_store_expr_eval(CMP_M(m)->left, obj, &value, filter)) - || (sdb_store_expr_eval(CMP_M(m)->right, obj, &array, filter))) + if (expr_eval2(CMP_M(m)->left, &value, + CMP_M(m)->right, &array, obj, filter)) status = 0; if (status) status = sdb_data_inarray(&value, &array); - sdb_data_free_datum(&value); - sdb_data_free_datum(&array); + expr_free_datum2(CMP_M(m)->left, &value, CMP_M(m)->right, &array); return status; } /* match_in */ static int -match_regex(sdb_store_matcher_t *m, sdb_store_obj_t *obj, - sdb_store_matcher_t *filter) +match_regex(sdb_memstore_matcher_t *m, sdb_memstore_obj_t *obj, + sdb_memstore_matcher_t *filter) { - sdb_data_t v = SDB_DATA_INIT; + sdb_data_t regex = SDB_DATA_INIT, v = SDB_DATA_INIT; int status = 0; - regex_t regex; - _Bool free_regex = 0; - assert((m->type == MATCHER_REGEX) || (m->type == MATCHER_NREGEX)); + assert(CMP_M(m)->left && CMP_M(m)->right); - if (! CMP_M(m)->right->type) { - assert(CMP_M(m)->right->data.type == SDB_TYPE_REGEX); - regex = CMP_M(m)->right->data.data.re.regex; - } - else { - sdb_data_t tmp = SDB_DATA_INIT; - char *raw; - - if (sdb_store_expr_eval(CMP_M(m)->right, obj, &tmp, filter)) - return 0; - - if (tmp.type != SDB_TYPE_STRING) { - sdb_data_free_datum(&tmp); - return 0; - } - - raw = tmp.data.string; - if (sdb_data_parse(raw, SDB_TYPE_REGEX, &tmp)) { - free(raw); - return 0; - } - - regex = tmp.data.re.regex; - free_regex = 1; - free(tmp.data.re.raw); - free(raw); - } + if (expr_eval2(CMP_M(m)->left, &v, CMP_M(m)->right, ®ex, obj, filter)) + return 0; - if ((sdb_store_expr_eval(CMP_M(m)->left, obj, &v, filter)) - || (sdb_data_isnull(&v))) - status = INT_MAX; - else { - char value[sdb_data_strlen(&v) + 1]; - if (sdb_data_format(&v, value, sizeof(value), SDB_UNQUOTED) < 0) - status = 0; - else if (! regexec(®ex, value, 0, NULL, 0)) - status = 1; - } + status = match_regex_value(m->type, &v, ®ex); - if (free_regex) - regfree(®ex); - sdb_data_free_datum(&v); - if (status == INT_MAX) - return 0; - if (m->type == MATCHER_NREGEX) - return !status; + expr_free_datum2(CMP_M(m)->left, &v, CMP_M(m)->right, ®ex); return status; } /* match_regex */ static int -match_isnull(sdb_store_matcher_t *m, sdb_store_obj_t *obj, - sdb_store_matcher_t *filter) +match_unary(sdb_memstore_matcher_t *m, sdb_memstore_obj_t *obj, + sdb_memstore_matcher_t *filter) { sdb_data_t v = SDB_DATA_INIT; int status; - assert((m->type == MATCHER_ISNULL) || (m->type == MATCHER_ISNNULL)); + assert((m->type == MATCHER_ISNULL) + || (m->type == MATCHER_ISTRUE) + || (m->type == MATCHER_ISFALSE)); - /* TODO: this might hide real errors; - * improve error reporting and propagation */ - if (sdb_store_expr_eval(ISNULL_M(m)->expr, obj, &v, filter) - || sdb_data_isnull(&v)) - status = 1; + if (UNARY_M(m)->expr->type) { + /* TODO: this might hide real errors; + * improve error reporting and propagation */ + if (sdb_memstore_expr_eval(UNARY_M(m)->expr, obj, &v, filter)) + return 1; + } else - status = 0; + v = UNARY_M(m)->expr->data; - sdb_data_free_datum(&v); - if (m->type == MATCHER_ISNNULL) - return !status; + if (m->type == MATCHER_ISNULL) + status = sdb_data_isnull(&v) ? 1 : 0; + else { /* ISTRUE or ISFALSE */ + if ((v.type == SDB_TYPE_BOOLEAN) + && (v.data.boolean == (m->type == MATCHER_ISTRUE))) + status = 1; + else + status = 0; + } + + if (UNARY_M(m)->expr->type) + sdb_data_free_datum(&v); return status; -} /* match_isnull */ +} /* match_unary */ -typedef int (*matcher_cb)(sdb_store_matcher_t *, sdb_store_obj_t *, - sdb_store_matcher_t *); +typedef int (*matcher_cb)(sdb_memstore_matcher_t *, sdb_memstore_obj_t *, + sdb_memstore_matcher_t *); /* this array needs to be indexable by the matcher types; * -> update the enum in store-private.h when updating this */ @@ -373,20 +338,27 @@ static matcher_cb matchers[] = { match_logical, match_logical, - match_unary, + match_uop, match_iter, match_iter, + match_in, + + /* unary operators */ + match_unary, + match_unary, + match_unary, + + /* ary operators */ match_cmp, match_cmp, match_cmp, match_cmp, match_cmp, match_cmp, - match_in, match_regex, match_regex, - match_isnull, - match_isnull, + + NULL, /* QUERY */ }; /* @@ -400,9 +372,9 @@ op_matcher_init(sdb_object_t *obj, va_list ap) if ((M(obj)->type != MATCHER_OR) && (M(obj)->type != MATCHER_AND)) return -1; - OP_M(obj)->left = va_arg(ap, sdb_store_matcher_t *); + OP_M(obj)->left = va_arg(ap, sdb_memstore_matcher_t *); sdb_object_ref(SDB_OBJ(OP_M(obj)->left)); - OP_M(obj)->right = va_arg(ap, sdb_store_matcher_t *); + OP_M(obj)->right = va_arg(ap, sdb_memstore_matcher_t *); sdb_object_ref(SDB_OBJ(OP_M(obj)->right)); if ((! OP_M(obj)->left) || (! OP_M(obj)->right)) @@ -423,19 +395,21 @@ static int iter_matcher_init(sdb_object_t *obj, va_list ap) { M(obj)->type = va_arg(ap, int); - ITER_M(obj)->type = va_arg(ap, int); - ITER_M(obj)->m = va_arg(ap, sdb_store_matcher_t *); - - if (! ITER_M(obj)->m) - return -1; + ITER_M(obj)->iter = va_arg(ap, sdb_memstore_expr_t *); + ITER_M(obj)->m = va_arg(ap, sdb_memstore_matcher_t *); + sdb_object_ref(SDB_OBJ(ITER_M(obj)->iter)); sdb_object_ref(SDB_OBJ(ITER_M(obj)->m)); + + if ((! ITER_M(obj)->iter) || (! ITER_M(obj)->m)) + return -1; return 0; } /* iter_matcher_init */ static void iter_matcher_destroy(sdb_object_t *obj) { + sdb_object_deref(SDB_OBJ(ITER_M(obj)->iter)); sdb_object_deref(SDB_OBJ(ITER_M(obj)->m)); } /* iter_matcher_destroy */ @@ -444,12 +418,12 @@ cmp_matcher_init(sdb_object_t *obj, va_list ap) { M(obj)->type = va_arg(ap, int); - CMP_M(obj)->left = va_arg(ap, sdb_store_expr_t *); + CMP_M(obj)->left = va_arg(ap, sdb_memstore_expr_t *); sdb_object_ref(SDB_OBJ(CMP_M(obj)->left)); - CMP_M(obj)->right = va_arg(ap, sdb_store_expr_t *); + CMP_M(obj)->right = va_arg(ap, sdb_memstore_expr_t *); sdb_object_ref(SDB_OBJ(CMP_M(obj)->right)); - if ((! CMP_M(obj)->left) || (! CMP_M(obj)->right)) + if (! CMP_M(obj)->right) return -1; return 0; } /* cmp_matcher_init */ @@ -468,7 +442,7 @@ uop_matcher_init(sdb_object_t *obj, va_list ap) if (M(obj)->type != MATCHER_NOT) return -1; - UOP_M(obj)->op = va_arg(ap, sdb_store_matcher_t *); + UOP_M(obj)->op = va_arg(ap, sdb_memstore_matcher_t *); sdb_object_ref(SDB_OBJ(UOP_M(obj)->op)); if (! UOP_M(obj)->op) @@ -484,23 +458,25 @@ uop_matcher_destroy(sdb_object_t *obj) } /* uop_matcher_destroy */ static int -isnull_matcher_init(sdb_object_t *obj, va_list ap) +unary_matcher_init(sdb_object_t *obj, va_list ap) { M(obj)->type = va_arg(ap, int); - if ((M(obj)->type != MATCHER_ISNULL) && (M(obj)->type != MATCHER_ISNNULL)) + if ((M(obj)->type != MATCHER_ISNULL) + && (M(obj)->type != MATCHER_ISTRUE) + && (M(obj)->type != MATCHER_ISFALSE)) return -1; - ISNULL_M(obj)->expr = va_arg(ap, sdb_store_expr_t *); - sdb_object_ref(SDB_OBJ(ISNULL_M(obj)->expr)); + UNARY_M(obj)->expr = va_arg(ap, sdb_memstore_expr_t *); + sdb_object_ref(SDB_OBJ(UNARY_M(obj)->expr)); return 0; -} /* isnull_matcher_init */ +} /* unary_matcher_init */ static void -isnull_matcher_destroy(sdb_object_t *obj) +unary_matcher_destroy(sdb_object_t *obj) { - sdb_object_deref(SDB_OBJ(ISNULL_M(obj)->expr)); - ISNULL_M(obj)->expr = NULL; -} /* isnull_matcher_destroy */ + sdb_object_deref(SDB_OBJ(UNARY_M(obj)->expr)); + UNARY_M(obj)->expr = NULL; +} /* unary_matcher_destroy */ static sdb_type_t op_type = { /* size = */ sizeof(op_matcher_t), @@ -526,87 +502,107 @@ static sdb_type_t cmp_type = { /* destroy = */ cmp_matcher_destroy, }; -static sdb_type_t isnull_type = { - /* size = */ sizeof(isnull_matcher_t), - /* init = */ isnull_matcher_init, - /* destroy = */ isnull_matcher_destroy, +static sdb_type_t unary_type = { + /* size = */ sizeof(unary_matcher_t), + /* init = */ unary_matcher_init, + /* destroy = */ unary_matcher_destroy, }; /* * public API */ -sdb_store_matcher_t * -sdb_store_any_matcher(int type, sdb_store_matcher_t *m) +sdb_memstore_matcher_t * +sdb_memstore_any_matcher(sdb_memstore_expr_t *iter, sdb_memstore_matcher_t *m) { - if ((type != SDB_SERVICE) && (type != SDB_METRIC) - && (type != SDB_ATTRIBUTE) && (type != SDB_FIELD_BACKEND)) + if ((m->type < MATCHER_LT) || (MATCHER_NREGEX < m->type)) { + sdb_log(SDB_LOG_ERR, "store: Invalid ANY -> %s matcher " + "(invalid operator)", MATCHER_SYM(m->type)); + return NULL; + } + if (CMP_M(m)->left) { + sdb_log(SDB_LOG_ERR, "store: Invalid ANY %s %s %s matcher " + "(invalid left operand)", + SDB_TYPE_TO_STRING(CMP_M(m)->left->data_type), + MATCHER_SYM(m->type), + SDB_TYPE_TO_STRING(CMP_M(m)->right->data_type)); return NULL; + } return M(sdb_object_create("any-matcher", iter_type, - MATCHER_ANY, type, m)); -} /* sdb_store_any_matcher */ + MATCHER_ANY, iter, m)); +} /* sdb_memstore_any_matcher */ -sdb_store_matcher_t * -sdb_store_all_matcher(int type, sdb_store_matcher_t *m) +sdb_memstore_matcher_t * +sdb_memstore_all_matcher(sdb_memstore_expr_t *iter, sdb_memstore_matcher_t *m) { - if ((type != SDB_SERVICE) && (type != SDB_METRIC) - && (type != SDB_ATTRIBUTE) && (type != SDB_FIELD_BACKEND)) + if ((m->type < MATCHER_LT) || (MATCHER_NREGEX < m->type)) { + sdb_log(SDB_LOG_ERR, "store: Invalid ALL -> %s matcher " + "(invalid operator)", MATCHER_SYM(m->type)); + return NULL; + } + if (CMP_M(m)->left) { + sdb_log(SDB_LOG_ERR, "store: Invalid ALL %s %s %s matcher " + "(invalid left operand)", + SDB_TYPE_TO_STRING(CMP_M(m)->left->data_type), + MATCHER_SYM(m->type), + SDB_TYPE_TO_STRING(CMP_M(m)->right->data_type)); return NULL; + } return M(sdb_object_create("all-matcher", iter_type, - MATCHER_ALL, type, m)); -} /* sdb_store_all_matcher */ + MATCHER_ALL, iter, m)); +} /* sdb_memstore_all_matcher */ -sdb_store_matcher_t * -sdb_store_lt_matcher(sdb_store_expr_t *left, sdb_store_expr_t *right) +sdb_memstore_matcher_t * +sdb_memstore_lt_matcher(sdb_memstore_expr_t *left, sdb_memstore_expr_t *right) { return M(sdb_object_create("lt-matcher", cmp_type, MATCHER_LT, left, right)); -} /* sdb_store_lt_matcher */ +} /* sdb_memstore_lt_matcher */ -sdb_store_matcher_t * -sdb_store_le_matcher(sdb_store_expr_t *left, sdb_store_expr_t *right) +sdb_memstore_matcher_t * +sdb_memstore_le_matcher(sdb_memstore_expr_t *left, sdb_memstore_expr_t *right) { return M(sdb_object_create("le-matcher", cmp_type, MATCHER_LE, left, right)); -} /* sdb_store_le_matcher */ +} /* sdb_memstore_le_matcher */ -sdb_store_matcher_t * -sdb_store_eq_matcher(sdb_store_expr_t *left, sdb_store_expr_t *right) +sdb_memstore_matcher_t * +sdb_memstore_eq_matcher(sdb_memstore_expr_t *left, sdb_memstore_expr_t *right) { return M(sdb_object_create("eq-matcher", cmp_type, MATCHER_EQ, left, right)); -} /* sdb_store_eq_matcher */ +} /* sdb_memstore_eq_matcher */ -sdb_store_matcher_t * -sdb_store_ne_matcher(sdb_store_expr_t *left, sdb_store_expr_t *right) +sdb_memstore_matcher_t * +sdb_memstore_ne_matcher(sdb_memstore_expr_t *left, sdb_memstore_expr_t *right) { return M(sdb_object_create("ne-matcher", cmp_type, MATCHER_NE, left, right)); -} /* sdb_store_ne_matcher */ +} /* sdb_memstore_ne_matcher */ -sdb_store_matcher_t * -sdb_store_ge_matcher(sdb_store_expr_t *left, sdb_store_expr_t *right) +sdb_memstore_matcher_t * +sdb_memstore_ge_matcher(sdb_memstore_expr_t *left, sdb_memstore_expr_t *right) { return M(sdb_object_create("ge-matcher", cmp_type, MATCHER_GE, left, right)); -} /* sdb_store_ge_matcher */ +} /* sdb_memstore_ge_matcher */ -sdb_store_matcher_t * -sdb_store_gt_matcher(sdb_store_expr_t *left, sdb_store_expr_t *right) +sdb_memstore_matcher_t * +sdb_memstore_gt_matcher(sdb_memstore_expr_t *left, sdb_memstore_expr_t *right) { return M(sdb_object_create("gt-matcher", cmp_type, MATCHER_GT, left, right)); -} /* sdb_store_gt_matcher */ +} /* sdb_memstore_gt_matcher */ -sdb_store_matcher_t * -sdb_store_in_matcher(sdb_store_expr_t *left, sdb_store_expr_t *right) +sdb_memstore_matcher_t * +sdb_memstore_in_matcher(sdb_memstore_expr_t *left, sdb_memstore_expr_t *right) { return M(sdb_object_create("in-matcher", cmp_type, MATCHER_IN, left, right)); -} /* sdb_store_in_matcher */ +} /* sdb_memstore_in_matcher */ -sdb_store_matcher_t * -sdb_store_regex_matcher(sdb_store_expr_t *left, sdb_store_expr_t *right) +sdb_memstore_matcher_t * +sdb_memstore_regex_matcher(sdb_memstore_expr_t *left, sdb_memstore_expr_t *right) { if (! right->type) { if ((right->data.type != SDB_TYPE_STRING) @@ -622,123 +618,64 @@ sdb_store_regex_matcher(sdb_store_expr_t *left, sdb_store_expr_t *right) } return M(sdb_object_create("regex-matcher", cmp_type, MATCHER_REGEX, left, right)); -} /* sdb_store_regex_matcher */ +} /* sdb_memstore_regex_matcher */ -sdb_store_matcher_t * -sdb_store_nregex_matcher(sdb_store_expr_t *left, sdb_store_expr_t *right) +sdb_memstore_matcher_t * +sdb_memstore_nregex_matcher(sdb_memstore_expr_t *left, sdb_memstore_expr_t *right) { - sdb_store_matcher_t *m = sdb_store_regex_matcher(left, right); + sdb_memstore_matcher_t *m = sdb_memstore_regex_matcher(left, right); if (! m) return NULL; m->type = MATCHER_NREGEX; return m; -} /* sdb_store_nregex_matcher */ +} /* sdb_memstore_nregex_matcher */ -sdb_store_matcher_t * -sdb_store_isnull_matcher(sdb_store_expr_t *expr) +sdb_memstore_matcher_t * +sdb_memstore_isnull_matcher(sdb_memstore_expr_t *expr) { - return M(sdb_object_create("isnull-matcher", isnull_type, + return M(sdb_object_create("isnull-matcher", unary_type, MATCHER_ISNULL, expr)); -} /* sdb_store_isnull_matcher */ - -sdb_store_matcher_t * -sdb_store_isnnull_matcher(sdb_store_expr_t *expr) -{ - return M(sdb_object_create("isnull-matcher", isnull_type, - MATCHER_ISNNULL, expr)); -} /* sdb_store_isnnull_matcher */ - -sdb_store_matcher_op_cb -sdb_store_parse_matcher_op(const char *op) -{ - if (! strcasecmp(op, "<")) - return sdb_store_lt_matcher; - else if (! strcasecmp(op, "<=")) - return sdb_store_le_matcher; - else if (! strcasecmp(op, "=")) - return sdb_store_eq_matcher; - else if (! strcasecmp(op, "!=")) - return sdb_store_ne_matcher; - else if (! strcasecmp(op, ">=")) - return sdb_store_ge_matcher; - else if (! strcasecmp(op, ">")) - return sdb_store_gt_matcher; - else if (! strcasecmp(op, "=~")) - return sdb_store_regex_matcher; - else if (! strcasecmp(op, "!~")) - return sdb_store_nregex_matcher; - return NULL; -} /* sdb_store_parse_matcher_op */ +} /* sdb_memstore_isnull_matcher */ -int -sdb_store_parse_object_type(const char *name) -{ - if (! strcasecmp(name, "host")) - return SDB_HOST; - else if (! strcasecmp(name, "service")) - return SDB_SERVICE; - else if (! strcasecmp(name, "metric")) - return SDB_METRIC; - else if (! strcasecmp(name, "attribute")) - return SDB_ATTRIBUTE; - return -1; -} /* sdb_store_parse_object_type */ +sdb_memstore_matcher_t * +sdb_memstore_istrue_matcher(sdb_memstore_expr_t *expr) +{ + return M(sdb_object_create("istrue-matcher", unary_type, + MATCHER_ISTRUE, expr)); +} /* sdb_memstore_istrue_matcher */ -int -sdb_store_parse_object_type_plural(const char *name) -{ - if (! strcasecmp(name, "hosts")) - return SDB_HOST; - else if (! strcasecmp(name, "services")) - return SDB_SERVICE; - else if (! strcasecmp(name, "metrics")) - return SDB_METRIC; - else if (! strcasecmp(name, "attributes")) - return SDB_ATTRIBUTE; - return -1; -} /* sdb_store_parse_object_type_plural */ +sdb_memstore_matcher_t * +sdb_memstore_isfalse_matcher(sdb_memstore_expr_t *expr) +{ + return M(sdb_object_create("isfalse-matcher", unary_type, + MATCHER_ISFALSE, expr)); +} /* sdb_memstore_isfalse_matcher */ -int -sdb_store_parse_field_name(const char *name) -{ - if (! strcasecmp(name, "name")) - return SDB_FIELD_NAME; - else if (! strcasecmp(name, "last_update")) - return SDB_FIELD_LAST_UPDATE; - else if (! strcasecmp(name, "age")) - return SDB_FIELD_AGE; - else if (! strcasecmp(name, "interval")) - return SDB_FIELD_INTERVAL; - else if (! strcasecmp(name, "backend")) - return SDB_FIELD_BACKEND; - return -1; -} /* sdb_store_parse_field_name */ - -sdb_store_matcher_t * -sdb_store_dis_matcher(sdb_store_matcher_t *left, sdb_store_matcher_t *right) +sdb_memstore_matcher_t * +sdb_memstore_dis_matcher(sdb_memstore_matcher_t *left, sdb_memstore_matcher_t *right) { return M(sdb_object_create("dis-matcher", op_type, MATCHER_OR, left, right)); -} /* sdb_store_dis_matcher */ +} /* sdb_memstore_dis_matcher */ -sdb_store_matcher_t * -sdb_store_con_matcher(sdb_store_matcher_t *left, sdb_store_matcher_t *right) +sdb_memstore_matcher_t * +sdb_memstore_con_matcher(sdb_memstore_matcher_t *left, sdb_memstore_matcher_t *right) { return M(sdb_object_create("con-matcher", op_type, MATCHER_AND, left, right)); -} /* sdb_store_con_matcher */ +} /* sdb_memstore_con_matcher */ -sdb_store_matcher_t * -sdb_store_inv_matcher(sdb_store_matcher_t *m) +sdb_memstore_matcher_t * +sdb_memstore_inv_matcher(sdb_memstore_matcher_t *m) { return M(sdb_object_create("inv-matcher", uop_type, MATCHER_NOT, m)); -} /* sdb_store_inv_matcher */ +} /* sdb_memstore_inv_matcher */ int -sdb_store_matcher_matches(sdb_store_matcher_t *m, sdb_store_obj_t *obj, - sdb_store_matcher_t *filter) +sdb_memstore_matcher_matches(sdb_memstore_matcher_t *m, sdb_memstore_obj_t *obj, + sdb_memstore_matcher_t *filter) { - if (filter && (! sdb_store_matcher_matches(filter, obj, NULL))) + if (filter && (! sdb_memstore_matcher_matches(filter, obj, NULL))) return 0; /* "NULL" always matches */ @@ -748,8 +685,10 @@ sdb_store_matcher_matches(sdb_store_matcher_t *m, sdb_store_obj_t *obj, if ((m->type < 0) || ((size_t)m->type >= SDB_STATIC_ARRAY_LEN(matchers))) return 0; + if (! matchers[m->type]) + return 0; return matchers[m->type](m, obj, filter); -} /* sdb_store_matcher_matches */ +} /* sdb_memstore_matcher_matches */ /* vim: set tw=78 sw=4 ts=4 noexpandtab : */