src/odbc/odbcStmt.cxx

   1
   2 // Class CSqlOdbcStmt
   3 // Description: Statement Handle manager.
   4
   5 #include "odbcCommon.h"
   6
   7 // Constructor
   8 CSqlOdbcStmt::CSqlOdbcStmt( void ) :
   9     handleType_( SQL_HANDLE_STMT ),
  10     parentDbc_( 0 ),
  11     state_( S1 ),
  12     err_( SQL_HANDLE_STMT ),
  13     rowsAffected_( -1 ),
  14     isParamBound_( true ),
  15     isPrepared_( false ),
  16     apd_(SQL_DESC_APP),
  17     ipd_(SQL_DESC_IMP),
  18     ard_(SQL_DESC_APP),
  19     ird_(SQL_DESC_IMP),
  20     fsqlStmt_( NULL )
  21     //HACK::
  22     //fetchMode_(SQL_FETCH_SINGLE_TUPLE)
  23 {
  24     cursorName_[0] = '\0';
  25 }
  26
  27 SQLRETURN SQLAllocStmt(
  28     SQLHDBC ConnectionHandle,
  29     SQLHSTMT *StatementHandle)
  30 {
  31     return( CSqlOdbcStmt::SQLAllocHandle( ConnectionHandle, StatementHandle ) );
  32 }
  33
  34 SQLRETURN CSqlOdbcStmt::SQLAllocHandle(
  35     SQLHANDLE   inputHandle,    // IN
  36     SQLHANDLE   *outputHandle ) // OUT
  37 {
  38     CSqlOdbcDbc *inputDbc = (CSqlOdbcDbc*) inputHandle;
  39
  40     // Is Dbc valid ?
  41     if( isValidHandle( inputDbc, SQL_HANDLE_DBC ) != SQL_SUCCESS )
  42         return( SQL_INVALID_HANDLE );
  43
  44     // Is Dbc connected ?
  45     if( inputDbc->state_ < C4 )
  46     {
  47         globalError.set( ERROR_CONNOTOPEN );
  48         globalError.printStr( SQL_OV_ODBC3 );
  49         return( SQL_ERROR );
  50     }
  51
  52     // Allocate Statement object.
  53     *outputHandle = (SQLHANDLE*) new CSqlOdbcStmt;
  54     if( *outputHandle == NULL )
  55     {
  56         globalError.set( ERROR_MEMALLOC );
  57         globalError.printStr( SQL_OV_ODBC3 );
  58         return( SQL_ERROR );
  59     }
  60
  61     // Initialize relation b/w Stmt and Dbc
  62     inputDbc->stmtList_.append(*outputHandle );
  63     inputDbc->stmtHdlList_.append(outputHandle);
  64     if( inputDbc->state_ <= C4 )
  65         inputDbc->state_ = C5;
  66     ((CSqlOdbcStmt*) *outputHandle)->parentDbc_ = inputDbc;
  67     //CSqlOdbcError::printDbg("proxy:stmt:setConnection");
  68     //((CSqlOdbcStmt*) *outputHandle)->fsqlStmt_->setConnection( inputDbc->fsqlConn_ );
  69      ((CSqlOdbcStmt*) *outputHandle)->fInfo = new FieldInfo();
  70     return( SQL_SUCCESS );
  71 }
  72
  73 SQLRETURN CSqlOdbcStmt::SQLFreeHandle(
  74     SQLHANDLE inputHandle)      // IN
  75 {
  76     CSqlOdbcStmt *inputStmt = (CSqlOdbcStmt*) inputHandle;
  77
  78     // Is Stmt valid ?
  79     if( isValidHandle( inputStmt, SQL_HANDLE_STMT ) != SQL_SUCCESS )
  80         return( SQL_INVALID_HANDLE );
  81
  82     // Can we proceed ?
  83     if( inputStmt->chkStateForSQLFreeHandle() != SQL_SUCCESS )
  84         return( SQL_ERROR );
  85
  86     // Free resultset
  87     inputStmt->resetStmt();
  88
  89     // Remove Stmt from Parent Dbc.
  90     ListIterator iter = inputStmt->parentDbc_->stmtList_.getIterator();
  91     CSqlOdbcStmt *stmtElem = NULL;
  92     while (iter.hasElement()) {
  93         stmtElem = (CSqlOdbcStmt *) iter.nextElement();
  94         if( stmtElem == inputStmt ) {
  95             iter.reset();
  96             inputStmt->parentDbc_->stmtList_.remove(stmtElem);
  97             break;
  98         }
  99     }
 100     // Set Dbc state_ = no statement.
 101     if( inputStmt->parentDbc_->stmtList_.size() == 0 )
 102             inputStmt->parentDbc_->state_ = C4;
 103
 104     inputStmt->handleType_ = -1; // Make object invalid.
 105     SQLHANDLE *elem;
 106     ListIterator it = inputStmt->parentDbc_->stmtHdlList_.getIterator();
 107     while (it.hasElement()) {
 108         elem = (SQLHANDLE *) it.nextElement();
 109         if(*elem == inputStmt) *elem = NULL;
 110     }
 111     inputStmt->parentDbc_->stmtHdlList_.remove(elem);
 112     delete inputStmt->fInfo;
 113     delete inputStmt;            // Delete Stmt.
 114     return( SQL_SUCCESS );
 115 }
 116
 117 SQLRETURN SQLFreeStmt(
 118     SQLHSTMT StatementHandle,   // IN
 119     SQLUSMALLINT Option)        // IN
 120 {
 121 #ifdef DEBUG
 122     printError(ErrWarning, "SQLFreeStmt opt:%d", Option);
 123 #endif
 124     // Is Stmt valid ?
 125     if( isValidHandle( (CSqlOdbcStmt*) StatementHandle, SQL_HANDLE_STMT ) != SQL_SUCCESS )
 126         return( SQL_INVALID_HANDLE );
 127
 128     // Free Handle
 129     if( Option == SQL_DROP )
 130         return( CSqlOdbcStmt::SQLFreeHandle( StatementHandle ) );
 131
 132     return( ((CSqlOdbcStmt*) StatementHandle)->SQLFreeStmt( Option ) );
 133 }
 134
 135 SQLRETURN CSqlOdbcStmt::SQLFreeStmt(
 136             SQLUSMALLINT option)
 137 {
 138     // Start with NO_ERR
 139     err_.set( NO_ERR );
 140
 141     // Can we proceed
 142     if( chkStateForSQLFreeStmt() != SQL_SUCCESS )
 143         return( SQL_ERROR );
 144     if (!fsqlStmt_) return (SQL_SUCCESS);
 145     switch( option )
 146     {
 147         case SQL_CLOSE:         // // Free resultset
 148                                 // if( fsqlStmt_->isSelect() == true ) // CSQL
 149                                 // {
 150                                 //    //CSqlOdbcError::printDbg("proxy:stmt:getResultSet");
 151                                 //    CSqlResultSet *resultSet_ = fsqlStmt_->getResultSet(); // CSQL
 152                                 //    if( resultSet_ && resultSet_->isOpen() == true )
 153                                 //    {
 154                                 //        resultSet_->close();
 155                                 //    }
 156                                 // }
 157
 158                                 // cursor states
 159                                 if( isPrepared_ )
 160                                 {
 161                                     if( fsqlStmt_->isSelect() == true ) { // CSQL
 162                                         fsqlStmt_->close();
 163                                         state_ = S3;    // With Cursor
 164                                     }
 165                                     else
 166                                         state_ = S2;    // Without Cursor
 167                                 }
 168                                 else
 169                                 {
 170                                     ard_.freeAllDesc();
 171                                     apd_.freeAllDesc();
 172                                     ipd_.freeAllDesc();
 173                                     ird_.freeAllDesc();
 174                                     fsqlStmt_->free(); // CSQL
 175                                     state_ = S1;
 176                                 }
 177
 178                                 break;
 179
 180         case SQL_UNBIND:        ard_.freeAllDesc();
 181                                 ird_.freeAllDesc();
 182                                 break;
 183
 184         case SQL_RESET_PARAMS:  apd_.freeAllDesc();
 185                                 ipd_.freeAllDesc();
 186                                 //isParamBound_ = false;
 187                                 break;
 188
 189         default: err_.set( ERROR_OPTRANGE );
 190                 return( SQL_ERROR );
 191     }
 192     return( SQL_SUCCESS );
 193 }
 194
 195 SQLRETURN SQLBindCol(
 196     SQLHSTMT        StatementHandle,
 197     SQLUSMALLINT    ColumnNumber,
 198     SQLSMALLINT     TargetType,
 199     SQLPOINTER      TargetValue,
 200     SQLINTEGER      BufferLength,
 201     SQLINTEGER      *StrLen_or_Ind)
 202 {
 203 #ifdef DEBUG
 204     printError(ErrWarning, "SQLBindCol");
 205 #endif
 206     // Is Stmt valid ?
 207     if( isValidHandle( (CSqlOdbcStmt*) StatementHandle, SQL_HANDLE_STMT ) != SQL_SUCCESS )
 208         return( SQL_INVALID_HANDLE );
 209
 210     return( ((CSqlOdbcStmt*) StatementHandle)->SQLBindCol( ColumnNumber,
 211         TargetType, TargetValue, BufferLength, StrLen_or_Ind ) );
 212 }
 213
 214 SQLRETURN CSqlOdbcStmt::SQLBindCol(
 215     SQLUSMALLINT columnNumber,
 216     SQLSMALLINT targetType,
 217     SQLPOINTER targetValue,
 218     SQLINTEGER bufferLength,
 219     SQLINTEGER *ind)
 220 {
 221     CSqlOdbcDesc *bindDesc = 0;
 222     CSqlOdbcDesc *inputDesc = 0;
 223     SQLRETURN found = SQL_ERROR;
 224
 225     // Start with NO_ERR
 226     err_.set( NO_ERR );
 227
 228     // Can we proceed ?
 229     if( chkStateForSQLBindCol() != SQL_SUCCESS )
 230         return( SQL_ERROR );
 231
 232     // Invalid Buffer Length.
 233     switch( targetType )
 234     {
 235         // switch is in order to support more types.
 236         case SQL_C_CHAR:
 237             if( bufferLength < 0 && bufferLength != SQL_NTS )
 238             {
 239                 err_.set( ERROR_BUFLEN );
 240                 return( SQL_ERROR );
 241             }
 242             break;
 243             case SQL_C_BINARY:
 244            if( bufferLength < 0 && bufferLength != SQL_NTS )
 245             {
 246                 err_.set( ERROR_BUFLEN );
 247                 return( SQL_ERROR );
 248             }
 249            break;
 250     }
 251
 252     // Invalid Column Number
 253     if( columnNumber < 1 )
 254     {
 255         err_.set( ERROR_COLNUM );
 256         return( SQL_ERROR );
 257     }
 258
 259     // Get the Descriptor if already exists
 260     found = ard_.getDescWithColNum( columnNumber , &bindDesc );
 261
 262     // UNBIND
 263     if( targetValue == 0 )
 264     {
 265         if( found != SQL_SUCCESS )
 266         {
 267             err_.set( ERROR_COLNUM );
 268             return( SQL_ERROR );
 269         }
 270         ard_.delDesc( bindDesc );    // UNBIND
 271
 272         return( SQL_SUCCESS );
 273     }
 274
 275     // Validate target Type, Value and Column no.
 276     if( targetValue == 0 || isValidCType( targetType ) != SQL_SUCCESS )
 277     {
 278         err_.set( ERROR_INVBUFTYPE );
 279         return( SQL_ERROR );
 280     }
 281
 282     // Add new descriptor
 283     if( found != SQL_SUCCESS )
 284     {
 285         bindDesc = new CSqlOdbcDesc();
 286         ard_.descList_.append(bindDesc);
 287     }
 288
 289     // Initialize Descriptor.
 290     bindDesc->col_ = columnNumber;
 291     bindDesc->cType_ = targetType;
 292     bindDesc->dataPtr_ = targetValue;
 293     bindDesc->length_ = (SQLUINTEGER) bufferLength;
 294     bindDesc->indPtr_ = (SQLPOINTER) ind;
 295
 296     found = ird_.getDescWithColNum( columnNumber , &inputDesc );
 297
 298     // Add new descriptor
 299     if( found != SQL_SUCCESS )
 300     {
 301         inputDesc = new CSqlOdbcDesc();
 302         ird_.descList_.append(inputDesc);
 303     }
 304     ResultSetPlan pl = fsqlStmt_->getResultSetPlan();
 305     //Get Field Information from CSQL
 306     fsqlStmt_->getProjFldInfo(columnNumber, fInfo);
 307     // Initialize input Descriptor.
 308     //DataType sourceType = getCSqlType( targetType );
 309     //char fldName[IDENTIFIER_LENGTH];
 310     //Table::getFieldNameAlone((char*)fInfo->fldName,fldName);
 311     strcpy((char *)inputDesc->colName_,(char*)fInfo->fldName);
 312     inputDesc->col_ = columnNumber;
 313     if( pl == GetColumns && columnNumber == 5) {
 314         inputDesc->csqlType_ = typeShort;
 315         inputDesc->cType_ = typeShort;
 316     }
 317     else {
 318         inputDesc->csqlType_ = fInfo->type;
 319         inputDesc->cType_ = fInfo->type;
 320     }
 321     getInputBuffer(&inputDesc->dataPtr_ ,fInfo->type,(SQLUINTEGER) bufferLength);
 322     inputDesc->length_ = fInfo->length;
 323     inputDesc->indPtr_ = (SQLPOINTER) ind;
 324     return( SQL_SUCCESS );
 325 }
 326
 327 SQLRETURN SQLSetParam(
 328     SQLHSTMT StatementHandle,
 329     SQLUSMALLINT ParameterNumber,
 330     SQLSMALLINT ValueType,
 331     SQLSMALLINT ParameterType,
 332     SQLUINTEGER LengthPrecision,
 333     SQLSMALLINT ParameterScale,
 334     SQLPOINTER ParameterValue,
 335     SQLINTEGER *StrLen_or_Ind)
 336 {
 337 #ifdef DEBUG
 338     printError(ErrWarning, "SQLSetParam");
 339 #endif
 340
 341     return( SQLBindParameter( StatementHandle, ParameterNumber,
 342         SQL_PARAM_INPUT_OUTPUT, ValueType, ParameterType, LengthPrecision,
 343         ParameterScale, ParameterValue, 0, StrLen_or_Ind) );
 344 }
 345
 346 SQLRETURN SQLBindParam(
 347     SQLHSTMT StatementHandle,
 348     SQLUSMALLINT ParameterNumber,
 349     SQLSMALLINT ValueType,
 350     SQLSMALLINT ParameterType,
 351     SQLUINTEGER LengthPrecision,
 352     SQLSMALLINT ParameterScale,
 353     SQLPOINTER ParameterValue,
 354     SQLINTEGER *StrLen_or_Ind)
 355 {
 356 #ifdef DEBUG
 357     printError(ErrWarning, "SQLBindParam");
 358 #endif
 359
 360     return( SQLBindParameter( StatementHandle, ParameterNumber,
 361         SQL_PARAM_INPUT_OUTPUT, ValueType, ParameterType, LengthPrecision,
 362         ParameterScale, ParameterValue, 0, StrLen_or_Ind) );
 363 }
 364
 365 SQLRETURN SQLBindParameter(
 366     SQLHSTMT StatementHandle,
 367     SQLUSMALLINT ParameterNumber,
 368     SQLSMALLINT InputOutputType,
 369     SQLSMALLINT ValueType,
 370     SQLSMALLINT ParameterType,
 371     SQLUINTEGER LengthPrecision,
 372     SQLSMALLINT ParameterScale,
 373     SQLPOINTER ParameterValue,
 374     SQLINTEGER BufferLength,
 375     SQLINTEGER *StrLen_or_Ind)
 376 {
 377 #ifdef DEBUG
 378     printError(ErrWarning, "SQLBindParameter");
 379 #endif
 380     // Is Stmt valid ?
 381     if( isValidHandle( (CSqlOdbcStmt*) StatementHandle, SQL_HANDLE_STMT ) != SQL_SUCCESS )
 382         return( SQL_INVALID_HANDLE );
 383
 384     return( ((CSqlOdbcStmt*) StatementHandle)->SQLBindParameter( ParameterNumber,
 385         InputOutputType, ValueType,
 386         ParameterType, LengthPrecision,
 387         ParameterScale, ParameterValue,
 388         BufferLength, StrLen_or_Ind ) );
 389 }
 390
 391 SQLRETURN CSqlOdbcStmt::SQLBindParameter(
 392     SQLUSMALLINT parameterNumber,
 393     SQLSMALLINT inputOutputType,
 394     SQLSMALLINT valueType,
 395     SQLSMALLINT parameterType,
 396     SQLUINTEGER lengthPrecision,
 397     SQLSMALLINT parameterScale,
 398     SQLPOINTER parameterValue,
 399     SQLINTEGER bufferLength,
 400     SQLINTEGER *ind)
 401 {
 402     CSqlOdbcDesc *bindDesc = 0;
 403     CSqlOdbcDesc *inputDesc =0;
 404     SQLRETURN found;
 405
 406     // Start with NO_ERR
 407     err_.set( NO_ERR );
 408
 409     // Can we proceed ?
 410     if( chkStateForSQLBindParameter() != SQL_SUCCESS )
 411         return( SQL_ERROR );
 412     // Invalid Buffer Length.
 413     switch( valueType )
 414     {
 415         // switch is in order to support more types.
 416         case SQL_C_CHAR:
 417             if( bufferLength < 0 && bufferLength != SQL_NTS )
 418             {
 419                 err_.set( ERROR_BUFLEN );
 420                 return( SQL_ERROR );
 421             }
 422             break;
 423         case SQL_C_BINARY:
 424             if( bufferLength < 0 && bufferLength != SQL_NTS )
 425             {
 426                 err_.set( ERROR_BUFLEN );
 427                 return( SQL_ERROR );
 428             }
 429             break;
 430     }
 431
 432     // Validate parameters
 433     switch( inputOutputType )
 434     {
 435         case SQL_PARAM_INPUT:
 436         case SQL_PARAM_OUTPUT:
 437         case SQL_PARAM_INPUT_OUTPUT: break;
 438         default: err_.set( ERROR_INV_PARAMTYPE );
 439                  return( SQL_ERROR );
 440     }
 441     if( isValidCType( valueType ) != SQL_SUCCESS )
 442 //        || isValidSQLType( parameterType ) != SQL_SUCCESS )
 443     {
 444         err_.set( ERROR_INVBUFTYPE );
 445         return( SQL_ERROR );
 446     }
 447     if( parameterNumber < 1 )
 448     {
 449         err_.set( ERROR_COLNUM );
 450         return( SQL_ERROR );
 451     }
 452
 453     // Get the Descriptor if already exists
 454     found = apd_.getDescWithColNum( parameterNumber , &bindDesc );
 455     if( found != SQL_SUCCESS )
 456     {
 457         bindDesc = new CSqlOdbcDesc();
 458         apd_.descList_.append(bindDesc);
 459         // Initialize Descriptor.
 460         bindDesc->col_ = parameterNumber;
 461         bindDesc->paramType_ = inputOutputType;
 462         bindDesc->cType_ = valueType;
 463         bindDesc->sqlType_ = parameterType;
 464         bindDesc->dataPtr_ = parameterValue;
 465         bindDesc->length_ = (SQLUINTEGER) bufferLength;
 466         bindDesc->precision_ =(short) lengthPrecision;
 467         bindDesc->scale_ = parameterScale;
 468         bindDesc->indPtr_ = (SQLPOINTER) ind;
 469     }
 470     found = ipd_.getDescWithColNum (parameterNumber, &inputDesc);
 471     if( found != SQL_SUCCESS )
 472     {
 473         inputDesc =  new CSqlOdbcDesc();
 474         ipd_.descList_.append(inputDesc);
 475         //Initialize inputDescriptor
 476         DataType destType=getCSqlType(valueType);
 477         inputDesc->col_ = parameterNumber;
 478         inputDesc->paramType_ = inputOutputType;
 479         inputDesc->cType_ = valueType;
 480         inputDesc->sqlType_ = parameterType;
 481         inputDesc->dataPtr_= NULL;
 482         //getInputBuffer(&inputDesc->dataPtr_,destType,(SQLUINTEGER)bufferLength);
 483         inputDesc->length_ = (SQLUINTEGER) bufferLength;
 484         inputDesc->precision_ = (short)lengthPrecision;
 485         inputDesc->scale_ = parameterScale;
 486         inputDesc->indPtr_ = (SQLPOINTER) ind;
 487     }
 488     //isParamBound_ = false;
 489     return( SQL_SUCCESS );
 490 }
 491
 492 SQLRETURN SQLExecDirect(
 493     SQLHSTMT StatementHandle,   // IN
 494     SQLCHAR *StatementText,     // IN
 495     SQLINTEGER TextLength)      // IN
 496 {
 497 #ifdef DEBUG
 498     printError(ErrWarning, "SQLExecDirect: %s", StatementText);
 499 #endif
 500
 501     // Is Stmt valid ?
 502     if( isValidHandle( (CSqlOdbcStmt*) StatementHandle, SQL_HANDLE_STMT ) != SQL_SUCCESS )
 503         return( SQL_INVALID_HANDLE );
 504
 505     // Prepare
 506     return( ((CSqlOdbcStmt*) StatementHandle)->SQLExecDirect( StatementText, TextLength ) );
 507 }
 508
 509 SQLRETURN CSqlOdbcStmt::SQLExecDirect(
 510     SQLCHAR *statementText,     // IN
 511     SQLINTEGER textLength)      // IN
 512 {
 513     // Start with NO_ERR
 514     err_.set( NO_ERR );
 515
 516     // Can we proceed ?
 517     if( chkStateForSQLPrepare() != SQL_SUCCESS )
 518         return( SQL_ERROR );
 519
 520     // Invalid Buffer Length.
 521     if( textLength < 0  && textLength != SQL_NTS )
 522     {
 523         err_.set( ERROR_BUFLEN );
 524         return( SQL_ERROR );
 525     }
 526
 527     // If Stmt is already prepared.
 528     if( state_ >= S2 ) {
 529         resetStmt();
 530     }
 531
 532     if (parentDbc_->mode_ ==1)
 533         fsqlStmt_ = SqlFactory::createStatement(CSql);
 534     else if (parentDbc_->mode_ ==2)
 535         fsqlStmt_ = SqlFactory::createStatement(CSqlAdapter);
 536     else if (parentDbc_->mode_ ==3)
 537         fsqlStmt_ = SqlFactory::createStatement(CSqlGateway);
 538     else if (parentDbc_->mode_ ==4)
 539         fsqlStmt_ = SqlFactory::createStatement(CSqlNetwork);
 540     else if (parentDbc_->mode_ ==5)
 541         fsqlStmt_ = SqlFactory::createStatement(CSqlNetworkAdapter);
 542     else if (parentDbc_->mode_ ==6)
 543         fsqlStmt_ = SqlFactory::createStatement(CSqlNetworkGateway);
 544     fsqlStmt_->setConnection( parentDbc_->fsqlConn_ );
 545     // Prepare
 546     //CSqlOdbcError::printDbg("proxy:stmt:prepare");
 547     DbRetVal rv=OK;
 548     if( (rv=fsqlStmt_->executeDirect( (char*) statementText ))!= OK) // CSQL
 549     {
 550         state_ = S1;
 551         resetStmt();
 552         //err_.set(ERROR_GENERAL);
 553         switch(rv)
 554         {
 555             case ErrNotExists: err_.set( ERROR_TBLNOTFOUND); break;
 556             case ErrNotFound: err_.set( ERROR_NO_COLEXISTS); break;
 557             case ErrAlready: err_.set( ERROR_TBLEXISTS); break;
 558             case ErrSyntaxError:err_.set(ERROR_SQL_SYNTAX);break;
 559             case ErrSyntax:err_.set(ERROR_SQL_SYNTAX);break;
 560             /*case csqlSqlErrSchNotFound:  err_.set( ERROR_SCHNOTFOUND); break;
 561             case csqlSqlErrIndexNotFound: err_.set( ERROR_NO_IDXEXISTS); break;
 562             case csqlSqlErrViewNotFound: err_.set( ERROR_TBLNOTFOUND); break;
 563             case csqlSqlErrFldExists: err_.set( ERROR_COLEXISTS); break;
 564             case csqlSqlErrIndexExists: err_.set( ERROR_IDXEXISTS); break;
 565             case csqlSqlErrViewExists: err_.set( ERROR_TBLEXISTS); break;
 566             case csqlSqlErrTooManyVals:err_.set(ERROR_MANY_VALS);break;
 567             case csqlSqlErrTooFewVals:err_.set(ERROR_FEW_VALS);break;
 568             case csqlSqlErrIncompatibleType:err_.set(ERROR_TYPE_INCMP);break;
 569             case csqlSqlErrInvalidFormat:err_.set(ERROR_DATA_FORMAT);break;
 570             case csqlSqlErrDuplicateFld:err_.set(ERROR_DUP_COL);break;
 571             case csqlSqlErrSqlInternal:err_.set(ERROR_SQL_INT);break;*/
 572             default: err_.set(ERROR_GENERAL);
 573         }
 574         return( SQL_ERROR );
 575     }
 576
 577     //parentDbc_->state_ = C6;
 578     isPrepared_ = true;
 579     return( SQL_SUCCESS );
 580 }
 581
 582 SQLRETURN SQLPrepare(
 583     SQLHSTMT StatementHandle,   // IN
 584     SQLCHAR *StatementText,     // IN
 585     SQLINTEGER TextLength)      // IN
 586 {
 587 #ifdef DEBUG
 588     printError(ErrWarning, "SQLPrepare: %s", StatementText);
 589 #endif
 590
 591     // Is Stmt valid ?
 592     if( isValidHandle( (CSqlOdbcStmt*) StatementHandle, SQL_HANDLE_STMT ) != SQL_SUCCESS )
 593         return( SQL_INVALID_HANDLE );
 594
 595     // Prepare
 596     return( ((CSqlOdbcStmt*) StatementHandle)->SQLPrepare( StatementText, TextLength ) );
 597 }
 598
 599 SQLRETURN CSqlOdbcStmt::SQLPrepare(
 600     SQLCHAR *statementText,     // IN
 601     SQLINTEGER textLength)      // IN
 602 {
 603     // Start with NO_ERR
 604     err_.set( NO_ERR );
 605
 606     // Can we proceed ?
 607     if( chkStateForSQLPrepare() != SQL_SUCCESS )
 608         return( SQL_ERROR );
 609
 610     // Invalid Buffer Length.
 611     if( textLength < 0  && textLength != SQL_NTS )
 612     {
 613         err_.set( ERROR_BUFLEN );
 614         return( SQL_ERROR );
 615     }
 616
 617     // If Stmt is already prepared.
 618     if( state_ >= S2 ) {
 619         resetStmt();
 620     }
 621
 622     if (parentDbc_->mode_ ==1)
 623         fsqlStmt_ = SqlFactory::createStatement(CSql);
 624     else if (parentDbc_->mode_ ==2)
 625         fsqlStmt_ = SqlFactory::createStatement(CSqlAdapter);
 626     else if (parentDbc_->mode_ ==3)
 627         fsqlStmt_ = SqlFactory::createStatement(CSqlGateway);
 628     else if (parentDbc_->mode_ ==4)
 629         fsqlStmt_ = SqlFactory::createStatement(CSqlNetwork);
 630     else if (parentDbc_->mode_ ==5)
 631         fsqlStmt_ = SqlFactory::createStatement(CSqlNetworkAdapter);
 632     else if (parentDbc_->mode_ ==6)
 633         fsqlStmt_ = SqlFactory::createStatement(CSqlNetworkGateway);
 634     fsqlStmt_->setConnection( parentDbc_->fsqlConn_ );
 635     // Prepare
 636     //CSqlOdbcError::printDbg("proxy:stmt:prepare");
 637     DbRetVal rv=OK;
 638     if( (rv=fsqlStmt_->prepare( (char*) statementText ))!= OK) // CSQL
 639     {
 640         state_ = S1;
 641         resetStmt();
 642         //err_.set(ERROR_GENERAL);
 643         switch(rv)
 644         {
 645             case ErrNotExists: err_.set( ERROR_TBLNOTFOUND); break;
 646             case ErrNotFound: err_.set( ERROR_NO_COLEXISTS); break;
 647             case ErrAlready: err_.set( ERROR_TBLEXISTS); break;
 648             case ErrSyntaxError:err_.set(ERROR_SQL_SYNTAX);break;
 649             case ErrSyntax:err_.set(ERROR_SQL_SYNTAX);break;
 650             /*case csqlSqlErrSchNotFound:  err_.set( ERROR_SCHNOTFOUND); break;
 651             case csqlSqlErrIndexNotFound: err_.set( ERROR_NO_IDXEXISTS); break;
 652             case csqlSqlErrViewNotFound: err_.set( ERROR_TBLNOTFOUND); break;
 653             case csqlSqlErrFldExists: err_.set( ERROR_COLEXISTS); break;
 654             case csqlSqlErrIndexExists: err_.set( ERROR_IDXEXISTS); break;
 655             case csqlSqlErrViewExists: err_.set( ERROR_TBLEXISTS); break;
 656             case csqlSqlErrTooManyVals:err_.set(ERROR_MANY_VALS);break;
 657             case csqlSqlErrTooFewVals:err_.set(ERROR_FEW_VALS);break;
 658             case csqlSqlErrIncompatibleType:err_.set(ERROR_TYPE_INCMP);break;
 659             case csqlSqlErrInvalidFormat:err_.set(ERROR_DATA_FORMAT);break;
 660             case csqlSqlErrDuplicateFld:err_.set(ERROR_DUP_COL);break;
 661             case csqlSqlErrSqlInternal:err_.set(ERROR_SQL_INT);break;*/
 662             default: err_.set(ERROR_GENERAL);
 663         }
 664         return( SQL_ERROR );
 665     }
 666     if( fsqlStmt_->isSelect() != true ) // CSQL
 667         state_ = S2;    // With cursor
 668     else
 669         state_ = S3;    // Without cursor
 670
 671     //parentDbc_->state_ = C6;
 672     isPrepared_ = true;
 673     return( SQL_SUCCESS );
 674 }
 675
 676 SQLRETURN SQLExecute(SQLHSTMT StatementHandle) // IN
 677 {
 678 #ifdef DEBUG
 679     printError(ErrWarning, "SQLExecute");
 680 #endif
 681
 682     // Is Stmt valid ?
 683     if( isValidHandle( (CSqlOdbcStmt*) StatementHandle, SQL_HANDLE_STMT ) != SQL_SUCCESS )
 684         return( SQL_INVALID_HANDLE );
 685
 686     return( ((CSqlOdbcStmt*) StatementHandle)->SQLExecute() );
 687 }
 688
 689 SQLRETURN CSqlOdbcStmt::SQLExecute() // TODO
 690 {
 691     // Start with NO_ERR
 692     err_.set( NO_ERR );
 693     // Can we proceed ?
 694     if( chkStateForSQLExecute() != SQL_SUCCESS )
 695         return( SQL_ERROR );
 696
 697     if( fsqlStmt_->noOfParamFields() > 0 )
 698     {
 699
 700         // Iterate through all apd_;
 701         CSqlOdbcDesc *appParamDesc;
 702         ListIterator apdIter = apd_.descList_.getIterator();
 703         CSqlOdbcDesc *csqlParamDesc;
 704         ListIterator ipdIter = ipd_.descList_.getIterator();
 705
 706         //Get the source and the destination type
 707         DataType sourceType = typeUnknown,destType = typeUnknown;
 708         int paramNum=1,sourceLength=-1,destLength=-1;
 709         bool nullFlag=false;
 710
 711         while(apdIter.hasElement() || ipdIter.hasElement()) {
 712             appParamDesc= (CSqlOdbcDesc *) apdIter.nextElement();
 713             csqlParamDesc=(CSqlOdbcDesc *) ipdIter.nextElement();
 714             if(paramNum <= fsqlStmt_->noOfParamFields())
 715             {
 716                 if( fsqlStmt_->getParamFldInfo(paramNum, fInfo ) != OK ) return( SQL_ERROR );
 717                 sourceType=getCSqlType(appParamDesc->cType_);
 718                 destType=fInfo->type;
 719                 sourceLength=(int)appParamDesc->length_;
 720                 destLength=fInfo->length;
 721                 if(sourceType != typeUnknown && destType != typeUnknown)
 722                 {
 723                     //Check if NULL is inserted
 724                     if((appParamDesc->indPtr_ != NULL ) && (*(SQLINTEGER *)appParamDesc->indPtr_) == SQL_NULL_DATA)
 725                     {
 726                         fsqlStmt_->setNull(paramNum);
 727                     }
 728                     else
 729                     {
 730                         //Only if both types are not the same, then we need to copy it onto intermediate buffer
 731                         //Else no need
 732                         if( (sourceType == typeString || sourceType == typeBinary) && (sourceLength <= 0))
 733                         {
 734                             if((appParamDesc->indPtr_!= NULL) && *(SQLINTEGER *)appParamDesc->indPtr_ > 0)
 735                                 sourceLength=(int)(*(SQLINTEGER *)appParamDesc->indPtr_);
 736                             else if (appParamDesc->precision_ > 0)
 737                                 sourceLength=appParamDesc->precision_;
 738                             else
 739                             {
 740                                 err_.set( ERROR_BUFLEN );
 741                                 return SQL_ERROR;
 742                             }
 743                         }
 744                         if(destType == typeString) //|| destType == typeVarString)
 745                         {
 746                             //fsqlStmt_->allocParam(paramNum,sourceLength); // CSQL TODO
 747                             destLength=sourceLength;
 748                         }
 749                         if(sourceType == destType)
 750                                 //|| (sourceType == typeString && destType == typeVarString)
 751                                 //|| (sourceType == typeBinary && destType == typeVarBinary))
 752                         {
 753                             copyFromOdbc(fsqlStmt_, paramNum, destLength, appParamDesc->dataPtr_, sourceLength,destType); // CSQL TODO
 754                         } else
 755                         {
 756                             getInputBuffer(&csqlParamDesc->dataPtr_ ,destType,destLength);
 757                             AllDataType::convert(sourceType,appParamDesc->dataPtr_,destType,csqlParamDesc->dataPtr_, destLength);
 758                             copyFromOdbc(fsqlStmt_, paramNum, destLength, csqlParamDesc->dataPtr_, destLength, destType);
 759                         }
 760                     }
 761                 }
 762                 else
 763                 {
 764                     err_.set(ERROR_GENERAL);
 765                     return SQL_ERROR;
 766                 }
 767             }
 768             paramNum++;
 769         }
 770     }
 771
 772
 773     // Get the result
 774     int rowsAffected=0;
 775     DbRetVal rv = fsqlStmt_->execute( rowsAffected );
 776
 777     if( rowsAffected < 0 || rv!=OK )
 778     {
 779         if( isPrepared_ ) state_ = S2; else resetStmt();
 780         err_.set( ERROR_GENERAL );
 781         /*switch(rv)
 782         {
 783             case csqlSqlErrOverflow:err_.set(ERROR_OVERFLOW);break;
 784             case csqlSqlErrUnderflow:err_.set(ERROR_UNDERFLOW);break;
 785             case csqlSqlErrTooManyTpl:err_.set(ERROR_MANY_TUP);break;
 786             case csqlSqlErrProjCnt:err_.set(ERROR_NUM_PROJ);break;
 787             case csqlSqlErrStorageAttr:err_.set(ERROR_STORAGE_ATTR);break;
 788             case csqlSqlErrFldCntMismatch:err_.set(ERROR_FLDCNT_MISMATCH);break;
 789             case csqlSqlErrSqlInternal:err_.set(ERROR_SQL_INT);break;
 790             case csqlSqlErrNoMatchKeyFound:err_.set(ERROR_MATCHKEY_NOTFOUND);break;
 791             default:
 792                    err_.set( ERROR_GENERAL );break;
 793         } */
 794         return( SQL_ERROR );
 795     }
 796
 797     // Set Stmt State
 798     if( fsqlStmt_->isSelect() == true )
 799     {
 800         rowsAffected_ = -1;
 801         state_ = S5;
 802     }
 803     else
 804     {
 805         rowsAffected_ = rowsAffected;
 806         state_ = S4;
 807     }
 808
 809     // Set Dbc State to Transaction Mode.
 810     parentDbc_->state_ = C6;
 811
 812     // AutoCommit Mode
 813     if( parentDbc_->autoCommit_ == SQL_AUTOCOMMIT_ON )
 814         parentDbc_->SQLEndTran( SQL_COMMIT );
 815
 816     return( SQL_SUCCESS );
 817 }
 818 /*
 819 SQLRETURN SQLExecDirect(
 820     SQLHSTMT StatementHandle,
 821     SQLCHAR *StatementText,
 822     SQLINTEGER TextLength)
 823 {
 824 #ifdef DEBUG
 825     printError(ErrWarning, "SQLExecDirect");
 826 #endif
 827
 828     // Is Stmt valid ?
 829     if( isValidHandle( (CSqlOdbcStmt*) StatementHandle, SQL_HANDLE_STMT ) != SQL_SUCCESS )
 830         return( SQL_INVALID_HANDLE );
 831
 832     return( ((CSqlOdbcStmt*) StatementHandle)->SQLExecDirect( StatementText, TextLength ) );
 833 }
 834
 835 SQLRETURN CSqlOdbcStmt::SQLExecDirect(
 836     SQLCHAR *statementText,
 837     SQLINTEGER textLength)
 838 {
 839     SQLRETURN ret;
 840
 841     // Can we proceed ?
 842     if( chkStateForSQLExecDirect() != SQL_SUCCESS )
 843         return( SQL_ERROR );
 844
 845     // SQLExecDirect = SQLPrepare + SQLExecute.
 846     if( SQLPrepare( statementText, textLength ) != SQL_SUCCESS )
 847         return( SQL_ERROR );
 848
 849     ret = SQLExecute();
 850     isPrepared_ = false;         // Set Stmt as non-prepared stmt.
 851
 852     if( ret != SQL_SUCCESS )
 853         return( SQL_ERROR );
 854
 855     return( SQL_SUCCESS );
 856 }
 857 */
 858 SQLRETURN SQLSetStmtOption(
 859     SQLHSTMT StatementHandle,
 860     SQLUSMALLINT Option,
 861     SQLUINTEGER Value)
 862 {
 863 #ifdef DEBUG
 864     printError(ErrWarning, "SQLSetStmtOption");
 865 #endif
 866
 867     return  (SQLSetStmtAttr(StatementHandle, Option, (SQLPOINTER) Value, 0));
 868 }
 869
 870 SQLRETURN  SQL_API SQLSetStmtAttr(SQLHSTMT StatementHandle,
 871            SQLINTEGER Attribute, SQLPOINTER Value,
 872            SQLINTEGER StringLength)
 873 {
 874 #ifdef DEBUG
 875     printError(ErrWarning, "SQLSetStmtAttr");
 876 #endif
 877
 878     return (((CSqlOdbcStmt*)StatementHandle)->SQLSetStmtAttr(Attribute, Value,StringLength));
 879 }
 880
 881 SQLRETURN CSqlOdbcStmt::SQLSetStmtAttr(
 882     SQLINTEGER Attribute,
 883     SQLPOINTER Value,
 884     SQLINTEGER stringLength)
 885 {
 886     CSqlOdbcError::printDbg("proxy:stmt:SQLSetStmtAttr");
 887     //HACK
 888     /*switch(Attribute)
 889     {
 890         //Values: SQL_FETCH_SINGLE_TUPLE or SQL_FETCH_MULTIPLE_TUPLES
 891         //Default is SQL_FETCH_SINGLE_TUPLE.
 892         //In SQL_FETCH_SINGLE_TUPLE mode, only a single tuple
 893         //is sent from server to client in a single packet whatever be
 894         //the packet size. If a tuple size is 50 and network packet size
 895         //is 500, the remaining 450 bytes can also be used to send more
 896         //in a single packet so that in the next SQLFetch call one network
 897         //packet transfer overhead is reduced.
 898          case SQL_FETCH_MODE:
 899                 if(state_ <= S5)
 900                 //state_ > S5 means Fetch has already started on this statement.
 901                 fetchMode_ = (SQLINTEGER)Value;
 902                 else
 903                         printf("ODBC:Error in setting fetch mode, can't set after fetch is started.\n");
 904                 break;
 905             default:
 906                     printf("ODBC: Error, Stmt Option %d is not supported.\n", Attribute);
 907     }*/
 908     return (SQL_SUCCESS);
 909 }
 910
 911 SQLRETURN SQLFetch(SQLHSTMT StatementHandle)
 912 {
 913 #ifdef DEBUG
 914     printError(ErrWarning, "SQLFetch");
 915 #endif
 916
 917     // Is Stmt valid ?
 918     if( isValidHandle( (CSqlOdbcStmt*) StatementHandle, SQL_HANDLE_STMT ) != SQL_SUCCESS )
 919         return( SQL_INVALID_HANDLE );
 920
 921     return( ((CSqlOdbcStmt*) StatementHandle)->SQLFetch() );
 922 }
 923
 924 SQLRETURN CSqlOdbcStmt::SQLFetch()
 925 {
 926     // Start with NO_ERR
 927     err_.set( NO_ERR );
 928
 929     // Can we proceed ?
 930     if( chkStateForSQLFetch() != SQL_SUCCESS )
 931         return( SQL_ERROR );
 932
 933     void *tuple;
 934     tuple = fsqlStmt_->next();
 935
 936     if( ! tuple ) // IF Row not found.
 937     {
 938         rowsAffected_ = 0;
 939         state_ = S6;
 940         return( SQL_NO_DATA_FOUND );
 941     }
 942     /*else if( rowsAffected != SQL_SUCCESS ) // IF Error
 943     {
 944         rowsAffected_ = -1;
 945         err_.set( ERROR_GENERAL );
 946         return( SQL_ERROR );
 947     }*/
 948     else // IF Row found.
 949     {
 950         rowsAffected_ = 1;
 951         if (ard_.descList_.size() > 0) {
 952           // Iterate through all ard_;
 953           CSqlOdbcDesc *appColDesc;
 954           ListIterator ardIter = ard_.descList_.getIterator();
 955           //Get the input parameter data
 956           CSqlOdbcDesc *csqlColDesc;
 957           ListIterator irdIter = ird_.descList_.getIterator();
 958
 959           DataType sourceType = typeUnknown,destType = typeUnknown;
 960           int colNum=-1,sourceLength=-1,destLength=-1;
 961           SQLINTEGER ind;
 962           void* sourceData = NULL;
 963           while(ardIter.hasElement() || irdIter.hasElement()) {
 964             appColDesc = (CSqlOdbcDesc *) ardIter.nextElement();
 965             csqlColDesc = (CSqlOdbcDesc *) irdIter.nextElement();
 966
 967             colNum = appColDesc->col_ - 1;
 968             sourceType = (DataType)csqlColDesc->cType_;
 969             destType = getCSqlType(appColDesc->cType_);
 970             sourceLength = (int)csqlColDesc->length_;
 971             destLength = (int)appColDesc->length_;
 972             if( sourceType != typeUnknown && destType != typeUnknown )
 973             {
 974                 sourceData = fsqlStmt_->getFieldValuePtr( colNum );
 975                 if(fsqlStmt_->isFldNull((char*)csqlColDesc->colName_) ||
 976                                                      sourceData == NULL )
 977                 {
 978                     if (appColDesc->indPtr_ != NULL)
 979                         *((SQLINTEGER *)(appColDesc->indPtr_))=SQL_NULL_DATA;
 980                 }
 981                 else
 982                 {
 983                     /*if( sourceType == csqlSqlTvarBinary)
 984                         sourceLength=resultSet_->getDataLength(colNum); */
 985                     if (sourceType == typeString ) // CSQL TODO - handle varchar also
 986                     {
 987                         sourceLength=(int)(strlen((char *) sourceData ));
 988                         if(appColDesc->indPtr_ != NULL)
 989                             *((SQLINTEGER *)(appColDesc->indPtr_))=copyToOdbc(appColDesc->dataPtr_,destLength,
 990                               sourceData,sourceLength, sourceType, destType);
 991                         else
 992                             copyToOdbc(appColDesc->dataPtr_,destLength,sourceData,
 993                                     sourceLength, sourceType, destType);
 994                     }
 995                     else
 996                     {
 997                         //convert(sourceType,sourceData,destType, csqlColDesc->dataPtr_,sourceLength,destLength);
 998                         if(appColDesc->indPtr_ != NULL){
 999                             *((SQLINTEGER *)(appColDesc->indPtr_))=
1000                             copyToOdbc(appColDesc->dataPtr_,destLength, sourceData, sourceLength, sourceType, destType);
1001                             }
1002                         else
1003                             copyToOdbc(appColDesc->dataPtr_,destLength, sourceData, sourceLength, sourceType,destType);
1004                     }
1005
1006                     // CSQL TODO - handle varstring, binary, varbinary
1007                     if( sourceType == typeString && sourceLength > destLength )
1008                         err_.set( ERROR_DATATRUNC );
1009                 }
1010             }
1011           }
1012         }
1013         state_ = S6;
1014     }
1015     if(err_.csqlErrCode ==  ERROR_DATATRUNC)
1016         return (SQL_SUCCESS_WITH_INFO);
1017
1018     return( SQL_SUCCESS );
1019 }
1020
1021 SQLRETURN SQLCloseCursor(SQLHSTMT StatementHandle)
1022 {
1023 #ifdef DEBUG
1024     printError(ErrWarning, "SQLCloseCursor");
1025 #endif
1026     // Is Stmt valid ?
1027     if( isValidHandle( (CSqlOdbcStmt*) StatementHandle, SQL_HANDLE_STMT ) != SQL_SUCCESS )
1028         return( SQL_INVALID_HANDLE );
1029
1030     return( ((CSqlOdbcStmt*) StatementHandle)->SQLCloseCursor() );
1031 }
1032
1033 SQLRETURN CSqlOdbcStmt::SQLCloseCursor()
1034 {
1035     // Start with NO_ERR
1036     err_.set( NO_ERR );
1037
1038     // Can we proceed ?
1039     if( chkStateForSQLCloseCursor() != SQL_SUCCESS )
1040         return( SQL_ERROR );
1041
1042     // Close the cursor
1043     fsqlStmt_->close();
1044     state_ = S3;
1045     return( SQL_SUCCESS );
1046 }
1047
1048 SQLRETURN SQLSetCursorName(
1049     SQLHSTMT StatementHandle,
1050     SQLCHAR *CursorName,
1051     SQLSMALLINT NameLength)
1052 {
1053 #ifdef DEBUG
1054     printError(ErrWarning, "SQLSetCursorName");
1055 #endif
1056     // Is Stmt valid ?
1057     if( isValidHandle( (CSqlOdbcStmt*) StatementHandle, SQL_HANDLE_STMT ) != SQL_SUCCESS )
1058         return( SQL_INVALID_HANDLE );
1059
1060     return( ((CSqlOdbcStmt*) StatementHandle)->SQLSetCursorName( CursorName, NameLength ) );
1061 }
1062
1063 SQLRETURN CSqlOdbcStmt::SQLSetCursorName(
1064     SQLCHAR *cursorName,
1065     SQLSMALLINT nameLength)
1066 {
1067     // Start with NO_ERR
1068     err_.set( NO_ERR );
1069
1070     // Can we proceed ?
1071     if( chkStateForSQLSetCursorName() != SQL_SUCCESS )
1072         return( SQL_ERROR );
1073
1074     // Invalid Stmt Length.
1075     if( nameLength < 0  && nameLength != SQL_NTS )
1076     {
1077         err_.set( ERROR_INVARGVAL );
1078         return( SQL_ERROR );
1079     }
1080
1081     // Validate Parameters
1082     if( cursorName == 0 || cursorName[0] == '\0' || strlen( (char*) cursorName ) > SQL_MAX_CURSOR_NAME_LEN ||
1083         nameLength > SQL_MAX_CURSOR_NAME_LEN )
1084     {
1085         err_.set( ERROR_CURNAME );
1086         return( SQL_ERROR );
1087     }
1088
1089     // Check for duplicate Name
1090     ListIterator iter = parentDbc_->stmtList_.getIterator();
1091     CSqlOdbcStmt *stmtElem = NULL;
1092     while (iter.hasElement()) {
1093         stmtElem = (CSqlOdbcStmt *) iter.nextElement();
1094         if(stmtElem != this ) {
1095             if( strcmp((char*)cursorName, (char*)stmtElem->cursorName_) == 0) {
1096                 err_.set( ERROR_DUP_CURNAME );
1097                 return( SQL_ERROR );
1098             }
1099         }
1100     }
1101     // Copy name
1102     strcpy( (char*) cursorName_, (char*) cursorName );
1103     return( SQL_SUCCESS );
1104 }
1105
1106 SQLRETURN SQLGetCursorName(
1107     SQLHSTMT StatementHandle,
1108     SQLCHAR *CursorName,
1109     SQLSMALLINT BufferLength,
1110     SQLSMALLINT *NameLength)
1111 {
1112 #ifdef DEBUG
1113     printError(ErrWarning, "SQLGetCursorName");
1114 #endif
1115
1116     // Is Stmt valid ?
1117     if( isValidHandle( (CSqlOdbcStmt*) StatementHandle, SQL_HANDLE_STMT ) != SQL_SUCCESS )
1118         return( SQL_INVALID_HANDLE );
1119
1120     return( ((CSqlOdbcStmt*) StatementHandle)->SQLGetCursorName( CursorName, BufferLength, NameLength ) );
1121 }
1122 SQLRETURN CSqlOdbcStmt::SQLGetCursorName(
1123     SQLCHAR *cursorName,
1124     SQLSMALLINT bufferLength,
1125     SQLSMALLINT *nameLength)
1126 {
1127     // Can we proceed ?
1128     if( chkStateForSQLGetCursorName() != SQL_SUCCESS )
1129         return( SQL_ERROR );
1130
1131     if( cursorName_[0] == '\0' )
1132     {
1133         err_.set( ERROR_NOCURNAME );
1134         return( SQL_ERROR );
1135     }
1136
1137     // Copy
1138     *nameLength = (short)strlen( (char*) cursorName_ );
1139     if( *nameLength > bufferLength )    *nameLength = bufferLength;
1140     strncpy( (char*) cursorName, (char*) cursorName_, *nameLength );
1141     cursorName[ *nameLength ] = '\0';
1142
1143     // Did truncate ?
1144     if( bufferLength < strlen( (char*) cursorName_ ) )
1145     {
1146         err_.set( ERROR_DATATRUNC );
1147         return( SQL_SUCCESS_WITH_INFO );
1148     }
1149
1150     return( SQL_SUCCESS );
1151 }
1152
1153 SQLRETURN SQLNumResultCols(
1154     SQLHSTMT StatementHandle,   // IN
1155     SQLSMALLINT *ColumnCount)   // OUT
1156 {
1157 #ifdef DEBUG
1158     printError(ErrWarning, "SQLNumResultCols");
1159 #endif
1160
1161     // Is Stmt valid ?
1162     if( isValidHandle( (CSqlOdbcStmt*) StatementHandle, SQL_HANDLE_STMT ) != SQL_SUCCESS )
1163         return( SQL_INVALID_HANDLE );
1164
1165     return( ((CSqlOdbcStmt*) StatementHandle)->SQLNumResultCols( ColumnCount ) );
1166 }
1167
1168 SQLRETURN CSqlOdbcStmt::SQLNumResultCols(
1169     SQLSMALLINT *columnCount)   // OUT
1170 {
1171     // Start with NO_ERR
1172     err_.set( NO_ERR );
1173     // Can we proceed ?
1174     if( chkStateForSQLNumResultCols() != SQL_SUCCESS )
1175         return( SQL_ERROR );
1176
1177     // If DML
1178     if( fsqlStmt_->isSelect() == false )
1179     {
1180         *columnCount=0;
1181         return (SQL_SUCCESS);
1182     }
1183     ResultSetPlan pl = fsqlStmt_->getResultSetPlan();
1184     if(pl != Normal)
1185     {
1186         *columnCount =getNumResultset(pl);
1187         return( SQL_SUCCESS );
1188     }
1189     // If Select
1190     SQLSMALLINT count = fsqlStmt_->noOfProjFields();
1191     if( count < 1 ) // Assume atleast one column is projected
1192         return( SQL_ERROR );
1193
1194     // Fill Column Count
1195     *columnCount = count;
1196
1197     return( SQL_SUCCESS );
1198 }
1199
1200 SQLRETURN  SQL_API SQLRowCount(
1201     SQLHSTMT StatementHandle,   // IN
1202     SQLINTEGER *RowCount)       // OUT
1203 {
1204 #ifdef DEBUG
1205     printError(ErrWarning, "SQLRowCount");
1206 #endif
1207
1208     // Is Stmt valid ?
1209     if( isValidHandle( (CSqlOdbcStmt*) StatementHandle, SQL_HANDLE_STMT ) != SQL_SUCCESS )
1210         return( SQL_INVALID_HANDLE );
1211
1212     return( ((CSqlOdbcStmt*) StatementHandle)->SQLRowCount( RowCount ) );
1213 }
1214
1215 SQLRETURN CSqlOdbcStmt::SQLRowCount(
1216     SQLINTEGER *rowCount)   // OUT
1217 { // TODO
1218     // Start with NO_ERR
1219     err_.set( NO_ERR );
1220
1221     // Can we proceed ?
1222     if( chkStateForSQLRowCount() != SQL_SUCCESS )
1223         return( SQL_ERROR );
1224
1225     if(rowCount == NULL)
1226         return SQL_SUCCESS;
1227
1228     if( state_ == S4 ) // For INSERT/DELETE/UPDATE
1229         *rowCount = (SQLINTEGER) rowsAffected_;
1230     else if( state_ == S5 ) // For SELECT before SQLFetch()
1231     {
1232         *rowCount = (SQLINTEGER) 0;
1233         // CSQL TODO - Think if you really want to do this!!!
1234
1235         /*CSqlOdbcError::printDbg("proxy:stmt:getResultSet");
1236         CSqlResultSet *resultSet_ = fsqlStmt_.getResultSet();
1237         if( resultSet_->next() != csqlSqlErrNoTuple )
1238            *rowCount = (SQLINTEGER) 1;
1239
1240         resultSet_->close();
1241         resultSet_->open(); */
1242     }
1243     else if( state_ == S6 )   // For SELECT after SQLFetch();
1244         *rowCount = (SQLINTEGER) rowsAffected_;
1245
1246     return( SQL_SUCCESS );
1247 }
1248
1249 SQLRETURN  SQLDescribeCol(
1250     SQLHSTMT     StatementHandle,
1251     SQLUSMALLINT ColumnNumber,
1252     SQLCHAR      *ColumnName,
1253     SQLSMALLINT  BufferLength,
1254     SQLSMALLINT  *NameLength,
1255     SQLSMALLINT  *DataType,
1256     SQLUINTEGER  *ColumnSize,
1257     SQLSMALLINT  *DecimalDigits,
1258     SQLSMALLINT  *Nullable)
1259 {
1260 #ifdef DEBUG
1261     printError(ErrWarning, "SQLDescribeCol");
1262 #endif
1263
1264     // Is Stmt valid ?
1265     if( isValidHandle( (CSqlOdbcStmt*) StatementHandle, SQL_HANDLE_STMT ) != SQL_SUCCESS )
1266         return( SQL_INVALID_HANDLE );
1267
1268     return( ((CSqlOdbcStmt*) StatementHandle)->SQLDescribeCol( ColumnNumber, ColumnName, BufferLength,
1269             NameLength, DataType, ColumnSize, DecimalDigits, Nullable) );
1270 }
1271
1272 SQLRETURN  CSqlOdbcStmt::SQLDescribeCol(
1273     SQLUSMALLINT columnNumber,
1274     SQLCHAR      *columnName,
1275     SQLSMALLINT  bufferLength,
1276     SQLSMALLINT  *nameLength,
1277     SQLSMALLINT  *dataType,
1278     SQLUINTEGER  *columnSize,
1279     SQLSMALLINT  *decimalDigits,
1280     SQLSMALLINT  *nullable)
1281 {
1282     int     nameLen;
1283     int     type;
1284     int     colSize;
1285     int     deciDigits;
1286     int     isNullable;
1287
1288     // Start with NO_ERR
1289     err_.set( NO_ERR );
1290
1291     // Can we proceed ?
1292     if( chkStateForSQLDescribeCol() != SQL_SUCCESS )
1293         return( SQL_ERROR );
1294
1295     if( columnNumber < 1 )
1296     {
1297         err_.set( ERROR_COLNUM );
1298         return( SQL_ERROR );
1299     }
1300
1301     if(columnName == NULL) {
1302         err_.set( ERROR_COLNUM );
1303         return( SQL_ERROR );
1304     }
1305     DbRetVal rv = fsqlStmt_->getProjFldInfo(columnNumber, fInfo);
1306     if (rv != OK) {
1307         err_.set( ERROR_COLNUM );
1308         return( SQL_ERROR );
1309     }
1310     Table::getFieldNameAlone((char*)fInfo->fldName, (char*)columnName);
1311     if (bufferLength <IDENTIFIER_LENGTH) {
1312        strncpy( (char*)columnName, (char*)fInfo->fldName, bufferLength );
1313        columnName[bufferLength-1] ='\0';
1314     }else {
1315        strcpy( (char*)columnName, (char*)fInfo->fldName);
1316     }
1317
1318     if(nameLength != NULL)
1319         *nameLength=(short)strlen((const char*)columnName); // HARDCODED - TO DO, need support for n/w layer & sql layer
1320     if(dataType != NULL)
1321         *dataType = (SQLSMALLINT) getSQLType(fInfo->type); // Need to convert from SQL<->ODBC - TO DO
1322     if(columnSize != NULL)
1323     {
1324         *columnSize = (SQLUINTEGER) fInfo->length;
1325         SQLSMALLINT sqlType=getSQLType(fInfo->type);
1326         if(sqlType == SQL_CHAR )
1327             *columnSize = *columnSize -1;
1328     }
1329
1330     /*if(decimalDigits != NULL) // CSQL TODO
1331         *decimalDigits = (SQLSMALLINT) fsqlStmt_->getPrecision( columnNumber-1 );*/
1332     *decimalDigits = 0;
1333     if(fInfo->isNull)
1334         *nullable = SQL_NO_NULLS ;
1335     else
1336         *nullable = SQL_NULLABLE ;
1337     if(strlen((char*)fInfo->fldName) > bufferLength)
1338     {
1339         err_.set( ERROR_DATATRUNC );
1340         return( SQL_SUCCESS_WITH_INFO );
1341     }
1342     return( SQL_SUCCESS );
1343 }
1344
1345 SQLRETURN  SQLColAttributes(
1346         SQLHSTMT     StatementHandle,
1347         SQLUSMALLINT ColumnNumber,
1348         SQLUSMALLINT     FieldIdentifier,
1349         SQLPOINTER     CharacterAttributePtr,
1350         SQLSMALLINT     BufferLength,
1351         SQLSMALLINT *StringLengthPtr,
1352         SQLINTEGER *NumericAttributePtr)
1353 {
1354 #ifdef DEBUG
1355     printError(ErrWarning, "SQLColAttributes");
1356 #endif
1357
1358     // Is Stmt valid ?
1359     if( isValidHandle( (CSqlOdbcStmt*) StatementHandle, SQL_HANDLE_STMT ) != SQL_SUCCESS )
1360         return( SQL_INVALID_HANDLE );
1361
1362     return( ((CSqlOdbcStmt*) StatementHandle)->SQLColAttribute(ColumnNumber ,FieldIdentifier ,
1363             CharacterAttributePtr, BufferLength, StringLengthPtr, (SQLPOINTER)NumericAttributePtr) );
1364 }
1365
1366 SQLRETURN  SQLColAttribute(
1367         SQLHSTMT     StatementHandle,
1368         SQLUSMALLINT ColumnNumber,
1369         SQLUSMALLINT     FieldIdentifier,
1370         SQLPOINTER     CharacterAttributePtr,
1371         SQLSMALLINT     BufferLength,
1372         SQLSMALLINT *     StringLengthPtr,
1373         SQLPOINTER NumericAttributePtr)
1374 {
1375 #ifdef DEBUG
1376     printError(ErrWarning, "SQLColAttribute");
1377 #endif
1378
1379     // Is Stmt valid ?
1380     if( isValidHandle( (CSqlOdbcStmt*) StatementHandle, SQL_HANDLE_STMT ) != SQL_SUCCESS )
1381         return( SQL_INVALID_HANDLE );
1382
1383     return( ((CSqlOdbcStmt*) StatementHandle)->SQLColAttribute(ColumnNumber ,FieldIdentifier ,
1384             CharacterAttributePtr, BufferLength, StringLengthPtr, NumericAttributePtr) );
1385 }
1386
1387 SQLRETURN  CSqlOdbcStmt::SQLColAttribute(
1388         SQLUSMALLINT columnNumber,
1389         SQLUSMALLINT     fieldIdentifier,
1390         SQLPOINTER     characterAttributePtr,
1391         SQLSMALLINT     bufferLength,
1392         SQLSMALLINT *     stringLengthPtr,
1393         SQLPOINTER numericAttributePtr)
1394 {
1395     int     nameLen;
1396     int     type;
1397     int     colSize;
1398     int     deciDigits;
1399     int     isNullable;
1400
1401     // Start with NO_ERR
1402     err_.set( NO_ERR );
1403
1404     // Can we proceed ?
1405     if( chkStateForSQLDescribeCol() != SQL_SUCCESS )
1406         return( SQL_ERROR );
1407
1408     if( columnNumber < 1 )
1409     {
1410         err_.set( ERROR_COLNUM );
1411         return( SQL_ERROR );
1412     }
1413     // If DML
1414     if( fsqlStmt_->isSelect() == false )
1415         return( SQL_ERROR );
1416
1417     fsqlStmt_->getProjFldInfo(columnNumber, fInfo);
1418
1419     // If SELECT
1420     if(columnNumber > fsqlStmt_->noOfProjFields())
1421     {
1422         err_.set( ERROR_COLNUM );
1423         return( SQL_ERROR );
1424     }
1425
1426     switch(fieldIdentifier)
1427     {
1428         case SQL_DESC_NAME:
1429         case SQL_COLUMN_LABEL:
1430         case SQL_COLUMN_NAME:
1431             if(characterAttributePtr != NULL)
1432             {
1433                 strncpy( (char*)characterAttributePtr, (char*)fInfo->fldName, bufferLength);
1434                 if(stringLengthPtr != NULL)
1435                     *stringLengthPtr=(short)strlen((char*)fInfo->fldName);
1436             }
1437             break;
1438         case SQL_DESC_COUNT:
1439         case SQL_COLUMN_COUNT:
1440             if(numericAttributePtr != NULL)
1441                 *(SQLINTEGER*)numericAttributePtr=fsqlStmt_->noOfProjFields();
1442             break;
1443         case SQL_DESC_TYPE:
1444         case SQL_COLUMN_TYPE:
1445             if(numericAttributePtr != NULL)
1446                 *(SQLINTEGER *)numericAttributePtr=getSQLType(fInfo->type);
1447             break;
1448         case SQL_DESC_LENGTH:
1449         case SQL_COLUMN_LENGTH:
1450             if(numericAttributePtr != NULL)
1451             {
1452                 SQLSMALLINT sqlType=getSQLType(fInfo->type);
1453                 *(SQLINTEGER *)numericAttributePtr=(SQLUINTEGER) fInfo->length;
1454                 if(sqlType == SQL_CHAR)
1455                     *(SQLINTEGER *)numericAttributePtr=*(SQLINTEGER *)numericAttributePtr -1;
1456             }
1457             break;
1458         case SQL_DESC_PRECISION:
1459         case SQL_COLUMN_PRECISION:
1460             /*if(numericAttributePtr != NULL) // CSQL TODO
1461                 *(SQLINTEGER *)numericAttributePtr=(SQLSMALLINT) rsMetaData->getPrecision( columnNumber-1 ); */
1462             break;
1463         case SQL_DESC_SCALE:
1464         case SQL_COLUMN_SCALE:
1465             /*if(numericAttributePtr != NULL) // CSQL TODO
1466                 *(SQLINTEGER*)numericAttributePtr=(SQLSMALLINT) rsMetaData->getScale( columnNumber-1 );*/
1467             break;
1468         case SQL_DESC_NULLABLE:
1469         case SQL_COLUMN_NULLABLE:
1470             /*if(numericAttributePtr != NULL) // CSQL TODO
1471                 *(SQLINTEGER*)numericAttributePtr=(SQLSMALLINT) rsMetaData->isNullable( columnNumber-1 )?SQL_NULLABLE_N:SQL_NO_NULLS_N;*/
1472             break;
1473         case SQL_DESC_UNSIGNED:
1474             if(numericAttributePtr != NULL)
1475             {
1476                 SQLSMALLINT sqlType=getSQLType(fInfo->type);
1477                 if((sqlType != SQL_TIME) && (sqlType != SQL_DATE) && (sqlType != SQL_TIMESTAMP)
1478                     && (sqlType != SQL_CHAR) && (sqlType != SQL_VARCHAR) && (sqlType != SQL_BINARY)
1479                     && (sqlType != SQL_VARBINARY) && (sqlType != SQL_BIT))
1480                     *(SQLINTEGER*)numericAttributePtr=SQL_FALSE;
1481                 else
1482                     *(SQLINTEGER*)numericAttributePtr=SQL_TRUE;
1483             }
1484             break;
1485         case SQL_DESC_FIXED_PREC_SCALE:
1486             if(numericAttributePtr != NULL)
1487                 *(SQLINTEGER*)numericAttributePtr=SQL_FALSE;
1488             break;
1489         case SQL_DESC_TYPE_NAME:
1490             if(characterAttributePtr != NULL)
1491             {
1492                 SQLSMALLINT sqlType=getSQLType(fInfo->type);
1493                 strncpy((char*)characterAttributePtr,(char *)(getSQLTypeName(sqlType)),bufferLength);
1494                 if(stringLengthPtr != NULL)
1495                     *stringLengthPtr=(int)strlen((char *)getSQLTypeName(sqlType));
1496             }
1497             break;
1498         case SQL_DESC_UPDATABLE:
1499                 if(numericAttributePtr != NULL)
1500                     *(SQLINTEGER*)numericAttributePtr=SQL_ATTR_READWRITE_UNKNOWN;
1501             break;
1502         case SQL_DESC_AUTO_UNIQUE_VALUE:
1503             if(numericAttributePtr != NULL)
1504                 *(SQLINTEGER*)numericAttributePtr=SQL_FALSE;
1505             break;
1506         case SQL_DESC_CASE_SENSITIVE:
1507             if(numericAttributePtr != NULL)
1508             {
1509                 SQLSMALLINT sqlType=getSQLType(fInfo->type);
1510                 if((sqlType != SQL_CHAR) && (sqlType != SQL_VARCHAR))
1511                     *(SQLINTEGER*)numericAttributePtr=SQL_FALSE;
1512                 else
1513                     *(SQLINTEGER*)numericAttributePtr=SQL_TRUE;
1514             }
1515             break;
1516         case SQL_DESC_SEARCHABLE:
1517             if(numericAttributePtr != NULL)
1518             {
1519                 SQLSMALLINT sqlType=getSQLType(fInfo->type);
1520                 if((sqlType != SQL_CHAR) && (sqlType != SQL_VARCHAR))
1521                     *(SQLINTEGER*)numericAttributePtr=SQL_PRED_BASIC;
1522                 else
1523                     *(SQLINTEGER*)numericAttributePtr=SQL_PRED_SEARCHABLE;
1524             }
1525             break;
1526        case SQL_COLUMN_DISPLAY_SIZE: {
1527             SQLSMALLINT sqlType=getSQLType(fInfo->type);
1528             if(numericAttributePtr != NULL) {
1529                  if(sqlType == SQL_CHAR || sqlType == SQL_BINARY)
1530                     *(SQLINTEGER *)numericAttributePtr=fInfo->length;
1531                  else
1532                     *(SQLINTEGER *)numericAttributePtr=20;
1533             }
1534             break;
1535             }
1536        default:
1537             break;
1538     }
1539     if(stringLengthPtr != NULL)
1540     {
1541         if(*stringLengthPtr > bufferLength)
1542         {
1543             err_.set( ERROR_DATATRUNC );
1544             return( SQL_SUCCESS_WITH_INFO );
1545         }
1546     }
1547     return( SQL_SUCCESS );
1548 }
1549
1550 SQLRETURN SQLNumParams(
1551         SQLHSTMT     StatementHandle,
1552         SQLSMALLINT *     ParameterCountPtr)
1553 {
1554 #ifdef DEBUG
1555     printError(ErrWarning, "SQLNumParams");
1556 #endif
1557
1558     // Is Stmt valid ?
1559     if( isValidHandle( (CSqlOdbcStmt*) StatementHandle, SQL_HANDLE_STMT ) != SQL_SUCCESS )
1560         return( SQL_INVALID_HANDLE );
1561
1562     return( ((CSqlOdbcStmt*) StatementHandle)->SQLNumParams(ParameterCountPtr) );
1563 }
1564
1565 SQLRETURN CSqlOdbcStmt::SQLNumParams(
1566         SQLSMALLINT *     ParameterCount)
1567 {
1568     // Start with NO_ERR
1569     err_.set( NO_ERR );
1570     // Can we proceed ?
1571     if( chkStateForSQLNumParams() != SQL_SUCCESS )
1572         return( SQL_ERROR );
1573     if(ParameterCount == NULL)
1574         return (SQL_ERROR);
1575     *ParameterCount=fsqlStmt_->noOfParamFields();
1576
1577     return SQL_SUCCESS;
1578 }
1579
1580 SQLRETURN SQLDescribeParam(
1581         SQLHSTMT     StatementHandle,
1582         SQLUSMALLINT     ParameterNumber,
1583         SQLSMALLINT *     DataTypePtr,
1584         SQLUINTEGER *     ParameterSizePtr,
1585         SQLSMALLINT *     DecimalDigitsPtr,
1586         SQLSMALLINT *     NullablePtr)
1587 {
1588 #ifdef DEBUG
1589     printError(ErrWarning, "SQLDescribeParam");
1590 #endif
1591
1592     // Is Stmt valid ?
1593     if( isValidHandle( (CSqlOdbcStmt*) StatementHandle, SQL_HANDLE_STMT ) != SQL_SUCCESS )
1594         return( SQL_INVALID_HANDLE );
1595
1596     return( ((CSqlOdbcStmt*) StatementHandle)->SQLDescribeParam(ParameterNumber,DataTypePtr,
1597                 ParameterSizePtr,DecimalDigitsPtr,NullablePtr ) );
1598 }
1599 SQLRETURN CSqlOdbcStmt::SQLDescribeParam(
1600          SQLUSMALLINT     paramNumber,
1601          SQLSMALLINT *     dataType,
1602           SQLUINTEGER *     paramSize,
1603           SQLSMALLINT *     decimalDigits,
1604            SQLSMALLINT *     isNullable)
1605 {
1606
1607     // Start with NO_ERR
1608     err_.set( NO_ERR );
1609
1610     // Can we proceed ?
1611     if( chkStateForSQLDescribeParam() != SQL_SUCCESS )
1612         return( SQL_ERROR );
1613
1614     if( paramNumber < 1 )
1615     {
1616         err_.set( ERROR_PARAMNUM);
1617         return( SQL_ERROR );
1618     }
1619
1620     //CSqlOdbcError::printDbg("proxy:stmt:getMetaData");
1621     //CSqlParamMetaData *paramMetaData = fsqlStmt_->getParamMetaData();
1622     if(paramNumber > fsqlStmt_->noOfParamFields())
1623     {
1624         err_.set( ERROR_PARAMNUM );
1625         return( SQL_ERROR );
1626     }
1627
1628     if( fsqlStmt_->getParamFldInfo( paramNumber, fInfo ) != OK ) {
1629        return( SQL_ERROR );
1630     }
1631     if(dataType != NULL)
1632         *dataType = (SQLSMALLINT) getSQLType(fInfo->type);
1633     if(paramSize != NULL)
1634     {
1635         *paramSize = (SQLUINTEGER) fInfo->length;
1636         SQLSMALLINT sqlType=getSQLType(fInfo->type);
1637         if(sqlType == SQL_CHAR )
1638             *paramSize= *paramSize -1;
1639     }
1640     /*if(decimalDigits != NULL) // CSQL TODO
1641         *decimalDigits = (SQLSMALLINT) paramMetaData->getPrecision( paramNumber-1 );*/
1642     *decimalDigits = 0;
1643     if(fInfo->isNull)
1644         *isNullable = SQL_NO_NULLS ;
1645     else
1646         *isNullable = SQL_NULLABLE ;
1647
1648     return( SQL_SUCCESS );
1649 }
1650
1651 // Resets the Stmt to initial state. As if newly allocated.
1652 void CSqlOdbcStmt::resetStmt( void ) // TO DO
1653 {
1654     SQLFreeStmt( SQL_CLOSE );
1655     SQLFreeStmt( SQL_UNBIND );
1656     SQLFreeStmt( SQL_RESET_PARAMS );
1657     if (fsqlStmt_) { fsqlStmt_->free(); delete fsqlStmt_; fsqlStmt_ = NULL; }
1658     isPrepared_ = false;
1659     state_ = S1;
1660 }
1661
1662 SQLRETURN SQLTables(
1663      SQLHSTMT     StatementHandle,
1664      SQLCHAR *     CatalogName,
1665      SQLSMALLINT     NameLength1,
1666      SQLCHAR *     SchemaName,
1667      SQLSMALLINT     NameLength2,
1668      SQLCHAR *     TableName,
1669      SQLSMALLINT     NameLength3,
1670      SQLCHAR *     TableType,
1671      SQLSMALLINT     NameLength4)
1672 {
1673 #ifdef DEBUG
1674     printError(ErrWarning, "SQLTables");
1675 #endif
1676
1677  if( isValidHandle( (CSqlOdbcStmt*) StatementHandle, SQL_HANDLE_STMT ) != SQL_SUCCESS )
1678         return( SQL_INVALID_HANDLE );
1679
1680     return( ((CSqlOdbcStmt*) StatementHandle)->SQLTables(CatalogName,SchemaName,TableName,TableType ) );
1681 }
1682
1683 SQLRETURN CSqlOdbcStmt::SQLTables(
1684      SQLCHAR *     CatalogName,
1685      SQLCHAR *     SchemaName,
1686      SQLCHAR *     TableName,
1687      SQLCHAR *     TableType )
1688 {
1689    // Start with NO_ERR
1690     err_.set( NO_ERR );
1691     SQLRETURN ret = SQL_SUCCESS;
1692     ret = SQLPrepare((SQLCHAR *)"GetAllTables",  strlen("GetAllTables"));
1693     if( ret != SQL_SUCCESS )  return (ret);
1694     ret = SQLExecute();
1695     if( ret != SQL_SUCCESS )  return (ret);
1696     return( SQL_SUCCESS );
1697
1698 }
1699
1700 SQLRETURN SQLColumns(
1701      SQLHSTMT     StatementHandle,
1702      SQLCHAR *     CatalogName,
1703      SQLSMALLINT     NameLength1,
1704      SQLCHAR *     SchemaName,
1705      SQLSMALLINT     NameLength2,
1706      SQLCHAR *     TableName,
1707      SQLSMALLINT     NameLength3,
1708      SQLCHAR *     ColumnName,
1709      SQLSMALLINT     NameLength4)
1710 {
1711 #ifdef DEBUG
1712     printError(ErrWarning, "SQLColumns");
1713 #endif
1714
1715      if( isValidHandle( (CSqlOdbcStmt*) StatementHandle, SQL_HANDLE_STMT ) != SQL_SUCCESS )
1716         return( SQL_INVALID_HANDLE );
1717
1718     return( ((CSqlOdbcStmt*) StatementHandle)->SQLColumns(CatalogName,SchemaName,TableName,ColumnName ) );
1719
1720 }
1721
1722 SQLRETURN CSqlOdbcStmt::SQLColumns(
1723      SQLCHAR *     CatalogName,
1724      SQLCHAR *     SchemaName,
1725      SQLCHAR *     TableName,
1726      SQLCHAR *     ColumnName )
1727 {
1728     SQLRETURN ret = SQL_SUCCESS;
1729     char str[256]="describe ";
1730     strcat(str,(char*)TableName);
1731     ret = SQLPrepare((SQLCHAR *)str,  strlen(str));
1732     if( ret != SQL_SUCCESS )  return (ret);
1733     ret = SQLExecute();
1734     if( ret != SQL_SUCCESS )  return (ret);
1735     return( SQL_SUCCESS );
1736 }
1737
1738 SQLRETURN SQLPrimaryKeys(
1739      SQLHSTMT     StatementHandle,
1740      SQLCHAR *     CatalogName,
1741      SQLSMALLINT     NameLength1,
1742      SQLCHAR *     SchemaName,
1743      SQLSMALLINT     NameLength2,
1744      SQLCHAR *     TableName,
1745      SQLSMALLINT     NameLength3)
1746 {
1747 #ifdef DEBUG
1748     printError(ErrWarning, "SQLPrimaryKeys");
1749 #endif
1750
1751     if( isValidHandle( (CSqlOdbcStmt*) StatementHandle, SQL_HANDLE_STMT ) != SQL_SUCCESS )
1752         return( SQL_INVALID_HANDLE );
1753
1754     return( ((CSqlOdbcStmt*) StatementHandle)->SQLPrimaryKeys(CatalogName,SchemaName,TableName ) );
1755
1756 }
1757 SQLRETURN CSqlOdbcStmt::SQLPrimaryKeys(
1758      SQLCHAR *     CatalogName,
1759      SQLCHAR *     SchemaName,
1760      SQLCHAR *     TableName)
1761 {
1762     SQLRETURN ret = SQL_SUCCESS;
1763     char str[256]="getprimarykey  ";
1764     strcat(str,(char*)TableName);
1765     ret = SQLPrepare((SQLCHAR *)str,  strlen(str));
1766     if( ret != SQL_SUCCESS )  return (ret);
1767     ret = SQLExecute();
1768     if( ret != SQL_SUCCESS )  return (ret);
1769     return( SQL_SUCCESS );
1770 }
1771
1772 int CSqlOdbcStmt::getNumResultset(ResultSetPlan plan)
1773 {
1774     switch(plan)
1775     {
1776         case GetTables:
1777             return 5;
1778         case GetColumns:
1779             return 18;
1780         case GetIndexes:
1781             return 13;
1782         case GetPriIndex:
1783             return 6;
1784         default :
1785             break;
1786     };
1787 }
1788
1789 SQLRETURN SQLGetData(SQLHSTMT     StatementHandle,  SQLUSMALLINT  ColumnNumber, SQLSMALLINT   TargetType,  SQLPOINTER  TargetValuePtr, SQLLEN     BufferLength, SQLLEN * StrLen_or_IndPtr)
1790 {
1791 #ifdef DEBUG
1792     printError(ErrWarning, "SQLGetData");
1793 #endif
1794
1795      if( isValidHandle( (CSqlOdbcStmt*) StatementHandle, SQL_HANDLE_STMT ) != SQL_SUCCESS )
1796         return( SQL_INVALID_HANDLE );
1797
1798     return( ((CSqlOdbcStmt*) StatementHandle)->SQLGetData(ColumnNumber,TargetType,TargetValuePtr,BufferLength,StrLen_or_IndPtr) );
1799
1800 }
1801
1802 SQLRETURN CSqlOdbcStmt::SQLGetData(SQLUSMALLINT     ColumnNumber, SQLSMALLINT     TargetType, SQLPOINTER     TargetValuePtr,SQLLEN     BufferLength, SQLLEN *     StrLen_or_IndPtr)
1803 {
1804      if(fsqlStmt_->isFldNull(ColumnNumber)){
1805           *((SQLINTEGER *)StrLen_or_IndPtr ) = SQL_NULL_DATA;
1806          return (SQL_SUCCESS);
1807      }
1808      void* sourceData = NULL;
1809      DataType sourceType = typeUnknown, destType = typeUnknown;
1810      DbRetVal rv = fsqlStmt_->getProjFldInfo(ColumnNumber, fInfo);
1811      if (rv != OK) {
1812          return SQL_INVALID_HANDLE;
1813      }
1814      sourceType = fInfo->type;
1815      sourceData = fsqlStmt_->getFieldValuePtr(ColumnNumber-1);
1816      destType = getCSqlType( TargetType );
1817      int sourceLength=-1;
1818      if(sourceType == typeString)
1819      {
1820          sourceLength=strlen((char *)sourceData);
1821          *((SQLINTEGER *)StrLen_or_IndPtr) = copyToOdbc(TargetValuePtr,BufferLength,sourceData,sourceLength,sourceType,destType);
1822      } else
1823      {
1824          copyToOdbc(TargetValuePtr,BufferLength,sourceData,sourceLength,sourceType,destType);
1825      }
1826      return (SQL_SUCCESS);
1827 }
1828
1829
1830 SQLRETURN SQLGetTypeInfo(
1831      SQLHSTMT     StatementHandle,
1832      SQLSMALLINT     DataType)
1833 {
1834 #ifdef DEBUG
1835     printError(ErrWarning, "SQLGetTypeInfo");
1836 #endif
1837
1838     if( isValidHandle( (CSqlOdbcStmt*) StatementHandle, SQL_HANDLE_STMT ) != SQL_SUCCESS )
1839         return( SQL_INVALID_HANDLE );
1840
1841     return( ((CSqlOdbcStmt*) StatementHandle)->SQLGetTypeInfo(DataType));
1842
1843 }
1844 SQLRETURN CSqlOdbcStmt::SQLGetTypeInfo(SQLSMALLINT     DataType)
1845 {
1846      return (SQL_SUCCESS);
1847 }
1848
1849
1850 SQLRETURN SQLStatistics(
1851      SQLHSTMT     StatementHandle,
1852      SQLCHAR *     CatalogName,
1853      SQLSMALLINT     NameLength1,
1854      SQLCHAR *     SchemaName,
1855      SQLSMALLINT     NameLength2,
1856      SQLCHAR *     TableName,
1857      SQLSMALLINT     NameLength3,
1858      SQLUSMALLINT     Unique,
1859      SQLUSMALLINT     Reserved)
1860 {
1861 #ifdef DEBUG
1862     printError(ErrWarning, "SQLStatistics");
1863 #endif
1864
1865      if( isValidHandle( (CSqlOdbcStmt*) StatementHandle, SQL_HANDLE_STMT ) != SQL_SUCCESS )
1866         return( SQL_INVALID_HANDLE );
1867
1868     return( ((CSqlOdbcStmt*) StatementHandle)->SQLStatistics(CatalogName,SchemaName,TableName,Unique,Reserved));
1869
1870 }
1871 SQLRETURN CSqlOdbcStmt::SQLStatistics(
1872      SQLCHAR *     CatalogName,
1873      SQLCHAR *     SchemaName,
1874      SQLCHAR *     TableName,
1875      SQLUSMALLINT     Unique,
1876      SQLUSMALLINT     Reserved)
1877 {
1878     SQLRETURN ret = SQL_SUCCESS;
1879     if(Unique != SQL_INDEX_ALL ) { printf("NOT SUPPORTED "); return (SQL_ERROR);}
1880     char str[256]="describe index ";
1881     strcat(str,(char*)TableName);
1882     ret = SQLPrepare((SQLCHAR *)str,  strlen(str));
1883     if( ret != SQL_SUCCESS )  return (ret);
1884     ret = SQLExecute();
1885     if( ret != SQL_SUCCESS )  return (ret);
1886     return( SQL_SUCCESS );
1887 }
1888
1889 SQLRETURN SQLForeignKeys(
1890      SQLHSTMT     StatementHandle,
1891      SQLCHAR *     PKCatalogName,
1892      SQLSMALLINT     NameLength1,
1893      SQLCHAR *     PKSchemaName,
1894      SQLSMALLINT     NameLength2,
1895      SQLCHAR *     PKTableName,
1896      SQLSMALLINT     NameLength3,
1897      SQLCHAR *     FKCatalogName,
1898      SQLSMALLINT     NameLength4,
1899      SQLCHAR *     FKSchemaName,
1900      SQLSMALLINT     NameLength5,
1901      SQLCHAR *     FKTableName,
1902      SQLSMALLINT     NameLength6)
1903 {
1904 #ifdef DEBUG
1905     printError(ErrWarning, "SQLForeignKeys");
1906 #endif
1907     if( PKCatalogName!=NULL || FKCatalogName!=NULL ){
1908             if(strcmp((char*)PKCatalogName,"csql")!=0 || strcmp((char*)PKCatalogName,"csql")!=0){
1909                 //error
1910                 printf("Error\n");
1911             }
1912     }
1913     if( isValidHandle( (CSqlOdbcStmt*) StatementHandle, SQL_HANDLE_STMT ) != SQL_SUCCESS )
1914         return( SQL_INVALID_HANDLE );
1915
1916     return( ((CSqlOdbcStmt*) StatementHandle)->SQLForeignKeys(PKTableName, FKTableName));
1917 }
1918
1919 SQLRETURN CSqlOdbcStmt::SQLForeignKeys(
1920      SQLCHAR *     PKTableName,
1921      SQLCHAR *     FKTableName)
1922 {
1923     SQLRETURN ret = SQL_SUCCESS;
1924     if(PKTableName!=NULL && FKTableName!=NULL) { printf("NOT SUPPORTED "); return (SQL_ERROR);}
1925     char str[256];
1926     if(PKTableName!=NULL && FKTableName==NULL){
1927         sprintf(str,"ExportedKey %s;",(char*)PKTableName);
1928     }
1929     else if(NULL == PKTableName && FKTableName!=NULL){
1930         sprintf(str,"ImportedKey %s;",(char*)FKTableName);
1931     }
1932     ret = SQLPrepare((SQLCHAR *)str,  strlen(str));
1933     if( ret != SQL_SUCCESS )  return (ret);
1934     ret = SQLExecute();
1935     if( ret != SQL_SUCCESS )  return (ret);
1936     return( SQL_SUCCESS );
1937 }
1938