#include "sqlite_functions.h"

#include "sqlite_db_migration.h"

#define DB_METADATA_VERSION 2

const char *database_config[] = {

"CREATE TABLE IF NOT EXISTS host(host_id blob PRIMARY KEY, hostname text, "

"registry_hostname text, update_every int, os text, timezone text, tags text, hops INT);",

"CREATE TABLE IF NOT EXISTS chart(chart_id blob PRIMARY KEY, host_id blob, type text, id text, name text, "

"family text, context text, title text, unit text, plugin text, module text, priority int, update_every int, "

"chart_type int, memory_mode int, history_entries);",

"CREATE TABLE IF NOT EXISTS dimension(dim_id blob PRIMARY KEY, chart_id blob, id text, name text, "

"multiplier int, divisor int , algorithm int, options text);",

"DROP TABLE IF EXISTS chart_active;",

"DROP TABLE IF EXISTS dimension_active;",

"CREATE TABLE IF NOT EXISTS chart_active(chart_id blob PRIMARY KEY, date_created int);",

"CREATE TABLE IF NOT EXISTS dimension_active(dim_id blob primary key, date_created int);",

"CREATE TABLE IF NOT EXISTS metadata_migration(filename text, file_size, date_created int);",

"CREATE INDEX IF NOT EXISTS ind_d1 on dimension (chart_id, id, name);",

"CREATE INDEX IF NOT EXISTS ind_c1 on chart (host_id, id, type, name);",

"CREATE TABLE IF NOT EXISTS chart_label(chart_id blob, source_type int, label_key text, "

"label_value text, date_created int, PRIMARY KEY (chart_id, label_key));",

"CREATE TABLE IF NOT EXISTS node_instance (host_id blob PRIMARY KEY, claim_id, node_id, date_created);",

"CREATE TABLE IF NOT EXISTS alert_hash(hash_id blob PRIMARY KEY, date_updated int, alarm text, template text, "

"on_key text, class text, component text, type text, os text, hosts text, lookup text, "

"every text, units text, calc text, families text, plugin text, module text, charts text, green text, "

"red text, warn text, crit text, exec text, to_key text, info text, delay text, options text, "

"repeat text, host_labels text, p_db_lookup_dimensions text, p_db_lookup_method text, p_db_lookup_options int, "

"p_db_lookup_after int, p_db_lookup_before int, p_update_every int);",

"CREATE TABLE IF NOT EXISTS chart_hash_map(chart_id blob , hash_id blob, UNIQUE (chart_id, hash_id));",

"CREATE TABLE IF NOT EXISTS chart_hash(hash_id blob PRIMARY KEY,type text, id text, name text, "

"family text, context text, title text, unit text, plugin text, "

"module text, priority integer, chart_type, last_used);",

"CREATE VIEW IF NOT EXISTS v_chart_hash as SELECT ch.*, chm.chart_id FROM chart_hash ch, chart_hash_map chm "

"WHERE ch.hash_id = chm.hash_id;",

"CREATE TRIGGER IF NOT EXISTS ins_host AFTER INSERT ON host BEGIN INSERT INTO node_instance (host_id, date_created)"

" SELECT new.host_id, unixepoch() WHERE new.host_id NOT IN (SELECT host_id FROM node_instance); END;",

"CREATE TRIGGER IF NOT EXISTS tr_v_chart_hash INSTEAD OF INSERT on v_chart_hash BEGIN "

"INSERT INTO chart_hash (hash_id, type, id, name, family, context, title, unit, plugin, "

"module, priority, chart_type, last_used) "

"values (new.hash_id, new.type, new.id, new.name, new.family, new.context, new.title, new.unit, new.plugin, "

"new.module, new.priority, new.chart_type, unixepoch()) "

"ON CONFLICT (hash_id) DO UPDATE SET last_used = unixepoch(); "

"INSERT INTO chart_hash_map (chart_id, hash_id) values (new.chart_id, new.hash_id) "

"on conflict (chart_id, hash_id) do nothing; END; ",

NULL

};

const char *database_cleanup[] = {

"delete from chart where chart_id not in (select chart_id from dimension);",

"delete from host where host_id not in (select host_id from chart);",

"delete from chart_label where chart_id not in (select chart_id from chart);",

"DELETE FROM chart_hash_map WHERE chart_id NOT IN (SELECT chart_id FROM chart);",

"DELETE FROM chart_hash WHERE hash_id NOT IN (SELECT hash_id FROM chart_hash_map);",

"DELETE FROM node_instance WHERE host_id NOT IN (SELECT host_id FROM host);",

NULL

};

sqlite3 *db_meta = NULL;

#define MAX_PREPARED_STATEMENTS (32)

pthread_key_t key_pool[MAX_PREPARED_STATEMENTS];

static uv_mutex_t sqlite_transaction_lock;

int execute_insert(sqlite3_stmt *res)

{

int rc;

int cnt = 0;

while ((rc = sqlite3_step(res)) != SQLITE_DONE && ++cnt < SQL_MAX_RETRY && likely(!netdata_exit)) {

if (likely(rc == SQLITE_BUSY || rc == SQLITE_LOCKED)) {

usleep(SQLITE_INSERT_DELAY * USEC_PER_MS);

error_report("Failed to insert/update, rc = %d -- attempt %d", rc, cnt);

}

else {

error_report("SQLite error %d", rc);

break;

}

}

return rc;

}

#define MAX_OPEN_STATEMENTS (512)

static void add_stmt_to_list(sqlite3_stmt *res)

{

static int idx = 0;

static sqlite3_stmt *statements[MAX_OPEN_STATEMENTS];

if (unlikely(!res)) {

if (idx)

info("Finilizing %d statements", idx);

else

info("No statements pending to finalize");

while (idx > 0) {

int rc;

rc = sqlite3_finalize(statements[--idx]);

if (unlikely(rc != SQLITE_OK))

error_report("Failed to finalize statement during shutdown, rc = %d", rc);

}

return;

}

if (unlikely(idx == MAX_OPEN_STATEMENTS))

return;

}

static void release_statement(void *statement)

{

int rc;

#ifdef NETDATA_INTERNAL_CHECKS

info("Thread %d: Cleaning prepared statement on %p", gettid(), statement);

if (unlikely(rc = sqlite3_finalize((sqlite3_stmt *) statement) != SQLITE_OK))

error_report("Failed to finalize statement, rc = %d", rc);

}

int prepare_statement(sqlite3 *database, char *query, sqlite3_stmt **statement)

{

static __thread uint32_t keys_used = 0;

pthread_key_t *key = NULL;

int ret = 1;

if (likely(keys_used < MAX_PREPARED_STATEMENTS))

key = &key_pool[keys_used++];

int rc = sqlite3_prepare_v2(database, query, -1, statement, 0);

if (likely(rc == SQLITE_OK)) {

if (likely(key)) {

ret = pthread_setspecific(*key, *statement);

#ifdef NETDATA_INTERNAL_CHECKS

info("Thread %d: Using key %u on statement %p", gettid(), keys_used, *statement);

}

if (ret)

add_stmt_to_list(*statement);

}

return rc;

}

static int store_active_uuid_object(sqlite3_stmt **res, char *statement, uuid_t *uuid)

{

int rc;

// Check if we should need to prepare the statement

if (!*res) {

rc = prepare_statement(db_meta, statement, res);

if (unlikely(rc != SQLITE_OK)) {

error_report("Failed to prepare statement to store active object, rc = %d", rc);

return rc;

}

}

rc = sqlite3_bind_blob(*res, 1, uuid, sizeof(*uuid), SQLITE_STATIC);

if (unlikely(rc != SQLITE_OK))

error_report("Failed to bind input parameter to store active object, rc = %d", rc);

else

rc = execute_insert(*res);

return rc;

}

void store_active_chart(uuid_t *chart_uuid)

{

static __thread sqlite3_stmt *res = NULL;

int rc;

if (unlikely(!db_meta)) {

if (default_rrd_memory_mode == RRD_MEMORY_MODE_DBENGINE)

error_report("Database has not been initialized");

return;

}

if (unlikely(!chart_uuid))

return;

rc = store_active_uuid_object(&res, SQL_STORE_ACTIVE_CHART, chart_uuid);

if (rc != SQLITE_DONE)

error_report("Failed to store active chart, rc = %d", rc);

rc = sqlite3_reset(res);

if (unlikely(rc != SQLITE_OK))

error_report("Failed to finalize statement in store active chart, rc = %d", rc);

return;

}

void store_active_dimension(uuid_t *dimension_uuid)

{

static __thread sqlite3_stmt *res = NULL;

int rc;

if (unlikely(!db_meta)) {

if (default_rrd_memory_mode == RRD_MEMORY_MODE_DBENGINE)

error_report("Database has not been initialized");

return;

}

if (unlikely(!dimension_uuid))

return;

rc = store_active_uuid_object(&res, SQL_STORE_ACTIVE_DIMENSION, dimension_uuid);

if (rc != SQLITE_DONE)

error_report("Failed to store active dimension, rc = %d", rc);

rc = sqlite3_reset(res);

if (unlikely(rc != SQLITE_OK))

error_report("Failed to finalize statement in store active dimension, rc = %d", rc);

return;

}

static int check_table_integrity_cb(void *data, int argc, char **argv, char **column)

{

int *status = data;

UNUSED(argc);

UNUSED(column);

info("---> %s", argv[0]);

*status = (strcmp(argv[0], "ok") != 0);

return 0;

}

static int check_table_integrity(char *table)

{

int status = 0;

char *err_msg = NULL;

char wstr[255];

if (table) {

info("Checking table %s", table);

snprintfz(wstr, 254, "PRAGMA integrity_check(%s);", table);

}

else {

info("Checking entire database");

strcpy(wstr,"PRAGMA integrity_check;");

}

int rc = sqlite3_exec(db_meta, wstr, check_table_integrity_cb, (void *) &status, &err_msg);

if (rc != SQLITE_OK) {

error_report("SQLite error during database integrity check for %s, rc = %d (%s)",

table ? table : "the entire database", rc, err_msg);

sqlite3_free(err_msg);

}

return status;

}

const char *rebuild_chart_commands[] = {

"BEGIN TRANSACTION; ",

"DROP INDEX IF EXISTS ind_c1;" ,

"DROP TABLE IF EXISTS chart_backup; " ,

"CREATE TABLE chart_backup AS SELECT * FROM chart; " ,

"DROP TABLE chart; ",

"CREATE TABLE IF NOT EXISTS chart(chart_id blob PRIMARY KEY, host_id blob, type text, id text, "

"name text, family text, context text, title text, unit text, plugin text, "

"module text, priority int, update_every int, chart_type int, memory_mode int, history_entries); ",

"INSERT INTO chart SELECT DISTINCT * FROM chart_backup; ",

"DROP TABLE chart_backup; " ,

"CREATE INDEX IF NOT EXISTS ind_c1 on chart (host_id, id, type, name);",

"COMMIT TRANSACTION;",

NULL

};

static void rebuild_chart()

{

int rc;

char *err_msg = NULL;

info("Rebuilding chart table");

for (int i = 0; rebuild_chart_commands[i]; i++) {

info("Executing %s", rebuild_chart_commands[i]);

rc = sqlite3_exec(db_meta, rebuild_chart_commands[i], 0, 0, &err_msg);

if (rc != SQLITE_OK) {

error_report("SQLite error during database setup, rc = %d (%s)", rc, err_msg);

error_report("SQLite failed statement %s", rebuild_chart_commands[i]);

sqlite3_free(err_msg);

}

}

return;

}

const char *rebuild_dimension_commands[] = {

"BEGIN TRANSACTION; ",

"DROP INDEX IF EXISTS ind_d1;" ,

"DROP TABLE IF EXISTS dimension_backup; " ,

"CREATE TABLE dimension_backup AS SELECT * FROM dimension; " ,

"DROP TABLE dimension; " ,

"CREATE TABLE IF NOT EXISTS dimension(dim_id blob PRIMARY KEY, chart_id blob, id text, name text, "

"multiplier int, divisor int , algorithm int, options text);" ,

"INSERT INTO dimension SELECT distinct * FROM dimension_backup; " ,

"DROP TABLE dimension_backup; " ,

"CREATE INDEX IF NOT EXISTS ind_d1 on dimension (chart_id, id, name);",

"COMMIT TRANSACTION;",

NULL

};

void rebuild_dimension()

{

int rc;

char *err_msg = NULL;

info("Rebuilding dimension table");

for (int i = 0; rebuild_dimension_commands[i]; i++) {

info("Executing %s", rebuild_dimension_commands[i]);

rc = sqlite3_exec(db_meta, rebuild_dimension_commands[i], 0, 0, &err_msg);

if (rc != SQLITE_OK) {

error_report("SQLite error during database setup, rc = %d (%s)", rc, err_msg);

error_report("SQLite failed statement %s", rebuild_dimension_commands[i]);

sqlite3_free(err_msg);

}

}

return;

}

static int attempt_database_fix()

{

info("Closing database and attempting to fix it");

int rc = sqlite3_close(db_meta);

if (rc != SQLITE_OK)

error_report("Failed to close database, rc = %d", rc);

info("Attempting to fix database");

db_meta = NULL;

return sql_init_database(DB_CHECK_FIX_DB | DB_CHECK_CONT, 0);

}

int init_database_batch(int rebuild, int init_type, const char *batch[])

{

int rc;

char *err_msg = NULL;

for (int i = 0; batch[i]; i++) {

debug(D_METADATALOG, "Executing %s", batch[i]);

rc = sqlite3_exec(db_meta, batch[i], 0, 0, &err_msg);

if (rc != SQLITE_OK) {

error_report("SQLite error during database %s, rc = %d (%s)", init_type ? "cleanup" : "setup", rc, err_msg);

error_report("SQLite failed statement %s", batch[i]);

sqlite3_free(err_msg);

if (SQLITE_CORRUPT == rc) {

if (!rebuild)

return attempt_database_fix();

rc = check_table_integrity(NULL);

if (rc)

error_report("Databse integrity errors reported");

}

return 1;

}

}

return 0;

}

int sql_init_database(db_check_action_type_t rebuild, int memory)

{

char *err_msg = NULL;

char sqlite_database[FILENAME_MAX + 1];

int rc;

if (likely(!memory))

snprintfz(sqlite_database, FILENAME_MAX, "%s/netdata-meta.db", netdata_configured_cache_dir);

else

strcpy(sqlite_database, ":memory:");

rc = sqlite3_open(sqlite_database, &db_meta);

if (rc != SQLITE_OK) {

error_report("Failed to initialize database at %s, due to \"%s\"", sqlite_database, sqlite3_errstr(rc));

sqlite3_close(db_meta);

db_meta = NULL;

return 1;

}

if (rebuild & (DB_CHECK_INTEGRITY | DB_CHECK_FIX_DB)) {

int errors_detected = 0;

if (!(rebuild & DB_CHECK_CONT))

info("Running database check on %s", sqlite_database);

if (check_table_integrity("chart")) {

errors_detected++;

if (rebuild & DB_CHECK_FIX_DB)

rebuild_chart();

else

error_report("Errors reported -- run with -W sqlite-fix");

}

if (check_table_integrity("dimension")) {

errors_detected++;

if (rebuild & DB_CHECK_FIX_DB)

rebuild_dimension();

else

error_report("Errors reported -- run with -W sqlite-fix");

}

if (!errors_detected) {

if (check_table_integrity(NULL))

error_report("Errors reported");

}

}

if (rebuild & DB_CHECK_RECLAIM_SPACE) {

if (!(rebuild & DB_CHECK_CONT))

info("Reclaiming space of %s", sqlite_database);

rc = sqlite3_exec(db_meta, "VACUUM;", 0, 0, &err_msg);

if (rc != SQLITE_OK) {

error_report("Failed to execute VACUUM rc = %d (%s)", rc, err_msg);

sqlite3_free(err_msg);

}

}

if (rebuild && !(rebuild & DB_CHECK_CONT))

return 1;

info("SQLite database %s initialization", sqlite_database);

char buf[1024 + 1] = "";

const char *list[2] = { buf, NULL };

int target_version = DB_METADATA_VERSION;

if (likely(!memory))

target_version = perform_database_migration(db_meta, DB_METADATA_VERSION);

// https://www.sqlite.org/pragma.html#pragma_auto_vacuum

// PRAGMA schema.auto_vacuum = 0 | NONE | 1 | FULL | 2 | INCREMENTAL;

snprintfz(buf, 1024, "PRAGMA auto_vacuum=%s;", config_get(CONFIG_SECTION_SQLITE, "auto vacuum", "INCREMENTAL"));

if(init_database_batch(rebuild, 0, list)) return 1;

// https://www.sqlite.org/pragma.html#pragma_synchronous

// PRAGMA schema.synchronous = 0 | OFF | 1 | NORMAL | 2 | FULL | 3 | EXTRA;

snprintfz(buf, 1024, "PRAGMA synchronous=%s;", config_get(CONFIG_SECTION_SQLITE, "synchronous", "NORMAL"));

if(init_database_batch(rebuild, 0, list)) return 1;

// https://www.sqlite.org/pragma.html#pragma_journal_mode

// PRAGMA schema.journal_mode = DELETE | TRUNCATE | PERSIST | MEMORY | WAL | OFF

snprintfz(buf, 1024, "PRAGMA journal_mode=%s;", config_get(CONFIG_SECTION_SQLITE, "journal mode", "WAL"));

if(init_database_batch(rebuild, 0, list)) return 1;

// https://www.sqlite.org/pragma.html#pragma_temp_store

// PRAGMA temp_store = 0 | DEFAULT | 1 | FILE | 2 | MEMORY;

snprintfz(buf, 1024, "PRAGMA temp_store=%s;", config_get(CONFIG_SECTION_SQLITE, "temp store", "MEMORY"));

if(init_database_batch(rebuild, 0, list)) return 1;

// https://www.sqlite.org/pragma.html#pragma_journal_size_limit

// PRAGMA schema.journal_size_limit = N ;

snprintfz(buf, 1024, "PRAGMA journal_size_limit=%lld;", config_get_number(CONFIG_SECTION_SQLITE, "journal size limit", 16777216));

if(init_database_batch(rebuild, 0, list)) return 1;

// https://www.sqlite.org/pragma.html#pragma_cache_size

// PRAGMA schema.cache_size = pages;

// PRAGMA schema.cache_size = -kibibytes;

snprintfz(buf, 1024, "PRAGMA cache_size=%lld;", config_get_number(CONFIG_SECTION_SQLITE, "cache size", -2000));

if(init_database_batch(rebuild, 0, list)) return 1;

snprintfz(buf, 1024, "PRAGMA user_version=%d;", target_version);

if(init_database_batch(rebuild, 0, list)) return 1;

if (init_database_batch(rebuild, 0, &database_config[0]))

return 1;

if (init_database_batch(rebuild, 0, &database_cleanup[0]))

return 1;

fatal_assert(0 == uv_mutex_init(&sqlite_transaction_lock));

info("SQLite database initialization completed");

for (int i = 0; i < MAX_PREPARED_STATEMENTS; i++)

(void)pthread_key_create(&key_pool[i], release_statement);

return 0;

}

void sql_close_database(void)

{

int rc;

if (unlikely(!db_meta))

return;

info("Closing SQLite database");

add_stmt_to_list(NULL);

rc = sqlite3_close_v2(db_meta);

if (unlikely(rc != SQLITE_OK))

error_report("Error %d while closing the SQLite database, %s", rc, sqlite3_errstr(rc));

return;

}

#define FIND_UUID_TYPE "select 1 from host where host_id = @uuid union select 2 from chart where chart_id = @uuid union select 3 from dimension where dim_id = @uuid;"

int find_uuid_type(uuid_t *uuid)

{

static __thread sqlite3_stmt *res = NULL;

int rc;

int uuid_type = 3;

if (unlikely(!res)) {

rc = prepare_statement(db_meta, FIND_UUID_TYPE, &res);

if (rc != SQLITE_OK) {

error_report("Failed to bind prepare statement to find UUID type in the database");

return 0;

}

}

rc = sqlite3_bind_blob(res, 1, uuid, sizeof(*uuid), SQLITE_STATIC);

if (unlikely(rc != SQLITE_OK))

goto bind_fail;

rc = sqlite3_step(res);

if (likely(rc == SQLITE_ROW))

uuid_type = sqlite3_column_int(res, 0);

rc = sqlite3_reset(res);

if (unlikely(rc != SQLITE_OK))

error_report("Failed to reset statement during find uuid type, rc = %d", rc);

return uuid_type;

bind_fail:

return 0;

}

int find_dimension_uuid(RRDSET *st, RRDDIM *rd, uuid_t *store_uuid)

{

static __thread sqlite3_stmt *res = NULL;

int rc;

int status = 1;

if (unlikely(!db_meta) && default_rrd_memory_mode != RRD_MEMORY_MODE_DBENGINE)

return 1;

if (unlikely(!res)) {

rc = prepare_statement(db_meta, SQL_FIND_DIMENSION_UUID, &res);

if (rc != SQLITE_OK) {

error_report("Failed to bind prepare statement to lookup dimension UUID in the database");

return 1;

}

}

rc = sqlite3_bind_blob(res, 1, st->chart_uuid, sizeof(*st->chart_uuid), SQLITE_STATIC);

if (unlikely(rc != SQLITE_OK))

goto bind_fail;

rc = sqlite3_bind_text(res, 2, rd->id, -1, SQLITE_STATIC);

if (unlikely(rc != SQLITE_OK))

goto bind_fail;

rc = sqlite3_bind_text(res, 3, rd->name, -1, SQLITE_STATIC);

if (unlikely(rc != SQLITE_OK))

goto bind_fail;

rc = sqlite3_step(res);

if (likely(rc == SQLITE_ROW)) {

uuid_copy(*store_uuid, *((uuid_t *) sqlite3_column_blob(res, 0)));

status = 0;

}

else {

uuid_generate(*store_uuid);

status = sql_store_dimension(store_uuid, st->chart_uuid, rd->id, rd->name, rd->multiplier, rd->divisor, rd->algorithm);

if (unlikely(status))

error_report("Failed to store dimension metadata in the database");

}

rc = sqlite3_reset(res);

if (unlikely(rc != SQLITE_OK))

error_report("Failed to reset statement find dimension uuid, rc = %d", rc);

return status;

bind_fail:

error_report("Failed to bind input parameter to perform dimension UUID database lookup, rc = %d", rc);

return 1;

}

#define DELETE_DIMENSION_UUID "delete from dimension where dim_id = @uuid;"

void delete_dimension_uuid(uuid_t *dimension_uuid)

{

static __thread sqlite3_stmt *res = NULL;

int rc;

#ifdef NETDATA_INTERNAL_CHECKS

char uuid_str[GUID_LEN + 1];

uuid_unparse_lower(*dimension_uuid, uuid_str);

debug(D_METADATALOG,"Deleting dimension uuid %s", uuid_str);

if (unlikely(!res)) {

rc = prepare_statement(db_meta, DELETE_DIMENSION_UUID, &res);

if (rc != SQLITE_OK) {

error_report("Failed to prepare statement to delete a dimension uuid");

return;

}

}

rc = sqlite3_bind_blob(res, 1, dimension_uuid, sizeof(*dimension_uuid), SQLITE_STATIC);

if (unlikely(rc != SQLITE_OK))

goto bind_fail;

rc = sqlite3_step(res);

if (unlikely(rc != SQLITE_DONE))

error_report("Failed to delete dimension uuid, rc = %d", rc);

bind_fail:

rc = sqlite3_reset(res);

if (unlikely(rc != SQLITE_OK))

error_report("Failed to reset statement when deleting dimension UUID, rc = %d", rc);

return;

}

uuid_t *find_chart_uuid(RRDHOST *host, const char *type, const char *id, const char *name)

{

static __thread sqlite3_stmt *res = NULL;

uuid_t *uuid = NULL;

int rc;

if (unlikely(!db_meta) && default_rrd_memory_mode != RRD_MEMORY_MODE_DBENGINE)

return NULL;

if (unlikely(!res)) {

rc = prepare_statement(db_meta, SQL_FIND_CHART_UUID, &res);

if (rc != SQLITE_OK) {

error_report("Failed to prepare statement to lookup chart UUID in the database");

return NULL;

}

}

rc = sqlite3_bind_blob(res, 1, &host->host_uuid, sizeof(host->host_uuid), SQLITE_STATIC);

if (unlikely(rc != SQLITE_OK))

goto bind_fail;

rc = sqlite3_bind_text(res, 2, type, -1, SQLITE_STATIC);

if (unlikely(rc != SQLITE_OK))

goto bind_fail;

rc = sqlite3_bind_text(res, 3, id, -1, SQLITE_STATIC);

if (unlikely(rc != SQLITE_OK))

goto bind_fail;

rc = sqlite3_bind_text(res, 4, name ? name : id, -1, SQLITE_STATIC);

if (unlikely(rc != SQLITE_OK))

goto bind_fail;

rc = sqlite3_step(res);

if (likely(rc == SQLITE_ROW)) {

uuid = mallocz(sizeof(uuid_t));

uuid_copy(*uuid, sqlite3_column_blob(res, 0));

}

rc = sqlite3_reset(res);

if (unlikely(rc != SQLITE_OK))

error_report("Failed to reset statement when searching for a chart UUID, rc = %d", rc);

#ifdef NETDATA_INTERNAL_CHECKS

char uuid_str[GUID_LEN + 1];

if (likely(uuid)) {

uuid_unparse_lower(*uuid, uuid_str);

debug(D_METADATALOG, "Found UUID %s for chart %s.%s", uuid_str, type, name ? name : id);

}

else

debug(D_METADATALOG, "UUID not found for chart %s.%s", type, name ? name : id);

return uuid;

bind_fail:

error_report("Failed to bind input parameter to perform chart UUID database lookup, rc = %d", rc);

rc = sqlite3_reset(res);

if (unlikely(rc != SQLITE_OK))

error_report("Failed to reset statement when searching for a chart UUID, rc = %d", rc);

return NULL;

}

int update_chart_metadata(uuid_t *chart_uuid, RRDSET *st, const char *id, const char *name)

{

int rc;

if (unlikely(!db_meta) && default_rrd_memory_mode != RRD_MEMORY_MODE_DBENGINE)

return 0;

rc = sql_store_chart(

chart_uuid, &st->rrdhost->host_uuid, st->type, id, name, st->family, st->context, st->title, st->units, st->plugin_name,

st->module_name, st->priority, st->update_every, st->chart_type, st->rrd_memory_mode, st->entries);

return rc;

}

uuid_t *create_chart_uuid(RRDSET *st, const char *id, const char *name)

{

uuid_t *uuid = NULL;

int rc;

uuid = mallocz(sizeof(uuid_t));

uuid_generate(*uuid);

#ifdef NETDATA_INTERNAL_CHECKS

char uuid_str[GUID_LEN + 1];

uuid_unparse_lower(*uuid, uuid_str);

debug(D_METADATALOG,"Generating uuid [%s] for chart %s under host %s", uuid_str, st->id, st->rrdhost->hostname);

rc = update_chart_metadata(uuid, st, id, name);

if (unlikely(rc))

error_report("Failed to store chart metadata in the database");

return uuid;

}

static int exec_statement_with_uuid(const char *sql, uuid_t *uuid)

{

int rc, result = 1;

sqlite3_stmt *res = NULL;

rc = sqlite3_prepare_v2(db_meta, sql, -1, &res, 0);

if (unlikely(rc != SQLITE_OK)) {

error_report("Failed to prepare statement %s, rc = %d", sql, rc);

return 1;

}

rc = sqlite3_bind_blob(res, 1, uuid, sizeof(*uuid), SQLITE_STATIC);

if (unlikely(rc != SQLITE_OK)) {

error_report("Failed to bind host parameter to %s, rc = %d", sql, rc);

goto failed;

}

rc = execute_insert(res);

if (likely(rc == SQLITE_DONE))

result = 0;

else

error_report("Failed to execute %s, rc = %d", sql, rc);

failed:

rc = sqlite3_finalize(res);

if (unlikely(rc != SQLITE_OK))

error_report("Failed to finalize statement %s, rc = %d", sql, rc);

return result;

}

void migrate_localhost(uuid_t *host_uuid)

{

int rc;

rc = exec_statement_with_uuid("UPDATE chart SET host_id = @host_id WHERE host_id in (SELECT host_id FROM host where host_id <> @host_id and hops = 0); ", host_uuid);

if (!rc)

rc = exec_statement_with_uuid("DELETE FROM host WHERE hops = 0 AND host_id <> @host_id; ", host_uuid);

if (!rc)

db_execute("DELETE FROM node_instance WHERE host_id NOT IN (SELECT host_id FROM host);");

}

int sql_store_host(

uuid_t *host_uuid, const char *hostname, const char *registry_hostname, int update_every, const char *os,

const char *tzone, const char *tags, int hops)

{

static __thread sqlite3_stmt *res = NULL;

int rc;

if (unlikely(!db_meta)) {

if (default_rrd_memory_mode != RRD_MEMORY_MODE_DBENGINE)

return 0;

error_report("Database has not been initialized");

return 1;

}

if (unlikely((!res))) {

rc = prepare_statement(db_meta, SQL_STORE_HOST, &res);

if (unlikely(rc != SQLITE_OK)) {

error_report("Failed to prepare statement to store host, rc = %d", rc);

return 1;

}

}

rc = sqlite3_bind_blob(res, 1, host_uuid, sizeof(*host_uuid), SQLITE_STATIC);

if (unlikely(rc != SQLITE_OK))

goto bind_fail;

rc = sqlite3_bind_text(res, 2, hostname, -1, SQLITE_STATIC);

if (unlikely(rc != SQLITE_OK))

goto bind_fail;

rc = sqlite3_bind_text(res, 3, registry_hostname, -1, SQLITE_STATIC);

if (unlikely(rc != SQLITE_OK))

goto bind_fail;

rc = sqlite3_bind_int(res, 4, update_every);

if (unlikely(rc != SQLITE_OK))

goto bind_fail;

rc = sqlite3_bind_text(res, 5, os, -1, SQLITE_STATIC);

if (unlikely(rc != SQLITE_OK))

goto bind_fail;

rc = sqlite3_bind_text(res, 6, tzone, -1, SQLITE_STATIC);

if (unlikely(rc != SQLITE_OK))

goto bind_fail;

rc = sqlite3_bind_text(res, 7, tags, -1, SQLITE_STATIC);

if (unlikely(rc != SQLITE_OK))

goto bind_fail;

rc = sqlite3_bind_int(res, 8, hops);

if (unlikely(rc != SQLITE_OK))

goto bind_fail;

int store_rc = sqlite3_step(res);

if (unlikely(store_rc != SQLITE_DONE))

error_report("Failed to store host %s, rc = %d", hostname, rc);

rc = sqlite3_reset(res);

if (unlikely(rc != SQLITE_OK))

error_report("Failed to reset statement to store host %s, rc = %d", hostname, rc);

return !(store_rc == SQLITE_DONE);

bind_fail:

error_report("Failed to bind parameter to store host %s, rc = %d", hostname, rc);

rc = sqlite3_reset(res);

if (unlikely(rc != SQLITE_OK))

error_report("Failed to reset statement to store host %s, rc = %d", hostname, rc);

return 1;

}

int sql_store_chart(

uuid_t *chart_uuid, uuid_t *host_uuid, const char *type, const char *id, const char *name, const char *family,

const char *context, const char *title, const char *units, const char *plugin, const char *module, long priority,

int update_every, int chart_type, int memory_mode, long history_entries)

{

static __thread sqlite3_stmt *res = NULL;

int rc, param = 0;

if (unlikely(!db_meta)) {

if (default_rrd_memory_mode != RRD_MEMORY_MODE_DBENGINE)

return 0;

error_report("Database has not been initialized");

return 1;

}

if (unlikely(!res)) {

rc = prepare_statement(db_meta, SQL_STORE_CHART, &res);

if (unlikely(rc != SQLITE_OK)) {

error_report("Failed to prepare statement to store chart, rc = %d", rc);

return 1;

}

}

param++;

rc = sqlite3_bind_blob(res, 1, chart_uuid, sizeof(*chart_uuid), SQLITE_STATIC);

if (unlikely(rc != SQLITE_OK))

goto bind_fail;

param++;

rc = sqlite3_bind_blob(res, 2, host_uuid, sizeof(*host_uuid), SQLITE_STATIC);

if (unlikely(rc != SQLITE_OK))

goto bind_fail;

param++;

rc = sqlite3_bind_text(res, 3, type, -1, SQLITE_STATIC);

if (unlikely(rc != SQLITE_OK))

goto bind_fail;

param++;

rc = sqlite3_bind_text(res, 4, id, -1, SQLITE_STATIC);

if (unlikely(rc != SQLITE_OK))

goto bind_fail;

param++;

if (name && *name)

rc = sqlite3_bind_text(res, 5, name, -1, SQLITE_STATIC);

else

rc = sqlite3_bind_null(res, 5);

if (unlikely(rc != SQLITE_OK))

goto bind_fail;

param++;

rc = sqlite3_bind_text(res, 6, family, -1, SQLITE_STATIC);

if (unlikely(rc != SQLITE_OK))

goto bind_fail;

param++;

rc = sqlite3_bind_text(res, 7, context, -1, SQLITE_STATIC);

if (unlikely(rc != SQLITE_OK))

goto bind_fail;

param++;

rc = sqlite3_bind_text(res, 8, title, -1, SQLITE_STATIC);

if (unlikely(rc != SQLITE_OK))

goto bind_fail;

param++;

rc = sqlite3_bind_text(res, 9, units, -1, SQLITE_STATIC);

if (unlikely(rc != SQLITE_OK))

goto bind_fail;

param++;

rc = sqlite3_bind_text(res, 10, plugin, -1, SQLITE_STATIC);

if (unlikely(rc != SQLITE_OK))

goto bind_fail;

param++;

rc = sqlite3_bind_text(res, 11, module, -1, SQLITE_STATIC);

if (unlikely(rc != SQLITE_OK))

goto bind_fail;

param++;

rc = sqlite3_bind_int(res, 12, priority);

if (unlikely(rc != SQLITE_OK))

goto bind_fail;

param++;

rc = sqlite3_bind_int(res, 13, update_every);

if (unlikely(rc != SQLITE_OK))

goto bind_fail;

param++;

rc = sqlite3_bind_int(res, 14, chart_type);

if (unlikely(rc != SQLITE_OK))

goto bind_fail;

param++;

rc = sqlite3_bind_int(res, 15, memory_mode);

if (unlikely(rc != SQLITE_OK))

goto bind_fail;

param++;

rc = sqlite3_bind_int(res, 16, history_entries);

if (unlikely(rc != SQLITE_OK))

goto bind_fail;

rc = execute_insert(res);

if (unlikely(rc != SQLITE_DONE))

error_report("Failed to store chart, rc = %d", rc);

rc = sqlite3_reset(res);

if (unlikely(rc != SQLITE_OK))

error_report("Failed to reset statement in chart store function, rc = %d", rc);

return 0;

bind_fail:

error_report("Failed to bind parameter %d to store chart, rc = %d", param, rc);

rc = sqlite3_reset(res);

if (unlikely(rc != SQLITE_OK))

error_report("Failed to reset statement in chart store function, rc = %d", rc);

return 1;

}

int sql_store_dimension(

uuid_t *dim_uuid, uuid_t *chart_uuid, const char *id, const char *name, collected_number multiplier,

collected_number divisor, int algorithm)

{

static __thread sqlite3_stmt *res = NULL;

int rc;

if (unlikely(!db_meta)) {

if (default_rrd_memory_mode != RRD_MEMORY_MODE_DBENGINE)

return 0;

error_report("Database has not been initialized");

return 1;

}

if (unlikely(!res)) {

rc = prepare_statement(db_meta, SQL_STORE_DIMENSION, &res);

if (unlikely(rc != SQLITE_OK)) {

error_report("Failed to prepare statement to store dimension, rc = %d", rc);