src/odbc/odbcDbc.cxx

   1 /*  Class CSqlOdbcDbc
   2     Description: Connection Handle manager.
   3
   4     ODBC API's:
   5                 CSqlOdbcDbc::SQLAllocDbc();
   6                 CSqlOdbcDbc::SQLFreeDbc();
   7                 CSqlOdbcDbc::SQLConnect();
   8 */
   9
  10 #include "odbcCommon.h"
  11
  12 // Constructor
  13 CSqlOdbcDbc::CSqlOdbcDbc( void ) :
  14         handleType_( SQL_HANDLE_DBC ),
  15         parentEnv_( 0 ),
  16         state_( C1 ),
  17         err_( SQL_HANDLE_DBC ),
  18         mode_ (1),
  19         curAccessMode_( ACCESSMODE_READ_WRITE ),
  20         curIsolationLevel_( READ_REPEATABLE ),
  21         accessMode_( ACCESSMODE_READ_WRITE ),
  22         isolationLevel_( READ_COMMITTED ),
  23         autoCommit_( SQL_AUTOCOMMIT_ON )
  24 {}
  25
  26 SQLRETURN SQLAllocConnect(
  27     SQLHENV EnvironmentHandle,
  28     SQLHDBC *ConnectionHandle)
  29 {
  30     return( CSqlOdbcDbc::SQLAllocHandle( EnvironmentHandle, ConnectionHandle ) );
  31 }
  32
  33 // All ODBC API's below.
  34 SQLRETURN CSqlOdbcDbc::SQLAllocHandle(
  35     SQLHANDLE   inputHandle,    // IN
  36     SQLHANDLE   *outputHandle ) // OUT
  37 {
  38
  39     CSqlOdbcEnv *inputEnv = (CSqlOdbcEnv*) inputHandle;
  40
  41     if( isValidHandle( inputEnv, SQL_HANDLE_ENV ) != SQL_SUCCESS )
  42         return( SQL_INVALID_HANDLE );
  43
  44     // Stop if odbcVersion not set.
  45     if( inputEnv->odbcVersion_ == 0 )
  46     {
  47         inputEnv->err_.set( ERROR_FUNCSEQ );
  48         return( SQL_ERROR );
  49     }
  50
  51     // Allocate Connection object.
  52     *outputHandle = (SQLHANDLE*) new CSqlOdbcDbc;
  53     if( *outputHandle == NULL )
  54     {
  55         globalError.set( ERROR_MEMALLOC );
  56         globalError.printStr( SQL_OV_ODBC3 );
  57         return( SQL_ERROR );
  58     }
  59
  60     // Initialize relation b/w Env and Dbc
  61     inputEnv->dbcList_.insert( inputEnv->dbcList_.begin(), (CSqlOdbcDbc*) *outputHandle );
  62     inputEnv->state_ = E2;
  63     ((CSqlOdbcDbc*) *outputHandle)->parentEnv_ = inputEnv;
  64     ((CSqlOdbcDbc*) *outputHandle)->state_ = C2;
  65
  66     return( SQL_SUCCESS );
  67 }
  68
  69 SQLRETURN SQLFreeConnect(
  70     SQLHDBC ConnectionHandle)
  71 {
  72     return( CSqlOdbcDbc::SQLFreeHandle( ConnectionHandle ) );
  73 }
  74
  75 SQLRETURN CSqlOdbcDbc::SQLFreeHandle(
  76     SQLHANDLE inputHandle)      // IN
  77 {
  78     CSqlOdbcDbc *inputDbc = (CSqlOdbcDbc*) inputHandle;
  79
  80     // Validate handle
  81     if( isValidHandle( inputDbc, SQL_HANDLE_DBC ) != SQL_SUCCESS )
  82         return( SQL_INVALID_HANDLE );
  83
  84     // Check whether we can proceed.
  85     if( inputDbc->chkStateForSQLFreeHandle() != SQL_SUCCESS )
  86         return( SQL_ERROR );
  87
  88     // Remove Dbc from Parent Env.
  89     std::vector<CSqlOdbcDbc*>::iterator iter;
  90     iter = inputDbc->parentEnv_->dbcList_.begin();
  91     while( iter != inputDbc->parentEnv_->dbcList_.end() )
  92     {
  93         if( *iter == inputDbc )
  94         {
  95             inputDbc->parentEnv_->dbcList_.erase( iter );
  96             break;
  97         }
  98         iter++;
  99     }
 100     if( inputDbc->parentEnv_->dbcList_.size() == 0 )
 101         inputDbc->parentEnv_->state_ = E1;
 102
 103     inputDbc->handleType_ = -1; // Make object invalid.
 104     delete inputDbc;            // Delete Dbc.
 105
 106     return( SQL_SUCCESS );
 107 }
 108
 109 SQLRETURN SQLDriverConnect(
 110      SQLHDBC     ConnectionHandle,
 111      SQLHWND     WindowHandle,
 112      SQLCHAR *     InConnectionString,
 113      SQLSMALLINT     StringLength1,
 114      SQLCHAR *     OutConnectionString,
 115      SQLSMALLINT     BufferLength,
 116      SQLSMALLINT *     StringLength2Ptr,
 117      SQLUSMALLINT     DriverCompletion)
 118 {
 119     printf("Connection string is %s\n", InConnectionString);
 120     // Validate handle
 121     if( isValidHandle( ConnectionHandle, SQL_HANDLE_DBC ) != SQL_SUCCESS )
 122                  return( SQL_INVALID_HANDLE );
 123
 124     return( ((CSqlOdbcDbc*) ConnectionHandle)->SQLConnect((SQLCHAR*)"a",
 125                       (SQLSMALLINT)strlen("a"), (SQLCHAR*)"root", (SQLSMALLINT)strlen("root"),
 126                       (SQLCHAR*)"manager", (SQLSMALLINT)strlen("manager")) );
 127
 128 }
 129
 130 SQLRETURN SQLConnect(           // All param's are IN
 131     SQLHDBC ConnectionHandle,
 132     SQLCHAR *ServerName,
 133     SQLSMALLINT NameLength1,
 134     SQLCHAR *UserName,
 135     SQLSMALLINT NameLength2,
 136     SQLCHAR *Authentication,
 137     SQLSMALLINT NameLength3)
 138 {
 139     // Validate handle
 140     if( isValidHandle( ConnectionHandle, SQL_HANDLE_DBC ) != SQL_SUCCESS )
 141         return( SQL_INVALID_HANDLE );
 142
 143     return( ((CSqlOdbcDbc*) ConnectionHandle)->SQLConnect( ServerName, NameLength1,
 144         UserName, NameLength2, Authentication, NameLength3) );
 145 }
 146
 147 SQLRETURN CSqlOdbcDbc::SQLConnect(           // All param's are IN
 148     SQLCHAR *serverName,
 149     SQLSMALLINT len1,
 150     SQLCHAR *user,
 151     SQLSMALLINT len2,
 152     SQLCHAR *pass,
 153     SQLSMALLINT len3)
 154 {
 155     int rc;
 156     char *hostName,*portNo;
 157     // Start with NO_ERR
 158     err_.set( NO_ERR );
 159
 160     // Can we proceed ?
 161     if( chkStateForSQLConnect() != SQL_SUCCESS )
 162         return( SQL_ERROR );
 163
 164     // Invalid Buffer Length.
 165     if( (len1 < 0 && len1 != SQL_NTS) || (len2 < 0 && len2 != SQL_NTS) || (len2 < 0 && len2 != SQL_NTS) )
 166     {
 167         err_.set( ERROR_BUFLEN );
 168         return( SQL_ERROR );
 169     }
 170     if (fsqlConn_ != NULL)
 171     {
 172         err_.set( ERROR_CONNINUSE);
 173         return ( SQL_ERROR );
 174     }
 175     if (strcasecmp((char*)serverName, "gateway") == 0)
 176     {
 177         fsqlConn_ = SqlFactory::createConnection(CSqlGateway);
 178         mode_ = 2;
 179     }else if (strcasecmp((char*)serverName, "adapter") == 0){
 180         fsqlConn_ = SqlFactory::createConnection(CSqlAdapter);
 181         mode_ = 3;
 182     }else{
 183         fsqlConn_ = SqlFactory::createConnection(CSql);
 184         mode_ = 1;
 185     }
 186
 187     rc = fsqlConn_->connect( (char*) user, (char*) pass );
 188     if( rc != OK )
 189     {
 190         err_.set( ERROR_CONNREJCTD);
 191         return( SQL_ERROR );
 192     }
 193     rc = fsqlConn_->beginTrans( isolationLevel_ );
 194     if( rc != OK )
 195     {
 196         err_.set( ERROR_INVTRANSTATE );
 197         return( SQL_ERROR );
 198     }
 199     curAccessMode_ = accessMode_;
 200     curIsolationLevel_ = isolationLevel_;
 201
 202     // Update Dbc state
 203     state_ = C4;
 204
 205     return( SQL_SUCCESS );
 206 }
 207
 208 SQLRETURN SQLDisconnect(
 209     SQLHDBC ConnectionHandle)   // IN
 210 {
 211     // Validate Handle
 212     if( isValidHandle( ConnectionHandle, SQL_HANDLE_DBC ) != SQL_SUCCESS )
 213         return( SQL_INVALID_HANDLE );
 214     SQLRETURN ret = ( ((CSqlOdbcDbc*) ConnectionHandle)->SQLDisconnect() );
 215     return ret;
 216 }
 217
 218 SQLRETURN CSqlOdbcDbc::SQLDisconnect( void )
 219 {
 220     SQLRETURN rc;
 221
 222     // Start with NO_ERR
 223     err_.set( NO_ERR );
 224
 225     // Can we proceed ?
 226     if( chkStateForSQLDisconnect() != SQL_SUCCESS )
 227         return( SQL_ERROR );
 228
 229     // Free all stmts
 230     while( stmtList_.size() != 0 )
 231     {
 232         rc = CSqlOdbcStmt::SQLFreeHandle( stmtList_[0] );
 233         // This free's the stmt and removes element from stmtList_.
 234         if( rc != OK )
 235             return( SQL_ERROR );
 236     }
 237
 238     // Commit the transaction
 239     if( fsqlConn_->commit() != OK )
 240         return( SQL_ERROR );
 241
 242     // Disconnect
 243     if( fsqlConn_->disconnect() != OK )
 244         return( SQL_ERROR );
 245
 246     delete fsqlConn_;
 247     fsqlConn_ = NULL;
 248     // Change the state of Dbc
 249     state_ = C2;
 250
 251     return( SQL_SUCCESS );
 252 }
 253
 254 SQLRETURN CSqlOdbcDbc::SQLEndTran(
 255     SQLSMALLINT completionType) // IN
 256 {
 257     SQLRETURN rc;
 258
 259     // Start with NO_ERR
 260     err_.set( NO_ERR );
 261
 262     // Can we proceed ?
 263     if( chkStateForSQLEndTran() != SQL_SUCCESS )
 264         return( SQL_ERROR );
 265
 266     // Stop if no transaction is started.
 267     if( state_ != C6 )
 268         return( SQL_SUCCESS );
 269
 270     // Close cursors of all the statements
 271     std::vector<CSqlOdbcStmt*>::iterator iter;
 272     iter = stmtList_.begin();
 273     while( iter != stmtList_.end() )
 274     {
 275         (*iter)->SQLFreeHandle( SQL_CLOSE );
 276         iter++;
 277     }
 278
 279     // Finish transaction
 280     switch( completionType )
 281     {
 282         case SQL_COMMIT:
 283
 284                     if( fsqlConn_->commit() != OK )
 285                         return( SQL_ERROR );
 286
 287                     if( fsqlConn_->beginTrans( curIsolationLevel_ ) != OK )
 288                         return( SQL_ERROR );
 289
 290                     break;
 291
 292         case SQL_ROLLBACK:
 293                     if( fsqlConn_->rollback() != OK )
 294                         return( SQL_ERROR );
 295
 296                     rc = fsqlConn_->beginTrans( curIsolationLevel_ );
 297                     break;
 298
 299         default:    err_.set( ERROR_OPTRANGE );
 300                     return( SQL_ERROR );
 301     }
 302
 303     // Had statements ?
 304     if( stmtList_.size() == 0 )
 305         state_ = C4;
 306     else
 307         state_ = C5;
 308
 309     return( SQL_SUCCESS );
 310 }
 311
 312 SQLRETURN SQLSetConnectOption(
 313     SQLHDBC ConnectionHandle,
 314     SQLUSMALLINT Option,
 315     SQLUINTEGER Value)
 316 {
 317     return( SQLSetConnectAttr( ConnectionHandle, Option, (SQLPOINTER) Value, 0) );
 318 }
 319
 320 SQLRETURN SQLSetConnectAttr(
 321     SQLHDBC ConnectionHandle,
 322     SQLINTEGER Attribute,
 323     SQLPOINTER Value,
 324     SQLINTEGER StringLength)
 325 {
 326    // Validate handle
 327    if( isValidHandle( ConnectionHandle, SQL_HANDLE_DBC ) != SQL_SUCCESS )
 328         return( SQL_INVALID_HANDLE );
 329
 330    return( ((CSqlOdbcDbc*)ConnectionHandle)->SQLSetConnectAttr( Attribute, Value, StringLength ) );
 331 }
 332
 333 SQLRETURN CSqlOdbcDbc::SQLSetConnectAttr(
 334     SQLINTEGER attribute,
 335     SQLPOINTER value,
 336     SQLINTEGER stringLength)
 337 {
 338     // Start with NO_ERR
 339     err_.set( NO_ERR );
 340
 341     switch( attribute )
 342     {
 343         case SQL_ATTR_ACCESS_MODE:
 344             // validate 'value'
 345             if( (SQLUINTEGER) value == SQL_MODE_READ_ONLY )
 346                 accessMode_ = ACCESSMODE_READ_ONLY;
 347             else if( (SQLUINTEGER) value == SQL_MODE_READ_WRITE )
 348                 accessMode_ = ACCESSMODE_READ_WRITE;
 349             else
 350                 return( SQL_ERROR );
 351
 352             break;
 353         case SQL_DEFAULT_TXN_ISOLATION:
 354         case SQL_ATTR_TXN_ISOLATION:
 355             // validate 'value'
 356             if( (SQLUINTEGER) value == SQL_TXN_READ_UNCOMMITTED )
 357                 isolationLevel_ = READ_UNCOMMITTED;
 358             else if( (SQLUINTEGER) value == SQL_TXN_READ_COMMITTED )
 359                 isolationLevel_ = READ_COMMITTED;
 360             else if( (SQLUINTEGER) value == SQL_TXN_REPEATABLE_READ )
 361                 isolationLevel_ = READ_REPEATABLE;
 362 //            else if( (SQLUINTEGER) value == SQL_TXN_SERIALIZABLE )
 363 //                isolationLevel_ = SERIALIZABLE;
 364             else
 365                 return( SQL_ERROR );
 366
 367             break;
 368         case SQL_ATTR_AUTOCOMMIT:
 369             autoCommit_ = (SQLUINTEGER) value;
 370             if( state_ == C6 )
 371                 SQLEndTran( SQL_COMMIT );
 372             break;
 373
 374         default: err_.set( ERROR_OPTRANGE );
 375                  return( SQL_ERROR );
 376     }
 377
 378     return( SQL_SUCCESS );
 379 }
 380
 381 SQLRETURN SQLGetConnectOption(
 382     SQLHDBC ConnectionHandle,
 383     SQLUSMALLINT Option,
 384     SQLPOINTER Value)
 385 {
 386     return( SQLGetConnectAttr( ConnectionHandle, Option, Value, 0, 0) );
 387 }
 388
 389 SQLRETURN SQLGetConnectAttr(
 390     SQLHDBC ConnectionHandle,
 391     SQLINTEGER Attribute,
 392     SQLPOINTER Value,
 393     SQLINTEGER BufferLength,
 394     SQLINTEGER *StringLength)
 395 {
 396    // Validate handle
 397    if( isValidHandle( ConnectionHandle, SQL_HANDLE_DBC ) != SQL_SUCCESS )
 398         return( SQL_INVALID_HANDLE );
 399
 400    return( ((CSqlOdbcDbc*)ConnectionHandle)->SQLGetConnectAttr( Attribute, Value, BufferLength, StringLength ) );
 401 }
 402
 403 SQLRETURN CSqlOdbcDbc::SQLGetConnectAttr(
 404     SQLINTEGER attribute,
 405     SQLPOINTER value,
 406     SQLINTEGER bufferLength,
 407     SQLINTEGER *stringLength)
 408 {
 409     // Start with NO_ERR
 410     err_.set( NO_ERR );
 411
 412     switch( attribute )
 413     {
 414         case SQL_ATTR_ACCESS_MODE:
 415             // Get ODBC Access Mode
 416             if( accessMode_ == ACCESSMODE_READ_ONLY )
 417                 *((SQLUINTEGER*) value) = SQL_MODE_READ_ONLY;
 418             else if( accessMode_ == ACCESSMODE_READ_WRITE )
 419                 *((SQLUINTEGER*) value) = SQL_MODE_READ_WRITE;
 420             else
 421                 return( SQL_ERROR );
 422
 423             break;
 424         case SQL_DEFAULT_TXN_ISOLATION:
 425         case SQL_ATTR_TXN_ISOLATION:
 426             // validate 'value'
 427             if( (SQLUINTEGER) isolationLevel_ == READ_UNCOMMITTED )
 428                 *((SQLUINTEGER*) value) = SQL_TXN_READ_UNCOMMITTED;
 429             else if( (SQLUINTEGER) isolationLevel_ == READ_COMMITTED )
 430                 *((SQLUINTEGER*) value) = SQL_TXN_READ_COMMITTED;
 431             else if( (SQLUINTEGER) isolationLevel_ == READ_REPEATABLE )
 432                 *((SQLUINTEGER*) value) = SQL_TXN_REPEATABLE_READ;
 433 //            else if( (SQLUINTEGER) isolationLevel_ == SERIALIZABLE )
 434 //                *((SQLUINTEGER*) value) = SQL_TXN_SERIALIZABLE;
 435             else
 436                 return( SQL_ERROR );
 437
 438             break;
 439         case SQL_ATTR_AUTOCOMMIT:
 440             *((SQLUINTEGER*) value) = autoCommit_;
 441             break;
 442
 443         default: err_.set( ERROR_OPTRANGE );
 444                  return( SQL_ERROR );
 445     }
 446
 447     return( SQL_SUCCESS );
 448 }