db/v7/data.h

#ifndef DBALLE_DB_V7_DATAV7_H
#define DBALLE_DB_V7_DATAV7_H
 
#include <cstdio>
#include <dballe/core/defs.h>
#include <dballe/core/fwd.h>
#include <dballe/db/defs.h>
#include <dballe/db/v7/fwd.h>
#include <dballe/fwd.h>
#include <dballe/sql/fwd.h>
#include <dballe/values.h>
#include <functional>
#include <list>
#include <memory>
#include <vector>
#include <wreport/var.h>
 
namespace dballe {
namespace db {
namespace v7 {
 
template <typename Traits> class DataCommon
{
protected:
    typedef typename Traits::BatchValue BatchValue;
    static const char* table_name;
 
    v7::Transaction& tr;

    void read_attrs_into_values(Tracer<>& trc, int id_data, Values& values);

    void read_attrs_into_values(Tracer<>& trc, int id_data, Values& values,
                                const db::AttrList& exclude);

    virtual void write_attrs(Tracer<>& trc, int id_data,
                             const Values& values) = 0;

    virtual void remove_all_attrs(Tracer<>& trc, int id_data) = 0;
 
public:
    DataCommon(v7::Transaction& tr) : tr(tr) {}
    virtual ~DataCommon() {}

    virtual void
    read_attrs(Tracer<>& trc, int id_data,
               std::function<void(std::unique_ptr<wreport::Var>)> dest) = 0;

    void merge_attrs(Tracer<>& trc, int id_data, const Values& attrs);

    void remove_attrs(Tracer<>& trc, int data_id, const db::AttrList& attrs);

    virtual void update(Tracer<>& trc,
                        std::vector<typename Traits::BatchValue>& vars,
                        bool with_attrs) = 0;

    virtual void remove(Tracer<>& trc, const v7::IdQueryBuilder& qb) = 0;

    virtual void remove_by_id(Tracer<>& trc, int id) = 0;

    virtual void dump(FILE* out) = 0;
 
    virtual void clear_cache() = 0;
};
 
struct StationDataDumper
{
    unsigned count = 0;
    FILE* out;
 
    StationDataDumper(FILE* out);
 
    void print_head();
    void print_row(int id, int id_station, wreport::Varcode code,
                   const char* val, const std::vector<uint8_t>& attrs);
    void print_tail();
};
 
struct DataDumper
{
    unsigned count = 0;
    FILE* out;
 
    DataDumper(FILE* out);
 
    void print_head();
    void print_row(int id, int id_station, int id_levtr, const Datetime& dt,
                   wreport::Varcode code, const char* val,
                   const std::vector<uint8_t>& attrs);
    void print_tail();
};
 
struct StationDataTraits
{
    typedef batch::StationDatum BatchValue;
    static const char* table_name;
};
 
struct DataTraits
{
    typedef batch::MeasuredDatum BatchValue;
    static const char* table_name;
};
 
extern template class DataCommon<StationDataTraits>;
extern template class DataCommon<DataTraits>;
 
struct StationData : public DataCommon<StationDataTraits>
{
    using DataCommon<StationDataTraits>::DataCommon;

    virtual void insert(Tracer<>& trc, int id_station,
                        std::vector<batch::StationDatum>& vars,
                        bool with_attrs) = 0;

    virtual void
    query(Tracer<>& trc, int id_station,
          std::function<void(int id, wreport::Varcode code)> dest) = 0;

    virtual void run_station_data_query(
        Tracer<>& trc, const v7::DataQueryBuilder& qb,
        std::function<void(const dballe::DBStation& station, int id_data,
                           std::unique_ptr<wreport::Var> var)>) = 0;
};
 
struct Data : public DataCommon<DataTraits>
{
    using DataCommon<DataTraits>::DataCommon;

    virtual void insert(Tracer<>& trc, int id_station, const Datetime& datetime,
                        std::vector<batch::MeasuredDatum>& vars,
                        bool with_attrs) = 0;

    virtual void
    query(Tracer<>& trc, int id_station, const Datetime& datetime,
          std::function<void(int id, int id_levtr, wreport::Varcode code)>
              dest) = 0;

    virtual void run_data_query(
        Tracer<>& trc, const v7::DataQueryBuilder& qb,
        std::function<void(const dballe::DBStation& station, int id_levtr,
                           const Datetime& datetime, int id_data,
                           std::unique_ptr<wreport::Var> var)>) = 0;

    virtual void run_summary_query(
        Tracer<>& trc, const v7::SummaryQueryBuilder& qb,
        std::function<void(const dballe::DBStation& station, int id_levtr,
                           wreport::Varcode code, const DatetimeRange& datetime,
                           size_t size)>) = 0;
};
 
} // namespace v7
} // namespace db
} // namespace dballe
#endif