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   char *plugin_instance_from;
  58
  59   unsigned int min_version;
  60   unsigned int max_version;
  61
  62   udb_result_t *results;
  63 }; /* }}} */
  64
  65 struct udb_result_preparation_area_s /* {{{ */
  66 {
  67   const   data_set_t *ds;
  68   size_t *instances_pos;
  69   size_t *values_pos;
  70   size_t *metadata_pos;
  71   char  **instances_buffer;
  72   char  **values_buffer;
  73   char  **metadata_buffer;
  74   char   *plugin_instance;
  75
  76   struct udb_result_preparation_area_s *next;
  77 }; /* }}} */
  78 typedef struct udb_result_preparation_area_s udb_result_preparation_area_t;
  79
  80 struct udb_query_preparation_area_s /* {{{ */
  81 {
  82   size_t column_num;
  83   size_t plugin_instance_pos;
  84   char *host;
  85   char *plugin;
  86   char *db_name;
  87
  88   cdtime_t interval;
  89
  90   udb_result_preparation_area_t *result_prep_areas;
  91 }; /* }}} */
  92
  93 /*
  94  * Config Private functions
  95  */
  96 static int udb_config_set_string (char **ret_string, /* {{{ */
  97     oconfig_item_t *ci)
  98 {
  99   char *string;
 100
 101   if ((ci->values_num != 1)
 102       || (ci->values[0].type != OCONFIG_TYPE_STRING))
 103   {
 104     WARNING ("db query utils: The `%s' config option "
 105         "needs exactly one string argument.", ci->key);
 106     return (-1);
 107   }
 108
 109   string = strdup (ci->values[0].value.string);
 110   if (string == NULL)
 111   {
 112     ERROR ("db query utils: strdup failed.");
 113     return (-1);
 114   }
 115
 116   if (*ret_string != NULL)
 117     free (*ret_string);
 118   *ret_string = string;
 119
 120   return (0);
 121 } /* }}} int udb_config_set_string */
 122
 123 static int udb_config_add_string (char ***ret_array, /* {{{ */
 124     size_t *ret_array_len, oconfig_item_t *ci)
 125 {
 126   char **array;
 127   size_t array_len;
 128   int i;
 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 (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 (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   size_t i;
 203   int status;
 204
 205   assert (r != NULL);
 206   assert (r_area->ds != NULL);
 207   assert (((size_t) r_area->ds->ds_num) == r->values_num);
 208   assert (r->values_num > 0);
 209
 210   vl.values = calloc (r->values_num, sizeof (*vl.values));
 211   if (vl.values == NULL)
 212   {
 213     ERROR ("db query utils: calloc failed.");
 214     return (-1);
 215   }
 216   vl.values_len = r_area->ds->ds_num;
 217
 218   for (i = 0; i < r->values_num; i++)
 219   {
 220     char *value_str = r_area->values_buffer[i];
 221
 222     if (0 != parse_value (value_str, &vl.values[i], r_area->ds->ds[i].type))
 223     {
 224       ERROR ("db query utils: udb_result_submit: Parsing `%s' as %s failed.",
 225           value_str, DS_TYPE_TO_STRING (r_area->ds->ds[i].type));
 226       errno = EINVAL;
 227       free (vl.values);
 228       return (-1);
 229     }
 230   }
 231
 232   if (q_area->interval > 0)
 233     vl.interval = q_area->interval;
 234
 235   sstrncpy (vl.host, q_area->host, sizeof (vl.host));
 236   sstrncpy (vl.plugin, q_area->plugin, sizeof (vl.plugin));
 237   sstrncpy (vl.type, r->type, sizeof (vl.type));
 238
 239   /* Set vl.plugin_instance */
 240   if (q->plugin_instance_from != NULL) {
 241     sstrncpy (vl.plugin_instance, r_area->plugin_instance, sizeof (vl.plugin_instance));
 242   }
 243   else {
 244     sstrncpy (vl.plugin_instance, q_area->db_name, sizeof (vl.plugin_instance));
 245   }
 246
 247   /* Set vl.type_instance {{{ */
 248   if (r->instances_num == 0)
 249   {
 250     if (r->instance_prefix == NULL)
 251       vl.type_instance[0] = 0;
 252     else
 253       sstrncpy (vl.type_instance, r->instance_prefix,
 254           sizeof (vl.type_instance));
 255   }
 256   else /* if ((r->instances_num > 0) */
 257   {
 258     if (r->instance_prefix == NULL)
 259     {
 260       strjoin (vl.type_instance, sizeof (vl.type_instance),
 261           r_area->instances_buffer, r->instances_num, "-");
 262     }
 263     else
 264     {
 265       char tmp[DATA_MAX_NAME_LEN];
 266
 267       strjoin (tmp, sizeof (tmp), r_area->instances_buffer,
 268           r->instances_num, "-");
 269       tmp[sizeof (tmp) - 1] = 0;
 270
 271       snprintf (vl.type_instance, sizeof (vl.type_instance), "%s-%s",
 272           r->instance_prefix, tmp);
 273     }
 274   }
 275   vl.type_instance[sizeof (vl.type_instance) - 1] = 0;
 276   /* }}} */
 277
 278   /* Annotate meta data. {{{ */
 279   if (r->metadata_num > 0)
 280   {
 281     vl.meta = meta_data_create ();
 282     if (vl.meta == NULL)
 283     {
 284       ERROR ("db query utils:: meta_data_create failed.");
 285       return (-ENOMEM);
 286     }
 287
 288     for (i = 0; i < r->metadata_num; i++)
 289     {
 290       status = meta_data_add_string (vl.meta, r->metadata[i],
 291           r_area->metadata_buffer[i]);
 292       if (status != 0)
 293       {
 294         ERROR ("db query utils:: meta_data_add_string failed.");
 295         meta_data_destroy (vl.meta);
 296         vl.meta = NULL;
 297         return (status);
 298       }
 299     }
 300   }
 301   /* }}} */
 302
 303   plugin_dispatch_values (&vl);
 304
 305   if (r->metadata_num > 0)
 306   {
 307     meta_data_destroy (vl.meta);
 308     vl.meta = NULL;
 309   }
 310   sfree (vl.values);
 311   return (0);
 312 } /* }}} void udb_result_submit */
 313
 314 static void udb_result_finish_result (udb_result_t const *r, /* {{{ */
 315     udb_result_preparation_area_t *prep_area)
 316 {
 317   if ((r == NULL) || (prep_area == NULL))
 318     return;
 319
 320   prep_area->ds = NULL;
 321   sfree (prep_area->instances_pos);
 322   sfree (prep_area->values_pos);
 323   sfree (prep_area->metadata_pos);
 324   sfree (prep_area->instances_buffer);
 325   sfree (prep_area->values_buffer);
 326   sfree (prep_area->metadata_buffer);
 327 } /* }}} void udb_result_finish_result */
 328
 329 static int udb_result_handle_result (udb_result_t *r, /* {{{ */
 330     udb_query_preparation_area_t *q_area,
 331     udb_result_preparation_area_t *r_area,
 332     udb_query_t const *q, char **column_values)
 333 {
 334   size_t i;
 335
 336   assert (r && q_area && r_area);
 337
 338   for (i = 0; i < r->instances_num; i++)
 339     r_area->instances_buffer[i] = column_values[r_area->instances_pos[i]];
 340
 341   for (i = 0; i < r->values_num; i++)
 342     r_area->values_buffer[i] = column_values[r_area->values_pos[i]];
 343
 344   for (i = 0; i < r->metadata_num; i++)
 345     r_area->metadata_buffer[i] = column_values[r_area->metadata_pos[i]];
 346
 347   if (q->plugin_instance_from)
 348     r_area->plugin_instance = column_values[q_area->plugin_instance_pos];
 349
 350   return udb_result_submit (r, r_area, q, q_area);
 351 } /* }}} int udb_result_handle_result */
 352
 353 static int udb_result_prepare_result (udb_result_t const *r, /* {{{ */
 354     udb_result_preparation_area_t *prep_area,
 355     char **column_names, size_t column_num)
 356 {
 357   size_t i;
 358
 359   if ((r == NULL) || (prep_area == NULL))
 360     return (-EINVAL);
 361
 362 #define BAIL_OUT(status) \
 363   prep_area->ds = NULL; \
 364   sfree (prep_area->instances_pos); \
 365   sfree (prep_area->values_pos); \
 366   sfree (prep_area->metadata_pos); \
 367   sfree (prep_area->instances_buffer); \
 368   sfree (prep_area->values_buffer); \
 369   sfree (prep_area->metadata_buffer); \
 370   return (status)
 371
 372   /* Make sure previous preparations are cleaned up. */
 373   udb_result_finish_result (r, prep_area);
 374   prep_area->instances_pos = NULL;
 375   prep_area->values_pos = NULL;
 376   prep_area->metadata_pos = NULL;
 377
 378   /* Read `ds' and check number of values {{{ */
 379   prep_area->ds = plugin_get_ds (r->type);
 380   if (prep_area->ds == NULL)
 381   {
 382     ERROR ("db query utils: udb_result_prepare_result: Type `%s' is not "
 383         "known by the daemon. See types.db(5) for details.",
 384         r->type);
 385     BAIL_OUT (-1);
 386   }
 387
 388   if (prep_area->ds->ds_num != r->values_num)
 389   {
 390     ERROR ("db query utils: udb_result_prepare_result: The type `%s' "
 391         "requires exactly %zu value%s, but the configuration specifies %zu.",
 392         r->type,
 393         prep_area->ds->ds_num, (prep_area->ds->ds_num == 1) ? "" : "s",
 394         r->values_num);
 395     BAIL_OUT (-1);
 396   }
 397   /* }}} */
 398
 399   /* Allocate r->instances_pos, r->values_pos, r->metadata_post,
 400    * r->instances_buffer, r->values_buffer, and r->metadata_buffer {{{ */
 401   if (r->instances_num > 0)
 402   {
 403     prep_area->instances_pos
 404       = (size_t *) calloc (r->instances_num, sizeof (size_t));
 405     if (prep_area->instances_pos == NULL)
 406     {
 407       ERROR ("db query utils: udb_result_prepare_result: calloc failed.");
 408       BAIL_OUT (-ENOMEM);
 409     }
 410
 411     prep_area->instances_buffer
 412       = (char **) calloc (r->instances_num, sizeof (char *));
 413     if (prep_area->instances_buffer == NULL)
 414     {
 415       ERROR ("db query utils: udb_result_prepare_result: calloc failed.");
 416       BAIL_OUT (-ENOMEM);
 417     }
 418   } /* if (r->instances_num > 0) */
 419
 420   prep_area->values_pos
 421     = (size_t *) calloc (r->values_num, sizeof (size_t));
 422   if (prep_area->values_pos == NULL)
 423   {
 424     ERROR ("db query utils: udb_result_prepare_result: calloc failed.");
 425     BAIL_OUT (-ENOMEM);
 426   }
 427
 428   prep_area->values_buffer
 429     = (char **) calloc (r->values_num, sizeof (char *));
 430   if (prep_area->values_buffer == NULL)
 431   {
 432     ERROR ("db query utils: udb_result_prepare_result: calloc failed.");
 433     BAIL_OUT (-ENOMEM);
 434   }
 435
 436   prep_area->metadata_pos
 437     = (size_t *) calloc (r->metadata_num, sizeof (size_t));
 438   if (prep_area->metadata_pos == NULL)
 439   {
 440     ERROR ("db query utils: udb_result_prepare_result: calloc failed.");
 441     BAIL_OUT (-ENOMEM);
 442   }
 443
 444   prep_area->metadata_buffer
 445     = (char **) calloc (r->metadata_num, sizeof (char *));
 446   if (prep_area->metadata_buffer == NULL)
 447   {
 448     ERROR ("db query utils: udb_result_prepare_result: calloc failed.");
 449     BAIL_OUT (-ENOMEM);
 450   }
 451
 452   /* }}} */
 453
 454   /* Determine the position of the plugin instance column {{{ */
 455   for (i = 0; i < r->instances_num; i++)
 456   {
 457     size_t j;
 458
 459     for (j = 0; j < column_num; j++)
 460     {
 461       if (strcasecmp (r->instances[i], column_names[j]) == 0)
 462       {
 463         prep_area->instances_pos[i] = j;
 464         break;
 465       }
 466     }
 467
 468     if (j >= column_num)
 469     {
 470       ERROR ("db query utils: udb_result_prepare_result: "
 471           "Column `%s' could not be found.",
 472           r->instances[i]);
 473       BAIL_OUT (-ENOENT);
 474     }
 475   } /* }}} for (i = 0; i < r->instances_num; i++) */
 476
 477
 478   /* Determine the position of the value columns {{{ */
 479   for (i = 0; i < r->values_num; i++)
 480   {
 481     size_t j;
 482
 483     for (j = 0; j < column_num; j++)
 484     {
 485       if (strcasecmp (r->values[i], column_names[j]) == 0)
 486       {
 487         prep_area->values_pos[i] = j;
 488         break;
 489       }
 490     }
 491
 492     if (j >= column_num)
 493     {
 494       ERROR ("db query utils: udb_result_prepare_result: "
 495           "Column `%s' could not be found.",
 496           r->values[i]);
 497       BAIL_OUT (-ENOENT);
 498     }
 499   } /* }}} for (i = 0; i < r->values_num; i++) */
 500
 501   /* Determine the position of the metadata columns {{{ */
 502   for (i = 0; i < r->metadata_num; i++)
 503   {
 504     size_t j;
 505
 506     for (j = 0; j < column_num; j++)
 507     {
 508       if (strcasecmp (r->metadata[i], column_names[j]) == 0)
 509       {
 510         prep_area->metadata_pos[i] = j;
 511         break;
 512       }
 513     }
 514
 515     if (j >= column_num)
 516     {
 517       ERROR ("db query utils: udb_result_prepare_result: "
 518           "Metadata column `%s' could not be found.",
 519           r->values[i]);
 520       BAIL_OUT (-ENOENT);
 521     }
 522   } /* }}} for (i = 0; i < r->metadata_num; i++) */
 523
 524 #undef BAIL_OUT
 525   return (0);
 526 } /* }}} int udb_result_prepare_result */
 527
 528 static void udb_result_free (udb_result_t *r) /* {{{ */
 529 {
 530   size_t i;
 531
 532   if (r == NULL)
 533     return;
 534
 535   sfree (r->type);
 536   sfree (r->instance_prefix);
 537
 538   for (i = 0; i < r->instances_num; i++)
 539     sfree (r->instances[i]);
 540   sfree (r->instances);
 541
 542   for (i = 0; i < r->values_num; i++)
 543     sfree (r->values[i]);
 544   sfree (r->values);
 545
 546   for (i = 0; i < r->metadata_num; i++)
 547     sfree (r->metadata[i]);
 548   sfree (r->metadata);
 549
 550   udb_result_free (r->next);
 551
 552   sfree (r);
 553 } /* }}} void udb_result_free */
 554
 555 static int udb_result_create (const char *query_name, /* {{{ */
 556     udb_result_t **r_head, oconfig_item_t *ci)
 557 {
 558   udb_result_t *r;
 559   int status;
 560   int i;
 561
 562   if (ci->values_num != 0)
 563   {
 564     WARNING ("db query utils: The `Result' block doesn't accept "
 565         "any arguments. Ignoring %i argument%s.",
 566         ci->values_num, (ci->values_num == 1) ? "" : "s");
 567   }
 568
 569   r = calloc (1, sizeof (*r));
 570   if (r == NULL)
 571   {
 572     ERROR ("db query utils: calloc failed.");
 573     return (-1);
 574   }
 575   r->type = NULL;
 576   r->instance_prefix = NULL;
 577   r->instances = NULL;
 578   r->values = NULL;
 579   r->metadata = NULL;
 580   r->next = NULL;
 581
 582   /* Fill the `udb_result_t' structure.. */
 583   status = 0;
 584   for (i = 0; i < ci->children_num; i++)
 585   {
 586     oconfig_item_t *child = ci->children + i;
 587
 588     if (strcasecmp ("Type", child->key) == 0)
 589       status = udb_config_set_string (&r->type, child);
 590     else if (strcasecmp ("InstancePrefix", child->key) == 0)
 591       status = udb_config_set_string (&r->instance_prefix, child);
 592     else if (strcasecmp ("InstancesFrom", child->key) == 0)
 593       status = udb_config_add_string (&r->instances, &r->instances_num, child);
 594     else if (strcasecmp ("ValuesFrom", child->key) == 0)
 595       status = udb_config_add_string (&r->values, &r->values_num, child);
 596     else if (strcasecmp ("MetadataFrom", child->key) == 0)
 597       status = udb_config_add_string (&r->metadata, &r->metadata_num, child);
 598     else
 599     {
 600       WARNING ("db query utils: Query `%s': Option `%s' not allowed here.",
 601           query_name, child->key);
 602       status = -1;
 603     }
 604
 605     if (status != 0)
 606       break;
 607   }
 608
 609   /* Check that all necessary options have been given. */
 610   while (status == 0)
 611   {
 612     if (r->type == NULL)
 613     {
 614       WARNING ("db query utils: `Type' not given for "
 615           "result in query `%s'", query_name);
 616       status = -1;
 617     }
 618     if (r->values == NULL)
 619     {
 620       WARNING ("db query utils: `ValuesFrom' not given for "
 621           "result in query `%s'", query_name);
 622       status = -1;
 623     }
 624
 625     break;
 626   } /* while (status == 0) */
 627
 628   if (status != 0)
 629   {
 630     udb_result_free (r);
 631     return (-1);
 632   }
 633
 634   /* If all went well, add this result to the list of results. */
 635   if (*r_head == NULL)
 636   {
 637     *r_head = r;
 638   }
 639   else
 640   {
 641     udb_result_t *last;
 642
 643     last = *r_head;
 644     while (last->next != NULL)
 645       last = last->next;
 646
 647     last->next = r;
 648   }
 649
 650   return (0);
 651 } /* }}} int udb_result_create */
 652
 653 /*
 654  * Query private functions
 655  */
 656 static void udb_query_free_one (udb_query_t *q) /* {{{ */
 657 {
 658   if (q == NULL)
 659     return;
 660
 661   sfree (q->name);
 662   sfree (q->statement);
 663   sfree (q->plugin_instance_from);
 664
 665   udb_result_free (q->results);
 666
 667   sfree (q);
 668 } /* }}} void udb_query_free_one */
 669
 670 /*
 671  * Query public functions
 672  */
 673 int udb_query_create (udb_query_t ***ret_query_list, /* {{{ */
 674     size_t *ret_query_list_len, oconfig_item_t *ci,
 675     udb_query_create_callback_t cb)
 676 {
 677   udb_query_t **query_list;
 678   size_t        query_list_len;
 679
 680   udb_query_t *q;
 681   int status;
 682   int i;
 683
 684   if ((ret_query_list == NULL) || (ret_query_list_len == NULL))
 685     return (-EINVAL);
 686   query_list     = *ret_query_list;
 687   query_list_len = *ret_query_list_len;
 688
 689   if ((ci->values_num != 1)
 690       || (ci->values[0].type != OCONFIG_TYPE_STRING))
 691   {
 692     WARNING ("db query utils: The `Query' block "
 693         "needs exactly one string argument.");
 694     return (-1);
 695   }
 696
 697   q = calloc (1, sizeof (*q));
 698   if (q == NULL)
 699   {
 700     ERROR ("db query utils: calloc failed.");
 701     return (-1);
 702   }
 703   q->min_version = 0;
 704   q->max_version = UINT_MAX;
 705   q->statement = NULL;
 706   q->results = NULL;
 707   q->plugin_instance_from = NULL;
 708
 709   status = udb_config_set_string (&q->name, ci);
 710   if (status != 0)
 711   {
 712     sfree (q);
 713     return (status);
 714   }
 715
 716   /* Fill the `udb_query_t' structure.. */
 717   for (i = 0; i < ci->children_num; i++)
 718   {
 719     oconfig_item_t *child = ci->children + i;
 720
 721     if (strcasecmp ("Statement", child->key) == 0)
 722       status = udb_config_set_string (&q->statement, child);
 723     else if (strcasecmp ("Result", child->key) == 0)
 724       status = udb_result_create (q->name, &q->results, child);
 725     else if (strcasecmp ("MinVersion", child->key) == 0)
 726       status = udb_config_set_uint (&q->min_version, child);
 727     else if (strcasecmp ("MaxVersion", child->key) == 0)
 728       status = udb_config_set_uint (&q->max_version, child);
 729     else if (strcasecmp ("PluginInstanceFrom", child->key) == 0)
 730       status = udb_config_set_string (&q->plugin_instance_from, child);
 731
 732     /* Call custom callbacks */
 733     else if (cb != NULL)
 734     {
 735       status = (*cb) (q, child);
 736       if (status != 0)
 737       {
 738         WARNING ("db query utils: The configuration callback failed "
 739             "to handle `%s'.", child->key);
 740       }
 741     }
 742     else
 743     {
 744       WARNING ("db query utils: Query `%s': Option `%s' not allowed here.",
 745           q->name, child->key);
 746       status = -1;
 747     }
 748
 749     if (status != 0)
 750       break;
 751   }
 752
 753   /* Check that all necessary options have been given. */
 754   if (status == 0)
 755   {
 756     if (q->statement == NULL)
 757     {
 758       WARNING ("db query utils: Query `%s': No `Statement' given.", q->name);
 759       status = -1;
 760     }
 761     if (q->results == NULL)
 762     {
 763       WARNING ("db query utils: Query `%s': No (valid) `Result' block given.",
 764           q->name);
 765       status = -1;
 766     }
 767   } /* if (status == 0) */
 768
 769   /* If all went well, add this query to the list of queries within the
 770    * database structure. */
 771   if (status == 0)
 772   {
 773     udb_query_t **temp;
 774
 775     temp = realloc (query_list,
 776         sizeof (*query_list) * (query_list_len + 1));
 777     if (temp == NULL)
 778     {
 779       ERROR ("db query utils: realloc failed");
 780       status = -1;
 781     }
 782     else
 783     {
 784       query_list = temp;
 785       query_list[query_list_len] = q;
 786       query_list_len++;
 787     }
 788   }
 789
 790   if (status != 0)
 791   {
 792     udb_query_free_one (q);
 793     return (-1);
 794   }
 795
 796   *ret_query_list     = query_list;
 797   *ret_query_list_len = query_list_len;
 798
 799   return (0);
 800 } /* }}} int udb_query_create */
 801
 802 void udb_query_free (udb_query_t **query_list, size_t query_list_len) /* {{{ */
 803 {
 804   size_t i;
 805
 806   if (query_list == NULL)
 807     return;
 808
 809   for (i = 0; i < query_list_len; i++)
 810     udb_query_free_one (query_list[i]);
 811
 812   sfree (query_list);
 813 } /* }}} void udb_query_free */
 814
 815 int udb_query_pick_from_list_by_name (const char *name, /* {{{ */
 816     udb_query_t **src_list, size_t src_list_len,
 817     udb_query_t ***dst_list, size_t *dst_list_len)
 818 {
 819   size_t i;
 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 (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     size_t i;
 993
 994     for (i = 0; i < prep_area->column_num; i++)
 995     {
 996       DEBUG ("db query utils: udb_query_handle_result (%s, %s): "
 997           "column[%zu] = %s;",
 998           prep_area->db_name, q->name, i, column_values[i]);
 999     }
1000   } while (0);
1001 #endif /* }}} */
1002
1003   success = 0;
1004   for (r = q->results, r_area = prep_area->result_prep_areas;
1005       r != NULL; r = r->next, r_area = r_area->next)
1006   {
1007     status = udb_result_handle_result (r, prep_area, r_area,
1008         q, column_values);
1009     if (status == 0)
1010       success++;
1011   }
1012
1013   if (success == 0)
1014   {
1015     ERROR ("db query utils: udb_query_handle_result (%s, %s): "
1016         "All results failed.", prep_area->db_name, q->name);
1017     return (-1);
1018   }
1019
1020   return (0);
1021 } /* }}} int udb_query_handle_result */
1022
1023 int udb_query_prepare_result (udb_query_t const *q, /* {{{ */
1024     udb_query_preparation_area_t *prep_area,
1025     const char *host, const char *plugin, const char *db_name,
1026     char **column_names, size_t column_num, cdtime_t interval)
1027 {
1028   udb_result_preparation_area_t *r_area;
1029   udb_result_t *r;
1030   int status;
1031
1032   if ((q == NULL) || (prep_area == NULL))
1033     return (-EINVAL);
1034
1035   udb_query_finish_result (q, prep_area);
1036
1037   prep_area->column_num = column_num;
1038   prep_area->host = strdup (host);
1039   prep_area->plugin = strdup (plugin);
1040   prep_area->db_name = strdup (db_name);
1041
1042   prep_area->interval = interval;
1043
1044   if ((prep_area->host == NULL) || (prep_area->plugin == NULL)
1045       || (prep_area->db_name == NULL))
1046   {
1047     ERROR ("db query utils: Query `%s': Prepare failed: Out of memory.", q->name);
1048     udb_query_finish_result (q, prep_area);
1049     return (-ENOMEM);
1050   }
1051
1052 #if defined(COLLECT_DEBUG) && COLLECT_DEBUG
1053   do
1054   {
1055     size_t i;
1056
1057     for (i = 0; i < column_num; i++)
1058     {
1059       DEBUG ("db query utils: udb_query_prepare_result: "
1060           "query = %s; column[%zu] = %s;",
1061           q->name, i, column_names[i]);
1062     }
1063   } while (0);
1064 #endif
1065
1066   /* Determine the position of the PluginInstance column {{{ */
1067   if (q->plugin_instance_from != NULL)
1068   {
1069     size_t i;
1070
1071     for (i = 0; i < column_num; i++)
1072     {
1073       if (strcasecmp (q->plugin_instance_from, column_names[i]) == 0)
1074       {
1075         prep_area->plugin_instance_pos = i;
1076         break;
1077       }
1078     }
1079
1080     if (i >= column_num)
1081     {
1082       ERROR ("db query utils: udb_query_prepare_result: "
1083           "Column `%s' from `PluginInstanceFrom' could not be found.",
1084           q->plugin_instance_from);
1085       udb_query_finish_result (q, prep_area);
1086       return (-ENOENT);
1087     }
1088   }
1089   /* }}} */
1090
1091   for (r = q->results, r_area = prep_area->result_prep_areas;
1092       r != NULL; r = r->next, r_area = r_area->next)
1093   {
1094     if (! r_area)
1095     {
1096       ERROR ("db query utils: Query `%s': Invalid number of result "
1097           "preparation areas.", q->name);
1098       udb_query_finish_result (q, prep_area);
1099       return (-EINVAL);
1100     }
1101
1102     status = udb_result_prepare_result (r, r_area, column_names, column_num);
1103     if (status != 0)
1104     {
1105       udb_query_finish_result (q, prep_area);
1106       return (status);
1107     }
1108   }
1109
1110   return (0);
1111 } /* }}} int udb_query_prepare_result */
1112
1113 udb_query_preparation_area_t *
1114 udb_query_allocate_preparation_area (udb_query_t *q) /* {{{ */
1115 {
1116   udb_query_preparation_area_t   *q_area;
1117   udb_result_preparation_area_t **next_r_area;
1118   udb_result_t *r;
1119
1120   q_area = calloc (1, sizeof (*q_area));
1121   if (q_area == NULL)
1122     return NULL;
1123
1124   next_r_area = &q_area->result_prep_areas;
1125   for (r = q->results; r != NULL; r = r->next)
1126   {
1127     udb_result_preparation_area_t *r_area;
1128
1129     r_area = calloc (1, sizeof (*r_area));
1130     if (r_area == NULL)
1131     {
1132       udb_result_preparation_area_t *a = q_area->result_prep_areas;
1133
1134       while (a != NULL)
1135       {
1136         udb_result_preparation_area_t *next = a->next;
1137         sfree (a);
1138         a = next;
1139       }
1140
1141       free (q_area);
1142       return NULL;
1143     }
1144
1145     *next_r_area = r_area;
1146     next_r_area  = &r_area->next;
1147   }
1148
1149   return (q_area);
1150 } /* }}} udb_query_preparation_area_t *udb_query_allocate_preparation_area */
1151
1152 void
1153 udb_query_delete_preparation_area (udb_query_preparation_area_t *q_area) /* {{{ */
1154 {
1155   udb_result_preparation_area_t *r_area;
1156
1157   if (q_area == NULL)
1158     return;
1159
1160   r_area = q_area->result_prep_areas;
1161   while (r_area != NULL)
1162   {
1163     udb_result_preparation_area_t *area = r_area;
1164
1165     r_area = r_area->next;
1166
1167     sfree (area->instances_pos);
1168     sfree (area->values_pos);
1169     sfree (area->instances_buffer);
1170     sfree (area->values_buffer);
1171     free (area);
1172   }
1173
1174   sfree (q_area->host);
1175   sfree (q_area->plugin);
1176   sfree (q_area->db_name);
1177
1178   free (q_area);
1179 } /* }}} void udb_query_delete_preparation_area */
1180
1181 /* vim: set sw=2 sts=2 et fdm=marker : */