Database.h

Go to the documentation of this file.

/*
* FinTP - Financial Transactions Processing Application
* Copyright (C) 2013 Business Information Systems (Allevo) S.R.L.
*
* 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 3 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, see <http://www.gnu.org/licenses/>
* or contact Allevo at : 031281 Bucuresti, 23C Calea Vitan, Romania,
* phone +40212554577, office@allevo.ro <mailto:office@allevo.ro>, www.allevo.ro.
*/

#ifndef ABSTRACTDATABASE_H
#define ABSTRACTDATABASE_H

#include <string>
#include <xercesc/dom/DOM.hpp>

using namespace std;

#include "AppExceptions.h"

#include "ConnectionString.h"
#include "DataSet.h"
#include "DataCommand.h"

namespace FinTP
{
        class ExportedUdalObject DBWarningException : public AppException
        {
                public:
                        explicit DBWarningException( const string& argumentName = "No argument", const EventType::EventTypeEnum eventType = EventType::Warning, const NameValueCollection* additionalInfo = NULL );
                        ~DBWarningException() throw() {}
        };

        class ExportedUdalObject DBErrorException : public AppException
        {
                private :
                        string m_Code;

                public:

                        explicit DBErrorException( const string& argumentName = "No argument", const EventType::EventTypeEnum eventType = EventType::Error, const NameValueCollection* additionalInfo = NULL );
                        ~DBErrorException() throw() {}

                        string code() const;
                        void setCode( const string& code );
        };

        class ExportedUdalObject DBConnectionLostException : public AppException
        {
                public:

                        explicit DBConnectionLostException( const string& argumentName = "No argument", const EventType::EventTypeEnum eventType = EventType::Error, const NameValueCollection* additionalInfo = NULL );
                        ~DBConnectionLostException() throw() {};
        };

        class ExportedUdalObject DBNoUpdatesException : public AppException
        {
                public:
                        explicit DBNoUpdatesException( const string& argumentName = "No argument",const EventType::EventTypeEnum eventType = EventType::Warning, const NameValueCollection* additionalInfo = NULL );
                        ~DBNoUpdatesException() throw() {}
        };

        class ExportedUdalObject TransactionType
        {
                public :

                        typedef enum
                        {
                            COMMIT,
                            ROLLBACK
                        } TRANSACTION_TYPE;

                        static string ToString( TRANSACTION_TYPE type );
        };

        class ExportedUdalObject Database
        {
                protected :
                        CacheManager< string, DataCommand > m_StatementCache;
                        string m_LastErrorCode;
                        unsigned int m_LastNumberofAffectedRows;
                        
                public:

                        Database();
                        virtual ~Database();

                        virtual void BeginTransaction( const bool readonly ) = 0;
                        void BeginTransaction() {
                                BeginTransaction( false );
                        }

                        virtual void EndTransaction( const TransactionType::TRANSACTION_TYPE transactionType, const bool throwOnError ) = 0;
                        void EndTransaction( const TransactionType::TRANSACTION_TYPE transactionType ) {
                                EndTransaction( transactionType, true );
                        }

                        virtual void Connect( const ConnectionString& connectionString ) = 0;

                        virtual void Disconnect() = 0;

                        virtual bool IsConnected() = 0;

                        virtual void ExecuteNonQuery( const DataCommand::COMMAND_TYPE commandType, const string& stringStatement, bool onCursor ) = 0;
                        void ExecuteNonQuery( const DataCommand::COMMAND_TYPE commandType, const string& stringStatement )
                        {
                                ExecuteNonQuery( commandType, stringStatement, false );
                        }

                        virtual void ExecuteNonQueryCached( const DataCommand::COMMAND_TYPE commandType, const string& stringStatement, bool onCursor ) = 0;
                        void ExecuteNonQueryCached( const DataCommand::COMMAND_TYPE commandType, const string& stringStatement )
                        {
                                ExecuteNonQueryCached( commandType, stringStatement, false );
                        }

                        virtual void ExecuteNonQuery( const DataCommand::COMMAND_TYPE commandType, const string& stringStatement, const ParametersVector& vectorOfParameters, bool onCursor ) = 0;
                        void ExecuteNonQuery( const DataCommand::COMMAND_TYPE commandType, const string& stringStatement, const ParametersVector& vectorOfParameters )
                        {
                                ExecuteNonQuery( commandType, stringStatement, vectorOfParameters, false );
                        }

                        virtual void ExecuteNonQueryCached( const DataCommand::COMMAND_TYPE commandType, const string& stringStatement, const ParametersVector& vectorOfParameters, bool onCursor ) = 0;
                        void ExecuteNonQueryCached( const DataCommand::COMMAND_TYPE commandType, const string& stringStatement, const ParametersVector& vectorOfParameters )
                        {
                                ExecuteNonQueryCached( commandType, stringStatement, vectorOfParameters, false );
                        }

                        virtual DataSet* ExecuteQuery( const DataCommand::COMMAND_TYPE commandType, const string& stringStatement, bool holdCursor, const unsigned int fetchRows ) = 0;
                        DataSet* ExecuteQuery( const DataCommand::COMMAND_TYPE commandType, const string& stringStatement, bool holdCursor )
                        {
                                return ExecuteQuery( commandType, stringStatement, holdCursor, 0 );
                        }
                        DataSet* ExecuteQuery( const DataCommand::COMMAND_TYPE commandType, const string& stringStatement )
                        {
                                return ExecuteQuery( commandType, stringStatement, false, 0 );
                        }

                        virtual DataSet* ExecuteQueryCached( const DataCommand::COMMAND_TYPE commandType, const string& stringStatement, const bool holdCursor, const unsigned int fetchRows ) = 0;
                        DataSet* ExecuteQueryCached( const DataCommand::COMMAND_TYPE commandType, const string& stringStatement, bool holdCursor )
                        {
                                return ExecuteQueryCached( commandType, stringStatement, holdCursor, 0 );
                        }
                        DataSet* ExecuteQueryCached( const DataCommand::COMMAND_TYPE commandType, const string& stringStatement )
                        {
                                return ExecuteQueryCached( commandType, stringStatement, false, 0 );
                        }

                        virtual DataSet* ExecuteQuery( const DataCommand::COMMAND_TYPE commandType, const string& stringStatement, const ParametersVector& vectorOfParameters, bool holdCursor, const unsigned int fetchRows ) = 0;
                        DataSet* ExecuteQuery( const DataCommand::COMMAND_TYPE commandType, const string& stringStatement, const ParametersVector& vectorOfParameters, bool holdCursor )
                        {
                                return ExecuteQuery( commandType, stringStatement, vectorOfParameters, holdCursor, 0 );
                        }
                        DataSet* ExecuteQuery( const DataCommand::COMMAND_TYPE commandType, const string& stringStatement, const ParametersVector& vectorOfParameters )
                        {
                                return ExecuteQuery( commandType, stringStatement, vectorOfParameters, false, 0 );
                        }

                        virtual DataSet* ExecuteQueryCached( const DataCommand::COMMAND_TYPE commandType, const string& stringStatement, const ParametersVector& vectorOfParameters, const bool holdCursor, const unsigned int fetchRows ) = 0;
                        DataSet* ExecuteQueryCached( const DataCommand::COMMAND_TYPE commandType, const string& stringStatement, const ParametersVector& vectorOfParameters, bool holdCursor )
                        {
                                return ExecuteQueryCached( commandType, stringStatement, vectorOfParameters, holdCursor, 0 );
                        }
                        DataSet* ExecuteQueryCached( const DataCommand::COMMAND_TYPE commandType, const string& stringStatement, const ParametersVector& vectorOfParameters )
                        {
                                return ExecuteQueryCached( commandType, stringStatement, vectorOfParameters, false, 0 );
                        }

                        virtual void ReleaseCursor( const bool checkConn ) = 0;
                        void ReleaseCursor() {
                                ReleaseCursor( true );
                        }

                        virtual bool CursorHeld() const {
                                return false;
                        }

                        virtual void RewindCursor() = 0;

                        static void DisplayDataSet( const DataSet* theDataSet );

                        int getLastNumberofAffectedRows() const {
                                return m_LastNumberofAffectedRows;
                        }

                        static string DateFormat;
                        static string TimestampFormat;
                        static XERCES_CPP_NAMESPACE_QUALIFIER DOMDocument* ConvertToXML( const DataSet* theDataSet, const bool doTrimm = true );
        };
}

#endif // ABSTRACTDATABASE_H