schema.h

#ifndef _SCHEMAS_H
#define _SCHEMAS_H
/*
 * Fledge utilities functions for handling stringa
 *
 * Copyright (c) 2022 Dianomic Systems
 *
 * Released under the Apache 2.0 Licence
 *
 * Author: Mark Riddoch
 */
 
#include <sql_buffer.h>
#include <string>
#include <rapidjson/document.h>
#include <sqlite3.h>
#include <logger.h>
#include <map>
 
#define DDL_BACKOFF 50  // Microseconds to backoff between DDL retries
 
class Schema {
    public:
        Schema(const std::string& name, const std::string& service, int version,
                const std::string& definition);
        Schema(sqlite3 *db, const rapidjson::Document& doc);
        ~Schema();
        int     getVersion() { return m_version; };
        std::string getService() { return m_service; };
        bool        upgrade(sqlite3 *db, const rapidjson::Document& doc, const std::string& definition);
        bool        attach(sqlite3 *db);
    private:
        std::string m_name;
        std::string m_service;
        int     m_version;
        std::string m_definition;
        int     m_indexNo;
        std::string m_schemaPath;
        std::map<sqlite3 *, bool>
                m_attached;
    private:
        bool        createTable(sqlite3 *db, const rapidjson::Value& table);
        bool        createIndex(sqlite3 *db, const std::string& table,
                        const rapidjson::Value& index);
        bool        hasTable(const rapidjson::Document& doc, const std::string& table);
        bool        hasColumn(const rapidjson::Document& doc, const std::string& table,
                        const std::string& column);
        bool        addTableColumn(sqlite3 *db, const std::string& table,
                        const rapidjson::Value& column);
        bool        executeDDL(sqlite3 *db, SQLBuffer& sql);
 
        bool        hasString(const rapidjson::Value& value, const char *key)
                {
                    return (value.HasMember(key) && value[key].IsString());
                };
        bool        hasInt(const rapidjson::Value& value, const char *key)
                {
                    return (value.HasMember(key) && value[key].IsInt());
                };
        bool        hasArray(const rapidjson::Value& value, const char *key)
                {
                    return (value.HasMember(key) && value[key].IsArray());
                };
        bool        createDatabase();
        void        setDatabasePath();
};
 
class SchemaManager {
    public:
        static SchemaManager        *getInstance();
        void                load(sqlite3 *db);
        bool                create(sqlite3 *db, const std::string& definition);
        bool                exists(sqlite3 *db, const std::string& schema);
    public:
        static SchemaManager        *instance;
    private:
        SchemaManager();
    private:
        Logger              *m_logger;
        std::map<std::string, Schema *> m_schema;
        bool                m_loaded;
};
#endif