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