DataCommand.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 DATACOMMAND_H
#define DATACOMMAND_H

#include "DllMainUdal.h"
#include "CacheManager.h"
#include "DataParameter.h"
#include "DataColumn.h"

namespace FinTP
{
        class ExportedUdalObject DataCommand
        {
                public :

                        typedef enum
                        {
                            SP,
                            INLINE,

                            CURSOR

                        } COMMAND_TYPE;
 
                        typedef enum
                        {
                            QUERY,

                            NONQUERY
                        } QUERY_TYPE;

                        static string ToString( COMMAND_TYPE type );

                public:

                        DataCommand();

                        DataCommand( const DataCommand::COMMAND_TYPE commandType, const DataCommand::QUERY_TYPE queryType,
                                     const string& statementString, const bool cacheable = false, const string& modStatementString = "" );
                        DataCommand( const DataCommand& source );

                        DataCommand& operator=( const DataCommand& source );

                        ~DataCommand();

                private :

                        DataCommand::COMMAND_TYPE m_CommandType;
                        DataCommand::QUERY_TYPE m_QueryType;

                        string m_StatementString;
                        string m_ModifiedStatementString;

                        bool m_Cacheable;

                        CacheManager< unsigned int, DataColumnBase > m_ResultColumns;

                public :
                        DataCommand::COMMAND_TYPE getCommandType() const {
                                return m_CommandType;
                        }
                        
                        void setCommandType( const DataCommand::COMMAND_TYPE commandType ) {
                                m_CommandType = commandType;
                        }

                        DataCommand::QUERY_TYPE getQueryType() const {
                                return m_QueryType;
                        }
                        bool isQuery() const {
                                return ( m_QueryType == DataCommand::QUERY );
                        }

                        void setQueryType( const DataCommand::QUERY_TYPE queryType ) {
                                m_QueryType = queryType;
                        }

                        string getModifiedStatementString() const {
                                return m_ModifiedStatementString;
                        }

                        void setModifiedStatementString( const string& modStatementString ) {
                                m_ModifiedStatementString = modStatementString;
                        }

                        string getStatementString() const {
                                return m_StatementString;
                        }

                        bool isCacheable() const {
                                return m_Cacheable;
                        }

                        void setCacheable( const bool cacheable ) {
                                m_Cacheable = cacheable;
                        }

                        const DataColumnBase& getResultColumn( unsigned int index ) const {
                                return m_ResultColumns[ index ];
                        }

                        unsigned int getResultColumnCount() const {
                                return m_ResultColumns.size();
                        }

                        void addResultColumn( const unsigned int index, const DataColumnBase* column )
                        {
                                m_ResultColumns.Add( index, DataColumnBase( column->getDimension(), column->getScale(), column->getName(), column->getType(), column->getBaseType() ) );
                        }
        };
}

#endif // DATACOMMAND_H