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