SelectListMetaData.hh

//********************************************************************
//*** ResourcePool/oracle/SelectListMetaData.hh
//*** Copyright (c) 2003-2008 by Markus Winand <mws@fatalmind.com>
//*** $Id: SelectListMetaData.hh,v 1.17 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_SELECTLISTMETADATA_HH
#define RESOURCEPOOL_ORACLE_SELECTLISTMETADATA_HH

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

#ifndef RESOURCEPOOL_ORACLE_ORACLEREFTYPE_HH
#include "oracleRefType.hh"
#endif

#ifndef RESOURCEPOOL_ORACLE_SQLSELECTROW_HH
#include "SQLSelectRow.hh"
#endif

#ifndef RESOURCEPOOL_ORACLE_ORACLESTATEMENT_HH
#include "oracleStatement.hh"
#endif

#include "mm/RawBuffer.hh"

#include <vector>
#include <string>
#include <ostream>

namespace fatalmind {
namespace oracle {

class ColumnMetaData {
    public:
        ColumnMetaData(const size_t offst); // for usag in std containers
        //ColumnMetaData(const ub2 datatype, const ub2 datasize);
        ColumnMetaData(const ColumnMetaData& rho);

        ub2 getType() const throw();
        ub2 getSize() const throw();
        size_t getOffset() const throw();
        bool bufferedDefine() const throw();

        /*
         * @returns true if the specified oracle type needs to be fetched via the buffer.
         *          false if it can be directly fetched into the users variable
         */
        static bool needsBuffer(ub2) throw();
        bool piecewise() const throw();

    private:
        const ub2* getTypePtr() const throw();
        const ub2* getSizePtr() const throw();
        void alignSize() throw();
        void setSize(ub2 s) throw();

        ub2 _datatype;
        ub2 _datasize;
        size_t _offst;
    friend
        class SelectListMetaData;
    friend
        std::ostream& operator<<(std::ostream& s, const ColumnMetaData& rho);   
};

std::ostream& operator<<(std::ostream& s, const ColumnMetaData& rho);   

class SelectListMetaData {
    public:
        SelectListMetaData(const OCIStatementHandle& sth
            , const oracleHandles& hand
            , const std::string& SQL
        );

        size_t getBufferSz() const throw();
        int getNumSelectListItems() const;
        const ColumnMetaData& getColumnMetaData(const int pos) const;
        const oracleStatement& getOraSQL() const;

    private:
        typedef std::vector<ColumnMetaData> selectlist_t;
        selectlist_t _selectlist;
        oracleStatement _oraSQL;
        size_t _bufsz;
    friend
        std::ostream& operator<<(std::ostream& s, const SelectListMetaData& rho);
};

std::ostream& operator<<(std::ostream& s, const SelectListMetaData& rho);

/*
 * this class will be used to provide OCI with the
 * indicator variable and the place to store the actual size
 * it's placement constructed into the memory managed by
 * SelectListBuffer
 * in fact it's just a pattern for the memory
 * 
 * Note: the actually used indicator variable is in the oracleRefType
 *       the indicator Variable managed by this class is used only in
 *       case of piecewise fetch (e.g. for LOBS) and just provides 
 *       the actual poiner to the indicator variable in the 
 *       oracleRefType class
 */
class DefineMetaData {
    public:
        DefineMetaData(const ub2 bufsz, oracleRefType& out) 
        : _bufsz(bufsz)
        , _out(out)
        , _dataPtr(this + 1)
        {
        }

        ub2* getSizePtr_ub2() throw() {
            return &s._size_ub2;
        }

        ub4* getSizePtr_ub4() throw() {
            return &s._size_ub4;
        }

        void* getDataPtr() throw() {
            return _dataPtr;
        }

        void resetSize() throw() {
            s._size_ub4 = _bufsz;
        }

        ub2 getSize_ub2() const throw() {
            return s._size_ub2;
        }   

        ub4 getSize_ub4() const throw() {
            return s._size_ub4;
        }   

        void done(ub4 len, void* buf) {
            _out.done(len, buf);
        }

        void setIndPtr(sb2* ind) {
            _ind = ind;
        }
        sb2* getIndPtr() const {
            return _ind;
        }
    private:
        //
        // Oracle uses two different types to describe the size of the buffer
        // and the actually written data:
        //   ub2 -> for non piecewise fetch
        //   ub4 -> for piecewise fetch
        // this class provides both, buth the user (of this class)
        // has to make sure to use the right functions.
        union size_union {
            ub2 _size_ub2;
            ub4 _size_ub4;
        } s;
        ub4 _bufsz;
        sb2* _ind;
        oracleRefType& _out;
        void* _dataPtr;
};

class SelectListBuffer: private RawBuffer {
    public:
        SelectListBuffer(const gc_ptr<SelectListMetaData> slmd, oracleBindOut& bindout);
        ~SelectListBuffer();

        int getNumSelectListItems() const;
        DefineMetaData* getDefineMetaData(const int pos) const;
        void* getDataPtr(const int pos) const;
        bool bufferedDefine(const int pos) const;
        bool piecewiseFetch(const int pos) const;
        
    private:
        const gc_ptr<SelectListMetaData> _slmd;     
};


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

---