fcst_db.h

Go to the documentation of this file.

//---------------------------------------------------------------------------
//
//    FCST: Fuel Cell Simulation Toolbox
//
//    Copyright (C) 2006-13 by Energy Systems Design Laboratory, University of Alberta
//
//    This software is distributed under the MIT License.
//    For more information, see the README file in /doc/LICENSE
//
//    - Class: FCSTdatabase
//    - Description: A class for interfacing with SQL databases,
//          for the purpose of accessing and storing simulation results.
//    - Developers: Philip Wardlaw
//
//---------------------------------------------------------------------------

#ifndef FCSTDATABASE_H_
#define FCSTDATABASE_H_

#include <utils/fcst_utilities.h>
#include  <utils/logging.h>
//SQLITE3
#include <sqlite3.h>

//STL
#include <iostream>
#include <ctime>
#include <string>
#include <cstddef>        // std::size_t
#include <vector>
#include <stdexcept>
#include <fstream>
#include <chrono>
#include <thread>
#include <random>

//Deal.ii



//Boost
#include <boost/algorithm/string.hpp>

namespace FcstUtilities
{
    class DatabaseOC;

        class FCSTdatabase {
                public:
            FCSTdatabase();
            virtual ~FCSTdatabase();

            bool connect(const std::string& db_path_, const bool& create_if_does_not_exist = false);

            bool connect();

            bool disconnect();

            bool has_data(const std::string& model_name, const DatabaseOC& OC);

            bool has_data(const std::string& model_name, const DatabaseOC& OC, const double& tolerance);

            std::vector<std::vector<double>> get_data(const std::string& model_name, const DatabaseOC& OC);

            std::vector<std::vector<double>> get_data(const std::string& model_name, const DatabaseOC& OC, const double& tolerance);

            std::vector<std::vector<double>> get_data(const std::string& model_name, const DatabaseOC& OC, const double& tolerance, const std::string& orderby);

            bool commit_data(const std::string& model_name, const DatabaseOC& OC, const std::vector<std::string>& column_names, const std::vector<std::vector<double>>& data);

            std::vector<std::vector<std::string>> request(const std::string& sqlCmd);

            bool clear_data(const std::string& model_name, const DatabaseOC& OC);

            void cleanUp();

                private:
            /*
             * SQLite object for all our db interactions
             */
            sqlite3 *db;

            /*
             * Status variables
             */
            bool connected;
            std::string db_path;

            /*
             * Temporary variable for storing requested data
             */
            std::vector<std::vector<std::string>> temp;

            /*
             * Static call back function used for interfacing with sqlite3_exec
             * Required by public function request
             */
            static int callback(void *db_, int argc, char **argv, char **azColName){

                FCSTdatabase* db = reinterpret_cast<FCSTdatabase*>(db_);
                std::vector<std::string> line_temp;
                std::string str_temp;
                for(int i=0; i<argc; i++){
                    str_temp = argv[i] ? argv[i] : "NULL";
                    line_temp.push_back(std::string(str_temp));

                }
                db->temp.push_back(line_temp);
                return 0;
            }

            /*
             * Function for creating new entry in HEAD table
             * Required by public function commit_data
             */
            std::string make_new_head_entry(const std::string& model_name, const DatabaseOC& OC);

            /*
             * Function for creating new entry in HEAD table
             * Required by public function commit_data
             */
            bool create_table(const std::string& table_name, const std::vector<std::string>& column_names);

            /*
             * Function for filling an empty table with data
             * Required by public function commit_data
             */
            bool fill_empty_table(const std::string&  table_name, const std::vector<std::vector<double>>& data, const std::vector<std::string>& column_names);

            /*
             * Function for finding a the table name for a given model name and OC
             * Required by public function has_data and clear_data
             */
            std::string find_table(const std::string&  model_name, const DatabaseOC& OC);

            std::string find_table(const std::string&  model_name, const DatabaseOC& OC, const double& tolerance);


            bool find_matching_head_term(const std::vector<std::string>& OC, const std::vector<std::string>& head_line, const double& tolerance);


            /*
             * Private wrapper function for making requests that don't require an answer other than a yes or no
             * The main difference between this function and request is that here callback is simply 0, i.e. we do not read the returned data
             * Required by several public and private functions
             */
            bool request_no_callback(const std::string&  sqlCmd);

            /*
             * Variables associated with database locking.
             */
            const static int max_lock;
            unsigned int max_milli;
            double lock_time;

            /*
             * Private function that implements the all request functionality.
             * Request(sqlCmd) and request_no_callback functions rely on this function.
             * Standard variable lockCounter is used to recursively call this function in the event of a database lock (for reattempts)
             * Bool useCallBack determines if we read the returned data
             */

            bool request(const std::string&  sqlCmd, const bool& useCallBack,  int lockCounter = max_lock);


            bool create_new_db(const std::string& filePath);
    };


    class DatabaseOC{

        //FCSTdatabase is allowed to access private members of this class
        friend class FCSTdatabase;

        public:
            DatabaseOC();

            bool add_param(const std::string& name, const double& value);
            bool add_param(const std::string&, const std::string& );

            inline void clear(){
                num_param = 0;
                param_data.clear();
            }


            bool compare(const DatabaseOC& other, const double& tolerance);

        private:


            int num_param;
            int max_param;
            std::vector<std::vector<std::string>> param_data;

    };

}



#endif /* FCSTDATABASE_H_ */