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