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 #if (defined MMDB && defined EMBED)
  31 bool SqlConnection::firstThread = false;
  32 GlobalUniqueID SqlConnection::UID;
  33 #endif
  34 List SqlConnection::connList;
  35
  36
  37 SqlStatement::~SqlStatement()
  38 {
  39     if (isPrepd) { free(); isPrepd = false; }
  40 }
  41
  42 List SqlStatement::getTableNameList()
  43 {
  44     return pData.getTableNameList();
  45 }
  46 SqlStatement::SqlStatement()
  47 {
  48     innerStmt = NULL;
  49     sqlCon = NULL;
  50     stmt = NULL;
  51     isPrepd = false;
  52     isCachedStmt=false;
  53     isMgmtStatement = false;
  54 }
  55 void SqlStatement::setConnection(AbsSqlConnection *conn)
  56 {
  57     sqlCon = (SqlConnection*)conn;
  58     con = conn;
  59
  60 }
  61 void SqlStatement::setSqlConnection(SqlConnection *conn)
  62 {
  63     sqlCon = conn;
  64 }
  65
  66 DbRetVal SqlStatement::executeDirect(char *str)
  67 {
  68     DbRetVal rv = OK;
  69     int rows = 0;
  70     rv = prepare(str);
  71     if (rv != OK) return rv;
  72     rv = execute(rows);
  73     if (rv != OK) return rv;
  74     return rv;
  75 }
  76
  77 DbRetVal SqlStatement::prepare(char *stmtstr)
  78 {
  79     DbRetVal rv = OK;
  80     if (! sqlCon->isConnectionOpen()) {
  81         printError(ErrNotOpen, "Connection not open");
  82         return ErrNotOpen;
  83     }
  84     SqlStatement *cachedStmt = sqlCon->findInCache(stmtstr);
  85     if (cachedStmt)
  86     {
  87         *this = *cachedStmt;
  88         this->stmt->setParsedData(&this->pData);
  89         logFine(Conf::logger,"GOT STMT FROM CACHE: %s %x", stmtstr, cachedStmt);
  90         return OK;
  91     }
  92     // take mutex here
  93     int ret = ProcessManager::prepareMutex.tryLock(10, 1000);
  94     if (ret != 0)
  95     {
  96         printError(ErrLockTimeOut, "Unable to get prepare mutex");
  97         return ErrLockTimeOut;
  98     }
  99
 100     DatabaseManager *dbMgr = sqlCon->getConnObject().getDatabaseManager();
 101     if (isPrepared()) free();
 102     lexInput = stmtstr;
 103     parsedData = &pData;
 104
 105     yy_buffer_state *yy_buffer= yy_scan_string(stmtstr);
 106     int rc = yyparse();
 107     if (yy_buffer) yy_delete_buffer(yy_buffer);
 108     if (rc != 0)
 109     {
 110         free();
 111         parsedData = NULL;
 112         ProcessManager::prepareMutex.releaseLock(-1, false);
 113         return ErrSyntaxError;
 114     }
 115     if( parsedData->getStmtType() == MgmtStatement)
 116     {
 117         isPrepd = true;
 118         parsedData = NULL;
 119         isMgmtStatement = true;
 120         ProcessManager::prepareMutex.releaseLock(-1, false);
 121         logFine(Conf::logger,"PREPARE: %s %x", stmtstr, stmt);
 122         return OK;
 123     }
 124     stmt = StatementFactory::getStatement(parsedData);
 125     stmt->setDbMgr(dbMgr);
 126     if( parsedData->getStmtType() == UserStatement)
 127     {
 128         UserManager* userMgr = sqlCon->getConnObject().getUserManager();
 129         UserTblStatement *ustmt = (UserTblStatement *)stmt;
 130         ustmt->setUserManager(userMgr,sqlCon->getConnObject().getUserName());
 131     }
 132     rv = stmt->resolve();
 133     if (rv != OK)
 134     {
 135         free();
 136         parsedData = NULL;
 137         ProcessManager::prepareMutex.releaseLock(-1, false);
 138         return rv;
 139     }
 140     isPrepd = true;
 141     if (Conf::config.getStmtCacheSize()) {
 142       if (stmt->noOfParamFields() > 0) {
 143         isCachedStmt = true;
 144         sqlCon->addToCache(this, stmtstr);
 145       }else if (Conf::config.useCacheNoParam())
 146       {
 147         if (parsedData->getCacheWorthy())
 148         {
 149            isCachedStmt = true;
 150            sqlCon->addToCache(this, stmtstr);
 151         }
 152       }
 153     }
 154     parsedData = NULL;
 155     ProcessManager::prepareMutex.releaseLock(-1, false);
 156     return OK;
 157 }
 158
 159 char*  SqlStatement::getTableName()
 160 {
 161     return pData.getTableName();
 162 }
 163
 164 bool SqlStatement::isSelect()
 165 {
 166     if ((pData.getStmtType() == SelectStatement) || (pData.getStmtType() == MetaStatement)) return true;
 167     return false;
 168 }
 169
 170 bool SqlStatement::isPrepared() { return isPrepd; }
 171
 172 DbRetVal SqlStatement::execute(int &rowsAffected)
 173 {
 174     DbRetVal rv = OK;
 175     if (! sqlCon->isConnectionOpen()) {
 176         printError(ErrNotOpen, "Connection not open");
 177         return ErrNotOpen;
 178     }
 179     if (! isPrepared()) {
 180         printError(ErrNotPrepared, "Statement Not Prepared");
 181         return ErrNotPrepared;
 182     }
 183     if( isMgmtStatement )
 184     {
 185         flushCacheStmt();
 186         logFiner(Conf::logger,"EXECUTE: %x", stmt);
 187         return OK;
 188     }
 189     rv = stmt->execute(rowsAffected);
 190     if (rv == ErrAlready  && pData.getStmtType() == SelectStatement )
 191     { //if previous scan is not closed, close it
 192         SelStatement *selStmt = (SelStatement*) stmt;
 193         selStmt->close();
 194         rv = stmt->execute(rowsAffected);
 195     }
 196     logFiner(Conf::logger,"EXECUTE: %x", stmt);
 197     return rv;
 198 }
 199
 200 void* SqlStatement::fetch()
 201 {
 202     if (! sqlCon->isConnectionOpen()) {
 203         printError(ErrNotOpen, "Connection not open");
 204         return NULL;
 205     }
 206     if (! isPrepared()) {
 207         printError(ErrNotPrepared, "Statement Not Prepared");
 208         return NULL;
 209     }
 210     if (pData.getStmtType() == SelectStatement ) {
 211         SelStatement *selStmt = (SelStatement*) stmt;
 212         return selStmt->fetch();
 213     }
 214     else if(pData.getStmtType() == MetaStatement){
 215         MetadataStatement *metaStmt = (MetadataStatement*) stmt;
 216         return metaStmt->fetch();
 217     }
 218     else  { return NULL;}
 219 }
 220
 221 void* SqlStatement::fetch(DbRetVal &rv)
 222 {
 223     if (! sqlCon->isConnectionOpen()) {
 224         printError(ErrNotOpen, "Connection not open");
 225         rv = ErrNoConnection;
 226         return NULL;
 227     }
 228     if (! isPrepared()) {
 229         printError(ErrNotPrepared, "Statement Not Prepared");
 230         return NULL;
 231     }
 232     if (pData.getStmtType() == SelectStatement ) {
 233         SelStatement *selStmt = (SelStatement*) stmt;
 234         return selStmt->fetch(rv);
 235     }
 236     else if(pData.getStmtType() == MetaStatement){
 237         MetadataStatement *metaStmt = (MetadataStatement*) stmt;
 238         return metaStmt->fetch(rv);
 239     }
 240     else  { return NULL;}
 241 }
 242
 243 void* SqlStatement::fetchAndPrint(bool SQL)
 244 {
 245     if (! sqlCon->isConnectionOpen()) {
 246         printError(ErrNotOpen, "Connection not open");
 247         return NULL;
 248     }
 249     if (! isPrepared()) {
 250         printError(ErrNotPrepared, "Statement Not Prepared");
 251         return NULL;
 252     }
 253     if (pData.getStmtType() != SelectStatement) return NULL;
 254     SelStatement *selStmt = (SelStatement*) stmt;
 255     return selStmt->fetchAndPrint(SQL);
 256 }
 257
 258 DbRetVal SqlStatement::bindParam(int pos, void* value)
 259 {
 260     DbRetVal rv = OK;
 261     rv = stmt->setParam(pos, value);
 262     return rv;
 263 }
 264
 265 DbRetVal SqlStatement::bindField(int pos, void* value)
 266 {
 267     DbRetVal rv = OK;
 268     if (pData.getStmtType() == SelectStatement ) {
 269         SelStatement *selStmt = (SelStatement*) stmt;
 270         return selStmt->setBindField(pos, value);
 271     }
 272     else if(pData.getStmtType() == MetaStatement){
 273         MetadataStatement *metaStmt = (MetadataStatement*) stmt;
 274         return metaStmt->setBindField(pos, value);
 275     }
 276     else  { return ErrBadCall;}
 277 }
 278 void* SqlStatement::next()
 279 {
 280     if (pData.getStmtType() == SelectStatement ) {
 281         SelStatement *selStmt = (SelStatement*) stmt;
 282         return( (void*) selStmt->next() );
 283     }
 284     else if(pData.getStmtType() == MetaStatement){
 285         MetadataStatement *metaStmt = (MetadataStatement*) stmt;
 286         return( (void*) metaStmt->next() );
 287     }
 288     else  { return 0;}
 289 }
 290
 291 bool SqlStatement::isFldNull(int pos)
 292 {
 293     if (pData.getStmtType() != SelectStatement) return 0;
 294     SelStatement *selStmt = (SelStatement*) stmt;
 295     return (selStmt->isFldNull(pos));
 296 }
 297 bool SqlStatement::isFldNull(char *name)
 298 {
 299     if (pData.getStmtType() != SelectStatement) return 0;
 300     SelStatement *selStmt = (SelStatement*) stmt;
 301     return (selStmt->isFldNull(name));
 302 }
 303 DbRetVal SqlStatement::close()
 304 {
 305     if (pData.getStmtType() == SelectStatement ) {
 306         SelStatement *selStmt = (SelStatement*) stmt;
 307         logFinest(Conf::logger,"CLOSE: %x", stmt);
 308         return selStmt->close();
 309     }
 310     else if(pData.getStmtType() == MetaStatement){
 311         MetadataStatement *selStmt = (MetadataStatement*) stmt;
 312         logFinest(Conf::logger,"CLOSE: %x", stmt);
 313         return selStmt->close();
 314     }
 315     else  { return OK;}
 316 }
 317
 318 void* SqlStatement::getParamValuePtr( int pos )
 319 {
 320     //if (pData.getStmtType() != SelectStatement) return 0;
 321     DmlStatement *dmlStmt = (DmlStatement*) stmt;
 322     return( (void*) dmlStmt->getParamValuePtr( pos ) );
 323 }
 324
 325 char* SqlStatement::getFieldName( int pos )
 326 {
 327     if (pData.getStmtType() == SelectStatement ) {
 328         SelStatement *selStmt = (SelStatement*) stmt;
 329         return( (char*) selStmt->getFieldName( pos ) );
 330     }
 331     else if(pData.getStmtType() == MetaStatement){
 332         MetadataStatement *selStmt = (MetadataStatement*) stmt;
 333         return( (char*) selStmt->getFieldName( pos ) );
 334     }
 335     else  { return 0;}
 336 }
 337
 338 DataType SqlStatement::getFieldType( int pos )
 339 {
 340     if (pData.getStmtType() == SelectStatement ) {
 341         SelStatement *selStmt = (SelStatement*) stmt;
 342         return( (DataType) selStmt->getFieldType( pos ) );
 343     }
 344     else if(pData.getStmtType() == MetaStatement){
 345         MetadataStatement *selStmt = (MetadataStatement*) stmt;
 346         return( (DataType) selStmt->getFieldType( pos ) );
 347     }
 348     else  { return typeUnknown;}
 349 }
 350 int SqlStatement::getFieldLength( int pos )
 351 {
 352     if (pData.getStmtType() == SelectStatement ) {
 353         SelStatement *selStmt = (SelStatement*) stmt;
 354         return( (int) selStmt->getFieldLength( pos ) );
 355     }
 356     else if(pData.getStmtType() == MetaStatement){
 357         MetadataStatement *selStmt = (MetadataStatement*) stmt;
 358         return( (int) selStmt->getFieldLength( pos ) );
 359     }
 360     else  { return 0;}
 361 }
 362
 363 void* SqlStatement::getFieldValuePtr( int pos )
 364 {
 365     if (pData.getStmtType() == SelectStatement ) {
 366         SelStatement *selStmt = (SelStatement*) stmt;
 367         return( (void*) selStmt->getFieldValuePtr( pos ) );
 368     }
 369     else if(pData.getStmtType() == MetaStatement){
 370         MetadataStatement *selStmt = (MetadataStatement*) stmt;
 371         return( (void*) selStmt->getFieldValuePtr( pos ) );
 372     }
 373     else  { return 0;}
 374 }
 375 void* SqlStatement::getFieldValuePtr( char *name )
 376 {
 377     if (pData.getStmtType() == SelectStatement ) {
 378         SelStatement *selStmt = (SelStatement*) stmt;
 379         return( (void*) selStmt->getFieldValuePtr( name ) );
 380     }
 381     else if(pData.getStmtType() == MetaStatement){
 382         MetadataStatement *selStmt = (MetadataStatement*) stmt;
 383         return( (void*) selStmt->getFieldValuePtr( name ) );
 384     }
 385     else  { return NULL;}
 386 }
 387
 388 int SqlStatement::noOfProjFields()
 389 {
 390     if (pData.getStmtType() == SelectStatement ) {
 391         SelStatement *selStmt = (SelStatement*) stmt;
 392         return selStmt->noOfProjFields();
 393     }
 394     else if(pData.getStmtType() == MetaStatement){
 395         MetadataStatement *selStmt = (MetadataStatement*) stmt;
 396         return selStmt->noOfProjFields();
 397     }
 398     else  { return 0;}
 399 }
 400
 401 void SqlStatement::getProjFieldType(int *data)
 402 {
 403     if (pData.getStmtType() == SelectStatement ) {
 404         SelStatement *selStmt = (SelStatement*) stmt;
 405         return( selStmt->getProjFieldType(data) );
 406     }
 407     else if(pData.getStmtType() == MetaStatement){
 408         MetadataStatement *selStmt = (MetadataStatement*) stmt;
 409         return(  selStmt->getProjFieldType(data) );
 410     }
 411
 412
 413 }
 414
 415 int SqlStatement::noOfParamFields()
 416 {
 417     return stmt->noOfParamFields();
 418 }
 419
 420 DbRetVal SqlStatement::getProjFldInfo (int projpos, FieldInfo *&fInfo)
 421 {
 422     DbRetVal rv = OK;
 423     if (pData.getStmtType() == SelectStatement ) {
 424         SelStatement *selStmt = (SelStatement*) stmt;
 425         rv = selStmt->getProjFldInfo(projpos, fInfo);
 426     }
 427     else if(pData.getStmtType() == MetaStatement){
 428         MetadataStatement *selStmt = (MetadataStatement*) stmt;
 429         rv = selStmt->getProjFldInfo(projpos, fInfo);
 430     } else  { return ErrBadCall;}
 431     return rv;
 432 }
 433
 434 DbRetVal SqlStatement::getParamFldInfo (int parampos, FieldInfo *&fInfo)
 435 {
 436     DbRetVal rv = OK;
 437     if (pData.getStmtType() ==SelectStatement ||
 438         pData.getStmtType() ==InsertStatement ||
 439         pData.getStmtType() ==UpdateStatement ||
 440         pData.getStmtType() ==DeleteStatement)
 441     {
 442
 443         DmlStatement *dmlStmt = (DmlStatement*) stmt;
 444         rv = dmlStmt->getParamFldInfo(parampos, fInfo);
 445     }
 446     return rv;
 447 }
 448
 449 DbRetVal SqlStatement::free()
 450 {
 451     logFinest(Conf::logger,"FREE: %x", stmt);
 452     if (isCachedStmt) {
 453         stmt=NULL;
 454         pData.init();
 455         isPrepd = false;
 456         return OK;
 457     }
 458     if(stmt) delete stmt;
 459     stmt = NULL;
 460     pData.reset();
 461     isMgmtStatement = false;
 462     isPrepd = false;
 463     return OK;
 464 }
 465
 466 void SqlStatement::setNull(int pos)
 467 {
 468     stmt->setNull(pos);
 469 }
 470 void SqlStatement::setShortParam(int paramPos, short value)
 471 {
 472     stmt->setShortParam(paramPos, value);
 473 }
 474 void SqlStatement::setIntParam(int paramPos, int value)
 475 {
 476     stmt->setIntParam(paramPos, value);
 477 }
 478 void SqlStatement::setLongParam(int paramPos, long value)
 479 {
 480     stmt->setLongParam(paramPos, value);
 481 }
 482 void SqlStatement::setLongLongParam(int paramPos, long long value)
 483 {
 484     stmt->setLongLongParam(paramPos, value);
 485 }
 486 void SqlStatement::setByteIntParam(int paramPos, ByteInt value)
 487 {
 488     stmt->setByteIntParam(paramPos, value);
 489 }
 490 void SqlStatement::setFloatParam(int paramPos, float value)
 491 {
 492     stmt->setFloatParam(paramPos, value);
 493 }
 494 void SqlStatement::setDoubleParam(int paramPos, double value)
 495 {
 496     stmt->setDoubleParam(paramPos, value);
 497 }
 498 void SqlStatement::setStringParam(int paramPos, char *value)
 499 {
 500     stmt->setStringParam(paramPos, value);
 501 }
 502 void SqlStatement::setDateParam(int paramPos, Date value)
 503 {
 504     stmt->setDateParam(paramPos, value);
 505 }
 506 void SqlStatement::setTimeParam(int paramPos, Time value)
 507 {
 508     stmt->setTimeParam(paramPos, value);
 509 }
 510 void SqlStatement::setTimeStampParam(int paramPos, TimeStamp value)
 511 {
 512     stmt->setTimeStampParam(paramPos, value);
 513 }
 514 void SqlStatement::setBinaryParam(int paramPos, void *value, int length)
 515 {
 516     stmt->setBinaryParam(paramPos, value, length);
 517 }
 518 int SqlStatement::getFldPos(char *name)
 519 {
 520     return stmt->getFldPos(name);
 521 }
 522 long long SqlStatement::getLastInsertedVal(DbRetVal &rv)
 523 {
 524    return stmt->getLastInsertedVal(rv);
 525 }
 526 List SqlStatement::getAllTableNames(DbRetVal &ret)
 527 {
 528     DatabaseManager *dbMgr = NULL;
 529     List tbNmList;
 530     dbMgr=sqlCon->getConnObject().getDatabaseManager();
 531     int rv = ret;
 532     if(dbMgr != NULL)
 533     tbNmList = dbMgr->getAllTableNames(&rv);
 534     ret = (DbRetVal) rv;
 535     return tbNmList;
 536 }
 537
 538 List SqlStatement::getAllUserNames(DbRetVal &ret)
 539 {
 540     UserManager *urMgr = NULL;
 541     List urNmList;
 542     urMgr=sqlCon->getConnObject().getUserManager();
 543     int rv = ret;
 544     if(urMgr != NULL)
 545         urNmList = urMgr->getAllUserNames(&rv);
 546     ret = (DbRetVal) rv;
 547     return urNmList;
 548 }
 549 List SqlStatement::getFieldNameList(const char *tblName)
 550 {
 551     DatabaseManager *dbMgr = sqlCon->getConnObject().getDatabaseManager();
 552     Table *table = dbMgr->openTable(tblName);
 553     if (NULL == table) {
 554         List dummyList;
 555         printError(ErrLockTimeOut, "Unable to open table %s", tblName);
 556         return dummyList;
 557     }
 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     if (NULL == table) {
 567         printError(ErrLockTimeOut, "Unable to open table %s", tblName);
 568         return ErrLockTimeOut;
 569     }
 570     DbRetVal rv = table->getFieldInfo(fldName, info);
 571     dbMgr->closeTable(table);
 572     return OK;
 573 }
 574 void SqlStatement::setLoading(bool flag)
 575 {
 576     if (pData.getStmtType() == InsertStatement||
 577         pData.getStmtType() == UpdateStatement||
 578         pData.getStmtType() == DeleteStatement)
 579     {
 580         DmlStatement *dmlStmt = (DmlStatement*) stmt;
 581         dmlStmt->setLoading(flag);
 582     }
 583     return;
 584 }
 585
 586 int SqlStatement::getNoOfPagesForTable(char *tblName)
 587 {
 588     DatabaseManager *dbMgr = sqlCon->getConnObject().getDatabaseManager();
 589     DatabaseManagerImpl *dbMgrImpl = (DatabaseManagerImpl *)dbMgr;
 590     return dbMgrImpl->getNoOfPagesForTable(tblName);
 591 }
 592
 593 DbRetVal SqlStatement::loadRecords(char *tblName, void *buf)
 594 {
 595     DatabaseManager *dbMgr = sqlCon->getConnObject().getDatabaseManager();
 596     DatabaseManagerImpl *dbMgrImpl = (DatabaseManagerImpl *)dbMgr;
 597     return dbMgrImpl->loadRecords(tblName, (char *) buf);
 598 }
 599
 600 DbRetVal SqlStatement::pasteRecords(char *tblName, void *buffer)
 601 {
 602     DatabaseManager *dbMgr = sqlCon->getConnObject().getDatabaseManager();
 603     DatabaseManagerImpl *dbMgrImpl = (DatabaseManagerImpl *)dbMgr;
 604     return dbMgrImpl->pasteRecords(tblName, buffer);
 605 }
 606 void SqlStatement::flushCacheStmt()
 607 {
 608     return sqlCon->flushCacheStmt();
 609 }
 610 //-------------------------------------------------------------------
 611
 612 static void sigTermHandler(int sig)
 613 {
 614     ListIterator iter= SqlConnection::connList.getIterator();
 615     SqlConnection *conn = NULL;
 616     while (iter.hasElement())
 617     {
 618         conn = (SqlConnection*) iter.nextElement();
 619         conn->flushCacheStmt();
 620         if (conn->isConnectionOpen()) conn->disconnect();
 621     }
 622     exit(0);
 623 }
 624
 625 DbRetVal SqlConnection::connect (char *user, char * pass)
 626 {
 627     DbRetVal ret = conn.open(user, pass);
 628     if (ret != OK) return ret;
 629     if (ret == OK) isConnOpen = true;
 630     if (!isInit) initialize();
 631     connList.append(this);
 632     DbRetVal rv = OK;
 633 #if (defined MMDB && EMBED)
 634     os::signal(SIGINT, sigTermHandler);
 635     os::signal(SIGTERM, sigTermHandler);
 636     if (Conf::config.useDurability() && !firstThread) {
 637         rv = recoverCsqlDB();
 638         if (rv != OK) {
 639             printError(ErrSysInternal, "Recovery Failed");
 640             return rv;
 641         }
 642         firstThread = true;
 643     }
 644     rollback(); //for drop table execute in redo log
 645 #endif
 646     return ret;
 647 }
 648
 649 void SqlConnection::flushCacheStmt()
 650 {
 651     ListIterator iter = cachedStmts.getIterator();
 652     while (iter.hasElement()) {
 653         CachedStmtNode* node = (CachedStmtNode*) iter.nextElement();
 654         free(node->sqlString);
 655         node->sqlStmt->setCachedStmt(false);
 656         node->sqlStmt->free();
 657         delete node->sqlStmt;
 658         delete node;
 659     }
 660     cachedStmts.reset();
 661     return;
 662 }
 663
 664 SqlStatement* SqlConnection::findInCache(char *stmtstr)
 665 {
 666     ListIterator iter = cachedStmts.getIterator();
 667     int inputStmtLen = strlen(stmtstr);
 668     CachedStmtNode *node = NULL;
 669     while ((node = (CachedStmtNode*)iter.nextElement()) != NULL)
 670     {
 671         if (node->stmtLength == inputStmtLen)
 672         {
 673            if (0 == strcmp(node->sqlString, stmtstr))
 674            {
 675                logFiner(Conf::logger, "Statement Retrieved From Cache %x\n",
 676                                       node->sqlStmt);
 677                node->hits++;
 678                return node->sqlStmt;
 679            }
 680         }
 681     }
 682     return NULL;
 683 }
 684 void SqlConnection::addToCache(SqlStatement *sqlStmt, char* stmtString)
 685 {
 686     SqlStatement *stmt = new SqlStatement();
 687     *stmt= *sqlStmt;
 688     CachedStmtNode *node = new CachedStmtNode();
 689     node->sqlStmt = stmt;
 690     node->stmtLength  = strlen(stmtString);
 691     node->sqlString = (char*)malloc(node->stmtLength+1);
 692     strcpy(node->sqlString, stmtString);
 693     if (cachedStmts.size() >= Conf::config.getStmtCacheSize())
 694     {
 695         removeLeastUsed();
 696     }
 697     cachedStmts.append(node);
 698     logFiner(Conf::logger, "Statement added To Cache %x\n", node->sqlStmt);
 699     logFinest(Conf::logger, "Statement added To Cache %s\n", node->sqlString);
 700     return ;
 701 }
 702 void SqlConnection::removeLeastUsed()
 703 {
 704     ListIterator iter = cachedStmts.getIterator();
 705     CachedStmtNode *node = NULL, *toRemove =NULL;
 706     int lowHits = 0;
 707     bool firstCall = true;
 708     while((node = (CachedStmtNode*) iter.nextElement()) != NULL)
 709     {
 710         if (firstCall) {
 711             firstCall = false;
 712             lowHits = node->hits;
 713             toRemove = node; //if cache size is 1
 714             continue;
 715         }
 716         if (lowHits >= node->hits) toRemove = node;
 717     }
 718     cachedStmts.remove(toRemove);
 719     logFiner(Conf::logger, "Statement removed from Cache %x\n", toRemove->sqlStmt);
 720     logFinest(Conf::logger, "Statement removed from Cache %s\n", toRemove->sqlString);
 721     return;
 722 }
 723 SqlConnection::~SqlConnection()
 724 {
 725     innerConn = NULL;
 726     flushCacheStmt();
 727     if (isConnOpen) disconnect();
 728 }
 729 static void sigUsr1Handler(int sig)
 730 {
 731     ListIterator iter= SqlConnection::connList.getIterator();
 732     SqlConnection *conn = NULL;
 733     while (iter.hasElement())
 734     {
 735         conn = (SqlConnection*) iter.nextElement();
 736         conn->flushCacheStmt();
 737     }
 738     os::signal(SIGCSQL1, sigUsr1Handler);
 739     return;
 740 }
 741
 742 static void exithandler(void)
 743 {
 744     ListIterator iter= SqlConnection::connList.getIterator();
 745     SqlConnection *conn = NULL;
 746     while (iter.hasElement())
 747     {
 748         conn = (SqlConnection*) iter.nextElement();
 749         conn->flushCacheStmt();
 750         conn->disconnect();
 751     }
 752 }
 753
 754 void SqlConnection::initialize()
 755 {
 756     os::signal(SIGCSQL1, sigUsr1Handler);
 757 #if (defined MMDB && defined EMBED)
 758     os::atexit(exithandler);
 759 #endif
 760     isInit = true;
 761 }
 762
 763 #if (defined MMDB && defined EMBED)
 764 DbRetVal SqlConnection::recoverCsqlDB()
 765 {
 766     DbRetVal rv = OK;
 767     char dbRedoFileName[MAX_FILE_LEN];
 768     char dbChkptSchema[MAX_FILE_LEN];
 769     char dbChkptMap[MAX_FILE_LEN];
 770     char dbChkptData[MAX_FILE_LEN];
 771     char dbBackupFile[MAX_FILE_LEN];
 772     char cmd[IDENTIFIER_LENGTH];
 773     //check for check point file if present recover
 774     sprintf(dbChkptSchema, "%s/db.chkpt.schema1", Conf::config.getDbFile());
 775     if (FILE *file = fopen(dbChkptSchema, "r")) {
 776         fclose(file);
 777         sprintf(cmd, "cp -f %s %s/db.chkpt.schema", dbChkptSchema,
 778                                                      Conf::config.getDbFile());
 779         int ret = system(cmd);
 780         if (ret != 0) return ErrOS;
 781     }
 782     sprintf(dbChkptMap, "%s/db.chkpt.map1", Conf::config.getDbFile());
 783     if (FILE *file = fopen(dbChkptMap, "r")) {
 784         fclose(file);
 785         sprintf(cmd, "cp -f %s %s/db.chkpt.map", dbChkptMap,
 786                                                      Conf::config.getDbFile());
 787         int ret = system(cmd);
 788         if (ret != 0) return ErrOS;
 789     }
 790     int chkptID= Database::getCheckpointID();
 791     sprintf(dbChkptData, "%s/db.chkpt.data%d", Conf::config.getDbFile(),
 792                                                                       chkptID);
 793     sprintf(dbBackupFile, "%s/db.chkpt.data1", Conf::config.getDbFile());
 794     FILE *fl = NULL;
 795     if (!Conf::config.useMmap() && (fl = fopen(dbBackupFile, "r"))) {
 796         fclose(fl);
 797         sprintf(cmd, "cp %s/db.chkpt.data1 %s", Conf::config.getDbFile(),
 798                                                                   dbChkptData);
 799         int ret = system(cmd);
 800         if (ret != 0) return ErrOS;
 801     }
 802     if (FILE *file = fopen(dbChkptData, "r")) {
 803         fclose(file);
 804         rv = recoverSystemAndUserDB();
 805     }
 806
 807     //check for redo log file if present apply redo logs
 808     sprintf(dbRedoFileName, "%s/csql.db.cur", Conf::config.getDbFile());
 809     if (FILE *file = fopen(dbRedoFileName, "r"))
 810     {
 811         fclose(file);
 812         applyRedoLogs(dbRedoFileName);
 813         DatabaseManager *dbMgr = getConnObject().getDatabaseManager();
 814         rv = dbMgr->checkPoint();
 815         if (rv != OK)
 816         {
 817             printError(ErrSysInternal, "checkpoint failed after redo log apply");
 818             return ErrOS;
 819         }
 820     }
 821     return OK;
 822 }
 823
 824 DbRetVal SqlConnection::recoverSystemAndUserDB()
 825 {
 826     DbRetVal rv = OK;
 827     char schFile[1024];
 828     sprintf(schFile, "%s/db.chkpt.schema", Conf::config.getDbFile());
 829     if (FILE *file = fopen(schFile, "r")) {
 830         applySchemaFile(file);
 831     }
 832     DatabaseManager *dbMgr = getConnObject().getDatabaseManager();
 833     dbMgr->recover();
 834     return OK;
 835 }
 836
 837 DbRetVal SqlConnection::applySchemaFile(FILE *fp)
 838 {
 839     char buf[8192];
 840     char eof;
 841     SqlStatement *stmt = new SqlStatement();
 842     while ((eof = getQueryFromSchemaFile(fp,buf)) != EOF) {
 843         stmt->setConnection(this);
 844         stmt->prepare(buf);
 845         int rows = 0;
 846         stmt->execute(rows);
 847     }
 848     delete stmt;
 849     return OK;
 850 }
 851
 852 char SqlConnection::getQueryFromSchemaFile(FILE *fp, char *buf)
 853 {
 854     char c, *bufBegin=buf;
 855     int charCnt=0;
 856     while( (c=(char ) fgetc(fp)) != EOF && c != ';')
 857     {
 858         *buf++ = c; charCnt++;
 859     if( charCnt == SQL_STMT_LEN ) {
 860             printf("SQL Statement length is greater than %d. "
 861         "Ignoring the statement.\n", SQL_STMT_LEN );
 862             *bufBegin++ =';';
 863             *bufBegin ='\0';
 864         return 0;
 865     }
 866     }
 867     *buf++ = ';';
 868     *buf = '\0';
 869     return c;
 870 }
 871
 872 void SqlConnection::addToHashTable(int stmtID, AbsSqlStatement* sHdl)
 873 {
 874     int bucketNo = stmtID % STMT_BUCKET_SIZE;
 875     StmtBucket *buck = (StmtBucket *) stmtBuckets;
 876     StmtBucket *stmtBucket = &buck[bucketNo];
 877     StmtNode *node = new StmtNode();
 878     node->stmtId = stmtID;
 879     node->stmt = sHdl;
 880     stmtBucket->bucketList.append(node);
 881     return;
 882 }
 883
 884 void SqlConnection::removeFromHashTable(int stmtID)
 885 {
 886     int bucketNo = stmtID % STMT_BUCKET_SIZE;
 887     StmtBucket *buck = (StmtBucket *) stmtBuckets;
 888     StmtBucket *stmtBucket = &buck[bucketNo];
 889     StmtNode *node = NULL;
 890     ListIterator it = stmtBucket->bucketList.getIterator();
 891     while(it.hasElement()) {
 892         node = (StmtNode *) it.nextElement();
 893         if(stmtID == node->stmtId) break;
 894     }
 895     it.reset();
 896     stmtBucket->bucketList.remove(node);
 897     return;
 898 }
 899
 900 AbsSqlStatement *SqlConnection::getStmtFromHashTable(int stmtId)
 901 {
 902     int bucketNo = stmtId % STMT_BUCKET_SIZE;
 903     StmtBucket *buck = (StmtBucket *) stmtBuckets;
 904     StmtBucket *stmtBucket = &buck[bucketNo];
 905     StmtNode *node = NULL;
 906     ListIterator it = stmtBucket->bucketList.getIterator();
 907     while(it.hasElement()) {
 908         node = (StmtNode *) it.nextElement();
 909         if(stmtId == node->stmtId) {
 910             return node->stmt;
 911         }
 912     }
 913     return NULL;
 914 }
 915
 916 void setParam(AbsSqlStatement *stmt, int pos, DataType type , int length, void *value)
 917 {
 918     switch(type)
 919     {
 920         case typeInt:
 921             stmt->setIntParam(pos, *(int*)value);
 922             break;
 923         case typeLong:
 924             stmt->setLongParam(pos, *(long*) value);
 925             break;
 926         case typeLongLong:
 927             stmt->setLongLongParam(pos, *(long long*)value);
 928             break;
 929         case typeShort:
 930             stmt->setShortParam(pos, *(short*)value);
 931             break;
 932         case typeByteInt:
 933             stmt->setByteIntParam(pos, *(ByteInt*)value);
 934             break;
 935         case typeDouble:
 936             stmt->setDoubleParam(pos, *(double*)value);
 937             break;
 938         case typeFloat:
 939             stmt->setFloatParam(pos, *(float*)value);
 940             break;
 941         case typeDate:
 942             stmt->setDateParam(pos, *(Date*)value);
 943             break;
 944         case typeTime:
 945             stmt->setTimeParam(pos, *(Time*)value);
 946             break;
 947         case typeTimeStamp:
 948             stmt->setTimeStampParam(pos, *(TimeStamp*)value);
 949             break;
 950         case typeString:
 951         case typeVarchar:
 952             stmt->setStringParam(pos, (char*)value);
 953             break;
 954         case typeBinary:
 955             stmt->setBinaryParam(pos, value, length);
 956             break;
 957         default:
 958             printf("unknown type\n");
 959             break;
 960     }
 961     return;
 962 }
 963
 964 int SqlConnection::applyRedoLogs(char *redoFile)
 965 {
 966     struct stat st;
 967     DbRetVal rv = OK;
 968     int fd = open(redoFile, O_RDONLY);
 969     if (-1 == fd) { return OK; }
 970     if (fstat(fd, &st) == -1) {
 971         printError(ErrSysInternal, "Unable to retrieve undo log file size");
 972         close(fd);
 973         return 1;
 974     }
 975     if (st.st_size ==0) {
 976         close(fd);
 977         return OK;
 978     }
 979     void *startAddr = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
 980     if (MAP_FAILED == startAddr) {
 981         printf("Unable to read undo log file:mmap failed.\n");
 982         return 2;
 983     }
 984     stmtBuckets = malloc (STMT_BUCKET_SIZE * sizeof(StmtBucket));
 985     memset(stmtBuckets, 0, STMT_BUCKET_SIZE * sizeof(StmtBucket));
 986
 987     char *iter = (char*)startAddr;
 988     void *value = NULL;
 989     int logType, eType;
 990     int stmtID;
 991     int txnID;
 992     int len, ret, retVal =0;
 993     int loglen;
 994     char stmtString[SQL_STMT_LEN];
 995     //printf("size of file %d\n", st.st_size);
 996     while(true) {
 997         //printf("OFFSET HERE %d\n", iter - (char*)startAddr);
 998         if (iter - (char*)startAddr >= st.st_size) break;
 999         logType = *(int*)iter;
1000         if (logType == -1) { //prepare
1001             iter = iter + sizeof(int);
1002             txnID = *(int*) iter; iter += sizeof(int);
1003             loglen = *(int*) iter; iter += sizeof(int);
1004             stmtID = *(int*)iter;
1005             iter = iter + sizeof(int);
1006             len = *(int*)iter;
1007             iter = iter + sizeof(int);
1008             strncpy(stmtString, iter, len);
1009             iter = iter + len;
1010             //printf("PREPARE:%d %d %s\n", stmtID, len, stmtString);
1011             AbsSqlStatement *st = SqlFactory::createStatement(CSqlDirect);
1012             SqlStatement *stmt = (SqlStatement *)st;
1013             stmt->setConnection(this);
1014             rv = stmt->prepare(stmtString);
1015             if (rv != OK) {
1016                 printError(ErrSysInternal, "unable to prepare stmt:%s", stmtString);
1017                 retVal=1;
1018                 break;
1019             }
1020             stmt->prepare(stmtString);
1021             SqlStatement *sqlStmt = (SqlStatement*)stmt;
1022             sqlStmt->setLoading(true);
1023             addToHashTable(stmtID, stmt);
1024         }
1025         else if(logType == -2) { //commit
1026             beginTrans();
1027             iter = iter + sizeof(int);
1028             txnID = *(int*) iter; iter += sizeof(int);
1029             loglen = *(int*) iter; iter += sizeof(int);
1030             char *curPtr = iter;
1031             while(true) {
1032                 //printf("Iter length %d\n", iter - curPtr);
1033                 if (iter - (char*)startAddr >= st.st_size) {
1034                     //file end reached
1035                     //printf("Redo log file end\n");
1036                     retVal=0;
1037                     break;
1038                 }
1039                 stmtID = *(int*)iter;
1040                 //printf("stmtid %d\n", stmtID);
1041                 iter = iter + sizeof(int);
1042                 eType = *(int*)iter;
1043                 //printf("eType is %d\n", eType);
1044                 AbsSqlStatement *stmt = getStmtFromHashTable(stmtID);
1045                 if (0 == eType) { //execute type
1046                     iter = iter + sizeof(int);
1047                     //printf("EXEC: %d\n", stmtID);
1048                     if (stmt) {
1049                         rv = stmt->execute(ret);
1050                         if (rv != OK) {
1051                             printError(ErrSysInternal, "unable to execute");
1052                             retVal=2;
1053                             break;
1054                         }
1055                     } else {
1056                         printError(ErrSysInternal, "statement not found for %d\n",stmtID);
1057                     }
1058                     if (*(int*)iter <0) break;
1059                 } else if ( 1 == eType) { //set type
1060                     iter=iter+sizeof(int);
1061                     int pos = *(int*) iter;
1062                     iter=iter+sizeof(int);
1063                     DataType type = (DataType)(*(int*)iter);
1064                     iter=iter+sizeof(int);
1065                     int len = *(int*) iter;
1066                     iter=iter+sizeof(int);
1067                     value = iter;
1068                     //AllDataType::printVal(value, type, len);
1069                     iter=iter+len;
1070                     //printf("SET: %d %d %d %d\n", stmtID, pos, type, len);
1071                     setParam(stmt, pos, type, len, value);
1072                     if (*(int*)iter <0) break;
1073                 }
1074             }
1075             commit();
1076         }
1077         else if(logType == -3) { //free
1078             iter = iter + sizeof(int);
1079             txnID = *(int*) iter; iter += sizeof(int);
1080             loglen = *(int*) iter; iter += sizeof(int);
1081             stmtID = *(int*)iter;
1082             iter = iter + sizeof(int);
1083             AbsSqlStatement *stmt = getStmtFromHashTable(stmtID);
1084             if (stmt) {
1085                 stmt->free();
1086                 removeFromHashTable(stmtID);
1087             } else { printError(ErrSysInternal, "statement not found for %d\n",stmtID);}
1088         }
1089         else if(logType == -4) { //prepare and execute
1090             iter = iter + sizeof(int);
1091             txnID = *(int*) iter; iter += sizeof(int);
1092             loglen = *(int*) iter; iter += sizeof(int);
1093             stmtID = *(int*)iter;
1094             iter = iter + sizeof(int);
1095             len = *(int*)iter;
1096             iter = iter + sizeof(int);
1097             strncpy(stmtString, iter, len);
1098             stmtString[len+1] ='\0';
1099             iter = iter + len;
1100             //printf("CREATE:%d %d %s\n", stmtID, len, stmtString);
1101             AbsSqlStatement *stmt = SqlFactory::createStatement(CSqlDirect);
1102             if ( NULL == stmt) {
1103                 printError(ErrSysInternal, "unable to prepare:%s", stmtString);
1104                 retVal=3;
1105                 break;
1106             }
1107             stmt->setConnection(this);
1108             rv = stmt->prepare(stmtString);
1109             if (rv != OK) {
1110                 printError(ErrSysInternal, "unable to prepare:%s", stmtString);
1111                 retVal=4;
1112                 break;
1113             }
1114             rv = stmt->execute(ret);
1115             if (rv != OK) {
1116                 if (strlen(stmtString) > 6 &&
1117                     ( (strncasecmp(stmtString,"CREATE", 6) == 0) ||
1118                       (strncasecmp(stmtString,"DROP", 4) == 0)) ) {
1119             //        conn->disconnect();
1120               //      return OK;
1121                     continue;
1122                 }
1123                 printError(ErrSysInternal, "unable to execute %s", stmtString);
1124                 retVal=5;
1125                 break;
1126             }
1127             stmt->free();
1128         }else{
1129             printError(ErrSysInternal, "Redo log file corrupted: logType:%d", logType);
1130             retVal=6;
1131             break;
1132         }
1133     }
1134     munmap((char*)startAddr, st.st_size);
1135     close(fd);
1136     //freeAllStmtHandles();
1137     return retVal;
1138 }
1139 #endif