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