// file : odb/oracle/oracle-types.hxx // copyright : Copyright (c) 2005-2018 Code Synthesis Tools CC // license : ODB NCUEL; see accompanying LICENSE file #ifndef ODB_ORACLE_ORACLE_TYPES_HXX #define ODB_ORACLE_ORACLE_TYPES_HXX #include #include #include #include // binding #include #include namespace odb { namespace oracle { enum chunk_position { chunk_one, chunk_first, chunk_next, chunk_last }; // Callback function signature used to specify LOB parameters that are // passed to the database. If false is returned from the callback, // statement execution is aborted. // typedef bool (*param_callback_type) ( const void* context, // [in] The user context. ub4* position_context, // [in] A position context. A callback is free to // use this to track position information. This is // initialized to zero before the callback is // invoked for the first time. const void** buffer, // [out] On return, a pointer to a buffer // containing parameter data. ub4* size, // [out] The parameter data size in bytes. chunk_position*, // [out] The position of the chunk of data in // buffer. void* temp_buffer, // [in] A temporary buffer that may be used if // required. The buffer argument should specify // this buffer on return if it is used. ub4 capacity); // [in] The temporary buffer size in bytes. // Callback function signature used to specify LOB values returned from // the database. If false is returned, database_exception is thrown. // typedef bool (*result_callback_type) ( void* context, // [in] The user context. ub4* position_context, // [in] A position context. A callback is free to // use this to track position information. This is // initialized to zero before the callback is // invoked for the first time. void* buffer, // [in] A buffer containing the result data. ub4 size, // [in] The result data size in bytes. chunk_position); // [in] The position of this chunk. struct lob_callback { union { param_callback_type param; result_callback_type result; } callback; union { const void* param; void* result; } context; }; struct bind { // This enumeration identifies the possible buffer types that can be // bound to a bind instance. In most cases, these map directly to // SQLT_XXX codes, identifying an external OCI type. nstring and nclob // however have no equivalent OCI typecode. These additional identifiers // allow for a consistent interface across all types. Note that these // values are mapped to their corresponding external OCI typecodes (if // any) using their integer values, and should therefore not be // rearranged or explicitly assigned without also adjusting the // sqlt_lookup array in odb/oracle/statement.cxx. // enum buffer_type { integer, // Buffer is an integer type of size specified by size. uinteger, // Buffer is an unsigned integer of size specified by // size. binary_float, // Buffer is a float. binary_double, // Buffer is a double. number, // Buffer is a variable length char array. date, // Buffer is a 7-byte char array. timestamp, // Buffer is a datetime. interval_ym, // Buffer is an interval_ym. interval_ds, // Buffer is an interval_ds. string, // Buffer is a variable length char array. nstring, // Buffer is a variable length char array. raw, // Buffer is a variable length char array. blob, // Bind is a callback. clob, // Bind is a callback. nclob, // Bind is a callback. last // Used as an end of list marker. }; buffer_type type; // The type stored by buffer. void* buffer; // Data buffer pointer. For LOB type bindings, this is // interpreted as an oracle::lob*. ub2* size; // The number of bytes in buffer. ub4 capacity; // The maximum number of bytes that can be stored in // the buffer. For LOBs, it used to store array skip // size. sb2* indicator; // Pointer to an OCI indicator variable. lob_callback* callback; }; // An instance of this structure specifies the function to invoke and // the context to pass when the object/view image is about to be // modified. This mechanism is used by the query machinery to save the // image between result iteration and dereferencing if something gets // executed between these two operations that would overwrite the // image. // struct change_callback { change_callback (): callback (0), context (0) {}; void (*callback) (void*); void* context; }; // The lob structure wraps data required for both parameter and result // LOB type bindings. // struct LIBODB_ORACLE_EXPORT lob { ~lob (); lob (): locator (0), buffer (0), position (0) {} lob (const lob&); lob& operator= (const lob&); private: void clone (const lob&); public: OCIEnv* environment; OCIError* error; OCILobLocator* locator; details::buffer* buffer; ub4 position; }; // // The OCIDateTime and OCIInterval APIs require that an environment and // error handle be passed to any function that manipulates an OCIDateTime // or OCIInterval descriptor. It is however impossible to obtain these // handles at the time a temporal data image is first initialized. The // following structures allow ODB generated code to interact with the OCI // temporal descriptor types indirectly via C++ primitives. The wrapped OCI // descriptor is then set using these primitives at a time when the // required data is available. A symmetric get interface is provided for // consistency. // // Descriptor management flags. // const unsigned short descriptor_cache = 0x01; const unsigned short descriptor_free = 0x02; struct LIBODB_ORACLE_EXPORT datetime { void get (sb2& year, ub1& month, ub1& day, ub1& hour, ub1& minute, ub1& second, ub4& nanosecond) const; void set (sb2 year, ub1 month, ub1 day, ub1 hour, ub1 minute, ub1 second, ub4 nanosecond); ~datetime (); datetime (unsigned short f = descriptor_cache | descriptor_free) : descriptor (0), flags (f) {} datetime (const datetime&); datetime& operator= (const datetime&); // Use the get() and set() functions above unless you know what you // are doing and understand how copying of datetime works. // public: OCIEnv* environment; OCIError* error; OCIDateTime* descriptor; unsigned short flags; public: sb2 year_; ub1 month_; ub1 day_; ub1 hour_; ub1 minute_; ub1 second_; ub4 nanosecond_; }; struct LIBODB_ORACLE_EXPORT interval_ym { void get (sb4& year, sb4& month) const; void set (sb4 year, sb4 month); ~interval_ym (); interval_ym (unsigned short f = descriptor_cache | descriptor_free) : descriptor (0), flags (f) {} interval_ym (const interval_ym&); interval_ym& operator= (const interval_ym&); // Use the get() and set() functions above unless you know what you // are doing and understand how copying of interval_ym works. // public: OCIEnv* environment; OCIError* error; OCIInterval* descriptor; unsigned short flags; public: sb4 year_; sb4 month_; }; struct LIBODB_ORACLE_EXPORT interval_ds { void get (sb4& day, sb4& hour, sb4& minute, sb4& second, sb4& nanosecond) const; void set (sb4 day, sb4 hour, sb4 minute, sb4 second, sb4 nanosecond); ~interval_ds (); interval_ds (unsigned short f = descriptor_cache | descriptor_free) : descriptor (0), flags (f) {} interval_ds (const interval_ds&); interval_ds& operator= (const interval_ds&); // Use the get() and set() functions above unless you know what you // are doing and understand how copying of interval_ds works. // public: OCIEnv* environment; OCIError* error; OCIInterval* descriptor; unsigned short flags; public: sb4 day_; sb4 hour_; sb4 minute_; sb4 second_; sb4 nanosecond_; }; } } #include #endif // ODB_ORACLE_ORACLE_TYPES_HXX