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 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
;
40 void *SqlNetworkHandler::process(PacketHeader
&header
, char *buffer
)
45 switch(header
.packetType
)
47 case SQL_NW_PKT_CONNECT
:
48 rpkt
= processSqlConnect(header
, buffer
);
50 case SQL_NW_PKT_EXECDIRECT
:
51 rpkt
= processSqlExecuteDirect(header
, buffer
);
53 case SQL_NW_PKT_PREPARE
:
54 rpkt
= processSqlPrepare(header
, buffer
);
56 case SQL_NW_PKT_EXECUTE
:
57 rpkt
= processSqlExecute(header
, buffer
);
59 case SQL_NW_PKT_FETCH
:
60 rpkt
= processSqlFetch(header
);
62 case SQL_NW_PKT_COMMIT
:
63 rpkt
= processSqlCommit(header
, buffer
);
65 case SQL_NW_PKT_ROLLBACK
:
66 rpkt
= processSqlRollback(header
, buffer
);
68 case SQL_NW_PKT_DISCONNECT
:
69 rpkt
= processSqlDisconnect(header
);
72 rpkt
= processSqlFree(header
, buffer
);
74 case SQL_NW_PKT_SHOWTABLES
:
75 rpkt
= processSqlShowTables(header
, buffer
);
77 case SQL_NW_PKT_ISTABLEPRESENT
:
78 rpkt
= processSqlIsTablePresent(header
, buffer
);
80 case SQL_NW_PKT_GETRECORDS
:
81 rpkt
= processSqlLoadRecords(header
, buffer
);
83 case SQL_NW_PKT_LASTAIVAL
:
84 rpkt
= processSqlLastAutoIncrementVal(header
);
87 if (rpkt
!= NULL
) sendResponse(rpkt
);
91 DbRetVal
SqlNetworkHandler::sendResponse(void *rpkt
)
93 size_t numbytes
= os::send(sockfd
, rpkt
, sizeof(ResponsePacket
), 0);
95 printError(ErrOS
, "Error writing to socket\n");
102 DbRetVal
SqlNetworkHandler::closeConnection()
105 return conn
->disconnect();
108 void * SqlNetworkHandler::processSqlConnect(PacketHeader
&header
, char *buffer
)
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
);
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
);
124 rpkt
->errRetVal
= rv
;
125 fillErrorString(rpkt
);
131 rv
= conn
->beginTrans();
137 void * SqlNetworkHandler::processSqlDisconnect(PacketHeader
&header
)
139 DbRetVal rv
= conn
->rollback();
140 rv
= conn
->disconnect();
141 ResponsePacket
*rpkt
= new ResponsePacket();
142 char *ptr
= (char *) &rpkt
->retVal
;
144 strcpy(rpkt
->errorString
, "Success");
148 void* SqlNetworkHandler::processSqlExecuteDirect(PacketHeader
&header
, char *buffer
)
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
);
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
);
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.");
178 stmtList
.append(nwStmt
);
179 rpkt
->stmtID
= nwStmt
->stmtID
;
180 strcpy(rpkt
->errorString
, "Success");
184 void* SqlNetworkHandler::processSqlPrepare(PacketHeader
&header
, char *buffer
)
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
);
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
);
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.");
213 //TODO: need to change retVal name
214 ResultSetPlan plan
= sqlstmt
->getResultSetPlan();
217 int param
= sqlstmt
->noOfParamFields();
218 int proj
= sqlstmt
->noOfProjFields();
219 BindSqlField
*bindField
= NULL
;
220 BindSqlProjectField
*projField
= NULL
;
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
);
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
);
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");
269 void * SqlNetworkHandler::processSqlExecute(PacketHeader
&header
, char *buffer
)
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
);
278 printDebug(DM_Network
, "EXECUTE %d\n", pkt
->stmtID
);
279 rpkt
->stmtID
= pkt
->stmtID
;
280 ListIterator stmtIter
= stmtList
.getIterator();
282 while (stmtIter
.hasElement())
284 stmt
= (NetworkStmt
*) stmtIter
.nextElement();
285 //TODO::Also check the srcNetworkID
286 if (stmt
->stmtID
== pkt
->stmtID
) break;
288 AbsSqlStatement
*sqlstmt
= stmt
->stmt
;
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
);
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
);
307 DbRetVal rv
= sqlstmt
->execute(rows
);
309 rpkt
->errRetVal
= rv
;
310 fillErrorString(rpkt
);
314 strcpy(rpkt
->errorString
, "Success");
318 void * SqlNetworkHandler::processSqlFetch(PacketHeader
&header
)
320 ListIterator stmtIter
= stmtList
.getIterator();
322 SqlPacketResultSet
*rspkt
= new SqlPacketResultSet();
323 while (stmtIter
.hasElement())
325 stmt
= (NetworkStmt
*) stmtIter
.nextElement();
326 //TODO::Also check srcNetworkID
327 if (stmt
->stmtID
== header
.stmtID
) break;
329 printDebug(DM_Network
, "FETCH STMTID: %d", stmt
->stmtID
);
330 AbsSqlStatement
*sqlstmt
= stmt
->stmt
;
334 if ((data
= sqlstmt
->fetch(rv
)) != NULL
&& rv
== OK
) {
335 len
= 0;//means record is there
337 else if (data
== NULL
&& rv
== OK
) {
339 len
=1; //end of resultset
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;
356 rspkt
->setNullInfo(nullInfo
);
357 rspkt
->setProjList(stmt
->projList
);
359 if (rv
!= OK
) { printf("marshall failed\n"); }
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
; }
365 //numbytes = os::recv(sockfd, &dummy, 4, 0);
366 numbytes
= os::send(sockfd
,rspkt
->getMarshalledBuffer(),
367 rspkt
->getBufferSize(), 0);
369 if (numbytes
== -1) {
370 printf("Error in sending the row to the client\n");
373 delete sqlstmt
; sqlstmt
= NULL
;
381 void * SqlNetworkHandler::processSqlFree(PacketHeader
&header
, char *buffer
)
383 ResponsePacket
*rpkt
= new ResponsePacket();
384 char *retval
= (char *) &rpkt
->retVal
;
385 SqlPacketFree
*pkt
= new SqlPacketFree();
386 pkt
->setBuffer(buffer
);
388 rpkt
->stmtID
= pkt
->stmtID
;
389 ListIterator stmtIter
= stmtList
.getIterator();
390 NetworkStmt
*stmt
= NULL
;
391 while (stmtIter
.hasElement())
393 stmt
= (NetworkStmt
*) stmtIter
.nextElement();
394 //TODO::Also check teh srcNetworkID
395 if (stmt
->stmtID
== pkt
->stmtID
) break;
399 printError(ErrWarning
, "Statement already freed.");
401 rpkt
->errRetVal
= ErrAlready
;
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
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
);
419 stmt
->projList
.reset();
422 stmtList
.remove(stmt
);
426 strcpy(rpkt
->errorString
, "Success");
431 void * SqlNetworkHandler::processSqlCommit(PacketHeader
&header
, char *buffer
)
433 ResponsePacket
*rpkt
= new ResponsePacket();
434 char *retval
= (char *) &rpkt
->retVal
;
435 DbRetVal rv
= conn
->commit();
437 rpkt
->errRetVal
= rv
;
438 strcpy(rpkt
->errorString
, "Commit failure\n");
441 rv
= conn
->beginTrans();
442 strcpy(rpkt
->errorString
, "Success");
446 void *SqlNetworkHandler::processSqlRollback(PacketHeader
&header
, char *buffer
)
448 ResponsePacket
*rpkt
= new ResponsePacket();
449 char *retval
= (char *) &rpkt
->retVal
;
450 DbRetVal rv
= conn
->rollback();
452 rpkt
->errRetVal
= rv
;
453 strcpy(rpkt
->errorString
, "Rollback failure\n");
456 rv
= conn
->beginTrans();
457 strcpy(rpkt
->errorString
, "Success");
461 AbsSqlConnection
* SqlNetworkHandler::createConnection(SqlApiImplType type
)
463 AbsSqlConnection
*con
= NULL
;
466 con
= SqlFactory::createConnection(CSql
);
468 case CSqlNetworkAdapter
:
469 con
= SqlFactory::createConnection(CSqlAdapter
);
471 case CSqlNetworkGateway
:
472 con
= SqlFactory::createConnection(CSqlGateway
);
480 AbsSqlStatement
* SqlNetworkHandler::createStatement(SqlApiImplType type
)
482 AbsSqlStatement
*stmt
= NULL
;
485 stmt
= SqlFactory::createStatement(CSql
);
487 case CSqlNetworkAdapter
:
488 stmt
= SqlFactory::createStatement(CSqlAdapter
);
490 case CSqlNetworkGateway
:
491 stmt
= SqlFactory::createStatement(CSqlGateway
);
499 void * SqlNetworkHandler::processSqlShowTables(PacketHeader
&header
, char *buffer
)
501 ResponsePacket
*rpkt
= new ResponsePacket();
502 rpkt
->isSelect
= false;
503 char *retval
= (char *) &rpkt
->retVal
;
504 AbsSqlStatement
*sqlstmt
= createStatement(type
);
505 sqlstmt
->setConnection(conn
);
507 tableNameList
= sqlstmt
->getAllTableNames(rv
);
508 rpkt
->errRetVal
= rv
;
509 rpkt
->rows
= tableNameList
.size();
510 strcpy(rpkt
->errorString
, "Success");
515 //only csql connection asks for this with or without durability.
516 void *SqlNetworkHandler::processSqlIsTablePresent(PacketHeader
&header
, char *buffer
)
518 ResponsePacket
*rpkt
= new ResponsePacket();
519 rpkt
->isSelect
= false;
520 SqlPacketIsTablePresent
*pkt
= new SqlPacketIsTablePresent();
521 pkt
->setBuffer(buffer
);
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) {
538 rpkt
->errRetVal
= rv
;
540 rpkt
->errRetVal
= ErrNotFound
;
541 strcpy(rpkt
->errorString
, "Table Not found.");
543 ListIterator tblIter
= SqlNetworkHandler::tableNameList
.getIterator();
544 while (tblIter
.hasElement()) delete tblIter
.nextElement();
545 SqlNetworkHandler::tableNameList
.reset();
551 //only csql connection asks for this with or without durability.
552 void *SqlNetworkHandler::processSqlLoadRecords(PacketHeader
&header
, char *buffer
)
554 ResponsePacket
*rpkt
= new ResponsePacket();
555 rpkt
->isSelect
= false;
556 char *retval
= (char *) &rpkt
->retVal
;
557 SqlPacketGetRecords
*pkt
= new SqlPacketGetRecords();
558 pkt
->setBuffer(buffer
);
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
);
566 int pages
= sqlstmt
->getNoOfPagesForTable(pkt
->tblName
);
567 printDebug(DM_Network
, "No of pages to be shipped: %d", pages
);
569 strcpy(rpkt
->errorString
, pkt
->tblName
);
575 void *SqlNetworkHandler::processSqlLastAutoIncrementVal(PacketHeader
&header
)
577 ListIterator stmtIter
= stmtList
.getIterator();
579 while (stmtIter
.hasElement())
581 stmt
= (NetworkStmt
*) stmtIter
.nextElement();
582 if (stmt
->stmtID
== header
.stmtID
) break;
584 AbsSqlStatement
*sqlstmt
= stmt
->stmt
;
585 ResponsePacket
*rpkt
= new ResponsePacket();
587 rpkt
->lastAutoIncVal
= sqlstmt
->getLastInsertedVal(rv
);
591 void SqlNetworkHandler::fillErrorString(ResponsePacket
*rpkt
)
593 switch(rpkt
->errRetVal
) {
594 case ErrNoConnection
:
595 strcpy(rpkt
->errorString
, "Connection not open.");
598 strcpy(rpkt
->errorString
, "Unique constraint violation");
600 case ErrNullViolation
:
601 strcpy(rpkt
->errorString
, "Not null constraint violation");
606 DbRetVal
SqlNetworkHandler::servePacket(PacketHeader
&header
, void *respkt
)
608 ResponsePacket
*rpkt
= (ResponsePacket
*) respkt
;
612 NetworkStmt
*stmt
=NULL
;
614 if (header
.packetType
== SQL_NW_PKT_ISTABLEPRESENT
||
615 header
.packetType
== SQL_NW_PKT_EXECDIRECT
) {
619 char *ptr
= (char *)&rpkt
->retVal
;
624 if (rpkt
->errRetVal
) {
630 if ((header
.packetType
== SQL_NW_PKT_PREPARE
&& params
!= 0) ||
631 (header
.packetType
== SQL_NW_PKT_PREPARE
&& proj
!= 0)) {
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;
640 prmpkt
->noParams
= stmt
->paramList
.size();
641 rv
= prmpkt
->marshall();
642 rv
= send(SQL_NW_PKT_PARAM_METADATA
, prmpkt
->getMarshalledBuffer(), prmpkt
->getBufferSize());
645 printf("Error in sending the metadata to the client\n");
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;
659 prjpkt
->noProjs
= stmt
->projList
.size();
660 rv
= prjpkt
->marshall();
661 rv
= send(SQL_NW_PKT_PROJ_METADATA
, prjpkt
->getMarshalledBuffer(), prjpkt
->getBufferSize());
664 printf("Error in sending the metadata to the client\n");
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());
681 printError(ErrOS
, "Error in sending the metadata to the client\n");
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
);
691 SqlStatement
*sqlstmt
= new SqlStatement();
692 SqlConnection
*sqlcon
= NULL
;
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());
703 printf("Error in sending the metadata to the client\n");
708 else if (header
.packetType
== SQL_NW_PKT_DISCONNECT
) exit(0);
709 if (rpkt
) { delete rpkt
; rpkt
= NULL
; }
713 DbRetVal
SqlNetworkHandler::send(NetworkPacketType type
, char *buf
, int len
)
716 PacketHeader
*hdr
= new PacketHeader();
717 hdr
->packetType
= type
;
718 hdr
->packetLength
= len
;
719 hdr
->srcNetworkID
= 0;//networkid;
722 if ((numbytes
=os::send(sockfd
, hdr
, sizeof(PacketHeader
), 0)) == -1) {
723 printError(ErrOS
, "Unable to send the packet\n");
726 if ((numbytes
=os::send(sockfd
, buf
, len
, 0)) == -1) {
727 printError(ErrOS
, "Unable to send the packet\n");