SQLExecute.hh

//********************************************************************
//*** ResourcePool/oracle/SQLExecute.hh
//*** Copyright (c) 2003-2009 by Markus Winand <mws@fatalmind.com>
//*** $Id: SQLExecute.hh,v 1.39 2009-05-11 14:06:05 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
#include "ResourcePool/SQL/SQLStatement.hh"

#include <string>
#include <deque>
#include <memory>

#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;

class BatchInfo;


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;
    public:
        SQLExecute(const SQL::SQLStatement& SQL);
        SQLExecute(const ResourcePool<ResourceType<TM> >& p, const SQL::SQLStatement& 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);

        // similar to addBatch, BUT
        // but returns an empty auto_ptr (auto_ptr.get() == 0) if not batchable 
        // OR auot_ptr.get() !=, which is then the already cloneed noop which must be added
        // Do i need a specialized noop wrapper, to have access to the bind data?, yes, because tx for example or Batche don't have
        std::auto_ptr<Command<oracle::ResourceType<TM, SLMDC> > > addBatch2(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);
        void copySizeIndicator(const typename super::super_bind::_argst& p);

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

        /*
         * basically the catch() block for batch exceptions.
         * in a seperate method, just for better overview in _execute
         */
        void handleBatchException(int ret, oracleResource<TM>& rhand);
        /*
         * 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;

        /*
         * perform the OCIBind and OCIBindArrayOfStruct() calls.
         */
        void real_bind_batch(oracleResource<TM>&);

        virtual void bindoutputoperator(std::ostream& str) const;
    private:
        StatementCache::handle_t _sth; // TODO, believed to be required for addBatch and similar (across execute() invitations), check again

        // lazy init
        gc_ptr<BatchInfo> batchInfo;
        void putInsideBatch();

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


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

---