src/sql/SqlStatement.cxx

   1 /***************************************************************************
   2  *   Copyright (C) 2007 by Prabakaran Thirumalai   *
   3  *   praba_tuty@yahoo.com   *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  19  ***************************************************************************/
  20 #include <os.h>
  21 #include <Statement.h>
  22 #include <SqlStatement.h>
  23 #include <dmllex.h>
  24
  25 char *lexInput;
  26 extern ParsedData *parsedData;
  27
  28 int yyparse ();
  29
  30 SqlStatement::~SqlStatement()
  31 {
  32     if (isPrepd) { free(); isPrepd = false; }
  33 }
  34
  35 List SqlStatement::getTableNameList()
  36 {
  37     return pData.getTableNameList();
  38 }
  39 SqlStatement::SqlStatement()
  40 {
  41     innerStmt = NULL;
  42     sqlCon = NULL;
  43     stmt = NULL;
  44     isPrepd = false;
  45     isCachedStmt=false;
  46     isMgmtStatement = false;
  47 }
  48 void SqlStatement::setConnection(AbsSqlConnection *conn)
  49 {
  50     sqlCon = (SqlConnection*)conn;
  51     con = conn;
  52
  53 }
  54 void SqlStatement::setSqlConnection(SqlConnection *conn)
  55 {
  56     sqlCon = conn;
  57 }
  58
  59 DbRetVal SqlStatement::executeDirect(char *str)
  60 {
  61     DbRetVal rv = OK;
  62     int rows = 0;
  63     rv = prepare(str);
  64     if (rv != OK) return rv;
  65     rv = execute(rows);
  66     if (rv != OK) return rv;
  67     return rv;
  68 }
  69
  70 DbRetVal SqlStatement::prepare(char *stmtstr)
  71 {
  72     DbRetVal rv = OK;
  73     if (! sqlCon->isConnectionOpen()) {
  74         printError(ErrNotOpen, "Connection not open");
  75         return ErrNotOpen;
  76     }
  77     SqlStatement *cachedStmt = sqlCon->findInCache(stmtstr);
  78     if (cachedStmt)
  79     {
  80         *this = *cachedStmt;
  81         this->stmt->setParsedData(&this->pData);
  82         logFine(Conf::logger,"GOT STMT FROM CACHE: %s %x", stmtstr, cachedStmt);
  83         return OK;
  84     }
  85     // take mutex here
  86     DatabaseManager *dbMgr = sqlCon->getConnObject().getDatabaseManager();
  87     Database *sysdb = ((DatabaseManagerImpl *)dbMgr)->sysDb();
  88     int tries = Conf::config.getMutexRetries();
  89     struct timeval timeout;
  90     timeout.tv_sec = Conf::config.getMutexSecs();
  91     timeout.tv_usec = Conf::config.getMutexUSecs();
  92
  93     while (true) {
  94         rv = sysdb->getPrepareStmtMutex();
  95         if (rv == OK) break;
  96         tries--;
  97         if (tries == 0) {
  98             printError(rv,
  99                         "Unable to get prepare statement mutex after %d tries", Conf::config.getMutexRetries());
 100             return rv;
 101         }
 102         os::select(0, 0, 0, 0, &timeout);
 103     }
 104
 105     if (isPrepared()) free();
 106     lexInput = stmtstr;
 107     parsedData = &pData;
 108
 109     yy_buffer_state *yy_buffer= yy_scan_string(stmtstr);
 110     int rc = yyparse();
 111     if (yy_buffer) yy_delete_buffer(yy_buffer);
 112     if (rc != 0)
 113     {
 114         free();
 115         parsedData = NULL;
 116         //yyrestart(yyin);
 117         sysdb->releasePrepareStmtMutex();
 118         return ErrSyntaxError;
 119     }
 120     if( parsedData->getStmtType() == MgmtStatement)
 121     {
 122         isPrepd = true;
 123         parsedData = NULL;
 124         isMgmtStatement = true;
 125         sysdb->releasePrepareStmtMutex();
 126         logFine(Conf::logger,"PREPARE: %s %x", stmtstr, stmt);
 127         return OK;
 128     }
 129     stmt = StatementFactory::getStatement(parsedData);
 130     stmt->setDbMgr(dbMgr);
 131     if( parsedData->getStmtType() == UserStatement)
 132     {
 133         UserManager* userMgr = sqlCon->getConnObject().getUserManager();
 134         UserTblStatement *ustmt = (UserTblStatement *)stmt;
 135         ustmt->setUserManager(userMgr,sqlCon->getConnObject().getUserName());
 136     }
 137     rv = stmt->resolve();
 138     if (rv != OK)
 139     {
 140         free();
 141         parsedData = NULL;
 142         //yyrestart(yyin);
 143         sysdb->releasePrepareStmtMutex();
 144         return rv;
 145     }
 146     parsedData = NULL;
 147     //yyrestart(yyin);
 148     sysdb->releasePrepareStmtMutex();
 149     isPrepd = true;
 150     if (Conf::config.getStmtCacheSize()) {
 151       if (stmt->noOfParamFields() > 0) {
 152         isCachedStmt = true;
 153         sqlCon->addToCache(this, stmtstr);
 154         return OK;
 155       }
 156       if (Conf::config.useCacheNoParam())
 157       {
 158         if (parsedData->getCacheWorthy())
 159         {
 160            isCachedStmt = true;
 161            sqlCon->addToCache(this, stmtstr);
 162            return OK;
 163         }
 164       }
 165     }
 166     return OK;
 167 }
 168
 169 char*  SqlStatement::getTableName()
 170 {
 171     return pData.getTableName();
 172 }
 173
 174 bool SqlStatement::isSelect()
 175 {
 176     if ((pData.getStmtType() == SelectStatement) || (pData.getStmtType() == MetaStatement)) return true;
 177     return false;
 178 }
 179
 180 bool SqlStatement::isPrepared() { return isPrepd; }
 181
 182 DbRetVal SqlStatement::execute(int &rowsAffected)
 183 {
 184     DbRetVal rv = OK;
 185     if (! sqlCon->isConnectionOpen()) {
 186         printError(ErrNotOpen, "Connection not open");
 187         return ErrNotOpen;
 188     }
 189     if (! isPrepared()) {
 190         printError(ErrNotPrepared, "Statement Not Prepared");
 191         return ErrNotPrepared;
 192     }
 193     if( isMgmtStatement )
 194     {
 195         flushCacheStmt();
 196         logFiner(Conf::logger,"EXECUTE: %x", stmt);
 197         return OK;
 198     }
 199     rv = stmt->execute(rowsAffected);
 200     if (rv == ErrAlready  && pData.getStmtType() == SelectStatement )
 201     { //if previous scan is not closed, close it
 202         SelStatement *selStmt = (SelStatement*) stmt;
 203         selStmt->close();
 204         rv = stmt->execute(rowsAffected);
 205     }
 206     logFiner(Conf::logger,"EXECUTE: %x", stmt);
 207     return rv;
 208 }
 209
 210 void* SqlStatement::fetch()
 211 {
 212     if (! sqlCon->isConnectionOpen()) {
 213         printError(ErrNotOpen, "Connection not open");
 214         return NULL;
 215     }
 216     if (! isPrepared()) {
 217         printError(ErrNotPrepared, "Statement Not Prepared");
 218         return NULL;
 219     }
 220     if (pData.getStmtType() == SelectStatement ) {
 221         SelStatement *selStmt = (SelStatement*) stmt;
 222         return selStmt->fetch();
 223     }
 224     else if(pData.getStmtType() == MetaStatement){
 225         MetadataStatement *metaStmt = (MetadataStatement*) stmt;
 226         return metaStmt->fetch();
 227     }
 228     else  { return NULL;}
 229 }
 230
 231 void* SqlStatement::fetch(DbRetVal &rv)
 232 {
 233     if (! sqlCon->isConnectionOpen()) {
 234         printError(ErrNotOpen, "Connection not open");
 235         return NULL;
 236     }
 237     if (! isPrepared()) {
 238         printError(ErrNotPrepared, "Statement Not Prepared");
 239         return NULL;
 240     }
 241     if (pData.getStmtType() == SelectStatement ) {
 242         SelStatement *selStmt = (SelStatement*) stmt;
 243         return selStmt->fetch(rv);
 244     }
 245     else if(pData.getStmtType() == MetaStatement){
 246         MetadataStatement *metaStmt = (MetadataStatement*) stmt;
 247         return metaStmt->fetch(rv);
 248     }
 249     else  { return NULL;}
 250 }
 251
 252 void* SqlStatement::fetchAndPrint(bool SQL)
 253 {
 254     if (! sqlCon->isConnectionOpen()) {
 255         printError(ErrNotOpen, "Connection not open");
 256         return NULL;
 257     }
 258     if (! isPrepared()) {
 259         printError(ErrNotPrepared, "Statement Not Prepared");
 260         return NULL;
 261     }
 262     if (pData.getStmtType() != SelectStatement) return NULL;
 263     SelStatement *selStmt = (SelStatement*) stmt;
 264     return selStmt->fetchAndPrint(SQL);
 265 }
 266
 267 DbRetVal SqlStatement::bindParam(int pos, void* value)
 268 {
 269     DbRetVal rv = OK;
 270     rv = stmt->setParam(pos, value);
 271     return rv;
 272 }
 273
 274 DbRetVal SqlStatement::bindField(int pos, void* value)
 275 {
 276     DbRetVal rv = OK;
 277     if (pData.getStmtType() == SelectStatement ) {
 278         SelStatement *selStmt = (SelStatement*) stmt;
 279         return selStmt->setBindField(pos, value);
 280     }
 281     else if(pData.getStmtType() == MetaStatement){
 282         MetadataStatement *metaStmt = (MetadataStatement*) stmt;
 283         return metaStmt->setBindField(pos, value);
 284     }
 285     else  { return ErrBadCall;}
 286 }
 287 void* SqlStatement::next()
 288 {
 289     if (pData.getStmtType() == SelectStatement ) {
 290         SelStatement *selStmt = (SelStatement*) stmt;
 291         return( (void*) selStmt->next() );
 292     }
 293     else if(pData.getStmtType() == MetaStatement){
 294         MetadataStatement *metaStmt = (MetadataStatement*) stmt;
 295         return( (void*) metaStmt->next() );
 296     }
 297     else  { return 0;}
 298 }
 299
 300 bool SqlStatement::isFldNull(int pos)
 301 {
 302     if (pData.getStmtType() != SelectStatement) return 0;
 303     SelStatement *selStmt = (SelStatement*) stmt;
 304     return (selStmt->isFldNull(pos));
 305 }
 306 bool SqlStatement::isFldNull(char *name)
 307 {
 308     if (pData.getStmtType() != SelectStatement) return 0;
 309     SelStatement *selStmt = (SelStatement*) stmt;
 310     return (selStmt->isFldNull(name));
 311 }
 312 DbRetVal SqlStatement::close()
 313 {
 314     if (pData.getStmtType() == SelectStatement ) {
 315         SelStatement *selStmt = (SelStatement*) stmt;
 316         logFinest(Conf::logger,"CLOSE: %x", stmt);
 317         return selStmt->close();
 318     }
 319     else if(pData.getStmtType() == MetaStatement){
 320         MetadataStatement *selStmt = (MetadataStatement*) stmt;
 321         logFinest(Conf::logger,"CLOSE: %x", stmt);
 322         return selStmt->close();
 323     }
 324     else  { return OK;}
 325 }
 326
 327 void* SqlStatement::getParamValuePtr( int pos )
 328 {
 329     //if (pData.getStmtType() != SelectStatement) return 0;
 330     DmlStatement *dmlStmt = (DmlStatement*) stmt;
 331     return( (void*) dmlStmt->getParamValuePtr( pos ) );
 332 }
 333
 334 char* SqlStatement::getFieldName( int pos )
 335 {
 336     if (pData.getStmtType() == SelectStatement ) {
 337         SelStatement *selStmt = (SelStatement*) stmt;
 338         return( (char*) selStmt->getFieldName( pos ) );
 339     }
 340     else if(pData.getStmtType() == MetaStatement){
 341         MetadataStatement *selStmt = (MetadataStatement*) stmt;
 342         return( (char*) selStmt->getFieldName( pos ) );
 343     }
 344     else  { return 0;}
 345 }
 346
 347 DataType SqlStatement::getFieldType( int pos )
 348 {
 349     if (pData.getStmtType() == SelectStatement ) {
 350         SelStatement *selStmt = (SelStatement*) stmt;
 351         return( (DataType) selStmt->getFieldType( pos ) );
 352     }
 353     else if(pData.getStmtType() == MetaStatement){
 354         MetadataStatement *selStmt = (MetadataStatement*) stmt;
 355         return( (DataType) selStmt->getFieldType( pos ) );
 356     }
 357     else  { return typeUnknown;}
 358 }
 359 int SqlStatement::getFieldLength( int pos )
 360 {
 361     if (pData.getStmtType() == SelectStatement ) {
 362         SelStatement *selStmt = (SelStatement*) stmt;
 363         return( (int) selStmt->getFieldLength( pos ) );
 364     }
 365     else if(pData.getStmtType() == MetaStatement){
 366         MetadataStatement *selStmt = (MetadataStatement*) stmt;
 367         return( (int) selStmt->getFieldLength( pos ) );
 368     }
 369     else  { return 0;}
 370 }
 371
 372 void* SqlStatement::getFieldValuePtr( int pos )
 373 {
 374     if (pData.getStmtType() == SelectStatement ) {
 375         SelStatement *selStmt = (SelStatement*) stmt;
 376         return( (void*) selStmt->getFieldValuePtr( pos ) );
 377     }
 378     else if(pData.getStmtType() == MetaStatement){
 379         MetadataStatement *selStmt = (MetadataStatement*) stmt;
 380         return( (void*) selStmt->getFieldValuePtr( pos ) );
 381     }
 382     else  { return 0;}
 383 }
 384 void* SqlStatement::getFieldValuePtr( char *name )
 385 {
 386     if (pData.getStmtType() == SelectStatement ) {
 387         SelStatement *selStmt = (SelStatement*) stmt;
 388         return( (void*) selStmt->getFieldValuePtr( name ) );
 389     }
 390     else if(pData.getStmtType() == MetaStatement){
 391         MetadataStatement *selStmt = (MetadataStatement*) stmt;
 392         return( (void*) selStmt->getFieldValuePtr( name ) );
 393     }
 394     else  { return NULL;}
 395 }
 396
 397 int SqlStatement::noOfProjFields()
 398 {
 399     if (pData.getStmtType() == SelectStatement ) {
 400         SelStatement *selStmt = (SelStatement*) stmt;
 401         return selStmt->noOfProjFields();
 402     }
 403     else if(pData.getStmtType() == MetaStatement){
 404         MetadataStatement *selStmt = (MetadataStatement*) stmt;
 405         return selStmt->noOfProjFields();
 406     }
 407     else  { return 0;}
 408 }
 409
 410 void SqlStatement::getProjFieldType(int *data)
 411 {
 412     if (pData.getStmtType() == SelectStatement ) {
 413         SelStatement *selStmt = (SelStatement*) stmt;
 414         return( selStmt->getProjFieldType(data) );
 415     }
 416     else if(pData.getStmtType() == MetaStatement){
 417         MetadataStatement *selStmt = (MetadataStatement*) stmt;
 418         return(  selStmt->getProjFieldType(data) );
 419     }
 420
 421
 422 }
 423
 424 int SqlStatement::noOfParamFields()
 425 {
 426     return stmt->noOfParamFields();
 427 }
 428
 429 DbRetVal SqlStatement::getProjFldInfo (int projpos, FieldInfo *&fInfo)
 430 {
 431     DbRetVal rv = OK;
 432     if (pData.getStmtType() == SelectStatement ) {
 433         SelStatement *selStmt = (SelStatement*) stmt;
 434         rv = selStmt->getProjFldInfo(projpos, fInfo);
 435     }
 436     else if(pData.getStmtType() == MetaStatement){
 437         MetadataStatement *selStmt = (MetadataStatement*) stmt;
 438         rv = selStmt->getProjFldInfo(projpos, fInfo);
 439     } else  { return ErrBadCall;}
 440     return rv;
 441 }
 442
 443 DbRetVal SqlStatement::getParamFldInfo (int parampos, FieldInfo *&fInfo)
 444 {
 445     DbRetVal rv = OK;
 446     if (pData.getStmtType() ==SelectStatement ||
 447         pData.getStmtType() ==InsertStatement ||
 448         pData.getStmtType() ==UpdateStatement ||
 449         pData.getStmtType() ==DeleteStatement)
 450     {
 451
 452         DmlStatement *dmlStmt = (DmlStatement*) stmt;
 453         rv = dmlStmt->getParamFldInfo(parampos, fInfo);
 454     }
 455     return rv;
 456 }
 457
 458 DbRetVal SqlStatement::free()
 459 {
 460     logFinest(Conf::logger,"FREE: %x", stmt);
 461     if (isCachedStmt) {
 462         stmt=NULL;
 463         pData.init();
 464         isPrepd = false;
 465         return OK;
 466     }
 467     if(stmt) delete stmt;
 468     stmt = NULL;
 469     pData.reset();
 470     isMgmtStatement = false;
 471     isPrepd = false;
 472     return OK;
 473 }
 474
 475 void SqlStatement::setNull(int pos)
 476 {
 477     stmt->setNull(pos);
 478 }
 479 void SqlStatement::setShortParam(int paramPos, short value)
 480 {
 481     stmt->setShortParam(paramPos, value);
 482 }
 483 void SqlStatement::setIntParam(int paramPos, int value)
 484 {
 485     stmt->setIntParam(paramPos, value);
 486 }
 487 void SqlStatement::setLongParam(int paramPos, long value)
 488 {
 489     stmt->setLongParam(paramPos, value);
 490 }
 491 void SqlStatement::setLongLongParam(int paramPos, long long value)
 492 {
 493     stmt->setLongLongParam(paramPos, value);
 494 }
 495 void SqlStatement::setByteIntParam(int paramPos, ByteInt value)
 496 {
 497     stmt->setByteIntParam(paramPos, value);
 498 }
 499 void SqlStatement::setFloatParam(int paramPos, float value)
 500 {
 501     stmt->setFloatParam(paramPos, value);
 502 }
 503 void SqlStatement::setDoubleParam(int paramPos, double value)
 504 {
 505     stmt->setDoubleParam(paramPos, value);
 506 }
 507 void SqlStatement::setStringParam(int paramPos, char *value)
 508 {
 509     stmt->setStringParam(paramPos, value);
 510 }
 511 void SqlStatement::setDateParam(int paramPos, Date value)
 512 {
 513     stmt->setDateParam(paramPos, value);
 514 }
 515 void SqlStatement::setTimeParam(int paramPos, Time value)
 516 {
 517     stmt->setTimeParam(paramPos, value);
 518 }
 519 void SqlStatement::setTimeStampParam(int paramPos, TimeStamp value)
 520 {
 521     stmt->setTimeStampParam(paramPos, value);
 522 }
 523 void SqlStatement::setBinaryParam(int paramPos, void *value, int length)
 524 {
 525     stmt->setBinaryParam(paramPos, value, length);
 526 }
 527 int SqlStatement::getFldPos(char *name)
 528 {
 529     return stmt->getFldPos(name);
 530 }
 531 List SqlStatement::getAllTableNames(DbRetVal &ret)
 532 {
 533     DatabaseManager *dbMgr = NULL;
 534     List tbNmList;
 535     dbMgr=sqlCon->getConnObject().getDatabaseManager();
 536     int rv = ret;
 537     if(dbMgr != NULL)
 538     tbNmList = dbMgr->getAllTableNames(&rv);
 539     ret = (DbRetVal) rv;
 540     return tbNmList;
 541 }
 542
 543 List SqlStatement::getAllUserNames(DbRetVal &ret)
 544 {
 545     UserManager *urMgr = NULL;
 546     List urNmList;
 547     urMgr=sqlCon->getConnObject().getUserManager();
 548     int rv = ret;
 549     if(urMgr != NULL)
 550         urNmList = urMgr->getAllUserNames(&rv);
 551     ret = (DbRetVal) rv;
 552     return urNmList;
 553 }
 554 List SqlStatement::getFieldNameList(const char *tblName)
 555 {
 556     DatabaseManager *dbMgr = sqlCon->getConnObject().getDatabaseManager();
 557     Table *table = dbMgr->openTable(tblName);
 558     List fldNameList = table->getFieldNameList();
 559     dbMgr->closeTable(table);
 560     return fldNameList;
 561 }
 562 DbRetVal SqlStatement::getFieldInfo(const char *tblName, const char *fldName, FieldInfo *&info)
 563 {
 564     DatabaseManager *dbMgr = sqlCon->getConnObject().getDatabaseManager();
 565     Table *table = dbMgr->openTable(tblName);
 566     DbRetVal rv = table->getFieldInfo(fldName, info);
 567     dbMgr->closeTable(table);
 568     return OK;
 569 }
 570 void SqlStatement::setLoading(bool flag)
 571 {
 572     if (pData.getStmtType() == InsertStatement||
 573         pData.getStmtType() == UpdateStatement||
 574         pData.getStmtType() == DeleteStatement)
 575     {
 576         DmlStatement *dmlStmt = (DmlStatement*) stmt;
 577         dmlStmt->setLoading(flag);
 578     }
 579     return;
 580 }
 581
 582 int SqlStatement::getNoOfPagesForTable(char *tblName)
 583 {
 584     DatabaseManager *dbMgr = sqlCon->getConnObject().getDatabaseManager();
 585     DatabaseManagerImpl *dbMgrImpl = (DatabaseManagerImpl *)dbMgr;
 586     return dbMgrImpl->getNoOfPagesForTable(tblName);
 587 }
 588
 589 DbRetVal SqlStatement::loadRecords(char *tblName, void *buf)
 590 {
 591     DatabaseManager *dbMgr = sqlCon->getConnObject().getDatabaseManager();
 592     DatabaseManagerImpl *dbMgrImpl = (DatabaseManagerImpl *)dbMgr;
 593     return dbMgrImpl->loadRecords(tblName, (char *) buf);
 594 }
 595
 596 DbRetVal SqlStatement::pasteRecords(char *tblName, void *buffer)
 597 {
 598     DatabaseManager *dbMgr = sqlCon->getConnObject().getDatabaseManager();
 599     DatabaseManagerImpl *dbMgrImpl = (DatabaseManagerImpl *)dbMgr;
 600     return dbMgrImpl->pasteRecords(tblName, buffer);
 601 }
 602 void SqlStatement::flushCacheStmt()
 603 {
 604     return sqlCon->flushCacheStmt();
 605 }
 606 //-------------------------------------------------------------------
 607 void SqlConnection::flushCacheStmt()
 608 {
 609     ListIterator iter = cachedStmts.getIterator();
 610     while (iter.hasElement()) {
 611         CachedStmtNode* node = (CachedStmtNode*) iter.nextElement();
 612         free(node->sqlString);
 613         node->sqlStmt->setCachedStmt(false);
 614         node->sqlStmt->free();
 615         delete node->sqlStmt;
 616         delete node;
 617     }
 618     cachedStmts.reset();
 619     return;
 620 }
 621
 622 SqlStatement* SqlConnection::findInCache(char *stmtstr)
 623 {
 624     ListIterator iter = cachedStmts.getIterator();
 625     int inputStmtLen = strlen(stmtstr);
 626     CachedStmtNode *node = NULL;
 627     while ((node = (CachedStmtNode*)iter.nextElement()) != NULL)
 628     {
 629         if (node->stmtLength == inputStmtLen)
 630         {
 631            if (0 == strcmp(node->sqlString, stmtstr))
 632            {
 633                logFiner(Conf::logger, "Statement Retrieved From Cache %x\n",
 634                                       node->sqlStmt);
 635                node->hits++;
 636                return node->sqlStmt;
 637            }
 638         }
 639     }
 640     return NULL;
 641 }
 642 void SqlConnection::addToCache(SqlStatement *sqlStmt, char* stmtString)
 643 {
 644     SqlStatement *stmt = new SqlStatement();
 645     *stmt= *sqlStmt;
 646     CachedStmtNode *node = new CachedStmtNode();
 647     node->sqlStmt = stmt;
 648     node->stmtLength  = strlen(stmtString);
 649     node->sqlString = (char*)malloc(node->stmtLength+1);
 650     strcpy(node->sqlString, stmtString);
 651     if (cachedStmts.size() >= Conf::config.getStmtCacheSize())
 652     {
 653         removeLeastUsed();
 654     }
 655     cachedStmts.append(node);
 656     logFiner(Conf::logger, "Statement added To Cache %x\n", node->sqlStmt);
 657     logFinest(Conf::logger, "Statement added To Cache %s\n", node->sqlString);
 658     return ;
 659 }
 660 void SqlConnection::removeLeastUsed()
 661 {
 662     ListIterator iter = cachedStmts.getIterator();
 663     CachedStmtNode *node = NULL, *toRemove =NULL;
 664     int lowHits = 0;
 665     bool firstCall = true;
 666     while((node = (CachedStmtNode*) iter.nextElement()) != NULL)
 667     {
 668         if (firstCall) {
 669             firstCall = false;
 670             lowHits = node->hits;
 671             toRemove = node; //if cache size is 1
 672             continue;
 673         }
 674         if (lowHits >= node->hits) toRemove = node;
 675     }
 676     cachedStmts.remove(toRemove);
 677     logFiner(Conf::logger, "Statement removed from Cache %x\n", toRemove->sqlStmt);
 678     logFinest(Conf::logger, "Statement removed from Cache %s\n", toRemove->sqlString);
 679     return;
 680 }
 681 SqlConnection::~SqlConnection()
 682 {
 683     innerConn = NULL;
 684     flushCacheStmt();
 685     if (isConnOpen) disconnect();
 686 }
 687