| TerraLib 4.1

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files
- Examples

- File List
- File Members

E:/Projetos_Primeiro_Semestre_2012/TerraView/terralib/src/terralib/drivers/Firebird/ibpp/core/_ibpp.h
Go to the documentation of this file.

    00001
    00002 //
    00003 //         File    : $Id: _ibpp.h 9672 2011-06-27 20:26:31Z frederico.bede $
    00004 //         Subject : IBPP internal declarations
    00005 //
    00007 //
    00008 //         (C) Copyright 2000-2006 T.I.P. Group S.A. and the IBPP Team (www.ibpp.org)
    00009 //
    00010 //         The contents of this file are subject to the IBPP License (the "License");
    00011 //         you may not use this file except in compliance with the License.  You may
    00012 //         obtain a copy of the License at http://www.ibpp.org or in the 'license.txt'
    00013 //         file which must have been distributed along with this file.
    00014 //
    00015 //         This software, distributed under the License, is distributed on an "AS IS"
    00016 //         basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See the
    00017 //         License for the specific language governing rights and limitations
    00018 //         under the License.
    00019 //
    00021 //
    00022 //         COMMENTS
    00023 //
    00024 //         * 'Internal declarations' means everything used to implement ibpp. This
    00025 //           file and its contents is NOT needed by users of the library. All those
    00026 //           declarations are wrapped in a namespace : 'ibpp_internals'.
    00027 //         * Tabulations should be set every four characters when editing this file.
    00028 //
    00030
    00031 #ifndef __INTERNAL_IBPP_H__
    00032 #define __INTERNAL_IBPP_H__
    00033
    00034 #include "ibpp.h"
    00035
    00036 #if defined(__BCPLUSPLUS__) || defined(_MSC_VER) || defined(__DMC__)
    00037 #define HAS_HDRSTOP
    00038 #endif
    00039
    00040 #if (defined(__GNUC__) && defined(IBPP_WINDOWS))
    00041 //         Setting flags for ibase.h -- using GCC/Cygwin/MinGW on Win32
    00042 #ifndef _MSC_VER
    00043 #define _MSC_VER 1299
    00044 #endif
    00045 #ifndef _WIN32
    00046 #define _WIN32   1
    00047 #endif
    00048 #endif
    00049
    00050 #include "ibase.h"               // From Firebird 1.x or InterBase 6.x installation
    00051
    00052 #if (defined(__GNUC__) && defined(IBPP_WINDOWS))
    00053 //         UNSETTING flags used above for ibase.h -- Huge conflicts with libstdc++ !
    00054 #undef _MSC_VER
    00055 #undef _WIN32
    00056 #endif
    00057
    00058 #ifdef IBPP_WINDOWS
    00059 #include <windows.h>
    00060 #endif
    00061
    00062 #include <limits>
    00063 #include <cstring>
    00064 #include <vector>
    00065 #include <sstream>
    00066 #include <cstdarg>
    00067 #include <memory>
    00068 #include <cstdlib>
    00069
    00070 #ifdef _DEBUG
    00071 #define ASSERTION(x)  {if (!(x)) {throw LogicExceptionImpl("ASSERTION", \
    00072                                                                              "'"#x"' is not verified at %s, line %d", \
    00073                                                                                         __FILE__, __LINE__);}}
    00074 #else
    00075 #define ASSERTION(x)  /* x */
    00076 #endif
    00077
    00078 // Fix to famous MSVC 6 variable scope bug
    00079 #if defined(_MSC_VER) && (_MSC_VER < 1300)  // MSVC 6 should be < 1300
    00080 #define for if(true)for
    00081 #endif
    00082
    00083 namespace ibpp_internals
    00084 {
    00085
    00086 enum flush_debug_stream_type {fds};
    00087
    00088 #ifdef _DEBUG
    00089
    00090 struct DebugStream : public std::stringstream
    00091 {
    00092            // next two operators fix some g++ and vc++ related problems
    00093            std::ostream& operator<< (const char* p)
    00094                       { static_cast<std::stringstream&>(*this)<< p; return *this; }
    00095
    00096            std::ostream& operator<< (const std::string& p)
    00097                       { static_cast<std::stringstream&>(*this)<< p; return *this; }
    00098
    00099            DebugStream& operator=(const DebugStream&) {return *this;}
    00100            DebugStream(const DebugStream&) {}
    00101            DebugStream() {}
    00102 };
    00103 std::ostream& operator<< (std::ostream& a, flush_debug_stream_type);
    00104
    00105 #else
    00106
    00107 struct DebugStream
    00108 {
    00109            template<class T> DebugStream& operator<< (const T&) { return *this; }
    00110            // for manipulators
    00111            DebugStream& operator<< (std::ostream&(*)(std::ostream&)) { return *this; }
    00112 };
    00113
    00114 #endif     // _DEBUG
    00115
    00116 class DatabaseImpl;
    00117 class TransactionImpl;
    00118 class StatementImpl;
    00119 class BlobImpl;
    00120 class ArrayImpl;
    00121 class EventsImpl;
    00122
    00123 //         Native data types
    00124 typedef enum {ivArray, ivBlob, ivDate, ivTime, ivTimestamp, ivString,
    00125                                  ivInt16, ivInt32, ivInt64, ivFloat, ivDouble,
    00126                                  ivBool, ivDBKey, ivByte} IITYPE;
    00127
    00128 //
    00129 //         Those are the Interbase C API prototypes that we use
    00130 //         Taken 'asis' from IBASE.H, prefix 'isc_' replaced with 'proto_',
    00131 //         and 'typedef' preprended...
    00132 //
    00133
    00134 typedef ISC_STATUS ISC_EXPORT proto_create_database (ISC_STATUS *,
    00135                                                            short,
    00136                                                            char *,
    00137                                                            isc_db_handle *,
    00138                                                            short,
    00139                                                            char *,
    00140                                                            short);
    00141
    00142 typedef ISC_STATUS ISC_EXPORT proto_attach_database (ISC_STATUS *,
    00143                                                            short,
    00144                                                            char *,
    00145                                                            isc_db_handle *,
    00146                                                            short,
    00147                                                            char *);
    00148
    00149 typedef ISC_STATUS  ISC_EXPORT proto_detach_database (ISC_STATUS *,
    00150                                                            isc_db_handle *);
    00151
    00152 typedef ISC_STATUS  ISC_EXPORT proto_drop_database (ISC_STATUS *,
    00153                                                          isc_db_handle *);
    00154
    00155 typedef ISC_STATUS  ISC_EXPORT proto_database_info (ISC_STATUS *,
    00156                                                          isc_db_handle *,
    00157                                                          short,
    00158                                                          char *,
    00159                                                          short,
    00160                                                          char *);
    00161
    00162 typedef ISC_STATUS  ISC_EXPORT proto_dsql_execute_immediate (ISC_STATUS *,
    00163                                                                      isc_db_handle *,
    00164                                                                      isc_tr_handle *,
    00165                                                                      unsigned short,
    00166                                                                      char *,
    00167                                                                      unsigned short,
    00168                                                                      XSQLDA *);
    00169
    00170 typedef ISC_STATUS  ISC_EXPORT proto_open_blob2 (ISC_STATUS *,
    00171                                                    isc_db_handle *,
    00172                                                    isc_tr_handle *,
    00173                                                    isc_blob_handle *,
    00174                                                    ISC_QUAD *,
    00175                                                    short,
    00176                                                    char *);
    00177
    00178 typedef ISC_STATUS  ISC_EXPORT proto_create_blob2 (ISC_STATUS *,
    00179                                                        isc_db_handle *,
    00180                                                        isc_tr_handle *,
    00181                                                        isc_blob_handle *,
    00182                                                        ISC_QUAD *,
    00183                                                        short,
    00184                                                        char *);
    00185
    00186 typedef ISC_STATUS  ISC_EXPORT proto_close_blob (ISC_STATUS *,
    00187                                                    isc_blob_handle *);
    00188
    00189 typedef ISC_STATUS  ISC_EXPORT proto_cancel_blob (ISC_STATUS *,
    00190                                                     isc_blob_handle *);
    00191
    00192 typedef ISC_STATUS  ISC_EXPORT proto_get_segment (ISC_STATUS *,
    00193                                                     isc_blob_handle *,
    00194                                                     unsigned short *,
    00195                                                     unsigned short,
    00196                                                     char *);
    00197
    00198 typedef ISC_STATUS  ISC_EXPORT proto_put_segment (ISC_STATUS *,
    00199                                                        isc_blob_handle *,
    00200                                                        unsigned short,
    00201                                                        char *);
    00202
    00203 typedef ISC_STATUS  ISC_EXPORT proto_blob_info (ISC_STATUS *,
    00204                                                   isc_blob_handle *,
    00205                                                   short,
    00206                                                   char *,
    00207                                                   short,
    00208                                                   char *);
    00209
    00210 typedef ISC_STATUS  ISC_EXPORT proto_array_lookup_bounds (ISC_STATUS *,
    00211                                                                   isc_db_handle *,
    00212                                                                   isc_tr_handle *,
    00213                                                                   char *,
    00214                                                                   char *,
    00215                                                                   ISC_ARRAY_DESC *);
    00216
    00217 typedef ISC_STATUS  ISC_EXPORT proto_array_get_slice (ISC_STATUS *,
    00218                                                            isc_db_handle *,
    00219                                                            isc_tr_handle *,
    00220                                                            ISC_QUAD *,
    00221                                                            ISC_ARRAY_DESC *,
    00222                                                            void *,
    00223                                                            ISC_LONG *);
    00224
    00225 typedef ISC_STATUS  ISC_EXPORT proto_array_put_slice (ISC_STATUS *,
    00226                                                            isc_db_handle *,
    00227                                                            isc_tr_handle *,
    00228                                                            ISC_QUAD *,
    00229                                                            ISC_ARRAY_DESC *,
    00230                                                            void *,
    00231                                                            ISC_LONG *);
    00232
    00233 typedef ISC_LONG    ISC_EXPORT proto_vax_integer (char *,
    00234                                                        short);
    00235
    00236 typedef ISC_LONG    ISC_EXPORT proto_sqlcode (ISC_STATUS *);
    00237
    00238 typedef void        ISC_EXPORT proto_sql_interprete (short,
    00239                                                           char *,
    00240                                                           short);
    00241
    00242 typedef ISC_STATUS  ISC_EXPORT proto_interprete (char *,
    00243                                                    ISC_STATUS * *);
    00244
    00245 typedef ISC_STATUS  ISC_EXPORT proto_que_events (ISC_STATUS *,
    00246                                                    isc_db_handle *,
    00247                                                    ISC_LONG *,
    00248                                                    short,
    00249                                                    char *,
    00250                                                    isc_callback,
    00251                                                    void *);
    00252
    00253 typedef ISC_STATUS  ISC_EXPORT proto_cancel_events (ISC_STATUS *,
    00254                                                          isc_db_handle *,
    00255                                                          ISC_LONG *);
    00256
    00257 typedef ISC_STATUS  ISC_EXPORT proto_start_multiple (ISC_STATUS *,
    00258                                                           isc_tr_handle *,
    00259                                                           short,
    00260                                                           void *);
    00261
    00262 typedef ISC_STATUS  ISC_EXPORT proto_commit_transaction (ISC_STATUS *,
    00263                                                               isc_tr_handle *);
    00264
    00265 typedef ISC_STATUS  ISC_EXPORT proto_commit_retaining (ISC_STATUS *,
    00266                                                             isc_tr_handle *);
    00267
    00268 typedef ISC_STATUS  ISC_EXPORT proto_rollback_transaction (ISC_STATUS *,
    00269                                                                    isc_tr_handle *);
    00270
    00271 typedef ISC_STATUS  ISC_EXPORT proto_rollback_retaining (ISC_STATUS *,
    00272                                                                    isc_tr_handle *);
    00273
    00275 typedef ISC_STATUS  ISC_EXPORT proto_dsql_allocate_statement (ISC_STATUS *,
    00276                                                                       isc_db_handle *,
    00277                                                                       isc_stmt_handle *);
    00278
    00279 typedef ISC_STATUS  ISC_EXPORT proto_dsql_describe (ISC_STATUS *,
    00280                                                          isc_stmt_handle *,
    00281                                                          unsigned short,
    00282                                                          XSQLDA *);
    00283
    00284 typedef ISC_STATUS  ISC_EXPORT proto_dsql_describe_bind (ISC_STATUS *,
    00285                                                               isc_stmt_handle *,
    00286                                                               unsigned short,
    00287                                                               XSQLDA *);
    00288
    00289 typedef ISC_STATUS  ISC_EXPORT proto_dsql_execute (ISC_STATUS *,
    00290                                                         isc_tr_handle *,
    00291                                                         isc_stmt_handle *,
    00292                                                         unsigned short,
    00293                                                         XSQLDA *);
    00294
    00295 typedef ISC_STATUS  ISC_EXPORT proto_dsql_execute2 (ISC_STATUS *,
    00296                                                          isc_tr_handle *,
    00297                                                          isc_stmt_handle *,
    00298                                                          unsigned short,
    00299                                                          XSQLDA *,
    00300                                                          XSQLDA *);
    00301
    00302 typedef ISC_STATUS  ISC_EXPORT proto_dsql_fetch (ISC_STATUS *,
    00303                                                    isc_stmt_handle *,
    00304                                                    unsigned short,
    00305                                                    XSQLDA *);
    00306
    00307 typedef ISC_STATUS  ISC_EXPORT proto_dsql_free_statement (ISC_STATUS *,
    00308                                                                   isc_stmt_handle *,
    00309                                                                   unsigned short);
    00310
    00311 typedef ISC_STATUS  ISC_EXPORT proto_dsql_prepare (ISC_STATUS *,
    00312                                                         isc_tr_handle *,
    00313                                                         isc_stmt_handle *,
    00314                                                         unsigned short,
    00315                                                         char *,
    00316                                                         unsigned short,
    00317                                                         XSQLDA *);
    00318
    00319 typedef ISC_STATUS  ISC_EXPORT proto_dsql_set_cursor_name (ISC_STATUS *,
    00320                                                                    isc_stmt_handle *,
    00321                                                                    char *,
    00322                                                                    unsigned short);
    00323
    00324 typedef ISC_STATUS  ISC_EXPORT proto_dsql_sql_info (ISC_STATUS *,
    00325                                                          isc_stmt_handle *,
    00326                                                          short,
    00327                                                          char *,
    00328                                                          short,
    00329                                                          char *);
    00330
    00331 typedef void        ISC_EXPORT proto_decode_date (ISC_QUAD *,
    00332                                                        void *);
    00333
    00334 typedef void        ISC_EXPORT proto_encode_date (void *,
    00335                                                        ISC_QUAD *);
    00336
    00337 typedef int                                 ISC_EXPORT proto_add_user (ISC_STATUS *, USER_SEC_DATA *);
    00338 typedef int                                 ISC_EXPORT proto_delete_user (ISC_STATUS *, USER_SEC_DATA *);
    00339 typedef int                                 ISC_EXPORT proto_modify_user (ISC_STATUS *, USER_SEC_DATA *);
    00340
    00341 //
    00342 //         Those API are only available in versions 6.x of the GDS32.DLL
    00343 //
    00344
    00345 typedef ISC_STATUS  ISC_EXPORT proto_service_attach (ISC_STATUS *,
    00346                                                           unsigned short,
    00347                                                           char *,
    00348                                                           isc_svc_handle *,
    00349                                                           unsigned short,
    00350                                                           char *);
    00351
    00352 typedef ISC_STATUS  ISC_EXPORT proto_service_detach (ISC_STATUS *,
    00353                                                           isc_svc_handle *);
    00354
    00355 typedef ISC_STATUS  ISC_EXPORT proto_service_query (ISC_STATUS *,
    00356                                                          isc_svc_handle *,
    00357                                                       isc_resv_handle *,
    00358                                                          unsigned short,
    00359                                                          char *,
    00360                                                          unsigned short,
    00361                                                          char *,
    00362                                                          unsigned short,
    00363                                                          char *);
    00364
    00365 typedef ISC_STATUS ISC_EXPORT proto_service_start (ISC_STATUS *,
    00366                                                         isc_svc_handle *,
    00367                                              isc_resv_handle *,
    00368                                                         unsigned short,
    00369                                                         char*);
    00370
    00371 typedef void        ISC_EXPORT proto_decode_sql_date (ISC_DATE *,
    00372                                                        void *);
    00373
    00374 typedef void        ISC_EXPORT proto_decode_sql_time (ISC_TIME *,
    00375                                                        void *);
    00376
    00377 typedef void        ISC_EXPORT proto_decode_timestamp (ISC_TIMESTAMP *,
    00378                                                        void *);
    00379
    00380 typedef void        ISC_EXPORT proto_encode_sql_date (void *,
    00381                                                        ISC_DATE *);
    00382
    00383 typedef void        ISC_EXPORT proto_encode_sql_time (void *,
    00384                                                        ISC_TIME *);
    00385
    00386 typedef void        ISC_EXPORT proto_encode_timestamp (void *,
    00387                                                        ISC_TIMESTAMP *);
    00388
    00389 //
    00390 //         Internal binding structure to the GDS32 DLL
    00391 //
    00392
    00393 struct GDS
    00394 {
    00395            // Attributes
    00396            bool mReady;
    00397            int mGDSVersion;                 // Version of the GDS32.DLL (50 for 5.0, 60 for 6.0)
    00398
    00399 #ifdef IBPP_WINDOWS
    00400            HMODULE mHandle;                            // The GDS32.DLL HMODULE
    00401            std::string mSearchPaths;        // Optional additional search paths
    00402 #endif
    00403
    00404            GDS* Call();
    00405
    00406            // GDS32 Entry Points
    00407            proto_create_database*                                 m_create_database;
    00408            proto_attach_database*                                 m_attach_database;
    00409            proto_detach_database*                                 m_detach_database;
    00410            proto_drop_database*                        m_drop_database;
    00411            proto_database_info*                        m_database_info;
    00412            proto_dsql_execute_immediate*    m_dsql_execute_immediate;
    00413            proto_open_blob2*                                      m_open_blob2;
    00414            proto_create_blob2*                                    m_create_blob2;
    00415            proto_close_blob*                                      m_close_blob;
    00416            proto_cancel_blob*                                     m_cancel_blob;
    00417            proto_get_segment*                                     m_get_segment;
    00418            proto_put_segment*                                     m_put_segment;
    00419            proto_blob_info*                                       m_blob_info;
    00420            proto_array_lookup_bounds*                  m_array_lookup_bounds;
    00421            proto_array_get_slice*                                 m_array_get_slice;
    00422            proto_array_put_slice*                                 m_array_put_slice;
    00423
    00424            proto_vax_integer*                                     m_vax_integer;
    00425            proto_sqlcode*                                                    m_sqlcode;
    00426            proto_sql_interprete*                       m_sql_interprete;
    00427            proto_interprete*                                      m_interprete;
    00428            proto_que_events*                                      m_que_events;
    00429            proto_cancel_events*                        m_cancel_events;
    00430            proto_start_multiple*                       m_start_multiple;
    00431            proto_commit_transaction*                   m_commit_transaction;
    00432            proto_commit_retaining*                                m_commit_retaining;
    00433            proto_rollback_transaction*                 m_rollback_transaction;
    00434            proto_rollback_retaining*                   m_rollback_retaining;
    00435            proto_dsql_allocate_statement*   m_dsql_allocate_statement;
    00436            proto_dsql_describe*                        m_dsql_describe;
    00437            proto_dsql_describe_bind*                   m_dsql_describe_bind;
    00438            proto_dsql_prepare*                                    m_dsql_prepare;
    00439            proto_dsql_execute*                                    m_dsql_execute;
    00440            proto_dsql_execute2*                        m_dsql_execute2;
    00441            proto_dsql_fetch*                                      m_dsql_fetch;
    00442            proto_dsql_free_statement*                  m_dsql_free_statement;
    00443            proto_dsql_set_cursor_name*                 m_dsql_set_cursor_name;
    00444            proto_dsql_sql_info*                        m_dsql_sql_info;
    00445            //proto_decode_date*                                   m_decode_date;
    00446            //proto_encode_date*                                   m_encode_date;
    00447            //proto_add_user*                                                 m_add_user;
    00448            //proto_delete_user*                                   m_delete_user;
    00449            //proto_modify_user*                                   m_modify_user;
    00450
    00451            proto_service_attach*                       m_service_attach;
    00452            proto_service_detach*                       m_service_detach;
    00453            proto_service_start*                        m_service_start;
    00454            proto_service_query*                        m_service_query;
    00455            //proto_decode_sql_date*                               m_decode_sql_date;
    00456            //proto_decode_sql_time*                               m_decode_sql_time;
    00457            //proto_decode_timestamp*                              m_decode_timestamp;
    00458            //proto_encode_sql_date*                               m_encode_sql_date;
    00459            //proto_encode_sql_time*                               m_encode_sql_time;
    00460            //proto_encode_timestamp*                              m_encode_timestamp;
    00461
    00462            // Constructor (No need for a specific destructor)
    00463            GDS()
    00464            {
    00465                       mReady = false;
    00466                       mGDSVersion = 0;
    00467 #ifdef IBPP_WINDOWS
    00468                       mHandle = 0;
    00469 #endif
    00470            };
    00471 };
    00472
    00473 extern GDS gds;
    00474
    00475 //
    00476 //         Service Parameter Block (used to define a service)
    00477 //
    00478
    00479 class SPB
    00480 {
    00481            static const int BUFFERINCR;
    00482
    00483            char* mBuffer;                                         // Dynamically allocated SPB structure
    00484            int mSize;                                             // Its used size in bytes
    00485            int mAlloc;                                                       // Its allocated size in bytes
    00486
    00487            void Grow(int needed);                      // Alloc or grow the mBuffer
    00488
    00489 public:
    00490            void Insert(char);                          // Insert a single byte code
    00491            void InsertString(char, int, const char*);  // Insert a string, len can be defined as 1 or 2 bytes
    00492            void InsertByte(char type, char data);
    00493            void InsertQuad(char type, int32_t data);
    00494            void Reset();                               // Clears the SPB
    00495            char* Self() { return mBuffer; }
    00496            short Size() { return (short)mSize; }
    00497
    00498            SPB() : mBuffer(0), mSize(0), mAlloc(0) { }
    00499            ~SPB() { Reset(); }
    00500 };
    00501
    00502 //
    00503 //         Database Parameter Block (used to define a database)
    00504 //
    00505
    00506 class DPB
    00507 {
    00508            static const int BUFFERINCR;
    00509
    00510            char* mBuffer;                                         // Dynamically allocated DPB structure
    00511            int mSize;                                             // Its used size in bytes
    00512            int mAlloc;                                                       // Its allocated size in bytes
    00513
    00514            void Grow(int needed);                      // Allocate or grow the mBuffer, so that
    00515                                                                                         // 'needed' bytes can be written (at least)
    00516
    00517 public:
    00518            void Insert(char, const char*);  // Insert a new char* 'cluster'
    00519            void Insert(char, int16_t);                 // Insert a new int16_t 'cluster'
    00520            void Insert(char, bool);                    // Insert a new bool 'cluster'
    00521            void Insert(char, char);                    // Insert a new byte 'cluster'
    00522            void Reset();                                          // Clears the DPB
    00523            char* Self() { return mBuffer; }
    00524            short Size() { return (short)mSize; }
    00525
    00526            DPB() : mBuffer(0), mSize(0), mAlloc(0) { }
    00527            ~DPB() { Reset(); }
    00528 };
    00529
    00530 //
    00531 //         Transaction Parameter Block (used to define a transaction)
    00532 //
    00533
    00534 class TPB
    00535 {
    00536            static const int BUFFERINCR;
    00537
    00538            char* mBuffer;                                                    // Dynamically allocated TPB structure
    00539            int mSize;                                                        // Its used size in bytes
    00540            int mAlloc;                                                                  // Its allocated size
    00541
    00542            void Grow(int needed);                                 // Alloc or re-alloc the mBuffer
    00543
    00544 public:
    00545            void Insert(char);                                     // Insert a flag item
    00546            void Insert(const std::string& data); // Insert a string (typically table name)
    00547            void Reset();                                          // Clears the TPB
    00548            char* Self() { return mBuffer; }
    00549            int Size() { return mSize; }
    00550
    00551            TPB() : mBuffer(0), mSize(0), mAlloc(0) { }
    00552            ~TPB() { Reset(); }
    00553 };
    00554
    00555 //
    00556 //         Used to receive (and process) a results buffer in various API calls
    00557 //
    00558
    00559 class RB
    00560 {
    00561            char* mBuffer;
    00562            int mSize;
    00563
    00564            char* FindToken(char token);
    00565            char* FindToken(char token, char subtoken);
    00566
    00567 public:
    00568            void Reset();
    00569            int GetValue(char token);
    00570            int GetCountValue(char token);
    00571            int GetValue(char token, char subtoken);
    00572            bool GetBool(char token);
    00573            int GetString(char token, std::string& data);
    00574
    00575            char* Self() { return mBuffer; }
    00576            short Size() { return (short)mSize; }
    00577
    00578            RB();
    00579            RB(int Size);
    00580            ~RB();
    00581 };
    00582
    00583 //
    00584 //         Used to receive status info from API calls
    00585 //
    00586
    00587 class IBS
    00588 {
    00589            mutable ISC_STATUS mVector[20];
    00590            mutable std::string mMessage;
    00591
    00592 public:
    00593            ISC_STATUS* Self() { return mVector; }
    00594            bool Errors() { return (mVector[0] == 1 && mVector[1] > 0) ? true : false; }
    00595            const char* ErrorMessage() const;
    00596            int SqlCode() const;
    00597            int EngineCode() const { return (mVector[0] == 1) ? (int)mVector[1] : 0; }
    00598            void Reset();
    00599
    00600            IBS();
    00601            IBS(IBS&); // Copy Constructor
    00602            ~IBS();
    00603 };
    00604
    00606 //
    00607 //         Implementation of the "hidden" classes associated with their public
    00608 //         counterparts. Their private data and methods can freely change without
    00609 //         breaking the compatibility of the DLL. If they receive new public methods,
    00610 //         and those methods are reflected in the public class, then the compatibility
    00611 //         is broken.
    00612 //
    00614
    00615 //
    00616 // Hidden implementation of Exception classes.
    00617 //
    00618
    00619 /*
    00620                          std::exception
    00621                                 |
    00622                          IBPP::Exception
    00623                        /                 \
    00624                       /                   \
    00625   IBPP::LogicException    ExceptionBase    IBPP::SQLException
    00626         |        \         /   |     \     /
    00627         |   LogicExceptionImpl |   SQLExceptionImpl
    00628         |                      |
    00629     IBPP::WrongType            |
    00630                \               |
    00631               IBPP::WrongTypeImpl
    00632 */
    00633
    00634 class ExceptionBase
    00635 {
    00636            //         (((((((( OBJECT INTERNALS ))))))))
    00637
    00638 protected:
    00639            std::string mContext;                                  // Exception context ("IDatabase::Drop")
    00640            std::string mWhat;                                     // Full formatted message
    00641
    00642            void buildErrorMessage(const char* message);
    00643            void raise(const std::string& context, const char* message, va_list argptr);
    00644
    00645 public:
    00646            // The following constructors are small and could be inlined, but for object
    00647            // code compacity of the library it is much better to have them non-inlined.
    00648            // The amount of code generated by compilers for a throw is well-enough.
    00649
    00650            ExceptionBase() throw();
    00651            ExceptionBase(const ExceptionBase& copied) throw();
    00652            ExceptionBase& operator=(const ExceptionBase& copied) throw();
    00653            ExceptionBase(const std::string& context, const char* message = 0, ...) throw();
    00654
    00655            virtual ~ExceptionBase() throw();
    00656
    00657            //         (((((((( OBJECT INTERFACE ))))))))
    00658
    00659     virtual const char* Origin() const throw();
    00660     virtual const char* ErrorMessage() const throw();
    00661            virtual const char* what() const throw();
    00662 };
    00663
    00664 class LogicExceptionImpl : public IBPP::LogicException, public ExceptionBase
    00665 {
    00666            //         (((((((( OBJECT INTERNALS ))))))))
    00667
    00668 public:
    00669            // The following constructors are small and could be inlined, but for object
    00670            // code compacity of the library it is much better to have them non-inlined.
    00671            // The amount of code generated by compilers for a throw is well-enough.
    00672
    00673            LogicExceptionImpl() throw();
    00674            LogicExceptionImpl(const LogicExceptionImpl& copied) throw();
    00675            LogicExceptionImpl& operator=(const LogicExceptionImpl& copied) throw();
    00676            LogicExceptionImpl(const std::string& context, const char* message = 0, ...) throw();
    00677
    00678            virtual ~LogicExceptionImpl() throw ();
    00679
    00680            //         (((((((( OBJECT INTERFACE ))))))))
    00681            //
    00682            //         The object public interface is partly implemented by inheriting from
    00683            //         the ExceptionBase class.
    00684
    00685 public:
    00686     virtual const char* Origin() const throw();
    00687     virtual const char* ErrorMessage() const throw();
    00688            virtual const char* what() const throw();
    00689 };
    00690
    00691 class SQLExceptionImpl : public IBPP::SQLException, public ExceptionBase
    00692 {
    00693            //         (((((((( OBJECT INTERNALS ))))))))
    00694
    00695 private:
    00696            int mSqlCode;
    00697            int mEngineCode;
    00698
    00699 public:
    00700            // The following constructors are small and could be inlined, but for object
    00701            // code compacity of the library it is much better to have them non-inlined.
    00702            // The amount of code generated by compilers for a throw is well-enough.
    00703
    00704            SQLExceptionImpl() throw();
    00705            SQLExceptionImpl(const SQLExceptionImpl& copied) throw();
    00706            SQLExceptionImpl& operator=(const SQLExceptionImpl& copied) throw();
    00707            SQLExceptionImpl(const IBS& status, const std::string& context,
    00708                                                                   const char* message = 0, ...) throw();
    00709
    00710            virtual ~SQLExceptionImpl() throw ();
    00711
    00712            //         (((((((( OBJECT INTERFACE ))))))))
    00713            //
    00714            //         The object public interface is partly implemented by inheriting from
    00715            //         the ExceptionBase class.
    00716
    00717 public:
    00718     virtual const char* Origin() const throw();
    00719     virtual const char* ErrorMessage() const throw();
    00720            virtual const char* what() const throw();
    00721            virtual int SqlCode() const throw();
    00722            virtual int EngineCode() const throw();
    00723 };
    00724
    00725 class WrongTypeImpl : public IBPP::WrongType, public ExceptionBase
    00726 {
    00727            //         (((((((( OBJECT INTERNALS ))))))))
    00728
    00729 public:
    00730            // The following constructors are small and could be inlined, but for object
    00731            // code compacity of the library it is much better to have them non-inlined.
    00732            // The amount of code generated by compilers for a throw is well-enough.
    00733
    00734            WrongTypeImpl() throw();
    00735            WrongTypeImpl(const WrongTypeImpl& copied) throw();
    00736            WrongTypeImpl& operator=(const WrongTypeImpl& copied) throw();
    00737            WrongTypeImpl(const std::string& context, int sqlType, IITYPE varType,
    00738                                                        const char* message = 0, ...) throw();
    00739
    00740            virtual ~WrongTypeImpl() throw ();
    00741
    00742            //         (((((((( OBJECT INTERFACE ))))))))
    00743            //
    00744            //         The object public interface is partly implemented by inheriting from
    00745            //         the ExceptionBase class.
    00746
    00747 public:
    00748     virtual const char* Origin() const throw();
    00749     virtual const char* ErrorMessage() const throw();
    00750            virtual const char* what() const throw();
    00751 };
    00752
    00753 class ServiceImpl : public IBPP::IService
    00754 {
    00755            //         (((((((( OBJECT INTERNALS ))))))))
    00756
    00757 private:
    00758            int mRefCount;                                         // Reference counter
    00759     isc_svc_handle mHandle;                 // InterBase API Service Handle
    00760            std::string mServerName;         // Nom du serveur
    00761     std::string mUserName;                  // Nom de l'utilisateur
    00762     std::string mUserPassword;   // Mot de passe de l'utilisateur
    00763            std::string mWaitMessage;        // Progress message returned by WaitMsg()
    00764
    00765            isc_svc_handle* GetHandlePtr() { return &mHandle; }
    00766            void SetServerName(const char*);
    00767            void SetUserName(const char*);
    00768            void SetUserPassword(const char*);
    00769
    00770 public:
    00771            isc_svc_handle GetHandle() { return mHandle; }
    00772
    00773            ServiceImpl(const std::string& ServerName, const std::string& UserName,
    00774                                                        const std::string& UserPassword);
    00775     ~ServiceImpl();
    00776
    00777            //         (((((((( OBJECT INTERFACE ))))))))
    00778
    00779 public:
    00780     void Connect();
    00781            bool Connected() { return mHandle == 0 ? false : true; }
    00782            void Disconnect();
    00783
    00784            void GetVersion(std::string& version);
    00785
    00786            void AddUser(const IBPP::User&);
    00787            void GetUser(IBPP::User&);
    00788            void GetUsers(std::vector<IBPP::User>&);
    00789            void ModifyUser(const IBPP::User&);
    00790            void RemoveUser(const std::string& username);
    00791
    00792            void SetPageBuffers(const std::string& dbfile, int buffers);
    00793            void SetSweepInterval(const std::string& dbfile, int sweep);
    00794            void SetSyncWrite(const std::string& dbfile, bool);
    00795            void SetReadOnly(const std::string& dbfile, bool);
    00796            void SetReserveSpace(const std::string& dbfile, bool);
    00797
    00798            void Shutdown(const std::string& dbfile, IBPP::DSM mode, int sectimeout);
    00799            void Restart(const std::string& dbfile);
    00800            void Sweep(const std::string& dbfile);
    00801            void Repair(const std::string& dbfile, IBPP::RPF flags);
    00802
    00803            void StartBackup(const std::string& dbfile, const std::string& bkfile,
    00804                       IBPP::BRF flags = IBPP::BRF(0));
    00805            void StartRestore(const std::string& bkfile, const std::string& dbfile,
    00806                       int pagesize, IBPP::BRF flags = IBPP::BRF(0));
    00807
    00808            const char* WaitMsg();
    00809            void Wait();
    00810
    00811            IBPP::IService* AddRef();
    00812            void Release();
    00813 };
    00814
    00815 class DatabaseImpl : public IBPP::IDatabase
    00816 {
    00817            //         (((((((( OBJECT INTERNALS ))))))))
    00818
    00819            int mRefCount;                                         // Reference counter
    00820     isc_db_handle mHandle;                  // InterBase API Session Handle
    00821            std::string mServerName;         // Server name
    00822     std::string mDatabaseName;   // Database name (path/file)
    00823     std::string mUserName;                  // User name
    00824     std::string mUserPassword;   // User password
    00825     std::string mRoleName;                  // Role used for the duration of the connection
    00826            std::string mCharSet;            // Character Set used for the connection
    00827            std::string mCreateParams;       // Other parameters (creation only)
    00828
    00829            int mDialect;                                                                           // 1 if IB5, 1 or 3 if IB6/FB1
    00830            std::vector<TransactionImpl*> mTransactions;// Table of Transaction*
    00831            std::vector<StatementImpl*> mStatements;// Table of Statement*
    00832            std::vector<BlobImpl*> mBlobs;                         // Table of Blob*
    00833            std::vector<ArrayImpl*> mArrays;            // Table of Array*
    00834            std::vector<EventsImpl*> mEvents;                      // Table of Events*
    00835
    00836 public:
    00837            isc_db_handle* GetHandlePtr() { return &mHandle; }
    00838            isc_db_handle GetHandle() { return mHandle; }
    00839
    00840            void AttachTransactionImpl(TransactionImpl*);
    00841            void DetachTransactionImpl(TransactionImpl*);
    00842            void AttachStatementImpl(StatementImpl*);
    00843            void DetachStatementImpl(StatementImpl*);
    00844            void AttachBlobImpl(BlobImpl*);
    00845            void DetachBlobImpl(BlobImpl*);
    00846            void AttachArrayImpl(ArrayImpl*);
    00847            void DetachArrayImpl(ArrayImpl*);
    00848            void AttachEventsImpl(EventsImpl*);
    00849            void DetachEventsImpl(EventsImpl*);
    00850
    00851            DatabaseImpl(const std::string& ServerName, const std::string& DatabaseName,
    00852                                             const std::string& UserName, const std::string& UserPassword,
    00853                                             const std::string& RoleName, const std::string& CharSet,
    00854                                             const std::string& CreateParams);
    00855     ~DatabaseImpl();
    00856
    00857            //         (((((((( OBJECT INTERFACE ))))))))
    00858
    00859 public:
    00860            const char* ServerName() const              { return mServerName.c_str(); }
    00861            const char* DatabaseName() const { return mDatabaseName.c_str(); }
    00862            const char* Username() const                { return mUserName.c_str(); }
    00863            const char* UserPassword() const { return mUserPassword.c_str(); }
    00864            const char* RoleName() const                { return mRoleName.c_str(); }
    00865            const char* CharSet() const                            { return mCharSet.c_str(); }
    00866            const char* CreateParams() const { return mCreateParams.c_str(); }
    00867
    00868            void Info(int* ODSMajor, int* ODSMinor,
    00869                       int* PageSize, int* Pages, int* Buffers, int* Sweep,
    00870                       bool* SyncWrites, bool* Reserve);
    00871            void Statistics(int* Fetches, int* Marks, int* Reads, int* Writes);
    00872            void Counts(int* Insert, int* Update, int* Delete,
    00873                       int* ReadIdx, int* ReadSeq);
    00874            void Users(std::vector<std::string>& users);
    00875            int Dialect() { return mDialect; }
    00876
    00877     void Create(int dialect);
    00878            void Connect();
    00879            bool Connected() { return mHandle == 0 ? false : true; }
    00880            void Inactivate();
    00881            void Disconnect();
    00882     void Drop();
    00883
    00884            IBPP::IDatabase* AddRef();
    00885            void Release();
    00886 };
    00887
    00888 class TransactionImpl : public IBPP::ITransaction
    00889 {
    00890            //         (((((((( OBJECT INTERNALS ))))))))
    00891
    00892 private:
    00893            int mRefCount;                                                    // Reference counter
    00894     isc_tr_handle mHandle;                             // Transaction InterBase
    00895
    00896            std::vector<DatabaseImpl*> mDatabases;      // Tableau de IDatabase*
    00897            std::vector<StatementImpl*> mStatements;    // Tableau de IStatement*
    00898            std::vector<BlobImpl*> mBlobs;                                    // Tableau de IBlob*
    00899            std::vector<ArrayImpl*> mArrays;                       // Tableau de Array*
    00900            std::vector<TPB*> mTPBs;                                                     // Tableau de TPB
    00901
    00902            void Init();                                // A usage exclusif des constructeurs
    00903
    00904 public:
    00905            isc_tr_handle* GetHandlePtr() { return &mHandle; }
    00906            isc_tr_handle GetHandle() { return mHandle; }
    00907
    00908            void AttachStatementImpl(StatementImpl*);
    00909            void DetachStatementImpl(StatementImpl*);
    00910            void AttachBlobImpl(BlobImpl*);
    00911            void DetachBlobImpl(BlobImpl*);
    00912            void AttachArrayImpl(ArrayImpl*);
    00913            void DetachArrayImpl(ArrayImpl*);
    00914     void AttachDatabaseImpl(DatabaseImpl* dbi, IBPP::TAM am = IBPP::amWrite,
    00915                                  IBPP::TIL il = IBPP::ilConcurrency,
    00916                                  IBPP::TLR lr = IBPP::lrWait, IBPP::TFF flags = IBPP::TFF(0));
    00917     void DetachDatabaseImpl(DatabaseImpl* dbi);
    00918
    00919            TransactionImpl(DatabaseImpl* db, IBPP::TAM am = IBPP::amWrite,
    00920                       IBPP::TIL il = IBPP::ilConcurrency,
    00921                       IBPP::TLR lr = IBPP::lrWait, IBPP::TFF flags = IBPP::TFF(0));
    00922     ~TransactionImpl();
    00923
    00924            //         (((((((( OBJECT INTERFACE ))))))))
    00925
    00926 public:
    00927     void AttachDatabase(IBPP::Database db, IBPP::TAM am = IBPP::amWrite,
    00928                                  IBPP::TIL il = IBPP::ilConcurrency,
    00929                                  IBPP::TLR lr = IBPP::lrWait, IBPP::TFF flags = IBPP::TFF(0));
    00930     void DetachDatabase(IBPP::Database db);
    00931            void AddReservation(IBPP::Database db,
    00932                                  const std::string& table, IBPP::TTR tr);
    00933
    00934     void Start();
    00935            bool Started() { return mHandle == 0 ? false : true; }
    00936     void Commit();
    00937     void Rollback();
    00938     void CommitRetain();
    00939            void RollbackRetain();
    00940
    00941            IBPP::ITransaction* AddRef();
    00942            void Release();
    00943 };
    00944
    00945 class RowImpl : public IBPP::IRow
    00946 {
    00947            //         (((((((( OBJECT INTERNALS ))))))))
    00948
    00949 private:
    00950            int mRefCount;                                                    // Reference counter
    00951
    00952            XSQLDA* mDescrArea;                                    // XSQLDA descriptor itself
    00953            std::vector<double> mNumerics;   // Temporary storage for Numerics
    00954            std::vector<float> mFloats;                 // Temporary storage for Floats
    00955            std::vector<int64_t> mInt64s;    // Temporary storage for 64 bits
    00956            std::vector<int32_t> mInt32s;    // Temporary storage for 32 bits
    00957            std::vector<int16_t> mInt16s;    // Temporary storage for 16 bits
    00958            std::vector<char> mBools;                   // Temporary storage for Bools
    00959            std::vector<std::string> mStrings;          // Temporary storage for Strings
    00960            std::vector<bool> mUpdated;                 // Which columns where updated (Set()) ?
    00961
    00962            int mDialect;                                                     // Related database dialect
    00963            DatabaseImpl* mDatabase;                    // Related Database (important for Blobs, ...)
    00964            TransactionImpl* mTransaction;   // Related Transaction (same remark)
    00965
    00966            void SetValue(int, IITYPE, const void* value, int = 0);
    00967            void* GetValue(int, IITYPE, void* = 0);
    00968
    00969 public:
    00970            void Free();
    00971            short AllocatedSize() { return mDescrArea->sqln; }
    00972            void Resize(int n);
    00973            void AllocVariables();
    00974            bool MissingValues();            // Returns wether one of the mMissing[] is true
    00975            XSQLDA* Self() { return mDescrArea; }
    00976
    00977            RowImpl& operator=(const RowImpl& copied);
    00978            RowImpl(const RowImpl& copied);
    00979            RowImpl(int dialect, int size, DatabaseImpl* db, TransactionImpl* tr);
    00980     ~RowImpl();
    00981
    00982            //         (((((((( OBJECT INTERFACE ))))))))
    00983
    00984 public:
    00985            void SetNull(int);
    00986            void Set(int, bool);
    00987            void Set(int, const char*);                                       // c-strings
    00988            void Set(int, const void*, int);            // byte buffers
    00989            void Set(int, const std::string&);
    00990            void Set(int, int16_t);
    00991            void Set(int, int32_t);
    00992            void Set(int, int64_t);
    00993            void Set(int, float);
    00994            void Set(int, double);
    00995            void Set(int, const IBPP::Timestamp&);
    00996            void Set(int, const IBPP::Date&);
    00997            void Set(int, const IBPP::Time&);
    00998            void Set(int, const IBPP::DBKey&);
    00999            void Set(int, const IBPP::Blob&);
    01000            void Set(int, const IBPP::Array&);
    01001
    01002            bool IsNull(int);
    01003            bool Get(int, bool&);
    01004            bool Get(int, char*);                       // c-strings, len unchecked
    01005            bool Get(int, void*, int&);      // byte buffers
    01006            bool Get(int, std::string&);
    01007            bool Get(int, int16_t&);
    01008            bool Get(int, int32_t&);
    01009            bool Get(int, int64_t&);
    01010            bool Get(int, float&);
    01011            bool Get(int, double&);
    01012            bool Get(int, IBPP::Timestamp&);
    01013            bool Get(int, IBPP::Date&);
    01014            bool Get(int, IBPP::Time&);
    01015            bool Get(int, IBPP::DBKey&);
    01016            bool Get(int, IBPP::Blob&);
    01017            bool Get(int, IBPP::Array&);
    01018
    01019            bool IsNull(const std::string&);
    01020            bool Get(const std::string&, bool&);
    01021            bool Get(const std::string&, char*);        // c-strings, len unchecked
    01022            bool Get(const std::string&, void*, int&);  // byte buffers
    01023            bool Get(const std::string&, std::string&);
    01024            bool Get(const std::string&, int16_t&);
    01025            bool Get(const std::string&, int32_t&);
    01026            bool Get(const std::string&, int64_t&);
    01027            bool Get(const std::string&, float&);
    01028            bool Get(const std::string&, double&);
    01029            bool Get(const std::string&, IBPP::Timestamp&);
    01030            bool Get(const std::string&, IBPP::Date&);
    01031            bool Get(const std::string&, IBPP::Time&);
    01032            bool Get(const std::string&, IBPP::DBKey&);
    01033            bool Get(const std::string&, IBPP::Blob&);
    01034            bool Get(const std::string&, IBPP::Array&);
    01035
    01036            int ColumnNum(const std::string&);
    01037            const char* ColumnName(int);
    01038            const char* ColumnAlias(int);
    01039            const char* ColumnTable(int);
    01040            IBPP::SDT ColumnType(int);
    01041            int ColumnSubtype(int);
    01042            int ColumnSize(int);
    01043            int ColumnScale(int);
    01044            int Columns();
    01045
    01046            bool ColumnUpdated(int);
    01047            bool Updated();
    01048
    01049            IBPP::Database DatabasePtr() const;
    01050            IBPP::Transaction TransactionPtr() const;
    01051
    01052            IBPP::IRow* Clone();
    01053            IBPP::IRow* AddRef();
    01054            void Release();
    01055 };
    01056
    01057 class StatementImpl : public IBPP::IStatement
    01058 {
    01059            //         (((((((( OBJECT INTERNALS ))))))))
    01060
    01061 private:
    01062            friend class TransactionImpl;
    01063
    01064            int mRefCount;                                         // Reference counter
    01065            isc_stmt_handle mHandle;         // Statement Handle
    01066
    01067            DatabaseImpl* mDatabase;                    // Attached database
    01068            TransactionImpl* mTransaction;   // Attached transaction
    01069            RowImpl* mInRow;
    01070            //bool* mInMissing;                         // Quels param�tres n'ont pas �t� sp�cifi�s
    01071            RowImpl* mOutRow;
    01072            bool mResultSetAvailable;        // Executed and result set is available
    01073            bool mCursorOpened;                         // dsql_set_cursor_name was called
    01074            IBPP::STT mType;                            // Type de requ�te
    01075            std::string mSql;                           // Last SQL statement prepared or executed
    01076
    01077            // Internal Methods
    01078            void CursorFree();
    01079
    01080 public:
    01081            // Properties and Attributes Access Methods
    01082            isc_stmt_handle GetHandle() { return mHandle; }
    01083
    01084            void AttachDatabaseImpl(DatabaseImpl*);
    01085            void DetachDatabaseImpl();
    01086            void AttachTransactionImpl(TransactionImpl*);
    01087            void DetachTransactionImpl();
    01088
    01089            StatementImpl(DatabaseImpl*, TransactionImpl*, const std::string&);
    01090     ~StatementImpl();
    01091
    01092            //         (((((((( OBJECT INTERFACE ))))))))
    01093
    01094 public:
    01095            void Prepare(const std::string& sql);
    01096            void Execute(const std::string& sql);
    01097            inline void Execute() { Execute(std::string()); }
    01098            void ExecuteImmediate(const std::string&);
    01099            void CursorExecute(const std::string& cursor, const std::string& sql);
    01100            inline void CursorExecute(const std::string& cursor)   { CursorExecute(cursor, std::string()); }
    01101            bool Fetch();
    01102            bool Fetch(IBPP::Row&);
    01103            int AffectedRows();
    01104            void Close();         // Free resources, attachments maintained
    01105            std::string& Sql() { return mSql; }
    01106            IBPP::STT Type() { return mType; }
    01107
    01108            void SetNull(int);
    01109            void Set(int, bool);
    01110            void Set(int, const char*);                                       // c-strings
    01111            void Set(int, const void*, int);            // byte buffers
    01112            void Set(int, const std::string&);
    01113            void Set(int, int16_t);
    01114            void Set(int, int32_t);
    01115            void Set(int, int64_t);
    01116            void Set(int, float);
    01117            void Set(int, double);
    01118            void Set(int, const IBPP::Timestamp&);
    01119            void Set(int, const IBPP::Date&);
    01120            void Set(int, const IBPP::Time&);
    01121            void Set(int, const IBPP::DBKey&);
    01122            void Set(int, const IBPP::Blob&);
    01123            void Set(int, const IBPP::Array&);
    01124
    01125            bool IsNull(int);
    01126            bool Get(int, bool*);
    01127            bool Get(int, bool&);
    01128            bool Get(int, char*);                                  // c-strings, len unchecked
    01129            bool Get(int, void*, int&);                            // byte buffers
    01130            bool Get(int, std::string&);
    01131            bool Get(int, int16_t*);
    01132            bool Get(int, int16_t&);
    01133            bool Get(int, int32_t*);
    01134            bool Get(int, int32_t&);
    01135            bool Get(int, int64_t*);
    01136            bool Get(int, int64_t&);
    01137            bool Get(int, float*);
    01138            bool Get(int, float&);
    01139            bool Get(int, double*);
    01140            bool Get(int, double&);
    01141            bool Get(int, IBPP::Timestamp&);
    01142            bool Get(int, IBPP::Date&);
    01143            bool Get(int, IBPP::Time&);
    01144            bool Get(int, IBPP::DBKey&);
    01145            bool Get(int, IBPP::Blob&);
    01146            bool Get(int, IBPP::Array&);
    01147
    01148            bool IsNull(const std::string&);
    01149            bool Get(const std::string&, bool*);
    01150            bool Get(const std::string&, bool&);
    01151            bool Get(const std::string&, char*);                   // c-strings, len unchecked
    01152            bool Get(const std::string&, void*, int&);  // byte buffers
    01153            bool Get(const std::string&, std::string&);
    01154            bool Get(const std::string&, int16_t*);
    01155            bool Get(const std::string&, int16_t&);
    01156            bool Get(const std::string&, int32_t*);
    01157            bool Get(const std::string&, int32_t&);
    01158            bool Get(const std::string&, int64_t*);
    01159            bool Get(const std::string&, int64_t&);
    01160            bool Get(const std::string&, float*);
    01161            bool Get(const std::string&, float&);
    01162            bool Get(const std::string&, double*);
    01163            bool Get(const std::string&, double&);
    01164            bool Get(const std::string&, IBPP::Timestamp&);
    01165            bool Get(const std::string&, IBPP::Date&);
    01166            bool Get(const std::string&, IBPP::Time&);
    01167            bool Get(const std::string&, IBPP::DBKey&);
    01168            bool Get(const std::string&, IBPP::Blob&);
    01169            bool Get(const std::string&, IBPP::Array&);
    01170
    01171            int ColumnNum(const std::string&);
    01172     int ColumnNumAlias(const std::string&);
    01173            const char* ColumnName(int);
    01174            const char* ColumnAlias(int);
    01175            const char* ColumnTable(int);
    01176            IBPP::SDT ColumnType(int);
    01177            int ColumnSubtype(int);
    01178            int ColumnSize(int);
    01179            int ColumnScale(int);
    01180            int Columns();
    01181
    01182            IBPP::SDT ParameterType(int);
    01183            int ParameterSubtype(int);
    01184            int ParameterSize(int);
    01185            int ParameterScale(int);
    01186            int Parameters();
    01187
    01188            void Plan(std::string&);
    01189
    01190            IBPP::Database DatabasePtr() const;
    01191            IBPP::Transaction TransactionPtr() const;
    01192
    01193            IBPP::IStatement* AddRef();
    01194            void Release();
    01195 };
    01196
    01197 class BlobImpl : public IBPP::IBlob
    01198 {
    01199            //         (((((((( OBJECT INTERNALS ))))))))
    01200
    01201 private:
    01202            friend class RowImpl;
    01203
    01204            int mRefCount;
    01205            bool                                                   mIdAssigned;
    01206            ISC_QUAD                                    mId;
    01207            isc_blob_handle                             mHandle;
    01208            bool                                                   mWriteMode;
    01209            DatabaseImpl*                               mDatabase;            // Belongs to this database
    01210            TransactionImpl*                 mTransaction;         // Belongs to this transaction
    01211
    01212            void Init();
    01213            void SetId(ISC_QUAD*);
    01214            void GetId(ISC_QUAD*);
    01215
    01216 public:
    01217            void AttachDatabaseImpl(DatabaseImpl*);
    01218            void DetachDatabaseImpl();
    01219            void AttachTransactionImpl(TransactionImpl*);
    01220            void DetachTransactionImpl();
    01221
    01222            BlobImpl(const BlobImpl&);
    01223            BlobImpl(DatabaseImpl*, TransactionImpl* = 0);
    01224            ~BlobImpl();
    01225
    01226            //         (((((((( OBJECT INTERFACE ))))))))
    01227
    01228 public:
    01229            void Create();
    01230            void Open();
    01231            void Close();
    01232            void Cancel();
    01233            int Read(void*, int size);
    01234            void Write(const void*, int size);
    01235            void Info(int* Size, int* Largest, int* Segments);
    01236
    01237            void Save(const std::string& data);
    01238            void Load(std::string& data);
    01239
    01240            IBPP::Database DatabasePtr() const;
    01241            IBPP::Transaction TransactionPtr() const;
    01242
    01243            IBPP::IBlob* AddRef();
    01244            void Release();
    01245 };
    01246
    01247 class ArrayImpl : public IBPP::IArray
    01248 {
    01249            //         (((((((( OBJECT INTERNALS ))))))))
    01250
    01251 private:
    01252            friend class RowImpl;
    01253
    01254            int                                                    mRefCount;            // Reference counter
    01255            bool                                        mIdAssigned;
    01256            ISC_QUAD                         mId;
    01257            bool                                        mDescribed;
    01258            ISC_ARRAY_DESC                   mDesc;
    01259            DatabaseImpl*                    mDatabase;            // Database attach�e
    01260            TransactionImpl*      mTransaction;         // Transaction attach�e
    01261            void*                                       mBuffer;              // Buffer for native data
    01262            int                                                    mBufferSize;          // Size of this buffer in bytes
    01263            int                                                    mElemCount;                      // Count of elements in this array
    01264            int                                                    mElemSize;            // Size of an element in the buffer
    01265
    01266            void Init();
    01267            void SetId(ISC_QUAD*);
    01268            void GetId(ISC_QUAD*);
    01269            void ResetId();
    01270            void AllocArrayBuffer();
    01271
    01272 public:
    01273            void AttachDatabaseImpl(DatabaseImpl*);
    01274            void DetachDatabaseImpl();
    01275            void AttachTransactionImpl(TransactionImpl*);
    01276            void DetachTransactionImpl();
    01277
    01278            ArrayImpl(const ArrayImpl&);
    01279            ArrayImpl(DatabaseImpl*, TransactionImpl* = 0);
    01280            ~ArrayImpl();
    01281
    01282            //         (((((((( OBJECT INTERFACE ))))))))
    01283
    01284 public:
    01285            void Describe(const std::string& table, const std::string& column);
    01286            void ReadTo(IBPP::ADT, void*, int);
    01287            void WriteFrom(IBPP::ADT, const void*, int);
    01288            IBPP::SDT ElementType();
    01289            int ElementSize();
    01290            int ElementScale();
    01291            int Dimensions();
    01292            void Bounds(int dim, int* low, int* high);
    01293            void SetBounds(int dim, int low, int high);
    01294
    01295            IBPP::Database DatabasePtr() const;
    01296            IBPP::Transaction TransactionPtr() const;
    01297
    01298            IBPP::IArray* AddRef();
    01299            void Release();
    01300 };
    01301
    01302 //
    01303 //         EventBufferIterator: used in EventsImpl implementation.
    01304 //
    01305
    01306 template<class It>
    01307 struct EventBufferIterator
    01308 {
    01309            It mIt;
    01310
    01311 public:
    01312            EventBufferIterator& operator++()
    01313                       { mIt += 1 + static_cast<int>(*mIt) + 4; return *this; }
    01314
    01315            bool operator == (const EventBufferIterator& i) const { return i.mIt == mIt; }
    01316            bool operator != (const EventBufferIterator& i) const { return i.mIt != mIt; }
    01317
    01318 #ifdef __BCPLUSPLUS__
    01319 #pragma warn -8027
    01320 #endif
    01321            std::string get_name() const
    01322            {
    01323                       return std::string(mIt + 1, mIt + 1 + static_cast<int32_t>(*mIt));
    01324            }
    01325 #ifdef __BCPLUSPLUS__
    01326 #pragma warn .8027
    01327 #endif
    01328
    01329            uint32_t get_count() const
    01330            {
    01331                       return (*gds.Call()->m_vax_integer)
    01332                                  (const_cast<char*>(&*(mIt + 1 + static_cast<int>(*mIt))), 4);
    01333            }
    01334
    01335            // Those container like begin() and end() allow access to the underlying type
    01336            It begin() { return mIt; }
    01337            It end()   { return mIt + 1 + static_cast<int>(*mIt) + 4; }
    01338
    01339            EventBufferIterator() {}
    01340            EventBufferIterator(It it) : mIt(it) {}
    01341 };
    01342
    01343 class EventsImpl : public IBPP::IEvents
    01344 {
    01345            static const size_t MAXEVENTNAMELEN;
    01346            static void EventHandler(const char*, short, const char*);
    01347
    01348            typedef std::vector<IBPP::EventInterface*> ObjRefs;
    01349            ObjRefs mObjectReferences;
    01350
    01351            typedef std::vector<char> Buffer;
    01352            Buffer mEventBuffer;
    01353            Buffer mResultsBuffer;
    01354
    01355            int mRefCount;                   // Reference counter
    01356
    01357            DatabaseImpl* mDatabase;
    01358            ISC_LONG mId;                               // Firebird internal Id of these events
    01359            bool mQueued;                               // Has isc_que_events() been called?
    01360            bool mTrapped;                              // EventHandled() was called since last que_events()
    01361
    01362            void FireActions();
    01363            void Queue();
    01364            void Cancel();
    01365
    01366            EventsImpl& operator=(const EventsImpl&);
    01367            EventsImpl(const EventsImpl&);
    01368
    01369 public:
    01370            void AttachDatabaseImpl(DatabaseImpl*);
    01371            void DetachDatabaseImpl();
    01372
    01373            EventsImpl(DatabaseImpl* dbi);
    01374            ~EventsImpl();
    01375
    01376            //         (((((((( OBJECT INTERFACE ))))))))
    01377
    01378 public:
    01379            void Add(const std::string&, IBPP::EventInterface*);
    01380            void Drop(const std::string&);
    01381            void List(std::vector<std::string>&);
    01382            void Clear();                                          // Drop all events
    01383            void Dispatch();                            // Dispatch NON async events
    01384
    01385            IBPP::Database DatabasePtr() const;
    01386
    01387            IBPP::IEvents* AddRef();
    01388            void Release();
    01389 };
    01390
    01391 void encodeDate(ISC_DATE& isc_dt, const IBPP::Date& dt);
    01392 void decodeDate(IBPP::Date& dt, const ISC_DATE& isc_dt);
    01393
    01394 void encodeTime(ISC_TIME& isc_tm, const IBPP::Time& tm);
    01395 void decodeTime(IBPP::Time& tm, const ISC_TIME& isc_tm);
    01396
    01397 void encodeTimestamp(ISC_TIMESTAMP& isc_ts, const IBPP::Timestamp& ts);
    01398 void decodeTimestamp(IBPP::Timestamp& ts, const ISC_TIMESTAMP& isc_ts);
    01399
    01400 struct consts         // See _ibpp.cpp for initializations of these constants
    01401 {
    01402            static const double dscales[19];
    01403            static const int Dec31_1899;
    01404            static const int16_t min16;
    01405            static const int16_t max16;
    01406            static const int32_t min32;
    01407            static const int32_t max32;
    01408 };
    01409
    01410 }          // namespace ibpp_internal
    01411
    01412 #endif // __INTERNAL_IBPP_H__
    01413
    01414 //
    01415 //         Eof
    01416 //

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines