batch.h

#ifndef DBALLE_DB_V7_BATCH_H
#define DBALLE_DB_V7_BATCH_H
 
#include <dballe/core/smallset.h>
#include <dballe/db/v7/fwd.h>
#include <dballe/db/v7/utils.h>
#include <dballe/types.h>
#include <memory>
#include <tuple>
#include <vector>
#include <wreport/var.h>
 
namespace dballe {
namespace db {
namespace v7 {
struct Transaction;
 
class Batch
{
protected:
    bool write_attrs             = true;
    batch::Station* last_station = nullptr;
 
    bool have_station(const std::string& report, const Coords& coords,
                      const Ident& ident);
    void new_station(Tracer<>& trc, const std::string& report,
                     const Coords& coords, const Ident& ident);
 
public:
    Transaction& transaction;
    unsigned count_select_stations     = 0;
    unsigned count_select_station_data = 0;
    unsigned count_select_data         = 0;
 
    Batch(Transaction& transaction) : transaction(transaction) {}
    ~Batch();
 
    void set_write_attrs(bool write_attrs);
 
    batch::Station* get_station(Tracer<>& trc, const dballe::DBStation& station,
                                bool station_can_add);
    batch::Station* get_station(Tracer<>& trc, const std::string& report,
                                const Coords& coords, const Ident& ident);
 
    void write_pending(Tracer<>& trc);
    void clear();
    void dump(FILE* out) const;
};
 
namespace batch {
 
enum UpdateMode {
    UPDATE,
    IGNORE,
    ERROR,
};
 
struct StationDatum
{
    int id = MISSING_INT;
    const wreport::Var* var;
 
    StationDatum(const wreport::Var* var) : var(var) {}
    StationDatum(int id, const wreport::Var* var) : id(id), var(var) {}
 
    void dump(FILE* out) const;
    bool operator<(const StationDatum& o) const
    {
        return var->code() < o.var->code();
    }
    bool operator==(const StationDatum& o) const
    {
        return var->code() == o.var->code();
    }
};
 
inline const wreport::Varcode& station_data_ids_get_value(const IdVarcode& item)
{
    return item.varcode;
}
 
struct StationDataIDs : public core::SmallSet<IdVarcode, wreport::Varcode,
                                              station_data_ids_get_value>
{
};
 
struct StationData
{
    StationDataIDs ids_by_code;
    std::vector<StationDatum> to_insert;
    std::vector<StationDatum> to_update;
    bool loaded = false;
 
    void add(const wreport::Var* var, UpdateMode on_conflict);
    void write_pending(Tracer<>& trc, Transaction& tr, int station_id,
                       bool with_attrs);
};
 
struct MeasuredDatum
{
    int id = MISSING_INT;
    int id_levtr;
    const wreport::Var* var;
 
    MeasuredDatum(int id_levtr, const wreport::Var* var)
        : id_levtr(id_levtr), var(var)
    {
    }
    MeasuredDatum(int id, int id_levtr, const wreport::Var* var)
        : id(id), id_levtr(id_levtr), var(var)
    {
    }
 
    void dump(FILE* out) const;
    bool operator<(const MeasuredDatum& o) const
    {
        return id_levtr < o.id_levtr ||
               (id_levtr == o.id_levtr && var->code() < o.var->code());
    }
    bool operator==(const MeasuredDatum& o) const
    {
        return id_levtr == o.id_levtr && var->code() == o.var->code();
    }
};
 
struct MeasuredDataID
{
    IdVarcode id_varcode;
    int id;
 
    MeasuredDataID(IdVarcode id_varcode, int id)
        : id_varcode(id_varcode), id(id)
    {
    }
};
 
inline const IdVarcode& measured_data_ids_get_value(const MeasuredDataID& item)
{
    return item.id_varcode;
}
 
struct MeasuredDataIDs : public core::SmallSet<MeasuredDataID, IdVarcode,
                                               measured_data_ids_get_value>
{
};
 
struct MeasuredData
{
    Datetime datetime;
    MeasuredDataIDs ids_on_db;
    std::vector<MeasuredDatum> to_insert;
    std::vector<MeasuredDatum> to_update;
 
    MeasuredData(Datetime datetime) : datetime(datetime) {}
 
    void add(int id_levtr, const wreport::Var* var, UpdateMode on_conflict);
    void write_pending(Tracer<>& trc, Transaction& tr, int station_id,
                       bool with_attrs);
};
 
inline const Datetime& measured_data_vector_get_value(MeasuredData* const& item)
{
    return item->datetime;
}
 
struct MeasuredDataVector
    : public core::SmallSet<MeasuredData*, Datetime,
                            measured_data_vector_get_value>
{
    MeasuredDataVector() {}
    MeasuredDataVector(const MeasuredDataVector&) = delete;
    MeasuredDataVector(MeasuredDataVector&&)      = default;
    ~MeasuredDataVector();
    MeasuredDataVector& operator=(const MeasuredDataVector&) = delete;
    MeasuredDataVector& operator=(MeasuredDataVector&&)      = default;
};
 
struct Station : public dballe::DBStation
{
    Batch& batch;
    bool is_new = true;
    StationData station_data;
    MeasuredDataVector measured_data;
 
    Station(Batch& batch) : batch(batch) {}
 
    StationData& get_station_data(Tracer<>& trc);
    MeasuredData& get_measured_data(Tracer<>& trc, const Datetime& datetime);
 
    void write_pending(Tracer<>& trc, bool with_attrs);
    void dump(FILE* out) const;
};
 
} // namespace batch
} // namespace v7
} // namespace db
} // namespace dballe
 
#endif