RTSQLBatch_Impl.hh

//********************************************************************
//*** ResourcePool/SQL/RTSQLBatch_Impl.hh
//*** Copyright (c) 2003-2008 by Markus Winand <mws@fatalmind.com>
//*** $Id: RTSQLBatch_Impl.hh,v 1.2 2008/04/14 07:43:53 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_SQL_RTSQLBATCH_IMPL_HH
#define RESOURCEPOOL_SQL_RTSQLBATCh_IMPL_HH

#include "config.h"
#include "util/Clone.hh"

#include "ResourcePool/SQL/Factory.hh"
#include "ResourcePool/SQL/ConcreteWrapper.hh"

#ifdef HAVE_MYSQL
#include "ResourcePool/mysql/ResourcePool.hh"
#endif

#ifdef HAVE_ORACLE
#include "ResourcePool/oracle/ResourcePool.hh"
#include "ResourcePool/oracle/Resource.hh"
#include "ResourcePool/oracle/oracleType.hh"
#endif


#include <sstream>

namespace fatalmind {
namespace SQL {

template<class TM>
class RTSQLBatch_Impl: public Clone {
    public:
        RTSQLBatch_Impl() {
        };
        virtual ~RTSQLBatch_Impl() {
        }

        virtual void execute(SQLResource<TM>& hand) = 0;
        virtual int getError() = 0;

        virtual int getExecOffset() const = 0;

        virtual void add(const Command<ResourceType<TM> > &) = 0;

        virtual bool doesContinue() const = 0;
        virtual bool empty() const = 0;
        virtual void outputoperator(std::ostream&) const = 0;

        template<class CS>
        static typename CS::Impl* newRealCommand(
              typename SQLFactory<TM>::databaseType_t a_type
            , typename CS::RTC& a_that
            , const bool cont
        ) {
            switch(a_type) {
#ifdef HAVE_MYSQL
            case SQLFactory<TM>::MYSQLTX :
            case SQLFactory<TM>::MYSQL :
                return new typename CS::template Specialized<fatalmind::ResourceType::mysql>::Impl(a_that, cont);
                break;
#endif
#ifdef HAVE_ORACLE
            case SQLFactory<TM>::OCI:
                return new typename CS::template Specialized<fatalmind::ResourceType::oracle>::Impl(a_that, cont);
                break;
#endif
            default:
                std::ostringstream oss;
                oss << "Assertaion failure (type=" << a_type << ")";
                throw Exception(oss.str());
                break;
        }
    }
};

template<class TM, template<class TM2>class B, class RT, class CW, class RTC>
class RTSQLBatch_SpecializedImplCloneHelper
{
    public:
    static Clone* DoClone(const Clone * const that) {
        throw CloneException(that); 
    }
};

// fwd decl
template<class TM, template<class TM2>class B, class RT, class CW, class RTC>
class RTSQLBatch_SpecializedImpl ;

template<class TM, class RT, class CW, class RTC>
class RTSQLBatch_SpecializedImplCloneHelper<TM, RTSQLBatch_Impl, RT, CW, RTC>
{
    public:
    typedef  RTSQLBatch_SpecializedImpl<TM, RTSQLBatch_Impl, RT, CW, RTC> target;
    static Clone* DoClone(const Clone *const that) {
        const target *x = dynamic_cast<const target*>(that);    
        return new target(*x);
    }
};


template<class TM, template<class TM2>class B, class RT, class CW, class RTC>
class RTSQLBatch_SpecializedImpl 
: public B<TM>
{
    public:
        RTSQLBatch_SpecializedImpl(RTC& rtc, const bool cont) 
        : sqlBatch_(rtc, cont)
        {
        }

        virtual void execute(SQLResource<TM>& hand) {
            sqlBatch_.execute(
                dynamic_cast<
                    SQLResourceSpecialized<TM, typename RT::resource_t>&
                >(hand).getRealResource()
            );
        }
        virtual int getError() {
            return sqlBatch_.getError();
        }

        virtual int getExecOffset() const {
            if (sqlBatch_.getExecPosition() == sqlBatch_.end()) {
                return -1;
            } else {
                return std::distance(sqlBatch_.begin(), sqlBatch_.getExecPosition());
            }
        }

        virtual bool doesContinue() const {
            return sqlBatch_.doesContinue();    
        }

        virtual bool empty() const {
            return sqlBatch_.empty();   
        }

        virtual void outputoperator(std::ostream& s) const {
            sqlBatch_.outputoperator(s);
        }

        virtual void add(const Command<ResourceType<TM> >& cmd) {
            const RTSQLCommand<TM>* rtcmd = dynamic_cast<const RTSQLCommand<TM>* >(&cmd);
            if (rtcmd != 0) {
                sqlBatch_.add(dynamic_cast<const Command<RT>& >(*rtcmd->getPlainSpecializedCommand()));
            } else {
                ConcreteWrapper<RT , ResourceType<TM> > wrap(cmd);
                sqlBatch_.add(wrap);
            }
        }

    protected:
        virtual Clone* DoClone() const {
            return RTSQLBatch_SpecializedImplCloneHelper<TM, B, RT, CW, RTC>::DoClone(this);
        }

        CW sqlBatch_;
};


} // namespace SQL
} // namespace fatalmind

#endif

---