src/utils_db_query.c

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