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     ListIterator iter = dbcList_.getIterator();
 113     CSqlOdbcDbc *dbcElem = NULL;
 114     while(iter.hasElement()) {
 115         dbcElem = (CSqlOdbcDbc *) iter.nextElement();
 116         if( dbcElem->chkStateForSQLEndTran() == SQL_SUCCESS ) {
 117             if( dbcElem->SQLEndTran( completionType ) == SQL_ERROR )
 118                 return( SQL_ERROR );
 119         }
 120         else return ( SQL_ERROR );
 121     }
 122     return( SQL_SUCCESS );
 123 }
 124
 125 SQLRETURN SQLSetEnvAttr(
 126             SQLHENV    inputEnv,        // IN
 127             SQLINTEGER Attribute,       // IN
 128             SQLPOINTER Value,           // IN
 129             SQLINTEGER StringLength)    // IN
 130 {
 131    // Validate handle
 132    if( isValidHandle( inputEnv, SQL_HANDLE_ENV ) != SQL_SUCCESS )
 133         return( SQL_INVALID_HANDLE );
 134
 135    return( ((CSqlOdbcEnv*)inputEnv)->SQLSetEnvAttr( Attribute, Value, StringLength ) );
 136 }
 137
 138 SQLRETURN  CSqlOdbcEnv::SQLSetEnvAttr(
 139             SQLINTEGER attribute,       // IN
 140             SQLPOINTER value,           // IN
 141             SQLINTEGER stringLength)    // IN
 142 {
 143     // Start with NO_ERR
 144     err_.set( NO_ERR );
 145
 146     // Check whether we can proceed.
 147     if( chkStateForSQLSetEnvAttr() != SQL_SUCCESS )
 148         return( SQL_ERROR );
 149
 150     switch( attribute )
 151     {
 152         case SQL_ATTR_ODBC_VERSION:
 153             switch( (SQLINTEGER) value )
 154             {
 155                 case SQL_OV_ODBC2:
 156                 case SQL_OV_ODBC3: break;
 157                 default:
 158                         err_.set( ERROR_OPTCHANGE );
 159                         return( SQL_ERROR );
 160             }
 161             odbcVersion_ = (SQLUINTEGER) value;
 162             break;
 163
 164         case SQL_ATTR_OUTPUT_NTS:
 165             if( (SQLINTEGER) value == SQL_TRUE )
 166                 return( SQL_SUCCESS );
 167             else
 168             {
 169                 err_.set( ERROR_OPTFEATURE_NOTIMP );
 170                 return( SQL_ERROR );
 171             }
 172             break;
 173
 174         default: err_.set( ERROR_OPTRANGE );
 175                  return( SQL_ERROR );
 176     }
 177
 178     return( SQL_SUCCESS );
 179 }
 180
 181 SQLRETURN SQLGetEnvAttr(
 182     SQLHENV EnvironmentHandle,
 183     SQLINTEGER Attribute,
 184     SQLPOINTER Value,
 185     SQLINTEGER BufferLength,
 186     SQLINTEGER *StringLength)
 187 {
 188    // Validate handle
 189    if( isValidHandle( EnvironmentHandle, SQL_HANDLE_ENV ) != SQL_SUCCESS )
 190         return( SQL_INVALID_HANDLE );
 191
 192    return( ((CSqlOdbcEnv*)EnvironmentHandle)->SQLGetEnvAttr( Attribute, Value, BufferLength, StringLength ) );
 193 }
 194
 195 SQLRETURN CSqlOdbcEnv::SQLGetEnvAttr(
 196     SQLINTEGER attribute,
 197     SQLPOINTER value,
 198     SQLINTEGER bufferLength,
 199     SQLINTEGER *stringLength)
 200 {
 201     // Start with NO_ERR
 202     err_.set( NO_ERR );
 203
 204     // Can we proceed.? Always ( in all states)
 205
 206     switch( attribute )
 207     {
 208         case SQL_ATTR_ODBC_VERSION:
 209             *((SQLUINTEGER*) value) = odbcVersion_;
 210             break;
 211
 212         case SQL_ATTR_OUTPUT_NTS:
 213             *((SQLUINTEGER*) value) = SQL_TRUE;
 214             break;
 215
 216         default: err_.set( ERROR_OPTRANGE );
 217                  return( SQL_ERROR );
 218     }
 219
 220     return( SQL_SUCCESS );
 221 }