Code

Add support for the 'NOT IN' operator.
[sysdb.git] / src / include / core / store.h
1 /*
2  * SysDB - src/include/core/store.h
3  * Copyright (C) 2012 Sebastian 'tokkee' Harl <sh@tokkee.org>
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
17  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
18  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
19  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
20  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
22  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
23  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
24  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
25  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26  */
28 #ifndef SDB_CORE_STORE_H
29 #define SDB_CORE_STORE_H 1
31 #include "sysdb.h"
32 #include "core/object.h"
33 #include "core/data.h"
34 #include "core/time.h"
35 #include "core/timeseries.h"
36 #include "utils/strbuf.h"
38 #include <stdbool.h>
39 #include <stdio.h>
41 #ifdef __cplusplus
42 extern "C" {
43 #endif
45 /*
46  * Store object types.
47  */
48 enum {
49         SDB_HOST = 1,
50         SDB_SERVICE,
51         SDB_METRIC,
53         SDB_ATTRIBUTE = 1 << 4,
55         /*
56          * Queryable fields of a stored object.
57          */
58         SDB_FIELD_NAME = 1 << 8, /* type: string */
59         SDB_FIELD_LAST_UPDATE,   /* type: datetime */
60         SDB_FIELD_AGE,           /* type: datetime */
61         SDB_FIELD_INTERVAL,      /* type: datetime */
62         SDB_FIELD_BACKEND,       /* type: array of strings */
63 };
64 #define SDB_STORE_TYPE_TO_NAME(t) \
65         (((t) == SDB_HOST) ? "host" \
66                 : ((t) == SDB_SERVICE) ? "service" \
67                 : ((t) == SDB_METRIC) ? "metric" \
68                 : ((t) == SDB_ATTRIBUTE) ? "attribute" \
69                 : ((t) == (SDB_ATTRIBUTE | SDB_HOST)) ? "host attribute" \
70                 : ((t) == (SDB_ATTRIBUTE | SDB_SERVICE)) ? "service attribute" \
71                 : ((t) == (SDB_ATTRIBUTE | SDB_METRIC)) ? "metric attribute" \
72                 : "unknown")
74 #define SDB_FIELD_TO_NAME(f) \
75         (((f) == SDB_FIELD_NAME) ? "name" \
76                 : ((f) == SDB_FIELD_LAST_UPDATE) ? "last-update" \
77                 : ((f) == SDB_FIELD_AGE) ? "age" \
78                 : ((f) == SDB_FIELD_INTERVAL) ? "interval" \
79                 : ((f) == SDB_FIELD_BACKEND) ? "backend" : "unknown")
81 #define SDB_FIELD_TYPE(f) \
82         (((f) == SDB_FIELD_NAME) ? SDB_TYPE_STRING \
83                 : ((f) == SDB_FIELD_LAST_UPDATE) ? SDB_TYPE_DATETIME \
84                 : ((f) == SDB_FIELD_AGE) ? SDB_TYPE_DATETIME \
85                 : ((f) == SDB_FIELD_INTERVAL) ? SDB_TYPE_DATETIME \
86                 : ((f) == SDB_FIELD_BACKEND) ? (SDB_TYPE_ARRAY | SDB_TYPE_STRING) \
87                 : -1)
89 /*
90  * sdb_store_obj_t represents the super-class of any object stored in the
91  * database. It inherits from sdb_object_t and may safely be cast to a generic
92  * object to access its name.
93  */
94 struct sdb_store_obj;
95 typedef struct sdb_store_obj sdb_store_obj_t;
97 /*
98  * A metric store describes how to access a metric's data.
99  */
100 typedef struct {
101         const char *type;
102         const char *id;
103 } sdb_metric_store_t;
105 /*
106  * Expressions represent arithmetic expressions based on stored objects and
107  * their various attributes.
108  *
109  * An expression object inherits from sdb_object_t and, thus, may safely be
110  * cast to a generic object.
111  */
112 struct sdb_store_expr;
113 typedef struct sdb_store_expr sdb_store_expr_t;
114 #define SDB_STORE_EXPR(obj) ((sdb_store_expr_t *)(obj))
116 /*
117  * Store matchers may be used to lookup hosts from the store based on their
118  * various attributes. Service and attribute matchers are applied to a host's
119  * services and attributes and evaluate to true if *any* service or attribute
120  * matches.
121  *
122  * A store matcher object inherits from sdb_object_t and, thus, may safely be
123  * cast to a generic object.
124  */
125 struct sdb_store_matcher;
126 typedef struct sdb_store_matcher sdb_store_matcher_t;
127 #define SDB_STORE_MATCHER(obj) ((sdb_store_matcher_t *)(obj))
129 /*
130  * A JSON formatter converts stored objects into the JSON format.
131  * See http://www.ietf.org/rfc/rfc4627.txt
132  */
133 struct sdb_store_json_formatter;
134 typedef struct sdb_store_json_formatter sdb_store_json_formatter_t;
136 /*
137  * A store writer describes the interface for plugins implementing a store.
138  */
139 typedef struct {
140         int (*store_host)(const char *name, sdb_time_t last_update,
141                         sdb_object_t *user_data);
142         int (*store_service)(const char *hostname, const char *name,
143                         sdb_time_t last_update, sdb_object_t *user_data);
144         int (*store_metric)(const char *hostname, const char *name,
145                         sdb_metric_store_t *store, sdb_time_t last_update,
146                         sdb_object_t *user_data);
147         int (*store_attribute)(const char *hostname,
148                         const char *key, const sdb_data_t *value, sdb_time_t last_update,
149                         sdb_object_t *user_data);
150         int (*store_service_attr)(const char *hostname, const char *service,
151                         const char *key, const sdb_data_t *value, sdb_time_t last_update,
152                         sdb_object_t *user_data);
153         int (*store_metric_attr)(const char *hostname, const char *metric,
154                         const char *key, const sdb_data_t *value, sdb_time_t last_update,
155                         sdb_object_t *user_data);
156 } sdb_store_writer_t;
158 /*
159  * sdb_store_clear:
160  * Clear the entire store and remove all stored objects.
161  */
162 void
163 sdb_store_clear(void);
165 /*
166  * sdb_store_host:
167  * Add/update a host in the store. If the host, identified by its
168  * canonicalized name, already exists, it will be updated according to the
169  * specified name and timestamp. Else, a new entry will be created in the
170  * store. Any memory required for storing the entry will be allocated an
171  * managed by the store itself.
172  *
173  * Returns:
174  *  - 0 on success
175  *  - a positive value if the new entry is older than the currently stored
176  *    entry (in this case, no update will happen)
177  *  - a negative value on error
178  */
179 int
180 sdb_store_host(const char *name, sdb_time_t last_update);
182 /*
183  * sdb_store_has_host:
184  * sdb_store_get_host:
185  * Query the store for a host by its (canonicalized) name.
186  *
187  * sdb_store_get_host increments the ref count of the host object. The caller
188  * needs to deref it when no longer using it.
189  */
190 bool
191 sdb_store_has_host(const char *name);
193 sdb_store_obj_t *
194 sdb_store_get_host(const char *name);
196 /*
197  * sdb_store_attribute:
198  * Add/update a host's attribute in the store. If the attribute, identified by
199  * its key, already exists for the specified host, it will be updated to the
200  * specified values. If the referenced host does not exist, an error will be
201  * reported. Else, a new entry will be created in the store. Any memory
202  * required for storing the entry will be allocated and managed by the store
203  * itself.
204  *
205  * Returns:
206  *  - 0 on success
207  *  - a positive value if the new entry is older than the currently stored
208  *    entry (in this case, no update will happen)
209  *  - a negative value on error
210  */
211 int
212 sdb_store_attribute(const char *hostname,
213                 const char *key, const sdb_data_t *value,
214                 sdb_time_t last_update);
216 /*
217  * sdb_store_service:
218  * Add/update a service in the store. If the service, identified by its name,
219  * already exists for the specified host, it will be updated according to the
220  * specified 'service' object. If the referenced host does not exist, an error
221  * will be reported. Else, a new entry will be created in the store. Any
222  * memory required for storing the entry will be allocated an managed by the
223  * store itself.
224  *
225  * Returns:
226  *  - 0 on success
227  *  - a positive value if the new entry is older than the currently stored
228  *    entry (in this case, no update will happen)
229  *  - a negative value on error
230  */
231 int
232 sdb_store_service(const char *hostname, const char *name,
233                 sdb_time_t last_update);
235 /*
236  * sdb_store_service_attr:
237  * Add/update a service's attribute in the store. If the attribute, identified
238  * by its key, already exists for the specified service, it will be updated to
239  * the specified value. If the references service (for the specified host)
240  * does not exist, an error will be reported. Any memory required for storing
241  * the entry will be allocated and managed by the store itself.
242  *
243  * Returns:
244  *  - 0 on success
245  *  - a positive value if the new entry is older than the currently stored
246  *    entry (in this case, no update will happen)
247  *  - a negative value on error
248  */
249 int
250 sdb_store_service_attr(const char *hostname, const char *service,
251                 const char *key, const sdb_data_t *value, sdb_time_t last_update);
253 /*
254  * sdb_store_metric:
255  * Add/update a metric in the store. If the metric, identified by its name,
256  * already exists for the specified host, it will be updated according to the
257  * specified 'metric' object. If the referenced host does not exist, an error
258  * will be reported. Else, a new entry will be created in the store. Any
259  * memory required for storing the entry will be allocated an managed by the
260  * store itself.
261  *
262  * If specified, the metric store describes where to access the metric's data.
263  *
264  * Returns:
265  *  - 0 on success
266  *  - a positive value if the new entry is older than the currently stored
267  *    entry (in this case, no update will happen)
268  *  - a negative value on error
269  */
270 int
271 sdb_store_metric(const char *hostname, const char *name,
272                 sdb_metric_store_t *store, sdb_time_t last_update);
274 /*
275  * sdb_store_metric_attr:
276  * Add/update a metric's attribute in the store. If the attribute, identified
277  * by its key, already exists for the specified metric, it will be updated to
278  * the specified value. If the references metric (for the specified host)
279  * does not exist, an error will be reported. Any memory required for storing
280  * the entry will be allocated and managed by the store itself.
281  *
282  * Returns:
283  *  - 0 on success
284  *  - a positive value if the new entry is older than the currently stored
285  *    entry (in this case, no update will happen)
286  *  - a negative value on error
287  */
288 int
289 sdb_store_metric_attr(const char *hostname, const char *metric,
290                 const char *key, const sdb_data_t *value, sdb_time_t last_update);
292 /*
293  * sdb_store_fetch_timeseries:
294  * Fetch the time-series described by the specified host's metric and
295  * serialize it as JSON into the provided string buffer.
296  *
297  * Returns:
298  *  - 0 on success
299  *  - a negative value else
300  */
301 int
302 sdb_store_fetch_timeseries(const char *hostname, const char *metric,
303                 sdb_timeseries_opts_t *opts, sdb_strbuf_t *buf);
305 /*
306  * sdb_store_get_child:
307  * Retrieve a host's child object of the specified type and name. The
308  * reference count of the child object will be incremented before returning
309  * it. The caller is responsible for releasing the object once it's no longer
310  * used.
311  *
312  * Returns:
313  *  - the child object on success
314  *  - NULL else
315  */
316 sdb_store_obj_t *
317 sdb_store_get_child(sdb_store_obj_t *host, int type, const char *name);
319 /*
320  * sdb_store_get_field:
321  * Get the value of a stored object's queryable field. The caller is
322  * responsible for freeing any dynamically allocated memory possibly stored in
323  * the returned value. If 'res' is NULL, the function will return whether the
324  * field exists.
325  *
326  * Note: Retrieving the backend this way is not currently supported.
327  *
328  * Returns:
329  *  - 0 on success
330  *  - a negative value else
331  */
332 int
333 sdb_store_get_field(sdb_store_obj_t *obj, int field, sdb_data_t *res);
335 /*
336  * sdb_store_get_attr:
337  * Get the value of a stored object's attribute. The caller is responsible for
338  * freeing any dynamically allocated memory possibly stored in the returned
339  * value. If 'res' is NULL, the function will return whether the attribute
340  * exists. If specified, only attributes matching the filter will be
341  * considered.
342  *
343  * Returns:
344  *  - 0 if the attribute exists
345  *  - a negative value else
346  */
347 int
348 sdb_store_get_attr(sdb_store_obj_t *obj, const char *name, sdb_data_t *res,
349                 sdb_store_matcher_t *filter);
351 /*
352  * sdb_store_expr_create:
353  * Creates an arithmetic expression implementing the specified operator on the
354  * specified left and right operand.
355  *
356  * Returns:
357  *  - an expression object on success
358  *  - NULL else
359  */
360 sdb_store_expr_t *
361 sdb_store_expr_create(int op, sdb_store_expr_t *left, sdb_store_expr_t *right);
363 /*
364  * sdb_store_expr_typed:
365  * Creates an expression which evaluates in the context of an object's sibling
366  * as specified by the given type.
367  *
368  * Returns:
369  *  - an expression object on success
370  *  - NULL else
371  */
372 sdb_store_expr_t *
373 sdb_store_expr_typed(int typ, sdb_store_expr_t *expr);
375 /*
376  * sdb_store_expr_fieldvalue:
377  * Creates an expression which evaluates to the value of the specified
378  * queryable field of a stored object.
379  *
380  * Returns:
381  *  - an expression object on success
382  *  - NULL else
383  */
384 sdb_store_expr_t *
385 sdb_store_expr_fieldvalue(int field);
387 /*
388  * sdb_store_expr_attrvalue:
389  * Creates an expression which evaluates to the value of the specified
390  * attribute of a stored object. Evaluates to a NULL value if the attribute
391  * does not exist.
392  *
393  * Returns:
394  *  - an expression object on success
395  *  - NULL else
396  */
397 sdb_store_expr_t *
398 sdb_store_expr_attrvalue(const char *name);
400 /*
401  * sdb_store_expr_constvalue:
402  * Creates an expression which evaluates to the specified constant value.
403  *
404  * Returns:
405  *  - an expression object on success
406  *  - NULL else
407  */
408 sdb_store_expr_t *
409 sdb_store_expr_constvalue(const sdb_data_t *value);
411 /*
412  * sdb_store_expr_eval:
413  * Evaluate an expression for the specified stored object and stores the
414  * result in 'res'. The result's value will be allocated dynamically if
415  * necessary and, thus, should be free'd by the caller (e.g. using
416  * sdb_data_free_datum). The object may be NULL, in which case the expression
417  * needs to evaluate to a constant value. If specified, only objects matching
418  * the filter will be used during the evaluation.
419  *
420  * Returns:
421  *  - 0 on success
422  *  - a negative value else
423  */
424 int
425 sdb_store_expr_eval(sdb_store_expr_t *expr, sdb_store_obj_t *obj,
426                 sdb_data_t *res, sdb_store_matcher_t *filter);
428 /*
429  * sdb_store_dis_matcher:
430  * Creates a matcher matching the disjunction (logical OR) of two matchers.
431  */
432 sdb_store_matcher_t *
433 sdb_store_dis_matcher(sdb_store_matcher_t *left, sdb_store_matcher_t *right);
435 /*
436  * sdb_store_con_matcher:
437  * Creates a matcher matching the conjunction (logical AND) of two matchers.
438  */
439 sdb_store_matcher_t *
440 sdb_store_con_matcher(sdb_store_matcher_t *left, sdb_store_matcher_t *right);
442 /*
443  * sdb_store_inv_matcher::
444  * Creates a matcher matching the inverse (logical NOT) of a matcher.
445  */
446 sdb_store_matcher_t *
447 sdb_store_inv_matcher(sdb_store_matcher_t *m);
449 /*
450  * sdb_store_any_matcher:
451  * Creates a matcher iterating over objects of the specified type. It matches
452  * if *any* of those objects match 'm'.
453  */
454 sdb_store_matcher_t *
455 sdb_store_any_matcher(int type, sdb_store_matcher_t *m);
457 /*
458  * sdb_store_all_matcher:
459  * Creates a matcher iterating over objects of the specified type. It matches
460  * if *all* of those objects match 'm'.
461  */
462 sdb_store_matcher_t *
463 sdb_store_all_matcher(int type, sdb_store_matcher_t *m);
465 /*
466  * sdb_store_in_matcher:
467  * Creates a matcher which matches if the right value evaluates to an array
468  * value and the left value is included in that array. See sdb_data_inarray
469  * for more details.
470  */
471 sdb_store_matcher_t *
472 sdb_store_in_matcher(sdb_store_expr_t *left, sdb_store_expr_t *right);
474 /*
475  * sdb_store_nin_matcher:
476  * Like sdb_store_in_matcher but matches if the left value is not included in
477  * the right value.
478  */
479 sdb_store_matcher_t *
480 sdb_store_nin_matcher(sdb_store_expr_t *left, sdb_store_expr_t *right);
482 /*
483  * sdb_store_lt_matcher, sdb_store_le_matcher, sdb_store_eq_matcher,
484  * sdb_store_ge_matcher, sdb_store_gt_matcher:
485  * Create conditional matchers comparing the values of two expressions. The
486  * matcher matches if the left expression compres less than, less or equal
487  * than, equal to, not equal to, greater or equal than, or greater than the
488  * right expression.
489  */
490 sdb_store_matcher_t *
491 sdb_store_lt_matcher(sdb_store_expr_t *left, sdb_store_expr_t *right);
492 sdb_store_matcher_t *
493 sdb_store_le_matcher(sdb_store_expr_t *left, sdb_store_expr_t *right);
494 sdb_store_matcher_t *
495 sdb_store_eq_matcher(sdb_store_expr_t *left, sdb_store_expr_t *right);
496 sdb_store_matcher_t *
497 sdb_store_ne_matcher(sdb_store_expr_t *left, sdb_store_expr_t *right);
498 sdb_store_matcher_t *
499 sdb_store_ge_matcher(sdb_store_expr_t *left, sdb_store_expr_t *right);
500 sdb_store_matcher_t *
501 sdb_store_gt_matcher(sdb_store_expr_t *left, sdb_store_expr_t *right);
503 /*
504  * sdb_store_regex_matcher:
505  * Creates a matcher which matches the string value the left expression
506  * evaluates to against the regular expression the right expression evaluates
507  * to. The right expression may either be a constant value regular expression
508  * or string or a dynamic value evaluating to a string. In the latter case,
509  * the string is compiled to a regex every time the matcher is executed.
510  */
511 sdb_store_matcher_t *
512 sdb_store_regex_matcher(sdb_store_expr_t *left, sdb_store_expr_t *right);
514 /*
515  * sdb_store_nregex_matcher:
516  * Creates a regex matcher just like sdb_store_regex_matcher except that it
517  * matches in case the regular expression does not match.
518  */
519 sdb_store_matcher_t *
520 sdb_store_nregex_matcher(sdb_store_expr_t *left, sdb_store_expr_t *right);
522 /*
523  * sdb_store_isnull_matcher:
524  * Creates a matcher matching NULL values.
525  */
526 sdb_store_matcher_t *
527 sdb_store_isnull_matcher(sdb_store_expr_t *expr);
529 /*
530  * sdb_store_isnnull_matcher:
531  * Creates a matcher matching non-NULL values.
532  */
533 sdb_store_matcher_t *
534 sdb_store_isnnull_matcher(sdb_store_expr_t *expr);
536 /*
537  * sdb_store_matcher_matches:
538  * Check whether the specified matcher matches the specified store object. If
539  * specified, the filter will be used to preselect objects for further
540  * evaluation. It is applied to any object that's used during the evaluation
541  * of the matcher. Only those objects matching the filter will be considered.
542  *
543  * Note that the filter is applied to all object types (hosts, service,
544  * metric, attribute). Thus, any object-specific matchers are mostly unsuited
545  * for this purpose and, if used, may result in unexpected behavior.
546  *
547  * Returns:
548  *  - 1 if the object matches
549  *  - 0 else
550  */
551 int
552 sdb_store_matcher_matches(sdb_store_matcher_t *m, sdb_store_obj_t *obj,
553                 sdb_store_matcher_t *filter);
555 /*
556  * sdb_store_matcher_op_cb:
557  * Callback constructing a matcher operator.
558  */
559 typedef sdb_store_matcher_t *(*sdb_store_matcher_op_cb)
560         (sdb_store_expr_t *, sdb_store_expr_t *);
562 /*
563  * sdb_store_parse_matcher_op:
564  * Parse a matcher operator and return a constructor for the respective
565  * matcher.
566  *
567  * Returns:
568  *  - matcher operator constructor on success
569  *  - NULL else
570  */
571 sdb_store_matcher_op_cb
572 sdb_store_parse_matcher_op(const char *op);
574 /*
575  * sdb_store_parse_object_type:
576  * Parse the type name of a stored object.
577  *
578  * Returns:
579  *  - the object type on success
580  *  - a negative value else
581  */
582 int
583 sdb_store_parse_object_type(const char *name);
585 /*
586  * sdb_store_parse_object_type_plural:
587  * Parse the type name (plural) of a stored object.
588  *
589  * Returns:
590  *  - the object type on success
591  *  - a negative value else
592  */
593 int
594 sdb_store_parse_object_type_plural(const char *name);
596 /*
597  * sdb_store_parse_field_name:
598  * Parse the name of a stored object's queryable field.
599  *
600  * Returns:
601  *  - the field id on success
602  *  - a negative value else
603  */
604 int
605 sdb_store_parse_field_name(const char *name);
607 /*
608  * sdb_store_lookup_cb:
609  * Lookup callback. It is called for each matching object when looking up data
610  * in the store passing on the lookup filter and the specified user-data. The
611  * lookup aborts early if the callback returns non-zero.
612  */
613 typedef int (*sdb_store_lookup_cb)(sdb_store_obj_t *obj,
614                 sdb_store_matcher_t *filter, void *user_data);
616 /*
617  * sdb_store_scan:
618  * Look up objects of the specified type in the store. The specified callback
619  * function is called for each object in the store matching 'm'. The function
620  * performs a full scan of all objects stored in the database. If specified,
621  * the filter will be used to preselect objects for further evaluation. See
622  * the description of 'sdb_store_matcher_matches' for details.
623  *
624  * Returns:
625  *  - 0 on success
626  *  - a negative value else
627  */
628 int
629 sdb_store_scan(int type, sdb_store_matcher_t *m, sdb_store_matcher_t *filter,
630                 sdb_store_lookup_cb cb, void *user_data);
632 /*
633  * Flags for JSON formatting.
634  */
635 enum {
636         SDB_WANT_ARRAY = 1 << 0,
637 };
639 /*
640  * sdb_store_json_formatter:
641  * Create a JSON formatter for the specified object types writing to the
642  * specified buffer.
643  */
644 sdb_store_json_formatter_t *
645 sdb_store_json_formatter(sdb_strbuf_t *buf, int type, int flags);
647 /*
648  * sdb_store_json_emit:
649  * Serialize a single object to JSON adding it to the string buffer associated
650  * with the formatter object. The serialized object will not include
651  * attributes or any child objects. Instead, call the function again for each
652  * of those objects. All attributes have to be emitted before any other
653  * children types. Use sdb_store_json_emit_full() to emit a full (filtered)
654  * object.
655  *
656  * Note that the output might not be valid JSON before calling
657  * sdb_store_json_finish().
658  *
659  * Returns:
660  *  - 0 on success
661  *  - a negative value else
662  */
663 int
664 sdb_store_json_emit(sdb_store_json_formatter_t *f, sdb_store_obj_t *obj);
666 /*
667  * sdb_store_json_emit_full:
668  * Serialize a single object including it's attributes and all children to
669  * JSON, adding it to the string buffer associated with the formatter object.
670  * The filter, if specified, is applied to each attribute and child object.
671  * Only matching objects will be included in the output.
672  *
673  * Note that the output might not be valid JSON before calling
674  * sdb_store_json_finish().
675  *
676  * Returns:
677  *  - 0 on success
678  *  - a negative value else
679  */
680 int
681 sdb_store_json_emit_full(sdb_store_json_formatter_t *f, sdb_store_obj_t *obj,
682                 sdb_store_matcher_t *filter);
684 /*
685  * sdb_store_json_finish:
686  * Finish the JSON output. This function has to be called once after emiting
687  * all objects.
688  */
689 int
690 sdb_store_json_finish(sdb_store_json_formatter_t *f);
692 #ifdef __cplusplus
693 } /* extern "C" */
694 #endif
696 #endif /* ! SDB_CORE_STORE_H */
698 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */