src/utils_db_query.c

   1 /**
   2  * collectd - src/utils_db_query.c
   3  * Copyright (C) 2008,2009  Florian octo Forster
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included in
  13  * all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  18  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  21  * DEALINGS IN THE SOFTWARE.
  22  *
  23  * Authors:
  24  *   Florian octo Forster <octo at collectd.org>
  25  **/
  26
  27 #include "collectd.h"
  28
  29 #include "common.h"
  30 #include "plugin.h"
  31 #include "utils_db_query.h"
  32
  33 /*
  34  * Data types
  35  */
  36 struct udb_result_s; /* {{{ */
  37 typedef struct udb_result_s udb_result_t;
  38 struct udb_result_s {
  39   char *type;
  40   char *instance_prefix;
  41   char **instances;
  42   size_t instances_num;
  43   char **values;
  44   size_t values_num;
  45   char **metadata;
  46   size_t metadata_num;
  47
  48   udb_result_t *next;
  49 }; /* }}} */
  50
  51 struct udb_query_s /* {{{ */
  52 {
  53   char *name;
  54   char *statement;
  55   void *user_data;
  56   char *plugin_instance_from;
  57
  58   unsigned int min_version;
  59   unsigned int max_version;
  60
  61   udb_result_t *results;
  62 }; /* }}} */
  63
  64 struct udb_result_preparation_area_s /* {{{ */
  65 {
  66   const data_set_t *ds;
  67   size_t *instances_pos;
  68   size_t *values_pos;
  69   size_t *metadata_pos;
  70   char **instances_buffer;
  71   char **values_buffer;
  72   char **metadata_buffer;
  73   char *plugin_instance;
  74
  75   struct udb_result_preparation_area_s *next;
  76 }; /* }}} */
  77 typedef struct udb_result_preparation_area_s udb_result_preparation_area_t;
  78
  79 struct udb_query_preparation_area_s /* {{{ */
  80 {
  81   size_t column_num;
  82   size_t plugin_instance_pos;
  83   char *host;
  84   char *plugin;
  85   char *db_name;
  86
  87   cdtime_t interval;
  88
  89   udb_result_preparation_area_t *result_prep_areas;
  90 }; /* }}} */
  91
  92 /*
  93  * Config Private functions
  94  */
  95 static int udb_config_add_string(char ***ret_array, /* {{{ */
  96                                  size_t *ret_array_len, oconfig_item_t *ci) {
  97   char **array;
  98   size_t array_len;
  99
 100   if (ci->values_num < 1) {
 101     P_WARNING("The `%s' config option "
 102               "needs at least one argument.",
 103               ci->key);
 104     return -1;
 105   }
 106
 107   for (int i = 0; i < ci->values_num; i++) {
 108     if (ci->values[i].type != OCONFIG_TYPE_STRING) {
 109       P_WARNING("Argument %i to the `%s' option "
 110                 "is not a string.",
 111                 i + 1, ci->key);
 112       return -1;
 113     }
 114   }
 115
 116   array_len = *ret_array_len;
 117   array = realloc(*ret_array, sizeof(char *) * (array_len + ci->values_num));
 118   if (array == NULL) {
 119     P_ERROR("udb_config_add_string: realloc failed.");
 120     return -1;
 121   }
 122   *ret_array = array;
 123
 124   for (int i = 0; i < ci->values_num; i++) {
 125     array[array_len] = strdup(ci->values[i].value.string);
 126     if (array[array_len] == NULL) {
 127       P_ERROR("udb_config_add_string: strdup failed.");
 128       *ret_array_len = array_len;
 129       return -1;
 130     }
 131     array_len++;
 132   }
 133
 134   *ret_array_len = array_len;
 135   return 0;
 136 } /* }}} int udb_config_add_string */
 137
 138 static int udb_config_set_uint(unsigned int *ret_value, /* {{{ */
 139                                oconfig_item_t *ci) {
 140
 141   if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_NUMBER)) {
 142     P_WARNING("The `%s' config option "
 143               "needs exactly one numeric argument.",
 144               ci->key);
 145     return -1;
 146   }
 147
 148   double tmp = ci->values[0].value.number;
 149   if ((tmp < 0.0) || (tmp > ((double)UINT_MAX))) {
 150     P_WARNING("The value given for the `%s` option is out of range.", ci->key);
 151     return -ERANGE;
 152   }
 153
 154   *ret_value = (unsigned int)(tmp + .5);
 155   return 0;
 156 } /* }}} int udb_config_set_uint */
 157
 158 /*
 159  * Result private functions
 160  */
 161 static int udb_result_submit(udb_result_t *r, /* {{{ */
 162                              udb_result_preparation_area_t *r_area,
 163                              udb_query_t const *q,
 164                              udb_query_preparation_area_t *q_area) {
 165   value_list_t vl = VALUE_LIST_INIT;
 166
 167   assert(r != NULL);
 168   assert(r_area->ds != NULL);
 169   assert(((size_t)r_area->ds->ds_num) == r->values_num);
 170   assert(r->values_num > 0);
 171
 172   vl.values = calloc(r->values_num, sizeof(*vl.values));
 173   if (vl.values == NULL) {
 174     P_ERROR("udb_result_submit: calloc failed.");
 175     return -1;
 176   }
 177   vl.values_len = r_area->ds->ds_num;
 178
 179   for (size_t i = 0; i < r->values_num; i++) {
 180     char *value_str = r_area->values_buffer[i];
 181
 182     if (0 != parse_value(value_str, &vl.values[i], r_area->ds->ds[i].type)) {
 183       P_ERROR("udb_result_submit: Parsing `%s' as %s failed.", value_str,
 184               DS_TYPE_TO_STRING(r_area->ds->ds[i].type));
 185       errno = EINVAL;
 186       free(vl.values);
 187       return -1;
 188     }
 189   }
 190
 191   if (q_area->interval > 0)
 192     vl.interval = q_area->interval;
 193
 194   sstrncpy(vl.host, q_area->host, sizeof(vl.host));
 195   sstrncpy(vl.plugin, q_area->plugin, sizeof(vl.plugin));
 196   sstrncpy(vl.type, r->type, sizeof(vl.type));
 197
 198   /* Set vl.plugin_instance */
 199   if (q->plugin_instance_from != NULL) {
 200     sstrncpy(vl.plugin_instance, r_area->plugin_instance,
 201              sizeof(vl.plugin_instance));
 202   } else {
 203     sstrncpy(vl.plugin_instance, q_area->db_name, sizeof(vl.plugin_instance));
 204   }
 205
 206   /* Set vl.type_instance {{{ */
 207   if (r->instances_num == 0) {
 208     if (r->instance_prefix == NULL)
 209       vl.type_instance[0] = 0;
 210     else
 211       sstrncpy(vl.type_instance, r->instance_prefix, sizeof(vl.type_instance));
 212   } else /* if ((r->instances_num > 0) */
 213   {
 214     if (r->instance_prefix == NULL) {
 215       int status = strjoin(vl.type_instance, sizeof(vl.type_instance),
 216                            r_area->instances_buffer, r->instances_num, "-");
 217       if (status < 0) {
 218         P_ERROR(
 219             "udb_result_submit: creating type_instance failed with status %d.",
 220             status);
 221         return status;
 222       }
 223     } else {
 224       char tmp[DATA_MAX_NAME_LEN];
 225
 226       int status = strjoin(tmp, sizeof(tmp), r_area->instances_buffer,
 227                            r->instances_num, "-");
 228       if (status < 0) {
 229         P_ERROR(
 230             "udb_result_submit: creating type_instance failed with status %d.",
 231             status);
 232         return status;
 233       }
 234       tmp[sizeof(tmp) - 1] = 0;
 235
 236       snprintf(vl.type_instance, sizeof(vl.type_instance), "%s-%s",
 237                r->instance_prefix, tmp);
 238     }
 239   }
 240   vl.type_instance[sizeof(vl.type_instance) - 1] = 0;
 241   /* }}} */
 242
 243   /* Annotate meta data. {{{ */
 244   if (r->metadata_num > 0) {
 245     vl.meta = meta_data_create();
 246     if (vl.meta == NULL) {
 247       P_ERROR("udb_result_submit: meta_data_create failed.");
 248       free(vl.values);
 249       return -ENOMEM;
 250     }
 251
 252     for (size_t i = 0; i < r->metadata_num; i++) {
 253       int status = meta_data_add_string(vl.meta, r->metadata[i],
 254                                         r_area->metadata_buffer[i]);
 255       if (status != 0) {
 256         P_ERROR("udb_result_submit: meta_data_add_string failed.");
 257         meta_data_destroy(vl.meta);
 258         vl.meta = NULL;
 259         free(vl.values);
 260         return status;
 261       }
 262     }
 263   }
 264   /* }}} */
 265
 266   plugin_dispatch_values(&vl);
 267
 268   if (r->metadata_num > 0) {
 269     meta_data_destroy(vl.meta);
 270     vl.meta = NULL;
 271   }
 272   sfree(vl.values);
 273   return 0;
 274 } /* }}} void udb_result_submit */
 275
 276 static void udb_result_finish_result(udb_result_t const *r, /* {{{ */
 277                                      udb_result_preparation_area_t *prep_area) {
 278   if ((r == NULL) || (prep_area == NULL))
 279     return;
 280
 281   prep_area->ds = NULL;
 282   sfree(prep_area->instances_pos);
 283   sfree(prep_area->values_pos);
 284   sfree(prep_area->metadata_pos);
 285   sfree(prep_area->instances_buffer);
 286   sfree(prep_area->values_buffer);
 287   sfree(prep_area->metadata_buffer);
 288 } /* }}} void udb_result_finish_result */
 289
 290 static int udb_result_handle_result(udb_result_t *r, /* {{{ */
 291                                     udb_query_preparation_area_t *q_area,
 292                                     udb_result_preparation_area_t *r_area,
 293                                     udb_query_t const *q,
 294                                     char **column_values) {
 295   assert(r && q_area && r_area);
 296
 297   for (size_t i = 0; i < r->instances_num; i++)
 298     r_area->instances_buffer[i] = column_values[r_area->instances_pos[i]];
 299
 300   for (size_t i = 0; i < r->values_num; i++)
 301     r_area->values_buffer[i] = column_values[r_area->values_pos[i]];
 302
 303   for (size_t i = 0; i < r->metadata_num; i++)
 304     r_area->metadata_buffer[i] = column_values[r_area->metadata_pos[i]];
 305
 306   if (q->plugin_instance_from)
 307     r_area->plugin_instance = column_values[q_area->plugin_instance_pos];
 308
 309   return udb_result_submit(r, r_area, q, q_area);
 310 } /* }}} int udb_result_handle_result */
 311
 312 static int udb_result_prepare_result(udb_result_t const *r, /* {{{ */
 313                                      udb_result_preparation_area_t *prep_area,
 314                                      char **column_names, size_t column_num) {
 315   if ((r == NULL) || (prep_area == NULL))
 316     return -EINVAL;
 317
 318 #if COLLECT_DEBUG
 319   assert(prep_area->ds == NULL);
 320   assert(prep_area->instances_pos == NULL);
 321   assert(prep_area->values_pos == NULL);
 322   assert(prep_area->metadata_pos == NULL);
 323   assert(prep_area->instances_buffer == NULL);
 324   assert(prep_area->values_buffer == NULL);
 325   assert(prep_area->metadata_buffer == NULL);
 326 #endif
 327
 328 #define BAIL_OUT(status)                                                       \
 329   udb_result_finish_result(r, prep_area);                                      \
 330   return (status)
 331
 332   /* Read `ds' and check number of values {{{ */
 333   prep_area->ds = plugin_get_ds(r->type);
 334   if (prep_area->ds == NULL) {
 335     P_ERROR("udb_result_prepare_result: Type `%s' is not "
 336             "known by the daemon. See types.db(5) for details.",
 337             r->type);
 338     BAIL_OUT(-1);
 339   }
 340
 341   if (prep_area->ds->ds_num != r->values_num) {
 342     P_ERROR("udb_result_prepare_result: The type `%s' "
 343             "requires exactly %" PRIsz
 344             " value%s, but the configuration specifies %" PRIsz ".",
 345             r->type, prep_area->ds->ds_num,
 346             (prep_area->ds->ds_num == 1) ? "" : "s", r->values_num);
 347     BAIL_OUT(-1);
 348   }
 349   /* }}} */
 350
 351   /* Allocate r->instances_pos, r->values_pos, r->metadata_post,
 352    * r->instances_buffer, r->values_buffer, and r->metadata_buffer {{{ */
 353   if (r->instances_num > 0) {
 354     prep_area->instances_pos =
 355         (size_t *)calloc(r->instances_num, sizeof(size_t));
 356     if (prep_area->instances_pos == NULL) {
 357       P_ERROR("udb_result_prepare_result: calloc failed.");
 358       BAIL_OUT(-ENOMEM);
 359     }
 360
 361     prep_area->instances_buffer =
 362         (char **)calloc(r->instances_num, sizeof(char *));
 363     if (prep_area->instances_buffer == NULL) {
 364       P_ERROR("udb_result_prepare_result: calloc failed.");
 365       BAIL_OUT(-ENOMEM);
 366     }
 367   } /* if (r->instances_num > 0) */
 368
 369   prep_area->values_pos = (size_t *)calloc(r->values_num, sizeof(size_t));
 370   if (prep_area->values_pos == NULL) {
 371     P_ERROR("udb_result_prepare_result: calloc failed.");
 372     BAIL_OUT(-ENOMEM);
 373   }
 374
 375   prep_area->values_buffer = (char **)calloc(r->values_num, sizeof(char *));
 376   if (prep_area->values_buffer == NULL) {
 377     P_ERROR("udb_result_prepare_result: calloc failed.");
 378     BAIL_OUT(-ENOMEM);
 379   }
 380
 381   prep_area->metadata_pos = (size_t *)calloc(r->metadata_num, sizeof(size_t));
 382   if (prep_area->metadata_pos == NULL) {
 383     P_ERROR("udb_result_prepare_result: calloc failed.");
 384     BAIL_OUT(-ENOMEM);
 385   }
 386
 387   prep_area->metadata_buffer = (char **)calloc(r->metadata_num, sizeof(char *));
 388   if (prep_area->metadata_buffer == NULL) {
 389     P_ERROR("udb_result_prepare_result: calloc failed.");
 390     BAIL_OUT(-ENOMEM);
 391   }
 392
 393   /* }}} */
 394
 395   /* Determine the position of the plugin instance column {{{ */
 396   for (size_t i = 0; i < r->instances_num; i++) {
 397     size_t j;
 398
 399     for (j = 0; j < column_num; j++) {
 400       if (strcasecmp(r->instances[i], column_names[j]) == 0) {
 401         prep_area->instances_pos[i] = j;
 402         break;
 403       }
 404     }
 405
 406     if (j >= column_num) {
 407       P_ERROR("udb_result_prepare_result: "
 408               "Column `%s' could not be found.",
 409               r->instances[i]);
 410       BAIL_OUT(-ENOENT);
 411     }
 412   } /* }}} for (i = 0; i < r->instances_num; i++) */
 413
 414   /* Determine the position of the value columns {{{ */
 415   for (size_t i = 0; i < r->values_num; i++) {
 416     size_t j;
 417
 418     for (j = 0; j < column_num; j++) {
 419       if (strcasecmp(r->values[i], column_names[j]) == 0) {
 420         prep_area->values_pos[i] = j;
 421         break;
 422       }
 423     }
 424
 425     if (j >= column_num) {
 426       P_ERROR("udb_result_prepare_result: "
 427               "Column `%s' could not be found.",
 428               r->values[i]);
 429       BAIL_OUT(-ENOENT);
 430     }
 431   } /* }}} for (i = 0; i < r->values_num; i++) */
 432
 433   /* Determine the position of the metadata columns {{{ */
 434   for (size_t i = 0; i < r->metadata_num; i++) {
 435     size_t j;
 436
 437     for (j = 0; j < column_num; j++) {
 438       if (strcasecmp(r->metadata[i], column_names[j]) == 0) {
 439         prep_area->metadata_pos[i] = j;
 440         break;
 441       }
 442     }
 443
 444     if (j >= column_num) {
 445       P_ERROR("udb_result_prepare_result: "
 446               "Metadata column `%s' could not be found.",
 447               r->values[i]);
 448       BAIL_OUT(-ENOENT);
 449     }
 450   } /* }}} for (i = 0; i < r->metadata_num; i++) */
 451
 452 #undef BAIL_OUT
 453   return 0;
 454 } /* }}} int udb_result_prepare_result */
 455
 456 static void udb_result_free(udb_result_t *r) /* {{{ */
 457 {
 458   if (r == NULL)
 459     return;
 460
 461   sfree(r->type);
 462   sfree(r->instance_prefix);
 463
 464   for (size_t i = 0; i < r->instances_num; i++)
 465     sfree(r->instances[i]);
 466   sfree(r->instances);
 467
 468   for (size_t i = 0; i < r->values_num; i++)
 469     sfree(r->values[i]);
 470   sfree(r->values);
 471
 472   for (size_t i = 0; i < r->metadata_num; i++)
 473     sfree(r->metadata[i]);
 474   sfree(r->metadata);
 475
 476   udb_result_free(r->next);
 477
 478   sfree(r);
 479 } /* }}} void udb_result_free */
 480
 481 static int udb_result_create(const char *query_name, /* {{{ */
 482                              udb_result_t **r_head, oconfig_item_t *ci) {
 483   udb_result_t *r;
 484   int status;
 485
 486   if (ci->values_num != 0) {
 487     P_WARNING("The `Result' block doesn't accept "
 488               "any arguments. Ignoring %i argument%s.",
 489               ci->values_num, (ci->values_num == 1) ? "" : "s");
 490   }
 491
 492   r = calloc(1, sizeof(*r));
 493   if (r == NULL) {
 494     P_ERROR("udb_result_create: calloc failed.");
 495     return -1;
 496   }
 497   r->type = NULL;
 498   r->instance_prefix = NULL;
 499   r->instances = NULL;
 500   r->values = NULL;
 501   r->metadata = NULL;
 502   r->next = NULL;
 503
 504   /* Fill the `udb_result_t' structure.. */
 505   status = 0;
 506   for (int i = 0; i < ci->children_num; i++) {
 507     oconfig_item_t *child = ci->children + i;
 508
 509     if (strcasecmp("Type", child->key) == 0)
 510       status = cf_util_get_string(child, &r->type);
 511     else if (strcasecmp("InstancePrefix", child->key) == 0)
 512       status = cf_util_get_string(child, &r->instance_prefix);
 513     else if (strcasecmp("InstancesFrom", child->key) == 0)
 514       status = udb_config_add_string(&r->instances, &r->instances_num, child);
 515     else if (strcasecmp("ValuesFrom", child->key) == 0)
 516       status = udb_config_add_string(&r->values, &r->values_num, child);
 517     else if (strcasecmp("MetadataFrom", child->key) == 0)
 518       status = udb_config_add_string(&r->metadata, &r->metadata_num, child);
 519     else {
 520       P_WARNING("Query `%s': Option `%s' not allowed here.", query_name,
 521                 child->key);
 522       status = -1;
 523     }
 524
 525     if (status != 0)
 526       break;
 527   }
 528
 529   /* Check that all necessary options have been given. */
 530   while (status == 0) {
 531     if (r->type == NULL) {
 532       P_WARNING("udb_result_create: `Type' not given for "
 533                 "result in query `%s'",
 534                 query_name);
 535       status = -1;
 536     }
 537     if (r->values == NULL) {
 538       P_WARNING("udb_result_create: `ValuesFrom' not given for "
 539                 "result in query `%s'",
 540                 query_name);
 541       status = -1;
 542     }
 543
 544     break;
 545   } /* while (status == 0) */
 546
 547   if (status != 0) {
 548     udb_result_free(r);
 549     return -1;
 550   }
 551
 552   /* If all went well, add this result to the list of results. */
 553   if (*r_head == NULL) {
 554     *r_head = r;
 555   } else {
 556     udb_result_t *last;
 557
 558     last = *r_head;
 559     while (last->next != NULL)
 560       last = last->next;
 561
 562     last->next = r;
 563   }
 564
 565   return 0;
 566 } /* }}} int udb_result_create */
 567
 568 /*
 569  * Query private functions
 570  */
 571 static void udb_query_free_one(udb_query_t *q) /* {{{ */
 572 {
 573   if (q == NULL)
 574     return;
 575
 576   sfree(q->name);
 577   sfree(q->statement);
 578   sfree(q->plugin_instance_from);
 579
 580   udb_result_free(q->results);
 581
 582   sfree(q);
 583 } /* }}} void udb_query_free_one */
 584
 585 /*
 586  * Query public functions
 587  */
 588 int udb_query_create(udb_query_t ***ret_query_list, /* {{{ */
 589                      size_t *ret_query_list_len, oconfig_item_t *ci,
 590                      udb_query_create_callback_t cb) {
 591   udb_query_t **query_list;
 592   size_t query_list_len;
 593
 594   udb_query_t *q;
 595   int status;
 596
 597   if ((ret_query_list == NULL) || (ret_query_list_len == NULL))
 598     return -EINVAL;
 599   query_list = *ret_query_list;
 600   query_list_len = *ret_query_list_len;
 601
 602   if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
 603     P_WARNING("udb_result_create: The `Query' block "
 604               "needs exactly one string argument.");
 605     return -1;
 606   }
 607
 608   q = calloc(1, sizeof(*q));
 609   if (q == NULL) {
 610     P_ERROR("udb_query_create: calloc failed.");
 611     return -1;
 612   }
 613   q->min_version = 0;
 614   q->max_version = UINT_MAX;
 615   q->statement = NULL;
 616   q->results = NULL;
 617   q->plugin_instance_from = NULL;
 618
 619   status = cf_util_get_string(ci, &q->name);
 620   if (status != 0) {
 621     sfree(q);
 622     return status;
 623   }
 624
 625   /* Fill the `udb_query_t' structure.. */
 626   for (int i = 0; i < ci->children_num; i++) {
 627     oconfig_item_t *child = ci->children + i;
 628
 629     if (strcasecmp("Statement", child->key) == 0)
 630       status = cf_util_get_string(child, &q->statement);
 631     else if (strcasecmp("Result", child->key) == 0)
 632       status = udb_result_create(q->name, &q->results, child);
 633     else if (strcasecmp("MinVersion", child->key) == 0)
 634       status = udb_config_set_uint(&q->min_version, child);
 635     else if (strcasecmp("MaxVersion", child->key) == 0)
 636       status = udb_config_set_uint(&q->max_version, child);
 637     else if (strcasecmp("PluginInstanceFrom", child->key) == 0)
 638       status = cf_util_get_string(child, &q->plugin_instance_from);
 639
 640     /* Call custom callbacks */
 641     else if (cb != NULL) {
 642       status = (*cb)(q, child);
 643       if (status != 0) {
 644         P_WARNING("The configuration callback failed "
 645                   "to handle `%s'.",
 646                   child->key);
 647       }
 648     } else {
 649       P_WARNING("Query `%s': Option `%s' not allowed here.", q->name,
 650                 child->key);
 651       status = -1;
 652     }
 653
 654     if (status != 0)
 655       break;
 656   }
 657
 658   /* Check that all necessary options have been given. */
 659   if (status == 0) {
 660     if (q->statement == NULL) {
 661       P_WARNING("Query `%s': No `Statement' given.", q->name);
 662       status = -1;
 663     }
 664     if (q->results == NULL) {
 665       P_WARNING("Query `%s': No (valid) `Result' block given.", q->name);
 666       status = -1;
 667     }
 668   } /* if (status == 0) */
 669
 670   /* If all went well, add this query to the list of queries within the
 671    * database structure. */
 672   if (status == 0) {
 673     udb_query_t **temp;
 674
 675     temp = realloc(query_list, sizeof(*query_list) * (query_list_len + 1));
 676     if (temp == NULL) {
 677       P_ERROR("udb_query_create: realloc failed");
 678       status = -1;
 679     } else {
 680       query_list = temp;
 681       query_list[query_list_len] = q;
 682       query_list_len++;
 683     }
 684   }
 685
 686   if (status != 0) {
 687     udb_query_free_one(q);
 688     return -1;
 689   }
 690
 691   *ret_query_list = query_list;
 692   *ret_query_list_len = query_list_len;
 693
 694   return 0;
 695 } /* }}} int udb_query_create */
 696
 697 void udb_query_free(udb_query_t **query_list, size_t query_list_len) /* {{{ */
 698 {
 699   if (query_list == NULL)
 700     return;
 701
 702   for (size_t i = 0; i < query_list_len; i++)
 703     udb_query_free_one(query_list[i]);
 704
 705   sfree(query_list);
 706 } /* }}} void udb_query_free */
 707
 708 int udb_query_pick_from_list_by_name(const char *name, /* {{{ */
 709                                      udb_query_t **src_list,
 710                                      size_t src_list_len,
 711                                      udb_query_t ***dst_list,
 712                                      size_t *dst_list_len) {
 713   int num_added;
 714
 715   if ((name == NULL) || (src_list == NULL) || (dst_list == NULL) ||
 716       (dst_list_len == NULL)) {
 717     P_ERROR("udb_query_pick_from_list_by_name: "
 718             "Invalid argument.");
 719     return -EINVAL;
 720   }
 721
 722   num_added = 0;
 723   for (size_t i = 0; i < src_list_len; i++) {
 724     udb_query_t **tmp_list;
 725     size_t tmp_list_len;
 726
 727     if (strcasecmp(name, src_list[i]->name) != 0)
 728       continue;
 729
 730     tmp_list_len = *dst_list_len;
 731     tmp_list = realloc(*dst_list, (tmp_list_len + 1) * sizeof(udb_query_t *));
 732     if (tmp_list == NULL) {
 733       P_ERROR("udb_query_pick_from_list_by_name: realloc failed.");
 734       return -ENOMEM;
 735     }
 736
 737     tmp_list[tmp_list_len] = src_list[i];
 738     tmp_list_len++;
 739
 740     *dst_list = tmp_list;
 741     *dst_list_len = tmp_list_len;
 742
 743     num_added++;
 744   } /* for (i = 0; i < src_list_len; i++) */
 745
 746   if (num_added <= 0) {
 747     P_ERROR("Cannot find query `%s'. Make sure the <Query> "
 748             "block is above the database definition!",
 749             name);
 750     return -ENOENT;
 751   } else {
 752     DEBUG("Added %i versions of query `%s'.", num_added, name);
 753   }
 754
 755   return 0;
 756 } /* }}} int udb_query_pick_from_list_by_name */
 757
 758 int udb_query_pick_from_list(oconfig_item_t *ci, /* {{{ */
 759                              udb_query_t **src_list, size_t src_list_len,
 760                              udb_query_t ***dst_list, size_t *dst_list_len) {
 761   const char *name;
 762
 763   if ((ci == NULL) || (src_list == NULL) || (dst_list == NULL) ||
 764       (dst_list_len == NULL)) {
 765     P_ERROR("udb_query_pick_from_list: "
 766             "Invalid argument.");
 767     return -EINVAL;
 768   }
 769
 770   if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
 771     P_ERROR("The `%s' config option "
 772             "needs exactly one string argument.",
 773             ci->key);
 774     return -1;
 775   }
 776   name = ci->values[0].value.string;
 777
 778   return udb_query_pick_from_list_by_name(name, src_list, src_list_len,
 779                                           dst_list, dst_list_len);
 780 } /* }}} int udb_query_pick_from_list */
 781
 782 const char *udb_query_get_name(udb_query_t *q) /* {{{ */
 783 {
 784   if (q == NULL)
 785     return NULL;
 786
 787   return q->name;
 788 } /* }}} const char *udb_query_get_name */
 789
 790 const char *udb_query_get_statement(udb_query_t *q) /* {{{ */
 791 {
 792   if (q == NULL)
 793     return NULL;
 794
 795   return q->statement;
 796 } /* }}} const char *udb_query_get_statement */
 797
 798 void udb_query_set_user_data(udb_query_t *q, void *user_data) /* {{{ */
 799 {
 800   if (q == NULL)
 801     return;
 802
 803   q->user_data = user_data;
 804 } /* }}} void udb_query_set_user_data */
 805
 806 void *udb_query_get_user_data(udb_query_t *q) /* {{{ */
 807 {
 808   if (q == NULL)
 809     return NULL;
 810
 811   return q->user_data;
 812 } /* }}} void *udb_query_get_user_data */
 813
 814 int udb_query_check_version(udb_query_t *q, unsigned int version) /* {{{ */
 815 {
 816   if (q == NULL)
 817     return -EINVAL;
 818
 819   if ((version < q->min_version) || (version > q->max_version))
 820     return 0;
 821
 822   return 1;
 823 } /* }}} int udb_query_check_version */
 824
 825 void udb_query_finish_result(udb_query_t const *q, /* {{{ */
 826                              udb_query_preparation_area_t *prep_area) {
 827   udb_result_preparation_area_t *r_area;
 828   udb_result_t *r;
 829
 830   if ((q == NULL) || (prep_area == NULL))
 831     return;
 832
 833   prep_area->column_num = 0;
 834   sfree(prep_area->host);
 835   sfree(prep_area->plugin);
 836   sfree(prep_area->db_name);
 837
 838   prep_area->interval = 0;
 839
 840   for (r = q->results, r_area = prep_area->result_prep_areas; r != NULL;
 841        r = r->next, r_area = r_area->next) {
 842     /* this may happen during error conditions of the caller */
 843     if (r_area == NULL)
 844       break;
 845     udb_result_finish_result(r, r_area);
 846   }
 847 } /* }}} void udb_query_finish_result */
 848
 849 int udb_query_handle_result(udb_query_t const *q, /* {{{ */
 850                             udb_query_preparation_area_t *prep_area,
 851                             char **column_values) {
 852   udb_result_preparation_area_t *r_area;
 853   udb_result_t *r;
 854   int success;
 855   int status;
 856
 857   if ((q == NULL) || (prep_area == NULL))
 858     return -EINVAL;
 859
 860   if ((prep_area->column_num < 1) || (prep_area->host == NULL) ||
 861       (prep_area->plugin == NULL) || (prep_area->db_name == NULL)) {
 862     P_ERROR("Query `%s': Query is not prepared; "
 863             "can't handle result.",
 864             q->name);
 865     return -EINVAL;
 866   }
 867
 868 #if defined(COLLECT_DEBUG) && COLLECT_DEBUG /* {{{ */
 869   do {
 870     for (size_t i = 0; i < prep_area->column_num; i++) {
 871       DEBUG("udb_query_handle_result (%s, %s): "
 872             "column[%" PRIsz "] = %s;",
 873             prep_area->db_name, q->name, i, column_values[i]);
 874     }
 875   } while (0);
 876 #endif /* }}} */
 877
 878   success = 0;
 879   for (r = q->results, r_area = prep_area->result_prep_areas; r != NULL;
 880        r = r->next, r_area = r_area->next) {
 881     status = udb_result_handle_result(r, prep_area, r_area, q, column_values);
 882     if (status == 0)
 883       success++;
 884   }
 885
 886   if (success == 0) {
 887     P_ERROR("udb_query_handle_result (%s, %s): "
 888             "All results failed.",
 889             prep_area->db_name, q->name);
 890     return -1;
 891   }
 892
 893   return 0;
 894 } /* }}} int udb_query_handle_result */
 895
 896 int udb_query_prepare_result(udb_query_t const *q, /* {{{ */
 897                              udb_query_preparation_area_t *prep_area,
 898                              const char *host, const char *plugin,
 899                              const char *db_name, char **column_names,
 900                              size_t column_num, cdtime_t interval) {
 901   udb_result_preparation_area_t *r_area;
 902   udb_result_t *r;
 903   int status;
 904
 905   if ((q == NULL) || (prep_area == NULL))
 906     return -EINVAL;
 907
 908 #if COLLECT_DEBUG
 909   assert(prep_area->column_num == 0);
 910   assert(prep_area->host == NULL);
 911   assert(prep_area->plugin == NULL);
 912   assert(prep_area->db_name == NULL);
 913   assert(prep_area->interval == 0);
 914 #endif
 915
 916   prep_area->column_num = column_num;
 917   prep_area->host = strdup(host);
 918   prep_area->plugin = strdup(plugin);
 919   prep_area->db_name = strdup(db_name);
 920
 921   prep_area->interval = interval;
 922
 923   if ((prep_area->host == NULL) || (prep_area->plugin == NULL) ||
 924       (prep_area->db_name == NULL)) {
 925     P_ERROR("Query `%s': Prepare failed: Out of memory.", q->name);
 926     udb_query_finish_result(q, prep_area);
 927     return -ENOMEM;
 928   }
 929
 930 #if defined(COLLECT_DEBUG) && COLLECT_DEBUG
 931   do {
 932     for (size_t i = 0; i < column_num; i++) {
 933       DEBUG("udb_query_prepare_result: "
 934             "query = %s; column[%" PRIsz "] = %s;",
 935             q->name, i, column_names[i]);
 936     }
 937   } while (0);
 938 #endif
 939
 940   /* Determine the position of the PluginInstance column {{{ */
 941   if (q->plugin_instance_from != NULL) {
 942     size_t i;
 943
 944     for (i = 0; i < column_num; i++) {
 945       if (strcasecmp(q->plugin_instance_from, column_names[i]) == 0) {
 946         prep_area->plugin_instance_pos = i;
 947         break;
 948       }
 949     }
 950
 951     if (i >= column_num) {
 952       P_ERROR("udb_query_prepare_result: "
 953               "Column `%s' from `PluginInstanceFrom' could not be found.",
 954               q->plugin_instance_from);
 955       udb_query_finish_result(q, prep_area);
 956       return -ENOENT;
 957     }
 958   }
 959   /* }}} */
 960
 961   for (r = q->results, r_area = prep_area->result_prep_areas; r != NULL;
 962        r = r->next, r_area = r_area->next) {
 963     if (!r_area) {
 964       P_ERROR("Query `%s': Invalid number of result "
 965               "preparation areas.",
 966               q->name);
 967       udb_query_finish_result(q, prep_area);
 968       return -EINVAL;
 969     }
 970
 971     status = udb_result_prepare_result(r, r_area, column_names, column_num);
 972     if (status != 0) {
 973       udb_query_finish_result(q, prep_area);
 974       return status;
 975     }
 976   }
 977
 978   return 0;
 979 } /* }}} int udb_query_prepare_result */
 980
 981 udb_query_preparation_area_t *
 982 udb_query_allocate_preparation_area(udb_query_t *q) /* {{{ */
 983 {
 984   udb_query_preparation_area_t *q_area;
 985   udb_result_preparation_area_t **next_r_area;
 986   udb_result_t *r;
 987
 988   q_area = calloc(1, sizeof(*q_area));
 989   if (q_area == NULL)
 990     return NULL;
 991
 992   next_r_area = &q_area->result_prep_areas;
 993   for (r = q->results; r != NULL; r = r->next) {
 994     udb_result_preparation_area_t *r_area;
 995
 996     r_area = calloc(1, sizeof(*r_area));
 997     if (r_area == NULL) {
 998       udb_result_preparation_area_t *a = q_area->result_prep_areas;
 999
1000       while (a != NULL) {
1001         udb_result_preparation_area_t *next = a->next;
1002         sfree(a);
1003         a = next;
1004       }
1005
1006       free(q_area);
1007       return NULL;
1008     }
1009
1010     *next_r_area = r_area;
1011     next_r_area = &r_area->next;
1012   }
1013
1014   return q_area;
1015 } /* }}} udb_query_preparation_area_t *udb_query_allocate_preparation_area */
1016
1017 void udb_query_delete_preparation_area(
1018     udb_query_preparation_area_t *q_area) /* {{{ */
1019 {
1020   udb_result_preparation_area_t *r_area;
1021
1022   if (q_area == NULL)
1023     return;
1024
1025   r_area = q_area->result_prep_areas;
1026   while (r_area != NULL) {
1027     udb_result_preparation_area_t *area = r_area;
1028
1029     r_area = r_area->next;
1030
1031     sfree(area->instances_pos);
1032     sfree(area->values_pos);
1033     sfree(area->instances_buffer);
1034     sfree(area->values_buffer);
1035     free(area);
1036   }
1037
1038   sfree(q_area->host);
1039   sfree(q_area->plugin);
1040   sfree(q_area->db_name);
1041
1042   free(q_area);
1043 } /* }}} void udb_query_delete_preparation_area */