DBConnection.h

Go to the documentation of this file.

#ifndef CARMA_DBMS_DBCONNECTION_H
#define CARMA_DBMS_DBCONNECTION_H

#include "carma/dbms/MonitorSystemAndDBMSRelationships.h"
#include "carma/dbms/Table.h"
#include "carma/util/ErrorException.h"
#include "carma/util/Logger.h"
#include "carma/util/Time.h"
#include <map>
#include <string>
#include <vector>
#include <unixODBC/sqlext.h>

namespace carma {
namespace dbms {

    class DBConfigurator;

class DBConnection {

public:
    friend class DBConnectionTest;
    friend class LogDatabase;
    friend class MonitorConfigurationDatabase;
    friend class MonitorDataDatabase;
    friend class MonitorDataQueryManager;

    typedef std::map<std::string, std::string> file2TableMap;


    virtual ~DBConnection();

    // -------------------- Database status/info methods --------------------
    static bool isUp(const DBConfigurator *dbconf = NULL); 
                     

    virtual bool isDBUp();

    void odbcInfo() const;

    inline std::string rdbmsName() const {return rdbmsName_;}

    //inline bool usingProductionDB() const {return useProductionDB_;}

    inline std::string dataSource() const {return dataSource_;}


    //------------------ Monitor data tables access --------------------

    virtual std::string createMonitorDataTable(
                                    const MonitorAverageType& averageType,
                                    const MonitorAggregateType& aggType,
                                    const std::string& tag, 
                                    const std::string *const location=NULL) 
        const = 0;


    virtual void loadDataFromFile
        (const std::string& filename, const std::string& table,
         const bool& useTransactions, const int& linesToIgnore=0,
         const std::string& columnDelimiter="\t") const = 0;

    virtual void loadDataFromFiles
        (const file2TableMap& file2Table, const bool& useTransactions, 
         const int& linesToIgnore=0, const std::string& columnDelimiter="\t") 
        const = 0;

    virtual void* getAggregate(const std::string& column, 
                               const std::string& table,
                               const std::string& function,
                               carma::dbms::Table::ColumnType& type) const;

    virtual long getRowCount(const std::string& tableName) const;
    

    //---------------------- General table access ------------------------

    virtual carma::dbms::Table execSQLSelect(const std::string& statement, 
                             const std::string& resultTableName="RESULT TABLE")
        const;


    virtual carma::dbms::Table execSQLSelect
        (const std::vector<std::string>& columnNames, 
         const std::string& tableName,
         const std::string& whereClause="", 
         const std::string& orderByClause="",
         const std::string& groupByClause="",
         const std::string& havingClause="",
         const std::string& resultTableName="RESULT TABLE")
        const;

    virtual void execSQLDropTable(const std::string& tableName) const;

    virtual void deleteFromMonitorIndexTable(const std::string& whereClause)
        const;

    virtual void monitorDataTableHasBeenPopulated(const std::string& tableName,
                                  const MonitorAverageType& averageType) 
        const;

    virtual void dropScratchTable(const std::string& table) const;

    //------------------- Transaction support -------------------------
    virtual void beginTransaction() const;

    virtual void rollBackTransaction() const;

    virtual void commitTransaction() const;

    virtual bool inTransaction() const;


    //------------------- Log table related methods ---------------------
    
     void insertLogMessage(const std::string& message, 
                          const carma::util::frameType& frameCount
                          =carma::util::Time::computeCurrentFrame()) const;


    Table getLogMessages(const carma::util::frameType& start,
                         const carma::util::frameType& end
                         =carma::util::Time::computeCurrentFrame(),
                         const std::string *matchString=NULL) const;

    void closeConnection();

    //--------------------------- Database info ----------------------
    bool tableExists(const std::string& table, const std::string& database) 
        const;

    carma::dbms::Table databaseInfo(const std::string& database="") const;

    // --------------------------SQL Helpers -------------------------
    static std::string createJoinClause
        (const std::string& leftTable, const std::string& rightTable,
         const std::string& leftColumn, const std::string& rightColumn="",
         const std::string& rightTableAlias="", 
         const std::string& indexCol="");

    static std::string createJoinClause
        (const std::string& joinTable, const std::string& onClause);

    static std::string createInsertStatement
        (const std::string& tableName, const std::vector<std::string> columns,
         const std::vector<std::string> values);
                                             
    static std::string createInsertStatement
        (const std::string& tableName, const std::vector<std::string> columns,
         const std::string values);
                                             

    //-------------------------- RDBMS limits --------------------------
    virtual unsigned maxTablesPerJoin() const = 0;

    virtual unsigned maxColumnsPerTable() const = 0;

    std::string virtual caseSensitiveSearchModifier() const { return " "; }

    //----------------------- table repair ---------------------

    virtual void repairMonitorDataTable(const std::string& tableName) 
        const = 0;



protected:
    std::string rdbmsName_;
    std::string dataSource_;
    std::string dbuser_;
    std::string odbcConnectString_;
    std::string socket_;
    unsigned port_;
                            
    // dbname is needed for methods which use native rdbms api calls
    std::string dbname_;
    std::string passwordFile_;
    log4cpp::Category& logger_;
    bool inTxn_;
    std::vector<SQLHSTMT> activeStatements;
    //bool useProductionDB_;
    std::string odbcini_;


    SQLHDBC hdbc_;
    SQLHENV henv_;

    DBConnection(const carma::dbms::DBConfigurator *dbconf); 

    //----------------------- Database access methods -----------------------
    void openODBCConnection_(SQLHENV *henv, SQLHDBC *hdbc);
    void openODBCConnection_();

    void closeODBCConnection_();
    void closeODBCConnection_(SQLHENV henv, SQLHDBC hdbc) const;

    void freeSQLStatement_(const SQLHSTMT& hstmt) const;


    //----------------------- Database query methods ------------------

    void directSQLInsert_(const std::string& statement) const;

    void directSQLExec_(const SQLHSTMT hstmt, const std::string& statement) 
        const;

    carma::dbms::Table odbcResultSetToTable_(const SQLHSTMT& hstmt) const;

    void directSQLExec_(const std::string& statement) const;

    //---------------- query construction methods ---------------------
     std::string readPassword_() const;

};

 class DBConnectionFactory {
     public:
    static DBConnection *createConnection(const DBConfigurator *dbconf=NULL);

 };



// DBConnectionException definition

class DBConnectionException : public carma::util::ErrorException {
public:
    DBConnectionException (const char* msg, const char* fileName = __FILE__, 
                           const int lineNum = __LINE__) 
        : carma::util::ErrorException (msg, fileName, lineNum) {};

    DBConnectionException (const std::string msg, 
                           const char* fileName = __FILE__, 
                           const int lineNum = __LINE__) 
        : carma::util::ErrorException (msg.c_str(), fileName, lineNum) {};

};

class SQLException : public carma::util::ErrorException {
public:
    SQLException (const char* msg, const char* fileName = __FILE__, 
                  const int lineNum = __LINE__) 
        : carma::util::ErrorException (msg, fileName, lineNum) {};

    SQLException (const std::string msg, 
                  const char* fileName = __FILE__, 
                  const int lineNum = __LINE__) 
        : carma::util::ErrorException (msg.c_str(), fileName, lineNum) {};

};

class InsertDeniedException : public carma::util::ErrorException {
public:
    InsertDeniedException (const char* msg, const char* fileName = __FILE__, 
                  const int lineNum = __LINE__) 
        : carma::util::ErrorException (msg, fileName, lineNum) {};

    InsertDeniedException (const std::string msg, 
                  const char* fileName = __FILE__, 
                  const int lineNum = __LINE__) 
        : carma::util::ErrorException (msg.c_str(), fileName, lineNum) {};

};

}}


#endif // CARMA_DBMS_DBCONNECTION_H