dbManager.h

Go to the documentation of this file.

#ifndef DATA_DEDUPLICATION_SERVICE_DBMANAGER_H
#define DATA_DEDUPLICATION_SERVICE_DBMANAGER_H
 
#include <iostream>
#include <vector>
#include <utility>
#include <string>
 
#include <pqxx/pqxx>
 
#include "myConcepts.h"
#include "dbCommon.h"
#include "HashUtils.h"
 
 
using myConcepts::paramType;
using
enum myConcepts::paramType;
using namespace hash_utils;
 
 
namespace db_services {
    using myConcepts::gClk;
 
    void diconnect(conPtr &conn);
 
    class dbManager {
    public:
        dbManager() : cString_(db_services::defaultConfiguration()), conn_(nullptr) {}
 
        explicit dbManager(myConnString &ss) : cString_(ss), conn_(nullptr) {}
 
        void setCString(myConnString &ss) {
            cString_ = ss;
            disconnect();
        }
 
        [[nodiscard]] const myConnString &getCString() const {
            return cString_;
        }
 
        int connectToDb();
 
        void disconnect() {
            db_services::diconnect(conn_);
        }
 
        //inpired by https://stackoverflow.com/questions/49122358/libbqxx-c-api-to-connect-to-postgresql-without-db-name
        int createDatabase(std::string_view dbName);
 
        int dropDatabase(std::string_view dbName);
 
        int fillSchemas();
 
        int clearSegments();
 
        std::vector<std::pair<indexType, std::string>> getAllFiles(std::string_view dirPath);
 
        indexType createFile(std::string_view filePath, uintmax_t fileSize = 0, size_t segmentSize = 0,
                             hash_function hash = SHA_256);
 
        indexType createDirectory(std::string_view dirPath);
 
        int deleteFile(std::string_view filePath, indexType fileId = paramType::EmptyParameterValue);
 
        int deleteDirectory(std::string_view directoryPath);
 
        int getFileStreamed(std::string_view fileName, std::ostream &output,
                            indexType fileId = paramType::EmptyParameterValue);
 
        int insertFileFromStream(std::string_view fileName, std::istream &in, size_t segmentSize, std::size_t fileSize,
                                 const hash_function& hash=SHA_256);
 
        int finishFileProcessing(std::string_view filePath, indexType fileId);
 
        bool checkConnection() {
            return db_services::checkConnection(conn_);
        }
 
        ~dbManager() {
            disconnect();
        }
 
        template<typename ResultType, typename ... Args>
        tl::expected<ResultType, int>
        executeInTransaction(ResultType (*call)(trasnactionType &, Args ...), Args &&... args) {
            return db_services::executeInTransaction(conn_, call, std::forward<Args>(args)...);
        }
 
        template<typename ResultType, typename ... Args>
        tl::expected<ResultType, int>
        executeInTransaction(const std::function<ResultType(trasnactionType &, Args ...)> &call, Args &&... args) {
            return db_services::executeInTransaction(conn_, call, std::forward<Args>(args)...);
        }
 
    private:
        int updateFileTime(indexType fileId);
 
        myConnString cString_;
        conPtr conn_;
 
    };
 
 
 
 
}
 
 
#endif //DATA_DEDUPLICATION_SERVICE_DBMANAGER_H