/*
---------------------------------------------------------
TestSQLProcedureColumns
---------------------------------------------------------
*/
PassFail TestMXSQLProcedureColumns(TestInfo *pTestInfo)
{
TEST_DECLARE;
TCHAR Heading[MAX_HEADING_SIZE];
RETCODE returncode;
SQLHANDLE henv;
SQLHANDLE hdbc;
SQLHANDLE hstmt;
TCHAR *ProcStr;
TCHAR ProcCatalog[NAME_LEN],ProcSchema[NAME_LEN],ProcName[NAME_LEN];
TCHAR ColName[NAME_LEN];
/* SEAQUEST */
char tmpbuf[1024];
TCHAR *myTestSch;
TCHAR *createSchStr;
TCHAR *setSchStr;
TCHAR *dropSchStr;
/* end of SEAQUEST */
TCHAR oProcCatalog[NAME_LEN];
TCHAR oProcSchema[NAME_LEN];
TCHAR oProcName[NAME_LEN];
TCHAR oColName[NAME_LEN];
SWORD oColType;
SWORD oColDataType;
TCHAR oColTypeName[NAME_LEN];
SDWORD oColSize;
SDWORD oBufferLen;
SWORD oDecDigits;
SWORD oColRadix;
SWORD oColNullable;
TCHAR oRemark[REM_LEN];
TCHAR oColDef[NAME_LEN];
SWORD oSQLDataType;
SWORD oSQLDateTimeSub;
SDWORD oCharOctetLen;
SDWORD oOrdinalPos;
TCHAR oIsNullable[NAME_LEN];
SQLLEN oProcCataloglen; // sushil
SQLLEN oProcSchemalen;
SQLLEN oProcNamelen;
SQLLEN oColNamelen;
SQLLEN oColTypelen;
SQLLEN oColDataTypelen;
SQLLEN oColTypeNamelen;
SQLLEN oColSizelen;
SQLLEN oBufferLenlen;
SQLLEN oDecDigitslen;
SQLLEN oColRadixlen;
SQLLEN oColNullablelen;
SQLLEN oRemarklen;
SQLLEN oColDeflen;
SQLLEN oSQLDataTypelen;
SQLLEN oSQLDateTimeSublen;
SQLLEN oCharOctetLenlen;
SQLLEN oOrdinalPoslen;
SQLLEN oIsNullablelen;
struct
{
TCHAR *DropProc;
TCHAR *CrtProc;
} CreateProc[] = {
{_T("DROP PROCEDURE N4210"),
_T("CREATE PROCEDURE N4210 (IN IN1 TIME) EXTERNAL NAME 'Procs.N4210' EXTERNAL PATH '/home/SQFQA/SPJRoot/spjrs/nci/spjrs.jar' LANGUAGE JAVA PARAMETER STYLE JAVA NO SQL NO ISOLATE")},
{_T("DROP PROCEDURE N4260"),
_T("CREATE PROCEDURE N4260 (IN IN1 REAL, INOUT INOUT1 INTEGER) EXTERNAL NAME 'Procs.N4260' EXTERNAL PATH '/home/SQFQA/SPJRoot/spjrs/nci/spjrs.jar' LANGUAGE JAVA PARAMETER STYLE JAVA NO SQL NO ISOLATE")},
{_T("DROP PROCEDURE N4261"),
_T("CREATE PROCEDURE N4261 (IN IN1 NUMERIC, INOUT INOUT1 REAL) EXTERNAL NAME 'Procs.N4261' EXTERNAL PATH '/home/SQFQA/SPJRoot/spjrs/nci/spjrs.jar' LANGUAGE JAVA PARAMETER STYLE JAVA NO SQL NO ISOLATE")},
{_T("DROP PROCEDURE N4264"),
_T("CREATE PROCEDURE N4264 (IN IN1 VARCHAR(30) CHARACTER SET ISO88591, OUT OUT1 VARCHAR(45) CHARACTER SET ISO88591) EXTERNAL NAME 'Procs.N4264' EXTERNAL PATH '/home/SQFQA/SPJRoot/spjrs/nci/spjrs.jar' LANGUAGE JAVA PARAMETER STYLE JAVA NO SQL NO ISOLATE")},
{_T("DROP PROCEDURE N4264A"),
_T("CREATE PROCEDURE N4264A (IN IN1 CHAR(30) CHARACTER SET ISO88591, OUT OUT1 CHAR(45) CHARACTER SET ISO88591) EXTERNAL NAME 'Procs.N4264' EXTERNAL PATH '/home/SQFQA/SPJRoot/spjrs/nci/spjrs.jar' LANGUAGE JAVA PARAMETER STYLE JAVA NO SQL NO ISOLATE")},
{_T("DROP PROCEDURE N4264B"),
_T("CREATE PROCEDURE N4264B (IN IN1 VARCHAR(2000) CHARACTER SET ISO88591, OUT OUT1 VARCHAR(2000) CHARACTER SET ISO88591) EXTERNAL NAME 'Procs.N4264' EXTERNAL PATH '/home/SQFQA/SPJRoot/spjrs/nci/spjrs.jar' LANGUAGE JAVA PARAMETER STYLE JAVA NO SQL NO ISOLATE")},
{_T("DROP PROCEDURE N4264C"),
_T("CREATE PROCEDURE N4264C (IN IN1 VARCHAR(30) CHARACTER SET UCS2, OUT OUT1 VARCHAR(45) CHARACTER SET UCS2) EXTERNAL NAME 'Procs.N4264' EXTERNAL PATH '/home/SQFQA/SPJRoot/spjrs/nci/spjrs.jar' LANGUAGE JAVA PARAMETER STYLE JAVA NO SQL NO ISOLATE")},
{_T("DROP PROCEDURE N4264D"),
_T("CREATE PROCEDURE N4264D (IN IN1 CHAR(30) CHARACTER SET UCS2, OUT OUT1 CHAR(45) CHARACTER SET UCS2) EXTERNAL NAME 'Procs.N4264' EXTERNAL PATH '/home/SQFQA/SPJRoot/spjrs/nci/spjrs.jar' LANGUAGE JAVA PARAMETER STYLE JAVA NO SQL NO ISOLATE")},
{_T("DROP PROCEDURE N4264E"),
_T("CREATE PROCEDURE N4264E (IN IN1 VARCHAR(2000) CHARACTER SET UCS2, OUT OUT1 VARCHAR(2000) CHARACTER SET UCS2) EXTERNAL NAME 'Procs.N4264' EXTERNAL PATH '/home/SQFQA/SPJRoot/spjrs/nci/spjrs.jar' LANGUAGE JAVA PARAMETER STYLE JAVA NO SQL NO ISOLATE")},
{_T("DROP PROCEDURE N4267"),
_T("CREATE PROCEDURE N4267 (IN IN1 NUMERIC, INOUT INOUT1 REAL) EXTERNAL NAME 'Procs.N4267' EXTERNAL PATH '/home/SQFQA/SPJRoot/spjrs/nci/spjrs.jar' LANGUAGE JAVA PARAMETER STYLE JAVA NO SQL NO ISOLATE")},
{_T("endloop"),_T("endloop")}
};
struct
{
TCHAR *ProcName;
TCHAR *ColName;
SWORD ColType;
SWORD ColDataType;
TCHAR *ColTypeName;
SDWORD ColSize;
SDWORD BufferLen;
SWORD DecDigits;
SWORD ColRadix;
SWORD ColNullable;
TCHAR *Remark;
TCHAR *ColDef;
SWORD SQLDataType;
SWORD SQLDateTimeSub;
SDWORD CharOctetLen;
SDWORD OrdinalPos;
TCHAR *IsNullable;
} ProcCol[] = {
/* {"N4210", "IN1", SQL_PARAM_INPUT, SQL_TYPE_TIME, "TIME", 8, 6, 0, <Null>, SQL_NULLABLE, <Null>, <Null>, 9, 2, <Null>, 1, "YES"},
{"N4260", "IN1", SQL_PARAM_INPUT, SQL_REAL, "REAL", 22, 4, 0, 2, SQL_NULLABLE, <Null>, <Null>, 7, <Null>, <Null>, 1, "YES"},
{"N4260", "INOUT1", SQL_PARAM_INPUT_OUTPUT, SQL_INTEGER, "INTEGER SIGNED", 10, 4, 0, 10, SQL_NULLABLE, <Null>, <Null>, 4, <Null>, <Null>, 2, "YES"},
{"N4261", "IN1", SQL_PARAM_INPUT, SQL_NUMERIC, "NUMERIC", 9, 11, 0, 10, SQL_NULLABLE, <Null>, <Null>, 2, <Null>, <Null>, 1, "YES"},
{"N4261", "INOUT1", SQL_PARAM_INPUT_OUTPUT, SQL_REAL, "REAL", 22, 4, 0, 2, SQL_NULLABLE, <Null>, <Null>, 7, <Null>, <Null>, 2, "YES"},
{"N4264", "IN1", SQL_PARAM_INPUT, SQL_WVARCHAR, "VARCHAR", 30, 30, 0, <Null>, SQL_NULLABLE, <Null>, <Null>, 12,<Null>, 30, 1, "YES"},
{"N4264", "OUT1", SQL_PARAM_OUTPUT, SQL_WVARCHAR, "VARCHAR", 45, 45, 0, <Null>, SQL_NULLABLE, <Null>, <Null>, 12,<Null>, 45, 2, "YES"},
{"N4267", "IN1", SQL_PARAM_INPUT, SQL_NUMERIC, "NUMERIC", 9, 11, 0, 10, SQL_NULLABLE, <Null>, <Null>, 2, <Null>, <Null>, 1, "YES"},
{"N4267", "INOUT1", SQL_PARAM_INPUT_OUTPUT, SQL_REAL, "REAL", 22, 4, 0, 2, SQL_NULLABLE, <Null>, <Null>, 7, <Null>, <Null>, 2, "YES"},
*/
{_T("N4210"), _T("IN1"), SQL_PARAM_INPUT, SQL_TYPE_TIME, _T("TIME"), 8, 6, 0, 0, SQL_NULLABLE, _T(""), _T(""), 9, 2, 0, 1, _T("YES")},
{_T("N4260"), _T("IN1"), SQL_PARAM_INPUT, SQL_REAL, _T("REAL"), 22, 4, 0, 2, SQL_NULLABLE, _T(""), _T(""), 7, 0, 0, 1, _T("YES")},
{_T("N4260"), _T("INOUT1"), SQL_PARAM_INPUT_OUTPUT, SQL_INTEGER, _T("INTEGER SIGNED"),10, 4, 0, 10, SQL_NULLABLE, _T(""), _T(""), 4, 0, 0, 2, _T("YES")},
{_T("N4261"), _T("IN1"), SQL_PARAM_INPUT, SQL_NUMERIC, _T("NUMERIC SIGNED"),9, 11, 0, 10, SQL_NULLABLE, _T(""), _T(""), 2, 0, 0, 1, _T("YES")},
{_T("N4261"), _T("INOUT1"), SQL_PARAM_INPUT_OUTPUT, SQL_REAL, _T("REAL"), 22, 4, 0, 2, SQL_NULLABLE, _T(""), _T(""), 7, 0, 0, 2, _T("YES")},
{_T("N4264"), _T("IN1"), SQL_PARAM_INPUT, SQL_VARCHAR, _T("VARCHAR"), 30, 30, 0, 0, SQL_NULLABLE, _T(""), _T(""), 12,0, 30,1, _T("YES")},
{_T("N4264"), _T("OUT1"), SQL_PARAM_OUTPUT, SQL_VARCHAR, _T("VARCHAR"), 45, 45, 0, 0, SQL_NULLABLE, _T(""), _T(""), 12,0, 45,2, _T("YES")},
{_T("N4264A"), _T("IN1"), SQL_PARAM_INPUT, SQL_CHAR, _T("CHAR"), 30, 30, 0, 0, SQL_NULLABLE, _T(""), _T(""), 1,0, 30,1, _T("YES")},
{_T("N4264A"), _T("OUT1"), SQL_PARAM_OUTPUT, SQL_CHAR, _T("CHAR"), 45, 45, 0, 0, SQL_NULLABLE, _T(""), _T(""), 1,0, 45,2, _T("YES")},
{_T("N4264B"), _T("IN1"), SQL_PARAM_INPUT, SQL_VARCHAR, _T("VARCHAR"),2000,2000,0,0, SQL_NULLABLE, _T(""), _T(""), 12,0,2000,1, _T("YES")},
{_T("N4264B"), _T("OUT1"), SQL_PARAM_OUTPUT, SQL_VARCHAR, _T("VARCHAR"),2000,2000,0,0, SQL_NULLABLE, _T(""), _T(""), 12,0,2000,2, _T("YES")},
{_T("N4264C"), _T("IN1"), SQL_PARAM_INPUT, SQL_WVARCHAR, _T("NCHAR VARYING"),30, 60, 0, 0, SQL_NULLABLE, _T(""), _T(""), -9,0, 60,1, _T("YES")},
{_T("N4264C"), _T("OUT1"), SQL_PARAM_OUTPUT, SQL_WVARCHAR, _T("NCHAR VARYING"),45, 90, 0, 0, SQL_NULLABLE, _T(""), _T(""), -9,0, 90,2, _T("YES")},
{_T("N4264D"), _T("IN1"), SQL_PARAM_INPUT, SQL_WCHAR, _T("NCHAR"), 30, 60, 0, 0, SQL_NULLABLE, _T(""), _T(""), -8,0, 60,1, _T("YES")},
{_T("N4264D"), _T("OUT1"), SQL_PARAM_OUTPUT, SQL_WCHAR, _T("NCHAR"), 45, 90, 0, 0, SQL_NULLABLE, _T(""), _T(""), -8,0, 90,2, _T("YES")},
{_T("N4264E"), _T("IN1"), SQL_PARAM_INPUT, SQL_WVARCHAR,_T("NCHAR VARYING"),2000,4000,0,0, SQL_NULLABLE, _T(""), _T(""),-9,0,4000,1, _T("YES")},
{_T("N4264E"), _T("OUT1"), SQL_PARAM_OUTPUT, SQL_WVARCHAR,_T("NCHAR VARYING"),2000,4000,0,0, SQL_NULLABLE, _T(""), _T(""),-9,0,4000,2, _T("YES")},
{_T("N4267"), _T("IN1"), SQL_PARAM_INPUT, SQL_NUMERIC, _T("NUMERIC SIGNED"),9, 11, 0, 10, SQL_NULLABLE, _T(""), _T(""), 2, 0, 0, 1, _T("YES")},
{_T("N4267"), _T("INOUT1"), SQL_PARAM_INPUT_OUTPUT, SQL_REAL, _T("REAL"), 22, 4, 0, 2, SQL_NULLABLE, _T(""), _T(""), 7, 0, 0, 2, _T("YES")},
{_T("endloop"),}
};
int i = 0, k = 0;
TCHAR State[STATE_SIZE];
SDWORD NativeError;
TCHAR buf[MAX_STRING_SIZE];
//TCHAR *charNameUCS2 = _T("NCHAR");
//TCHAR *varcharNameUCS2 = _T("NCHAR VARYING");
LogMsg(SHORTTIMESTAMP,_T("Begin testing API => MX Specific SQLProcedureColumns.\n"));
//=================================================================================================
//if(isUCS2) {
// LogMsg(LINEBEFORE,_T("Setup for UCS2 mode testing: ColSize,BufferLen and CharOctetlen has to be doubled\n"));
// k = sizeof(ProcCol)/sizeof(ProcCol[0]);
// while(i < k) {
// if(ProcCol[i].ColDataType == SQL_WCHAR)
// {
// ProcCol[i].ColDataType = SQL_WCHAR;
// ProcCol[i].SQLDataType = SQL_WCHAR;
// ProcCol[i].ColTypeName = charNameUCS2;
// //ProcCol[i].ColSize *= 2; --> This is in character, no need to double
// ProcCol[i].BufferLen *= 2;
// ProcCol[i].CharOctetLen *= 2;
// }
// else if (ProcCol[i].ColDataType == SQL_WVARCHAR)
// {
// ProcCol[i].ColDataType = SQL_WVARCHAR;
// ProcCol[i].SQLDataType = SQL_WVARCHAR;
// ProcCol[i].ColTypeName = varcharNameUCS2;
// //ProcCol[i].ColSize *= 2; --> This is in character, no need to double
// ProcCol[i].BufferLen *= 2;
// ProcCol[i].CharOctetLen *= 2;
// }
// else if (ProcCol[i].ColDataType == SQL_WLONGVARCHAR)
// {
// ProcCol[i].ColDataType = SQL_WLONGVARCHAR;
// ProcCol[i].SQLDataType = SQL_WLONGVARCHAR;
// ProcCol[i].ColTypeName = varcharNameUCS2;
// //ProcCol[i].ColSize *= 2; --> This is in character, no need to double
// ProcCol[i].BufferLen *= 2;
// ProcCol[i].CharOctetLen *= 2;
// }
// else {}
// i++;
// }
// i = 0;
// k = 0;
//}
//=================================================================================================
TEST_INIT;
TESTCASE_BEGIN("Setup for SQLProcedureColumns tests\n");
if(!FullConnectWithOptions(pTestInfo, CONNECT_ODBC_VERSION_3))
{
LogMsg(NONE,_T("Unable to connect\n"));
//TEST_FAILED;
TEST_RETURN;
}
henv = pTestInfo->henv;
hdbc = pTestInfo->hdbc;
hstmt = (SQLHANDLE)pTestInfo->hstmt;
returncode = SQLAllocHandle(SQL_HANDLE_STMT, (SQLHANDLE)hdbc, &hstmt);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocHandle"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
FullDisconnect3(pTestInfo);
//TEST_FAILED;
TEST_RETURN;
}
//TESTCASE_END;
ProcStr = (TCHAR *)malloc(MAX_NOS_SIZE);
/* SEAQUEST */
myTestSch = (TCHAR *)malloc(MAX_NOS_SIZE);
createSchStr = (TCHAR *)malloc(MAX_NOS_SIZE);
setSchStr = (TCHAR *)malloc(MAX_NOS_SIZE);
dropSchStr = (TCHAR *)malloc(MAX_NOS_SIZE);
_tcscpy (myTestSch, _T("ODBC_PROCCOL_TEST"));
_tcscpy (createSchStr, _T("create schema "));
_tcscat (createSchStr, pTestInfo->Catalog);
_tcscat (createSchStr, _T("."));
_tcscat (createSchStr, myTestSch);
_tcscpy (setSchStr, _T("set schema "));
_tcscat (setSchStr, pTestInfo->Catalog);
_tcscat (setSchStr, _T("."));
_tcscat (setSchStr, myTestSch);
_tcscpy (dropSchStr, _T("drop schema "));
_tcscat (dropSchStr, pTestInfo->Catalog);
_tcscat (dropSchStr, _T("."));
_tcscat (dropSchStr, myTestSch);
_tcscat (dropSchStr, _T(" cascade"));
returncode = SQLExecDirect(hstmt,(SQLTCHAR*) dropSchStr,SQL_NTS);
// if(!CHECKRC(SQL_SUCCESS,returncode,"Drop Schema"))
// {
// TEST_FAILED;
// LogAllErrors(henv,hdbc,hstmt);
// }
returncode = SQLExecDirect(hstmt,(SQLTCHAR*) createSchStr,SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"Create Schema"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt);
}
returncode = SQLExecDirect(hstmt,(SQLTCHAR*) setSchStr,SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"Set Schema"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt);
}
/* end of SEAQUEST */
while (_tcsicmp(CreateProc[i].DropProc,_T("endloop")) != 0)
{
_tcscpy(ProcStr,_T(""));
_tcscat(ProcStr,CreateProc[i].DropProc);
SQLExecDirect(hstmt,(SQLTCHAR*) ProcStr,SQL_NTS); // cleanup
_tcscpy(ProcStr,_T(""));
_tcscat(ProcStr,CreateProc[i].CrtProc);
_stprintf(Heading,_T("Adding Procedure => "));
_tcscat(Heading,ProcStr);
_tcscat(Heading,_T("\n"));
TESTCASE_BEGINW(Heading);
returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ProcStr,SQL_NTS);
if(returncode != SQL_SUCCESS)
{
returncode = SQLError((SQLHANDLE)NULL, (SQLHANDLE)NULL, hstmt, (SQLTCHAR*)State, &NativeError, (SQLTCHAR*)buf, MAX_STRING_SIZE, NULL);
if (NativeError == -2013)
{
LogMsg(NONE, _T("Stored Procedures not supported\n"));
_gTestCount--;
free(ProcStr);
FullDisconnect(pTestInfo);
LogMsg(SHORTTIMESTAMP,_T("End testing API => MX Specific SQLProcedureColumns.\n"));
TEST_RETURN;
}
else
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt);
}
}
TESTCASE_END;
i++;
}
_tcscpy(ProcCatalog, pTestInfo->Catalog);
_tcscpy(ProcSchema, myTestSch /*SEAQUEST pTestInfo->Schema*/);
_stprintf(Heading,_T("Test Positive Functionality of SQLProcedureColumns \n"));
TESTCASE_BEGINW(Heading);
returncode = SQLProcedureColumns(hstmt,(SQLTCHAR*)pTestInfo->Catalog,(SWORD)_tcslen(pTestInfo->Catalog),(SQLTCHAR*)myTestSch/* SEAQUEST pTestInfo->Schema*/,(SWORD)_tcslen(myTestSch/* SEAQUEST pTestInfo->Schema*/),(SQLTCHAR *)_T("%"),(SWORD)1,(SQLTCHAR *)_T("%"),(SWORD)1);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLProcedureColumns"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt);
}
if (returncode == SQL_SUCCESS)
{
_tcscpy(oProcCatalog,_T(""));
_tcscpy(oProcSchema,_T(""));
_tcscpy(oProcName,_T(""));
_tcscpy(oColName,_T(""));
oColType = 0;
oColDataType = 0;
_tcscpy(oColTypeName,_T(""));
oColSize = 0;
oBufferLen = 0;
oDecDigits = 0;
oColRadix = 0;
oColNullable = 0;
_tcscpy(oRemark,_T(""));
_tcscpy(oColDef,_T(""));
oSQLDataType = 0;
oSQLDateTimeSub = 0;
oCharOctetLen = 0;
oOrdinalPos = 0;
_tcscpy(oIsNullable,_T(""));
SQLBindCol(hstmt,1,SQL_C_TCHAR,oProcCatalog,NAME_LEN,&oProcCataloglen);
SQLBindCol(hstmt,2,SQL_C_TCHAR,oProcSchema,NAME_LEN,&oProcSchemalen);
SQLBindCol(hstmt,3,SQL_C_TCHAR,oProcName,NAME_LEN,&oProcNamelen);
SQLBindCol(hstmt,4,SQL_C_TCHAR,oColName,NAME_LEN,&oColNamelen);
SQLBindCol(hstmt,5,SQL_C_SHORT,&oColType,0,&oColTypelen);
SQLBindCol(hstmt,6,SQL_C_SHORT,&oColDataType,0,&oColDataTypelen);
SQLBindCol(hstmt,7,SQL_C_TCHAR,oColTypeName,NAME_LEN,&oColTypeNamelen);
SQLBindCol(hstmt,8,SQL_C_LONG,&oColSize,0,&oColSizelen);
SQLBindCol(hstmt,9,SQL_C_LONG,&oBufferLen,0,&oBufferLenlen);
SQLBindCol(hstmt,10,SQL_C_SHORT,&oDecDigits,0,&oDecDigitslen);
SQLBindCol(hstmt,11,SQL_C_SHORT,&oColRadix,0,&oColRadixlen);
SQLBindCol(hstmt,12,SQL_C_SHORT,&oColNullable,0,&oColNullablelen);
SQLBindCol(hstmt,13,SQL_C_TCHAR,oRemark,REM_LEN,&oRemarklen);
SQLBindCol(hstmt,14,SQL_C_TCHAR,oColDef,NAME_LEN,&oColDeflen);
SQLBindCol(hstmt,15,SQL_C_SHORT,&oSQLDataType,0,&oSQLDataTypelen);
SQLBindCol(hstmt,16,SQL_C_SHORT,&oSQLDateTimeSub,0,&oSQLDateTimeSublen);
SQLBindCol(hstmt,17,SQL_C_LONG,&oCharOctetLen,0,&oCharOctetLenlen);
SQLBindCol(hstmt,18,SQL_C_LONG,&oOrdinalPos,0,&oOrdinalPoslen);
SQLBindCol(hstmt,19,SQL_C_TCHAR,oIsNullable,NAME_LEN,&oIsNullablelen);
k = 0;
i = 0;
while (returncode == SQL_SUCCESS)
{
if(_tcscmp(ProcCol[i].ProcName,_T("endloop")) == 0)
break;
returncode = SQLFetch(hstmt);
if((returncode!=SQL_NO_DATA_FOUND) &&(!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch")))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
if (returncode == SQL_SUCCESS)
{
k++;
_stprintf(Heading,_T("SQLProcedureColumns: Comparing Results\n"));
TESTCASE_BEGINW(Heading);
if ((_tcsicmp(ProcCatalog,oProcCatalog) == 0)
&& (_tcsicmp(ProcSchema,oProcSchema) == 0)
&& (_tcsicmp(ProcCol[i].ProcName,oProcName) == 0)
&& (_tcsicmp(ProcCol[i].ColName,oColName) == 0)
&& (ProcCol[i].ColType == oColType)
&& (ProcCol[i].ColDataType == oColDataType)
&& (_tcsicmp(ProcCol[i].ColTypeName,oColTypeName) == 0)
&& (ProcCol[i].ColSize == oColSize)
&& (ProcCol[i].BufferLen == oBufferLen)
&& (ProcCol[i].DecDigits == oDecDigits)
&& (ProcCol[i].ColRadix == oColRadix)
&& (ProcCol[i].ColNullable == oColNullable)
&& (_tcsicmp(ProcCol[i].Remark,oRemark) == 0)
&& (_tcsicmp(ProcCol[i].ColDef,oColDef) == 0)
&& (ProcCol[i].SQLDataType == oSQLDataType)
&& (ProcCol[i].SQLDateTimeSub == oSQLDateTimeSub)
&& (ProcCol[i].CharOctetLen == oCharOctetLen)
&& (ProcCol[i].OrdinalPos == oOrdinalPos)
&& (_tcsicmp(ProcCol[i].IsNullable,oIsNullable) == 0)){
LogMsg(NONE,_T("ProcCatalog expect: %s and actual: %s are matched\n"),ProcCatalog,oProcCatalog);
LogMsg(NONE,_T("ProcSchema expect: %s and actual: %s are matched\n"),ProcSchema,oProcSchema);
LogMsg(NONE,_T("ProcName expect: %s and actual: %s are matched\n"),ProcCol[i].ProcName,oProcName);
LogMsg(NONE,_T("ColName expect: %s and actual: %s are matched\n"),ProcCol[i].ColName,oColName);
LogMsg(NONE,_T("ColType expect: %d and actual: %d are matched\n"),ProcCol[i].ColType,oColType);
LogMsg(NONE,_T("ColDataType expect: %d and actual: %d are matched\n"),ProcCol[i].ColDataType,oColDataType);
LogMsg(NONE,_T("ColTypeName expect: %s and actual: %s are matched\n"),ProcCol[i].ColTypeName,oColTypeName);
LogMsg(NONE,_T("ColSize expect: %d and actual: %d are matched\n"),ProcCol[i].ColSize,oColSize);
LogMsg(NONE,_T("BufferLen expect: %d and actual: %d are matched\n"),ProcCol[i].BufferLen,oBufferLen);
LogMsg(NONE,_T("DecDigits expect: %d and actual: %d are matched\n"),ProcCol[i].DecDigits,oDecDigits);
LogMsg(NONE,_T("ColRadix expect: %d and actual: %d are matched\n"),ProcCol[i].ColRadix,oColRadix);
LogMsg(NONE,_T("ColNullable expect: %d and actual: %d are matched\n"),ProcCol[i].ColNullable,oColNullable);
LogMsg(NONE,_T("Remark expect: %s and actual: %s are matched\n"),ProcCol[i].Remark,oRemark);
LogMsg(NONE,_T("ColDef expect: %s and actual: %s are matched\n"),ProcCol[i].ColDef,oColDef);
LogMsg(NONE,_T("SQLDataType expect: %d and actual: %d are matched\n"),ProcCol[i].SQLDataType,oSQLDataType);
LogMsg(NONE,_T("SQLDateTimeSub expect: %d and actual: %d are matched\n"),ProcCol[i].SQLDateTimeSub,oSQLDateTimeSub);
LogMsg(NONE,_T("CharOctetLen expect: %d and actual: %d are matched\n"),ProcCol[i].CharOctetLen,oCharOctetLen);
LogMsg(NONE,_T("OrdinalPos expect: %d and actual: %d are matched\n"),ProcCol[i].OrdinalPos,oOrdinalPos);
LogMsg(NONE,_T("IsNullable expect: %s and actual: %s are matched\n"),ProcCol[i].IsNullable,oIsNullable);
}
else
{
TEST_FAILED;
if (_tcsicmp(ProcCatalog,oProcCatalog) != 0)
LogMsg(ERRMSG,_T("ProcCatalog expect: %s and actual: %s are not matched\n"),ProcCatalog,oProcCatalog);
else
LogMsg(NONE,_T("ProcCatalog expect: %s and actual: %s are matched\n"),ProcCatalog,oProcCatalog);
if (_tcsicmp(ProcSchema,oProcSchema) != 0)
LogMsg(ERRMSG,_T("ProcSchema expect: %s and actual: %s are not matched\n"),ProcSchema,oProcSchema);
else
LogMsg(NONE,_T("ProcSchema expect: %s and actual: %s are matched\n"),ProcSchema,oProcSchema);
if (_tcsicmp(ProcCol[i].ProcName,oProcName) != 0)
LogMsg(ERRMSG,_T("ProcName expect: %s and actual: %s are not matched\n"),ProcCol[i].ProcName,oProcName);
else
LogMsg(NONE,_T("ProcName expect: %s and actual: %s are matched\n"),ProcCol[i].ProcName,oProcName);
if (_tcsicmp(ProcCol[i].ColName,oColName) != 0)
LogMsg(ERRMSG,_T("ColName expect: %s and actual: %s are not matched\n"),ProcCol[i].ColName,oColName);
else
LogMsg(NONE,_T("ColName expect: %s and actual: %s are matched\n"),ProcCol[i].ColName,oColName);
if (ProcCol[i].ColType != oColType)
LogMsg(ERRMSG,_T("ColType expect: %d and actual: %d are not matched\n"),ProcCol[i].ColType,oColType);
else
LogMsg(NONE,_T("ColType expect: %d and actual: %d are matched\n"),ProcCol[i].ColType,oColType);
if (ProcCol[i].ColDataType != oColDataType)
LogMsg(ERRMSG,_T("ColDataType expect: %d and actual: %d are not matched\n"),ProcCol[i].ColDataType,oColDataType);
else
LogMsg(NONE,_T("ColDataType expect: %d and actual: %d are matched\n"),ProcCol[i].ColDataType,oColDataType);
if (_tcsicmp(ProcCol[i].ColTypeName,oColTypeName) != 0)
LogMsg(ERRMSG,_T("ColTypeName expect: %s and actual: %s are not matched\n"),ProcCol[i].ColTypeName,oColTypeName);
else
LogMsg(NONE,_T("ColTypeName expect: %s and actual: %s are matched\n"),ProcCol[i].ColTypeName,oColTypeName);
if (ProcCol[i].ColSize != oColSize)
LogMsg(ERRMSG,_T("ColSize expect: %d and actual: %d are not matched\n"),ProcCol[i].ColSize,oColSize);
else
LogMsg(NONE,_T("ColSize expect: %d and actual: %d are matched\n"),ProcCol[i].ColSize,oColSize);
if (ProcCol[i].BufferLen != oBufferLen)
LogMsg(ERRMSG,_T("BufferLen expect: %d and actual: %d are not matched\n"),ProcCol[i].BufferLen,oBufferLen);
else
LogMsg(NONE,_T("BufferLen expect: %d and actual: %d are matched\n"),ProcCol[i].BufferLen,oBufferLen);
if (ProcCol[i].DecDigits != oDecDigits)
LogMsg(ERRMSG,_T("DecDigits expect: %d and actual: %d are not matched\n"),ProcCol[i].DecDigits,oDecDigits);
else
LogMsg(NONE,_T("DecDigits expect: %d and actual: %d are matched\n"),ProcCol[i].DecDigits,oDecDigits);
if (ProcCol[i].ColRadix != oColRadix)
LogMsg(ERRMSG,_T("ColRadix expect: %d and actual: %d are not matched\n"),ProcCol[i].ColRadix,oColRadix);
else
LogMsg(NONE,_T("ColRadix expect: %d and actual: %d are matched\n"),ProcCol[i].ColRadix,oColRadix);
if (ProcCol[i].ColNullable != oColNullable)
LogMsg(ERRMSG,_T("ColNullable expect: %d and actual: %d are not matched\n"),ProcCol[i].ColNullable,oColNullable);
else
LogMsg(NONE,_T("ColNullable expect: %d and actual: %d are matched\n"),ProcCol[i].ColNullable,oColNullable);
if (_tcsicmp(ProcCol[i].Remark,oRemark) != 0)
LogMsg(ERRMSG,_T("Remark expect: %s and actual: %s are not matched\n"),ProcCol[i].Remark,oRemark);
else
LogMsg(NONE,_T("Remark expect: %s and actual: %s are matched\n"),ProcCol[i].Remark,oRemark);
if (_tcsicmp(ProcCol[i].ColDef,oColDef) != 0)
LogMsg(ERRMSG,_T("Remark expect: %s and actual: %s are not matched\n"),ProcCol[i].ColDef,oColDef);
else
LogMsg(NONE,_T("Remark expect: %s and actual: %s are matched\n"),ProcCol[i].ColDef,oColDef);
if (ProcCol[i].SQLDataType != oSQLDataType)
LogMsg(ERRMSG,_T("SQLDataType expect: %d and actual: %d are not matched\n"),ProcCol[i].SQLDataType,oSQLDataType);
else
LogMsg(NONE,_T("SQLDataType expect: %d and actual: %d are matched\n"),ProcCol[i].SQLDataType,oSQLDataType);
if (ProcCol[i].SQLDateTimeSub != oSQLDateTimeSub)
LogMsg(ERRMSG,_T("SQLDateTimeSub expect: %d and actual: %d are not matched\n"),ProcCol[i].SQLDateTimeSub,oSQLDateTimeSub);
else
LogMsg(NONE,_T("SQLDateTimeSub expect: %d and actual: %d are matched\n"),ProcCol[i].SQLDateTimeSub,oSQLDateTimeSub);
if (ProcCol[i].CharOctetLen != oCharOctetLen)
LogMsg(ERRMSG,_T("CharOctetLen expect: %d and actual: %d are not matched\n"),ProcCol[i].CharOctetLen,oCharOctetLen);
else
LogMsg(NONE,_T("CharOctetLen expect: %d and actual: %d are matched\n"),ProcCol[i].CharOctetLen,oCharOctetLen);
if (ProcCol[i].OrdinalPos != oOrdinalPos)
LogMsg(ERRMSG,_T("OrdinalPos expect: %d and actual: %d are not matched\n"),ProcCol[i].OrdinalPos,oOrdinalPos);
else
LogMsg(NONE,_T("OrdinalPos expect: %d and actual: %d are matched\n"),ProcCol[i].OrdinalPos,oOrdinalPos);
if (_tcsicmp(ProcCol[i].IsNullable,oIsNullable) != 0)
LogMsg(ERRMSG,_T("IsNullable expect: %s and actual: %s are not matched\n"),ProcCol[i].IsNullable,oIsNullable);
else
LogMsg(NONE,_T("IsNullable expect: %s and actual: %s are matched\n"),ProcCol[i].IsNullable,oIsNullable);
}
}
}
if(k == 0)
{
TEST_FAILED;
LogMsg(ERRMSG,_T("No Data Found => Atleast one row should be fetched\n"));
}
TESTCASE_END;
_tcscpy(oProcCatalog,_T(""));
_tcscpy(oProcSchema,_T(""));
_tcscpy(oProcName,_T(""));
_tcscpy(oColName,_T(""));
oColType = 0;
oColDataType = 0;
_tcscpy(oColTypeName,_T(""));
oColSize = 0;
oBufferLen = 0;
oDecDigits = 0;
oColRadix = 0;
oColNullable = 0;
_tcscpy(oRemark,_T(""));
_tcscpy(oColDef,_T(""));
oSQLDataType = 0;
oSQLDateTimeSub = 0;
oCharOctetLen = 0;
oOrdinalPos = 0;
_tcscpy(oIsNullable,_T(""));
i++;
} // while
}
SQLFreeStmt(hstmt,SQL_UNBIND);
SQLFreeStmt(hstmt,SQL_CLOSE);
i=0;
while (_tcsicmp(CreateProc[i].DropProc,_T("endloop")) != 0)
{
_tcscpy(ProcStr,_T(""));
_tcscat(ProcStr,CreateProc[i].DropProc);
returncode = SQLExecDirect(hstmt,(SQLTCHAR*) ProcStr,SQL_NTS); // cleanup
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
i++;
}
SQLFreeStmt(hstmt,SQL_UNBIND);
SQLFreeStmt(hstmt,SQL_CLOSE);
//========================================================================================================
_stprintf(Heading,_T("SQLProcedureColumns: Negative test with NULL handle\n"));
TESTCASE_BEGINW(Heading);
hstmt = (SQLHANDLE)NULL;
_tcscpy(ProcName,_T("junkproc"));
_tcscpy(ColName,_T("C1"));
returncode = SQLProcedureColumns(hstmt,(SQLTCHAR*)pTestInfo->Catalog,(SWORD)_tcslen(pTestInfo->Catalog),(SQLTCHAR*)myTestSch /* SEAQUEST pTestInfo->Schema */,(SWORD)_tcslen(myTestSch /* SEAQUEST pTestInfo->Schema*/),(SQLTCHAR*)ProcName,(SWORD)_tcslen(ProcName),(SQLTCHAR*)ColName,(SWORD)_tcslen(ColName));
if(!CHECKRC(SQL_INVALID_HANDLE,returncode,"SQLProcedureColumns"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt);
}
TESTCASE_END;
//========================================================================================================
returncode = SQLExecDirect(hstmt,(SQLTCHAR*) dropSchStr,SQL_NTS);
free(ProcStr);
FullDisconnect3(pTestInfo);
LogMsg(SHORTTIMESTAMP+LINEAFTER,_T("End testing API => MX Specific SQLProcedureColumns.\n"));
TEST_RETURN;
}
/*
---------------------------------------------------------
TestSQLTransact
---------------------------------------------------------
*/
PassFail TestSQLTransact(TestInfo *pTestInfo)
{
TEST_DECLARE;
RETCODE returncode;
TCHAR Heading[MAX_STRING_SIZE];
SQLHANDLE henv;
SQLHANDLE hdbc;
SQLHANDLE hstmt;
TCHAR *ExecDirStr[6];
UWORD fType[] = { SQL_ROLLBACK,SQL_COMMIT };
TCHAR *TypeDesc[] = { _T("SQL_ROLLBACK"),_T("SQL_COMMIT") };
TCHAR *Output;
SQLLEN OutputLen;
struct
{
SWORD ExeRes[2];
SWORD FetchRes[2];
TCHAR *DataRes[2];
} CheckRes[] =
{
{SQL_ERROR,SQL_SUCCESS,SQL_NO_DATA_FOUND,SQL_NO_DATA_FOUND,_T(""),_T("")},
{SQL_SUCCESS,SQL_SUCCESS,SQL_NO_DATA_FOUND,SQL_SUCCESS,_T(""),_T("--")},
{SQL_SUCCESS,SQL_SUCCESS,SQL_SUCCESS,SQL_SUCCESS,_T("--"),_T("--")},
{SQL_SUCCESS,SQL_SUCCESS,SQL_SUCCESS,SQL_NO_DATA_FOUND,_T("--"),_T("")},
{SQL_SUCCESS,SQL_ERROR,SQL_NO_DATA_FOUND,SQL_NO_DATA_FOUND,_T(""),_T("")}
};
int i = 0, j = 0, iend = 5, jend = 1, commit_on_off = 0;
//===========================================================================================================
var_list_t *var_list;
var_list = load_api_vars(_T("SQLTransact"), charset_file);
if (var_list == NULL) return FAILED;
ExecDirStr[0] = var_mapping(_T("SQLTransact_ExecDirStr_0"), var_list);
ExecDirStr[1] = var_mapping(_T("SQLTransact_ExecDirStr_1"), var_list);
ExecDirStr[2] = var_mapping(_T("SQLTransact_ExecDirStr_2"), var_list);
ExecDirStr[3] = var_mapping(_T("SQLTransact_ExecDirStr_3"), var_list);
ExecDirStr[4] = var_mapping(_T("SQLTransact_ExecDirStr_4"), var_list);
ExecDirStr[5] = var_mapping(_T("SQLTransact_ExecDirStr_5"), var_list);
CheckRes[1].DataRes[1] = var_mapping(_T("SQLTransact_Insert"), var_list);
CheckRes[2].DataRes[0] = var_mapping(_T("SQLTransact_Insert"), var_list);
CheckRes[2].DataRes[1] = var_mapping(_T("SQLTransact_Update"), var_list);
CheckRes[3].DataRes[0] = var_mapping(_T("SQLTransact_Update"), var_list);
//========================================================================================================
LogMsg(LINEBEFORE+SHORTTIMESTAMP,_T("Begin testing API => SQLTransact.\n"));
TEST_INIT;
TESTCASE_BEGIN("Initializing SQLTransact test environment\n");
//
if(!FullConnect(pTestInfo))
{
LogMsg(NONE,_T("Unable to connect\n"));
TEST_FAILED;
TEST_RETURN;
}
henv = pTestInfo->henv;
hdbc = pTestInfo->hdbc;
hstmt = (SQLHANDLE)pTestInfo->hstmt;
returncode = SQLAllocStmt((SQLHANDLE)hdbc, &hstmt);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocStmt"))
{
LogAllErrors(henv,hdbc,hstmt);
FullDisconnect(pTestInfo);
TEST_FAILED;
TEST_RETURN;
}
for (commit_on_off = 0; commit_on_off < 10; commit_on_off++)
{
returncode = SQLSetConnectOption((SQLHANDLE)hdbc,SQL_AUTOCOMMIT,SQL_AUTOCOMMIT_ON);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetConnectOption"))
{
LogAllErrors(henv,hdbc,hstmt);
FullDisconnect(pTestInfo);
TEST_FAILED;
TEST_RETURN;
}
TESTCASE_END;
SQLExecDirect(hstmt, (SQLTCHAR*)ExecDirStr[4], SQL_NTS); /* CLEANUP */
for (i = 0; i <= (iend-1); i++)
{
_stprintf(Heading,_T("Test Positive Functionality of SQLTransact while Autocommit is ON and executing\n"));
_tcscat(Heading, ExecDirStr[i]);
_tcscat(Heading, _T("\n"));
TESTCASE_BEGINW(Heading);
returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i],SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
}
SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[4],SQL_NTS); /* CLEANUP */
returncode = SQLSetConnectOption((SQLHANDLE)hdbc,SQL_AUTOCOMMIT,SQL_AUTOCOMMIT_OFF);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetConnectOption"))
{
LogAllErrors(henv,hdbc,hstmt);
FullDisconnect(pTestInfo);
TEST_FAILED;
TEST_RETURN;
}
TESTCASE_END;
for (i = 0; i <= (iend-1); i++)
{
for (j = 0; j <= jend; j++)
{
_stprintf(Heading,_T("Test Positive Functionality of SQLTransact while Autocommit is OFF and executing\n"));
_tcscat(Heading, ExecDirStr[i]);
_tcscat(Heading, _T(" & "));
_tcscat(Heading, TypeDesc[j]);
_tcscat(Heading, _T("\n"));
TESTCASE_BEGINW(Heading);
//MAY 9, 2014 - TURNING AUTOCOMMIT ON FOR DDLs FOR TRAF, AS DDLs ARE NOT SUPPORTED WITH AUTOCOMMIT OFF
if (i == 4 || i == 0)
SQLSetConnectOption((SQLHANDLE)hdbc, SQL_AUTOCOMMIT, SQL_AUTOCOMMIT_ON);
returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i],SQL_NTS);
SQLSetConnectOption((SQLHANDLE)hdbc, SQL_AUTOCOMMIT, SQL_AUTOCOMMIT_OFF);
if (!CHECKRC(SQL_SUCCESS, returncode, "SQLExecDirect"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
returncode=SQLTransact((SQLHANDLE)henv,(SQLHANDLE)hdbc,fType[j]);
Sleep(2); // tmf rollback is slower.
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLTransact"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[iend],SQL_NTS);
if(!CHECKRC(CheckRes[i].ExeRes[j],returncode,"SQLExecDirect"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
if (returncode == SQL_SUCCESS || returncode == SQL_SUCCESS_WITH_INFO)
{
Output = (TCHAR *)malloc(NAME_LEN);
returncode=SQLBindCol(hstmt,1,SQL_C_TCHAR,Output,NAME_LEN,&OutputLen);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
returncode = SQLFetch(hstmt);
if(!CHECKRC(CheckRes[i].FetchRes[j],returncode,"SQLFetch"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
if (returncode != SQL_NO_DATA_FOUND && returncode != SQL_ERROR)
{
if (_tcscspn(CheckRes[i].DataRes[j],Output) == 0)
{
LogMsg(NONE,_T("expect: %s and actual: %s are matched\n"),Output,CheckRes[i].DataRes[j]);
}
else
{
LogMsg(NONE,_T("expect: %s and actual: %s are not matched\n"),Output,CheckRes[i].DataRes[j]);
TEST_FAILED;
}
}
}
free(Output);
SQLFreeStmt(hstmt,SQL_CLOSE);
}
}
}
}
TESTCASE_END;
}/* end j loop */
}/* end i loop */
}
//========================================================================================================
SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[4],SQL_NTS); /* CLEANUP */
returncode = SQLDisconnect((SQLHANDLE)hdbc);
if(!CHECKRC(SQL_ERROR,returncode,"SQLDisconnect"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
// Free the open transactions.
returncode=SQLTransact((SQLHANDLE)henv,(SQLHANDLE)hdbc,SQL_ROLLBACK);
Sleep(2);
returncode=FullDisconnect(pTestInfo);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFullDisconnect"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
LogMsg(SHORTTIMESTAMP+LINEAFTER,_T("End testing API => SQLTransact.\n"));
free_list(var_list);
TEST_RETURN;
}
/*
---------------------------------------------------------
TestSQLEndTran
---------------------------------------------------------
*/
PassFail TestMXSQLEndTran(TestInfo *pTestInfo)
{
TEST_DECLARE;
RETCODE returncode;
TCHAR Heading[MAX_STRING_SIZE];
SQLHANDLE henv;
SQLHANDLE hdbc;
SQLHANDLE hstmt;
TCHAR *ExecDirStr[] =
{
//"create table testtransact(c1 TCHAR(20),c2 integer)",
//"create table testtransact(c1 TCHAR(20),c2 integer) NO PARTITION",
// The NO PARTITION is to help speed up this test on NEO/clustered systems with POS turned on.
_T("--"),
_T("--"),
_T("--"),
_T("--"),
_T("--"),
_T("--")
};
UWORD fType[] = { SQL_ROLLBACK, SQL_COMMIT };
TCHAR *TypeDesc[] = { _T("SQL_ROLLBACK"), _T("SQL_COMMIT") };
TCHAR *Output;
SQLLEN OutputLen; // sushil
struct
{
SWORD ExeRes[2];
SWORD FetchRes[2];
TCHAR *DataRes[2];
} CheckRes[] = {
{SQL_ERROR,SQL_SUCCESS,SQL_NO_DATA_FOUND,SQL_NO_DATA_FOUND,_T(""),_T("")},
{SQL_SUCCESS,SQL_SUCCESS,SQL_NO_DATA_FOUND,SQL_SUCCESS,_T(""),_T("--")},
{SQL_SUCCESS,SQL_SUCCESS,SQL_SUCCESS,SQL_SUCCESS,_T("--"),_T("--")},
{SQL_SUCCESS,SQL_SUCCESS,SQL_SUCCESS,SQL_NO_DATA_FOUND,_T("--"),_T("")},
{SQL_SUCCESS,SQL_ERROR,SQL_NO_DATA_FOUND,SQL_NO_DATA_FOUND,_T(""),_T("")}
};
int i = 0, j = 0, iend = 5, jend = 1, commit_on_off = 0;
//===========================================================================================================
var_list_t *var_list;
var_list = load_api_vars(_T("SQLEndTran"), charset_file);
if (var_list == NULL) return FAILED;
ExecDirStr[0] = var_mapping(_T("SQLEndTran_ExecDirStr_0"), var_list);
ExecDirStr[1] = var_mapping(_T("SQLEndTran_ExecDirStr_1"), var_list);
ExecDirStr[2] = var_mapping(_T("SQLEndTran_ExecDirStr_2"), var_list);
ExecDirStr[3] = var_mapping(_T("SQLEndTran_ExecDirStr_3"), var_list);
ExecDirStr[4] = var_mapping(_T("SQLEndTran_ExecDirStr_4"), var_list);
ExecDirStr[5] = var_mapping(_T("SQLEndTran_ExecDirStr_5"), var_list);
CheckRes[1].DataRes[1] = var_mapping(_T("SQLEndTran_Insert"), var_list);
CheckRes[2].DataRes[0] = var_mapping(_T("SQLEndTran_Insert"), var_list);
CheckRes[2].DataRes[1] = var_mapping(_T("SQLEndTran_Update"), var_list);
CheckRes[3].DataRes[0] = var_mapping(_T("SQLEndTran_Update"), var_list);
//========================================================================================================
LogMsg(LINEBEFORE+SHORTTIMESTAMP,_T("Begin testing API => SQLEndTran.\n"));
TEST_INIT;
TESTCASE_BEGIN("Initializing SQLEndTran test environment\n");
if(!FullConnectWithOptions(pTestInfo, CONNECT_ODBC_VERSION_3))
{
LogMsg(NONE,_T("Unable to connect\n"));
TEST_FAILED;
TEST_RETURN;
}
henv = pTestInfo->henv;
hdbc = pTestInfo->hdbc;
hstmt = (SQLHANDLE)pTestInfo->hstmt;
returncode = SQLAllocHandle(SQL_HANDLE_STMT, (SQLHANDLE)hdbc, &hstmt);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocHandle"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
FullDisconnect(pTestInfo);
TEST_FAILED;
TEST_RETURN;
}
//setting CQD to set POS OFF,as some tests fail otherwise. (to be fixed)
//SQLExecDirect (hstmt,"CONTROL QUERY DEFAULT POS 'OFF'",SQL_NTS);
for (commit_on_off = 0; commit_on_off < 10; commit_on_off++)
{
returncode = SQLSetConnectAttr((SQLHANDLE)hdbc,SQL_AUTOCOMMIT,(void *)SQL_AUTOCOMMIT_ON,0);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetConnectAttr"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
FullDisconnect(pTestInfo);
TEST_FAILED;
TEST_RETURN;
}
TESTCASE_END;
SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[4],SQL_NTS); /* CLEANUP */
for (i = 0; i <= (iend-1); i++)
{
_stprintf(Heading,_T("Test Positive Functionality of SQLEndTran while Autocommit is ON and executing\n"));
_tcscat(Heading, ExecDirStr[i]);
_tcscat(Heading, _T("\n"));
TESTCASE_BEGINW(Heading);
returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i],SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
}
SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[4],SQL_NTS); /* CLEANUP */
returncode = SQLSetConnectAttr((SQLHANDLE)hdbc,SQL_AUTOCOMMIT,(void *)SQL_AUTOCOMMIT_OFF,0);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetConnectAttr"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
FullDisconnect(pTestInfo);
TEST_FAILED;
TEST_RETURN;
}
TESTCASE_END;
for (i = 0; i <= (iend-1); i++)
{
for (j = 0; j <= jend; j++)
{
_stprintf(Heading,_T("Test Positive Functionality of SQLEndTran while Autocommit is OFF and executing\n"));
_tcscat(Heading, ExecDirStr[i]);
_tcscat(Heading, _T(" & "));
_tcscat(Heading, TypeDesc[j]);
_tcscat(Heading, _T("\n"));
TESTCASE_BEGINW(Heading);
returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i],SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
returncode=SQLEndTran(SQL_HANDLE_DBC,(SQLHANDLE)hdbc,fType[j]);
Sleep(2); // tmf rollback is slower.
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLTransact"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[iend],SQL_NTS);
if(!CHECKRC(CheckRes[i].ExeRes[j],returncode,"SQLExecDirect"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
if (returncode == SQL_SUCCESS || returncode == SQL_SUCCESS_WITH_INFO)
{
Output = (TCHAR *)malloc(NAME_LEN);
returncode=SQLBindCol(hstmt,1,SQL_C_TCHAR,Output,NAME_LEN,&OutputLen);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
returncode = SQLFetch(hstmt);
if(!CHECKRC(CheckRes[i].FetchRes[j],returncode,"SQLFetch"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
if (returncode != SQL_NO_DATA_FOUND && returncode != SQL_ERROR)
{
if (_tcscspn(CheckRes[i].DataRes[j],Output) == 0)
{
//LogMsg(NONE,_T("expect: %s and actual: %s are matched\n"),Output,CheckRes[i].DataRes[j]);
}
else
{
LogMsg(ERRMSG,_T("expect: %s and actual: %s are not matched at line %d \n"),Output,CheckRes[i].DataRes[j],__LINE__);
TEST_FAILED;
}
}
}
free(Output);
SQLFreeStmt(hstmt,SQL_CLOSE);
}
}
}
}
//SQLFreeStmt(hstmt,SQL_CLOSE);
TESTCASE_END;
}/* end i loop */
//SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[4],SQL_NTS); /* CLEANUP */
}/* end j loop */
}
//========================================================================================================
SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[4],SQL_NTS); /* CLEANUP */
returncode = SQLDisconnect((SQLHANDLE)hdbc);
if(!CHECKRC(SQL_ERROR,returncode,"SQLDisconnect"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
// Free the open transactions.
returncode=SQLEndTran(SQL_HANDLE_DBC,(SQLHANDLE)hdbc,SQL_ROLLBACK);
Sleep(2);
returncode=FullDisconnect3(pTestInfo);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFullDisconnect"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
LogMsg(SHORTTIMESTAMP+LINEAFTER,_T("End testing API => SQLEndTran.\n"));
free_list(var_list);
TEST_RETURN;
}
/*
---------------------------------------------------------
TestSQLProcedures
---------------------------------------------------------
*/
PassFail TestMXSQLProcedures(TestInfo *pTestInfo)
{
TEST_DECLARE;
char Heading[MAX_HEADING_SIZE];
RETCODE returncode;
SQLHANDLE henv;
SQLHANDLE hdbc;
SQLHANDLE hstmt;
CHAR *ProcStr;
CHAR *myTestSch = "ODBC_PROC_TEST";
CHAR createSchStr[128];
CHAR setSchStr[128];
CHAR dropSchStr[128];
CHAR ProcName[NAME_LEN];
CHAR ServerName[NAME_LEN];
char SerName[4];
SQLSMALLINT serLen;
SWORD ProcType = SQL_PT_PROCEDURE;
CHAR opqua[NAME_LEN],opowner[NAME_LEN],opname[NAME_LEN],oremark[REM_LEN];
SWORD onuminpar,onumoutpar,onumresset,optype;
SQLLEN opqualen,opownerlen,opnamelen,onuminparlen,onumoutparlen,onumressetlen,oremarklen,optypelen;
struct
{
CHAR *DropProc;
CHAR *CrtProc;
} CreateProc[] = {
{"DROP PROCEDURE N4210_REG",
"CREATE PROCEDURE N4210_REG (IN IN1 TIME) EXTERNAL NAME 'Procs.N4210' EXTERNAL PATH '/home/SQFQA/SPJRoot/odbctest_spjs' LANGUAGE JAVA PARAMETER STYLE JAVA NO SQL NO ISOLATE"},
{"DROP PROCEDURE N4260_REG",
"CREATE PROCEDURE N4260_REG (IN IN1 REAL, INOUT INOUT1 INTEGER) EXTERNAL NAME 'Procs.N4260' EXTERNAL PATH '/home/SQFQA/SPJRoot/odbctest_spjs' LANGUAGE JAVA PARAMETER STYLE JAVA NO SQL NO ISOLATE"},
{"DROP PROCEDURE N4261_REG",
"CREATE PROCEDURE N4261_REG (IN IN1 NUMERIC, INOUT INOUT1 REAL) EXTERNAL NAME 'Procs.N4261' EXTERNAL PATH '/home/SQFQA/SPJRoot/odbctest_spjs' LANGUAGE JAVA PARAMETER STYLE JAVA NO SQL NO ISOLATE"},
{"DROP PROCEDURE N4264_REG",
"CREATE PROCEDURE N4264_REG (IN IN1 VARCHAR(30), OUT OUT1 VARCHAR(45)) EXTERNAL NAME 'Procs.N4264' EXTERNAL PATH '/home/SQFQA/SPJRoot/odbctest_spjs' LANGUAGE JAVA PARAMETER STYLE JAVA NO SQL NO ISOLATE"},
{"DROP PROCEDURE N4267_REG",
"CREATE PROCEDURE N4267_REG (IN IN1 NUMERIC, INOUT INOUT1 REAL) EXTERNAL NAME 'Procs.N4267' EXTERNAL PATH '/home/SQFQA/SPJRoot/odbctest_spjs' LANGUAGE JAVA PARAMETER STYLE JAVA NO SQL NO ISOLATE"},
{"endloop","endloop"}
};
struct
{
CHAR *ProcName;
SDWORD NumInParams;
SDWORD NumOutParams;
SDWORD NumResSet;
CHAR *Remark;
} Procedure[] = {
{"N4210_REG",0,0,0,""},
{"N4260_REG",0,0,0,""},
{"N4261_REG",0,0,0,""},
{"N4264_REG",0,0,0,""},
{"N4267_REG",0,0,0,""},
{"endloop",0,0,0,""}
};
int i = 0, k = 0;
//===========================================================================================================
// Initialization Test Case
LogMsg(LINEBEFORE+SHORTTIMESTAMP,"Begin testing API => MX Specific SQLProcedures | SQLProcedures | MXProc.c\n");
TEST_INIT;
TESTCASE_BEGIN("Setup for SQLProcedures tests\n");
if(!FullConnectWithOptions(pTestInfo, CONNECT_ODBC_VERSION_3))
{
LogMsg(NONE,"Unable to connect\n");
TEST_RETURN;
}
henv = pTestInfo->henv;
hdbc = pTestInfo->hdbc;
hstmt = (SQLHANDLE)pTestInfo->hstmt;
returncode = SQLAllocHandle(SQL_HANDLE_STMT, (SQLHANDLE)hdbc, &hstmt);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocHandle"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
FullDisconnect3(pTestInfo);
TEST_RETURN;
}
returncode = SQLGetInfo(hdbc, SQL_SERVER_NAME, (SQLPOINTER)&ServerName, NAME_LEN, &serLen);
strncpy(SerName, ServerName+1, 3);
SerName[3] = '\0';
/* sq: This test calls SQLProcedures() with wildcard characters. It
* needs its own empty schema to create the procedures, Otherwise the
* standard schema that everybody uses may already have other procedures
* created and will be returned by SQLProcedures() to confuse the test.
*/
sprintf (createSchStr, "CREATE SCHEMA %s.%s", pTestInfo->Catalog, myTestSch);
sprintf (setSchStr, "SET SCHEMA %s.%s", pTestInfo->Catalog, myTestSch);
sprintf (dropSchStr, "DROP SCHEMA %s.%s cascade", pTestInfo->Catalog, myTestSch);
returncode = SQLExecDirect(hstmt,(SQLCHAR*) dropSchStr,SQL_NTS);
returncode = SQLExecDirect(hstmt,(SQLCHAR*) createSchStr,SQL_NTS);
returncode = SQLExecDirect(hstmt,(SQLCHAR*) setSchStr,SQL_NTS);
ProcStr = (char *)malloc(MAX_NOS_SIZE);
while (_stricmp(CreateProc[i].DropProc,"endloop") != 0)
{
sprintf(ProcStr,"%s",CreateProc[i].DropProc);
returncode = SQLExecDirect(hstmt,(SQLCHAR*) ProcStr,SQL_NTS); // cleanup
sprintf(ProcStr,"%s",CreateProc[i].CrtProc);
replace_str(ProcStr,"$$$",SerName);
sprintf(Heading,"Procedure => %s\n",ProcStr);
TESTCASE_BEGIN(Heading);
returncode = SQLExecDirect(hstmt,(SQLCHAR*)ProcStr,SQL_NTS);
if(returncode != SQL_SUCCESS)
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt);
}
TESTCASE_END;
i++;
}
sprintf(Heading,"Test Positive Functionality of SQLProcedures \n");
TESTCASE_BEGIN(Heading);
returncode = SQLProcedures(hstmt,(SQLCHAR*)pTestInfo->Catalog,(SWORD)strlen(pTestInfo->Catalog),(SQLCHAR*)myTestSch/*pTestInfo->Schema*/,(SWORD)strlen(myTestSch/*pTestInfo->Schema*/),(SQLCHAR *)"%",(SWORD)1);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLProcedures"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt);
}
if (returncode == SQL_SUCCESS)
{
strcpy(opqua,"");
strcpy(opowner,"");
strcpy(opname,"");
onuminpar = 0;
onumoutpar = 0;
onumresset = 0;
strcpy(oremark,"");
optype = 0;
SQLBindCol(hstmt,1,SQL_C_CHAR,opqua,NAME_LEN,&opqualen);
SQLBindCol(hstmt,2,SQL_C_CHAR,opowner,NAME_LEN,&opownerlen);
SQLBindCol(hstmt,3,SQL_C_CHAR,opname,NAME_LEN,&opnamelen);
SQLBindCol(hstmt,4,SQL_C_SHORT,&onuminpar,0,&onuminparlen);
SQLBindCol(hstmt,5,SQL_C_SHORT,&onumoutpar,0,&onumoutparlen);
SQLBindCol(hstmt,6,SQL_C_SHORT,&onumresset,0,&onumressetlen);
SQLBindCol(hstmt,7,SQL_C_CHAR,oremark,NAME_LEN,&oremarklen);
SQLBindCol(hstmt,8,SQL_C_SHORT,&optype,0,&optypelen);
k = 0;
i = 0;
while (returncode == SQL_SUCCESS)
{
if(strcmp(Procedure[i].ProcName,"endloop") == 0)
break;
returncode = SQLFetch(hstmt);
if((returncode!=SQL_NO_DATA_FOUND) &&(!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch")))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
if (returncode == SQL_SUCCESS)
{
k++;
sprintf(Heading,"SQLProcedures: Comparing Results\n");
TESTCASE_BEGIN(Heading);
if ((_stricmp(pTestInfo->Catalog,opqua) == 0)
&& (_stricmp(myTestSch/*pTestInfo->Schema*/,opowner) == 0)
&& (_stricmp(Procedure[i].ProcName,opname) == 0)
&& (Procedure[i].NumInParams == onuminpar)
&& (Procedure[i].NumOutParams == onumoutpar)
&& (Procedure[i].NumResSet == onumresset)
&& (_stricmp(Procedure[i].Remark,oremark) == 0)
&& (ProcType == optype))
{
//LogMsg(NONE,"Catalog Name expect: %s and actual: %s are matched\n",pTestInfo->Catalog,opqua);
//LogMsg(NONE,"Schema Name expect: %s and actual: %s are matched\n",pTestInfo->Schema,opowner);
//LogMsg(NONE,"ProcName expect: %s and actual: %s are matched\n",Procedure[i].ProcName,opname);
//LogMsg(NONE,"NumInParams expect: %d and actual: %d are matched\n",Procedure[i].NumInParams,onuminpar);
//LogMsg(NONE,"NumOutParams expect: %d and actual: %d are matched\n",Procedure[i].NumOutParams,onumoutpar);
//LogMsg(NONE,"NumResSet expect: %d and actual: %d are matched\n",Procedure[i].NumResSet, onumresset);
//LogMsg(NONE,"Remark expect: %s and actual: %s are matched\n",Procedure[i].Remark,oremark);
//LogMsg(NONE,"ProcType expect: %d and actual: %d are matched\n",ProcType,optype);
}
else
{
TEST_FAILED;
if (_stricmp(pTestInfo->Catalog,opqua) != 0)
LogMsg(ERRMSG,"Catalog Name expect: %s and actual: %s are not matched\n",pTestInfo->Catalog,opqua);
if (_stricmp(myTestSch/*pTestInfo->Schema*/,opowner) != 0)
LogMsg(ERRMSG,"Schema Name expect: %s and actual: %s are not matched\n",myTestSch/*pTestInfo->Schema*/,opowner);
if (_stricmp(Procedure[i].ProcName,opname) != 0)
LogMsg(ERRMSG,"ProcName expect: %s and actual: %s are not matched\n",Procedure[i].ProcName,opname);
if (Procedure[i].NumInParams != onuminpar)
LogMsg(ERRMSG,"NumInParams expect: %d and actual: %d are not matched\n",Procedure[i].NumInParams,onuminpar);
if (Procedure[i].NumOutParams != onumoutpar)
LogMsg(ERRMSG,"NumOutParams expect: %d and actual: %d are not matched\n",Procedure[i].NumOutParams,onumoutpar);
if (Procedure[i].NumResSet != onumresset)
LogMsg(ERRMSG,"NumResSet expect: %d and actual: %d are not matched\n",Procedure[i].NumResSet, onumresset);
if (_stricmp(Procedure[i].Remark,oremark) != 0)
LogMsg(ERRMSG,"Remark expect: %s and actual: %s are not matched\n",Procedure[i].Remark,oremark);
if (ProcType != optype)
LogMsg(ERRMSG,"ProcType expect: %d and actual: %d are not matched\n",ProcType,optype);
}
}
}
if(k == 0)
{
TEST_FAILED;
LogMsg(ERRMSG,"No Data Found => Atleast one row should be fetched\n");
}
TESTCASE_END;
i++;
} // while
}
SQLFreeStmt(hstmt,SQL_UNBIND);
SQLFreeStmt(hstmt,SQL_CLOSE);
//========================================================================================================
sprintf(Heading,"SQLProcedures: Negative test with NULL handle\n");
TESTCASE_BEGIN(Heading);
hstmt = (SQLHANDLE)NULL;
strcpy(ProcName,"junkproc");
returncode = SQLProcedures(hstmt,(SQLCHAR*)pTestInfo->Catalog,(SWORD)strlen(pTestInfo->Catalog),(SQLCHAR*)myTestSch/*pTestInfo->Schema*/,(SWORD)strlen(myTestSch/*pTestInfo->Schema*/),(SQLCHAR*)ProcName,(SWORD)strlen(ProcName));
if(!CHECKRC(SQL_INVALID_HANDLE,returncode,"SQLProcedures"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt);
}
returncode = SQLExecDirect(hstmt,(SQLCHAR*) dropSchStr,SQL_NTS);
TESTCASE_END;
//========================================================================================================
free(ProcStr);
FullDisconnect3(pTestInfo);
LogMsg(SHORTTIMESTAMP+LINEAFTER,"End testing API => MX Specific SQLProcedures.\n");
TEST_RETURN;
}
/*
---------------------------------------------------------
TestSQLGetDescRec
---------------------------------------------------------
*/
PassFail TestMXSQLGetDescRec(TestInfo *pTestInfo)
{
TEST_DECLARE;
RETCODE returncode;
SQLHANDLE henv;
SQLHANDLE hdbc;
SQLHANDLE hstmt, hstmt1;
//Common input params to the apis
SQLHDESC hIrd, hImArd, hImIrd, hImApd, hImIpd, hExArd, hExApd;
SWORD RecNumber = 0;
//SQLGetDescRec: params
SQLHDESC getDescRecHandle; //input
SWORD getDescRecNumber; //input
TCHAR getDescName[MAXLEN];
SWORD getNameMaxLength; //input; MAXLEN = 100 : defined in Common.h
SWORD getDescNameActualLength;
SQLSMALLINT getDescType;
SWORD getDescIntervalCode;
SQLLEN getDescOctectLength;
SWORD getDescPrecision;
SWORD getDescScale;
SWORD getDescNullable;
//SQLSetDescRec: params
SQLHDESC setDescRecHandle;
SQLSMALLINT setDescRecNumber;
SQLSMALLINT setDescType;
SQLSMALLINT setDescIntervalCode;
SQLINTEGER setDescOctetLength;
SQLSMALLINT setDescPrecision;
SQLSMALLINT setDescScale;
SQLPOINTER setDescDataPtr;
SQLLEN setDescOctectLengthPtr;
SQLLEN setDescIndicatorPtr;
TCHAR setDescName[1];
SQLINTEGER setDescNullable = SQL_NULL_DATA;
short int i;
// Template for a Descriptor record
typedef struct {
// TCHAR DescName[MAXLEN];
TCHAR *DescName;
short int DescType;
short int DescDatetimeIntervalCode;
short int DescOctetLength;
short int DescPrecision;
short int DescScale;
void* DescDataPtr;
short int DescOctectLengthPtr;
short int DescIndicatorPtr;
short int DescNullable;
}DescRec;
DescRec TestDataAPD[DATA_ARR_LEN] =
{
//APD
// DescName Type DatetimeIntervalCode DescOctetLength Precision DescScale DescDataPtr OctectLengthPtr IndicatorPtr DescNullable
{_T(""), SQL_C_DEFAULT, 0, 0, 0, 0, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN },
{_T(""), SQL_C_TCHAR, 0, 80, 0, 0, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN },
{_T(""), SQL_C_TCHAR, 0, 300, 0, 0, NULL, SQL_NTS, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN },
{_T(""), SQL_C_NUMERIC, 0, 0, 0, 0, NULL, SQL_DATA_AT_EXEC, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN },
{_T(""), SQL_C_TYPE_TIMESTAMP, SQL_CODE_TIMESTAMP, 0, 6, 1, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN },
{_T(""), SQL_C_INTERVAL_SECOND, SQL_CODE_SECOND, 0, 2, 0, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }
};
DescRec TestDataARD[DATA_ARR_LEN] =
{
//ARD
// DescName Type DatetimeIntervalCode DescOctetLength Precision DescScale DescDataPtr OctectLengthPtr IndicatorPtr DescNullable
{_T(""), SQL_C_DEFAULT, 0, 0, 0, 0, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN },
{_T(""), SQL_C_TCHAR, 0, 80, 0, 0, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN },
{_T(""), SQL_C_TCHAR, 0, 300, 0, 0, NULL, SQL_NTS, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN },
{_T(""), SQL_C_NUMERIC, 0, 0, 0, 0, NULL, SQL_DATA_AT_EXEC, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN },
{_T(""), SQL_C_TYPE_TIMESTAMP, SQL_CODE_TIMESTAMP, 0, 6, 1, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN },
{_T(""), SQL_C_INTERVAL_SECOND, SQL_CODE_SECOND, 0, 2, 0, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }
};
DescRec TestDataIPD[DATA_ARR_LEN] =
{
//IPD
// DescName Type DatetimeIntervalCode DescOctetLength Precision DescScale DescDataPtr OctectLengthPtr IndicatorPtr DescNullable
{_T(""), SQL_C_DEFAULT, 0, 0, 0, 0, 0, 0, 0, SQL_NULLABLE_UNKNOWN },
{_T(""), SQL_TCHAR, 0, 80, 0, 0, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN },
{_T(""), SQL_TCHAR, 0, 300, 0, 0, NULL, SQL_NTS, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN },
{_T(""), SQL_NUMERIC, 0, 0, 0, 0, NULL, SQL_DATA_AT_EXEC, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN },
{_T(""), SQL_TYPE_TIMESTAMP, SQL_CODE_TIMESTAMP, 0, 6, 1, 0, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN },
{_T(""), SQL_INTERVAL_SECOND, SQL_CODE_SECOND, 0, 2, 0, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }
};
DescRec TestDataIRD[DATA_ARR_LEN] =
{
//IRD can only be read
// DescName Type DatetimeIntervalCode DescOctetLength Precision DescScale DescDataPtr OctectLengthPtr IndicatorPtr DescNullable
{_T(""), SQL_C_DEFAULT, 0, 0, 0, 0, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN },
{_T(""), SQL_C_TCHAR, 0, 80, 0, 0, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN },
{_T(""), SQL_C_TCHAR, 0, 300, 0, 0, NULL, SQL_NTS, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN },
{_T(""), SQL_C_NUMERIC, 0, 0, 0, 0, NULL, SQL_DATA_AT_EXEC, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN },
{_T(""), SQL_C_TIMESTAMP, SQL_CODE_TIMESTAMP, 0, 6, 1, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN },
{_T(""), SQL_C_INTERVAL_SECOND, SQL_CODE_SECOND, 0, 2, 0, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }
};
_tcscpy(setDescName, _T(""));
// ================================================================================================================
// begin common test setup
//==================================================================================================================
LogMsg(LINEBEFORE+SHORTTIMESTAMP,_T("Begin testing API => SQLSetDescRec and SQLGetDescRec.\n"));
TEST_INIT;
if(!FullConnectWithOptions(pTestInfo, CONNECT_ODBC_VERSION_3))
{
LogMsg(NONE,_T("Unable to connect\n"));
TEST_FAILED;
TEST_RETURN;
}
henv = pTestInfo->henv;
hdbc = pTestInfo->hdbc;
returncode = SQLAllocHandle(SQL_HANDLE_STMT, (SQLHANDLE)hdbc, &hstmt);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocHandle"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
FullDisconnect(pTestInfo);
TEST_FAILED;
TEST_RETURN;
}
//Explicit APD
//allocate an Explicit APD desc
returncode = SQLAllocHandle(SQL_HANDLE_DESC, (SQLHANDLE)hdbc, &hExApd);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocHandle to get explicit APD"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
FullDisconnect(pTestInfo);
TEST_FAILED;
TEST_RETURN;
}
//Explicit ARD
returncode = SQLAllocHandle(SQL_HANDLE_DESC, (SQLHANDLE)hdbc, &hExArd);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocHandle to get explicit ARD"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
FullDisconnect(pTestInfo);
TEST_FAILED;
TEST_RETURN;
}
//===============================================================================================================
// Begin Testing:Positive Test for Implicit APD
//===============================================================================================================
//Get Implicit APD handle
returncode = SQLGetStmtAttr(hstmt, SQL_ATTR_APP_PARAM_DESC, &hImApd, 0, NULL);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetStmtAttr: get APD"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
LogMsg(ERRMSG,_T("Cannot allocate descriptor: Aborting Implicit APD tests.\n"));
TEST_FAILED;
goto ExAPDtests; // transfers control to the next set of tests
}
for (i = 0;i < DATA_ARR_LEN; i++) // i = index to TestDataAPD
{
TESTCASE_BEGIN("Test the positive functionality of SQLSetDescRec and SQLGetDescRec for Implicit APD.\n");
//set multiple Fields
RecNumber = i + 1; //increment the recnumber and thus set the next rec (change SQL_DESC_COUNT)
setDescRecHandle = hImApd ;
setDescRecNumber = RecNumber;
setDescType = TestDataAPD[i].DescType;
setDescIntervalCode = TestDataAPD[i].DescDatetimeIntervalCode;
setDescOctetLength = TestDataAPD[i].DescOctetLength;
setDescPrecision = TestDataAPD[i].DescPrecision;
setDescScale = TestDataAPD[i].DescScale;
setDescDataPtr = TestDataAPD[i].DescDataPtr;
setDescOctectLengthPtr = TestDataAPD[i].DescOctectLengthPtr;
setDescIndicatorPtr = TestDataAPD[i].DescIndicatorPtr;
/*LogMsg(NONE,_T("SQLSetDescRec(handle,%d,%d,%d,%d,%d,%d,%s,%d,%d)\n"),
setDescRecNumber,
setDescType,
setDescIntervalCode,
setDescOctetLength ,
setDescPrecision,
setDescScale,
setDescDataPtr,
setDescOctectLengthPtr,
setDescIndicatorPtr); */
returncode = SQLSetDescRec(setDescRecHandle, setDescRecNumber, setDescType, setDescIntervalCode, setDescOctetLength , setDescPrecision, setDescScale, setDescDataPtr,&setDescOctectLengthPtr, &setDescIndicatorPtr);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetDescRec "))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
LogMsg(ERRMSG,_T("SQLSetDescRec: positive tests for Implicit APD: TestDataAPD['%d'].\n"),i);
//FullDisconnect(pTestInfo);
TEST_FAILED;
//TEST_RETURN;
continue;
}
//Get the Implicit APD Descriptor
//LogMsg(SHORTTIMESTAMP,"SQLGetDescRec: test for Implicit APD.\n");
LogMsg(NONE,_T("SQLSetDescRec / SQLGetDescRec: positive tests for Implicit APD.\n"));
getDescRecHandle = hImApd;
getDescRecNumber = RecNumber;
getNameMaxLength = MAXLEN;
_tcscpy(getDescName ,_T("")); //initialize
setDescNullable = TestDataAPD[i].DescNullable;
returncode = SQLGetDescRec(getDescRecHandle, getDescRecNumber, (SQLTCHAR*)getDescName, getNameMaxLength, &getDescNameActualLength, &getDescType, &getDescIntervalCode, &getDescOctectLength, &getDescPrecision, &getDescScale, &getDescNullable);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetDescRec"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
LogMsg(ERRMSG,_T("SQLGetDescRec: positive tests for Implicit APD: TestDataAPD['%d'].\n"),i);
//FullDisconnect(pTestInfo);
TEST_FAILED;
//TEST_RETURN;
continue;
}
//begin checking APD values ----------
//check SQL_DESC_NAME
if (!(_tcscmp(getDescName, setDescName)))
{
LogMsg(NONE,_T("SQL_DESC_NAME value returned is '%s'\n"),getDescName);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_NAME: '%s' and actual: '%s' are not matched\n"), setDescName,getDescName);
}
//check SQL_DESC_TYPE
if (getDescType == setDescType)
{
LogMsg(NONE,_T("SQL_DESC_TYPE value returned is '%d'\n"),getDescType);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_TYPE: '%d' and actual: '%d' are not matched\n"), setDescType, getDescType);
}
//check SQL_DESC_DATETIME_INTERVAL_CODE
if (getDescIntervalCode == setDescIntervalCode)
{
LogMsg(NONE,_T("SQL_DESC_DATETIME_INTERVAL_CODE value returned is '%d'\n"),getDescIntervalCode);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_DATETIME_INTERVAL_CODE: '%d' and actual: '%d' are not matched\n"), setDescIntervalCode, getDescIntervalCode);
}
//check SQL_DESC_OCTECT_LENGTH
if (getDescOctectLength == setDescOctetLength)
{
LogMsg(NONE,_T("SQL_DESC_OCTECT_LENGTH value returned is '%d'\n"),getDescOctectLength);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_OCTECT_LENGTH: '%d' and actual: '%d' are not matched\n"), setDescOctetLength,getDescOctectLength);
}
//check SQL_DESC_PRECISION
if (getDescPrecision == setDescPrecision)
{
LogMsg(NONE,_T("SQL_DESC_PRECISION value returned is '%d'\n"),getDescPrecision);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_PRECISION: '%d' and actual: '%d' are not matched\n"), setDescPrecision,getDescPrecision);
}
//check SQL_DESC_SCALE
if (getDescScale == setDescScale)
{
LogMsg(NONE,_T("SQL_DESC_SCALE value returned is '%d'\n"),getDescScale);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_SCALE: '%d' and actual: '%d' are not matched\n"), setDescScale,getDescScale);
}
//check SQL_DESCNULLABLE
if (getDescNullable == setDescNullable)
{
LogMsg(NONE,_T("SQL_DESC_NULLABLE value returned is '%d'\n"),getDescNullable);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_NULLABLE: '%d' and actual: '%d' are not matched\n"), setDescNullable, getDescNullable);
}
// end of checks
TESTCASE_END;
} //end for loop; end of positive tests for APD
//===============================================================================================================
// Begin Testing:Positive Test for Explicit APD
//===============================================================================================================
ExAPDtests: ; // beginning next set of tests
//mark the beginning of tests in log file
//LogMsg(SHORTTIMESTAMP, "Test the positive functionality of SQLSetDescRec and SQLGetDescRec for Explicit APD.\n");
//Get Explicit APD handle
returncode = SQLAllocHandle(SQL_HANDLE_DESC, (SQLHANDLE)hdbc, &hExApd);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocHandle: get Explicit APD"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
LogMsg(ERRMSG,_T("Cannot allocate descriptor: Aborting Explicit APD tests.\n"));
TEST_FAILED;
//TEST_RETURN;
goto ARDtests; // transfers control to the next set of tests
}
//associate with a statement
returncode = SQLSetStmtAttr(hstmt, SQL_ATTR_APP_PARAM_DESC, (SQLPOINTER)hExApd, SQL_IS_POINTER);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetStmtAttr: explicit APD"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
LogMsg(ERRMSG, _T("Cannot set Explicit APD for statement.\n"));
TEST_FAILED;
}
setDescRecHandle = hExApd ;
for (i = 0;i < DATA_ARR_LEN; i++) // i = index to TestDataAPD
{
TESTCASE_BEGIN("Test the positive functionality of SQLSetDescRec and SQLGetDescRec for Explicit APD.\n");
//set multiple Fields
RecNumber = i + 1; //increment the recnumber and thus set the next rec (change SQL_DESC_COUNT)
setDescRecNumber = RecNumber;
setDescType = TestDataAPD[i].DescType;
setDescIntervalCode = TestDataAPD[i].DescDatetimeIntervalCode;
setDescOctetLength = TestDataAPD[i].DescOctetLength;
setDescPrecision = TestDataAPD[i].DescPrecision;
setDescScale = TestDataAPD[i].DescScale;
setDescDataPtr = TestDataAPD[i].DescDataPtr;
setDescOctectLengthPtr = TestDataAPD[i].DescOctectLengthPtr;
setDescIndicatorPtr = TestDataAPD[i].DescIndicatorPtr;
/*LogMsg(NONE,_T("SQLSetDescRect(handle,%d,%d,%d,%d,%d,%d,%s,%d,%d)\n"),
setDescRecNumber,
setDescType,
setDescIntervalCode,
setDescOctetLength ,
setDescPrecision,
setDescScale,
setDescDataPtr,
setDescOctectLengthPtr,
setDescIndicatorPtr);*/
returncode = SQLSetDescRec(setDescRecHandle, setDescRecNumber, setDescType, setDescIntervalCode, setDescOctetLength , setDescPrecision, setDescScale, setDescDataPtr,&setDescOctectLengthPtr, &setDescIndicatorPtr);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetDescRec"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
LogMsg(ERRMSG,_T("SQLSetDescRec: positive tests for Explicit APD: TestDataAPD['%d'].\n"),i);
TEST_FAILED;
//TEST_RETURN;
continue;
}
//Get the Explicit APD Descriptor
//LogMsg(SHORTTIMESTAMP,"SQLGetDescRec: test for Implicit APD.\n");
LogMsg(NONE,_T("SQLSetDescRec / SQLGetDescRec: positive tests for Explicit APD.\n"));
getDescRecHandle = setDescRecHandle;
getDescRecNumber = RecNumber;
getNameMaxLength = MAXLEN;
_tcscpy(getDescName ,_T("")); //initialize
setDescNullable = TestDataAPD[i].DescNullable;
returncode = SQLGetDescRec(getDescRecHandle, getDescRecNumber, (SQLTCHAR*)getDescName, getNameMaxLength, &getDescNameActualLength, &getDescType, &getDescIntervalCode, &getDescOctectLength, &getDescPrecision, &getDescScale, &getDescNullable);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetDescRec and SQLGetDescRec"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
LogMsg(ERRMSG,_T("SQLGetDescRec: positive tests for Explicit APD: TestDataAPD['%d'].\n"),i);
TEST_FAILED;
continue;
}
//begin checking APD values
//check SQL_DESC_NAME
if (!(_tcscmp(getDescName, setDescName)))
{
LogMsg(NONE,_T("SQL_DESC_NAME value returned is '%s'\n"),getDescName);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_NAME: '%s' and actual: '%s' are not matched\n"), setDescName,getDescName);
}
//check SQL_DESC_TYPE
if (getDescType == setDescType)
{
LogMsg(NONE,_T("SQL_DESC_TYPE value returned is '%d'\n"),getDescType);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_TYPE: '%d' and actual: '%d' are not matched\n"), setDescType, getDescType);
}
//check SQL_DESC_DATETIME_INTERVAL_CODE
if (getDescIntervalCode == setDescIntervalCode)
{
LogMsg(NONE,_T("SQL_DESC_DATETIME_INTERVAL_CODE value returned is '%d'\n"),getDescIntervalCode);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_DATETIME_INTERVAL_CODE: '%d' and actual: '%d' are not matched\n"), setDescIntervalCode, getDescIntervalCode);
}
//check SQL_DESC_OCTECT_LENGTH
if (getDescOctectLength == setDescOctetLength)
{
LogMsg(NONE,_T("SQL_DESC_OCTECT_LENGTH value returned is '%d'\n"),getDescOctectLength);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_OCTECT_LENGTH: '%d' and actual: '%d' are not matched\n"), setDescOctetLength,getDescOctectLength);
}
//check SQL_DESC_PRECISION
if (getDescPrecision == setDescPrecision)
{
LogMsg(NONE,_T("SQL_DESC_PRECISION value returned is '%d'\n"),getDescPrecision);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_PRECISION: '%d' and actual: '%d' are not matched\n"), setDescPrecision,getDescPrecision);
}
//check SQL_DESC_SCALE
if (getDescScale == setDescScale)
{
LogMsg(NONE,_T("SQL_DESC_SCALE value returned is '%d'\n"),getDescScale);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_SCALE: '%d' and actual: '%d' are not matched\n"), setDescScale,getDescScale);
}
//check SQL_DESCNULLABLE
if (getDescNullable == setDescNullable)
{
LogMsg(NONE,_T("SQL_DESC_NULLABLE value returned is '%d'\n"),getDescNullable);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_NULLABLE: '%d' and actual: '%d' are not matched\n"), setDescNullable, getDescNullable);
}
// end of checks
TESTCASE_END;
} //end for loop; end of positive tests for Explicit APD
//===============================================================================================================
// Begin Testing: Statement reverts to Implicit APD after freeing Explicit Descriptor
//===============================================================================================================
//mark the beginning of tests in log file
//LogMsg(SHORTTIMESTAMP, "SQLGetDescRec for Explicit-Implicit APD: statement reverts to implicit descriptor after explicit descriptor has been freed.\n");
//free Explicit APD
returncode = SQLFreeHandle(SQL_HANDLE_DESC, hExApd);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFreeHandle (for APD)"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
LogMsg(ERRMSG,_T("Cannot free explicit descriptor: Aborting Explicit-Implicit Descriptor tests.\n"));
TEST_FAILED;
goto ARDtests; // transfers control to the next set of tests
}
//Use the previously allocated Implicit APD handle
getDescRecHandle = hImApd;
TESTCASE_BEGIN("Test that the implicit descriptor get associated with statement after explicit descriptor has been freed.\n");
//set multiple Fields
i = 0;
RecNumber = i + 1; //increment the recnumber and thus set the next rec (change SQL_DESC_COUNT)
setDescRecNumber = RecNumber;
setDescType = TestDataAPD[i].DescType;
setDescIntervalCode = TestDataAPD[i].DescDatetimeIntervalCode;
setDescOctetLength = TestDataAPD[i].DescOctetLength;
setDescPrecision = TestDataAPD[i].DescPrecision;
setDescScale = TestDataAPD[i].DescScale;
setDescDataPtr = TestDataAPD[i].DescDataPtr;
setDescOctectLengthPtr = TestDataAPD[i].DescOctectLengthPtr;
setDescIndicatorPtr = TestDataAPD[i].DescIndicatorPtr;
//Get the Implicit APD Descriptor
LogMsg(NONE,_T("SQLGetDescRec: tests for Explicit-Implicit Descriptor.\n"));
getDescRecNumber = RecNumber;
getNameMaxLength = MAXLEN;
_tcscpy(getDescName ,_T("")); //initialize
setDescNullable = TestDataAPD[i].DescNullable;
returncode = SQLGetDescRec(getDescRecHandle, getDescRecNumber, (SQLTCHAR*)getDescName, getNameMaxLength, &getDescNameActualLength, &getDescType, &getDescIntervalCode, &getDescOctectLength, &getDescPrecision, &getDescScale, &getDescNullable);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetDescRec"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
LogMsg(ERRMSG,_T("SQLGetDescRec: tests for Explicit-Implicit APD: TestDataAPD['%d'].\n"),i);
TEST_FAILED;
//continue;
}
//begin checking APD values ----------
//check SQL_DESC_NAME
if (!(_tcscmp(getDescName, setDescName)))
{
LogMsg(NONE,_T("SQL_DESC_NAME value returned is '%s'\n"),getDescName);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_NAME: '%s' and actual: '%s' are not matched\n"), setDescName,getDescName);
}
//check SQL_DESC_TYPE
if (getDescType == setDescType)
{
LogMsg(NONE,_T("SQL_DESC_TYPE value returned is '%d'\n"),getDescType);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_TYPE: '%d' and actual: '%d' are not matched\n"), setDescType, getDescType);
}
//check SQL_DESC_DATETIME_INTERVAL_CODE
if (getDescIntervalCode == setDescIntervalCode)
{
LogMsg(NONE,_T("SQL_DESC_DATETIME_INTERVAL_CODE value returned is '%d'\n"),getDescIntervalCode);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_DATETIME_INTERVAL_CODE: '%d' and actual: '%d' are not matched\n"), setDescIntervalCode, getDescIntervalCode);
}
//check SQL_DESC_OCTECT_LENGTH
if (getDescOctectLength == setDescOctetLength)
{
LogMsg(NONE,_T("SQL_DESC_OCTECT_LENGTH value returned is '%d'\n"),getDescOctectLength);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_OCTECT_LENGTH: '%d' and actual: '%d' are not matched\n"), setDescOctetLength,getDescOctectLength);
}
//check SQL_DESC_PRECISION
if (getDescPrecision == setDescPrecision)
{
LogMsg(NONE,_T("SQL_DESC_PRECISION value returned is '%d'\n"),getDescPrecision);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_PRECISION: '%d' and actual: '%d' are not matched\n"), setDescPrecision,getDescPrecision);
}
//check SQL_DESC_SCALE
if (getDescScale == setDescScale)
{
LogMsg(NONE,_T("SQL_DESC_SCALE value returned is '%d'\n"),getDescScale);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_SCALE: '%d' and actual: '%d' are not matched\n"), setDescScale,getDescScale);
}
//check SQL_DESCNULLABLE
if (getDescNullable == setDescNullable)
{
LogMsg(NONE,_T("SQL_DESC_NULLABLE value returned is '%d'\n"),getDescNullable);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_NULLABLE: '%d' and actual: '%d' are not matched\n"), setDescNullable, getDescNullable);
}
// end of checks
TESTCASE_END;
//==================================================================================================================
// Begin Testing: Positive Test for Implicit ARD
//===================================================================================================================
ARDtests: ;
//mark the beginning of tests in log file
//LogMsg(SHORTTIMESTAMP, "Test the positive functionality of SQLSetDescRec and SQLGetDescRec for Implicit ARD.\n");
//Get Implicit ARD handle
returncode = SQLGetStmtAttr(hstmt, SQL_ATTR_APP_ROW_DESC, &hImArd, 0, NULL);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetStmtAttr: get ARD"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
LogMsg(ERRMSG, _T("Cannot get ARD: Aborting Implicit ARD tests.\n"));
TEST_FAILED;
goto ExARDtests; //go to next set of tests
}
for (i = 0;i < DATA_ARR_LEN; i++) // i = index to TestDataARD
{
TESTCASE_BEGIN("Test the positive functionality of SQLSetDescRec and SQLGetDescRec for Implicit ARD.\n");
//set multiple Fields
RecNumber = i + 1; //increment the recnumber and thus set the next rec (change SQL_DESC_COUNT)
setDescRecHandle = hImArd ;
setDescRecNumber = RecNumber;
setDescType = TestDataARD[i].DescType;
setDescIntervalCode = TestDataARD[i].DescDatetimeIntervalCode;
setDescOctetLength = TestDataARD[i].DescOctetLength;
setDescPrecision = TestDataARD[i].DescPrecision;
setDescScale = TestDataARD[i].DescScale;
setDescDataPtr = TestDataARD[i].DescDataPtr;
setDescOctectLengthPtr = TestDataARD[i].DescOctectLengthPtr;
setDescIndicatorPtr = TestDataARD[i].DescIndicatorPtr;
returncode = SQLSetDescRec(setDescRecHandle, setDescRecNumber, setDescType, setDescIntervalCode, setDescOctetLength , setDescPrecision, setDescScale, setDescDataPtr,&setDescOctectLengthPtr, &setDescIndicatorPtr);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetDescRec and SQLGetDescRec"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
LogMsg(ERRMSG,_T("SQLSetDescRec: positive tests for Implicit ARD: TestDataARD['%d'].\n"),i);
//FullDisconnect(pTestInfo);
TEST_FAILED;
//TEST_RETURN;
continue;
}
//Get the Implicit ARD Descriptor
LogMsg(NONE,_T("SQLSetDescRec / SQLGetDescRec: positive tests for Implicit ARD.\n"));
getDescRecHandle = hImApd;
getDescRecNumber = RecNumber;
getNameMaxLength = MAXLEN;
_tcscpy(getDescName ,_T("")); //initialize
setDescNullable = TestDataARD[i].DescNullable;
returncode = SQLGetDescRec(getDescRecHandle, getDescRecNumber, (SQLTCHAR*)getDescName, getNameMaxLength, &getDescNameActualLength, &getDescType, &getDescIntervalCode, &getDescOctectLength, &getDescPrecision, &getDescScale, &getDescNullable);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetDescRec and SQLGetDescRec"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
LogMsg(ERRMSG,_T("SQLGetDescRec: positive tests for Implicit ARD: TestDataARD['%d'].\n"),i);
//FullDisconnect(pTestInfo);
TEST_FAILED;
//TEST_RETURN;
break;
}
//begin checking ARD values
//check SQL_DESC_NAME
if (!(_tcscmp(getDescName, setDescName)))
{
LogMsg(NONE,_T("SQL_DESC_NAME value returned is '%s'\n"),getDescName);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_NAME: '%s' and actual: '%s' are not matched\n"), setDescName,getDescName);
}
//check SQL_DESC_TYPE
if (getDescType == setDescType)
{
LogMsg(NONE,_T("SQL_DESC_TYPE value returned is '%d'\n"),getDescType);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_TYPE: '%d' and actual: '%d' are not matched\n"), setDescType, getDescType);
}
//check SQL_DESC_DATETIME_INTERVAL_CODE
if (getDescIntervalCode == setDescIntervalCode)
{
LogMsg(NONE,_T("SQL_DESC_DATETIME_INTERVAL_CODE value returned is '%d'\n"),getDescIntervalCode);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_DATETIME_INTERVAL_CODE: '%d' and actual: '%d' are not matched\n"), setDescIntervalCode, getDescIntervalCode);
}
//check SQL_DESC_OCTECT_LENGTH
if (getDescOctectLength == setDescOctetLength)
{
LogMsg(NONE,_T("SQL_DESC_OCTECT_LENGTH value returned is '%d'\n"),getDescOctectLength);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_OCTECT_LENGTH: '%d' and actual: '%d' are not matched\n"), setDescOctetLength,getDescOctectLength);
}
//check SQL_DESC_PRECISION
if (getDescPrecision == setDescPrecision)
{
LogMsg(NONE,_T("SQL_DESC_PRECISION value returned is '%d'\n"),getDescPrecision);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_PRECISION: '%d' and actual: '%d' are not matched\n"), setDescPrecision,getDescPrecision);
}
//check SQL_DESC_SCALE
if (getDescScale == setDescScale)
{
LogMsg(NONE,_T("SQL_DESC_SCALE value returned is '%d'\n"),getDescScale);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_SCALE: '%d' and actual: '%d' are not matched\n"), setDescScale,getDescScale);
}
//check SQL_DESCNULLABLE
if (getDescNullable == setDescNullable)
{
LogMsg(NONE,_T("SQL_DESC_NULLABLE value returned is '%d'\n"),getDescNullable);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_NULLABLE: '%d' and actual: '%d' are not matched\n"), setDescNullable, getDescNullable);
}
// end of checks
TESTCASE_END;
} //end for loop; end of positive tests for ARD
//==================================================================================================================
// Begin Testing: Positive Test for Explicit ARD
//===================================================================================================================
ExARDtests: ;
//mark the beginning of tests in log file
//LogMsg(SHORTTIMESTAMP, "Test the positive functionality of SQLSetDescRec and SQLGetDescRec for Explicit ARD.\n");
//Get Explicit ARD handle
returncode = SQLAllocHandle(SQL_HANDLE_DESC, (SQLHANDLE)hdbc, &hExArd);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocHandle: get explicit ARD"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
LogMsg(ERRMSG, _T("Cannot get ARD: Aborting Implicit ARD tests.\n"));
TEST_FAILED;
goto IPDtests; //go to next set of tests
}
//associate with a statement
returncode = SQLSetStmtAttr(hstmt, SQL_ATTR_APP_ROW_DESC, (SQLPOINTER)hExArd, SQL_IS_POINTER);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetStmtAttr: explicit ARD"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
LogMsg(ERRMSG, _T("Cannot set Explicit ARD for statement.\n"));
TEST_FAILED;
}
for (i = 0;i < DATA_ARR_LEN; i++) // i = index to TestDataARD
{
TESTCASE_BEGIN("Test the positive functionality of SQLSetDescRec and SQLGetDescRec for Explicit ARD.\n");
//set multiple Fields
RecNumber = i + 1; //increment the recnumber and thus set the next rec (change SQL_DESC_COUNT)
setDescRecHandle = hExArd ;
setDescRecNumber = RecNumber;
setDescType = TestDataARD[i].DescType;
setDescIntervalCode = TestDataARD[i].DescDatetimeIntervalCode;
setDescOctetLength = TestDataARD[i].DescOctetLength;
setDescPrecision = TestDataARD[i].DescPrecision;
setDescScale = TestDataARD[i].DescScale;
setDescDataPtr = TestDataARD[i].DescDataPtr;
setDescOctectLengthPtr = TestDataARD[i].DescOctectLengthPtr;
setDescIndicatorPtr = TestDataARD[i].DescIndicatorPtr;
returncode = SQLSetDescRec(setDescRecHandle, setDescRecNumber, setDescType, setDescIntervalCode, setDescOctetLength , setDescPrecision, setDescScale, setDescDataPtr,&setDescOctectLengthPtr, &setDescIndicatorPtr);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetDescRec"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
LogMsg(ERRMSG,_T("SQLSetDescRec: positive tests for Explicit ARD: TestDataARD['%d'].\n"),i);
TEST_FAILED;
continue;
}
//Get the Explicit ARD Descriptor
LogMsg(NONE,_T("SQLSetDescRec and SQLGetDescRec: positive tests for Explicit ARD.\n"));
getDescRecHandle = hExArd;
getDescRecNumber = RecNumber;
getNameMaxLength = MAXLEN;
_tcscpy(getDescName ,_T("")); //initialize
setDescNullable = TestDataARD[i].DescNullable;
returncode = SQLGetDescRec(getDescRecHandle, getDescRecNumber, (SQLTCHAR*)getDescName, getNameMaxLength, &getDescNameActualLength, &getDescType, &getDescIntervalCode, &getDescOctectLength, &getDescPrecision, &getDescScale, &getDescNullable);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetDescRec"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
LogMsg(ERRMSG,_T("SQLGetDescRec: positive tests for Explicit ARD: TestDataARD['%d'].\n"),i);
TEST_FAILED;
break;
}
//begin checking ARD values
//check SQL_DESC_NAME
if (!(_tcscmp(getDescName, setDescName)))
{
LogMsg(NONE,_T("SQL_DESC_NAME value returned is '%s'\n"),getDescName);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_NAME: '%s' and actual: '%s' are not matched\n"), setDescName,getDescName);
}
//check SQL_DESC_TYPE
if (getDescType == setDescType)
{
LogMsg(NONE,_T("SQL_DESC_TYPE value returned is '%d'\n"),getDescType);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_TYPE: '%d' and actual: '%d' are not matched\n"), setDescType, getDescType);
}
//check SQL_DESC_DATETIME_INTERVAL_CODE
if (getDescIntervalCode == setDescIntervalCode)
{
LogMsg(NONE,_T("SQL_DESC_DATETIME_INTERVAL_CODE value returned is '%d'\n"),getDescIntervalCode);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_DATETIME_INTERVAL_CODE: '%d' and actual: '%d' are not matched\n"), setDescIntervalCode, getDescIntervalCode);
}
//check SQL_DESC_OCTECT_LENGTH
if (getDescOctectLength == setDescOctetLength)
{
LogMsg(NONE,_T("SQL_DESC_OCTECT_LENGTH value returned is '%d'\n"),getDescOctectLength);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_OCTECT_LENGTH: '%d' and actual: '%d' are not matched\n"), setDescOctetLength,getDescOctectLength);
}
//check SQL_DESC_PRECISION
if (getDescPrecision == setDescPrecision)
{
LogMsg(NONE,_T("SQL_DESC_PRECISION value returned is '%d'\n"), getDescPrecision);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_PRECISION: '%d' and actual: '%d' are not matched\n"), setDescPrecision,getDescPrecision);
}
//check SQL_DESC_SCALE
if (getDescScale == setDescScale)
{
LogMsg(NONE,_T("SQL_DESC_SCALE value returned is '%d'\n"),getDescScale);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_SCALE: '%d' and actual: '%d' are not matched\n"), setDescScale,getDescScale);
}
//check SQL_DESCNULLABLE
if (getDescNullable == setDescNullable)
{
LogMsg(NONE,_T("SQL_DESC_NULLABLE value returned is '%d'\n"),getDescNullable);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_NULLABLE: '%d' and actual: '%d' are not matched\n"), setDescNullable, getDescNullable);
}
// end of checks
TESTCASE_END;
} //end for loop; end of positive tests for Explicit ARD
//free explicit ARD
returncode = SQLFreeHandle(SQL_HANDLE_DESC, hExArd);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFreeHandle (for ARD)"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
//======================================================================================================================
// Begin Testing: Positive Test for Implicit IPD
//=====================================================================================================================
IPDtests: ;
//mark the beginning of tests in log file
//LogMsg(SHORTTIMESTAMP, "Test the positive functionality of SQLSetDescRec and SQLGetDescRec for Implicit IPD.\n");
//Get Implicit IPD handle
returncode = SQLGetStmtAttr(hstmt, SQL_ATTR_APP_ROW_DESC, &hImIpd, 0, NULL);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetStmtAttr: get IPD"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
LogMsg(ERRMSG, _T("Cannot get IPD: Aborting Implicit IPD tests.\n"));
TEST_FAILED;
goto IRDtests; //go to next set of tests
}
for (i = 0;i < DATA_ARR_LEN; i++) // i = index to TestDataIPD
{
TESTCASE_BEGIN("Test the positive functionality of SQLSetDescRec and SQLGetDescRec for Implicit IPD.\n");
//set multiple Fields
RecNumber = i + 1; //increment the recnumber and thus set the next rec (change SQL_DESC_COUNT)
setDescRecHandle = hImIpd ;
setDescRecNumber = RecNumber;
setDescType = TestDataIPD[i].DescType;
setDescIntervalCode = TestDataIPD[i].DescDatetimeIntervalCode;
setDescOctetLength = TestDataIPD[i].DescOctetLength;
setDescPrecision = TestDataIPD[i].DescPrecision;
setDescScale = TestDataIPD[i].DescScale;
setDescDataPtr = TestDataIPD[i].DescDataPtr;
setDescOctectLengthPtr = TestDataIPD[i].DescOctectLengthPtr;
setDescIndicatorPtr = TestDataIPD[i].DescIndicatorPtr;
returncode = SQLSetDescRec(setDescRecHandle, setDescRecNumber, setDescType, setDescIntervalCode, setDescOctetLength , setDescPrecision, setDescScale, setDescDataPtr,&setDescOctectLengthPtr, &setDescIndicatorPtr);
if(!CHECKRC(SQL_SUCCESS,returncode, "SQLSetDescRec and SQLGetDescRec"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
LogMsg(ERRMSG,_T("SQLSetDescRec: positive tests for Implicit IPD: TestDataIPD['%d'].\n"),i);
//FullDisconnect(pTestInfo);
TEST_FAILED;
//TEST_RETURN;
continue;
}
//Get the Implicit IPD Descriptor
LogMsg(NONE,_T("SQLSetDescRec and SQLGetDescRec: positive tests for Implicit IPD.\n"));
getDescRecHandle = hImApd;
getDescRecNumber = RecNumber;
getNameMaxLength = MAXLEN;
_tcscpy(getDescName ,_T("")); //initialize
setDescNullable = TestDataIPD[i].DescNullable;
returncode = SQLGetDescRec(getDescRecHandle, getDescRecNumber, (SQLTCHAR*)getDescName, getNameMaxLength, &getDescNameActualLength, &getDescType, &getDescIntervalCode, &getDescOctectLength, &getDescPrecision, &getDescScale, &getDescNullable);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetDescRec"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
LogMsg(ERRMSG,_T("SQLGetDescRec: positive tests for Implicit IPD: TestDataIPD['%d'].\n"),i);
//FullDisconnect(pTestInfo);
TEST_FAILED;
//TEST_RETURN;
continue;
}
//begin checking IPD values
//check SQL_DESC_NAME
if (!(_tcscmp(getDescName, setDescName)))
{
LogMsg(NONE,_T("SQL_DESC_NAME value returned is '%s'\n"),getDescName);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_NAME: '%s' and actual: '%s' are not matched\n"), setDescName,getDescName);
}
//check SQL_DESC_TYPE
if (getDescType == setDescType)
{
LogMsg(NONE,_T("SQL_DESC_TYPE value returned is '%d'\n"), getDescType);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_TYPE: '%d' and actual: '%d' are not matched\n"), setDescType, getDescType);
}
//check SQL_DESC_DATETIME_INTERVAL_CODE
if (getDescIntervalCode == setDescIntervalCode)
{
LogMsg(NONE,_T("SQL_DESC_DATETIME_INTERVAL_CODE value returned is '%d'\n"),getDescIntervalCode);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_DATETIME_INTERVAL_CODE: '%d' and actual: '%d' are not matched\n"), setDescIntervalCode, getDescIntervalCode);
}
//check SQL_DESC_OCTECT_LENGTH
if (getDescOctectLength == setDescOctetLength)
{
LogMsg(NONE,_T("SQL_DESC_OCTECT_LENGTH value returned is '%d'\n"),getDescOctectLength);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_OCTECT_LENGTH: '%d' and actual: '%d' are not matched\n"), setDescOctetLength,getDescOctectLength);
}
//check SQL_DESC_PRECISION
if (getDescPrecision == setDescPrecision)
{
LogMsg(NONE,_T("SQL_DESC_PRECISION value returned is '%d'\n"),getDescPrecision);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_PRECISION: '%d' and actual: '%d' are not matched\n"), setDescPrecision,getDescPrecision);
}
//check SQL_DESC_SCALE
if (getDescScale == setDescScale)
{
LogMsg(NONE,_T("SQL_DESC_SCALE value returned is '%d'\n"),getDescScale);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_SCALE: '%d' and actual: '%d' are not matched\n"), setDescScale,getDescScale);
}
//check SQL_DESCNULLABLE
if (getDescNullable == setDescNullable)
{
LogMsg(NONE,_T("SQL_DESC_NULLABLE value returned is '%d'\n"),getDescNullable);
}
else
{
TEST_FAILED;
LogMsg(ERRMSG, _T("expect SQL_DESC_NULLABLE: '%d' and actual: '%d' are not matched\n"), setDescNullable, getDescNullable);
}
// end of checks
TESTCASE_END;
} //end for loop; end of positive tests for IPD
//==================================================================================================================
// Begin Testing: Posituve Tests for IRD (IRD Desc Fields are read only)
//==================================================================================================================
IRDtests: ;
//mark the beginning of tests in log file
//LogMsg(SHORTTIMESTAMP, "Test the positive functionality of SQLSetDescRec and SQLGetDescRec for Implicit IRD.\n");
//Get Implicit IRD handle
returncode = SQLGetStmtAttr(hstmt, SQL_ATTR_IMP_ROW_DESC, &hImIrd, 0, NULL);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetStmtAttr"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
LogMsg(ERRMSG, _T("Cannot get IRD: Aborting Implicit IRD tests.\n"));
TEST_FAILED;
// TEST_RETURN; //this will abort tests and perform a full disconnect.
}
//---------------------------------------------------------------------------------------------------------
TESTCASE_BEGIN("Test SQLSetDescRec for Implicit IRD: IRD Descriptor Fields cannot be set by the application.\n");
//set multiple Fields
RecNumber = i + 1; //increment the recnumber and thus set the next rec (change SQL_DESC_COUNT)
setDescRecHandle = hImIrd ;
setDescRecNumber = RecNumber;
setDescType = TestDataIRD[i].DescType;
setDescIntervalCode = TestDataIRD[i].DescDatetimeIntervalCode;
setDescOctetLength = TestDataIRD[i].DescOctetLength;
setDescPrecision = TestDataIRD[i].DescPrecision;
setDescScale = TestDataIRD[i].DescScale;
setDescDataPtr = TestDataIRD[i].DescDataPtr;
setDescOctectLengthPtr = TestDataIRD[i].DescOctectLengthPtr;
setDescIndicatorPtr = TestDataIRD[i].DescIndicatorPtr;
returncode = SQLSetDescRec(setDescRecHandle, setDescRecNumber, setDescType, setDescIntervalCode, setDescOctetLength , setDescPrecision, setDescScale, setDescDataPtr,&setDescOctectLengthPtr, &setDescIndicatorPtr);
if(!CHECKRC(SQL_ERROR,returncode,"SQLSetDescRec"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
TESTCASE_END;
//-------------------------------------------------------------------------------------------------------------
TESTCASE_BEGIN("Test SQLGetDescRec for Implicit IRD: IRD Descriptor Fields not populated before call to DB.\n");
//This testcases use the Implicit IRD handle obtained in previous testcase
returncode = SQLGetDescRec(hImIrd, 1, (SQLTCHAR*)getDescName, MAXLEN, &getDescNameActualLength, &getDescType, &getDescIntervalCode, &getDescOctectLength, &getDescPrecision, &getDescScale, &getDescNullable);
if(!CHECKRC(SQL_NO_DATA_FOUND,returncode,"SQLGetDescField"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
//TEST_RETURN; //last test: valid to use TEST_RETURN when the test suite must be exited.
}
TESTCASE_END;
//===============================================================================================================
// Begin Testing:Positive Test for populated Implicit IRD
//===============================================================================================================
TESTCASE_BEGIN("Test SQLGetDescRec for populated Implicit IRD.\n");
//mark the beginning of tests in log file
//LogMsg(SHORTTIMESTAMP, "Test the positive functionality of (SQLSetDescRec) and SQLGetDescRec for Implicit IRD.\n");
//alloc new handle
returncode = SQLAllocHandle(SQL_HANDLE_STMT, (SQLHANDLE)hdbc, &hstmt1);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocHandle"))
{
LogAllErrorsVer3(henv,hdbc,hstmt1);
LogMsg(ERRMSG,_T("Cannot allocate statement: Aborting populated Implicit IRD tests.\n"));
FullDisconnect(pTestInfo);
TEST_FAILED;
goto Cleanup; // transfers control to the next set
}
//Get Implicit IRD handle
returncode = SQLGetStmtAttr(hstmt, SQL_ATTR_APP_PARAM_DESC, &hIrd, 0, NULL);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetStmtAttr: get IRD"))
{
LogAllErrorsVer3(henv,hdbc,hstmt1);
LogMsg(ERRMSG,_T("Cannot allocate descriptor: Aborting populated Implicit IRD tests.\n"));
TEST_FAILED;
goto Cleanup; // transfers control to the next set
}
//populate the IRD by executing an catalog api
returncode = SQLGetTypeInfo(hstmt1, SQL_ALL_TYPES);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetTypeInfo: population of IRD"))
{
LogAllErrorsVer3(henv,hdbc,hstmt1);
LogMsg(ERRMSG,_T("Cannot execute statement: Aborting populated Implicit IRD tests.\n"));
TEST_FAILED;
goto Cleanup; // transfers control to the next set
}
//check IRD
returncode = SQLGetDescRec(hIrd, 1, (SQLTCHAR*)getDescName, MAXLEN, &getDescNameActualLength, &getDescType, &getDescIntervalCode, &getDescOctectLength, &getDescPrecision, &getDescScale, &getDescNullable);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetDescField"))
{
LogAllErrorsVer3(henv,hdbc,hstmt1);
TEST_FAILED;
//TEST_RETURN; //last test: valid to use TEST_RETURN when the test suite must be exited.
}
TESTCASE_END;
// free implicitly allocated descriptors by freeing statement
returncode = SQLFreeHandle(SQL_HANDLE_STMT,hstmt1);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFreeHandle"))
{
LogAllErrorsVer3(henv,hdbc,hstmt1);
TEST_FAILED;
}
//===========================================================================================================
// begin cleanup
//==============================================================================================================
Cleanup: ;
// free implicitly allocated descriptors by freeing statement
returncode = SQLFreeHandle(SQL_HANDLE_STMT,hstmt);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFreeHandle"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
FullDisconnect3(pTestInfo);
LogMsg(SHORTTIMESTAMP+LINEAFTER,_T("End testing API => SQLSetDescRec and SQLGetDescRec.\n"));
TEST_RETURN;
} //end of test ****************
/*
------------------------------------------------------------------
TestSQLGetTypeInfo: Tests SQLGetTypeInfo
------------------------------------------------------------------
*/
PassFail TestSQLGetTypeInfoR18(TestInfo *pTestInfo)
{
TEST_DECLARE;
char Heading[MAX_STRING_SIZE];
RETCODE returncode;
SQLHANDLE henv;
SQLHANDLE hdbc;
SQLHANDLE hstmt;
char TempBuf[MAX_STRING_SIZE];
int j = 0,END_LOOP;
struct
{
char *TYPE_NAME;
SWORD DATA_TYPE;
SDWORD PRECISION;
char *LITERAL_PREFIX;
char *LITERAL_SUFFIX;
char *CREATE_PARAMS;
SWORD NULLABLE;
SWORD CASE_SENSITIVE;
SWORD SEARCHABLE;
SWORD UNSIGNED_ATTRIBUTE;
SWORD MONEY;
SWORD AUTO_INCREMENT;
char *LOCAL_TYPE_NAME;
SWORD MINIMUM_SCALE;
SWORD MAXIMUM_SCALE;
} TypeInfo[] =
{//TYPENAME,DATATYPE,PREC,LITPRE,LITSUF,PARAM,NULL,CASE,SRCH,ATTR,MON,INC,LOC,MIN,MAX
{"",SQL_ALL_TYPES,0,"","","",0,0,0,0,0,0,"",0,0}, // this is for get all types
{"CHAR", SQL_CHAR, 254, "'", "'", "max length", SQL_NULLABLE, 1, SQL_SEARCHABLE, 0, 0, 0, "CHARACTER", 0, 0},
{"VARCHAR", SQL_VARCHAR, 254, "'", "'", "max length", SQL_NULLABLE, 1, SQL_SEARCHABLE, 0, 0, 0, "VARCHAR", 0, 0},
{"DECIMAL", SQL_DECIMAL, 18, "", "", "precision,scale", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "DECIMAL", 0, 18},
{"NUMERIC", SQL_NUMERIC, 128, "", "", "precision,scale", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "NUMERIC", 0, 128},
{"SMALLINT", SQL_SMALLINT, 5, "", "", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "SMALLINT", 0, 0},
{"INTEGER", SQL_INTEGER, 10, "", "", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "INTEGER", 0, 0},
{"REAL", SQL_REAL, 7, "", "", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "REAL", 0, 0},
{"FLOAT", SQL_FLOAT, 15, "", "", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "FLOAT", 0, 0},
{"DOUBLE PRECISION", SQL_DOUBLE, 15, "", "", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "DOUBLE", 0, 0},
// {"DATE", SQL_DATE, 10, "{d '", "'}","", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "DATE", 0, 0},
// {"TIME", SQL_TIME, 8, "{t '", "'}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "TIME", 0, 0},
// {"TIMESTAMP", SQL_TIMESTAMP, 23, "{ts '", "'}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "TIMESTAMP", 0, 6},
{"DATE", SQL_TYPE_DATE, 10, "{d '", "'}","", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "DATE", 0, 0},
{"TIME", SQL_TYPE_TIME, 8, "{t '", "'}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "TIME", 0, 0},
{"TIMESTAMP", SQL_TYPE_TIMESTAMP, 26, "{ts '", "'}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "TIMESTAMP", 0, 6},
{"BIGINT", SQL_BIGINT, 19, "", "", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "LARGEINT", 0, 0},
{"LONG VARCHAR", SQL_LONGVARCHAR, 4018, "'", "'", "", SQL_NULLABLE, 1, SQL_SEARCHABLE, 0, 0, 0, "LONG VARCHAR", 0, 0},
// {"BINARY", SQL_BINARY, 4059, "'", "'", "max length", 1, 0, 0, 0, 0, 0, "", 0, 0},
// {"VARBINARY", -3, 4059, "'", "'", "max length", 1, 0, 0, 0, 0, 0, "", 0, 0},
// {"LONG VARBINARY", -4, 4059, "'", "'", "max length", 1, 0, 0, 0, 0, 0, "", 0, 0},
// {"TINYINT", -6, 3, "", "", "", 1, 0, SQL_ALL_EXCEPT_LIKE, 1, 0, 0, "", 0, 0},
// {"BIT", -7, 1, "", "", "", 1, 0, SQL_UNSEARCHABLE, 0, 0, 0, "", 0, 0},
{"INTERVAL", SQL_INTERVAL_YEAR, 0, "{INTERVAL '", "' YEAR}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "INTERVAL", 0, 0},
{"INTERVAL", SQL_INTERVAL_MONTH, 0, "{INTERVAL '", "' MONTH}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "INTERVAL", 0, 0},
{"INTERVAL", SQL_INTERVAL_DAY, 0, "{INTERVAL '", "' DAY}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "INTERVAL", 0, 0},
{"INTERVAL", SQL_INTERVAL_HOUR, 0, "{INTERVAL '", "' HOUR}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "INTERVAL", 0, 0},
{"INTERVAL", SQL_INTERVAL_MINUTE, 0, "{INTERVAL '", "' MINUTE}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "INTERVAL", 0, 0},
{"INTERVAL", SQL_INTERVAL_SECOND, 0, "{INTERVAL '", "' SECOND}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "INTERVAL", 0, 0},
{"INTERVAL", SQL_INTERVAL_YEAR_TO_MONTH, 0, "{INTERVAL '", "' YEAR TO MONTH}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "INTERVAL", 0, 0},
{"INTERVAL", SQL_INTERVAL_DAY_TO_HOUR, 0, "{INTERVAL '", "' DAY TO HOUR}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "INTERVAL", 0, 0},
{"INTERVAL", SQL_INTERVAL_DAY_TO_MINUTE, 0, "{INTERVAL '", "' DAY TO MINUTE}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "INTERVAL", 0, 0},
{"INTERVAL", SQL_INTERVAL_DAY_TO_SECOND, 0, "{INTERVAL '", "' DAY TO SECOND}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "INTERVAL", 0, 0},
{"INTERVAL", SQL_INTERVAL_HOUR_TO_MINUTE, 0, "{INTERVAL '", "' HOUR TO MINUTE}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "INTERVAL", 0, 0},
{"INTERVAL", SQL_INTERVAL_HOUR_TO_SECOND, 0, "{INTERVAL '", "' HOUR TO SECOND}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "INTERVAL", 0, 0},
{"INTERVAL", SQL_INTERVAL_MINUTE_TO_SECOND, 0, "{INTERVAL '", "' MINUTE TO SECOND}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "INTERVAL", 0, 0},
{"",999,}
};
char oTYPE_NAME[TYPE_LEN];
SWORD oDATA_TYPE, fSqlType1;
SDWORD oPRECISION;
char oLITERAL_PREFIX[TYPE_LEN];
char oLITERAL_SUFFIX[TYPE_LEN];
char oCREATE_PARAMS[TYPE_LEN];
SWORD oNULLABLE;
SWORD oCASE_SENSITIVE;
SWORD oSEARCHABLE;
SWORD oUNSIGNED_ATTRIBUTE;
SWORD oMONEY;
SWORD oAUTO_INCREMENT;
char oLOCAL_TYPE_NAME[TYPE_LEN];
SWORD oMINIMUM_SCALE;
SWORD oMAXIMUM_SCALE;
SQLLEN oTYPE_NAMElen;
SQLLEN oDATA_TYPElen;
SQLLEN oPRECISIONlen;
SQLLEN oLITERAL_PREFIXlen;
SQLLEN oLITERAL_SUFFIXlen;
SQLLEN oCREATE_PARAMSlen;
SQLLEN oNULLABLElen;
SQLLEN oCASE_SENSITIVElen;
SQLLEN oSEARCHABLElen;
SQLLEN oUNSIGNED_ATTRIBUTElen;
SQLLEN oMONEYlen;
SQLLEN oAUTO_INCREMENTlen;
SQLLEN oLOCAL_TYPE_NAMElen;
SQLLEN oMINIMUM_SCALElen;
SQLLEN oMAXIMUM_SCALElen;
/* Set up some local variables to save on typing in longer ones */
/* This previously was R1.8 */
//================Modified for Longvarchar Changes===========================================================
if(!pTestInfo->bLongOn)
{
char *TYPE_NAME = "VARCHAR";
SWORD DATA_TYPE = SQL_VARCHAR;
SDWORD PRECISION = 32000;
char *CREATE_PARAMS = "max length";
char *LOCAL_TYPE_NAME = "VARCHAR";
TypeInfo[1].PRECISION = PRECISION;
TypeInfo[2].PRECISION = PRECISION;
TypeInfo[14].TYPE_NAME = TYPE_NAME;
TypeInfo[14].DATA_TYPE = DATA_TYPE;
TypeInfo[14].PRECISION = PRECISION;
TypeInfo[14].CREATE_PARAMS = CREATE_PARAMS;
TypeInfo[14].LOCAL_TYPE_NAME = LOCAL_TYPE_NAME;
}
//================Modified for Longvarhcar Changes===========================================================
LogMsg(LINEBEFORE+SHORTTIMESTAMP,"Begin testing API =>SQLGetTypeInfo30 | SQLGetTypeInfo3 | gettypeiR18.c\n");
TEST_INIT;
TESTCASE_BEGIN("Setup for SQLGetTypeInfo tests for ODBC 3.0\n");
if(!FullConnectWithOptions(pTestInfo, CONNECT_ODBC_VERSION_3))
{
LogMsg(NONE,"Unable to connect\n");
TEST_FAILED;
TEST_RETURN;
}
/* Set up some local variables to save on typing in longer ones */
henv = pTestInfo->henv;
hdbc = pTestInfo->hdbc;
hstmt = (SQLHANDLE)pTestInfo->hstmt;
returncode = SQLAllocHandle(SQL_HANDLE_STMT, (SQLHANDLE)hdbc, &hstmt);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocHandle")){
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
TEST_RETURN;
}
TESTCASE_END; // end of setup
//=========================================================================================
/* if (MX_MP_SPECIFIC == MX_SPECIFIC)
END_LOOP = SQL_BINARY;
else if (MX_MP_SPECIFIC == MP_SPECIFIC)
END_LOOP = 999;
else
{
LogMsg(ERRMSG,"gettypeinfo test failed.\n");
TEST_RETURN;
}
*/
END_LOOP = 999;
j = 0;
while (TypeInfo[j].DATA_TYPE != END_LOOP)
{
sprintf(Heading,"Test Positive functionality of SQLGetTypeInfo for data type: %s\n",
SQLTypeToChar(TypeInfo[j].DATA_TYPE,TempBuf));
TESTCASE_BEGIN(Heading);
returncode = SQLGetTypeInfo(hstmt,TypeInfo[j].DATA_TYPE);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetTypeInfo"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt);
}
else
{
if (TypeInfo[j].DATA_TYPE != 0)
{
strcpy(oTYPE_NAME,"");
oDATA_TYPE = 0;
oPRECISION = 0;
strcpy(oLITERAL_PREFIX,"");
strcpy(oLITERAL_SUFFIX,"");
strcpy(oCREATE_PARAMS,"");
oNULLABLE = 0;
oCASE_SENSITIVE = 0;
oSEARCHABLE = 0;
oUNSIGNED_ATTRIBUTE = 0;
oMONEY = 0;
oAUTO_INCREMENT = 0;
strcpy(oLOCAL_TYPE_NAME,"");
oMINIMUM_SCALE = 0;
oMAXIMUM_SCALE = 0;
returncode = SQLBindCol(hstmt,1,SQL_C_CHAR,oTYPE_NAME,TYPE_LEN,&oTYPE_NAMElen);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLBindCol(hstmt,2,SQL_C_SHORT,&oDATA_TYPE,0,&oDATA_TYPElen);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLBindCol(hstmt,3,SQL_C_LONG,&oPRECISION,0,&oPRECISIONlen);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLBindCol(hstmt,4,SQL_C_CHAR,oLITERAL_PREFIX,TYPE_LEN,&oLITERAL_PREFIXlen);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLBindCol(hstmt,5,SQL_C_CHAR,oLITERAL_SUFFIX,TYPE_LEN,&oLITERAL_SUFFIXlen);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLBindCol(hstmt,6,SQL_C_CHAR,oCREATE_PARAMS,TYPE_LEN,&oCREATE_PARAMSlen);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLBindCol(hstmt,7,SQL_C_SHORT,&oNULLABLE,0,&oNULLABLElen);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLBindCol(hstmt,8,SQL_C_SHORT,&oCASE_SENSITIVE,0,&oCASE_SENSITIVElen);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLBindCol(hstmt,9,SQL_C_SHORT,&oSEARCHABLE,0,&oSEARCHABLElen);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLBindCol(hstmt,10,SQL_C_SHORT,&oUNSIGNED_ATTRIBUTE,0,&oUNSIGNED_ATTRIBUTElen);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLBindCol(hstmt,11,SQL_C_SHORT,&oMONEY,0,&oMONEYlen);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLBindCol(hstmt,12,SQL_C_SHORT,&oAUTO_INCREMENT,0,&oAUTO_INCREMENTlen);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLBindCol(hstmt,13,SQL_C_CHAR,oLOCAL_TYPE_NAME,TYPE_LEN,&oLOCAL_TYPE_NAMElen);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLBindCol(hstmt,14,SQL_C_SHORT,&oMINIMUM_SCALE,0,&oMINIMUM_SCALElen);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLBindCol(hstmt,15,SQL_C_SHORT,&oMAXIMUM_SCALE,0,&oMAXIMUM_SCALElen);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol"))
{
LogAllErrors(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLFetch(hstmt);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt);
}
else
{
LogMsg(NONE,"Comparing results\n");
if ((_stricmp(TypeInfo[j].TYPE_NAME,oTYPE_NAME) == 0)
&& (TypeInfo[j].DATA_TYPE == oDATA_TYPE)
&& (TypeInfo[j].PRECISION == oPRECISION)
&& (_stricmp(TypeInfo[j].LITERAL_PREFIX,oLITERAL_PREFIX) == 0)
&& (_stricmp(TypeInfo[j].LITERAL_SUFFIX,oLITERAL_SUFFIX) == 0)
&& (_stricmp(TypeInfo[j].CREATE_PARAMS,oCREATE_PARAMS) == 0)
&& (TypeInfo[j].NULLABLE == oNULLABLE)
&& (TypeInfo[j].CASE_SENSITIVE == oCASE_SENSITIVE)
&& (TypeInfo[j].SEARCHABLE == oSEARCHABLE)
&& (TypeInfo[j].UNSIGNED_ATTRIBUTE == oUNSIGNED_ATTRIBUTE)
&& (TypeInfo[j].MONEY == oMONEY)
&& (TypeInfo[j].AUTO_INCREMENT == oAUTO_INCREMENT)
&& (_stricmp(TypeInfo[j].LOCAL_TYPE_NAME,oLOCAL_TYPE_NAME) == 0)
&& (TypeInfo[j].MINIMUM_SCALE == oMINIMUM_SCALE)
&& (TypeInfo[j].MAXIMUM_SCALE == oMAXIMUM_SCALE))
{
//LogMsg(NONE,"Data Type Name actual: %s and expected: %s are matched\n",oTYPE_NAME,TypeInfo[j].TYPE_NAME);
//LogMsg(NONE,"Data Type actual: %d and expected: %d are matched\n",oDATA_TYPE,TypeInfo[j].DATA_TYPE);
//LogMsg(NONE,"Precision actual: %d and expected: %d are matched\n",oPRECISION,TypeInfo[j].PRECISION);
//LogMsg(NONE,"Literal Prefix actual: %s and expected: %s are matched\n",oLITERAL_PREFIX,TypeInfo[j].LITERAL_PREFIX);
//LogMsg(NONE,"Literal Suffix actual: %s and expected: %s are matched\n",oLITERAL_SUFFIX,TypeInfo[j].LITERAL_SUFFIX);
//LogMsg(NONE,"Create Params actual: %s and expected: %s are matched\n",oCREATE_PARAMS,TypeInfo[j].CREATE_PARAMS);
//LogMsg(NONE,"Nullable actual: %d and expected: %d are matched\n",oNULLABLE,TypeInfo[j].NULLABLE);
//LogMsg(NONE,"Case sensitive actual: %d and expected: %d are matched\n",oCASE_SENSITIVE,TypeInfo[j].CASE_SENSITIVE);
//LogMsg(NONE,"Searchable actual: %d and expected: %d are matched\n",oSEARCHABLE,TypeInfo[j].SEARCHABLE);
//LogMsg(NONE,"Unsigned attribute actual: %d and expected: %d are matched\n",oUNSIGNED_ATTRIBUTE,TypeInfo[j].UNSIGNED_ATTRIBUTE);
//LogMsg(NONE,"Money actual: %d and expected: %d are matched\n",oMONEY,TypeInfo[j].MONEY);
//LogMsg(NONE,"Auto Increment actual: %d and expected: %d are matched\n",oAUTO_INCREMENT,TypeInfo[j].AUTO_INCREMENT);
//LogMsg(NONE,"Local Type name actual: %s and expected: %s are matched\n",oLOCAL_TYPE_NAME,TypeInfo[j].LOCAL_TYPE_NAME);
//LogMsg(NONE,"Minimum Scale actual: %d and expected: %d are matched\n",oMINIMUM_SCALE,TypeInfo[j].MINIMUM_SCALE);
//LogMsg(NONE,"Maximum Scale actual: %d and expected: %d are matched\n",oMAXIMUM_SCALE,TypeInfo[j].MAXIMUM_SCALE);
}
else
{
TEST_FAILED;
if (_stricmp(TypeInfo[j].TYPE_NAME,oTYPE_NAME) != 0)
LogMsg(ERRMSG,"Data Type Name actual: %s and expected: %s are not matched\n",oTYPE_NAME,TypeInfo[j].TYPE_NAME);
if (TypeInfo[j].DATA_TYPE != oDATA_TYPE)
LogMsg(ERRMSG,"Data Type actual: %d and expected: %d are not matched\n",oDATA_TYPE,TypeInfo[j].DATA_TYPE);
if (TypeInfo[j].PRECISION != oPRECISION)
LogMsg(ERRMSG,"Precision actual: %d and expected: %d are not matched\n",oPRECISION,TypeInfo[j].PRECISION);
if (_stricmp(TypeInfo[j].LITERAL_PREFIX,oLITERAL_PREFIX) != 0)
LogMsg(ERRMSG,"Literal Prefix actual: %s and expected: %s are not matched\n",oLITERAL_PREFIX,TypeInfo[j].LITERAL_PREFIX);
if (_stricmp(TypeInfo[j].LITERAL_SUFFIX,oLITERAL_SUFFIX) != 0)
LogMsg(ERRMSG,"Literal Suffix actual: %s and expected: %s are not matched\n",oLITERAL_SUFFIX,TypeInfo[j].LITERAL_SUFFIX);
if (_stricmp(TypeInfo[j].CREATE_PARAMS,oCREATE_PARAMS) != 0)
LogMsg(ERRMSG,"Create Params actual: %s and expected: %s are not matched\n",oCREATE_PARAMS,TypeInfo[j].CREATE_PARAMS);
if (TypeInfo[j].NULLABLE != oNULLABLE)
LogMsg(ERRMSG,"Nullable actual: %d and expected: %d are not matched\n",oNULLABLE,TypeInfo[j].NULLABLE);
if (TypeInfo[j].CASE_SENSITIVE != oCASE_SENSITIVE)
LogMsg(ERRMSG,"Case sensitive actual: %d and expected: %d are not matched\n",oCASE_SENSITIVE,TypeInfo[j].CASE_SENSITIVE);
if (TypeInfo[j].SEARCHABLE != oSEARCHABLE)
LogMsg(ERRMSG,"Searchable actual: %d and expected: %d are not matched\n",oSEARCHABLE,TypeInfo[j].SEARCHABLE);
if (TypeInfo[j].UNSIGNED_ATTRIBUTE != oUNSIGNED_ATTRIBUTE)
LogMsg(ERRMSG,"Unsigned attribute actual: %d and expected: %d are not matched\n",oUNSIGNED_ATTRIBUTE,TypeInfo[j].UNSIGNED_ATTRIBUTE);
if (TypeInfo[j].MONEY != oMONEY)
LogMsg(ERRMSG,"Money actual: %d and expected: %d are not matched\n",oMONEY,TypeInfo[j].MONEY);
if (TypeInfo[j].AUTO_INCREMENT != oAUTO_INCREMENT)
LogMsg(ERRMSG,"Auto Increment actual: %d and expected: %d are not matched\n",oAUTO_INCREMENT,TypeInfo[j].AUTO_INCREMENT);
if (_stricmp(TypeInfo[j].LOCAL_TYPE_NAME,oLOCAL_TYPE_NAME) != 0)
LogMsg(ERRMSG,"Local Type name actual: %s and expected: %s are not matched\n",oLOCAL_TYPE_NAME,TypeInfo[j].LOCAL_TYPE_NAME);
if (TypeInfo[j].MINIMUM_SCALE != oMINIMUM_SCALE)
LogMsg(ERRMSG,"Minimum Scale actual: %d and expected: %d are not matched\n",oMINIMUM_SCALE,TypeInfo[j].MINIMUM_SCALE);
if (TypeInfo[j].MAXIMUM_SCALE != oMAXIMUM_SCALE)
LogMsg(ERRMSG,"Maximum Scale actual: %d and expected: %d are not matched\n",oMAXIMUM_SCALE,TypeInfo[j].MAXIMUM_SCALE);
}
}
}
}
TESTCASE_END;
SQLFreeStmt(hstmt,SQL_CLOSE); // This is a bug this should be after the inner for loop.
j++;
}
//==========================================================================================
TESTCASE_BEGIN("SQLGetTypeInfo: Negative test for invalid data type\n");
fSqlType1 = 50;
returncode = SQLGetTypeInfo(hstmt,fSqlType1);
if(!CHECKRC(SQL_ERROR,returncode,"SQLGetTypeInfo"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt);
}
TESTCASE_END;
//=========================================================================================
sprintf(Heading,"SQLGetTypeInfo: Negative test with invalid handle\n");
TESTCASE_BEGIN(Heading);
hstmt = (SQLHANDLE)NULL;
fSqlType1 = 1;
returncode = SQLGetTypeInfo(hstmt,fSqlType1);
if(!CHECKRC(SQL_INVALID_HANDLE,returncode,"SQLGetTypeInfo"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt);
}
TESTCASE_END;
//=========================================================================================
FullDisconnect3(pTestInfo);
LogMsg(SHORTTIMESTAMP+LINEAFTER,"End testing API => SQLGetTypeInfo.\n");
TEST_RETURN;
}
/*
---------------------------------------------------------
TestSQLDescribeColVer3 for MP Specific
---------------------------------------------------------
*/
PassFail TestMXSQLDescribeColVer3(TestInfo *pTestInfo)
{
TEST_DECLARE;
char Heading[MAX_STRING_SIZE];
RETCODE returncode;
SQLHANDLE henv, hdbc, hstmt;
UWORD icol;
SWORD numcol, st, cs, cnull, cl, colsize = 2;
SQLULEN cp;
CHAR cn[COLNAME_LEN];
CHAR *colname[21];
CHAR *ExecDirStr[12];
#ifndef _WM
SWORD SQLType[] = {SQL_CHAR,SQL_VARCHAR,SQL_DECIMAL,SQL_NUMERIC,SQL_SMALLINT,SQL_INTEGER,
SQL_REAL,SQL_DOUBLE,SQL_DOUBLE,SQL_TYPE_DATE,SQL_TYPE_TIME,SQL_TYPE_TIMESTAMP,SQL_LONGVARCHAR,SQL_BIGINT,
SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC};
SQLULEN ColPrec[] = {254,254,18,18,5,10,7,15,15,10,8,26,2000,19,19,19,128,128,10,18,30};
#else
SWORD SQLType[] = {SQL_CHAR,SQL_VARCHAR,SQL_DECIMAL,SQL_NUMERIC,SQL_SMALLINT,SQL_INTEGER,
SQL_REAL,SQL_DOUBLE,SQL_DOUBLE,SQL_CHAR,SQL_TYPE_TIME,SQL_TYPE_TIMESTAMP,SQL_LONGVARCHAR,SQL_BIGINT,
SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC};
SQLULEN ColPrec[] = {254,254,18,18,5,10,7,15,15,8,8,26,2000,19,19,19,128,128,10,18,30};
#endif
SWORD ColScale[]= {0, 0, 6, 6, 0,0, 0,0, 0, 0, 0,6, 0, 0, 0, 6, 0, 128,5, 5, 10};
char TempType1[50],TempType2[50];
SWORD ColNullable[] = {SQL_NULLABLE,SQL_NO_NULLS,SQL_NULLABLE};
CHAR *TestCase[] = {
"before preparing stmt ",
"before preparing & executing stmt ",
"before preparing, executing & fetching stmt ",
"before execdirect stmt ",
"before execdirect & fetching stmt ",
"before preparing param stmt ",
"before preparing & binding stmt ",
"before preparing, binding & executing stmt ",
"before preparing, binding, executing & fetching stmt "
};
int lend = 9, iend = 3;
SQLUSMALLINT i = 0, l = 0;
SQLLEN cbIn = SQL_NTS;
//===========================================================================================================
var_list_t *var_list;
var_list = load_api_vars("SQLDescribeColumns30", charset_file);
if (var_list == NULL) return FAILED;
//================Modified for Longvarchar Changes===========================================================
if(!pTestInfo->bLongOn)
{
SWORD iNoLong = SQL_VARCHAR;
SQLType[12] = iNoLong;
}
//================Modified for Longvarchar Changes===========================================================
//print_list(var_list);
colname[0] = var_mapping("SQLDescribeColumns30_colname_1", var_list);
colname[1] = var_mapping("SQLDescribeColumns30_colname_2", var_list);
colname[2] = var_mapping("SQLDescribeColumns30_colname_3", var_list);
colname[3] = var_mapping("SQLDescribeColumns30_colname_4", var_list);
colname[4] = var_mapping("SQLDescribeColumns30_colname_5", var_list);
colname[5] = var_mapping("SQLDescribeColumns30_colname_6", var_list);
colname[6] = var_mapping("SQLDescribeColumns30_colname_7", var_list);
colname[7] = var_mapping("SQLDescribeColumns30_colname_8", var_list);
colname[8] = var_mapping("SQLDescribeColumns30_colname_9", var_list);
colname[9] = var_mapping("SQLDescribeColumns30_colname_10", var_list);
colname[10] = var_mapping("SQLDescribeColumns30_colname_11", var_list);
colname[11] = var_mapping("SQLDescribeColumns30_colname_12", var_list);
colname[12] = var_mapping("SQLDescribeColumns30_colname_13", var_list);
colname[13] = var_mapping("SQLDescribeColumns30_colname_14", var_list);
colname[14] = var_mapping("SQLDescribeColumns30_colname_15", var_list);
colname[15] = var_mapping("SQLDescribeColumns30_colname_16", var_list);
colname[16] = var_mapping("SQLDescribeColumns30_colname_17", var_list);
colname[17] = var_mapping("SQLDescribeColumns30_colname_18", var_list);
colname[18] = var_mapping("SQLDescribeColumns30_colname_19", var_list);
colname[19] = var_mapping("SQLDescribeColumns30_colname_20", var_list);
colname[20] = var_mapping("SQLDescribeColumns30_colname_21", var_list);
ExecDirStr[0] = var_mapping("SQLDescribeColumns30_ExecDirStr_1", var_list);
ExecDirStr[1] = var_mapping("SQLDescribeColumns30_ExecDirStr_2", var_list);
ExecDirStr[2] = var_mapping("SQLDescribeColumns30_ExecDirStr_3", var_list);
ExecDirStr[3] = var_mapping("SQLDescribeColumns30_ExecDirStr_4", var_list);
ExecDirStr[4] = var_mapping("SQLDescribeColumns30_ExecDirStr_5", var_list);
ExecDirStr[5] = var_mapping("SQLDescribeColumns30_ExecDirStr_6", var_list);
ExecDirStr[6] = var_mapping("SQLDescribeColumns30_ExecDirStr_7", var_list);
ExecDirStr[7] = var_mapping("SQLDescribeColumns30_ExecDirStr_8", var_list);
ExecDirStr[8] = var_mapping("SQLDescribeColumns30_ExecDirStr_9", var_list);
ExecDirStr[9] = var_mapping("SQLDescribeColumns30_ExecDirStr_10", var_list);
ExecDirStr[10] = var_mapping("SQLDescribeColumns30_ExecDirStr_11", var_list);
ExecDirStr[11] = var_mapping("SQLDescribeColumns30_ExecDirStr_12", var_list);
//=========================================================================================
if(isUCS2) {
LogMsg(NONE,"Setup for UCS2 mode testing: ColPrec has to be doubled\n");
ExecDirStr[3] = replace_str(ExecDirStr[3],"$$$","127");
ExecDirStr[4] = replace_str(ExecDirStr[4],"$$$","127");
ExecDirStr[5] = replace_str(ExecDirStr[5],"$$$","127");
l = sizeof(SQLType)/sizeof(SQLType[0]);
while(i < l) {
if(SQLType[i] == SQL_CHAR) {
//SQLType[i] = SQL_WCHAR;
ColPrec[i] *= 2; //--> This is in character, so no need to double
}
else if (SQLType[i] == SQL_VARCHAR) {
//SQLType[i] = SQL_WVARCHAR;
}
else if (SQLType[i] == SQL_LONGVARCHAR) {
//SQLType[i] = SQL_WLONGVARCHAR;
ColPrec[i] *= 2; //--> This is in character, so no need to double
}
else {
}
i++;
}
i = 0;
l = 0;
} else {
ExecDirStr[3] = replace_str(ExecDirStr[3],"$$$","254");
ExecDirStr[4] = replace_str(ExecDirStr[4],"$$$","254");
ExecDirStr[5] = replace_str(ExecDirStr[5],"$$$","254");
}
//===========================================================================================================
LogMsg(LINEBEFORE+SHORTTIMESTAMP,"Begin testing API => MX Specific SQLDescribeColumns | SQLDescribeColumns30 | sqldescribecolver3.c\n");
TEST_INIT;
TESTCASE_BEGIN("Setup for SQLDescribCol tests\n");
if(!FullConnectWithOptions(pTestInfo, CONNECT_ODBC_VERSION_3))
{
LogMsg(NONE,"Unable to connect\n");
TEST_FAILED;
TEST_RETURN;
}
henv = pTestInfo->henv;
hdbc = pTestInfo->hdbc;
hstmt = (SQLHANDLE)pTestInfo->hstmt;
returncode = SQLAllocHandle(SQL_HANDLE_STMT, (SQLHANDLE)hdbc, &hstmt);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocHandle"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
TEST_RETURN;
}
TESTCASE_END; // end of setup
for (l = 0; l < lend; l++)
{
for (i = 0; i < iend; i++)
{
//==================================================================================
sprintf(Heading,"SQLDescribeCol: Test #%d.%d\n",l,i);
TESTCASE_BEGIN(Heading);
if ((i != (iend-1)) && (l < 5))
{
rerutncode = SQLExecDirect(hstmt,(SQLCHAR*)ExecDirStr[i],SQL_NTS); /* cleanup */
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLExecDirect(hstmt,(SQLCHAR*)ExecDirStr[i+iend],SQL_NTS); /* create table */
LogMsg(NONE,"%s\n", ExecDirStr[i+iend]);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
returncode = SQLExecDirect(hstmt,(SQLCHAR*)ExecDirStr[i+iend+iend],SQL_NTS); /* insert into table */
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
LogMsg(NONE,"SQLDescribeCol: %s\n",TestCase[l]);
LogMsg(NONE," %s\n",ExecDirStr[i+iend+iend+iend]);
switch( l )
{
case 0:
returncode = SQLPrepare(hstmt,(SQLCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
break;
case 1 :
returncode = SQLPrepare(hstmt,(SQLCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
returncode = SQLExecute(hstmt);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
}
break;
case 2 :
returncode = SQLPrepare(hstmt,(SQLCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
returncode = SQLExecute(hstmt);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
returncode = SQLFetch(hstmt);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
}
}
break;
case 3 :
returncode = SQLExecDirect(hstmt,(SQLCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
break;
case 4 :
returncode = SQLExecDirect(hstmt,(SQLCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
returncode = SQLFetch(hstmt);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
}
break;
}
if (returncode == SQL_SUCCESS)
{
returncode=SQLNumResultCols(hstmt, &numcol);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLNumResultCols"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
for (icol = 1; icol <= numcol; icol++)
{
LogMsg(LINEBEFORE,"SQLDescribeCol: checking Column #%d\n",icol);
returncode = SQLDescribeCol(hstmt,icol,(SQLCHAR*)cn,COLNAME_LEN,&cl,&st,&cp,&cs,&cnull);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLDescribeCol"))
{
TEST_FAILED;
LogAllErrorsVer3(henv,hdbc,hstmt);
}
colsize=strlen(colname[icol-1]);
if(isCharSet == TRUE)
colsize -= 2;
if ((cstrcmp(cn,colname[icol-1],FALSE,isCharSet) == 0)
&& (cl == colsize)
&& (st == SQLType[icol-1])
&& (cp == ColPrec[icol-1])
&& (cs == ColScale[icol-1])
&& (cnull == ColNullable[i]))
{
//LogMsg(NONE,"colname expect: %s and actual: %s are matched\n",colname[icol-1],cn);
//LogMsg(NONE,"ColNameLen expect: %d and actual: %d are matched\n",colsize,cl);
//LogMsg(NONE,"SQLType expect: %s and actual: %s are matched\n",
//SQLTypeToChar(SQLType[icol-1],TempType1),SQLTypeToChar(st,TempType2));
//LogMsg(NONE,"ColPrec expect: %d and actual: %d are matched\n",ColPrec[icol-1],cp);
//LogMsg(NONE,"ColScale expect: %d and actual: %d are matched\n",ColScale[icol-1],cs);
//LogMsg(NONE,"ColNullable expect: %s and actual: %s are matched\n\n",
//SQLNullToChar(ColNullable[i],TempType1),SQLNullToChar(cnull,TempType2));
}
else
{
TEST_FAILED;
if (cstrcmp(cn,colname[icol-1],FALSE,isCharSet) != 0)
LogMsg(ERRMSG,"colname expect: %s and actual: %s are not matched\n",colname[icol-1],cn);
if (cl != colsize)
LogMsg(ERRMSG,"ColNameLen expect: %d and actual: %d are not matched\n",colsize,cl);
if (st != SQLType[icol-1])
LogMsg(ERRMSG,"SQLType expect: %s and actual: %s are not matched\n",
SQLTypeToChar(SQLType[icol-1],TempType1),SQLTypeToChar(st,TempType2));
if (cp != ColPrec[icol-1])
LogMsg(ERRMSG,"ColPrec expect: %d and actual: %d are not matched\n",ColPrec[icol-1],cp);
if (cs != ColScale[icol-1])
LogMsg(ERRMSG,"ColScale expect: %d and actual: %d are not matched\n",ColScale[icol-1],cs);
if (cnull != ColNullable[i])
LogMsg(ERRMSG,"ColNullable expect: %s and actual: %s are not matched\n\n",
SQLNullToChar(ColNullable[i],TempType1),SQLNullToChar(cnull,TempType2));
}
} /* end icol loop */
}
else
{
TEST_FAILED;
LogAllErrorsVer3(henv,hdbc,hstmt);
}
SQLFreeStmt(hstmt,SQL_CLOSE);
SQLExecDirect(hstmt,(SQLCHAR*) ExecDirStr[i],SQL_NTS); /* cleanup */
}
}
}
else if ((i == (iend-1)) && (l >= 5))
{
SQLExecDirect(hstmt,(SQLCHAR*)ExecDirStr[i],SQL_NTS); /* cleanup */
returncode = SQLExecDirect(hstmt,(SQLCHAR*)ExecDirStr[i+iend],SQL_NTS); /* create table */
LogMsg(NONE,"%s\n", ExecDirStr[i+iend]);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
returncode = SQLExecDirect(hstmt,(SQLCHAR*)ExecDirStr[i+iend+iend],SQL_NTS); /* insert into table */
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
LogMsg(NONE,"SQLDescribeCol: %s\n",TestCase[l]);
LogMsg(NONE," %s\n",ExecDirStr[i+iend+iend+iend]);
switch( l )
{
case 5 :
returncode = SQLPrepare(hstmt,(SQLCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
break;
case 6 :
returncode = SQLPrepare(hstmt,(SQLCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
returncode = SQLBindParameter(hstmt,1,SQL_PARAM_INPUT,SQL_C_CHAR,SQL_CHAR,2000,0,(SQLPOINTER) "0123456789",300,&cbIn);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindParameter"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLBindParameter(hstmt,2,SQL_PARAM_INPUT,SQL_C_CHAR,SQL_CHAR,2000,0,(SQLPOINTER)"0123456789",300,&cbIn);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindParameter"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
}
break;
case 7 :
returncode = SQLPrepare(hstmt,(SQLCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
returncode = SQLBindParameter(hstmt,1,SQL_PARAM_INPUT,SQL_C_CHAR,SQL_CHAR,2000,0,(SQLPOINTER)"0123456789",300,&cbIn);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindParameter"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLBindParameter(hstmt,2,SQL_PARAM_INPUT,SQL_C_CHAR,SQL_CHAR,2000,0,(SQLPOINTER)"0123456789",300,&cbIn);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindParameter"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLExecute(hstmt);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
}
break;
case 8 :
returncode = SQLPrepare(hstmt,(SQLCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
returncode = SQLBindParameter(hstmt,1,SQL_PARAM_INPUT,SQL_C_CHAR,SQL_CHAR,2000,0,(SQLPOINTER)"0123456789",300,&cbIn);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindParameter"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLBindParameter(hstmt,2,SQL_PARAM_INPUT,SQL_C_CHAR,SQL_CHAR,2000,0,(SQLPOINTER)"0123456789",300,&cbIn);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindParameter"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
returncode = SQLExecute(hstmt);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
else
{
returncode = SQLFetch(hstmt);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
}
}
break;
}
if (returncode == SQL_SUCCESS)
{
SQLNumResultCols(hstmt, &numcol);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLNumResultCols"))
{
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
}
for (icol = 1; icol <= numcol; icol++)
{
LogMsg(LINEBEFORE,"SQLDescribeCol: checking Column #%d\n",icol);
returncode = SQLDescribeCol(hstmt,icol,(SQLCHAR*)cn,COLNAME_LEN,&cl,&st,&cp,&cs,&cnull);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLDescribeCol"))
{
TEST_FAILED;
LogAllErrorsVer3(henv,hdbc,hstmt);
}
colsize=strlen(colname[icol-1]);
if(isCharSet == TRUE)
colsize -= 2;
if ((cstrcmp(cn,colname[icol-1],FALSE,isCharSet) == 0)
&& (cl == colsize)
&& (st == SQLType[icol-1])
&& (cp == ColPrec[icol-1])
&& (cs == ColScale[icol-1])
&& (cnull == ColNullable[i]))
{
//LogMsg(NONE,"colname expect: %s and actual: %s are matched\n",colname[icol-1],cn);
//LogMsg(NONE,"ColNameLen expect: %d and actual: %d are matched\n",colsize,cl);
//LogMsg(NONE,"SQLType expect: %s and actual: %s are matched\n",
// SQLTypeToChar(SQLType[icol-1],TempType1),SQLTypeToChar(st,TempType2));
//LogMsg(NONE,"ColPrec expect: %d and actual: %d are matched\n",ColPrec[icol-1],cp);
//LogMsg(NONE,"ColScale expect: %d and actual: %d are matched\n",ColScale[icol-1],cs);
//LogMsg(NONE,"ColNullable expect: %s and actual: %s are matched\n\n",
// SQLNullToChar(ColNullable[i],TempType1),SQLNullToChar(cnull,TempType2));
}
else
{
TEST_FAILED;
if (cstrcmp(cn,colname[icol-1],FALSE,isCharSet) != 0)
LogMsg(ERRMSG,"colname expect: %s and actual: %s are not matched\n",colname[icol-1],cn);
if (cl != colsize)
LogMsg(ERRMSG,"ColNameLen expect: %d and actual: %d are not matched\n",colsize,cl);
if (st != SQLType[icol-1])
LogMsg(ERRMSG,"SQLType expect: %s and actual: %s are not matched\n",
SQLTypeToChar(SQLType[icol-1],TempType1),SQLTypeToChar(st,TempType2));
if (cp != ColPrec[icol-1])
LogMsg(ERRMSG,"ColPrec expect: %d and actual: %d are not matched\n",ColPrec[icol-1],cp);
if (cs != ColScale[icol-1])
LogMsg(ERRMSG,"ColScale expect: %d and actual: %d are not matched\n",ColScale[icol-1],cs);
if (cnull != ColNullable[i])
LogMsg(ERRMSG,"ColNullable expect: %s and actual: %s are not matched\n\n",
SQLNullToChar(ColNullable[i],TempType1),SQLNullToChar(cnull,TempType2));
}
}
}
}
SQLFreeStmt(hstmt,SQL_CLOSE);
SQLExecDirect(hstmt,(SQLCHAR*) ExecDirStr[i],SQL_NTS);
}
}
TESTCASE_END;
} /* iend loop */
} /* lend loop */
SQLFreeHandle(SQL_HANDLE_STMT, hstmt);
FullDisconnect3(pTestInfo);
LogMsg(SHORTTIMESTAMP+LINEAFTER,"End testing API => MX Specific SQLDescribeColumns.\n");
free_list(var_list);
TEST_RETURN;
}
//---------------------------------------------------------
// TestSQLAllocStmt()
//---------------------------------------------------------
PassFail TestSQLAllocStmt (TestInfo *pTestInfo, int MX_MP_SPECIFIC)
{
TEST_DECLARE;
char Heading[MAX_STRING_SIZE];
RETCODE returncode;
SQLHANDLE henv;
SQLHANDLE hdbc;
SQLHANDLE hstmt[NUM_STMT];
//RETCODE AsyncStmt[NUM_ASYNC_STMT];
char *StmtHndlStr;
int i = 0, j = 0, k = 0;
int AnyAsync;
int AsyncOper[] = {CREATE_TABLE,INSERT_TABLE,SELECT_TABLE,DROP_TABLE,999};
char *teststmthndl[21];
//===========================================================================================================
var_list_t *var_list;
var_list = load_api_vars("SQLAllocateStatement", charset_file);
if (var_list == NULL) return FAILED;
teststmthndl[0] = var_mapping("TestStmtHndl_0", var_list);
teststmthndl[1] = var_mapping("TestStmtHndl_1", var_list);
teststmthndl[2] = var_mapping("TestStmtHndl_2", var_list);
teststmthndl[3] = var_mapping("TestStmtHndl_3", var_list);
teststmthndl[4] = var_mapping("TestStmtHndl_4", var_list);
teststmthndl[5] = var_mapping("TestStmtHndl_5", var_list);
teststmthndl[6] = var_mapping("TestStmtHndl_6", var_list);
teststmthndl[7] = var_mapping("TestStmtHndl_7", var_list);
teststmthndl[8] = var_mapping("TestStmtHndl_8", var_list);
teststmthndl[9] = var_mapping("TestStmtHndl_9", var_list);
teststmthndl[10] = var_mapping("TestStmtHndl_10", var_list);
teststmthndl[11] = var_mapping("TestStmtHndl_11", var_list);
teststmthndl[12] = var_mapping("TestStmtHndl_12", var_list);
teststmthndl[13] = var_mapping("TestStmtHndl_13", var_list);
teststmthndl[14] = var_mapping("TestStmtHndl_14", var_list);
teststmthndl[15] = var_mapping("TestStmtHndl_15", var_list);
teststmthndl[16] = var_mapping("TestStmtHndl_16", var_list);
teststmthndl[17] = var_mapping("TestStmtHndl_17", var_list);
teststmthndl[18] = var_mapping("TestStmtHndl_18", var_list);
teststmthndl[19] = var_mapping("TestStmtHndl_19", var_list);
teststmthndl[20] = var_mapping("TestStmtHndl_20", var_list);
//======================================================================================
if (MX_MP_SPECIFIC == MX_SPECIFIC)
LogMsg(LINEBEFORE+SHORTTIMESTAMP,"Begin testing API => MX specific SQLAllocStmt | SQLAllocStmt | alocstmt.c\n");
else
LogMsg(LINEBEFORE+SHORTTIMESTAMP,"Begin testing API => MP specific SQLAllocStmt | SQLAllocStmt | alocstmt.c\n");
TEST_INIT;
TESTCASE_BEGIN("Setup for SQLAllocStmt/SQLFreeStmt tests\n");
/* 6-5-00:
Need to turn Autocommit off since MX will close all open cursors that are
open if the end of ANY of the cursors is reached. */
if(!FullConnectWithOptions(pTestInfo, CONNECT_ODBC_VERSION_2))
{
LogMsg(NONE,"Unable to connect\n");
TEST_FAILED;
TEST_RETURN;
}
henv = pTestInfo->henv;
hdbc = pTestInfo->hdbc;
//set the connection attribute to SQL_AUTOCOMMIT_OFF to enable use of multiple stmt without errors
SQLSetConnectAttr((SQLHANDLE)hdbc, SQL_ATTR_AUTOCOMMIT, SQL_AUTOCOMMIT_OFF, SQL_IS_UINTEGER);
TESTCASE_END; // end of setup
StmtHndlStr = (char *)malloc(MAX_NOS_SIZE);
//====================================================================================================
// General statement handle exercise testcases.
for (k = 0; k < 2; k++)
{
for (i = 0; i < NUM_STMT; i++)
{
hstmt[i] = (SQLHANDLE)pTestInfo->hstmt;
sprintf(Heading,"SQLAllocstmt: Test #%d\n",i);
TESTCASE_BEGIN(Heading);
returncode = SQLAllocStmt((SQLHANDLE)hdbc, &hstmt[i]);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocStmt"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt[i]);
}
TESTCASE_END;
if (returncode == SQL_SUCCESS)
{
if (i == 0) // cleanup
{
for (j = 0; j < NUM_STMT; j++)
{
SQLExecDirect(hstmt[0],StmtQueries(DROP_TABLE,teststmthndl[j],StmtHndlStr),SQL_NTS);
}
}
sprintf(Heading,"SQLAllocStmt: create table teststmthndl%d\n",i+1);
TESTCASE_BEGIN(Heading);
if (k == 0) // prepare & execute
{
returncode = SQLPrepare(hstmt[i],StmtQueries(CREATE_TABLE,teststmthndl[i],StmtHndlStr),SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt[i]);
}
else{
returncode = SQLExecute(hstmt[i]);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")){
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt[i]);
}
}
}
else // execdirect
{
returncode = SQLExecDirect(hstmt[i],StmtQueries(CREATE_TABLE,teststmthndl[i],StmtHndlStr),SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt[i]);
}
}
}
if (returncode == SQL_SUCCESS) TESTCASE_END;
}
for (i = 0; i < NUM_STMT; i++)
{
sprintf(Heading,"SQLAllocStmt: inserts on Stmt Handle(%d)\n",i);
TESTCASE_BEGIN(Heading);
if (k == 0) // prepare & execute
{
returncode = SQLPrepare(hstmt[i],StmtQueries(INSERT_TABLE,teststmthndl[i],StmtHndlStr),SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt[i]);
}
else
{
returncode = SQLExecute(hstmt[i]);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt[i]);
}
}
}
else // execdirect
{
returncode = SQLExecDirect(hstmt[i],StmtQueries(INSERT_TABLE,teststmthndl[i],StmtHndlStr),SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt[i]);
}
}
if (returncode == SQL_SUCCESS)TESTCASE_END;
}
for (i = 0; i < NUM_STMT; i++)
{
sprintf(Heading,"SQLAllocStmt: selects on Stmt Handle(%d)\n",i);
TESTCASE_BEGIN(Heading);
if (k == 0) // prepare & execute
{
returncode = SQLPrepare(hstmt[i],StmtQueries(SELECT_TABLE,teststmthndl[i],StmtHndlStr),SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt[i]);
}
else{
returncode = SQLExecute(hstmt[i]);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")){
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt[i]);
}
}
}
else // execdirect
{
returncode = SQLExecDirect(hstmt[i],StmtQueries(SELECT_TABLE,teststmthndl[i],StmtHndlStr),SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt[i]);
}
}
if (returncode == SQL_SUCCESS) TESTCASE_END;
}
for (i = (NUM_STMT-1); i > -1; i--)
{
sprintf(Heading,"SQLAllocStmt: fetches on selects on Stmt Handle(%d)\n",i);
TESTCASE_BEGIN(Heading);
returncode = SQLFetch(hstmt[i]);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt[i]);
}
if (returncode == SQL_SUCCESS) TESTCASE_END;
}
for (i = 0; i < NUM_STMT; i++)
{
sprintf(Heading,"SQLAllocStmt: SQLFreeStmt(%d) with SQL_CLOSE\n",i);
TESTCASE_BEGIN(Heading);
returncode = SQLFreeStmt(hstmt[i],SQL_CLOSE);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFreeStmt"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt[i]);
}
else{
TESTCASE_END;
}
if (i == (NUM_STMT-1)) // cleanup
{
for (j = 0; j < NUM_STMT; j++)
{
SQLExecDirect(hstmt[0],StmtQueries(DROP_TABLE,teststmthndl[j],StmtHndlStr),SQL_NTS);
}
}
}
for (i = 0; i < NUM_STMT; i++)
{
sprintf(Heading,"SQLAllocStmt: SQLFreeStmt(%d) with SQL_DROP\n",i);
TESTCASE_BEGIN(Heading);
returncode = SQLFreeStmt(hstmt[i],SQL_DROP);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFreeStmt"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt[i]);
}
else{
TESTCASE_END;
}
}
sprintf(Heading,"SLQAllocStmt: same sql operations on different of SQLAllocstmt(%d)s\n",i);
TESTCASE_BEGIN(Heading);
for (i = 0; i < NUM_STMT; i++)
{
hstmt[i] = (SQLHANDLE)pTestInfo->hstmt;
returncode = SQLAllocStmt((SQLHANDLE)hdbc, &hstmt[i]);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocStmt"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt[i]);
}
if (returncode == SQL_SUCCESS)
{
if (i == 0) // cleanup
{
SQLExecDirect(hstmt[0],StmtQueries(DROP_TABLE,teststmthndl[20],StmtHndlStr),SQL_NTS);
returncode = SQLExecDirect(hstmt[0],StmtQueries(CREATE_TABLE,teststmthndl[20],StmtHndlStr),SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt[0]);
}
}
if (k == 0) // prepare & execute
{
returncode = SQLPrepare(hstmt[i],StmtQueries(INSERT_TABLE,teststmthndl[20],StmtHndlStr),SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt[i]);
}
returncode = SQLExecute(hstmt[i]);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt[i]);
}
}
else // execdirect
{
returncode = SQLExecDirect(hstmt[i],StmtQueries(INSERT_TABLE,teststmthndl[20],StmtHndlStr),SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt[i]);
}
}
if (k == 0) // prepare & execute
{
returncode = SQLPrepare(hstmt[i],StmtQueries(SELECT_TABLE,teststmthndl[20],StmtHndlStr),SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt[i]);
}
returncode = SQLExecute(hstmt[i]);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt[i]);
}
}
else
{
returncode = SQLExecDirect(hstmt[i],StmtQueries(SELECT_TABLE,teststmthndl[20],StmtHndlStr),SQL_NTS);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt[i]);
}
}
returncode = SQLFetch(hstmt[i]);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt[i]);
}
}
}
for (i = 0; i < NUM_STMT; i++)
{
returncode = SQLFreeStmt(hstmt[i],SQL_CLOSE);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocStmt"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt[i]);
}
if (i == 0)
{
SQLExecDirect(hstmt[0],StmtQueries(DROP_TABLE,teststmthndl[20],StmtHndlStr),SQL_NTS);
}
returncode = SQLFreeStmt(hstmt[i],SQL_DROP);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFreeStmt"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt[i]);
}
}
TESTCASE_END;
}
//====================================================================================================
// Asynchronus Testcases
if (MX_MP_SPECIFIC == MX_SPECIFIC)
{
for (i = 0; i < NUM_ASYNC_STMT; i++)
{
hstmt[i] = (SQLHANDLE)pTestInfo->hstmt;
// Creating statement handles
sprintf(Heading,"SQLAllocstmt: Test #%d and Enable the ASYNC MODE ON.\n",i);
TESTCASE_BEGIN(Heading);
returncode = SQLAllocStmt((SQLHANDLE)hdbc, &hstmt[i]);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocStmt"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt[i]);
}
else
{
if (i == 0) // cleanup
{
// Creating tables to be used by each of the stmt handles
for (j = 0; j < NUM_ASYNC_STMT; j++)
{
SQLExecDirect(hstmt[0],StmtQueries(DROP_TABLE,teststmthndl[j],StmtHndlStr),SQL_NTS);
}
}
// Putting each stmthandle into Asynchronus mode
returncode = SQLSetStmtOption(hstmt[i],SQL_ASYNC_ENABLE,SQL_ASYNC_ENABLE_ON);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetStmtOptions"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt[i]);
}
}
TESTCASE_END;
}
// Running the Asynchronus tests
// WHAT IS GOING ON
// Two tests cases are being checked:
// 1. That the status of an asynchronus stmt handle CAN be checked.
// 2. That the stmt handle completes correctly.
//
// HOW IT'S BEING RUN
// Steps being performed until all handles are no longer executing:
// 1. Prepare the async test data structure.
// 2. Generate table name based on statement handle being used.
// 3. If handle's status has not been checked already, check as test case 1.
// Else, check it's status NOT as a test case.
// 4. Run the statement (also used to check the status of the handle).
// 5. If the stmt completes, verify that it does so successfully. Test case 2.
//
// Once all of the handles have completed, perform the next Async Operation
// until the terminating operation (a.k.a "999") is reached.
k = 0;
while (AsyncOper[k] != 999)
{
// 1. Preparing the async test data structure
for (i = 0; i < NUM_ASYNC_STMT; i++)
{
AsyncStmt[i].status = SQL_STILL_EXECUTING;
AsyncStmt[i].checked = FALSE;
}
AnyAsync = 1;
// Testing begins
while (AnyAsync > 0)
{
for (i = 0; i < NUM_ASYNC_STMT; i++)
{
if (AsyncStmt[i].status == SQL_STILL_EXECUTING)
{
// 3. Has the handle been checked for its status?
if (AsyncStmt[i].checked)
{
// 4. Run the statement.
returncode = SQLExecDirect(hstmt[i],StmtQueries(AsyncOper[k],teststmthndl[i],StmtHndlStr),SQL_NTS);
AsyncStmt[i].status = returncode;
// 5. Result Test: Verifying that the statement completes correctly.
if (returncode != SQL_STILL_EXECUTING)
{
sprintf(Heading,"SQLAllocStmt: Result Test: %d; SQLStmt: %s.\n",i,StmtQueries(AsyncOper[k],teststmthndl[i],StmtHndlStr));
TESTCASE_BEGIN(Heading);
if (returncode != SQL_SUCCESS)
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt[i]);
}
TESTCASE_END;
}
}
else
{
// Status Test (Test case 1):
// Only EXECUTING and SUCCESS are acceptable, others are errors.
// This test is only run once!
sprintf(Heading,"SQLAllocStmt: Status Test: %d; SQLStmt: %s.\n",i,StmtQueries(AsyncOper[k],teststmthndl[i],StmtHndlStr));
TESTCASE_BEGIN(Heading);
// 4. Run the statement.
returncode = SQLExecDirect(hstmt[i],StmtQueries(AsyncOper[k],teststmthndl[i],StmtHndlStr),SQL_NTS);
AsyncStmt[i].status = returncode;
AsyncStmt[i].checked = TRUE;
if ((returncode != SQL_STILL_EXECUTING) && (returncode != SQL_SUCCESS))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt[i]);
}
TESTCASE_END;
// 5. If the stmt completes, verify that it does so successfully.
if (returncode != SQL_STILL_EXECUTING)
{
// Result Test: Verifying that the stmt completes successfully.
sprintf(Heading,"SQLAllocStmt: Result Test: %d; SQLStmt: %s.\n",i,StmtQueries(AsyncOper[k],teststmthndl[i],StmtHndlStr));
TESTCASE_BEGIN(Heading);
if (returncode != SQL_SUCCESS)
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt[i]);
}
TESTCASE_END;
}
//Sleep (500);
}
}
}
AnyAsync = 0;
for (i = 0; i < NUM_ASYNC_STMT; i++)
{
if (AsyncStmt[i].status == SQL_STILL_EXECUTING)
{
AnyAsync = AnyAsync + 1;
}
}
}
// Special tests for Fetching after doing a SELECT
// Steps are identical to the above steps.
if (AsyncOper[k] == SELECT_TABLE)
{
// Preparing data structure
for (i = 0; i < NUM_ASYNC_STMT; i++)
{
AsyncStmt[i].status = SQL_STILL_EXECUTING;
AsyncStmt[i].checked = FALSE;
}
AnyAsync = 1;
// Select testing begins
while (AnyAsync > 0)
{
for (i = 0; i < NUM_ASYNC_STMT; i++)
{
if (AsyncStmt[i].status == SQL_STILL_EXECUTING)
{
if (AsyncStmt[i].checked)
{
returncode = SQLFetch(hstmt[i]);
AsyncStmt[i].status = returncode;
if (returncode != SQL_STILL_EXECUTING)
{
// Result Test
sprintf(Heading,"SQLAllocStmt: Result Test:%d; performing SQLFetch.\n",i);
TESTCASE_BEGIN(Heading);
if (returncode != SQL_SUCCESS)
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt[i]);
}
TESTCASE_END;
}
}
else
{
// Status Test
sprintf(Heading,"SQLAllocStmt: Status Test:%d; performing SQLFetch.\n",i);
TESTCASE_BEGIN(Heading);
returncode = SQLFetch(hstmt[i]);
AsyncStmt[i].status = returncode;
AsyncStmt[i].checked = TRUE;
if ((returncode != SQL_STILL_EXECUTING) && (returncode != SQL_SUCCESS))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt[i]);
}
TESTCASE_END;
// Result Test
if (returncode != SQL_STILL_EXECUTING)
{
sprintf(Heading,"SQLAllocStmt: Result Test:%d; performing SQLFetch.\n",i);
TESTCASE_BEGIN(Heading);
if (returncode != SQL_SUCCESS)
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt[i]);
}
TESTCASE_END;
}
}
}
}
AnyAsync = 0;
for (i = 0; i < NUM_ASYNC_STMT; i++)
{
if (AsyncStmt[i].status == SQL_STILL_EXECUTING)
{
AnyAsync = AnyAsync + 1;
}
}
}
// Closing the cursor from the SELECT stmt result set.
for (i = 0; i < NUM_ASYNC_STMT; i++)
{
sprintf(Heading,"SQLFreeStmt: %d.\n",i);
TESTCASE_BEGIN(Heading);
returncode = SQLFreeStmt(hstmt[i],SQL_CLOSE);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFreeStmt"))
{
TEST_FAILED;
LogAllErrors(henv,hdbc,hstmt[i]);
}
TESTCASE_END;
}
} // End of async SELECT test.
// Resetting the checked status for the next operation.
for (i = 0; i < NUM_ASYNC_STMT; i++)
{
AsyncStmt[i].checked = FALSE;
}
k++;
}
}
//====================================================================================================
free(StmtHndlStr);
returncode = SQLDisconnect((SQLHANDLE)hdbc);
if(!CHECKRC(SQL_ERROR,returncode,"SQLDisconnect"))
{
TEST_FAILED;
LogAllErrorsVer3(henv,hdbc,hstmt[0]);
}
// Free the open transactions.
returncode=SQLTransact((SQLHANDLE)henv,(SQLHANDLE)hdbc,SQL_ROLLBACK);
Sleep(2);
returncode=FullDisconnect(pTestInfo);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFullDisconnect"))
{
TEST_FAILED;
LogAllErrorsVer3(henv,hdbc,hstmt[0]);
}
LogMsg(SHORTTIMESTAMP+LINEAFTER,"End testing API => SQLAllocStmt.\n");
free_list(var_list);
TEST_RETURN;
}
/*
------------------------------------------------------------------
TestSQLGetInfo: Tests SQLGetInfoVer3
------------------------------------------------------------------
*/
PassFail TestMXSQLGetInfoVer3(TestInfo *pTestInfo)
{
TEST_DECLARE;
char Heading[MAX_STRING_SIZE];
RETCODE returncode;
SQLHANDLE henv;
SQLHANDLE hdbc;
SQLHANDLE hstmt;
union{
SQLLEN longInfoValue;//
SQLUINTEGER intInfoValue;
SQLUSMALLINT smiInfoValue;
char charInfoValue[MAX_LEN_BUF+1];
} u1;
SWORD pcbInfoValue;
short i;
char TempString[MAX_STRING_SIZE];
char ExpectedStr[MAX_LEN_BUF];
char ActualHex[MAX_STRING_SIZE];
char ActualStr[MAX_LEN_BUF]; // Changed to reflect the very large amount of data SQL_KEYWORDS returns.
TrueFalse DifferenceOK;
// The following list of variables are alphabetized,
// please try and keep it that way!
char accessible_procedures[]={"N"};
char accessible_tables[]={"N"};
SQLUSMALLINT active_environments = 0;
SQLUINTEGER aggregate_functions = {SQL_AF_AVG | SQL_AF_COUNT | SQL_AF_MAX |
SQL_AF_MIN | SQL_AF_SUM};
SQLUINTEGER alter_domain=0;
SQLUINTEGER alter_table=0;
SQLUINTEGER async_mode=SQL_AM_STATEMENT;
SQLUINTEGER batch_row_count = 0;
SQLUINTEGER batch_support = 0;
SQLUINTEGER bookmark_persistence=0;
SQLUSMALLINT catalog_location=SQL_CL_START;
char catalog_name[]={"Y"};
char catalog_name_separator[]={"."};
char catalog_term[]={"CATALOG"};
SQLUINTEGER catalog_usage={SQL_CU_DML_STATEMENTS | SQL_CU_TABLE_DEFINITION |
SQL_CU_INDEX_DEFINITION};
char collation_seq[]={"ISO 8859-1"};
char column_alias[]={"Y"};
SQLUSMALLINT concat_null_behavior=SQL_CB_NULL;
SQLUINTEGER convert_bigint={SQL_CVT_CHAR | SQL_CVT_BIGINT | SQL_CVT_DECIMAL |
SQL_CVT_DOUBLE | SQL_CVT_FLOAT | SQL_CVT_INTEGER |
SQL_CVT_LONGVARCHAR | SQL_CVT_NUMERIC | SQL_CVT_REAL |
SQL_CVT_SMALLINT | SQL_CVT_VARCHAR};
SQLUINTEGER convert_binary=0;
SQLUINTEGER convert_bit=0;
SQLUINTEGER convert_char={SQL_CVT_CHAR | SQL_CVT_BIGINT | SQL_CVT_DATE |
SQL_CVT_DECIMAL | SQL_CVT_DOUBLE | SQL_CVT_FLOAT |
SQL_CVT_INTEGER | SQL_CVT_LONGVARCHAR | SQL_CVT_NUMERIC |
SQL_CVT_REAL | SQL_CVT_SMALLINT | SQL_CVT_TIME |
SQL_CVT_TIMESTAMP | SQL_CVT_VARCHAR};
SQLUINTEGER convert_date={SQL_CVT_CHAR | SQL_CVT_DATE | SQL_CVT_LONGVARCHAR |
SQL_CVT_TIMESTAMP | SQL_CVT_VARCHAR};
SQLUINTEGER convert_decimal=convert_bigint;
SQLUINTEGER convert_double=convert_bigint;
SQLUINTEGER convert_float=convert_bigint;
SQLUINTEGER convert_functions=SQL_FN_CVT_CONVERT;
SQLUINTEGER convert_integer=convert_bigint;
SQLUINTEGER convert_interval_day_time = 0;
SQLUINTEGER convert_interval_year_month = 0;
SQLUINTEGER convert_longvarbinary=0;
#ifdef unixcli
SQLUINTEGER convert_longvarchar=convert_char;
#else
SQLUINTEGER convert_longvarchar=0;
#endif
SQLUINTEGER convert_numeric=convert_bigint;
SQLUINTEGER convert_real=convert_bigint;
SQLUINTEGER convert_smallint=convert_bigint;
SQLUINTEGER convert_time={SQL_CVT_CHAR | SQL_CVT_LONGVARCHAR | SQL_CVT_TIME |
SQL_CVT_TIMESTAMP | SQL_CVT_VARCHAR};
SQLUINTEGER convert_timestamp={SQL_CVT_CHAR | SQL_CVT_DATE | SQL_CVT_LONGVARCHAR |
SQL_CVT_TIME | SQL_CVT_TIMESTAMP | SQL_CVT_VARCHAR};
SQLUINTEGER convert_tinyint=0;
SQLUINTEGER convert_varbinary=0;
SQLUINTEGER convert_varchar=convert_char;
/* sq
SQLUINTEGER convert_wchar = 0;
SQLUINTEGER convert_wlongvarchar = 0;
SQLUINTEGER convert_wvarchar = 0;
*/
/* sq new */
SQLUINTEGER convert_wchar={SQL_CVT_CHAR | SQL_CVT_BIGINT | SQL_CVT_DATE
|
SQL_CVT_DECIMAL
| SQL_CVT_DOUBLE | SQL_CVT_FLOAT |
SQL_CVT_INTEGER
| SQL_CVT_NUMERIC | SQL_CVT_REAL |
SQL_CVT_SMALLINT
| SQL_CVT_TIME | SQL_CVT_TIMESTAMP |
SQL_CVT_VARCHAR
| SQL_CVT_WCHAR | SQL_CVT_WVARCHAR};
#ifdef unixcli
SQLUINTEGER convert_wlongvarchar = convert_wchar;
#else
SQLUINTEGER convert_wlongvarchar = 0;
#endif
SQLUINTEGER convert_wvarchar = convert_wchar;
/* end of sq new */
SQLUSMALLINT correlation_name=SQL_CN_ANY;
SQLUINTEGER create_assertion = 0;
SQLUINTEGER create_character_set = 0;
SQLUINTEGER create_collation = 0;
SQLUINTEGER create_domain = 0;
SQLUINTEGER create_schema = 0;
SQLUINTEGER create_table = {SQL_CT_CREATE_TABLE};
SQLUINTEGER create_translation = 0;
SQLUINTEGER create_view = {SQL_CV_CREATE_VIEW | SQL_CV_CHECK_OPTION | SQL_CV_CASCADED};
// (replaced with above) SQLUINTEGER create_view = {SQL_CV_CREATE_VIEW};
SQLUSMALLINT cursor_commit_behavior=SQL_CB_CLOSE;
SQLUSMALLINT cursor_rollback_behavior=SQL_CB_CLOSE;
SQLUINTEGER cursor_sensitivity=SQL_UNSPECIFIED;
char data_source_name[60];
char data_source_read_only[]={"N"};
char database_name[60];
SQLUINTEGER datetime_literals = {SQL_DL_SQL92_DATE | SQL_DL_SQL92_TIME | SQL_DL_SQL92_TIMESTAMP | SQL_DL_SQL92_INTERVAL_YEAR |
SQL_DL_SQL92_INTERVAL_MONTH | SQL_DL_SQL92_INTERVAL_DAY |
SQL_DL_SQL92_INTERVAL_HOUR | SQL_DL_SQL92_INTERVAL_MINUTE |
SQL_DL_SQL92_INTERVAL_SECOND | SQL_DL_SQL92_INTERVAL_YEAR_TO_MONTH |
SQL_DL_SQL92_INTERVAL_DAY_TO_HOUR | SQL_DL_SQL92_INTERVAL_DAY_TO_MINUTE |
SQL_DL_SQL92_INTERVAL_DAY_TO_SECOND |SQL_DL_SQL92_INTERVAL_HOUR_TO_MINUTE |
SQL_DL_SQL92_INTERVAL_HOUR_TO_SECOND | SQL_DL_SQL92_INTERVAL_MINUTE_TO_SECOND};
char dbms_name[]={"Trafodion"};
char dbms_ver[]=/* sq {"02.03.0054"} */ {"0.8.0"};
SQLUINTEGER ddl_index = {SQL_DI_CREATE_INDEX | SQL_DI_DROP_INDEX};
SQLUINTEGER default_txn_isolation=SQL_TXN_READ_COMMITTED;
char describe_parameter[]={"Y"};
char dm_ver[] = {"03.51.4202.0000"}; //must be greatr than 3.51.0: checking in test code
SQLUINTEGER driver_hdbc=0;
SQLUINTEGER driver_henv=0;
SQLUINTEGER driver_hlib=0;
SQLUINTEGER driver_hstmt=0;
#ifdef unixcli
char driver_name[]={"libhpodbc"};
#else
char driver_name[]={"HP_ODBC0200.DLL"};
#endif /* WIN32 */
char driver_odbc_ver[]={"03.51"};
char driver_ver[]=/* SEAQUSET {"02.03"} */ {"03.00"};
SQLUINTEGER drop_assertion = 0;
SQLUINTEGER drop_character_set = 0;
SQLUINTEGER drop_collation = 0;
SQLUINTEGER drop_domain = 0;
SQLUINTEGER drop_schema = 0;
SQLUINTEGER drop_table = {SQL_DT_DROP_TABLE | SQL_DT_RESTRICT | SQL_DT_CASCADE};
// (replaced with above) SQLUINTEGER drop_table = {SQL_DT_DROP_TABLE};
SQLUINTEGER drop_translation = 0;
SQLUINTEGER drop_view = {SQL_DV_DROP_VIEW | SQL_DV_RESTRICT | SQL_DV_CASCADE};
// (replaced with above) SQLUINTEGER drop_view = {SQL_DV_DROP_VIEW};
SQLUINTEGER dynamic_cursor_attributes1 = 0;
SQLUINTEGER dynamic_cursor_attributes2 = 0;
char expressions_in_orderby[]={"N"};
SQLUINTEGER fetch_direction=SQL_FD_FETCH_NEXT;
SQLUSMALLINT file_usage=SQL_FILE_NOT_SUPPORTED;
SQLUINTEGER forward_only_cursor_attributes1={SQL_CA1_NEXT | SQL_CA1_SELECT_FOR_UPDATE};
SQLUINTEGER forward_only_cursor_attributes2={SQL_CA2_READ_ONLY_CONCURRENCY |
SQL_CA2_LOCK_CONCURRENCY |
SQL_CA2_MAX_ROWS_SELECT};
SQLUINTEGER getdata_extensions={SQL_GD_ANY_COLUMN | SQL_GD_ANY_ORDER | SQL_GD_BOUND};
SQLUSMALLINT group_by=SQL_GB_GROUP_BY_EQUALS_SELECT;
SQLUSMALLINT identifier_case=SQL_IC_UPPER;
char identifier_quote_char[]={"\""};
SQLUINTEGER index_keywords = {SQL_IK_ASC | SQL_IK_DESC};
SQLUINTEGER info_schema_views = 0;
SQLUINTEGER insert_statement = {SQL_IS_INSERT_LITERALS | SQL_IS_INSERT_SEARCHED |
SQL_IS_SELECT_INTO};
char integrity[]={"N"};
SQLUINTEGER keyset_cursor_attributes1 = 0;
SQLUINTEGER keyset_cursor_attributes2 = 0;
char keywords[] ={"ABS,AFTER,ALIAS,BEFORE,BOOLEAN,BREADTH,CALL,COMPLETION,CONVERTTIMESTAMP,CYCLE,DATEFORMAT,DAYOFWEEK,DEPTH,DICTIONARY,EACH,EQUALS,GENERAL,IF,IGNORE,INDEX_TABLE,INVOKE,JULIANTIMESTAMP,LEAVE,LESS,LIMIT,LOAD_TABLE,LOOP,MODIFY,NEW,OBJECT,OFF,OID,OLD,OPERATION,OPERATORS,OTHERS,PARAMETERS,PENDANT,PREORDER,PRIVATE,PROTECTED,PROTOTYPE,RECURSIVE,REF,REFERENCING,REPLACE,RESIGNAL,RESOURCE_FORK,RETURN,RETURNS,ROLE,ROUTINE,ROW,SAVEPOINT,SEARCH,SENSITIVE,SHOWDDL,SHOWPLAN,SIGNAL,SIMILAR,SQLEXCEPTION,STDDEV,STRUCTURE,TEST,THERE,TRANSPOSE,TRIGGER,TYPE,UNDER,UPSHIFT,VARIABLE,VARIANCE,VIRTUAL,WAIT,WHILE,WITHOUT"};
char like_escape_clause[]={"Y"};
SQLUINTEGER lock_types = 0;
SQLUINTEGER max_async_concurrent_statements=0;
SQLUINTEGER max_binary_literal_len=8100;
SQLUSMALLINT max_catalog_name_len=128; //Changed to 128 in R2.2
SQLUINTEGER max_char_literal_len=4050;
SQLUSMALLINT max_column_name_len=128; //Changed to 128 in R2.2
SQLUSMALLINT max_columns_in_group_by=0;
SQLUSMALLINT max_columns_in_index=0;
SQLUSMALLINT max_columns_in_order_by=0;
SQLUSMALLINT max_columns_in_select=0;
SQLUSMALLINT max_columns_in_table=0;
SQLUSMALLINT max_concurrent_activities=0; // zero for unlimit
SQLUSMALLINT max_cursor_name_len=128; //Changed to 128 in R2.2
SQLUSMALLINT max_driver_connections=0;
SQLUSMALLINT max_identifier_len=128; //Changed to 128 in R2.2
SQLUINTEGER max_index_size=4050;
SQLUSMALLINT max_procedure_name_len=128;
SQLUINTEGER max_row_size=4050;
char max_row_size_includes_long[]={"Y"};
SQLUSMALLINT max_schema_name_len=128; //Changed to 128 in R2.2
SQLUINTEGER max_statement_len=0;
SQLUSMALLINT max_table_name_len=128; //Changed to 128 in R2.2
SQLUSMALLINT max_tables_in_select=0;
SQLUSMALLINT max_user_name_len=32;
char mult_result_sets[]={"N"};
char multiple_active_txn[]={"N"};
char need_long_data_len[]={"N"};
SQLUSMALLINT non_nullable_columns=SQL_NNC_NON_NULL;
SQLUSMALLINT null_collation=SQL_NC_HIGH;
SQLUINTEGER numeric_functions={SQL_FN_NUM_ABS | SQL_FN_NUM_ACOS | SQL_FN_NUM_ASIN |
SQL_FN_NUM_ATAN | SQL_FN_NUM_ATAN2 | SQL_FN_NUM_CEILING |
SQL_FN_NUM_COS | SQL_FN_NUM_DEGREES | SQL_FN_NUM_EXP |
SQL_FN_NUM_FLOOR | SQL_FN_NUM_LOG | SQL_FN_NUM_LOG10 |
SQL_FN_NUM_MOD | SQL_FN_NUM_PI | SQL_FN_NUM_POWER |
SQL_FN_NUM_RADIANS | SQL_FN_NUM_RAND | SQL_FN_NUM_SIGN |
SQL_FN_NUM_SIN | SQL_FN_NUM_SQRT | SQL_FN_NUM_TAN};
SQLUSMALLINT odbc_api_conformance=SQL_OAC_LEVEL2;
SQLUINTEGER odbc_interface_conformance = {SQL_OIC_CORE};
SQLUSMALLINT odbc_sql_conformance = {SQL_OSC_CORE};
char odbc_ver[]=/* sq {"03.52.0000"} */ {"03.51"};
SQLUINTEGER oj_capabilities={SQL_OJ_LEFT | SQL_OJ_RIGHT | SQL_OJ_NESTED |
SQL_OJ_NOT_ORDERED | SQL_OJ_INNER |
SQL_OJ_ALL_COMPARISON_OPS | SQL_OJ_FULL};
char order_by_columns_in_select[]={"N"};
char outer_joins[]={"Y"};
SQLUINTEGER param_array_roy_counts = SQL_PARC_NO_BATCH;
SQLUINTEGER param_array_selects = SQL_PAS_NO_SELECT;
SQLUINTEGER pos_operations = 0;
SQLUINTEGER positioned_statements = {SQL_PS_POSITIONED_DELETE |
SQL_PS_POSITIONED_UPDATE |
SQL_PS_SELECT_FOR_UPDATE};
char procedure_term[]={"PROCEDURE"};
char procedures[]={"Y"};
SQLUSMALLINT quoted_identifier_case=SQL_IC_SENSITIVE;
char row_updates[]={"N"};
char schema_term[]={"SCHEMA"};
SQLUINTEGER schema_usage={SQL_SU_DML_STATEMENTS | SQL_SU_TABLE_DEFINITION |
SQL_SU_PRIVILEGE_DEFINITION};
SQLUINTEGER scroll_concurrency = {SQL_SCCO_LOCK};
SQLUINTEGER scroll_options=SQL_SO_FORWARD_ONLY;
char search_pattern_escape[]={"\\"};
SQLUINTEGER sql_conformance = {SQL_SC_SQL92_ENTRY};
SQLUINTEGER sql92_datetime_functions = {SQL_SDF_CURRENT_DATE | SQL_SDF_CURRENT_TIME |
SQL_SDF_CURRENT_TIMESTAMP};
SQLUINTEGER sql92_foreign_key_delete_rule = 0;
SQLUINTEGER sql92_foreign_key_update_rule = 0;
SQLUINTEGER sql92_grant = 0;
SQLUINTEGER sql92_numeric_value_functions = {SQL_SNVF_CHAR_LENGTH |
SQL_SNVF_CHARACTER_LENGTH |
SQL_SNVF_EXTRACT | SQL_SNVF_OCTET_LENGTH |
SQL_SNVF_POSITION};
SQLUINTEGER sql92_predicates = {SQL_SP_EXISTS | SQL_SP_ISNOTNULL | SQL_SP_ISNULL |
SQL_SP_MATCH_FULL | SQL_SP_MATCH_PARTIAL | SQL_SP_LIKE |
SQL_SP_IN | SQL_SP_BETWEEN | SQL_SP_COMPARISON |
SQL_SP_QUANTIFIED_COMPARISON};
SQLUINTEGER sql92_relational_join_operators = {SQL_SRJO_CORRESPONDING_CLAUSE |
SQL_SRJO_CROSS_JOIN |
SQL_SRJO_FULL_OUTER_JOIN |
SQL_SRJO_INNER_JOIN |
SQL_SRJO_LEFT_OUTER_JOIN |
SQL_SRJO_NATURAL_JOIN |
SQL_SRJO_RIGHT_OUTER_JOIN |
SQL_SRJO_UNION_JOIN};
SQLUINTEGER sql92_revoke = 0;
SQLUINTEGER sql92_row_value_constructor = 0;
SQLUINTEGER sql92_string_functions = {SQL_SSF_CONVERT | SQL_SSF_LOWER | SQL_SSF_UPPER |
SQL_SSF_SUBSTRING | SQL_SSF_TRIM_BOTH |
SQL_SSF_TRIM_LEADING | SQL_SSF_TRIM_TRAILING};
SQLUINTEGER sql92_value_expressions = {SQL_SVE_CASE | SQL_SVE_CAST};
SQLUINTEGER standard_cli_conformance = {SQL_SCC_XOPEN_CLI_VERSION1 | SQL_SCC_ISO92_CLI};
/* SQLUINTEGER static_cursor_attributes1={SQL_CA1_NEXT | SQL_CA1_POSITIONED_UPDATE |
SQL_CA1_POSITIONED_DELETE | SQL_CA1_SELECT_FOR_UPDATE};*/
SQLUINTEGER static_cursor_attributes1 = 0;
SQLUINTEGER static_cursor_attributes2 = 0;
// char server_name[]={"TDM_Default_DataSource"};
char server_name[128];
char special_characters[]={"$\\"};
SQLUINTEGER static_sensitivity = {SQL_SS_ADDITIONS | SQL_SS_DELETIONS | SQL_SS_UPDATES};
SQLUINTEGER string_functions={SQL_FN_STR_ASCII | SQL_FN_STR_CHAR | SQL_FN_STR_CONCAT |
SQL_FN_STR_INSERT | SQL_FN_STR_LCASE | SQL_FN_STR_LEFT |
SQL_FN_STR_LENGTH | SQL_FN_STR_LOCATE_2 | SQL_FN_STR_LTRIM |
SQL_FN_STR_REPEAT | SQL_FN_STR_REPLACE | SQL_FN_STR_RIGHT |
SQL_FN_STR_RTRIM | SQL_FN_STR_SPACE | SQL_FN_STR_SUBSTRING |
SQL_FN_STR_UCASE };
SQLUINTEGER subqueries={SQL_SQ_CORRELATED_SUBQUERIES | SQL_SQ_COMPARISON |
SQL_SQ_EXISTS | SQL_SQ_IN | SQL_SQ_QUANTIFIED};
SQLUINTEGER system_functions={SQL_FN_SYS_USERNAME};
char table_term[]={"TABLE"};
SQLUINTEGER timedate_add_intervals={SQL_FN_TSI_FRAC_SECOND | SQL_FN_TSI_SECOND |
SQL_FN_TSI_MINUTE | SQL_FN_TSI_HOUR |
SQL_FN_TSI_DAY | SQL_FN_TSI_WEEK |
SQL_FN_TSI_MONTH | SQL_FN_TSI_YEAR};
SQLUINTEGER timedate_diff_intervals={SQL_FN_TSI_FRAC_SECOND | SQL_FN_TSI_SECOND |
SQL_FN_TSI_MINUTE | SQL_FN_TSI_HOUR |
SQL_FN_TSI_DAY | SQL_FN_TSI_WEEK |
SQL_FN_TSI_MONTH | SQL_FN_TSI_YEAR};
SQLUINTEGER timedate_functions={SQL_FN_TD_DAYOFMONTH
| SQL_FN_TD_DAYOFWEEK | SQL_FN_TD_DAYOFYEAR | SQL_FN_TD_MONTH | SQL_FN_TD_QUARTER
| SQL_FN_TD_WEEK | SQL_FN_TD_YEAR | SQL_FN_TD_HOUR | SQL_FN_TD_MINUTE | SQL_FN_TD_SECOND
| SQL_FN_TD_DAYNAME | SQL_FN_TD_MONTHNAME | SQL_FN_TD_CURRENT_DATE | SQL_FN_TD_CURRENT_TIME
| SQL_FN_TD_CURRENT_TIMESTAMP};
SQLUSMALLINT txn_capable=SQL_TC_ALL;
SQLUINTEGER txn_isolation_option={SQL_TXN_READ_UNCOMMITTED | SQL_TXN_READ_COMMITTED |
SQL_TXN_REPEATABLE_READ | SQL_TXN_SERIALIZABLE};
SQLUINTEGER sql_union={SQL_U_UNION};
char user_name[100]; // size is based upon SQL_MAX_USER_NAME_LEN
char xopen_cli_year[] = {"1995"};
// The SQLGetInfo options initialized in this structure are in alphabetical
// order to make it easier to maintain. Please try and keep it that way
struct{
SQLUSMALLINT InfoType;
SQLPOINTER pInfoValue;
long InfoValueLength; // equals zero if variable length string returned
} ExpectedResults[] = {
{SQL_ACCESSIBLE_PROCEDURES,accessible_procedures,1},
{SQL_ACCESSIBLE_TABLES,accessible_tables,1},
{SQL_ACTIVE_ENVIRONMENTS,&active_environments, 2},
{SQL_AGGREGATE_FUNCTIONS, &aggregate_functions, 4},
{SQL_ALTER_DOMAIN, &alter_domain, 4},
{SQL_ALTER_TABLE,&alter_table,4},
{SQL_ASYNC_MODE,&async_mode,4},
{SQL_BATCH_ROW_COUNT, &batch_row_count, 4},
{SQL_BATCH_SUPPORT, &batch_support, 4},
{SQL_BOOKMARK_PERSISTENCE,&bookmark_persistence,4},
{SQL_CATALOG_LOCATION,&catalog_location,2},
{SQL_CATALOG_NAME,catalog_name,1},
{SQL_CATALOG_NAME_SEPARATOR,catalog_name_separator,1},
{SQL_CATALOG_TERM,catalog_term,strlen(catalog_term)},
{SQL_CATALOG_USAGE,&catalog_usage,4},
{SQL_COLLATION_SEQ,collation_seq,strlen(collation_seq)},
{SQL_COLUMN_ALIAS,column_alias,strlen(column_alias)},
{SQL_CONCAT_NULL_BEHAVIOR,&concat_null_behavior,2},
{SQL_CONVERT_BIGINT,&convert_bigint,4},
{SQL_CONVERT_BINARY,&convert_binary,4},
{SQL_CONVERT_BIT,&convert_bit,4},
{SQL_CONVERT_CHAR,&convert_char,4},
{SQL_CONVERT_DATE,&convert_date,4},
{SQL_CONVERT_DECIMAL,&convert_decimal,4},
{SQL_CONVERT_DOUBLE,&convert_double,4},
{SQL_CONVERT_FLOAT,&convert_float,4},
{SQL_CONVERT_FUNCTIONS,&convert_functions,4},
{SQL_CONVERT_INTERVAL_DAY_TIME, &convert_interval_day_time, 4},
{SQL_CONVERT_INTERVAL_YEAR_MONTH, &convert_interval_year_month, 4},
{SQL_CONVERT_INTEGER,&convert_integer,4},
{SQL_CONVERT_LONGVARBINARY,&convert_longvarbinary,4},
{SQL_CONVERT_LONGVARCHAR,&convert_longvarchar,4},
{SQL_CONVERT_NUMERIC,&convert_numeric,4},
{SQL_CONVERT_REAL,&convert_real,4},
{SQL_CONVERT_SMALLINT,&convert_smallint,4},
{SQL_CONVERT_TIME,&convert_time,4},
{SQL_CONVERT_TIMESTAMP,&convert_timestamp,4},
{SQL_CONVERT_TINYINT,&convert_tinyint,4},
{SQL_CONVERT_VARBINARY,&convert_varbinary,4},
{SQL_CONVERT_VARCHAR,&convert_varchar,4},
{SQL_CONVERT_WCHAR, &convert_wchar, 4},
{SQL_CONVERT_WLONGVARCHAR, &convert_wlongvarchar, 4},
{SQL_CONVERT_WVARCHAR, &convert_wvarchar, 4},
{SQL_CORRELATION_NAME,&correlation_name,2},
{SQL_CREATE_ASSERTION, &create_assertion, 4},
{SQL_CREATE_CHARACTER_SET, &create_character_set, 4},
{SQL_CREATE_COLLATION, &create_collation, 4},
{SQL_CREATE_DOMAIN, &create_domain, 4},
{SQL_CREATE_SCHEMA, &create_schema, 4},
{SQL_CREATE_TABLE, &create_table, 4},
{SQL_CREATE_TRANSLATION, &create_translation, 4},
{SQL_CREATE_VIEW, &create_view, 4},
{SQL_CURSOR_COMMIT_BEHAVIOR,&cursor_commit_behavior,2},
{SQL_CURSOR_ROLLBACK_BEHAVIOR,&cursor_rollback_behavior,2},
{SQL_CURSOR_SENSITIVITY,&cursor_sensitivity,4},
{SQL_DATA_SOURCE_NAME,data_source_name,strlen(data_source_name)},
{SQL_DATA_SOURCE_READ_ONLY,data_source_read_only,1},
{SQL_DATABASE_NAME,database_name,strlen(database_name)},
{SQL_DATETIME_LITERALS, &datetime_literals, 4},
{SQL_DBMS_NAME,dbms_name,strlen(dbms_name)},
{SQL_DBMS_VER,dbms_ver,strlen(dbms_ver)},
{SQL_DDL_INDEX, &ddl_index, 4},
{SQL_DEFAULT_TXN_ISOLATION,&default_txn_isolation,4},
{SQL_DESCRIBE_PARAMETER,describe_parameter,1},
{SQL_DM_VER, dm_ver, strlen(dm_ver)},
#ifdef _LP64 //
{SQL_DRIVER_HDBC,&driver_hdbc,8},
{SQL_DRIVER_HENV,&driver_henv,8},
#else
{SQL_DRIVER_HDBC,&driver_hdbc,4},
{SQL_DRIVER_HENV,&driver_henv,4},
#endif
/* sq */ #ifndef unixcli
{SQL_DRIVER_HLIB,&driver_hlib,4},
/* SEAQUSET */ #endif
#ifdef _LP64 //
{SQL_DRIVER_HSTMT,&driver_hstmt,8},
#else
{SQL_DRIVER_HSTMT,&driver_hstmt,4},
#endif
{SQL_DRIVER_NAME,driver_name,strlen(driver_name)},
{SQL_DRIVER_ODBC_VER,driver_odbc_ver,strlen(driver_odbc_ver)},
{SQL_DRIVER_VER,driver_ver,strlen(driver_ver)},
{SQL_DROP_ASSERTION, &drop_assertion, 4},
{SQL_DROP_CHARACTER_SET, &drop_character_set, 4},
{SQL_DROP_COLLATION, &drop_collation, 4},
{SQL_DROP_DOMAIN, &drop_domain, 4},
{SQL_DROP_SCHEMA, &drop_schema, 4},
{SQL_DROP_TABLE, &drop_table, 4},
{SQL_DROP_TRANSLATION, &drop_translation, 4},
{SQL_DROP_VIEW, &drop_view, 4},
{SQL_DYNAMIC_CURSOR_ATTRIBUTES1,&dynamic_cursor_attributes1,4},
{SQL_DYNAMIC_CURSOR_ATTRIBUTES2, &dynamic_cursor_attributes2, 4},
{SQL_EXPRESSIONS_IN_ORDERBY,expressions_in_orderby,1},
{SQL_FETCH_DIRECTION,&fetch_direction,4},
{SQL_FILE_USAGE,&file_usage,2},
{SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES1,&forward_only_cursor_attributes1,4},
{SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES2, &forward_only_cursor_attributes2, 4},
{SQL_GETDATA_EXTENSIONS,&getdata_extensions,4},
{SQL_GROUP_BY,&group_by,2},
{SQL_IDENTIFIER_CASE,&identifier_case,2},
{SQL_IDENTIFIER_QUOTE_CHAR,identifier_quote_char,1},
{SQL_INDEX_KEYWORDS, &index_keywords, 4},
{SQL_INFO_SCHEMA_VIEWS, &info_schema_views, 4},
{SQL_INSERT_STATEMENT, &insert_statement, 4},
{SQL_INTEGRITY,integrity,1},
{SQL_KEYWORDS,keywords,strlen(keywords)},
{SQL_KEYSET_CURSOR_ATTRIBUTES1,&keyset_cursor_attributes1,4},
{SQL_KEYSET_CURSOR_ATTRIBUTES2, &keyset_cursor_attributes2, 4},
{SQL_LIKE_ESCAPE_CLAUSE,like_escape_clause,1},
{SQL_LOCK_TYPES, &lock_types, 4},
{SQL_MAX_ASYNC_CONCURRENT_STATEMENTS,&max_async_concurrent_statements,4},
{SQL_MAX_BINARY_LITERAL_LEN,&max_binary_literal_len,4},
{SQL_MAX_CATALOG_NAME_LEN,&max_catalog_name_len,2},
{SQL_MAX_CHAR_LITERAL_LEN,&max_char_literal_len,4},
{SQL_MAX_COLUMN_NAME_LEN,&max_column_name_len,2},
{SQL_MAX_COLUMNS_IN_GROUP_BY,&max_columns_in_group_by,2},
{SQL_MAX_COLUMNS_IN_INDEX,&max_columns_in_index,2},
{SQL_MAX_COLUMNS_IN_ORDER_BY,&max_columns_in_order_by,2},
{SQL_MAX_COLUMNS_IN_SELECT,&max_columns_in_select,2},
{SQL_MAX_COLUMNS_IN_TABLE,&max_columns_in_table,2},
{SQL_MAX_CONCURRENT_ACTIVITIES,&max_concurrent_activities,2},
{SQL_MAX_CURSOR_NAME_LEN,&max_cursor_name_len,2},
{SQL_MAX_DRIVER_CONNECTIONS,&max_driver_connections,2},
{SQL_MAX_IDENTIFIER_LEN,&max_identifier_len,2},
{SQL_MAX_INDEX_SIZE,&max_index_size,4},
{SQL_MAX_PROCEDURE_NAME_LEN,&max_procedure_name_len,2},
{SQL_MAX_ROW_SIZE,&max_row_size,4},
{SQL_MAX_ROW_SIZE_INCLUDES_LONG,max_row_size_includes_long,1},
{SQL_MAX_SCHEMA_NAME_LEN,&max_schema_name_len,2},
{SQL_MAX_STATEMENT_LEN,&max_statement_len,4},
{SQL_MAX_TABLE_NAME_LEN,&max_table_name_len,2},
{SQL_MAX_TABLES_IN_SELECT,&max_tables_in_select,2},
{SQL_MAX_USER_NAME_LEN,&max_user_name_len,2},
{SQL_MULT_RESULT_SETS,mult_result_sets,1},
{SQL_MULTIPLE_ACTIVE_TXN,multiple_active_txn,1},
{SQL_NEED_LONG_DATA_LEN,need_long_data_len,1},
{SQL_NON_NULLABLE_COLUMNS,&non_nullable_columns,2},
{SQL_NULL_COLLATION,&null_collation,2},
{SQL_NUMERIC_FUNCTIONS,&numeric_functions,4},
{SQL_ODBC_API_CONFORMANCE,&odbc_api_conformance,2},
{SQL_ODBC_INTERFACE_CONFORMANCE, &odbc_interface_conformance, 4},
{SQL_ODBC_SAG_CLI_CONFORMANCE, &odbc_sql_conformance, 2},
{SQL_ODBC_SQL_CONFORMANCE, &odbc_sql_conformance, 2},
{SQL_ODBC_VER,odbc_ver,strlen(odbc_ver)},
{SQL_OJ_CAPABILITIES,&oj_capabilities,4},
{SQL_ORDER_BY_COLUMNS_IN_SELECT,order_by_columns_in_select,1},
{SQL_OUTER_JOINS,outer_joins,1},
{SQL_PARAM_ARRAY_ROW_COUNTS, ¶m_array_roy_counts, 4},
{SQL_PARAM_ARRAY_SELECTS, ¶m_array_selects, 4},
{SQL_POS_OPERATIONS, &pos_operations, 4},
{SQL_POSITIONED_STATEMENTS, &positioned_statements, 4},
{SQL_PROCEDURE_TERM,procedure_term,strlen(procedure_term)},
{SQL_PROCEDURES,procedures,1},
{SQL_QUOTED_IDENTIFIER_CASE,"ed_identifier_case,2},
{SQL_ROW_UPDATES,row_updates,1},
{SQL_SCHEMA_TERM,schema_term,strlen(schema_term)},
{SQL_SCHEMA_USAGE,&schema_usage,4},
{SQL_SCROLL_CONCURRENCY, &scroll_concurrency, 4},
{SQL_SCROLL_OPTIONS,&scroll_options,4},
{SQL_SEARCH_PATTERN_ESCAPE,search_pattern_escape,1},
{SQL_SERVER_NAME,server_name,strlen(server_name)},
{SQL_SPECIAL_CHARACTERS,special_characters,strlen(special_characters)},
{SQL_SQL_CONFORMANCE, &sql_conformance, 4},
{SQL_SQL92_DATETIME_FUNCTIONS, &sql92_datetime_functions, 4},
{SQL_SQL92_FOREIGN_KEY_DELETE_RULE, &sql92_foreign_key_delete_rule, 4},
{SQL_SQL92_FOREIGN_KEY_UPDATE_RULE, &sql92_foreign_key_update_rule, 4},
{SQL_SQL92_GRANT, &sql92_grant, 4},
{SQL_SQL92_NUMERIC_VALUE_FUNCTIONS, &sql92_numeric_value_functions, 4},
{SQL_SQL92_PREDICATES, &sql92_predicates, 4},
{SQL_SQL92_RELATIONAL_JOIN_OPERATORS, &sql92_relational_join_operators, 4},
{SQL_SQL92_REVOKE, &sql92_revoke, 4},
{SQL_SQL92_ROW_VALUE_CONSTRUCTOR, &sql92_row_value_constructor, 4},
{SQL_SQL92_STRING_FUNCTIONS, &sql92_string_functions, 4},
{SQL_SQL92_VALUE_EXPRESSIONS, &sql92_value_expressions, 4},
{SQL_STANDARD_CLI_CONFORMANCE, &standard_cli_conformance, 4},
{SQL_STATIC_CURSOR_ATTRIBUTES1,&static_cursor_attributes1,4},
{SQL_STATIC_CURSOR_ATTRIBUTES2, &static_cursor_attributes2, 4},
{SQL_STATIC_SENSITIVITY, &static_sensitivity, 4},
{SQL_STRING_FUNCTIONS,&string_functions,4},
{SQL_SUBQUERIES,&subqueries,4},
{SQL_SYSTEM_FUNCTIONS,&system_functions,4},
{SQL_TABLE_TERM,table_term,strlen(table_term)},
{SQL_TIMEDATE_ADD_INTERVALS,&timedate_add_intervals,4},
{SQL_TIMEDATE_DIFF_INTERVALS,&timedate_diff_intervals,4},
{SQL_TIMEDATE_FUNCTIONS,&timedate_functions,4},
{SQL_TXN_CAPABLE,&txn_capable,2},
{SQL_TXN_ISOLATION_OPTION,&txn_isolation_option,4},
{SQL_UNION,&sql_union,4},
{SQL_USER_NAME,user_name,strlen(user_name)},
{SQL_XOPEN_CLI_YEAR, xopen_cli_year, strlen(xopen_cli_year)}
};
short TotalOptions=sizeof(ExpectedResults)/sizeof(ExpectedResults[0]);
//=====================Modified for Longvarchar Changes========================================================
if(!pTestInfo->bLongOn)
{
int i = 0;
convert_bigint = SQL_CVT_CHAR | SQL_CVT_BIGINT | SQL_CVT_DECIMAL |
SQL_CVT_DOUBLE | SQL_CVT_FLOAT | SQL_CVT_INTEGER |
SQL_CVT_VARCHAR | SQL_CVT_NUMERIC | SQL_CVT_REAL |
SQL_CVT_SMALLINT | SQL_CVT_VARCHAR ;
convert_char = SQL_CVT_CHAR | SQL_CVT_BIGINT | SQL_CVT_DATE |
SQL_CVT_DECIMAL | SQL_CVT_DOUBLE | SQL_CVT_FLOAT |
SQL_CVT_INTEGER | SQL_CVT_VARCHAR | SQL_CVT_NUMERIC |
SQL_CVT_REAL | SQL_CVT_SMALLINT | SQL_CVT_TIME |
SQL_CVT_TIMESTAMP | SQL_CVT_VARCHAR;
convert_date = SQL_CVT_CHAR | SQL_CVT_DATE | SQL_CVT_VARCHAR |
SQL_CVT_TIMESTAMP | SQL_CVT_VARCHAR;
convert_time = SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_TIME |
SQL_CVT_TIMESTAMP | SQL_CVT_VARCHAR;
convert_timestamp = SQL_CVT_CHAR | SQL_CVT_DATE | SQL_CVT_VARCHAR |
SQL_CVT_TIME | SQL_CVT_TIMESTAMP | SQL_CVT_VARCHAR;
convert_decimal=convert_bigint;
convert_double=convert_bigint;
convert_float=convert_bigint;
convert_integer=convert_bigint;
convert_numeric=convert_bigint;
convert_real=convert_bigint;
convert_smallint=convert_bigint;
#ifdef unixcli
convert_longvarchar=convert_char;
#else
convert_longvarchar=0;
#endif
convert_varchar=convert_char;
}
//=====================Modified for Longvarchar Changes========================================================
LogMsg(LINEBEFORE+SHORTTIMESTAMP,"Begin testing API => MX specific SQLGetInfo | SQLGetInfo30 | sqlgetinfover3.c\n");
TEST_INIT;
TESTCASE_BEGIN("Setup for SQLGetInfo tests\n");
if(!FullConnectWithOptions(pTestInfo, CONNECT_ODBC_VERSION_3))
{
LogMsg(NONE,"Unable to connect\n");
TEST_FAILED;
TEST_RETURN;
}
/* Set up some local variables to save on typing in longer ones */
henv = pTestInfo->henv;
hdbc = pTestInfo->hdbc;
hstmt = (SQLHANDLE)pTestInfo->hstmt;
returncode = SQLAllocHandle(SQL_HANDLE_STMT, (SQLHANDLE)hdbc, &hstmt);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocHandle")){
LogAllErrorsVer3(henv,hdbc,hstmt);
TEST_FAILED;
TEST_RETURN;
}
TESTCASE_END;
// Further defining data for some of the test cases that are run-time dependant.
for (i = 0; i < TotalOptions; i++)
{
switch (ExpectedResults[i].InfoType)
{
case SQL_DATA_SOURCE_NAME:
strcpy(data_source_name,pTestInfo->DataSource);
ExpectedResults[i].InfoValueLength = strlen(data_source_name);
break;
case SQL_DATABASE_NAME:
strcpy(database_name,pTestInfo->Catalog);
ExpectedResults[i].InfoValueLength = strlen(database_name);
break;
case SQL_SERVER_NAME:
strcpy(server_name,pTestInfo->Server);
strupr(server_name);
ExpectedResults[i].InfoValueLength = strlen(server_name);
break;
case SQL_USER_NAME:
//We now return schema as user_name.
//And now return the login name as user_name. 06/21/07 - R2.2
strcpy(user_name,pTestInfo->UserID);
//strcpy(user_name,pTestInfo->Schema);
ExpectedResults[i].InfoValueLength = strlen(user_name);
default:
break;
}
}
// Running tests
for (i = 0; i < TotalOptions; i++){
sprintf(Heading,"Test SQLGetInfo(%s)\n",
InfoTypeToChar(ExpectedResults[i].InfoType, TempString));
TESTCASE_BEGIN(Heading);
memset(u1.charInfoValue,NULL_STRING,sizeof(u1.charInfoValue));
pcbInfoValue=INVALID_pcbINFOVALUE;
if(SQL_DRIVER_HSTMT==ExpectedResults[i].InfoType){
u1.longInfoValue=(unsigned long)hstmt;
}
returncode = SQLGetInfo((SQLHANDLE)hdbc,ExpectedResults[i].InfoType,u1.charInfoValue,
(SWORD)sizeof(u1.charInfoValue),&pcbInfoValue);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetInfo")){
TEST_FAILED;
LogAllErrorsVer3(henv,hdbc,hstmt);
}
else{
// Check results for correct values
// Check returned length
switch(ExpectedResults[i].InfoType){
// These options can have a different length so don't check the length
/* sq new */
case SQL_DBMS_NAME:
/* end of sq new */
case SQL_DRIVER_NAME:
case SQL_DRIVER_VER:
case SQL_SERVER_NAME:
case SQL_ODBC_VER:
case SQL_DRIVER_HLIB:
break;
default:
if(ExpectedResults[i].InfoValueLength!=pcbInfoValue){
LogMsg(ERRMSG,"Count of bytes returned is wrong\n");
if(pcbInfoValue==INVALID_pcbINFOVALUE){
LogMsg(NONE," Expected:%ld Actual:<no value returned>\n",
ExpectedResults[i].InfoValueLength);
pcbInfoValue=(SWORD)ExpectedResults[i].InfoValueLength; // set it to a safe value since no value was returned
}
else{
LogMsg(NONE," Expected:%ld Actual:%ld\n",
ExpectedResults[i].InfoValueLength,pcbInfoValue);
}
TEST_FAILED;
}
break;
} // end of switch
// Check returned value
DifferenceOK=FALSE;
if(memcmp(ExpectedResults[i].pInfoValue,u1.charInfoValue,ExpectedResults[i].InfoValueLength)){
switch(ExpectedResults[i].InfoType){
// Yes/No return values
case SQL_ACCESSIBLE_PROCEDURES:
case SQL_ACCESSIBLE_TABLES:
case SQL_CATALOG_NAME:
case SQL_COLUMN_ALIAS:
case SQL_DATA_SOURCE_READ_ONLY:
case SQL_DESCRIBE_PARAMETER:
case SQL_EXPRESSIONS_IN_ORDERBY:
case SQL_LIKE_ESCAPE_CLAUSE:
case SQL_MULT_RESULT_SETS:
case SQL_MULTIPLE_ACTIVE_TXN:
case SQL_NEED_LONG_DATA_LEN:
case SQL_ORDER_BY_COLUMNS_IN_SELECT:
case SQL_PROCEDURES:
case SQL_ROW_UPDATES:
case SQL_OUTER_JOINS:
strcpy(ExpectedStr,(char *)ExpectedResults[i].pInfoValue);
BufferToHex(u1.charInfoValue,ActualHex,pcbInfoValue+1);
strncpy(ActualStr,u1.charInfoValue,pcbInfoValue+1);
break;
// SQLUINTEGER return values
case SQL_AGGREGATE_FUNCTIONS:
AggregateToString(*((long *)ExpectedResults[i].pInfoValue),ExpectedStr);
sprintf(ActualHex,"0x%08lX",u1.intInfoValue);
AggregateToString(u1.intInfoValue,ActualStr);
break;
case SQL_ALTER_TABLE:
AlterTableToString(*((long *)ExpectedResults[i].pInfoValue),ExpectedStr);
sprintf(ActualHex,"0x%08lX",u1.intInfoValue);
AlterTableToString(u1.intInfoValue,ActualStr);
break;
case SQL_CATALOG_USAGE:
CatalogUsageToString(*((long *)ExpectedResults[i].pInfoValue),ExpectedStr);
sprintf(ActualHex,"0x%08lX",u1.intInfoValue);
CatalogUsageToString(u1.intInfoValue,ActualStr);
break;
case SQL_CONVERT_BIGINT:
case SQL_CONVERT_BINARY:
case SQL_CONVERT_BIT:
case SQL_CONVERT_CHAR:
case SQL_CONVERT_DATE:
case SQL_CONVERT_DECIMAL:
case SQL_CONVERT_DOUBLE:
case SQL_CONVERT_FLOAT:
case SQL_CONVERT_INTERVAL_DAY_TIME:
case SQL_CONVERT_INTERVAL_YEAR_MONTH:
case SQL_CONVERT_INTEGER:
case SQL_CONVERT_LONGVARBINARY:
case SQL_CONVERT_LONGVARCHAR:
case SQL_CONVERT_NUMERIC:
case SQL_CONVERT_REAL:
case SQL_CONVERT_SMALLINT:
case SQL_CONVERT_TIME:
case SQL_CONVERT_TIMESTAMP:
case SQL_CONVERT_TINYINT:
case SQL_CONVERT_VARBINARY:
case SQL_CONVERT_VARCHAR:
case SQL_CONVERT_WCHAR:
case SQL_CONVERT_WLONGVARCHAR:
case SQL_CONVERT_WVARCHAR:
ConvertValueToString(*((long *)ExpectedResults[i].pInfoValue),ExpectedStr);
sprintf(ActualHex,"0x%08lX",u1.intInfoValue);
ConvertValueToString(u1.intInfoValue,ActualStr);
break;
case SQL_CONVERT_FUNCTIONS:
CvtFunctionToString(*((long *)ExpectedResults[i].pInfoValue),ExpectedStr);
sprintf(ActualHex,"0x%08lX",u1.intInfoValue);
CvtFunctionToString(u1.intInfoValue,ActualStr);
break;
case SQL_DEFAULT_TXN_ISOLATION:
TxnIsolationToString(*((long *)ExpectedResults[i].pInfoValue),ExpectedStr);
sprintf(ActualHex,"0x%08lX",u1.intInfoValue);
TxnIsolationToString(u1.intInfoValue,ActualStr);
break;
case SQL_DYNAMIC_CURSOR_ATTRIBUTES1:
case SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES1:
case SQL_KEYSET_CURSOR_ATTRIBUTES1:
case SQL_STATIC_CURSOR_ATTRIBUTES1:
CA1ToString(*((long *)ExpectedResults[i].pInfoValue),ExpectedStr);
sprintf(ActualHex,"0x%08lX",u1.intInfoValue);
CA1ToString(u1.intInfoValue,ActualStr);
break;
case SQL_DYNAMIC_CURSOR_ATTRIBUTES2:
case SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES2:
case SQL_KEYSET_CURSOR_ATTRIBUTES2:
case SQL_STATIC_CURSOR_ATTRIBUTES2:
CA2ToString(*((long *)ExpectedResults[i].pInfoValue),ExpectedStr);
sprintf(ActualHex,"0x%08lX",u1.intInfoValue);
CA2ToString(u1.intInfoValue,ActualStr);
break;
case SQL_NUMERIC_FUNCTIONS:
NumFunctionToString(*((long *)ExpectedResults[i].pInfoValue),ExpectedStr);
sprintf(ActualHex,"0x%08lX",u1.intInfoValue);
NumFunctionToString(u1.intInfoValue,ActualStr);
break;
case SQL_STRING_FUNCTIONS:
StrFunctionToString(*((long *)ExpectedResults[i].pInfoValue),ExpectedStr);
sprintf(ActualHex,"0x%08lX",u1.intInfoValue);
StrFunctionToString(u1.intInfoValue,ActualStr);
break;
case SQL_TIMEDATE_ADD_INTERVALS:
case SQL_TIMEDATE_DIFF_INTERVALS:
TimeIntToString(*((long *)ExpectedResults[i].pInfoValue),ExpectedStr);
sprintf(ActualHex,"0x%08lX",u1.intInfoValue);
TimeIntToString(u1.intInfoValue,ActualStr);
break;
case SQL_TIMEDATE_FUNCTIONS:
TimeFunctionToString(*((long *)ExpectedResults[i].pInfoValue),ExpectedStr);
sprintf(ActualHex,"0x%08lX",u1.intInfoValue);
TimeFunctionToString(u1.intInfoValue,ActualStr);
break;
case SQL_OJ_CAPABILITIES:
OJToString(*((long *)ExpectedResults[i].pInfoValue),ExpectedStr);
sprintf(ActualHex,"0x%08lX",u1.intInfoValue);
OJToString(u1.intInfoValue,ActualStr);
break;
case SQL_GETDATA_EXTENSIONS:
GDExtToString(*((long *)ExpectedResults[i].pInfoValue),ExpectedStr);
sprintf(ActualHex,"0x%08lX",u1.intInfoValue);
GDExtToString(u1.intInfoValue,ActualStr);
break;
case SQL_SCHEMA_USAGE:
SchemaUsageToString(*((long *)ExpectedResults[i].pInfoValue),ExpectedStr);
sprintf(ActualHex,"0x%08lX",u1.intInfoValue);
SchemaUsageToString(u1.intInfoValue,ActualStr);
break;
case SQL_DRIVER_HDBC:
case SQL_DRIVER_HENV:
case SQL_DRIVER_HLIB:
case SQL_DRIVER_HSTMT:
DifferenceOK=TRUE;
break;
case SQL_ALTER_DOMAIN:
case SQL_ASYNC_MODE:
case SQL_BATCH_ROW_COUNT:
case SQL_BATCH_SUPPORT:
case SQL_BOOKMARK_PERSISTENCE:
case SQL_SQL_CONFORMANCE:
case SQL_CREATE_ASSERTION:
case SQL_CREATE_CHARACTER_SET:
case SQL_CREATE_COLLATION:
case SQL_CREATE_DOMAIN:
case SQL_CREATE_SCHEMA:
case SQL_CREATE_TABLE:
case SQL_CREATE_TRANSLATION:
case SQL_CREATE_VIEW:
case SQL_CURSOR_SENSITIVITY:
case SQL_DATETIME_LITERALS:
case SQL_DDL_INDEX:
case SQL_DROP_ASSERTION:
case SQL_DROP_CHARACTER_SET:
case SQL_DROP_COLLATION:
case SQL_DROP_DOMAIN:
case SQL_DROP_SCHEMA:
case SQL_DROP_TABLE:
case SQL_DROP_TRANSLATION:
case SQL_DROP_VIEW:
case SQL_FETCH_DIRECTION:
case SQL_INDEX_KEYWORDS:
case SQL_INFO_SCHEMA_VIEWS:
case SQL_INSERT_STATEMENT:
case SQL_LOCK_TYPES:
case SQL_MAX_ASYNC_CONCURRENT_STATEMENTS:
case SQL_MAX_BINARY_LITERAL_LEN:
case SQL_MAX_CHAR_LITERAL_LEN:
case SQL_MAX_INDEX_SIZE:
case SQL_MAX_ROW_SIZE:
case SQL_MAX_STATEMENT_LEN:
case SQL_ODBC_INTERFACE_CONFORMANCE:
case SQL_PARAM_ARRAY_ROW_COUNTS:
case SQL_PARAM_ARRAY_SELECTS:
case SQL_POS_OPERATIONS:
case SQL_POSITIONED_STATEMENTS:
case SQL_SCROLL_CONCURRENCY:
case SQL_SCROLL_OPTIONS:
case SQL_SQL92_DATETIME_FUNCTIONS:
case SQL_SQL92_FOREIGN_KEY_DELETE_RULE:
case SQL_SQL92_FOREIGN_KEY_UPDATE_RULE:
case SQL_SQL92_GRANT:
case SQL_SQL92_NUMERIC_VALUE_FUNCTIONS:
case SQL_SQL92_PREDICATES:
case SQL_SQL92_RELATIONAL_JOIN_OPERATORS:
case SQL_SQL92_REVOKE:
case SQL_SQL92_ROW_VALUE_CONSTRUCTOR:
case SQL_SQL92_STRING_FUNCTIONS:
case SQL_SQL92_VALUE_EXPRESSIONS:
case SQL_STANDARD_CLI_CONFORMANCE:
case SQL_STATIC_SENSITIVITY:
case SQL_SUBQUERIES:
case SQL_SYSTEM_FUNCTIONS:
case SQL_TXN_ISOLATION_OPTION:
case SQL_UNION:
sprintf(ExpectedStr,"%ld",*((long *)ExpectedResults[i].pInfoValue));
sprintf(ActualHex,"0x%08lX",u1.intInfoValue);
sprintf(ActualStr,"%ld",u1.intInfoValue);
break;
// SQLUSMALLINT return values
case SQL_CATALOG_LOCATION:
CatalogLocationToString(*((short *)ExpectedResults[i].pInfoValue),ExpectedStr);
sprintf(ActualHex,"0x%04X",u1.smiInfoValue);
CatalogLocationToString(u1.smiInfoValue,ActualStr);
break;
case SQL_CONCAT_NULL_BEHAVIOR:
ConcatNullToString(*((short *)ExpectedResults[i].pInfoValue),ExpectedStr);
sprintf(ActualHex,"0x%04X",u1.smiInfoValue);
ConcatNullToString(u1.smiInfoValue,ActualStr);
break;
case SQL_CORRELATION_NAME:
CorrelationToString(*((short *)ExpectedResults[i].pInfoValue),ExpectedStr);
sprintf(ActualHex,"0x%04X",u1.smiInfoValue);
CorrelationToString(u1.smiInfoValue,ActualStr);
break;
case SQL_CURSOR_COMMIT_BEHAVIOR:
case SQL_CURSOR_ROLLBACK_BEHAVIOR:
CursorBehaviorToString(*((short *)ExpectedResults[i].pInfoValue),ExpectedStr);
sprintf(ActualHex,"0x%04X",u1.smiInfoValue);
CursorBehaviorToString(u1.smiInfoValue,ActualStr);
break;
case SQL_FILE_USAGE:
FileUsageToString(*((short *)ExpectedResults[i].pInfoValue),ExpectedStr);
sprintf(ActualHex,"0x%04X",u1.smiInfoValue);
FileUsageToString(u1.smiInfoValue,ActualStr);
break;
case SQL_GROUP_BY:
GroupByToString(*((short *)ExpectedResults[i].pInfoValue),ExpectedStr);
sprintf(ActualHex,"0x%04X",u1.smiInfoValue);
GroupByToString(u1.smiInfoValue,ActualStr);
break;
case SQL_IDENTIFIER_CASE:
CaseToString(*((short *)ExpectedResults[i].pInfoValue),ExpectedStr);
sprintf(ActualHex,"0x%04X",u1.smiInfoValue);
CaseToString(u1.smiInfoValue,ActualStr);
break;
case SQL_ACTIVE_ENVIRONMENTS:
case SQL_MAX_CATALOG_NAME_LEN:
case SQL_MAX_COLUMN_NAME_LEN:
case SQL_MAX_COLUMNS_IN_GROUP_BY:
case SQL_MAX_COLUMNS_IN_INDEX:
case SQL_MAX_COLUMNS_IN_ORDER_BY:
case SQL_MAX_COLUMNS_IN_SELECT:
case SQL_MAX_COLUMNS_IN_TABLE:
case SQL_MAX_CONCURRENT_ACTIVITIES:
case SQL_MAX_CURSOR_NAME_LEN:
case SQL_MAX_DRIVER_CONNECTIONS:
case SQL_MAX_PROCEDURE_NAME_LEN:
case SQL_MAX_SCHEMA_NAME_LEN:
case SQL_MAX_TABLE_NAME_LEN:
case SQL_MAX_TABLES_IN_SELECT:
case SQL_MAX_USER_NAME_LEN:
case SQL_ODBC_SAG_CLI_CONFORMANCE:
case SQL_ODBC_SQL_CONFORMANCE:
sprintf(ExpectedStr,"%d",*((short *)ExpectedResults[i].pInfoValue));
sprintf(ActualHex,"0x%04X",u1.smiInfoValue);
sprintf(ActualStr,"%d",u1.smiInfoValue);
break;
// Character string return values
/* sq new */
/* These values change from time to
* time, mark them as OK.
*/
case SQL_DBMS_NAME:
case SQL_DBMS_VER:
case SQL_DRIVER_NAME:
case SQL_DRIVER_VER:
case SQL_SERVER_NAME:
case SQL_ODBC_VER:
case SQL_DM_VER:
DifferenceOK = TRUE;
break;
/* end of sq new */
case SQL_CATALOG_NAME_SEPARATOR:
case SQL_CATALOG_TERM:
case SQL_COLLATION_SEQ:
case SQL_DATA_SOURCE_NAME:
case SQL_DATABASE_NAME:
// sq case SQL_DBMS_NAME:
// sq case SQL_DBMS_VER:
//case SQL_DM_VER: special case
//case SQL_DRIVER_ODBC_VER: special case handled later
case SQL_IDENTIFIER_QUOTE_CHAR:
// case SQL_KEYWORDS:
// sq case SQL_ODBC_VER:
case SQL_PROCEDURE_TERM:
case SQL_SCHEMA_TERM:
case SQL_SEARCH_PATTERN_ESCAPE:
case SQL_SPECIAL_CHARACTERS:
case SQL_TABLE_TERM:
case SQL_USER_NAME:
case SQL_XOPEN_CLI_YEAR:
// Verifying to see if our first check failed due to text casing.
if (strcmp((char *)ExpectedResults[i].pInfoValue,
_strupr(_strdup(u1.charInfoValue))) == 0) {
DifferenceOK = TRUE;
break;
}
// Mismatched casing wasn't the problem! Let's log this as an error.
strcpy(ExpectedStr,(char *)ExpectedResults[i].pInfoValue);
BufferToHex(u1.charInfoValue,ActualHex,pcbInfoValue+1);
strncpy(ActualStr,u1.charInfoValue,pcbInfoValue+1);
break;
case SQL_KEYWORDS:
// Verifying to see if our first check failed due to text casing.
if (strcmp((char *)ExpectedResults[i].pInfoValue,
_strupr(_strdup(u1.charInfoValue))) == 0) {
DifferenceOK = TRUE;
break;
}
// Mismatched casing wasn't the problem! Let's log this as an error.
strcpy(ExpectedStr,(char *)ExpectedResults[i].pInfoValue);
strncpy(ActualStr,u1.charInfoValue,pcbInfoValue+1);
break;
// sq case SQL_DRIVER_NAME:
// sq case SQL_DRIVER_VER:
// sq case SQL_SERVER_NAME:
#if 0 /* SEAQUSET */
if(strstr(_strupr(_strdup(u1.charInfoValue)),
(char *)ExpectedResults[i].pInfoValue)==NULL)
{
sprintf(ExpectedStr," something containing this string -->'%s'",
(char *)ExpectedResults[i].pInfoValue);
BufferToHex(u1.charInfoValue,ActualHex,pcbInfoValue+1);
strncpy(ActualStr,u1.charInfoValue,pcbInfoValue+1);
}
else DifferenceOK=TRUE;
break;
#endif /* SEAQUSET */
//check for driver version >= 3.51
case SQL_DRIVER_ODBC_VER:
// case SQL_DM_VER:
if(strstr(u1.charInfoValue,
"3.5")==NULL)
{
sprintf(ExpectedStr," something containing this string -->'%s'",
"3.5");
BufferToHex(u1.charInfoValue,ActualHex,pcbInfoValue+1);
strncpy(ActualStr,u1.charInfoValue,pcbInfoValue+1);
}
else DifferenceOK=TRUE;
break;
// These options still need functions to convert their flag values to
// a more user friendly string. Until then, we'll simple display them
// in hex.
// SQLUSMALLINT
case SQL_MAX_IDENTIFIER_LEN:
case SQL_NON_NULLABLE_COLUMNS:
case SQL_NULL_COLLATION:
case SQL_QUOTED_IDENTIFIER_CASE:
case SQL_TXN_CAPABLE:
case SQL_ODBC_API_CONFORMANCE:
sprintf(ExpectedStr,"%d (0x%04X)",*((short *)ExpectedResults[i].pInfoValue),
*((short *)ExpectedResults[i].pInfoValue));
sprintf(ActualHex,"0x%04X",u1.smiInfoValue);
sprintf(ActualStr,"%d",u1.smiInfoValue);
break;
} // end of switch
if(DifferenceOK){
// don't display any message
}
else{
LogMsg(ERRMSG,"Returned value is wrong\n"
" Expected:%s\n"
" Actual:%s\n"
" Actual(hex):%s\n",ExpectedStr,ActualStr,ActualHex);
TEST_FAILED;
}
} // end of if
}
TESTCASE_END;
}
// Test with StringLengthPtr set to NULL
for (i = 0; i < TotalOptions; i++){
sprintf(Heading,"Test SQLGetInfo(%s) with StringLengthPtr set to NULL.\n",
InfoTypeToChar(ExpectedResults[i].InfoType, TempString));
TESTCASE_BEGIN(Heading);
if(SQL_DRIVER_HSTMT==ExpectedResults[i].InfoType){
u1.longInfoValue=(unsigned long)hstmt;
}
returncode = SQLGetInfo((SQLHANDLE)hdbc,ExpectedResults[i].InfoType,u1.charInfoValue,
(SWORD)sizeof(u1.charInfoValue),NULL);
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetInfo")){
TEST_FAILED;
LogAllErrorsVer3(henv,hdbc,hstmt);
}
TESTCASE_END;
}
// Test with InfoValuePtr set to NULL
for (i = 0; i < TotalOptions; i++){
sprintf(Heading,"Test SQLGetInfo(%s) with InfoValuePtr set to NULL.\n",
InfoTypeToChar(ExpectedResults[i].InfoType, TempString));
TESTCASE_BEGIN(Heading);
if (ExpectedResults[i].InfoType==SQL_GETDATA_EXTENSIONS) {
returncode = SQLGetInfo((SQLHANDLE)hdbc,ExpectedResults[i].InfoType,
&u1.intInfoValue, (SWORD)sizeof(u1.intInfoValue),&pcbInfoValue);
}
else {
returncode = SQLGetInfo((SQLHANDLE)hdbc,ExpectedResults[i].InfoType,NULL,
(SWORD)sizeof(u1.charInfoValue),&pcbInfoValue);
}
if(SQL_DRIVER_HSTMT==ExpectedResults[i].InfoType){
if(!CHECKRC(SQL_ERROR,returncode,"SQLGetInfo")){
TEST_FAILED;
LogAllErrorsVer3(henv,hdbc,hstmt);
}
}
else{
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetInfo")){
TEST_FAILED;
LogAllErrorsVer3(henv,hdbc,hstmt);
}
}
TESTCASE_END;
}
// BufferLength should only effect character data returned.
// BufferLength should be ignored for any numeric values returned.
for (i = 0; i < TotalOptions; i++){
sprintf(Heading,"Test SQLGetInfo(%s) with BufferLength set to 1.\n",
InfoTypeToChar(ExpectedResults[i].InfoType, TempString));
TESTCASE_BEGIN(Heading);
if(SQL_DRIVER_HSTMT==ExpectedResults[i].InfoType){
u1.longInfoValue=(unsigned long)hstmt;
}
returncode = SQLGetInfo((SQLHANDLE)hdbc,ExpectedResults[i].InfoType,
u1.charInfoValue,1,&pcbInfoValue);
switch(ExpectedResults[i].InfoType){
// character string return values
case SQL_ACCESSIBLE_PROCEDURES:
case SQL_ACCESSIBLE_TABLES:
case SQL_CATALOG_NAME:
case SQL_CATALOG_NAME_SEPARATOR:
case SQL_CATALOG_TERM:
case SQL_COLLATION_SEQ:
case SQL_COLUMN_ALIAS:
case SQL_DATA_SOURCE_NAME:
case SQL_DATA_SOURCE_READ_ONLY:
case SQL_DATABASE_NAME:
case SQL_DBMS_NAME:
case SQL_DBMS_VER:
case SQL_DESCRIBE_PARAMETER:
case SQL_DM_VER:
case SQL_DRIVER_NAME:
case SQL_DRIVER_ODBC_VER:
case SQL_DRIVER_VER:
case SQL_EXPRESSIONS_IN_ORDERBY:
case SQL_IDENTIFIER_QUOTE_CHAR:
case SQL_INTEGRITY:
//case SQL_KEYWORDS: This is returning nothing and will return SQL_SUCCESS.
case SQL_LIKE_ESCAPE_CLAUSE:
case SQL_MAX_ROW_SIZE_INCLUDES_LONG:
case SQL_MULT_RESULT_SETS:
case SQL_MULTIPLE_ACTIVE_TXN:
case SQL_NEED_LONG_DATA_LEN:
case SQL_ODBC_VER:
case SQL_ORDER_BY_COLUMNS_IN_SELECT:
case SQL_OUTER_JOINS:
//case SQL_PROCEDURE_TERM: This is returning nothing and will return SQL_SUCCESS.
case SQL_PROCEDURES:
case SQL_ROW_UPDATES:
case SQL_SCHEMA_TERM:
case SQL_SEARCH_PATTERN_ESCAPE:
case SQL_SERVER_NAME:
case SQL_SPECIAL_CHARACTERS:
case SQL_TABLE_TERM:
//case SQL_USER_NAME: This is returning nothing and will return SQL_SUCCESS.
case SQL_XOPEN_CLI_YEAR:
if(!CHECKRC(SQL_SUCCESS_WITH_INFO,returncode,"SQLGetInfo")){
TEST_FAILED;
LogAllErrorsVer3(henv,hdbc,hstmt);
}
break;
// if not character, assume numeric return values
default:
if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetInfo")){
TEST_FAILED;
LogAllErrorsVer3(henv,hdbc,hstmt);
}
break;
}
TESTCASE_END;
}
// Testing with ConnectionHandle set to NULL
for (i = 0; i < TotalOptions; i++){
sprintf(Heading,"Test SQLGetInfo(%s) with ConnectionHandle set to NULL.\n",
InfoTypeToChar(ExpectedResults[i].InfoType, TempString));
TESTCASE_BEGIN(Heading);
if(SQL_DRIVER_HSTMT==ExpectedResults[i].InfoType){
u1.longInfoValue=(unsigned long)hstmt;
}
returncode = SQLGetInfo((SQLHANDLE)NULL,ExpectedResults[i].InfoType,u1.charInfoValue,
(SWORD)sizeof(u1.charInfoValue),&pcbInfoValue);
if(!CHECKRC(SQL_INVALID_HANDLE,returncode,"SQLGetInfo")){
TEST_FAILED;
LogAllErrorsVer3(henv,hdbc,hstmt);
}
TESTCASE_END;
}
SQLFreeHandle(SQL_HANDLE_STMT, hstmt);
FullDisconnectVer(pTestInfo, SQL_OV_ODBC3);
LogMsg(SHORTTIMESTAMP+LINEAFTER,"End testing API => MX specific SQLGetInfo.\n");
LogMsg(LINEAFTER,"\n");
TEST_RETURN;
}
