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