3 // Description: Statement Handle manager.
5 #include "odbcCommon.h"
8 CSqlOdbcStmt::CSqlOdbcStmt( void ) :
9 handleType_( SQL_HANDLE_STMT
),
12 err_( SQL_HANDLE_STMT
),
14 isParamBound_( true ),
22 //fetchMode_(SQL_FETCH_SINGLE_TUPLE)
24 cursorName_
[0] = '\0';
27 SQLRETURN
SQLAllocStmt(
28 SQLHDBC ConnectionHandle
,
29 SQLHSTMT
*StatementHandle
)
31 return( CSqlOdbcStmt::SQLAllocHandle( ConnectionHandle
, StatementHandle
) );
34 SQLRETURN
CSqlOdbcStmt::SQLAllocHandle(
35 SQLHANDLE inputHandle
, // IN
36 SQLHANDLE
*outputHandle
) // OUT
38 CSqlOdbcDbc
*inputDbc
= (CSqlOdbcDbc
*) inputHandle
;
41 if( isValidHandle( inputDbc
, SQL_HANDLE_DBC
) != SQL_SUCCESS
)
42 return( SQL_INVALID_HANDLE
);
45 if( inputDbc
->state_
< C4
)
47 globalError
.set( ERROR_CONNOTOPEN
);
48 globalError
.printStr( SQL_OV_ODBC3
);
52 // Allocate Statement object.
53 *outputHandle
= (SQLHANDLE
*) new CSqlOdbcStmt
;
54 if( *outputHandle
== NULL
)
56 globalError
.set( ERROR_MEMALLOC
);
57 globalError
.printStr( SQL_OV_ODBC3
);
61 // Initialize relation b/w Stmt and Dbc
62 inputDbc
->stmtList_
.append(*outputHandle
);
63 inputDbc
->stmtHdlList_
.append(outputHandle
);
64 if( inputDbc
->state_
<= C4
)
65 inputDbc
->state_
= C5
;
66 ((CSqlOdbcStmt
*) *outputHandle
)->parentDbc_
= inputDbc
;
67 //CSqlOdbcError::printDbg("proxy:stmt:setConnection");
68 //((CSqlOdbcStmt*) *outputHandle)->fsqlStmt_->setConnection( inputDbc->fsqlConn_ );
69 ((CSqlOdbcStmt
*) *outputHandle
)->fInfo
= new FieldInfo();
70 return( SQL_SUCCESS
);
73 SQLRETURN
CSqlOdbcStmt::SQLFreeHandle(
74 SQLHANDLE inputHandle
) // IN
76 CSqlOdbcStmt
*inputStmt
= (CSqlOdbcStmt
*) inputHandle
;
79 if( isValidHandle( inputStmt
, SQL_HANDLE_STMT
) != SQL_SUCCESS
)
80 return( SQL_INVALID_HANDLE
);
83 if( inputStmt
->chkStateForSQLFreeHandle() != SQL_SUCCESS
)
87 inputStmt
->resetStmt();
89 // Remove Stmt from Parent Dbc.
90 ListIterator iter
= inputStmt
->parentDbc_
->stmtList_
.getIterator();
91 CSqlOdbcStmt
*stmtElem
= NULL
;
92 while (iter
.hasElement()) {
93 stmtElem
= (CSqlOdbcStmt
*) iter
.nextElement();
94 if( stmtElem
== inputStmt
) {
96 inputStmt
->parentDbc_
->stmtList_
.remove(stmtElem
);
100 // Set Dbc state_ = no statement.
101 if( inputStmt
->parentDbc_
->stmtList_
.size() == 0 )
102 inputStmt
->parentDbc_
->state_
= C4
;
104 inputStmt
->handleType_
= -1; // Make object invalid.
106 ListIterator it
= inputStmt
->parentDbc_
->stmtHdlList_
.getIterator();
107 while (it
.hasElement()) {
108 elem
= (SQLHANDLE
*) it
.nextElement();
109 if(*elem
== inputStmt
) *elem
= NULL
;
111 inputStmt
->parentDbc_
->stmtHdlList_
.remove(elem
);
112 delete inputStmt
->fInfo
;
113 delete inputStmt
; // Delete Stmt.
114 return( SQL_SUCCESS
);
117 SQLRETURN
SQLFreeStmt(
118 SQLHSTMT StatementHandle
, // IN
119 SQLUSMALLINT Option
) // IN
122 printError(ErrWarning
, "SQLFreeStmt opt:%d", Option
);
125 if( isValidHandle( (CSqlOdbcStmt
*) StatementHandle
, SQL_HANDLE_STMT
) != SQL_SUCCESS
)
126 return( SQL_INVALID_HANDLE
);
129 if( Option
== SQL_DROP
)
130 return( CSqlOdbcStmt::SQLFreeHandle( StatementHandle
) );
132 return( ((CSqlOdbcStmt
*) StatementHandle
)->SQLFreeStmt( Option
) );
135 SQLRETURN
CSqlOdbcStmt::SQLFreeStmt(
142 if( chkStateForSQLFreeStmt() != SQL_SUCCESS
)
144 if (!fsqlStmt_
) return (SQL_SUCCESS
);
147 case SQL_CLOSE
: // // Free resultset
148 // if( fsqlStmt_->isSelect() == true ) // CSQL
150 // //CSqlOdbcError::printDbg("proxy:stmt:getResultSet");
151 // CSqlResultSet *resultSet_ = fsqlStmt_->getResultSet(); // CSQL
152 // if( resultSet_ && resultSet_->isOpen() == true )
154 // resultSet_->close();
161 if( fsqlStmt_
->isSelect() == true ) { // CSQL
163 state_
= S3
; // With Cursor
166 state_
= S2
; // Without Cursor
174 fsqlStmt_
->free(); // CSQL
180 case SQL_UNBIND
: ard_
.freeAllDesc();
184 case SQL_RESET_PARAMS
: apd_
.freeAllDesc();
186 //isParamBound_ = false;
189 default: err_
.set( ERROR_OPTRANGE
);
192 return( SQL_SUCCESS
);
195 SQLRETURN
SQLBindCol(
196 SQLHSTMT StatementHandle
,
197 SQLUSMALLINT ColumnNumber
,
198 SQLSMALLINT TargetType
,
199 SQLPOINTER TargetValue
,
200 SQLINTEGER BufferLength
,
201 SQLINTEGER
*StrLen_or_Ind
)
204 printError(ErrWarning
, "SQLBindCol");
207 if( isValidHandle( (CSqlOdbcStmt
*) StatementHandle
, SQL_HANDLE_STMT
) != SQL_SUCCESS
)
208 return( SQL_INVALID_HANDLE
);
210 return( ((CSqlOdbcStmt
*) StatementHandle
)->SQLBindCol( ColumnNumber
,
211 TargetType
, TargetValue
, BufferLength
, StrLen_or_Ind
) );
214 SQLRETURN
CSqlOdbcStmt::SQLBindCol(
215 SQLUSMALLINT columnNumber
,
216 SQLSMALLINT targetType
,
217 SQLPOINTER targetValue
,
218 SQLINTEGER bufferLength
,
221 CSqlOdbcDesc
*bindDesc
= 0;
222 CSqlOdbcDesc
*inputDesc
= 0;
223 SQLRETURN found
= SQL_ERROR
;
229 if( chkStateForSQLBindCol() != SQL_SUCCESS
)
232 // Invalid Buffer Length.
235 // switch is in order to support more types.
237 if( bufferLength
< 0 && bufferLength
!= SQL_NTS
)
239 err_
.set( ERROR_BUFLEN
);
244 if( bufferLength
< 0 && bufferLength
!= SQL_NTS
)
246 err_
.set( ERROR_BUFLEN
);
252 // Invalid Column Number
253 if( columnNumber
< 1 )
255 err_
.set( ERROR_COLNUM
);
259 // Get the Descriptor if already exists
260 found
= ard_
.getDescWithColNum( columnNumber
, &bindDesc
);
263 if( targetValue
== 0 )
265 if( found
!= SQL_SUCCESS
)
267 err_
.set( ERROR_COLNUM
);
270 ard_
.delDesc( bindDesc
); // UNBIND
272 return( SQL_SUCCESS
);
275 // Validate target Type, Value and Column no.
276 if( targetValue
== 0 || isValidCType( targetType
) != SQL_SUCCESS
)
278 err_
.set( ERROR_INVBUFTYPE
);
282 // Add new descriptor
283 if( found
!= SQL_SUCCESS
)
285 bindDesc
= new CSqlOdbcDesc();
286 ard_
.descList_
.append(bindDesc
);
289 // Initialize Descriptor.
290 bindDesc
->col_
= columnNumber
;
291 bindDesc
->cType_
= targetType
;
292 bindDesc
->dataPtr_
= targetValue
;
293 bindDesc
->length_
= (SQLUINTEGER
) bufferLength
;
294 bindDesc
->indPtr_
= (SQLPOINTER
) ind
;
296 found
= ird_
.getDescWithColNum( columnNumber
, &inputDesc
);
298 // Add new descriptor
299 if( found
!= SQL_SUCCESS
)
301 inputDesc
= new CSqlOdbcDesc();
302 ird_
.descList_
.append(inputDesc
);
304 ResultSetPlan pl
= fsqlStmt_
->getResultSetPlan();
305 //Get Field Information from CSQL
306 fsqlStmt_
->getProjFldInfo(columnNumber
, fInfo
);
307 // Initialize input Descriptor.
308 //DataType sourceType = getCSqlType( targetType );
309 //char fldName[IDENTIFIER_LENGTH];
310 //Table::getFieldNameAlone((char*)fInfo->fldName,fldName);
311 strcpy((char *)inputDesc
->colName_
,(char*)fInfo
->fldName
);
312 inputDesc
->col_
= columnNumber
;
313 if( pl
== GetColumns
&& columnNumber
== 5) {
314 inputDesc
->csqlType_
= typeShort
;
315 inputDesc
->cType_
= typeShort
;
318 inputDesc
->csqlType_
= fInfo
->type
;
319 inputDesc
->cType_
= fInfo
->type
;
321 getInputBuffer(&inputDesc
->dataPtr_
,fInfo
->type
,(SQLUINTEGER
) bufferLength
);
322 inputDesc
->length_
= fInfo
->length
;
323 inputDesc
->indPtr_
= (SQLPOINTER
) ind
;
324 return( SQL_SUCCESS
);
327 SQLRETURN
SQLSetParam(
328 SQLHSTMT StatementHandle
,
329 SQLUSMALLINT ParameterNumber
,
330 SQLSMALLINT ValueType
,
331 SQLSMALLINT ParameterType
,
332 SQLUINTEGER LengthPrecision
,
333 SQLSMALLINT ParameterScale
,
334 SQLPOINTER ParameterValue
,
335 SQLINTEGER
*StrLen_or_Ind
)
338 printError(ErrWarning
, "SQLSetParam");
341 return( SQLBindParameter( StatementHandle
, ParameterNumber
,
342 SQL_PARAM_INPUT_OUTPUT
, ValueType
, ParameterType
, LengthPrecision
,
343 ParameterScale
, ParameterValue
, 0, StrLen_or_Ind
) );
346 SQLRETURN
SQLBindParam(
347 SQLHSTMT StatementHandle
,
348 SQLUSMALLINT ParameterNumber
,
349 SQLSMALLINT ValueType
,
350 SQLSMALLINT ParameterType
,
351 SQLUINTEGER LengthPrecision
,
352 SQLSMALLINT ParameterScale
,
353 SQLPOINTER ParameterValue
,
354 SQLINTEGER
*StrLen_or_Ind
)
357 printError(ErrWarning
, "SQLBindParam");
360 return( SQLBindParameter( StatementHandle
, ParameterNumber
,
361 SQL_PARAM_INPUT_OUTPUT
, ValueType
, ParameterType
, LengthPrecision
,
362 ParameterScale
, ParameterValue
, 0, StrLen_or_Ind
) );
365 SQLRETURN
SQLBindParameter(
366 SQLHSTMT StatementHandle
,
367 SQLUSMALLINT ParameterNumber
,
368 SQLSMALLINT InputOutputType
,
369 SQLSMALLINT ValueType
,
370 SQLSMALLINT ParameterType
,
371 SQLUINTEGER LengthPrecision
,
372 SQLSMALLINT ParameterScale
,
373 SQLPOINTER ParameterValue
,
374 SQLINTEGER BufferLength
,
375 SQLINTEGER
*StrLen_or_Ind
)
378 printError(ErrWarning
, "SQLBindParameter");
381 if( isValidHandle( (CSqlOdbcStmt
*) StatementHandle
, SQL_HANDLE_STMT
) != SQL_SUCCESS
)
382 return( SQL_INVALID_HANDLE
);
384 return( ((CSqlOdbcStmt
*) StatementHandle
)->SQLBindParameter( ParameterNumber
,
385 InputOutputType
, ValueType
,
386 ParameterType
, LengthPrecision
,
387 ParameterScale
, ParameterValue
,
388 BufferLength
, StrLen_or_Ind
) );
391 SQLRETURN
CSqlOdbcStmt::SQLBindParameter(
392 SQLUSMALLINT parameterNumber
,
393 SQLSMALLINT inputOutputType
,
394 SQLSMALLINT valueType
,
395 SQLSMALLINT parameterType
,
396 SQLUINTEGER lengthPrecision
,
397 SQLSMALLINT parameterScale
,
398 SQLPOINTER parameterValue
,
399 SQLINTEGER bufferLength
,
402 CSqlOdbcDesc
*bindDesc
= 0;
403 CSqlOdbcDesc
*inputDesc
=0;
410 if( chkStateForSQLBindParameter() != SQL_SUCCESS
)
412 // Invalid Buffer Length.
415 // switch is in order to support more types.
417 if( bufferLength
< 0 && bufferLength
!= SQL_NTS
)
419 err_
.set( ERROR_BUFLEN
);
424 if( bufferLength
< 0 && bufferLength
!= SQL_NTS
)
426 err_
.set( ERROR_BUFLEN
);
432 // Validate parameters
433 switch( inputOutputType
)
435 case SQL_PARAM_INPUT
:
436 case SQL_PARAM_OUTPUT
:
437 case SQL_PARAM_INPUT_OUTPUT
: break;
438 default: err_
.set( ERROR_INV_PARAMTYPE
);
441 if( isValidCType( valueType
) != SQL_SUCCESS
)
442 // || isValidSQLType( parameterType ) != SQL_SUCCESS )
444 err_
.set( ERROR_INVBUFTYPE
);
447 if( parameterNumber
< 1 )
449 err_
.set( ERROR_COLNUM
);
453 // Get the Descriptor if already exists
454 found
= apd_
.getDescWithColNum( parameterNumber
, &bindDesc
);
455 if( found
!= SQL_SUCCESS
)
457 bindDesc
= new CSqlOdbcDesc();
458 apd_
.descList_
.append(bindDesc
);
459 // Initialize Descriptor.
460 bindDesc
->col_
= parameterNumber
;
461 bindDesc
->paramType_
= inputOutputType
;
462 bindDesc
->cType_
= valueType
;
463 bindDesc
->sqlType_
= parameterType
;
464 bindDesc
->dataPtr_
= parameterValue
;
465 bindDesc
->length_
= (SQLUINTEGER
) bufferLength
;
466 bindDesc
->precision_
=(short) lengthPrecision
;
467 bindDesc
->scale_
= parameterScale
;
468 bindDesc
->indPtr_
= (SQLPOINTER
) ind
;
470 found
= ipd_
.getDescWithColNum (parameterNumber
, &inputDesc
);
471 if( found
!= SQL_SUCCESS
)
473 inputDesc
= new CSqlOdbcDesc();
474 ipd_
.descList_
.append(inputDesc
);
475 //Initialize inputDescriptor
476 DataType destType
=getCSqlType(valueType
);
477 inputDesc
->col_
= parameterNumber
;
478 inputDesc
->paramType_
= inputOutputType
;
479 inputDesc
->cType_
= valueType
;
480 inputDesc
->sqlType_
= parameterType
;
481 inputDesc
->dataPtr_
= NULL
;
482 //getInputBuffer(&inputDesc->dataPtr_,destType,(SQLUINTEGER)bufferLength);
483 inputDesc
->length_
= (SQLUINTEGER
) bufferLength
;
484 inputDesc
->precision_
= (short)lengthPrecision
;
485 inputDesc
->scale_
= parameterScale
;
486 inputDesc
->indPtr_
= (SQLPOINTER
) ind
;
488 //isParamBound_ = false;
489 return( SQL_SUCCESS
);
492 SQLRETURN
SQLExecDirect(
493 SQLHSTMT StatementHandle
, // IN
494 SQLCHAR
*StatementText
, // IN
495 SQLINTEGER TextLength
) // IN
498 printError(ErrWarning
, "SQLExecDirect");
502 if( isValidHandle( (CSqlOdbcStmt
*) StatementHandle
, SQL_HANDLE_STMT
) != SQL_SUCCESS
)
503 return( SQL_INVALID_HANDLE
);
506 return( ((CSqlOdbcStmt
*) StatementHandle
)->SQLExecDirect( StatementText
, TextLength
) );
509 SQLRETURN
CSqlOdbcStmt::SQLExecDirect(
510 SQLCHAR
*statementText
, // IN
511 SQLINTEGER textLength
) // IN
517 if( chkStateForSQLPrepare() != SQL_SUCCESS
)
520 // Invalid Buffer Length.
521 if( textLength
< 0 && textLength
!= SQL_NTS
)
523 err_
.set( ERROR_BUFLEN
);
527 // If Stmt is already prepared.
532 if (parentDbc_
->mode_
==1)
533 fsqlStmt_
= SqlFactory::createStatement(CSql
);
534 else if (parentDbc_
->mode_
==2)
535 fsqlStmt_
= SqlFactory::createStatement(CSqlAdapter
);
536 else if (parentDbc_
->mode_
==3)
537 fsqlStmt_
= SqlFactory::createStatement(CSqlGateway
);
538 else if (parentDbc_
->mode_
==4)
539 fsqlStmt_
= SqlFactory::createStatement(CSqlNetwork
);
540 else if (parentDbc_
->mode_
==5)
541 fsqlStmt_
= SqlFactory::createStatement(CSqlNetworkAdapter
);
542 else if (parentDbc_
->mode_
==6)
543 fsqlStmt_
= SqlFactory::createStatement(CSqlNetworkGateway
);
544 fsqlStmt_
->setConnection( parentDbc_
->fsqlConn_
);
546 //CSqlOdbcError::printDbg("proxy:stmt:prepare");
548 if( (rv
=fsqlStmt_
->executeDirect( (char*) statementText
))!= OK
) // CSQL
552 //err_.set(ERROR_GENERAL);
555 case ErrNotExists
: err_
.set( ERROR_TBLNOTFOUND
); break;
556 case ErrNotFound
: err_
.set( ERROR_NO_COLEXISTS
); break;
557 case ErrAlready
: err_
.set( ERROR_TBLEXISTS
); break;
558 case ErrSyntaxError
:err_
.set(ERROR_SQL_SYNTAX
);break;
559 case ErrSyntax
:err_
.set(ERROR_SQL_SYNTAX
);break;
560 /*case csqlSqlErrSchNotFound: err_.set( ERROR_SCHNOTFOUND); break;
561 case csqlSqlErrIndexNotFound: err_.set( ERROR_NO_IDXEXISTS); break;
562 case csqlSqlErrViewNotFound: err_.set( ERROR_TBLNOTFOUND); break;
563 case csqlSqlErrFldExists: err_.set( ERROR_COLEXISTS); break;
564 case csqlSqlErrIndexExists: err_.set( ERROR_IDXEXISTS); break;
565 case csqlSqlErrViewExists: err_.set( ERROR_TBLEXISTS); break;
566 case csqlSqlErrTooManyVals:err_.set(ERROR_MANY_VALS);break;
567 case csqlSqlErrTooFewVals:err_.set(ERROR_FEW_VALS);break;
568 case csqlSqlErrIncompatibleType:err_.set(ERROR_TYPE_INCMP);break;
569 case csqlSqlErrInvalidFormat:err_.set(ERROR_DATA_FORMAT);break;
570 case csqlSqlErrDuplicateFld:err_.set(ERROR_DUP_COL);break;
571 case csqlSqlErrSqlInternal:err_.set(ERROR_SQL_INT);break;*/
572 default: err_
.set(ERROR_GENERAL
);
577 //parentDbc_->state_ = C6;
579 return( SQL_SUCCESS
);
582 SQLRETURN
SQLPrepare(
583 SQLHSTMT StatementHandle
, // IN
584 SQLCHAR
*StatementText
, // IN
585 SQLINTEGER TextLength
) // IN
588 printError(ErrWarning
, "SQLPrepare");
592 if( isValidHandle( (CSqlOdbcStmt
*) StatementHandle
, SQL_HANDLE_STMT
) != SQL_SUCCESS
)
593 return( SQL_INVALID_HANDLE
);
596 return( ((CSqlOdbcStmt
*) StatementHandle
)->SQLPrepare( StatementText
, TextLength
) );
599 SQLRETURN
CSqlOdbcStmt::SQLPrepare(
600 SQLCHAR
*statementText
, // IN
601 SQLINTEGER textLength
) // IN
607 if( chkStateForSQLPrepare() != SQL_SUCCESS
)
610 // Invalid Buffer Length.
611 if( textLength
< 0 && textLength
!= SQL_NTS
)
613 err_
.set( ERROR_BUFLEN
);
617 // If Stmt is already prepared.
622 if (parentDbc_
->mode_
==1)
623 fsqlStmt_
= SqlFactory::createStatement(CSql
);
624 else if (parentDbc_
->mode_
==2)
625 fsqlStmt_
= SqlFactory::createStatement(CSqlAdapter
);
626 else if (parentDbc_
->mode_
==3)
627 fsqlStmt_
= SqlFactory::createStatement(CSqlGateway
);
628 else if (parentDbc_
->mode_
==4)
629 fsqlStmt_
= SqlFactory::createStatement(CSqlNetwork
);
630 else if (parentDbc_
->mode_
==5)
631 fsqlStmt_
= SqlFactory::createStatement(CSqlNetworkAdapter
);
632 else if (parentDbc_
->mode_
==6)
633 fsqlStmt_
= SqlFactory::createStatement(CSqlNetworkGateway
);
634 fsqlStmt_
->setConnection( parentDbc_
->fsqlConn_
);
636 //CSqlOdbcError::printDbg("proxy:stmt:prepare");
638 if( (rv
=fsqlStmt_
->prepare( (char*) statementText
))!= OK
) // CSQL
642 //err_.set(ERROR_GENERAL);
645 case ErrNotExists
: err_
.set( ERROR_TBLNOTFOUND
); break;
646 case ErrNotFound
: err_
.set( ERROR_NO_COLEXISTS
); break;
647 case ErrAlready
: err_
.set( ERROR_TBLEXISTS
); break;
648 case ErrSyntaxError
:err_
.set(ERROR_SQL_SYNTAX
);break;
649 case ErrSyntax
:err_
.set(ERROR_SQL_SYNTAX
);break;
650 /*case csqlSqlErrSchNotFound: err_.set( ERROR_SCHNOTFOUND); break;
651 case csqlSqlErrIndexNotFound: err_.set( ERROR_NO_IDXEXISTS); break;
652 case csqlSqlErrViewNotFound: err_.set( ERROR_TBLNOTFOUND); break;
653 case csqlSqlErrFldExists: err_.set( ERROR_COLEXISTS); break;
654 case csqlSqlErrIndexExists: err_.set( ERROR_IDXEXISTS); break;
655 case csqlSqlErrViewExists: err_.set( ERROR_TBLEXISTS); break;
656 case csqlSqlErrTooManyVals:err_.set(ERROR_MANY_VALS);break;
657 case csqlSqlErrTooFewVals:err_.set(ERROR_FEW_VALS);break;
658 case csqlSqlErrIncompatibleType:err_.set(ERROR_TYPE_INCMP);break;
659 case csqlSqlErrInvalidFormat:err_.set(ERROR_DATA_FORMAT);break;
660 case csqlSqlErrDuplicateFld:err_.set(ERROR_DUP_COL);break;
661 case csqlSqlErrSqlInternal:err_.set(ERROR_SQL_INT);break;*/
662 default: err_
.set(ERROR_GENERAL
);
666 if( fsqlStmt_
->isSelect() != true ) // CSQL
667 state_
= S2
; // With cursor
669 state_
= S3
; // Without cursor
671 //parentDbc_->state_ = C6;
673 return( SQL_SUCCESS
);
676 SQLRETURN
SQLExecute(SQLHSTMT StatementHandle
) // IN
679 printError(ErrWarning
, "SQLExecute");
683 if( isValidHandle( (CSqlOdbcStmt
*) StatementHandle
, SQL_HANDLE_STMT
) != SQL_SUCCESS
)
684 return( SQL_INVALID_HANDLE
);
686 return( ((CSqlOdbcStmt
*) StatementHandle
)->SQLExecute() );
689 SQLRETURN
CSqlOdbcStmt::SQLExecute() // TODO
694 if( chkStateForSQLExecute() != SQL_SUCCESS
)
697 if( fsqlStmt_
->noOfParamFields() > 0 )
700 // Iterate through all apd_;
701 CSqlOdbcDesc
*appParamDesc
;
702 ListIterator apdIter
= apd_
.descList_
.getIterator();
703 CSqlOdbcDesc
*csqlParamDesc
;
704 ListIterator ipdIter
= ipd_
.descList_
.getIterator();
706 //Get the source and the destination type
707 DataType sourceType
= typeUnknown
,destType
= typeUnknown
;
708 int paramNum
=1,sourceLength
=-1,destLength
=-1;
711 while(apdIter
.hasElement() || ipdIter
.hasElement()) {
712 appParamDesc
= (CSqlOdbcDesc
*) apdIter
.nextElement();
713 csqlParamDesc
=(CSqlOdbcDesc
*) ipdIter
.nextElement();
714 if(paramNum
<= fsqlStmt_
->noOfParamFields())
716 if( fsqlStmt_
->getParamFldInfo(paramNum
, fInfo
) != OK
) return( SQL_ERROR
);
717 sourceType
=getCSqlType(appParamDesc
->cType_
);
718 destType
=fInfo
->type
;
719 sourceLength
=(int)appParamDesc
->length_
;
720 destLength
=fInfo
->length
;
721 if(sourceType
!= typeUnknown
&& destType
!= typeUnknown
)
723 //Check if NULL is inserted
724 if((appParamDesc
->indPtr_
!= NULL
) && (*(SQLINTEGER
*)appParamDesc
->indPtr_
) == SQL_NULL_DATA
)
726 fsqlStmt_
->setNull(paramNum
);
730 //Only if both types are not the same, then we need to copy it onto intermediate buffer
732 if( (sourceType
== typeString
|| sourceType
== typeBinary
) && (sourceLength
<= 0))
734 if((appParamDesc
->indPtr_
!= NULL
) && *(SQLINTEGER
*)appParamDesc
->indPtr_
> 0)
735 sourceLength
=(int)(*(SQLINTEGER
*)appParamDesc
->indPtr_
);
736 else if (appParamDesc
->precision_
> 0)
737 sourceLength
=appParamDesc
->precision_
;
740 err_
.set( ERROR_BUFLEN
);
744 if(destType
== typeString
) //|| destType == typeVarString)
746 //fsqlStmt_->allocParam(paramNum,sourceLength); // CSQL TODO
747 destLength
=sourceLength
;
749 if(sourceType
== destType
)
750 //|| (sourceType == typeString && destType == typeVarString)
751 //|| (sourceType == typeBinary && destType == typeVarBinary))
753 copyFromOdbc(fsqlStmt_
, paramNum
, destLength
, appParamDesc
->dataPtr_
, sourceLength
,destType
); // CSQL TODO
756 getInputBuffer(&csqlParamDesc
->dataPtr_
,destType
,destLength
);
757 AllDataType::convert(sourceType
,appParamDesc
->dataPtr_
,destType
,csqlParamDesc
->dataPtr_
, destLength
);
758 copyFromOdbc(fsqlStmt_
, paramNum
, destLength
, csqlParamDesc
->dataPtr_
, destLength
, destType
);
764 err_
.set(ERROR_GENERAL
);
775 DbRetVal rv
= fsqlStmt_
->execute( rowsAffected
);
777 if( rowsAffected
< 0 || rv
!=OK
)
779 if( isPrepared_
) state_
= S2
; else resetStmt();
780 err_
.set( ERROR_GENERAL
);
783 case csqlSqlErrOverflow:err_.set(ERROR_OVERFLOW);break;
784 case csqlSqlErrUnderflow:err_.set(ERROR_UNDERFLOW);break;
785 case csqlSqlErrTooManyTpl:err_.set(ERROR_MANY_TUP);break;
786 case csqlSqlErrProjCnt:err_.set(ERROR_NUM_PROJ);break;
787 case csqlSqlErrStorageAttr:err_.set(ERROR_STORAGE_ATTR);break;
788 case csqlSqlErrFldCntMismatch:err_.set(ERROR_FLDCNT_MISMATCH);break;
789 case csqlSqlErrSqlInternal:err_.set(ERROR_SQL_INT);break;
790 case csqlSqlErrNoMatchKeyFound:err_.set(ERROR_MATCHKEY_NOTFOUND);break;
792 err_.set( ERROR_GENERAL );break;
798 if( fsqlStmt_
->isSelect() == true )
805 rowsAffected_
= rowsAffected
;
809 // Set Dbc State to Transaction Mode.
810 parentDbc_
->state_
= C6
;
813 if( parentDbc_
->autoCommit_
== SQL_AUTOCOMMIT_ON
)
814 parentDbc_
->SQLEndTran( SQL_COMMIT
);
816 return( SQL_SUCCESS
);
819 SQLRETURN SQLExecDirect(
820 SQLHSTMT StatementHandle,
821 SQLCHAR *StatementText,
822 SQLINTEGER TextLength)
825 printError(ErrWarning, "SQLExecDirect");
829 if( isValidHandle( (CSqlOdbcStmt*) StatementHandle, SQL_HANDLE_STMT ) != SQL_SUCCESS )
830 return( SQL_INVALID_HANDLE );
832 return( ((CSqlOdbcStmt*) StatementHandle)->SQLExecDirect( StatementText, TextLength ) );
835 SQLRETURN CSqlOdbcStmt::SQLExecDirect(
836 SQLCHAR *statementText,
837 SQLINTEGER textLength)
842 if( chkStateForSQLExecDirect() != SQL_SUCCESS )
845 // SQLExecDirect = SQLPrepare + SQLExecute.
846 if( SQLPrepare( statementText, textLength ) != SQL_SUCCESS )
850 isPrepared_ = false; // Set Stmt as non-prepared stmt.
852 if( ret != SQL_SUCCESS )
855 return( SQL_SUCCESS );
858 SQLRETURN
SQLSetStmtOption(
859 SQLHSTMT StatementHandle
,
864 printError(ErrWarning
, "SQLSetStmtOption");
867 return (SQLSetStmtAttr(StatementHandle
, Option
, (SQLPOINTER
) Value
, 0));
870 SQLRETURN SQL_API
SQLSetStmtAttr(SQLHSTMT StatementHandle
,
871 SQLINTEGER Attribute
, SQLPOINTER Value
,
872 SQLINTEGER StringLength
)
875 printError(ErrWarning
, "SQLSetStmtAttr");
878 return (((CSqlOdbcStmt
*)StatementHandle
)->SQLSetStmtAttr(Attribute
, Value
,StringLength
));
881 SQLRETURN
CSqlOdbcStmt::SQLSetStmtAttr(
882 SQLINTEGER Attribute
,
884 SQLINTEGER stringLength
)
886 CSqlOdbcError::printDbg("proxy:stmt:SQLSetStmtAttr");
890 //Values: SQL_FETCH_SINGLE_TUPLE or SQL_FETCH_MULTIPLE_TUPLES
891 //Default is SQL_FETCH_SINGLE_TUPLE.
892 //In SQL_FETCH_SINGLE_TUPLE mode, only a single tuple
893 //is sent from server to client in a single packet whatever be
894 //the packet size. If a tuple size is 50 and network packet size
895 //is 500, the remaining 450 bytes can also be used to send more
896 //in a single packet so that in the next SQLFetch call one network
897 //packet transfer overhead is reduced.
900 //state_ > S5 means Fetch has already started on this statement.
901 fetchMode_ = (SQLINTEGER)Value;
903 printf("ODBC:Error in setting fetch mode, can't set after fetch is started.\n");
906 printf("ODBC: Error, Stmt Option %d is not supported.\n", Attribute);
908 return (SQL_SUCCESS
);
911 SQLRETURN
SQLFetch(SQLHSTMT StatementHandle
)
914 printError(ErrWarning
, "SQLFetch");
918 if( isValidHandle( (CSqlOdbcStmt
*) StatementHandle
, SQL_HANDLE_STMT
) != SQL_SUCCESS
)
919 return( SQL_INVALID_HANDLE
);
921 return( ((CSqlOdbcStmt
*) StatementHandle
)->SQLFetch() );
924 SQLRETURN
CSqlOdbcStmt::SQLFetch()
930 if( chkStateForSQLFetch() != SQL_SUCCESS
)
934 tuple
= fsqlStmt_
->next();
936 if( ! tuple
) // IF Row not found.
940 return( SQL_NO_DATA_FOUND
);
942 /*else if( rowsAffected != SQL_SUCCESS ) // IF Error
945 err_.set( ERROR_GENERAL );
948 else // IF Row found.
951 if (ard_
.descList_
.size() > 0) {
952 // Iterate through all ard_;
953 CSqlOdbcDesc
*appColDesc
;
954 ListIterator ardIter
= ard_
.descList_
.getIterator();
955 //Get the input parameter data
956 CSqlOdbcDesc
*csqlColDesc
;
957 ListIterator irdIter
= ird_
.descList_
.getIterator();
959 DataType sourceType
= typeUnknown
,destType
= typeUnknown
;
960 int colNum
=-1,sourceLength
=-1,destLength
=-1;
962 void* sourceData
= NULL
;
963 while(ardIter
.hasElement() || irdIter
.hasElement()) {
964 appColDesc
= (CSqlOdbcDesc
*) ardIter
.nextElement();
965 csqlColDesc
= (CSqlOdbcDesc
*) irdIter
.nextElement();
967 colNum
= appColDesc
->col_
- 1;
968 sourceType
= (DataType
)csqlColDesc
->cType_
;
969 destType
= getCSqlType(appColDesc
->cType_
);
970 sourceLength
= (int)csqlColDesc
->length_
;
971 destLength
= (int)appColDesc
->length_
;
972 if( sourceType
!= typeUnknown
&& destType
!= typeUnknown
)
974 sourceData
= fsqlStmt_
->getFieldValuePtr( colNum
);
975 if(fsqlStmt_
->isFldNull((char*)csqlColDesc
->colName_
) ||
978 if (appColDesc
->indPtr_
!= NULL
)
979 *((SQLINTEGER
*)(appColDesc
->indPtr_
))=SQL_NULL_DATA
;
983 /*if( sourceType == csqlSqlTvarBinary)
984 sourceLength=resultSet_->getDataLength(colNum); */
985 if (sourceType
== typeString
) // CSQL TODO - handle varchar also
987 sourceLength
=(int)(strlen((char *) sourceData
));
988 if(appColDesc
->indPtr_
!= NULL
)
989 *((SQLINTEGER
*)(appColDesc
->indPtr_
))=copyToOdbc(appColDesc
->dataPtr_
,destLength
,
990 sourceData
,sourceLength
, sourceType
, destType
);
992 copyToOdbc(appColDesc
->dataPtr_
,destLength
,sourceData
,
993 sourceLength
, sourceType
, destType
);
997 //convert(sourceType,sourceData,destType, csqlColDesc->dataPtr_,sourceLength,destLength);
998 if(appColDesc
->indPtr_
!= NULL
){
999 *((SQLINTEGER
*)(appColDesc
->indPtr_
))=
1000 copyToOdbc(appColDesc
->dataPtr_
,destLength
, sourceData
, sourceLength
, sourceType
, destType
);
1003 copyToOdbc(appColDesc
->dataPtr_
,destLength
, sourceData
, sourceLength
, sourceType
,destType
);
1006 // CSQL TODO - handle varstring, binary, varbinary
1007 if( sourceType
== typeString
&& sourceLength
> destLength
)
1008 err_
.set( ERROR_DATATRUNC
);
1015 if(err_
.csqlErrCode
== ERROR_DATATRUNC
)
1016 return (SQL_SUCCESS_WITH_INFO
);
1018 return( SQL_SUCCESS
);
1021 SQLRETURN
SQLCloseCursor(SQLHSTMT StatementHandle
)
1024 printError(ErrWarning
, "SQLCloseCursor");
1027 if( isValidHandle( (CSqlOdbcStmt
*) StatementHandle
, SQL_HANDLE_STMT
) != SQL_SUCCESS
)
1028 return( SQL_INVALID_HANDLE
);
1030 return( ((CSqlOdbcStmt
*) StatementHandle
)->SQLCloseCursor() );
1033 SQLRETURN
CSqlOdbcStmt::SQLCloseCursor()
1035 // Start with NO_ERR
1039 if( chkStateForSQLCloseCursor() != SQL_SUCCESS
)
1040 return( SQL_ERROR
);
1045 return( SQL_SUCCESS
);
1048 SQLRETURN
SQLSetCursorName(
1049 SQLHSTMT StatementHandle
,
1050 SQLCHAR
*CursorName
,
1051 SQLSMALLINT NameLength
)
1054 printError(ErrWarning
, "SQLSetCursorName");
1057 if( isValidHandle( (CSqlOdbcStmt
*) StatementHandle
, SQL_HANDLE_STMT
) != SQL_SUCCESS
)
1058 return( SQL_INVALID_HANDLE
);
1060 return( ((CSqlOdbcStmt
*) StatementHandle
)->SQLSetCursorName( CursorName
, NameLength
) );
1063 SQLRETURN
CSqlOdbcStmt::SQLSetCursorName(
1064 SQLCHAR
*cursorName
,
1065 SQLSMALLINT nameLength
)
1067 // Start with NO_ERR
1071 if( chkStateForSQLSetCursorName() != SQL_SUCCESS
)
1072 return( SQL_ERROR
);
1074 // Invalid Stmt Length.
1075 if( nameLength
< 0 && nameLength
!= SQL_NTS
)
1077 err_
.set( ERROR_INVARGVAL
);
1078 return( SQL_ERROR
);
1081 // Validate Parameters
1082 if( cursorName
== 0 || cursorName
[0] == '\0' || strlen( (char*) cursorName
) > SQL_MAX_CURSOR_NAME_LEN
||
1083 nameLength
> SQL_MAX_CURSOR_NAME_LEN
)
1085 err_
.set( ERROR_CURNAME
);
1086 return( SQL_ERROR
);
1089 // Check for duplicate Name
1090 ListIterator iter
= parentDbc_
->stmtList_
.getIterator();
1091 CSqlOdbcStmt
*stmtElem
= NULL
;
1092 while (iter
.hasElement()) {
1093 stmtElem
= (CSqlOdbcStmt
*) iter
.nextElement();
1094 if(stmtElem
!= this ) {
1095 if( strcmp((char*)cursorName
, (char*)stmtElem
->cursorName_
) == 0) {
1096 err_
.set( ERROR_DUP_CURNAME
);
1097 return( SQL_ERROR
);
1102 strcpy( (char*) cursorName_
, (char*) cursorName
);
1103 return( SQL_SUCCESS
);
1106 SQLRETURN
SQLGetCursorName(
1107 SQLHSTMT StatementHandle
,
1108 SQLCHAR
*CursorName
,
1109 SQLSMALLINT BufferLength
,
1110 SQLSMALLINT
*NameLength
)
1113 printError(ErrWarning
, "SQLGetCursorName");
1117 if( isValidHandle( (CSqlOdbcStmt
*) StatementHandle
, SQL_HANDLE_STMT
) != SQL_SUCCESS
)
1118 return( SQL_INVALID_HANDLE
);
1120 return( ((CSqlOdbcStmt
*) StatementHandle
)->SQLGetCursorName( CursorName
, BufferLength
, NameLength
) );
1122 SQLRETURN
CSqlOdbcStmt::SQLGetCursorName(
1123 SQLCHAR
*cursorName
,
1124 SQLSMALLINT bufferLength
,
1125 SQLSMALLINT
*nameLength
)
1128 if( chkStateForSQLGetCursorName() != SQL_SUCCESS
)
1129 return( SQL_ERROR
);
1131 if( cursorName_
[0] == '\0' )
1133 err_
.set( ERROR_NOCURNAME
);
1134 return( SQL_ERROR
);
1138 *nameLength
= (short)strlen( (char*) cursorName_
);
1139 if( *nameLength
> bufferLength
) *nameLength
= bufferLength
;
1140 strncpy( (char*) cursorName
, (char*) cursorName_
, *nameLength
);
1141 cursorName
[ *nameLength
] = '\0';
1144 if( bufferLength
< strlen( (char*) cursorName_
) )
1146 err_
.set( ERROR_DATATRUNC
);
1147 return( SQL_SUCCESS_WITH_INFO
);
1150 return( SQL_SUCCESS
);
1153 SQLRETURN
SQLNumResultCols(
1154 SQLHSTMT StatementHandle
, // IN
1155 SQLSMALLINT
*ColumnCount
) // OUT
1158 printError(ErrWarning
, "SQLNumResultCols");
1162 if( isValidHandle( (CSqlOdbcStmt
*) StatementHandle
, SQL_HANDLE_STMT
) != SQL_SUCCESS
)
1163 return( SQL_INVALID_HANDLE
);
1165 return( ((CSqlOdbcStmt
*) StatementHandle
)->SQLNumResultCols( ColumnCount
) );
1168 SQLRETURN
CSqlOdbcStmt::SQLNumResultCols(
1169 SQLSMALLINT
*columnCount
) // OUT
1171 // Start with NO_ERR
1174 if( chkStateForSQLNumResultCols() != SQL_SUCCESS
)
1175 return( SQL_ERROR
);
1178 if( fsqlStmt_
->isSelect() == false )
1181 return (SQL_SUCCESS
);
1183 ResultSetPlan pl
= fsqlStmt_
->getResultSetPlan();
1186 *columnCount
=getNumResultset(pl
);
1187 return( SQL_SUCCESS
);
1190 SQLSMALLINT count
= fsqlStmt_
->noOfProjFields();
1191 if( count
< 1 ) // Assume atleast one column is projected
1192 return( SQL_ERROR
);
1194 // Fill Column Count
1195 *columnCount
= count
;
1197 return( SQL_SUCCESS
);
1200 SQLRETURN SQL_API
SQLRowCount(
1201 SQLHSTMT StatementHandle
, // IN
1202 SQLINTEGER
*RowCount
) // OUT
1205 printError(ErrWarning
, "SQLRowCount");
1209 if( isValidHandle( (CSqlOdbcStmt
*) StatementHandle
, SQL_HANDLE_STMT
) != SQL_SUCCESS
)
1210 return( SQL_INVALID_HANDLE
);
1212 return( ((CSqlOdbcStmt
*) StatementHandle
)->SQLRowCount( RowCount
) );
1215 SQLRETURN
CSqlOdbcStmt::SQLRowCount(
1216 SQLINTEGER
*rowCount
) // OUT
1218 // Start with NO_ERR
1222 if( chkStateForSQLRowCount() != SQL_SUCCESS
)
1223 return( SQL_ERROR
);
1225 if(rowCount
== NULL
)
1228 if( state_
== S4
) // For INSERT/DELETE/UPDATE
1229 *rowCount
= (SQLINTEGER
) rowsAffected_
;
1230 else if( state_
== S5
) // For SELECT before SQLFetch()
1232 *rowCount
= (SQLINTEGER
) 0;
1233 // CSQL TODO - Think if you really want to do this!!!
1235 /*CSqlOdbcError::printDbg("proxy:stmt:getResultSet");
1236 CSqlResultSet *resultSet_ = fsqlStmt_.getResultSet();
1237 if( resultSet_->next() != csqlSqlErrNoTuple )
1238 *rowCount = (SQLINTEGER) 1;
1240 resultSet_->close();
1241 resultSet_->open(); */
1243 else if( state_
== S6
) // For SELECT after SQLFetch();
1244 *rowCount
= (SQLINTEGER
) rowsAffected_
;
1246 return( SQL_SUCCESS
);
1249 SQLRETURN
SQLDescribeCol(
1250 SQLHSTMT StatementHandle
,
1251 SQLUSMALLINT ColumnNumber
,
1252 SQLCHAR
*ColumnName
,
1253 SQLSMALLINT BufferLength
,
1254 SQLSMALLINT
*NameLength
,
1255 SQLSMALLINT
*DataType
,
1256 SQLUINTEGER
*ColumnSize
,
1257 SQLSMALLINT
*DecimalDigits
,
1258 SQLSMALLINT
*Nullable
)
1261 printError(ErrWarning
, "SQLDescribeCol");
1265 if( isValidHandle( (CSqlOdbcStmt
*) StatementHandle
, SQL_HANDLE_STMT
) != SQL_SUCCESS
)
1266 return( SQL_INVALID_HANDLE
);
1268 return( ((CSqlOdbcStmt
*) StatementHandle
)->SQLDescribeCol( ColumnNumber
, ColumnName
, BufferLength
,
1269 NameLength
, DataType
, ColumnSize
, DecimalDigits
, Nullable
) );
1272 SQLRETURN
CSqlOdbcStmt::SQLDescribeCol(
1273 SQLUSMALLINT columnNumber
,
1274 SQLCHAR
*columnName
,
1275 SQLSMALLINT bufferLength
,
1276 SQLSMALLINT
*nameLength
,
1277 SQLSMALLINT
*dataType
,
1278 SQLUINTEGER
*columnSize
,
1279 SQLSMALLINT
*decimalDigits
,
1280 SQLSMALLINT
*nullable
)
1288 // Start with NO_ERR
1292 if( chkStateForSQLDescribeCol() != SQL_SUCCESS
)
1293 return( SQL_ERROR
);
1295 if( columnNumber
< 1 )
1297 err_
.set( ERROR_COLNUM
);
1298 return( SQL_ERROR
);
1301 if(columnName
== NULL
) {
1302 err_
.set( ERROR_COLNUM
);
1303 return( SQL_ERROR
);
1305 DbRetVal rv
= fsqlStmt_
->getProjFldInfo(columnNumber
, fInfo
);
1307 err_
.set( ERROR_COLNUM
);
1308 return( SQL_ERROR
);
1310 Table::getFieldNameAlone((char*)fInfo
->fldName
, (char*)columnName
);
1311 if (bufferLength
<IDENTIFIER_LENGTH
) {
1312 strncpy( (char*)columnName
, (char*)fInfo
->fldName
, bufferLength
);
1313 columnName
[bufferLength
-1] ='\0';
1315 strcpy( (char*)columnName
, (char*)fInfo
->fldName
);
1318 if(nameLength
!= NULL
)
1319 *nameLength
=(short)strlen((const char*)columnName
); // HARDCODED - TO DO, need support for n/w layer & sql layer
1320 if(dataType
!= NULL
)
1321 *dataType
= (SQLSMALLINT
) getSQLType(fInfo
->type
); // Need to convert from SQL<->ODBC - TO DO
1322 if(columnSize
!= NULL
)
1324 *columnSize
= (SQLUINTEGER
) fInfo
->length
;
1325 SQLSMALLINT sqlType
=getSQLType(fInfo
->type
);
1326 if(sqlType
== SQL_CHAR
)
1327 *columnSize
= *columnSize
-1;
1330 /*if(decimalDigits != NULL) // CSQL TODO
1331 *decimalDigits = (SQLSMALLINT) fsqlStmt_->getPrecision( columnNumber-1 );*/
1334 *nullable
= SQL_NO_NULLS
;
1336 *nullable
= SQL_NULLABLE
;
1337 if(strlen((char*)fInfo
->fldName
) > bufferLength
)
1339 err_
.set( ERROR_DATATRUNC
);
1340 return( SQL_SUCCESS_WITH_INFO
);
1342 return( SQL_SUCCESS
);
1345 SQLRETURN
SQLColAttributes(
1346 SQLHSTMT StatementHandle
,
1347 SQLUSMALLINT ColumnNumber
,
1348 SQLUSMALLINT FieldIdentifier
,
1349 SQLPOINTER CharacterAttributePtr
,
1350 SQLSMALLINT BufferLength
,
1351 SQLSMALLINT
*StringLengthPtr
,
1352 SQLINTEGER
*NumericAttributePtr
)
1355 printError(ErrWarning
, "SQLColAttributes");
1359 if( isValidHandle( (CSqlOdbcStmt
*) StatementHandle
, SQL_HANDLE_STMT
) != SQL_SUCCESS
)
1360 return( SQL_INVALID_HANDLE
);
1362 return( ((CSqlOdbcStmt
*) StatementHandle
)->SQLColAttribute(ColumnNumber
,FieldIdentifier
,
1363 CharacterAttributePtr
, BufferLength
, StringLengthPtr
, (SQLPOINTER
)NumericAttributePtr
) );
1366 SQLRETURN
SQLColAttribute(
1367 SQLHSTMT StatementHandle
,
1368 SQLUSMALLINT ColumnNumber
,
1369 SQLUSMALLINT FieldIdentifier
,
1370 SQLPOINTER CharacterAttributePtr
,
1371 SQLSMALLINT BufferLength
,
1372 SQLSMALLINT
* StringLengthPtr
,
1373 SQLPOINTER NumericAttributePtr
)
1376 printError(ErrWarning
, "SQLColAttribute");
1380 if( isValidHandle( (CSqlOdbcStmt
*) StatementHandle
, SQL_HANDLE_STMT
) != SQL_SUCCESS
)
1381 return( SQL_INVALID_HANDLE
);
1383 return( ((CSqlOdbcStmt
*) StatementHandle
)->SQLColAttribute(ColumnNumber
,FieldIdentifier
,
1384 CharacterAttributePtr
, BufferLength
, StringLengthPtr
, NumericAttributePtr
) );
1387 SQLRETURN
CSqlOdbcStmt::SQLColAttribute(
1388 SQLUSMALLINT columnNumber
,
1389 SQLUSMALLINT fieldIdentifier
,
1390 SQLPOINTER characterAttributePtr
,
1391 SQLSMALLINT bufferLength
,
1392 SQLSMALLINT
* stringLengthPtr
,
1393 SQLPOINTER numericAttributePtr
)
1401 // Start with NO_ERR
1405 if( chkStateForSQLDescribeCol() != SQL_SUCCESS
)
1406 return( SQL_ERROR
);
1408 if( columnNumber
< 1 )
1410 err_
.set( ERROR_COLNUM
);
1411 return( SQL_ERROR
);
1414 if( fsqlStmt_
->isSelect() == false )
1415 return( SQL_ERROR
);
1417 fsqlStmt_
->getProjFldInfo(columnNumber
, fInfo
);
1420 if(columnNumber
> fsqlStmt_
->noOfProjFields())
1422 err_
.set( ERROR_COLNUM
);
1423 return( SQL_ERROR
);
1426 switch(fieldIdentifier
)
1429 case SQL_COLUMN_LABEL
:
1430 case SQL_COLUMN_NAME
:
1431 if(characterAttributePtr
!= NULL
)
1433 strncpy( (char*)characterAttributePtr
, (char*)fInfo
->fldName
, bufferLength
);
1434 if(stringLengthPtr
!= NULL
)
1435 *stringLengthPtr
=(short)strlen((char*)fInfo
->fldName
);
1438 case SQL_DESC_COUNT
:
1439 case SQL_COLUMN_COUNT
:
1440 if(numericAttributePtr
!= NULL
)
1441 *(SQLINTEGER
*)numericAttributePtr
=fsqlStmt_
->noOfProjFields();
1444 case SQL_COLUMN_TYPE
:
1445 if(numericAttributePtr
!= NULL
)
1446 *(SQLINTEGER
*)numericAttributePtr
=getSQLType(fInfo
->type
);
1448 case SQL_DESC_LENGTH
:
1449 case SQL_COLUMN_LENGTH
:
1450 if(numericAttributePtr
!= NULL
)
1452 SQLSMALLINT sqlType
=getSQLType(fInfo
->type
);
1453 *(SQLINTEGER
*)numericAttributePtr
=(SQLUINTEGER
) fInfo
->length
;
1454 if(sqlType
== SQL_CHAR
)
1455 *(SQLINTEGER
*)numericAttributePtr
=*(SQLINTEGER
*)numericAttributePtr
-1;
1458 case SQL_DESC_PRECISION
:
1459 case SQL_COLUMN_PRECISION
:
1460 /*if(numericAttributePtr != NULL) // CSQL TODO
1461 *(SQLINTEGER *)numericAttributePtr=(SQLSMALLINT) rsMetaData->getPrecision( columnNumber-1 ); */
1463 case SQL_DESC_SCALE
:
1464 case SQL_COLUMN_SCALE
:
1465 /*if(numericAttributePtr != NULL) // CSQL TODO
1466 *(SQLINTEGER*)numericAttributePtr=(SQLSMALLINT) rsMetaData->getScale( columnNumber-1 );*/
1468 case SQL_DESC_NULLABLE
:
1469 case SQL_COLUMN_NULLABLE
:
1470 /*if(numericAttributePtr != NULL) // CSQL TODO
1471 *(SQLINTEGER*)numericAttributePtr=(SQLSMALLINT) rsMetaData->isNullable( columnNumber-1 )?SQL_NULLABLE_N:SQL_NO_NULLS_N;*/
1473 case SQL_DESC_UNSIGNED
:
1474 if(numericAttributePtr
!= NULL
)
1476 SQLSMALLINT sqlType
=getSQLType(fInfo
->type
);
1477 if((sqlType
!= SQL_TIME
) && (sqlType
!= SQL_DATE
) && (sqlType
!= SQL_TIMESTAMP
)
1478 && (sqlType
!= SQL_CHAR
) && (sqlType
!= SQL_VARCHAR
) && (sqlType
!= SQL_BINARY
)
1479 && (sqlType
!= SQL_VARBINARY
) && (sqlType
!= SQL_BIT
))
1480 *(SQLINTEGER
*)numericAttributePtr
=SQL_FALSE
;
1482 *(SQLINTEGER
*)numericAttributePtr
=SQL_TRUE
;
1485 case SQL_DESC_FIXED_PREC_SCALE
:
1486 if(numericAttributePtr
!= NULL
)
1487 *(SQLINTEGER
*)numericAttributePtr
=SQL_FALSE
;
1489 case SQL_DESC_TYPE_NAME
:
1490 if(characterAttributePtr
!= NULL
)
1492 SQLSMALLINT sqlType
=getSQLType(fInfo
->type
);
1493 strncpy((char*)characterAttributePtr
,(char *)(getSQLTypeName(sqlType
)),bufferLength
);
1494 if(stringLengthPtr
!= NULL
)
1495 *stringLengthPtr
=(int)strlen((char *)getSQLTypeName(sqlType
));
1498 case SQL_DESC_UPDATABLE
:
1499 if(numericAttributePtr
!= NULL
)
1500 *(SQLINTEGER
*)numericAttributePtr
=SQL_ATTR_READWRITE_UNKNOWN
;
1502 case SQL_DESC_AUTO_UNIQUE_VALUE
:
1503 if(numericAttributePtr
!= NULL
)
1504 *(SQLINTEGER
*)numericAttributePtr
=SQL_FALSE
;
1506 case SQL_DESC_CASE_SENSITIVE
:
1507 if(numericAttributePtr
!= NULL
)
1509 SQLSMALLINT sqlType
=getSQLType(fInfo
->type
);
1510 if((sqlType
!= SQL_CHAR
) && (sqlType
!= SQL_VARCHAR
))
1511 *(SQLINTEGER
*)numericAttributePtr
=SQL_FALSE
;
1513 *(SQLINTEGER
*)numericAttributePtr
=SQL_TRUE
;
1516 case SQL_DESC_SEARCHABLE
:
1517 if(numericAttributePtr
!= NULL
)
1519 SQLSMALLINT sqlType
=getSQLType(fInfo
->type
);
1520 if((sqlType
!= SQL_CHAR
) && (sqlType
!= SQL_VARCHAR
))
1521 *(SQLINTEGER
*)numericAttributePtr
=SQL_PRED_BASIC
;
1523 *(SQLINTEGER
*)numericAttributePtr
=SQL_PRED_SEARCHABLE
;
1526 case SQL_COLUMN_DISPLAY_SIZE
: {
1527 SQLSMALLINT sqlType
=getSQLType(fInfo
->type
);
1528 if(numericAttributePtr
!= NULL
) {
1529 if(sqlType
== SQL_CHAR
|| sqlType
== SQL_BINARY
)
1530 *(SQLINTEGER
*)numericAttributePtr
=fInfo
->length
;
1532 *(SQLINTEGER
*)numericAttributePtr
=20;
1539 if(stringLengthPtr
!= NULL
)
1541 if(*stringLengthPtr
> bufferLength
)
1543 err_
.set( ERROR_DATATRUNC
);
1544 return( SQL_SUCCESS_WITH_INFO
);
1547 return( SQL_SUCCESS
);
1550 SQLRETURN
SQLNumParams(
1551 SQLHSTMT StatementHandle
,
1552 SQLSMALLINT
* ParameterCountPtr
)
1555 printError(ErrWarning
, "SQLNumParams");
1559 if( isValidHandle( (CSqlOdbcStmt
*) StatementHandle
, SQL_HANDLE_STMT
) != SQL_SUCCESS
)
1560 return( SQL_INVALID_HANDLE
);
1562 return( ((CSqlOdbcStmt
*) StatementHandle
)->SQLNumParams(ParameterCountPtr
) );
1565 SQLRETURN
CSqlOdbcStmt::SQLNumParams(
1566 SQLSMALLINT
* ParameterCount
)
1568 // Start with NO_ERR
1571 if( chkStateForSQLNumParams() != SQL_SUCCESS
)
1572 return( SQL_ERROR
);
1573 if(ParameterCount
== NULL
)
1575 *ParameterCount
=fsqlStmt_
->noOfParamFields();
1580 SQLRETURN
SQLDescribeParam(
1581 SQLHSTMT StatementHandle
,
1582 SQLUSMALLINT ParameterNumber
,
1583 SQLSMALLINT
* DataTypePtr
,
1584 SQLUINTEGER
* ParameterSizePtr
,
1585 SQLSMALLINT
* DecimalDigitsPtr
,
1586 SQLSMALLINT
* NullablePtr
)
1589 printError(ErrWarning
, "SQLDescribeParam");
1593 if( isValidHandle( (CSqlOdbcStmt
*) StatementHandle
, SQL_HANDLE_STMT
) != SQL_SUCCESS
)
1594 return( SQL_INVALID_HANDLE
);
1596 return( ((CSqlOdbcStmt
*) StatementHandle
)->SQLDescribeParam(ParameterNumber
,DataTypePtr
,
1597 ParameterSizePtr
,DecimalDigitsPtr
,NullablePtr
) );
1599 SQLRETURN
CSqlOdbcStmt::SQLDescribeParam(
1600 SQLUSMALLINT paramNumber
,
1601 SQLSMALLINT
* dataType
,
1602 SQLUINTEGER
* paramSize
,
1603 SQLSMALLINT
* decimalDigits
,
1604 SQLSMALLINT
* isNullable
)
1607 // Start with NO_ERR
1611 if( chkStateForSQLDescribeParam() != SQL_SUCCESS
)
1612 return( SQL_ERROR
);
1614 if( paramNumber
< 1 )
1616 err_
.set( ERROR_PARAMNUM
);
1617 return( SQL_ERROR
);
1620 //CSqlOdbcError::printDbg("proxy:stmt:getMetaData");
1621 //CSqlParamMetaData *paramMetaData = fsqlStmt_->getParamMetaData();
1622 if(paramNumber
> fsqlStmt_
->noOfParamFields())
1624 err_
.set( ERROR_PARAMNUM
);
1625 return( SQL_ERROR
);
1628 if( fsqlStmt_
->getParamFldInfo( paramNumber
, fInfo
) != OK
) {
1629 return( SQL_ERROR
);
1631 if(dataType
!= NULL
)
1632 *dataType
= (SQLSMALLINT
) getSQLType(fInfo
->type
);
1633 if(paramSize
!= NULL
)
1635 *paramSize
= (SQLUINTEGER
) fInfo
->length
;
1636 SQLSMALLINT sqlType
=getSQLType(fInfo
->type
);
1637 if(sqlType
== SQL_CHAR
)
1638 *paramSize
= *paramSize
-1;
1640 /*if(decimalDigits != NULL) // CSQL TODO
1641 *decimalDigits = (SQLSMALLINT) paramMetaData->getPrecision( paramNumber-1 );*/
1644 *isNullable
= SQL_NO_NULLS
;
1646 *isNullable
= SQL_NULLABLE
;
1648 return( SQL_SUCCESS
);
1651 // Resets the Stmt to initial state. As if newly allocated.
1652 void CSqlOdbcStmt::resetStmt( void ) // TO DO
1654 SQLFreeStmt( SQL_CLOSE
);
1655 SQLFreeStmt( SQL_UNBIND
);
1656 SQLFreeStmt( SQL_RESET_PARAMS
);
1657 if (fsqlStmt_
) { fsqlStmt_
->free(); delete fsqlStmt_
; fsqlStmt_
= NULL
; }
1658 isPrepared_
= false;
1662 SQLRETURN
SQLTables(
1663 SQLHSTMT StatementHandle
,
1664 SQLCHAR
* CatalogName
,
1665 SQLSMALLINT NameLength1
,
1666 SQLCHAR
* SchemaName
,
1667 SQLSMALLINT NameLength2
,
1668 SQLCHAR
* TableName
,
1669 SQLSMALLINT NameLength3
,
1670 SQLCHAR
* TableType
,
1671 SQLSMALLINT NameLength4
)
1674 printError(ErrWarning
, "SQLTables");
1677 if( isValidHandle( (CSqlOdbcStmt
*) StatementHandle
, SQL_HANDLE_STMT
) != SQL_SUCCESS
)
1678 return( SQL_INVALID_HANDLE
);
1680 return( ((CSqlOdbcStmt
*) StatementHandle
)->SQLTables(CatalogName
,SchemaName
,TableName
,TableType
) );
1683 SQLRETURN
CSqlOdbcStmt::SQLTables(
1684 SQLCHAR
* CatalogName
,
1685 SQLCHAR
* SchemaName
,
1686 SQLCHAR
* TableName
,
1687 SQLCHAR
* TableType
)
1689 // Start with NO_ERR
1691 SQLRETURN ret
= SQL_SUCCESS
;
1692 ret
= SQLPrepare((SQLCHAR
*)"GetAllTables", strlen("GetAllTables"));
1693 if( ret
!= SQL_SUCCESS
) return (ret
);
1695 if( ret
!= SQL_SUCCESS
) return (ret
);
1696 return( SQL_SUCCESS
);
1700 SQLRETURN
SQLColumns(
1701 SQLHSTMT StatementHandle
,
1702 SQLCHAR
* CatalogName
,
1703 SQLSMALLINT NameLength1
,
1704 SQLCHAR
* SchemaName
,
1705 SQLSMALLINT NameLength2
,
1706 SQLCHAR
* TableName
,
1707 SQLSMALLINT NameLength3
,
1708 SQLCHAR
* ColumnName
,
1709 SQLSMALLINT NameLength4
)
1712 printError(ErrWarning
, "SQLColumns");
1715 if( isValidHandle( (CSqlOdbcStmt
*) StatementHandle
, SQL_HANDLE_STMT
) != SQL_SUCCESS
)
1716 return( SQL_INVALID_HANDLE
);
1718 return( ((CSqlOdbcStmt
*) StatementHandle
)->SQLColumns(CatalogName
,SchemaName
,TableName
,ColumnName
) );
1722 SQLRETURN
CSqlOdbcStmt::SQLColumns(
1723 SQLCHAR
* CatalogName
,
1724 SQLCHAR
* SchemaName
,
1725 SQLCHAR
* TableName
,
1726 SQLCHAR
* ColumnName
)
1728 SQLRETURN ret
= SQL_SUCCESS
;
1729 char str
[256]="describe ";
1730 strcat(str
,(char*)TableName
);
1731 ret
= SQLPrepare((SQLCHAR
*)str
, strlen(str
));
1732 if( ret
!= SQL_SUCCESS
) return (ret
);
1734 if( ret
!= SQL_SUCCESS
) return (ret
);
1735 return( SQL_SUCCESS
);
1738 SQLRETURN
SQLPrimaryKeys(
1739 SQLHSTMT StatementHandle
,
1740 SQLCHAR
* CatalogName
,
1741 SQLSMALLINT NameLength1
,
1742 SQLCHAR
* SchemaName
,
1743 SQLSMALLINT NameLength2
,
1744 SQLCHAR
* TableName
,
1745 SQLSMALLINT NameLength3
)
1748 printError(ErrWarning
, "SQLPrimaryKeys");
1751 if( isValidHandle( (CSqlOdbcStmt
*) StatementHandle
, SQL_HANDLE_STMT
) != SQL_SUCCESS
)
1752 return( SQL_INVALID_HANDLE
);
1754 return( ((CSqlOdbcStmt
*) StatementHandle
)->SQLPrimaryKeys(CatalogName
,SchemaName
,TableName
) );
1757 SQLRETURN
CSqlOdbcStmt::SQLPrimaryKeys(
1758 SQLCHAR
* CatalogName
,
1759 SQLCHAR
* SchemaName
,
1760 SQLCHAR
* TableName
)
1762 SQLRETURN ret
= SQL_SUCCESS
;
1763 char str
[256]="getprimarykey ";
1764 strcat(str
,(char*)TableName
);
1765 ret
= SQLPrepare((SQLCHAR
*)str
, strlen(str
));
1766 if( ret
!= SQL_SUCCESS
) return (ret
);
1768 if( ret
!= SQL_SUCCESS
) return (ret
);
1769 return( SQL_SUCCESS
);
1772 int CSqlOdbcStmt::getNumResultset(ResultSetPlan plan
)
1789 SQLRETURN
SQLGetData(SQLHSTMT StatementHandle
, SQLUSMALLINT ColumnNumber
, SQLSMALLINT TargetType
, SQLPOINTER TargetValuePtr
, SQLLEN BufferLength
, SQLLEN
* StrLen_or_IndPtr
)
1792 printError(ErrWarning
, "SQLGetData");
1795 if( isValidHandle( (CSqlOdbcStmt
*) StatementHandle
, SQL_HANDLE_STMT
) != SQL_SUCCESS
)
1796 return( SQL_INVALID_HANDLE
);
1798 return( ((CSqlOdbcStmt
*) StatementHandle
)->SQLGetData(ColumnNumber
,TargetType
,TargetValuePtr
,BufferLength
,StrLen_or_IndPtr
) );
1802 SQLRETURN
CSqlOdbcStmt::SQLGetData(SQLUSMALLINT ColumnNumber
, SQLSMALLINT TargetType
, SQLPOINTER TargetValuePtr
,SQLLEN BufferLength
, SQLLEN
* StrLen_or_IndPtr
)
1804 if(fsqlStmt_
->isFldNull(ColumnNumber
)){
1805 *((SQLINTEGER
*)StrLen_or_IndPtr
) = SQL_NULL_DATA
;
1806 return (SQL_SUCCESS
);
1808 void* sourceData
= NULL
;
1809 DataType sourceType
= typeUnknown
, destType
= typeUnknown
;
1810 DbRetVal rv
= fsqlStmt_
->getProjFldInfo(ColumnNumber
, fInfo
);
1812 return SQL_INVALID_HANDLE
;
1814 sourceType
= fInfo
->type
;
1815 sourceData
= fsqlStmt_
->getFieldValuePtr(ColumnNumber
-1);
1816 destType
= getCSqlType( TargetType
);
1817 int sourceLength
=-1;
1818 if(sourceType
== typeString
)
1820 sourceLength
=strlen((char *)sourceData
);
1821 *((SQLINTEGER
*)StrLen_or_IndPtr
) = copyToOdbc(TargetValuePtr
,BufferLength
,sourceData
,sourceLength
,sourceType
,destType
);
1824 copyToOdbc(TargetValuePtr
,BufferLength
,sourceData
,sourceLength
,sourceType
,destType
);
1826 return (SQL_SUCCESS
);
1830 SQLRETURN
SQLGetTypeInfo(
1831 SQLHSTMT StatementHandle
,
1832 SQLSMALLINT DataType
)
1835 printError(ErrWarning
, "SQLGetTypeInfo");
1838 if( isValidHandle( (CSqlOdbcStmt
*) StatementHandle
, SQL_HANDLE_STMT
) != SQL_SUCCESS
)
1839 return( SQL_INVALID_HANDLE
);
1841 return( ((CSqlOdbcStmt
*) StatementHandle
)->SQLGetTypeInfo(DataType
));
1844 SQLRETURN
CSqlOdbcStmt::SQLGetTypeInfo(SQLSMALLINT DataType
)
1846 return (SQL_SUCCESS
);
1850 SQLRETURN
SQLStatistics(
1851 SQLHSTMT StatementHandle
,
1852 SQLCHAR
* CatalogName
,
1853 SQLSMALLINT NameLength1
,
1854 SQLCHAR
* SchemaName
,
1855 SQLSMALLINT NameLength2
,
1856 SQLCHAR
* TableName
,
1857 SQLSMALLINT NameLength3
,
1858 SQLUSMALLINT Unique
,
1859 SQLUSMALLINT Reserved
)
1862 printError(ErrWarning
, "SQLStatistics");
1865 if( isValidHandle( (CSqlOdbcStmt
*) StatementHandle
, SQL_HANDLE_STMT
) != SQL_SUCCESS
)
1866 return( SQL_INVALID_HANDLE
);
1868 return( ((CSqlOdbcStmt
*) StatementHandle
)->SQLStatistics(CatalogName
,SchemaName
,TableName
,Unique
,Reserved
));
1871 SQLRETURN
CSqlOdbcStmt::SQLStatistics(
1872 SQLCHAR
* CatalogName
,
1873 SQLCHAR
* SchemaName
,
1874 SQLCHAR
* TableName
,
1875 SQLUSMALLINT Unique
,
1876 SQLUSMALLINT Reserved
)
1878 SQLRETURN ret
= SQL_SUCCESS
;
1879 if(Unique
!= SQL_INDEX_ALL
) { printf("NOT SUPPORTED "); return (SQL_ERROR
);}
1880 char str
[256]="describe index ";
1881 strcat(str
,(char*)TableName
);
1882 ret
= SQLPrepare((SQLCHAR
*)str
, strlen(str
));
1883 if( ret
!= SQL_SUCCESS
) return (ret
);
1885 if( ret
!= SQL_SUCCESS
) return (ret
);
1886 return( SQL_SUCCESS
);
1889 SQLRETURN
SQLForeignKeys(
1890 SQLHSTMT StatementHandle
,
1891 SQLCHAR
* PKCatalogName
,
1892 SQLSMALLINT NameLength1
,
1893 SQLCHAR
* PKSchemaName
,
1894 SQLSMALLINT NameLength2
,
1895 SQLCHAR
* PKTableName
,
1896 SQLSMALLINT NameLength3
,
1897 SQLCHAR
* FKCatalogName
,
1898 SQLSMALLINT NameLength4
,
1899 SQLCHAR
* FKSchemaName
,
1900 SQLSMALLINT NameLength5
,
1901 SQLCHAR
* FKTableName
,
1902 SQLSMALLINT NameLength6
)
1905 printError(ErrWarning
, "SQLForeignKeys");
1907 if( PKCatalogName
!=NULL
|| FKCatalogName
!=NULL
){
1908 if(strcmp((char*)PKCatalogName
,"csql")!=0 || strcmp((char*)PKCatalogName
,"csql")!=0){
1913 if( isValidHandle( (CSqlOdbcStmt
*) StatementHandle
, SQL_HANDLE_STMT
) != SQL_SUCCESS
)
1914 return( SQL_INVALID_HANDLE
);
1916 return( ((CSqlOdbcStmt
*) StatementHandle
)->SQLForeignKeys(PKTableName
, FKTableName
));
1919 SQLRETURN
CSqlOdbcStmt::SQLForeignKeys(
1920 SQLCHAR
* PKTableName
,
1921 SQLCHAR
* FKTableName
)
1923 SQLRETURN ret
= SQL_SUCCESS
;
1924 if(PKTableName
!=NULL
&& FKTableName
!=NULL
) { printf("NOT SUPPORTED "); return (SQL_ERROR
);}
1926 if(PKTableName
!=NULL
&& FKTableName
==NULL
){
1927 sprintf(str
,"ExportedKey %s;",(char*)PKTableName
);
1929 else if(NULL
== PKTableName
&& FKTableName
!=NULL
){
1930 sprintf(str
,"ImportedKey %s;",(char*)FKTableName
);
1932 ret
= SQLPrepare((SQLCHAR
*)str
, strlen(str
));
1933 if( ret
!= SQL_SUCCESS
) return (ret
);
1935 if( ret
!= SQL_SUCCESS
) return (ret
);
1936 return( SQL_SUCCESS
);