src/odbc/odbcEnv.cxx

   1 /*  Class CSqlOdbcEnv
   2     Description: Environment Handle manager.
   3
   4     ODBC API's:
   5                 CSqlOdbcEnv::SQLAllocHandle();
   6                 CSqlOdbcEnv::SQLFreeHandle();
   7                 CSqlOdbcEnv::SQLSetEnvAttr();
   8
   9     Other Functions:
  10                 CSqlOdbcEnv::CSqlOdbcEnv();
  11 */
  12
  13 #include "odbcCommon.h"
  14
  15 // Constructor
  16 CSqlOdbcEnv::CSqlOdbcEnv( void ) :
  17     handleType_( SQL_HANDLE_ENV ),
  18     state_( E1 ),
  19     err_( SQL_HANDLE_ENV ),
  20     odbcVersion_( SQL_OV_ODBC3 )
  21 {}
  22
  23 SQLRETURN SQLAllocEnv(
  24     SQLHENV *EnvironmentHandle)
  25 {
  26     return( CSqlOdbcEnv::SQLAllocHandle( (SQLHANDLE) SQL_NULL_HANDLE, EnvironmentHandle ) );
  27 }
  28
  29 // Static function
  30 SQLRETURN CSqlOdbcEnv::SQLAllocHandle(
  31     SQLHANDLE   inputHandle,    // IN
  32     SQLHANDLE   *outputHandle ) // OUT
  33 {
  34     // Error in parameters
  35     if( inputHandle != SQL_NULL_HANDLE )
  36     {
  37         *outputHandle = SQL_NULL_HENV;
  38         return( SQL_ERROR );
  39     }
  40
  41     // Allocate Environment.
  42     *outputHandle = (SQLHANDLE*) new CSqlOdbcEnv;
  43     if( *outputHandle == NULL )
  44     {
  45         globalError.set((int) ERROR_MEMALLOC );
  46         globalError.printStr( SQL_OV_ODBC3 );
  47         return( SQL_ERROR );
  48     }
  49
  50     return( SQL_SUCCESS );
  51 }
  52
  53 SQLRETURN SQLFreeEnv(
  54     SQLHENV EnvironmentHandle)
  55 {
  56     return( CSqlOdbcEnv::SQLFreeHandle( EnvironmentHandle ) );
  57 }
  58
  59 // Static function
  60 SQLRETURN CSqlOdbcEnv::SQLFreeHandle(
  61     SQLHANDLE inputHandle)      // IN
  62 {
  63     CSqlOdbcEnv *inputEnv = (CSqlOdbcEnv*) inputHandle;
  64
  65     // Validate handle
  66     if( isValidHandle( inputEnv, SQL_HANDLE_ENV ) != SQL_SUCCESS )
  67         return( SQL_INVALID_HANDLE );
  68
  69     // Check whether we can proceed.
  70     if( inputEnv->chkStateForSQLFreeHandle() != SQL_SUCCESS )
  71         return( SQL_ERROR );
  72
  73     inputEnv->handleType_ = -1; // Make object invalid.
  74     delete inputEnv;            // Delete Environment.
  75
  76     return( SQL_SUCCESS );
  77 }
  78
  79 SQLRETURN SQLTransact(
  80     SQLHENV EnvironmentHandle,
  81     SQLHDBC ConnectionHandle,
  82     SQLUSMALLINT CompletionType)
  83 {
  84     // Call SQLEndTrans() on handle whichever is valid
  85     if( isValidHandle( EnvironmentHandle, SQL_HANDLE_ENV ) == SQL_SUCCESS )
  86         return( ((CSqlOdbcEnv*) EnvironmentHandle)->SQLEndTran( CompletionType ) );
  87
  88     if( isValidHandle( ConnectionHandle, SQL_HANDLE_DBC ) == SQL_SUCCESS )
  89         return( ((CSqlOdbcDbc*) ConnectionHandle)->SQLEndTran( CompletionType ) );
  90
  91     return( SQL_INVALID_HANDLE );
  92 }
  93
  94 SQLRETURN CSqlOdbcEnv::SQLEndTran(
  95     SQLSMALLINT completionType) // IN
  96 {
  97     // Start with NO_ERR
  98     err_.set( NO_ERR );
  99
 100     // Stop if odbcVersion not set.
 101     if( odbcVersion_ == 0 )
 102     {
 103         err_.set( ERROR_FUNCSEQ );
 104         return( SQL_ERROR );
 105     }
 106
 107     // If no connection objects ?
 108     if( dbcList_.size() == 0 )
 109         return( SQL_SUCCESS );
 110
 111     // For each connect obj, call SQLEndTran
 112     std::vector<CSqlOdbcDbc*>::iterator iter;
 113     iter = dbcList_.begin();
 114     while( iter != dbcList_.end() )
 115     {
 116         if( (*iter)->chkStateForSQLEndTran() == SQL_SUCCESS ) {
 117             if( (*iter)->SQLEndTran( completionType ) == SQL_ERROR )
 118                 return( SQL_ERROR );
 119         }
 120         else return ( SQL_ERROR );
 121         iter++;
 122     }
 123
 124     return( SQL_SUCCESS );
 125 }
 126
 127 SQLRETURN SQLSetEnvAttr(
 128             SQLHENV    inputEnv,        // IN
 129             SQLINTEGER Attribute,       // IN
 130             SQLPOINTER Value,           // IN
 131             SQLINTEGER StringLength)    // IN
 132 {
 133    // Validate handle
 134    if( isValidHandle( inputEnv, SQL_HANDLE_ENV ) != SQL_SUCCESS )
 135         return( SQL_INVALID_HANDLE );
 136
 137    return( ((CSqlOdbcEnv*)inputEnv)->SQLSetEnvAttr( Attribute, Value, StringLength ) );
 138 }
 139
 140 SQLRETURN  CSqlOdbcEnv::SQLSetEnvAttr(
 141             SQLINTEGER attribute,       // IN
 142             SQLPOINTER value,           // IN
 143             SQLINTEGER stringLength)    // IN
 144 {
 145     // Start with NO_ERR
 146     err_.set( NO_ERR );
 147
 148     // Check whether we can proceed.
 149     if( chkStateForSQLSetEnvAttr() != SQL_SUCCESS )
 150         return( SQL_ERROR );
 151
 152     switch( attribute )
 153     {
 154         case SQL_ATTR_ODBC_VERSION:
 155             switch( (SQLINTEGER) value )
 156             {
 157                 case SQL_OV_ODBC2:
 158                 case SQL_OV_ODBC3: break;
 159                 default:
 160                         err_.set( ERROR_OPTCHANGE );
 161                         return( SQL_ERROR );
 162             }
 163             odbcVersion_ = (SQLUINTEGER) value;
 164             break;
 165
 166         case SQL_ATTR_OUTPUT_NTS:
 167             if( (SQLINTEGER) value == SQL_TRUE )
 168                 return( SQL_SUCCESS );
 169             else
 170             {
 171                 err_.set( ERROR_OPTFEATURE_NOTIMP );
 172                 return( SQL_ERROR );
 173             }
 174             break;
 175
 176         default: err_.set( ERROR_OPTRANGE );
 177                  return( SQL_ERROR );
 178     }
 179
 180     return( SQL_SUCCESS );
 181 }
 182
 183 SQLRETURN SQLGetEnvAttr(
 184     SQLHENV EnvironmentHandle,
 185     SQLINTEGER Attribute,
 186     SQLPOINTER Value,
 187     SQLINTEGER BufferLength,
 188     SQLINTEGER *StringLength)
 189 {
 190    // Validate handle
 191    if( isValidHandle( EnvironmentHandle, SQL_HANDLE_ENV ) != SQL_SUCCESS )
 192         return( SQL_INVALID_HANDLE );
 193
 194    return( ((CSqlOdbcEnv*)EnvironmentHandle)->SQLGetEnvAttr( Attribute, Value, BufferLength, StringLength ) );
 195 }
 196
 197 SQLRETURN CSqlOdbcEnv::SQLGetEnvAttr(
 198     SQLINTEGER attribute,
 199     SQLPOINTER value,
 200     SQLINTEGER bufferLength,
 201     SQLINTEGER *stringLength)
 202 {
 203     // Start with NO_ERR
 204     err_.set( NO_ERR );
 205
 206     // Can we proceed.? Always ( in all states)
 207
 208     switch( attribute )
 209     {
 210         case SQL_ATTR_ODBC_VERSION:
 211             *((SQLUINTEGER*) value) = odbcVersion_;
 212             break;
 213
 214         case SQL_ATTR_OUTPUT_NTS:
 215             *((SQLUINTEGER*) value) = SQL_TRUE;
 216             break;
 217
 218         default: err_.set( ERROR_OPTRANGE );
 219                  return( SQL_ERROR );
 220     }
 221
 222     return( SQL_SUCCESS );
 223 }