X-Git-Url: https://git.tokkee.org/?p=sysdb.git;a=blobdiff_plain;f=src%2Fcore%2Fstore_lookup.c;h=18a0235536e3f154128ff576cbc624c9dfa49a5f;hp=11d85fea0a5ead05b42f6fffd089b6b135b0bcb9;hb=da52b4da948c741d20c7a3995ce5d133af377def;hpb=82605756814adadc0fcad9ee55e472c1730bf9ba diff --git a/src/core/store_lookup.c b/src/core/store_lookup.c index 11d85fe..18a0235 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,34 +50,108 @@ #include -/* - * private data types - */ +static int +expr_eval2(sdb_store_expr_t *e1, sdb_data_t *v1, + sdb_store_expr_t *e2, sdb_data_t *v2, + sdb_store_obj_t *obj, sdb_store_matcher_t *filter) +{ + if (e1->type) { + if (sdb_store_expr_eval(e1, obj, v1, filter)) + return -1; + } + else + *v1 = e1->data; + if (e2->type) { + if (sdb_store_expr_eval(e2, obj, v2, filter)) { + if (e1->type) + sdb_data_free_datum(v1); + return -1; + } + } + else + *v2 = e2->data; + return 0; +} /* expr_eval2 */ -typedef struct { - sdb_store_matcher_t *m; - sdb_store_matcher_t *filter; - sdb_store_lookup_cb cb; - void *user_data; -} scan_iter_data_t; +static void +expr_free_datum2(sdb_store_expr_t *e1, sdb_data_t *v1, + sdb_store_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 */ /* - * private helper functions + * matcher implementations */ +/* + * cmp_expr: + * Compare two values using the specified matcher operator. If strcmp_fallback + * is enabled, compare the string values in case of a type mismatch. + */ static int -scan_iter(sdb_store_obj_t *obj, void *user_data) +match_cmp_value(int op, sdb_data_t *v1, sdb_data_t *v2, bool strcmp_fallback) { - scan_iter_data_t *d = user_data; + int status; - if (sdb_store_matcher_matches(d->m, obj, d->filter)) - return d->cb(obj, d->user_data); + if (sdb_data_isnull(v1) || (sdb_data_isnull(v2))) + status = INT_MAX; + else if (v1->type == v2->type) + status = sdb_data_cmp(v1, v2); + else if (! strcmp_fallback) + status = INT_MAX; + else + status = sdb_data_strcmp(v1, v2); + + if (status == INT_MAX) + return 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; -} /* scan_iter */ +} /* match_cmp_value */ -/* - * matcher implementations - */ +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, @@ -108,34 +183,34 @@ match_unary(sdb_store_matcher_t *m, sdb_store_obj_t *obj, return !sdb_store_matcher_matches(UOP_M(m)->op, obj, filter); } /* match_unary */ +/* iterate: ANY/ALL */ static int match_iter(sdb_store_matcher_t *m, sdb_store_obj_t *obj, sdb_store_matcher_t *filter) { - sdb_avltree_iter_t *iter = NULL; + sdb_store_expr_iter_t *iter = NULL; int status; - int all = 0; + int all = (int)(m->type == MATCHER_ALL); - assert(m->type == MATCHER_ANY); + assert((m->type == MATCHER_ANY) || (m->type == MATCHER_ALL)); + assert((! CMP_M(ITER_M(m)->m)->left) && CMP_M(ITER_M(m)->m)->right); - /* TODO: support all object types */ - if (obj->type != SDB_HOST) + iter = sdb_store_expr_iter(ITER_M(m)->iter, obj, filter); + if (! iter) return 0; - 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); - 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_store_expr_iter_has_next(iter)) { + sdb_data_t v = sdb_store_expr_iter_get_next(iter); + sdb_store_expr_t expr = CONST_EXPR(v); + bool matches; + + CMP_M(ITER_M(m)->m)->left = &expr; + matches = sdb_store_matcher_matches(ITER_M(m)->m, obj, filter); + CMP_M(ITER_M(m)->m)->left = NULL; + sdb_data_free_datum(&v); - if (sdb_store_matcher_matches(ITER_M(m)->m, child, filter)) { + if (matches) { if (! all) { status = 1; break; @@ -145,106 +220,36 @@ match_iter(sdb_store_matcher_t *m, sdb_store_obj_t *obj, break; } } - sdb_avltree_iter_destroy(iter); + sdb_store_expr_iter_destroy(iter); return status; } /* match_iter */ -/* - * cmp_expr: - * Compare the values of two expressions when evaluating them using the - * specified stored object and filter. Returns a value less than, equal to, or - * greater than zero if the value of the first expression compares less than, - * equal to, or greater than the value of the second expression. Returns - * INT_MAX if any of the expressions could not be evaluated or if any of them - * evaluated to NULL. - */ -static int -cmp_expr(sdb_store_expr_t *e1, sdb_store_expr_t *e2, - sdb_store_obj_t *obj, sdb_store_matcher_t *filter) -{ - sdb_data_t v1 = SDB_DATA_INIT, v2 = SDB_DATA_INIT; - int status; - - if (sdb_store_expr_eval(e1, obj, &v1, filter)) - return INT_MAX; - if (sdb_store_expr_eval(e2, obj, &v2, filter)) { - sdb_data_free_datum(&v1); - return INT_MAX; - } - - if (sdb_data_isnull(&v1) || (sdb_data_isnull(&v2))) - status = INT_MAX; - else if (v1.type == v2.type) - status = sdb_data_cmp(&v1, &v2); - else if ((e1->data_type >= 0) && (e2->data_type >= 0)) - status = INT_MAX; - else - status = sdb_data_strcmp(&v1, &v2); - - sdb_data_free_datum(&v1); - sdb_data_free_datum(&v2); - return status; -} /* cmp_expr */ - static int -match_lt(sdb_store_matcher_t *m, sdb_store_obj_t *obj, - sdb_store_matcher_t *filter) -{ - int status; - assert(m->type == MATCHER_LT); - status = cmp_expr(CMP_M(m)->left, CMP_M(m)->right, obj, filter); - return (status != INT_MAX) && (status < 0); -} /* match_lt */ - -static int -match_le(sdb_store_matcher_t *m, sdb_store_obj_t *obj, +match_cmp(sdb_store_matcher_t *m, sdb_store_obj_t *obj, sdb_store_matcher_t *filter) { + sdb_store_expr_t *e1 = CMP_M(m)->left; + sdb_store_expr_t *e2 = CMP_M(m)->right; + sdb_data_t v1 = SDB_DATA_INIT, v2 = SDB_DATA_INIT; int status; - assert(m->type == MATCHER_LE); - status = cmp_expr(CMP_M(m)->left, CMP_M(m)->right, obj, filter); - return (status != INT_MAX) && (status <= 0); -} /* match_le */ -static int -match_eq(sdb_store_matcher_t *m, sdb_store_obj_t *obj, - sdb_store_matcher_t *filter) -{ - int status; - assert(m->type == MATCHER_EQ); - status = cmp_expr(CMP_M(m)->left, CMP_M(m)->right, obj, filter); - return (status != INT_MAX) && (! status); -} /* match_eq */ + assert((m->type == MATCHER_LT) + || (m->type == MATCHER_LE) + || (m->type == MATCHER_EQ) + || (m->type == MATCHER_NE) + || (m->type == MATCHER_GE) + || (m->type == MATCHER_GT)); + assert(e1 && e2); -static int -match_ne(sdb_store_matcher_t *m, sdb_store_obj_t *obj, - sdb_store_matcher_t *filter) -{ - int status; - assert(m->type == MATCHER_NE); - status = cmp_expr(CMP_M(m)->left, CMP_M(m)->right, obj, filter); - return (status != INT_MAX) && status; -} /* match_ne */ + if (expr_eval2(e1, &v1, e2, &v2, obj, filter)) + return 0; -static int -match_ge(sdb_store_matcher_t *m, sdb_store_obj_t *obj, - sdb_store_matcher_t *filter) -{ - int status; - assert(m->type == MATCHER_GE); - status = cmp_expr(CMP_M(m)->left, CMP_M(m)->right, obj, filter); - return (status != INT_MAX) && (status >= 0); -} /* match_ge */ + status = match_cmp_value(m->type, &v1, &v2, + (e1->data_type) < 0 || (e2->data_type < 0)); -static int -match_gt(sdb_store_matcher_t *m, sdb_store_obj_t *obj, - sdb_store_matcher_t *filter) -{ - int status; - assert(m->type == MATCHER_GT); - status = cmp_expr(CMP_M(m)->left, CMP_M(m)->right, obj, filter); - return (status != INT_MAX) && (status > 0); -} /* match_gt */ + 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, @@ -253,17 +258,19 @@ match_in(sdb_store_matcher_t *m, sdb_store_obj_t *obj, sdb_data_t value = SDB_DATA_INIT, array = SDB_DATA_INIT; int status = 1; - assert(m->type == MATCHER_IN); + assert((m->type == MATCHER_IN) || (m->type == MATCHER_NIN)); + 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); + if (m->type == MATCHER_NIN) + return !status; return status; } /* match_in */ @@ -271,59 +278,19 @@ static int match_regex(sdb_store_matcher_t *m, sdb_store_obj_t *obj, sdb_store_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 = 0; - 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 (m->type == MATCHER_NREGEX) - return !status; + expr_free_datum2(CMP_M(m)->left, &v, CMP_M(m)->right, ®ex); return status; } /* match_regex */ @@ -336,15 +303,22 @@ match_isnull(sdb_store_matcher_t *m, sdb_store_obj_t *obj, assert((m->type == MATCHER_ISNULL) || (m->type == MATCHER_ISNNULL)); - /* 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)) + if (ISNULL_M(m)->expr->type) { + /* TODO: this might hide real errors; + * improve error reporting and propagation */ + if (sdb_store_expr_eval(ISNULL_M(m)->expr, obj, &v, filter)) + return 1; + } + else + v = ISNULL_M(m)->expr->data; + + if (sdb_data_isnull(&v)) status = 1; else status = 0; - sdb_data_free_datum(&v); + if (ISNULL_M(m)->expr->type) + sdb_data_free_datum(&v); if (m->type == MATCHER_ISNNULL) return !status; return status; @@ -361,17 +335,23 @@ matchers[] = { match_logical, match_unary, match_iter, - match_lt, - match_le, - match_eq, - match_ne, - match_ge, - match_gt, + match_iter, match_in, - match_regex, - match_regex, + match_in, + + /* unary operators */ match_isnull, match_isnull, + + /* ary operators */ + match_cmp, + match_cmp, + match_cmp, + match_cmp, + match_cmp, + match_cmp, + match_regex, + match_regex, }; /* @@ -408,19 +388,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)->iter = va_arg(ap, sdb_store_expr_t *); ITER_M(obj)->m = va_arg(ap, sdb_store_matcher_t *); - if (! ITER_M(obj)->m) - return -1; - + 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 */ @@ -434,7 +416,7 @@ cmp_matcher_init(sdb_object_t *obj, va_list ap) CMP_M(obj)->right = va_arg(ap, sdb_store_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 */ @@ -522,14 +504,44 @@ static sdb_type_t isnull_type = { */ sdb_store_matcher_t * -sdb_store_any_matcher(int type, sdb_store_matcher_t *m) +sdb_store_any_matcher(sdb_store_expr_t *iter, sdb_store_matcher_t *m) { - if ((type != SDB_SERVICE) && (type != SDB_METRIC) - && (type != SDB_ATTRIBUTE)) + 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_iter_matcher */ + MATCHER_ANY, iter, m)); +} /* sdb_store_any_matcher */ + +sdb_store_matcher_t * +sdb_store_all_matcher(sdb_store_expr_t *iter, sdb_store_matcher_t *m) +{ + 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, iter, m)); +} /* sdb_store_all_matcher */ sdb_store_matcher_t * sdb_store_lt_matcher(sdb_store_expr_t *left, sdb_store_expr_t *right) @@ -580,6 +592,13 @@ sdb_store_in_matcher(sdb_store_expr_t *left, sdb_store_expr_t *right) MATCHER_IN, left, right)); } /* sdb_store_in_matcher */ +sdb_store_matcher_t * +sdb_store_nin_matcher(sdb_store_expr_t *left, sdb_store_expr_t *right) +{ + return M(sdb_object_create("not-in-matcher", cmp_type, + MATCHER_NIN, left, right)); +} /* sdb_store_in_matcher */ + sdb_store_matcher_t * sdb_store_regex_matcher(sdb_store_expr_t *left, sdb_store_expr_t *right) { @@ -686,6 +705,8 @@ sdb_store_parse_field_name(const char *name) return SDB_FIELD_INTERVAL; else if (! strcasecmp(name, "backend")) return SDB_FIELD_BACKEND; + else if (! strcasecmp(name, "value")) + return SDB_FIELD_VALUE; return -1; } /* sdb_store_parse_field_name */ @@ -726,16 +747,5 @@ sdb_store_matcher_matches(sdb_store_matcher_t *m, sdb_store_obj_t *obj, return matchers[m->type](m, obj, filter); } /* sdb_store_matcher_matches */ -int -sdb_store_scan(sdb_store_matcher_t *m, sdb_store_matcher_t *filter, - sdb_store_lookup_cb cb, void *user_data) -{ - scan_iter_data_t data = { m, filter, cb, user_data }; - - if (! cb) - return -1; - return sdb_store_iterate(scan_iter, &data); -} /* sdb_store_scan */ - /* vim: set tw=78 sw=4 ts=4 noexpandtab : */