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