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             return typeInt;
 143         case SQL_C_ULONG:
 144             return typeLong;
 145         case SQL_C_FLOAT:
 146             return typeFloat;
 147         case SQL_C_DOUBLE:
 148             return typeDouble;
 149         case SQL_C_BIT:
 150             return typeUnknown;
 151         case SQL_C_SHORT:
 152         case SQL_C_SSHORT:
 153         case SQL_C_USHORT:
 154             return typeShort;
 155         case SQL_C_TINYINT:
 156         case SQL_C_STINYINT:
 157         case SQL_C_UTINYINT:
 158             return typeByteInt;
 159         case SQL_C_SBIGINT:
 160         case SQL_C_UBIGINT:
 161             return typeLongLong;
 162         case SQL_C_NUMERIC:
 163             return typeDecimal;
 164         case SQL_C_DATE:
 165         case SQL_C_TYPE_DATE:
 166             return typeDate;
 167         case SQL_C_TIME:
 168         case SQL_C_TYPE_TIME:
 169             return typeTime;
 170         case SQL_C_TIMESTAMP:
 171         case SQL_C_TYPE_TIMESTAMP:
 172             return typeTimeStamp;
 173             break;
 174         case SQL_C_BINARY:
 175             return typeBinary;
 176         default: return( typeUnknown);
 177     }
 178 }
 179
 180 SQLSMALLINT  getSQLType( DataType type )
 181 {
 182     switch(type)
 183     {
 184         case typeShort:
 185             return SQL_SMALLINT;
 186         case typeInt:
 187         case typeLong:
 188             return SQL_INTEGER;
 189         case typeLongLong:
 190             return SQL_BIGINT;
 191         case typeByteInt:
 192             return SQL_TINYINT;
 193
 194         case typeFloat:
 195             return SQL_FLOAT;
 196         case typeDouble:
 197             return SQL_DOUBLE;
 198         case typeDecimal:
 199             return SQL_NUMERIC;
 200
 201         case typeDate:
 202             return SQL_DATE;
 203         case typeTime:
 204             return SQL_TIME;
 205         case typeTimeStamp:
 206             return SQL_TIMESTAMP;
 207
 208         case typeString:
 209             return SQL_CHAR;
 210         case typeBinary:
 211             return SQL_BINARY;
 212
 213         // NOT SUPPORTED
 214         //case csqlSqlTlongDouble: might be equal typeDecimal
 215         //    return SQL_REAL;
 216         //case csqlSqlTvarString:
 217         //    return SQL_VARCHAR;
 218         //case csqlSqlTvarBinary:
 219         //    return SQL_BINARY;
 220         //case typeBit:
 221         //    return SQL_BIT;
 222         default:
 223             return SQL_ERROR;
 224             break;
 225     }
 226 }
 227
 228 SQLCHAR *getSQLTypeName( SQLSMALLINT type )
 229 {
 230     switch( type )
 231     {
 232         case SQL_CHAR:
 233             return (SQLCHAR *)"CHAR";
 234         case SQL_VARCHAR:
 235             return (SQLCHAR *)"VARCHAR";
 236         case SQL_BIT:
 237             return (SQLCHAR *)"BIT";
 238         case SQL_SMALLINT:
 239             return (SQLCHAR *)"SMALLINT";
 240         case SQL_INTEGER:
 241             return (SQLCHAR *)"INTEGER";
 242         case SQL_REAL:
 243             return (SQLCHAR *)"REAL";
 244         case SQL_DECIMAL:
 245         case SQL_NUMERIC:
 246             return (SQLCHAR *)"NUMERIC";
 247         case SQL_DOUBLE:
 248             return (SQLCHAR *)"DOUBLE";
 249         case SQL_FLOAT:
 250             return (SQLCHAR *)"FLOAT";
 251         case SQL_TINYINT:
 252             return (SQLCHAR *)"TINYINT";
 253         case SQL_BIGINT:
 254             return (SQLCHAR *)"BIGINT";
 255         case SQL_DATE:
 256         case SQL_TYPE_DATE:
 257             return (SQLCHAR *)"DATE";
 258         case SQL_TIME:
 259         case SQL_TYPE_TIME:
 260             return (SQLCHAR *)"TIME";
 261         case SQL_TIMESTAMP:
 262         case SQL_TYPE_TIMESTAMP:
 263             return (SQLCHAR *)"TIMESTAMP";
 264             case SQL_BINARY:
 265             return (SQLCHAR *)"BINARY";
 266         default:
 267             break;
 268     }
 269 }
 270
 271 void getInputBuffer(void **buffer,SQLSMALLINT type,SQLUINTEGER length)
 272 {
 273     switch(type)
 274     {
 275         case typeShort:
 276             *buffer = new short();
 277             break;
 278         case typeInt:
 279             *buffer= new int();
 280             break;
 281         case typeLong:
 282             *buffer= new long();
 283             break;
 284         case typeLongLong:
 285             *buffer = new long long();
 286             break;
 287         case typeByteInt:
 288             *buffer = new signed char();
 289             break;
 290 /*        case csqlSqlTbit:
 291             *buffer = new unsigned char ();
 292             break;*/
 293
 294         case typeFloat:
 295             *buffer = new float();
 296             break;
 297         case typeDouble:
 298             *buffer = new double();
 299             break;
 300         case typeDecimal:
 301 //        case csqlSqlTlongDouble:
 302 //        case csqlSqlTnumeric:
 303             *buffer = new long double ();
 304             break;
 305
 306         case typeString:
 307 //        case csqlSqlTvarString:
 308             *buffer = new char [length+1];
 309             break;
 310         case typeDate:
 311             *buffer = new Date();
 312             break;
 313         case typeTime:
 314             *buffer = new Time();
 315             break;
 316         case typeTimeStamp:
 317             *buffer = new TimeStamp();
 318             break;
 319         case typeBinary:
 320 //        case csqlSqlTvarBinary:
 321             *buffer = new unsigned char [length+1];
 322             break;
 323     }
 324 }
 325
 326 // CSQL TODO - Need to review and finalize.
 327 //Copies data from the application onto the destination
 328 //Called from SQLExecute
 329 //Destination here can be directly the database bound buffer or
 330 //it may be ird
 331 void copyFromOdbc(AbsSqlStatement *stmt, int paramNo, SQLUINTEGER destLen,void *odbcData,SQLUINTEGER odbcLen,SQLSMALLINT type)
 332 {
 333     //No point in continuing further
 334     if(odbcData == NULL)
 335         return;
 336     switch( type )
 337     {
 338         case typeShort:
 339             //*(short*)destData = *(short*)odbcData;
 340             stmt->setShortParam(paramNo, *(short*)odbcData);
 341             break;
 342         case typeInt:
 343             //*(int*)destData = *(int*)odbcData;
 344             stmt->setIntParam(paramNo, *(int*)odbcData);
 345             break;
 346         case typeLong:
 347             //*(long*)destData = *(long*)odbcData;
 348             stmt->setLongParam(paramNo, *(long*)odbcData);
 349             break;
 350         case typeLongLong:
 351             //*(long long*)destData = *(long long*)odbcData;
 352             stmt->setLongLongParam(paramNo, *(long long *)odbcData);
 353             break;
 354         case typeByteInt: {
 355             //*(char*)destData = *(char*)odbcData;
 356             ByteInt bt(*(char*)odbcData);
 357              stmt->setByteIntParam(paramNo, bt);
 358             break;
 359         }
 360 /*        case csqlSqlTbit:
 361             *(unsigned char*)destData = *(unsigned char*)odbcData;
 362             break;*/
 363
 364         case typeFloat:
 365             //*(float*)destData = *(float*)odbcData;
 366             stmt->setFloatParam(paramNo, *(float*)odbcData);
 367             break;
 368
 369         case typeDouble:
 370             //*(double*)destData = *(double*)odbcData;
 371             stmt->setDoubleParam(paramNo, *(double*)odbcData);
 372             break;
 373
 374 //        case csqlSqlTlongDouble:
 375 //        case csqlSqlTnumeric:
 376         case typeDecimal:
 377             //*(long double*)destData = *(long double*)odbcData;
 378             // TODO
 379             break;
 380
 381         case typeString:
 382             stmt->setStringParam(paramNo, (char*) odbcData);
 383             /*if(odbcLen < destLen)
 384             {
 385                 strcpy( (char*)destData, (char*)odbcData);
 386                 *((char*)destData+odbcLen)='\0';
 387             }
 388             else
 389             {
 390                 strncpy((char*)destData,(char*)odbcData,(destLen-1));
 391                 *((char*)destData+destLen)='\0';
 392             }*/
 393
 394             break;
 395         case typeDate: {
 396             Date dt;
 397             dt.set((*(SQL_DATE_STRUCT *)odbcData).year,
 398                    (*(SQL_DATE_STRUCT *)odbcData).month,
 399                    (*(SQL_DATE_STRUCT *)odbcData).day);
 400             stmt->setDateParam(paramNo, dt);
 401             break;
 402         }
 403         case typeTime: {
 404             Time tm;
 405             tm.set((*(SQL_TIME_STRUCT *)odbcData).hour,
 406                    (*(SQL_TIME_STRUCT *)odbcData).minute,
 407                    (*(SQL_TIME_STRUCT *)odbcData).second);
 408             stmt->setTimeParam(paramNo, tm);
 409             break;
 410         }
 411         case typeTimeStamp: {
 412             TimeStamp ts;
 413             ts.setDate((*(SQL_TIMESTAMP_STRUCT *)odbcData).year,
 414                        (*(SQL_TIMESTAMP_STRUCT *)odbcData).month,
 415                        (*(SQL_TIMESTAMP_STRUCT *)odbcData).day);
 416             ts.setTime((*(SQL_TIMESTAMP_STRUCT*)odbcData).hour,
 417                        (*(SQL_TIMESTAMP_STRUCT *)odbcData).minute,
 418                        (*(SQL_TIMESTAMP_STRUCT *)odbcData).second);
 419             stmt->setTimeStampParam(paramNo, ts);
 420             break;
 421         }
 422    }
 423
 424 }
 425
 426 //Copies data from the database onto the application buffer
 427 //Called from SQLFetch
 428 //Destination here can be the actual application buffer or
 429 //it may be ipd_
 430 SQLINTEGER copyToOdbc(void *odbcData,SQLUINTEGER odbcLen,void *sourceData,SQLUINTEGER sourceLen,SQLSMALLINT type, SQLSMALLINT apptype)
 431 {
 432     SQLINTEGER ind;
 433     if(odbcData == NULL || sourceData == NULL)
 434         return -1;
 435     if( apptype == typeString && type != apptype){
 436         AllDataType::convertToString(odbcData , sourceData,(DataType) type);
 437         if(sourceLen < odbcLen) return sourceLen;
 438         else return odbcLen;
 439     }
 440     switch( type )
 441     {
 442         case typeShort:
 443             *(short*)odbcData = *(short*)sourceData;
 444             break;
 445
 446         case typeInt:
 447             *(int*)odbcData = *(int*)sourceData;
 448             break;
 449
 450         case typeLong:
 451             *(long*)odbcData = *(long*)sourceData;
 452             break;
 453
 454         case typeLongLong:
 455             *(long long*)odbcData = *(long long*)sourceData;
 456             break;
 457
 458         case typeByteInt:
 459             *(char*)odbcData = *(char*)sourceData;
 460             break;
 461
 462 //        case csqlSqlTbit:
 463 //            CSqlOdbcError::printDbg("copyToOdbc");
 464 //            *(unsigned char*)odbcData = *(unsigned char*)sourceData;
 465 //            break;
 466
 467         case typeFloat:
 468             *(float*)odbcData = *(float*)sourceData;
 469             break;
 470         case typeDouble:
 471             *(double*)odbcData = *(double*)sourceData;
 472             break;
 473         case typeDecimal:
 474
 475 //        case csqlSqlTlongDouble:
 476 //        case csqlSqlTnumeric:
 477             *(long double*)odbcData = *(long double*)sourceData;
 478             break;
 479         case typeString:
 480 //      case csqlSqlTvarString:
 481             if(sourceLen < odbcLen)
 482             {
 483                 strcpy((char*)odbcData,(char*)sourceData);
 484                 ind=strlen((char*)odbcData)+1;
 485             }
 486             else
 487             {
 488                 strncpy((char*)odbcData,(char*)sourceData ,odbcLen);
 489                 ind=odbcLen;
 490             }
 491             *((char *)odbcData+ind-1)='\0';
 492             break;
 493         case typeDate:
 494             (*(SQL_DATE_STRUCT *)odbcData).year = (*(Date *)sourceData).year();
 495             (*(SQL_DATE_STRUCT *)odbcData).month= (*(Date *)sourceData).month();
 496             (*(SQL_DATE_STRUCT *)odbcData).day = (*(Date *)sourceData).dayOfMonth();
 497             break;
 498         case typeTime:
 499             (*(SQL_TIME_STRUCT *)odbcData).hour = (*(Time *)sourceData).hours();
 500             (*(SQL_TIME_STRUCT *)odbcData).minute= (*(Time *)sourceData).minutes();
 501             (*(SQL_TIME_STRUCT *)odbcData).second = (*(Time *)sourceData).seconds();
 502             break;
 503         case typeTimeStamp:
 504             (*(SQL_TIMESTAMP_STRUCT *)odbcData).year= (*(TimeStamp *)sourceData).year();
 505             (*(SQL_TIMESTAMP_STRUCT *)odbcData).month= (*(TimeStamp *)sourceData).month();
 506             (*(SQL_TIMESTAMP_STRUCT *)odbcData).day= (*(TimeStamp *)sourceData).dayOfMonth();
 507             (*(SQL_TIMESTAMP_STRUCT *)odbcData).hour = (*(TimeStamp *)sourceData).hours();
 508             (*(SQL_TIMESTAMP_STRUCT *)odbcData).minute= (*(TimeStamp *)sourceData).minutes();
 509             (*(SQL_TIMESTAMP_STRUCT *)odbcData).second = (*(TimeStamp *)sourceData).seconds();
 510             break;
 511         case typeBinary:
 512 //        case csqlSqlTvarBinary:
 513 //            CSqlOdbcError::printDbg("copyToOdbc");
 514 //            memset((unsigned char*)odbcData,0,odbcLen);
 515             if(sourceLen < odbcLen)
 516             {
 517                 memcpy( (unsigned char*)odbcData , (unsigned char*)sourceData,sourceLen);
 518                 ind=sourceLen;
 519             }
 520             else
 521             {
 522                 memcpy( (unsigned char*)odbcData , (unsigned char*)sourceData,odbcLen);
 523                 ind=odbcLen;
 524             }
 525             break;
 526     }
 527     return ind;
 528 }
 529 bool isFunctionSupports(SQLUSMALLINT type)
 530 {
 531     switch(type)
 532     {
 533         case SQL_API_SQLALLOCHANDLE:
 534         {
 535             return true;
 536         }
 537         case SQL_API_SQLGETDESCFIELD:
 538         {
 539             return false;
 540         }
 541         case SQL_API_SQLBINDCOL:
 542         {
 543             return true;
 544         }
 545         case SQL_API_SQLGETDESCREC:
 546         {
 547             return false;
 548         }
 549         case SQL_API_SQLCANCEL:
 550         {
 551             return false;
 552         }
 553         case SQL_API_SQLGETDIAGFIELD:
 554         {
 555             return false;
 556         }
 557         case SQL_API_SQLCLOSECURSOR:
 558         {
 559             return true;
 560         }
 561         case SQL_API_SQLGETDIAGREC:
 562         {
 563             return true;
 564         }
 565         case SQL_API_SQLCOLATTRIBUTE:
 566         {
 567             return true;
 568         }
 569         case SQL_API_SQLGETENVATTR:
 570         {
 571             return false;
 572         }
 573         case SQL_API_SQLCONNECT:
 574         {
 575             return true;
 576         }
 577         case SQL_API_SQLGETFUNCTIONS:
 578         {
 579             return true;
 580         }
 581         case SQL_API_SQLCOPYDESC:
 582         {
 583             return false;
 584         }
 585         case SQL_API_SQLGETINFO:
 586         {
 587             return true;
 588         }
 589         case SQL_API_SQLDATASOURCES:
 590         {
 591             return false;
 592         }
 593         case SQL_API_SQLGETSTMTATTR:
 594         {
 595             return true;
 596         }
 597         case SQL_API_SQLDESCRIBECOL:
 598         {
 599             return true;
 600         }
 601         case SQL_API_SQLGETTYPEINFO:
 602         {
 603             return true;
 604         }
 605         case SQL_API_SQLDISCONNECT:
 606         {
 607             return true;
 608         }
 609         case SQL_API_SQLNUMRESULTCOLS:
 610         {
 611             return true;
 612         }
 613         case SQL_API_SQLDRIVERS:
 614         {
 615             return false;
 616         }
 617         case SQL_API_SQLPARAMDATA:
 618         {
 619             return false;
 620         }
 621         case SQL_API_SQLENDTRAN:
 622         {
 623             return true;
 624         }
 625         case SQL_API_SQLPREPARE:
 626         {
 627             return true;
 628         }
 629         case SQL_API_SQLEXECDIRECT:
 630         {
 631             return true;
 632         }
 633         case SQL_API_SQLPUTDATA:
 634         {
 635             return false;
 636         }
 637         case SQL_API_SQLEXECUTE:
 638         {
 639             return true;
 640         }
 641         case SQL_API_SQLROWCOUNT:
 642         {
 643             return true;
 644         }
 645         case SQL_API_SQLFETCH:
 646         {
 647             return true;
 648         }
 649         case SQL_API_SQLSETCONNECTATTR:
 650         {
 651             return true;
 652         }
 653         case SQL_API_SQLFETCHSCROLL:
 654         {
 655             return false;
 656         }
 657         case SQL_API_SQLSETCURSORNAME:
 658         {
 659             return false;
 660         }
 661         case SQL_API_SQLFREEHANDLE:
 662         {
 663             return true;
 664         }
 665         case SQL_API_SQLSETDESCFIELD:
 666         {
 667             return false;
 668         }
 669         case SQL_API_SQLFREESTMT:
 670         {
 671             return true;
 672         }
 673         case SQL_API_SQLSETDESCREC:
 674         {
 675             return false;
 676         }
 677         case SQL_API_SQLGETCONNECTATTR:
 678         {
 679             return true;
 680         }
 681         case SQL_API_SQLSETENVATTR:
 682         {
 683             return true;
 684         }
 685         case SQL_API_SQLGETCURSORNAME:
 686         {
 687             return false;
 688         }
 689         case SQL_API_SQLSETSTMTATTR:
 690         {
 691             return true;
 692         }
 693         case SQL_API_SQLGETDATA:
 694         {
 695             return true;
 696         }
 697         case SQL_API_SQLCOLUMNS:
 698         {
 699             return true;
 700         }
 701         case SQL_API_SQLSTATISTICS:
 702         {
 703             return true;
 704         }
 705         case SQL_API_SQLSPECIALCOLUMNS:
 706         {
 707             return false;
 708         }
 709         case SQL_API_SQLTABLES:
 710         {
 711             return true;
 712         }
 713         case SQL_API_SQLBINDPARAMETER:
 714         {
 715             return true;
 716         }
 717         case SQL_API_SQLNATIVESQL:
 718         {
 719             return false;
 720         }
 721         case SQL_API_SQLBROWSECONNECT:
 722         {
 723             return false;
 724         }
 725         case SQL_API_SQLNUMPARAMS:
 726         {
 727             return true;
 728         }
 729         case SQL_API_SQLPRIMARYKEYS:
 730         {
 731             return true;
 732         }
 733         case SQL_API_SQLCOLUMNPRIVILEGES:
 734         {
 735             return false;
 736         }
 737         case SQL_API_SQLPROCEDURECOLUMNS:
 738         {
 739             return false;
 740         }
 741         case SQL_API_SQLDESCRIBEPARAM:
 742         {
 743             return true;
 744         }
 745         case SQL_API_SQLPROCEDURES:
 746         {
 747             return false;
 748         }
 749         case SQL_API_SQLDRIVERCONNECT:
 750         {
 751             return true;
 752         }
 753         case SQL_API_SQLSETPOS:
 754         {
 755             return false;
 756         }
 757         case SQL_API_SQLFOREIGNKEYS:
 758         {
 759             return true;
 760         }
 761         case SQL_API_SQLTABLEPRIVILEGES:
 762         {
 763             return false;
 764         }
 765         case SQL_API_SQLMORERESULTS:
 766         {
 767             return false;
 768         }
 769         default :
 770             return false;
 771     }
 772
 773 }