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