types.hpp

/*
 * OCILIB - C Driver for Oracle (C Wrapper for Oracle OCI)
 *
 * Website: http://www.ocilib.net
 *
 * Copyright (c) 2007-2026 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.
 */
 
#pragma once
 
#include <cstddef>
#include <iterator>
#include <vector>
 
#include "ocilibcpp/core.hpp"
#include "ocilibcpp/support.hpp"
 
 // ReSharper disable CppClangTidyCppcoreguidelinesMacroUsage
 // ReSharper disable CppClangTidyModernizeUseNodiscard
 // ReSharper disable CppClangTidyHicppSpecialMemberFunctions
 // ReSharper disable CppClangTidyReadabilityRedundantDeclaration
 // ReSharper disable CppFunctionIsNotImplemented
 // ReSharper disable CppClangTidyCppcoreguidelinesSpecialMemberFunctions
 // ReSharper disable CppClassCanBeFinal
 
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,
        Oracle18cR5 = OCI_18_5,
        Oracle19cR3 = OCI_19_3,
        Oracle19cR5 = OCI_19_5,
        Oracle21cR3 = OCI_21_3
    };
 
    typedef core::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,
        TypeXmlType = OCI_CDT_XMLTYPE,
        TypeVector = OCI_CDT_VECTOR
    };
 
    typedef core::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 core::Enum<NumericTypeValues> NumericType;
 
    enum CharsetFormValues
    {
        CharsetFormDefault = OCI_CSF_DEFAULT,
        CharsetFormNational = OCI_CSF_NATIONAL
    };
 
    typedef core::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 core::Enum<CollationIDValues> CollationID;
 
 
    enum SeekModeValues
    {
        SeekSet = OCI_SEEK_SET,
        SeekEnd = OCI_SEEK_END,
        SeekOffset = OCI_SEEK_CUR
    };
 
    typedef core::Enum<SeekModeValues> SeekMode;
 
    enum OpenModeValues
    {
        ReadOnly = OCI_LOB_READONLY,
        ReadWrite = OCI_LOB_READWRITE
    };
 
    typedef core::Enum<OpenModeValues> OpenMode;
 
    enum LobTypeValues
    {
        LobBinary = OCI_BLOB,
        LobCharacter = OCI_CLOB,
        LobNationalCharacter = OCI_NCLOB
    };
 
    typedef core::Enum<LobTypeValues> LobType;
 
    enum LongTypeValues
    {
        LongBinary = OCI_BLONG,
        LongCharacter = OCI_CLONG
    };
 
    typedef core::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 core::Enum<FormatTypeValues> FormatType;
 
    class Exception : public std::exception
    {
        template<class T>
        friend T core::Check(T result);
        friend class Statement;
 
    public:
 
        enum ExceptionTypeValues
        {
            OracleError = OCI_ERR_ORACLE,
            OcilibError = OCI_ERR_OCILIB,
            OracleWarning = OCI_ERR_WARNING
        };
 
        typedef core::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 noexcept override;
 
        Exception(const Exception& other) noexcept;
 
        Exception& operator = (const Exception& other) noexcept;
 
        virtual ~Exception() noexcept;
 
    private:
 
        Exception() noexcept;
        Exception(OCI_Error* err) noexcept;
 
        void SetWhat(const otext* value) noexcept;
        void CopyWhat(const char* value) noexcept;
 
        char* _what;
        OCI_Statement* _pStatement;
        OCI_Connection* _pConnection;
        unsigned int _row;
        ExceptionType _type;
        int _errLib;
        int _errOracle;
    };
 
    class Environment
    {
        friend class Mutex;
        friend class Connection;
        friend class Pool;
        friend class TypeInfo;
        friend class Subscription;
        friend class Dequeue;
        friend class Date;
        friend class Timestamp;
        friend class Number;
        friend class Interval;
        friend class Agent;
        friend class Transaction;
        friend class Exception;
        friend class File;
        friend class Log;
        friend class Statement;
        friend class Object;
        friend class Reference;
        friend class Message;
        friend class Event;
        friend class Column;
        template<class, int>
        friend class Lob;
 
        friend class core::HandleStore;
 
    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 core::Enum<HAEventSourceValues>  HAEventSource;
 
        enum HAEventTypeValues
        {
            EventDown = OCI_HET_DOWN,
            EventUp = OCI_HET_UP
        };
 
        typedef core::Enum<HAEventTypeValues>  HAEventType;
 
        enum EnvironmentFlagsValues
        {
            Default = OCI_ENV_DEFAULT,
            Threaded = OCI_ENV_THREADED,
            Events = OCI_ENV_EVENTS
        };
 
        typedef core::Flags<EnvironmentFlagsValues> EnvironmentFlags;
 
        enum ImportModeValues
        {
            ImportLinkage = OCI_IMPORT_MODE_LINKAGE,
            ImportRuntime = OCI_IMPORT_MODE_RUNTIME
        };
 
        typedef core::Enum<ImportModeValues> ImportMode;
 
        enum CharsetModeValues
        {
            CharsetAnsi = OCI_CHAR_ANSI,
            CharsetWide = OCI_CHAR_WIDE
        };
 
        typedef core::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 core::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 core::Flags<StartModeValues> StartMode;
 
        enum StartFlagsValues
        {
            StartDefault = OCI_DB_SPF_DEFAULT,
            StartForce = OCI_DB_SPF_FORCE,
            StartRestrict = OCI_DB_SPF_RESTRICT
        };
 
        typedef core::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 core::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 core::Flags<ShutdownFlagsValues> ShutdownFlags;
 
        enum AllocatedBytesValues
        {
            OracleClientBytes = OCI_MEM_ORACLE,
            OcilibBytes = OCI_MEM_OCILIB,
            AllBytes = OCI_MEM_ALL
        };
 
        typedef core::Flags<AllocatedBytesValues> AllocatedBytesFlags;
 
        enum LocaleCodeValues
        {
            LocaleDayname1 = OCI_LSI_DAYNAME1,
            LocaleDayname2 = OCI_LSI_DAYNAME2,
            LocaleDayname3 = OCI_LSI_DAYNAME3,
            LocaleDayname4 = OCI_LSI_DAYNAME4,
            LocaleDayname5 = OCI_LSI_DAYNAME5,
            LocaleDayname6 = OCI_LSI_DAYNAME6,
            LocaleDayname7 = OCI_LSI_DAYNAME7,
            LocaleAbdayname1 = OCI_LSI_ABDAYNAME1,
            LocaleAbdayname2 = OCI_LSI_ABDAYNAME2,
            LocaleAbdayname3 = OCI_LSI_ABDAYNAME3,
            LocaleAbdayname4 = OCI_LSI_ABDAYNAME4,
            LocaleAbdayname5 = OCI_LSI_ABDAYNAME5,
            LocaleAbdayname6 = OCI_LSI_ABDAYNAME6,
            LocaleAbdayname7 = OCI_LSI_ABDAYNAME7,
            LocaleMonthname1 = OCI_LSI_MONTHNAME1,
            LocaleMonthname2 = OCI_LSI_MONTHNAME2,
            LocaleMonthname3 = OCI_LSI_MONTHNAME3,
            LocaleMonthname4 = OCI_LSI_MONTHNAME4,
            LocaleMonthname5 = OCI_LSI_MONTHNAME5,
            LocaleMonthname6 = OCI_LSI_MONTHNAME6,
            LocaleMonthname7 = OCI_LSI_MONTHNAME7,
            LocaleMonthname8 = OCI_LSI_MONTHNAME8,
            LocaleMonthname9 = OCI_LSI_MONTHNAME9,
            LocaleMonthname10 = OCI_LSI_MONTHNAME10,
            LocaleMonthname11 = OCI_LSI_MONTHNAME11,
            LocaleMonthname12 = OCI_LSI_MONTHNAME12,
            LocaleAbmonthname1 = OCI_LSI_ABMONTHNAME1,
            LocaleAbmonthname2 = OCI_LSI_ABMONTHNAME2,
            LocaleAbmonthname3 = OCI_LSI_ABMONTHNAME3,
            LocaleAbmonthname4 = OCI_LSI_ABMONTHNAME4,
            LocaleAbmonthname5 = OCI_LSI_ABMONTHNAME5,
            LocaleAbmonthname6 = OCI_LSI_ABMONTHNAME6,
            LocaleAbmonthname7 = OCI_LSI_ABMONTHNAME7,
            LocaleAbmonthname8 = OCI_LSI_ABMONTHNAME8,
            LocaleAbmonthname9 = OCI_LSI_ABMONTHNAME9,
            LocaleAbmonthname10 = OCI_LSI_ABMONTHNAME10,
            LocaleAbmonthname11 = OCI_LSI_ABMONTHNAME11,
            LocaleAbmonthname12 = OCI_LSI_ABMONTHNAME12,
            LocaleYes = OCI_LSI_YES,
            LocaleNo = OCI_LSI_NO,
            LocaleAm = OCI_LSI_AM,
            LocalePm = OCI_LSI_PM,
            LocaleAd = OCI_LSI_AD,
            LocaleBc = OCI_LSI_BC,
            LocaleDecimal = OCI_LSI_DECIMAL,
            LocaleGroup = OCI_LSI_GROUP,
            LocaleDebit = OCI_LSI_DEBIT,
            LocaleCredit = OCI_LSI_CREDIT,
            LocaleDateformat = OCI_LSI_DATEFORMAT,
            LocaleInt = OCI_LSI_INT_CURRENCY,
            LocaleLoc = OCI_LSI_LOC_CURRENCY,
            LocaleLanguage = OCI_LSI_LANGUAGE,
            LocaleAblanguage = OCI_LSI_ABLANGUAGE,
            LocaleTerritory = OCI_LSI_TERRITORY,
            LocaleCharacterSEt = OCI_LSI_CHARACTER_SET,
            LocaleLinguisticName = OCI_LSI_LINGUISTIC_NAME,
            LocaleCalendar = OCI_LSI_CALENDAR,
            LocaleDualCurrency = OCI_LSI_DUAL_CURRENCY,
            LocaleWritingdir = OCI_LSI_WRITINGDIR,
            LocaleAbterritory = OCI_LSI_ABTERRITORY,
            LocaleDdateformat = OCI_LSI_DDATEFORMAT,
            LocaleDtimeformat = OCI_LSI_DTIMEFORMAT,
            LocaleSfdateformat = OCI_LSI_SFDATEFORMAT,
            LocaleSftimeformat = OCI_LSI_SFTIMEFORMAT,
            LocaleNumgrouping = OCI_LSI_NUMGROUPING,
            LocaleListsep = OCI_LSI_LISTSEP,
            LocaleMondecimal = OCI_LSI_MONDECIMAL,
            LocaleMongroup = OCI_LSI_MONGROUP,
            LocaleMongrouping = OCI_LSI_MONGROUPING,
            LocaleIntCurrenySep = OCI_LSI_INT_CURRENCYSEP
        };
 
        typedef core::Enum<LocaleCodeValues> LocaleCode;
        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 ostring GetLocaleString(LocaleCode code);
 
        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 : core::HandleHolder<OCI_Environment*>
        {
            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);
 
        static core::Handle* GetEnvironmentHandle();
        static Environment* GetInstance();
 
        static core::HandleStore& GetDefaultStore();
 
        Environment(EnvironmentFlags mode, const ostring& libpath);
        ~Environment();
 
        core::SynchronizationGuard _guard;
        core::ConcurrentMap<AnyPointer, CallbackPointer> _callbacks;
        core::HandleStore _defaultStore;
        EnvironmentHandle _handle;
        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, AnyPointer arg);
 
        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 core::HandleHolder<OCI_Pool*>
    {
    public:
 
        enum PoolTypeValues
        {
            ConnectionPool = OCI_POOL_CONNECTION,
            SessionPool = OCI_POOL_SESSION
        };
 
        typedef core::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 core::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;
        friend class Agent;
        friend class Dequeue;
        friend class Enqueue;
        friend class Column;
        friend class Message;
        friend class DirectPath;
        friend class Vector;
 
        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 core::Enum<TimeoutTypeValues> TimeoutType;
 
        enum FailoverRequestValues
        {
            FailoverRequestSession = OCI_FOT_SESSION,
            FailoverRequestSelect = OCI_FOT_SELECT
        };
 
        typedef core::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 core::Enum<FailoverEventValues> FailoverEvent;
 
        enum FailoverResultValues
        {
            FailoverOk = OCI_FOC_OK,
            FailoverRetry = OCI_FOC_RETRY
        };
 
        typedef core::Enum<FailoverResultValues> FailoverResult;
 
        enum SessionTraceValues
        {
            TraceIdentity = OCI_TRC_IDENTITY,
            TraceModule = OCI_TRC_MODULE,
            TraceAction = OCI_TRC_ACTION,
            TraceDetail = OCI_TRC_DETAIL
        };
 
        typedef core::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, core::Handle* parent, bool allocated);
    };
 
    class Transaction : public core::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 core::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 core::HandleHolder<OCI_Number*>, public core::Streamable
    {
        friend class Statement;
        friend class Resultset;
        friend class support::BindArray;
        friend class Object;
        template<class>
        friend class Collection;
 
    public:
 
        Number(bool create = false);
 
        template<class T, typename core::SupportedNumeric<T>::Type::type* = nullptr>
        Number(const T& value);
 
 
        Number(const Number& other);
 
        Number& operator= (const Number& other) noexcept;
 
        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, typename core::SupportedNumeric<T>::Type::type* = nullptr>
        Number& operator = (const T& lhs);
 
        template<class T, typename core::SupportedNumeric<T>::Type::type* = nullptr>
        operator T() const;
 
        template<class T, typename core::SupportedNumeric<T>::Type::type* = nullptr>
        Number operator - (const T& value);
 
        template<class T, typename core::SupportedNumeric<T>::Type::type* = nullptr>
        Number operator + (const T& value);
 
        template<class T, typename core::SupportedNumeric<T>::Type::type* = nullptr>
        Number operator * (const T& value);
 
        template<class T, typename core::SupportedNumeric<T>::Type::type* = nullptr>
        Number operator / (const T& value);
 
        template<class T, typename core::SupportedNumeric<T>::Type::type* = nullptr>
        Number& operator += (const T& value);
 
        template<class T, typename core::SupportedNumeric<T>::Type::type* = nullptr>
        Number& operator -= (const T& value);
 
        template<class T, typename core::SupportedNumeric<T>::Type::type* = nullptr>
        Number& operator *= (const T& value);
 
        template<class T, typename core::SupportedNumeric<T>::Type::type* = nullptr>
        Number& operator /= (const T& value);
 
    private:
 
        template<class T>
        static AnyPointer GetNativeValue(const T& value);
 
        Number(OCI_Number* pNumber, core::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 core::HandleHolder<OCI_Date*>, public core::Streamable
    {
        friend class Statement;
        friend class Resultset;
        friend class support::BindArray;
        friend class Object;
        template<class>
        friend class Collection;
        friend class Message;
 
    public:
 
        static Date SysDate();
 
        Date(bool create = false);
 
        Date(const Date& other);
 
        Date& operator= (const Date& other) noexcept;
 
        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, core::Handle* parent = nullptr);
 
        void Allocate();
    };
 
    class Interval : public core::HandleHolder<OCI_Interval*>, public core::Streamable
    {
        friend class Environment;
        friend class Statement;
        friend class Resultset;
        friend class support::BindArray;
        friend class Object;
        template<class>
        friend class Collection;
 
    public:
 
        enum IntervalTypeValues
        {
            YearMonth = OCI_INTERVAL_YM,
            DaySecond = OCI_INTERVAL_DS
        };
 
        typedef core::Enum<IntervalTypeValues> IntervalType;
 
        Interval();
 
        Interval(IntervalType type);
 
        Interval(const Interval& other);
 
        Interval& operator= (const Interval& other) noexcept;
 
        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);
 
        int GetNanoSeconds() const;
 
        void SetNanoSeconds(int value);
 
        void GetDaySecond(int& day, int& hour, int& min, int& sec, int& nsec) const;
 
        void SetDaySecond(int day, int hour, int min, int sec, int nsec);
 
        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;
 
        void Allocate(IntervalType type);
 
        Interval(OCI_Interval* pInterval, core::Handle* parent = nullptr);
    };
 
    class Timestamp : public core::HandleHolder<OCI_Timestamp*>, public core::Streamable
    {
        friend class Environment;
        friend class Statement;
        friend class Resultset;
        friend class support::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 core::Enum<TimestampTypeValues> TimestampType;
 
        static Timestamp SysTimestamp(TimestampType type = NoTimeZone);
 
        Timestamp();
 
        Timestamp(const Timestamp& other);
 
        Timestamp& operator= (const Timestamp& other) noexcept;
 
        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;
 
        void Allocate(TimestampType type);
 
        Timestamp(OCI_Timestamp* pTimestamp, core::Handle* parent = nullptr);
    };
 
    template<class T, int U>
    class Lob : public core::HandleHolder<OCI_Lob*>
    {
        friend class Statement;
        friend class Resultset;
        friend class support::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, core::Handle* parent = nullptr);
 
    };
 
    typedef Lob<ostring, LobCharacter> Clob;
 
    typedef Lob<ostring, LobNationalCharacter> NClob;
 
    typedef Lob<Raw, LobBinary> Blob;
 
    class File : public core::HandleHolder<OCI_File*>
    {
        friend class Statement;
        friend class Resultset;
        friend class support::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, core::Handle* parent = nullptr);
    };
 
    class TypeInfo : public core::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 core::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, core::Handle* parent);
    };
 
    class Object : public core::HandleHolder<OCI_Object*>, public core::Streamable
    {
        friend class Statement;
        friend class Resultset;
        friend class support::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 core::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 override;
 
    private:
 
        Object(OCI_Object* pObject, core::Handle* parent = nullptr);
    };
 
    class Reference : public core::HandleHolder<OCI_Ref*>, public core::Streamable
    {
        friend class Statement;
        friend class Resultset;
        friend class support::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, core::Handle* parent = nullptr);
    };
 
    class XmlType : public core::HandleHolder<OCI_XmlType*>, public core::Streamable
    {
        friend class Resultset;
 
    public:
 
        ostring ToString() const override;
 
    private:
 
        XmlType(OCI_XmlType* pXmlType, core::Handle* parent = nullptr);
    };
 
    class Vector : public core::HandleHolder<OCI_Vector*>, public core::Streamable
    {
        friend class Resultset;
 
    public:
 
        enum VectorFormatValues
        {
            Flex = OCI_VEC_FLEX,
            Int8 = OCI_VEC_INT8,
            Float32 = OCI_VEC_FLOAT32,
            Float64 = OCI_VEC_FLOAT64,
            Binary = OCI_VEC_BINARY
        };
 
        typedef core::Enum<VectorFormatValues> VectorFormat;
 
        Vector();
 
        Vector(const Connection& connection);
 
        template<class T, typename core::SupportedVectorNumeric<T>::Type::type* = nullptr>
        void Set(T* values, unsigned int size);
 
        template<class T, typename core::SupportedVectorNumeric<T>::Type::type* = nullptr>
        void Get(T* values);
 
        template<class T, typename core::SupportedVectorNumeric<T>::Type::type* = nullptr>
        void Set(const std::vector<T>& values);
 
        template<class T, typename core::SupportedVectorNumeric<T>::Type::type* = nullptr>
        std::vector<T> Get();
 
        unsigned int GetDimensionCount();
 
        VectorFormat GetFormat();
 
        void FromString(const ostring& str, VectorFormat format, unsigned int dimensions);
 
        ostring ToString() const override;
 
    private:
 
        Vector(OCI_Vector* pVector, core::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& other);
        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 core::HandleHolder<OCI_Coll*>, public core::Streamable
    {
        friend class Statement;
        friend class Resultset;
        friend class support::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 core::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& value);
 
        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);
 
        CollectionElement<T> operator [](unsigned int index) const;
 
    private:
 
        static T GetElem(OCI_Elem* elem, core::Handle* parent);
 
        static void SetElem(OCI_Elem* elem, const T& value);
 
        Collection(OCI_Coll* pColl, core::Handle* parent = nullptr);
    };
 
    template<class T, int U>
    class Long : public core::HandleHolder<OCI_Long*>
    {
        friend class Statement;
        friend class Resultset;
        friend class support::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, core::Handle* parent = nullptr);
    };
 
    typedef Long<ostring, LongCharacter> Clong;
 
    typedef Long<Raw, LongBinary> Blong;
 
    class BindInfo : public core::HandleHolder<OCI_Bind*>
    {
        friend class Statement;
 
    public:
 
        enum BindDirectionValues
        {
            In = OCI_BDM_IN,
            Out = OCI_BDM_OUT,
            InOut = OCI_BDM_IN_OUT
        };
 
        typedef core::Enum<BindDirectionValues> BindDirection;
 
        enum VectorTypeValues
        {
            AsArray = 1,
            AsPlSqlTable = 2
        };
 
        typedef core::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, core::Handle* parent);
    };
 
    class Statement : public core::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 core::Enum<StatementTypeValues> StatementType;
 
        enum FetchModeValues
        {
            FetchForward = OCI_SFM_DEFAULT,
            FetchScrollable = OCI_SFM_SCROLLABLE
        };
 
        typedef core::Enum<FetchModeValues> FetchMode;
 
        enum BindModeValues
        {
            BindByPosition = OCI_BIND_BY_POS,
            BindByName = OCI_BIND_BY_NAME
        };
 
        typedef core::Enum<BindModeValues> BindMode;
 
        enum LongModeValues
        {
            LongExplicit = OCI_LONG_EXPLICIT,
            LongImplicit = OCI_LONG_IMPLICIT
        };
 
        typedef core::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 SetPieceSize(unsigned int value);
 
        unsigned int GetPieceSize() const;
 
        void SetLongMode(LongMode value);
 
        LongMode GetLongMode() const;
 
        unsigned int GetSQLCommand() const;
 
        ostring GetSQLVerb() const;
 
        std::vector<ostring> GetParseBindNames() const;
 
        void GetBatchErrors(std::vector<Exception>& exceptions);
 
    private:
 
        static bool IsResultsetHandle(core::Handle* handle);
        static void OnFreeSmartHandle(SmartHandle* smartHandle);
 
        Statement(OCI_Statement* stmt, core::Handle* parent = nullptr);
 
        support::BindsHolder* GetBindsHolder(bool create) 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 core::HandleHolder<OCI_Resultset*>
    {
        friend class Statement;
    public:
 
        enum SeekModeValues
        {
            SeekAbsolute = OCI_SFD_ABSOLUTE,
            SeekRelative = OCI_SFD_RELATIVE
        };
 
        typedef core::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, core::Handle* parent);
    };
 
    class Column : public core::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 core::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;
 
 
        int GetDimension() const;
 
        PropertyFlags GetPropertyFlags() const;
 
        bool IsNullable() const;
 
        bool IsCharSemanticUsed() const;
 
        TypeInfo GetTypeInfo() const;
 
    private:
 
        Column(OCI_Column* pColumn, core::Handle* parent);
    };
 
    class Subscription : public core::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 core::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* pSubscription);
    };
 
    class Event : public core::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 core::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 core::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 core::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, core::Handle* parent);
    };
 
    class Message : public core::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 core::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, core::Handle* parent);
    };
 
    class Enqueue : public core::HandleHolder<OCI_Enqueue*>
    {
    public:
 
        enum EnqueueModeValues
        {
            Before = OCI_ASD_BEFORE,
            OnTop = OCI_ASD_TOP
        };
 
        typedef core::Enum<EnqueueModeValues> EnqueueMode;
 
        enum EnqueueVisibilityValues
        {
            Immediate = OCI_AMV_IMMEDIATE,
            OnCommit = OCI_AMV_ON_COMMIT
        };
 
        typedef core::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 core::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 core::Enum<DequeueModeValues> DequeueMode;
 
        enum DequeueVisibilityValues
        {
            Immediate = OCI_AMV_IMMEDIATE,
            OnCommit = OCI_AMV_ON_COMMIT
        };
 
        typedef core::Enum<DequeueVisibilityValues> DequeueVisibility;
 
        enum NavigationModeValues
        {
            FirstMessage = OCI_ADN_FIRST_MSG,
            NextMessage = OCI_ADN_NEXT_MSG,
            NextTransaction = OCI_ADN_NEXT_TRANSACTION
        };
 
        typedef core::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, core::Handle* parent);
    };
 
    class Queue
    {
    public:
 
        enum QueueTypeValues
        {
            NormalQueue = OCI_AQT_NORMAL,
            ExceptionQueue = OCI_AQT_EXCEPTION,
            NonPersistentQueue = OCI_AQT_NON_PERSISTENT
        };
 
        typedef core::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 core::Enum<GroupingModeValues> GroupingMode;
 
        enum PurgeModeValues
        {
            Buffered = OCI_APM_BUFFERED,
            Persistent = OCI_APM_PERSISTENT,
            All = OCI_APM_ALL
        };
 
        typedef core::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 core::HandleHolder<OCI_DirPath*>
    {
    public:
 
        enum ConversionModeValues
        {
            Default = OCI_DCM_DEFAULT,
            Force = OCI_DCM_FORCE
        };
 
        typedef core::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 core::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();
    };
 
 
#define OCILIB_DEFINE_FLAG_OPERATORS(T) \
        inline core::Flags<T> operator | (T a, T b) { return core::Flags<T>(a) | core::Flags<T>(b); } \
 
        OCILIB_DEFINE_FLAG_OPERATORS(Environment::EnvironmentFlagsValues)
        OCILIB_DEFINE_FLAG_OPERATORS(Environment::SessionFlagsValues)
        OCILIB_DEFINE_FLAG_OPERATORS(Environment::StartFlagsValues)
        OCILIB_DEFINE_FLAG_OPERATORS(Environment::StartModeValues)
        OCILIB_DEFINE_FLAG_OPERATORS(Environment::ShutdownModeValues)
        OCILIB_DEFINE_FLAG_OPERATORS(Environment::ShutdownFlagsValues)
        OCILIB_DEFINE_FLAG_OPERATORS(Environment::AllocatedBytesValues)
        OCILIB_DEFINE_FLAG_OPERATORS(Transaction::TransactionFlagsValues)
        OCILIB_DEFINE_FLAG_OPERATORS(Column::PropertyFlagsValues)
        OCILIB_DEFINE_FLAG_OPERATORS(Subscription::ChangeTypesValues)
}