Program Listing for File dbRoot.hpp

↰ Return to documentation for file (include/db/dbRoot.hpp)

#pragma once
#include <string>
#include <vector>
#include <optional>
#include <sqlite3.h>

#include <rocksdb/db.h>
#include <rocksdb/options.h>
#include <rocksdb/table.h>
#include <rocksdb/filter_policy.h>


#include "musicDB.hpp"
#include "trackDB.hpp"
#include <filesystem>
#include "PDJE_EXPORT_SETTER.hpp"

namespace fs = std::filesystem;

using MUS_VEC = std::vector<musdata>;
using MAYBE_MUS_VEC = std::optional<MUS_VEC>;

using TRACK_VEC = std::vector<trackdata>;
using MAYBE_TRACK_VEC = std::optional<TRACK_VEC>;

namespace RDB = ROCKSDB_NAMESPACE;
class PDJE_API litedb{
private:
    fs::path ROOT_PATH;
    fs::path sqldbPath;
    fs::path kvdbPath;
    fs::path vectordbPath;
    sqlite3* sdb = nullptr;
    RDB::DB* kvdb = nullptr;
    RDB::WriteOptions wops;
    RDB::ReadOptions rops;

    bool CheckTables();
public:
    template<typename DBType>
    std::optional<std::vector<DBType>>
    operator<<(DBType& searchClue);

    template<typename DBType>
    bool
    operator<=(DBType& insertObject);

    template<typename DBType>
    bool
    DeleteData(DBType& deleteObject);

    template<typename DBType>
    bool
    EditData(DBType& searchObject, DBType& editObject); //to-do impl

    bool
    KVGet(const SANITIZED& K, DONT_SANITIZE& V);

    bool
    KVPut(const SANITIZED& K, const DONT_SANITIZE& V);

    bool openDB(const fs::path& dbPath);

    const fs::path
    getRoot(){
        return ROOT_PATH;
    }

    litedb();
    ~litedb();
};

template<typename DBType>
std::optional<std::vector<DBType>>
litedb::operator<<(DBType& searchClue)
{
    stmt dbstate = stmt();
    if(searchClue.GenSearchSTMT(dbstate, sdb)){
        std::vector<DBType> data;
        while(sqlite3_step(dbstate.S) == SQLITE_ROW){
            data.emplace_back(&dbstate);
        }
        return std::move(data);
    }
    else{
        return std::nullopt;
    }
}
#include <iostream>
template<typename DBType>
bool
litedb::operator<=(DBType& insertObject)
{
    sqlite3_exec(sdb, "BEGIN TRANSACTION;", NULL, NULL, NULL);
    std::cout << "dbRoot.hpp:115 operator" << "   " << std::endl;
    stmt dbstate = stmt();
    if(insertObject.GenInsertSTMT(dbstate, sdb)){
        auto insertRes = sqlite3_step(dbstate.S);
        if(insertRes != SQLITE_DONE){
            std::cout << "dbRoot.hpp:119 FATAL ERROR: insertRes-" << insertRes << "   " << std::endl;
            sqlite3_exec(sdb, "ROLLBACK;", NULL, NULL, NULL);
            return false;
        }
        sqlite3_exec(sdb, "COMMIT;", nullptr, nullptr, NULL);
        return true;
    }
    std::cout << "dbRoot.hpp:124 FATAL ERROR: GenInsertSTMT ERROR" << std::endl;
    return false;
}

template<typename DBType>
bool
litedb::DeleteData(DBType& deleteObject)
{
    stmt dbstate = stmt();
    if(deleteObject.GenDeleteSTMT(dbstate, sdb)){
        auto deleteRes = sqlite3_step(dbstate.S);
        if(deleteRes != SQLITE_DONE){
            return false;
        }
        return true;
    }
    return false;
}

template<typename DBType>
bool
litedb::EditData(DBType& searchObject, DBType& editObject)
{
    stmt dbstate = stmt();
    if(searchObject.GenEditSTMT(dbstate, sdb, editObject)){
        auto editRes = sqlite3_step(dbstate.S);
        if(editRes != SQLITE_DONE){
            return false;
        }
        return true;
    }
    return false;
}