db/db.h

Go to the documentation of this file.

#ifndef DBALLE_DB_DB_H
#define DBALLE_DB_DB_H

#include <dballe/core/cursor.h>
#include <dballe/db.h>
#include <dballe/db/defs.h>
#include <dballe/db/fwd.h>
#include <dballe/fwd.h>
#include <dballe/msg/fwd.h>
#include <dballe/sql/fwd.h>
#include <functional>
#include <memory>
#include <string>
#include <wreport/var.h>
#include <wreport/varinfo.h>

namespace dballe {

namespace impl {

struct DBImportOptions : public dballe::DBImportOptions
{
    DBImportOptions()                                  = default;
    DBImportOptions(const DBImportOptions& o)          = default;
    DBImportOptions(DBImportOptions&& o)               = default;
    DBImportOptions& operator=(const DBImportOptions&) = default;
    DBImportOptions& operator=(DBImportOptions&&)      = default;
};

struct DBInsertOptions : public dballe::DBInsertOptions
{
    DBInsertOptions()                                  = default;
    DBInsertOptions(const DBInsertOptions& o)          = default;
    DBInsertOptions(DBInsertOptions&& o)               = default;
    DBInsertOptions& operator=(const DBInsertOptions&) = default;
    DBInsertOptions& operator=(DBInsertOptions&&)      = default;
};

} // namespace impl

namespace db {

std::string format_format(Format format);

Format format_parse(const std::string& str);

struct CursorStation : public impl::CursorStation
{
    virtual void remove() = 0;

    virtual unsigned test_iterate(FILE* dump = 0) = 0;
};

struct CursorStationData : public impl::CursorStationData
{
    virtual void remove() = 0;

    virtual std::shared_ptr<db::Transaction> get_transaction() const = 0;

    virtual int attr_reference_id() const = 0;

    virtual void
    query_attrs(std::function<void(std::unique_ptr<wreport::Var>)> dest,
                bool force_read = false) = 0;

    virtual void insert_attrs(const Values& attrs);

    virtual void remove_attrs(const db::AttrList& attrs);

    virtual unsigned test_iterate(FILE* dump = 0) = 0;
};

struct CursorData : public impl::CursorData
{
    virtual void remove() = 0;

    virtual std::shared_ptr<db::Transaction> get_transaction() const = 0;

    virtual int attr_reference_id() const = 0;

    virtual void
    query_attrs(std::function<void(std::unique_ptr<wreport::Var>)> dest,
                bool force_read = false) = 0;

    virtual void insert_attrs(const Values& attrs);

    virtual void remove_attrs(const db::AttrList& attrs);

    virtual unsigned test_iterate(FILE* dump = 0) = 0;
};

struct CursorSummary : public impl::CursorSummary
{
    virtual void remove() = 0;

    virtual unsigned test_iterate(FILE* dump = 0) = 0;
};

class Transaction : public dballe::Transaction
{
public:
    virtual ~Transaction() {}

    virtual void clear_cached_state() = 0;

    virtual void attr_query_station(
        int data_id,
        std::function<void(std::unique_ptr<wreport::Var>)> dest) = 0;

    virtual void attr_query_data(
        int data_id,
        std::function<void(std::unique_ptr<wreport::Var>)> dest) = 0;

    virtual void attr_insert_station(int data_id, const Values& attrs) = 0;

    virtual void attr_insert_data(int data_id, const Values& attrs) = 0;

    virtual void attr_remove_station(int data_id,
                                     const db::AttrList& attrs) = 0;

    virtual void attr_remove_data(int data_id, const db::AttrList& attrs) = 0;

    virtual void update_repinfo(const char* repinfo_file, int* added,
                                int* deleted, int* updated) = 0;

    virtual void dump(FILE* out) = 0;
};

class DB : public dballe::DB
{
public:
    static db::Format get_default_format();
    static void set_default_format(db::Format format);

    static std::shared_ptr<DB> connect_from_file(const char* pathname);

    static std::shared_ptr<DB> connect_memory();

    static std::shared_ptr<DB> create(std::shared_ptr<sql::Connection> conn);

    static bool is_url(const char* str);

    virtual db::Format format() const = 0;

    virtual void disappear() = 0;

    virtual void reset(const char* repinfo_file = 0) = 0;

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

    virtual void vacuum() = 0;

    virtual void attr_query_station(
        int data_id, std::function<void(std::unique_ptr<wreport::Var>)>&& dest);

    virtual void
    attr_query_data(int data_id,
                    std::function<void(std::unique_ptr<wreport::Var>)>&& dest);

    void attr_insert_station(int data_id, const Values& attrs);

    void attr_insert_data(int data_id, const Values& attrs);

    void attr_remove_station(int data_id, const db::AttrList& attrs);

    void attr_remove_data(int data_id, const db::AttrList& attrs);

    void dump(FILE* out);

    virtual void print_info(FILE* out);

    static const char* default_repinfo_file();

    inline static std::unique_ptr<db::DB>
    downcast(std::unique_ptr<dballe::DB> db)
    {
        db::DB* res = dynamic_cast<db::DB*>(db.get());
        if (!res)
            throw std::runtime_error(
                "Attempted to downcast the wrong kind of DB");
        db.release();
        return std::unique_ptr<db::DB>(res);
    }

    inline static std::shared_ptr<db::DB>
    downcast(std::shared_ptr<dballe::DB> db)
    {
        auto res = std::dynamic_pointer_cast<db::DB>(db);
        if (!res)
            throw std::runtime_error(
                "Attempted to downcast the wrong kind of DB");
        return res;
    }
};

} // namespace db
} // namespace dballe
#endif