DBInterface.cpp

Go to the documentation of this file.

/***************************************************************************
 *   SpikeStream Library                                                   *
 *   Copyright (C) 2007 by David Gamez                                     *
 *   david@davidgamez.eu                                                   *
 *   Version 0.1                                                           *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

//SpikeStream includes
#include "DBInterface.h"
#include "Utilities.h"
#include "GlobalVariables.h"

//Other includes
#include <iostream>
#include <iomanip>
using namespace std;
using namespace mysqlpp;


/*! Empty default constructor - not used. */
DBInterface::DBInterface(){
}


/*! Main constructor. */
DBInterface::DBInterface(const char* host, const char* user, const char* password, const char* database){
        Utilities::safeCStringCopy(dbParam.host, host, dbParam.maxParamLength);
        Utilities::safeCStringCopy(dbParam.user, user, dbParam.maxParamLength);
        Utilities::safeCStringCopy(dbParam.password, password, dbParam.maxParamLength);
        Utilities::safeCStringCopy(dbParam.database, database, dbParam.maxParamLength);
}


/*! Destructor. */
DBInterface::~DBInterface(){
        #ifdef MEMORY_DEBUG
                cout<<"DELETING DBINTERFACE. NUMBER OF EXTRA CONNECTIONS: "<<connectionVector.size()<<";"<<endl;
        #endif//MEMORY_DEBUG
        
        //Close and delete the standard connection
        if(connection->connected()){
                connection->close();
        }
        delete connection;
        
        //Close and delete any connections that were created by getNewConnection()
        for(vector<Connection*>::iterator iter = connectionVector.begin(); iter != connectionVector.end(); ++iter){
                if((*iter)->connected()){
                        (*iter)->close();
                }
                delete *iter;
        }
}


//---------------------------------------------------------------------------
//---------------------------- PUBLIC METHODS -------------------------------
//---------------------------------------------------------------------------

/*! Checks the supplied database connection. If it cannot be reconnected, 
        an exception is thrown. */
void DBInterface::checkDatabaseConnection(Connection*& conn){
        /* Ping database to see if we are still connected
                Returns zero if we are ok.*/
        int pingRes = conn->ping();

        //If ping fails, ping a few more times to see if the automatic reconnection works.
        unsigned int reconnectCounter = 1;
        while(pingRes){
                cout<<"DBInterface: Trying to ping "<<dbParam.database<<" database."<<endl;

                //Try to reconnect to the database
                pingRes = conn->ping();

                //Sleep if we have failed less than the maximum number of attempts
                if(pingRes && reconnectCounter <= MAX_NUMBER_RECONNECT_ATTEMPTS)
                        sleep(1);

                /* Try creating a new connection object and if this fails, throw
                        an exception if we have pinged more than the maximum number.*/
                else if (reconnectCounter > MAX_NUMBER_RECONNECT_ATTEMPTS){
                        cout<<"DBInterface. Cannot ping "<<dbParam.database<<" on existing connection. Trying to reconnect to database."<<endl;

                        if(connectToDatabase(conn))//Have successfully reconnected to database
                                pingRes = 0;
                        else
                                throw ConnectionFailed("DBInterface: Failed to reconnect to the database.");
                }

                //Increase the count of the number of failed attempts
                ++reconnectCounter;
        }
}


/*! Connects to the database using the parameters stored in the constructor. */
bool DBInterface::connectToDatabase(bool useEx){
        //Record whether we are using exceptions or not
        useExceptions = useEx;

        //Create a connection using the main connection object of this class
        connection = new Connection(useExceptions);
        return connectToDatabase(connection);
}


/*! Returns the database parameters.
        Mainly used for passing dbparameters to spawned processes. */
const DBParameters DBInterface::getDBParameters(){
        return dbParam;
}


/*! Creates a new connection and returns it. This is generally used for large 
        queries, which need to use ResUse instead of Result.
        NOTE: Exception handling should be done by the calling class.*/
Connection* DBInterface::getNewConnection(){
        // Create a new connection
        Connection *tempConnection = new Connection(useExceptions);

        //Connect this connection to the database
        if(!connectToDatabase(tempConnection)){
                cerr<<"DBInterface: NEW CONNECTION TO DATABASE FAILED: "<<tempConnection->error()<<endl;
                return 0;
        }
        else{
                connectionVector.push_back(tempConnection);//Store a reference to the query for deletion later
                return tempConnection;
        }
}


/*! Returns the query from the main connection.
        Throws an exception if the database connection has failed and cannot be restored.*/
Query DBInterface::getQuery(){

        /* Check the database connection before returning the query.
                This will throw an exception if the database cannot be
                reconnected.*/
        checkDatabaseConnection(connection);

        //Return the query if we have not thrown an exception
        return connection->query();
}


//---------------------------------------------------------------------------
//---------------------------- PRIVATE METHODS -------------------------------
//---------------------------------------------------------------------------

/*! Connects the specified connection to the database.*/
bool DBInterface::connectToDatabase(Connection*& conn){
        try{
                conn->connect(dbParam.database, dbParam.host, dbParam.user, dbParam.password);
                if(!conn->connected()){
                        cerr<<"DBInterface: CONNECTION TO DATABASE FAILED: "<<connection->error()<<endl;
                        return false;
                }
                else{
                        return true;
                }
        }
        catch (const std::exception er) {
                cerr<<"DBInterface: EXCEPTION THROWN CONNECTING TO DATABASE: "<<er.what()<<endl;
        return false;
    }
}

---