/* --------------------------------------------------------- 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; }