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     // Change the state of Dbc
 248     state_ = C2;
 249
 250     return( SQL_SUCCESS );
 251 }
 252
 253 SQLRETURN CSqlOdbcDbc::SQLEndTran(
 254     SQLSMALLINT completionType) // IN
 255 {
 256     SQLRETURN rc;
 257
 258     // Start with NO_ERR
 259     err_.set( NO_ERR );
 260
 261     // Can we proceed ?
 262     if( chkStateForSQLEndTran() != SQL_SUCCESS )
 263         return( SQL_ERROR );
 264
 265     // Stop if no transaction is started.
 266     if( state_ != C6 )
 267         return( SQL_SUCCESS );
 268
 269     // Close cursors of all the statements
 270     std::vector<CSqlOdbcStmt*>::iterator iter;
 271     iter = stmtList_.begin();
 272     while( iter != stmtList_.end() )
 273     {
 274         (*iter)->SQLFreeHandle( SQL_CLOSE );
 275         iter++;
 276     }
 277
 278     // Finish transaction
 279     switch( completionType )
 280     {
 281         case SQL_COMMIT:
 282
 283                     if( fsqlConn_->commit() != OK )
 284                         return( SQL_ERROR );
 285
 286                     if( fsqlConn_->beginTrans( curIsolationLevel_ ) != OK )
 287                         return( SQL_ERROR );
 288
 289                     break;
 290
 291         case SQL_ROLLBACK:
 292                     if( fsqlConn_->rollback() != OK )
 293                         return( SQL_ERROR );
 294
 295                     rc = fsqlConn_->beginTrans( curIsolationLevel_ );
 296                     break;
 297
 298         default:    err_.set( ERROR_OPTRANGE );
 299                     return( SQL_ERROR );
 300     }
 301
 302     // Had statements ?
 303     if( stmtList_.size() == 0 )
 304         state_ = C4;
 305     else
 306         state_ = C5;
 307
 308     return( SQL_SUCCESS );
 309 }
 310
 311 SQLRETURN SQLSetConnectOption(
 312     SQLHDBC ConnectionHandle,
 313     SQLUSMALLINT Option,
 314     SQLUINTEGER Value)
 315 {
 316 printf("PRABA::I AM CALLED in setconnect otpion\n");
 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 printf("PRABA::I AM CALLEDn conn attr\n");
 327    // Validate handle
 328    if( isValidHandle( ConnectionHandle, SQL_HANDLE_DBC ) != SQL_SUCCESS )
 329         return( SQL_INVALID_HANDLE );
 330
 331    return( ((CSqlOdbcDbc*)ConnectionHandle)->SQLSetConnectAttr( Attribute, Value, StringLength ) );
 332 }
 333
 334 SQLRETURN CSqlOdbcDbc::SQLSetConnectAttr(
 335     SQLINTEGER attribute,
 336     SQLPOINTER value,
 337     SQLINTEGER stringLength)
 338 {
 339     // Start with NO_ERR
 340     err_.set( NO_ERR );
 341
 342     switch( attribute )
 343     {
 344         case SQL_ATTR_ACCESS_MODE:
 345             // validate 'value'
 346             if( (SQLUINTEGER) value == SQL_MODE_READ_ONLY )
 347                 accessMode_ = ACCESSMODE_READ_ONLY;
 348             else if( (SQLUINTEGER) value == SQL_MODE_READ_WRITE )
 349                 accessMode_ = ACCESSMODE_READ_WRITE;
 350             else
 351                 return( SQL_ERROR );
 352
 353             break;
 354         case SQL_DEFAULT_TXN_ISOLATION:
 355         case SQL_ATTR_TXN_ISOLATION:
 356             // validate 'value'
 357             if( (SQLUINTEGER) value == SQL_TXN_READ_UNCOMMITTED )
 358                 isolationLevel_ = READ_UNCOMMITTED;
 359             else if( (SQLUINTEGER) value == SQL_TXN_READ_COMMITTED )
 360                 isolationLevel_ = READ_COMMITTED;
 361             else if( (SQLUINTEGER) value == SQL_TXN_REPEATABLE_READ )
 362                 isolationLevel_ = READ_REPEATABLE;
 363 //            else if( (SQLUINTEGER) value == SQL_TXN_SERIALIZABLE )
 364 //                isolationLevel_ = SERIALIZABLE;
 365             else
 366                 return( SQL_ERROR );
 367
 368             break;
 369         case SQL_ATTR_AUTOCOMMIT:
 370             autoCommit_ = (SQLUINTEGER) value;
 371             if( state_ == C6 )
 372                 SQLEndTran( SQL_COMMIT );
 373             break;
 374
 375         default: err_.set( ERROR_OPTRANGE );
 376                  return( SQL_ERROR );
 377     }
 378
 379     return( SQL_SUCCESS );
 380 }
 381
 382 SQLRETURN SQLGetConnectOption(
 383     SQLHDBC ConnectionHandle,
 384     SQLUSMALLINT Option,
 385     SQLPOINTER Value)
 386 {
 387     return( SQLGetConnectAttr( ConnectionHandle, Option, Value, 0, 0) );
 388 }
 389
 390 SQLRETURN SQLGetConnectAttr(
 391     SQLHDBC ConnectionHandle,
 392     SQLINTEGER Attribute,
 393     SQLPOINTER Value,
 394     SQLINTEGER BufferLength,
 395     SQLINTEGER *StringLength)
 396 {
 397    // Validate handle
 398    if( isValidHandle( ConnectionHandle, SQL_HANDLE_DBC ) != SQL_SUCCESS )
 399         return( SQL_INVALID_HANDLE );
 400
 401    return( ((CSqlOdbcDbc*)ConnectionHandle)->SQLGetConnectAttr( Attribute, Value, BufferLength, StringLength ) );
 402 }
 403
 404 SQLRETURN CSqlOdbcDbc::SQLGetConnectAttr(
 405     SQLINTEGER attribute,
 406     SQLPOINTER value,
 407     SQLINTEGER bufferLength,
 408     SQLINTEGER *stringLength)
 409 {
 410     // Start with NO_ERR
 411     err_.set( NO_ERR );
 412
 413     switch( attribute )
 414     {
 415         case SQL_ATTR_ACCESS_MODE:
 416             // Get ODBC Access Mode
 417             if( accessMode_ == ACCESSMODE_READ_ONLY )
 418                 *((SQLUINTEGER*) value) = SQL_MODE_READ_ONLY;
 419             else if( accessMode_ == ACCESSMODE_READ_WRITE )
 420                 *((SQLUINTEGER*) value) = SQL_MODE_READ_WRITE;
 421             else
 422                 return( SQL_ERROR );
 423
 424             break;
 425         case SQL_DEFAULT_TXN_ISOLATION:
 426         case SQL_ATTR_TXN_ISOLATION:
 427             // validate 'value'
 428             if( (SQLUINTEGER) isolationLevel_ == READ_UNCOMMITTED )
 429                 *((SQLUINTEGER*) value) = SQL_TXN_READ_UNCOMMITTED;
 430             else if( (SQLUINTEGER) isolationLevel_ == READ_COMMITTED )
 431                 *((SQLUINTEGER*) value) = SQL_TXN_READ_COMMITTED;
 432             else if( (SQLUINTEGER) isolationLevel_ == READ_REPEATABLE )
 433                 *((SQLUINTEGER*) value) = SQL_TXN_REPEATABLE_READ;
 434 //            else if( (SQLUINTEGER) isolationLevel_ == SERIALIZABLE )
 435 //                *((SQLUINTEGER*) value) = SQL_TXN_SERIALIZABLE;
 436             else
 437                 return( SQL_ERROR );
 438
 439             break;
 440         case SQL_ATTR_AUTOCOMMIT:
 441             *((SQLUINTEGER*) value) = autoCommit_;
 442             break;
 443
 444         default: err_.set( ERROR_OPTRANGE );
 445                  return( SQL_ERROR );
 446     }
 447
 448     return( SQL_SUCCESS );
 449 }