Resource.hh

//********************************************************************
//*** ResourcePool/oracle/Resource.hh
//*** Copyright (c) 2003-2009 by Markus Winand <mws@fatalmind.com>
//*** $Id: Resource.hh,v 1.40 2009-05-11 14:54:36 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 "ResourcePool/ResourcePoolEventObserver.hh"
#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

#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() {
        }

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

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

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

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

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

        inline int getTxDepth() const {
            return _txDepth;
        }

        // constant versions of stuff which would otherwise
        // be constructed on demand.
        // it might be hard not not clash with already defined symbols
        static struct LogConstants {
            static const std::string OCIHandleAlloc;
            static const std::string OCIStmtPrepare;
            static const std::string OCIAttrGet;
            static const std::string OCIAttrGetType;
            static const std::string OCIAttrGetSize;
            static const std::string OCIStmtExecute;
            static const std::string OCIBindByPos;
            static const std::string OCIBindArrayOfStruct;
            static const std::string OCITransCommit;
            static const std::string OCITransRollback;
            static const std::string OCI_NODATA;
            static const std::string NODATA; // incl. semikolon
            static const std::string MOREDATA; // incl. semikolon
            static const std::string ORA01422MSG;
            static const std::string ORA01422;
            static const std::string ORA99999;

            static const std::string EXACT;
            static const std::string IMPLICIT;
            static const std::string SLMDC;

            static const std::string EMPTY;
            static const std::string SEMICOLON;
        } LogConstant;

    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;

        inline int incTxDepth() {
            return _txDepth++;
        }
        inline 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
            , gc_ptr<ResourcePoolEventObserver, TM> o
        );
        ~oracleResource();
        bool precheck();
        bool postcheck();
        void close();
        void fail_close();

        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.
         */
        const std::string& getSessionID() const {
            return sessionid_;
        }
        const 
        inline
        std::string& getResourceID() const {
            return sessionid_;
        }

        struct Events {
            ResourcePoolEventObserver::event_t PREPARE;
            ResourcePoolEventObserver::event_t EXECUTE;
            ResourcePoolEventObserver::event_t EXECUTE_FAIL;
            ResourcePoolEventObserver::event_t FETCH;
            ResourcePoolEventObserver::event_t COMMIT;
            ResourcePoolEventObserver::event_t ROLLBACK;
        } Event;

        void event(const ResourcePoolEventObserver::event_t eventid, const std::string& status = "") {
            observer->event(eventid, getResourceID(), status);
        }
        
        gc_ptr<EventReader> getReader(const ResourcePoolEventObserver::event_t eventid) {
            return observer->getReader(eventid, getResourceID());
        }

        oracle::StatementCache& getStatementCache() {
            return sthcache;
        }

    private:

        void fetchSessionID();

        std::string sid_; 
        std::string serial_; 
        std::string audsid_; 
        std::string sessionid_;
        gc_ptr<ResourcePoolEventObserver> observer;
        oracle::StatementCache sthcache;
};

} // namespace fatalmind
#endif

---