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