Database.hpp

Go to the documentation of this file.

/*
 *
 * ---
 *
 *  Copyright (C) 2021 Anselm Schmidt (ans[ät]ohai.su)
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version in addition to the terms of any
 *  licences already herein identified.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * ---
 *
 * Database.hpp
 *
 * Interface to be inherited by the module threads.
 * Allows them access to the database by providing basic Database functionality as well as the option to add prepared SQL statements.
 *
 *  Created on: Oct 22, 2018
 *      Author: ans
 */

#ifndef WRAPPER_DATABASE_HPP_
#define WRAPPER_DATABASE_HPP_

#include "../Data/Data.hpp"
#include "../Helper/Portability/mysqlcppconn.h"
#include "../Module/Database.hpp"
#include "../Struct/DatabaseSettings.hpp"
#include "../Struct/ModuleOptions.hpp"
#include "../Struct/QueryProperties.hpp"
#include "../Struct/TableColumn.hpp"
#include "../Struct/TableProperties.hpp"
#include "../Struct/TargetTableProperties.hpp"
#include "../Wrapper/DatabaseLock.hpp"
#include "../Wrapper/DatabaseTryLock.hpp"

#include <cppconn/prepared_statement.h>

#include <mysql_connection.h>

#include <cstddef>      // std::size_t
#include <cstdint>      // std::uint8_t, std::uint64_t
#include <functional>   // std::function
#include <queue>        // std::queue
#include <string>       // std::string
#include <string_view>  // std::string_view
#include <utility>      // std::pair

namespace crawlservpp::Wrapper {

    /*
     * DECLARATION
     */


    class Database {
        // for convenience
        using ModuleOptions = Struct::ModuleOptions;
        using QueryProperties = Struct::QueryProperties;
        using TableColumn = Struct::TableColumn;
        using TableProperties = Struct::TableProperties;
        using TargetTableProperties = Struct::TargetTableProperties;

        using IdString = std::pair<std::uint64_t, std::string>;
        using IsRunningCallback = std::function<bool()>;

    public:
        template<class DB> friend class Wrapper::DatabaseLock;

        template<class DB> friend class Wrapper::DatabaseTryLock;


        explicit Database(Module::Database& dbThread);

        virtual ~Database() = default;


        void setLogging(std::uint8_t level, std::uint8_t min, std::uint8_t verbose);
        void setSleepOnError(std::uint64_t seconds);
        void setTimeOut(std::uint64_t milliseconds);


        void log(std::uint8_t level, const std::string& logEntry);
        void log(std::uint8_t level, std::queue<std::string>& logEntries);


        [[nodiscard]] std::string getWebsiteDomain(std::uint64_t websiteId);


        void getQueryProperties(std::uint64_t queryId, QueryProperties& queryPropertiesTo);


        [[nodiscard]] std::string getConfiguration(std::uint64_t configId);


        std::uint64_t addOrUpdateTargetTable(const TargetTableProperties& properties);
        [[nodiscard]] std::queue<IdString> getTargetTables(const std::string& type, std::uint64_t listId);
        [[nodiscard]] std::uint64_t getTargetTableId(
                const std::string& type,
                std::uint64_t listId,
                const std::string& tableName
        );
        [[nodiscard]] std::string getTargetTableName(const std::string& type, std::uint64_t tableId);
        void addTargetColumn(const std::string& tableName, const TableColumn& column);
        void deleteTargetTable(const std::string& type, std::uint64_t tableId);


        void beginNoLock();
        void endNoLock();


        [[nodiscard]] bool isTableEmpty(const std::string& tableName);
        [[nodiscard]] bool isTableExists(const std::string& tableName);
        [[nodiscard]] bool isColumnExists(const std::string& tableName, const std::string& columnName);
        [[nodiscard]] std::string getColumnType(const std::string& tableName, const std::string& columnName);


        void getCustomData(Data::GetValue& data);
        void getCustomData(Data::GetFields& data);
        void getCustomData(Data::GetFieldsMixed& data);
        void getCustomData(Data::GetColumn& data);
        void getCustomData(Data::GetColumns& data);
        void getCustomData(Data::GetColumnsMixed& data);
        void insertCustomData(const Data::InsertValue& data);
        void insertCustomData(const Data::InsertFields& data);
        void insertCustomData(const Data::InsertFieldsMixed& data);
        void updateCustomData(const Data::UpdateValue& data);
        void updateCustomData(const Data::UpdateFields& data);
        void updateCustomData(const Data::UpdateFieldsMixed& data);


        [[nodiscard]] static std::uint64_t getRequestCounter();



        Database(Database&) = delete;

        Database& operator=(Database&) = delete;

        Database(Database&&) = delete;

        Database& operator=(Database&&) = delete;


    protected:

        Module::Database& database;


        [[nodiscard]] const ModuleOptions& getOptions() const;
        [[nodiscard]] const std::string& getWebsiteIdString() const;
        [[nodiscard]] const std::string& getUrlListIdString() const;
        [[nodiscard]] std::uint8_t getLoggingMin() const;
        [[nodiscard]] std::uint8_t getLoggingVerbose() const;
        [[nodiscard]] std::uint64_t getMaxAllowedPacketSize() const;


        void checkConnection();


        // wrappers for managing prepared SQL statements
        void reserveForPreparedStatements(std::size_t n);
        void addPreparedStatement(const std::string& sqlQuery, std::size_t& id);
        void clearPreparedStatement(std::size_t& id);
        [[nodiscard]] sql::PreparedStatement& getPreparedStatement(std::size_t id);


        [[nodiscard]] std::uint64_t getLastInsertedId();
        static void addDatabaseLock(const std::string& name, const IsRunningCallback& isRunningCallback);
        static bool tryDatabaseLock(const std::string& name);
        static void removeDatabaseLock(const std::string& name);
        void createTable(const TableProperties& properties);
        void addColumn(const std::string& tableName, const TableColumn& column);
        void dropTable(const std::string& tableName);
        void compressTable(const std::string& tableName);


        void setUrlListCaseSensitive(std::uint64_t listId, bool isCaseSensitive);


        static void sqlException(const std::string& function, const sql::SQLException& e);


        static bool sqlExecute(sql::PreparedStatement& sqlPreparedStatement);
        static sql::ResultSet * sqlExecuteQuery(sql::PreparedStatement& sqlPreparedStatement);
        static int sqlExecuteUpdate(sql::PreparedStatement& sqlPreparedStatement);

    };

    /*
     * IMPLEMENTATION
     */

    /*
     * CONSTRUCTION AND DESTRUCTION
     */


    inline Database::Database(Module::Database& dbThread) : database(dbThread) {}

    /*
     * SETTERS
     */

    inline void Database::setLogging(std::uint8_t level, std::uint8_t min, std::uint8_t verbose) {
        this->database.setLogging(level, min, verbose);
    }

    inline void Database::setSleepOnError(std::uint64_t seconds) {
        this->database.setSleepOnError(seconds);
    }

    inline void Database::setTimeOut(std::uint64_t milliseconds) {
        this->database.setTimeOut(milliseconds);
    }

    /*
     * LOGGING
     */

    inline void Database::log(std::uint8_t level, const std::string& logEntry) {
        this->database.log(level, logEntry);
    }

    inline void Database::log(std::uint8_t level, std::queue<std::string>& logEntries) {
        this->database.log(level, logEntries);
    }

    /*
     * WEBSITES
     */

    inline std::string Database::getWebsiteDomain(std::uint64_t websiteId) {
        return this->database.getWebsiteDomain(websiteId);
    }

    /*
     * QUERIES
     */

    inline void Database::getQueryProperties(std::uint64_t queryId, QueryProperties& queryPropertiesTo) {
        this->database.getQueryProperties(queryId, queryPropertiesTo);
    }

    /*
     * CONFIGURATIONS
     */

    inline std::string Database::getConfiguration(std::uint64_t configId) {
        return this->database.getConfiguration(configId);
    }

    /*
     * TARGET TABLES
     */

    inline std::uint64_t Database::addOrUpdateTargetTable(const TargetTableProperties& properties) {
        return this->database.addOrUpdateTargetTable(properties);
    }

    inline std::queue<Database::IdString> Database::getTargetTables(const std::string& type, std::uint64_t listId) {
        return this->database.getTargetTables(type, listId);
    }

    inline std::uint64_t Database::getTargetTableId(
            const std::string& type,
            std::uint64_t listId,
            const std::string& tableName
    ) {
        return this->database.getTargetTableId(type, listId, tableName);
    }

    inline std::string Database::getTargetTableName(const std::string& type, std::uint64_t tableId) {
        return this->database.getTargetTableName(type, tableId);
    }


    inline void Database::addTargetColumn(const std::string& tableName, const TableColumn& column) {
        if(!(this->isColumnExists(tableName, column.name))) {
            this->addColumn(tableName, column);
        }
    }

    inline void Database::deleteTargetTable(const std::string& type, std::uint64_t tableId) {
        this->database.deleteTargetTable(type, tableId);
    }

    /*
     * LOCKING
     */

    inline void Database::beginNoLock() {
        this->database.beginNoLock();
    }

    inline void Database::endNoLock() {
        this->database.endNoLock();
    }

    /*
     * TABLES
     */

    inline bool Database::isTableEmpty(const std::string& tableName) {
        return this->database.isTableEmpty(tableName);
    }

    inline bool Database::isTableExists(const std::string& tableName) {
        return this->database.isTableExists(tableName);
    }

    inline bool Database::isColumnExists(const std::string& tableName, const std::string& columnName) {
        return this->database.isColumnExists(tableName, columnName);
    }

    inline std::string Database::getColumnType(const std::string& tableName, const std::string& columnName) {
        return this->database.getColumnType(tableName, columnName);
    }

    /*
     * CUSTOM DATA
     */

    inline void Database::getCustomData(Data::GetValue& data) {
        this->database.getCustomData(data);
    }

    inline void Database::getCustomData(Data::GetFields& data) {
        this->database.getCustomData(data);
    }

    inline void Database::getCustomData(Data::GetFieldsMixed& data) {
        this->database.getCustomData(data);
    }

    inline void Database::getCustomData(Data::GetColumn& data) {
        this->database.getCustomData(data);
    }

    inline void Database::getCustomData(Data::GetColumns& data) {
        this->database.getCustomData(data);
    }

    inline void Database::getCustomData(Data::GetColumnsMixed& data) {
        this->database.getCustomData(data);
    }

    inline void Database::insertCustomData(const Data::InsertValue& data) {
        this->database.insertCustomData(data);
    }

    inline void Database::insertCustomData(const Data::InsertFields& data) {
        this->database.insertCustomData(data);
    }

    inline void Database::insertCustomData(const Data::InsertFieldsMixed& data) {
        this->database.insertCustomData(data);
    }

    inline void Database::updateCustomData(const Data::UpdateValue& data) {
        this->database.updateCustomData(data);
    }

    inline void Database::updateCustomData(const Data::UpdateFields& data) {
        this->database.updateCustomData(data);
    }

    inline void Database::updateCustomData(const Data::UpdateFieldsMixed& data) {
        this->database.updateCustomData(data);
    }

    /*
     * REQUEST COUNTER
     */

    inline std::uint64_t Database::getRequestCounter() {
        return Main::Database::getRequestCounter();
    }

    /*
     * GETTERS
     */


    inline const Struct::ModuleOptions& Database::getOptions() const {
        return this->database.options;
    }


    inline const std::string& Database::getWebsiteIdString() const {
        return this->database.websiteIdString;
    }


    inline const std::string& Database::getUrlListIdString() const {
        return this->database.urlListIdString;
    }


    inline std::uint8_t Database::getLoggingMin() const {
        return this->database.loggingMin;
    }


    inline std::uint8_t Database::getLoggingVerbose() const {
        return this->database.loggingVerbose;
    }

    inline std::uint64_t Database::getMaxAllowedPacketSize() const {
        return this->database.getMaxAllowedPacketSize();
    }

    /*
     * VALIDATION
     */

    inline void Database::checkConnection() {
        this->database.checkConnection();
    }

    /*
     * HELPER FUNCTIONS FOR PREPARED SQL STATEMENTS
     */

    inline void Database::reserveForPreparedStatements(std::size_t n) {
        this->database.reserveForPreparedStatements(n);
    }

    inline void Database::addPreparedStatement(const std::string& sqlQuery, std::size_t& id) {
        this->database.addPreparedStatement(sqlQuery, id);
    }

    inline void Database::clearPreparedStatement(std::size_t& id) {
        this->database.clearPreparedStatement(id);
    }

    inline sql::PreparedStatement& Database::getPreparedStatement(std::size_t id) {
        return this->database.getPreparedStatement(id);
    }

    /*
     * DATABASE HELPER FUNCTIONS
     */

    inline std::uint64_t Database::getLastInsertedId() {
        return this->database.getLastInsertedId();
    }

    inline void Database::addDatabaseLock(const std::string& name, const IsRunningCallback& isRunningCallback) {
        Main::Database::addDatabaseLock(name, isRunningCallback);
    }

    inline bool Database::tryDatabaseLock(const std::string& name) {
        return Main::Database::tryDatabaseLock(name);
    }

    inline void Database::removeDatabaseLock(const std::string& name) {
        Main::Database::removeDatabaseLock(name);
    }

    inline void Database::createTable(const TableProperties& properties) {
        this->database.createTable(properties);
    }

    inline void Database::addColumn(const std::string& tableName, const TableColumn& column) {
        this->database.addColumn(tableName, column);
    }

    inline void Database::dropTable(const std::string& tableName) {
        this->database.dropTable(tableName);
    }

    inline void Database::compressTable(const std::string& tableName) {
        this->database.compressTable(tableName);
    }

    /*
     * URL LIST HELPER FUNCTION
     */

    inline void Database::setUrlListCaseSensitive(std::uint64_t listId, bool isCaseSensitive) {
        this->database.setUrlListCaseSensitive(listId, isCaseSensitive);
    }

    /*
     * EXCEPTION HELPER FUNCTION
     */

    inline void Database::sqlException(const std::string& function, const sql::SQLException& e) {
        Main::Database::sqlException(function, e);
    }


    inline bool Database::sqlExecute(sql::PreparedStatement& sqlPreparedStatement) {
        return Main::Database::sqlExecute(sqlPreparedStatement);
    }

    /*
     * HELPER FUNCTIONS FOR EXECUTING SQL QUERIES
     */


    inline sql::ResultSet * Database::sqlExecuteQuery(sql::PreparedStatement& sqlPreparedStatement) {
        return Main::Database::sqlExecuteQuery(sqlPreparedStatement);
    }


    inline int Database::sqlExecuteUpdate(sql::PreparedStatement& sqlPreparedStatement) {
        return Main::Database::sqlExecuteUpdate(sqlPreparedStatement);
    }

} /* namespace crawlservpp::Wrapper */

#endif /* WRAPPER_DATABASE_HPP_ */