ocilib.hpp

/*
 * OCILIB - C Driver for Oracle (C Wrapper for Oracle OCI)
 *
 * Website: http://www.ocilib.net
 *
 * Copyright (c) 2007-2019 Vincent ROGIER <vince.rogier@ocilib.net>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

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

#ifndef OCILIBCPP_H_INCLUDED
#define OCILIBCPP_H_INCLUDED

/* includes */

#include <string>
#include <list>
#include <vector>
#include <iterator>
#include <cstddef>

extern "C"{
#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 OracleVersionValues
{
    Oracle80 = OCI_8_0,
    Oracle8i = OCI_8_1,
    Oracle9iR1 = OCI_9_0,
    Oracle9iR2 = OCI_9_2,
    Oracle10gR1 = OCI_10_1,
    Oracle10gR2 = OCI_10_2,
    Oracle11gR1 = OCI_11_1,
    Oracle11gR2 = OCI_11_2,
    Oracle12cR1 = OCI_12_1,
    Oracle12cR2 = OCI_12_2,
    Oracle18cR1 = OCI_18_1,
    Oracle18cR2 = OCI_18_2,
    Oracle18cR3 = OCI_18_3,
    Oracle18cR4 = OCI_18_4
};

typedef Enum<OracleVersionValues> OracleVersion;

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,
    TypeBoolean = OCI_CDT_BOOLEAN
};

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,
    NumericNumber = OCI_NUM_NUMBER
};

typedef Enum<NumericTypeValues> NumericType;

enum CharsetFormValues
{
    CharsetFormDefault = OCI_CSF_DEFAULT,
    CharsetFormNational = OCI_CSF_NATIONAL
};

typedef Enum<CharsetFormValues> CharsetForm;

enum CollationIDValues
{
    CollationIDNone = OCI_CCI_NONE,
    CollationIDNlsComp = OCI_CCI_NLS_COMP,
    CollationIDNlsSort = OCI_CCI_NLS_SORT,
    CollationIDNlsSortCI = OCI_CCI_NLS_SORT_CI,
    CollationIDNlsSortAI = OCI_CCI_NLS_SORT_AI,
    CollationIDNlsSortCS = OCI_CCI_NLS_SORT_CS,
    CollationIDNlsSortVar1 = OCI_CCI_NLS_SORT_VAR1,
    CollationIDNlsSortVar1CI = OCI_CCI_NLS_SORT_VAR1_CI,
    CollationIDNlsSortVar1AI = OCI_CCI_NLS_SORT_VAR1_AI,
    CollationIDNlsSortVar1CS = OCI_CCI_NLS_SORT_VAR1_CS,
    CollationIDBinary = OCI_CCI_BINARY,
    CollationIDBinaryCI = OCI_CCI_BINARY_CI,
    CollationIDBinaryAI = OCI_CCI_BINARY_AI
};

typedef Enum<CollationIDValues> CollationID;


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;

enum FormatTypeValues
{
    FormatDate = OCI_FMT_DATE,
    FormatTimestamp = OCI_FMT_TIMESTAMP,
    FormatNumeric = OCI_FMT_NUMERIC,
    FormatBinaryDouble = OCI_FMT_BINARY_DOUBLE,
    FormatBinaryFloat = OCI_FMT_BINARY_FLOAT
};

typedef Enum<FormatTypeValues> FormatType;

class Exception : public std::exception
{
    template<class T>
    friend T Check(T result);
    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;

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

    virtual ~Exception() throw ();

private:

    Exception();
    Exception(OCI_Error *err);

    std::string _what;
    OCI_Statement *_pStatement;
    OCI_Connection *_pConnnection;
    unsigned int _row;
    ExceptionType _type;
    int _errLib;
    int _errOracle;
};

class Environment
{
    friend class Mutex;
    friend class Connection;
    friend class Pool;
    friend class Subscription;
    friend class Dequeue;
    template<class>
    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,
        SessionSysAsm = OCI_SESSION_SYSASM,
        SessionSysBkp = OCI_SESSION_SYSBKP,
        SessionSysDgD = OCI_SESSION_SYSDGD,
        SessionSysKmt = OCI_SESSION_SYSKMT,
        SessionSysRac = OCI_SESSION_SYSRAC,
        SessionPreAuth = OCI_SESSION_PRELIM_AUTH
    };

    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 Flags<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 Flags<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;

    enum AllocatedBytesValues
    {
        OracleClientBytes = OCI_MEM_ORACLE,
        OcilibBytes = OCI_MEM_OCILIB,
        AllBytes = OCI_MEM_ALL
    };

    typedef Flags<AllocatedBytesValues> AllocatedBytesFlags;

    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 GetCharMaxSize();

    static big_uint GetAllocatedBytes(AllocatedBytesFlags type);

    static bool Initialized();

    static OracleVersion GetCompileVersion();

    static unsigned int GetCompileMajorVersion();

    static unsigned int GetCompileMinorVersion();

    static unsigned int GetCompileRevisionVersion();

    static OracleVersion GetRuntimeVersion();

    static unsigned int GetRuntimeMajorVersion();

    static unsigned int GetRuntimeMinorVersion();

    static unsigned int GetRuntimeRevisionVersion();

    static void EnableWarnings(bool value);

    static bool SetFormat(FormatType formatType, const ostring& format);

    static ostring GetFormat(FormatType formatType);

    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:

    class EnvironmentHandle : HandleHolder < AnyPointer >
    {
        friend class Environment;
    };

    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);

    template<class T>
    static T GetUserCallback(AnyPointer ptr);

    template<class T>
    static void SetUserCallback(AnyPointer ptr, T callback);

    template<class T>
    static void SetSmartHandle(AnyPointer ptr, T handle);

    template<class T>
    static T GetSmartHandle(AnyPointer ptr);

    static Handle * GetEnvironmentHandle();

    static Environment& GetInstance();

    Environment();

    void SelfInitialize(EnvironmentFlags mode, const ostring& libpath);
    void SelfCleanup();

    Locker _locker;
    EnvironmentHandle _handle;
    ConcurrentMap<AnyPointer, Handle *>  _handles;
    ConcurrentMap<AnyPointer, CallbackPointer> _callbacks;
    EnvironmentFlags _mode;
    unsigned int _charMaxSize;
    bool _initialized;
};

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 = nullptr);

    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, int>
    friend class Lob;
    template<class>
    friend class Collection;
public:

    enum TimeoutTypeValues
    {
        TimeoutSend = OCI_NTO_SEND,
        TimeoutReceive = OCI_NTO_RECEIVE,
        TimeoutCall = OCI_NTO_CALL
    };

    typedef Enum<TimeoutTypeValues> TimeoutType;

    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;

    OracleVersion 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);

    bool SetFormat(FormatType formatType, const ostring& format);

    ostring GetFormat(FormatType formatType);

    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);

    unsigned int GetMaxCursors() const;

    bool IsTAFCapable() const;

    void SetTAFHandler(TAFHandlerProc handler);

    AnyPointer GetUserData();

    void SetUserData(AnyPointer value);

    unsigned int GetTimeout(TimeoutType timeout);

    void SetTimeout(TimeoutType timeout, unsigned int 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 = nullptr);

   void Prepare();

   void Start();

   void Stop();

   void Resume();

   void Forget();

   TransactionFlags GetFlags() const;

   unsigned int GetTimeout() const;

private:

    Transaction(OCI_Transaction *trans);
};

class Number : public HandleHolder<OCI_Number *>, public Streamable
{
    friend class Statement;
    friend class Resultset;
    friend class BindArray;
    friend class Object;
    template<class>
    friend class Collection;

public:

    Number(bool create = false);

    Number(const otext* str, const otext* format = OTEXT(""));

    Number(const ostring& str, const ostring& format = OTEXT(""));

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

    ostring ToString(const ostring& format) const;

    ostring ToString() const override;

    Number Clone() const;

    Number& operator ++ ();
    Number& operator -- ();
    Number operator ++ (int);
    Number operator -- (int);

    bool operator == (const Number& other) const;
    bool operator != (const Number& other) const;
    bool operator > (const Number& other) const;
    bool operator < (const Number& other) const;
    bool operator >= (const Number& other) const;
    bool operator <= (const Number& other) const;

    template<class T>
    Number& operator = (const T &lhs);

    template<class T>
    operator T() const;

    template<class T>
    Number operator - (const T &value);

    template<class T>
    Number operator + (const T &value);

    template<class T>
    Number operator * (const T &value);

    template<class T>
    Number operator / (const T &value);

    template<class T>
    Number& operator += (const T &value);

    template<class T>
    Number& operator -= (const T &value);

    template<class T>
    Number& operator *= (const T &value);

    template<class T>
    Number& operator /= (const T &value);

private:

    Number(OCI_Number *pNumber, Handle *parent = nullptr);

    void Allocate();

    int Compare(const Number& other) const;

    template<class T>
    inline T GetValue() const;

    template<class T>
    Number& SetValue(const T &value);

    template<class T>
    void Add(const T &value);

    template<class T>
    void Sub(const T &value);

    template<class T>
    void Multiply(const T &value);

    template<class T>
    void Divide(const T &value);

    Number& operator = (OCI_Number * &lhs);
};

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

public:

    static Date SysDate();

    Date(bool create = false);

    Date(const otext* str, const otext* format = OTEXT(""));

    Date(const ostring& str, const ostring& format = OTEXT(""));

    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);

    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 = OTEXT(""));

    ostring ToString(const ostring& format) const;

    ostring ToString() const override;

    Date Clone() const;

    Date& operator ++ ();

    Date operator ++ (int);

    Date& operator -- ();

    Date operator -- (int);

    Date operator + (int value) const;

    Date operator - (int value) const;

    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 = nullptr);

    void Allocate();
};

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

public:

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

    typedef Enum<IntervalTypeValues> IntervalType;

    Interval();

    Interval(IntervalType type);

    Interval(IntervalType type, const ostring& data);

    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, int fractionPrecision) const;

    ostring ToString() const override;

    Interval Clone() const;

    Interval operator + (const Interval& other) const;

    Interval operator - (const Interval& other) const;

    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 = nullptr);
};

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

public:

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

    typedef Enum<TimestampTypeValues> TimestampType;

    static Timestamp SysTimestamp(TimestampType type = NoTimeZone);

    Timestamp();

    Timestamp(TimestampType type);

    Timestamp(TimestampType type, const ostring& data, const ostring& format = OTEXT(""));

    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 FromString(const ostring& data, const ostring& format = OCI_STRING_FORMAT_DATE);

    ostring ToString(const ostring& format, int precision) const;

    ostring ToString() const override;

    Timestamp Clone() const;

    Timestamp& operator ++ ();

    Timestamp operator ++ (int);

    Timestamp& operator -- ();

    Timestamp operator -- (int);

    Timestamp operator + (int value) const;

    Timestamp operator - (int value) const;

    Interval operator - (const Timestamp& other);

    Timestamp& operator += (int value);

    Timestamp& operator -= (int value);

    Timestamp operator + (const Interval& other) const;

    Timestamp operator - (const Interval& other) const;

    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 = nullptr);
};

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

public:

    Lob();

    Lob(const Connection &connection);

    T Read(unsigned int length);

    unsigned int Write(const T &content);

    unsigned int Append(const T& 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;

    bool IsRemote() const;

    void Open(OpenMode mode);

    void Flush();

    void Close();

    void EnableBuffering(bool value);

    Lob Clone() 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 = nullptr);

};

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>
    friend class Collection;

public:

    File();

    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 = nullptr);
};

class TypeInfo : public HandleHolder<OCI_TypeInfo *>
{
    friend class Object;
    friend class Reference;
    template<class>
    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;

    boolean IsFinalType() const;

    TypeInfo GetSuperType() const;

private:

    TypeInfo(OCI_TypeInfo *pTypeInfo);
};

class Object : public HandleHolder<OCI_Object *>, public Streamable
{
    friend class Statement;
    friend class Resultset;
    friend class BindArray;
    friend class Reference;
    template<class>
    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();

    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 T>
    T Get(const ostring& name) const;

    template<class T>
    void Get(const ostring& name, T &value) const;

    template<class T>
    void Get(const ostring& name, Collection<T> &value) const;

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

    Object Clone() const;

    ostring ToString() const;

private:

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

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

public:

    Reference();

    Reference(const TypeInfo &typeInfo);

    TypeInfo GetTypeInfo() const;

    Object GetObject() const;

    bool IsReferenceNull() const;

    void SetReferenceNull();

    Reference Clone() const;

    ostring ToString() const override;

private:

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

template<class T>
class CollectionElement
{
    template<class>
    friend class CollectionIterator;

public:

    typedef T ValueType;
    typedef Collection<ValueType> CollectionType;

    CollectionElement();
    CollectionElement(CollectionType *coll, unsigned int pos);
    operator T() const;
    CollectionElement& operator = (const ValueType& value);
    CollectionElement& operator = (const CollectionElement& other);
    bool IsNull() const;
    void SetNull();

private:

    CollectionType* _coll;
    unsigned int _pos;
};

template<class T>
class CollectionIterator
{
public:
    
    template<class>
    friend class Collection;

    typedef typename T::ValueType value_type;
    typedef Collection<value_type> CollectionType;

    typedef std::random_access_iterator_tag iterator_category;
    typedef ptrdiff_t difference_type;
    typedef ptrdiff_t distance_type;
    typedef value_type* pointer;
    typedef value_type& reference;

    CollectionIterator();
    CollectionIterator(const CollectionIterator& other);

    CollectionIterator& operator = (const CollectionIterator& other);
    CollectionIterator& operator += (difference_type value);
    CollectionIterator& operator -= (difference_type value);

    T& operator*();
    T* operator->();

    CollectionIterator& operator++();
    CollectionIterator& operator--();

    CollectionIterator operator++(int);
    CollectionIterator operator--(int);

    CollectionIterator operator + (difference_type value);
    CollectionIterator operator - (difference_type value);

    difference_type operator - (const CollectionIterator &other);

    bool operator == (const CollectionIterator& other);
    bool operator != (const CollectionIterator& other);
    bool operator >  (const CollectionIterator& other);
    bool operator <  (const CollectionIterator& other);
    bool operator >= (const CollectionIterator& other);
    bool operator <= (const CollectionIterator& other);

protected:

    CollectionIterator(CollectionType *collection, unsigned int pos);

    T _elem;
};

template<class T>
class Collection : public HandleHolder<OCI_Coll *>, public Streamable
{
    friend class Statement;
    friend class Resultset;
    friend class BindArray;
    friend class Object;
    template<class>
    friend class CollectionIterator;
    template<class>
    friend class Collection;

public:

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

    typedef Enum<CollectionTypeValues> CollectionType;

    Collection();

    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;

    T Get(unsigned int index) const;

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

    void Append(const T &data);

    TypeInfo GetTypeInfo() const;

    Collection Clone() const;

    ostring ToString() const override;

    typedef CollectionIterator<CollectionElement<T> > iterator;

    typedef CollectionIterator<const CollectionElement<T> > const_iterator;

    iterator begin();

    const_iterator begin() const;

    iterator end();

    const_iterator end() const;

    CollectionElement<T> operator [] (unsigned int index);

    const CollectionElement<T> operator [] (unsigned int index) const;

private:

    static T GetElem(OCI_Elem *elem, Handle *parent);

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

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

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

public:

    Long();

    Long(const Statement &statement);

    unsigned int Write(const T& content);

    unsigned int GetLength() const;

    T GetContent() const;

private:

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

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;

    enum VectorTypeValues
    {
        AsArray = 1,
        AsPlSqlTable = 2
    };

    typedef Enum<VectorTypeValues> VectorType;

    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, int>
    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,
        TypeMerge = OCI_CST_MERGE
    };

    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();

    Statement(const Connection &connection);

    Connection GetConnection() const;

    void Describe(const ostring& sql);

    void Parse(const ostring& sql);

    void Prepare(const ostring& sql);

    void ExecutePrepared();

    void Execute(const ostring& sql);

    template<class T>
    unsigned int ExecutePrepared(T callback);

    template<class T, class U>
    unsigned int ExecutePrepared(T callback, U adapter);

    template<class T>
    unsigned int Execute(const ostring& sql, T callback);

    template<class T, class U>
    unsigned int Execute(const ostring& sql, T callback, U adapter);

    unsigned int GetAffectedRows() const;

    ostring GetSql()  const;

    ostring GetSqlIdentifier()  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 T>
    void Bind(const ostring& name, T &value, BindInfo::BindDirection mode);

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

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

    template<class T>
    void Bind(const ostring& name, std::vector<T> &values, BindInfo::BindDirection mode, BindInfo::VectorType type = BindInfo::AsArray);

    template<class T>
    void Bind(const ostring& name, std::vector<T> &values, TypeInfo &typeInfo, BindInfo::BindDirection mode, BindInfo::VectorType type = BindInfo::AsArray);

    template<class T>
    void Bind(const ostring& name, std::vector<Collection<T> > &values, TypeInfo &typeInfo, BindInfo::BindDirection mode, BindInfo::VectorType type = BindInfo::AsArray);

    template<class T, class U>
    void Bind(const ostring& name, std::vector<T> &values, U extraInfo, BindInfo::BindDirection mode, BindInfo::VectorType type = BindInfo::AsArray);

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

    template<class T, class U>
    void Register(const ostring& name, U& extraInfo);

    template<class T, class U>
    void Register(const ostring& name, U 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:

    static bool IsResultsetHandle(Handle *handle);
    static void OnFreeSmartHandle(SmartHandle *smartHandle);

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

    BindsHolder *GetBindsHolder(bool allocate) const;

    void ReleaseResultsets() const;

    void SetLastBindMode(BindInfo::BindDirection mode);

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

    template<typename M, class T>
    void Bind1 (M &method, const ostring& name, T& value, BindInfo::BindDirection mode);

    template<typename M, class T>
    void Bind2 (M &method, const ostring& name, T &value, BindInfo::BindDirection mode);

    template<typename M, class T>
    void BindVector1(M &method, const ostring& name, std::vector<T> &values, BindInfo::BindDirection mode, BindInfo::VectorType type);

    template<typename M, class T, class U>
    void BindVector2(M &method, const ostring& name, std::vector<T> &values, BindInfo::BindDirection mode, U subType, BindInfo::VectorType type);

    template<typename T>
    unsigned int Fetch(T callback);

    template<typename T, typename U>
    unsigned int Fetch(T callback, U adapter);
};

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 T>
    T Get(unsigned int index) const;

    template<class T>
    void Get(unsigned int index, T &value) const;

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

    template<class T>
    void Get(const ostring &name, T &value) const;

    template<class T, class U>
    bool Get(T& value, U adapter) const;

    template<typename T>
    unsigned int ForEach(T callback);

    template<typename T, typename U>
    unsigned int ForEach(T callback, U adapter);

    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,
        IsLogicalPartitioning = OCI_CPF_IS_LPART,
        IsGeneratedByContainers = OCI_CPF_IS_CONID
    };

    typedef Flags<PropertyFlagsValues> PropertyFlags;

    ostring GetName() const;

    ostring GetSQLType() const;

    ostring GetFullSQLType() const;

    DataType GetType() const;

    unsigned int GetSubType() const;

    CharsetForm GetCharsetForm() const;

    CollationID GetCollationID() 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 T>
    T GetPayload();

    template<class T>
    void SetPayload(const T &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 T>
    void SetEntry(unsigned int rowIndex, unsigned int colIndex, const T& 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