src/core/data.c

   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  */
  27
  28 #if HAVE_CONFIG_H
  29 #       include "config.h"
  30 #endif /* HAVE_CONFIG_H */
  31
  32 #include "sysdb.h"
  33
  34 #include "core/data.h"
  35 #include "utils/error.h"
  36
  37 #include <assert.h>
  38
  39 #include <errno.h>
  40
  41 #include <inttypes.h>
  42
  43 #include <stdio.h>
  44 #include <stdlib.h>
  45 #include <string.h>
  46
  47 #include <math.h>
  48
  49 /*
  50  * Operator support maxtrix.
  51  * <type1> <op> <type2> -> op_matrix[<op>][<type1>][<type2>]
  52  */
  53
  54 /* add, sub, mul, div, mod, concat */
  55
  56 /* integer, decimal, string, datetime, binary, regex */
  57
  58 static int op_matrix[6][6][6] = {
  59         /* SDB_DATA_ADD */
  60         {
  61                 { SDB_TYPE_INTEGER, -1, -1, -1, -1, -1 },
  62                 { -1, SDB_TYPE_DECIMAL, -1, -1, -1, -1 },
  63                 { -1, -1, -1, -1, -1, -1 },
  64                 { -1, -1, -1, SDB_TYPE_DATETIME, -1, -1 },
  65                 { -1, -1, -1, -1, -1, -1 },
  66                 { -1, -1, -1, -1, -1, -1 },
  67         },
  68
  69         /* SDB_DATA_SUB */
  70         {
  71                 { SDB_TYPE_INTEGER, -1, -1, -1, -1, -1 },
  72                 { -1, SDB_TYPE_DECIMAL, -1, -1, -1, -1 },
  73                 { -1, -1, -1, -1, -1, -1 },
  74                 { -1, -1, -1, SDB_TYPE_DATETIME, -1, -1 },
  75                 { -1, -1, -1, -1, -1, -1 },
  76                 { -1, -1, -1, -1, -1, -1 },
  77         },
  78
  79         /* SDB_DATA_MUL */
  80         {
  81                 { SDB_TYPE_INTEGER, -1, -1, SDB_TYPE_DATETIME, -1, -1 },
  82                 { -1, SDB_TYPE_DECIMAL, -1, SDB_TYPE_DATETIME, -1, -1 },
  83                 { -1, -1, -1, -1, -1, -1 },
  84                 { SDB_TYPE_DATETIME, SDB_TYPE_DATETIME, -1, SDB_TYPE_DATETIME, -1, -1 },
  85                 { -1, -1, -1, -1, -1, -1 },
  86                 { -1, -1, -1, -1, -1, -1 },
  87         },
  88
  89         /* SDB_DATA_DIV */
  90         {
  91                 { SDB_TYPE_INTEGER, -1, -1, -1, -1, -1 },
  92                 { -1, SDB_TYPE_DECIMAL, -1, -1, -1, -1 },
  93                 { -1, -1, -1, -1, -1, -1 },
  94                 { SDB_TYPE_DATETIME, SDB_TYPE_DATETIME, -1, SDB_TYPE_DATETIME, -1, -1 },
  95                 { -1, -1, -1, -1, -1, -1 },
  96                 { -1, -1, -1, -1, -1, -1 },
  97         },
  98
  99         /* SDB_DATA_MOD */
 100         {
 101                 { SDB_TYPE_INTEGER, -1, -1, -1, -1, -1 },
 102                 { -1, SDB_TYPE_DECIMAL, -1, -1, -1, -1 },
 103                 { -1, -1, -1, -1, -1, -1 },
 104                 { SDB_TYPE_DATETIME, SDB_TYPE_DATETIME, -1, SDB_TYPE_DATETIME, -1, -1 },
 105                 { -1, -1, -1, -1, -1, -1 },
 106                 { -1, -1, -1, -1, -1, -1 },
 107         },
 108
 109         /* SDB_DATA_CONCAT */
 110         {
 111                 { -1, -1, -1, -1, -1, -1 },
 112                 { -1, -1, -1, -1, -1, -1 },
 113                 { -1, -1, SDB_TYPE_STRING, -1, -1, -1 },
 114                 { -1, -1, -1, -1, -1, -1 },
 115                 { -1, -1, -1, -1, SDB_TYPE_BINARY, -1 },
 116                 { -1, -1, -1, -1, -1, -1 },
 117         },
 118 };
 119
 120 /*
 121  * private helper functions
 122  */
 123
 124 /* this function supports in-place copies */
 125 static int
 126 copy_array_values(sdb_data_t *dst, const sdb_data_t *src, size_t elem_size)
 127 {
 128         int type = src->type & 0xff;
 129
 130         if ((type == SDB_TYPE_INTEGER) || (type == SDB_TYPE_DECIMAL)) {
 131                 if (dst != src)
 132                         memcpy(dst->data.array.values, src->data.array.values,
 133                                         src->data.array.length * elem_size);
 134         }
 135         else if (type == SDB_TYPE_STRING) {
 136                 char **s = src->data.array.values;
 137                 char **d = dst->data.array.values;
 138                 size_t i;
 139
 140                 for (i = 0; i < src->data.array.length; ++i) {
 141                         d[i] = strdup(s[i]);
 142                         if (! d[i])
 143                                 return -1;
 144                 }
 145         }
 146         else {
 147                 /* TODO */
 148                 errno = ENOTSUP;
 149                 return -1;
 150         }
 151         return 0;
 152 } /* copy_array_values */
 153
 154 static void
 155 free_array_values(sdb_data_t *datum)
 156 {
 157         int type = datum->type & 0xff;
 158
 159         if (type == SDB_TYPE_STRING) {
 160                 char **v = datum->data.array.values;
 161                 size_t i;
 162
 163                 for (i = 0; i < datum->data.array.length; ++i) {
 164                         if (v[i])
 165                                 free(v[i]);
 166                         v[i] = NULL;
 167                 }
 168         }
 169 } /* free_array_values */
 170
 171 /* compare two arrays element-by-element returning how the first non-equal
 172  * elements compare to each other */
 173 static int
 174 array_cmp(const sdb_data_t *a1, const sdb_data_t *a2)
 175 {
 176         int type = a1->type & 0xff;
 177         size_t len, i;
 178
 179         assert((a1->type == a2->type) && (a1->type & SDB_TYPE_ARRAY));
 180
 181         len = SDB_MIN(a1->data.array.length, a2->data.array.length);
 182
 183         if (type == SDB_TYPE_INTEGER) {
 184                 int64_t *v1 = a1->data.array.values;
 185                 int64_t *v2 = a2->data.array.values;
 186
 187                 for (i = 0; i < len; ++i)
 188                         if (v1[i] != v2[i])
 189                                 return SDB_CMP(v1[i], v2[i]);
 190         }
 191         else if (type == SDB_TYPE_DECIMAL) {
 192                 double *v1 = a1->data.array.values;
 193                 double *v2 = a2->data.array.values;
 194
 195                 for (i = 0; i < len; ++i)
 196                         if (v1[i] != v2[i])
 197                                 return SDB_CMP(v1[i], v2[i]);
 198         }
 199         else if (type == SDB_TYPE_STRING) {
 200                 char **v1 = a1->data.array.values;
 201                 char **v2 = a2->data.array.values;
 202
 203                 for (i = 0; i < len; ++i) {
 204                         int diff = strcasecmp(v1[i], v2[i]);
 205                         if (diff)
 206                                 return diff;
 207                 }
 208         }
 209         else {
 210                 /* TODO */
 211                 errno = ENOTSUP;
 212                 /* but fall through to ensure stable sorting: */
 213         }
 214         return SDB_CMP(a1->data.array.length, a2->data.array.length);
 215 } /* array_cmp */
 216
 217 /* Calculate the linear function 'd1 + n * d2'. */
 218 static int
 219 data_lin(const sdb_data_t *d1, int n, const sdb_data_t *d2, sdb_data_t *res)
 220 {
 221         if (d1->type != d2->type)
 222                 return -1;
 223
 224         if (d1->type == SDB_TYPE_INTEGER)
 225                 res->data.integer = d1->data.integer + (int64_t)n * d2->data.integer;
 226         else if (d1->type == SDB_TYPE_DECIMAL)
 227                 res->data.decimal = d1->data.decimal + (double)n * d2->data.decimal;
 228         else if (d1->type ==  SDB_TYPE_DATETIME)
 229                 res->data.datetime = d1->data.datetime + (sdb_time_t)n * d2->data.datetime;
 230         else
 231                 return -1;
 232         res->type = d1->type;
 233         return 0;
 234 } /* data_lin */
 235
 236 /* Multiply d1 with d2. */
 237 static int
 238 data_mul(const sdb_data_t *d1, const sdb_data_t *d2, sdb_data_t *res)
 239 {
 240         if (d1->type == SDB_TYPE_INTEGER) {
 241                 if (d2->type == SDB_TYPE_INTEGER)
 242                         res->data.integer = d1->data.integer * d2->data.integer;
 243                 else if (d2->type == SDB_TYPE_DATETIME) {
 244                         res->data.datetime = (sdb_time_t)d1->data.integer
 245                                 * d2->data.datetime;
 246                         res->type = SDB_TYPE_DATETIME;
 247                         return 0;
 248                 }
 249                 else
 250                         return -1;
 251         }
 252         else if (d1->type == SDB_TYPE_DECIMAL) {
 253                 if (d2->type == SDB_TYPE_DECIMAL)
 254                         res->data.decimal = d1->data.decimal * d2->data.decimal;
 255                 else if (d2->type == SDB_TYPE_DATETIME) {
 256                         res->data.datetime = (sdb_time_t)(d1->data.decimal
 257                                         * (double)d2->data.datetime);
 258                         res->type = SDB_TYPE_DATETIME;
 259                         return 0;
 260                 }
 261                 else
 262                         return -1;
 263         }
 264         else if (d1->type == SDB_TYPE_DATETIME) {
 265                 if (d2->type == SDB_TYPE_DATETIME)
 266                         res->data.datetime = d1->data.datetime
 267                                 * d2->data.datetime;
 268                 else if (d2->type == SDB_TYPE_INTEGER)
 269                         res->data.datetime = d1->data.datetime
 270                                 * (sdb_time_t)d2->data.integer;
 271                 else if (d2->type == SDB_TYPE_DECIMAL)
 272                         res->data.datetime = (sdb_time_t)((double)d1->data.datetime
 273                                         * d2->data.decimal);
 274                 else
 275                         return -1;
 276         }
 277         else
 278                 return -1;
 279
 280         res->type = d1->type;
 281         return 0;
 282 } /* data_mul */
 283
 284 /* Device d1 by d2 and return the result and the remainder. */
 285 static int
 286 data_div(const sdb_data_t *d1, const sdb_data_t *d2,
 287                 sdb_data_t *res, sdb_data_t *rem)
 288 {
 289         if (d1->type == SDB_TYPE_INTEGER) {
 290                 if (d2->type != SDB_TYPE_INTEGER)
 291                         return -1;
 292                 if (res)
 293                         res->data.integer = d1->data.integer / d2->data.integer;
 294                 if (rem)
 295                         rem->data.integer = d1->data.integer % d2->data.integer;
 296         }
 297         else if (d1->type == SDB_TYPE_DECIMAL) {
 298                 if (d2->type != SDB_TYPE_DECIMAL)
 299                         return -1;
 300                 if (res)
 301                         res->data.decimal = d1->data.decimal / d2->data.decimal;
 302                 if (rem)
 303                         rem->data.decimal = fmod(d1->data.decimal, d2->data.decimal);
 304         }
 305         else if (d1->type == SDB_TYPE_DATETIME) {
 306                 if (d2->type == SDB_TYPE_DECIMAL) {
 307                         if (res)
 308                                 res->data.datetime = (sdb_time_t)((double)d1->data.datetime
 309                                                 / d2->data.decimal);
 310                         if (rem) {
 311                                 double tmp = fmod((double)d1->data.datetime, d2->data.decimal);
 312                                 rem->data.datetime = (sdb_time_t)tmp;
 313                         }
 314                 }
 315                 else {
 316                         sdb_time_t a, b;
 317                         if (d2->type == SDB_TYPE_DATETIME) {
 318                                 a = d1->data.datetime;
 319                                 b = d2->data.datetime;
 320                         }
 321                         else if (d2->type == SDB_TYPE_INTEGER) {
 322                                 a = d1->data.datetime;
 323                                 b = (sdb_time_t)d2->data.integer;
 324                         }
 325                         else
 326                                 return -1;
 327                         if (res)
 328                                 res->data.datetime = a / b;
 329                         if (rem)
 330                                 rem->data.datetime = a % b;
 331                 }
 332         }
 333         else
 334                 return -1;
 335
 336         if (res)
 337                 res->type = d1->type;
 338         if (rem)
 339                 rem->type = d1->type;
 340         return 0;
 341 } /* data_div */
 342
 343 /* Concatenate d1 and d2. */
 344 static int
 345 data_concat(const sdb_data_t *d1, const sdb_data_t *d2, sdb_data_t *res)
 346 {
 347         unsigned char *new;
 348         const unsigned char *s1, *s2;
 349         size_t len1, len2, array1_len = 0, array2_len = 0;
 350
 351         if ((d1->type & 0xff) != (d2->type & 0xff))
 352                 return -1;
 353
 354         if ((d1->type & SDB_TYPE_ARRAY) || (d2->type & SDB_TYPE_ARRAY)) {
 355                 size_t elem_size = sdb_data_sizeof(d1->type & 0xff);
 356                 if (d1->type & SDB_TYPE_ARRAY) {
 357                         s1 = (const unsigned char *)d1->data.array.values;
 358                         array1_len = d1->data.array.length;
 359                 }
 360                 else {
 361                         /* As per C99, section 6.7.2.1, paragraph 14:
 362                          * "A pointer to a union object, suitably converted, points to
 363                          * each of its members" */
 364                         s1 = (const unsigned char *)&d1->data;
 365                         array1_len = 1;
 366                 }
 367                 if (d2->type & SDB_TYPE_ARRAY) {
 368                         s2 = (const unsigned char *)d2->data.array.values;
 369                         array2_len = d2->data.array.length;
 370                 }
 371                 else {
 372                         s2 = (const unsigned char *)&d2->data;
 373                         array2_len = 1;
 374                 }
 375                 len1 = array1_len * elem_size;
 376                 len2 = array2_len * elem_size;
 377         }
 378         else if (d1->type == SDB_TYPE_STRING) {
 379                 s1 = (unsigned char *)d1->data.string;
 380                 s2 = (unsigned char *)d2->data.string;
 381                 len1 = s1 ? strlen((const char *)s1) : 0;
 382                 len2 = s2 ? strlen((const char *)s2) : 0;
 383         }
 384         else if (d1->type == SDB_TYPE_BINARY) {
 385                 s1 = d1->data.binary.datum;
 386                 s2 = d2->data.binary.datum;
 387                 len1 = d1->data.binary.length;
 388                 len2 = d2->data.binary.length;
 389         }
 390         else
 391                 return -1;
 392
 393         new = malloc(len1 + len2 + 1);
 394         if (! new)
 395                 return -1;
 396
 397         if (len1)
 398                 memcpy(new, s1, len1);
 399         if (len2)
 400                 memcpy(new + len1, s2, len2);
 401         new[len1 + len2] = '\0';
 402
 403         /* element types match and if either datum is an array,
 404          * the result is an array as well */
 405         res->type = d1->type | d2->type;
 406         if (res->type == SDB_TYPE_STRING) {
 407                 res->data.string = (char *)new;
 408         }
 409         else if (res->type == SDB_TYPE_BINARY) {
 410                 res->data.binary.datum = new;
 411                 res->data.binary.length = len1 + len2;
 412         }
 413         else if (res->type & SDB_TYPE_ARRAY) {
 414                 res->data.array.values = new;
 415                 res->data.array.length = array1_len + array2_len;
 416                 if (copy_array_values(res, res, sdb_data_sizeof(res->type & 0xff))) {
 417                         /* this leaks already copied values but there's not much we can
 418                          * do and this should only happen if we're in trouble anyway */
 419                         free(new);
 420                         res->data.array.values = NULL;
 421                         res->data.array.length = 0;
 422                         return -1;
 423                 }
 424         }
 425         return 0;
 426 } /* data_concat */
 427
 428 /*
 429  * public API
 430  */
 431
 432 const sdb_data_t SDB_DATA_NULL = SDB_DATA_INIT;
 433
 434 int
 435 sdb_data_copy(sdb_data_t *dst, const sdb_data_t *src)
 436 {
 437         sdb_data_t tmp;
 438
 439         if ((! dst) || (! src))
 440                 return -1;
 441
 442         tmp = *src;
 443         if (src->type == SDB_TYPE_STRING) {
 444                 if (src->data.string) {
 445                         tmp.data.string = strdup(src->data.string);
 446                         if (! tmp.data.string)
 447                                 return -1;
 448                 }
 449         }
 450         else if (src->type == SDB_TYPE_BINARY) {
 451                 if (src->data.binary.datum) {
 452                         tmp.data.binary.datum = malloc(src->data.binary.length);
 453                         if (! tmp.data.binary.datum)
 454                                 return -1;
 455                         memcpy(tmp.data.binary.datum, src->data.binary.datum,
 456                                         src->data.binary.length);
 457                 }
 458         }
 459         else if (src->type == SDB_TYPE_REGEX) {
 460                 if (src->data.re.raw) {
 461                         tmp.data.re.raw = strdup(src->data.re.raw);
 462                         if (! tmp.data.re.raw)
 463                                 return -1;
 464                         /* we need to recompile because the regex might point to
 465                          * dynamically allocated memory */
 466                         if (regcomp(&tmp.data.re.regex, tmp.data.re.raw,
 467                                                 REG_EXTENDED | REG_ICASE | REG_NOSUB)) {
 468                                 free(tmp.data.re.raw);
 469                                 return -1;
 470                         }
 471                 }
 472                 else
 473                         memset(&tmp.data.re.regex, 0, sizeof(tmp.data.re.regex));
 474         }
 475         else if (src->type & SDB_TYPE_ARRAY) {
 476                 if (src->data.array.values) {
 477                         size_t elem_size = sdb_data_sizeof(src->type & 0xff);
 478                         tmp.data.array.values = calloc(src->data.array.length, elem_size);
 479                         if (! tmp.data.array.values)
 480                                 return -1;
 481                         if (copy_array_values(&tmp, src, elem_size)) {
 482                                 sdb_data_free_datum(&tmp);
 483                                 return -1;
 484                         }
 485                 }
 486         }
 487
 488         sdb_data_free_datum(dst);
 489         *dst = tmp;
 490         return 0;
 491 } /* sdb_data_copy */
 492
 493 void
 494 sdb_data_free_datum(sdb_data_t *datum)
 495 {
 496         if (! datum)
 497                 return;
 498
 499         if (datum->type == SDB_TYPE_STRING) {
 500                 if (datum->data.string)
 501                         free(datum->data.string);
 502                 datum->data.string = NULL;
 503         }
 504         else if (datum->type == SDB_TYPE_BINARY) {
 505                 if (datum->data.binary.datum)
 506                         free(datum->data.binary.datum);
 507                 datum->data.binary.datum = NULL;
 508                 datum->data.binary.length = 0;
 509         }
 510         else if (datum->type == SDB_TYPE_REGEX) {
 511                 if (datum->data.re.raw) {
 512                         free(datum->data.re.raw);
 513                         regfree(&datum->data.re.regex);
 514                 }
 515                 datum->data.re.raw = NULL;
 516                 memset(&datum->data.re.regex, 0, sizeof(datum->data.re.regex));
 517         }
 518         else if (datum->type & SDB_TYPE_ARRAY) {
 519                 free_array_values(datum);
 520                 if (datum->data.array.values)
 521                         free(datum->data.array.values);
 522                 datum->data.array.values = NULL;
 523                 datum->data.array.length = 0;
 524         }
 525 } /* sdb_data_free_datum */
 526
 527 int
 528 sdb_data_cmp(const sdb_data_t *d1, const sdb_data_t *d2)
 529 {
 530 #define CMP_NULL(a, b) \
 531         do { \
 532                 if (!(a) && !(b)) return 0; \
 533                 if (!(a)) return -1; \
 534                 if (!(b)) return 1; \
 535         } while (0)
 536
 537         CMP_NULL(d1, d2);
 538
 539         if (d1->type != d2->type)
 540                 return SDB_CMP(d1->type, d2->type);
 541
 542         if (d1->type == SDB_TYPE_INTEGER)
 543                 return SDB_CMP(d1->data.integer, d2->data.integer);
 544         else if (d1->type == SDB_TYPE_DECIMAL)
 545                 return SDB_CMP(d1->data.decimal, d2->data.decimal);
 546         else if (d1->type == SDB_TYPE_STRING) {
 547                 CMP_NULL(d1->data.string, d2->data.string);
 548                 return strcasecmp(d1->data.string, d2->data.string);
 549         }
 550         else if (d1->type == SDB_TYPE_DATETIME)
 551                 return SDB_CMP(d1->data.datetime, d2->data.datetime);
 552         else if (d1->type == SDB_TYPE_BINARY) {
 553                 int diff;
 554
 555                 CMP_NULL(d1->data.binary.datum, d2->data.binary.datum);
 556
 557                 /* on a common prefix, the shorter datum sorts less */
 558                 if (d1->data.binary.length < d2->data.binary.length) {
 559                         diff = memcmp(d1->data.binary.datum, d2->data.binary.datum,
 560                                         d1->data.binary.length);
 561                         diff = diff ? diff : -1;
 562                 }
 563                 else if (d1->data.binary.length > d2->data.binary.length) {
 564                         diff = memcmp(d1->data.binary.datum, d2->data.binary.datum,
 565                                         d2->data.binary.length);
 566                         diff = diff ? diff : 1;
 567                 }
 568                 else
 569                         diff = memcmp(d1->data.binary.datum, d2->data.binary.datum,
 570                                         d1->data.binary.length);
 571
 572                 return diff;
 573         }
 574         else if (d1->type == SDB_TYPE_REGEX) {
 575                 CMP_NULL(d1->data.re.raw, d2->data.re.raw);
 576                 return strcmp(d1->data.re.raw, d2->data.re.raw);
 577         }
 578         else if (d1->type & SDB_TYPE_ARRAY) {
 579                 CMP_NULL(d1->data.array.values, d2->data.array.values);
 580                 return array_cmp(d1, d2);
 581         }
 582         return -1;
 583 } /* sdb_data_cmp */
 584
 585 int
 586 sdb_data_strcmp(const sdb_data_t *d1, const sdb_data_t *d2)
 587 {
 588         char d1_str[sdb_data_strlen(d1) + 1];
 589         char d2_str[sdb_data_strlen(d2) + 1];
 590
 591         if ((d1->type & SDB_TYPE_ARRAY) || (d2->type & SDB_TYPE_ARRAY)) {
 592                 /* TODO */
 593                 errno = ENOTSUP;
 594                 return -1;
 595         }
 596
 597         if (sdb_data_isnull(d1))
 598                 d1 = NULL;
 599         if (sdb_data_isnull(d2))
 600                 d2 = NULL;
 601
 602         CMP_NULL(d1, d2);
 603
 604         if (sdb_data_format(d1, d1_str, sizeof(d1_str), SDB_UNQUOTED) < 0)
 605                 return SDB_CMP(sizeof(d1_str), sizeof(d2_str));
 606         if (sdb_data_format(d2, d2_str, sizeof(d2_str), SDB_UNQUOTED) < 0)
 607                 return SDB_CMP(sizeof(d1_str), sizeof(d2_str));
 608
 609         return strcasecmp(d1_str, d2_str);
 610 #undef CMP_NULL
 611 } /* sdb_data_strcmp */
 612
 613 bool
 614 sdb_data_isnull(const sdb_data_t *datum)
 615 {
 616         if (! datum)
 617                 return 1;
 618         if (datum->type == SDB_TYPE_NULL)
 619                 return 1;
 620         if ((datum->type == SDB_TYPE_STRING) && (! datum->data.string))
 621                 return 1;
 622         if ((datum->type == SDB_TYPE_BINARY) && (! datum->data.binary.datum))
 623                 return 1;
 624         if ((datum->type == SDB_TYPE_REGEX) && (! datum->data.re.raw))
 625                 return 1;
 626         return 0;
 627 } /* sdb_data_isnull */
 628
 629 bool
 630 sdb_data_inarray(const sdb_data_t *value, const sdb_data_t *array)
 631 {
 632         const void *values;
 633         size_t length, i;
 634         int type = value->type & 0xff;
 635
 636         if (sdb_data_isnull(value) || sdb_data_isnull(array))
 637                 return 0;
 638         if (! (array->type & SDB_TYPE_ARRAY))
 639                 return 0;
 640         if ((value->type & 0xff) != (array->type & 0xff))
 641                 return 0;
 642
 643         if (value->type & SDB_TYPE_ARRAY) {
 644                 values = value->data.array.values;
 645                 length = value->data.array.length;
 646         }
 647         else {
 648                 values = &value->data;
 649                 length = 1;
 650         }
 651
 652         for (i = 0; i < length; ++i) {
 653                 size_t j;
 654
 655                 if (type == SDB_TYPE_INTEGER) {
 656                         int64_t *v = array->data.array.values;
 657                         for (j = 0; j < array->data.array.length; ++j)
 658                                 if (((const int64_t *)values)[i] == v[j])
 659                                         break;
 660                 }
 661                 else if (type == SDB_TYPE_DECIMAL) {
 662                         double *v = array->data.array.values;
 663                         for (j = 0; j < array->data.array.length; ++j)
 664                                 if (((const double *)values)[i] == v[j])
 665                                         break;
 666                 }
 667                 else if (type == SDB_TYPE_STRING) {
 668                         char **v = array->data.array.values;
 669                         for (j = 0; j < array->data.array.length; ++j)
 670                                 if (!strcasecmp(((const char * const*)values)[i], v[j]))
 671                                         break;
 672                 }
 673                 else {
 674                         /* TODO */
 675                         errno = ENOTSUP;
 676                         return 0;
 677                 }
 678
 679                 if (j >= array->data.array.length)
 680                         /* value not found */
 681                         return 0;
 682         }
 683         return 1;
 684 } /* sdb_data_inarray */
 685
 686 int
 687 sdb_data_array_get(const sdb_data_t *array, size_t i, sdb_data_t *value)
 688 {
 689         sdb_data_t tmp = SDB_DATA_INIT;
 690         int type;
 691
 692         if ((! array) || (! (array->type & SDB_TYPE_ARRAY)))
 693                 return -1;
 694         if (i >= array->data.array.length)
 695                 return -1;
 696
 697         type = array->type & 0xff;
 698         if (type == SDB_TYPE_INTEGER) {
 699                 int64_t *v = array->data.array.values;
 700                 tmp.data.integer = v[i];
 701         }
 702         else if (type == SDB_TYPE_DECIMAL) {
 703                 double *v = array->data.array.values;
 704                 tmp.data.decimal = v[i];
 705         }
 706         else if (type == SDB_TYPE_STRING) {
 707                 char **v = array->data.array.values;
 708                 tmp.data.string = v[i];
 709         }
 710         else {
 711                 /* TODO */
 712                 errno = ENOTSUP;
 713                 return -1;
 714         }
 715
 716         if (value) {
 717                 *value = tmp;
 718                 value->type = type;
 719         }
 720         return 0;
 721 } /* sdb_data_array_get */
 722
 723 int
 724 sdb_data_parse_op(const char *op)
 725 {
 726         if (! strcmp(op, "+"))
 727                 return SDB_DATA_ADD;
 728         else if (! strcmp(op, "-"))
 729                 return SDB_DATA_SUB;
 730         else if (! strcmp(op, "*"))
 731                 return SDB_DATA_MUL;
 732         else if (! strcmp(op, "/"))
 733                 return SDB_DATA_DIV;
 734         else if (! strcmp(op, "%"))
 735                 return SDB_DATA_MOD;
 736         else if (! strcmp(op, "||"))
 737                 return SDB_DATA_CONCAT;
 738         return -1;
 739 } /* sdb_data_parse_op */
 740
 741 int
 742 sdb_data_expr_eval(int op, const sdb_data_t *d1, const sdb_data_t *d2,
 743                 sdb_data_t *res)
 744 {
 745         if ((! d1) || (! d2) || (! res))
 746                 return -1;
 747         if (sdb_data_isnull(d1) || sdb_data_isnull(d2)) {
 748                 *res = SDB_DATA_NULL;
 749                 return 0;
 750         }
 751         switch (op) {
 752                 case SDB_DATA_CONCAT: return data_concat(d1, d2, res);
 753                 case SDB_DATA_ADD: return data_lin(d1, 1, d2, res);
 754                 case SDB_DATA_SUB: return data_lin(d1, -1, d2, res);
 755                 case SDB_DATA_MUL: return data_mul(d1, d2, res);
 756                 case SDB_DATA_DIV: return data_div(d1, d2, res, NULL);
 757                 case SDB_DATA_MOD: return data_div(d1, d2, NULL, res);
 758         }
 759         return -1;
 760 } /* sdb_data_expr_eval */
 761
 762 int
 763 sdb_data_expr_type(int op, int type1, int type2)
 764 {
 765         int types_num = (int)SDB_STATIC_ARRAY_LEN(op_matrix[0]);
 766
 767         assert(SDB_STATIC_ARRAY_LEN(op_matrix[0])
 768                         == SDB_STATIC_ARRAY_LEN(op_matrix[0][0]));
 769
 770         if ((op <= 0) || (SDB_STATIC_ARRAY_LEN(op_matrix) < (size_t)op))
 771                 return -1;
 772
 773         /* arrays only support concat; element type has to match */
 774         if ((type1 & SDB_TYPE_ARRAY) || (type2 & SDB_TYPE_ARRAY)) {
 775                 if (((type1 & 0xff) != (type2 & 0xff)) || (op != SDB_DATA_CONCAT))
 776                         return -1;
 777                 return type1 | SDB_TYPE_ARRAY;
 778         }
 779         if ((type1 < 0) || (types_num < type1)
 780                         || (type2 < 0) || (types_num < type2))
 781                 return -1;
 782
 783         if ((type1 == SDB_TYPE_NULL) || (type2 == SDB_TYPE_NULL))
 784                 return SDB_TYPE_NULL;
 785         return op_matrix[op - 1][type1 - 1][type2 - 1];
 786 } /* sdb_data_expr_type */
 787
 788 size_t
 789 sdb_data_strlen(const sdb_data_t *datum)
 790 {
 791         if (! datum)
 792                 return 0;
 793
 794         if (datum->type == SDB_TYPE_INTEGER) {
 795                 /* log(64) */
 796                 return 20;
 797         }
 798         else if (datum->type == SDB_TYPE_DECIMAL) {
 799                 /* XXX: -d.dddddde+dd or -ddddd.dddddd */
 800                 return 42;
 801         }
 802         else if (datum->type == SDB_TYPE_STRING) {
 803                 if (! datum->data.string)
 804                         return 6; /* NULL */
 805                 /* in the worst case, each character needs to be escaped */
 806                 return 2 * strlen(datum->data.string) + 2;
 807         }
 808         else if (datum->type == SDB_TYPE_DATETIME) {
 809                 /* "YYYY-MM-DD HH:MM:SS +zzzz" */
 810                 return 27;
 811         }
 812         else if (datum->type == SDB_TYPE_BINARY) {
 813                 if (! datum->data.binary.datum)
 814                         return 6; /* NULL */
 815                 /* "\xNN" */
 816                 return 4 * datum->data.binary.length + 2;
 817         }
 818         else if (datum->type == SDB_TYPE_REGEX) {
 819                 if (! datum->data.re.raw)
 820                         return 6; /* NULL */
 821                 /* "/.../" */
 822                 return strlen(datum->data.re.raw) + 4;
 823         }
 824         else if (datum->type & SDB_TYPE_ARRAY) {
 825                 size_t len = 2; /* [] */
 826                 size_t i;
 827                 for (i = 0; i < datum->data.array.length; ++i) {
 828                         sdb_data_t v = SDB_DATA_INIT;
 829                         sdb_data_array_get(datum, i, &v);
 830                         len += sdb_data_strlen(&v) + 1;
 831                 }
 832                 return len;
 833         }
 834         return 0;
 835 } /* sdb_data_strlen */
 836
 837 int
 838 sdb_data_format(const sdb_data_t *datum, char *buf, size_t buflen, int quoted)
 839 {
 840         char tmp[sdb_data_strlen(datum) + 1];
 841         char *data = NULL;
 842         bool is_null = 0;
 843         int ret = -1;
 844
 845         size_t i, pos;
 846
 847         if ((! datum) || (! buf) || (! buflen))
 848                 return -1;
 849
 850         if (datum->type == SDB_TYPE_INTEGER) {
 851                 ret = snprintf(buf, buflen, "%"PRIi64, datum->data.integer);
 852         }
 853         else if (datum->type == SDB_TYPE_DECIMAL) {
 854                 if (isnan(datum->data.decimal))
 855                         ret = snprintf(buf, buflen, "nan");
 856                 else
 857                         ret = snprintf(buf, buflen, "%g", datum->data.decimal);
 858         }
 859         else if (datum->type == SDB_TYPE_STRING) {
 860                 if (! datum->data.string)
 861                         is_null = 1;
 862                 else {
 863                         pos = 0;
 864                         for (i = 0; i < strlen(datum->data.string); ++i) {
 865                                 char byte = datum->data.string[i];
 866
 867                                 if ((byte == '\\') || (byte == '"')) {
 868                                         tmp[pos] = '\\';
 869                                         ++pos;
 870                                 }
 871                                 tmp[pos] = byte;
 872                                 ++pos;
 873                         }
 874                         tmp[pos] = '\0';
 875                         data = tmp;
 876                 }
 877         }
 878         else if (datum->type == SDB_TYPE_DATETIME) {
 879                 if (! sdb_strftime(tmp, sizeof(tmp), "%F %T %z",
 880                                         datum->data.datetime))
 881                         return -1;
 882                 tmp[sizeof(tmp) - 1] = '\0';
 883                 data = tmp;
 884         }
 885         else if (datum->type == SDB_TYPE_BINARY) {
 886                 pos = 0;
 887                 for (i = 0; i < datum->data.binary.length; ++i) {
 888                         int byte = (int)datum->data.binary.datum[i];
 889                         char hex[] = {'0', '1', '2', '3', '4', '5', '6', '7',
 890                                 '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
 891
 892                         tmp[pos] = '\\';
 893                         tmp[pos + 1] = 'x';
 894                         pos += 2;
 895
 896                         if (byte > 0xf) {
 897                                 tmp[pos] = hex[byte >> 4];
 898                                 ++pos;
 899                         }
 900                         tmp[pos] = hex[byte & 0xf];
 901                         ++pos;
 902                 }
 903                 if (datum->data.binary.datum) {
 904                         tmp[pos] = '\0';
 905                         data = tmp;
 906                 }
 907                 else
 908                         is_null = 1;
 909         }
 910         else if (datum->type == SDB_TYPE_REGEX) {
 911                 if (! datum->data.re.raw)
 912                         is_null = 1;
 913                 else {
 914                         snprintf(tmp, sizeof(tmp), "/%s/", datum->data.re.raw);
 915                         data = tmp;
 916                 }
 917         }
 918         else if (datum->type & SDB_TYPE_ARRAY) {
 919                 ret = 1;
 920                 buf[0] = '[';
 921                 for (i = 0; i < datum->data.array.length; ++i) {
 922                         sdb_data_t v = SDB_DATA_INIT;
 923                         int n;
 924                         if ((size_t)ret >= buflen - 1)
 925                                 break;
 926
 927                         if (ret > 1) {
 928                                 buf[ret] = ',';
 929                                 buf[ret + 1] = ' ';
 930                                 ret += 2;
 931                         }
 932
 933                         sdb_data_array_get(datum, i, &v);
 934                         n = sdb_data_format(&v, buf + ret, buflen - ret, quoted);
 935                         if (n > 0)
 936                                 ret += n;
 937                         else
 938                                 break;
 939                 }
 940                 if ((size_t)ret < buflen - 1) {
 941                         buf[ret] = ']';
 942                         buf[ret + 1] = '\0';
 943                         ++ret;
 944                 }
 945         }
 946
 947         if (is_null) {
 948                 /* never quote NULL */
 949                 strncpy(buf, "NULL", buflen);
 950                 ret = (int)SDB_MIN(buflen, 4);
 951         }
 952         else if (data) {
 953                 if (quoted == SDB_UNQUOTED)
 954                         ret = snprintf(buf, buflen, "%s", data);
 955                 else if (quoted == SDB_SINGLE_QUOTED)
 956                         ret = snprintf(buf, buflen, "'%s'", data);
 957                 else
 958                         ret = snprintf(buf, buflen, "\"%s\"", data);
 959         }
 960         buf[buflen - 1] = '\0';
 961         return ret;
 962 } /* sdb_data_format */
 963
 964 int
 965 sdb_data_parse(char *str, int type, sdb_data_t *data)
 966 {
 967         sdb_data_t tmp;
 968
 969         char *endptr = NULL;
 970
 971         errno = 0;
 972         if (type == SDB_TYPE_INTEGER) {
 973                 tmp.data.integer = strtoll(str, &endptr, 0);
 974         }
 975         else if (type == SDB_TYPE_DECIMAL) {
 976                 tmp.data.decimal = strtod(str, &endptr);
 977         }
 978         else if (type == SDB_TYPE_STRING) {
 979                 tmp.data.string = str;
 980         }
 981         else if (type == SDB_TYPE_DATETIME) {
 982                 double datetime = strtod(str, &endptr);
 983                 tmp.data.datetime = DOUBLE_TO_SDB_TIME(datetime);
 984         }
 985         else if (type == SDB_TYPE_BINARY) {
 986                 /* we don't support any binary information containing 0-bytes */
 987                 tmp.data.binary.length = strlen(str);
 988                 tmp.data.binary.datum = (unsigned char *)str;
 989         }
 990         else if (type == SDB_TYPE_REGEX) {
 991                 tmp.data.re.raw = strdup(str);
 992                 if (! tmp.data.re.raw)
 993                         return -1;
 994                 if (regcomp(&tmp.data.re.regex, tmp.data.re.raw,
 995                                         REG_EXTENDED | REG_ICASE | REG_NOSUB)) {
 996                         sdb_log(SDB_LOG_ERR, "core: Failed to compile regular "
 997                                         "expression '%s'", tmp.data.re.raw);
 998                         free(tmp.data.re.raw);
 999                         return -1;
1000                 }
1001                 if (! data) {
1002                         tmp.type = SDB_TYPE_REGEX;
1003                         sdb_data_free_datum(&tmp);
1004                 }
1005         }
1006         else if (type & SDB_TYPE_ARRAY) {
1007                 /* TODO */
1008                 errno = ENOTSUP;
1009                 return -1;
1010         }
1011         else {
1012                 errno = EINVAL;
1013                 return -1;
1014         }
1015
1016         if ((type == SDB_TYPE_INTEGER) || (type == SDB_TYPE_DECIMAL)
1017                         || (type == SDB_TYPE_DATETIME)) {
1018                 if (errno || (str == endptr)) {
1019                         char errbuf[1024];
1020                         sdb_log(SDB_LOG_ERR, "core: Failed to parse string "
1021                                         "'%s' as numeric value (type %i): %s", str, type,
1022                                         sdb_strerror(errno, errbuf, sizeof(errbuf)));
1023                         return -1;
1024                 }
1025                 else if (endptr && (*endptr != '\0'))
1026                         sdb_log(SDB_LOG_WARNING, "core: Ignoring garbage after "
1027                                         "number while parsing numeric value (type %i): %s.",
1028                                         type, endptr);
1029         }
1030
1031         if (data) {
1032                 *data = tmp;
1033                 data->type = type;
1034         }
1035         return 0;
1036 } /* sdb_data_parse */
1037
1038 size_t
1039 sdb_data_sizeof(int type)
1040 {
1041         sdb_data_t v;
1042         if (type == SDB_TYPE_INTEGER)
1043                 return sizeof(v.data.integer);
1044         else if (type == SDB_TYPE_DECIMAL)
1045                 return sizeof(v.data.decimal);
1046         else if (type == SDB_TYPE_STRING)
1047                 return sizeof(v.data.string);
1048         else if (type == SDB_TYPE_DATETIME)
1049                 return sizeof(v.data.datetime);
1050         else if (type == SDB_TYPE_BINARY)
1051                 return sizeof(v.data.binary);
1052         else if (type == SDB_TYPE_REGEX)
1053                 return sizeof(v.data.re);
1054         return 0;
1055 } /* sdb_data_sizeof */
1056
1057 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */
1058