SQLExecute.hh

//********************************************************************
//*** ResourcePool/oracle/SQLExecute.hh
//*** Copyright (c) 2003-2008 by Markus Winand <mws@fatalmind.com>
//*** $Id: SQLExecute.hh,v 1.26 2008/04/14 13:38:27 mws Exp $
//********************************************************************
/*
This file is part of ResourcePool.

ResourcePool 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.

ResourcePool 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 ResourcePool; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307  USA */

#ifndef RESOURCEPOOL_ORACLE_SQLEXECUTE_HH
#define RESOURCEPOOL_ORACLE_SQLEXECUTE_HH

#ifndef RESOURCEPOOL_ORACLE_RESOURCEFWD_HH
#include "ResourceFwd.hh"
#endif

#ifndef RESOURCEPOOL_ORACLE_COMMANDCOMMON_HH
#include "CommandCommon.hh"
#endif

// TODO: exposes oci.h, or not?
//#include "OracleExceptionFactory.hh"
 
#include <string>
#include <deque>

#include "mm/RawBuffer.hh"

namespace fatalmind {

// forward decl
class OracleExceptionFactory;

namespace oracle {

// forward decl, to be able to be friends
template <class CommandType>
class OptimizedBatchCommand;

template <class TM, template<class>class SLMDC>
class SQLExecute
: public CommandCommon<TM, SLMDC>
{
        typedef CommandCommon<TM, SLMDC> super;
        typedef SQLExecute<TM, SLMDC> this_t;
        using super::_SQL;
        using super::_sth;
    public:
        SQLExecute(const std::string& SQL);
        SQLExecute(const ResourcePool<ResourceType<TM> >& p, const std::string& SQL);
        virtual ~SQLExecute();

        // TODO: make protected
        /*
         * attemts to add another command for batch execution.
         * batching is only possible for exactly same SQL statements
         * where number and types of arguments match exactly.
         *
         * \return true if the statement was added to the batch.
         *         false otherwise.
         */
        bool addBatch(const SQLExecute<TM, SLMDC>& p);

        /*
         * returns the number of executions currently scheduled.
         * usually 1, or bigger in case addBatch was called.
         */
        int  batchSize() const;

#ifndef FATALMIND_TEST_SHOW_PROTECTED
    protected:
#endif
        SQLExecute(const this_t&);
        virtual Clone* DoClone() const;
        void _execute(fatalmind::oracleResource<TM>&,StatementCache&);
        bool push_onto_BatchParamSizes(const typename super::super_bind::_argst& p);

        virtual const std::string& getCommandName() const;
        static const std::string _SQLExecuteName;

        /*
         * throws a previously stored exection (which happend
         * during a batch execution or returns immediately
         * if there is no (further) exception.
         */
        void throwBatchException() const;
        /*
         * retruns the offset of the "next" thrown exception.
         * or BatchCommand::NO_FURTHER_ERROR if there is none.
         */
        int  getBatchExceptionOffset() const;

        typedef std::vector<typename super::super_bind::_argst> batchParams_t;
        batchParams_t batchParams;
        std::vector<gc_ptr<RawBuffer> > batchBuffers;

        // the following store all the excetptions which occured
        // during a batch execution.
        // These structrues are filled during the actual execution
        // of the batch, and the can be accessed afterwards,
        // without the need for an actual resource.
        // candidate for circular buffesr
        mutable std::deque<OracleExceptionFactory> batchedExceptions;
        mutable std::deque<int>                    batchedExceptionOffsets;

        /*
         * perform the OCIBind and OCIBindArrayOfStruct() calls.
         */
        void real_bind_batch(oracleHandles&);

    private:
        class SQLExecuteBatchArguementsImpl;
        gc_ptr<SQLExecuteBatchArguementsImpl> batchParamData;


        this_t& operator=(const this_t&);
        
    friend
        class oracle::OptimizedBatchCommand<Command<oracle::ResourceType<TM, SLMDC> > >;
};


} // namespace oracle
} // namespace fatalmind
#endif

---