1 /***************************************************************************
2 * Copyright (C) 2007 by Prabakaran Thirumalai *
3 * praba_tuty@yahoo.com *
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. *
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. *
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 ***************************************************************************/
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>
32 List
SqlNetworkHandler::stmtList
;
33 List
SqlNetworkHandler::tableNameList
;
34 AbsSqlConnection
* SqlNetworkHandler::conn
;
35 SqlApiImplType
SqlNetworkHandler::type
;
36 int SqlNetworkHandler::stmtID
;
37 int SqlNetworkHandler::sockfd
;
39 void *SqlNetworkHandler::process(PacketHeader
&header
, char *buffer
)
44 switch(header
.packetType
)
46 case SQL_NW_PKT_CONNECT
:
47 rpkt
= processSqlConnect(header
, buffer
);
49 case SQL_NW_PKT_EXECDIRECT
:
50 rpkt
= processSqlExecuteDirect(header
, buffer
);
52 case SQL_NW_PKT_PREPARE
:
53 rpkt
= processSqlPrepare(header
, buffer
);
55 case SQL_NW_PKT_EXECUTE
:
56 rpkt
= processSqlExecute(header
, buffer
);
58 case SQL_NW_PKT_FETCH
:
59 rpkt
= processSqlFetch(header
);
61 case SQL_NW_PKT_COMMIT
:
62 rpkt
= processSqlCommit(header
, buffer
);
64 case SQL_NW_PKT_ROLLBACK
:
65 rpkt
= processSqlRollback(header
, buffer
);
67 case SQL_NW_PKT_DISCONNECT
:
68 rpkt
= processSqlDisconnect(header
);
71 rpkt
= processSqlFree(header
, buffer
);
73 case SQL_NW_PKT_SHOWTABLES
:
74 rpkt
= processSqlShowTables(header
, buffer
);
76 case SQL_NW_PKT_ISTABLEPRESENT
:
77 rpkt
= processSqlIsTablePresent(header
, buffer
);
79 case SQL_NW_PKT_GETRECORDS
:
80 rpkt
= processSqlLoadRecords(header
, buffer
);
83 if (rpkt
!= NULL
) sendResponse(rpkt
);
87 DbRetVal
SqlNetworkHandler::sendResponse(void *rpkt
)
89 size_t numbytes
= os::send(sockfd
, rpkt
, sizeof(ResponsePacket
), 0);
91 printError(ErrOS
, "Error writing to socket\n");
98 DbRetVal
SqlNetworkHandler::closeConnection()
101 return conn
->disconnect();
104 void * SqlNetworkHandler::processSqlConnect(PacketHeader
&header
, char *buffer
)
106 ResponsePacket
*rpkt
= new ResponsePacket();
107 printDebug(DM_Network
, "Processing CONNECT");
108 SqlPacketConnect
*pkt
= new SqlPacketConnect();
109 pkt
->setBuffer(buffer
);
110 pkt
->setBufferSize(header
.packetLength
);
112 type
= (SqlApiImplType
) pkt
->sqlApiImplType
;
113 conn
= createConnection(type
);
114 char *ptr
= (char *) &rpkt
->retVal
;
115 DbRetVal rv
=conn
->connect(pkt
->userName
, pkt
->passWord
);
118 rpkt
->errRetVal
= rv
;
119 fillErrorString(rpkt
);
125 rv
= conn
->beginTrans();
131 void * SqlNetworkHandler::processSqlDisconnect(PacketHeader
&header
)
133 DbRetVal rv
= conn
->rollback();
134 rv
= conn
->disconnect();
135 ResponsePacket
*rpkt
= new ResponsePacket();
136 char *ptr
= (char *) &rpkt
->retVal
;
138 strcpy(rpkt
->errorString
, "Success");
142 void* SqlNetworkHandler::processSqlExecuteDirect(PacketHeader
&header
, char *buffer
)
144 ResponsePacket
*rpkt
= new ResponsePacket();
145 rpkt
->isSelect
= false;
146 char *retval
= (char *) &rpkt
->retVal
;
147 SqlPacketPrepare
*pkt
= new SqlPacketPrepare();
148 pkt
->setBuffer(buffer
);
149 pkt
->setBufferSize(header
.packetLength
);
151 printDebug(DM_Network
, "EXECDIRECT %s\n", pkt
->stmtString
);
152 AbsSqlStatement
*sqlstmt
= createStatement(type
);
153 sqlstmt
->setConnection(conn
);
154 NetworkStmt
*nwStmt
= new NetworkStmt();
155 nwStmt
->stmtID
= ++stmtID
;
156 printDebug(DM_Network
, "Statement string %s\n", pkt
->stmtString
);
157 nwStmt
->stmt
= sqlstmt
;
158 DbRetVal rv
= sqlstmt
->executeDirect(pkt
->stmtString
);
162 printError(ErrSysInit
, "ExecuteDirect failed\n");
163 rpkt
->errRetVal
= rv
;
164 fillErrorString(rpkt
);
165 if (rpkt
->errorString
[0] == '\0')
166 strcpy(rpkt
->errorString
, "Prepare failed.");
172 stmtList
.append(nwStmt
);
173 rpkt
->stmtID
= nwStmt
->stmtID
;
174 strcpy(rpkt
->errorString
, "Success");
178 void* SqlNetworkHandler::processSqlPrepare(PacketHeader
&header
, char *buffer
)
180 ResponsePacket
*rpkt
= new ResponsePacket();
181 rpkt
->isSelect
= false;
182 char *retval
= (char *) &rpkt
->retVal
;
183 SqlPacketPrepare
*pkt
= new SqlPacketPrepare();
184 pkt
->setBuffer(buffer
);
185 pkt
->setBufferSize(header
.packetLength
);
187 printDebug(DM_Network
, "PREPARE %s\n", pkt
->stmtString
);
188 AbsSqlStatement
*sqlstmt
= createStatement(type
);
189 sqlstmt
->setConnection(conn
);
190 NetworkStmt
*nwStmt
= new NetworkStmt();
191 nwStmt
->stmtID
= ++stmtID
;
192 printDebug(DM_Network
, "Statement string %s\n", pkt
->stmtString
);
193 nwStmt
->stmt
= sqlstmt
;
194 DbRetVal rv
= sqlstmt
->prepare(pkt
->stmtString
);
198 printError(ErrSysInit
, "statement prepare failed\n");
199 rpkt
->errRetVal
= rv
;
200 fillErrorString(rpkt
);
201 if (rpkt
->errorString
[0] == '\0')
202 strcpy(rpkt
->errorString
, "Prepare failed.");
207 //TODO: need to change retVal name
208 ResultSetPlan plan
= sqlstmt
->getResultSetPlan();
211 int param
= sqlstmt
->noOfParamFields();
212 int proj
= sqlstmt
->noOfProjFields();
213 BindSqlField
*bindField
= NULL
;
214 BindSqlProjectField
*projField
= NULL
;
216 FieldInfo
* fInfo
= new FieldInfo();
217 for (int i
= 0; i
< param
; i
++) {
218 bindField
= new BindSqlField();
219 sqlstmt
->getParamFldInfo(i
+ 1, fInfo
);
220 strcpy(bindField
->fName
, fInfo
->fldName
);
221 bindField
->type
= fInfo
->type
;
222 bindField
->length
= fInfo
->length
;
223 bindField
->offset
= fInfo
->offset
;
224 strcpy(bindField
->defaultValueBuf
, fInfo
->defaultValueBuf
);
225 bindField
->isNull
= fInfo
->isNull
;
226 bindField
->isPrimary
= fInfo
->isPrimary
;
227 bindField
->isDefault
= fInfo
->isDefault
;
228 bindField
->isUnique
= fInfo
->isUnique
;
229 bindField
->isUnique
= fInfo
->isUnique
;
230 //bindField->value = AllDataType::alloc(bindField->type, bindField->length);
231 bindField
->value
= NULL
;
232 nwStmt
->paramList
.append(bindField
);
235 FieldInfo
*fldInfo
= new FieldInfo();
236 for (int i
= 0; i
< proj
; i
++) {
237 projField
= new BindSqlProjectField();
238 sqlstmt
->getProjFldInfo(i
+ 1, fldInfo
);
239 strcpy(projField
->fName
, fldInfo
->fldName
);
240 projField
->type
= fldInfo
->type
;
241 projField
->length
= fldInfo
->length
;
242 projField
->offset
= fldInfo
->offset
;
243 strcpy(projField
->defaultValueBuf
, fldInfo
->defaultValueBuf
);
244 projField
->aType
= fldInfo
->aType
;
245 projField
->isNull
= fldInfo
->isNull
;
246 projField
->isPrimary
= fldInfo
->isPrimary
;
247 projField
->isDefault
= fldInfo
->isDefault
;
248 projField
->isUnique
= fldInfo
->isUnique
;
249 projField
->value
= AllDataType::alloc(projField
->type
, projField
->length
);
250 memset(projField
->value
, 0, projField
->length
);
251 nwStmt
->projList
.append(projField
);
254 stmtList
.append(nwStmt
);
255 if(sqlstmt
->isSelect()) rpkt
->isSelect
= true;
256 if (param
) *(retval
+2) = 1;
257 if (proj
) *(retval
+3) = 1;
258 rpkt
->stmtID
= nwStmt
->stmtID
;
259 strcpy(rpkt
->errorString
, "Success");
263 void * SqlNetworkHandler::processSqlExecute(PacketHeader
&header
, char *buffer
)
265 ResponsePacket
*rpkt
= new ResponsePacket();
266 char *retval
= (char *) &rpkt
->retVal
;
267 SqlPacketExecute
*pkt
= new SqlPacketExecute();
268 pkt
->setBuffer(buffer
);
269 pkt
->setBufferSize(header
.packetLength
);
270 pkt
->setStatementList(stmtList
);
272 printDebug(DM_Network
, "EXECUTE %d\n", pkt
->stmtID
);
273 rpkt
->stmtID
= pkt
->stmtID
;
274 ListIterator stmtIter
= stmtList
.getIterator();
276 while (stmtIter
.hasElement())
278 stmt
= (NetworkStmt
*) stmtIter
.nextElement();
279 //TODO::Also check the srcNetworkID
280 if (stmt
->stmtID
== pkt
->stmtID
) break;
282 AbsSqlStatement
*sqlstmt
= stmt
->stmt
;
284 char *nullInfo
= NULL
;
285 if (pkt
->noParams
) nullInfo
= pkt
->getNullInfo();
286 for (int i
=0; i
< pkt
->noParams
; i
++) {
287 BindSqlField
*bindField
= (BindSqlField
*) stmt
->paramList
.get(i
+1);
288 if (nullInfo
[i
]) sqlstmt
->setNull(i
+1);
289 else setParamValues(sqlstmt
, i
+1, bindField
->type
, bindField
->length
, (char *)bindField
->value
);
291 //SqlStatement *st = (SqlStatement *)sqlstmt;
292 if(sqlstmt
->isSelect()) {
293 int noProj
= stmt
->projList
.size();
294 for (int i
=0; i
< noProj
; i
++) {
295 BindSqlProjectField
*prjFld
= (BindSqlProjectField
*) stmt
->projList
.get(i
+1);
296 sqlstmt
->bindField(i
+1, prjFld
->value
);
300 DbRetVal rv
= sqlstmt
->execute(rows
);
302 rpkt
->errRetVal
= rv
;
303 fillErrorString(rpkt
);
307 strcpy(rpkt
->errorString
, "Success");
311 void * SqlNetworkHandler::processSqlFetch(PacketHeader
&header
)
313 ListIterator stmtIter
= stmtList
.getIterator();
315 SqlPacketResultSet
*rspkt
= new SqlPacketResultSet();
316 while (stmtIter
.hasElement())
318 stmt
= (NetworkStmt
*) stmtIter
.nextElement();
319 //TODO::Also check srcNetworkID
320 if (stmt
->stmtID
== header
.stmtID
) break;
322 printDebug(DM_Network
, "FETCH STMTID: %d", stmt
->stmtID
);
323 AbsSqlStatement
*sqlstmt
= stmt
->stmt
;
327 if ((data
= sqlstmt
->fetch(rv
)) != NULL
&& rv
== OK
) {
328 len
= 0;//means record is there
330 else if (data
== NULL
&& rv
== OK
) {
332 len
=1; //end of resultset
337 rspkt
->noProjs
= stmt
->projList
.size();
338 // set null info for all the fetched field values in projection list
339 int nullInfoLen
= os::align(rspkt
->noProjs
);
340 char *nullInfo
= (char *) malloc(nullInfoLen
);
341 memset(nullInfo
, 0, nullInfoLen
);
342 char *ptr
= nullInfo
;
343 ListIterator it
= stmt
->projList
.getIterator();
344 while (it
.hasElement()) {
345 BindSqlProjectField
*prjFld
= (BindSqlProjectField
*) it
.nextElement();
346 if (sqlstmt
->isFldNull(prjFld
->fName
)) *ptr
= 1;
349 rspkt
->setNullInfo(nullInfo
);
350 rspkt
->setProjList(stmt
->projList
);
352 if (rv
!= OK
) { printf("marshall failed\n"); }
354 if(len
== 0) len
= rspkt
->getBufferSize();
355 int numbytes
= os::send(sockfd
, &len
, 4, 0);
356 if (len
== 1 || len
== 2) { delete rspkt
; ::free (nullInfo
); return NULL
; }
358 //numbytes = os::recv(sockfd, &dummy, 4, 0);
359 numbytes
= os::send(sockfd
,rspkt
->getMarshalledBuffer(),
360 rspkt
->getBufferSize(), 0);
362 if (numbytes
== -1) {
363 printf("Error in sending the row to the client\n");
366 delete sqlstmt
; sqlstmt
= NULL
;
374 void * SqlNetworkHandler::processSqlFree(PacketHeader
&header
, char *buffer
)
376 ResponsePacket
*rpkt
= new ResponsePacket();
377 char *retval
= (char *) &rpkt
->retVal
;
378 SqlPacketFree
*pkt
= new SqlPacketFree();
379 pkt
->setBuffer(buffer
);
381 rpkt
->stmtID
= pkt
->stmtID
;
382 ListIterator stmtIter
= stmtList
.getIterator();
383 NetworkStmt
*stmt
= NULL
;
384 while (stmtIter
.hasElement())
386 stmt
= (NetworkStmt
*) stmtIter
.nextElement();
387 //TODO::Also check teh srcNetworkID
388 if (stmt
->stmtID
== pkt
->stmtID
) break;
392 printError(ErrWarning
, "Statement already freed.");
394 rpkt
->errRetVal
= ErrAlready
;
397 AbsSqlStatement
*sqlstmt
= stmt
->stmt
;
398 if (sqlstmt
) sqlstmt
->free();
399 ListIterator itprm
= stmt
->paramList
.getIterator();
400 BindSqlField
*fld
= NULL
;
401 while((fld
= (BindSqlField
*) itprm
.nextElement()) != NULL
) {
402 //if (fld->value) free(fld->value); memory never allocated for this
405 stmt
->paramList
.reset();
406 ListIterator itprj
= stmt
->projList
.getIterator();
407 BindSqlProjectField
*pfld
= NULL
;
408 while((pfld
= (BindSqlProjectField
*) itprj
.nextElement()) != NULL
) {
409 if (pfld
->value
) free(pfld
->value
);
412 stmt
->projList
.reset();
415 stmtList
.remove(stmt
);
419 strcpy(rpkt
->errorString
, "Success");
424 void * SqlNetworkHandler::processSqlCommit(PacketHeader
&header
, char *buffer
)
426 ResponsePacket
*rpkt
= new ResponsePacket();
427 char *retval
= (char *) &rpkt
->retVal
;
428 DbRetVal rv
= conn
->commit();
430 rpkt
->errRetVal
= rv
;
431 strcpy(rpkt
->errorString
, "Commit failure\n");
434 rv
= conn
->beginTrans();
435 strcpy(rpkt
->errorString
, "Success");
439 void *SqlNetworkHandler::processSqlRollback(PacketHeader
&header
, char *buffer
)
441 ResponsePacket
*rpkt
= new ResponsePacket();
442 char *retval
= (char *) &rpkt
->retVal
;
443 DbRetVal rv
= conn
->rollback();
445 rpkt
->errRetVal
= rv
;
446 strcpy(rpkt
->errorString
, "Rollback failure\n");
449 rv
= conn
->beginTrans();
450 strcpy(rpkt
->errorString
, "Success");
454 void SqlNetworkHandler::setParamValues(AbsSqlStatement
*stmt
, int parampos
, DataType type
,
455 int length
, char *value
)
460 stmt
->setIntParam(parampos
, *(int*)value
);
463 stmt
->setLongParam(parampos
, *(long*)value
);
466 stmt
->setLongLongParam(parampos
, *(long long*)value
);
469 stmt
->setShortParam(parampos
, *(short*)value
);
472 stmt
->setByteIntParam(parampos
, *(char*)value
);
475 stmt
->setDoubleParam(parampos
, *(double*)value
);
478 stmt
->setFloatParam(parampos
, *(float*)value
);
481 stmt
->setDateParam(parampos
, *(Date
*)value
);
484 stmt
->setTimeParam(parampos
, *(Time
*)value
);
487 stmt
->setTimeStampParam(parampos
, *(TimeStamp
*)value
);
491 char *d
=(char*)value
;
493 stmt
->setStringParam(parampos
, (char*)value
);
497 stmt
->setBinaryParam(parampos
, (char *) value
, length
);
503 AbsSqlConnection
* SqlNetworkHandler::createConnection(SqlApiImplType type
)
505 AbsSqlConnection
*con
= NULL
;
508 con
= SqlFactory::createConnection(CSql
);
510 case CSqlNetworkAdapter
:
511 con
= SqlFactory::createConnection(CSqlAdapter
);
513 case CSqlNetworkGateway
:
514 con
= SqlFactory::createConnection(CSqlGateway
);
522 AbsSqlStatement
* SqlNetworkHandler::createStatement(SqlApiImplType type
)
524 AbsSqlStatement
*stmt
= NULL
;
527 stmt
= SqlFactory::createStatement(CSql
);
529 case CSqlNetworkAdapter
:
530 stmt
= SqlFactory::createStatement(CSqlAdapter
);
532 case CSqlNetworkGateway
:
533 stmt
= SqlFactory::createStatement(CSqlGateway
);
541 void * SqlNetworkHandler::processSqlShowTables(PacketHeader
&header
, char *buffer
)
543 ResponsePacket
*rpkt
= new ResponsePacket();
544 rpkt
->isSelect
= false;
545 char *retval
= (char *) &rpkt
->retVal
;
546 AbsSqlStatement
*sqlstmt
= createStatement(type
);
547 sqlstmt
->setConnection(conn
);
549 tableNameList
= sqlstmt
->getAllTableNames(rv
);
550 rpkt
->errRetVal
= rv
;
551 rpkt
->rows
= tableNameList
.size();
552 strcpy(rpkt
->errorString
, "Success");
557 //only csql connection asks for this with or without durability.
558 void *SqlNetworkHandler::processSqlIsTablePresent(PacketHeader
&header
, char *buffer
)
560 ResponsePacket
*rpkt
= new ResponsePacket();
561 rpkt
->isSelect
= false;
562 SqlPacketIsTablePresent
*pkt
= new SqlPacketIsTablePresent();
563 pkt
->setBuffer(buffer
);
565 SqlStatement
*sqlstmt
= new SqlStatement();
566 SqlConnection
*sqlcon
= NULL
;
567 if (Conf::config
.useDurability())
568 sqlcon
= (SqlConnection
*) conn
->getInnerConnection();
569 else sqlcon
= (SqlConnection
*) conn
;
570 sqlstmt
->setSqlConnection(sqlcon
);
571 DbRetVal rv
= OK
; bool found
= false;
572 tableNameList
= sqlstmt
->getAllTableNames(rv
);
573 ListIterator it
= tableNameList
.getIterator();
574 while (it
.hasElement()) {
575 Identifier
*elem
= (Identifier
*) it
.nextElement();
576 if (strcmp(elem
->name
, pkt
->tblName
) == 0) {
581 rpkt
->errRetVal
= rv
;
583 rpkt
->errRetVal
= ErrNotFound
;
584 strcpy(rpkt
->errorString
, "Table Not found.");
586 ListIterator tblIter
= SqlNetworkHandler::tableNameList
.getIterator();
587 while (tblIter
.hasElement()) delete tblIter
.nextElement();
588 SqlNetworkHandler::tableNameList
.reset();
594 //only csql connection asks for this with or without durability.
595 void *SqlNetworkHandler::processSqlLoadRecords(PacketHeader
&header
, char *buffer
)
597 ResponsePacket
*rpkt
= new ResponsePacket();
598 rpkt
->isSelect
= false;
599 char *retval
= (char *) &rpkt
->retVal
;
600 SqlPacketGetRecords
*pkt
= new SqlPacketGetRecords();
601 pkt
->setBuffer(buffer
);
603 SqlStatement
*sqlstmt
= new SqlStatement();
604 SqlConnection
*sqlcon
= NULL
;
605 if (Conf::config
.useDurability())
606 sqlcon
= (SqlConnection
*) conn
->getInnerConnection();
607 else sqlcon
= (SqlConnection
*) conn
;
608 sqlstmt
->setSqlConnection(sqlcon
);
610 int pages
= sqlstmt
->getNoOfPagesForTable(pkt
->tblName
);
611 printDebug(DM_Network
, "No of pages to be shipped: %d", pages
);
613 strcpy(rpkt
->errorString
, pkt
->tblName
);
619 void SqlNetworkHandler::fillErrorString(ResponsePacket
*rpkt
)
621 switch(rpkt
->errRetVal
) {
622 case ErrNoConnection
:
623 strcpy(rpkt
->errorString
, "Connection not open.");
626 strcpy(rpkt
->errorString
, "Unique constraint violation");
628 case ErrNullViolation
:
629 strcpy(rpkt
->errorString
, "Not null constraint violation");
634 DbRetVal
SqlNetworkHandler::servePacket(PacketHeader
&header
, void *respkt
)
636 ResponsePacket
*rpkt
= (ResponsePacket
*) respkt
;
640 NetworkStmt
*stmt
=NULL
;
642 if (header
.packetType
== SQL_NW_PKT_ISTABLEPRESENT
||
643 header
.packetType
== SQL_NW_PKT_EXECDIRECT
) {
647 char *ptr
= (char *)&rpkt
->retVal
;
652 if (rpkt
->errRetVal
) {
658 if ((header
.packetType
== SQL_NW_PKT_PREPARE
&& params
!= 0) ||
659 (header
.packetType
== SQL_NW_PKT_PREPARE
&& proj
!= 0)) {
661 SqlPacketParamMetadata
*prmpkt
= new SqlPacketParamMetadata();
662 prmpkt
->stmtID
= rpkt
->stmtID
;
663 ListIterator stmtIter
= SqlNetworkHandler::stmtList
.getIterator();
664 while (stmtIter
.hasElement()) {
665 stmt
= (NetworkStmt
*) stmtIter
.nextElement();
666 if (stmt
->stmtID
== prmpkt
->stmtID
) break;
668 prmpkt
->noParams
= stmt
->paramList
.size();
669 rv
= prmpkt
->marshall();
670 rv
= send(SQL_NW_PKT_PARAM_METADATA
, prmpkt
->getMarshalledBuffer(), prmpkt
->getBufferSize());
673 printf("Error in sending the metadata to the client\n");
679 //fill projection list and send it to client
680 SqlPacketProjMetadata
*prjpkt
= new SqlPacketProjMetadata();
681 prjpkt
->stmtID
= rpkt
->stmtID
;
682 ListIterator stmtIter
= SqlNetworkHandler::stmtList
.getIterator();
683 while (stmtIter
.hasElement()) {
684 stmt
= (NetworkStmt
*) stmtIter
.nextElement();
685 if (stmt
->stmtID
== prjpkt
->stmtID
) break;
687 prjpkt
->noProjs
= stmt
->projList
.size();
688 rv
= prjpkt
->marshall();
689 rv
= send(SQL_NW_PKT_PROJ_METADATA
, prjpkt
->getMarshalledBuffer(), prjpkt
->getBufferSize());
692 printf("Error in sending the metadata to the client\n");
698 else if (header
.packetType
== SQL_NW_PKT_SHOWTABLES
) {
699 SqlPacketShowTables
*shTblPkt
= new SqlPacketShowTables();
700 shTblPkt
->numOfTables
= rpkt
->rows
;
701 rv
= shTblPkt
->marshall();
702 if (rv
!= OK
) { printf("marshall failed\n"); }
703 ListIterator tblIter
= SqlNetworkHandler::tableNameList
.getIterator();
704 while (tblIter
.hasElement()) delete tblIter
.nextElement();
705 SqlNetworkHandler::tableNameList
.reset();
706 rv
= send(SQL_NW_PKT_SHOWTABLES
, shTblPkt
->getMarshalledBuffer(), shTblPkt
->getBufferSize());
709 printError(ErrOS
, "Error in sending the metadata to the client\n");
714 else if (header
.packetType
== SQL_NW_PKT_GETRECORDS
) {
715 if (!rpkt
->rows
) return OK
;
716 SqlPacketLoadRecords
*pkt
= new SqlPacketLoadRecords();
717 pkt
->setPages(rpkt
->rows
);
719 SqlStatement
*sqlstmt
= new SqlStatement();
720 SqlConnection
*sqlcon
= NULL
;
721 if (Conf::config
.useDurability())
722 sqlcon
= (SqlConnection
*) conn
->getInnerConnection();
723 else sqlcon
= (SqlConnection
*) conn
;
724 sqlstmt
->setSqlConnection(sqlcon
);
725 sqlstmt
->loadRecords(&rpkt
->errorString
[0], pkt
->getMarshalledBuffer());
726 char *buf
= pkt
->getMarshalledBuffer();
727 rv
= send(SQL_NW_PKT_LOADRECORDS
, pkt
->getMarshalledBuffer(), pkt
->getBufferSize());
731 printf("Error in sending the metadata to the client\n");
736 else if (header
.packetType
== SQL_NW_PKT_DISCONNECT
) exit(0);
737 if (rpkt
) { delete rpkt
; rpkt
= NULL
; }
741 DbRetVal
SqlNetworkHandler::send(NetworkPacketType type
, char *buf
, int len
)
744 PacketHeader
*hdr
= new PacketHeader();
745 hdr
->packetType
= type
;
746 hdr
->packetLength
= len
;
747 hdr
->srcNetworkID
= 0;//networkid;
750 if ((numbytes
=os::send(sockfd
, hdr
, sizeof(PacketHeader
), 0)) == -1) {
751 printError(ErrOS
, "Unable to send the packet\n");
754 if ((numbytes
=os::send(sockfd
, buf
, len
, 0)) == -1) {
755 printError(ErrOS
, "Unable to send the packet\n");