screening-manager.hpp

#pragma once
 
#include "tom-tsdb/engine.hpp"
#include "tom-tsdb/session.hpp"
#include "tom-tsdb/connection.hpp"
#include "tom-tsdb/datastore.hpp"
#include "tom-tsdb/provider.hpp"
#include "tom-tsdb/smart_pointers.hpp"
// #include "config.h"
#include <dbsql.h>
#include <vector>
#include <unordered_map>
#include <tom-util/environment.hpp>
#include <thread>
#include <tuple>
 
namespace tom {
    namespace tsdb {
 
    class screening_db;
 
    class sql_query_result {
    public:
        sql_query_result( screening_db & scrn_db, sqlite3 *db, const std::string &sql_statement );
        ~sql_query_result();
 
        bool
        valid() const { return m_statement_valid; }
 
        bool
        next();
 
        bool
        valid_row() const { return m_valid_row; }
 
        int
        get_int( int col );
 
        std::int64_t
        get_int64( int col );
 
        double
        get_double( int col );
 
        std::string
        get_string( int col );
 
    private:
        sqlite3 *       m_db_hndl   { nullptr };
        sqlite3_stmt *  m_statement { nullptr };
        bool            m_statement_valid { false };
        bool            m_valid_row { false };
        screening_db &  m_screen_db;
        tom::logger &   m_logger;
    };
 
    class screening_db {
        class field {
        public:
            field( const tom::observation &field, const tom::observation &dim ) : m_field(field), m_dim(dim) { }
 
            const tom::String &
            field_name() const { return m_field; }
 
            const tom::Int &
            dimension() const { return m_dim; }
        private:
            tom::String m_field;
            tom::Int    m_dim;
        };
    public:
 
        typedef std::vector<field>                  field_vec;
        typedef field_vec::const_iterator           const_iterator;
        typedef field_vec::iterator                 iterator;
        typedef std::vector<time_series_sptr>       ts_vec;
 
        screening_db(   const tom::observation &path,
                        const tom::observation &name,
                        const tom::observation &max_days,
                        const tom::observation &max_rows,
                        const tom::observation &default_repo,
                        const tom::observation &default_db,
                        const tom::observation &discovery_id );
 
        ~screening_db();
 
        void
        add_field(  const tom::observation &field,
                    const tom::observation &dimension );
 
        void
        init();
 
        bool
        exists();
 
        void
        create_table();
 
        void
        populate_table();
 
        void
        update_table();
 
        tom::calendars::date
        get_most_recent_date(const std::string &id );
 
        void
        add_ts( std::string &id, ts_vec & );
 
        void
        update_ts( std::string &id, ts_vec & );
 
        const field_vec &
        fields() const { return m_fields; }
 
        // this can be optimized by caching query result objects, but lets keep it simple to start
        sql_query_result_sptr
        query( const std::string & sql_statement ) { return sql_query_result_sptr( new sql_query_result( *this, m_db_hndl, sql_statement)); }
 
    private:
        tom::String     m_path;
        tom::String     m_name;
        tom::Int        m_max_days;
        tom::Int        m_max_rows;
        tom::String     m_default_repo;
        tom::String     m_default_db;
        tom::String     m_discovery_id;
        sqlite3 *       m_db_hndl { nullptr };
        tom::logger &   m_logger;
 
        field_vec       m_fields;
    };
 
    typedef std::vector<std::string> string_vec;
    typedef std::shared_ptr<string_vec> string_vec_sptr;
 
    class screening_manager {
    public:
        screening_manager( );
 
        string_vec_sptr
        screens() const;
 
        screening_db_sptr
        get_screening_db( const std::string & db_name );
 
        // when a given engine instance is deleted
        // this class is joined, so screening maint. can finish its work
        // before shutting down
        void
        join();
    private:
        void run();
 
        typedef std::unordered_map<std::string,screening_db_sptr>   screen_map;
 
        tom::logger &   m_logger;
        tom::String     m_path;
        screen_map      m_screen_dbs;           // use to init and create/populate/trunc/etc screening dbs
        static thread_local screen_map s_screen_map;    // use to hand out screening_db ptrs to clients
        std::thread *   m_run_thread;
    };
 
    } // end tsdb namespace
} // end tom namespace