ocilib.hpp

/*
    +-----------------------------------------------------------------------------------------+
    |                                                                                         |
    |                                                                                         |
    |                          OCILIB ++ - C++ wrapper around OCILIB                          |
    |                                                                                         |
    |                                (C Wrapper for Oracle OCI)                               |
    |                                                                                         |
    |                              Website : http://www.ocilib.net                            |
    |                                                                                         |
    |             Copyright (c) 2007-2014 Vincent ROGIER <vince.rogier@ocilib.net>            |
    |                                                                                         |
    +-----------------------------------------------------------------------------------------+
    |                                                                                         |
    |             This library is free software; you can redistribute it and/or               |
    |             modify it under the terms of the GNU Lesser General Public                  |
    |             License as published by the Free Software Foundation; either                |
    |             version 2 of the License, or (at your option) any later version.            |
    |                                                                                         |
    |             This library 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           |
    |             Lesser General Public License for more details.                             |
    |                                                                                         |
    |             You should have received a copy of the GNU Lesser General Public            |
    |             License along with this library; if not, write to the Free                  |
    |             Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.          |
    |                                                                                         |
    +-----------------------------------------------------------------------------------------+

    +-----------------------------------------------------------------------------------------+
    |                                     IMPORTANT NOTICE                                    |
    +-----------------------------------------------------------------------------------------+
    |                                                                                         |
    |            This C++ header defines C++ wrapper classes around the OCILIB C API          |
    |            It requires a compatible version of OCILIB                                   |
    +-----------------------------------------------------------------------------------------+

 */

/* --------------------------------------------------------------------------------------------- *
 * $Id: ocilib.hpp, Vincent Rogier $
 * --------------------------------------------------------------------------------------------- */

#ifndef OCILIBCPP_H_INCLUDED
#define OCILIBCPP_H_INCLUDED

/* includes */

#include <string>
#include <list>
#include <algorithm>
#include <iostream>
#include <vector>
#include <map>

#include "ocilib.h"

namespace ocilib
{

typedef std::basic_string<otext, std::char_traits<otext>, std::allocator<otext> > ostring;

typedef void * AnyPointer;

typedef std::vector<unsigned char> Raw;

typedef OCI_Mutex *  MutexHandle ;

typedef OCI_Thread * ThreadHandle;

typedef const void * ThreadId;

typedef void * CallbackPointer;

}

/* Including core classes  */

#include "ocilib_core.hpp"

/* Defining public classes  */

namespace ocilib
{

enum DataTypeValues
{
    TypeNumeric = OCI_CDT_NUMERIC,
    TypeDate = OCI_CDT_DATETIME,
    TypeString = OCI_CDT_TEXT,
    TypeLong = OCI_CDT_LONG,
    TypeStatement = OCI_CDT_CURSOR,
    TypeLob = OCI_CDT_LOB,
    TypeFile = OCI_CDT_FILE,
    TypeTimestamp = OCI_CDT_TIMESTAMP,
    TypeInterval = OCI_CDT_INTERVAL,
    TypeRaw = OCI_CDT_RAW,
    TypeObject = OCI_CDT_OBJECT,
    TypeCollection = OCI_CDT_COLLECTION,
    TypeReference = OCI_CDT_REF
};

typedef Enum<DataTypeValues> DataType;

enum NumericTypeValues
{
    NumericShort = OCI_NUM_SHORT,
    NumericInt = OCI_NUM_INT,
    NumericBigInt = OCI_NUM_BIGINT,
    NumericUnsignedShort = OCI_NUM_USHORT,
    NumericUnsignedInt = OCI_NUM_UINT,
    NumericUnsignedBigInt = OCI_NUM_BIGUINT,
    NumericDouble = OCI_NUM_DOUBLE,
    NumericFloat = OCI_NUM_FLOAT
};

typedef Enum<NumericTypeValues> NumericType;

enum CharsetFormValues
{
    CharsetFormDefault = OCI_CSF_DEFAULT,
    CharsetFormNational = OCI_CSF_NATIONAL
};
typedef Enum<CharsetFormValues> CharsetForm;


enum SeekModeValues
{
    SeekSet = OCI_SEEK_SET,
    SeekEnd = OCI_SEEK_END,
    SeekOffset = OCI_SEEK_CUR
};

typedef Enum<SeekModeValues> SeekMode;

enum OpenModeValues
{
    ReadOnly = OCI_LOB_READONLY,
    ReadWrite = OCI_LOB_READWRITE
};

typedef Enum<OpenModeValues> OpenMode;

enum LobTypeValues
{
    LobBinary = OCI_BLOB,
    LobCharacter = OCI_CLOB,
    LobNationalCharacter = OCI_NCLOB
};

typedef Enum<LobTypeValues> LobType;


enum LongTypeValues
{
    LongBinary = OCI_BLONG,
    LongCharacter = OCI_CLONG
};

typedef Enum<LongTypeValues> LongType;

class Exception : public HandleHolder<OCI_Error *>, public std::exception
{
    friend void Check();
    friend class Statement;

public:

    enum ExceptionTypeValues
    {
        OracleError  = OCI_ERR_ORACLE,
        OcilibError = OCI_ERR_OCILIB,
        OracleWarning = OCI_ERR_WARNING
    };

    typedef Enum<ExceptionTypeValues>  ExceptionType;

    ostring GetMessage() const;

    ExceptionType GetType() const;

    int GetOracleErrorCode() const;

    int GetInternalErrorCode() const;

    Statement GetStatement() const;

    Connection GetConnection() const;

    unsigned int GetRow() const;

    virtual const char *what() const throw();

    virtual ~Exception() throw ();

private:

    Exception();
    Exception(OCI_Error *err);

    std::string _what;
};

class Environment
{
    friend class Connection;
    friend class Subscription;
    friend class Dequeue;
    template<class THandleType>
    friend class HandleHolder;

public:

    enum HAEventSourceValues
    {
        SourceInstance = OCI_HES_INSTANCE,
        SourceDatabase = OCI_HES_DATABASE,
        SourceNode = OCI_HES_NODE,
        SourceService = OCI_HES_SERVICE,
        SourceServiceMember = OCI_HES_SERVICE_MEMBER,
        SourceASMInstance = OCI_HES_ASM_INSTANCE,
        SourcePreConnect = OCI_HES_PRECONNECT
    };

    typedef Enum<HAEventSourceValues>  HAEventSource;

    enum HAEventTypeValues
    {
        EventDown = OCI_HET_DOWN,
        EventUp = OCI_HET_UP
    };

    typedef Enum<HAEventTypeValues>  HAEventType;

    enum EnvironmentFlagsValues
    {
        Default = OCI_ENV_DEFAULT,
        Threaded  = OCI_ENV_THREADED,
        Events = OCI_ENV_EVENTS
    };

    typedef Flags<EnvironmentFlagsValues> EnvironmentFlags;

    enum ImportModeValues
    {
        ImportLinkage = OCI_IMPORT_MODE_LINKAGE,
        ImportRuntime  = OCI_IMPORT_MODE_RUNTIME
    };

    typedef Enum<ImportModeValues> ImportMode;

    enum CharsetModeValues
    {
        CharsetAnsi = OCI_CHAR_ANSI,
        CharsetWide  = OCI_CHAR_WIDE
    };

    typedef Enum<CharsetModeValues> CharsetMode;

    enum SessionFlagsValues
    {
        SessionDefault = OCI_SESSION_DEFAULT,
        SessionXa  = OCI_SESSION_XA,
        SessionSysDba = OCI_SESSION_SYSDBA,
        SessionSysOper = OCI_SESSION_SYSOPER
    };

    typedef Flags<SessionFlagsValues> SessionFlags;

    enum StartModeValues
    {
        StartOnly = OCI_DB_SPM_START,
        StartMount  = OCI_DB_SPM_MOUNT,
        StartOpen = OCI_DB_SPM_OPEN,
        StartFull = OCI_DB_SPM_FULL
    };

    typedef Enum<StartModeValues> StartMode;

    enum StartFlagsValues
    {
        StartDefault = OCI_DB_SPF_DEFAULT,
        StartForce  = OCI_DB_SPF_FORCE,
        StartRestrict = OCI_DB_SPF_RESTRICT
    };

    typedef Flags<StartFlagsValues> StartFlags;

    enum ShutdownModeValues
    {
        ShutdownOnly = OCI_DB_SDM_SHUTDOWN,
        ShutdownClose  = OCI_DB_SDM_CLOSE,
        ShutdownDismount = OCI_DB_SDM_DISMOUNT,
        ShutdownFull = OCI_DB_SDM_FULL
    };

    typedef Enum<ShutdownModeValues> ShutdownMode;

    enum ShutdownFlagsValues
    {
        ShutdowntDefault = OCI_DB_SDF_DEFAULT,
        ShutdowTrans  = OCI_DB_SDF_TRANS,
        ShutdownTransLocal = OCI_DB_SDF_TRANS_LOCAL,
        ShutdownImmediate = OCI_DB_SDF_IMMEDIATE,
        ShutdownAbort = OCI_DB_SDF_ABORT
    };

    typedef Flags<ShutdownFlagsValues> ShutdownFlags;

    typedef void(*HAHandlerProc) (Connection &con, HAEventSource eventSource, HAEventType eventType, Timestamp  &time);

    static void Initialize(EnvironmentFlags mode = Environment::Default, const ostring& libpath = OTEXT(""));

    static void Cleanup();

    static Environment::EnvironmentFlags GetMode();

    static Environment::ImportMode GetImportMode();

    static Environment::CharsetMode GetCharset();

    static unsigned int GetCompileVersion();

    static unsigned int GetRuntimeVersion();

    static void EnableWarnings(bool value);

    static void StartDatabase(const ostring &db, const ostring &user, const ostring& pwd,
                              Environment::StartFlags startFlags,
                              Environment::StartMode startMode,
                              Environment::SessionFlags sessionFlags = SessionSysDba,
                              const ostring& spfile = OTEXT(""));

    static void ShutdownDatabase(const ostring& db, const ostring& user, const ostring& pwd,
                                 Environment::ShutdownFlags shutdownFlags,
                                 Environment::ShutdownMode shutdownMode,
                                 Environment::SessionFlags sessionFlags = SessionSysDba);

    static void ChangeUserPassword(const ostring& db, const ostring& user, const ostring& pwd, const ostring& newPwd);

    static void SetHAHandler(HAHandlerProc handler);

private:

    static void HAHandler(OCI_Connection *pConnection, unsigned int source, unsigned int event, OCI_Timestamp  *pTimestamp);
    static unsigned int TAFHandler(OCI_Connection *pConnection, unsigned int type, unsigned int event);
    static void NotifyHandler(OCI_Event *pEvent);
    static void NotifyHandlerAQ(OCI_Dequeue *pDequeue);

    typedef ConcurrentPool<AnyPointer, Handle *> HandlePool;
    typedef ConcurrentPool<AnyPointer, CallbackPointer> CallbackPool;

    class EnvironmentHandle : public HandleHolder<AnyPointer>
    {
        friend class Connection;

    public:

        HandlePool   Handles;
        CallbackPool Callbacks;
        unsigned int Mode;

        EnvironmentHandle();

        void Initialize(AnyPointer pEnv, unsigned int envMode);
        void Finalize();
    };

    static EnvironmentHandle& GetEnvironmentHandle();
};

class Thread
{
public:

    typedef POCI_THREAD ThreadProc;

    static ThreadHandle Create();

    static void Destroy(ThreadHandle handle);

    static void Run(ThreadHandle handle, ThreadProc func, void *args);

    static void Join(ThreadHandle handle);

    static ThreadId GetThreadId(ThreadHandle handle);
};

class Mutex
{
public:

    static MutexHandle Create();

    static void Destroy(MutexHandle handle);

    static void Acquire(MutexHandle handle);

    static void Release(MutexHandle handle);
};

class ThreadKey
{
public:

    typedef POCI_THREADKEYDEST ThreadKeyFreeProc;

    static void Create(const ostring& name, ThreadKeyFreeProc freeProc = 0);

    static void SetValue(const ostring& name, AnyPointer value);

    static AnyPointer GetValue(const ostring& name);
};

class Pool : public HandleHolder<OCI_Pool *>
{
public:

    enum PoolTypeValues
    {
        ConnectionPool = OCI_POOL_CONNECTION,
        SessionPool  = OCI_POOL_SESSION
    };

    typedef Enum<PoolTypeValues> PoolType;

    Pool();

    Pool(const ostring& db, const ostring& user, const ostring& pwd, Pool::PoolType poolType,
         unsigned int minSize, unsigned int maxSize, unsigned int increment = 1,
         Environment::SessionFlags sessionFlags = Environment::SessionDefault);

    void Open(const ostring& db, const ostring& user, const ostring& pwd, Pool::PoolType poolType,
              unsigned int minSize, unsigned int maxSize, unsigned int increment = 1,
              Environment::SessionFlags sessionFlags = Environment::SessionDefault);

    void Close();

    Connection GetConnection(const ostring& sessionTag = OTEXT(""));

    unsigned int GetTimeout() const;

    void SetTimeout(unsigned int value);

    bool GetNoWait() const;

    void SetNoWait(bool value);

    unsigned int GetBusyConnectionsCount() const;

    unsigned int GetOpenedConnectionsCount() const;

    unsigned int GetMinSize() const;

    unsigned int GetMaxSize() const;

    unsigned int GetIncrement() const;

    unsigned int GetStatementCacheSize() const;

    void SetStatementCacheSize(unsigned int value);
};

class Connection : public HandleHolder<OCI_Connection *>
{
    friend class Environment;
    friend class Exception;
    friend class Statement;
    friend class File;
    friend class Timestamp;
    friend class Pool;
    friend class Object;
    friend class TypeInfo;
    friend class Reference;
    friend class Resultset;
    friend class Subscription;

    template<class TLobObjectType, int TLobOracleType>
    friend class Lob;
    template <class TDataType>
    friend class Collection;
public:

    enum FailoverRequestValues
    {
        FailoverRequestSession = OCI_FOT_SESSION,
        FailoverRequestSelect = OCI_FOT_SELECT
    };

    typedef Enum<FailoverRequestValues> FailoverRequest;

    enum FailoverEventValues
    {
        FailoverEventEnd = OCI_FOE_END,
        FailoverEventAbort = OCI_FOE_ABORT,
        FailoverEventReauthentificate = OCI_FOE_REAUTH,
        FailoverEventBegin = OCI_FOE_BEGIN,
        FailoverEventError = OCI_FOE_ERROR
    };

    typedef Enum<FailoverEventValues> FailoverEvent;

    enum FailoverResultValues
    {
        FailoverOk = OCI_FOC_OK,
        FailoverRetry = OCI_FOC_RETRY
    };

    typedef Enum<FailoverResultValues> FailoverResult;

    enum SessionTraceValues
    {
        TraceIdentity = OCI_TRC_IDENTITY,
        TraceModule  = OCI_TRC_MODULE,
        TraceAction = OCI_TRC_ACTION,
        TraceDetail  = OCI_TRC_DETAIL
    };

    typedef Enum<SessionTraceValues> SessionTrace;

    typedef FailoverResult(*TAFHandlerProc) (Connection &con, FailoverRequest failoverRequest, FailoverEvent failoverEvent);

    Connection();

    Connection(const ostring& db, const ostring& user, const ostring& pwd, Environment::SessionFlags sessionFlags = Environment::SessionDefault);

    void Open(const ostring& db, const ostring& user, const ostring& pwd,  Environment::SessionFlags sessionFlags = Environment::SessionDefault);

    void Close();

    void Commit();

    void Rollback();

    void Break();

    void SetAutoCommit(bool enabled);

    bool GetAutoCommit() const;

    bool IsServerAlive() const;

    bool PingServer() const;

    ostring GetConnectionString() const;

    ostring GetUserName() const;

    ostring GetPassword() const;

    ostring GetServerVersion() const;

    unsigned int GetVersion() const;

    unsigned int GetServerMajorVersion() const;

    unsigned int GetServerMinorVersion() const;

    unsigned int GetServerRevisionVersion() const;

    void ChangePassword(const ostring& newPwd);

    ostring GetSessionTag() const;

    void SetSessionTag(const ostring& tag);

    Transaction GetTransaction() const;

    void SetTransaction(const Transaction &transaction);

    void SetDefaultDateFormat(const ostring& format);

    ostring  GetDefaultDateFormat() const;

    void SetDefaultNumericFormat(const ostring& format);

    ostring  GetDefaultNumericFormat() const;

    void EnableServerOutput(unsigned int bufsize, unsigned int arrsize, unsigned int lnsize);

    void DisableServerOutput();

    bool GetServerOutput(ostring &line) const;

    void GetServerOutput(std::vector<ostring> &lines) const;


    void SetTrace(SessionTrace trace, const ostring& value);

    ostring GetTrace(SessionTrace trace) const;

    ostring GetDatabase() const;

    ostring GetInstance() const;

    ostring GetService() const;

    ostring GetServer() const;

    ostring GetDomain() const;

    Timestamp GetInstanceStartTime() const;

    unsigned int GetStatementCacheSize() const;

    void SetStatementCacheSize(unsigned int value);

    unsigned int GetDefaultLobPrefetchSize() const;

    void SetDefaultLobPrefetchSize(unsigned int value);

    bool IsTAFCapable() const;

    void SetTAFHandler(TAFHandlerProc handler);

    AnyPointer GetUserData();

    void SetUserData(AnyPointer value);

private:

    Connection(OCI_Connection *con, Handle *parent);
};

class Transaction : public HandleHolder<OCI_Transaction *>
{
    friend class Connection;

public:

    enum TransactionFlagsValues
    {
        Unknown = OCI_UNKNOWN,
        New = OCI_TRS_NEW,
        Tight  = OCI_TRS_TIGHT,
        Loose = OCI_TRS_LOOSE,
        ReadOnly  = OCI_TRS_READONLY,
        ReadWrite = OCI_TRS_READWRITE,
        Serializable  = OCI_TRS_SERIALIZABLE
    };

    typedef Flags<TransactionFlagsValues> TransactionFlags;

   Transaction(const Connection &connection, unsigned int timeout, TransactionFlags flags, OCI_XID *pxid = NULL);

   void Prepare();

   void Start();

   void Stop();

   void Resume();

   void Forget();

   TransactionFlags GetFlags() const;

   unsigned int GetTimeout() const;

private:

    Transaction(OCI_Transaction *trans);
};

class Date : public HandleHolder<OCI_Date *>
{
    friend class Statement;
    friend class Resultset;
    friend class BindArray;
    friend class Object;
    template <class TDataType>
    friend class Collection;
    friend class Message;

public:

    Date();

    bool IsValid() const;

    int GetYear() const;

    void SetYear(int value);

    int GetMonth() const;

    void SetMonth(int value);

    int GetDay() const;

    void SetDay(int value);

    int GetHours() const;

    void SetHours(int value);

    int GetMinutes() const;

    void SetMinutes(int value);

    int GetSeconds() const;

    void SetSeconds(int value);

    int DaysBetween(const Date& other) const;

    void SetDate(int year, int month, int day);

    void SetTime(int hour, int min,   int sec);

    void SetDateTime(int year, int month, int day, int hour, int min, int sec);

    void GetDate(int &year, int &month, int &day) const;

    void GetTime(int &hour, int &min, int &sec) const;

    void GetDateTime(int &year, int &month, int &day, int &hour, int &min, int &sec) const;

    void AddDays(int days);

    void AddMonths(int months);

    void SysDate();

    Date NextDay(const ostring& day) const;

    Date LastDay() const;

    void ChangeTimeZone(const ostring& tzSrc, const ostring& tzDst);

    void FromString(const ostring& str, const ostring& format = OCI_STRING_FORMAT_DATE);

    ostring ToString(const ostring& format = OCI_STRING_FORMAT_DATE) const;

    Date Clone() const;

    operator ostring() const;

    Date& operator ++ ();

    Date operator ++ (int);

    Date& operator -- ();

    Date operator -- (int);

    Date operator + (int value);

    Date operator - (int value);

    Date& operator += (int value);

    Date& operator -= (int value);

    bool operator == (const Date& other) const;

    bool operator != (const Date& other) const;

    bool operator > (const Date& other) const;

    bool operator < (const Date& other) const;

    bool operator >= (const Date& other) const;

    bool operator <= (const Date& other) const;

private:

    int Compare(const Date& other) const;

    Date(OCI_Date *pDate, Handle *parent = 0);
};

class Interval : public HandleHolder<OCI_Interval *>
{
    friend class Environment;
    friend class Statement;
    friend class Resultset;
    friend class BindArray;
    friend class Object;
    template <class TDataType>
    friend class Collection;

public:

    enum IntervalTypeValues
    {
        YearMonth = OCI_INTERVAL_YM,
        DaySecond = OCI_INTERVAL_DS
    };

    typedef Enum<IntervalTypeValues> IntervalType;

    Interval(IntervalType type);

    IntervalType GetType() const;

    bool IsValid() const;

    int GetYear() const;

    void SetYear(int value);

    int GetMonth() const;

    void SetMonth(int value);

    int GetDay() const;

    void SetDay(int value);

    int GetHours() const;

    void SetHours(int value);

    int GetMinutes() const;

    void SetMinutes(int value);

    int GetSeconds() const;

    void SetSeconds(int value);

    int GetMilliSeconds() const;

    void SetMilliSeconds(int value);

    void GetDaySecond(int &day, int &hour, int &min, int &sec, int &fsec) const;

    void SetDaySecond(int day, int hour, int min, int sec, int fsec);

    void GetYearMonth(int &year, int &month) const;

    void SetYearMonth(int year, int month);

    void UpdateTimeZone(const ostring& timeZone);

    void FromString(const ostring& data);

    ostring ToString(int leadingPrecision = 10, int fractionPrecision = 10) const;

    Interval Clone() const;

    operator ostring() const;

    Interval operator + (const Interval& other);

    Interval operator - (const Interval& other);

    Interval& operator += (const Interval& other);

    Interval& operator -= (const Interval& other);

    bool operator == (const Interval& other) const;

    bool operator != (const Interval& other) const;

    bool operator > (const Interval& other) const;

    bool operator < (const Interval& other) const;

    bool operator >= (const Interval& other) const;

    bool operator <= (const Interval& other) const;

private:

    int Compare(const Interval& other) const;

    Interval(OCI_Interval *pInterval, Handle *parent = 0);
};

class Timestamp : public HandleHolder<OCI_Timestamp *>
{
    friend class Environment;
    friend class Statement;
    friend class Resultset;
    friend class BindArray;
    friend class Object;
    friend class Connection;
    template <class TDataType>
    friend class Collection;

public:

    enum TimestampTypeValues
    {
        NoTimeZone = OCI_TIMESTAMP,
        WithTimeZone = OCI_TIMESTAMP_TZ,
        WithLocalTimeZone = OCI_TIMESTAMP_LTZ
    };

    typedef Enum<TimestampTypeValues> TimestampType;

    Timestamp(TimestampType type);

    TimestampType GetType() const;

    void Convert(const Timestamp& other);

    bool IsValid() const;

    int GetYear() const;

    void SetYear(int value);

    int GetMonth() const;

    void SetMonth(int value);

    int GetDay() const;

    void SetDay(int value);

    int GetHours() const;

    void SetHours(int value);

    int GetMinutes() const;

    void SetMinutes(int value);

    int GetSeconds() const;

    void SetSeconds(int value);

    int GetMilliSeconds() const;

    void SetMilliSeconds(int value);

    void GetDate(int &year, int &month, int &day) const;

    void GetTime(int &hour, int &min, int &sec, int &fsec) const;

    void SetDate(int year, int month, int day);

    void SetTime(int hour, int min, int sec, int fsec);

    void GetDateTime(int &year, int &month, int &day, int &hour, int &min, int &sec, int &fsec) const;

    void SetDateTime(int year, int month, int day, int hour, int min, int sec, int fsec, const ostring& timeZone = OTEXT(""));

    ostring GetTimeZone() const;

    void SetTimeZone(const ostring& timeZone);

    void GetTimeZoneOffset(int &hour, int &min) const;


    static void Substract(const Timestamp &lsh, const Timestamp &rsh, Interval &result);

    void SysTimestamp();

    void FromString(const ostring& data, const ostring& format = OCI_STRING_FORMAT_DATE);

    ostring ToString(const ostring& format = OCI_STRING_FORMAT_DATE, int precision = 0) const;

    Timestamp Clone() const;

    operator ostring() const;

    Timestamp& operator ++ ();

    Timestamp operator ++ (int);

    Timestamp& operator -- ();

    Timestamp operator -- (int);

    Timestamp operator + (int value);

    Timestamp operator - (int value);

    Interval operator - (const Timestamp& other);

    Timestamp& operator += (int value);

    Timestamp& operator -= (int value);

    Timestamp operator + (const Interval& other);

    Timestamp operator - (const Interval& other);

    Timestamp& operator += (const Interval& other);

    Timestamp& operator -= (const Interval& other);

    bool operator == (const Timestamp& other) const;

    bool operator != (const Timestamp& other) const;

    bool operator > (const Timestamp& other) const;

    bool operator < (const Timestamp& other) const;

    bool operator >= (const Timestamp& other) const;

    bool operator <= (const Timestamp& other) const;

private:

    int Compare(const Timestamp& other) const;

    Timestamp(OCI_Timestamp *pTimestamp, Handle *parent = 0);
};

template<class TLobObjectType, int TLobOracleType>
class Lob : public HandleHolder<OCI_Lob *>
{
    friend class Statement;
    friend class Resultset;
    friend class BindArray;
    friend class Object;
    template <class TDataType>
    friend class Collection;

public:

    Lob(const Connection &connection);

    TLobObjectType Read(unsigned int length);

    unsigned int Write(const TLobObjectType &content);

    unsigned int Append(const TLobObjectType& content);

    void Append(const Lob& other);

    bool Seek(SeekMode seekMode, big_uint offset);

    LobType GetType() const;

    big_uint GetOffset() const;

    big_uint GetLength() const;

    big_uint GetMaxSize() const;

    big_uint GetChunkSize() const;

    Connection GetConnection() const;

    void Truncate(big_uint length);

    big_uint Erase(big_uint offset, big_uint length);

    void Copy(Lob &dest, big_uint offset, big_uint offsetDest, big_uint length) const;

    bool IsTemporary() const;

    void Open(OpenMode mode);

    void Flush();

    void Close();

    void EnableBuffering(bool value);

    Lob Clone() const;

    operator TLobObjectType() const;

    Lob& operator += (const Lob& other);

    bool operator == (const Lob& other) const;

    bool operator != (const Lob& other) const;

private:

    bool Equals(const Lob &other) const;

    Lob(OCI_Lob *pLob, Handle *parent = 0);

};

typedef Lob<ostring, LobCharacter> Clob;

typedef Lob<ostring, LobNationalCharacter> NClob;

typedef Lob<Raw, LobBinary> Blob;

class File : public HandleHolder<OCI_File *>
{
    friend class Statement;
    friend class Resultset;
    friend class BindArray;
    friend class Object;
    template <class TDataType>
    friend class Collection;

public:

    File(const Connection &connection);

    File(const Connection &connection, const ostring& directory, const ostring& name);

    Raw Read(unsigned int size);

    bool Seek(SeekMode seekMode, big_uint offset);

    bool Exists() const;

    big_uint GetOffset() const;

    big_uint GetLength() const;

    Connection GetConnection() const;

    void SetInfos(const ostring& directory, const ostring& name);

    ostring GetName() const;

    ostring GetDirectory() const;

    void Open();

    void Close();

    bool IsOpened() const;

    File Clone() const;

    bool operator == (const File& other) const;

    bool operator != (const File& other) const;

private:

    bool Equals(const File &other) const;

    File(OCI_File *pFile, Handle *parent = 0);
};

class TypeInfo : public HandleHolder<OCI_TypeInfo *>
{
    friend class Object;
    friend class Reference;
    template <class TDataType>
    friend class Collection;
    friend class Column;
public:

    enum TypeInfoTypeValues
    {
        Table = OCI_TIF_TABLE,
        View = OCI_TIF_VIEW,
        Type = OCI_TIF_TYPE
    };

    typedef Enum<TypeInfoTypeValues> TypeInfoType;

    TypeInfo(const Connection &connection, const ostring& name, TypeInfoType type);

    TypeInfoType GetType() const;
    ostring GetName() const;

    Connection GetConnection() const;

    unsigned int GetColumnCount() const;

    Column GetColumn(unsigned int index) const;

private:

    TypeInfo(OCI_TypeInfo *pTypeInfo);
};

class Object : public HandleHolder<OCI_Object *>
{
    friend class Statement;
    friend class Resultset;
    friend class BindArray;
    friend class Reference;
    template <class TDataType>
    friend class Collection;
    friend class Message;

public:

    enum ObjectTypeValues
    {
        Persistent = OCI_OBJ_PERSISTENT,
        Transient = OCI_OBJ_TRANSIENT,
        Value = OCI_OBJ_VALUE
    };

    typedef Enum<ObjectTypeValues> ObjectType;

    Object(const TypeInfo &typeInfo);

    bool IsAttributeNull(const ostring& name) const;

    void SetAttributeNull(const ostring& name);

    TypeInfo GetTypeInfo() const;

    Reference GetReference() const;

    ObjectType GetType() const;

    template<class TDataType>
    TDataType Get(const ostring& name) const;

    template<class TDataType>
    void Set(const ostring& name, const TDataType &value);

    Object Clone() const;

    ostring ToString() const;

    operator ostring() const;

private:

    Object(OCI_Object *pObject, Handle *parent = 0);
};

class Reference : public HandleHolder<OCI_Ref *>
{
    friend class Statement;
    friend class Resultset;
    friend class BindArray;
    friend class Object;
    template <class TDataType>
    friend class Collection;

public:

    Reference(const TypeInfo &typeInfo);

    TypeInfo GetTypeInfo() const;

    Object GetObject() const;

    bool IsReferenceNull() const;

    void SetReferenceNull();

    Reference Clone() const;

    ostring ToString() const;

    operator ostring() const;

private:

    Reference(OCI_Ref *pRef, Handle *parent = 0);
};

template <class TDataType>
class Collection : public HandleHolder<OCI_Coll *>
{
    friend class Statement;
    friend class Resultset;
    friend class BindArray;
    friend class Object;
    template <class TOtherDataType>
    friend class CollectionIterator;

    template <class TOtherDataType>
    friend class Collection;
public:

    enum CollectionTypeValues
    {
        Varray = OCI_COLL_VARRAY,
        NestedTable = OCI_COLL_NESTED_TABLE
    };

    typedef Enum<CollectionTypeValues> CollectionType;

    Collection(const TypeInfo &typeInfo);

    CollectionType GetType() const;

    unsigned int GetMax() const;

    unsigned int GetSize() const;

    unsigned int GetCount() const;

    void Truncate(unsigned int size);

    void Clear();

    bool IsElementNull(unsigned int index) const;

    void SetElementNull(unsigned int index);

    bool Delete(unsigned int index) const;

    TDataType Get(unsigned int index) const;

    void Set(unsigned int index, const TDataType &value);

    void Append(const TDataType &data);

    TypeInfo GetTypeInfo() const;

    Collection Clone() const;

    ostring ToString() const;

    operator ostring() const;

    class Element
    {
        friend class Collection<TDataType>::Iterator;

    public:
        Element(Collection &coll, unsigned int pos);
        operator TDataType() const;
        Element& operator = (TDataType value);
        bool IsNull() const;
        void SetNull();

    private:
        Collection & _coll;
        unsigned int _pos;
    };

    class Iterator : public std::iterator<std::bidirectional_iterator_tag, TDataType>
    {

    public:

        Iterator(Collection &collection, unsigned int pos);
        Iterator(const Iterator& other);

        bool operator== (const Iterator& other);
        bool operator!= (const Iterator& other);

        Element& operator*();

        Iterator &operator--();
        Iterator operator--(int);

        Iterator &operator++();
        Iterator operator++(int);

    private:

        Element _elem;
    };

    typedef Iterator iterator;

    Iterator begin();

    Iterator end();

    Element operator [] (int index);

private:

    TDataType GetElem(OCI_Elem *elem, Handle *parent) const;

    void SetElem(OCI_Elem *elem, const TDataType &value);

    Collection(OCI_Coll *pColl, Handle *parent = 0);
};

template<class TLongObjectType, int TLongOracleType>
class Long : public HandleHolder<OCI_Long *>
{
    friend class Statement;
    friend class Resultset;
    friend class BindArray;

public:

    Long(const Statement &statement);

    unsigned int Write(const TLongObjectType& content);

    unsigned int GetLength() const;

    TLongObjectType GetContent() const;

private:

    Long(OCI_Long *pLong, Handle *parent = 0);
};

class BindInfo : public HandleHolder<OCI_Bind *>
{
    friend class Statement;

public:

    enum BindDirectionValues
    {
        In = OCI_BDM_IN,
        Out = OCI_BDM_OUT,
        InOut = OCI_BDM_IN_OUT
    };

    typedef Enum<BindDirectionValues> BindDirection;

    ostring GetName() const;

    DataType GetType() const;

    unsigned int GetSubType() const;

    unsigned int GetDataCount() const;

    Statement GetStatement() const;

    void SetDataNull(bool value, unsigned int index = 1);

    bool IsDataNull(unsigned int index = 1) const;

    void SetCharsetForm(CharsetForm value);

    BindDirection GetDirection() const;

private:

    BindInfo(OCI_Bind *pBind, Handle *parent);
};

class Statement : public HandleHolder<OCI_Statement *>
{
    friend class Exception;
    friend class Resultset;
    template<class TLongObjectType, int TLongOracleType>
    friend class Long;
    friend class BindInfo;
    friend class BindObject;

public:

    enum StatementTypeValues
    {
        TypeSelect = OCI_CST_SELECT,
        TypeUpdate = OCI_CST_UPDATE,
        TypeDelete = OCI_CST_DELETE,
        TypeInsert = OCI_CST_INSERT,
        TypeCreate = OCI_CST_CREATE,
        TypeDrop = OCI_CST_DROP,
        TypeAlter = OCI_CST_ALTER,
        TypeBegin = OCI_CST_BEGIN,
        TypeDeclare = OCI_CST_DECLARE,
        TypeCall = OCI_CST_CALL,
    };

    typedef Enum<StatementTypeValues> StatementType;

    enum FetchModeValues
    {
        FetchForward = OCI_SFM_DEFAULT,
        FetchScrollable = OCI_SFM_SCROLLABLE
    };

    typedef Enum<FetchModeValues> FetchMode;

    enum BindModeValues
    {
        BindByPosition =  OCI_BIND_BY_POS,
        BindByName = OCI_BIND_BY_NAME
    };

    typedef Enum<BindModeValues> BindMode;

    enum LongModeValues
    {
        LongExplicit = OCI_LONG_EXPLICIT,
        LongImplicit = OCI_LONG_IMPLICIT
    };

    typedef Enum<LongModeValues> LongMode;

    Statement(const Connection &connection);
    ~Statement();

    Connection GetConnection() const;

    void Describe(const ostring& sql);

    void Parse(const ostring& sql);

    void Prepare(const ostring& sql);

    void Execute();

    void Execute(const ostring& sql);

    unsigned int GetAffectedRows() const;

    ostring GetSql()  const;

    Resultset GetResultset();

    Resultset GetNextResultset();

    void SetBindArraySize(unsigned int size);

    unsigned int GetBindArraySize() const;

    void AllowRebinding(bool value);

    bool IsRebindingAllowed() const;

    unsigned int GetBindIndex(const ostring& name) const;

    unsigned int GetBindCount() const;

    BindInfo GetBind(unsigned int index) const;

    BindInfo GetBind(const ostring& name) const;

    template <class TDataType>
    void Bind(const ostring& name, TDataType &value, BindInfo::BindDirection mode);

    template <class TDataType, class TExtraInfo>
    void Bind(const ostring& name, TDataType &value, TExtraInfo extraInfo, BindInfo::BindDirection mode);

    template <class TDataType>
    void Bind(const ostring& name, std::vector<TDataType> &values, BindInfo::BindDirection mode);

    template <class TDataType>
    void Bind(const ostring& name, std::vector<TDataType> &values, TypeInfo &typeInfo, BindInfo::BindDirection mode);

    template <class TDataType, class TExtraInfo>
    void Bind(const ostring& name, std::vector<TDataType> &values, TExtraInfo extraInfo, BindInfo::BindDirection mode);

    template <class TDataType>
    void Register(const ostring& name);

    template <class TDataType, class TExtraInfo>
    void Register(const ostring& name, TExtraInfo& extraInfo);

    template <class TDataType, class TExtraInfo>
    void Register(const ostring& name, TExtraInfo extraInfo);

    StatementType GetStatementType() const;

    unsigned int GetSqlErrorPos() const;

    void SetFetchMode(FetchMode value);

    FetchMode GetFetchMode() const;

    void SetBindMode(BindMode value);

    BindMode GetBindMode() const;

    void SetFetchSize(unsigned int value);

    unsigned int GetFetchSize() const;

    void SetPrefetchSize(unsigned int value);

    unsigned int GetPrefetchSize() const;

    void SetPrefetchMemory(unsigned int value);

    unsigned int GetPrefetchMemory() const;

    void SetLongMaxSize(unsigned int value);

    unsigned int GetLongMaxSize() const;

    void SetLongMode(LongMode value);

    LongMode GetLongMode() const;

    unsigned int GetSQLCommand() const;

    ostring GetSQLVerb() const;

    void GetBatchErrors(std::vector<Exception> &exceptions);

private:

    Statement(OCI_Statement *stmt, Handle *parent = 0);

    BindsHolder *GetBindsHolder(bool allocate);

    void ReleaseResultsets();

    void SetLastBindMode(BindInfo::BindDirection mode);

    void SetInData();
    void SetOutData();
    void ClearBinds();

    template <typename TBindMethod, class TDataType>
    void Bind (TBindMethod &method, const ostring& name, TDataType& value, BindInfo::BindDirection mode);

    template <typename TBindMethod, class TObjectType, class TDataType>
    void Bind (TBindMethod &method, const ostring& name, TObjectType &value, BindValue<TDataType> datatype, BindInfo::BindDirection mode);

    template <typename TBindMethod, class TObjectType, class TDataType>
    void Bind (TBindMethod &method, const ostring& name, std::vector<TObjectType> &values, BindValue<TDataType> datatype, BindInfo::BindDirection mode);

    template <typename TBindMethod, class TObjectType, class TDataType, class TElemType>
    void Bind (TBindMethod &method, const ostring& name, std::vector<TObjectType> &values, BindValue<TDataType> datatype, BindInfo::BindDirection mode, TElemType type);
};

class Resultset : public HandleHolder<OCI_Resultset *>
{
    friend class Statement;
public:

    enum SeekModeValues
    {
        SeekAbsolute = OCI_SFD_ABSOLUTE,
        SeekRelative = OCI_SFD_RELATIVE
    };

    typedef Enum<SeekModeValues> SeekMode;

    template<class TDataType>
    TDataType Get(unsigned int index) const;

    template<class TDataType>
    TDataType Get(const ostring& name) const;

    bool Next();

    bool Prev();

    bool First();

    bool Last();

    bool Seek(SeekMode mode, int offset);

    unsigned int GetCount() const;

    unsigned int GetCurrentRow() const;

    unsigned int GetColumnIndex(const ostring& name) const;

    unsigned int GetColumnCount() const;

    Column GetColumn(unsigned int index) const;

    Column GetColumn(const ostring& name) const;

    bool IsColumnNull(unsigned int index) const;

    bool IsColumnNull(const ostring& name) const;

    Statement GetStatement() const;

    bool operator ++ (int);

    bool operator -- (int);

    bool operator += (int offset);

    bool operator -= (int offset);

private:

   Resultset(OCI_Resultset *resultset, Handle *parent);
};

class Column : public HandleHolder<OCI_Column *>
{
    friend class TypeInfo;
    friend class Resultset;

public:

    enum PropertyFlagsValues
    {
        NoFlags = OCI_CPF_NONE,
        IsIdentity = OCI_CPF_IS_IDENTITY,
        IsGeneratedAlways = OCI_CPF_IS_GEN_ALWAYS,
        IsGeneratedByDefaultOnNull = OCI_CPF_IS_GEN_BY_DEFAULT_ON_NULL
    };

    typedef Flags<PropertyFlagsValues> PropertyFlags;

    ostring GetName() const;

    ostring GetSQLType() const;

    ostring GetFullSQLType() const;

    DataType GetType() const;

    unsigned int GetSubType() const;

    CharsetForm GetCharsetForm() const;

    unsigned int GetSize() const;

    int GetScale() const;

    int GetPrecision() const;

    int GetFractionalPrecision() const;

    int GetLeadingPrecision() const;

    PropertyFlags GetPropertyFlags() const;

    bool IsNullable() const;

    bool IsCharSemanticUsed() const;

    TypeInfo GetTypeInfo() const;

private:

    Column(OCI_Column *pColumn, Handle *parent);
};

class Subscription : public HandleHolder<OCI_Subscription *>
{
    friend class Event;

public:

    typedef void (*NotifyHandlerProc) (Event &evt);


    enum ChangeTypesValues
    {
        ObjectChanges = OCI_CNT_OBJECTS,
        RowChanges = OCI_CNT_ROWS,
        DatabaseChanges = OCI_CNT_DATABASES,
        AllChanges = OCI_CNT_ALL
    };

    typedef Flags<ChangeTypesValues> ChangeTypes;

    Subscription();

    void Register(const Connection &connection, const ostring& name, ChangeTypes changeTypes, NotifyHandlerProc handler, unsigned int port = 0, unsigned int timeout = 0);

    void Unregister();

    void Watch(const ostring& sql);

    ostring GetName() const;

    unsigned int GetTimeout() const;

    unsigned int GetPort() const;

    Connection GetConnection() const;

private:

    Subscription(OCI_Subscription *pSubcription);
};

class Event : public HandleHolder<OCI_Event *>
{
    friend class Subscription;
    friend class Environment;

public:

    enum EventTypeValues
    {
        DatabaseStart = OCI_ENT_STARTUP,
        DatabaseShutdown = OCI_ENT_SHUTDOWN,
        DatabaseShutdownAny = OCI_ENT_SHUTDOWN_ANY,
        DatabaseDrop = OCI_ENT_DROP_DATABASE,
        Unregister = OCI_ENT_DEREGISTER,
        ObjectChanged = OCI_ENT_OBJECT_CHANGED
    };

    typedef Enum<EventTypeValues> EventType;

    enum ObjectEventValues
    {
        ObjectInserted = OCI_ONT_INSERT,
        ObjectUpdated = OCI_ONT_UPDATE,
        ObjectDeleted = OCI_ONT_DELETE,
        ObjectAltered = OCI_ONT_ALTER,
        ObjectDropped = OCI_ONT_DROP,
        ObjectGeneric = OCI_ONT_GENERIC
    };

    typedef Enum<ObjectEventValues> ObjectEvent;

    EventType GetType() const;

    ObjectEvent GetObjectEvent() const;

    ostring GetDatabaseName() const;

    ostring GetObjectName() const;

    ostring GetRowID() const;

    Subscription GetSubscription() const;

private:

    Event(OCI_Event *pEvent);
};


class Agent : public HandleHolder<OCI_Agent *>
{
    friend class Message;
    friend class Dequeue;

public:

    Agent(const Connection &connection, const ostring& name = OTEXT(""), const ostring& address = OTEXT(""));

    ostring GetName() const;

    void SetName(const ostring& value);

    ostring GetAddress() const;

    void SetAddress(const ostring& value);

private:

    Agent(OCI_Agent *pAgent, Handle *parent);
};

class Message : public HandleHolder<OCI_Msg *>
{
    friend class Dequeue;

public:

    enum MessageStateValues
    {
        Ready = OCI_AMS_READY,
        Waiting = OCI_AMS_WAITING,
        Processed = OCI_AMS_PROCESSED,
        Expired = OCI_AMS_EXPIRED
    };

    typedef Enum<MessageStateValues> MessageState;

    Message(const TypeInfo &typeInfo);

    void Reset();

    template <class TPayloadType>
    TPayloadType GetPayload();

    template <class TPayloadType>
    void SetPayload(const TPayloadType &value);

    Date GetEnqueueTime() const;

    int GetAttemptCount() const;

    MessageState GetState() const;

    Raw GetID() const;

    int GetExpiration() const;

    void SetExpiration(int value);

    int GetEnqueueDelay() const;

    void SetEnqueueDelay(int value);

    int GetPriority() const;

    void SetPriority(int value);

    Raw GetOriginalID() const;

    void SetOriginalID(const Raw &value);

    ostring GetCorrelation() const;

    void SetCorrelation(const ostring& value);

    ostring GetExceptionQueue() const;

    void SetExceptionQueue(const ostring& value);

    Agent GetSender() const;

    void SetSender(const Agent &agent);

    void SetConsumers(std::vector<Agent> &agents);

private:

    Message(OCI_Msg *pMessage, Handle *parent);
};

class Enqueue : public HandleHolder<OCI_Enqueue *>
{
public:

    enum EnqueueModeValues
    {
        Before = OCI_ASD_BEFORE,
        OnTop  = OCI_ASD_TOP
    };

    typedef Enum<EnqueueModeValues> EnqueueMode;

    enum EnqueueVisibilityValues
    {
        Immediate = OCI_AMV_IMMEDIATE,
        OnCommit  = OCI_AMV_ON_COMMIT
    };

    typedef Enum<EnqueueVisibilityValues> EnqueueVisibility;

    Enqueue(const TypeInfo &typeInfo, const ostring& queueName);

    void Put(const Message &message);

    EnqueueVisibility GetVisibility() const;

    void SetVisibility(EnqueueVisibility value);

    EnqueueMode GetMode() const;

    void SetMode(EnqueueMode value);

    Raw GetRelativeMsgID() const;

    void SetRelativeMsgID(const Raw &value);
};

class Dequeue : public HandleHolder<OCI_Dequeue *>
{
    friend class Environment;

public:

    typedef void (*NotifyAQHandlerProc) (Dequeue &dequeue);

    enum DequeueModeValues
    {
        Browse =  OCI_ADM_BROWSE,
        Locked = OCI_ADM_LOCKED,
        Remove = OCI_ADM_REMOVE,
        Confirm = OCI_ADM_REMOVE_NODATA
    };

    typedef Enum<DequeueModeValues> DequeueMode;

    enum DequeueVisibilityValues
    {
        Immediate = OCI_AMV_IMMEDIATE,
        OnCommit  = OCI_AMV_ON_COMMIT
    };

    typedef Enum<DequeueVisibilityValues> DequeueVisibility;

    enum NavigationModeValues
    {
        FirstMessage = OCI_ADN_FIRST_MSG,
        NextMessage = OCI_ADN_NEXT_MSG,
        NextTransaction = OCI_ADN_NEXT_TRANSACTION,
    };

    typedef Enum<NavigationModeValues> NavigationMode;

    Dequeue(const TypeInfo &typeInfo, const ostring& queueName);

    Message Get();

    Agent Listen(int timeout);

    ostring GetConsumer() const;

    void SetConsumer(const ostring& value);

    ostring GetCorrelation() const;

    void SetCorrelation(const ostring& value);

    Raw GetRelativeMsgID() const;

    void SetRelativeMsgID(const Raw &value);

    DequeueVisibility GetVisibility() const;

    void SetVisibility(DequeueVisibility value);

    DequeueMode GetMode() const;

    void SetMode(DequeueMode value);

    NavigationMode GetNavigation() const;

    void SetNavigation(NavigationMode value);

    int GetWaitTime() const;

    void SetWaitTime(int value);

    void SetAgents(std::vector<Agent> &agents);

    void Subscribe(unsigned int port, unsigned int timeout, NotifyAQHandlerProc handler);

    void Unsubscribe();

private:

    Dequeue(OCI_Dequeue *pDequeue);
};

class Queue
{
public:

    enum QueueTypeValues
    {
        NormalQueue = OCI_AQT_NORMAL,
        ExceptionQueue = OCI_AQT_EXCEPTION,
        NonPersistentQueue = OCI_AQT_NON_PERSISTENT
    };

    typedef Enum<QueueTypeValues> QueueType;

    static void Create(const Connection &connection, const ostring& queue, const ostring& table, QueueType type = NormalQueue,
                       unsigned int maxRetries = 0, unsigned int retryDelay = 0, unsigned int retentionTime = 0,
                       bool dependencyTracking = false, const ostring& comment = OTEXT(""));

    static void Alter(const Connection &connection, const ostring& queue,
                      unsigned int maxRetries= 0, unsigned int retryDelay= 0,
                      unsigned int retentionTime= 0, const ostring& comment = OTEXT(""));

    static void Drop(const Connection &connection, const ostring& queue);

    static void Start(const Connection &connection, const ostring& queue, bool enableEnqueue = true, bool enableDequeue = true);

    static void Stop(const Connection &connection, const ostring& queue, bool stopEnqueue = true, bool stopDequeue = true, bool wait = true);
};

class QueueTable
{
public:

    enum GroupingModeValues
    {
        None = OCI_AGM_NONE,
        Transactionnal = OCI_AGM_TRANSACTIONNAL
    };

    typedef Enum<GroupingModeValues> GroupingMode;

    enum PurgeModeValues
    {
        Buffered = OCI_APM_BUFFERED,
        Persistent = OCI_APM_PERSISTENT,
        All = OCI_APM_ALL
    };

    typedef Enum<PurgeModeValues> PurgeMode;

    static void Create(const Connection &connection, const ostring& table, const ostring& payloadType, bool multipleConsumers,
                       const ostring& storageClause = OTEXT(""), const ostring& sortList = OTEXT(""),
                       GroupingMode groupingMode = None, const ostring& comment = OTEXT(""),
                       unsigned int primaryInstance = 0, unsigned int secondaryInstance = 0,
                       const ostring& compatible = OTEXT(""));

    static void Alter(const Connection &connection, const ostring& table, const ostring& comment, unsigned int primaryInstance = 0, unsigned int secondaryInstance = 0);

    static void Drop(const Connection &connection, const ostring& table, bool force = true);

    static void Purge(const Connection &connection, const ostring& table, PurgeMode mode, const ostring& condition = OTEXT(""), bool block = true);

    static void Migrate(const Connection &connection, const ostring& table, const ostring& compatible = OTEXT(""));
};

class DirectPath : public HandleHolder<OCI_DirPath *>
{
public:

    enum ConversionModeValues
    {
        Default = OCI_DCM_DEFAULT,
        Force = OCI_DCM_FORCE
    };

    typedef Enum<ConversionModeValues> ConversionMode;

    enum ResultValues
    {
        ResultComplete = OCI_DPR_COMPLETE,
        ResultError = OCI_DPR_ERROR,
        ResultFull = OCI_DPR_FULL ,
        ResultPartial = OCI_DPR_PARTIAL,
        ResultEmpty = OCI_DPR_EMPTY
    };

    typedef Enum<ResultValues> Result;

    DirectPath(const TypeInfo &typeInfo, unsigned int nbCols, unsigned int  nbRows, const ostring& partition = OTEXT(""));

    void SetColumn(unsigned int colIndex, const ostring& name, unsigned int maxSize,  const ostring& format = OTEXT(""));

    template <class TDataType>
    void SetEntry(unsigned int rowIndex, unsigned int colIndex, const TDataType& value, bool complete = true);

    void Reset();

    void Prepare();

    DirectPath::Result Convert();

    DirectPath::Result Load();

    void Finish();

    void Abort();

    void Save();

    void FlushRow();

    void SetCurrentRows(unsigned int value);

    unsigned int GetCurrentRows() const;

    unsigned int GetMaxRows() const;

    unsigned int GetRowCount() const;

    unsigned int GetAffectedRows() const;

    void SetDateFormat(const ostring& format);

    void SetParallel(bool value);

    void SetNoLog(bool value);

    void SetCacheSize(unsigned int value);

    void SetBufferSize(unsigned int value);

    void SetConversionMode(ConversionMode value);

    unsigned int GetErrorColumn();

    unsigned int GetErrorRow();
};

}

#include "ocilib_impl.hpp"


#endif