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