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 #include <strings.h>
  47
  48 #include <math.h>
  49
  50 /*
  51  * Operator support maxtrix.
  52  * <type1> <op> <type2> -> op_matrix[<op>][<type1>][<type2>]
  53  */
  54
  55 /* add, sub, mul, div, mod, concat */
  56
  57 /* integer, decimal, string, datetime, binary, regex */
  58
  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         },
  70
  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         },
  81
  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         },
  92
  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         },
 103
 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         },
 114
 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 };
 126
 127 /*
 128  * private helper functions
 129  */
 130
 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;
 136
 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;
 147
 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 */
 161
 162 static void
 163 free_array_values(sdb_data_t *datum)
 164 {
 165         int type = datum->type & 0xff;
 166
 167         if (type == SDB_TYPE_STRING) {
 168                 char **v = datum->data.array.values;
 169                 size_t i;
 170
 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;
 183
 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;
 196
 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 */
 206
 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;
 214
 215         assert((a1->type == a2->type) && (a1->type & SDB_TYPE_ARRAY));
 216
 217         len = SDB_MIN(a1->data.array.length, a2->data.array.length);
 218
 219         if (type == SDB_TYPE_BOOLEAN) {
 220                 bool *v1 = a1->data.array.values;
 221                 bool *v2 = a2->data.array.values;
 222
 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;
 230
 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;
 238
 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;
 246
 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;
 256
 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;
 270
 271                 for (i = 0; i < len; ++i) {
 272                         int diff;
 273
 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);
 285
 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;
 299
 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 */
 312
 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;
 319
 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 */
 331
 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;
 375
 376         res->type = d1->type;
 377         return 0;
 378 } /* data_mul */
 379
 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;
 431
 432         if (res)
 433                 res->type = d1->type;
 434         if (rem)
 435                 rem->type = d1->type;
 436         return 0;
 437 } /* data_div */
 438
 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;
 446
 447         if ((d1->type & 0xff) != (d2->type & 0xff))
 448                 return -1;
 449
 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;
 488
 489         new = malloc(len1 + len2 + 1);
 490         if (! new)
 491                 return -1;
 492
 493         if (len1)
 494                 memcpy(new, s1, len1);
 495         if (len2)
 496                 memcpy(new + len1, s2, len2);
 497         new[len1 + len2] = '\0';
 498
 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 */
 523
 524 /*
 525  * public API
 526  */
 527
 528 const sdb_data_t SDB_DATA_NULL = SDB_DATA_INIT;
 529
 530 int
 531 sdb_data_copy(sdb_data_t *dst, const sdb_data_t *src)
 532 {
 533         sdb_data_t tmp;
 534
 535         if ((! dst) || (! src))
 536                 return -1;
 537
 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         }
 583
 584         sdb_data_free_datum(dst);
 585         *dst = tmp;
 586         return 0;
 587 } /* sdb_data_copy */
 588
 589 void
 590 sdb_data_free_datum(sdb_data_t *datum)
 591 {
 592         if (! datum)
 593                 return;
 594
 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 */
 622
 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)
 632
 633         CMP_NULL(d1, d2);
 634
 635         if (d1->type != d2->type)
 636                 return SDB_CMP(d1->type, d2->type);
 637
 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;
 652
 653                 CMP_NULL(d1->data.binary.datum, d2->data.binary.datum);
 654
 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);
 669
 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 */
 682
 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];
 688
 689         if (sdb_data_isnull(d1))
 690                 d1 = NULL;
 691         if (sdb_data_isnull(d2))
 692                 d2 = NULL;
 693
 694         CMP_NULL(d1, d2);
 695
 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));
 700
 701         return strcasecmp(d1_str, d2_str);
 702 #undef CMP_NULL
 703 } /* sdb_data_strcmp */
 704
 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 */
 720
 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;
 727
 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;
 734
 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         }
 743
 744         for (i = 0; i < length; ++i) {
 745                 size_t j;
 746
 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                 }
 776
 777                 if (j >= array->data.array.length)
 778                         /* value not found */
 779                         return 0;
 780         }
 781         return 1;
 782 } /* sdb_data_inarray */
 783
 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;
 789
 790         if ((! array) || (! (array->type & SDB_TYPE_ARRAY)))
 791                 return -1;
 792         if (i >= array->data.array.length)
 793                 return -1;
 794
 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         }
 836
 837         if (value) {
 838                 *value = tmp;
 839                 value->type = type;
 840         }
 841         return 0;
 842 } /* sdb_data_array_get */
 843
 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 */
 861
 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 */
 882
 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]);
 887
 888         assert(SDB_STATIC_ARRAY_LEN(op_matrix[0])
 889                         == SDB_STATIC_ARRAY_LEN(op_matrix[0][0]));
 890
 891         if ((op <= 0) || (SDB_STATIC_ARRAY_LEN(op_matrix) < (size_t)op))
 892                 return -1;
 893
 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;
 903
 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 */
 908
 909 size_t
 910 sdb_data_strlen(const sdb_data_t *datum)
 911 {
 912         if (! datum)
 913                 return 0;
 914
 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 */
 960
 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;
 968
 969         size_t i, pos;
 970
 971         if (! datum)
 972                 return 0;
 973
 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];
1004
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'};
1028
1029                         tmp[pos] = '\\';
1030                         tmp[pos + 1] = 'x';
1031                         pos += 2;
1032
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;
1062
1063                         if (ret > 1) {
1064                                 if (buflen > ret + 1) {
1065                                         buf[ret] = ',';
1066                                         buf[ret + 1] = ' ';
1067                                 }
1068                                 ret += 2;
1069                         }
1070
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         }
1087
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 */
1105
1106 int
1107 sdb_data_parse(const char *str, int type, sdb_data_t *data)
1108 {
1109         sdb_data_t tmp;
1110
1111         char *endptr = NULL;
1112
1113         if (! str) {
1114                 errno = EINVAL;
1115                 return -1;
1116         }
1117
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         }
1174
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         }
1189
1190         if (data) {
1191                 *data = tmp;
1192                 data->type = type;
1193         }
1194         return 0;
1195 } /* sdb_data_parse */
1196
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 */
1217
1218 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */
1219