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