Resource.hh

//********************************************************************
//*** ResourcePool/oracle/Resource.hh
//*** Copyright (c) 2003-2008 by Markus Winand <mws@fatalmind.com>
//*** $Id: Resource.hh,v 1.27 2008/06/02 14:41:10 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_RESOURCE_HH
#define RESOURCEPOOL_ORACLE_RESOURCE_HH


void TEST_oracle_resource_two(); // fwd decl

#ifndef RESOURCEPOOL_CREATEEXCEPTION_HH
#include "ResourcePool/CreateException.hh"
#endif

#include "ResourceFwd.hh"

#ifndef RESOURCEPOOL_ORACLE_ORACLEEXCEPTION_HH
#include "OracleException.hh"
#endif

#ifndef RESOURCEPOOL_ORACLE_OCIHANDLE_HH
#include "OCIHandle.hh"
#endif

#ifndef RESOURCEPOOL_ORACLE_OCIENVHANDLEFWD_HH
#include "OCIEnvHandleFwd.hh"
#endif

#ifndef RESOURCEPOOL_ORACLE_STATEMENTCACHE_HH
#include "StatementCache.hh"
#endif

#ifndef RESOURCEPOOL_ORACLE_SELECTLISTMETADATA_HH
#include "SelectListMetaData.hh"
#endif


#include "Transaction.hh"

#ifndef OCI_ORACLE
#include <oci.h>
#endif

#include <string>

namespace fatalmind {

namespace oracle {
// TODO, use a more generic approach
template<class TM>
class FinallyTxDepth {
    public:
        FinallyTxDepth(oracleHandlesWithCache<TM>& a_hand)
        : hand(a_hand)
        {
            hand.incTxDepth();
        }

        ~FinallyTxDepth() {
            hand.decTxDepth();
        }
    private:
        oracleHandlesWithCache<TM>& hand;
};

};

class oracleHandles {
    public:
        oracleHandles(const oracle::OCIEnvHandle& env
        ):_env(env) 
        , _err(_env)
        , _srv(_env)
        , _svc(_env)
        , _ses(_env)
        , _txDepth(0)
        {
        }

        virtual ~oracleHandles() {
        }

        OCIEnv* getEnv() const {
            return _env.get();
        }

        inline OCIError* getError() const {
            return _err.get();
        }

        OCIServer* getServer() const {
            return _srv.get();
        }

        OCISvcCtx* getSvcCtx() const {
            return _svc.get();
        }

        OCISession* getSession() const {
            return _ses.get();
        }

        int getTxDepth() {
            return _txDepth;
        }

    protected:
        const oracle::OCIEnvHandle&     _env;
        const oracle::OCIErrorHandle    _err;
        const oracle::OCIServerHandle   _srv;
        const oracle::OCISvcCtxHandle   _svc;
        const oracle::OCISessionHandle  _ses;
    private:
    // hidden stuff
        oracleHandles(const oracleHandles&);
        oracleHandles& operator=(const oracleHandles&);

    // transaction managment helper function
        int _txDepth;

        int incTxDepth() {
            return _txDepth++;
        }
        void decTxDepth() {
            --_txDepth;
        }

    friend class oracle::FinallyTxDepth<DefaultThreadedModel>;
    friend void ::TEST_oracle_resource_two();
};

template<class TM = DefaultThreadedModel >
class oracleHandlesWithCache: public oracleHandles {
    public:
        oracleHandlesWithCache(const oracle::OCIEnvHandle& env
            , gc_ptr<typename oracle::SelectListMetaDataCacheInterface<TM>::type > slmdc
        ):oracleHandles(env)
        , _slmdc(slmdc)
        {
        }
        virtual ~oracleHandlesWithCache()
        {
        }

        virtual typename oracle::SelectListMetaDataCacheInterface<TM>::type& getSelectListMetaDataCache() {
            return *_slmdc;
        }

//      typedef typename SLMDC::value_t slmdc_value_t;
    protected:
        gc_ptr<typename oracle::SelectListMetaDataCacheInterface<TM>::type, TM> _slmdc;
    private:
    // hidden stuff
        oracleHandlesWithCache(const oracleHandlesWithCache<TM>&);
        oracleHandlesWithCache& operator=(const oracleHandlesWithCache<TM>&);
};


template<class TM>
class oracleResource: public  oracleHandlesWithCache<TM> {
    public:
        typedef oracleHandlesWithCache<TM> super;
        using super::_srv;
        using super::_svc;
        using super::_ses;
        using super::_err;
        typedef typename oracle::SelectListMetaDataCacheInterface<TM>::type _slmdci_t;

        oracleResource<TM>(const std::string& service_name
            , const std::string& user
            , const std::string& pass
            , const oracle::OCIEnvHandle& env
            , gc_ptr<_slmdci_t, TM> slmdc
        );
        ~oracleResource();
        bool precheck();
        bool postcheck();
        void close();
        void fail_close();
        oracleHandlesWithCache<TM>& get_plain_resource();

        std::string getSID() const {
            return sid_;
        };

        std::string getSerialNo() const {
            return serial_;
        };
        std::string getAudSID() const {
            return audsid_;
        };

        /*
         * Returns a string describing the identiy of the database session.
         * Intended for human usage to perform administrative actions upon the session.
         *
         * All database types support such a functionality, althout the content is strongly
         * depending on the database type.
         */
        std::string getSessionID() const {
            return sessionid_;
        }
    private:
        std::string sid_; 
        std::string serial_; 
        std::string audsid_; 
        std::string sessionid_;
};

} // namespace fatalmind
#endif

---