X-Git-Url: https://git.tokkee.org/?a=blobdiff_plain;f=src%2Fcore%2Fdata.c;h=8754f8868a11471fe1e359cee75ac0d52b87721d;hb=419b318ff64a7d9048e9692dba7470eab9532d1f;hp=f489367a42218e35a94bbf64afbff7d6255442fb;hpb=b0e3b4920d34fcf9a70671bc1c424384bd388a2b;p=sysdb.git diff --git a/src/core/data.c b/src/core/data.c index f489367..8754f88 100644 --- a/src/core/data.c +++ b/src/core/data.c @@ -46,10 +46,174 @@ #include +/* + * Operator support maxtrix. + * -> op_matrix[][][] + */ + +/* add, sub, mul, div, mod, concat */ + +/* integer, decimal, string, datetime, binary, regex */ + +static int op_matrix[6][6][6] = { + /* SDB_DATA_ADD */ + { + { SDB_TYPE_INTEGER, -1, -1, -1, -1, -1 }, + { -1, SDB_TYPE_DECIMAL, -1, -1, -1, -1 }, + { -1, -1, -1, -1, -1, -1 }, + { -1, -1, -1, SDB_TYPE_DATETIME, -1, -1 }, + { -1, -1, -1, -1, -1, -1 }, + { -1, -1, -1, -1, -1, -1 }, + }, + + /* SDB_DATA_SUB */ + { + { SDB_TYPE_INTEGER, -1, -1, -1, -1, -1 }, + { -1, SDB_TYPE_DECIMAL, -1, -1, -1, -1 }, + { -1, -1, -1, -1, -1, -1 }, + { -1, -1, -1, SDB_TYPE_DATETIME, -1, -1 }, + { -1, -1, -1, -1, -1, -1 }, + { -1, -1, -1, -1, -1, -1 }, + }, + + /* SDB_DATA_MUL */ + { + { SDB_TYPE_INTEGER, -1, -1, SDB_TYPE_DATETIME, -1, -1 }, + { -1, SDB_TYPE_DECIMAL, -1, SDB_TYPE_DATETIME, -1, -1 }, + { -1, -1, -1, -1, -1, -1 }, + { SDB_TYPE_DATETIME, SDB_TYPE_DATETIME, -1, SDB_TYPE_DATETIME, -1, -1 }, + { -1, -1, -1, -1, -1, -1 }, + { -1, -1, -1, -1, -1, -1 }, + }, + + /* SDB_DATA_DIV */ + { + { SDB_TYPE_INTEGER, -1, -1, -1, -1, -1 }, + { -1, SDB_TYPE_DECIMAL, -1, -1, -1, -1 }, + { -1, -1, -1, -1, -1, -1 }, + { SDB_TYPE_DATETIME, SDB_TYPE_DATETIME, -1, SDB_TYPE_DATETIME, -1, -1 }, + { -1, -1, -1, -1, -1, -1 }, + { -1, -1, -1, -1, -1, -1 }, + }, + + /* SDB_DATA_MOD */ + { + { SDB_TYPE_INTEGER, -1, -1, -1, -1, -1 }, + { -1, SDB_TYPE_DECIMAL, -1, -1, -1, -1 }, + { -1, -1, -1, -1, -1, -1 }, + { SDB_TYPE_DATETIME, SDB_TYPE_DATETIME, -1, SDB_TYPE_DATETIME, -1, -1 }, + { -1, -1, -1, -1, -1, -1 }, + { -1, -1, -1, -1, -1, -1 }, + }, + + /* SDB_DATA_CONCAT */ + { + { -1, -1, -1, -1, -1, -1 }, + { -1, -1, -1, -1, -1, -1 }, + { -1, -1, SDB_TYPE_STRING, -1, -1, -1 }, + { -1, -1, -1, -1, -1, -1 }, + { -1, -1, -1, -1, SDB_TYPE_BINARY, -1 }, + { -1, -1, -1, -1, -1, -1 }, + }, +}; + /* * private helper functions */ +/* this function supports in-place copies */ +static int +copy_array_values(sdb_data_t *dst, const sdb_data_t *src, size_t elem_size) +{ + int type = src->type & 0xff; + + if ((type == SDB_TYPE_INTEGER) || (type == SDB_TYPE_DECIMAL)) { + if (dst != src) + memcpy(dst->data.array.values, src->data.array.values, + src->data.array.length * elem_size); + } + else if (type == SDB_TYPE_STRING) { + char **s = src->data.array.values; + char **d = dst->data.array.values; + size_t i; + + for (i = 0; i < src->data.array.length; ++i) { + d[i] = strdup(s[i]); + if (! d[i]) + return -1; + } + } + else { + /* TODO */ + errno = ENOTSUP; + return -1; + } + return 0; +} /* copy_array_values */ + +static void +free_array_values(sdb_data_t *datum) +{ + int type = datum->type & 0xff; + + if (type == SDB_TYPE_STRING) { + char **v = datum->data.array.values; + size_t i; + + for (i = 0; i < datum->data.array.length; ++i) { + if (v[i]) + free(v[i]); + v[i] = NULL; + } + } +} /* free_array_values */ + +/* compare two arrays element-by-element returning how the first non-equal + * elements compare to each other */ +static int +array_cmp(const sdb_data_t *a1, const sdb_data_t *a2) +{ + int type = a1->type & 0xff; + size_t len, i; + + assert((a1->type == a2->type) && (a1->type & SDB_TYPE_ARRAY)); + + len = SDB_MIN(a1->data.array.length, a2->data.array.length); + + if (type == SDB_TYPE_INTEGER) { + int64_t *v1 = a1->data.array.values; + int64_t *v2 = a2->data.array.values; + + for (i = 0; i < len; ++i) + if (v1[i] != v2[i]) + return SDB_CMP(v1[i], v2[i]); + } + else if (type == SDB_TYPE_DECIMAL) { + double *v1 = a1->data.array.values; + double *v2 = a2->data.array.values; + + for (i = 0; i < len; ++i) + if (v1[i] != v2[i]) + return SDB_CMP(v1[i], v2[i]); + } + else if (type == SDB_TYPE_STRING) { + char **v1 = a1->data.array.values; + char **v2 = a2->data.array.values; + + for (i = 0; i < len; ++i) { + int diff = strcasecmp(v1[i], v2[i]); + if (diff) + return diff; + } + } + else { + /* TODO */ + errno = ENOTSUP; + /* but fall through to ensure stable sorting: */ + } + return SDB_CMP(a1->data.array.length, a2->data.array.length); +} /* array_cmp */ + /* Calculate the linear function 'd1 + n * d2'. */ static int data_lin(const sdb_data_t *d1, int n, const sdb_data_t *d2, sdb_data_t *res) @@ -184,6 +348,7 @@ data_concat(const sdb_data_t *d1, const sdb_data_t *d2, sdb_data_t *res) unsigned char *s1, *s2; size_t len1, len2; + /* TODO: support array plus element */ if (d1->type != d2->type) return -1; @@ -199,6 +364,13 @@ data_concat(const sdb_data_t *d1, const sdb_data_t *d2, sdb_data_t *res) len1 = d1->data.binary.length; len2 = d2->data.binary.length; } + else if (d1->type & SDB_TYPE_ARRAY) { + size_t elem_size = sdb_data_sizeof(d1->type & 0xff); + s1 = (unsigned char *)d1->data.array.values; + s2 = (unsigned char *)d2->data.array.values; + len1 = d1->data.array.length * elem_size; + len2 = d2->data.array.length * elem_size; + } else return -1; @@ -218,10 +390,22 @@ data_concat(const sdb_data_t *d1, const sdb_data_t *d2, sdb_data_t *res) if (res->type == SDB_TYPE_STRING) { res->data.string = (char *)new; } - else { + else if (res->type == SDB_TYPE_BINARY) { res->data.binary.datum = new; res->data.binary.length = len1 + len2; } + else if (d1->type & SDB_TYPE_ARRAY) { + res->data.array.values = new; + res->data.array.length = d1->data.array.length + d2->data.array.length; + if (copy_array_values(res, res, sdb_data_sizeof(res->type & 0xff))) { + /* this leaks already copied values but there's not much we can + * do and this should only happen if we're in trouble anyway */ + free(new); + res->data.array.values = NULL; + res->data.array.length = 0; + return -1; + } + } return 0; } /* data_concat */ @@ -240,39 +424,49 @@ sdb_data_copy(sdb_data_t *dst, const sdb_data_t *src) return -1; tmp = *src; - switch (src->type) { - case SDB_TYPE_STRING: - if (src->data.string) { - tmp.data.string = strdup(src->data.string); - if (! tmp.data.string) - return -1; - } - break; - case SDB_TYPE_BINARY: - if (src->data.binary.datum) { - tmp.data.binary.datum = malloc(src->data.binary.length); - if (! tmp.data.binary.datum) - return -1; - memcpy(tmp.data.binary.datum, src->data.binary.datum, - src->data.binary.length); + if (src->type == SDB_TYPE_STRING) { + if (src->data.string) { + tmp.data.string = strdup(src->data.string); + if (! tmp.data.string) + return -1; + } + } + else if (src->type == SDB_TYPE_BINARY) { + if (src->data.binary.datum) { + tmp.data.binary.datum = malloc(src->data.binary.length); + if (! tmp.data.binary.datum) + return -1; + memcpy(tmp.data.binary.datum, src->data.binary.datum, + src->data.binary.length); + } + } + else if (src->type == SDB_TYPE_REGEX) { + if (src->data.re.raw) { + tmp.data.re.raw = strdup(src->data.re.raw); + if (! tmp.data.re.raw) + return -1; + /* we need to recompile because the regex might point to + * dynamically allocated memory */ + if (regcomp(&tmp.data.re.regex, tmp.data.re.raw, + REG_EXTENDED | REG_ICASE | REG_NOSUB)) { + free(tmp.data.re.raw); + return -1; } - break; - case SDB_TYPE_REGEX: - if (src->data.re.raw) { - tmp.data.re.raw = strdup(src->data.re.raw); - if (! tmp.data.re.raw) - return -1; - /* we need to recompile because the regex might point to - * dynamically allocated memory */ - if (regcomp(&tmp.data.re.regex, tmp.data.re.raw, - REG_EXTENDED | REG_ICASE | REG_NOSUB)) { - free(tmp.data.re.raw); - return -1; - } + } + else + memset(&tmp.data.re.regex, 0, sizeof(tmp.data.re.regex)); + } + else if (src->type & SDB_TYPE_ARRAY) { + if (src->data.array.values) { + size_t elem_size = sdb_data_sizeof(src->type & 0xff); + tmp.data.array.values = calloc(src->data.array.length, elem_size); + if (! tmp.data.array.values) + return -1; + if (copy_array_values(&tmp, src, elem_size)) { + sdb_data_free_datum(&tmp); + return -1; } - else - memset(&tmp.data.re.regex, 0, sizeof(tmp.data.re.regex)); - break; + } } sdb_data_free_datum(dst); @@ -286,26 +480,31 @@ sdb_data_free_datum(sdb_data_t *datum) if (! datum) return; - switch (datum->type) { - case SDB_TYPE_STRING: - if (datum->data.string) - free(datum->data.string); - datum->data.string = NULL; - break; - case SDB_TYPE_BINARY: - if (datum->data.binary.datum) - free(datum->data.binary.datum); - datum->data.binary.datum = NULL; - datum->data.binary.length = 0; - break; - case SDB_TYPE_REGEX: - if (datum->data.re.raw) { - free(datum->data.re.raw); - regfree(&datum->data.re.regex); - } - datum->data.re.raw = NULL; - memset(&datum->data.re.regex, 0, sizeof(datum->data.re.regex)); - break; + if (datum->type == SDB_TYPE_STRING) { + if (datum->data.string) + free(datum->data.string); + datum->data.string = NULL; + } + else if (datum->type == SDB_TYPE_BINARY) { + if (datum->data.binary.datum) + free(datum->data.binary.datum); + datum->data.binary.datum = NULL; + datum->data.binary.length = 0; + } + else if (datum->type == SDB_TYPE_REGEX) { + if (datum->data.re.raw) { + free(datum->data.re.raw); + regfree(&datum->data.re.regex); + } + datum->data.re.raw = NULL; + memset(&datum->data.re.regex, 0, sizeof(datum->data.re.regex)); + } + else if (datum->type & SDB_TYPE_ARRAY) { + free_array_values(datum); + if (datum->data.array.values) + free(datum->data.array.values); + datum->data.array.values = NULL; + datum->data.array.length = 0; } } /* sdb_data_free_datum */ @@ -324,42 +523,45 @@ sdb_data_cmp(const sdb_data_t *d1, const sdb_data_t *d2) if (d1->type != d2->type) return SDB_CMP(d1->type, d2->type); - switch (d1->type) { - case SDB_TYPE_INTEGER: - return SDB_CMP(d1->data.integer, d2->data.integer); - case SDB_TYPE_DECIMAL: - return SDB_CMP(d1->data.decimal, d2->data.decimal); - case SDB_TYPE_STRING: - CMP_NULL(d1->data.string, d2->data.string); - return strcasecmp(d1->data.string, d2->data.string); - case SDB_TYPE_DATETIME: - return SDB_CMP(d1->data.datetime, d2->data.datetime); - case SDB_TYPE_BINARY: - { - int diff; - - CMP_NULL(d1->data.binary.datum, d2->data.binary.datum); - - /* on a common prefix, the shorter datum sorts less */ - if (d1->data.binary.length < d2->data.binary.length) { - diff = memcmp(d1->data.binary.datum, d2->data.binary.datum, - d1->data.binary.length); - diff = diff ? diff : -1; - } - else if (d1->data.binary.length > d2->data.binary.length) { - diff = memcmp(d1->data.binary.datum, d2->data.binary.datum, - d2->data.binary.length); - diff = diff ? diff : 1; - } - else - diff = memcmp(d1->data.binary.datum, d2->data.binary.datum, - d1->data.binary.length); + if (d1->type == SDB_TYPE_INTEGER) + return SDB_CMP(d1->data.integer, d2->data.integer); + else if (d1->type == SDB_TYPE_DECIMAL) + return SDB_CMP(d1->data.decimal, d2->data.decimal); + else if (d1->type == SDB_TYPE_STRING) { + CMP_NULL(d1->data.string, d2->data.string); + return strcasecmp(d1->data.string, d2->data.string); + } + else if (d1->type == SDB_TYPE_DATETIME) + return SDB_CMP(d1->data.datetime, d2->data.datetime); + else if (d1->type == SDB_TYPE_BINARY) { + int diff; - return diff; + CMP_NULL(d1->data.binary.datum, d2->data.binary.datum); + + /* on a common prefix, the shorter datum sorts less */ + if (d1->data.binary.length < d2->data.binary.length) { + diff = memcmp(d1->data.binary.datum, d2->data.binary.datum, + d1->data.binary.length); + diff = diff ? diff : -1; + } + else if (d1->data.binary.length > d2->data.binary.length) { + diff = memcmp(d1->data.binary.datum, d2->data.binary.datum, + d2->data.binary.length); + diff = diff ? diff : 1; } - case SDB_TYPE_REGEX: - CMP_NULL(d1->data.re.raw, d2->data.re.raw); - return strcmp(d1->data.re.raw, d2->data.re.raw); + else + diff = memcmp(d1->data.binary.datum, d2->data.binary.datum, + d1->data.binary.length); + + return diff; + } + else if (d1->type == SDB_TYPE_REGEX) { + CMP_NULL(d1->data.re.raw, d2->data.re.raw); + return strcmp(d1->data.re.raw, d2->data.re.raw); + } + else if (d1->type & SDB_TYPE_ARRAY) { + CMP_NULL(d1->data.array.values, d2->data.array.values); + return array_cmp(d1, d2); } return -1; } /* sdb_data_cmp */ @@ -370,6 +572,12 @@ sdb_data_strcmp(const sdb_data_t *d1, const sdb_data_t *d2) char d1_str[sdb_data_strlen(d1) + 1]; char d2_str[sdb_data_strlen(d2) + 1]; + if ((d1->type & SDB_TYPE_ARRAY) || (d2->type & SDB_TYPE_ARRAY)) { + /* TODO */ + errno = ENOTSUP; + return -1; + } + if (sdb_data_isnull(d1)) d1 = NULL; if (sdb_data_isnull(d2)) @@ -399,9 +607,49 @@ sdb_data_isnull(const sdb_data_t *datum) return 1; if ((datum->type == SDB_TYPE_REGEX) && (! datum->data.re.raw)) return 1; + if ((datum->type & SDB_TYPE_ARRAY) && (! datum->data.array.values)) + return 1; return 0; } /* sdb_data_isnull */ +_Bool +sdb_data_inarray(const sdb_data_t *value, const sdb_data_t *array) +{ + size_t i; + + if (sdb_data_isnull(value) || sdb_data_isnull(array)) + return 0; + if ((value->type & SDB_TYPE_ARRAY) || (! (array->type & SDB_TYPE_ARRAY))) + return 0; + if (value->type != (array->type & 0xff)) + return 0; + + if (value->type == SDB_TYPE_INTEGER) { + int64_t *v = array->data.array.values; + for (i = 0; i < array->data.array.length; ++i) + if (value->data.integer == v[i]) + return 1; + } + else if (value->type == SDB_TYPE_DECIMAL) { + double *v = array->data.array.values; + for (i = 0; i < array->data.array.length; ++i) + if (value->data.decimal == v[i]) + return 1; + } + else if (value->type == SDB_TYPE_STRING) { + char **v = array->data.array.values; + for (i = 0; i < array->data.array.length; ++i) + if (!strcasecmp(value->data.string, v[i])) + return 1; + } + else { + /* TODO */ + errno = ENOTSUP; + return 0; + } + return 0; +} /* sdb_data_inarray */ + int sdb_data_parse_op(const char *op) { @@ -447,37 +695,72 @@ sdb_data_expr_eval(int op, const sdb_data_t *d1, const sdb_data_t *d2, return -1; } /* sdb_data_expr_eval */ +int +sdb_data_expr_type(int op, int type1, int type2) +{ + int types_num = (int)SDB_STATIC_ARRAY_LEN(op_matrix[0]); + + assert(SDB_STATIC_ARRAY_LEN(op_matrix[0]) + == SDB_STATIC_ARRAY_LEN(op_matrix[0][0])); + + if ((op <= 0) || (SDB_STATIC_ARRAY_LEN(op_matrix) < (size_t)op)) + return -1; + + /* arrays only support concat; type has to match */ + if ((type1 & SDB_TYPE_ARRAY) || (type2 & SDB_TYPE_ARRAY)) { + if ((type1 != type2) || (op != SDB_DATA_CONCAT)) + return -1; + return type1; + } + if ((type1 < 0) || (types_num < type1) + || (type2 < 0) || (types_num < type2)) + return -1; + + if ((type1 == SDB_TYPE_NULL) || (type2 == SDB_TYPE_NULL)) + return SDB_TYPE_NULL; + return op_matrix[op - 1][type1 - 1][type2 - 1]; +} /* sdb_data_expr_type */ + size_t sdb_data_strlen(const sdb_data_t *datum) { if (! datum) return 0; - switch (datum->type) { - case SDB_TYPE_INTEGER: - /* log(64) */ - return 20; - case SDB_TYPE_DECIMAL: - /* XXX: -d.dddddde+dd or -ddddd.dddddd */ - return 42; - case SDB_TYPE_STRING: - if (! datum->data.string) - return 8; /* "" */ - /* in the worst case, each character needs to be escaped */ - return 2 * strlen(datum->data.string) + 2; - case SDB_TYPE_DATETIME: - /* "YYYY-MM-DD HH:MM:SS +zzzz" */ - return 27; - case SDB_TYPE_BINARY: - if (! datum->data.binary.datum) - return 8; /* "" */ - /* "\xNN" */ - return 4 * datum->data.binary.length + 2; - case SDB_TYPE_REGEX: - if (! datum->data.re.raw) - return 8; /* "" */ - /* "/.../" */ - return strlen(datum->data.re.raw) + 4; + if (datum->type == SDB_TYPE_INTEGER) { + /* log(64) */ + return 20; + } + else if (datum->type == SDB_TYPE_DECIMAL) { + /* XXX: -d.dddddde+dd or -ddddd.dddddd */ + return 42; + } + else if (datum->type == SDB_TYPE_STRING) { + if (! datum->data.string) + return 6; /* NULL */ + /* in the worst case, each character needs to be escaped */ + return 2 * strlen(datum->data.string) + 2; + } + else if (datum->type == SDB_TYPE_DATETIME) { + /* "YYYY-MM-DD HH:MM:SS +zzzz" */ + return 27; + } + else if (datum->type == SDB_TYPE_BINARY) { + if (! datum->data.binary.datum) + return 6; /* NULL */ + /* "\xNN" */ + return 4 * datum->data.binary.length + 2; + } + else if (datum->type == SDB_TYPE_REGEX) { + if (! datum->data.re.raw) + return 6; /* NULL */ + /* "/.../" */ + return strlen(datum->data.re.raw) + 4; + } + else if (datum->type & SDB_TYPE_ARRAY) { + /* TODO */ + errno = ENOTSUP; + return 0; } return 0; } /* sdb_data_strlen */ @@ -487,6 +770,7 @@ sdb_data_format(const sdb_data_t *datum, char *buf, size_t buflen, int quoted) { char tmp[sdb_data_strlen(datum) + 1]; char *data = NULL; + _Bool is_null = 0; int ret = -1; size_t i, pos; @@ -494,75 +778,83 @@ sdb_data_format(const sdb_data_t *datum, char *buf, size_t buflen, int quoted) if ((! datum) || (! buf)) return -1; - switch (datum->type) { - case SDB_TYPE_INTEGER: - ret = snprintf(buf, buflen, "%"PRIi64, datum->data.integer); - break; - case SDB_TYPE_DECIMAL: - ret = snprintf(buf, buflen, "%g", datum->data.decimal); - break; - case SDB_TYPE_STRING: - if (! datum->data.string) - data = ""; - else { - pos = 0; - for (i = 0; i < strlen(datum->data.string); ++i) { - char byte = datum->data.string[i]; - - if ((byte == '\\') || (byte == '"')) { - tmp[pos] = '\\'; - ++pos; - } - tmp[pos] = byte; - ++pos; - } - tmp[pos] = '\0'; - data = tmp; - } - break; - case SDB_TYPE_DATETIME: - if (! sdb_strftime(tmp, sizeof(tmp), "%F %T %z", - datum->data.datetime)) - return -1; - tmp[sizeof(tmp) - 1] = '\0'; - data = tmp; - break; - case SDB_TYPE_BINARY: + if (datum->type == SDB_TYPE_INTEGER) { + ret = snprintf(buf, buflen, "%"PRIi64, datum->data.integer); + } + else if (datum->type == SDB_TYPE_DECIMAL) { + ret = snprintf(buf, buflen, "%g", datum->data.decimal); + } + else if (datum->type == SDB_TYPE_STRING) { + if (! datum->data.string) + is_null = 1; + else { pos = 0; - for (i = 0; i < datum->data.binary.length; ++i) { - int byte = (int)datum->data.binary.datum[i]; - char hex[] = {'0', '1', '2', '3', '4', '5', '6', '7', - '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'}; + for (i = 0; i < strlen(datum->data.string); ++i) { + char byte = datum->data.string[i]; - tmp[pos] = '\\'; - tmp[pos + 1] = 'x'; - pos += 2; - - if (byte > 0xf) { - tmp[pos] = hex[byte >> 4]; + if ((byte == '\\') || (byte == '"')) { + tmp[pos] = '\\'; ++pos; } - tmp[pos] = hex[byte & 0xf]; + tmp[pos] = byte; ++pos; } - if (datum->data.binary.datum) { - tmp[pos] = '\0'; - data = tmp; - } - else - data = ""; - break; - case SDB_TYPE_REGEX: - if (! datum->data.re.raw) - data = ""; - else { - snprintf(tmp, sizeof(tmp), "/%s/", datum->data.re.raw); - data = tmp; + tmp[pos] = '\0'; + data = tmp; + } + } + else if (datum->type == SDB_TYPE_DATETIME) { + if (! sdb_strftime(tmp, sizeof(tmp), "%F %T %z", + datum->data.datetime)) + return -1; + tmp[sizeof(tmp) - 1] = '\0'; + data = tmp; + } + else if (datum->type == SDB_TYPE_BINARY) { + pos = 0; + for (i = 0; i < datum->data.binary.length; ++i) { + int byte = (int)datum->data.binary.datum[i]; + char hex[] = {'0', '1', '2', '3', '4', '5', '6', '7', + '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'}; + + tmp[pos] = '\\'; + tmp[pos + 1] = 'x'; + pos += 2; + + if (byte > 0xf) { + tmp[pos] = hex[byte >> 4]; + ++pos; } - break; + tmp[pos] = hex[byte & 0xf]; + ++pos; + } + if (datum->data.binary.datum) { + tmp[pos] = '\0'; + data = tmp; + } + else + is_null = 1; + } + else if (datum->type == SDB_TYPE_REGEX) { + if (! datum->data.re.raw) + is_null = 1; + else { + snprintf(tmp, sizeof(tmp), "/%s/", datum->data.re.raw); + data = tmp; + } + } + else if (datum->type & SDB_TYPE_ARRAY) { + /* TODO */ + errno = ENOTSUP; + return -1; } - if (data) { + if (is_null) { + /* never quote NULL */ + strncpy(buf, "NULL", buflen); + ret = (int)SDB_MIN(buflen, 4); + } + else if (data) { if (quoted == SDB_UNQUOTED) ret = snprintf(buf, buflen, "%s", data); else if (quoted == SDB_SINGLE_QUOTED) @@ -582,46 +874,48 @@ sdb_data_parse(char *str, int type, sdb_data_t *data) char *endptr = NULL; errno = 0; - switch (type) { - case SDB_TYPE_INTEGER: - tmp.data.integer = strtoll(str, &endptr, 0); - break; - case SDB_TYPE_DECIMAL: - tmp.data.decimal = strtod(str, &endptr); - break; - case SDB_TYPE_STRING: - tmp.data.string = str; - break; - case SDB_TYPE_DATETIME: - { - double datetime = strtod(str, &endptr); - tmp.data.datetime = DOUBLE_TO_SDB_TIME(datetime); - } - break; - case SDB_TYPE_BINARY: - /* we don't support any binary information containing 0-bytes */ - tmp.data.binary.length = strlen(str); - tmp.data.binary.datum = (unsigned char *)str; - break; - case SDB_TYPE_REGEX: - tmp.data.re.raw = strdup(str); - if (! tmp.data.re.raw) - return -1; - if (regcomp(&tmp.data.re.regex, tmp.data.re.raw, - REG_EXTENDED | REG_ICASE | REG_NOSUB)) { - sdb_log(SDB_LOG_ERR, "core: Failed to compile regular " - "expression '%s'", tmp.data.re.raw); - free(tmp.data.re.raw); - return -1; - } - if (! data) { - tmp.type = SDB_TYPE_REGEX; - sdb_data_free_datum(&tmp); - } - break; - default: - errno = EINVAL; + if (type == SDB_TYPE_INTEGER) { + tmp.data.integer = strtoll(str, &endptr, 0); + } + else if (type == SDB_TYPE_DECIMAL) { + tmp.data.decimal = strtod(str, &endptr); + } + else if (type == SDB_TYPE_STRING) { + tmp.data.string = str; + } + else if (type == SDB_TYPE_DATETIME) { + double datetime = strtod(str, &endptr); + tmp.data.datetime = DOUBLE_TO_SDB_TIME(datetime); + } + else if (type == SDB_TYPE_BINARY) { + /* we don't support any binary information containing 0-bytes */ + tmp.data.binary.length = strlen(str); + tmp.data.binary.datum = (unsigned char *)str; + } + else if (type == SDB_TYPE_REGEX) { + tmp.data.re.raw = strdup(str); + if (! tmp.data.re.raw) return -1; + if (regcomp(&tmp.data.re.regex, tmp.data.re.raw, + REG_EXTENDED | REG_ICASE | REG_NOSUB)) { + sdb_log(SDB_LOG_ERR, "core: Failed to compile regular " + "expression '%s'", tmp.data.re.raw); + free(tmp.data.re.raw); + return -1; + } + if (! data) { + tmp.type = SDB_TYPE_REGEX; + sdb_data_free_datum(&tmp); + } + } + else if (type & SDB_TYPE_ARRAY) { + /* TODO */ + errno = ENOTSUP; + return -1; + } + else { + errno = EINVAL; + return -1; } if ((type == SDB_TYPE_INTEGER) || (type == SDB_TYPE_DECIMAL) @@ -646,5 +940,24 @@ sdb_data_parse(char *str, int type, sdb_data_t *data) return 0; } /* sdb_data_parse */ +size_t +sdb_data_sizeof(int type) +{ + sdb_data_t v; + if (type == SDB_TYPE_INTEGER) + return sizeof(v.data.integer); + else if (type == SDB_TYPE_DECIMAL) + return sizeof(v.data.decimal); + else if (type == SDB_TYPE_STRING) + return sizeof(v.data.string); + else if (type == SDB_TYPE_DATETIME) + return sizeof(v.data.datetime); + else if (type == SDB_TYPE_BINARY) + return sizeof(v.data.binary); + else if (type == SDB_TYPE_REGEX) + return sizeof(v.data.re); + return 0; +} /* sdb_data_sizeof */ + /* vim: set tw=78 sw=4 ts=4 noexpandtab : */