1 /*
2 * SysDB - src/core/data.c
3 * Copyright (C) 2014 Sebastian 'tokkee' Harl <sh@tokkee.org>
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
17 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
18 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
19 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
20 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
28 #if HAVE_CONFIG_H
29 # include "config.h"
30 #endif /* HAVE_CONFIG_H */
32 #include "sysdb.h"
34 #include "core/data.h"
35 #include "utils/error.h"
37 #include <assert.h>
39 #include <errno.h>
41 #include <inttypes.h>
43 #include <stdio.h>
44 #include <stdlib.h>
45 #include <string.h>
46 #include <strings.h>
48 #include <math.h>
50 /*
51 * Operator support maxtrix.
52 * <type1> <op> <type2> -> op_matrix[<op>][<type1>][<type2>]
53 */
55 /* add, sub, mul, div, mod, concat */
57 /* integer, decimal, string, datetime, binary, regex */
59 static int op_matrix[6][7][7] = {
60 /* SDB_DATA_ADD */
61 {
62 { -1, -1, -1, -1, -1, -1, -1, },
63 { -1, SDB_TYPE_INTEGER, -1, -1, -1, -1, -1 },
64 { -1, -1, SDB_TYPE_DECIMAL, -1, -1, -1, -1 },
65 { -1, -1, -1, -1, -1, -1, -1 },
66 { -1, -1, -1, -1, SDB_TYPE_DATETIME, -1, -1 },
67 { -1, -1, -1, -1, -1, -1, -1 },
68 { -1, -1, -1, -1, -1, -1, -1 },
69 },
71 /* SDB_DATA_SUB */
72 {
73 { -1, -1, -1, -1, -1, -1, -1, },
74 { -1, SDB_TYPE_INTEGER, -1, -1, -1, -1, -1 },
75 { -1, -1, SDB_TYPE_DECIMAL, -1, -1, -1, -1 },
76 { -1, -1, -1, -1, -1, -1, -1 },
77 { -1, -1, -1, -1, SDB_TYPE_DATETIME, -1, -1 },
78 { -1, -1, -1, -1, -1, -1, -1 },
79 { -1, -1, -1, -1, -1, -1, -1 },
80 },
82 /* SDB_DATA_MUL */
83 {
84 { -1, -1, -1, -1, -1, -1, -1, },
85 { -1, SDB_TYPE_INTEGER, -1, -1, SDB_TYPE_DATETIME, -1, -1 },
86 { -1, -1, SDB_TYPE_DECIMAL, -1, SDB_TYPE_DATETIME, -1, -1 },
87 { -1, -1, -1, -1, -1, -1, -1 },
88 { -1, SDB_TYPE_DATETIME, SDB_TYPE_DATETIME, -1, SDB_TYPE_DATETIME, -1, -1 },
89 { -1, -1, -1, -1, -1, -1, -1 },
90 { -1, -1, -1, -1, -1, -1, -1 },
91 },
93 /* SDB_DATA_DIV */
94 {
95 { -1, -1, -1, -1, -1, -1, -1, },
96 { -1, SDB_TYPE_INTEGER, -1, -1, -1, -1, -1 },
97 { -1, -1, SDB_TYPE_DECIMAL, -1, -1, -1, -1 },
98 { -1, -1, -1, -1, -1, -1, -1 },
99 { -1, SDB_TYPE_DATETIME, SDB_TYPE_DATETIME, -1, SDB_TYPE_DATETIME, -1, -1 },
100 { -1, -1, -1, -1, -1, -1, -1 },
101 { -1, -1, -1, -1, -1, -1, -1 },
102 },
104 /* SDB_DATA_MOD */
105 {
106 { -1, -1, -1, -1, -1, -1, -1, },
107 { -1, SDB_TYPE_INTEGER, -1, -1, -1, -1, -1 },
108 { -1, -1, SDB_TYPE_DECIMAL, -1, -1, -1, -1 },
109 { -1, -1, -1, -1, -1, -1, -1 },
110 { -1, SDB_TYPE_DATETIME, SDB_TYPE_DATETIME, -1, SDB_TYPE_DATETIME, -1, -1 },
111 { -1, -1, -1, -1, -1, -1, -1 },
112 { -1, -1, -1, -1, -1, -1, -1 },
113 },
115 /* SDB_DATA_CONCAT */
116 {
117 { -1, -1, -1, -1, -1, -1, -1, },
118 { -1, -1, -1, -1, -1, -1, -1 },
119 { -1, -1, -1, -1, -1, -1, -1 },
120 { -1, -1, -1, SDB_TYPE_STRING, -1, -1, -1 },
121 { -1, -1, -1, -1, -1, -1, -1 },
122 { -1, -1, -1, -1, -1, SDB_TYPE_BINARY, -1 },
123 { -1, -1, -1, -1, -1, -1, -1 },
124 },
125 };
127 /*
128 * private helper functions
129 */
131 /* this function supports in-place copies */
132 static int
133 copy_array_values(sdb_data_t *dst, const sdb_data_t *src, size_t elem_size)
134 {
135 int type = src->type & 0xff;
137 if ((type == SDB_TYPE_BOOLEAN) || (type == SDB_TYPE_INTEGER)
138 || (type == SDB_TYPE_DECIMAL)) {
139 if (dst != src)
140 memcpy(dst->data.array.values, src->data.array.values,
141 src->data.array.length * elem_size);
142 }
143 else if (type == SDB_TYPE_STRING) {
144 char **s = src->data.array.values;
145 char **d = dst->data.array.values;
146 size_t i;
148 for (i = 0; i < src->data.array.length; ++i) {
149 d[i] = strdup(s[i]);
150 if (! d[i])
151 return -1;
152 }
153 }
154 else {
155 /* TODO */
156 errno = ENOTSUP;
157 return -1;
158 }
159 return 0;
160 } /* copy_array_values */
162 static void
163 free_array_values(sdb_data_t *datum)
164 {
165 int type = datum->type & 0xff;
167 if (type == SDB_TYPE_STRING) {
168 char **v = datum->data.array.values;
169 size_t i;
171 for (i = 0; i < datum->data.array.length; ++i) {
172 if (v[i])
173 free(v[i]);
174 v[i] = NULL;
175 }
176 }
177 else if (type == SDB_TYPE_BINARY) {
178 struct {
179 size_t length;
180 unsigned char *datum;
181 } *v = datum->data.array.values;
182 size_t i;
184 for (i = 0; i < datum->data.array.length; ++i) {
185 if (v[i].datum)
186 free(v[i].datum);
187 v[i].datum = NULL;
188 }
189 }
190 else if (type == SDB_TYPE_REGEX) {
191 struct {
192 char *raw;
193 regex_t regex;
194 } *v = datum->data.array.values;
195 size_t i;
197 for (i = 0; i < datum->data.array.length; ++i) {
198 if (v[i].raw) {
199 free(v[i].raw);
200 regfree(&v[i].regex);
201 }
202 v[i].raw = NULL;
203 }
204 }
205 } /* free_array_values */
207 /* compare two arrays element-by-element returning how the first non-equal
208 * elements compare to each other */
209 static int
210 array_cmp(const sdb_data_t *a1, const sdb_data_t *a2)
211 {
212 int type = a1->type & 0xff;
213 size_t len, i;
215 assert((a1->type == a2->type) && (a1->type & SDB_TYPE_ARRAY));
217 len = SDB_MIN(a1->data.array.length, a2->data.array.length);
219 if (type == SDB_TYPE_BOOLEAN) {
220 bool *v1 = a1->data.array.values;
221 bool *v2 = a2->data.array.values;
223 for (i = 0; i < len; ++i)
224 if (v1[i] != v2[i])
225 return SDB_CMP(v1[i], v2[i]);
226 }
227 else if (type == SDB_TYPE_INTEGER) {
228 int64_t *v1 = a1->data.array.values;
229 int64_t *v2 = a2->data.array.values;
231 for (i = 0; i < len; ++i)
232 if (v1[i] != v2[i])
233 return SDB_CMP(v1[i], v2[i]);
234 }
235 else if (type == SDB_TYPE_DECIMAL) {
236 double *v1 = a1->data.array.values;
237 double *v2 = a2->data.array.values;
239 for (i = 0; i < len; ++i)
240 if (v1[i] != v2[i])
241 return SDB_CMP(v1[i], v2[i]);
242 }
243 else if (type == SDB_TYPE_STRING) {
244 char **v1 = a1->data.array.values;
245 char **v2 = a2->data.array.values;
247 for (i = 0; i < len; ++i) {
248 int diff = strcasecmp(v1[i], v2[i]);
249 if (diff)
250 return diff;
251 }
252 }
253 else if (type == SDB_TYPE_DATETIME) {
254 sdb_time_t *v1 = a1->data.array.values;
255 sdb_time_t *v2 = a2->data.array.values;
257 for (i = 0; i < len; ++i)
258 if (v1[i] != v2[i])
259 return SDB_CMP(v1[i], v2[i]);
260 }
261 else if (type == SDB_TYPE_BINARY) {
262 struct {
263 size_t length;
264 unsigned char *datum;
265 } *v1 = a1->data.array.values;
266 struct {
267 size_t length;
268 unsigned char *datum;
269 } *v2 = a2->data.array.values;
271 for (i = 0; i < len; ++i) {
272 int diff;
274 /* on a common prefix, the shorter datum sorts less */
275 if (v1[i].length < v2[i].length) {
276 diff = memcmp(v1[i].datum, v2[i].datum, v1[i].length);
277 diff = diff ? diff : -1;
278 }
279 else if (v1[i].length > v2[i].length) {
280 diff = memcmp(v1[i].datum, v2[i].datum, v2[i].length);
281 diff = diff ? diff : 1;
282 }
283 else
284 diff = memcmp(v1[i].datum, v2[i].datum, v1[i].length);
286 if (diff)
287 return diff;
288 }
289 }
290 else if (type == SDB_TYPE_REGEX) {
291 struct {
292 char *raw;
293 regex_t regex;
294 } *v1 = a1->data.array.values;
295 struct {
296 char *raw;
297 regex_t regex;
298 } *v2 = a2->data.array.values;
300 for (i = 0; i < len; ++i) {
301 int diff = strcasecmp(v1[i].raw, v2[i].raw);
302 if (diff)
303 return diff;
304 }
305 }
306 else {
307 errno = EINVAL;
308 /* but fall through to ensure stable sorting: */
309 }
310 return SDB_CMP(a1->data.array.length, a2->data.array.length);
311 } /* array_cmp */
313 /* Calculate the linear function 'd1 + n * d2'. */
314 static int
315 data_lin(const sdb_data_t *d1, int n, const sdb_data_t *d2, sdb_data_t *res)
316 {
317 if (d1->type != d2->type)
318 return -1;
320 if (d1->type == SDB_TYPE_INTEGER)
321 res->data.integer = d1->data.integer + (int64_t)n * d2->data.integer;
322 else if (d1->type == SDB_TYPE_DECIMAL)
323 res->data.decimal = d1->data.decimal + (double)n * d2->data.decimal;
324 else if (d1->type == SDB_TYPE_DATETIME)
325 res->data.datetime = d1->data.datetime + (sdb_time_t)n * d2->data.datetime;
326 else
327 return -1;
328 res->type = d1->type;
329 return 0;
330 } /* data_lin */
332 /* Multiply d1 with d2. */
333 static int
334 data_mul(const sdb_data_t *d1, const sdb_data_t *d2, sdb_data_t *res)
335 {
336 if (d1->type == SDB_TYPE_INTEGER) {
337 if (d2->type == SDB_TYPE_INTEGER)
338 res->data.integer = d1->data.integer * d2->data.integer;
339 else if (d2->type == SDB_TYPE_DATETIME) {
340 res->data.datetime = (sdb_time_t)d1->data.integer
341 * d2->data.datetime;
342 res->type = SDB_TYPE_DATETIME;
343 return 0;
344 }
345 else
346 return -1;
347 }
348 else if (d1->type == SDB_TYPE_DECIMAL) {
349 if (d2->type == SDB_TYPE_DECIMAL)
350 res->data.decimal = d1->data.decimal * d2->data.decimal;
351 else if (d2->type == SDB_TYPE_DATETIME) {
352 res->data.datetime = (sdb_time_t)(d1->data.decimal
353 * (double)d2->data.datetime);
354 res->type = SDB_TYPE_DATETIME;
355 return 0;
356 }
357 else
358 return -1;
359 }
360 else if (d1->type == SDB_TYPE_DATETIME) {
361 if (d2->type == SDB_TYPE_DATETIME)
362 res->data.datetime = d1->data.datetime
363 * d2->data.datetime;
364 else if (d2->type == SDB_TYPE_INTEGER)
365 res->data.datetime = d1->data.datetime
366 * (sdb_time_t)d2->data.integer;
367 else if (d2->type == SDB_TYPE_DECIMAL)
368 res->data.datetime = (sdb_time_t)((double)d1->data.datetime
369 * d2->data.decimal);
370 else
371 return -1;
372 }
373 else
374 return -1;
376 res->type = d1->type;
377 return 0;
378 } /* data_mul */
380 /* Device d1 by d2 and return the result and the remainder. */
381 static int
382 data_div(const sdb_data_t *d1, const sdb_data_t *d2,
383 sdb_data_t *res, sdb_data_t *rem)
384 {
385 if (d1->type == SDB_TYPE_INTEGER) {
386 if (d2->type != SDB_TYPE_INTEGER)
387 return -1;
388 if (res)
389 res->data.integer = d1->data.integer / d2->data.integer;
390 if (rem)
391 rem->data.integer = d1->data.integer % d2->data.integer;
392 }
393 else if (d1->type == SDB_TYPE_DECIMAL) {
394 if (d2->type != SDB_TYPE_DECIMAL)
395 return -1;
396 if (res)
397 res->data.decimal = d1->data.decimal / d2->data.decimal;
398 if (rem)
399 rem->data.decimal = fmod(d1->data.decimal, d2->data.decimal);
400 }
401 else if (d1->type == SDB_TYPE_DATETIME) {
402 if (d2->type == SDB_TYPE_DECIMAL) {
403 if (res)
404 res->data.datetime = (sdb_time_t)((double)d1->data.datetime
405 / d2->data.decimal);
406 if (rem) {
407 double tmp = fmod((double)d1->data.datetime, d2->data.decimal);
408 rem->data.datetime = (sdb_time_t)tmp;
409 }
410 }
411 else {
412 sdb_time_t a, b;
413 if (d2->type == SDB_TYPE_DATETIME) {
414 a = d1->data.datetime;
415 b = d2->data.datetime;
416 }
417 else if (d2->type == SDB_TYPE_INTEGER) {
418 a = d1->data.datetime;
419 b = (sdb_time_t)d2->data.integer;
420 }
421 else
422 return -1;
423 if (res)
424 res->data.datetime = a / b;
425 if (rem)
426 rem->data.datetime = a % b;
427 }
428 }
429 else
430 return -1;
432 if (res)
433 res->type = d1->type;
434 if (rem)
435 rem->type = d1->type;
436 return 0;
437 } /* data_div */
439 /* Concatenate d1 and d2. */
440 static int
441 data_concat(const sdb_data_t *d1, const sdb_data_t *d2, sdb_data_t *res)
442 {
443 unsigned char *new;
444 const unsigned char *s1, *s2;
445 size_t len1, len2, array1_len = 0, array2_len = 0;
447 if ((d1->type & 0xff) != (d2->type & 0xff))
448 return -1;
450 if ((d1->type & SDB_TYPE_ARRAY) || (d2->type & SDB_TYPE_ARRAY)) {
451 size_t elem_size = sdb_data_sizeof(d1->type & 0xff);
452 if (d1->type & SDB_TYPE_ARRAY) {
453 s1 = (const unsigned char *)d1->data.array.values;
454 array1_len = d1->data.array.length;
455 }
456 else {
457 /* As per C99, section 6.7.2.1, paragraph 14:
458 * "A pointer to a union object, suitably converted, points to
459 * each of its members" */
460 s1 = (const unsigned char *)&d1->data;
461 array1_len = 1;
462 }
463 if (d2->type & SDB_TYPE_ARRAY) {
464 s2 = (const unsigned char *)d2->data.array.values;
465 array2_len = d2->data.array.length;
466 }
467 else {
468 s2 = (const unsigned char *)&d2->data;
469 array2_len = 1;
470 }
471 len1 = array1_len * elem_size;
472 len2 = array2_len * elem_size;
473 }
474 else if (d1->type == SDB_TYPE_STRING) {
475 s1 = (unsigned char *)d1->data.string;
476 s2 = (unsigned char *)d2->data.string;
477 len1 = s1 ? strlen((const char *)s1) : 0;
478 len2 = s2 ? strlen((const char *)s2) : 0;
479 }
480 else if (d1->type == SDB_TYPE_BINARY) {
481 s1 = d1->data.binary.datum;
482 s2 = d2->data.binary.datum;
483 len1 = d1->data.binary.length;
484 len2 = d2->data.binary.length;
485 }
486 else
487 return -1;
489 new = malloc(len1 + len2 + 1);
490 if (! new)
491 return -1;
493 if (len1)
494 memcpy(new, s1, len1);
495 if (len2)
496 memcpy(new + len1, s2, len2);
497 new[len1 + len2] = '\0';
499 /* element types match and if either datum is an array,
500 * the result is an array as well */
501 res->type = d1->type | d2->type;
502 if (res->type == SDB_TYPE_STRING) {
503 res->data.string = (char *)new;
504 }
505 else if (res->type == SDB_TYPE_BINARY) {
506 res->data.binary.datum = new;
507 res->data.binary.length = len1 + len2;
508 }
509 else if (res->type & SDB_TYPE_ARRAY) {
510 res->data.array.values = new;
511 res->data.array.length = array1_len + array2_len;
512 if (copy_array_values(res, res, sdb_data_sizeof(res->type & 0xff))) {
513 /* this leaks already copied values but there's not much we can
514 * do and this should only happen if we're in trouble anyway */
515 free(new);
516 res->data.array.values = NULL;
517 res->data.array.length = 0;
518 return -1;
519 }
520 }
521 return 0;
522 } /* data_concat */
524 /*
525 * public API
526 */
528 const sdb_data_t SDB_DATA_NULL = SDB_DATA_INIT;
530 int
531 sdb_data_copy(sdb_data_t *dst, const sdb_data_t *src)
532 {
533 sdb_data_t tmp;
535 if ((! dst) || (! src))
536 return -1;
538 tmp = *src;
539 if (src->type == SDB_TYPE_STRING) {
540 if (src->data.string) {
541 tmp.data.string = strdup(src->data.string);
542 if (! tmp.data.string)
543 return -1;
544 }
545 }
546 else if (src->type == SDB_TYPE_BINARY) {
547 if (src->data.binary.datum) {
548 tmp.data.binary.datum = malloc(src->data.binary.length);
549 if (! tmp.data.binary.datum)
550 return -1;
551 memcpy(tmp.data.binary.datum, src->data.binary.datum,
552 src->data.binary.length);
553 }
554 }
555 else if (src->type == SDB_TYPE_REGEX) {
556 if (src->data.re.raw) {
557 tmp.data.re.raw = strdup(src->data.re.raw);
558 if (! tmp.data.re.raw)
559 return -1;
560 /* we need to recompile because the regex might point to
561 * dynamically allocated memory */
562 if (regcomp(&tmp.data.re.regex, tmp.data.re.raw,
563 REG_EXTENDED | REG_ICASE | REG_NOSUB)) {
564 free(tmp.data.re.raw);
565 return -1;
566 }
567 }
568 else
569 memset(&tmp.data.re.regex, 0, sizeof(tmp.data.re.regex));
570 }
571 else if (src->type & SDB_TYPE_ARRAY) {
572 if (src->data.array.values) {
573 size_t elem_size = sdb_data_sizeof(src->type & 0xff);
574 tmp.data.array.values = calloc(src->data.array.length, elem_size);
575 if (! tmp.data.array.values)
576 return -1;
577 if (copy_array_values(&tmp, src, elem_size)) {
578 sdb_data_free_datum(&tmp);
579 return -1;
580 }
581 }
582 }
584 sdb_data_free_datum(dst);
585 *dst = tmp;
586 return 0;
587 } /* sdb_data_copy */
589 void
590 sdb_data_free_datum(sdb_data_t *datum)
591 {
592 if (! datum)
593 return;
595 if (datum->type == SDB_TYPE_STRING) {
596 if (datum->data.string)
597 free(datum->data.string);
598 datum->data.string = NULL;
599 }
600 else if (datum->type == SDB_TYPE_BINARY) {
601 if (datum->data.binary.datum)
602 free(datum->data.binary.datum);
603 datum->data.binary.datum = NULL;
604 datum->data.binary.length = 0;
605 }
606 else if (datum->type == SDB_TYPE_REGEX) {
607 if (datum->data.re.raw) {
608 free(datum->data.re.raw);
609 regfree(&datum->data.re.regex);
610 }
611 datum->data.re.raw = NULL;
612 memset(&datum->data.re.regex, 0, sizeof(datum->data.re.regex));
613 }
614 else if (datum->type & SDB_TYPE_ARRAY) {
615 free_array_values(datum);
616 if (datum->data.array.values)
617 free(datum->data.array.values);
618 datum->data.array.values = NULL;
619 datum->data.array.length = 0;
620 }
621 } /* sdb_data_free_datum */
623 int
624 sdb_data_cmp(const sdb_data_t *d1, const sdb_data_t *d2)
625 {
626 #define CMP_NULL(a, b) \
627 do { \
628 if (!(a) && !(b)) return 0; \
629 if (!(a)) return -1; \
630 if (!(b)) return 1; \
631 } while (0)
633 CMP_NULL(d1, d2);
635 if (d1->type != d2->type)
636 return SDB_CMP(d1->type, d2->type);
638 if (d1->type == SDB_TYPE_BOOLEAN)
639 return SDB_CMP(d1->data.boolean, d2->data.boolean);
640 else if (d1->type == SDB_TYPE_INTEGER)
641 return SDB_CMP(d1->data.integer, d2->data.integer);
642 else if (d1->type == SDB_TYPE_DECIMAL)
643 return SDB_CMP(d1->data.decimal, d2->data.decimal);
644 else if (d1->type == SDB_TYPE_STRING) {
645 CMP_NULL(d1->data.string, d2->data.string);
646 return strcasecmp(d1->data.string, d2->data.string);
647 }
648 else if (d1->type == SDB_TYPE_DATETIME)
649 return SDB_CMP(d1->data.datetime, d2->data.datetime);
650 else if (d1->type == SDB_TYPE_BINARY) {
651 int diff;
653 CMP_NULL(d1->data.binary.datum, d2->data.binary.datum);
655 /* on a common prefix, the shorter datum sorts less */
656 if (d1->data.binary.length < d2->data.binary.length) {
657 diff = memcmp(d1->data.binary.datum, d2->data.binary.datum,
658 d1->data.binary.length);
659 diff = diff ? diff : -1;
660 }
661 else if (d1->data.binary.length > d2->data.binary.length) {
662 diff = memcmp(d1->data.binary.datum, d2->data.binary.datum,
663 d2->data.binary.length);
664 diff = diff ? diff : 1;
665 }
666 else
667 diff = memcmp(d1->data.binary.datum, d2->data.binary.datum,
668 d1->data.binary.length);
670 return diff;
671 }
672 else if (d1->type == SDB_TYPE_REGEX) {
673 CMP_NULL(d1->data.re.raw, d2->data.re.raw);
674 return strcmp(d1->data.re.raw, d2->data.re.raw);
675 }
676 else if (d1->type & SDB_TYPE_ARRAY) {
677 CMP_NULL(d1->data.array.values, d2->data.array.values);
678 return array_cmp(d1, d2);
679 }
680 return -1;
681 } /* sdb_data_cmp */
683 int
684 sdb_data_strcmp(const sdb_data_t *d1, const sdb_data_t *d2)
685 {
686 char d1_str[sdb_data_strlen(d1) + 1];
687 char d2_str[sdb_data_strlen(d2) + 1];
689 if (sdb_data_isnull(d1))
690 d1 = NULL;
691 if (sdb_data_isnull(d2))
692 d2 = NULL;
694 CMP_NULL(d1, d2);
696 if (! sdb_data_format(d1, d1_str, sizeof(d1_str), SDB_UNQUOTED))
697 return SDB_CMP(sizeof(d1_str), sizeof(d2_str));
698 if (! sdb_data_format(d2, d2_str, sizeof(d2_str), SDB_UNQUOTED))
699 return SDB_CMP(sizeof(d1_str), sizeof(d2_str));
701 return strcasecmp(d1_str, d2_str);
702 #undef CMP_NULL
703 } /* sdb_data_strcmp */
705 bool
706 sdb_data_isnull(const sdb_data_t *datum)
707 {
708 if (! datum)
709 return 1;
710 if (datum->type == SDB_TYPE_NULL)
711 return 1;
712 if ((datum->type == SDB_TYPE_STRING) && (! datum->data.string))
713 return 1;
714 if ((datum->type == SDB_TYPE_BINARY) && (! datum->data.binary.datum))
715 return 1;
716 if ((datum->type == SDB_TYPE_REGEX) && (! datum->data.re.raw))
717 return 1;
718 return 0;
719 } /* sdb_data_isnull */
721 bool
722 sdb_data_inarray(const sdb_data_t *value, const sdb_data_t *array)
723 {
724 const void *values;
725 size_t length, i;
726 int type = value->type & 0xff;
728 if (sdb_data_isnull(value) || sdb_data_isnull(array))
729 return 0;
730 if (! (array->type & SDB_TYPE_ARRAY))
731 return 0;
732 if ((value->type & 0xff) != (array->type & 0xff))
733 return 0;
735 if (value->type & SDB_TYPE_ARRAY) {
736 values = value->data.array.values;
737 length = value->data.array.length;
738 }
739 else {
740 values = &value->data;
741 length = 1;
742 }
744 for (i = 0; i < length; ++i) {
745 size_t j;
747 if (type == SDB_TYPE_BOOLEAN) {
748 bool *v = array->data.array.values;
749 for (j = 0; j < array->data.array.length; ++j)
750 if (((const bool *)values)[i] == v[j])
751 break;
752 }
753 else if (type == SDB_TYPE_INTEGER) {
754 int64_t *v = array->data.array.values;
755 for (j = 0; j < array->data.array.length; ++j)
756 if (((const int64_t *)values)[i] == v[j])
757 break;
758 }
759 else if (type == SDB_TYPE_DECIMAL) {
760 double *v = array->data.array.values;
761 for (j = 0; j < array->data.array.length; ++j)
762 if (((const double *)values)[i] == v[j])
763 break;
764 }
765 else if (type == SDB_TYPE_STRING) {
766 char **v = array->data.array.values;
767 for (j = 0; j < array->data.array.length; ++j)
768 if (!strcasecmp(((const char * const*)values)[i], v[j]))
769 break;
770 }
771 else {
772 /* TODO */
773 errno = ENOTSUP;
774 return 0;
775 }
777 if (j >= array->data.array.length)
778 /* value not found */
779 return 0;
780 }
781 return 1;
782 } /* sdb_data_inarray */
784 int
785 sdb_data_array_get(const sdb_data_t *array, size_t i, sdb_data_t *value)
786 {
787 sdb_data_t tmp = SDB_DATA_INIT;
788 int type;
790 if ((! array) || (! (array->type & SDB_TYPE_ARRAY)))
791 return -1;
792 if (i >= array->data.array.length)
793 return -1;
795 type = array->type & 0xff;
796 if (type == SDB_TYPE_BOOLEAN) {
797 bool *v = array->data.array.values;
798 tmp.data.boolean = v[i];
799 }
800 else if (type == SDB_TYPE_INTEGER) {
801 int64_t *v = array->data.array.values;
802 tmp.data.integer = v[i];
803 }
804 else if (type == SDB_TYPE_DECIMAL) {
805 double *v = array->data.array.values;
806 tmp.data.decimal = v[i];
807 }
808 else if (type == SDB_TYPE_STRING) {
809 char **v = array->data.array.values;
810 tmp.data.string = v[i];
811 }
812 else if (type == SDB_TYPE_DATETIME) {
813 sdb_time_t *v = array->data.array.values;
814 tmp.data.datetime = v[i];
815 }
816 else if (type == SDB_TYPE_BINARY) {
817 struct {
818 size_t length;
819 unsigned char *datum;
820 } *v = array->data.array.values;
821 assert(sizeof(tmp.data.binary) == sizeof(v[i]));
822 memcpy(&tmp.data.binary, &v[i], sizeof(v[i]));
823 }
824 else if (type == SDB_TYPE_REGEX) {
825 struct {
826 char *raw;
827 regex_t regex;
828 } *v = array->data.array.values;
829 assert(sizeof(tmp.data.re) == sizeof(v[i]));
830 memcpy(&tmp.data.re, &v[i], sizeof(v[i]));
831 }
832 else {
833 errno = EINVAL;
834 return -1;
835 }
837 if (value) {
838 *value = tmp;
839 value->type = type;
840 }
841 return 0;
842 } /* sdb_data_array_get */
844 int
845 sdb_data_parse_op(const char *op)
846 {
847 if (! strcmp(op, "+"))
848 return SDB_DATA_ADD;
849 else if (! strcmp(op, "-"))
850 return SDB_DATA_SUB;
851 else if (! strcmp(op, "*"))
852 return SDB_DATA_MUL;
853 else if (! strcmp(op, "/"))
854 return SDB_DATA_DIV;
855 else if (! strcmp(op, "%"))
856 return SDB_DATA_MOD;
857 else if (! strcmp(op, "||"))
858 return SDB_DATA_CONCAT;
859 return -1;
860 } /* sdb_data_parse_op */
862 int
863 sdb_data_expr_eval(int op, const sdb_data_t *d1, const sdb_data_t *d2,
864 sdb_data_t *res)
865 {
866 if ((! d1) || (! d2) || (! res))
867 return -1;
868 if (sdb_data_isnull(d1) || sdb_data_isnull(d2)) {
869 *res = SDB_DATA_NULL;
870 return 0;
871 }
872 switch (op) {
873 case SDB_DATA_CONCAT: return data_concat(d1, d2, res);
874 case SDB_DATA_ADD: return data_lin(d1, 1, d2, res);
875 case SDB_DATA_SUB: return data_lin(d1, -1, d2, res);
876 case SDB_DATA_MUL: return data_mul(d1, d2, res);
877 case SDB_DATA_DIV: return data_div(d1, d2, res, NULL);
878 case SDB_DATA_MOD: return data_div(d1, d2, NULL, res);
879 }
880 return -1;
881 } /* sdb_data_expr_eval */
883 int
884 sdb_data_expr_type(int op, int type1, int type2)
885 {
886 int types_num = (int)SDB_STATIC_ARRAY_LEN(op_matrix[0]);
888 assert(SDB_STATIC_ARRAY_LEN(op_matrix[0])
889 == SDB_STATIC_ARRAY_LEN(op_matrix[0][0]));
891 if ((op <= 0) || (SDB_STATIC_ARRAY_LEN(op_matrix) < (size_t)op))
892 return -1;
894 /* arrays only support concat; element type has to match */
895 if ((type1 & SDB_TYPE_ARRAY) || (type2 & SDB_TYPE_ARRAY)) {
896 if (((type1 & 0xff) != (type2 & 0xff)) || (op != SDB_DATA_CONCAT))
897 return -1;
898 return type1 | SDB_TYPE_ARRAY;
899 }
900 if ((type1 < 0) || (types_num < type1)
901 || (type2 < 0) || (types_num < type2))
902 return -1;
904 if ((type1 == SDB_TYPE_NULL) || (type2 == SDB_TYPE_NULL))
905 return SDB_TYPE_NULL;
906 return op_matrix[op - 1][type1 - 1][type2 - 1];
907 } /* sdb_data_expr_type */
909 size_t
910 sdb_data_strlen(const sdb_data_t *datum)
911 {
912 if (! datum)
913 return 0;
915 if (sdb_data_isnull(datum)) {
916 /* NULL */
917 return 4;
918 }
919 switch (datum->type) {
920 case SDB_TYPE_BOOLEAN:
921 /* true | false */
922 return 5;
923 case SDB_TYPE_INTEGER:
924 /* log(64) */
925 return 20;
926 case SDB_TYPE_DECIMAL:
927 /* XXX: -d.dddddde+dd or -ddddd.dddddd */
928 return 42;
929 case SDB_TYPE_STRING:
930 if (! datum->data.string)
931 return 6; /* NULL */
932 /* in the worst case, each character needs to be escaped */
933 return 2 * strlen(datum->data.string) + 2;
934 case SDB_TYPE_DATETIME:
935 /* "YYYY-MM-DD HH:MM:SS[.nnnnnnnnn] +zzzz" */
936 return 37;
937 case SDB_TYPE_BINARY:
938 if (! datum->data.binary.datum)
939 return 6; /* NULL */
940 /* "\xNN" */
941 return 4 * datum->data.binary.length + 2;
942 case SDB_TYPE_REGEX:
943 if (! datum->data.re.raw)
944 return 6; /* NULL */
945 /* "/.../" */
946 return strlen(datum->data.re.raw) + 4;
947 }
948 if (datum->type & SDB_TYPE_ARRAY) {
949 size_t len = 2; /* [] */
950 size_t i;
951 for (i = 0; i < datum->data.array.length; ++i) {
952 sdb_data_t v = SDB_DATA_INIT;
953 sdb_data_array_get(datum, i, &v);
954 len += sdb_data_strlen(&v) + 1;
955 }
956 return len;
957 }
958 return 0;
959 } /* sdb_data_strlen */
961 size_t
962 sdb_data_format(const sdb_data_t *datum, char *buf, size_t buflen, int quoted)
963 {
964 char tmp[sdb_data_strlen(datum) + 1];
965 char *data = NULL;
966 bool is_null = 0;
967 size_t ret = 0;
969 size_t i, pos;
971 if (! datum)
972 return 0;
974 if (datum->type == SDB_TYPE_NULL) {
975 strncpy(buf, "NULL", buflen);
976 ret = 4;
977 }
978 else if (datum->type == SDB_TYPE_BOOLEAN) {
979 if (datum->data.boolean) {
980 strncpy(buf, "true", buflen);
981 ret = 4;
982 }
983 else {
984 strncpy(buf, "false", buflen);
985 ret = 5;
986 }
987 }
988 else if (datum->type == SDB_TYPE_INTEGER) {
989 ret = snprintf(buf, buflen, "%"PRIi64, datum->data.integer);
990 }
991 else if (datum->type == SDB_TYPE_DECIMAL) {
992 if (isnan(datum->data.decimal))
993 ret = snprintf(buf, buflen, "nan");
994 else
995 ret = snprintf(buf, buflen, "%g", datum->data.decimal);
996 }
997 else if (datum->type == SDB_TYPE_STRING) {
998 if (! datum->data.string)
999 is_null = 1;
1000 else {
1001 pos = 0;
1002 for (i = 0; i < strlen(datum->data.string); ++i) {
1003 char byte = datum->data.string[i];
1005 if ((byte == '\\') || (byte == '"')) {
1006 tmp[pos] = '\\';
1007 ++pos;
1008 }
1009 tmp[pos] = byte;
1010 ++pos;
1011 }
1012 tmp[pos] = '\0';
1013 data = tmp;
1014 }
1015 }
1016 else if (datum->type == SDB_TYPE_DATETIME) {
1017 if (! sdb_strftime(tmp, sizeof(tmp), datum->data.datetime))
1018 return -1;
1019 tmp[sizeof(tmp) - 1] = '\0';
1020 data = tmp;
1021 }
1022 else if (datum->type == SDB_TYPE_BINARY) {
1023 pos = 0;
1024 for (i = 0; i < datum->data.binary.length; ++i) {
1025 int byte = (int)datum->data.binary.datum[i];
1026 char hex[] = {'0', '1', '2', '3', '4', '5', '6', '7',
1027 '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
1029 tmp[pos] = '\\';
1030 tmp[pos + 1] = 'x';
1031 pos += 2;
1033 if (byte > 0xf) {
1034 tmp[pos] = hex[byte >> 4];
1035 ++pos;
1036 }
1037 tmp[pos] = hex[byte & 0xf];
1038 ++pos;
1039 }
1040 if (datum->data.binary.datum) {
1041 tmp[pos] = '\0';
1042 data = tmp;
1043 }
1044 else
1045 is_null = 1;
1046 }
1047 else if (datum->type == SDB_TYPE_REGEX) {
1048 if (! datum->data.re.raw)
1049 is_null = 1;
1050 else {
1051 snprintf(tmp, sizeof(tmp), "/%s/", datum->data.re.raw);
1052 data = tmp;
1053 }
1054 }
1055 else if (datum->type & SDB_TYPE_ARRAY) {
1056 ret = 1;
1057 if (buflen > 0)
1058 buf[0] = '[';
1059 for (i = 0; i < datum->data.array.length; ++i) {
1060 sdb_data_t v = SDB_DATA_INIT;
1061 size_t n;
1063 if (ret > 1) {
1064 if (buflen > ret + 1) {
1065 buf[ret] = ',';
1066 buf[ret + 1] = ' ';
1067 }
1068 ret += 2;
1069 }
1071 sdb_data_array_get(datum, i, &v);
1072 if (buflen > ret)
1073 n = sdb_data_format(&v, buf + ret, buflen - ret, quoted);
1074 else
1075 n = sdb_data_format(&v, NULL, 0, quoted);
1076 if (n > 0)
1077 ret += n;
1078 else
1079 break;
1080 }
1081 if (buflen > ret + 1) {
1082 buf[ret] = ']';
1083 buf[ret + 1] = '\0';
1084 }
1085 ++ret;
1086 }
1088 if (is_null) {
1089 /* never quote NULL */
1090 strncpy(buf, "NULL", buflen);
1091 ret = 4;
1092 }
1093 else if (data) {
1094 if (quoted == SDB_UNQUOTED)
1095 ret = snprintf(buf, buflen, "%s", data);
1096 else if (quoted == SDB_SINGLE_QUOTED)
1097 ret = snprintf(buf, buflen, "'%s'", data);
1098 else
1099 ret = snprintf(buf, buflen, "\"%s\"", data);
1100 }
1101 if (buflen > 0)
1102 buf[buflen - 1] = '\0';
1103 return ret;
1104 } /* sdb_data_format */
1106 int
1107 sdb_data_parse(const char *str, int type, sdb_data_t *data)
1108 {
1109 sdb_data_t tmp;
1111 char *endptr = NULL;
1113 if (! str) {
1114 errno = EINVAL;
1115 return -1;
1116 }
1118 errno = 0;
1119 if (type == SDB_TYPE_BOOLEAN) {
1120 if (! strcasecmp(str, "true"))
1121 tmp.data.boolean = true;
1122 else if (! strcasecmp(str, "false"))
1123 tmp.data.boolean = false;
1124 else
1125 return -1;
1126 }
1127 else if (type == SDB_TYPE_INTEGER) {
1128 tmp.data.integer = strtoll(str, &endptr, 0);
1129 }
1130 else if (type == SDB_TYPE_DECIMAL) {
1131 tmp.data.decimal = strtod(str, &endptr);
1132 }
1133 else if (type == SDB_TYPE_STRING) {
1134 tmp.data.string = strdup(str);
1135 if (! tmp.data.string)
1136 return -1;
1137 }
1138 else if (type == SDB_TYPE_DATETIME) {
1139 double datetime = strtod(str, &endptr);
1140 tmp.data.datetime = DOUBLE_TO_SDB_TIME(datetime);
1141 }
1142 else if (type == SDB_TYPE_BINARY) {
1143 /* we don't support any binary information containing 0-bytes here */
1144 tmp.data.binary.datum = (unsigned char *)strdup(str);
1145 if (! tmp.data.binary.datum)
1146 return -1;
1147 tmp.data.binary.length = strlen(str);
1148 }
1149 else if (type == SDB_TYPE_REGEX) {
1150 tmp.data.re.raw = strdup(str);
1151 if (! tmp.data.re.raw)
1152 return -1;
1153 if (regcomp(&tmp.data.re.regex, tmp.data.re.raw,
1154 REG_EXTENDED | REG_ICASE | REG_NOSUB)) {
1155 sdb_log(SDB_LOG_ERR, "core: Failed to compile regular "
1156 "expression '%s'", tmp.data.re.raw);
1157 free(tmp.data.re.raw);
1158 return -1;
1159 }
1160 if (! data) {
1161 tmp.type = SDB_TYPE_REGEX;
1162 sdb_data_free_datum(&tmp);
1163 }
1164 }
1165 else if (type & SDB_TYPE_ARRAY) {
1166 /* TODO */
1167 errno = ENOTSUP;
1168 return -1;
1169 }
1170 else {
1171 errno = EINVAL;
1172 return -1;
1173 }
1175 if ((type == SDB_TYPE_INTEGER) || (type == SDB_TYPE_DECIMAL)
1176 || (type == SDB_TYPE_DATETIME)) {
1177 if (errno || (str == endptr)) {
1178 char errbuf[1024];
1179 sdb_log(SDB_LOG_ERR, "core: Failed to parse string "
1180 "'%s' as numeric value (type %i): %s", str, type,
1181 sdb_strerror(errno, errbuf, sizeof(errbuf)));
1182 return -1;
1183 }
1184 else if (endptr && (*endptr != '\0'))
1185 sdb_log(SDB_LOG_WARNING, "core: Ignoring garbage after "
1186 "number while parsing numeric value (type %i): %s.",
1187 type, endptr);
1188 }
1190 if (data) {
1191 *data = tmp;
1192 data->type = type;
1193 }
1194 return 0;
1195 } /* sdb_data_parse */
1197 size_t
1198 sdb_data_sizeof(int type)
1199 {
1200 sdb_data_t v;
1201 if (type == SDB_TYPE_BOOLEAN)
1202 return sizeof(v.data.boolean);
1203 else if (type == SDB_TYPE_INTEGER)
1204 return sizeof(v.data.integer);
1205 else if (type == SDB_TYPE_DECIMAL)
1206 return sizeof(v.data.decimal);
1207 else if (type == SDB_TYPE_STRING)
1208 return sizeof(v.data.string);
1209 else if (type == SDB_TYPE_DATETIME)
1210 return sizeof(v.data.datetime);
1211 else if (type == SDB_TYPE_BINARY)
1212 return sizeof(v.data.binary);
1213 else if (type == SDB_TYPE_REGEX)
1214 return sizeof(v.data.re);
1215 return 0;
1216 } /* sdb_data_sizeof */
1218 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */