RTSQLExecute_Impl.hh

//********************************************************************
//*** ResourcePool/SQL/RTSQLExecute_Impl.hh
//*** Copyright (c) 2003-2008 by Markus Winand <mws@fatalmind.com>
//*** $Id: RTSQLExecute_Impl.hh,v 1.22 2008/05/19 07:50:24 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_RTSQLEXECUTE_IMPL_HH
#define RESOURCEPOOL_SQL_RTSQLEXECUTE_IMPL_HH

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

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

#ifdef HAVE_MYSQL
#include "ResourcePool/mysql/ResourcePool.hh"
#include "ResourcePool/mysql/Resource.hh"
#include <mysql/mysql.h>
#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 RTSQLExecute_Impl: public Clone {
    public:
        RTSQLExecute_Impl() {
        };
        virtual ~RTSQLExecute_Impl() {
        }

        virtual void bind(const int pos, const char, bool nul = false) = 0;
        virtual void bind(const int pos, const signed char, bool nul = false) = 0;
        virtual void bind(const int pos, const unsigned char, bool nul = false) = 0;

        virtual void bind(const int pos, const short int val, bool nul = false) = 0;
        virtual void bind(const int pos, const int val, bool nul = false) = 0;
        virtual void bind(const int pos, const long int val, bool nul = false) = 0;

        virtual void bind(const int pos, const unsigned short int val, bool nul = false) = 0;
        virtual void bind(const int pos, const unsigned int val, bool nul = false) = 0;
        virtual void bind(const int pos, const unsigned long int val, bool nul = false) = 0;

        virtual void bind(const int pos, const float val, bool nul = false) = 0;
        virtual void bind(const int pos, const double val, bool nul = false) = 0;
        virtual void bind(const int pos, const long double val, bool nul = false) = 0;
        virtual void bind(const int pos, const std::string& val, bool nul = false) = 0;

        virtual void clearParameters() = 0;

        virtual void execute(SQLResource<TM>& hand) = 0;
        virtual void outputoperator(std::ostream&) const = 0;

        virtual const Clone* getPlainSpecializedCommand() const = 0;

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

template<class TM>
class RTSQLSelectRow_Impl
: public RTSQLExecute_Impl<TM>
{
    public:
        RTSQLSelectRow_Impl() {
        };

        virtual void bindout(const int pos, char& val, bool& isnull) = 0;
        virtual void bindout(const int pos, char& val, BindOutInterface::BindOutNotNullConstraint) = 0;
        virtual void bindout(const int pos, signed char& val, bool& isnull) = 0;
        virtual void bindout(const int pos, signed char& val, BindOutInterface::BindOutNotNullConstraint) = 0;
        virtual void bindout(const int pos, unsigned char& val, bool& isnull) = 0;
        virtual void bindout(const int pos, unsigned char& val, BindOutInterface::BindOutNotNullConstraint) = 0;

        virtual void bindout(const int pos, short int& val, bool& isnull) = 0;
        virtual void bindout(const int pos, short int& val, BindOutInterface::BindOutNotNullConstraint) = 0;
        virtual void bindout(const int pos, int& val, bool& isnull) = 0;
        virtual void bindout(const int pos, int& val, BindOutInterface::BindOutNotNullConstraint) = 0;
        virtual void bindout(const int pos, long int& val, bool& isnull) = 0;
        virtual void bindout(const int pos, long int& val, BindOutInterface::BindOutNotNullConstraint) = 0;

        virtual void bindout(const int pos, unsigned short int& val, bool& isnull) = 0;
        virtual void bindout(const int pos, unsigned short int& val, BindOutInterface::BindOutNotNullConstraint) = 0;
        virtual void bindout(const int pos, unsigned int& val, bool& isnull) = 0;
        virtual void bindout(const int pos, unsigned int& val, BindOutInterface::BindOutNotNullConstraint) = 0;
        virtual void bindout(const int pos, unsigned long int& val, bool& isnull) = 0;
        virtual void bindout(const int pos, unsigned long int& val, BindOutInterface::BindOutNotNullConstraint) = 0;

        virtual void bindout(const int pos, float& val, bool& isnull) = 0;
        virtual void bindout(const int pos, float& val, BindOutInterface::BindOutNotNullConstraint) = 0;
        virtual void bindout(const int pos, double& val, bool& isnull) = 0;
        virtual void bindout(const int pos, double& val, BindOutInterface::BindOutNotNullConstraint) = 0;
        virtual void bindout(const int pos, long double& val, bool& isnull) = 0;
        virtual void bindout(const int pos, long double& val, BindOutInterface::BindOutNotNullConstraint) = 0;

        virtual void bindout(const int pos, std::string& val, bool& isnull) = 0;
        virtual void bindout(const int pos, std::string& val, BindOutInterface::BindOutNotNullConstraint) = 0;

//      virtual bool isnull(const unsigned int pos) const = 0;


        template<class CS>
        static typename CS::Impl* newRealCommand(
              typename SQLFactory<TM>::databaseType_t a_type
            , typename CS::RTC& a_that
            , const std::string& a_sql
            , SQL::SQLFetcher& fetcher
        ) {
            switch(a_type) {
#ifdef HAVE_MYSQL
            case SQLFactory<TM>::MYSQL :
            case SQLFactory<TM>::MYSQLTX :
                return new typename CS::template Specialized<fatalmind::ResourceType::mysql>::Impl(a_that, a_sql, fetcher);
                break;
#endif
#ifdef HAVE_ORACLE
            case SQLFactory<TM>::OCI:
                return new typename CS::template Specialized<fatalmind::ResourceType::oracle>::Impl(a_that, a_sql, fetcher);
                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 RTSQLExecute_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 RTSQLExecute_SpecializedImpl ;

template<class TM, class RT, class CW, class RTC>
class RTSQLExecute_SpecializedImplCloneHelper<TM, RTSQLExecute_Impl, RT, CW, RTC>
{
    public:
    typedef  RTSQLExecute_SpecializedImpl<TM, RTSQLExecute_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 RTSQLExecute_SpecializedImpl 
: public B<TM>
{
    public:
        RTSQLExecute_SpecializedImpl(RTC& rtc, const std::string& sql) 
        : sqlExecute_(rtc, sql)
        {
        }
    
        // also used for SQLSelect(Row)
        RTSQLExecute_SpecializedImpl(RTC& rtc, const std::string& sql, SQL::SQLFetcher& fetcher) 
        : sqlExecute_(rtc, sql, fetcher)
        {
        }

        void bind(const int pos, const char val, bool nul = false) {
            sqlExecute_.bind(pos, val, nul);
        }
        void bind(const int pos, const signed char val, bool nul = false) {
            sqlExecute_.bind(pos, val, nul);
        }
        void bind(const int pos, const unsigned char val, bool nul = false) {
            sqlExecute_.bind(pos, val, nul);
        }

        void bind(const int pos, const short int val, bool nul = false) {
            sqlExecute_.bind(pos, val, nul);
        }
        void bind(const int pos, const int val, bool nul = false) {
            sqlExecute_.bind(pos, val, nul);
        }
        void bind(const int pos, const long int val, bool nul = false) {
            sqlExecute_.bind(pos, val, nul);
        }

        void bind(const int pos, const unsigned short int val, bool nul = false) {
            sqlExecute_.bind(pos, val, nul);
        }
        void bind(const int pos, const unsigned int val, bool nul = false) {
            sqlExecute_.bind(pos, val, nul);
        }
        void bind(const int pos, const unsigned long int val, bool nul = false) {
            sqlExecute_.bind(pos, val, nul);
        }


        void bind(const int pos, const float val, bool nul = false) {
            sqlExecute_.bind(pos, val, nul);
        }
        void bind(const int pos, const double val, bool nul = false) {
            sqlExecute_.bind(pos, val, nul);
        }
        void bind(const int pos, const long double val, bool nul = false) {
            sqlExecute_.bind(pos, val, nul);
        }

        void bind(const int pos, const std::string& val, bool nul = false) {
            sqlExecute_.bind(pos, val, nul);
        }

        void clearParameters() {
            sqlExecute_.clearParameters();
        }

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

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

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

        virtual const Clone* getPlainSpecializedCommand() const {
            return &sqlExecute_;
        };

        CW sqlExecute_;
};


} // namespace SQL
} // namespace fatalmind

#endif

---