libs/ibpp/_ibpp.h

   1 ///////////////////////////////////////////////////////////////////////////////\r
   2 //\r
   3 //      File    : $Id: _ibpp.h,v 1.2 2007/05/17 08:37:05 faust Exp $\r
   4 //      Subject : IBPP internal declarations\r
   5 //\r
   6 ///////////////////////////////////////////////////////////////////////////////\r
   7 //\r
   8 //      (C) Copyright 2000-2006 T.I.P. Group S.A. and the IBPP Team (www.ibpp.org)\r
   9 //\r
  10 //      The contents of this file are subject to the IBPP License (the "License");\r
  11 //      you may not use this file except in compliance with the License.  You may\r
  12 //      obtain a copy of the License at http://www.ibpp.org or in the 'license.txt'\r
  13 //      file which must have been distributed along with this file.\r
  14 //\r
  15 //      This software, distributed under the License, is distributed on an "AS IS"\r
  16 //      basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See the\r
  17 //      License for the specific language governing rights and limitations\r
  18 //      under the License.\r
  19 //\r
  20 ///////////////////////////////////////////////////////////////////////////////\r
  21 //\r
  22 //      COMMENTS\r
  23 //\r
  24 //      * 'Internal declarations' means everything used to implement ibpp. This\r
  25 //        file and its contents is NOT needed by users of the library. All those\r
  26 //        declarations are wrapped in a namespace : 'ibpp_internals'.\r
  27 //      * Tabulations should be set every four characters when editing this file.\r
  28 //\r
  29 ///////////////////////////////////////////////////////////////////////////////\r
  30 \r
  31 #ifndef __INTERNAL_IBPP_H__\r
  32 #define __INTERNAL_IBPP_H__\r
  33 \r
  34 #include "stg/ibpp.h"\r
  35 \r
  36 #if defined(__BCPLUSPLUS__) || defined(_MSC_VER) || defined(__DMC__)\r
  37 #define HAS_HDRSTOP\r
  38 #endif\r
  39 \r
  40 #if (defined(__GNUC__) && defined(IBPP_WINDOWS))\r
  41 //      Setting flags for ibase.h -- using GCC/Cygwin/MinGW on Win32\r
  42 #ifndef _MSC_VER\r
  43 #define _MSC_VER 1299\r
  44 #endif\r
  45 #ifndef _WIN32\r
  46 #define _WIN32   1\r
  47 #endif\r
  48 #endif\r
  49 \r
  50 #include "ibase.h"              // From Firebird 1.x or InterBase 6.x installation\r
  51 \r
  52 #if (defined(__GNUC__) && defined(IBPP_WINDOWS))\r
  53 //      UNSETTING flags used above for ibase.h -- Huge conflicts with libstdc++ !\r
  54 #undef _MSC_VER\r
  55 #undef _WIN32\r
  56 #endif\r
  57 \r
  58 #ifdef IBPP_WINDOWS\r
  59 #include <windows.h>\r
  60 #endif\r
  61 \r
  62 //#include <limits>\r
  63 #include <string>\r
  64 #include <vector>\r
  65 #include <sstream>\r
  66 #include <cstdarg>\r
  67 \r
  68 #ifdef _DEBUG\r
  69 #define ASSERTION(x)    {if (!(x)) {throw LogicExceptionImpl("ASSERTION", \\r
  70                                                         "'"#x"' is not verified at %s, line %d", \\r
  71                                                                 __FILE__, __LINE__);}}\r
  72 #else\r
  73 #define ASSERTION(x)    /* x */\r
  74 #endif\r
  75 \r
  76 // Fix to famous MSVC 6 variable scope bug\r
  77 #if defined(_MSC_VER) && (_MSC_VER < 1300)      // MSVC 6 should be < 1300\r
  78 #define for if(true)for\r
  79 #endif\r
  80 \r
  81 namespace ibpp_internals\r
  82 {\r
  83 \r
  84 enum flush_debug_stream_type {fds};\r
  85 \r
  86 #ifdef _DEBUG\r
  87 \r
  88 struct DebugStream : public std::stringstream\r
  89 {\r
  90         // next two operators fix some g++ and vc++ related problems\r
  91         std::ostream& operator<< (const char* p)\r
  92                 { static_cast<std::stringstream&>(*this)<< p; return *this; }\r
  93 \r
  94         std::ostream& operator<< (const std::string& p)\r
  95                 { static_cast<std::stringstream&>(*this)<< p; return *this; }\r
  96 \r
  97         DebugStream& operator=(const DebugStream&) {return *this;}\r
  98         DebugStream(const DebugStream&) {}\r
  99         DebugStream() {}\r
 100 };\r
 101 std::ostream& operator<< (std::ostream& a, flush_debug_stream_type);\r
 102 \r
 103 #else\r
 104 \r
 105 struct DebugStream\r
 106 {\r
 107         template<class T> DebugStream& operator<< (const T&) { return *this; }\r
 108         // for manipulators\r
 109         DebugStream& operator<< (std::ostream&(*)(std::ostream&)) { return *this; }\r
 110 };\r
 111 \r
 112 #endif  // _DEBUG\r
 113 \r
 114 class DatabaseImpl;\r
 115 class TransactionImpl;\r
 116 class StatementImpl;\r
 117 class BlobImpl;\r
 118 class ArrayImpl;\r
 119 class EventsImpl;\r
 120 \r
 121 //      Native data types\r
 122 typedef enum {ivArray, ivBlob, ivDate, ivTime, ivTimestamp, ivString,\r
 123                         ivInt16, ivInt32, ivInt64, ivFloat, ivDouble,\r
 124                         ivBool, ivDBKey, ivByte} IITYPE;\r
 125 \r
 126 //\r
 127 //      Those are the Interbase C API prototypes that we use\r
 128 //      Taken 'asis' from IBASE.H, prefix 'isc_' replaced with 'proto_',\r
 129 //      and 'typedef' preprended...\r
 130 //\r
 131 \r
 132 typedef ISC_STATUS ISC_EXPORT proto_create_database (ISC_STATUS *,\r
 133                                             short,\r
 134                                             char *,\r
 135                                             isc_db_handle *,\r
 136                                             short,\r
 137                                             char *,\r
 138                                             short);\r
 139 \r
 140 typedef ISC_STATUS ISC_EXPORT proto_attach_database (ISC_STATUS *,\r
 141                                             short,\r
 142                                             char *,\r
 143                                             isc_db_handle *,\r
 144                                             short,\r
 145                                             char *);\r
 146 \r
 147 typedef ISC_STATUS  ISC_EXPORT proto_detach_database (ISC_STATUS *,\r
 148                                             isc_db_handle *);\r
 149 \r
 150 typedef ISC_STATUS  ISC_EXPORT proto_drop_database (ISC_STATUS *,\r
 151                                           isc_db_handle *);\r
 152 \r
 153 typedef ISC_STATUS  ISC_EXPORT proto_database_info (ISC_STATUS *,\r
 154                                           isc_db_handle *,\r
 155                                           short,\r
 156                                           char *,\r
 157                                           short,\r
 158                                           char *);\r
 159 \r
 160 typedef ISC_STATUS  ISC_EXPORT proto_dsql_execute_immediate (ISC_STATUS *,\r
 161                                                    isc_db_handle *,\r
 162                                                    isc_tr_handle *,\r
 163                                                    unsigned short,\r
 164                                                    char *,\r
 165                                                    unsigned short,\r
 166                                                    XSQLDA *);\r
 167 \r
 168 typedef ISC_STATUS  ISC_EXPORT proto_open_blob2 (ISC_STATUS *,\r
 169                                        isc_db_handle *,\r
 170                                        isc_tr_handle *,\r
 171                                        isc_blob_handle *,\r
 172                                        ISC_QUAD *,\r
 173                                        short,\r
 174                                        char *);\r
 175 \r
 176 typedef ISC_STATUS  ISC_EXPORT proto_create_blob2 (ISC_STATUS *,\r
 177                                         isc_db_handle *,\r
 178                                         isc_tr_handle *,\r
 179                                         isc_blob_handle *,\r
 180                                         ISC_QUAD *,\r
 181                                         short,\r
 182                                         char *);\r
 183 \r
 184 typedef ISC_STATUS  ISC_EXPORT proto_close_blob (ISC_STATUS *,\r
 185                                        isc_blob_handle *);\r
 186 \r
 187 typedef ISC_STATUS  ISC_EXPORT proto_cancel_blob (ISC_STATUS *,\r
 188                                         isc_blob_handle *);\r
 189 \r
 190 typedef ISC_STATUS  ISC_EXPORT proto_get_segment (ISC_STATUS *,\r
 191                                         isc_blob_handle *,\r
 192                                         unsigned short *,\r
 193                                         unsigned short,\r
 194                                         char *);\r
 195 \r
 196 typedef ISC_STATUS  ISC_EXPORT proto_put_segment (ISC_STATUS *,\r
 197                                         isc_blob_handle *,\r
 198                                         unsigned short,\r
 199                                         char *);\r
 200 \r
 201 typedef ISC_STATUS  ISC_EXPORT proto_blob_info (ISC_STATUS *,\r
 202                                       isc_blob_handle *,\r
 203                                       short,\r
 204                                       char *,\r
 205                                       short,\r
 206                                       char *);\r
 207 \r
 208 typedef ISC_STATUS  ISC_EXPORT proto_array_lookup_bounds (ISC_STATUS *,\r
 209                                                 isc_db_handle *,\r
 210                                                 isc_tr_handle *,\r
 211                                                 char *,\r
 212                                                 char *,\r
 213                                                 ISC_ARRAY_DESC *);\r
 214 \r
 215 typedef ISC_STATUS  ISC_EXPORT proto_array_get_slice (ISC_STATUS *,\r
 216                                             isc_db_handle *,\r
 217                                             isc_tr_handle *,\r
 218                                             ISC_QUAD *,\r
 219                                             ISC_ARRAY_DESC *,\r
 220                                             void *,\r
 221                                             ISC_LONG *);\r
 222 \r
 223 typedef ISC_STATUS  ISC_EXPORT proto_array_put_slice (ISC_STATUS *,\r
 224                                             isc_db_handle *,\r
 225                                             isc_tr_handle *,\r
 226                                             ISC_QUAD *,\r
 227                                             ISC_ARRAY_DESC *,\r
 228                                             void *,\r
 229                                             ISC_LONG *);\r
 230 \r
 231 typedef ISC_LONG    ISC_EXPORT proto_vax_integer (char *,\r
 232                                         short);\r
 233 \r
 234 typedef ISC_LONG    ISC_EXPORT proto_sqlcode (ISC_STATUS *);\r
 235 \r
 236 typedef void        ISC_EXPORT proto_sql_interprete (short,\r
 237                                            char *,\r
 238                                            short);\r
 239 \r
 240 typedef ISC_STATUS  ISC_EXPORT proto_interprete (char *,\r
 241                                        ISC_STATUS * *);\r
 242 \r
 243 typedef ISC_STATUS  ISC_EXPORT proto_que_events (ISC_STATUS *,\r
 244                                        isc_db_handle *,\r
 245                                        ISC_LONG *,\r
 246                                        short,\r
 247                                        char *,\r
 248                                        isc_callback,\r
 249                                        void *);\r
 250 \r
 251 typedef ISC_STATUS  ISC_EXPORT proto_cancel_events (ISC_STATUS *,\r
 252                                           isc_db_handle *,\r
 253                                           ISC_LONG *);\r
 254 \r
 255 typedef ISC_STATUS  ISC_EXPORT proto_start_multiple (ISC_STATUS *,\r
 256                                            isc_tr_handle *,\r
 257                                            short,\r
 258                                            void *);\r
 259 \r
 260 typedef ISC_STATUS  ISC_EXPORT proto_commit_transaction (ISC_STATUS *,\r
 261                                                isc_tr_handle *);\r
 262 \r
 263 typedef ISC_STATUS  ISC_EXPORT proto_commit_retaining (ISC_STATUS *,\r
 264                                              isc_tr_handle *);\r
 265 \r
 266 typedef ISC_STATUS  ISC_EXPORT proto_rollback_transaction (ISC_STATUS *,\r
 267                                                  isc_tr_handle *);\r
 268 \r
 269 typedef ISC_STATUS  ISC_EXPORT proto_rollback_retaining (ISC_STATUS *,\r
 270                                                  isc_tr_handle *);\r
 271 \r
 272 ///////////\r
 273 typedef ISC_STATUS  ISC_EXPORT proto_dsql_allocate_statement (ISC_STATUS *,\r
 274                                                     isc_db_handle *,\r
 275                                                     isc_stmt_handle *);\r
 276 \r
 277 typedef ISC_STATUS  ISC_EXPORT proto_dsql_describe (ISC_STATUS *,\r
 278                                           isc_stmt_handle *,\r
 279                                           unsigned short,\r
 280                                           XSQLDA *);\r
 281 \r
 282 typedef ISC_STATUS  ISC_EXPORT proto_dsql_describe_bind (ISC_STATUS *,\r
 283                                                isc_stmt_handle *,\r
 284                                                unsigned short,\r
 285                                                XSQLDA *);\r
 286 \r
 287 typedef ISC_STATUS  ISC_EXPORT proto_dsql_execute (ISC_STATUS *,\r
 288                                          isc_tr_handle *,\r
 289                                          isc_stmt_handle *,\r
 290                                          unsigned short,\r
 291                                          XSQLDA *);\r
 292 \r
 293 typedef ISC_STATUS  ISC_EXPORT proto_dsql_execute2 (ISC_STATUS *,\r
 294                                           isc_tr_handle *,\r
 295                                           isc_stmt_handle *,\r
 296                                           unsigned short,\r
 297                                           XSQLDA *,\r
 298                                           XSQLDA *);\r
 299 \r
 300 typedef ISC_STATUS  ISC_EXPORT proto_dsql_fetch (ISC_STATUS *,\r
 301                                        isc_stmt_handle *,\r
 302                                        unsigned short,\r
 303                                        XSQLDA *);\r
 304 \r
 305 typedef ISC_STATUS  ISC_EXPORT proto_dsql_free_statement (ISC_STATUS *,\r
 306                                                 isc_stmt_handle *,\r
 307                                                 unsigned short);\r
 308 \r
 309 typedef ISC_STATUS  ISC_EXPORT proto_dsql_prepare (ISC_STATUS *,\r
 310                                          isc_tr_handle *,\r
 311                                          isc_stmt_handle *,\r
 312                                          unsigned short,\r
 313                                          char *,\r
 314                                          unsigned short,\r
 315                                          XSQLDA *);\r
 316 \r
 317 typedef ISC_STATUS  ISC_EXPORT proto_dsql_set_cursor_name (ISC_STATUS *,\r
 318                                                  isc_stmt_handle *,\r
 319                                                  char *,\r
 320                                                  unsigned short);\r
 321 \r
 322 typedef ISC_STATUS  ISC_EXPORT proto_dsql_sql_info (ISC_STATUS *,\r
 323                                           isc_stmt_handle *,\r
 324                                           short,\r
 325                                           char *,\r
 326                                           short,\r
 327                                           char *);\r
 328 \r
 329 typedef void        ISC_EXPORT proto_decode_date (ISC_QUAD *,\r
 330                                         void *);\r
 331 \r
 332 typedef void        ISC_EXPORT proto_encode_date (void *,\r
 333                                         ISC_QUAD *);\r
 334 \r
 335 typedef int                     ISC_EXPORT proto_add_user (ISC_STATUS *, USER_SEC_DATA *);\r
 336 typedef int                     ISC_EXPORT proto_delete_user (ISC_STATUS *, USER_SEC_DATA *);\r
 337 typedef int                     ISC_EXPORT proto_modify_user (ISC_STATUS *, USER_SEC_DATA *);\r
 338 \r
 339 //\r
 340 //      Those API are only available in versions 6.x of the GDS32.DLL\r
 341 //\r
 342 \r
 343 typedef ISC_STATUS  ISC_EXPORT proto_service_attach (ISC_STATUS *,\r
 344                                            unsigned short,\r
 345                                            char *,\r
 346                                            isc_svc_handle *,\r
 347                                            unsigned short,\r
 348                                            char *);\r
 349 \r
 350 typedef ISC_STATUS  ISC_EXPORT proto_service_detach (ISC_STATUS *,\r
 351                                            isc_svc_handle *);\r
 352 \r
 353 typedef ISC_STATUS  ISC_EXPORT proto_service_query (ISC_STATUS *,\r
 354                                           isc_svc_handle *,\r
 355                                           isc_resv_handle *,\r
 356                                           unsigned short,\r
 357                                           char *,\r
 358                                           unsigned short,\r
 359                                           char *,\r
 360                                           unsigned short,\r
 361                                           char *);\r
 362 \r
 363 typedef ISC_STATUS ISC_EXPORT proto_service_start (ISC_STATUS *,\r
 364                                          isc_svc_handle *,\r
 365                                          isc_resv_handle *,\r
 366                                          unsigned short,\r
 367                                          char*);\r
 368 \r
 369 typedef void        ISC_EXPORT proto_decode_sql_date (ISC_DATE *,\r
 370                                         void *);\r
 371 \r
 372 typedef void        ISC_EXPORT proto_decode_sql_time (ISC_TIME *,\r
 373                                         void *);\r
 374 \r
 375 typedef void        ISC_EXPORT proto_decode_timestamp (ISC_TIMESTAMP *,\r
 376                                         void *);\r
 377 \r
 378 typedef void        ISC_EXPORT proto_encode_sql_date (void *,\r
 379                                         ISC_DATE *);\r
 380 \r
 381 typedef void        ISC_EXPORT proto_encode_sql_time (void *,\r
 382                                         ISC_TIME *);\r
 383 \r
 384 typedef void        ISC_EXPORT proto_encode_timestamp (void *,\r
 385                                         ISC_TIMESTAMP *);\r
 386 \r
 387 //\r
 388 //      Internal binding structure to the GDS32 DLL\r
 389 //\r
 390 \r
 391 struct GDS\r
 392 {\r
 393         // Attributes\r
 394         bool mReady;\r
 395         int mGDSVersion;                // Version of the GDS32.DLL (50 for 5.0, 60 for 6.0)\r
 396 \r
 397 #ifdef IBPP_WINDOWS\r
 398         HMODULE mHandle;                        // The GDS32.DLL HMODULE\r
 399         std::string mSearchPaths;       // Optional additional search paths\r
 400 #endif\r
 401 \r
 402         GDS* Call();\r
 403 \r
 404         // GDS32 Entry Points\r
 405         proto_create_database*                  m_create_database;\r
 406         proto_attach_database*                  m_attach_database;\r
 407         proto_detach_database*                  m_detach_database;\r
 408         proto_drop_database*                    m_drop_database;\r
 409         proto_database_info*                    m_database_info;\r
 410         proto_dsql_execute_immediate*   m_dsql_execute_immediate;\r
 411         proto_open_blob2*                               m_open_blob2;\r
 412         proto_create_blob2*                             m_create_blob2;\r
 413         proto_close_blob*                               m_close_blob;\r
 414         proto_cancel_blob*                              m_cancel_blob;\r
 415         proto_get_segment*                              m_get_segment;\r
 416         proto_put_segment*                              m_put_segment;\r
 417         proto_blob_info*                                m_blob_info;\r
 418         proto_array_lookup_bounds*              m_array_lookup_bounds;\r
 419         proto_array_get_slice*                  m_array_get_slice;\r
 420         proto_array_put_slice*                  m_array_put_slice;\r
 421 \r
 422         proto_vax_integer*                              m_vax_integer;\r
 423         proto_sqlcode*                                  m_sqlcode;\r
 424         proto_sql_interprete*                   m_sql_interprete;\r
 425         proto_interprete*                               m_interprete;\r
 426         proto_que_events*                               m_que_events;\r
 427         proto_cancel_events*                    m_cancel_events;\r
 428         proto_start_multiple*                   m_start_multiple;\r
 429         proto_commit_transaction*               m_commit_transaction;\r
 430         proto_commit_retaining*                 m_commit_retaining;\r
 431         proto_rollback_transaction*             m_rollback_transaction;\r
 432         proto_rollback_retaining*               m_rollback_retaining;\r
 433         proto_dsql_allocate_statement*  m_dsql_allocate_statement;\r
 434         proto_dsql_describe*                    m_dsql_describe;\r
 435         proto_dsql_describe_bind*               m_dsql_describe_bind;\r
 436         proto_dsql_prepare*                             m_dsql_prepare;\r
 437         proto_dsql_execute*                             m_dsql_execute;\r
 438         proto_dsql_execute2*                    m_dsql_execute2;\r
 439         proto_dsql_fetch*                               m_dsql_fetch;\r
 440         proto_dsql_free_statement*              m_dsql_free_statement;\r
 441         proto_dsql_set_cursor_name*             m_dsql_set_cursor_name;\r
 442         proto_dsql_sql_info*                    m_dsql_sql_info;\r
 443         //proto_decode_date*                            m_decode_date;\r
 444         //proto_encode_date*                            m_encode_date;\r
 445         //proto_add_user*                                       m_add_user;\r
 446         //proto_delete_user*                            m_delete_user;\r
 447         //proto_modify_user*                            m_modify_user;\r
 448 \r
 449         proto_service_attach*                   m_service_attach;\r
 450         proto_service_detach*                   m_service_detach;\r
 451         proto_service_start*                    m_service_start;\r
 452         proto_service_query*                    m_service_query;\r
 453         //proto_decode_sql_date*                        m_decode_sql_date;\r
 454         //proto_decode_sql_time*                        m_decode_sql_time;\r
 455         //proto_decode_timestamp*                       m_decode_timestamp;\r
 456         //proto_encode_sql_date*                        m_encode_sql_date;\r
 457         //proto_encode_sql_time*                        m_encode_sql_time;\r
 458         //proto_encode_timestamp*                       m_encode_timestamp;\r
 459 \r
 460         // Constructor (No need for a specific destructor)\r
 461         GDS()\r
 462         {\r
 463                 mReady = false;\r
 464                 mGDSVersion = 0;\r
 465 #ifdef IBPP_WINDOWS\r
 466                 mHandle = 0;\r
 467 #endif\r
 468         }\r
 469 };\r
 470 \r
 471 extern GDS gds;\r
 472 \r
 473 //\r
 474 //      Service Parameter Block (used to define a service)\r
 475 //\r
 476 \r
 477 class SPB\r
 478 {\r
 479         static const int BUFFERINCR;\r
 480 \r
 481         char* mBuffer;                          // Dynamically allocated SPB structure\r
 482         int mSize;                              // Its used size in bytes\r
 483         int mAlloc;                                     // Its allocated size in bytes\r
 484 \r
 485         void Grow(int needed);          // Alloc or grow the mBuffer\r
 486 \r
 487 public:\r
 488         void Insert(char);                      // Insert a single byte code\r
 489         void InsertString(char, int, const char*);      // Insert a string, len can be defined as 1 or 2 bytes\r
 490         void InsertByte(char type, char data);\r
 491         void InsertQuad(char type, int32_t data);\r
 492         void Reset();                   // Clears the SPB\r
 493         char* Self() { return mBuffer; }\r
 494         short Size() { return (short)mSize; }\r
 495 \r
 496         SPB() : mBuffer(0), mSize(0), mAlloc(0) { }\r
 497         ~SPB() { Reset(); }\r
 498 };\r
 499 \r
 500 //\r
 501 //      Database Parameter Block (used to define a database)\r
 502 //\r
 503 \r
 504 class DPB\r
 505 {\r
 506         static const int BUFFERINCR;\r
 507 \r
 508         char* mBuffer;                          // Dynamically allocated DPB structure\r
 509         int mSize;                              // Its used size in bytes\r
 510         int mAlloc;                                     // Its allocated size in bytes\r
 511 \r
 512         void Grow(int needed);          // Allocate or grow the mBuffer, so that\r
 513                                                                 // 'needed' bytes can be written (at least)\r
 514 \r
 515 public:\r
 516         void Insert(char, const char*); // Insert a new char* 'cluster'\r
 517         void Insert(char, int16_t);             // Insert a new int16_t 'cluster'\r
 518         void Insert(char, bool);                // Insert a new bool 'cluster'\r
 519         void Insert(char, char);                // Insert a new byte 'cluster'\r
 520         void Reset();                           // Clears the DPB\r
 521         char* Self() { return mBuffer; }\r
 522         short Size() { return (short)mSize; }\r
 523 \r
 524         DPB() : mBuffer(0), mSize(0), mAlloc(0) { }\r
 525         ~DPB() { Reset(); }\r
 526 };\r
 527 \r
 528 //\r
 529 //      Transaction Parameter Block (used to define a transaction)\r
 530 //\r
 531 \r
 532 class TPB\r
 533 {\r
 534         static const int BUFFERINCR;\r
 535 \r
 536         char* mBuffer;                                  // Dynamically allocated TPB structure\r
 537         int mSize;                                              // Its used size in bytes\r
 538         int mAlloc;                                             // Its allocated size\r
 539 \r
 540         void Grow(int needed);                  // Alloc or re-alloc the mBuffer\r
 541 \r
 542 public:\r
 543         void Insert(char);                              // Insert a flag item\r
 544         void Insert(const std::string& data); // Insert a string (typically table name)\r
 545         void Reset();                           // Clears the TPB\r
 546         char* Self() { return mBuffer; }\r
 547         int Size() { return mSize; }\r
 548 \r
 549         TPB() : mBuffer(0), mSize(0), mAlloc(0) { }\r
 550         ~TPB() { Reset(); }\r
 551 };\r
 552 \r
 553 //\r
 554 //      Used to receive (and process) a results buffer in various API calls\r
 555 //\r
 556 \r
 557 class RB\r
 558 {\r
 559         char* mBuffer;\r
 560         int mSize;\r
 561 \r
 562         char* FindToken(char token);\r
 563         char* FindToken(char token, char subtoken);\r
 564 \r
 565 public:\r
 566         void Reset();\r
 567         int GetValue(char token);\r
 568         int GetCountValue(char token);\r
 569         int GetValue(char token, char subtoken);\r
 570         bool GetBool(char token);\r
 571         int GetString(char token, std::string& data);\r
 572 \r
 573         char* Self() { return mBuffer; }\r
 574         short Size() { return (short)mSize; }\r
 575 \r
 576         RB();\r
 577         RB(int Size);\r
 578         ~RB();\r
 579 };\r
 580 \r
 581 //\r
 582 //      Used to receive status info from API calls\r
 583 //\r
 584 \r
 585 class IBS\r
 586 {\r
 587         mutable ISC_STATUS mVector[20];\r
 588         mutable std::string mMessage;\r
 589 \r
 590 public:\r
 591         ISC_STATUS* Self() { return mVector; }\r
 592         bool Errors() { return (mVector[0] == 1 && mVector[1] > 0) ? true : false; }\r
 593         const char* ErrorMessage() const;\r
 594         int SqlCode() const;\r
 595         int EngineCode() const { return (mVector[0] == 1) ? (int)mVector[1] : 0; }\r
 596         void Reset();\r
 597 \r
 598         IBS();\r
 599         IBS(IBS&);      // Copy Constructor\r
 600         ~IBS();\r
 601 };\r
 602 \r
 603 ///////////////////////////////////////////////////////////////////////////////\r
 604 //\r
 605 //      Implementation of the "hidden" classes associated with their public\r
 606 //      counterparts. Their private data and methods can freely change without\r
 607 //      breaking the compatibility of the DLL. If they receive new public methods,\r
 608 //      and those methods are reflected in the public class, then the compatibility\r
 609 //      is broken.\r
 610 //\r
 611 ///////////////////////////////////////////////////////////////////////////////\r
 612 \r
 613 //\r
 614 // Hidden implementation of Exception classes.\r
 615 //\r
 616 \r
 617 /*\r
 618                          std::exception\r
 619                                 |\r
 620                          IBPP::Exception\r
 621                        /                 \\r
 622                       /                   \\r
 623   IBPP::LogicException    ExceptionBase    IBPP::SQLException\r
 624         |        \         /   |     \     /\r
 625         |   LogicExceptionImpl |   SQLExceptionImpl\r
 626         |                      |\r
 627     IBPP::WrongType            |\r
 628                \               |\r
 629               IBPP::WrongTypeImpl\r
 630 */\r
 631 \r
 632 class ExceptionBase\r
 633 {\r
 634         //      (((((((( OBJECT INTERNALS ))))))))\r
 635 \r
 636 protected:\r
 637         std::string mContext;                   // Exception context ("IDatabase::Drop")\r
 638         std::string mWhat;                              // Full formatted message\r
 639 \r
 640         void buildErrorMessage(const char* message);\r
 641         void raise(const std::string& context, const char* message, va_list argptr);\r
 642 \r
 643 public:\r
 644         // The following constructors are small and could be inlined, but for object\r
 645         // code compacity of the library it is much better to have them non-inlined.\r
 646         // The amount of code generated by compilers for a throw is well-enough.\r
 647 \r
 648         ExceptionBase() throw();\r
 649         ExceptionBase(const ExceptionBase& copied) throw();\r
 650         ExceptionBase& operator=(const ExceptionBase& copied) throw();\r
 651         ExceptionBase(const std::string& context, const char* message = 0, ...) throw();\r
 652 \r
 653         virtual ~ExceptionBase() throw();\r
 654 \r
 655         //      (((((((( OBJECT INTERFACE ))))))))\r
 656 \r
 657     virtual const char* Origin() const throw();\r
 658     virtual const char* ErrorMessage() const throw();\r
 659         virtual const char* what() const throw();\r
 660 };\r
 661 \r
 662 class LogicExceptionImpl : public IBPP::LogicException, public ExceptionBase\r
 663 {\r
 664         //      (((((((( OBJECT INTERNALS ))))))))\r
 665 \r
 666 public:\r
 667         // The following constructors are small and could be inlined, but for object\r
 668         // code compacity of the library it is much better to have them non-inlined.\r
 669         // The amount of code generated by compilers for a throw is well-enough.\r
 670 \r
 671         LogicExceptionImpl() throw();\r
 672         LogicExceptionImpl(const LogicExceptionImpl& copied) throw();\r
 673         LogicExceptionImpl& operator=(const LogicExceptionImpl& copied) throw();\r
 674         LogicExceptionImpl(const std::string& context, const char* message = 0, ...) throw();\r
 675 \r
 676         virtual ~LogicExceptionImpl() throw ();\r
 677 \r
 678         //      (((((((( OBJECT INTERFACE ))))))))\r
 679         //\r
 680         //      The object public interface is partly implemented by inheriting from\r
 681         //      the ExceptionBase class.\r
 682 \r
 683 public:\r
 684     virtual const char* Origin() const throw();\r
 685     virtual const char* ErrorMessage() const throw();\r
 686         virtual const char* what() const throw();\r
 687 };\r
 688 \r
 689 class SQLExceptionImpl : public IBPP::SQLException, public ExceptionBase\r
 690 {\r
 691         //      (((((((( OBJECT INTERNALS ))))))))\r
 692 \r
 693 private:\r
 694         int mSqlCode;\r
 695         int mEngineCode;\r
 696 \r
 697 public:\r
 698         // The following constructors are small and could be inlined, but for object\r
 699         // code compacity of the library it is much better to have them non-inlined.\r
 700         // The amount of code generated by compilers for a throw is well-enough.\r
 701 \r
 702         SQLExceptionImpl() throw();\r
 703         SQLExceptionImpl(const SQLExceptionImpl& copied) throw();\r
 704         SQLExceptionImpl& operator=(const SQLExceptionImpl& copied) throw();\r
 705         SQLExceptionImpl(const IBS& status, const std::string& context,\r
 706                                                 const char* message = 0, ...) throw();\r
 707 \r
 708         virtual ~SQLExceptionImpl() throw ();\r
 709 \r
 710         //      (((((((( OBJECT INTERFACE ))))))))\r
 711         //\r
 712         //      The object public interface is partly implemented by inheriting from\r
 713         //      the ExceptionBase class.\r
 714 \r
 715 public:\r
 716     virtual const char* Origin() const throw();\r
 717     virtual const char* ErrorMessage() const throw();\r
 718         virtual const char* what() const throw();\r
 719         virtual int SqlCode() const throw();\r
 720         virtual int EngineCode() const throw();\r
 721 };\r
 722 \r
 723 class WrongTypeImpl : public IBPP::WrongType, public ExceptionBase\r
 724 {\r
 725         //      (((((((( OBJECT INTERNALS ))))))))\r
 726 \r
 727 public:\r
 728         // The following constructors are small and could be inlined, but for object\r
 729         // code compacity of the library it is much better to have them non-inlined.\r
 730         // The amount of code generated by compilers for a throw is well-enough.\r
 731 \r
 732         WrongTypeImpl() throw();\r
 733         WrongTypeImpl(const WrongTypeImpl& copied) throw();\r
 734         WrongTypeImpl& operator=(const WrongTypeImpl& copied) throw();\r
 735         WrongTypeImpl(const std::string& context, int sqlType, IITYPE varType,\r
 736                                         const char* message = 0, ...) throw();\r
 737 \r
 738         virtual ~WrongTypeImpl() throw ();\r
 739 \r
 740         //      (((((((( OBJECT INTERFACE ))))))))\r
 741         //\r
 742         //      The object public interface is partly implemented by inheriting from\r
 743         //      the ExceptionBase class.\r
 744 \r
 745 public:\r
 746     virtual const char* Origin() const throw();\r
 747     virtual const char* ErrorMessage() const throw();\r
 748         virtual const char* what() const throw();\r
 749 };\r
 750 \r
 751 class ServiceImpl : public IBPP::IService\r
 752 {\r
 753         //      (((((((( OBJECT INTERNALS ))))))))\r
 754 \r
 755 private:\r
 756         int mRefCount;                          // Reference counter\r
 757     isc_svc_handle mHandle;             // InterBase API Service Handle\r
 758         std::string mServerName;        // Nom du serveur\r
 759     std::string mUserName;              // Nom de l'utilisateur\r
 760     std::string mUserPassword;  // Mot de passe de l'utilisateur\r
 761         std::string mWaitMessage;       // Progress message returned by WaitMsg()\r
 762 \r
 763         isc_svc_handle* GetHandlePtr() { return &mHandle; }\r
 764         void SetServerName(const char*);\r
 765         void SetUserName(const char*);\r
 766         void SetUserPassword(const char*);\r
 767 \r
 768 public:\r
 769         isc_svc_handle GetHandle() { return mHandle; }\r
 770 \r
 771         ServiceImpl(const std::string& ServerName, const std::string& UserName,\r
 772                                         const std::string& UserPassword);\r
 773     ~ServiceImpl();\r
 774 \r
 775         //      (((((((( OBJECT INTERFACE ))))))))\r
 776 \r
 777 public:\r
 778     void Connect();\r
 779         bool Connected() { return mHandle == 0 ? false : true; }\r
 780         void Disconnect();\r
 781 \r
 782         void GetVersion(std::string& version);\r
 783 \r
 784         void AddUser(const IBPP::User&);\r
 785         void GetUser(IBPP::User&);\r
 786         void GetUsers(std::vector<IBPP::User>&);\r
 787         void ModifyUser(const IBPP::User&);\r
 788         void RemoveUser(const std::string& username);\r
 789 \r
 790         void SetPageBuffers(const std::string& dbfile, int buffers);\r
 791         void SetSweepInterval(const std::string& dbfile, int sweep);\r
 792         void SetSyncWrite(const std::string& dbfile, bool);\r
 793         void SetReadOnly(const std::string& dbfile, bool);\r
 794         void SetReserveSpace(const std::string& dbfile, bool);\r
 795 \r
 796         void Shutdown(const std::string& dbfile, IBPP::DSM mode, int sectimeout);\r
 797         void Restart(const std::string& dbfile);\r
 798         void Sweep(const std::string& dbfile);\r
 799         void Repair(const std::string& dbfile, IBPP::RPF flags);\r
 800 \r
 801         void StartBackup(const std::string& dbfile, const std::string& bkfile,\r
 802                 IBPP::BRF flags = IBPP::BRF(0));\r
 803         void StartRestore(const std::string& bkfile, const std::string& dbfile,\r
 804                 int pagesize, IBPP::BRF flags = IBPP::BRF(0));\r
 805 \r
 806         const char* WaitMsg();\r
 807         void Wait();\r
 808 \r
 809         IBPP::IService* AddRef();\r
 810         void Release();\r
 811 };\r
 812 \r
 813 class DatabaseImpl : public IBPP::IDatabase\r
 814 {\r
 815         //      (((((((( OBJECT INTERNALS ))))))))\r
 816 \r
 817         int mRefCount;                          // Reference counter\r
 818     isc_db_handle mHandle;              // InterBase API Session Handle\r
 819         std::string mServerName;        // Server name\r
 820     std::string mDatabaseName;  // Database name (path/file)\r
 821     std::string mUserName;              // User name\r
 822     std::string mUserPassword;  // User password\r
 823     std::string mRoleName;              // Role used for the duration of the connection\r
 824         std::string mCharSet;           // Character Set used for the connection\r
 825         std::string mCreateParams;      // Other parameters (creation only)\r
 826 \r
 827         int mDialect;                                                   // 1 if IB5, 1 or 3 if IB6/FB1\r
 828         std::vector<TransactionImpl*> mTransactions;// Table of Transaction*\r
 829         std::vector<StatementImpl*> mStatements;// Table of Statement*\r
 830         std::vector<BlobImpl*> mBlobs;                  // Table of Blob*\r
 831         std::vector<ArrayImpl*> mArrays;                // Table of Array*\r
 832         std::vector<EventsImpl*> mEvents;               // Table of Events*\r
 833 \r
 834 public:\r
 835         isc_db_handle* GetHandlePtr() { return &mHandle; }\r
 836         isc_db_handle GetHandle() { return mHandle; }\r
 837 \r
 838         void AttachTransactionImpl(TransactionImpl*);\r
 839         void DetachTransactionImpl(TransactionImpl*);\r
 840         void AttachStatementImpl(StatementImpl*);\r
 841         void DetachStatementImpl(StatementImpl*);\r
 842         void AttachBlobImpl(BlobImpl*);\r
 843         void DetachBlobImpl(BlobImpl*);\r
 844         void AttachArrayImpl(ArrayImpl*);\r
 845         void DetachArrayImpl(ArrayImpl*);\r
 846         void AttachEventsImpl(EventsImpl*);\r
 847         void DetachEventsImpl(EventsImpl*);\r
 848 \r
 849         DatabaseImpl(const std::string& ServerName, const std::string& DatabaseName,\r
 850                                 const std::string& UserName, const std::string& UserPassword,\r
 851                                 const std::string& RoleName, const std::string& CharSet,\r
 852                                 const std::string& CreateParams);\r
 853     ~DatabaseImpl();\r
 854 \r
 855         //      (((((((( OBJECT INTERFACE ))))))))\r
 856 \r
 857 public:\r
 858         const char* ServerName() const          { return mServerName.c_str(); }\r
 859         const char* DatabaseName() const        { return mDatabaseName.c_str(); }\r
 860         const char* Username() const            { return mUserName.c_str(); }\r
 861         const char* UserPassword() const        { return mUserPassword.c_str(); }\r
 862         const char* RoleName() const            { return mRoleName.c_str(); }\r
 863         const char* CharSet() const                     { return mCharSet.c_str(); }\r
 864         const char* CreateParams() const        { return mCreateParams.c_str(); }\r
 865 \r
 866         void Info(int* ODSMajor, int* ODSMinor,\r
 867                 int* PageSize, int* Pages, int* Buffers, int* Sweep,\r
 868                 bool* SyncWrites, bool* Reserve);\r
 869         void Statistics(int* Fetches, int* Marks, int* Reads, int* Writes);\r
 870         void Counts(int* Insert, int* Update, int* Delete,\r
 871                 int* ReadIdx, int* ReadSeq);\r
 872         void Users(std::vector<std::string>& users);\r
 873         int Dialect() { return mDialect; }\r
 874 \r
 875     void Create(int dialect);\r
 876         void Connect();\r
 877         bool Connected() { return mHandle == 0 ? false : true; }\r
 878         void Inactivate();\r
 879         void Disconnect();\r
 880     void Drop();\r
 881 \r
 882         IBPP::IDatabase* AddRef();\r
 883         void Release();\r
 884 };\r
 885 \r
 886 class TransactionImpl : public IBPP::ITransaction\r
 887 {\r
 888         //      (((((((( OBJECT INTERNALS ))))))))\r
 889 \r
 890 private:\r
 891         int mRefCount;                                  // Reference counter\r
 892     isc_tr_handle mHandle;                      // Transaction InterBase\r
 893 \r
 894         std::vector<DatabaseImpl*> mDatabases;          // Tableau de IDatabase*\r
 895         std::vector<StatementImpl*> mStatements;        // Tableau de IStatement*\r
 896         std::vector<BlobImpl*> mBlobs;                          // Tableau de IBlob*\r
 897         std::vector<ArrayImpl*> mArrays;                        // Tableau de Array*\r
 898         std::vector<TPB*> mTPBs;                                        // Tableau de TPB\r
 899 \r
 900         void Init();                    // A usage exclusif des constructeurs\r
 901 \r
 902 public:\r
 903         isc_tr_handle* GetHandlePtr() { return &mHandle; }\r
 904         isc_tr_handle GetHandle() { return mHandle; }\r
 905 \r
 906         void AttachStatementImpl(StatementImpl*);\r
 907         void DetachStatementImpl(StatementImpl*);\r
 908         void AttachBlobImpl(BlobImpl*);\r
 909         void DetachBlobImpl(BlobImpl*);\r
 910         void AttachArrayImpl(ArrayImpl*);\r
 911         void DetachArrayImpl(ArrayImpl*);\r
 912     void AttachDatabaseImpl(DatabaseImpl* dbi, IBPP::TAM am = IBPP::amWrite,\r
 913                         IBPP::TIL il = IBPP::ilConcurrency,\r
 914                         IBPP::TLR lr = IBPP::lrWait, IBPP::TFF flags = IBPP::TFF(0));\r
 915     void DetachDatabaseImpl(DatabaseImpl* dbi);\r
 916 \r
 917         TransactionImpl(DatabaseImpl* db, IBPP::TAM am = IBPP::amWrite,\r
 918                 IBPP::TIL il = IBPP::ilConcurrency,\r
 919                 IBPP::TLR lr = IBPP::lrWait, IBPP::TFF flags = IBPP::TFF(0));\r
 920     ~TransactionImpl();\r
 921 \r
 922         //      (((((((( OBJECT INTERFACE ))))))))\r
 923 \r
 924 public:\r
 925     void AttachDatabase(IBPP::Database db, IBPP::TAM am = IBPP::amWrite,\r
 926                         IBPP::TIL il = IBPP::ilConcurrency,\r
 927                         IBPP::TLR lr = IBPP::lrWait, IBPP::TFF flags = IBPP::TFF(0));\r
 928     void DetachDatabase(IBPP::Database db);\r
 929         void AddReservation(IBPP::Database db,\r
 930                         const std::string& table, IBPP::TTR tr);\r
 931 \r
 932     void Start();\r
 933         bool Started() { return mHandle == 0 ? false : true; }\r
 934     void Commit();\r
 935     void Rollback();\r
 936     void CommitRetain();\r
 937         void RollbackRetain();\r
 938 \r
 939         IBPP::ITransaction* AddRef();\r
 940         void Release();\r
 941 };\r
 942 \r
 943 class RowImpl : public IBPP::IRow\r
 944 {\r
 945         //      (((((((( OBJECT INTERNALS ))))))))\r
 946 \r
 947 private:\r
 948         int mRefCount;                                  // Reference counter\r
 949 \r
 950         XSQLDA* mDescrArea;                             // XSQLDA descriptor itself\r
 951         std::vector<double> mNumerics;  // Temporary storage for Numerics\r
 952         std::vector<float> mFloats;             // Temporary storage for Floats\r
 953         std::vector<int64_t> mInt64s;   // Temporary storage for 64 bits\r
 954         std::vector<int32_t> mInt32s;   // Temporary storage for 32 bits\r
 955         std::vector<int16_t> mInt16s;   // Temporary storage for 16 bits\r
 956         std::vector<char> mBools;               // Temporary storage for Bools\r
 957         std::vector<std::string> mStrings;      // Temporary storage for Strings\r
 958         std::vector<bool> mUpdated;             // Which columns where updated (Set()) ?\r
 959 \r
 960         int mDialect;                                   // Related database dialect\r
 961         DatabaseImpl* mDatabase;                // Related Database (important for Blobs, ...)\r
 962         TransactionImpl* mTransaction;  // Related Transaction (same remark)\r
 963 \r
 964         void SetValue(int, IITYPE, const void* value, int = 0);\r
 965         void* GetValue(int, IITYPE, void* = 0);\r
 966 \r
 967 public:\r
 968         void Free();\r
 969         short AllocatedSize() { return mDescrArea->sqln; }\r
 970         void Resize(int n);\r
 971         void AllocVariables();\r
 972         bool MissingValues();           // Returns wether one of the mMissing[] is true\r
 973         XSQLDA* Self() { return mDescrArea; }\r
 974 \r
 975         RowImpl& operator=(const RowImpl& copied);\r
 976         RowImpl(const RowImpl& copied);\r
 977         RowImpl(int dialect, int size, DatabaseImpl* db, TransactionImpl* tr);\r
 978     ~RowImpl();\r
 979 \r
 980         //      (((((((( OBJECT INTERFACE ))))))))\r
 981 \r
 982 public:\r
 983         void SetNull(int);\r
 984         void Set(int, bool);\r
 985         void Set(int, const char*);                             // c-strings\r
 986         void Set(int, const void*, int);                // byte buffers\r
 987         void Set(int, const std::string&);\r
 988         void Set(int, int16_t);\r
 989         void Set(int, int32_t);\r
 990         void Set(int, int64_t);\r
 991         void Set(int, float);\r
 992         void Set(int, double);\r
 993         void Set(int, const IBPP::Timestamp&);\r
 994         void Set(int, const IBPP::Date&);\r
 995         void Set(int, const IBPP::Time&);\r
 996         void Set(int, const IBPP::DBKey&);\r
 997         void Set(int, const IBPP::Blob&);\r
 998         void Set(int, const IBPP::Array&);\r
 999 \r
1000         bool IsNull(int);\r
1001         bool Get(int, bool&);\r
1002         bool Get(int, char*);           // c-strings, len unchecked\r
1003         bool Get(int, void*, int&);     // byte buffers\r
1004         bool Get(int, std::string&);\r
1005         bool Get(int, int16_t&);\r
1006         bool Get(int, int32_t&);\r
1007         bool Get(int, int64_t&);\r
1008         bool Get(int, float&);\r
1009         bool Get(int, double&);\r
1010         bool Get(int, IBPP::Timestamp&);\r
1011         bool Get(int, IBPP::Date&);\r
1012         bool Get(int, IBPP::Time&);\r
1013         bool Get(int, IBPP::DBKey&);\r
1014         bool Get(int, IBPP::Blob&);\r
1015         bool Get(int, IBPP::Array&);\r
1016 \r
1017         bool IsNull(const std::string&);\r
1018         bool Get(const std::string&, bool&);\r
1019         bool Get(const std::string&, char*);    // c-strings, len unchecked\r
1020         bool Get(const std::string&, void*, int&);      // byte buffers\r
1021         bool Get(const std::string&, std::string&);\r
1022         bool Get(const std::string&, int16_t&);\r
1023         bool Get(const std::string&, int32_t&);\r
1024         bool Get(const std::string&, int64_t&);\r
1025         bool Get(const std::string&, float&);\r
1026         bool Get(const std::string&, double&);\r
1027         bool Get(const std::string&, IBPP::Timestamp&);\r
1028         bool Get(const std::string&, IBPP::Date&);\r
1029         bool Get(const std::string&, IBPP::Time&);\r
1030         bool Get(const std::string&, IBPP::DBKey&);\r
1031         bool Get(const std::string&, IBPP::Blob&);\r
1032         bool Get(const std::string&, IBPP::Array&);\r
1033 \r
1034         int ColumnNum(const std::string&);\r
1035         const char* ColumnName(int);\r
1036         const char* ColumnAlias(int);\r
1037         const char* ColumnTable(int);\r
1038         IBPP::SDT ColumnType(int);\r
1039         int ColumnSubtype(int);\r
1040         int ColumnSize(int);\r
1041         int ColumnScale(int);\r
1042         int Columns();\r
1043 \r
1044         bool ColumnUpdated(int);\r
1045         bool Updated();\r
1046 \r
1047         IBPP::Database DatabasePtr() const;\r
1048         IBPP::Transaction TransactionPtr() const;\r
1049 \r
1050         IBPP::IRow* Clone();\r
1051         IBPP::IRow* AddRef();\r
1052         void Release();\r
1053 };\r
1054 \r
1055 class StatementImpl : public IBPP::IStatement\r
1056 {\r
1057         //      (((((((( OBJECT INTERNALS ))))))))\r
1058 \r
1059 private:\r
1060         friend class TransactionImpl;\r
1061 \r
1062         int mRefCount;                          // Reference counter\r
1063         isc_stmt_handle mHandle;        // Statement Handle\r
1064 \r
1065         DatabaseImpl* mDatabase;                // Attached database\r
1066         TransactionImpl* mTransaction;  // Attached transaction\r
1067         RowImpl* mInRow;\r
1068         //bool* mInMissing;                     // Quels paramètres n'ont pas été spécifiés\r
1069         RowImpl* mOutRow;\r
1070         bool mResultSetAvailable;       // Executed and result set is available\r
1071         bool mCursorOpened;                     // dsql_set_cursor_name was called\r
1072         IBPP::STT mType;                        // Type de requète\r
1073         std::string mSql;                       // Last SQL statement prepared or executed\r
1074 \r
1075         // Internal Methods\r
1076         void CursorFree();\r
1077 \r
1078 public:\r
1079         // Properties and Attributes Access Methods\r
1080         isc_stmt_handle GetHandle() { return mHandle; }\r
1081 \r
1082         void AttachDatabaseImpl(DatabaseImpl*);\r
1083         void DetachDatabaseImpl();\r
1084         void AttachTransactionImpl(TransactionImpl*);\r
1085         void DetachTransactionImpl();\r
1086 \r
1087         StatementImpl(DatabaseImpl*, TransactionImpl*, const std::string&);\r
1088     ~StatementImpl();\r
1089 \r
1090         //      (((((((( OBJECT INTERFACE ))))))))\r
1091 \r
1092 public:\r
1093         void Prepare(const std::string& sql);\r
1094         void Execute(const std::string& sql);\r
1095         inline void Execute()   { Execute(std::string()); }\r
1096         void ExecuteImmediate(const std::string&);\r
1097         void CursorExecute(const std::string& cursor, const std::string& sql);\r
1098         inline void CursorExecute(const std::string& cursor)    { CursorExecute(cursor, std::string()); }\r
1099         bool Fetch();\r
1100         bool Fetch(IBPP::Row&);\r
1101         int AffectedRows();\r
1102         void Close();   // Free resources, attachments maintained\r
1103         std::string& Sql() { return mSql; }\r
1104         IBPP::STT Type() { return mType; }\r
1105 \r
1106         void SetNull(int);\r
1107         void Set(int, bool);\r
1108         void Set(int, const char*);                             // c-strings\r
1109         void Set(int, const void*, int);                // byte buffers\r
1110         void Set(int, const std::string&);\r
1111         void Set(int, int16_t);\r
1112         void Set(int, int32_t);\r
1113         void Set(int, int64_t);\r
1114         void Set(int, float);\r
1115         void Set(int, double);\r
1116         void Set(int, const IBPP::Timestamp&);\r
1117         void Set(int, const IBPP::Date&);\r
1118         void Set(int, const IBPP::Time&);\r
1119         void Set(int, const IBPP::DBKey&);\r
1120         void Set(int, const IBPP::Blob&);\r
1121         void Set(int, const IBPP::Array&);\r
1122 \r
1123         bool IsNull(int);\r
1124         bool Get(int, bool*);\r
1125         bool Get(int, bool&);\r
1126         bool Get(int, char*);                           // c-strings, len unchecked\r
1127         bool Get(int, void*, int&);                     // byte buffers\r
1128         bool Get(int, std::string&);\r
1129         bool Get(int, int16_t*);\r
1130         bool Get(int, int16_t&);\r
1131         bool Get(int, int32_t*);\r
1132         bool Get(int, int32_t&);\r
1133         bool Get(int, int64_t*);\r
1134         bool Get(int, int64_t&);\r
1135         bool Get(int, float*);\r
1136         bool Get(int, float&);\r
1137         bool Get(int, double*);\r
1138         bool Get(int, double&);\r
1139         bool Get(int, IBPP::Timestamp&);\r
1140         bool Get(int, IBPP::Date&);\r
1141         bool Get(int, IBPP::Time&);\r
1142         bool Get(int, IBPP::DBKey&);\r
1143         bool Get(int, IBPP::Blob&);\r
1144         bool Get(int, IBPP::Array&);\r
1145 \r
1146         bool IsNull(const std::string&);\r
1147         bool Get(const std::string&, bool*);\r
1148         bool Get(const std::string&, bool&);\r
1149         bool Get(const std::string&, char*);            // c-strings, len unchecked\r
1150         bool Get(const std::string&, void*, int&);      // byte buffers\r
1151         bool Get(const std::string&, std::string&);\r
1152         bool Get(const std::string&, int16_t*);\r
1153         bool Get(const std::string&, int16_t&);\r
1154         bool Get(const std::string&, int32_t*);\r
1155         bool Get(const std::string&, int32_t&);\r
1156         bool Get(const std::string&, int64_t*);\r
1157         bool Get(const std::string&, int64_t&);\r
1158         bool Get(const std::string&, float*);\r
1159         bool Get(const std::string&, float&);\r
1160         bool Get(const std::string&, double*);\r
1161         bool Get(const std::string&, double&);\r
1162         bool Get(const std::string&, IBPP::Timestamp&);\r
1163         bool Get(const std::string&, IBPP::Date&);\r
1164         bool Get(const std::string&, IBPP::Time&);\r
1165         bool Get(const std::string&, IBPP::DBKey&);\r
1166         bool Get(const std::string&, IBPP::Blob&);\r
1167         bool Get(const std::string&, IBPP::Array&);\r
1168 \r
1169         int ColumnNum(const std::string&);\r
1170     int ColumnNumAlias(const std::string&);\r
1171         const char* ColumnName(int);\r
1172         const char* ColumnAlias(int);\r
1173         const char* ColumnTable(int);\r
1174         IBPP::SDT ColumnType(int);\r
1175         int ColumnSubtype(int);\r
1176         int ColumnSize(int);\r
1177         int ColumnScale(int);\r
1178         int Columns();\r
1179 \r
1180         IBPP::SDT ParameterType(int);\r
1181         int ParameterSubtype(int);\r
1182         int ParameterSize(int);\r
1183         int ParameterScale(int);\r
1184         int Parameters();\r
1185 \r
1186         void Plan(std::string&);\r
1187 \r
1188         IBPP::Database DatabasePtr() const;\r
1189         IBPP::Transaction TransactionPtr() const;\r
1190 \r
1191         IBPP::IStatement* AddRef();\r
1192         void Release();\r
1193 };\r
1194 \r
1195 class BlobImpl : public IBPP::IBlob\r
1196 {\r
1197         //      (((((((( OBJECT INTERNALS ))))))))\r
1198 \r
1199 private:\r
1200         friend class RowImpl;\r
1201 \r
1202         int mRefCount;\r
1203         bool                                    mIdAssigned;\r
1204         ISC_QUAD                                mId;\r
1205         isc_blob_handle                 mHandle;\r
1206         bool                                    mWriteMode;\r
1207         DatabaseImpl*                   mDatabase;              // Belongs to this database\r
1208         TransactionImpl*                mTransaction;   // Belongs to this transaction\r
1209 \r
1210         void Init();\r
1211         void SetId(ISC_QUAD*);\r
1212         void GetId(ISC_QUAD*);\r
1213 \r
1214 public:\r
1215         void AttachDatabaseImpl(DatabaseImpl*);\r
1216         void DetachDatabaseImpl();\r
1217         void AttachTransactionImpl(TransactionImpl*);\r
1218         void DetachTransactionImpl();\r
1219 \r
1220         BlobImpl(const BlobImpl&);\r
1221         BlobImpl(DatabaseImpl*, TransactionImpl* = 0);\r
1222         ~BlobImpl();\r
1223 \r
1224         //      (((((((( OBJECT INTERFACE ))))))))\r
1225 \r
1226 public:\r
1227         void Create();\r
1228         void Open();\r
1229         void Close();\r
1230         void Cancel();\r
1231         int Read(void*, int size);\r
1232         void Write(const void*, int size);\r
1233         void Info(int* Size, int* Largest, int* Segments);\r
1234 \r
1235         void Save(const std::string& data);\r
1236         void Load(std::string& data);\r
1237 \r
1238         IBPP::Database DatabasePtr() const;\r
1239         IBPP::Transaction TransactionPtr() const;\r
1240 \r
1241         IBPP::IBlob* AddRef();\r
1242         void Release();\r
1243 };\r
1244 \r
1245 class ArrayImpl : public IBPP::IArray\r
1246 {\r
1247         //      (((((((( OBJECT INTERNALS ))))))))\r
1248 \r
1249 private:\r
1250         friend class RowImpl;\r
1251 \r
1252         int                                     mRefCount;              // Reference counter\r
1253         bool                            mIdAssigned;\r
1254         ISC_QUAD                        mId;\r
1255         bool                            mDescribed;\r
1256         ISC_ARRAY_DESC          mDesc;\r
1257         DatabaseImpl*           mDatabase;              // Database attachée\r
1258         TransactionImpl*        mTransaction;   // Transaction attachée\r
1259         void*                           mBuffer;                // Buffer for native data\r
1260         int                                     mBufferSize;    // Size of this buffer in bytes\r
1261         int                                     mElemCount;             // Count of elements in this array\r
1262         int                                     mElemSize;              // Size of an element in the buffer\r
1263 \r
1264         void Init();\r
1265         void SetId(ISC_QUAD*);\r
1266         void GetId(ISC_QUAD*);\r
1267         void ResetId();\r
1268         void AllocArrayBuffer();\r
1269 \r
1270 public:\r
1271         void AttachDatabaseImpl(DatabaseImpl*);\r
1272         void DetachDatabaseImpl();\r
1273         void AttachTransactionImpl(TransactionImpl*);\r
1274         void DetachTransactionImpl();\r
1275 \r
1276         ArrayImpl(const ArrayImpl&);\r
1277         ArrayImpl(DatabaseImpl*, TransactionImpl* = 0);\r
1278         ~ArrayImpl();\r
1279 \r
1280         //      (((((((( OBJECT INTERFACE ))))))))\r
1281 \r
1282 public:\r
1283         void Describe(const std::string& table, const std::string& column);\r
1284         void ReadTo(IBPP::ADT, void*, int);\r
1285         void WriteFrom(IBPP::ADT, const void*, int);\r
1286         IBPP::SDT ElementType();\r
1287         int ElementSize();\r
1288         int ElementScale();\r
1289         int Dimensions();\r
1290         void Bounds(int dim, int* low, int* high);\r
1291         void SetBounds(int dim, int low, int high);\r
1292 \r
1293         IBPP::Database DatabasePtr() const;\r
1294         IBPP::Transaction TransactionPtr() const;\r
1295 \r
1296         IBPP::IArray* AddRef();\r
1297         void Release();\r
1298 };\r
1299 \r
1300 //\r
1301 //      EventBufferIterator: used in EventsImpl implementation.\r
1302 //\r
1303 \r
1304 template<class It>\r
1305 struct EventBufferIterator\r
1306 {\r
1307         It mIt;\r
1308 \r
1309 public:\r
1310         EventBufferIterator& operator++()\r
1311                 { mIt += 1 + static_cast<int>(*mIt) + 4; return *this; }\r
1312 \r
1313         bool operator == (const EventBufferIterator& i) const { return i.mIt == mIt; }\r
1314         bool operator != (const EventBufferIterator& i) const { return i.mIt != mIt; }\r
1315 \r
1316 #ifdef __BCPLUSPLUS__\r
1317 #pragma warn -8027\r
1318 #endif\r
1319         std::string get_name() const\r
1320         {\r
1321                 return std::string(mIt + 1, mIt + 1 + static_cast<int32_t>(*mIt));\r
1322         }\r
1323 #ifdef __BCPLUSPLUS__\r
1324 #pragma warn .8027\r
1325 #endif\r
1326 \r
1327         uint32_t get_count() const\r
1328         {\r
1329                 return (*gds.Call()->m_vax_integer)\r
1330                         (const_cast<char*>(&*(mIt + 1 + static_cast<int>(*mIt))), 4);\r
1331         }\r
1332 \r
1333         // Those container like begin() and end() allow access to the underlying type\r
1334         It begin()      { return mIt; }\r
1335         It end()        { return mIt + 1 + static_cast<int>(*mIt) + 4; }\r
1336 \r
1337         EventBufferIterator() {}\r
1338         EventBufferIterator(It it) : mIt(it) {}\r
1339 };\r
1340 \r
1341 class EventsImpl : public IBPP::IEvents\r
1342 {\r
1343         static const size_t MAXEVENTNAMELEN;\r
1344         static void EventHandler(const char*, short, const char*);\r
1345 \r
1346         typedef std::vector<IBPP::EventInterface*> ObjRefs;\r
1347         ObjRefs mObjectReferences;\r
1348 \r
1349         typedef std::vector<char> Buffer;\r
1350         Buffer mEventBuffer;\r
1351         Buffer mResultsBuffer;\r
1352 \r
1353         int mRefCount;          // Reference counter\r
1354 \r
1355         DatabaseImpl* mDatabase;\r
1356         ISC_LONG mId;                   // Firebird internal Id of these events\r
1357         bool mQueued;                   // Has isc_que_events() been called?\r
1358         bool mTrapped;                  // EventHandled() was called since last que_events()\r
1359 \r
1360         void FireActions();\r
1361         void Queue();\r
1362         void Cancel();\r
1363 \r
1364         EventsImpl& operator=(const EventsImpl&);\r
1365         EventsImpl(const EventsImpl&);\r
1366 \r
1367 public:\r
1368         void AttachDatabaseImpl(DatabaseImpl*);\r
1369         void DetachDatabaseImpl();\r
1370         \r
1371         EventsImpl(DatabaseImpl* dbi);\r
1372         ~EventsImpl();\r
1373                 \r
1374         //      (((((((( OBJECT INTERFACE ))))))))\r
1375 \r
1376 public:\r
1377         void Add(const std::string&, IBPP::EventInterface*);\r
1378         void Drop(const std::string&);\r
1379         void List(std::vector<std::string>&);\r
1380         void Clear();                           // Drop all events\r
1381         void Dispatch();                        // Dispatch NON async events\r
1382 \r
1383         IBPP::Database DatabasePtr() const;\r
1384 \r
1385         IBPP::IEvents* AddRef();\r
1386         void Release();\r
1387 };\r
1388 \r
1389 void encodeDate(ISC_DATE& isc_dt, const IBPP::Date& dt);\r
1390 void decodeDate(IBPP::Date& dt, const ISC_DATE& isc_dt);\r
1391 \r
1392 void encodeTime(ISC_TIME& isc_tm, const IBPP::Time& tm);\r
1393 void decodeTime(IBPP::Time& tm, const ISC_TIME& isc_tm);\r
1394 \r
1395 void encodeTimestamp(ISC_TIMESTAMP& isc_ts, const IBPP::Timestamp& ts);\r
1396 void decodeTimestamp(IBPP::Timestamp& ts, const ISC_TIMESTAMP& isc_ts);\r
1397 \r
1398 struct consts   // See _ibpp.cpp for initializations of these constants\r
1399 {\r
1400         static const double dscales[19];\r
1401         static const int Dec31_1899;\r
1402         static const int16_t min16;\r
1403         static const int16_t max16;\r
1404         static const int32_t min32;\r
1405         static const int32_t max32;\r
1406 };\r
1407 \r
1408 }       // namespace ibpp_internal\r
1409 \r
1410 #endif // __INTERNAL_IBPP_H__\r
1411 \r
1412 //\r
1413 //      Eof\r
1414 //\r