db.h

#ifndef DBALLE_DB_H
#define DBALLE_DB_H

#include <dballe/fwd.h>
#include <memory>
#include <vector>
#include <wreport/var.h>

namespace dballe {

class DBConnectOptions
{
public:
    std::string url;

    bool wipe = false;

    void reset_actions();

    static std::unique_ptr<DBConnectOptions> create(const std::string& url);

    static std::unique_ptr<DBConnectOptions>
    test_create(const char* backend = nullptr);

protected:
    DBConnectOptions()                                   = default;
    DBConnectOptions(const DBConnectOptions&)            = default;
    DBConnectOptions(DBConnectOptions&&)                 = default;
    DBConnectOptions& operator=(const DBConnectOptions&) = default;
    DBConnectOptions& operator=(DBConnectOptions&&)      = default;
};

class DBImportOptions
{
public:
    std::string report;

    bool import_attributes = false;

    bool update_station = false;

    bool overwrite = false;

    std::vector<wreport::Varcode> varlist;

    static std::unique_ptr<DBImportOptions> create();

    static const DBImportOptions defaults;

    friend class DB;
    friend class Transaction;

protected:
    DBImportOptions()                                  = default;
    DBImportOptions(const DBImportOptions&)            = default;
    DBImportOptions(DBImportOptions&&)                 = default;
    DBImportOptions& operator=(const DBImportOptions&) = default;
    DBImportOptions& operator=(DBImportOptions&&)      = default;
};

class DBInsertOptions
{
public:
    bool can_replace = false;

    bool can_add_stations = true;

    static std::unique_ptr<DBInsertOptions> create();

    static const DBInsertOptions defaults;

protected:
    DBInsertOptions()                                  = default;
    DBInsertOptions(const DBInsertOptions&)            = default;
    DBInsertOptions(DBInsertOptions&&)                 = default;
    DBInsertOptions& operator=(const DBInsertOptions&) = default;
    DBInsertOptions& operator=(DBInsertOptions&&)      = default;
};

class Transaction : public std::enable_shared_from_this<Transaction>
{
public:
    virtual ~Transaction();

    virtual void commit() = 0;

    virtual void rollback() = 0;

    virtual void rollback_nothrow() noexcept = 0;

    virtual std::shared_ptr<CursorStation>
    query_stations(const Query& query) = 0;

    virtual std::shared_ptr<CursorStationData>
    query_station_data(const Query& query) = 0;

    virtual std::shared_ptr<CursorData> query_data(const Query& query) = 0;

    virtual std::shared_ptr<CursorSummary>
    query_summary(const Query& query) = 0;

    virtual std::shared_ptr<CursorMessage>
    query_messages(const Query& query) = 0;

    virtual void remove_all() = 0;

    virtual void remove_station_data(const Query& query) = 0;

    virtual void remove_data(const Query& query) = 0;

    virtual void
    import_message(const Message& message,
                   const DBImportOptions& opts = DBImportOptions::defaults) = 0;

    virtual void
    import_messages(const std::vector<std::shared_ptr<Message>>& messages,
                    const DBImportOptions& opts = DBImportOptions::defaults);

    virtual void insert_station_data(
        Data& data,
        const DBInsertOptions& opts = DBInsertOptions::defaults) = 0;

    virtual void
    insert_data(Data& data,
                const DBInsertOptions& opts = DBInsertOptions::defaults) = 0;
};

class DB : public std::enable_shared_from_this<DB>
{
public:
    virtual ~DB();

    static std::shared_ptr<DB> connect(const DBConnectOptions& opts);

    virtual std::shared_ptr<dballe::Transaction>
    transaction(bool readonly = false) = 0;

    virtual std::shared_ptr<CursorStation> query_stations(const Query& query);

    virtual std::shared_ptr<CursorStationData>
    query_station_data(const Query& query);

    virtual std::shared_ptr<CursorData> query_data(const Query& query);

    virtual std::shared_ptr<CursorSummary> query_summary(const Query& query);

    virtual std::shared_ptr<CursorMessage> query_messages(const Query& query);

    void remove_all();

    void remove_station_data(const Query& query);

    void remove_data(const Query& query);

    void
    import_message(const Message& message,
                   const DBImportOptions& opts = DBImportOptions::defaults);

    void
    import_messages(const std::vector<std::shared_ptr<Message>>& messages,
                    const DBImportOptions& opts = DBImportOptions::defaults);

    void insert_station_data(
        Data& vals, const DBInsertOptions& opts = DBInsertOptions::defaults);

    void insert_data(Data& vals,
                     const DBInsertOptions& opts = DBInsertOptions::defaults);
};

} // namespace dballe

#endif