src/odbc/odbcCommon.cxx

   1 #include "odbcCommon.h"
   2
   3 SQLRETURN SQLAllocHandle( SQLSMALLINT hdlType,
   4                           SQLHANDLE inHdl,
   5                           SQLHANDLE *outHdl )
   6 {
   7     switch( hdlType )
   8     {
   9         case SQL_HANDLE_ENV:
  10                 return CSqlOdbcEnv::SQLAllocHandle( inHdl, outHdl );
  11         case SQL_HANDLE_DBC:
  12                 return CSqlOdbcDbc::SQLAllocHandle( inHdl, outHdl );
  13         case SQL_HANDLE_STMT:
  14                 return CSqlOdbcStmt::SQLAllocHandle( inHdl, outHdl );
  15     }
  16
  17     globalError.set( ERROR_OPTRANGE );
  18     globalError.printStr( SQL_OV_ODBC3 );
  19     return( SQL_ERROR );
  20 }
  21
  22 SQLRETURN SQLFreeHandle(
  23     SQLSMALLINT hdlType,
  24     SQLHANDLE   inHdl)
  25 {
  26     switch( hdlType )
  27     {
  28         case SQL_HANDLE_ENV: return CSqlOdbcEnv::SQLFreeHandle( inHdl );
  29         case SQL_HANDLE_DBC: return CSqlOdbcDbc::SQLFreeHandle( inHdl );
  30         case SQL_HANDLE_STMT: return CSqlOdbcStmt::SQLFreeHandle( inHdl );
  31     }
  32
  33     globalError.set( ERROR_OPTRANGE );
  34     globalError.printStr( SQL_OV_ODBC3 );
  35     return( SQL_ERROR );
  36 }
  37
  38 SQLRETURN SQLEndTran(
  39     SQLSMALLINT hdlType,
  40     SQLHANDLE hdl,
  41     SQLSMALLINT compType)
  42 {
  43     if( isValidHandle( hdl, hdlType ) != SQL_SUCCESS )
  44         return( SQL_INVALID_HANDLE );
  45
  46     switch( hdlType )
  47     {
  48         case SQL_HANDLE_ENV:
  49                 return ((CSqlOdbcEnv*) hdl)->SQLEndTran( compType );
  50         case SQL_HANDLE_DBC:
  51                 return ((CSqlOdbcDbc*) hdl)->SQLEndTran( compType );
  52     }
  53
  54     globalError.set( ERROR_OPTRANGE );
  55     globalError.printStr( SQL_OV_ODBC3 );
  56     return( SQL_ERROR );
  57 }
  58
  59 SQLRETURN isValidHandle( SQLHANDLE hdl,
  60     SQLSMALLINT hdlType)
  61 {
  62     if( hdlType == SQL_HANDLE_ENV || hdlType == SQL_HANDLE_DBC || hdlType == SQL_HANDLE_STMT )
  63
  64         if( hdl != 0 )
  65             if( ((CSqlOdbcEnv*) hdl)->handleType_ == hdlType )
  66                 return( SQL_SUCCESS );
  67
  68     globalError.set( ERROR_MEM_MGMNT );
  69     globalError.printStr( SQL_OV_ODBC3 );
  70     return( SQL_INVALID_HANDLE );
  71 }
  72
  73 SQLRETURN isValidCType( SQLSMALLINT type )
  74 {
  75     switch( type )
  76     {
  77         case SQL_C_CHAR:
  78         case SQL_C_SLONG:
  79         case SQL_C_ULONG:
  80         case SQL_C_LONG:
  81         case SQL_C_FLOAT:
  82         case SQL_C_DOUBLE:
  83         case SQL_C_BIT:
  84         case SQL_C_SSHORT:
  85         case SQL_C_USHORT:
  86         case SQL_C_SHORT:
  87         case SQL_C_STINYINT:
  88         case SQL_C_UTINYINT:
  89         case SQL_C_TINYINT:
  90         case SQL_C_SBIGINT:
  91         case SQL_C_UBIGINT:
  92         case SQL_C_NUMERIC:
  93         case SQL_C_DATE:
  94         case SQL_C_TIME:
  95         case SQL_C_TIMESTAMP:
  96         case SQL_C_TYPE_DATE:
  97         case SQL_C_TYPE_TIME:
  98         case SQL_C_TYPE_TIMESTAMP:
  99         case SQL_C_BINARY: break;
 100         default: return( SQL_ERROR );
 101     }
 102     return( SQL_SUCCESS );
 103 }
 104
 105 SQLRETURN isValidSQLType( SQLSMALLINT type )
 106 {
 107     switch( type )
 108     {
 109         case SQL_CHAR:
 110         case SQL_VARCHAR:
 111         case SQL_BIT:
 112         case SQL_SMALLINT:
 113         case SQL_INTEGER:
 114         case SQL_REAL:
 115         case SQL_DOUBLE:
 116         case SQL_FLOAT:
 117         case SQL_TINYINT:
 118         case SQL_BIGINT:
 119         case SQL_DECIMAL:
 120         case SQL_NUMERIC:
 121         case SQL_DATE:
 122         case SQL_TIME:
 123         case SQL_TIMESTAMP:
 124         case SQL_TYPE_DATE:
 125         case SQL_TYPE_TIME:
 126         case SQL_TYPE_TIMESTAMP:
 127         case SQL_BINARY:
 128         case SQL_VARBINARY: break;
 129         default: return( SQL_ERROR );
 130     }
 131     return( SQL_SUCCESS );
 132 }
 133
 134 DataType getCSqlType( SQLSMALLINT type )
 135 {
 136     switch( type )
 137     {
 138         case SQL_C_CHAR:
 139             return typeString;
 140         case SQL_C_LONG:
 141         case SQL_C_SLONG:
 142         case SQL_C_ULONG:
 143             return typeLong;
 144         case SQL_C_FLOAT:
 145             return typeFloat;
 146         case SQL_C_DOUBLE:
 147             return typeDouble;
 148         case SQL_C_BIT:
 149             return typeUnknown;
 150         case SQL_C_SHORT:
 151         case SQL_C_SSHORT:
 152         case SQL_C_USHORT:
 153             return typeShort;
 154         case SQL_C_TINYINT:
 155         case SQL_C_STINYINT:
 156         case SQL_C_UTINYINT:
 157             return typeByteInt;
 158         case SQL_C_SBIGINT:
 159         case SQL_C_UBIGINT:
 160             return typeLongLong;
 161         case SQL_C_NUMERIC:
 162             return typeDecimal;
 163         case SQL_C_DATE:
 164         case SQL_C_TYPE_DATE:
 165             return typeDate;
 166         case SQL_C_TIME:
 167         case SQL_C_TYPE_TIME:
 168             return typeTime;
 169         case SQL_C_TIMESTAMP:
 170         case SQL_C_TYPE_TIMESTAMP:
 171             return typeTimeStamp;
 172             break;
 173         case SQL_C_BINARY:
 174             return typeBinary;
 175         default: return( typeUnknown);
 176     }
 177 }
 178
 179 SQLSMALLINT  getSQLType( DataType type )
 180 {
 181     switch(type)
 182     {
 183         case typeShort:
 184             return SQL_SMALLINT;
 185         case typeInt:
 186         case typeLong:
 187             return SQL_INTEGER;
 188         case typeLongLong:
 189             return SQL_BIGINT;
 190         case typeByteInt:
 191             return SQL_TINYINT;
 192
 193         case typeFloat:
 194             return SQL_FLOAT;
 195         case typeDouble:
 196             return SQL_DOUBLE;
 197         case typeDecimal:
 198             return SQL_NUMERIC;
 199
 200         case typeDate:
 201             return SQL_DATE;
 202         case typeTime:
 203             return SQL_TIME;
 204         case typeTimeStamp:
 205             return SQL_TIMESTAMP;
 206
 207         case typeString:
 208             return SQL_CHAR;
 209         case typeBinary:
 210             return SQL_BINARY;
 211
 212         // NOT SUPPORTED
 213         //case csqlSqlTlongDouble: might be equal typeDecimal
 214         //    return SQL_REAL;
 215         //case csqlSqlTvarString:
 216         //    return SQL_VARCHAR;
 217         //case csqlSqlTvarBinary:
 218         //    return SQL_BINARY;
 219         //case typeBit:
 220         //    return SQL_BIT;
 221         default:
 222             return SQL_ERROR;
 223             break;
 224     }
 225 }
 226
 227 SQLCHAR *getSQLTypeName( SQLSMALLINT type )
 228 {
 229     switch( type )
 230     {
 231         case SQL_CHAR:
 232             return (SQLCHAR *)"CHAR";
 233         case SQL_VARCHAR:
 234             return (SQLCHAR *)"VARCHAR";
 235         case SQL_BIT:
 236             return (SQLCHAR *)"BIT";
 237         case SQL_SMALLINT:
 238             return (SQLCHAR *)"SMALLINT";
 239         case SQL_INTEGER:
 240             return (SQLCHAR *)"INTEGER";
 241         case SQL_REAL:
 242             return (SQLCHAR *)"REAL";
 243         case SQL_DECIMAL:
 244         case SQL_NUMERIC:
 245             return (SQLCHAR *)"NUMERIC";
 246         case SQL_DOUBLE:
 247             return (SQLCHAR *)"DOUBLE";
 248         case SQL_FLOAT:
 249             return (SQLCHAR *)"FLOAT";
 250         case SQL_TINYINT:
 251             return (SQLCHAR *)"TINYINT";
 252         case SQL_BIGINT:
 253             return (SQLCHAR *)"BIGINT";
 254         case SQL_DATE:
 255         case SQL_TYPE_DATE:
 256             return (SQLCHAR *)"DATE";
 257         case SQL_TIME:
 258         case SQL_TYPE_TIME:
 259             return (SQLCHAR *)"TIME";
 260         case SQL_TIMESTAMP:
 261         case SQL_TYPE_TIMESTAMP:
 262             return (SQLCHAR *)"TIMESTAMP";
 263             case SQL_BINARY:
 264             return (SQLCHAR *)"BINARY";
 265         default:
 266             break;
 267     }
 268 }
 269
 270 void getInputBuffer(void **buffer,SQLSMALLINT type,SQLUINTEGER length)
 271 {
 272     switch(type)
 273     {
 274         case typeShort:
 275             *buffer = new short();
 276             break;
 277         case typeInt:
 278             *buffer= new int();
 279             break;
 280         case typeLong:
 281             *buffer= new long();
 282             break;
 283         case typeLongLong:
 284             *buffer = new long long();
 285             break;
 286         case typeByteInt:
 287             *buffer = new signed char();
 288             break;
 289 /*        case csqlSqlTbit:
 290             *buffer = new unsigned char ();
 291             break;*/
 292
 293         case typeFloat:
 294             *buffer = new float();
 295             break;
 296         case typeDouble:
 297             *buffer = new double();
 298             break;
 299         case typeDecimal:
 300 //        case csqlSqlTlongDouble:
 301 //        case csqlSqlTnumeric:
 302             *buffer = new long double ();
 303             break;
 304
 305         case typeString:
 306 //        case csqlSqlTvarString:
 307             *buffer = new char [length+1];
 308             break;
 309         case typeDate:
 310             *buffer = new Date();
 311             break;
 312         case typeTime:
 313             *buffer = new Time();
 314             break;
 315         case typeTimeStamp:
 316             *buffer = new TimeStamp();
 317             break;
 318         case typeBinary:
 319 //        case csqlSqlTvarBinary:
 320             *buffer = new unsigned char [length+1];
 321             break;
 322     }
 323 }
 324
 325 // CSQL TODO - Need to review and finalize.
 326 //Copies data from the application onto the destination
 327 //Called from SQLExecute
 328 //Destination here can be directly the database bound buffer or
 329 //it may be ird
 330 void copyFromOdbc(AbsSqlStatement *stmt, int paramNo, SQLUINTEGER destLen,void *odbcData,SQLUINTEGER odbcLen,SQLSMALLINT type)
 331 {
 332     //No point in continuing further
 333     if(odbcData == NULL)
 334         return;
 335     switch( type )
 336     {
 337         case typeShort:
 338             //*(short*)destData = *(short*)odbcData;
 339             stmt->setShortParam(paramNo, *(short*)odbcData);
 340             break;
 341         case typeInt:
 342             //*(int*)destData = *(int*)odbcData;
 343             stmt->setIntParam(paramNo, *(int*)odbcData);
 344             break;
 345         case typeLong:
 346             //*(long*)destData = *(long*)odbcData;
 347             stmt->setLongParam(paramNo, *(long*)odbcData);
 348             break;
 349         case typeLongLong:
 350             //*(long long*)destData = *(long long*)odbcData;
 351             stmt->setLongLongParam(paramNo, *(long long *)odbcData);
 352             break;
 353         case typeByteInt: {
 354             //*(char*)destData = *(char*)odbcData;
 355             ByteInt bt(*(char*)odbcData);
 356              stmt->setByteIntParam(paramNo, bt);
 357             break;
 358         }
 359 /*        case csqlSqlTbit:
 360             *(unsigned char*)destData = *(unsigned char*)odbcData;
 361             break;*/
 362
 363         case typeFloat:
 364             //*(float*)destData = *(float*)odbcData;
 365             stmt->setFloatParam(paramNo, *(float*)odbcData);
 366             break;
 367
 368         case typeDouble:
 369             //*(double*)destData = *(double*)odbcData;
 370             stmt->setDoubleParam(paramNo, *(double*)odbcData);
 371             break;
 372
 373 //        case csqlSqlTlongDouble:
 374 //        case csqlSqlTnumeric:
 375         case typeDecimal:
 376             //*(long double*)destData = *(long double*)odbcData;
 377             // TODO
 378             break;
 379
 380         case typeString:
 381             stmt->setStringParam(paramNo, (char*) odbcData);
 382             /*if(odbcLen < destLen)
 383             {
 384                 strcpy( (char*)destData, (char*)odbcData);
 385                 *((char*)destData+odbcLen)='\0';
 386             }
 387             else
 388             {
 389                 strncpy((char*)destData,(char*)odbcData,(destLen-1));
 390                 *((char*)destData+destLen)='\0';
 391             }*/
 392
 393             break;
 394         case typeDate: {
 395             Date dt;
 396             dt.set((*(SQL_DATE_STRUCT *)odbcData).year,
 397                    (*(SQL_DATE_STRUCT *)odbcData).month,
 398                    (*(SQL_DATE_STRUCT *)odbcData).day);
 399             stmt->setDateParam(paramNo, dt);
 400             break;
 401         }
 402         case typeTime: {
 403             Time tm;
 404             tm.set((*(SQL_TIME_STRUCT *)odbcData).hour,
 405                    (*(SQL_TIME_STRUCT *)odbcData).minute,
 406                    (*(SQL_TIME_STRUCT *)odbcData).second);
 407             stmt->setTimeParam(paramNo, tm);
 408             break;
 409         }
 410         case typeTimeStamp: {
 411             TimeStamp ts;
 412             ts.setDate((*(SQL_TIMESTAMP_STRUCT *)odbcData).year,
 413                        (*(SQL_TIMESTAMP_STRUCT *)odbcData).month,
 414                        (*(SQL_TIMESTAMP_STRUCT *)odbcData).day);
 415             ts.setTime((*(SQL_TIMESTAMP_STRUCT*)odbcData).hour,
 416                        (*(SQL_TIMESTAMP_STRUCT *)odbcData).minute,
 417                        (*(SQL_TIMESTAMP_STRUCT *)odbcData).second);
 418             stmt->setTimeStampParam(paramNo, ts);
 419             break;
 420         }
 421    }
 422
 423 }
 424
 425 //Copies data from the database onto the application buffer
 426 //Called from SQLFetch
 427 //Destination here can be the actual application buffer or
 428 //it may be ipd_
 429 SQLINTEGER copyToOdbc(void *odbcData,SQLUINTEGER odbcLen,void *sourceData,SQLUINTEGER sourceLen,SQLSMALLINT type)
 430 {
 431     SQLINTEGER ind;
 432     if(odbcData == NULL || sourceData == NULL)
 433         return -1;
 434     switch( type )
 435     {
 436         case typeShort:
 437             *(short*)odbcData = *(short*)sourceData;
 438             break;
 439
 440         case typeInt:
 441             *(int*)odbcData = *(int*)sourceData;
 442             break;
 443
 444         case typeLong:
 445             *(long*)odbcData = *(long*)sourceData;
 446             break;
 447
 448         case typeLongLong:
 449             *(long long*)odbcData = *(long long*)sourceData;
 450             break;
 451
 452         case typeByteInt:
 453             *(char*)odbcData = *(char*)sourceData;
 454             break;
 455
 456 //        case csqlSqlTbit:
 457 //            CSqlOdbcError::printDbg("copyToOdbc");
 458 //            *(unsigned char*)odbcData = *(unsigned char*)sourceData;
 459 //            break;
 460
 461         case typeFloat:
 462             *(float*)odbcData = *(float*)sourceData;
 463             break;
 464         case typeDouble:
 465             *(double*)odbcData = *(double*)sourceData;
 466             break;
 467         case typeDecimal:
 468
 469 //        case csqlSqlTlongDouble:
 470 //        case csqlSqlTnumeric:
 471             *(long double*)odbcData = *(long double*)sourceData;
 472             break;
 473         case typeString:
 474 //      case csqlSqlTvarString:
 475             if(sourceLen < odbcLen)
 476             {
 477                 strcpy((char*)odbcData,(char*)sourceData);
 478                 ind=strlen((char*)odbcData)+1;
 479             }
 480             else
 481             {
 482                 strncpy((char*)odbcData,(char*)sourceData ,odbcLen);
 483                 ind=odbcLen;
 484             }
 485             *((char *)odbcData+ind-1)='\0';
 486             break;
 487         case typeDate:
 488             (*(SQL_DATE_STRUCT *)odbcData).year = (*(Date *)sourceData).year();
 489             (*(SQL_DATE_STRUCT *)odbcData).month= (*(Date *)sourceData).month();
 490             (*(SQL_DATE_STRUCT *)odbcData).day = (*(Date *)sourceData).dayOfMonth();
 491             break;
 492         case typeTime:
 493             (*(SQL_TIME_STRUCT *)odbcData).hour = (*(Time *)sourceData).hours();
 494             (*(SQL_TIME_STRUCT *)odbcData).minute= (*(Time *)sourceData).minutes();
 495             (*(SQL_TIME_STRUCT *)odbcData).second = (*(Time *)sourceData).seconds();
 496             break;
 497         case typeTimeStamp:
 498             (*(SQL_TIMESTAMP_STRUCT *)odbcData).year= (*(TimeStamp *)sourceData).year();
 499             (*(SQL_TIMESTAMP_STRUCT *)odbcData).month= (*(TimeStamp *)sourceData).month();
 500             (*(SQL_TIMESTAMP_STRUCT *)odbcData).day= (*(TimeStamp *)sourceData).dayOfMonth();
 501             (*(SQL_TIMESTAMP_STRUCT *)odbcData).hour = (*(TimeStamp *)sourceData).hours();
 502             (*(SQL_TIMESTAMP_STRUCT *)odbcData).minute= (*(TimeStamp *)sourceData).minutes();
 503             (*(SQL_TIMESTAMP_STRUCT *)odbcData).second = (*(TimeStamp *)sourceData).seconds();
 504             break;
 505         case typeBinary:
 506 //        case csqlSqlTvarBinary:
 507 //            CSqlOdbcError::printDbg("copyToOdbc");
 508 //            memset((unsigned char*)odbcData,0,odbcLen);
 509             if(sourceLen < odbcLen)
 510             {
 511                 memcpy( (unsigned char*)odbcData , (unsigned char*)sourceData,sourceLen);
 512                 ind=sourceLen;
 513             }
 514             else
 515             {
 516                 memcpy( (unsigned char*)odbcData , (unsigned char*)sourceData,odbcLen);
 517                 ind=odbcLen;
 518             }
 519             break;
 520     }
 521     return ind;
 522 }