@cryptotaxi247 / netdata-1 / commits / b1bb1e9de

Additional code cleanup (#17541)

* Use macros for readability * Fix macros to return proper value Remove unused variable * Use macro to prepare statement in more places

Stelios Fragkakis committed Apr 30, 2024 at 17:43 UTC b1bb1e9ded69b68dcc31cb7e2303f5fd80d8c1bf
8 files changed +259 -586
src/database/sqlite/sqlite_aclk.c
+13 -37
@@ -178,19 +178,13 @@ static int create_host_callback(void *data, int argc, char **argv, char **column
178 static int is_host_available(uuid_t *host_id)
179 {
180 sqlite3_stmt *res = NULL;
181 - int rc;
181 + int rc = 0;
182
183 - if (unlikely(!db_meta)) {
184 - if (default_rrd_memory_mode == RRD_MEMORY_MODE_DBENGINE)
185 - error_report("Database has not been initialized");
183 + if (!REQUIRE_DB(db_meta))
184 return 1;
187 - }
185
189 - rc = sqlite3_prepare_v2(db_meta, SQL_SELECT_HOST_BY_UUID, -1, &res, 0);
190 - if (unlikely(rc != SQLITE_OK)) {
191 - error_report("Failed to prepare statement to select node instance information for a node");
186 + if (!PREPARE_STATEMENT(db_meta, SQL_SELECT_HOST_BY_UUID, &res))
187 return 1;
193 - }
188
189 int param = 0;
190 SQLITE_BIND_FAIL(done, sqlite3_bind_blob(res, ++param, host_id, sizeof(*host_id), SQLITE_STATIC));
@@ -200,9 +194,7 @@ static int is_host_available(uuid_t *host_id)
194
195 done:
196 REPORT_BIND_FAIL(res, param);
203 -
197 SQLITE_FINALIZE(res);
205 -
198 return (rc == SQLITE_ROW);
199 }
200
@@ -235,11 +227,9 @@ static void sql_delete_aclk_table_list(char *host_guid)
227 buffer_sprintf(sql,"SELECT 'drop '||type||' IF EXISTS '||name||';' FROM sqlite_schema " \
228 "WHERE name LIKE 'aclk_%%_%s' AND type IN ('table', 'trigger', 'index')", uuid_str);
229
238 - rc = sqlite3_prepare_v2(db_meta, buffer_tostring(sql), -1, &res, 0);
239 - if (rc != SQLITE_OK) {
240 - error_report("Failed to prepare statement to clean up aclk tables");
230 + if (!PREPARE_STATEMENT(db_meta, buffer_tostring(sql), &res))
231 goto fail;
242 - }
232 +
233 buffer_flush(sql);
234
235 while (sqlite3_step_monitored(res) == SQLITE_ROW)
@@ -265,19 +255,13 @@ static void sql_unregister_node(char *machine_guid)
255 return;
256
257 rc = uuid_parse(machine_guid, host_uuid);
268 - if (rc) {
269 - freez(machine_guid);
270 - return;
271 - }
258 + if (rc)
259 + goto skip;
260
261 sqlite3_stmt *res = NULL;
262
275 - rc = sqlite3_prepare_v2(db_meta, "UPDATE node_instance SET node_id = NULL WHERE host_id = @host_id", -1, &res, 0);
276 - if (unlikely(rc != SQLITE_OK)) {
277 - error_report("Failed to prepare statement to remove the host node id");
278 - freez(machine_guid);
279 - return;
280 - }
263 + if (!PREPARE_STATEMENT(db_meta, "UPDATE node_instance SET node_id = NULL WHERE host_id = @host_id", &res))
264 + goto skip;
265
266 int param = 0;
267 SQLITE_BIND_FAIL(done, sqlite3_bind_blob(res, ++param, &host_uuid, sizeof(host_uuid), SQLITE_STATIC));
@@ -294,8 +278,8 @@ static void sql_unregister_node(char *machine_guid)
278
279 done:
280 REPORT_BIND_FAIL(res, param);
297 -
281 SQLITE_FINALIZE(res);
282 +skip:
283 freez(machine_guid);
284 }
285
@@ -352,10 +336,8 @@ static int aclk_config_parameters(void *data __maybe_unused, int argc __maybe_un
336 uuid_unparse_lower(*((uuid_t *) argv[0]), uuid_str);
337
338 RRDHOST *host = rrdhost_find_by_guid(uuid_str);
355 - if (host == localhost)
356 - return 0;
357 -
358 - sql_create_aclk_table(host, (uuid_t *) argv[0], (uuid_t *) argv[1]);
339 + if (host != localhost)
340 + sql_create_aclk_table(host, (uuid_t *) argv[0], (uuid_t *) argv[1]);
341 return 0;
342 }
343
@@ -576,13 +558,7 @@ void sql_aclk_sync_init(void)
558 char *err_msg = NULL;
559 int rc;
560
579 - if (unlikely(!db_meta)) {
580 - if (default_rrd_memory_mode != RRD_MEMORY_MODE_DBENGINE) {
581 - return;
582 - }
583 - error_report("Database has not been initialized");
584 - return;
585 - }
561 + REQUIRE_DB(db_meta);
562
563 netdata_log_info("Creating archived hosts");
564 int number_of_children = 0;
src/database/sqlite/sqlite_aclk.h
-8
@@ -3,14 +3,6 @@
3 #ifndef NETDATA_SQLITE_ACLK_H
4 #define NETDATA_SQLITE_ACLK_H
5
6 -#include "sqlite3.h"
7 -
8 -#ifndef ACLK_MAX_CHART_BATCH
9 -#define ACLK_MAX_CHART_BATCH (200)
10 -#endif
11 -#ifndef ACLK_MAX_CHART_BATCH_COUNT
12 -#define ACLK_MAX_CHART_BATCH_COUNT (10)
13 -#endif
6 #define ACLK_MAX_ALERT_UPDATES "5"
7 #define ACLK_DATABASE_CLEANUP_FIRST (1200)
8 #define ACLK_DATABASE_CLEANUP_INTERVAL (3600)
src/database/sqlite/sqlite_aclk_alert.c
+49 -91
@@ -23,24 +23,20 @@ static void update_filtered(ALARM_ENTRY *ae, int64_t unique_id, char *uuid_str)
23
24 char sql[ACLK_SYNC_QUERY_SIZE];
25 snprintfz(sql, sizeof(sql) - 1, SQL_UPDATE_FILTERED_ALERT, uuid_str);
26 - int rc = sqlite3_prepare_v2(db_meta, sql, -1, &res, 0);
27 - if (rc != SQLITE_OK) {
28 - error_report("Failed to prepare statement when trying to update_filtered");
26 +
27 + if (!PREPARE_STATEMENT(db_meta, sql, &res))
28 return;
30 - }
29
30 int param = 0;
31 SQLITE_BIND_FAIL(done, sqlite3_bind_int64(res, ++param, ae->unique_id));
32 SQLITE_BIND_FAIL(done, sqlite3_bind_int64(res, ++param, unique_id));
33
34 param = 0;
37 - rc = sqlite3_step_monitored(res);
38 - if (likely(rc == SQLITE_DONE))
35 + if (likely(sqlite3_step_monitored(res) == SQLITE_DONE))
36 ae->flags |= HEALTH_ENTRY_FLAG_ACLK_QUEUED;
37
38 done:
39 REPORT_BIND_FAIL(res, param);
43 -
40 SQLITE_FINALIZE(res);
41 }
42
@@ -53,11 +49,8 @@ static inline bool is_event_from_alert_variable_config(int64_t unique_id, uuid_t
49 {
50 sqlite3_stmt *res = NULL;
51
56 - int rc = sqlite3_prepare_v2(db_meta, SQL_SELECT_VARIABLE_ALERT_BY_UNIQUE_ID, -1, &res, 0);
57 - if (rc != SQLITE_OK) {
58 - error_report("Failed to prepare statement when trying to check for alert variables.");
52 + if (!PREPARE_STATEMENT(db_meta, SQL_SELECT_VARIABLE_ALERT_BY_UNIQUE_ID, &res))
53 return false;
60 - }
54
55 bool ret = false;
56
@@ -66,15 +59,11 @@ static inline bool is_event_from_alert_variable_config(int64_t unique_id, uuid_t
59 SQLITE_BIND_FAIL(done, sqlite3_bind_blob(res, ++param, host_id, sizeof(*host_id), SQLITE_STATIC));
60
61 param = 0;
69 - rc = sqlite3_step_monitored(res);
70 - if (likely(rc == SQLITE_ROW))
71 - ret = true;
62 + ret = (sqlite3_step_monitored(res) == SQLITE_ROW);
63
64 done:
65 REPORT_BIND_FAIL(res, param);
75 -
66 SQLITE_FINALIZE(res);
77 -
67 return ret;
68 }
69
@@ -103,11 +92,8 @@ static bool should_send_to_cloud(RRDHOST *host, ALARM_ENTRY *ae)
92 //base the search on the last filtered event
93 snprintfz(sql, sizeof(sql) - 1, SQL_SELECT_ALERT_BY_ID, host->aclk_config->uuid_str);
94
106 - int rc = sqlite3_prepare_v2(db_meta, sql, -1, &res, 0);
107 - if (rc != SQLITE_OK) {
108 - error_report("Failed to prepare statement when trying should_send_to_cloud.");
95 + if (!PREPARE_STATEMENT(db_meta, sql, &res))
96 return true;
110 - }
97
98 bool send = false;
99
@@ -116,7 +102,7 @@ static bool should_send_to_cloud(RRDHOST *host, ALARM_ENTRY *ae)
102 SQLITE_BIND_FAIL(done, sqlite3_bind_int(res, ++param, (int) ae->alarm_id));
103
104 param = 0;
119 - rc = sqlite3_step_monitored(res);
105 + int rc = sqlite3_step_monitored(res);
106 if (likely(rc == SQLITE_ROW)) {
107 uuid_t config_hash_id;
108 RRDCALC_STATUS status = (RRDCALC_STATUS)sqlite3_column_int(res, 0);
@@ -135,9 +121,7 @@ static bool should_send_to_cloud(RRDHOST *host, ALARM_ENTRY *ae)
121
122 done:
123 REPORT_BIND_FAIL(res, param);
138 -
124 SQLITE_FINALIZE(res);
140 -
125 return send;
126 }
127
@@ -147,7 +131,7 @@ done:
131
132 void sql_queue_alarm_to_aclk(RRDHOST *host, ALARM_ENTRY *ae, bool skip_filter)
133 {
150 - sqlite3_stmt *res_alert = NULL;
134 + sqlite3_stmt *res = NULL;
135 char sql[ACLK_SYNC_QUERY_SIZE];
136
137 if (!service_running(SERVICE_ACLK))
@@ -164,17 +148,14 @@ void sql_queue_alarm_to_aclk(RRDHOST *host, ALARM_ENTRY *ae, bool skip_filter)
148
149 snprintfz(sql, sizeof(sql) - 1, SQL_QUEUE_ALERT_TO_CLOUD, host->aclk_config->uuid_str);
150
167 - int rc = sqlite3_prepare_v2(db_meta, sql, -1, &res_alert, 0);
168 - if (unlikely(rc != SQLITE_OK)) {
169 - error_report("Failed to prepare statement to store alert event");
151 + if (!PREPARE_STATEMENT(db_meta, sql, &res))
152 return;
171 - }
153
173 - rc = sqlite3_bind_int64(res_alert, 1, ae->unique_id);
174 - if (unlikely(rc != SQLITE_OK))
175 - goto done;
154 + int param = 0;
155 + SQLITE_BIND_FAIL(done, sqlite3_bind_int64(res, ++param, ae->unique_id));
156
177 - rc = execute_insert(res_alert);
157 + param = 0;
158 + int rc = execute_insert(res);
159 if (unlikely(rc == SQLITE_DONE)) {
160 ae->flags |= HEALTH_ENTRY_FLAG_ACLK_QUEUED;
161 rrdhost_flag_set(host, RRDHOST_FLAG_ACLK_STREAM_ALERTS);
@@ -182,7 +163,8 @@ void sql_queue_alarm_to_aclk(RRDHOST *host, ALARM_ENTRY *ae, bool skip_filter)
163 error_report("Failed to store alert event %"PRIu32", rc = %d", ae->unique_id, rc);
164
165 done:
185 - SQLITE_FINALIZE(res_alert);
166 + REPORT_BIND_FAIL(res, param);
167 + SQLITE_FINALIZE(res);
168 }
169
170 int rrdcalc_status_to_proto_enum(RRDCALC_STATUS status)
@@ -275,8 +257,7 @@ static void aclk_push_alert_event(struct aclk_sync_cfg_t *wc __maybe_unused)
257 " ORDER BY aa.sequence_id ASC LIMIT "ACLK_MAX_ALERT_UPDATES,
258 wc->uuid_str);
259
278 - rc = sqlite3_prepare_v2(db_meta, buffer_tostring(sql), -1, &res, 0);
279 - if (rc != SQLITE_OK) {
260 + if (!PREPARE_STATEMENT(db_meta, buffer_tostring(sql), &res)) {
261
262 BUFFER *sql_fix = buffer_create(1024, &netdata_buffers_statistics.buffers_sqlite);
263 buffer_sprintf(sql_fix, TABLE_ACLK_ALERT, wc->uuid_str);
@@ -287,10 +268,7 @@ static void aclk_push_alert_event(struct aclk_sync_cfg_t *wc __maybe_unused)
268 buffer_free(sql_fix);
269
270 // Try again
290 - rc = sqlite3_prepare_v2(db_meta, buffer_tostring(sql), -1, &res, 0);
291 - if (rc != SQLITE_OK) {
292 - error_report("Failed to prepare statement when trying to send an alert update via ACLK");
293 -
271 + if (!PREPARE_STATEMENT(db_meta, buffer_tostring(sql), &res)) {
272 buffer_free(sql);
273 freez(claim_id);
274 return;
@@ -455,24 +433,21 @@ void sql_queue_existing_alerts_to_aclk(RRDHOST *host)
433 "AND hld.updated_by_id = 0 AND hl.host_id = @host_id ORDER BY hld.unique_id ASC ON CONFLICT (alert_unique_id) DO NOTHING",
434 wc->uuid_str);
435
458 - rc = sqlite3_prepare_v2(db_meta, buffer_tostring(sql), -1, &res, 0);
459 - if (rc != SQLITE_OK) {
460 - error_report("Failed to prepare statement when trying to queue existing alerts.");
436 + if (!PREPARE_STATEMENT(db_meta, buffer_tostring(sql), &res))
437 goto skip;
462 - }
438
464 - rc = sqlite3_bind_blob(res, 1, &host->host_uuid, sizeof(host->host_uuid), SQLITE_STATIC);
465 - if (unlikely(rc != SQLITE_OK)) {
466 - error_report("Failed to bind host_id for when trying to queue existing alerts.");
467 - goto done;
468 - }
439 + int param = 0;
440 + SQLITE_BIND_FAIL(done, sqlite3_bind_blob(res, ++param, &host->host_uuid, sizeof(host->host_uuid), SQLITE_STATIC));
441
442 + param = 0;
443 rc = execute_insert(res);
444 if (unlikely(rc != SQLITE_DONE))
445 error_report("Failed to queue existing alerts, rc = %d", rc);
446 else
447 rrdhost_flag_set(host, RRDHOST_FLAG_ACLK_STREAM_ALERTS);
448 +
449 done:
450 + REPORT_BIND_FAIL(res, param);
451 SQLITE_FINALIZE(res);
452
453 skip:
@@ -508,8 +483,6 @@ void aclk_send_alarm_configuration(char *config_hash)
483 void aclk_push_alert_config_event(char *node_id __maybe_unused, char *config_hash __maybe_unused)
484 {
485 #ifdef ENABLE_ACLK
511 - int rc;
512 -
486 sqlite3_stmt *res = NULL;
487 struct aclk_sync_cfg_t *wc;
488
@@ -521,27 +494,22 @@ void aclk_push_alert_config_event(char *node_id __maybe_unused, char *config_has
494 return;
495 }
496
524 - rc = sqlite3_prepare_v2(db_meta, SQL_SELECT_ALERT_CONFIG, -1, &res, 0);
525 - if (rc != SQLITE_OK) {
526 - error_report("Failed to prepare statement when trying to fetch an alarm hash configuration");
497 + if (!PREPARE_STATEMENT(db_meta, SQL_SELECT_ALERT_CONFIG, &res))
498 return;
528 - }
499
500 uuid_t hash_uuid;
501 if (uuid_parse(config_hash, hash_uuid))
502 return;
503
534 - rc = sqlite3_bind_blob(res, 1, &hash_uuid , sizeof(hash_uuid), SQLITE_STATIC);
535 - if (unlikely(rc != SQLITE_OK))
536 - goto bind_fail;
504 + int param = 0;
505 + SQLITE_BIND_FAIL(done, sqlite3_bind_blob(res, ++param, &hash_uuid , sizeof(hash_uuid), SQLITE_STATIC));
506
507 struct aclk_alarm_configuration alarm_config;
508 struct provide_alarm_configuration p_alarm_config;
509 p_alarm_config.cfg_hash = NULL;
510
511 + param = 0;
512 if (sqlite3_step_monitored(res) == SQLITE_ROW) {
543 -
544 - int param = 0;
513 alarm_config.alarm = SQLITE3_COLUMN_STRDUPZ_OR_NULL(res, param++);
514 alarm_config.tmpl = SQLITE3_COLUMN_STRDUPZ_OR_NULL(res, param++);
515 alarm_config.on_chart = SQLITE3_COLUMN_STRDUPZ_OR_NULL(res, param++);
@@ -600,6 +568,8 @@ void aclk_push_alert_config_event(char *node_id __maybe_unused, char *config_has
568 p_alarm_config.cfg = alarm_config;
569 }
570
571 + param = 0;
572 +
573 if (likely(p_alarm_config.cfg_hash)) {
574 nd_log(NDLS_ACCESS, NDLP_DEBUG, "ACLK RES [%s (%s)]: Sent alert config %s.", wc->node_id, wc->host ? rrdhost_hostname(wc->host) : "N/A", config_hash);
575 aclk_send_provide_alarm_cfg(&p_alarm_config);
@@ -609,9 +579,9 @@ void aclk_push_alert_config_event(char *node_id __maybe_unused, char *config_has
579 else
580 nd_log(NDLS_ACCESS, NDLP_WARNING, "ACLK STA [%s (%s)]: Alert config for %s not found.", wc->node_id, wc->host ? rrdhost_hostname(wc->host) : "N/A", config_hash);
581
612 -bind_fail:
582 +done:
583 + REPORT_BIND_FAIL(res, param);
584 SQLITE_FINALIZE(res);
614 -
585 freez(config_hash);
586 freez(node_id);
587 #endif
@@ -666,31 +636,27 @@ void sql_process_queue_removed_alerts_to_aclk(char *node_id)
636 if (unlikely(!host || !(wc = host->aclk_config)))
637 return;
638
669 - char sql[ACLK_SYNC_QUERY_SIZE * 2];
639 sqlite3_stmt *res = NULL;
640
672 - snprintfz(sql, sizeof(sql) - 1, SQL_QUEUE_REMOVE_ALERTS, wc->uuid_str, wc->uuid_str);
641 + CLEAN_BUFFER *wb = buffer_create(1024, NULL); // Note buffer auto free on function return
642 + buffer_sprintf(wb, SQL_QUEUE_REMOVE_ALERTS, wc->uuid_str, wc->uuid_str);
643
674 - int rc = sqlite3_prepare_v2(db_meta, sql, -1, &res, 0);
675 - if (rc != SQLITE_OK) {
676 - error_report("Failed to prepare statement when trying to queue removed alerts.");
644 + if (!PREPARE_STATEMENT(db_meta, buffer_tostring(wb), &res))
645 return;
678 - }
646
680 - rc = sqlite3_bind_blob(res, 1, &host->host_uuid, sizeof(host->host_uuid), SQLITE_STATIC);
681 - if (unlikely(rc != SQLITE_OK)) {
682 - error_report("Failed to bind host_id for when trying to queue remvoed alerts.");
683 - goto skip;
684 - }
647 + int param = 0;
648 + SQLITE_BIND_FAIL(done, sqlite3_bind_blob(res, ++param, &host->host_uuid, sizeof(host->host_uuid), SQLITE_STATIC));
649
686 - rc = execute_insert(res);
650 + param = 0;
651 + int rc = execute_insert(res);
652 if (likely(rc == SQLITE_DONE)) {
653 nd_log(NDLS_ACCESS, NDLP_DEBUG, "ACLK STA [%s (%s)]: QUEUED REMOVED ALERTS", wc->node_id, rrdhost_hostname(wc->host));
654 rrdhost_flag_set(wc->host, RRDHOST_FLAG_ACLK_STREAM_ALERTS);
655 wc->alert_queue_removed = 0;
656 }
657
693 -skip:
658 +done:
659 + REPORT_BIND_FAIL(res, param);
660 SQLITE_FINALIZE(res);
661 }
662
@@ -932,23 +898,19 @@ void sql_aclk_alert_clean_dead_entries(RRDHOST *host)
898 snprintfz(sql, sizeof(sql) - 1, SQL_DELETE_ALERT_ENTRIES, wc->uuid_str);
899
900 sqlite3_stmt *res = NULL;
935 - int rc = sqlite3_prepare_v2(db_meta, sql, -1, &res, 0);
936 - if (rc != SQLITE_OK) {
937 - error_report("Failed to prepare statement for cleaning stale ACLK alert entries.");
901 +
902 + if (!PREPARE_STATEMENT(db_meta, sql, &res))
903 return;
939 - }
904
941 - rc = sqlite3_bind_int64(res, 1, MAX_REMOVED_PERIOD);
942 - if (unlikely(rc != SQLITE_OK)) {
943 - error_report("Failed to bind MAX_REMOVED_PERIOD parameter.");
944 - goto skip;
945 - }
905 + int param = 0;
906 + SQLITE_BIND_FAIL(done, sqlite3_bind_int64(res, ++param, MAX_REMOVED_PERIOD));
907
947 - rc = sqlite3_step_monitored(res);
908 + int rc = sqlite3_step_monitored(res);
909 if (rc != SQLITE_DONE)
910 error_report("Failed to execute DELETE query for cleaning stale ACLK alert entries.");
911
951 -skip:
912 +done:
913 + REPORT_BIND_FAIL(res, param);
914 SQLITE_FINALIZE(res);
915 }
916
@@ -965,15 +927,11 @@ int get_proto_alert_status(RRDHOST *host, struct proto_alert_status *proto_alert
927 proto_alert_status->alert_updates = wc->alert_updates;
928
929 char sql[ACLK_SYNC_QUERY_SIZE];
968 -
969 - sqlite3_stmt *res = NULL;
930 snprintfz(sql, sizeof(sql) - 1, SQL_GET_MIN_MAX_ALERT_SEQ, wc->uuid_str, wc->uuid_str);
931
972 - int rc = sqlite3_prepare_v2(db_meta, sql, -1, &res, 0);
973 - if (rc != SQLITE_OK) {
974 - error_report("Failed to prepare statement to get alert log status from the database.");
932 + sqlite3_stmt *res = NULL;
933 + if (!PREPARE_STATEMENT(db_meta, sql, &res))
934 return 1;
976 - }
935
936 while (sqlite3_step_monitored(res) == SQLITE_ROW) {
937 proto_alert_status->pending_min_sequence_id =
src/database/sqlite/sqlite_context.c
+13 -50
@@ -80,7 +80,6 @@ int sql_init_context_database(int memory)
80
81 void ctx_get_chart_list(uuid_t *host_uuid, void (*dict_cb)(SQL_CHART_DATA *, void *), void *data)
82 {
83 - int rc;
83 static __thread sqlite3_stmt *res = NULL;
84
85 if (unlikely(!host_uuid)) {
@@ -88,13 +87,9 @@ void ctx_get_chart_list(uuid_t *host_uuid, void (*dict_cb)(SQL_CHART_DATA *, voi
87 return;
88 }
89
91 - if (unlikely(!res)) {
92 - rc = prepare_statement(db_meta, CTX_GET_CHART_LIST, &res);
93 - if (rc != SQLITE_OK) {
94 - error_report("Failed to prepare statement to fetch chart list");
95 - return;
96 - }
97 - }
90 + if (!PREPARE_COMPILED_STATEMENT(db_meta, CTX_GET_CHART_LIST, &res))
91 + return;
92 +
93 int param = 0;
94 SQLITE_BIND_FAIL(done, sqlite3_bind_blob(res, ++param, host_uuid, sizeof(*host_uuid), SQLITE_STATIC));
95
@@ -116,7 +111,6 @@ void ctx_get_chart_list(uuid_t *host_uuid, void (*dict_cb)(SQL_CHART_DATA *, voi
111
112 done:
113 REPORT_BIND_FAIL(res, param);
119 -
114 SQLITE_RESET(res);
115 }
116
@@ -125,16 +119,10 @@ done:
119 "FROM dimension d WHERE d.chart_id = @id AND d.dim_id IS NOT NULL ORDER BY d.rowid ASC"
120 void ctx_get_dimension_list(uuid_t *chart_uuid, void (*dict_cb)(SQL_DIMENSION_DATA *, void *), void *data)
121 {
128 - int rc;
122 static __thread sqlite3_stmt *res = NULL;
123
131 - if (unlikely(!res)) {
132 - rc = prepare_statement(db_meta, CTX_GET_DIMENSION_LIST, &res);
133 - if (rc != SQLITE_OK) {
134 - error_report("Failed to prepare statement to fetch chart dimension data");
135 - return;
136 - }
137 - }
124 + if (!PREPARE_COMPILED_STATEMENT(db_meta, CTX_GET_DIMENSION_LIST, &res))
125 + return;
126
127 int param = 0;
128 SQLITE_BIND_FAIL(done, sqlite3_bind_blob(res, ++param, chart_uuid, sizeof(*chart_uuid), SQLITE_STATIC));
@@ -152,7 +140,6 @@ void ctx_get_dimension_list(uuid_t *chart_uuid, void (*dict_cb)(SQL_DIMENSION_DA
140
141 done:
142 REPORT_BIND_FAIL(res, param);
155 -
143 SQLITE_RESET(res);
144 }
145
@@ -161,16 +148,10 @@ done:
148
149 void ctx_get_label_list(uuid_t *chart_uuid, void (*dict_cb)(SQL_CLABEL_DATA *, void *), void *data)
150 {
164 - int rc;
151 static __thread sqlite3_stmt *res = NULL;
152
167 - if (unlikely(!res)) {
168 - rc = prepare_statement(db_context_meta, CTX_GET_LABEL_LIST, &res);
169 - if (rc != SQLITE_OK) {
170 - error_report("Failed to prepare statement to fetch chart labels");
171 - return;
172 - }
173 - }
153 + if (!PREPARE_COMPILED_STATEMENT(db_context_meta, CTX_GET_LABEL_LIST, &res))
154 + return;
155
156 int param = 0;
157 SQLITE_BIND_FAIL(done, sqlite3_bind_blob(res, ++param, chart_uuid, sizeof(*chart_uuid), SQLITE_STATIC));
@@ -187,7 +168,6 @@ void ctx_get_label_list(uuid_t *chart_uuid, void (*dict_cb)(SQL_CLABEL_DATA *, v
168
169 done:
170 REPORT_BIND_FAIL(res, param);
190 -
171 SQLITE_RESET(res);
172 }
173
@@ -201,16 +181,10 @@ void ctx_get_context_list(uuid_t *host_uuid, void (*dict_cb)(VERSIONED_CONTEXT_D
181 if (unlikely(!host_uuid))
182 return;
183
204 - int rc;
184 static __thread sqlite3_stmt *res = NULL;
185
207 - if (unlikely(!res)) {
208 - rc = prepare_statement(db_context_meta, CTX_GET_CONTEXT_LIST, &res);
209 - if (rc != SQLITE_OK) {
210 - error_report("Failed to prepare statement to fetch stored context list");
211 - return;
212 - }
213 - }
186 + if (!PREPARE_COMPILED_STATEMENT(db_context_meta, CTX_GET_CONTEXT_LIST, &res))
187 + return;
188
189 VERSIONED_CONTEXT_DATA context_data = {0};
190
@@ -234,7 +208,6 @@ void ctx_get_context_list(uuid_t *host_uuid, void (*dict_cb)(VERSIONED_CONTEXT_D
208
209 done:
210 REPORT_BIND_FAIL(res, param);
237 -
211 SQLITE_RESET(res);
212 }
213
@@ -249,17 +222,14 @@ done:
222
223 int ctx_store_context(uuid_t *host_uuid, VERSIONED_CONTEXT_DATA *context_data)
224 {
252 - int rc, rc_stored = 1;
225 + int rc_stored = 1;
226 sqlite3_stmt *res = NULL;
227
228 if (unlikely(!host_uuid || !context_data || !context_data->id))
229 return 0;
230
258 - rc = sqlite3_prepare_v2(db_context_meta, CTX_STORE_CONTEXT, -1, &res, 0);
259 - if (unlikely(rc != SQLITE_OK)) {
260 - error_report("Failed to prepare statement to store context");
231 + if (!PREPARE_STATEMENT(db_context_meta, CTX_STORE_CONTEXT, &res))
232 return 1;
262 - }
233
234 int param = 0;
235 SQLITE_BIND_FAIL(done, sqlite3_bind_blob(res, ++param, host_uuid, sizeof(*host_uuid), SQLITE_STATIC));
@@ -282,9 +252,7 @@ int ctx_store_context(uuid_t *host_uuid, VERSIONED_CONTEXT_DATA *context_data)
252
253 done:
254 REPORT_BIND_FAIL(res, param);
285 -
255 SQLITE_FINALIZE(res);
287 -
256 return (rc_stored != SQLITE_DONE);
257 }
258
@@ -293,17 +261,14 @@ done:
261 #define CTX_DELETE_CONTEXT "DELETE FROM context WHERE host_id = @host_id AND id = @context"
262 int ctx_delete_context(uuid_t *host_uuid, VERSIONED_CONTEXT_DATA *context_data)
263 {
296 - int rc, rc_stored = 1;
264 + int rc_stored = 1;
265 sqlite3_stmt *res = NULL;
266
267 if (unlikely(!context_data || !context_data->id))
268 return 0;
269
302 - rc = sqlite3_prepare_v2(db_context_meta, CTX_DELETE_CONTEXT, -1, &res, 0);
303 - if (unlikely(rc != SQLITE_OK)) {
304 - error_report("Failed to prepare statement to delete context");
270 + if (!PREPARE_STATEMENT(db_context_meta, CTX_DELETE_CONTEXT, &res))
271 return 1;
306 - }
272
273 int param = 0;
274 SQLITE_BIND_FAIL(done, sqlite3_bind_blob(res, ++param, host_uuid, sizeof(*host_uuid), SQLITE_STATIC));
@@ -317,9 +282,7 @@ int ctx_delete_context(uuid_t *host_uuid, VERSIONED_CONTEXT_DATA *context_data)
282
283 done:
284 REPORT_BIND_FAIL(res, param);
320 -
285 SQLITE_FINALIZE(res);
322 -
286 return (rc_stored != SQLITE_DONE);
287 }
288
src/database/sqlite/sqlite_functions.c
+5 -10
@@ -279,17 +279,12 @@ void sql_drop_table(const char *table)
279 static int get_pragma_value(sqlite3 *database, const char *sql)
280 {
281 sqlite3_stmt *res = NULL;
282 - int rc = sqlite3_prepare_v2(database, sql, -1, &res, 0);
283 - if (unlikely(rc != SQLITE_OK))
284 - return -1;
285 -
282 int result = -1;
287 - rc = sqlite3_step_monitored(res);
288 - if (likely(rc == SQLITE_ROW))
289 - result = sqlite3_column_int(res, 0);
290 -
291 - SQLITE_FINALIZE(res);
292 -
283 + if (PREPARE_STATEMENT(database, sql, &res)) {
284 + if (likely(sqlite3_step_monitored(res) == SQLITE_ROW))
285 + result = sqlite3_column_int(res, 0);
286 + SQLITE_FINALIZE(res);
287 + }
288 return result;
289 }
290
src/database/sqlite/sqlite_functions.h
+33
@@ -48,6 +48,39 @@ void analytics_set_data_str(char **name, const char *value);
48 } \
49 } while (0)
50
51 +#define REQUIRE_DB(db) \
52 + ({ \
53 + if (unlikely(!(db))) { \
54 + if (default_rrd_memory_mode == RRD_MEMORY_MODE_DBENGINE) \
55 + error_report("Database has not been initialized in %s", __FUNCTION__); \
56 + } \
57 + (db) != NULL; \
58 + })
59 +
60 +#define PREPARE_COMPILED_STATEMENT(db, sql, stmt_ptr) \
61 + ({ \
62 + bool _ret = true; \
63 + if ((!*(stmt_ptr))) { \
64 + int _rc = prepare_statement((db), (sql), stmt_ptr); \
65 + if (_rc != SQLITE_OK) { \
66 + internal_error(true, "Failed to prepare statement \"%s\", rc=%d in %s", (sql), _rc, __FUNCTION__); \
67 + nd_log(NDLS_DAEMON, NDLP_ERR, "Failed to prepare statement, rc=%d in %s", _rc, __FUNCTION__); \
68 + } \
69 + _ret = (_rc == SQLITE_OK); \
70 + } \
71 + _ret; \
72 + })
73 +
74 +#define PREPARE_STATEMENT(db, sql, stmt_ptr) \
75 + ({ \
76 + int _rc = sqlite3_prepare_v2((db), (sql), -1, stmt_ptr, 0); \
77 + if (_rc != SQLITE_OK) { \
78 + internal_error(true, "Failed to prepare statement \"%s\", rc=%d in %s", (sql), _rc, __FUNCTION__); \
79 + nd_log(NDLS_DAEMON, NDLP_ERR, "Failed to prepare statement, rc=%d in %s", _rc, __FUNCTION__); \
80 + } \
81 + _rc == SQLITE_OK; \
82 + })
83 +
84 #define SQL_MAX_RETRY (100)
85 #define SQLITE_INSERT_DELAY (10) // Insert delay in case of lock
86
src/database/sqlite/sqlite_health.c
+84 -220
@@ -29,19 +29,10 @@ static void sql_health_alarm_log_update(RRDHOST *host, ALARM_ENTRY *ae)
29 static __thread sqlite3_stmt *res = NULL;
30 int rc;
31
32 - if (unlikely(!db_meta)) {
33 - if (default_rrd_memory_mode == RRD_MEMORY_MODE_DBENGINE)
34 - error_report("HEALTH [%s]: Database has not been initialized", rrdhost_hostname(host));
35 - return;
36 - }
32 + REQUIRE_DB(db_meta);
33
38 - if (unlikely(!res)) {
39 - rc = prepare_statement(db_meta, SQL_UPDATE_HEALTH_LOG, &res);
40 - if (unlikely(rc != SQLITE_OK)) {
41 - error_report("HEALTH [%s]: Failed to prepare statement for SQL_UPDATE_HEALTH_LOG", rrdhost_hostname(host));
42 - return;
43 - }
44 - }
34 + if (!PREPARE_COMPILED_STATEMENT(db_meta, SQL_UPDATE_HEALTH_LOG, &res))
35 + return;
36
37 int param = 0;
38 SQLITE_BIND_FAIL(done, sqlite3_bind_int64(res, ++param, (sqlite3_int64) ae->updated_by_id));
@@ -60,7 +51,6 @@ static void sql_health_alarm_log_update(RRDHOST *host, ALARM_ENTRY *ae)
51
52 done:
53 REPORT_BIND_FAIL(res, param);
63 -
54 SQLITE_RESET(res);
55 }
56
@@ -82,14 +72,8 @@ static void sql_health_alarm_log_insert_detail(RRDHOST *host, uint64_t health_lo
72 static __thread sqlite3_stmt *res = NULL;
73 int rc;
74
85 - if (unlikely(!res)) {
86 - rc = prepare_statement(db_meta, SQL_INSERT_HEALTH_LOG_DETAIL, &res);
87 - if (unlikely(rc != SQLITE_OK)) {
88 - error_report(
89 - "HEALTH [%s]: Failed to prepare statement for SQL_INSERT_HEALTH_LOG_DETAIL", rrdhost_hostname(host));
90 - return;
91 - }
92 - }
75 + if (!PREPARE_COMPILED_STATEMENT(db_meta, SQL_INSERT_HEALTH_LOG_DETAIL, &res))
76 + return;
77
78 int param = 0;
79 SQLITE_BIND_FAIL(done, sqlite3_bind_int64(res, ++param, (sqlite3_int64)health_log_id));
@@ -126,7 +110,6 @@ static void sql_health_alarm_log_insert_detail(RRDHOST *host, uint64_t health_lo
110
111 done:
112 REPORT_BIND_FAIL(res, param);
129 -
113 SQLITE_RESET(res);
114 }
115
@@ -144,19 +127,10 @@ static void sql_health_alarm_log_insert(RRDHOST *host, ALARM_ENTRY *ae)
127 int rc;
128 uint64_t health_log_id;
129
147 - if (unlikely(!db_meta)) {
148 - if (default_rrd_memory_mode == RRD_MEMORY_MODE_DBENGINE)
149 - error_report("HEALTH [%s]: Database has not been initialized", rrdhost_hostname(host));
150 - return;
151 - }
130 + REQUIRE_DB(db_meta);
131
153 - if (unlikely(!res)) {
154 - rc = prepare_statement(db_meta, SQL_INSERT_HEALTH_LOG, &res);
155 - if (unlikely(rc != SQLITE_OK)) {
156 - error_report("HEALTH [%s]: Failed to prepare statement for SQL_INSERT_HEALTH_LOG", rrdhost_hostname(host));
157 - return;
158 - }
159 - }
132 + if (!PREPARE_COMPILED_STATEMENT(db_meta, SQL_INSERT_HEALTH_LOG, &res))
133 + return;
134
135 int param = 0;
136 SQLITE_BIND_FAIL(done, sqlite3_bind_blob(res, ++param, &host->host_uuid, sizeof(host->host_uuid), SQLITE_STATIC));
@@ -181,7 +155,6 @@ static void sql_health_alarm_log_insert(RRDHOST *host, ALARM_ENTRY *ae)
155
156 done:
157 REPORT_BIND_FAIL(res, param);
184 -
158 SQLITE_RESET(res);
159 }
160
@@ -228,11 +201,7 @@ void sql_health_alarm_log_cleanup(RRDHOST *host, bool claimed) {
201 int rc;
202 char command[MAX_HEALTH_SQL_SIZE + 1];
203
231 - if (unlikely(!db_meta)) {
232 - if (default_rrd_memory_mode == RRD_MEMORY_MODE_DBENGINE)
233 - error_report("Database has not been initialized");
234 - return;
235 - }
204 + REQUIRE_DB(db_meta);
205
206 char uuid_str[UUID_STR_LEN];
207 uuid_unparse_lower_fix(&host->host_uuid, uuid_str);
@@ -247,11 +216,8 @@ void sql_health_alarm_log_cleanup(RRDHOST *host, bool claimed) {
216 sql = command;
217 }
218
250 - rc = sqlite3_prepare_v2(db_meta, sql, -1, &res, 0);
251 - if (unlikely(rc != SQLITE_OK)) {
252 - error_report("Failed to prepare statement to cleanup health log detail table (claimed)");
219 + if (!PREPARE_STATEMENT(db_meta, sql, &res))
220 return;
254 - }
221
222 int param = 0;
223 SQLITE_BIND_FAIL(done, sqlite3_bind_blob(res, ++param, &host->host_uuid, sizeof(host->host_uuid), SQLITE_STATIC));
@@ -267,7 +233,6 @@ void sql_health_alarm_log_cleanup(RRDHOST *host, bool claimed) {
233
234 done:
235 REPORT_BIND_FAIL(res, param);
270 -
236 SQLITE_FINALIZE(res);
237 }
238
@@ -286,14 +251,11 @@ done:
251
252 bool sql_update_removed_in_health_log(RRDHOST *host, uint32_t alarm_id, uuid_t *transition_id, uuid_t *last_transition)
253 {
289 - int rc;
254 + int rc = 0;
255 sqlite3_stmt *res;
256
292 - rc = sqlite3_prepare_v2(db_meta, SQL_INJECT_REMOVED_UPDATE_LOG, -1, &res, 0);
293 - if (rc != SQLITE_OK) {
294 - error_report("Failed to prepare statement when trying to update health_log during inject removed event");
257 + if (!PREPARE_STATEMENT(db_meta, SQL_INJECT_REMOVED_UPDATE_LOG, &res))
258 return false;
296 - }
259
260 int param = 0;
261 SQLITE_BIND_FAIL(done, sqlite3_bind_blob(res, ++param, transition_id, sizeof(*transition_id), SQLITE_STATIC));
@@ -308,7 +270,6 @@ bool sql_update_removed_in_health_log(RRDHOST *host, uint32_t alarm_id, uuid_t *
270
271 done:
272 REPORT_BIND_FAIL(res, param);
311 -
273 SQLITE_FINALIZE(res);
274
275 return (param == 0 && rc == SQLITE_DONE);
@@ -316,14 +277,11 @@ done:
277
278 bool sql_update_removed_in_health_log_detail(uint32_t unique_id, uint32_t max_unique_id, uuid_t *prev_transition_id)
279 {
319 - int rc;
280 + int rc = 0;
281 sqlite3_stmt *res;
282
322 - rc = sqlite3_prepare_v2(db_meta, SQL_INJECT_REMOVED_UPDATE_DETAIL, -1, &res, 0);
323 - if (rc != SQLITE_OK) {
324 - error_report("Failed to prepare statement when trying to update health_log_detail during inject removed event");
283 + if (!PREPARE_STATEMENT(db_meta, SQL_INJECT_REMOVED_UPDATE_DETAIL, &res))
284 return false;
326 - }
285
286 int param = 0;
287 SQLITE_BIND_FAIL(done, sqlite3_bind_int64(res, ++param, (sqlite3_int64) HEALTH_ENTRY_FLAG_UPDATED));
@@ -338,7 +296,6 @@ bool sql_update_removed_in_health_log_detail(uint32_t unique_id, uint32_t max_un
296
297 done:
298 REPORT_BIND_FAIL(res, param);
341 -
299 SQLITE_FINALIZE(res);
300
301 return (param == 0 && rc == SQLITE_DONE);
@@ -352,18 +309,13 @@ void sql_inject_removed_status(
309 uint32_t max_unique_id,
310 uuid_t *last_transition)
311 {
355 - int rc;
356 -
312 if (!alarm_id || !alarm_event_id || !unique_id || !max_unique_id)
313 return;
314
315 sqlite3_stmt *res = NULL;
316
362 - rc = sqlite3_prepare_v2(db_meta, SQL_INJECT_REMOVED, -1, &res, 0);
363 - if (rc != SQLITE_OK) {
364 - error_report("Failed to prepare statement when trying to inject removed event");
317 + if (!PREPARE_STATEMENT(db_meta, SQL_INJECT_REMOVED, &res))
318 return;
366 - }
319
320 uuid_t transition_id;
321 uuid_generate_random(transition_id);
@@ -378,7 +330,7 @@ void sql_inject_removed_status(
330 SQLITE_BIND_FAIL(done, sqlite3_bind_blob(res, ++param, last_transition, sizeof(*last_transition), SQLITE_STATIC));
331
332 param = 0;
381 - rc = execute_insert(res);
333 + int rc = execute_insert(res);
334 if (rc == SQLITE_DONE) {
335 //update the old entry in health_log_detail
336 sql_update_removed_in_health_log_detail(unique_id, max_unique_id, last_transition);
@@ -390,7 +342,6 @@ void sql_inject_removed_status(
342
343 done:
344 REPORT_BIND_FAIL(res, param);
393 -
345 SQLITE_FINALIZE(res);
346 }
347
@@ -400,31 +351,24 @@ done:
351
352 uint32_t sql_get_max_unique_id (RRDHOST *host)
353 {
403 - int rc;
354 uint32_t max_unique_id = 0;
355
356 sqlite3_stmt *res = NULL;
357
408 - rc = sqlite3_prepare_v2(db_meta, SQL_SELECT_MAX_UNIQUE_ID, -1, &res, 0);
409 - if (rc != SQLITE_OK) {
410 - error_report("Failed to prepare statement when trying to get max unique id");
411 - return 0;
412 - }
413 -
414 - rc = sqlite3_bind_blob(res, 1, &host->host_uuid, sizeof(host->host_uuid), SQLITE_STATIC);
415 - if (unlikely(rc != SQLITE_OK)) {
416 - error_report("Failed to bind host_id parameter for SQL_SELECT_MAX_UNIQUE_ID.");
417 - SQLITE_FINALIZE(res);
358 + if (!PREPARE_STATEMENT(db_meta, SQL_SELECT_MAX_UNIQUE_ID, &res))
359 return 0;
419 - }
360
421 - while (sqlite3_step_monitored(res) == SQLITE_ROW) {
422 - max_unique_id = (uint32_t) sqlite3_column_int64(res, 0);
423 - }
361 + int param = 0;
362 + SQLITE_BIND_FAIL(done, sqlite3_bind_blob(res, ++param, &host->host_uuid, sizeof(host->host_uuid), SQLITE_STATIC));
363
425 - SQLITE_FINALIZE(res);
364 + param = 0;
365 + while (sqlite3_step_monitored(res) == SQLITE_ROW)
366 + max_unique_id = (uint32_t)sqlite3_column_int64(res, 0);
367
427 - return max_unique_id;
368 +done:
369 + REPORT_BIND_FAIL(res, param);
370 + SQLITE_FINALIZE(res);
371 + return max_unique_id;
372 }
373
374 #define SQL_SELECT_LAST_STATUSES \
@@ -433,24 +377,17 @@ uint32_t sql_get_max_unique_id (RRDHOST *host)
377
378 void sql_check_removed_alerts_state(RRDHOST *host)
379 {
436 - int rc;
380 uint32_t max_unique_id = 0;
381 sqlite3_stmt *res = NULL;
382 uuid_t transition_id;
383
441 - rc = sqlite3_prepare_v2(db_meta, SQL_SELECT_LAST_STATUSES, -1, &res, 0);
442 - if (rc != SQLITE_OK) {
443 - error_report("Failed to prepare statement when trying to check removed statuses");
384 + if (!PREPARE_STATEMENT(db_meta, SQL_SELECT_LAST_STATUSES, &res))
385 return;
445 - }
386
447 - rc = sqlite3_bind_blob(res, 1, &host->host_uuid, sizeof(host->host_uuid), SQLITE_STATIC);
448 - if (unlikely(rc != SQLITE_OK)) {
449 - error_report("Failed to bind host_id parameter for SQL_SELECT_LAST_STATUSES.");
450 - SQLITE_FINALIZE(res);
451 - return;
452 - }
387 + int param = 0;
388 + SQLITE_BIND_FAIL(done, sqlite3_bind_blob(res, ++param, &host->host_uuid, sizeof(host->host_uuid), SQLITE_STATIC));
389
390 + param = 0;
391 while (sqlite3_step_monitored(res) == SQLITE_ROW) {
392 uint32_t alarm_id, alarm_event_id, unique_id;
393 RRDCALC_STATUS status;
@@ -468,7 +405,8 @@ void sql_check_removed_alerts_state(RRDHOST *host)
405 sql_inject_removed_status(host, alarm_id, alarm_event_id, unique_id, ++max_unique_id, &transition_id);
406 }
407 }
471 -
408 +done:
409 + REPORT_BIND_FAIL(res, param);
410 SQLITE_FINALIZE(res);
411 }
412
@@ -476,32 +414,28 @@ void sql_check_removed_alerts_state(RRDHOST *host)
414 "DELETE FROM health_log WHERE host_id = @host_id AND chart NOT IN " \
415 "(SELECT type||'.'||id FROM chart WHERE host_id = @host_id)"
416
479 -static void sql_remove_alerts_from_deleted_charts(RRDHOST *host, uuid_t *host_id)
417 +static void sql_remove_alerts_from_deleted_charts(RRDHOST *host, uuid_t *host_uuid)
418 {
419 sqlite3_stmt *res = NULL;
420 int ret;
421
484 - ret = sqlite3_prepare_v2(db_meta, SQL_DELETE_MISSING_CHART_ALERT, -1, &res, 0);
485 - if (unlikely(ret != SQLITE_OK)) {
486 - error_report("HEALTH [%s]: Failed to prepare sql statement to sql_remove_alerts_from_deleted_charts", rrdhost_hostname(host));
422 + uuid_t *actual_uuid = host ? &host->host_uuid : host_uuid;
423 + if (!actual_uuid)
424 return;
488 - }
489 -
490 - if (host)
491 - ret = sqlite3_bind_blob(res, 1, &host->host_uuid, sizeof(host->host_uuid), SQLITE_STATIC);
492 - else
493 - ret = sqlite3_bind_blob(res, 1, host_id, sizeof(*host_id), SQLITE_STATIC);
425
495 - if (unlikely(ret != SQLITE_OK)) {
496 - error_report("Failed to bind host_id parameter for sql_remove_alerts_from_deleted_charts.");
497 - SQLITE_FINALIZE(res);
426 + if (!PREPARE_STATEMENT(db_meta, SQL_DELETE_MISSING_CHART_ALERT, &res))
427 return;
499 - }
428
429 + int param = 0;
430 + SQLITE_BIND_FAIL(done, sqlite3_bind_blob(res, ++param, actual_uuid, sizeof(*actual_uuid), SQLITE_STATIC));
431 +
432 + param = 0;
433 ret = execute_insert(res);
434 if (ret != SQLITE_DONE)
435 error_report("Failed to execute command to delete missing charts from health_log");
436
437 +done:
438 + REPORT_BIND_FAIL(res, param);
439 SQLITE_FINALIZE(res);
440 }
441
@@ -558,19 +492,13 @@ void sql_health_alarm_log_load(RRDHOST *host)
492 int ret;
493 ssize_t errored = 0, loaded = 0;
494
561 - if (unlikely(!db_meta)) {
562 - if (default_rrd_memory_mode == RRD_MEMORY_MODE_DBENGINE)
563 - error_report("HEALTH [%s]: Database has not been initialized", rrdhost_hostname(host));
495 + if (!REQUIRE_DB(db_meta))
496 return;
565 - }
497
498 sql_check_removed_alerts_state(host);
499
569 - ret = sqlite3_prepare_v2(db_meta, SQL_LOAD_HEALTH_LOG, -1, &res, 0);
570 - if (unlikely(ret != SQLITE_OK)) {
571 - error_report("HEALTH [%s]: Failed to prepare sql statement to load health log.", rrdhost_hostname(host));
500 + if (!PREPARE_STATEMENT(db_meta, SQL_LOAD_HEALTH_LOG, &res))
501 return;
573 - }
502
503 ret = sqlite3_bind_blob(res, 1, &host->host_uuid, sizeof(host->host_uuid), SQLITE_STATIC);
504 if (unlikely(ret != SQLITE_OK)) {
@@ -746,20 +674,15 @@ void sql_health_alarm_log_load(RRDHOST *host)
674 void sql_alert_store_config(RRD_ALERT_PROTOTYPE *ap __maybe_unused)
675 {
676 static __thread sqlite3_stmt *res = NULL;
749 - int rc, param = 0;
677 + int param = 0;
678
751 - if (unlikely(!res)) {
752 - rc = prepare_statement(db_meta, SQL_STORE_ALERT_CONFIG_HASH, &res);
753 - if (unlikely(rc != SQLITE_OK)) {
754 - error_report("Failed to prepare statement to store alert configuration, rc = %d", rc);
755 - return;
756 - }
757 - }
679 + if (!PREPARE_COMPILED_STATEMENT(db_meta, SQL_STORE_ALERT_CONFIG_HASH, &res))
680 + return;
681
682 BUFFER *buf = buffer_create(128, NULL);
683
684 SQLITE_BIND_FAIL(
762 - done, rc = sqlite3_bind_blob(res, ++param, &ap->config.hash_id, sizeof(ap->config.hash_id), SQLITE_STATIC));
685 + done, sqlite3_bind_blob(res, ++param, &ap->config.hash_id, sizeof(ap->config.hash_id), SQLITE_STATIC));
686
687 if (ap->match.is_template) {
688 SQLITE_BIND_FAIL(done, SQLITE3_BIND_STRING_OR_NULL(res, ++param, NULL));
@@ -850,13 +773,13 @@ void sql_alert_store_config(RRD_ALERT_PROTOTYPE *ap __maybe_unused)
773 SQLITE_BIND_FAIL(done, sqlite3_bind_int(res, ++param, ap->config.data_source));
774
775 param = 0;
853 - rc = execute_insert(res);
776 + int rc = execute_insert(res);
777 if (unlikely(rc != SQLITE_DONE))
778 error_report("Failed to store alert config, rc = %d", rc);
779
780 done:
858 - REPORT_BIND_FAIL(res, param);
781 buffer_free(buf);
782 + REPORT_BIND_FAIL(res, param);
783 SQLITE_RESET(res);
784 }
785
@@ -867,39 +790,19 @@ done:
790
791 int sql_health_get_last_executed_event(RRDHOST *host, ALARM_ENTRY *ae, RRDCALC_STATUS *last_executed_status)
792 {
870 - int rc = 0, ret = -1;
793 + int ret = -1;
794 sqlite3_stmt *res = NULL;
795
873 - rc = sqlite3_prepare_v2(db_meta, SQL_SELECT_HEALTH_LAST_EXECUTED_EVENT, -1, &res, 0);
874 - if (rc != SQLITE_OK) {
875 - error_report("Failed to prepare statement when trying to get last executed status");
796 + if (!PREPARE_STATEMENT(db_meta, SQL_SELECT_HEALTH_LAST_EXECUTED_EVENT, &res))
797 return ret;
877 - }
878 -
879 - rc = sqlite3_bind_blob(res, 1, &host->host_uuid, sizeof(host->host_uuid), SQLITE_STATIC);
880 - if (unlikely(rc != SQLITE_OK)) {
881 - error_report("Failed to bind host_id parameter for SQL_SELECT_HEALTH_LAST_EXECUTED_EVENT.");
882 - goto done;
883 - }
884 -
885 - rc = sqlite3_bind_int(res, 2, (int) ae->alarm_id);
886 - if (unlikely(rc != SQLITE_OK)) {
887 - error_report("Failed to bind alarm_id parameter for SQL_SELECT_HEALTH_LAST_EXECUTED_EVENT.");
888 - goto done;
889 - }
798
891 - rc = sqlite3_bind_int(res, 3, (int) ae->unique_id);
892 - if (unlikely(rc != SQLITE_OK)) {
893 - error_report("Failed to bind unique_id parameter for SQL_SELECT_HEALTH_LAST_EXECUTED_EVENT.");
894 - goto done;
895 - }
896 -
897 - rc = sqlite3_bind_int(res, 4, (uint32_t) HEALTH_ENTRY_FLAG_EXEC_RUN);
898 - if (unlikely(rc != SQLITE_OK)) {
899 - error_report("Failed to bind unique_id parameter for SQL_SELECT_HEALTH_LAST_EXECUTED_EVENT.");
900 - goto done;
901 - }
799 + int param = 0;
800 + SQLITE_BIND_FAIL(done, sqlite3_bind_blob(res, ++param, &host->host_uuid, sizeof(host->host_uuid), SQLITE_STATIC));
801 + SQLITE_BIND_FAIL(done, sqlite3_bind_int(res, ++param, (int) ae->alarm_id));
802 + SQLITE_BIND_FAIL(done, sqlite3_bind_int(res, ++param, (int) ae->unique_id));
803 + SQLITE_BIND_FAIL(done, sqlite3_bind_int(res, ++param, (uint32_t) HEALTH_ENTRY_FLAG_EXEC_RUN));
804
805 + param = 0;
806 ret = 0;
807 while (sqlite3_step_monitored(res) == SQLITE_ROW) {
808 *last_executed_status = (RRDCALC_STATUS) sqlite3_column_int(res, 0);
@@ -907,6 +810,7 @@ int sql_health_get_last_executed_event(RRDHOST *host, ALARM_ENTRY *ae, RRDCALC_S
810 }
811
812 done:
813 + REPORT_BIND_FAIL(res, param);
814 SQLITE_FINALIZE(res);
815 return ret;
816 }
@@ -1204,7 +1108,7 @@ static uint32_t get_next_alarm_event_id(uint64_t health_log_id, uint32_t alarm_i
1108 {
1109 int rc;
1110 sqlite3_stmt *res = NULL;
1207 - uint32_t next_event_id = 0;
1111 + uint32_t next_event_id = alarm_id;
1112
1113 rc = sqlite3_prepare_v2(db_meta, SQL_GET_EVENT_ID, -1, &res, 0);
1114 if (rc != SQLITE_OK) {
@@ -1212,26 +1116,17 @@ static uint32_t get_next_alarm_event_id(uint64_t health_log_id, uint32_t alarm_i
1116 return alarm_id;
1117 }
1118
1215 - rc = sqlite3_bind_int64(res, 1, (sqlite3_int64) health_log_id);
1216 - if (unlikely(rc != SQLITE_OK)) {
1217 - error_report("Failed to bind host_id parameter for SQL_GET_EVENT_ID.");
1218 - SQLITE_FINALIZE(res);
1219 - return alarm_id;
1220 - }
1221 -
1222 - rc = sqlite3_bind_int64(res, 2, (sqlite3_int64) alarm_id);
1223 - if (unlikely(rc != SQLITE_OK)) {
1224 - error_report("Failed to bind char parameter for SQL_GET_EVENT_ID.");
1225 - SQLITE_FINALIZE(res);
1226 - return alarm_id;
1227 - }
1119 + int param = 0;
1120 + SQLITE_BIND_FAIL(done, sqlite3_bind_int64(res, ++param, (sqlite3_int64) health_log_id));
1121 + SQLITE_BIND_FAIL(done, sqlite3_bind_int64(res, ++param, (sqlite3_int64) alarm_id));
1122
1229 - while (sqlite3_step_monitored(res) == SQLITE_ROW) {
1230 - next_event_id = (uint32_t) sqlite3_column_int64(res, 0);
1231 - }
1123 + param = 0;
1124 + while (sqlite3_step_monitored(res) == SQLITE_ROW)
1125 + next_event_id = (uint32_t)sqlite3_column_int64(res, 0);
1126
1127 +done:
1128 + REPORT_BIND_FAIL(res, param);
1129 SQLITE_FINALIZE(res);
1234 -
1130 return next_event_id;
1131 }
1132
@@ -1240,49 +1135,30 @@ static uint32_t get_next_alarm_event_id(uint64_t health_log_id, uint32_t alarm_i
1135
1136 uint32_t sql_get_alarm_id(RRDHOST *host, STRING *chart, STRING *name, uint32_t *next_event_id)
1137 {
1243 - int rc = 0;
1138 sqlite3_stmt *res = NULL;
1139 uint32_t alarm_id = 0;
1140 uint64_t health_log_id = 0;
1141
1248 - rc = sqlite3_prepare_v2(db_meta, SQL_GET_ALARM_ID, -1, &res, 0);
1249 - if (rc != SQLITE_OK) {
1250 - error_report("Failed to prepare statement when trying to get an alarm id");
1251 - return alarm_id;
1252 - }
1253 -
1254 - rc = sqlite3_bind_blob(res, 1, &host->host_uuid, sizeof(host->host_uuid), SQLITE_STATIC);
1255 - if (unlikely(rc != SQLITE_OK)) {
1256 - error_report("Failed to bind host_id parameter for SQL_GET_ALARM_ID.");
1257 - SQLITE_FINALIZE(res);
1258 - return alarm_id;
1259 - }
1260 -
1261 - rc = SQLITE3_BIND_STRING_OR_NULL(res, 2, chart);
1262 - if (unlikely(rc != SQLITE_OK)) {
1263 - error_report("Failed to bind char parameter for SQL_GET_ALARM_ID.");
1264 - SQLITE_FINALIZE(res);
1142 + if (!PREPARE_STATEMENT(db_meta, SQL_GET_ALARM_ID, &res))
1143 return alarm_id;
1266 - }
1144
1268 - rc = SQLITE3_BIND_STRING_OR_NULL(res, 3, name);
1269 - if (unlikely(rc != SQLITE_OK)) {
1270 - error_report("Failed to bind name parameter for SQL_GET_ALARM_ID.");
1271 - SQLITE_FINALIZE(res);
1272 - return alarm_id;
1273 - }
1145 + int param = 0;
1146 + SQLITE_BIND_FAIL(done, sqlite3_bind_blob(res, ++param, &host->host_uuid, sizeof(host->host_uuid), SQLITE_STATIC));
1147 + SQLITE_BIND_FAIL(done, SQLITE3_BIND_STRING_OR_NULL(res, ++param, chart));
1148 + SQLITE_BIND_FAIL(done, SQLITE3_BIND_STRING_OR_NULL(res, ++param, name));
1149
1150 + param = 0;
1151 while (sqlite3_step_monitored(res) == SQLITE_ROW) {
1276 - alarm_id = (uint32_t) sqlite3_column_int64(res, 0);
1277 - health_log_id = (uint64_t) sqlite3_column_int64(res, 1);
1152 + alarm_id = (uint32_t)sqlite3_column_int64(res, 0);
1153 + health_log_id = (uint64_t)sqlite3_column_int64(res, 1);
1154 }
1155
1156 + if (alarm_id)
1157 + *next_event_id = get_next_alarm_event_id(health_log_id, alarm_id);
1158 +done:
1159 + REPORT_BIND_FAIL(res, param);
1160 SQLITE_FINALIZE(res);
1281 -
1282 - if (alarm_id)
1283 - *next_event_id = get_next_alarm_event_id(health_log_id, alarm_id);
1284 -
1285 - return alarm_id;
1161 + return alarm_id;
1162 }
1163
1164 #define SQL_GET_ALARM_ID_FROM_TRANSITION_ID \
@@ -1299,18 +1175,12 @@ bool sql_find_alert_transition(
1175
1176 char machine_guid[UUID_STR_LEN];
1177
1302 - int rc;
1178 uuid_t transition_uuid;
1179 if (uuid_parse(transition, transition_uuid))
1180 return false;
1181
1307 - if (unlikely(!res)) {
1308 - rc = prepare_statement(db_meta, SQL_GET_ALARM_ID_FROM_TRANSITION_ID, &res);
1309 - if (unlikely(rc != SQLITE_OK)) {
1310 - error_report("Failed to prepare statement when trying to get transition id");
1311 - return false;
1312 - }
1313 - }
1182 + if (!PREPARE_COMPILED_STATEMENT(db_meta, SQL_GET_ALARM_ID_FROM_TRANSITION_ID, &res))
1183 + return false;
1184
1185 bool ok = false;
1186
@@ -1326,9 +1196,7 @@ bool sql_find_alert_transition(
1196
1197 done:
1198 REPORT_BIND_FAIL(res, param);
1329 -
1199 SQLITE_RESET(res);
1331 -
1200 return ok;
1201 }
1202
@@ -1382,11 +1250,8 @@ void sql_alert_transitions(
1250 return;
1251 }
1252
1385 - rc = sqlite3_prepare_v2(db_meta, SQL_SEARCH_ALERT_TRANSITION_DIRECT, -1, &res, 0);
1386 - if (unlikely(rc != SQLITE_OK)) {
1387 - error_report("Failed to prepare statement to search transition");
1253 + if (!PREPARE_STATEMENT(db_meta, SQL_SEARCH_ALERT_TRANSITION_DIRECT, &res))
1254 goto done_only_drop;
1389 - }
1255
1256 SQLITE_BIND_FAIL(done, sqlite3_bind_blob(res, ++param, &transition_uuid, sizeof(transition_uuid), SQLITE_STATIC));
1257 goto run_query;
@@ -1495,7 +1360,6 @@ run_query:;
1360
1361 done:
1362 REPORT_BIND_FAIL(res, param);
1498 -
1363 SQLITE_FINALIZE(res);
1364
1365 done_only_drop:
src/database/sqlite/sqlite_metadata.c
+62 -170
@@ -221,7 +221,7 @@ int sql_metadata_cache_stats(int op)
221 {
222 int count, dummy;
223
224 - if (unlikely(!db_meta))
224 + if (!REQUIRE_DB(db_meta))
225 return 0;
226
227 netdata_thread_disable_cancelability();
@@ -274,17 +274,11 @@ int update_node_id(uuid_t *host_id, uuid_t *node_id)
274 set_host_node_id(host, node_id);
275 rrd_unlock();
276
277 - if (unlikely(!db_meta)) {
278 - if (default_rrd_memory_mode == RRD_MEMORY_MODE_DBENGINE)
279 - error_report("Database has not been initialized");
277 + if (!REQUIRE_DB(db_meta))
278 return 1;
281 - }
279
283 - rc = sqlite3_prepare_v2(db_meta, SQL_UPDATE_NODE_ID, -1, &res, 0);
284 - if (unlikely(rc != SQLITE_OK)) {
285 - error_report("Failed to prepare statement to store node instance information");
280 + if (!PREPARE_STATEMENT(db_meta, SQL_UPDATE_NODE_ID, &res))
281 return 1;
287 - }
282
283 int param = 0;
284 SQLITE_BIND_FAIL(done, sqlite3_bind_blob(res, ++param, node_id, sizeof(*node_id), SQLITE_STATIC));
@@ -307,24 +301,16 @@ done:
301 int get_node_id(uuid_t *host_id, uuid_t *node_id)
302 {
303 sqlite3_stmt *res = NULL;
310 - int rc;
304
312 - if (unlikely(!db_meta)) {
313 - if (default_rrd_memory_mode == RRD_MEMORY_MODE_DBENGINE)
314 - error_report("Database has not been initialized");
305 + if (!REQUIRE_DB(db_meta))
306 return 1;
316 - }
307
318 - rc = sqlite3_prepare_v2(db_meta, SQL_SELECT_NODE_ID, -1, &res, 0);
319 - if (unlikely(rc != SQLITE_OK)) {
320 - error_report("Failed to prepare statement to select node instance information for a host");
308 + if (!PREPARE_STATEMENT(db_meta, SQL_SELECT_NODE_ID, &res))
309 return 1;
322 - }
310
324 - int param = 0;
311 + int param = 0, rc = 0;
312 SQLITE_BIND_FAIL(done, sqlite3_bind_blob(res, ++param, host_id, sizeof(*host_id), SQLITE_STATIC));
313
327 -
314 param = 0;
315 rc = sqlite3_step_monitored(res);
316 if (likely(rc == SQLITE_ROW && node_id))
@@ -333,7 +319,6 @@ int get_node_id(uuid_t *host_id, uuid_t *node_id)
319 done:
320 REPORT_BIND_FAIL(res, param);
321 SQLITE_FINALIZE(res);
336 -
322 return (rc == SQLITE_ROW) ? 0 : -1;
323 }
324
@@ -344,19 +329,12 @@ done:
329 void invalidate_node_instances(uuid_t *host_id, uuid_t *claim_id)
330 {
331 sqlite3_stmt *res = NULL;
347 - int rc;
332
349 - if (unlikely(!db_meta)) {
350 - if (default_rrd_memory_mode == RRD_MEMORY_MODE_DBENGINE)
351 - error_report("Database has not been initialized");
333 + if (!REQUIRE_DB(db_meta))
334 return;
353 - }
335
355 - rc = sqlite3_prepare_v2(db_meta, SQL_INVALIDATE_NODE_INSTANCES, -1, &res, 0);
356 - if (unlikely(rc != SQLITE_OK)) {
357 - error_report("Failed to prepare statement to invalidate node instance ids");
336 + if (!PREPARE_STATEMENT(db_meta, SQL_INVALIDATE_NODE_INSTANCES, &res))
337 return;
359 - }
338
339 int param = 0;
340 SQLITE_BIND_FAIL(done, sqlite3_bind_blob(res, ++param, host_id, sizeof(*host_id), SQLITE_STATIC));
@@ -367,7 +345,7 @@ void invalidate_node_instances(uuid_t *host_id, uuid_t *claim_id)
345 SQLITE_BIND_FAIL(done, sqlite3_bind_null(res, ++param));
346
347 param = 0;
370 - rc = execute_insert(res);
348 + int rc = execute_insert(res);
349 if (unlikely(rc != SQLITE_DONE))
350 error_report("Failed to invalidate node instance information, rc = %d", rc);
351
@@ -384,19 +362,12 @@ struct node_instance_list *get_node_list(void)
362 {
363 struct node_instance_list *node_list = NULL;
364 sqlite3_stmt *res = NULL;
387 - int rc;
365
389 - if (unlikely(!db_meta)) {
390 - if (default_rrd_memory_mode == RRD_MEMORY_MODE_DBENGINE)
391 - error_report("Database has not been initialized");
366 + if (!REQUIRE_DB(db_meta))
367 return NULL;
393 - }
368
395 - rc = sqlite3_prepare_v2(db_meta, SQL_GET_NODE_INSTANCE_LIST, -1, &res, 0);
396 - if (unlikely(rc != SQLITE_OK)) {
397 - error_report("Failed to prepare statement to get node instance information");
369 + if (!PREPARE_STATEMENT(db_meta, SQL_GET_NODE_INSTANCE_LIST, &res))
370 return NULL;
399 - }
371
372 int row = 0;
373 char host_guid[UUID_STR_LEN];
@@ -454,25 +425,18 @@ failed:
425 void sql_load_node_id(RRDHOST *host)
426 {
427 sqlite3_stmt *res = NULL;
457 - int rc;
428
459 - if (unlikely(!db_meta)) {
460 - if (default_rrd_memory_mode == RRD_MEMORY_MODE_DBENGINE)
461 - error_report("Database has not been initialized");
429 + if (!REQUIRE_DB(db_meta))
430 return;
463 - }
431
465 - rc = sqlite3_prepare_v2(db_meta, SQL_GET_HOST_NODE_ID, -1, &res, 0);
466 - if (unlikely(rc != SQLITE_OK)) {
467 - error_report("Failed to prepare statement to fetch node id");
432 + if (!PREPARE_STATEMENT(db_meta, SQL_GET_HOST_NODE_ID, &res))
433 return;
469 - }
434
435 int param = 0;
436 SQLITE_BIND_FAIL(done, sqlite3_bind_blob(res, ++param, &host->host_uuid, sizeof(host->host_uuid), SQLITE_STATIC));
437
438 param = 0;
475 - rc = sqlite3_step_monitored(res);
439 + int rc = sqlite3_step_monitored(res);
440 if (likely(rc == SQLITE_ROW)) {
441 if (likely(sqlite3_column_bytes(res, 0) == sizeof(uuid_t)))
442 set_host_node_id(host, (uuid_t *)sqlite3_column_blob(res, 0));
@@ -489,15 +453,10 @@ done:
453
454 void sql_build_host_system_info(uuid_t *host_id, struct rrdhost_system_info *system_info)
455 {
492 - int rc;
493 -
456 sqlite3_stmt *res = NULL;
457
496 - rc = sqlite3_prepare_v2(db_meta, SELECT_HOST_INFO, -1, &res, 0);
497 - if (unlikely(rc != SQLITE_OK)) {
498 - error_report("Failed to prepare statement to read host information");
458 + if (!PREPARE_STATEMENT(db_meta, SELECT_HOST_INFO, &res))
459 return;
500 - }
460
461 int param = 0;
462 SQLITE_BIND_FAIL(done, sqlite3_bind_blob(res, ++param, host_id, sizeof(*host_id), SQLITE_STATIC));
@@ -518,16 +477,11 @@ done:
477
478 RRDLABELS *sql_load_host_labels(uuid_t *host_id)
479 {
521 - int rc;
522 -
480 RRDLABELS *labels = NULL;
481 sqlite3_stmt *res = NULL;
482
526 - rc = sqlite3_prepare_v2(db_meta, SELECT_HOST_LABELS, -1, &res, 0);
527 - if (unlikely(rc != SQLITE_OK)) {
528 - error_report("Failed to prepare statement to read host information");
483 + if (!PREPARE_STATEMENT(db_meta, SELECT_HOST_LABELS, &res))
484 return NULL;
530 - }
485
486 int param = 0;
487 SQLITE_BIND_FAIL(done, sqlite3_bind_blob(res, ++param, host_id, sizeof(*host_id), SQLITE_STATIC));
@@ -551,12 +505,11 @@ done:
505
506 static int exec_statement_with_uuid(const char *sql, uuid_t *uuid)
507 {
554 - int rc, result = 1;
508 + int result = 1;
509 sqlite3_stmt *res = NULL;
510
557 - rc = sqlite3_prepare_v2(db_meta, sql, -1, &res, 0);
558 - if (unlikely(rc != SQLITE_OK)) {
559 - error_report("Failed to prepare statement %s, rc = %d", sql, rc);
511 + if (!PREPARE_STATEMENT(db_meta, sql, &res)) {
512 + error_report("Failed to prepare statement %s", sql);
513 return 1;
514 }
515
@@ -564,7 +517,7 @@ static int exec_statement_with_uuid(const char *sql, uuid_t *uuid)
517 SQLITE_BIND_FAIL(done, sqlite3_bind_blob(res, ++param, uuid, sizeof(*uuid), SQLITE_STATIC));
518
519 param = 0;
567 - rc = execute_insert(res);
520 + int rc = execute_insert(res);
521 if (likely(rc == SQLITE_DONE))
522 result = SQLITE_OK;
523 else
@@ -777,22 +730,19 @@ static void delete_host_chart_labels(uuid_t *host_uuid)
730 {
731 sqlite3_stmt *res = NULL;
732
780 - int rc = sqlite3_prepare_v2(db_meta, SQL_DELETE_CHART_LABELS_BY_HOST, -1, &res, 0);
781 - if (unlikely(rc != SQLITE_OK)) {
782 - error_report("Failed to prepare statement to delete chart labels by host");
733 + if (!PREPARE_STATEMENT(db_meta, SQL_DELETE_CHART_LABELS_BY_HOST, &res))
734 return;
784 - }
735
786 - rc = sqlite3_bind_blob(res, 1, host_uuid, sizeof(*host_uuid), SQLITE_STATIC);
787 - if (unlikely(rc != SQLITE_OK)) {
788 - error_report("Failed to bind host_id parameter to host chart labels");
789 - goto failed;
790 - }
791 - rc = sqlite3_step_monitored(res);
736 + int param = 0;
737 + SQLITE_BIND_FAIL(done, sqlite3_bind_blob(res, ++param, host_uuid, sizeof(*host_uuid), SQLITE_STATIC));
738 +
739 + param = 0;
740 + int rc = sqlite3_step_monitored(res);
741 if (unlikely(rc != SQLITE_DONE))
793 - error_report("Failed to execute command to remove host chart labels");
742 + error_report("Failed to execute command to remove chart labels, rc = %d", rc);
743
795 -failed:
744 +done:
745 + REPORT_BIND_FAIL(res, param);
746 SQLITE_FINALIZE(res);
747 }
748
@@ -873,19 +823,13 @@ void detect_machine_guid_change(uuid_t *host_uuid)
823 static int store_claim_id(uuid_t *host_id, uuid_t *claim_id)
824 {
825 sqlite3_stmt *res = NULL;
876 - int rc;
826 + int rc = 0;
827
878 - if (unlikely(!db_meta)) {
879 - if (default_rrd_memory_mode == RRD_MEMORY_MODE_DBENGINE)
880 - error_report("Database has not been initialized");
828 + if (!REQUIRE_DB(db_meta))
829 return 1;
882 - }
830
884 - rc = sqlite3_prepare_v2(db_meta, SQL_STORE_CLAIM_ID, -1, &res, 0);
885 - if (unlikely(rc != SQLITE_OK)) {
886 - error_report("Failed to prepare statement to store host claim id");
831 + if (!PREPARE_STATEMENT(db_meta, SQL_STORE_CLAIM_ID, &res))
832 return 1;
888 - }
833
834 int param = 0;
835 SQLITE_BIND_FAIL(done, sqlite3_bind_blob(res, ++param, host_id, sizeof(*host_id), SQLITE_STATIC));
@@ -903,7 +847,6 @@ static int store_claim_id(uuid_t *host_id, uuid_t *claim_id)
847 done:
848 REPORT_BIND_FAIL(res, param);
849 SQLITE_FINALIZE(res);
906 -
850 return rc != SQLITE_DONE;
851 }
852
@@ -912,23 +855,19 @@ static void delete_dimension_uuid(uuid_t *dimension_uuid, sqlite3_stmt **action_
855 static __thread sqlite3_stmt *res = NULL;
856 int rc;
857
915 - if (unlikely(!res)) {
916 - rc = prepare_statement(db_meta, DELETE_DIMENSION_UUID, &res);
917 - if (rc != SQLITE_OK) {
918 - error_report("Failed to prepare statement to delete a dimension uuid");
919 - return;
920 - }
921 - }
858 + if (!PREPARE_COMPILED_STATEMENT(db_meta, DELETE_DIMENSION_UUID, &res))
859 + return;
860
923 - rc = sqlite3_bind_blob(res, 1, dimension_uuid, sizeof(*dimension_uuid), SQLITE_STATIC);
924 - if (unlikely(rc != SQLITE_OK))
925 - goto skip_execution;
861 + int param = 0;
862 + SQLITE_BIND_FAIL(done, sqlite3_bind_blob(res, ++param, dimension_uuid, sizeof(*dimension_uuid), SQLITE_STATIC));
863
864 + param = 0;
865 rc = sqlite3_step_monitored(res);
866 if (unlikely(rc != SQLITE_DONE))
867 error_report("Failed to delete dimension uuid, rc = %d", rc);
868
931 -skip_execution:
869 +done:
870 + REPORT_BIND_FAIL(res, param);
871 SQLITE_RESET(res);
872 }
873
@@ -937,16 +876,11 @@ skip_execution:
876 static int store_host_metadata(RRDHOST *host)
877 {
878 static __thread sqlite3_stmt *res = NULL;
940 - int rc, param = 0;
879
942 - if (unlikely((!res))) {
943 - rc = prepare_statement(db_meta, SQL_STORE_HOST_INFO, &res);
944 - if (unlikely(rc != SQLITE_OK)) {
945 - error_report("Failed to prepare statement to store host, rc = %d", rc);
946 - return 1;
947 - }
948 - }
880 + if (!PREPARE_COMPILED_STATEMENT(db_meta, SQL_STORE_HOST_INFO, &res))
881 + return false;
882
883 + int param = 0;
884 SQLITE_BIND_FAIL(bind_fail, sqlite3_bind_blob(res, ++param, &host->host_uuid, sizeof(host->host_uuid), SQLITE_STATIC));
885 SQLITE_BIND_FAIL(bind_fail, bind_text_null(res, ++param, rrdhost_hostname(host), 0));
886 SQLITE_BIND_FAIL(bind_fail, bind_text_null(res, ++param, rrdhost_registry_hostname(host), 1));
@@ -967,7 +901,7 @@ static int store_host_metadata(RRDHOST *host)
901 int store_rc = sqlite3_step_monitored(res);
902
903 if (unlikely(store_rc != SQLITE_DONE))
970 - error_report("Failed to store host %s, rc = %d", rrdhost_hostname(host), rc);
904 + error_report("Failed to store host %s, rc = %d", rrdhost_hostname(host), store_rc);
905
906 SQLITE_RESET(res);
907
@@ -975,7 +909,6 @@ static int store_host_metadata(RRDHOST *host)
909
910 bind_fail:
911 REPORT_BIND_FAIL(res, param);
978 -
912 SQLITE_RESET(res);
913 return 1;
914 }
@@ -983,23 +916,14 @@ bind_fail:
916 static int add_host_sysinfo_key_value(const char *name, const char *value, uuid_t *uuid)
917 {
918 static __thread sqlite3_stmt *res = NULL;
986 - int rc, param = 0;
919
988 - if (unlikely(!db_meta)) {
989 - if (default_rrd_memory_mode != RRD_MEMORY_MODE_DBENGINE)
990 - return 0;
991 - error_report("Database has not been initialized");
920 + if (!REQUIRE_DB(db_meta))
921 return 0;
993 - }
922
995 - if (unlikely((!res))) {
996 - rc = prepare_statement(db_meta, SQL_STORE_HOST_SYSTEM_INFO_VALUES, &res);
997 - if (unlikely(rc != SQLITE_OK)) {
998 - error_report("Failed to prepare statement to store host info values, rc = %d", rc);
999 - return 0;
1000 - }
1001 - }
923 + if (!PREPARE_COMPILED_STATEMENT(db_meta, SQL_STORE_HOST_SYSTEM_INFO_VALUES, &res))
924 + return 0;
925
926 + int param = 0;
927 SQLITE_BIND_FAIL(bind_fail, sqlite3_bind_blob(res, ++param, uuid, sizeof(*uuid), SQLITE_STATIC));
928 SQLITE_BIND_FAIL(bind_fail, bind_text_null(res, ++param, name, 0));
929 SQLITE_BIND_FAIL(bind_fail, bind_text_null(res, ++param, value ? value : "unknown", 0));
@@ -1014,7 +938,6 @@ static int add_host_sysinfo_key_value(const char *name, const char *value, uuid_
938
939 bind_fail:
940 REPORT_BIND_FAIL(res, param);
1017 -
941 SQLITE_RESET(res);
942 return 0;
943 }
@@ -1064,16 +987,11 @@ static bool store_host_systeminfo(RRDHOST *host)
987 static int store_chart_metadata(RRDSET *st)
988 {
989 static __thread sqlite3_stmt *res = NULL;
1067 - int rc, param = 0, store_rc = 0;
990
1069 - if (unlikely(!res)) {
1070 - rc = prepare_statement(db_meta, SQL_STORE_CHART, &res);
1071 - if (unlikely(rc != SQLITE_OK)) {
1072 - error_report("Failed to prepare statement to store chart, rc = %d", rc);
1073 - return 1;
1074 - }
1075 - }
991 + if (!PREPARE_COMPILED_STATEMENT(db_meta, SQL_STORE_CHART, &res))
992 + return 1;
993
994 + int param = 0;
995 SQLITE_BIND_FAIL(bind_fail, sqlite3_bind_blob(res, ++param, &st->chart_uuid, sizeof(st->chart_uuid), SQLITE_STATIC));
996 SQLITE_BIND_FAIL(bind_fail, sqlite3_bind_blob(res, ++param, &st->rrdhost->host_uuid, sizeof(st->rrdhost->host_uuid), SQLITE_STATIC));
997 SQLITE_BIND_FAIL(bind_fail, sqlite3_bind_text(res, ++param, string2str(st->parts.type), -1, SQLITE_STATIC));
@@ -1097,7 +1015,7 @@ static int store_chart_metadata(RRDSET *st)
1015 SQLITE_BIND_FAIL(bind_fail, sqlite3_bind_int(res, ++param, st->rrd_memory_mode));
1016 SQLITE_BIND_FAIL(bind_fail, sqlite3_bind_int(res, ++param, (int) st->db.entries));
1017
1100 - store_rc = execute_insert(res);
1018 + int store_rc = execute_insert(res);
1019 if (unlikely(store_rc != SQLITE_DONE))
1020 error_report("Failed to store chart, rc = %d", store_rc);
1021
@@ -1107,7 +1025,6 @@ static int store_chart_metadata(RRDSET *st)
1025
1026 bind_fail:
1027 REPORT_BIND_FAIL(res, param);
1110 -
1028 SQLITE_RESET(res);
1029 return 1;
1030 }
@@ -1120,13 +1037,8 @@ static int store_dimension_metadata(RRDDIM *rd)
1037 static __thread sqlite3_stmt *res = NULL;
1038 int rc, param = 0;
1039
1123 - if (unlikely(!res)) {
1124 - rc = prepare_statement(db_meta, SQL_STORE_DIMENSION, &res);
1125 - if (unlikely(rc != SQLITE_OK)) {
1126 - error_report("Failed to prepare statement to store dimension, rc = %d", rc);
1127 - return 1;
1128 - }
1129 - }
1040 + if (!PREPARE_COMPILED_STATEMENT(db_meta, SQL_STORE_DIMENSION, &res))
1041 + return 1;
1042
1043 SQLITE_BIND_FAIL(bind_fail, sqlite3_bind_blob(res, ++param, &rd->metric_uuid, sizeof(rd->metric_uuid), SQLITE_STATIC));
1044 SQLITE_BIND_FAIL(bind_fail, sqlite3_bind_blob(res, ++param, &rd->rrdset->chart_uuid, sizeof(rd->rrdset->chart_uuid), SQLITE_STATIC));
@@ -1149,7 +1061,6 @@ static int store_dimension_metadata(RRDDIM *rd)
1061
1062 bind_fail:
1063 REPORT_BIND_FAIL(res, param);
1152 -
1064 SQLITE_RESET(res);
1065 return 1;
1066 }
@@ -1230,14 +1141,12 @@ static bool chart_can_be_deleted(uuid_t *chart_uuid, sqlite3_stmt **check_res, b
1141 sqlite3_stmt *res = check_res ? *check_res : NULL;
1142
1143 if (!res) {
1233 - if (check_in_dimension)
1234 - rc = sqlite3_prepare_v2(db_meta, SQL_CHECK_CHART_EXISTENCE_IN_DIMENSION, -1, &res, 0);
1235 - else
1236 - rc = sqlite3_prepare_v2(db_meta, SQL_CHECK_CHART_EXISTENCE_IN_CHART, -1, &res, 0);
1237 - if (unlikely(rc != SQLITE_OK)) {
1238 - error_report("Failed to prepare statement to check for chart existence, rc = %d", rc);
1144 + if (!PREPARE_STATEMENT(
1145 + db_meta,
1146 + check_in_dimension ? SQL_CHECK_CHART_EXISTENCE_IN_DIMENSION : SQL_CHECK_CHART_EXISTENCE_IN_CHART,
1147 + &res))
1148 return 0;
1240 - }
1149 +
1150 if (check_res)
1151 *check_res = res;
1152 }
@@ -1270,14 +1179,8 @@ static void delete_chart_uuid(uuid_t *chart_uuid, sqlite3_stmt **action_res, boo
1179 sqlite3_stmt *res = action_res ? *action_res : NULL;
1180
1181 if (!res) {
1273 - if (label_only)
1274 - rc = sqlite3_prepare_v2(db_meta, SQL_DELETE_CHART_LABEL_BY_UUID, -1, &res, 0);
1275 - else
1276 - rc = sqlite3_prepare_v2(db_meta, SQL_DELETE_CHART_BY_UUID, -1, &res, 0);
1277 - if (unlikely(rc != SQLITE_OK)) {
1278 - error_report("Failed to prepare statement to check for chart existence, rc = %d", rc);
1182 + if (!PREPARE_STATEMENT(db_meta, label_only ? SQL_DELETE_CHART_LABEL_BY_UUID : SQL_DELETE_CHART_BY_UUID, &res))
1183 return;
1280 - }
1184 if (action_res)
1185 *action_res = res;
1186 }
@@ -1312,14 +1215,10 @@ static void check_dimension_metadata(struct metadata_wc *wc)
1215 if (next_execution_t && next_execution_t > now)
1216 return;
1217
1315 - int rc;
1218 sqlite3_stmt *res = NULL;
1219
1318 - rc = sqlite3_prepare_v2(db_meta, SELECT_DIMENSION_LIST, -1, &res, 0);
1319 - if (unlikely(rc != SQLITE_OK)) {
1320 - error_report("Failed to prepare statement to fetch host dimensions");
1220 + if (!PREPARE_STATEMENT(db_meta, SELECT_DIMENSION_LIST, &res))
1221 return;
1322 - }
1222
1223 uint32_t total_checked = 0;
1224 uint32_t total_deleted = 0;
@@ -1374,11 +1273,8 @@ static void check_chart_metadata(struct metadata_wc *wc)
1273
1274 sqlite3_stmt *res = NULL;
1275
1377 - int rc = sqlite3_prepare_v2(db_meta, SELECT_CHART_LIST, -1, &res, 0);
1378 - if (unlikely(rc != SQLITE_OK)) {
1379 - error_report("Failed to prepare statement to fetch charts");
1276 + if (!PREPARE_STATEMENT(db_meta, SELECT_CHART_LIST, &res))
1277 return;
1381 - }
1278
1279 uint32_t total_checked = 0;
1280 uint32_t total_deleted = 0;
@@ -1436,14 +1332,10 @@ static void check_label_metadata(struct metadata_wc *wc)
1332 if (next_execution_t && next_execution_t > now)
1333 return;
1334
1439 - int rc;
1335 sqlite3_stmt *res = NULL;
1336
1442 - rc = sqlite3_prepare_v2(db_meta, SELECT_CHART_LABEL_LIST, -1, &res, 0);
1443 - if (unlikely(rc != SQLITE_OK)) {
1444 - error_report("Failed to prepare statement to fetch charts");
1337 + if (!PREPARE_STATEMENT(db_meta, SELECT_CHART_LABEL_LIST, &res))
1338 return;
1446 - }
1339
1340 uint32_t total_checked = 0;
1341 uint32_t total_deleted = 0;