src/network/SqlNetworkHandler.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 <TableConfig.h>
  22 #include <SqlNetworkHandler.h>
  23 #include <AbsSqlConnection.h>
  24 #include <SqlConnection.h>
  25 #include <SqlOdbcConnection.h>
  26 #include <AbsSqlStatement.h>
  27 #include <SqlStatement.h>
  28 #include <SqlOdbcStatement.h>
  29 #include <SqlLogStatement.h>
  30 #include <Parser.h>
  31
  32 bool SqlNetworkHandler::isSqlLogNeeded;
  33 List SqlNetworkHandler::stmtList;
  34 List SqlNetworkHandler::tableNameList;
  35 AbsSqlConnection* SqlNetworkHandler::conn;
  36 SqlApiImplType SqlNetworkHandler::type;
  37 int SqlNetworkHandler::stmtID;
  38 int SqlNetworkHandler::sockfd;
  39
  40 void *SqlNetworkHandler::process(PacketHeader &header, char *buffer)
  41 {
  42     DbRetVal rv = OK;
  43     char *ptr = NULL;
  44     void *rpkt = NULL;
  45     switch(header.packetType)
  46     {
  47         case SQL_NW_PKT_CONNECT:
  48             rpkt = processSqlConnect(header, buffer);
  49             break;
  50         case SQL_NW_PKT_EXECDIRECT:
  51             rpkt = processSqlExecuteDirect(header, buffer);
  52             break;
  53         case SQL_NW_PKT_PREPARE:
  54             rpkt = processSqlPrepare(header, buffer);
  55             break;
  56         case SQL_NW_PKT_EXECUTE:
  57             rpkt = processSqlExecute(header, buffer);
  58             break;
  59         case SQL_NW_PKT_FETCH:
  60             rpkt = processSqlFetch(header);
  61             break;
  62         case SQL_NW_PKT_COMMIT:
  63             rpkt = processSqlCommit(header, buffer);
  64             break;
  65         case SQL_NW_PKT_ROLLBACK:
  66             rpkt = processSqlRollback(header, buffer);
  67             break;
  68         case SQL_NW_PKT_DISCONNECT:
  69             rpkt = processSqlDisconnect(header);
  70             break;
  71         case SQL_NW_PKT_FREE:
  72             rpkt = processSqlFree(header, buffer);
  73             break;
  74         case SQL_NW_PKT_SHOWTABLES:
  75             rpkt = processSqlShowTables(header, buffer);
  76             break;
  77         case SQL_NW_PKT_ISTABLEPRESENT:
  78             rpkt = processSqlIsTablePresent(header, buffer);
  79             break;
  80         case SQL_NW_PKT_GETRECORDS:
  81             rpkt =  processSqlLoadRecords(header, buffer);
  82             break;
  83         case SQL_NW_PKT_LASTAIVAL:
  84             rpkt = processSqlLastAutoIncrementVal(header);
  85             break;
  86     }
  87     if (rpkt != NULL) sendResponse(rpkt);
  88     return rpkt;
  89 }
  90
  91 DbRetVal SqlNetworkHandler::sendResponse(void *rpkt)
  92 {
  93     size_t numbytes = os::send(sockfd, rpkt, sizeof(ResponsePacket), 0);
  94     if (numbytes == -1) {
  95         printError(ErrOS, "Error writing to socket\n");
  96         closeConnection();
  97         exit(1);
  98     }
  99     return OK;
 100 }
 101
 102 DbRetVal SqlNetworkHandler::closeConnection()
 103 {
 104     conn->rollback();
 105     return conn->disconnect();
 106 }
 107
 108 void * SqlNetworkHandler::processSqlConnect(PacketHeader &header, char *buffer)
 109 {
 110     ResponsePacket *rpkt = new ResponsePacket();
 111     printDebug(DM_Network, "Processing CONNECT");
 112     SqlPacketConnect *pkt = new SqlPacketConnect();
 113     pkt->setBuffer(buffer);
 114     pkt->setBufferSize(header.packetLength);
 115     pkt->unmarshall();
 116     type = (SqlApiImplType) pkt->sqlApiImplType;
 117     isSqlLogNeeded = (Conf::config.useDurability() || (Conf::config.useCache()
 118                                && Conf::config.getCacheMode() == ASYNC_MODE ));
 119     conn = createConnection(type);
 120     char *ptr = (char *) &rpkt->retVal;
 121     DbRetVal rv=conn->connect(pkt->userName, pkt->passWord);
 122     if (rv != OK) {
 123         //*ptr = 0;
 124         rpkt->errRetVal = rv;
 125         fillErrorString(rpkt);
 126         delete pkt;
 127         return rpkt;
 128     }
 129     if (rv == OK) {
 130         //*ptr = 1;
 131         rv = conn->beginTrans();
 132         delete pkt;
 133         return rpkt;
 134     }
 135 }
 136
 137 void * SqlNetworkHandler::processSqlDisconnect(PacketHeader &header)
 138 {
 139     DbRetVal rv = conn->rollback();
 140     rv = conn->disconnect();
 141     ResponsePacket *rpkt = new ResponsePacket();
 142     char *ptr = (char *) &rpkt->retVal;
 143     //*ptr = 1;
 144     strcpy(rpkt->errorString, "Success");
 145     return rpkt;
 146 }
 147
 148 void* SqlNetworkHandler::processSqlExecuteDirect(PacketHeader &header, char *buffer)
 149 {
 150     ResponsePacket *rpkt = new ResponsePacket();
 151     rpkt->isSelect = false;
 152     char *retval = (char *) &rpkt->retVal;
 153     SqlPacketPrepare *pkt = new SqlPacketPrepare();
 154     pkt->setBuffer(buffer);
 155     pkt->setBufferSize(header.packetLength);
 156     pkt->unmarshall();
 157     printDebug(DM_Network, "EXECDIRECT %s\n", pkt->stmtString);
 158     AbsSqlStatement *sqlstmt = createStatement(type);
 159     sqlstmt->setConnection(conn);
 160     NetworkStmt *nwStmt = new NetworkStmt();
 161     nwStmt->stmtID = ++stmtID;
 162     printDebug(DM_Network, "Statement string %s\n", pkt->stmtString);
 163     nwStmt->stmt = sqlstmt;
 164     DbRetVal rv = sqlstmt->executeDirect(pkt->stmtString);
 165     delete pkt;
 166     if (rv != OK)
 167     {
 168         printError(ErrSysInit, "ExecuteDirect failed\n");
 169         rpkt->errRetVal = rv;
 170         fillErrorString(rpkt);
 171         if (rpkt->errorString[0] == '\0')
 172             strcpy(rpkt->errorString, "Prepare failed.");
 173         delete nwStmt;
 174         delete sqlstmt;
 175         return rpkt;
 176     }
 177
 178     stmtList.append(nwStmt);
 179     rpkt->stmtID = nwStmt->stmtID;
 180     strcpy(rpkt->errorString, "Success");
 181     return rpkt;
 182 }
 183
 184 void* SqlNetworkHandler::processSqlPrepare(PacketHeader &header, char *buffer)
 185 {
 186     ResponsePacket *rpkt = new ResponsePacket();
 187     rpkt->isSelect = false;
 188     char *retval = (char *) &rpkt->retVal;
 189     SqlPacketPrepare *pkt = new SqlPacketPrepare();
 190     pkt->setBuffer(buffer);
 191     pkt->setBufferSize(header.packetLength);
 192     pkt->unmarshall();
 193     printDebug(DM_Network, "PREPARE %s\n", pkt->stmtString);
 194     AbsSqlStatement *sqlstmt = createStatement(type);
 195     sqlstmt->setConnection(conn);
 196     NetworkStmt *nwStmt = new NetworkStmt();
 197     nwStmt->stmtID = ++stmtID;
 198     printDebug(DM_Network, "Statement string %s\n", pkt->stmtString);
 199     nwStmt->stmt = sqlstmt;
 200     DbRetVal rv = sqlstmt->prepare(pkt->stmtString);
 201     delete pkt;
 202     if (rv != OK)
 203     {
 204         printError(ErrSysInit, "statement prepare failed\n");
 205         rpkt->errRetVal = rv;
 206         fillErrorString(rpkt);
 207         if (rpkt->errorString[0] == '\0')
 208             strcpy(rpkt->errorString, "Prepare failed.");
 209         delete nwStmt;
 210         delete sqlstmt;
 211         return rpkt;
 212     }
 213     //TODO: need to change retVal name
 214     ResultSetPlan plan = sqlstmt->getResultSetPlan();
 215     *retval = plan;
 216
 217     int param = sqlstmt->noOfParamFields();
 218     int proj = sqlstmt->noOfProjFields();
 219     BindSqlField *bindField = NULL;
 220     BindSqlProjectField *projField = NULL;
 221     //populate paramList
 222     FieldInfo * fInfo = new FieldInfo();
 223     for (int i = 0; i < param; i++) {
 224         bindField = new BindSqlField();
 225         sqlstmt->getParamFldInfo(i + 1, fInfo);
 226         strcpy(bindField->fName, fInfo->fldName);
 227         bindField->type = fInfo->type;
 228         bindField->length = fInfo->length;
 229         bindField->offset = fInfo->offset;
 230         strcpy(bindField->defaultValueBuf, fInfo->defaultValueBuf);
 231         bindField->isNull = fInfo->isNull;
 232         bindField->isPrimary = fInfo->isPrimary;
 233         bindField->isDefault = fInfo->isDefault;
 234         bindField->isUnique = fInfo->isUnique;
 235         bindField->isUnique = fInfo->isUnique;
 236         //bindField->value = AllDataType::alloc(bindField->type, bindField->length);
 237         bindField->value = NULL;
 238         nwStmt->paramList.append(bindField);
 239     }
 240     delete fInfo;
 241     FieldInfo *fldInfo = new FieldInfo();
 242     for (int i = 0; i < proj; i++) {
 243         projField = new BindSqlProjectField();
 244         sqlstmt->getProjFldInfo(i + 1, fldInfo);
 245         strcpy(projField->fName, fldInfo->fldName);
 246         projField->type = fldInfo->type;
 247         projField->length = fldInfo->length;
 248         projField->offset = fldInfo->offset;
 249         strcpy(projField->defaultValueBuf, fldInfo->defaultValueBuf);
 250         projField->aType = fldInfo->aType;
 251         projField->isNull = fldInfo->isNull;
 252         projField->isPrimary = fldInfo->isPrimary;
 253         projField->isDefault = fldInfo->isDefault;
 254         projField->isUnique = fldInfo->isUnique;
 255         projField->value = AllDataType::alloc(projField->type, projField->length);
 256         memset(projField->value, 0, projField->length);
 257         nwStmt->projList.append(projField);
 258     }
 259     delete fldInfo;
 260     stmtList.append(nwStmt);
 261     if(sqlstmt->isSelect()) rpkt->isSelect = true;
 262     if (param) *(retval+2) = 1;
 263     if (proj) *(retval+3) = 1;
 264     rpkt->stmtID = nwStmt->stmtID;
 265     strcpy(rpkt->errorString, "Success");
 266     return rpkt;
 267 }
 268
 269 void * SqlNetworkHandler::processSqlExecute(PacketHeader &header, char *buffer)
 270 {
 271     ResponsePacket *rpkt = new ResponsePacket();
 272     char *retval = (char *) &rpkt->retVal;
 273     SqlPacketExecute *pkt = new SqlPacketExecute();
 274     pkt->setBuffer(buffer);
 275     pkt->setBufferSize(header.packetLength);
 276     pkt->setStatementList(stmtList);
 277     pkt->unmarshall();
 278     printDebug(DM_Network, "EXECUTE %d\n", pkt->stmtID);
 279     rpkt->stmtID = pkt->stmtID;
 280     ListIterator stmtIter = stmtList.getIterator();
 281     NetworkStmt *stmt;
 282     while (stmtIter.hasElement())
 283     {
 284        stmt = (NetworkStmt*) stmtIter.nextElement();
 285        //TODO::Also check the srcNetworkID
 286        if (stmt->stmtID == pkt->stmtID ) break;
 287     }
 288     AbsSqlStatement *sqlstmt = stmt->stmt;
 289     int rows = 0;
 290     char *nullInfo = NULL;
 291     if (pkt->noParams) nullInfo = pkt->getNullInfo();
 292     for (int i=0; i < pkt->noParams; i++) {
 293         BindSqlField *bindField = (BindSqlField *) stmt->paramList.get(i+1);
 294         if (nullInfo[i]) sqlstmt->setNull(i+1);
 295         else SqlStatement::setParamValues(sqlstmt, i+1, bindField->type,
 296                                   bindField->length, (char *)bindField->value);
 297     }
 298     //SqlStatement *st = (SqlStatement *)sqlstmt;
 299     if(sqlstmt->isSelect()) {
 300         int noProj = stmt->projList.size();
 301         for (int i=0; i < noProj; i++) {
 302             BindSqlProjectField *prjFld = (BindSqlProjectField *) stmt->projList.get(i+1);
 303             sqlstmt->bindField(i+1, prjFld->value);
 304         }
 305     }
 306     delete pkt;
 307     DbRetVal rv = sqlstmt->execute(rows);
 308     if (rv != OK) {
 309         rpkt->errRetVal = rv;
 310         fillErrorString(rpkt);
 311         return rpkt;
 312     }
 313     rpkt->rows = rows;
 314     strcpy(rpkt->errorString, "Success");
 315     return rpkt;
 316 }
 317
 318 void * SqlNetworkHandler::processSqlFetch(PacketHeader &header)
 319 {
 320     ListIterator stmtIter = stmtList.getIterator();
 321     NetworkStmt *stmt;
 322     SqlPacketResultSet *rspkt = new SqlPacketResultSet();
 323     while (stmtIter.hasElement())
 324     {
 325        stmt = (NetworkStmt*) stmtIter.nextElement();
 326        //TODO::Also check srcNetworkID
 327        if (stmt->stmtID == header.stmtID ) break;
 328     }
 329     printDebug(DM_Network, "FETCH STMTID: %d", stmt->stmtID);
 330     AbsSqlStatement *sqlstmt = stmt->stmt;
 331     void *data=NULL;
 332     int len=1;
 333     DbRetVal rv = OK;
 334     if ((data = sqlstmt->fetch(rv)) != NULL && rv == OK) {
 335         len = 0;//means record is there
 336     }
 337     else if (data == NULL && rv == OK) {
 338         sqlstmt->close();
 339         len =1; //end of resultset
 340     }
 341     else {
 342         len=2;//error
 343     }
 344     rspkt->noProjs = stmt->projList.size();
 345     // set null info for all the fetched field values in projection list
 346     int nullInfoLen = os::align(rspkt->noProjs);
 347     char *nullInfo = (char *) malloc(nullInfoLen);
 348     memset(nullInfo, 0, nullInfoLen);
 349     char *ptr = nullInfo;
 350     ListIterator it = stmt->projList.getIterator();
 351     while (it.hasElement()) {
 352         BindSqlProjectField *prjFld = (BindSqlProjectField *) it.nextElement();
 353         if (sqlstmt->isFldNull(prjFld->fName)) *ptr = 1;
 354         ptr++;
 355     }
 356     rspkt->setNullInfo(nullInfo);
 357     rspkt->setProjList(stmt->projList);
 358     rspkt->marshall();
 359     if (rv != OK) { printf("marshall failed\n"); }
 360
 361     if(len == 0) len = rspkt->getBufferSize();
 362     int numbytes = os::send(sockfd, &len , 4, 0);
 363     if (len == 1 || len == 2) { delete rspkt; ::free (nullInfo); return NULL; }
 364     int dummy =0;
 365     //numbytes = os::recv(sockfd, &dummy, 4, 0);
 366     numbytes = os::send(sockfd,rspkt->getMarshalledBuffer(),
 367                            rspkt->getBufferSize(), 0);
 368     delete rspkt;
 369     if (numbytes == -1) {
 370        printf("Error in sending the row to the client\n");
 371        ::free (nullInfo);
 372        sqlstmt->free();
 373        delete sqlstmt; sqlstmt= NULL;
 374        conn->disconnect();
 375        exit(1);
 376     }
 377     ::free (nullInfo);
 378     return NULL;
 379 }
 380
 381 void * SqlNetworkHandler::processSqlFree(PacketHeader &header, char *buffer)
 382 {
 383     ResponsePacket *rpkt = new ResponsePacket();
 384     char *retval = (char *) &rpkt->retVal;
 385     SqlPacketFree *pkt = new SqlPacketFree();
 386     pkt->setBuffer(buffer);
 387     pkt->unmarshall();
 388     rpkt->stmtID = pkt->stmtID;
 389     ListIterator stmtIter = stmtList.getIterator();
 390     NetworkStmt *stmt = NULL;
 391     while (stmtIter.hasElement())
 392     {
 393        stmt = (NetworkStmt*) stmtIter.nextElement();
 394        //TODO::Also check teh srcNetworkID
 395        if (stmt->stmtID == pkt->stmtID ) break;
 396     }
 397     if (stmt == NULL)
 398     {
 399         printError(ErrWarning, "Statement already freed.");
 400         delete pkt;
 401         rpkt->errRetVal = ErrAlready;
 402         return rpkt;
 403     }
 404     AbsSqlStatement *sqlstmt = stmt->stmt;
 405     if (sqlstmt) sqlstmt->free();
 406     ListIterator itprm = stmt->paramList.getIterator();
 407     BindSqlField *fld = NULL;
 408     while((fld = (BindSqlField *) itprm.nextElement()) != NULL) {
 409         //if (fld->value) free(fld->value); memory never allocated for this
 410         delete fld;
 411     }
 412     stmt->paramList.reset();
 413     ListIterator itprj = stmt->projList.getIterator();
 414     BindSqlProjectField *pfld = NULL;
 415     while((pfld = (BindSqlProjectField *) itprj.nextElement()) != NULL) {
 416        if (pfld->value) free(pfld->value);
 417        delete pfld;
 418     }
 419     stmt->projList.reset();
 420     delete stmt->stmt;
 421     stmt->stmt = NULL;
 422     stmtList.remove(stmt);
 423     delete stmt;
 424     stmt= NULL;
 425     delete pkt;
 426     strcpy(rpkt->errorString, "Success");
 427     return rpkt;
 428 }
 429
 430
 431 void * SqlNetworkHandler::processSqlCommit(PacketHeader &header, char *buffer)
 432 {
 433     ResponsePacket *rpkt = new ResponsePacket();
 434     char *retval = (char *) &rpkt->retVal;
 435     DbRetVal rv = conn->commit();
 436     if (rv != OK) {
 437         rpkt->errRetVal = rv;
 438         strcpy(rpkt->errorString, "Commit failure\n");
 439         return rpkt;
 440     }
 441     rv = conn->beginTrans();
 442     strcpy(rpkt->errorString, "Success");
 443     return rpkt;
 444 }
 445
 446 void *SqlNetworkHandler::processSqlRollback(PacketHeader &header, char *buffer)
 447 {
 448     ResponsePacket *rpkt = new ResponsePacket();
 449     char *retval = (char *) &rpkt->retVal;
 450     DbRetVal rv = conn->rollback();
 451     if (rv != OK) {
 452         rpkt->errRetVal = rv;
 453         strcpy(rpkt->errorString, "Rollback failure\n");
 454         return rpkt;
 455     }
 456     rv = conn->beginTrans();
 457     strcpy(rpkt->errorString, "Success");
 458     return rpkt;
 459 }
 460
 461 AbsSqlConnection * SqlNetworkHandler::createConnection(SqlApiImplType type)
 462 {
 463     AbsSqlConnection *con = NULL;
 464     switch(type) {
 465         case CSqlNetwork:
 466             con = SqlFactory::createConnection(CSql);
 467             break;
 468         case CSqlNetworkAdapter:
 469             con = SqlFactory::createConnection(CSqlAdapter);
 470             break;
 471         case CSqlNetworkGateway:
 472             con = SqlFactory::createConnection(CSqlGateway);
 473             break;
 474         default:
 475             return NULL;
 476     }
 477     return con;
 478 }
 479
 480 AbsSqlStatement * SqlNetworkHandler::createStatement(SqlApiImplType type)
 481 {
 482     AbsSqlStatement *stmt = NULL;
 483     switch(type) {
 484         case CSqlNetwork:
 485             stmt = SqlFactory::createStatement(CSql);
 486             break;
 487         case CSqlNetworkAdapter:
 488             stmt = SqlFactory::createStatement(CSqlAdapter);
 489             break;
 490         case CSqlNetworkGateway:
 491             stmt = SqlFactory::createStatement(CSqlGateway);
 492             break;
 493         default:
 494             return NULL;
 495     }
 496     return stmt;
 497 }
 498
 499 void * SqlNetworkHandler::processSqlShowTables(PacketHeader &header, char *buffer)
 500 {
 501     ResponsePacket *rpkt = new ResponsePacket();
 502     rpkt->isSelect = false;
 503     char *retval = (char *) &rpkt->retVal;
 504     AbsSqlStatement *sqlstmt = createStatement(type);
 505     sqlstmt->setConnection(conn);
 506     DbRetVal rv = OK;
 507     tableNameList = sqlstmt->getAllTableNames(rv);
 508     rpkt->errRetVal = rv;
 509     rpkt->rows = tableNameList.size();
 510     strcpy(rpkt->errorString, "Success");
 511     delete sqlstmt;
 512     return rpkt;
 513 }
 514
 515 //only csql connection asks for this with or without durability.
 516 void *SqlNetworkHandler::processSqlIsTablePresent(PacketHeader &header, char *buffer)
 517 {
 518     ResponsePacket *rpkt = new ResponsePacket();
 519     rpkt->isSelect = false;
 520     SqlPacketIsTablePresent *pkt = new SqlPacketIsTablePresent();
 521     pkt->setBuffer(buffer);
 522     pkt->unmarshall();
 523     SqlStatement *sqlstmt = new SqlStatement();
 524     SqlConnection *sqlcon = NULL;
 525     if (isSqlLogNeeded) sqlcon = (SqlConnection *) conn->getInnerConnection();
 526     else sqlcon = (SqlConnection *) conn;
 527     sqlstmt->setSqlConnection(sqlcon);
 528     DbRetVal rv = OK; bool found = false;
 529     tableNameList = sqlstmt->getAllTableNames(rv);
 530     ListIterator it = tableNameList.getIterator();
 531     while (it.hasElement()) {
 532         Identifier *elem = (Identifier *) it.nextElement();
 533         if (strcmp(elem->name, pkt->tblName) == 0) {
 534             found = true;
 535             break;
 536         }
 537     }
 538     rpkt->errRetVal = rv;
 539     if (!found) {
 540         rpkt->errRetVal = ErrNotFound;
 541         strcpy(rpkt->errorString, "Table Not found.");
 542     }
 543     ListIterator tblIter = SqlNetworkHandler::tableNameList.getIterator();
 544     while (tblIter.hasElement()) delete tblIter.nextElement();
 545     SqlNetworkHandler::tableNameList.reset();
 546     delete pkt;
 547     delete sqlstmt;
 548     return rpkt;
 549 }
 550
 551 //only csql connection asks for this with or without durability.
 552 void *SqlNetworkHandler::processSqlLoadRecords(PacketHeader &header, char *buffer)
 553 {
 554     ResponsePacket *rpkt = new ResponsePacket();
 555     rpkt->isSelect = false;
 556     char *retval = (char *) &rpkt->retVal;
 557     SqlPacketGetRecords *pkt = new SqlPacketGetRecords();
 558     pkt->setBuffer(buffer);
 559     pkt->unmarshall();
 560     SqlStatement *sqlstmt = new SqlStatement();
 561     SqlConnection *sqlcon = NULL;
 562     if (isSqlLogNeeded) sqlcon = (SqlConnection *) conn->getInnerConnection();
 563     else sqlcon = (SqlConnection *) conn;
 564     sqlstmt->setSqlConnection(sqlcon);
 565     DbRetVal rv = OK;
 566     int pages = sqlstmt->getNoOfPagesForTable(pkt->tblName);
 567     printDebug(DM_Network, "No of pages to be shipped: %d", pages);
 568     rpkt->rows = pages;
 569     strcpy(rpkt->errorString, pkt->tblName);
 570     delete pkt;
 571     delete sqlstmt;
 572     return rpkt;
 573 }
 574
 575 void *SqlNetworkHandler::processSqlLastAutoIncrementVal(PacketHeader &header)
 576 {
 577     ListIterator stmtIter = stmtList.getIterator();
 578     NetworkStmt *stmt;
 579     while (stmtIter.hasElement())
 580     {
 581        stmt = (NetworkStmt*) stmtIter.nextElement();
 582        if (stmt->stmtID == header.stmtID ) break;
 583     }
 584     AbsSqlStatement *sqlstmt = stmt->stmt;
 585     ResponsePacket *rpkt = new ResponsePacket();
 586     DbRetVal rv = OK;
 587     rpkt->lastAutoIncVal = sqlstmt->getLastInsertedVal(rv);
 588     return rpkt;
 589 }
 590
 591 void SqlNetworkHandler::fillErrorString(ResponsePacket *rpkt)
 592 {
 593     switch(rpkt->errRetVal) {
 594         case ErrNoConnection:
 595             strcpy(rpkt->errorString, "Connection not open.");
 596             break;
 597         case ErrUnique:
 598             strcpy(rpkt->errorString, "Unique constraint violation");
 599             break;
 600         case ErrNullViolation:
 601             strcpy(rpkt->errorString, "Not null constraint violation");
 602             break;
 603     }
 604 }
 605
 606 DbRetVal SqlNetworkHandler::servePacket(PacketHeader &header, void *respkt)
 607 {
 608     ResponsePacket *rpkt = (ResponsePacket *) respkt;
 609     DbRetVal rv = OK;
 610     int params=0;
 611     int proj=0;
 612     NetworkStmt *stmt=NULL;
 613
 614     if (header.packetType == SQL_NW_PKT_ISTABLEPRESENT ||
 615                       header.packetType == SQL_NW_PKT_EXECDIRECT ) {
 616         delete rpkt;
 617         return OK;
 618     }
 619     char *ptr = (char *)&rpkt->retVal;
 620     /*if (*ptr==0) {
 621         delete rpkt;
 622         return OK;
 623     }*/
 624     if (rpkt->errRetVal) {
 625         delete rpkt;
 626         return OK;
 627     }
 628     params =  *(ptr + 2);
 629     proj = *(ptr + 3);
 630     if ((header.packetType == SQL_NW_PKT_PREPARE && params != 0) ||
 631                       (header.packetType == SQL_NW_PKT_PREPARE && proj != 0)) {
 632         if (params) {
 633             SqlPacketParamMetadata *prmpkt = new SqlPacketParamMetadata();
 634             prmpkt->stmtID = rpkt->stmtID;
 635             ListIterator stmtIter = SqlNetworkHandler::stmtList.getIterator();
 636             while (stmtIter.hasElement()) {
 637                 stmt = (NetworkStmt*) stmtIter.nextElement();
 638                 if (stmt->stmtID == prmpkt->stmtID) break;
 639             }
 640             prmpkt->noParams = stmt->paramList.size();
 641             rv = prmpkt->marshall();
 642             rv = send(SQL_NW_PKT_PARAM_METADATA, prmpkt->getMarshalledBuffer(), prmpkt->getBufferSize());
 643             delete prmpkt;
 644             if (rv != OK) {
 645                 printf("Error in sending the metadata to the client\n");
 646                 closeConnection();
 647                 exit(1);
 648             }
 649         }
 650         if (proj) {
 651             //fill projection list and send it to client
 652             SqlPacketProjMetadata *prjpkt = new SqlPacketProjMetadata();
 653             prjpkt->stmtID = rpkt->stmtID;
 654             ListIterator stmtIter = SqlNetworkHandler::stmtList.getIterator();
 655             while (stmtIter.hasElement()) {
 656                 stmt = (NetworkStmt*) stmtIter.nextElement();
 657                 if (stmt->stmtID == prjpkt->stmtID) break;
 658             }
 659             prjpkt->noProjs = stmt->projList.size();
 660             rv = prjpkt->marshall();
 661             rv = send(SQL_NW_PKT_PROJ_METADATA, prjpkt->getMarshalledBuffer(), prjpkt->getBufferSize());
 662             delete prjpkt;
 663             if (rv != OK) {
 664                 printf("Error in sending the metadata to the client\n");
 665                 closeConnection();
 666                 exit(1);
 667             }
 668         }
 669     }
 670     else if (header.packetType == SQL_NW_PKT_SHOWTABLES) {
 671         SqlPacketShowTables *shTblPkt = new SqlPacketShowTables();
 672         shTblPkt->numOfTables = rpkt->rows;
 673         rv = shTblPkt->marshall();
 674         if (rv != OK) { printf("marshall failed\n"); }
 675         ListIterator tblIter = SqlNetworkHandler::tableNameList.getIterator();
 676         while (tblIter.hasElement()) delete tblIter.nextElement();
 677         SqlNetworkHandler::tableNameList.reset();
 678         rv = send(SQL_NW_PKT_SHOWTABLES, shTblPkt->getMarshalledBuffer(), shTblPkt->getBufferSize());
 679         delete shTblPkt;
 680         if (rv != OK) {
 681             printError(ErrOS, "Error in sending the metadata to the client\n");
 682             closeConnection();
 683             exit(1);
 684         }
 685     }
 686     else if (header.packetType == SQL_NW_PKT_GETRECORDS) {
 687         if (!rpkt->rows) return OK;
 688         SqlPacketLoadRecords *pkt = new SqlPacketLoadRecords();
 689         pkt->setPages(rpkt->rows);
 690         pkt->marshall();
 691         SqlStatement *sqlstmt = new SqlStatement();
 692         SqlConnection *sqlcon = NULL;
 693         if (isSqlLogNeeded)
 694             sqlcon = (SqlConnection *) conn->getInnerConnection();
 695         else sqlcon = (SqlConnection *) conn;
 696         sqlstmt->setSqlConnection(sqlcon);
 697         sqlstmt->loadRecords(&rpkt->errorString[0], pkt->getMarshalledBuffer());
 698         char *buf = pkt->getMarshalledBuffer();
 699         rv = send(SQL_NW_PKT_LOADRECORDS, pkt->getMarshalledBuffer(), pkt->getBufferSize());
 700         delete pkt;
 701         delete sqlstmt;
 702         if (rv != OK) {
 703             printf("Error in sending the metadata to the client\n");
 704             closeConnection();
 705             exit(1);
 706         }
 707     }
 708     else if (header.packetType == SQL_NW_PKT_DISCONNECT) exit(0);
 709     if (rpkt) { delete rpkt; rpkt = NULL; }
 710     return OK;
 711 }
 712
 713 DbRetVal SqlNetworkHandler::send(NetworkPacketType type, char *buf, int len)
 714 {
 715     DbRetVal rv = OK;
 716     PacketHeader *hdr=  new PacketHeader();
 717     hdr->packetType = type;
 718     hdr->packetLength = len;
 719     hdr->srcNetworkID = 0;//networkid;
 720     hdr->version = 1;
 721     int numbytes=0;
 722     if ((numbytes=os::send(sockfd, hdr, sizeof(PacketHeader), 0)) == -1) {
 723         printError(ErrOS, "Unable to send the packet\n");
 724         return ErrOS;
 725     }
 726     if ((numbytes=os::send(sockfd, buf, len, 0)) == -1) {
 727         printError(ErrOS, "Unable to send the packet\n");
 728         return ErrOS;
 729     }
 730     delete hdr;
 731     return rv;
 732 }