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