home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / sdk / dbmsg / odbc / quiktest / quiktest.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-09-03  |  219.7 KB  |  7,294 lines
  1. //---------------------------------------------------------------------------------------
  2. //
  3. // PROGRAM: quiktest.c
  4. //        This code is furnished on an as-is basis as part of the ODBC SDK and is
  5. //        intended for example purposes only.
  6. //
  7. //  PURPOSE: This is a Quick Test of the basic functionality of an ODBC driver.
  8. //
  9. //  FUNCTIONS:
  10. //         QuickTest() - performs the quick test focusing on basic functionalities.
  11. //
  12. //--------------------------------------------------------------------------------------------
  13. #pragma warning (disable : 4703)
  14.  
  15. #define QUIKTEST
  16.  
  17. #include "autotest.h"
  18. #include <stdio.h>
  19. #include <string.h>
  20. #include <malloc.h>
  21. #include <wchar.h>
  22. #include <tchar.h>
  23. #include <time.h>
  24. // #include <crtdbg.h>
  25. #include "sql.h"
  26. #include "sqlext.h"
  27. #include "quiktest.h"
  28.  
  29. //--------------------------------------------------------------------------------------
  30. //      static
  31. //--------------------------------------------------------------------------------------
  32. static TCHAR  vszFile[]                = TEXT(__FILE__);
  33.  
  34. static LPTSTR sz07009                    = TEXT("07009");
  35. static LPTSTR szIM001                    = TEXT("IM001");
  36. static LPTSTR szHYC00                    = TEXT("HYC00");
  37. static LPTSTR szHY009                    = TEXT("HY009");
  38. static LPTSTR szHY091                    = TEXT("HY091");
  39. static LPTSTR szHY092                    = TEXT("HY092");
  40. static LPTSTR szISO                        = TEXT("ISO 9075");
  41. static LPTSTR szODBC30                    = TEXT("ODBC 3.0");
  42. static LPTSTR szNotSupported            = TEXT("did not return Not supported message");
  43. static LPTSTR szSQLSETCONNECTATTR    = TEXT("SQLSetConnectAttr");
  44. static LPTSTR szSQLGETCONNECTATTR    = TEXT("SQLGetConnecTAttr");
  45. static LPTSTR szSQLGETINFO                = TEXT("SQLGetInfo");
  46. static LPTSTR szSQLGETTYPEINFO        = TEXT("SQLGetTypeInfo");
  47. static LPTSTR szSQLALLOCHANDLE        = TEXT("SQLAllocHandle");
  48. static LPTSTR szSQLALLOCSTMT            = TEXT("SQLAllocStmt");
  49. static LPTSTR szSQLALLOCCONNECT        = TEXT("SQLAllocConnect");
  50. static LPTSTR szSQLALLOCENV            = TEXT("SQLAllocEnv");
  51. static LPTSTR szSQLSETSTMTATTR        = TEXT("SQLSetStmtAttr");
  52. static LPTSTR szSQLGETSTMTATTR        = TEXT("SQLGetStmtAttr");
  53. static LPTSTR szSQLSETSTMTOPTION        = TEXT("SQLSetStmtOption");
  54. static LPTSTR szSQLGETSTMTOPTION        = TEXT("SQLGetStmtOption");
  55. static LPTSTR szSQLSETCONNECTOPTION    = TEXT("SQLSetConnectOption");
  56. static LPTSTR szSQLGETCONNECTOPTION    = TEXT("SQLGetConnectOption");
  57. static LPTSTR szSQLFETCH                = TEXT("SQLFetch");
  58. static LPTSTR szSQLBINDCOL                = TEXT("SQLBindCol");
  59. static LPTSTR szSQLFOREIGNKEYS        = TEXT("SQLForeignkeys");
  60. static LPTSTR szSQLFREEHANDLE            = TEXT("SQLFreeHandle");
  61. static LPTSTR szSQLFREECONNECT        = TEXT("SQLFreeConnect");
  62. static LPTSTR szSQLFREEENV                = TEXT("SQLFreeEnv");
  63. static LPTSTR szSQLGETDESCREC            = TEXT("SQLGetDescRec");
  64. static LPTSTR szSQLSETDESCREC            = TEXT("SQLSetDescRec");
  65. static LPTSTR szSQLGETDESCFIELD        = TEXT("SQLGetDescField");
  66. static LPTSTR szSQLSETDESCFIELD        = TEXT("SQLSetDescField");
  67. static LPTSTR szSQLCOPYDESC            = TEXT("SQLCopyDesc");
  68. static LPTSTR szSQLSETENVATTR            = TEXT("SQLSetEnvAttr");
  69. static LPTSTR szSQLGETENVATTR            = TEXT("SQLGetEnvAttr");
  70. static LPTSTR szSQLFREESTMT            = TEXT("SQLFreeStmt");
  71. static LPTSTR szSQLENDTRAN                = TEXT("SQLEndTran");
  72. static LPTSTR szSQLGETCURSORNAME        = TEXT("SQLGetCursorName");
  73. static LPTSTR szSQLEXECDIRECT            = TEXT("SQLExecDirect");
  74. static LPTSTR szSQLPUTDATA                = TEXT("SQLPutData");
  75. static LPTSTR szSQLPARAMDATA            = TEXT("SQLParamData");
  76. static LPTSTR szSQLROWCOUNT            = TEXT("SQLRowCount");
  77. static LPTSTR szSQLSETPARAM            = TEXT("SQLSetParam");
  78. static LPTSTR szSQLBINDPARAMETER        = TEXT("SQLBindParameter");
  79. static LPTSTR szSQLBINDPARAM            = TEXT("SQLBindParam");
  80. static LPTSTR szSQLPREPARE                = TEXT("SQLPrepare");
  81. static LPTSTR szSQLEXECUTE                = TEXT("SQLExecute");
  82. static LPTSTR szSQLCOLATTRIBUTES        = TEXT("SQLColAttributes");
  83. static LPTSTR szSQLGETDATA                = TEXT("SQLGetData");
  84. static LPTSTR szSQLCOLUMNS                = TEXT("SQLColumns");
  85. static LPTSTR szSQLGETFUNCTIONS        = TEXT("SQLGetFunctions");                  
  86. static LPTSTR szSQLDRIVERCONNECT        = TEXT("SQLDriverConnect");
  87. static LPTSTR szSQLDISCONNECT            = TEXT("SQLDisconnect");
  88. static LPTSTR szSQLCONNECT                = TEXT("SQLConnect");
  89. static LPTSTR szSQLCANCEL                = TEXT("SQLCancel");
  90. static LPTSTR szSQLDESCRIBECOL        = TEXT("SQLDescribeCol");
  91. static LPTSTR szSQLTABLES                = TEXT("SQLTables");
  92. static LPTSTR szSQLSPECIALCOLUMNS    = TEXT("SQLSpecialColumns");
  93. static LPTSTR szSQLDESCRIBEPARAM        = TEXT("SQLDescribeParam");
  94. static LPTSTR szSQLNUMPARAMS            = TEXT("SQLNumParams");
  95. static LPTSTR szSQLPARAMOPTIONS        = TEXT("SQLParamOptions");
  96. static LPTSTR szSQLPRIMARYKEYS        = TEXT("SQLPrimaryKeys");
  97. static LPTSTR szSQLEXTENDEDFETCH        = TEXT("SQLExtendedFetch");
  98. static LPTSTR szSELECTSTAR                = TEXT("select * from %s");
  99. static LPTSTR szQUICKREBIND            = TEXT("Quick Rebind");
  100. static LPTSTR szSQLBROWSECONNECT        = TEXT("SQLBrowseConnect");
  101. static LPTSTR szBLANKLINE                = TEXT(" ");
  102. static LPTSTR szTAB                        = TEXT("\t");
  103. static LPTSTR szSQLNUMRESULTCOLS        = TEXT("SQLNumResultCols");
  104. static LPTSTR szSQLSETSCROLLOPTIONS    = TEXT("SQLSetScrollOptions");
  105. static LPTSTR szSQLFETCHSCROLL        = TEXT("SQLFetchScroll");
  106. static LPTSTR szSQLSTATISTICS            = TEXT("SQLStatistics");
  107. static LPTSTR szSQLCLOSECURSOR        = TEXT("SQLCloseCursor");
  108. static LPTSTR szSQLGETDIAGREC            = TEXT("SQLGetDiagRec");
  109. static LPTSTR szSQLGETDIAGFIELD        = TEXT("SQLGetDiagField");
  110. static LPTSTR szRETDATA                    = TEXT("returned data");
  111. static LPTSTR szINCORRECTOUTLEN        = TEXT("incorrect outlen");
  112. static LPTSTR szSQLNATIVESQL            = TEXT("SQLNativeSql");
  113. static LPTSTR szSQLNATIVESQLW            = TEXT("SQLNativeSqlW");
  114. static LPTSTR szSQLCONNECTW            = TEXT("SQLConnectW");
  115. static LPTSTR szSQLTABLESA                = TEXT("SQLTablesA");
  116. static LPTSTR szSQLTABLESW                = TEXT("SQLTablesW");
  117. static LPTSTR szSQLCOLUMNSA            = TEXT("SQLColumnsA");
  118. static LPTSTR szSQLCOLUMNSW            = TEXT("SQLColumnsW");
  119. static LPTSTR szSQLEXECDIRECTA        = TEXT("SQLExecDirectA");
  120. static LPTSTR szSQLEXECDIRECTW        = TEXT("SQLExecDirectW");
  121.  
  122. LPTSTR iTestNames[]={
  123.     TEXT("Test Connection Options"),
  124.     TEXT("Test Statement Options"),
  125.     TEXT("Test SQLGetCursorName"),
  126.     TEXT("Test Data"),
  127.     TEXT("Test SQLNumResultCols"),
  128.     TEXT("Test Meta-Data"),
  129.     TEXT("Test Searched Query"),
  130.     TEXT("Test Large Query"),
  131.     TEXT("Test SQLTables"),
  132.     TEXT("Test SQLStatistics"),
  133.     TEXT("Test SQLSpecialColumns"),
  134.     TEXT("Test 'Like' Query"),
  135.     TEXT("Test SQLForeignKeys"),
  136.     TEXT("Test SQLBrowseConnect"),
  137.     TEXT("Test SQLDataSources"),
  138.     TEXT("Test SQLDrivers"),
  139.     TEXT("Test SQLMoreResults"),
  140.     TEXT("Test SQLNativeSQL"),
  141.     TEXT("Test SQLDescribeParam"),
  142.     TEXT("Test SQLNumParams"),
  143.     TEXT("Test SQLParamOptions"),
  144.     TEXT("Test SQLPrimaryKeys"),
  145.     TEXT("Test SQLProcedures"),
  146.     TEXT("Test SQLTablePrivileges"),
  147.     TEXT("Test SQLColumnPrivileges"),
  148.     TEXT("Test SQLSetScrollOptions"),
  149.     TEXT("Test SQLExtendedFetch"),
  150.     TEXT("Test SQL_OJ_CAPABILITIES"),
  151.     TEXT("Test SQLSetConnectAttr"),
  152.     TEXT("Test SQLSetStmtAttr"),
  153.     TEXT("Test Threading"),
  154.     TEXT("Test GetDescField"),
  155.     TEXT("Test SetDescField"),
  156.     TEXT("Test GetDescRec"),
  157.     TEXT("Test SetDescRec"),
  158.     TEXT("Test CopyDesc"),
  159.     TEXT("Test Descriptor Defaults"),
  160.     TEXT("Test Usage of Descriptor"),
  161.     TEXT("Test Environment Attributes"),
  162.     TEXT("Test SQLEndTran"),
  163.     TEXT("Test SQLBindParam"),
  164.     TEXT("Test Quick Rebind"),
  165.     TEXT("Test SQLFetchScroll"),
  166.     TEXT("Test GetDiagRec"),
  167.     TEXT("Test GetDiagField"),
  168.     TEXT("Test MixedAnsiUnicode")
  169. };
  170.  
  171.  
  172. typedef struct tagHANDLES
  173. {
  174.     SWORD            fHandleType;
  175.     SQLHANDLE    hHandle;
  176.  
  177. } HANDLES, *lpHANDLES;
  178.  
  179. SUPPORTOPTINFO OptionList[] = {SQL_SO_FORWARD_ONLY, SQL_SCROLL_FORWARD_ONLY,
  180.                                     SQL_SO_KEYSET_DRIVEN, SQL_SCROLL_KEYSET_DRIVEN,
  181.                                     SQL_SO_DYNAMIC, SQL_SCROLL_DYNAMIC};
  182.  
  183. SUPPORTCONCURINFO ConcurList[] = {SQL_SCCO_READ_ONLY, SQL_CONCUR_READ_ONLY,
  184.                                     SQL_SCCO_LOCK, SQL_CONCUR_LOCK,
  185.                                     SQL_SCCO_OPT_TIMESTAMP, SQL_CONCUR_TIMESTAMP,
  186.                                     SQL_SCCO_OPT_VALUES, SQL_CONCUR_VALUES};
  187.  
  188.  
  189. /*--------------------------------------------------------------------------------------*/
  190. /*     globals                                                                                                         */
  191. /*--------------------------------------------------------------------------------------*/
  192. lpSERVERINFO    lpSI = NULL;
  193. UWORD                fBindParameter=FALSE,
  194.                     fDiagRecSupported=FALSE,
  195.                     fDiagFieldSupported=FALSE,
  196.                     uDriverODBCVer=0;
  197. UWORD                guwRowCount=0;    // Count of rows in the automaketable
  198.   
  199. /* these are globals so that the error functions can access them without
  200.         needing to have them passed to every error check */
  201. static HENV            henv=SQL_NULL_HENV;
  202. static HDBC            hdbc=SQL_NULL_HDBC;
  203. static HSTMT           hstmt=SQL_NULL_HSTMT;
  204. static SQLHDESC        hdesc=SQL_NULL_HDESC;
  205.  
  206.  
  207.  
  208. //globals for test descriptors
  209. TIMESTAMP_STRUCT tsval= {1955, 12, 31, 23, 59, 59, 999};
  210. SQLINTEGER cbtsval=sizeof(TIMESTAMP_STRUCT);
  211. SQLINTEGER cbValueMax, cbValue, swBindOffset=128;
  212. SQLUINTEGER RowsProcessed;
  213. SQLSMALLINT DescBuf[MAX_DESC_BUF]; 
  214. SQLUSMALLINT StatusArray[STATUS_ARRAY_SIZE];
  215. SQLTCHAR buf[MAX_STRING_SIZE];
  216. SQLTCHAR szParamName[MAX_STRING_SIZE]=TEXT("Parameter Name");
  217.  
  218. struct tagDescType {
  219.     SQLUSMALLINT    uwDescType;
  220.     SQLUSMALLINT    uwTypeMask;
  221.     TCHAR szDescName[4];
  222. } DescTypes[] = {
  223.     SQL_ATTR_APP_ROW_DESC,        DESC_ARD,    TEXT("ARD"),
  224.     SQL_ATTR_APP_PARAM_DESC,    DESC_APD,    TEXT("APD"),
  225.     SQL_ATTR_IMP_ROW_DESC,        DESC_IRD,    TEXT("IRD"),
  226.     SQL_ATTR_IMP_PARAM_DESC,    DESC_IPD,    TEXT("IPD")
  227. };
  228.  
  229. struct tagDescInfo {
  230.     SQLSMALLINT uwDescField;
  231.     LPTSTR szDescFieldName;
  232.     BOOL fHeader;
  233.     SQLSMALLINT fGettable;    // Can be retrieved for given descriptor types
  234.     SQLSMALLINT fSettable;    // Can be set for given descriptor types
  235.     SQLSMALLINT fDefault;    // Has a default value for the descriptor types
  236.     SQLINTEGER NewValue;
  237.     SQLINTEGER DefaultVal;
  238.     SQLSMALLINT cbValue;
  239.     SQLINTEGER size;
  240. } rgDescInfo[] =    {
  241.     // Test expects all header fields to be listed first.  The TYPE field must be the first record field listed.
  242.     // size should be set to 0 for string fields, since we don't know up front what to set it to
  243.     // Field ID                                Field Name                                            Header    Gettable            Settable        fDefault        New Value                            Default Value            Data Size                    Data Type
  244.  
  245.     //Header fields
  246.     SQL_DESC_COUNT,                        TEXT("SQL_DESC_COUNT"),                        TRUE,    DESC_ALL,        DESC_MOST,    DESC_MOST,    1,                                0,                        sizeof(SQLSMALLINT),    SQL_IS_SMALLINT,
  247.     SQL_DESC_ALLOC_TYPE,                TEXT("SQL_DESC_ALLOC_TYPE"),                TRUE,    DESC_ALL,        DESC_NONE,    DESC_ALL,    0,                                SQL_DESC_ALLOC_AUTO,    sizeof(SQLSMALLINT),    SQL_IS_SMALLINT,
  248.     SQL_DESC_ARRAY_SIZE,                TEXT("SQL_DESC_ARRAY_SIZE"),                TRUE,    DESC_AD,        DESC_AD,    DESC_AD,    STATUS_ARRAY_SIZE,                1,                        sizeof(SQLUINTEGER),    SQL_IS_UINTEGER,
  249.     SQL_DESC_ARRAY_STATUS_PTR,            TEXT("SQL_DESC_ARRAY_STATUS_PTR"),            TRUE,    DESC_ALL,        DESC_ALL,    DESC_ALL,    (SQLINTEGER)(StatusArray),        (SQLINTEGER)NULL,        sizeof(SQLPOINTER),        SQL_IS_POINTER,
  250.     SQL_DESC_BIND_OFFSET_PTR,            TEXT("SQL_DESC_BIND_OFFSET_PTR"),            TRUE,    DESC_AD,        DESC_AD,    DESC_AD,    (SQLINTEGER)(&swBindOffset),    (SQLINTEGER)NULL,        sizeof(SQLPOINTER),        SQL_IS_POINTER,
  251.     SQL_DESC_BIND_TYPE,                    TEXT("SQL_DESC_BIND_TYPE"),                    TRUE,    DESC_AD,        DESC_AD,    DESC_AD,    BIND_SIZE,                        0,                        sizeof(SQLINTEGER),        SQL_IS_INTEGER,
  252. //    SQL_DESC_OUT_OF_LINE_HEAP,            TEXT("SQL_DESC_OUT_OF_LINE_HEAP"),            TRUE,    DESC_AD,        DESC_AD,                (SQLINTEGER)(StatusArray),    sizeof(SQLINTEGER),    SQL_IS_POINTER,
  253. //    SQL_DESC_OUT_OF_LINE_HEAP_OCTET_LENGTH,    TEXT("SQL_DESC_OUT_OF_LINE_HEAP_OCTET_LENGTH"),    TRUE, DESC_AD,    DESC_AD,                                                                sizeof(StatusArray),                    sizeof(SQLINTEGER),    SQL_IS_NOT_POINTER,
  254.     SQL_DESC_ROWS_PROCESSED_PTR,        TEXT("SQL_DESC_ROWS_PROCESSED_PTR"),        TRUE,    DESC_ID,        DESC_ID,    DESC_ID,    (SQLINTEGER)(&RowsProcessed),    (SQLINTEGER)NULL,        sizeof(SQLPOINTER),        SQL_IS_POINTER,
  255.  
  256.     // Record fields
  257.     SQL_DESC_TYPE,                        TEXT("SQL_DESC_TYPE"),                         FALSE,    DESC_ALL,        DESC_MOST,    DESC_AD,    SQL_DATETIME,                    SQL_C_DEFAULT,            sizeof(SQLSMALLINT),    SQL_IS_SMALLINT,
  258.     SQL_DESC_DATETIME_INTERVAL_CODE,    TEXT("SQL_DESC_DATETIME_INTERVAL_CODE"),    FALSE,    DESC_ALL,         DESC_MOST,    DESC_NONE,    SQL_CODE_TIMESTAMP,                0,                        sizeof(SQLSMALLINT),    SQL_IS_SMALLINT,
  259.     SQL_DESC_CONCISE_TYPE,                TEXT("SQL_DESC_CONCISE_TYPE"),                FALSE,    DESC_ALL,        DESC_MOST,    DESC_AD,    SQL_TYPE_TIMESTAMP,                SQL_C_DEFAULT,            sizeof(SQLSMALLINT),    SQL_IS_SMALLINT,
  260.     SQL_DESC_AUTO_UNIQUE_VALUE,            TEXT("SQL_DESC_AUTO_UNIQUE_VALUE"),            FALSE,    DESC_IRD,        DESC_NONE,    DESC_NONE,    0,                                0,                        sizeof(SQLINTEGER),        SQL_IS_INTEGER,
  261. //    SQL_DESC_BIND_OUT_OF_LINE,            TEXT("SQL_DESC_BIND_OUT_OF_LINE"),            FALSE,    DESC_AD,        DESC_AD,                SQL_TRUE,                                                sizeof(SQLSMALLINT),    SQL_IS_NOT_POINTER,
  262.     SQL_DESC_BASE_COLUMN_NAME,            TEXT("SQL_DESC_BASE_COLUMN_NAME"),            FALSE,    DESC_IRD,        DESC_NONE,    DESC_NONE,    (SQLINTEGER)szParamName,        0,                        sizeof(SQLCHAR),        0,
  263.     SQL_DESC_CASE_SENSITIVE,            TEXT("SQL_DESC_CASE_SENSITIVE"),            FALSE,    DESC_ID,        DESC_NONE,    DESC_NONE,    0,                                0,                        sizeof(SQLINTEGER),        SQL_IS_INTEGER,
  264.     SQL_DESC_CATALOG_NAME,                TEXT("SQL_DESC_CATALOG_NAME"),                FALSE,    DESC_IRD,        DESC_NONE,    DESC_NONE,    (SQLINTEGER)szParamName,        0,                        sizeof(SQLCHAR),        0,
  265.     SQL_DESC_DATETIME_INTERVAL_PRECISION, TEXT("SQL_DESC_DATETIME_INTERVAL_PRECISION"),    FALSE, DESC_ALL,DESC_MOST,    DESC_NONE,    3,                                    0,                        sizeof(SQLINTEGER),        SQL_IS_INTEGER,
  266.     SQL_DESC_DISPLAY_SIZE,                TEXT("SQL_DESC_DISPLAY_SIZE"),                FALSE,    DESC_IRD,        DESC_NONE,     DESC_NONE,    0,                                0,                        sizeof(SQLINTEGER),        SQL_IS_INTEGER,
  267.     SQL_DESC_FIXED_PREC_SCALE,            TEXT("SQL_DESC_FIXED_PREC_SCALE"),            FALSE,    DESC_ID,        DESC_NONE,    DESC_NONE,    0,                                0,                        sizeof(SQLSMALLINT),    SQL_IS_SMALLINT,
  268.     SQL_DESC_LABEL,                        TEXT("SQL_DESC_LABEL"),                        FALSE,    DESC_IRD,        DESC_NONE,    DESC_NONE,    (SQLINTEGER)szParamName,        0,                        sizeof(SQLCHAR),        0,
  269.     SQL_DESC_LENGTH,                    TEXT("SQL_DESC_LENGTH"),                    FALSE,    DESC_ALL,        DESC_MOST,    DESC_NONE,    23,                                0,                        sizeof(SQLUINTEGER),    SQL_IS_UINTEGER,
  270.     SQL_DESC_LITERAL_PREFIX,            TEXT("SQL_DESC_LITERAL_PREFIX"),            FALSE,    DESC_IRD,        DESC_NONE,    DESC_NONE,    (SQLINTEGER)szParamName,        0,                        sizeof(SQLCHAR),        0,
  271.     SQL_DESC_LITERAL_SUFFIX,            TEXT("SQL_DESC_LITERAL_SUFFIX"),            FALSE,    DESC_IRD,        DESC_NONE,    DESC_NONE,    (SQLINTEGER)szParamName,        0,                        sizeof(SQLCHAR),        0,
  272.     SQL_DESC_LOCAL_TYPE_NAME,            TEXT("SQL_DESC_LOCAL_TYPE_NAME"),            FALSE,    DESC_IRD,        DESC_NONE,    DESC_NONE,    (SQLINTEGER)szParamName,        0,                        sizeof(SQLCHAR),        0,
  273.     SQL_DESC_NAME,                        TEXT("SQL_DESC_NAME"),                        FALSE,    DESC_ID,        DESC_IPD,    DESC_NONE,    (SQLINTEGER)szParamName,        0,                        sizeof(SQLCHAR),        0,
  274.     SQL_DESC_NULLABLE,                    TEXT("SQL_DESC_NULLABLE"),                    FALSE,    DESC_ID,        DESC_NONE,    DESC_NONE,    0,                                0,                        sizeof(SQLSMALLINT),    SQL_IS_SMALLINT,
  275.     SQL_DESC_OCTET_LENGTH,                TEXT("SQL_DESC_OCTET_LENGTH"),                FALSE,    DESC_ALL,        DESC_MOST,    DESC_NONE,    sizeof(tsval),                    0,                        sizeof(SQLINTEGER),        SQL_IS_INTEGER,
  276.     SQL_DESC_OCTET_LENGTH_PTR,            TEXT("SQL_DESC_OCTET_LENGTH_PTR"),            FALSE,    DESC_AD,        DESC_AD,    DESC_AD,    (SQLINTEGER)(&cbtsval),            (SQLINTEGER)NULL,        sizeof(SQLINTEGER),        SQL_IS_POINTER,
  277.     SQL_DESC_PARAMETER_TYPE,            TEXT("SQL_DESC_PARAMETER_TYPE"),            FALSE,    DESC_IPD,        DESC_IPD,    DESC_IPD,    SQL_PARAM_OUTPUT,                SQL_PARAM_INPUT,        sizeof(SQLSMALLINT),    SQL_IS_SMALLINT,
  278.     SQL_DESC_PRECISION,                    TEXT("SQL_DESC_PRECISION"),                    FALSE,    DESC_ALL,        DESC_MOST,    DESC_NONE,    23,                                0,                        sizeof(SQLSMALLINT),    SQL_IS_SMALLINT,
  279.     SQL_DESC_SCALE,                        TEXT("SQL_DESC_SCALE"),                        FALSE,    DESC_ALL,        DESC_MOST,    DESC_NONE,    3,                                0,                        sizeof(SQLSMALLINT),    SQL_IS_SMALLINT,
  280.     SQL_DESC_SCHEMA_NAME,                TEXT("SQL_DESC_SCHEMA_NAME"),                FALSE,    DESC_IRD,        DESC_NONE,    DESC_NONE,    (SQLINTEGER)szParamName,        0,                        sizeof(SQLCHAR),        0,
  281.     SQL_DESC_SEARCHABLE,                TEXT("SQL_DESC_SEARCHABLE"),                FALSE,    DESC_IRD,        DESC_NONE,    DESC_NONE,    0,                                0,                        sizeof(SQLSMALLINT),    SQL_IS_SMALLINT,
  282.     SQL_DESC_TABLE_NAME,                TEXT("SQL_DESC_TABLE_NAME"),                FALSE,    DESC_IRD,        DESC_NONE,    DESC_NONE,    (SQLINTEGER)szParamName,        0,                        sizeof(SQLCHAR),        0,
  283.     SQL_DESC_TYPE_NAME,                    TEXT("SQL_DESC_TYPE_NAME"),                    FALSE,    DESC_ID,        DESC_NONE,    DESC_NONE,    (SQLINTEGER)szParamName,        0,                        sizeof(SQLCHAR),        0,
  284.     SQL_DESC_UNSIGNED,                    TEXT("SQL_DESC_UNSIGNED"),                    FALSE,    DESC_ID,        DESC_NONE,    DESC_NONE,    0,                                0,                        sizeof(SQLSMALLINT),    SQL_IS_SMALLINT,
  285.     SQL_DESC_UPDATABLE,                    TEXT("SQL_DESC_UPDATABLE"),                    FALSE,    DESC_IRD,        DESC_NONE,    DESC_NONE,    0,                                0,                        sizeof(SQLSMALLINT),    SQL_IS_SMALLINT,
  286.     SQL_DESC_INDICATOR_PTR,                TEXT("SQL_DESC_INDICATOR_PTR"),                FALSE,    DESC_AD,        DESC_AD,    DESC_AD,    SQL_NULL_DATA,                    (SQLINTEGER)NULL,        sizeof(SQLPOINTER),        SQL_IS_POINTER,
  287.     SQL_DESC_UNNAMED,                    TEXT("SQL_DESC_UNNAMED"),                    FALSE,    DESC_ID,        DESC_IPD,    DESC_NONE,    SQL_UNNAMED,                    SQL_NAMED,                sizeof(SQLSMALLINT),    SQL_IS_SMALLINT,
  288.     SQL_DESC_DATA_PTR,                    TEXT("SQL_DESC_DATA_PTR"),                    FALSE,    DESC_AD,        DESC_MOST,    DESC_AD,    (SQLINTEGER)&tsval,                (SQLINTEGER)NULL,        sizeof(SQLPOINTER),        SQL_IS_POINTER
  289.  };
  290.  
  291. struct tagDIAGINFO {
  292.     SQLSMALLINT uwDescField;
  293.     LPTSTR szDescFieldName;
  294.     SWORD irecRecNumber;
  295. } rgDiagInfo[] =    {
  296. //    SQL_DIAG_CURSOR_ROW_COUNT,            TEXT("SQL_DIAG_CURSOR_ROW_COUNT"),            0,
  297. //    SQL_DIAG_DYNAMIC_FUNCTION,            TEXT("SQL_DIAG_DYNAMIC_FUNCTION"),            0,
  298. //    SQL_DIAG_DYNAMIC_FUNCTION_CODE,    TEXT("SQL_DIAG_DYNAMIC_FUNCTION_CODE"),    0,
  299.     SQL_DIAG_NUMBER,                        TEXT("SQL_DIAG_NUMBER"),                        0,
  300.     SQL_DIAG_RETURNCODE,                    TEXT("SQL_DIAG_RETURNCODE"),                    0,
  301. //    SQL_DIAG_ROW_NUMBER,                    TEXT("SQL_DIAG_ROW_NUMBER"),                    0,
  302. //    SQL_DIAG_COLUMN_NUMBER,                TEXT("SQL_DIAG_COLUMN_NUMBER"),                1,
  303. //    SQL_DIAG_ROW_COUNT,                    TEXT("SQL_DIAG_ROW_COUNT"),                    0,
  304.     SQL_DIAG_SQLSTATE,                    TEXT("SQL_DIAG_SQLSTATE"),                        1,
  305.     SQL_DIAG_NATIVE,                        TEXT("SQL_DIAG_NATIVE"),                        1,
  306.     SQL_DIAG_MESSAGE_TEXT,                TEXT("SQL_DIAG_MESSAGE_TEXT"),                1,
  307.     SQL_DIAG_CLASS_ORIGIN,                TEXT("SQL_DIAG_CLASS_ORIGIN"),                1,
  308.     SQL_DIAG_SUBCLASS_ORIGIN,            TEXT("SQL_DIAG_SUBCLASS_ORIGIN"),            1,
  309. //    SQL_DIAG_CONNECTION_NAME,            TEXT("SQL_DIAG_CONNECTION_NAME"),            1,
  310.     SQL_DIAG_SERVER_NAME,                TEXT("SQL_DIAG_SERVER_NAME"),                    1,
  311. };
  312.  
  313. BOOL    g_f3XDriver=FALSE;
  314.  
  315. //the insert statement buffer    to hold the insert statement
  316. TCHAR szInsertStmt[MAX_STRING_SIZE];
  317.  
  318. //-----------------------------------------------------------------------
  319. //      Function:               Supported
  320. //-----------------------------------------------------------------------
  321.  
  322. _inline UWORD  PASCAL Supported(UWORD uwSQLFunc)
  323. {
  324.     UWORD        fLevel2=FALSE;
  325.     RETCODE    rc=SQL_SUCCESS;
  326.  
  327.     rc = SQLGetFunctions(hdbc, uwSQLFunc,&fLevel2);
  328.     RETCHECK(SQL_SUCCESS, rc,szSQLGETFUNCTIONS);
  329.  
  330.     return(fLevel2);
  331.  
  332. } //Supported()
  333.  
  334.  
  335. /*------------------------------------------------------------------------------
  336.  *    Function:    CheckDataResults - To check data returned by Fetch calls 
  337.  *    Checks data at (row, col) in result set against (row, col) in table
  338.  * ----------------------------------------------------------------------------*/
  339. BOOL CheckDataResults(SWORD row, SWORD iTableCol, FIELDINFO*  pField, DSTRUCT* pDataStr,
  340.                              SDWORD cbValue, TCHAR* rgbValue)
  341. {
  342.     if((pField ->nullable)&& (cbValue<1))
  343.     {
  344.         if(cbValue == SQL_NULL_DATA && pDataStr[iTableCol].cb == SQL_NULL_DATA)
  345.             return TRUE;
  346.         return FALSE;
  347.     }
  348.  
  349.     return CmpODBCtoCHAR(pDataStr, rgbValue, pField->wSQLType, iTableCol);
  350. }
  351.  
  352.  
  353. /*------------------------------------------------------------------------------
  354. /    Function:    BinToHex
  355. /    Purpose:    Render a buffer contents as a hexidecimal string.
  356. /*----------------------------------------------------------------------------*/
  357.  
  358. void PASCAL BinToHex(PTR rgbValue, SWORD cbValue, LPTSTR szHexString)
  359. {
  360.     UWORD ib;
  361.     LPTSTR pch;
  362.     TCHAR rgchDigits[] = TEXT("0123456789ABCDEF");
  363.  
  364.     lstrcpy(szHexString, TEXT("0x"));
  365.     if(cbValue > (MAX_STRING_SIZE - 3)/2 || cbValue < 0)
  366.         cbValue = (MAX_STRING_SIZE - 3)/2;
  367.  
  368.     pch = &szHexString[lstrlen(szHexString)];
  369.     for(ib=0; ib < cbValue; ib++)
  370.         {
  371.         *pch++ = rgchDigits[((LPBYTE)rgbValue)[ib] >> 4];
  372.         *pch++ = rgchDigits[((LPBYTE)rgbValue)[ib] & 0xF];
  373.         }
  374.     *pch = TEXT('\0');
  375.  
  376. } /* BinToHex() */
  377.  
  378.  
  379.  
  380. /*-----------------------------------------------------------------------*/
  381. /*      Function:               SearchForError                           */
  382. /*-----------------------------------------------------------------------*/
  383.  
  384. _inline int PASCAL SearchForError(HENV henv, HDBC hdbc,HSTMT hstmt,LPTSTR szFindState)
  385. {
  386.     TCHAR buf[MAX_STRING_SIZE];
  387.     RETCODE rc;
  388.     TCHAR szState[6];
  389.     int found = FALSE;
  390.  
  391.     for(rc = SQLError(henv, hdbc, hstmt, szState, NULL, buf, MAX_STRING_SIZE, NULL)
  392.         ; !found && (rc == SQL_SUCCESS || rc == SQL_SUCCESS_WITH_INFO)
  393.         ; rc = SQLError(henv, NULL, NULL, szState, NULL, buf, MAX_STRING_SIZE, NULL)) 
  394.     {
  395.         found = lstrcmp(szState, szFindState) == 0;
  396.     }
  397.  
  398.     return(found);
  399.  
  400. } /* SearchForError() */
  401.  
  402.  
  403. /*-----------------------------------------------------------------------*/
  404. /*      Function:               szWrite                                  */
  405. /*-----------------------------------------------------------------------*/
  406.  
  407. _inline VOID WINAPI szWrite(LPTSTR szStr, BOOL fNewLine)
  408. {
  409.     szLogPrintf(lpSI, FALSE, szStr);
  410.     if(fNewLine)
  411.         szLogPrintf(lpSI, FALSE, TEXT("\r\n"));
  412. }
  413.  
  414. /*-----------------------------------------------------------------------*/
  415. /*      Function:               GetErrors                                     */
  416. /*-----------------------------------------------------------------------*/
  417.  
  418. VOID PASCAL GetErrors(HENV henv,HDBC hdbc,HSTMT hstmt)
  419. {
  420.     TCHAR buf[MAX_ERROR_SIZE];
  421.     TCHAR largebuf[COMBINED_SIZE];
  422.     TCHAR szState[100];
  423.     RETCODE rc=SQL_SUCCESS;
  424.  
  425.     for(rc = SQLError(henv, hdbc, hstmt, szState, NULL, buf, MAX_ERROR_SIZE, NULL)
  426.         ; RC_SUCCESSFUL(rc)
  427.         ; rc = SQLError(henv, NULL, NULL, szState, NULL, buf, MAX_ERROR_SIZE, NULL))
  428.     {
  429.         wsprintf(largebuf,TEXT("\t\t\tState: %s"), szState);
  430.         szWrite(largebuf, TRUE);
  431.         wsprintf(largebuf,TEXT("\t\t\tError: %s"), buf);
  432.         szWrite(largebuf, TRUE);
  433.     }
  434.  
  435. } /* GetErrors() */
  436.  
  437.  
  438. /*-----------------------------------------------------------------------*/
  439. /*      Function:               GetDiagRecs                                 */
  440. /*-----------------------------------------------------------------------*/
  441.  
  442. VOID PASCAL GetDiagRecs(SWORD fHandleType,SQLHANDLE hHandle)
  443. {
  444.     TCHAR        szMessageText[XLARGEBUFF]=TEXT(""),
  445.                 szBuff[XLARGEBUFF]=TEXT("");
  446.     TCHAR        szSQLState[100]=TEXT("");
  447.     RETCODE    rc=SQL_SUCCESS;
  448.     SWORD        irecRecNumber=0;
  449.     SDWORD    fNativeError=0;
  450.     SWORD        cbBufferLength=sizeof(szMessageText),
  451.                 cbTextLength=0;
  452.     SDWORD    sdNumRecs=0;
  453.  
  454.     if (fDiagFieldSupported)
  455.     {
  456.         /* Get number of diag, records */
  457.         rc = SQLGetDiagField(fHandleType, hHandle,0,SQL_DIAG_NUMBER,
  458.             &sdNumRecs,sizeof(sdNumRecs),NULL);
  459.     }
  460.  
  461.  
  462.     for(irecRecNumber=1;(irecRecNumber <= sdNumRecs) && RC_SUCCESSFUL(rc);irecRecNumber++)
  463.     {
  464.         rc = SQLGetDiagRec(fHandleType, hHandle, irecRecNumber,szSQLState,&fNativeError,
  465.             szMessageText,cbBufferLength,&cbTextLength);
  466.  
  467.         if (RC_SUCCESSFUL(rc))
  468.         {
  469.             wsprintf(szBuff,TEXT("\t\t\tState: %s"), szSQLState);
  470.             szWrite(szBuff, TRUE);
  471.             wsprintf(szBuff,TEXT("\t\t\tError: %s"), szMessageText);
  472.             szWrite(szBuff, TRUE);
  473.         }
  474.  
  475.     }
  476.  
  477.  
  478. } /* GetErrors() */
  479.  
  480.  
  481.  
  482. /*-----------------------------------------------------------------------*/
  483. /*      Function:               DisplayAllErrors                         */
  484. /*-----------------------------------------------------------------------*/
  485.  
  486. void  PASCAL DisplayAllErrors()
  487. {
  488.     if (!fDiagRecSupported)
  489.     {
  490.         GetErrors(henv,NULL,NULL);
  491.         GetErrors(NULL,hdbc,NULL);
  492.         GetErrors(NULL,NULL,hstmt);
  493.     }
  494.     else
  495.     {
  496.         GetDiagRecs(SQL_HANDLE_ENV,henv);
  497.         GetDiagRecs(SQL_HANDLE_DBC,hdbc);
  498.         GetDiagRecs(SQL_HANDLE_STMT,hstmt);
  499.         GetDiagRecs(SQL_HANDLE_DESC,hdesc);
  500.     }
  501.  
  502. } /* DisplayAllErrors() */
  503.  
  504.  
  505. /*-----------------------------------------------------------------------*/
  506. /*      Function:               RetcodeToTCHAR                            */
  507. /*-----------------------------------------------------------------------*/
  508.  
  509. LPTSTR  PASCAL RetcodeToTCHAR(RETCODE retcode, LPTSTR buf)
  510. {
  511.     switch (retcode) 
  512.         {
  513.         case SQL_SUCCESS:
  514.             lstrcpy (buf,TEXT("SQL_SUCCESS"));
  515.             break;
  516.         case SQL_ERROR:
  517.             lstrcpy (buf,TEXT("SQL_ERROR"));
  518.             break;
  519.         case SQL_SUCCESS_WITH_INFO:
  520.             lstrcpy (buf,TEXT("SQL_SUCCESS_WITH_INFO"));
  521.             break;
  522.         case SQL_NO_DATA_FOUND:
  523.             lstrcpy (buf,TEXT("SQL_NO_DATA_FOUND"));
  524.             break;
  525.         case SQL_NEED_DATA:
  526.             lstrcpy (buf,TEXT("SQL_NEED_DATA"));
  527.             break;
  528.         case SQL_INVALID_HANDLE:
  529.             lstrcpy (buf,TEXT("SQL_INVALID_HANDLE"));
  530.             break;
  531.         case SQL_STILL_EXECUTING:
  532.             lstrcpy (buf,TEXT("SQL_STILL_EXECUTING"));
  533.             break;
  534.         default:
  535.             lstrcpy(buf,TEXT("UNKNOWN rc"));
  536.         }
  537.  
  538.     return buf;
  539. }
  540.  
  541.  
  542.  
  543. //-----------------------------------------------------------------------
  544. //      Function:               ReturnCheck
  545. //-----------------------------------------------------------------------
  546.  
  547. int  PASCAL ReturnCheck(RETCODE retExpected, RETCODE retReceived, LPTSTR szFunction, 
  548.                                 LPTSTR szFile, int iLine,BOOL fDiag)
  549. {
  550.     TCHAR buf[MAX_STRING_SIZE];
  551.  
  552.     if(retExpected == retReceived)
  553.         return TRUE;
  554.  
  555.     szWrite(TEXT(""), TRUE);
  556.                         
  557.     szWrite(TEXT("\t\t\t"), FALSE);
  558.     szWrite(szFunction, TRUE);
  559.  
  560.     szWrite(TEXT("\t\t\tExpected: "), FALSE);
  561.     szWrite(RetcodeToTCHAR(retExpected, buf), TRUE);
  562.  
  563.     szWrite(TEXT("\t\t\tReceived: "), FALSE);
  564.     szWrite(RetcodeToTCHAR(retReceived, buf), TRUE);
  565.  
  566.     if (!fDiag)
  567.         DisplayAllErrors();
  568.  
  569.     wsprintf(buf,TEXT("\t\t\t%s: %d"), szFile, iLine);
  570.     szWrite(buf, TRUE);
  571.  
  572.     szWrite(TEXT("\t\t\t --------  "), TRUE);
  573.  
  574.     lpSI->failed++;
  575.  
  576.     return FALSE;
  577. }
  578.  
  579. //-----------------------------------------------------------------------
  580. //      Function:               ErrsHandle
  581. //-----------------------------------------------------------------------
  582.  
  583. int  PASCAL ErrsHandle(SWORD fHandleType,SQLHANDLE hHandle, RETCODE retExpected,
  584.     RETCODE retReceived, LPTSTR szFunction, LPTSTR szFile, int iLine,BOOL fDiag)
  585. {
  586.     TCHAR buf[MAX_STRING_SIZE];
  587.  
  588.     if(retExpected == retReceived)
  589.         return TRUE;
  590.  
  591.     szWrite(TEXT(""), TRUE);
  592.                         
  593.     szWrite(TEXT("\t\t\t"), FALSE);
  594.     szWrite(szFunction, TRUE);
  595.  
  596.     szWrite(TEXT("\t\t\tExpected: "), FALSE);
  597.     szWrite(RetcodeToTCHAR(retExpected, buf), TRUE);
  598.  
  599.     szWrite(TEXT("\t\t\tReceived: "), FALSE);
  600.     szWrite(RetcodeToTCHAR(retReceived, buf), TRUE);
  601.  
  602.     if (!fDiag)
  603.         GetDiagRecs(fHandleType,hHandle);
  604.  
  605.     wsprintf(buf,TEXT("\t\t\t%s: %d"), szFile, iLine);
  606.     szWrite(buf, TRUE);
  607.  
  608.     szWrite(TEXT("\t\t\t --------  "), TRUE);
  609.  
  610.     lpSI->failed++;
  611.  
  612.     return FALSE;
  613. }
  614.  
  615. /*------------------------------------------------------------------------------
  616. /    Function:    FindError
  617. /    Purpose:    Find the expected error message. Display a failure if not found.
  618. /*----------------------------------------------------------------------------*/
  619.  
  620. BOOL PASCAL FindError(SWORD fHandleType, LPTSTR szFindState)
  621. {
  622.     SQLHANDLE handle = SQL_NULL_HANDLE;
  623.     SWORD irec;
  624.     TCHAR szErrorMsg[SQL_MAX_MESSAGE_LENGTH];
  625.     RETCODE rc;
  626.     TCHAR szState[6];
  627.  
  628.     switch(fHandleType)
  629.     {
  630.         case SQL_HANDLE_ENV:
  631.             handle = henv;
  632.             break;
  633.  
  634.         case SQL_HANDLE_DBC:
  635.             handle = hdbc;
  636.             break;
  637.  
  638.         case SQL_HANDLE_STMT:
  639.             handle = hstmt;
  640.             break;
  641.  
  642.         case SQL_HANDLE_DESC:
  643.             if(!Supported(SQL_API_SQLGETDIAGREC))
  644.                 return TRUE;
  645.  
  646.             handle = hdesc;
  647.             break;
  648.  
  649.         default:
  650.             DISPLAYERROR(TEXT("FindError"), TEXT("invalid fHandleType"));
  651.             return FALSE;
  652.     }
  653.  
  654.     for(irec = 1
  655.         ; rc = SQLGetDiagRec(fHandleType, handle, irec, szState, NULL, szErrorMsg, SQL_MAX_MESSAGE_LENGTH, NULL)
  656.         , RC_SUCCESSFUL(rc)
  657.         ; irec++)
  658.     {
  659.         if(lstrcmp(szState, szFindState) == 0)
  660.             return TRUE;
  661.     }
  662.     return FALSE;
  663.  
  664. } /* FindError() */
  665.  
  666. /*------------------------------------------------------------------------------
  667.  *    Function:    CompareWithExpected
  668.  *    Checks data in rgbValue against expected value given row, col, and rgFields.
  669.  *    Posts an error if mismatch
  670.  * ----------------------------------------------------------------------------*/
  671. void CompareWithExpected(PTR rgbValue, SDWORD * pcbValue, UWORD row, UWORD icol, FIELDINFO  *rgFields)
  672. {
  673.     LPTSTR   pch=NULL;
  674.     TCHAR szExpBuf[MAX_STRING_SIZE]=TEXT("");
  675.     TCHAR * stopstr;
  676.  
  677.     pch = qtMakeData(row-1, icol-1, &rgFields[icol-1], szExpBuf);
  678.  
  679.     // Field is not READ ONLY, compare the value we inserted
  680.     if(pch) 
  681.     {
  682.          // Where row and column match and field is nullable, a NULL exists
  683.         if (icol-1 == row-1 && rgFields[icol-1].nullable)
  684.         {
  685.             // Post an error if not SQL_NULL_DATA
  686.             if (*pcbValue != SQL_NULL_DATA)
  687.                 DISPLAYERROR(TEXT("Simulate BindCol"),TEXT("Didn't return SQL_NULL_DATA"));
  688.         }
  689.         else
  690.         {
  691.             BOOL bCompare;
  692.             TCHAR * pstr=szExpBuf;    // Pointer to start of expected string
  693.  
  694.             switch(rgFields[icol-1].wSQLType)
  695.             {
  696.                 case SQL_BIT:
  697.                 case SQL_TINYINT:
  698.                 case SQL_SMALLINT:
  699.                 case SQL_INTEGER:
  700.                     // Compare the data values as long // tcsncmp
  701.                     bCompare=(_ttol(rgbValue) == _ttol(pstr));
  702.                     break;
  703.                 case SQL_NUMERIC:
  704.                 case SQL_DECIMAL:
  705.                 case SQL_FLOAT:
  706.                 case SQL_REAL:
  707.                 case SQL_DOUBLE:
  708.                     // Compare the data values as doubles strtod
  709.                     bCompare=(_tcstod(rgbValue, &stopstr) == _tcstod(pstr, &stopstr));
  710.                     break;
  711.                 case SQL_DATE:
  712.                 case SQL_TIME:
  713.                 case SQL_TIMESTAMP:
  714.                 case SQL_TYPE_DATE:
  715.                 case SQL_TYPE_TIME:
  716.                 case SQL_TYPE_TIMESTAMP:
  717.                     pstr=szExpBuf+lstrlen(TEXT("{ts '"));
  718.                     // Replace second ' with '\0'                                    '
  719.                     _tcstok(pstr, TEXT("'"));
  720.                     if (lstrlen(rgbValue) > lstrlen(TEXT("1994-10-10 10:00:00")))
  721.                         lstrcat(pstr, TEXT(".000"));
  722.                     bCompare=(!_tcsncmp(rgbValue, pstr, rgFields[icol-1].precision));
  723.                     break;
  724.                 default:
  725.                     bCompare=(!_tcsncmp(rgbValue, pstr, lstrlen(pstr)));
  726.             }
  727.  
  728.             // Compare the data values as char 
  729.             if (!bCompare)
  730.             {
  731.                 DISPLAYERROR(TEXT("Simulate BindCol"),TEXT("Returned data didn't match"));
  732.                 szWrite(TEXT("\t\t\tExpected: "), FALSE);
  733.                 szWrite(pstr, TRUE);
  734.                 szWrite(TEXT("\t\t\tReceived: "), FALSE);
  735.                 szWrite(rgbValue, TRUE);
  736.             }
  737.         }
  738.     }
  739. } //CompareWithExpected
  740.  
  741. //-----------------------------------------------------------------------
  742. //      Function:               ResetHstmt
  743. //-----------------------------------------------------------------------
  744. void ResetHstmt(SQLHSTMT * phstmt)
  745. {
  746.     SQLRETURN rc;
  747.  
  748.     // Free and reallocate stmt handle to clean up
  749.     rc=SQLFreeHandle(SQL_HANDLE_STMT, *phstmt);
  750.     ERRSHANDLE(SQL_HANDLE_STMT, *phstmt, SQL_SUCCESS, rc, szSQLFREESTMT);
  751.     rc=SQLAllocHandle(SQL_HANDLE_STMT, hdbc, phstmt);
  752.     RETCHECK(SQL_SUCCESS, rc,szSQLALLOCHANDLE);
  753. }
  754.  
  755. /*-----------------------------------------------------------------------*/
  756. /*      Function:               GetSomeData                              */
  757. /*-----------------------------------------------------------------------*/
  758.  
  759. VOID PASCAL GetSomeData(HSTMT lhstmt, LPTSTR szTableName,BOOL fBindCol,
  760.                                 FIELDINFO  rgField)
  761. {
  762.     RETCODE    rc=SQL_SUCCESS;
  763.     SDWORD    cbValue=0;
  764.     TCHAR        szQuery[XLARGEBUFF]=TEXT(""),
  765.                 szBuff[XLARGEBUFF]=TEXT("");
  766.     TCHAR        szErrMsg[MAX_STRING_SIZE]=TEXT(""),
  767.                 szDataItem[XLARGEBUFF]=TEXT("");
  768.     LPTSTR   pch=NULL;
  769.  
  770.     pch = qtMakeData(0, 0,&rgField, szDataItem);
  771.  
  772.     wsprintf(szQuery,szSELECTSTAR,szTableName);
  773.     rc=SQLExecDirect(lhstmt,szQuery,SQL_NTS);
  774. //    RETCHECK(SQL_SUCCESS,rc,szSQLEXECDIRECT);
  775.  
  776.     if (fBindCol)
  777.     {
  778.         rc = SQLBindCol(lhstmt, 1, SQL_C_TCHAR, szBuff, sizeof(szBuff),&cbValue);
  779. //        RETCHECK(SQL_SUCCESS, rc, szSQLBINDCOL);
  780.     }
  781.  
  782.     rc = SQLFetch(lhstmt);
  783. //    RETCHECK(SQL_SUCCESS, rc,szSQLFETCH);
  784.  
  785.     if (!fBindCol)
  786.     {
  787.         rc = SQLGetData(lhstmt,1, SQL_C_TCHAR,szBuff, sizeof(szBuff), NULL);
  788. //        RETCHECK(SQL_SUCCESS, rc,szSQLGETDATA);
  789.     }
  790.  
  791.     lstrcmp(szDataItem,szBuff);
  792.  
  793. } /* GetSomeData() */
  794.  
  795.  
  796.  
  797. /*-----------------------------------------------------------------------*/
  798. /*      Function:               SelectFromTable                          */
  799. /*-----------------------------------------------------------------------*/
  800.  
  801. _inline RETCODE PASCAL SelectFromTable(QTSTRUCT *lpqt)
  802. {
  803.     RETCODE    rc=SQL_SUCCESS;
  804.     TCHAR        szQuery[LARGEBUFF];
  805.  
  806.     wsprintf(szQuery,TEXT("select %s from %s"), 
  807.     //wsprintf(szQuery,TEXT("select %s from %s order by %s"), 
  808.         lpqt->szColNames, lpqt->szTableName/*, lpqt->szColNames*/);
  809.  
  810.     rc = SQLExecDirect(hstmt, szQuery, SQL_NTS);
  811.     RETCHECK(SQL_SUCCESS, rc,szSQLEXECDIRECT);
  812.  
  813.     return(rc);
  814.  
  815. } /* SelectFromTable() */
  816.  
  817. /*-----------------------------------------------------------------------*/
  818. /*      Function:               SelectFromTableFetch                     */
  819. /*-----------------------------------------------------------------------*/
  820.  
  821. _inline RETCODE PASCAL SelectFromTableFetch(QTSTRUCT *lpqt, TCHAR* szColName)
  822. {
  823.     RETCODE    rc=SQL_SUCCESS;
  824.     TCHAR        szQuery[LARGEBUFF];
  825.  
  826.     wsprintf(szQuery,TEXT("select %s from %s order by %s"), 
  827.         lpqt->szColNames, lpqt->szTableName, szColName);
  828.  
  829.     rc = SQLExecDirect(hstmt, szQuery, SQL_NTS);
  830.     if((SQL_SUCCESS!=rc) && (SQL_SUCCESS_WITH_INFO!=rc)){
  831.         RETCHECK(SQL_SUCCESS_WITH_INFO, rc,szSQLEXECDIRECT);
  832.         return SQL_NO_DATA;
  833.     }
  834.  
  835.     return SQL_SUCCESS;
  836. } /* SelectFromTableFetch() */
  837.  
  838. //-----------------------------------------------------------------------
  839. //      Function:               AllocHstmt
  840. //-----------------------------------------------------------------------
  841.  
  842. _inline BOOL PASCAL AllocHstmt()
  843. {
  844.     BOOL        fFailed=FALSE;
  845.     RETCODE    rc=SQL_SUCCESS;
  846.  
  847.     if (Supported(SQL_API_SQLALLOCHANDLE))
  848.     {
  849.         rc = SQLAllocHandle(SQL_HANDLE_STMT,hdbc, &hstmt);
  850.         if(!RETCHECK(SQL_SUCCESS, rc, szSQLALLOCHANDLE))
  851.             fFailed=TRUE;
  852.     }
  853.     else
  854.     {
  855.         rc = SQLAllocStmt(hdbc, &hstmt);
  856.         if(!RETCHECK(SQL_SUCCESS, rc, szSQLALLOCSTMT))
  857.             fFailed=TRUE;
  858.     }
  859.  
  860.  
  861.     return(fFailed);
  862.  
  863. } //AllocHstmt()
  864.  
  865.  
  866.  
  867. //-----------------------------------------------------------------------
  868. //      Function:               AllocHdbc
  869. //-----------------------------------------------------------------------
  870.  
  871. _inline BOOL PASCAL AllocHdbc(HDBC *phdbc)
  872. {
  873.     BOOL        fFailed=FALSE;
  874.     RETCODE    rc=SQL_SUCCESS;
  875.  
  876.     if (Supported(SQL_API_SQLALLOCHANDLE))
  877.     {
  878.         rc = SQLAllocHandle(SQL_HANDLE_DBC,henv, phdbc);
  879.         if(!RETCHECK(SQL_SUCCESS, rc, szSQLALLOCHANDLE))
  880.             fFailed=TRUE;
  881.     }
  882.     else
  883.     {
  884.         rc = SQLAllocConnect(henv, phdbc);
  885.         if(!RETCHECK(SQL_SUCCESS, rc, szSQLALLOCCONNECT))
  886.             fFailed=TRUE;
  887.     }
  888.  
  889.  
  890.     return(fFailed);
  891.  
  892. } //AllocHdbc()
  893.  
  894.  
  895. //-----------------------------------------------------------------------
  896. //      Function:                    AllocHenv
  897. //-----------------------------------------------------------------------
  898.  
  899. _inline BOOL PASCAL PASCAL AllocHenv()
  900. {
  901.     BOOL        fFailed=FALSE;
  902.     RETCODE    rc=SQL_SUCCESS;
  903.  
  904.     rc = SQLAllocEnv(&henv);
  905.     if (!RETCHECK(SQL_SUCCESS, rc,szSQLALLOCENV))
  906.         fFailed=TRUE;
  907.  
  908.     return(fFailed);
  909.  
  910. } //AllocHenv()
  911.  
  912. //-----------------------------------------------------------------------
  913. //      Function:               SetStatementAttributes
  914. //-----------------------------------------------------------------------
  915.  
  916. _inline BOOL PASCAL SetStatementAttributes(UWORD fAttr, PTR rgbValue)
  917. {
  918.     RETCODE    rc=SQL_SUCCESS;
  919.     TCHAR        szAPI[MEDBUFF];
  920.     BOOL        fFailed=FALSE;
  921.  
  922.     if (Supported(SQL_API_SQLSETSTMTATTR))
  923.     {
  924.         rc = SQLSetStmtAttr(hstmt,(SDWORD)fAttr,rgbValue,sizeof(UDWORD));
  925.         lstrcpy(szAPI,szSQLSETSTMTATTR);
  926.     }
  927.     else
  928.     {
  929.         rc = SQLSetStmtOption(hstmt,fAttr,(UDWORD)rgbValue);
  930.         lstrcpy(szAPI,szSQLSETSTMTOPTION);
  931.     }
  932.  
  933.     if (rc != SQL_SUCCESS)
  934.     {
  935.         if(!FindError(SQL_HANDLE_STMT,szHYC00))
  936.             RETCHECK(SQL_SUCCESS, rc,szAPI);
  937.  
  938.         fFailed=TRUE;
  939.     }
  940.  
  941.     return(fFailed);
  942.  
  943. } //SetStatementAttributes()
  944.  
  945.  
  946.  
  947. //-----------------------------------------------------------------------
  948. //      Function:               SetConnectionAttributes
  949. //-----------------------------------------------------------------------
  950.  
  951. _inline BOOL PASCAL SetConnectionAttributes(HDBC lhdbc,UWORD fAttr, UDWORD rgbValue)
  952. {
  953.     RETCODE    rc=SQL_SUCCESS;
  954.     TCHAR        szAPI[MEDBUFF];
  955.     BOOL        fFailed=FALSE;
  956.  
  957.     if (Supported(SQL_API_SQLSETCONNECTATTR))
  958.     {
  959.         rc = SQLSetConnectAttr(lhdbc,(SDWORD)fAttr,(PTR)rgbValue,sizeof(UDWORD));
  960.         lstrcpy(szAPI,szSQLSETCONNECTATTR);
  961.     }
  962.     else
  963.     {
  964.         rc = SQLSetConnectOption(lhdbc,fAttr,rgbValue);
  965.         lstrcpy(szAPI,szSQLSETCONNECTOPTION);
  966.     }
  967.  
  968.     if (rc != SQL_SUCCESS)
  969.     {
  970.         if(!FindError(SQL_HANDLE_DBC,szHYC00))
  971.             RETCHECK(SQL_SUCCESS, rc,szAPI);
  972.  
  973.         fFailed=TRUE;
  974.     }
  975.  
  976.     return(fFailed);
  977.  
  978. } //SetConnectionAttributes()
  979.  
  980.  
  981.  
  982. //-----------------------------------------------------------------------
  983. //      Function:               FreeStmt
  984. //-----------------------------------------------------------------------
  985.  
  986. _inline BOOL PASCAL FreeStmt(UWORD fOption)
  987. {
  988.     RETCODE    rc=SQL_SUCCESS;
  989.  
  990.     if (Supported(SQL_API_SQLFREEHANDLE) && (fOption == SQL_DROP))
  991.     {
  992.         rc = SQLFreeHandle(SQL_HANDLE_STMT,hstmt);
  993.         RETCHECK(SQL_SUCCESS, rc,szSQLFREEHANDLE);
  994.     }
  995.     else
  996.     {
  997.         rc = SQLFreeStmt(hstmt, fOption);
  998.         RETCHECK(SQL_SUCCESS, rc,szSQLFREESTMT);
  999.     }
  1000.  
  1001.     return(RC_NOTSUCCESSFUL(rc));
  1002.  
  1003. } //FreeStmt()
  1004.  
  1005. //-----------------------------------------------------------------------
  1006. //      Function:               DropHdbc
  1007. //-----------------------------------------------------------------------
  1008.  
  1009. VOID PASCAL DropHdbc(HDBC hdbc)
  1010. {
  1011.     RETCODE rc=SQL_SUCCESS;
  1012.  
  1013.     if (Supported(SQL_API_SQLFREEHANDLE))
  1014.     {
  1015.         rc = SQLFreeHandle(SQL_HANDLE_DBC,hdbc);
  1016.         RETCHECK(SQL_SUCCESS, rc,szSQLFREEHANDLE);
  1017.     }
  1018.     else
  1019.     {
  1020.         rc = SQLFreeConnect(hdbc);
  1021.         RETCHECK(SQL_SUCCESS, rc,szSQLFREECONNECT);
  1022.     }
  1023.  
  1024. } //DropHdbc()
  1025.  
  1026.  
  1027.  
  1028. //-----------------------------------------------------------------------
  1029. //      Function:               DropHenv
  1030. //-----------------------------------------------------------------------
  1031.  
  1032. _inline VOID PASCAL DropHenv()
  1033. {
  1034.     RETCODE rc=SQL_SUCCESS;
  1035.  
  1036.     if (Supported(SQL_API_SQLFREEHANDLE))
  1037.     {
  1038.         rc = SQLFreeHandle(SQL_HANDLE_ENV,henv);
  1039.         RETCHECK(SQL_SUCCESS, rc,szSQLFREEHANDLE);
  1040.     }
  1041.     else
  1042.     {
  1043.         rc = SQLFreeEnv(henv);
  1044.         RETCHECK(SQL_SUCCESS, rc,szSQLFREEENV);
  1045.     }
  1046.  
  1047. } //DropHenv()
  1048.  
  1049.  
  1050. //-----------------------------------------------------------------------
  1051. //      Function:               ClearErrorQueue
  1052. //-----------------------------------------------------------------------
  1053.  
  1054. VOID PASCAL ClearErrorQueue()
  1055. {
  1056.     TCHAR szErrMsg[MAX_STRING_SIZE];
  1057.     TCHAR szState[6];
  1058.  
  1059.     /* Eat up the SQL_SUCCESS_WITH_INFO error record */
  1060.     while (RC_SUCCESSFUL(SQLError(NULL, hdbc,NULL, szState, NULL, 
  1061.         szErrMsg, sizeof(szErrMsg), NULL)))
  1062.             ;
  1063. }
  1064.  
  1065.  
  1066. //-----------------------------------------------------------------------
  1067. //      Function:               Is3XDriver
  1068. //-----------------------------------------------------------------------
  1069.  
  1070. BOOL PASCAL Is3XDriver(HDBC hdbc,QTSTRUCT *lpqt)
  1071. {
  1072.     RETCODE        rc=SQL_SUCCESS;
  1073.     LPTSTR        pch=NULL;
  1074.     BOOL            f3XDriver=FALSE;
  1075.  
  1076.     rc = SQLGetInfo(hdbc, SQL_DRIVER_ODBC_VER, lpqt->buf, MAX_STRING_SIZE, NULL);
  1077.     if(RETCHECK(SQL_SUCCESS, rc,szSQLGETINFO))
  1078.     {
  1079.         pch = _tcstok(lpqt->buf,TEXT("."));
  1080.  
  1081.         if (!_tcsnccmp(pch,TEXT("02"), 2))
  1082.         {
  1083.             pch = _tcstok(NULL,TEXT("."));
  1084.         
  1085.             if(!_tcsnccmp(pch,TEXT("00"), 2))
  1086.                 DISPLAYERROR(szSQLGETINFO,TEXT("Driver returned ODBC version 2.00 which is no longer supported.  Please upgrade to 2.01"));
  1087.             
  1088.         }
  1089.         else if (!_tcsnccmp(pch,TEXT("03"), 2))
  1090.             f3XDriver=TRUE;
  1091.     }
  1092.  
  1093.     uDriverODBCVer=_ttoi(lpqt->buf);
  1094.  
  1095.     return(f3XDriver);
  1096.  
  1097. } //Is3XDriver()
  1098.  
  1099.  
  1100. //-----------------------------------------------------------------------
  1101. //      Function:               Connect
  1102. //-----------------------------------------------------------------------
  1103.  
  1104. BOOL  PASCAL Connect(lpSERVERINFO lpSI,QTSTRUCT  *lpqt)
  1105. {
  1106.     RETCODE    rc=SQL_SUCCESS;
  1107.     SDWORD sdwAppVer;
  1108.  
  1109. /* The signal for test to use it's
  1110.     own allocated handles, is if the a server name is passed in.  If it
  1111.     is not, the test should use the hdbc passed in */
  1112.  
  1113.     /* ****************** Allocate Env ************************* */
  1114.     if (AllocHenv())
  1115.         goto ConnectErrorRet;
  1116.  
  1117.     /* ****************** Set Application Version ************************* */
  1118.     rc = SQLSetEnvAttr(henv, SQL_ATTR_ODBC_VERSION, (SQLPOINTER)SQL_OV_ODBC3,
  1119.         SQL_IS_UINTEGER);
  1120.     if(!RETCHECK(SQL_SUCCESS, rc, szSQLSETENVATTR))
  1121.         goto ConnectErrorRet;
  1122.  
  1123.     /* ****************** Allocate Connection ************************* */
  1124.  
  1125.     rc = SQLAllocConnect(henv, &hdbc);
  1126.     if(!RETCHECK(SQL_SUCCESS, rc, szSQLALLOCCONNECT))
  1127.         goto ConnectErrorRet;
  1128.  
  1129.     /* ****************** Set Connection Attributes ************************* */
  1130.     rc = SQLSetConnectOption(hdbc,SQL_ODBC_CURSORS,lpSI->vCursorLib);
  1131.  
  1132.     if(!FindError(SQL_HANDLE_DBC,szHYC00))
  1133.         if (!RETCHECK(SQL_SUCCESS, rc,szSQLSETCONNECTOPTION))
  1134.         goto ConnectErrorRet;
  1135.  
  1136.     /* create a DriverConnect string */
  1137.     wsprintf(lpqt->sz, TEXT("dsn=%s;uid=%s;pwd=%s;"),
  1138.         lpSI->szValidServer0,
  1139.         lpSI->szValidLogin0,
  1140.         lpSI->szValidPassword0);
  1141.  
  1142.     /* since SQL_DRIVER_COMPLETE is used, it is possible that the
  1143.     driver will bring up a dialog asking for more information. */
  1144.     rc = SQLDriverConnect(hdbc, lpSI->hwnd, lpqt->sz,
  1145.         SQL_NTS, lpqt->buf, MAX_STRING_SIZE, NULL, SQL_DRIVER_COMPLETE);
  1146.     
  1147.     if (RC_NOTSUCCESSFUL(rc))
  1148.     {
  1149.         if (!RETCHECK(SQL_SUCCESS, rc,szSQLDRIVERCONNECT))
  1150.             goto ConnectErrorRet;
  1151.     }
  1152.     else
  1153.         ClearErrorQueue();
  1154.  
  1155.  
  1156.     rc = SQLDisconnect(hdbc);
  1157.     RETCHECK(SQL_SUCCESS, rc,szSQLDISCONNECT);
  1158.  
  1159.     rc = SQLConnect(hdbc, lpSI->szValidServer0, SQL_NTS,
  1160.                         lpSI->szValidLogin0, SQL_NTS,
  1161.                         lpSI->szValidPassword0, SQL_NTS);
  1162.  
  1163.     if (RC_SUCCESSFUL(rc))
  1164.         ClearErrorQueue();
  1165.     else if (!RETCHECK(SQL_SUCCESS, rc,szSQLCONNECT))
  1166.         goto ConnectErrorRet;
  1167.  
  1168.     // Set the global 3.0 driver flag
  1169.     g_f3XDriver=Is3XDriver(hdbc,lpqt);
  1170.  
  1171.     // We're now connected, check application version and adjust expected error
  1172.     // states appropriately.
  1173.     rc = SQLGetEnvAttr(henv, SQL_ATTR_ODBC_VERSION, &sdwAppVer, SQL_IS_UINTEGER, NULL);
  1174.     RETCHECK(SQL_SUCCESS, rc,szSQLGETENVATTR);
  1175.  
  1176.     if (RC_SUCCESSFUL(rc) && (SQL_OV_ODBC2 == sdwAppVer))
  1177.     {
  1178.         lstrcpy(szHY009, TEXT("S1009"));
  1179.         lstrcpy(szHYC00, TEXT("S1C00"));
  1180.     }
  1181.  
  1182.     return(FALSE);
  1183.  
  1184. ConnectErrorRet:
  1185.  
  1186.     return(TRUE);
  1187.  
  1188. } //Connect()
  1189.  
  1190.  
  1191. //-----------------------------------------------------------------------
  1192. //      Function:               IgnoreType
  1193. //-----------------------------------------------------------------------
  1194.  
  1195. BOOL  PASCAL IgnoreType(LPTSTR szType,SWORD wSQLType)
  1196. {
  1197.     BOOL fIgnore=FALSE;
  1198.  
  1199. /* If a line below is compiled in, that type will not be used in creating
  1200.  the table.  (useful for when one specific type is causing problems in
  1201.  a particular test, this way the test can be run for all other types)
  1202. */
  1203.  
  1204.     if (!lstrcmp(szType,TEXT("LONG RAW")) ||
  1205.          !lstrcmp(szType,TEXT("LONG VARTCHAR")) ||
  1206.           !lstrcmp(szType,TEXT("LONG VARTCHAR FOR BIT DATA")))
  1207.         {
  1208.          fIgnore=TRUE;
  1209.         }
  1210.  
  1211.     //if (wSQLType != SQL_CHAR)
  1212.     //    fIgnore=TRUE;
  1213.  
  1214.     return(fIgnore);
  1215.  
  1216. } //IgnoreType()
  1217.             
  1218.     
  1219. //-----------------------------------------------------------------------
  1220. //      Function:               CheckConformanceLevel
  1221. //-----------------------------------------------------------------------
  1222.  
  1223. UWORD  PASCAL CheckConformanceLevel()
  1224. {
  1225.     RETCODE     rc=SQL_SUCCESS;
  1226.     UWORD        fIndex=0;
  1227.     SWORD        cb=0;
  1228.  
  1229.     rc = SQLGetInfo(hdbc, SQL_ODBC_SQL_CONFORMANCE, &fIndex,
  1230.         sizeof (fIndex), &cb);
  1231.     RETCHECK(SQL_SUCCESS, rc,szSQLGETINFO);
  1232.  
  1233.     if(fIndex != 0 && fIndex != 1 && fIndex != 2) {
  1234.         /* one of these two values should always be returned */
  1235.         DISPLAYERROR(szSQLGETINFO,TEXT("SQL_ODBC_API_CONFORMANCE - invalid value"));
  1236.     }
  1237.  
  1238.     return(fIndex);
  1239.  
  1240. } //CheckConformanceLevel()
  1241.  
  1242. /*-----------------------------------------------------------------------*/
  1243. /*      Function:               TestConnectionOptions                             */
  1244. /*-----------------------------------------------------------------------*/
  1245.  
  1246. void  PASCAL TestConnectionOptions()
  1247. {
  1248.     RETCODE    rc=SQL_SUCCESS;
  1249.     SDWORD    sdw,
  1250.                 cbValue=0;
  1251.     BOOL        fConnectOption=TRUE;
  1252.     TCHAR        szAPI[MEDBUFF];
  1253.     HDBC        lhdbc=NULL;
  1254.  
  1255.  
  1256.     rc=SQLAllocConnect(henv,&lhdbc);
  1257.     RETCHECK(SQL_SUCCESS, rc,szSQLALLOCCONNECT);
  1258.     
  1259.     SetConnectionAttributes(lhdbc,SQL_ACCESS_MODE,SQL_MODE_READ_WRITE);
  1260.  
  1261.     SetConnectionAttributes(lhdbc,SQL_AUTOCOMMIT,TRUE);
  1262.  
  1263.     if (SetConnectionAttributes(lhdbc,SQL_LOGIN_TIMEOUT,TEST_CONNECT_OPTION))
  1264.         fConnectOption = FALSE;
  1265.  
  1266.     if (Supported(SQL_API_SQLGETCONNECTATTR))
  1267.     {
  1268.         rc = SQLGetConnectAttr(lhdbc, SQL_LOGIN_TIMEOUT, (PTR)&sdw,0,&cbValue);
  1269.         lstrcpy(szAPI,szSQLGETCONNECTATTR);
  1270.     }
  1271.     else
  1272.     {
  1273.         rc = SQLGetConnectOption(lhdbc, SQL_LOGIN_TIMEOUT, &sdw);
  1274.         lstrcpy(szAPI,szSQLSETCONNECTOPTION);
  1275.     }
  1276.  
  1277.  
  1278.     if(rc != SQL_SUCCESS)
  1279.     {
  1280.         if(!FindError(SQL_HANDLE_DBC,szHYC00))
  1281.             RETCHECK(SQL_SUCCESS, rc,szAPI);
  1282.     }
  1283.     else
  1284.     {
  1285.         if(sdw != TEST_CONNECT_OPTION && fConnectOption)
  1286.             DISPLAYERROR(szAPI,TEXT("SQL_LOGIN_TIMEOUT returned incorrect value"));
  1287.     }
  1288.  
  1289.     rc=SQLFreeConnect(lhdbc);
  1290.     RETCHECK(SQL_SUCCESS, rc,szSQLFREECONNECT);
  1291.  
  1292. } //TestConnectionOptions()
  1293.  
  1294.  
  1295.  
  1296. /*-----------------------------------------------------------------------*/
  1297. /*      Function:            CanAllocHdesc                                        */
  1298. /*-----------------------------------------------------------------------*/
  1299.  
  1300. BOOL PASCAL CanAllocHdesc()
  1301. {
  1302.     BOOL fSupported=FALSE;
  1303.  
  1304.     /* Allocate an hdesc: */
  1305.     if(Supported(SQL_API_SQLALLOCHANDLE))
  1306.         fSupported = RC_SUCCESSFUL(SQLAllocHandle(SQL_HANDLE_DESC, hdbc, &hdesc));
  1307.  
  1308.     return(fSupported);
  1309.  
  1310. }
  1311.  
  1312.  
  1313. /*-----------------------------------------------------------------------*/
  1314. /*      Function:            SetErrorCondition                                    */
  1315. /*-----------------------------------------------------------------------*/
  1316.  
  1317. VOID PASCAL SetErrorCondition(SWORD fHandleType)
  1318. {
  1319.     RETCODE rc=SQL_SUCCESS;
  1320.  
  1321.     /* The following are used to produce "(S1)HY009" SQL State */
  1322.     switch (fHandleType)
  1323.     {
  1324.         case SQL_HANDLE_ENV:
  1325.             rc = SQLAllocConnect(henv, NULL);
  1326.             break;
  1327.         case SQL_HANDLE_DBC:
  1328.             rc = SQLAllocStmt(hdbc, NULL);
  1329.             break;
  1330.         case SQL_HANDLE_STMT:
  1331.             rc = SQLExecDirect(hstmt, NULL, SQL_NTS);        // Produces a DM error
  1332.             break;
  1333.         case SQL_HANDLE_DESC:
  1334.             rc = SQLGetDescField(hdesc, 0, SQL_DESC_AUTO_UNIQUE_VALUE, NULL, 0, NULL);
  1335.             break;
  1336.     }
  1337.  
  1338. } //SetErrorCondition()
  1339.  
  1340.  
  1341.  
  1342. VOID PASCAL CheckData(SWORD fHandleType,UWORD uwDescField, PTR rgbValue,LPTSTR szDataSourceName)
  1343. {
  1344.     TCHAR            szBuff[MEDBUFF]=TEXT("");
  1345.     LPTSTR        pszExpState=szHY009;
  1346.  
  1347.     if (fHandleType == SQL_HANDLE_DESC)
  1348.         pszExpState=szHY091;
  1349.  
  1350.     switch(uwDescField)
  1351.     {
  1352.         case SQL_DIAG_RETURNCODE:
  1353.             {
  1354.                 RETCODE rcRec=*(RETCODE *)rgbValue;
  1355.                 
  1356.                 if (rcRec!= SQL_ERROR)
  1357.                 {
  1358.                     wsprintf(szBuff,TEXT("\t\t\tSQL_DIAG_RETURN_CODE\tReceived: %d\tExpected: %d"),rcRec,-1);
  1359.                 }
  1360.             }
  1361.             break;
  1362.         
  1363.         case SQL_DIAG_SQLSTATE:
  1364.             {
  1365.                 if (lstrcmp((LPTSTR)rgbValue,pszExpState))
  1366.                 {
  1367.                     wsprintf(szBuff,TEXT("\t\t\tSQL_DIAG_SQLSTATE\tReceived: %s\tExpected: %s"),(LPTSTR)rgbValue,pszExpState);
  1368.                 }
  1369.             }
  1370.             break;
  1371.         case SQL_DIAG_CLASS_ORIGIN:
  1372.             {
  1373.                 if (lstrcmp((LPTSTR)rgbValue,szISO))
  1374.                     wsprintf(szBuff,TEXT("\t\t\tSQL_DIAG_CLASS_ORIGIN\tReceived: %s\tExpected: %s"),(LPTSTR)rgbValue,szISO);
  1375.             }
  1376.             break;
  1377.         case SQL_DIAG_SUBCLASS_ORIGIN:
  1378.             {
  1379.                 if (lstrcmp((LPTSTR)rgbValue,szISO))
  1380.                     wsprintf(szBuff,TEXT("\t\t\tSQL_DIAG_CLASS_ORIGIN\tReceived: %s\tExpected: %s"),(LPTSTR)rgbValue,szISO);
  1381.             }
  1382.             break;
  1383.         case SQL_DIAG_NUMBER:
  1384.             {
  1385.                 SDWORD cRecs=*(SDWORD *)rgbValue;
  1386.                 if (cRecs != 1)
  1387.                     wsprintf(szBuff,TEXT("\t\t\tSQL_DIAG_NUMBER\tReceived: %d\tExpected: %d"),cRecs,1);
  1388.             }
  1389.             break;
  1390.         case SQL_DIAG_SERVER_NAME:
  1391.             {
  1392.                 switch(fHandleType)
  1393.                 {
  1394.                 case SQL_HANDLE_DBC:
  1395.                 case SQL_HANDLE_STMT:
  1396.                     if (lstrcmp((LPTSTR)rgbValue,szDataSourceName))
  1397.                         wsprintf(szBuff,TEXT("\t\t\tSQL_DIAG_SERVER_NAME\tReceived: %s\tExpected: %s"),(LPTSTR)rgbValue,szDataSourceName);
  1398.                     break;
  1399.                 }
  1400.             }
  1401.             break;
  1402.         default:
  1403.             break;
  1404.  
  1405.     }
  1406.  
  1407.     if (*szBuff)
  1408.         DISPLAYERROR(szSQLGETDIAGREC,szBuff);
  1409.  
  1410. } /* CheckData() */
  1411.  
  1412.  
  1413. /*------------------------------------------------------------------------------
  1414. /    Function:    TestDiagRec                                              
  1415. /    Purpose:    For each type of handle, generate an error. If SQLGetDiagField      
  1416. /                is not supported, verify the appropriate DM error is returned.      
  1417. /                Otherwise, verify SQLGetDiagField returns the expected error        
  1418. /                information. If SQLGetDiagRec is not supported, verify the          
  1419. /                appropriate DM error is returned. Otherwise, verify                 
  1420. /                SQLGetDiagField returns the expected error information. If          
  1421. /                SQLGetDiagRec is supported, compare its output with that of         
  1422. /                SQLGetDiagField.                                                    
  1423. /*----------------------------------------------------------------------------*/
  1424.  
  1425. void PASCAL TestDiagRec()
  1426. {
  1427.     SQLRETURN    rcFunction, 
  1428.                     rc=SQL_SUCCESS;
  1429.     SWORD            cbErrorMsg;
  1430.     SDWORD        fNativeError;
  1431.     UWORD            iHandle=0,
  1432.                     iField=0,
  1433.                     cHandles;
  1434.  
  1435.     SDWORD        *pfNativeError = NULL;
  1436.     LPTSTR        pchMessageText = NULL;
  1437.  
  1438.     TCHAR            szDataSourceName[MAX_STRING_SIZE] = TEXT("");
  1439.     TCHAR            szState[SQL_SQLSTATE_SIZE+1];
  1440.     TCHAR            szErrorMsg[SQL_MAX_MESSAGE_LENGTH];
  1441.     TCHAR            szAPI[MEDBUFF]=TEXT("");
  1442.     TCHAR            szBuff[MEDBUFF]=TEXT("");
  1443.  
  1444.     LPTSTR        pszExpState=szHY009;
  1445.     RETCODE        rcExp=SQL_SUCCESS;
  1446.  
  1447.     HANDLES rgHandles[] = 
  1448.     {
  1449.         SQL_HANDLE_ENV, henv,
  1450.         SQL_HANDLE_DBC, hdbc,
  1451.         SQL_HANDLE_STMT, hstmt,
  1452.         SQL_HANDLE_DESC, hdesc,
  1453.     };
  1454.  
  1455.     cHandles=sizeof(rgHandles)/sizeof(HANDLES);
  1456.  
  1457.     /* Call SQLGetInfo to get values to compare: */
  1458.     rcFunction = SQLGetInfo(hdbc, SQL_DATA_SOURCE_NAME, szDataSourceName, MAX_STRING_SIZE, NULL);
  1459.     RETCHECK(SQL_SUCCESS, rcFunction, szSQLGETINFO);
  1460.  
  1461.     /* Allocate an hdesc: */
  1462.     if(Supported(SQL_API_SQLALLOCHANDLE) && g_f3XDriver)
  1463.     { 
  1464.         rcFunction = SQLAllocHandle(SQL_HANDLE_DESC, hdbc, &hdesc);
  1465.         RETCHECK(SQL_SUCCESS, rcFunction, szSQLALLOCHANDLE);
  1466.  
  1467.         // Update the array entry for the hdesc
  1468.         rgHandles[3].hHandle=hdesc;
  1469.  
  1470.     }
  1471.     else
  1472.         cHandles--;
  1473.  
  1474.     for (iHandle=0; iHandle < cHandles; iHandle++)
  1475.     {
  1476.  
  1477.         SetErrorCondition(rgHandles[iHandle].fHandleType);
  1478.  
  1479.         rc = SQLGetDiagRec(rgHandles[iHandle].fHandleType, rgHandles[iHandle].hHandle, 
  1480.                     1,szState,&fNativeError, szErrorMsg,
  1481.                     SQL_MAX_MESSAGE_LENGTH, &cbErrorMsg);
  1482.  
  1483.         if (rgHandles[iHandle].fHandleType == SQL_HANDLE_DESC)
  1484.             pszExpState=szHY091;
  1485.  
  1486.         rcExp=SQL_SUCCESS;
  1487.  
  1488.         if(fDiagRecSupported)
  1489.         {
  1490.  
  1491.             DIAGRETCHECK(rcExp, rc, szSQLGETDIAGREC);
  1492.             if (RC_SUCCESSFUL(rc) && lstrcmp(szState,pszExpState))
  1493.             {
  1494.                 wsprintf(szBuff,TEXT("\t\t\tReceived: %s\tExpected: %s"),szState,    pszExpState);
  1495.                 DISPLAYERROR(szSQLGETDIAGREC,szBuff);
  1496.             }
  1497.         }
  1498.         else
  1499.         {
  1500.             if(!FindError(rgHandles[iHandle].fHandleType, szIM001))
  1501.                 DISPLAYERROR(szSQLGETDIAGREC, szNotSupported);
  1502.         }
  1503.  
  1504.     }
  1505.  
  1506.  
  1507.     /* Free the hdesc: */
  1508.     if (hdesc)
  1509.     {
  1510.         rcFunction = SQLFreeHandle(SQL_HANDLE_DESC, hdesc);
  1511.         RETCHECK(rcExp, rcFunction, szSQLFREEHANDLE);
  1512.         hdesc = SQL_NULL_HDESC;
  1513.     }
  1514.  
  1515. //ExitTestDiagRec
  1516.  
  1517.     FreeStmt(SQL_CLOSE);
  1518.  
  1519. } /* TestDiagRec() */
  1520.  
  1521.  
  1522. /*------------------------------------------------------------------------------
  1523. /    Function:    TestDiagField                                                       
  1524. /    Purpose:    For each type of handle, generate an error. If SQLGetDiagField      
  1525. /                is not supported, verify the appropriate DM error is returned.      
  1526. /                Otherwise, verify SQLGetDiagField returns the expected error        
  1527. /                information. If SQLGetDiagRec is not supported, verify the          
  1528. /                appropriate DM error is returned. Otherwise, verify                 
  1529. /                SQLGetDiagField returns the expected error information. If          
  1530. /                SQLGetDiagRec is supported, compare its output with that of         
  1531. /                SQLGetDiagField.                                                    
  1532. /*----------------------------------------------------------------------------*/
  1533.  
  1534. void PASCAL TestDiagField()
  1535. {
  1536.     SQLRETURN    rcFunction, 
  1537.                     rc=SQL_SUCCESS;
  1538.     SWORD            cbValue=0;
  1539.     UWORD            iHandle=0,
  1540.                     iField=0,
  1541.                     cHandles;
  1542.  
  1543.     TCHAR            szDataSourceName[MAX_STRING_SIZE] = TEXT("");
  1544.     TCHAR            rgbValue[SQL_MAX_MESSAGE_LENGTH];
  1545.     TCHAR            szAPI[MEDBUFF]=TEXT("");
  1546.     TCHAR            szBuff[MEDBUFF]=TEXT("");
  1547.     RETCODE        rcExp=SQL_SUCCESS;
  1548.  
  1549.     HANDLES rgHandles[] = 
  1550.     {
  1551.         SQL_HANDLE_ENV, henv,
  1552.         SQL_HANDLE_DBC, hdbc,
  1553.         SQL_HANDLE_STMT, hstmt,
  1554.         SQL_HANDLE_DESC, hdesc,
  1555.     };
  1556.  
  1557.     cHandles=sizeof(rgHandles)/sizeof(HANDLES);
  1558.  
  1559.     /* Call SQLGetInfo to get values to compare: */
  1560.     rcFunction = SQLGetInfo(hdbc, SQL_DATA_SOURCE_NAME, szDataSourceName, MAX_STRING_SIZE, NULL);
  1561.     RETCHECK(SQL_SUCCESS, rcFunction, szSQLGETINFO);
  1562.  
  1563.     hdesc = SQL_NULL_HDESC;
  1564.  
  1565.     /* Allocate an hdesc: */
  1566.     if(Supported(SQL_API_SQLALLOCHANDLE) && g_f3XDriver)
  1567.     { 
  1568.         rcFunction = SQLAllocHandle(SQL_HANDLE_DESC, hdbc, &hdesc);
  1569.         RETCHECK(SQL_SUCCESS, rcFunction, szSQLALLOCHANDLE);
  1570.  
  1571.         // Update the array entry for the hdesc
  1572.         rgHandles[3].hHandle=hdesc;
  1573.  
  1574.     }
  1575.     else
  1576.         cHandles--;
  1577.  
  1578.     for (iHandle=0; iHandle < cHandles; iHandle++)
  1579.     {
  1580.  
  1581.         SetErrorCondition(rgHandles[iHandle].fHandleType);
  1582.  
  1583.         if(fDiagFieldSupported)
  1584.         {
  1585.             for (iField=0;iField < sizeof(rgDiagInfo)/sizeof(struct tagDIAGINFO);iField++)
  1586.             {
  1587.                 rc = SQLGetDiagField(rgHandles[iHandle].fHandleType, rgHandles[iHandle].hHandle, 
  1588.                             rgDiagInfo[iField].irecRecNumber, rgDiagInfo[iField].uwDescField,
  1589.                             rgbValue, SQL_MAX_MESSAGE_LENGTH, &cbValue);
  1590.     
  1591.                 DIAGRETCHECK(rcExp, rc, szSQLGETDIAGFIELD);
  1592.  
  1593.                 if (RC_SUCCESSFUL(rc))
  1594.                     CheckData(rgHandles[iHandle].fHandleType,rgDiagInfo[iField].uwDescField, 
  1595.                         rgbValue,szDataSourceName);
  1596.             }
  1597.             
  1598.         }
  1599.         else
  1600.         {
  1601.             rc = SQLGetDiagField(SQL_HANDLE_ENV, henv, 0, SQL_DIAG_RETURNCODE, rgbValue,SQL_MAX_MESSAGE_LENGTH, &cbValue);
  1602.  
  1603.             if(!FindError(rgHandles[iHandle].fHandleType, szIM001))
  1604.                 DISPLAYERROR(szAPI, szNotSupported);
  1605.                 
  1606.         }
  1607.  
  1608.     }
  1609.  
  1610.  
  1611.     /* Free the hdesc: */
  1612.     if (hdesc)
  1613.     {
  1614.         rcFunction = SQLFreeHandle(SQL_HANDLE_DESC, hdesc);
  1615.         RETCHECK(rcExp, rcFunction, szSQLFREEHANDLE);
  1616.         hdesc = SQL_NULL_HDESC;
  1617.     }
  1618.  
  1619. //ExitTestDiagField
  1620.  
  1621.     FreeStmt(SQL_CLOSE);
  1622.  
  1623. } /* TestDiagField() */
  1624.  
  1625. //------------------------------------------------------------------------------
  1626. //    Function:    CompareAnsiToUnicode
  1627. //        Compares an ANSI string to a Unicode string
  1628. //------------------------------------------------------------------------------
  1629. BOOL CompareAnsiToUnicode(SQLCHAR * aszBuf, SQLINTEGER cbA, SQLWCHAR * wszBuf,
  1630.     SQLINTEGER cbW, SQLTCHAR * szAPI)
  1631. {
  1632.     SQLCHAR aszConvBuf[MAX_STRING_SIZE];
  1633.     SQLINTEGER cbT;
  1634.     BOOL bCompare=TRUE;
  1635.  
  1636.     // Check ANSI count of bytes returned
  1637.     if ((cbA != SQL_NULL_DATA) && (SQLINTEGER)strlen(aszBuf) != cbA)
  1638.     {
  1639.         wsprintf(buf, TEXT("ANSI count of bytes returned incorrect.")\
  1640.             TEXT(" Expected: %d, received: %d"),
  1641.             strlen(aszBuf), cbA);
  1642.         DISPLAYERROR(szAPI, buf);
  1643.         bCompare=FALSE;
  1644.     }
  1645.  
  1646.     // Compare ANSI count of bytes with Unicode count
  1647.     cbT = (cbA > 0) ? (SQLINTEGER)(cbA * sizeof(SQLWCHAR)) : cbA;
  1648.     if (cbW != cbT)
  1649.     {
  1650.         wsprintf(buf, TEXT("Unicode count of bytes returned incorrect.")\
  1651.             TEXT(" Expected: %d, received: %d"), cbT, cbW);
  1652.         DISPLAYERROR(szAPI, buf);
  1653.         bCompare=FALSE;
  1654.     }
  1655.  
  1656.     // Compare strings if not NULL DATA
  1657.     if (cbA != SQL_NULL_DATA)
  1658.     {
  1659.         // Compare ANSI and Unicode strings returned
  1660.         (void)(WideCharToMultiByte(CP_ACP, 0, wszBuf, wcslen(wszBuf), aszConvBuf,
  1661.             sizeof(aszConvBuf), NULL, NULL));
  1662.         aszConvBuf[wcslen(wszBuf)]=TEXT('\0');
  1663.  
  1664.         if (strcmp(aszBuf, aszConvBuf))
  1665.         {
  1666.             wsprintf(buf, TEXT("Unicode string did not match ANSI string.\r\n")\
  1667.                 TEXT("\t\t\tExpected: '%hs', Received: '%hs'"), aszBuf, aszConvBuf);
  1668.             DISPLAYERROR(szAPI, buf);
  1669.             bCompare=FALSE;
  1670.         }
  1671.     }
  1672.  
  1673.     return bCompare;
  1674. }
  1675.  
  1676. //------------------------------------------------------------------------------
  1677. //    Function:    CompareAnsiUnicodeResults
  1678. //        Compares an ANSI result set to a Unicode result set
  1679. //------------------------------------------------------------------------------
  1680. void CompareAnsiUnicodeResults(SQLHSTMT hstmtA, SQLHSTMT hstmtW, SQLTCHAR * szAPI)
  1681. {
  1682.     SQLCHAR aszBuf[MAX_STRING_SIZE];
  1683.     SQLWCHAR wszBuf[MAX_STRING_SIZE];
  1684.     SQLINTEGER cbANSI, cbUnicode;
  1685.     SQLUSMALLINT    uwCol;
  1686.     SQLSMALLINT        swColCountA, swColCountW;
  1687.     SQLRETURN rc, rcA, rcW;
  1688.  
  1689.     // Check width of result sets
  1690.     rc=SQLNumResultCols(hstmtA, &swColCountA);
  1691.     ERRSHANDLE(SQL_HANDLE_STMT, hstmtA, SQL_SUCCESS, rc, szSQLNUMRESULTCOLS);
  1692.     rc=SQLNumResultCols(hstmtW, &swColCountW);
  1693.     ERRSHANDLE(SQL_HANDLE_STMT, hstmtW, SQL_SUCCESS, rc, szSQLNUMRESULTCOLS);
  1694.     if (swColCountA != swColCountW)
  1695.         DISPLAYERROR(szAPI,TEXT("ANSI and Unicode result sets different widths."));
  1696.  
  1697.     uwCol=1;
  1698.     do {
  1699.         rc=SQLBindCol(hstmtA, uwCol, SQL_C_CHAR, aszBuf, sizeof(aszBuf), &cbANSI);
  1700.         ERRSHANDLE(SQL_HANDLE_STMT, hstmtA, SQL_SUCCESS, rc, szSQLBINDCOL);
  1701.         rc=SQLBindCol(hstmtW, uwCol, SQL_C_WCHAR, wszBuf, sizeof(wszBuf), &cbUnicode);
  1702.         ERRSHANDLE(SQL_HANDLE_STMT, hstmtW, SQL_SUCCESS, rc, szSQLBINDCOL);
  1703.  
  1704.         // Copy something into the buffers so we can tell if they were modified
  1705.         strcpy(aszBuf, "Untouched");
  1706.         wcscpy(wszBuf, L"Untouched");
  1707.  
  1708.         // Fetch into the buffers
  1709.         rcA=SQLFetch(hstmtA);
  1710.         rcW=SQLFetch(hstmtW);
  1711.  
  1712.  
  1713.         if (RC_SUCCESSFUL(rcA) && RC_SUCCESSFUL(rcW))
  1714.         {
  1715.             if (!CompareAnsiToUnicode(aszBuf, cbANSI, wszBuf, cbUnicode, szSQLFETCH))
  1716.             {
  1717.                 rcW=SQL_NO_DATA;    // Abort the loop w/o generating failure
  1718.                 rcA=SQL_NO_DATA;
  1719.             }
  1720.         }
  1721.  
  1722.         // Unbind the column bound above on each statement
  1723.         rc=SQLFreeStmt(hstmtA, SQL_UNBIND);
  1724.         ERRSHANDLE(SQL_HANDLE_STMT, hstmtA, SQL_SUCCESS, rc, szSQLFREESTMT);
  1725.         rc=SQLFreeStmt(hstmtW, SQL_UNBIND);
  1726.         ERRSHANDLE(SQL_HANDLE_STMT, hstmtW, SQL_SUCCESS, rc, szSQLFREESTMT);
  1727.  
  1728.         // Don't exceed the total number of columns in result set
  1729.         uwCol++;
  1730.         if (uwCol > (SQLUSMALLINT)swColCountA)
  1731.             uwCol=1;
  1732.     }
  1733.     while (RC_SUCCESSFUL(rcA) && RC_SUCCESSFUL(rcW));
  1734.  
  1735.     // Make sure the result sets were the same size
  1736.     if (rcW != SQL_NO_DATA)
  1737.         ERRSHANDLE(SQL_HANDLE_STMT, hstmtW, SQL_NO_DATA, rc, szSQLFETCH);
  1738.  
  1739.     // Make sure the result sets were the same size
  1740.     if (rcA != rcW)
  1741.         DISPLAYERROR(szAPI,TEXT("ANSI and Unicode result sets not the same length."));
  1742.  
  1743.     rc=SQLFreeStmt(hstmtA, SQL_CLOSE);
  1744.     ERRSHANDLE(SQL_HANDLE_STMT, hstmtA, SQL_SUCCESS, rc, szSQLFREESTMT);
  1745.     rc=SQLFreeStmt(hstmtW, SQL_CLOSE);
  1746.     ERRSHANDLE(SQL_HANDLE_STMT, hstmtW, SQL_SUCCESS, rc, szSQLFREESTMT);
  1747.  
  1748. }
  1749.  
  1750.  
  1751. /*------------------------------------------------------------------------------
  1752. /    Function:    TestMixedAnsiUnicode
  1753. /    Purpose:    Call several of the Unicode functions mixed with ANSI functions
  1754. /                to verify functions succeed in the mixed case.
  1755. /*----------------------------------------------------------------------------*/
  1756. void PASCAL TestMixedAnsiUnicode(QTSTRUCT * lpqt)
  1757. {
  1758.     HDBC    hdbcANSI, hdbcUnicode;
  1759.     HSTMT hstmtANSIA, hstmtANSIW, hstmtUA, hstmtUW, hstmtW;
  1760.     SQLINTEGER cbANSI, cbUnicode;
  1761.     SQLWCHAR wszServer[MAX_STRING_SIZE], wszLogin[MAX_STRING_SIZE],
  1762.         wszPassword[MAX_STRING_SIZE], wszQuery[MAX_STRING_SIZE],
  1763.         wszBuf[MAX_STRING_SIZE], wszTable[MAX_STRING_SIZE];
  1764.     SQLCHAR    aszServer[MAX_STRING_SIZE], aszLogin[MAX_STRING_SIZE],
  1765.         aszPassword[MAX_STRING_SIZE], aszQuery[MAX_STRING_SIZE],
  1766.         aszBuf[MAX_STRING_SIZE], aszTable[MAX_STRING_SIZE];
  1767.     SQLUSMALLINT fStmts;
  1768.     SQLRETURN rc, rcA=SQL_SUCCESS, rcW=SQL_SUCCESS;
  1769.     
  1770.     // We've already set the environment attribute to 3.0 by this point
  1771.     
  1772. #ifdef UNICODE
  1773.     // Copy the unicode strings
  1774.     lstrcpy(wszServer, lpSI->szValidServer0);
  1775.     lstrcpy(wszLogin, lpSI->szValidLogin0);
  1776.     lstrcpy(wszPassword, lpSI->szValidPassword0);
  1777.     lstrcpy(wszTable, lpqt->szTableName);
  1778.     wsprintf(wszQuery,szSELECTSTAR,lpqt->szTableName);
  1779.  
  1780.     // Convert and copy to ANSI strings
  1781.     /*
  1782.     int WideCharToMultiByte(
  1783.          UINT  CodePage,    // code page 
  1784.          DWORD  dwFlags,    // performance and mapping flags 
  1785.          LPCWSTR  lpWideCharStr,    // address of wide-character string 
  1786.          int  cchWideChar,    // number of characters in string 
  1787.          LPSTR  lpMultiByteStr,    // address of buffer for new string 
  1788.          int  cchMultiByte,    // size of buffer 
  1789.          LPCSTR  lpDefaultChar,    // address of default for unmappable characters  
  1790.          LPBOOL  lpUsedDefaultChar     // address of flag set when default char. used 
  1791.         );    
  1792.     */
  1793.     // Server
  1794.     (void)(WideCharToMultiByte(CP_ACP,
  1795.                           0,
  1796.                           lpSI->szValidServer0,
  1797.                           lstrlen(lpSI->szValidServer0),
  1798.                           aszServer,
  1799.                           sizeof(aszServer),
  1800.                           NULL,
  1801.                           NULL));
  1802.     aszServer[lstrlen(lpSI->szValidServer0)]=TEXT('\0');
  1803.  
  1804.     // UID
  1805.     (void)(WideCharToMultiByte(CP_ACP,
  1806.                           0,
  1807.                           lpSI->szValidLogin0,
  1808.                           lstrlen(lpSI->szValidLogin0),
  1809.                           aszLogin,
  1810.                           sizeof(aszLogin),
  1811.                           NULL,
  1812.                           NULL));
  1813.     aszLogin[lstrlen(lpSI->szValidLogin0)]=TEXT('\0');
  1814.  
  1815.     // PWD
  1816.     (void)(WideCharToMultiByte(CP_ACP,
  1817.                           0,
  1818.                           lpSI->szValidPassword0,
  1819.                           lstrlen(lpSI->szValidPassword0),
  1820.                           aszPassword,
  1821.                           sizeof(aszPassword),
  1822.                           NULL,
  1823.                           NULL));
  1824.     aszPassword[lstrlen(lpSI->szValidPassword0)]=TEXT('\0');
  1825.  
  1826.     // Select stmt
  1827.     (void)(WideCharToMultiByte(CP_ACP,
  1828.                           0,
  1829.                           wszQuery,
  1830.                           lstrlen(wszQuery),
  1831.                           aszQuery,
  1832.                           sizeof(aszQuery),
  1833.                           NULL,
  1834.                           NULL));
  1835.     aszQuery[lstrlen(wszQuery)]=TEXT('\0');
  1836.  
  1837.     // Table name
  1838.     (void)(WideCharToMultiByte(CP_ACP,
  1839.                           0,
  1840.                           wszTable,
  1841.                           lstrlen(wszTable),
  1842.                           aszQuery,
  1843.                           sizeof(aszTable),
  1844.                           NULL,
  1845.                           NULL));
  1846.     aszTable[lstrlen(wszTable)]=TEXT('\0');
  1847.  
  1848. #else
  1849.     // Copy the ANSI strings
  1850.     lstrcpy(aszServer, lpSI->szValidServer0);
  1851.     lstrcpy(aszLogin, lpSI->szValidLogin0);
  1852.     lstrcpy(aszPassword, lpSI->szValidPassword0);
  1853.     lstrcpy(aszTable, lpqt->szTableName);
  1854.     wsprintf(aszQuery,szSELECTSTAR,lpqt->szTableName);
  1855.  
  1856.     // Convert and copy to Unicode strings
  1857.     /*
  1858.     int MultiByteToWideChar(
  1859.          UINT  CodePage,    // code page 
  1860.          DWORD  dwFlags,    // character-type options 
  1861.          LPCSTR  lpMultiByteStr,    // address of string to map 
  1862.          int  cchMultiByte,    // number of characters in string 
  1863.          LPWSTR  lpWideCharStr,    // address of wide-character buffer 
  1864.          int  cchWideChar     // size of buffer 
  1865.         );    
  1866.     */
  1867.  
  1868.     // Server
  1869.     (void) MultiByteToWideChar(CP_ACP,
  1870.                                     0,
  1871.                                     lpSI->szValidServer0,
  1872.                                     lstrlen(lpSI->szValidServer0),
  1873.                                     wszServer,
  1874.                                     sizeof(wszServer)/sizeof(WCHAR)
  1875.                                     );
  1876.     wszServer[lstrlen(lpSI->szValidServer0)]=TEXT('\0');
  1877.  
  1878.     // UID
  1879.     (void) MultiByteToWideChar(CP_ACP,
  1880.                                     0,
  1881.                                     lpSI->szValidLogin0,
  1882.                                     lstrlen(lpSI->szValidLogin0),
  1883.                                     wszLogin,
  1884.                                     sizeof(wszLogin)/sizeof(WCHAR)
  1885.                                     );
  1886.     wszLogin[lstrlen(lpSI->szValidLogin0)]=TEXT('\0');
  1887.  
  1888.     // PWD
  1889.     (void) MultiByteToWideChar(CP_ACP,
  1890.                                     0,
  1891.                                     lpSI->szValidPassword0,
  1892.                                     lstrlen(lpSI->szValidPassword0),
  1893.                                     wszPassword,
  1894.                                     sizeof(wszPassword)/sizeof(WCHAR)
  1895.                                     );
  1896.     wszPassword[lstrlen(lpSI->szValidPassword0)]=TEXT('\0');
  1897.  
  1898.     // Select stmt
  1899.     (void) MultiByteToWideChar(CP_ACP,
  1900.                                     0,
  1901.                                     aszQuery,
  1902.                                     lstrlen(aszQuery),
  1903.                                     wszQuery,
  1904.                                     sizeof(wszQuery)/sizeof(WCHAR)
  1905.                                     );
  1906.     wszQuery[lstrlen(aszQuery)]=TEXT('\0');
  1907.  
  1908.     // Table name
  1909.     (void) MultiByteToWideChar(CP_ACP,
  1910.                                     0,
  1911.                                     aszTable,
  1912.                                     lstrlen(aszTable),
  1913.                                     wszTable,
  1914.                                     sizeof(wszTable)/sizeof(WCHAR)
  1915.                                     );
  1916.     wszTable[lstrlen(aszTable)]=TEXT('\0');
  1917.  
  1918. #endif
  1919.  
  1920.     // Allocate connection for ANSI
  1921.     rc = SQLAllocConnect(henv, &hdbcANSI);
  1922.     RETCHECK(SQL_SUCCESS, rc, szSQLALLOCCONNECT);
  1923.  
  1924.     // Allocate connection for Unicode
  1925.     rc = SQLAllocConnect(henv, &hdbcUnicode);
  1926.     RETCHECK(SQL_SUCCESS, rc, szSQLALLOCCONNECT);
  1927.  
  1928.     // If Unicode is defined, then strings need to be converted to ANSI
  1929.     // before calling SQLConnectA
  1930.     rc = SQLConnectA(hdbcANSI, (LPSTR)aszServer, SQL_NTS,
  1931.                         (LPSTR)aszLogin, SQL_NTS,
  1932.                         (LPSTR)aszPassword, SQL_NTS);
  1933.     if (!RC_SUCCESSFUL(rc))
  1934.         ERRSHANDLE(SQL_HANDLE_DBC, hdbcANSI, SQL_SUCCESS, rc,szSQLCONNECT);
  1935.  
  1936.     rc = SQLConnectW(hdbcUnicode, (LPWSTR)wszServer, SQL_NTS,
  1937.                         (LPWSTR)wszLogin, SQL_NTS,
  1938.                         (LPWSTR)wszPassword, SQL_NTS);
  1939.     if (!RC_SUCCESSFUL(rc))
  1940.         ERRSHANDLE(SQL_HANDLE_DBC, hdbcUnicode, SQL_SUCCESS, rc,szSQLCONNECTW);
  1941.  
  1942.     // Test mixed SQLNativeSQL calls    on the ANSI connection
  1943.     rc=SQLNativeSqlA(hdbcANSI, aszQuery, strlen(aszQuery), aszBuf, sizeof(aszBuf), &cbANSI);
  1944.     ERRSHANDLE(SQL_HANDLE_DBC, hdbcANSI, SQL_SUCCESS, rc,szSQLNATIVESQL);
  1945.     rc=SQLNativeSqlW(hdbcANSI,    wszQuery, wcslen(wszQuery)*sizeof(WCHAR), wszBuf, sizeof(wszBuf),
  1946.         &cbUnicode);
  1947.     ERRSHANDLE(SQL_HANDLE_DBC, hdbcANSI, SQL_SUCCESS, rc,szSQLNATIVESQL);
  1948.  
  1949.     CompareAnsiToUnicode(aszBuf, cbANSI, wszBuf, cbUnicode, szSQLNATIVESQLW);
  1950.  
  1951.     // Allocate stmt handles for ANSI connection
  1952.     rc = SQLAllocStmt(hdbcANSI, &hstmtANSIA);    // Handle for ANSI calls
  1953.     ERRSHANDLE(SQL_HANDLE_DBC, hdbcANSI, SQL_SUCCESS, rc,szSQLALLOCSTMT);
  1954.     rc = SQLAllocStmt(hdbcANSI, &hstmtANSIW);    // Handle for Unicode calls
  1955.     ERRSHANDLE(SQL_HANDLE_DBC, hdbcANSI, SQL_SUCCESS, rc,szSQLALLOCSTMT);
  1956.  
  1957.     // Allocate stmt handles for Unicode connection
  1958.     rc = SQLAllocStmt(hdbcUnicode, &hstmtUA); // Handle for ANSI calls
  1959.     ERRSHANDLE(SQL_HANDLE_DBC, hdbcUnicode, SQL_SUCCESS, rc,szSQLALLOCSTMT);
  1960.     rc = SQLAllocStmt(hdbcUnicode, &hstmtUW); // Handle for Unicode calls
  1961.     ERRSHANDLE(SQL_HANDLE_DBC, hdbcUnicode, SQL_SUCCESS, rc,szSQLALLOCSTMT);
  1962.  
  1963.     // Call SQLTablesA&W on two different hdbcs
  1964.     strcpy(aszBuf,"%");
  1965.     wcscpy(wszBuf,L"%");
  1966.     rc = SQLTablesA(hstmtANSIA, NULL, 0, NULL, 0, aszBuf, SQL_NTS, NULL, 0);
  1967.     ERRSHANDLE(SQL_HANDLE_STMT, hstmtANSIA, SQL_SUCCESS, rc, szSQLTABLESA);
  1968.     rc = SQLTablesW(hstmtUW, NULL, 0, NULL, 0, wszBuf, SQL_NTS, NULL, 0);
  1969.     ERRSHANDLE(SQL_HANDLE_STMT, hstmtUW, SQL_SUCCESS, rc, szSQLTABLESW);
  1970.  
  1971.     // Compare the two result sets
  1972.     CompareAnsiUnicodeResults(hstmtANSIA, hstmtUW, szSQLTABLESW);
  1973.  
  1974.     // See if the driver supports multiple active stmts
  1975.     rc = SQLGetInfo(hdbcANSI, SQL_ACTIVE_STATEMENTS, &fStmts, 0, NULL);
  1976.     ERRSHANDLE(SQL_HANDLE_DBC, hdbcANSI, SQL_SUCCESS, rc, szSQLGETINFO);
  1977.  
  1978.     // Create a search string for ANSI
  1979.     aszBuf[0]=aszTable[0];
  1980.     aszBuf[1]=TEXT('\0');
  1981.     strcat(aszBuf,"%");
  1982.  
  1983.     // Create a search string for Unicode
  1984.     wszBuf[0]=wszTable[0];
  1985.     wszBuf[1]=TEXT('\0');
  1986.     wcscat(wszBuf,L"%");
  1987.  
  1988.     // If the allowed active statements is > 1, then use the same connection
  1989.     // otherwise use the other connection
  1990.     if (fStmts > 1)
  1991.         hstmtW=hstmtUW;
  1992.     else
  1993.         hstmtW=hstmtANSIW;
  1994.  
  1995.     // Call SQLColumnsA&W on two different hstmts (same connection if allowed)
  1996.     // Call for only the given table to limit compare errors at this time
  1997.     rc = SQLColumnsA(hstmtUA, NULL, 0, NULL, 0, aszTable, SQL_NTS, NULL, 0);
  1998.     ERRSHANDLE(SQL_HANDLE_STMT, hstmtANSIA, SQL_SUCCESS, rc, szSQLCOLUMNSA);
  1999.     
  2000.     // Call for only the given table to limit compare errors at this time
  2001.     rc = SQLColumnsW(hstmtW, NULL, 0, NULL, 0, wszTable, SQL_NTS, NULL, 0);
  2002.     ERRSHANDLE(SQL_HANDLE_STMT, hstmtW, SQL_SUCCESS, rc, szSQLCOLUMNSW);
  2003.  
  2004.     CompareAnsiUnicodeResults(hstmtUA, hstmtW, szSQLCOLUMNSW);
  2005.  
  2006.     rc = SQLExecDirectA(hstmtUA, aszQuery, SQL_NTS);
  2007.     ERRSHANDLE(SQL_HANDLE_STMT, hstmtUA, SQL_SUCCESS, rc, szSQLEXECDIRECTA);
  2008.     
  2009.     // Call for only the given table to limit compare errors at this time
  2010.     rc = SQLExecDirectW(hstmtW, wszQuery, SQL_NTS);
  2011.     ERRSHANDLE(SQL_HANDLE_STMT, hstmtW, SQL_SUCCESS, rc, szSQLEXECDIRECTW);
  2012.  
  2013.     CompareAnsiUnicodeResults(hstmtUA, hstmtW, szSQLEXECDIRECTW);
  2014.  
  2015.     // Disconnect and free ANSI handles
  2016.     rc=SQLFreeStmt(hstmtANSIA, SQL_DROP);
  2017.     ERRSHANDLE(SQL_HANDLE_STMT, hstmtANSIA, SQL_SUCCESS, rc,szSQLFREESTMT);
  2018.     rc=SQLFreeStmt(hstmtANSIW, SQL_DROP);
  2019.     ERRSHANDLE(SQL_HANDLE_STMT, hstmtANSIW, SQL_SUCCESS, rc,szSQLFREESTMT);
  2020.     rc=SQLDisconnect(hdbcANSI);
  2021.     ERRSHANDLE(SQL_HANDLE_DBC, hdbcANSI, SQL_SUCCESS, rc,szSQLCONNECT);
  2022.     rc=SQLFreeConnect(hdbcANSI);
  2023.     ERRSHANDLE(SQL_HANDLE_DBC, hdbcANSI, SQL_SUCCESS, rc,szSQLCONNECT);
  2024.     // Disconnect and free Unicode handles
  2025.     rc=SQLFreeStmt(hstmtUA, SQL_DROP);
  2026.     ERRSHANDLE(SQL_HANDLE_STMT, hstmtUA, SQL_SUCCESS, rc,szSQLFREESTMT);
  2027.     rc=SQLFreeStmt(hstmtUW, SQL_DROP);
  2028.     ERRSHANDLE(SQL_HANDLE_STMT, hstmtUW, SQL_SUCCESS, rc,szSQLFREESTMT);
  2029.     rc=SQLDisconnect(hdbcUnicode);
  2030.     ERRSHANDLE(SQL_HANDLE_DBC, hdbcUnicode, SQL_SUCCESS, rc,szSQLCONNECT);
  2031.     rc=SQLFreeConnect(hdbcUnicode);
  2032.     ERRSHANDLE(SQL_HANDLE_DBC, hdbcUnicode, SQL_SUCCESS, rc,szSQLCONNECT);
  2033.  
  2034. } /* TestMixedAnsiUnicode() */
  2035.  
  2036. //-----------------------------------------------------------------------
  2037. //      Function:               TestStmtOptions
  2038. //-----------------------------------------------------------------------
  2039.  
  2040. void  PASCAL TestStmtOptions()
  2041. {
  2042.     UDWORD    dwLen,
  2043.                 udw;
  2044.     BOOL        fConnectOption;
  2045.     RETCODE    rc=SQL_SUCCESS;
  2046.     TCHAR        szAPI[MEDBUFF];
  2047.     SDWORD    cbValue=0;
  2048.  
  2049.     SetStatementAttributes(SQL_MAX_LENGTH,(PTR)&udw);
  2050.  
  2051.     if (SetStatementAttributes(SQL_MAX_LENGTH, (PTR)TEST_STMT_OPTION))
  2052.         fConnectOption = TRUE;
  2053.  
  2054.     if (Supported(SQL_API_SQLGETSTMTATTR))
  2055.     {
  2056.         rc = SQLGetStmtAttr(hstmt, SQL_MAX_LENGTH, (PTR)&dwLen,sizeof(dwLen),&cbValue);
  2057.         lstrcpy(szAPI,szSQLGETSTMTATTR);
  2058.     }
  2059.     else
  2060.     {
  2061.         rc = SQLGetStmtOption(hstmt, SQL_MAX_LENGTH, &dwLen);
  2062.         lstrcpy(szAPI,szSQLGETSTMTOPTION);
  2063.     }
  2064.  
  2065.     if(rc != SQL_SUCCESS)
  2066.     {
  2067.         if(!FindError(SQL_HANDLE_STMT,szHYC00))
  2068.             RETCHECK(SQL_SUCCESS, rc,szSQLGETSTMTOPTION);
  2069.     }
  2070.     else
  2071.     {
  2072.         if(dwLen != TEST_STMT_OPTION && rc == SQL_SUCCESS && fConnectOption)
  2073.             DISPLAYERROR(szSQLGETSTMTOPTION,TEXT("incorrect SQL_MAX_LENGTH value returned"));
  2074.     }
  2075.  
  2076.  
  2077. } //TestStmtOptions()
  2078.  
  2079.  
  2080. //-----------------------------------------------------------------------
  2081. //      Function:               SetTableName
  2082. //-----------------------------------------------------------------------
  2083.  
  2084. void  PASCAL SetTableName(QTSTRUCT  *lpqt)
  2085. {
  2086.     RETCODE    rc=SQL_SUCCESS;
  2087.     UWORD        cTableName;
  2088.     TCHAR        szTime[MEDBUFF]=TEXT(""),
  2089.                 szTmpBuff[MEDBUFF],
  2090.                 *pTime=NULL;
  2091.  
  2092.     _tstrtime(szTmpBuff);
  2093.  
  2094.     /* Remove colons */
  2095.     pTime=_tcstok(szTmpBuff, TEXT(":"));
  2096.     while (pTime)
  2097.     {
  2098.         lstrcat(szTime,pTime);
  2099.         pTime=_tcstok(NULL, TEXT(":"));        
  2100.     }
  2101.      
  2102.     rc = SQLGetInfo(hdbc, SQL_MAX_TABLE_NAME_LEN, &cTableName,
  2103.         sizeof (int), NULL);
  2104.     if(rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO)
  2105.         RETCHECK(SQL_SUCCESS, rc,szSQLGETINFO);
  2106.  
  2107.     rc = SQLGetInfo(hdbc, SQL_QUALIFIER_NAME_SEPARATOR, lpqt->buf,
  2108.         MAX_STRING_SIZE, NULL);
  2109.     if(rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO)
  2110.         RETCHECK(SQL_SUCCESS, rc,szSQLGETINFO);
  2111.  
  2112.     if(!lstrcmp(TEXT("\\"), lpqt->buf))
  2113.         cTableName -= 4;
  2114.     
  2115.     _sntprintf(lpqt->szTableName, min(cTableName, MAX_TABLE_NAME-1),
  2116.                 TEXT("q%s"), szTime);
  2117.  
  2118. } //SetTableName()
  2119.  
  2120.  
  2121. //-----------------------------------------------------------------------
  2122. //      Function:               AllowedType
  2123. //
  2124. //        If swNumTypes > 0, limits SQL types to those in array
  2125. //-----------------------------------------------------------------------
  2126. BOOL AllowedType(SWORD fType)
  2127. {
  2128.     SWORD i, swNumTypes=0;
  2129.     BOOL bAllowed=TRUE;
  2130.     SWORD rgAllowedTypes[MAX_TYPES_SUPPORTED]={
  2131.         SQL_CHAR,
  2132.         SQL_BINARY
  2133. //        SQL_BIT
  2134. /*
  2135.         SQL_TINYINT
  2136.         SQL_NUMERIC,
  2137.         SQL_INTEGER,
  2138.         SQL_SMALLINT,
  2139.         SQL_FLOAT,
  2140.         SQL_REAL,
  2141.         SQL_TYPE_TIMESTAMP,
  2142.         SQL_LONGVARBINARY,
  2143.         SQL_LONGVARCHAR
  2144. */
  2145.     };
  2146.  
  2147.     if (swNumTypes > 0)
  2148.     {
  2149.         bAllowed=FALSE;
  2150.  
  2151.         for (i=0; i < swNumTypes; i++)
  2152.         {
  2153.             if (fType == rgAllowedTypes[i])
  2154.                 bAllowed=TRUE;
  2155.         }
  2156.     }
  2157.  
  2158.     return bAllowed;
  2159. }
  2160.  
  2161. //-----------------------------------------------------------------------
  2162. //      Function:               GetTypeInfo
  2163. //-----------------------------------------------------------------------
  2164.  
  2165. UWORD  PASCAL GetTypeInfo(FIELDINFO  *rgFields,QTSTRUCT  *lpqt)
  2166. {
  2167.     RETCODE        rc=SQL_SUCCESS;
  2168.     UWORD       cFieldName;
  2169.     SDWORD      cMaxTypeSize, cMaxRowSize;
  2170.     UWORD       i,
  2171.                     cTypes=0;
  2172.     SDWORD      sdw;
  2173.     LPTSTR       pch=NULL;
  2174.     BOOL            fAutoInc=0;
  2175.  
  2176.     /* Get the type information to use in a create statement for a table */
  2177.  
  2178.     rc = SQLGetInfo(hdbc, SQL_MAX_COLUMN_NAME_LEN, &cFieldName,
  2179.         sizeof cFieldName, NULL);
  2180.     RETCHECK(SQL_SUCCESS, rc,szSQLGETINFO);
  2181.  
  2182.     rc = SQLGetInfo(hdbc, SQL_MAX_ROW_SIZE, &cMaxRowSize,
  2183.         sizeof cMaxRowSize, NULL);
  2184.     /* don't check for SQL_SUCCES here, it's a 2.0 function.  If it's successful
  2185.         That's great, if not then no maximum is assumed. */
  2186.     
  2187.     cMaxTypeSize = cMaxRowSize / MAX_TYPES_SUPPORTED;
  2188.     
  2189. /* TO DO: add checks in here for dos file types GetInfo SQL_QUALIFIER_NAME_SEPARATER */
  2190.  
  2191.     if(cFieldName > MAX_FIELD - 1)
  2192.         cFieldName = MAX_FIELD - 1;
  2193.  
  2194.     if(cFieldName < PREFIX_SIZE)
  2195.     {
  2196.         DISPLAYERROR(szSQLGETINFO,TEXT("MAX_COLUMN_NAME_LEN is too small for autotest to run"));
  2197.         goto TypeErrorRet;
  2198.     }
  2199.  
  2200.     rc = SQLGetTypeInfo(hstmt, SQL_ALL_TYPES);
  2201.     RETCHECK(SQL_SUCCESS, rc,szSQLGETTYPEINFO);
  2202.  
  2203.     for(i = 0; i < MAX_TYPES_SUPPORTED; i++)
  2204.     {
  2205.     
  2206.         rc = SQLFetch(hstmt);
  2207.         if(rc != SQL_SUCCESS && rc !=SQL_SUCCESS_WITH_INFO)
  2208.             break;
  2209.  
  2210.         *rgFields[i].szType = *rgFields[i].szLength = *rgFields[i].szParams = TEXT('\0');
  2211.  
  2212.         /* get type name */
  2213.         rc = SQLGetData(hstmt, 1, SQL_C_TCHAR,
  2214.             rgFields[i].szType, MAX_TYPE_NAME, &sdw);
  2215.  
  2216.         if(!RETCHECK(SQL_SUCCESS, rc,szSQLGETDATA))
  2217.             goto TypeErrorRet;
  2218.  
  2219.         wsprintf(rgFields[i].szFieldName,TEXT("c%02u"), i+COLNAME_START);
  2220.         /* copy first portion of type name for easy reference */
  2221.         _tcsnccat(rgFields[i].szFieldName, rgFields[i].szType, TYPE_PORTION);
  2222.  
  2223.  
  2224.         /* change spaces in field name to '_' */
  2225.         while((pch = (LPTSTR)_tcschr(rgFields[i].szFieldName, TEXT(' '))) != NULL)
  2226.             *pch = TEXT('_');
  2227.  
  2228.         /* get the SQLType */
  2229.         rc = SQLGetData(hstmt, 2, SQL_C_DEFAULT,
  2230.             (SWORD  *)&rgFields[i].wSQLType, IGNORED,
  2231.             &sdw);
  2232.         if(!RETCHECK(SQL_SUCCESS, rc,szSQLGETDATA))
  2233.             goto TypeErrorRet;
  2234.  
  2235.         /* Max length */
  2236.         rc = SQLGetData(hstmt, 3, SQL_C_TCHAR,
  2237.             rgFields[i].szLength, MAX_FIELD, &sdw);
  2238.         if(!RETCHECK(SQL_SUCCESS, rc,szSQLGETDATA))
  2239.             goto TypeErrorRet;
  2240.  
  2241.         /* limit the row size for those drivers that don't support a long
  2242.             enough row length for all the fields to be at the max length */
  2243.         switch(rgFields[i].wSQLType)
  2244.         {
  2245.             case SQL_CHAR:
  2246.             case SQL_VARCHAR:
  2247.             case SQL_VARBINARY:
  2248.             case SQL_BINARY:
  2249.             case SQL_LONGVARCHAR:
  2250.             case SQL_LONGVARBINARY:
  2251.  
  2252.                 if(cMaxTypeSize)
  2253.                 {
  2254.                     if(_ttol (rgFields[i].szLength) > cMaxTypeSize)
  2255.                         _ltot(cMaxTypeSize, rgFields[i].szLength, 10);
  2256.                 }
  2257.         }
  2258.  
  2259.         /* prefix */
  2260.         rc = SQLGetData(hstmt, 4, SQL_C_TCHAR,
  2261.             rgFields[i].szPrefix, MAX_PREFIX, &sdw);
  2262.         if(!RETCHECK(SQL_SUCCESS, rc,szSQLGETDATA))
  2263.             goto TypeErrorRet;
  2264.  
  2265.         /* suffix */
  2266.         rc = SQLGetData(hstmt, 5, SQL_C_TCHAR,
  2267.             rgFields[i].szSuffix, MAX_SUFFIX, &sdw);
  2268.         if(!RETCHECK(SQL_SUCCESS, rc,szSQLGETDATA))
  2269.             goto TypeErrorRet;
  2270.  
  2271.         /* create params */
  2272.         rc = SQLGetData(hstmt, 6, SQL_C_TCHAR,
  2273.             rgFields[i].szParams, MAX_PARAM_SIZE, &sdw);
  2274.         if(!RETCHECK(SQL_SUCCESS, rc,szSQLGETDATA))
  2275.             goto TypeErrorRet;
  2276.  
  2277.         /* nullable */
  2278.         rc = SQLGetData(hstmt, 7, SQL_C_SHORT, &rgFields[i].nullable, IGNORED,
  2279.             &sdw);
  2280.         if(!RETCHECK(SQL_SUCCESS, rc,szSQLGETDATA))
  2281.             goto TypeErrorRet;
  2282.  
  2283.         /* searchable */
  2284.         rc = SQLGetData(hstmt, 9, SQL_C_SHORT, &rgFields[i].fSearchable, IGNORED,
  2285.             &sdw);
  2286.         if(!RETCHECK(SQL_SUCCESS, rc,szSQLGETDATA))
  2287.             goto TypeErrorRet;
  2288.  
  2289.         /* autoincrement */
  2290.         rc = SQLGetData(hstmt, 12, SQL_C_SHORT, &rgFields[i].autoinc, IGNORED,
  2291.             &sdw);
  2292.         if(!RETCHECK(SQL_SUCCESS, rc,szSQLGETDATA))
  2293.             goto TypeErrorRet;
  2294.  
  2295.         // Since some data types will have NULL for autoincrement, we need to set to FALSE
  2296.         if (SQL_NULL_DATA == sdw)
  2297.             rgFields[i].autoinc=FALSE;
  2298.  
  2299.         if (IgnoreType(rgFields[i].szType,rgFields[i].wSQLType))
  2300.         {
  2301.             i--;
  2302.             continue;
  2303.         }
  2304.  
  2305.         /* The following code only allows the first autoincrement column to
  2306.             be placed in the table.  Many DBMS's do not allow more than one per table. */
  2307.         if(rgFields[i].autoinc == TRUE)
  2308.         {
  2309.             if(fAutoInc)
  2310.             {
  2311.                 i--;
  2312.                 continue;
  2313.             }
  2314.             else
  2315.                 fAutoInc = TRUE;
  2316.         }
  2317.  
  2318.         // Limit data types to those desired (use for debugging)
  2319.         if (!AllowedType(rgFields[i].wSQLType))
  2320.         {
  2321.             i--;
  2322.             continue;
  2323.         }
  2324.     }
  2325.  
  2326.     cTypes = i;
  2327.  
  2328.     /* if the type name contains spaces, replace them with _ because
  2329.         most servers don't allow spaces in field names */
  2330.  
  2331.     RETCHECK(SQL_NO_DATA_FOUND, rc,szSQLFETCH);
  2332.  
  2333.     rc = SQLFreeStmt(hstmt, SQL_CLOSE);
  2334.     RETCHECK(SQL_SUCCESS, rc,szSQLFREESTMT);
  2335.  
  2336.     SetTableName(lpqt);
  2337.  
  2338.     return(cTypes);
  2339.  
  2340. TypeErrorRet:
  2341.  
  2342.     return(0);
  2343.  
  2344. } //GetTypeInfo()
  2345.  
  2346.  
  2347.  
  2348.  
  2349. //-----------------------------------------------------------------------
  2350. //      Function:               BuildCreateStmt
  2351. //-----------------------------------------------------------------------
  2352.  
  2353. BOOL  PASCAL BuildCreateStmt(QTSTRUCT  *lpqt,FIELDINFO  *rgFields,UWORD cTypes)
  2354. {
  2355.     RETCODE        rc=SQL_SUCCESS;
  2356.     TCHAR        szNum[MAX_NUM_BUFFER];   /* used with _ttoi and itoa conversions */
  2357.     SWORD       wNum;
  2358.     UWORD       i;
  2359.     SDWORD      sdw;
  2360.     LPTSTR       pch=NULL;
  2361.  
  2362.  
  2363.     /* the column names will be ctypname (where typename is the
  2364.         type name returned by the source in SQLGetTypeInfo) */
  2365.  
  2366.     *lpqt->sz = TEXT('\0');
  2367.     lstrcpy(lpqt->sz,TEXT("Create Table "));
  2368.     lstrcat(lpqt->sz, lpqt->szTableName);
  2369.     lstrcat(lpqt->sz,TEXT(" ("));
  2370.     for(i = 0; i < cTypes; i++) {
  2371.             TCHAR szParamType[50];
  2372.             TCHAR szNotNull[10];
  2373.             *lpqt->szParam = TEXT('\0');
  2374.  
  2375.         /* if SQLGetTypeInfo returned params they need to be used in
  2376.             the create statement */
  2377.         
  2378.         if(rgFields[i].szParams == NULL || lstrlen(rgFields[i].szParams) == 0)
  2379.             *lpqt->szParam = TEXT('\0');
  2380.         else if(_tcschr(rgFields[i].szParams, TEXT(',')) == NULL)
  2381.             wsprintf(lpqt->szParam,TEXT("(%s)"), rgFields[i].szLength);
  2382.         else
  2383.             {
  2384.             lstrcpy(szNum, rgFields[i].szLength);
  2385.             wsprintf(lpqt->szParam,TEXT("(%s, %d)"), rgFields[i].szLength,
  2386.                 _ttoi(szNum) - SCALEDIFF);
  2387.             }
  2388.  
  2389.         lstrcpy(szParamType, rgFields[i].szType);
  2390.         if(pch = _tcschr((LPTSTR)szParamType, TEXT('('))) 
  2391.             {
  2392.             *pch = TEXT('\0');
  2393.             lstrcat(szParamType, lpqt->szParam);
  2394.             lstrcat(szParamType, (LPTSTR)_tcschr(rgFields[i].szType, TEXT(')')) + 1);
  2395.             }
  2396.         else
  2397.             {
  2398.             lstrcat(szParamType, lpqt->szParam);
  2399.             }
  2400.  
  2401.         /* If the field is not nullable, we need to create the table that way */
  2402.         rc = SQLGetInfo(hdbc, SQL_NON_NULLABLE_COLUMNS, &wNum,
  2403.             sizeof (SWORD), NULL);
  2404.         if(rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO)
  2405.             RETCHECK(SQL_SUCCESS, rc,szSQLGETINFO);
  2406.         
  2407.         if((rgFields[i].nullable == SQL_NO_NULLS) && (wNum != SQL_NNC_NULL))
  2408.             lstrcpy(szNotNull,TEXT("NOT NULL"));
  2409.         else
  2410.             szNotNull[0] = TEXT('\0');
  2411.         
  2412.         wsprintf(&lpqt->sz[lstrlen(lpqt->sz)],TEXT(" %s %s %s ,"),
  2413.             rgFields[i].szFieldName, (LPTSTR)szParamType, (LPTSTR)szNotNull);
  2414.     }
  2415.  
  2416.     /* remove the last comma and space */
  2417.     lpqt->sz[lstrlen(lpqt->sz) - 2] = TEXT('\0');
  2418.     lstrcat(lpqt->sz,TEXT(")"));
  2419.  
  2420.     rc = SQLExecDirect(hstmt, lpqt->sz, SQL_NTS);
  2421.     if(rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO)
  2422.         if(!RETCHECK(SQL_SUCCESS, rc,szSQLEXECDIRECT))
  2423.             goto BuildErrorRet;
  2424.  
  2425.     /* now that table was created, call SQLColumns.  Both as
  2426.         a test and to get necessary information to insert data */
  2427.  
  2428.     rc = SQLColumns(hstmt, NULL, SQL_NTS, NULL, SQL_NTS,
  2429.         lpqt->szTableName, SQL_NTS, NULL, SQL_NTS);
  2430.     RETCHECK(SQL_SUCCESS, rc,szSQLCOLUMNS);
  2431.  
  2432.     for(i = 0; i < cTypes; i++) {
  2433.         rc = SQLFetch(hstmt);
  2434.         RETCHECK(SQL_SUCCESS, rc,szSQLFETCH);
  2435.  
  2436.         /* precision */
  2437.         rc = SQLGetData(hstmt, 7, SQL_C_LONG, &rgFields[i].precision, IGNORED,
  2438.             &sdw);
  2439.         RETCHECK(SQL_SUCCESS, rc,szSQLGETDATA);
  2440.  
  2441.         /* length */
  2442.         if((rgFields[i].precision == 0) || (sdw == SQL_NO_TOTAL)){
  2443.             rc = SQLGetData(hstmt, 8, SQL_C_LONG, &rgFields[i].precision, IGNORED,
  2444.                 &sdw);
  2445.             RETCHECK(SQL_SUCCESS, rc,szSQLGETDATA);
  2446.             if(sdw == SQL_NO_TOTAL)        /* precision & length were undetermined */
  2447.                 rgFields[i].precision = 1000;    /* so set it to an arbitary value */
  2448.         }
  2449.  
  2450.         /* numeric scale */
  2451.         rc = SQLGetData(hstmt, 9, SQL_C_SHORT, &rgFields[i].scale, IGNORED,
  2452.             &sdw);
  2453.         RETCHECK(SQL_SUCCESS, rc,szSQLGETDATA);
  2454.         if(sdw == SQL_NO_TOTAL)
  2455.             rgFields[i].scale = 0;
  2456.     }
  2457.  
  2458.     rc = SQLFreeStmt(hstmt, SQL_CLOSE);
  2459.     RETCHECK(SQL_SUCCESS, rc,szSQLFREESTMT);
  2460.  
  2461.     /* look for columns the test should not try to update by running
  2462.         a select * query and calling ColAttributes on the result fields */
  2463.     /* select * does not return the fields in a defined order, so field order
  2464.         must be specified */
  2465.  
  2466.     lstrcpy(lpqt->sz,TEXT("select "));
  2467.     for(i = 0; i < cTypes; i ++) {
  2468.         if(i)
  2469.             lstrcat(lpqt->sz,TEXT(","));
  2470.         lstrcat(lpqt->sz, rgFields[i].szFieldName);
  2471.     }
  2472.  
  2473.     lstrcat(lpqt->sz,TEXT(" from "));
  2474.     lstrcat(lpqt->sz, lpqt->szTableName);
  2475.  
  2476.     rc = SQLExecDirect(hstmt, lpqt->sz, SQL_NTS);
  2477.     RETCHECK(SQL_SUCCESS, rc,szSQLEXECDIRECT);
  2478.  
  2479.     for(i = 1; i <= cTypes; i++) {
  2480.  
  2481.         rc = SQLColAttributes(hstmt, i, SQL_COLUMN_UPDATABLE, NULL,
  2482.             0, NULL, &sdw);
  2483.         RETCHECK(SQL_SUCCESS, rc,szSQLCOLATTRIBUTES);
  2484.  
  2485.         rgFields[i - 1].fAutoUpdate = sdw == SQL_ATTR_READONLY;
  2486.  
  2487.         rc = SQLColAttributes(hstmt, i, SQL_COLUMN_UNSIGNED, NULL,
  2488.             0, NULL, &sdw);
  2489.         RETCHECK(SQL_SUCCESS, rc,szSQLCOLATTRIBUTES);
  2490.  
  2491.         rgFields[i - 1].fUnsigned = sdw;
  2492.     }
  2493.  
  2494.     rc = SQLFreeStmt(hstmt, SQL_CLOSE);
  2495.     RETCHECK(SQL_SUCCESS, rc,szSQLFREESTMT);
  2496.  
  2497.     return(FALSE);
  2498.  
  2499. BuildErrorRet:
  2500.  
  2501.     return(TRUE);
  2502.  
  2503. } //BuildCreateStmt()
  2504.  
  2505.  
  2506.  
  2507. //-----------------------------------------------------------------------
  2508. //      Function:               BuildInsertStmt
  2509. //-----------------------------------------------------------------------
  2510.                                           
  2511. BOOL  PASCAL BuildInsertStmt(QTSTRUCT  *lpqt,FIELDINFO  *rgFields,UWORD cTypes,
  2512.     DSTRUCT  *lpd,SDWORD  *cColsSelected,BOOL fBindParameter)
  2513. {
  2514.     RETCODE      rc;
  2515.     UWORD        w;
  2516.     UWORD        i;
  2517.     PTR            ptr;
  2518.     UWORD        ind;
  2519.     SDWORD       sdw;
  2520.     LPTSTR        pch=NULL;
  2521.     BOOL            fColNames=TRUE,
  2522.                     fLongData=FALSE;
  2523.     SDWORD          *sdwArray = (SDWORD  *)AllocateMemory(sizeof(SDWORD) * MAX_TYPES_SUPPORTED);
  2524.     
  2525.     lstrcpy(lpqt->szColNames,TEXT("\0"));
  2526.     lstrcpy(lpqt->szValues,TEXT("\0"));
  2527.     
  2528.     for(i = 0; i < cTypes; i++) {
  2529.  
  2530.         for(ind = 0, w = 0; ind < cTypes; ind++) {
  2531.  
  2532.             pch = qtMakeData(i, ind,&rgFields[ind], lpqt->szDataItem);
  2533.  
  2534.             if(!pch) /* current type is READ_ONLY) */
  2535.                 continue;
  2536.  
  2537.             /* for every nullable type, that field will be set to     */
  2538.             /* null when the row number corresponds with the field */
  2539.             /* number */
  2540.  
  2541.             if(*pch) 
  2542.                 {
  2543.                 lstrcpy(lpd[w].data, pch);
  2544.                 lpd[w].cb = SQL_NTS;
  2545.                 }
  2546.             else 
  2547.                 {
  2548.                 lstrcpy(lpd[w].data,TEXT(""));
  2549.                 lpd[w].cb = SQL_NULL_DATA;
  2550.                 }
  2551.  
  2552.             if(fColNames) 
  2553.                 {
  2554.                 /* the first time throught, the insert */
  2555.                 /* statement itself is created         */
  2556.                 lstrcat(lpqt->szColNames, rgFields[ind].szFieldName);
  2557.                 lstrcat(lpqt->szColNames,TEXT(", "));
  2558.                 lstrcat(lpqt->szValues,TEXT(" ?, "));
  2559.  
  2560.                 /* and parameters are set                                         */
  2561.                 /* set all the parameters using pointers to buffers in*/
  2562.                 /* the param struct.                                             */
  2563.                 if(!fBindParameter)
  2564.                     {
  2565.                     rc = SQLSetParam(hstmt, (UWORD)(w+1),
  2566.                         SQL_C_TCHAR, rgFields[ind].wSQLType,
  2567.                         rgFields[ind].precision, rgFields[ind].scale,
  2568.                         &lpd[w].data,
  2569.                         &lpd[w].cb);
  2570.                     RETCHECK(SQL_SUCCESS, rc,szSQLSETPARAM);
  2571.                     }
  2572.                 else
  2573.                     {
  2574.                     rc = SQLBindParameter(hstmt, (UWORD)(w+1),
  2575.                         SQL_PARAM_INPUT,
  2576.                         SQL_C_TCHAR, rgFields[ind].wSQLType,
  2577.                         rgFields[ind].precision, rgFields[ind].scale,
  2578.                         &lpd[w].data, MAX_STRING_SIZE,
  2579.                         &lpd[w].cb);
  2580.                     RETCHECK(SQL_SUCCESS, rc,szSQLBINDPARAMETER);
  2581.                     }
  2582.             }
  2583.             w++;
  2584.             cNumResSetCols=w;
  2585.         }
  2586.  
  2587.         if(fColNames) 
  2588.             { 
  2589.             /* the first time through, the insert            */
  2590.             /* statement needs to be SQLPrepare'd            */
  2591.             /* remove the "," at the end of the string    */
  2592.             lpqt->szColNames[lstrlen(lpqt->szColNames) - 2] = TEXT('\0');
  2593.             lpqt->szValues[lstrlen(lpqt->szValues) - 2] = TEXT('\0');
  2594.  
  2595.             wsprintf(lpqt->sz,TEXT("insert into %s (%s) VALUES(%s)"),
  2596.                 lpqt->szTableName, lpqt->szColNames, lpqt->szValues);
  2597.  
  2598.             //copy the insert statement, with the column names. 
  2599.             //_ASSERTE(lstrlen(lpqt->sz) < MAX_STRING_SIZE);
  2600.             lstrcpy(szInsertStmt,lpqt->sz);
  2601.  
  2602.             //prepare the statement
  2603.             rc = SQLPrepare(hstmt, lpqt->sz, SQL_NTS);
  2604.             if(!RETCHECK(SQL_SUCCESS, rc,szSQLPREPARE))
  2605.                 goto InsertErrorRet;
  2606.  
  2607.             fColNames = FALSE; /* no more first times through */
  2608.             }
  2609.  
  2610.         rc = SQLExecute(hstmt); /* insert a row */
  2611.  
  2612.         if(!RETCHECK(SQL_SUCCESS, rc,szSQLEXECUTE))
  2613.         {
  2614.             if (SQL_SUCCESS_WITH_INFO != rc)        // BANDAID, normally would fail on S.W.I
  2615.                 goto InsertErrorRet;
  2616.         }
  2617.  
  2618.         rc = SQLRowCount(hstmt, &sdw);
  2619.         RETCHECK(SQL_SUCCESS, rc,szSQLROWCOUNT);
  2620.  
  2621.         if(sdw != 1) /* the execute inserted 1 row */
  2622.             DISPLAYERROR(szSQLROWCOUNT,TEXT("Insert single row"));
  2623.  
  2624.         /* FreeStmt SQL_CLOSE */
  2625.         rc = SQLFreeStmt(hstmt, SQL_CLOSE);
  2626.         RETCHECK(SQL_SUCCESS, rc,szSQLFREESTMT);
  2627.     }
  2628.  
  2629.     /* for the last row use SQLParamData and SQLPutData */
  2630.  
  2631.     /* First check to see if the SQL_LEN_DATA_AT_EXEC macro is supported */
  2632.     rc = SQLGetInfo(hdbc, SQL_NEED_LONG_DATA_LEN, lpqt->buf, (SWORD)sizeof(lpqt->buf), NULL);
  2633.     if(rc == SQL_SUCCESS)
  2634.         if(lpqt->buf[0] == TEXT('Y'))
  2635.             fLongData = TRUE;
  2636.     
  2637.     for(ind = 0, w = 0; ind < cTypes; ind++) 
  2638.         { 
  2639.  
  2640.         /* set all the params */
  2641.         
  2642.         if(rgFields[ind].fAutoUpdate)
  2643.             continue;
  2644.  
  2645.         if(fLongData && ((rgFields[ind].wSQLType == SQL_LONGVARBINARY) || 
  2646.             (rgFields[ind].wSQLType == SQL_LONGVARCHAR))){
  2647.             /* Make sure we don't exceed the max negative SDWORD value */
  2648.             if(rgFields[ind].precision > (MAXSDWORD + SQL_LEN_DATA_AT_EXEC_OFFSET))
  2649.                 sdwArray[ind] = MINSDWORD - SQL_LEN_DATA_AT_EXEC_OFFSET;
  2650.             else
  2651.                 sdwArray[ind] = SQL_LEN_DATA_AT_EXEC(rgFields[ind].precision);
  2652.             }
  2653.         else
  2654.             sdwArray[ind] = SQL_DATA_AT_EXEC;
  2655.  
  2656.         w++;
  2657.         if(!fBindParameter){
  2658.             rc = SQLSetParam(hstmt, w,
  2659.                 SQL_C_TCHAR, rgFields[ind].wSQLType,
  2660.                 rgFields[ind].precision, rgFields[ind].scale,
  2661.                 (LPTSTR)(UDWORD)ind, &sdwArray[ind]);
  2662.             RETCHECK(SQL_SUCCESS, rc,szSQLSETPARAM);
  2663.             }
  2664.         else{
  2665.             rc = SQLBindParameter(hstmt, w, SQL_PARAM_INPUT,
  2666.                 SQL_C_TCHAR, rgFields[ind].wSQLType,
  2667.                 rgFields[ind].precision, rgFields[ind].scale,
  2668.                 (LPTSTR)(((UDWORD)ind)+BIND_PARM_OFFSET), 0, &sdwArray[ind]);
  2669.             RETCHECK(SQL_SUCCESS, rc,szSQLBINDPARAMETER);
  2670.             }
  2671.     }
  2672.  
  2673.     *cColsSelected = w;
  2674.  
  2675.     rc = SQLExecDirect(hstmt, lpqt->sz, SQL_NTS);
  2676.     if (!RETCHECK(SQL_NEED_DATA, rc,szSQLEXECDIRECT))
  2677.         goto InsertErrorRet;
  2678.  
  2679.  
  2680.     for(ind = 0; ind <= cTypes; ind++) 
  2681.         {
  2682.         rc = SQLParamData(hstmt, &ptr);
  2683.         if(rc != SQL_NEED_DATA)
  2684.             break;
  2685.  
  2686.         pch = qtMakeData(cTypes, ind, &rgFields[(unsigned long)ptr-BIND_PARM_OFFSET],
  2687.             lpqt->szDataItem);
  2688.  
  2689.         if(*pch) {
  2690.             rc = SQLPutData(hstmt, pch, SQL_NTS);
  2691.             RETCHECK(SQL_SUCCESS, rc,szSQLPUTDATA);
  2692.         } else {
  2693.             rc = SQLPutData(hstmt, (LPTSTR)IGNORED, SQL_NULL_DATA);
  2694.             RETCHECK(SQL_SUCCESS, rc,szSQLPUTDATA);
  2695.         }
  2696.     }
  2697.                               
  2698.     RETCHECK(SQL_SUCCESS, rc,szSQLPARAMDATA);
  2699.  
  2700.     rc = SQLRowCount(hstmt, &sdw);
  2701.     RETCHECK(SQL_SUCCESS, rc,szSQLROWCOUNT);
  2702.  
  2703.     if(sdw != 1)
  2704.         DISPLAYERROR(szSQLROWCOUNT,TEXT("Insert single row"));
  2705.  
  2706.     rc = SQLFreeStmt(hstmt, SQL_RESET_PARAMS);
  2707.     RETCHECK(SQL_SUCCESS, rc,szSQLFREESTMT);
  2708.  
  2709.  
  2710.  
  2711.     ReleaseMemory(sdwArray);
  2712.  
  2713.     return(FALSE);
  2714.  
  2715. InsertErrorRet:
  2716.  
  2717.     ReleaseMemory(sdwArray);
  2718.  
  2719.     return(TRUE);
  2720.  
  2721. } //BuildInsertStmt()
  2722.  
  2723.  
  2724. //-----------------------------------------------------------------------
  2725. //      Function:               FullDisconnect
  2726. //-----------------------------------------------------------------------
  2727.  
  2728. void  PASCAL FullDisconnect()
  2729. { 
  2730.     RETCODE rc=SQL_SUCCESS;
  2731.  
  2732.     /* SQLCancel has the same functionality as SQLFreeStmt w/ SQL_CLOSE    */
  2733.     /*    in a non-asynchronous environment                                             */
  2734.  
  2735.     rc = SQLCancel(hstmt);
  2736.     RETCHECK(SQL_SUCCESS, rc,szSQLCANCEL);
  2737.  
  2738.     FreeStmt(SQL_DROP);
  2739.  
  2740.     /* if the connection was made in the                        */
  2741.     /*    test, it should be disconnected                            */
  2742.     /* in the test, otherwise it should be left connected */
  2743.  
  2744.     rc = SQLDisconnect(hdbc);
  2745.     RETCHECK(SQL_SUCCESS, rc,szSQLDISCONNECT);
  2746.  
  2747.     rc = SQLFreeConnect(hdbc);
  2748.     RETCHECK(SQL_SUCCESS, rc,szSQLFREECONNECT);
  2749.  
  2750.     rc = SQLFreeEnv(henv);
  2751.     RETCHECK(SQL_SUCCESS, rc,szSQLFREEENV);
  2752.  
  2753.  
  2754. } //FullDisconnect()
  2755.  
  2756.  
  2757.  
  2758. //-----------------------------------------------------------------------
  2759. //      Function:               DropTable
  2760. //-----------------------------------------------------------------------
  2761.  
  2762. void  PASCAL DropTable(LPTSTR szTableName, BOOL fSilent)
  2763. {        
  2764.     TCHAR        szBuff[100];
  2765.     RETCODE    rc=SQL_ERROR;
  2766.  
  2767.     lstrcpy(szBuff,TEXT("drop table "));
  2768.     lstrcat(szBuff, szTableName);
  2769.  
  2770.     rc = SQLExecDirect(hstmt, szBuff, SQL_NTS);
  2771.  
  2772.     if (!fSilent)
  2773.         {
  2774.         if(!RETCHECK(SQL_SUCCESS, rc,szSQLEXECDIRECT))
  2775.             szWrite(TEXT("Unable to drop table"), TRUE);
  2776.         }
  2777.  
  2778. } //DropTable()
  2779.  
  2780.  
  2781.  
  2782. //-----------------------------------------------------------------------
  2783. //    Function:    CleanUp
  2784. //        Purpose:        To drop the table,disconnect from data source and
  2785. //                        release memory.            
  2786. //-----------------------------------------------------------------------
  2787.     
  2788. void  PASCAL CleanUp(DSTRUCT  *lpd,QTSTRUCT  *lpqt,FIELDINFO  *rgFields,
  2789.     LPTSTR szTableName,BOOL fSilent,LPTSTR szValidServer)
  2790. {
  2791.  
  2792.     DropTable(szTableName, fSilent);
  2793.  
  2794.     if(szValidServer)
  2795.         FullDisconnect();
  2796.  
  2797.     ReleaseMemory(lpd);
  2798.     ReleaseMemory(lpqt);
  2799.     ReleaseMemory(rgFields);
  2800.  
  2801. } //CleanUp()
  2802.  
  2803.  
  2804. //-----------------------------------------------------------------------
  2805. //      Function:               BindAllColumns
  2806. //-----------------------------------------------------------------------
  2807.  
  2808. BOOL  PASCAL BindAllColumns(QTSTRUCT  *lpqt,FIELDINFO  *rgFields,UWORD cTypes,
  2809.     DSTRUCT  *lpd)
  2810. {
  2811. //-----------------------------------------------------------------------
  2812. //      Function:               BindAllColumns
  2813.     UWORD        i,
  2814.                 w;
  2815.     RETCODE    rc=SQL_SUCCESS;
  2816.  
  2817.     for(i = 0, w = 0; i < cTypes; i++) 
  2818.         {
  2819.  
  2820.         if(!qtMakeData(1, i,&rgFields[i],lpqt->szDataItem))
  2821.             continue;
  2822.  
  2823.         w++;
  2824.  
  2825.         switch(rgFields[i].wSQLType) 
  2826.             {
  2827.             case SQL_INTEGER:
  2828.                 rc = SQLBindCol(hstmt, w, SQL_C_DEFAULT,
  2829.                             &lpd[i].sdword, IGNORED, &lpd[i].cb);
  2830.                 break;
  2831.             case SQL_SMALLINT:
  2832.                 rc = SQLBindCol(hstmt, w, SQL_C_DEFAULT,
  2833.                             &lpd[i].sword, IGNORED, &lpd[i].cb);
  2834.                 break;
  2835.             case SQL_FLOAT:
  2836.             case SQL_DOUBLE:
  2837.                 rc = SQLBindCol(hstmt, w, SQL_C_DEFAULT,
  2838.                             &lpd[i].sdouble, IGNORED, &lpd[i].cb);
  2839.                 break;
  2840.             case SQL_REAL:
  2841.                 rc = SQLBindCol(hstmt, w, SQL_C_DEFAULT,
  2842.                             &lpd[i].sfloat, IGNORED, &lpd[i].cb);
  2843.                 break;
  2844.             case SQL_DATE:
  2845.                 rc = SQLBindCol(hstmt, w, SQL_C_DEFAULT,
  2846.                             &lpd[i].date, IGNORED, &lpd[i].cb);
  2847.                 break;
  2848.             case SQL_TIME:
  2849.                 rc = SQLBindCol(hstmt, w, SQL_C_DEFAULT,
  2850.                             &lpd[i].time, IGNORED, &lpd[i].cb);
  2851.                 break;
  2852.             case SQL_TIMESTAMP:
  2853.                 rc = SQLBindCol(hstmt, w, SQL_C_DEFAULT,
  2854.                             &lpd[i].timestamp, IGNORED, &lpd[i].cb);
  2855.                 break;
  2856.             case SQL_CHAR:
  2857.             case SQL_VARCHAR:
  2858.             case SQL_NUMERIC:
  2859.             case SQL_DECIMAL:
  2860.             default:
  2861.                 rc = SQLBindCol(hstmt, w, SQL_C_DEFAULT,
  2862.                             lpd[i].data, MAX_STRING_SIZE, &lpd[i].cb);
  2863.                 break;
  2864.             }
  2865.  
  2866.         if(!RETCHECK(SQL_SUCCESS, rc, szSQLBINDCOL))
  2867.             return(FALSE);
  2868.         }
  2869.  
  2870.     return(TRUE);
  2871.  
  2872. } //BindAllColumns()
  2873.  
  2874. /*-----------------------------------------------------------------------
  2875.  *      Function:               BindFetchColumns
  2876.  *  Used for Checking data in Result sets from fetch calls.
  2877.  *  Binds Binary data types as SQL_C_CHAR
  2878.  *----------------------------------------------------------------------- */
  2879.  
  2880. BOOL  PASCAL BindFetchColumns(QTSTRUCT  *lpqt,FIELDINFO  *rgFields,UWORD cTypes,
  2881.     DSTRUCT  *lpdFetch)
  2882. {
  2883.     UWORD        i,
  2884.                 w;
  2885.     RETCODE    rc=SQL_SUCCESS;
  2886.  
  2887.     for(i = 0, w = 0; i < cTypes; i++) 
  2888.         {
  2889.  
  2890.         if(!qtMakeData(0, i,&rgFields[i],lpqt->szDataItem))
  2891.             continue;
  2892.  
  2893.         w++;
  2894.  
  2895.         switch(rgFields[i].wSQLType) 
  2896.             {
  2897.             case SQL_BIGINT:
  2898.             case SQL_INTEGER:
  2899.                 rc = SQLBindCol(hstmt, w, SQL_C_DEFAULT,
  2900.                             &lpdFetch[i].sdword, IGNORED, &lpdFetch[i].cb);
  2901.                 break;
  2902.             case SQL_TINYINT:
  2903.             case SQL_SMALLINT:
  2904.                 rc = SQLBindCol(hstmt, w, SQL_C_DEFAULT,
  2905.                             &lpdFetch[i].sword, IGNORED, &lpdFetch[i].cb);
  2906.                 break;
  2907.             case SQL_FLOAT:
  2908.             case SQL_DOUBLE:
  2909.                 rc = SQLBindCol(hstmt, w, SQL_C_DEFAULT,
  2910.                             &lpdFetch[i].sdouble, IGNORED, &lpdFetch[i].cb);
  2911.                 break;
  2912.             case SQL_REAL:
  2913.                 rc = SQLBindCol(hstmt, w, SQL_C_DEFAULT,
  2914.                             &lpdFetch[i].sfloat, IGNORED, &lpdFetch[i].cb);
  2915.                 break;
  2916.             case SQL_DATE:
  2917.             case SQL_TYPE_DATE:
  2918.                 rc = SQLBindCol(hstmt, w, SQL_C_DEFAULT,
  2919.                             &lpdFetch[i].date, IGNORED, &lpdFetch[i].cb);
  2920.                 break;
  2921.             case SQL_TIME:
  2922.             case SQL_TYPE_TIME:
  2923.                 rc = SQLBindCol(hstmt, w, SQL_C_DEFAULT,
  2924.                             &lpdFetch[i].time, IGNORED, &lpdFetch[i].cb);
  2925.                 break;
  2926.             case SQL_TIMESTAMP:
  2927.             case SQL_TYPE_TIMESTAMP:
  2928.                 rc = SQLBindCol(hstmt, w, SQL_C_DEFAULT,
  2929.                             &lpdFetch[i].timestamp, IGNORED, &lpdFetch[i].cb);
  2930.                 break;
  2931.             case SQL_BIT:
  2932.             case SQL_BINARY:
  2933.             case SQL_VARBINARY:
  2934.             case SQL_LONGVARBINARY:
  2935.                 rc = SQLBindCol(hstmt, w, SQL_C_TCHAR,
  2936.                             lpdFetch[i].data, MAX_STRING_SIZE, &lpdFetch[i].cb);
  2937.                 break;
  2938.             case SQL_CHAR:
  2939.             case SQL_VARCHAR:
  2940.             case SQL_NUMERIC:
  2941.             case SQL_DECIMAL:
  2942.             default:
  2943.                 rc = SQLBindCol(hstmt, w, SQL_C_DEFAULT,
  2944.                             lpdFetch[i].data, MAX_STRING_SIZE, &lpdFetch[i].cb);
  2945.                 break;
  2946.             }
  2947.  
  2948.         if(!RETCHECK(SQL_SUCCESS, rc, szSQLBINDCOL))
  2949.             return(FALSE);
  2950.         }
  2951.  
  2952.     return(TRUE);
  2953.  
  2954. } /*BindFetchColumns() */
  2955.  
  2956. //-----------------------------------------------------------------------
  2957. //      Function:               TestMetaData
  2958. //-----------------------------------------------------------------------
  2959.  
  2960. void  PASCAL TestMetaData(lpSERVERINFO lpSI, QTSTRUCT  *lpqt,FIELDINFO  *rgFields,UWORD cTypes)
  2961. {
  2962.     SWORD    wNum;
  2963.     UWORD    w;
  2964.     UWORD    i;
  2965.     UDWORD   dwLen;
  2966.     RETCODE    rc=SQL_SUCCESS;
  2967.     SWORD        wType;
  2968.     SWORD        wNull;
  2969.  
  2970.     SelectFromTable(lpqt);
  2971.  
  2972.     for(i = 0, w = 0; i < cTypes; i++) 
  2973.         {
  2974.         dwLen = 0;
  2975.         wNum = 0;
  2976.         wNull = 0;
  2977.  
  2978.         /* information returned by SQLDescribeCol should match info */
  2979.         /*    used to create table */
  2980.  
  2981.         if(!qtMakeData(1, i,&rgFields[i],lpqt->szDataItem))
  2982.             continue;
  2983.  
  2984.         w++;
  2985.         rc = SQLDescribeCol(hstmt, w, lpqt->buf,
  2986.             MAX_STRING_SIZE, NULL, &wType, &dwLen, &wNum, &wNull);
  2987.         RETCHECK(SQL_SUCCESS, rc,szSQLDESCRIBECOL);
  2988.  
  2989.         /* verify that column name returned is column name created */
  2990.  
  2991.         if(0 != lstrcmpi(rgFields[i].szFieldName, lpqt->buf))
  2992.             DISPLAYERROR(szSQLDESCRIBECOL,TEXT("incorrect column name"));
  2993.  
  2994.         if(wType != rgFields[i].wSQLType)
  2995.         {
  2996.             // For a 2.x driver, SQLGetTypeInfo result will be SQL_DATE, etc,
  2997.             // but 3.0 DM will convert SQLDescribeCol values to TYPE_DATE, ETC.
  2998.             if ((uDriverODBCVer < 3) && 
  2999.                 ((SQL_TYPE_DATE == wType && SQL_DATE == rgFields[i].wSQLType) ||
  3000.                 (SQL_TYPE_TIME == wType && SQL_TIME == rgFields[i].wSQLType) ||
  3001.                 (SQL_TYPE_TIMESTAMP == wType && SQL_TIMESTAMP == rgFields[i].wSQLType)))
  3002.                 NULL;
  3003.             else
  3004.                 DISPLAYERROR(szSQLDESCRIBECOL,TEXT("incorrect SQLType"));
  3005.         }
  3006.  
  3007.         if(dwLen != (UDWORD)rgFields[i].precision)
  3008.             DISPLAYERROR(szSQLDESCRIBECOL,TEXT("incorrect precision"));
  3009.         
  3010.         if(wNum != rgFields[i].scale)
  3011.             DISPLAYERROR(szSQLDESCRIBECOL,TEXT("incorrect scale"));
  3012.         
  3013.         if(wNull != rgFields[i].nullable && wNull != SQL_NULLABLE_UNKNOWN &&
  3014.             rgFields[i].nullable != SQL_NULLABLE_UNKNOWN)
  3015.             {
  3016.             DISPLAYERROR(szSQLDESCRIBECOL,TEXT("incorrect nullable"));
  3017.             }
  3018.         }
  3019.  
  3020.     FreeStmt(SQL_CLOSE);
  3021.  
  3022. } //TestMetaData()
  3023.  
  3024.  
  3025. //-----------------------------------------------------------------------
  3026. //      Function:               RetrieveData
  3027. //-----------------------------------------------------------------------
  3028.  
  3029. void PASCAL RetrieveData(QTSTRUCT *lpqt,FIELDINFO *rgFields,
  3030.     UWORD cTypes,DSTRUCT *lpd)
  3031. {
  3032.     RETCODE    rc=SQL_SUCCESS;
  3033.     UWORD        ind,
  3034.                 i;
  3035.     int        nSame;
  3036.     LPTSTR    pch=NULL;
  3037.     TCHAR        szNum[MAX_NUM_BUFFER];   /* used with _ttoi and itoa conversions */
  3038.     TCHAR        *stopstring=NULL;
  3039.     double    Num=0,
  3040.                 Num2=0;
  3041.  
  3042.     for(ind = 0; ;ind++) 
  3043.         {
  3044.  
  3045.         /* Get the data back */
  3046.         rc = SQLFetch(hstmt);
  3047.         if(rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO)
  3048.             break;
  3049.  
  3050.         for(i = 0; i < cTypes; i++) 
  3051.             { 
  3052.             /* make sure it's original data placed */
  3053.             /* in that field/row location             */
  3054.             pch = qtMakeData(ind, i,&rgFields[i], lpqt->szDataItem);
  3055.  
  3056.             if(!pch)
  3057.                 continue;
  3058.  
  3059.             if(!*pch) {
  3060.                 if(lpd[i].cb != SQL_NULL_DATA)
  3061.                     DISPLAYERROR(szRETDATA, TEXT("should have been NULL"));
  3062.                 continue;
  3063.             }
  3064.             switch(rgFields[i].wSQLType) 
  3065.                 {
  3066.                 /* check the outlen and data    */
  3067.                 /* returned for each type.     */
  3068.                 case SQL_INTEGER:
  3069.                     if(lpd[i].cb != sizeof(SDWORD))
  3070.                         DISPLAYERROR(szRETDATA,szINCORRECTOUTLEN);
  3071.  
  3072.                     lstrcpy(szNum, pch);
  3073.                     nSame = _ttol(szNum) == lpd[i].sdword;
  3074.                     break;
  3075.                 case SQL_SMALLINT:
  3076.                     if(lpd[i].cb != sizeof(SWORD))
  3077.                         DISPLAYERROR(szRETDATA,szINCORRECTOUTLEN);
  3078.  
  3079.                     lstrcpy(szNum, pch);
  3080.                     nSame = _ttoi(szNum) == lpd[i].sword;
  3081.                     break;
  3082.  
  3083.                 case SQL_FLOAT:
  3084.                 case SQL_DOUBLE:
  3085.                     if(lpd[i].cb != sizeof(SDOUBLE))
  3086.                         DISPLAYERROR(szRETDATA,szINCORRECTOUTLEN);
  3087.  
  3088.                     lstrcpy(szNum, pch);
  3089.                     Num=_tcstod(szNum, &stopstring);
  3090.                     nSame = Num - lpd[i].sdouble < 0.001 && Num - lpd[i].sdouble > -0.001;
  3091.  
  3092.                     break;
  3093.  
  3094.                 case SQL_REAL:
  3095.                     if(lpd[i].cb != sizeof(SFLOAT))
  3096.                         DISPLAYERROR(szRETDATA,szINCORRECTOUTLEN);
  3097.  
  3098.                     lstrcpy(szNum, pch);
  3099.                     Num=_tcstod(szNum, &stopstring);
  3100.  
  3101.                     nSame = Num - lpd[i].sfloat < 0.001 && Num - lpd[i].sfloat > -0.001;
  3102.                     break;
  3103.  
  3104.                 case SQL_TINYINT:
  3105.                     if(lpd[i].cb != sizeof(TCHAR))
  3106.                         DISPLAYERROR(szRETDATA,szINCORRECTOUTLEN);
  3107.  
  3108.                     lstrcpy(szNum, pch);
  3109.                     nSame = (TCHAR)_ttoi(szNum) == (TCHAR)lpd[i].data[0];
  3110.                     break;
  3111.  
  3112.                 case SQL_DECIMAL:
  3113.                 case SQL_NUMERIC:
  3114.                     if(lpd[i].cb > MAX_STRING_SIZE)
  3115.                         DISPLAYERROR(szRETDATA,szINCORRECTOUTLEN);
  3116.  
  3117.                     if(lpd[i].cb > lstrlen(lpd[i].data))
  3118.                         DISPLAYERROR(szRETDATA,szINCORRECTOUTLEN);
  3119.  
  3120.                     {
  3121.                     TCHAR szNum2[MAX_NUM_BUFFER];
  3122.  
  3123.                     lstrcpy(szNum, pch);
  3124.                     lstrcpy(szNum2, pch);
  3125.                     Num=_tcstod(szNum, &stopstring);
  3126.                     Num2=_tcstod(szNum2, &stopstring);
  3127.  
  3128.                     nSame = Num - Num2 < 0.001 &&    Num - Num2 > -0.001;
  3129.                     }
  3130.  
  3131.                     break;
  3132.  
  3133.  
  3134.                 case SQL_VARCHAR:
  3135.                 case SQL_LONGVARCHAR:
  3136.                     if(lpd[i].cb > MAX_STRING_SIZE)
  3137.                         DISPLAYERROR(szRETDATA,szINCORRECTOUTLEN);
  3138.  
  3139.                     if(lpd[i].cb > lstrlen(lpd[i].data))
  3140.                         DISPLAYERROR(szRETDATA,szINCORRECTOUTLEN);
  3141.  
  3142.                     nSame = !!_tcsstr(lpd[i].data, pch);
  3143.  
  3144.                     break;
  3145.  
  3146.                 case SQL_VARBINARY:
  3147.                 case SQL_LONGVARBINARY:
  3148.                     if(lpd[i].cb > MAX_STRING_SIZE)
  3149.                         DISPLAYERROR(szRETDATA,szINCORRECTOUTLEN);
  3150.  
  3151.                     if(lpd[i].cb  * 2 != lstrlen(pch))
  3152.                         DISPLAYERROR(szRETDATA,szINCORRECTOUTLEN);
  3153.  
  3154.                     nSame = TRUE; /* not checking returned data for binary */
  3155.  
  3156.                     break;
  3157.  
  3158.                 case SQL_CHAR:
  3159.                     if(lpd[i].cb > MAX_STRING_SIZE && rc == SQL_SUCCESS)
  3160.                         DISPLAYERROR(szRETDATA,TEXT("incorrect return code for outlen"));
  3161.  
  3162.                     if(lpd[i].cb != rgFields[i].precision && rc == SQL_SUCCESS)
  3163.                         DISPLAYERROR(szRETDATA,szINCORRECTOUTLEN);
  3164.  
  3165.                     nSame = !_tcsnccmp(lpd[i].data, pch, lstrlen(pch));
  3166.  
  3167.                     break;
  3168.                 case SQL_BINARY:
  3169.                 default:
  3170.                     if(lpd[i].cb > MAX_STRING_SIZE && rc == SQL_SUCCESS)
  3171.                         DISPLAYERROR(szRETDATA,szINCORRECTOUTLEN);
  3172.                     nSame = TRUE; /* not checking returned data for binary */
  3173.                 }
  3174.  
  3175.         if(!nSame)
  3176.             DISPLAYERROR(szRETDATA, TEXT("invalid data"));
  3177.         }
  3178.     }
  3179.  
  3180.     RETCHECK(SQL_NO_DATA_FOUND, rc, szSQLFETCH);
  3181.  
  3182.     if(ind != cTypes + 1)
  3183.         DISPLAYERROR(szSQLFETCH, TEXT("Incorrect number of result rows"));
  3184.  
  3185.     rc = SQLFreeStmt(hstmt, SQL_CLOSE);
  3186.     RETCHECK(SQL_SUCCESS, rc, szSQLFREESTMT);
  3187.  
  3188.     rc = SQLFreeStmt(hstmt, SQL_UNBIND);
  3189.     RETCHECK(SQL_SUCCESS, rc, szSQLFREESTMT);
  3190.  
  3191.     rc = SQLFreeStmt(hstmt, SQL_RESET_PARAMS);
  3192.     RETCHECK(SQL_SUCCESS, rc, szSQLFREESTMT);
  3193.  
  3194. } // RetrieveData()
  3195.  
  3196.  
  3197.                                       
  3198. //-----------------------------------------------------------------------
  3199. //      Function:               TestData
  3200. //-----------------------------------------------------------------------
  3201.  
  3202. void  PASCAL TestData(QTSTRUCT  *lpqt,FIELDINFO  *rgFields,
  3203.     UWORD cTypes,DSTRUCT  *lpd)
  3204. {
  3205.  
  3206.     /* bind all fields to a variable of the correct type for retreiving data */
  3207.     if (!BindAllColumns(lpqt,rgFields,cTypes,lpd))
  3208.         return;
  3209.  
  3210.     SelectFromTable(lpqt);
  3211.  
  3212.     RetrieveData(lpqt,rgFields,cTypes,lpd);
  3213.  
  3214. } // TestData()
  3215.  
  3216.  
  3217. //-----------------------------------------------------------------------
  3218. //      Function:               CreateParamQuery
  3219. //-----------------------------------------------------------------------
  3220.  
  3221. void  PASCAL CreateParamQuery(QTSTRUCT *lpqt, FIELDINFO *rgFields,UWORD cTypes)
  3222. {    
  3223.     RETCODE    rc=SQL_SUCCESS;
  3224.     UWORD        i;
  3225.     LPTSTR    pch=NULL;
  3226.     TCHAR        szQuery[MAX_QUERY_SIZE];
  3227.     SDWORD    sdw = SQL_DATA_AT_EXEC;
  3228.     UWORD        w,
  3229.                 ind;
  3230.  
  3231.  
  3232.     wsprintf(szQuery,TEXT("select %s from %s where "), lpqt->szColNames,lpqt->szTableName);
  3233.  
  3234.  
  3235.     for(i = 0, w = 0,ind=0; i < cTypes; i++) 
  3236.         {
  3237.         pch = qtMakeData(ind, i,&rgFields[i], lpqt->szDataItem);
  3238.  
  3239.         if ((rgFields[i].fSearchable == SQL_SEARCHABLE ||
  3240.             rgFields[i].fSearchable == SQL_ALL_EXCEPT_LIKE) &&
  3241.             pch && *pch) 
  3242.         {
  3243.             w++;
  3244.  
  3245.             switch(rgFields[i].wSQLType)
  3246.             {
  3247.                 case SQL_REAL:
  3248.                 case SQL_FLOAT:
  3249.                 case SQL_DOUBLE:
  3250.                     wsprintf(&szQuery[lstrlen(szQuery)],TEXT("%s < ? + 1 and "),
  3251.                         rgFields[i].szFieldName);
  3252.                     break;
  3253.                 default:
  3254.                     wsprintf(&szQuery[lstrlen(szQuery)],TEXT("%s = ? and "),
  3255.                         rgFields[i].szFieldName);
  3256.             }
  3257.  
  3258.             if(!fBindParameter)
  3259.             {
  3260.                 rc = SQLSetParam(hstmt, w,
  3261.                     SQL_C_TCHAR, rgFields[i].wSQLType,
  3262.                     rgFields[i].precision, rgFields[i].scale,
  3263.                     (LPTSTR)(UDWORD)i, &sdw);
  3264.                 RETCHECK(SQL_SUCCESS, rc,szSQLSETPARAM);
  3265.             }
  3266.             else
  3267.             {
  3268.                 rc = SQLBindParameter(hstmt, w, SQL_PARAM_INPUT,
  3269.                     SQL_C_TCHAR, rgFields[i].wSQLType,
  3270.                     rgFields[i].precision, rgFields[i].scale,
  3271.                     (LPTSTR)((UDWORD)i+BIND_PARM_OFFSET), 0, &sdw);
  3272.                 RETCHECK(SQL_SUCCESS, rc,szSQLBINDPARAMETER);
  3273.             }
  3274.  
  3275.             ind++;
  3276.         }
  3277.     }
  3278.  
  3279.     if (_tcsstr(szQuery,TEXT("and")))
  3280.     {
  3281.         /* remove the final "and " */
  3282.         szQuery[lstrlen(szQuery) - 5] = TEXT('\0');
  3283.     }
  3284.  
  3285.     lstrcpy(lpqt->szParamQuery, szQuery);
  3286.  
  3287. }
  3288.  
  3289. //-----------------------------------------------------------------------
  3290. //      Function:               TestSearchedQuery
  3291. //-----------------------------------------------------------------------
  3292.  
  3293. void  PASCAL TestSearchedQuery(QTSTRUCT  *lpqt,FIELDINFO  *rgFields,
  3294.     UWORD cTypes,DSTRUCT  *lpd,BOOL fBindParameter)
  3295. {
  3296.     RETCODE    rc=SQL_SUCCESS;
  3297.     UWORD        i;
  3298.     LPTSTR        pch=NULL;
  3299.     SDWORD    sdw;
  3300.     UWORD        w;
  3301.     UDWORD    udw;
  3302.     UWORD        ind;
  3303.  
  3304.  
  3305.     wsprintf(lpqt->sz, TEXT("select %s from %s where "), lpqt->szColNames,
  3306.         lpqt->szTableName);
  3307.  
  3308.     sdw = SQL_DATA_AT_EXEC;
  3309.  
  3310.     for(i = 0, w = 0,ind=0; i < cTypes; i++) 
  3311.         {
  3312.         pch = qtMakeData(ind, i,&rgFields[i], lpqt->szDataItem);
  3313.  
  3314.         if ((rgFields[i].fSearchable == SQL_SEARCHABLE ||
  3315.             rgFields[i].fSearchable == SQL_ALL_EXCEPT_LIKE) &&
  3316.             pch && *pch) {
  3317.             w++;
  3318.             switch(rgFields[i].wSQLType) {
  3319.                 case SQL_REAL:
  3320.                 case SQL_FLOAT:
  3321.                 case SQL_DOUBLE:
  3322.                     wsprintf(&lpqt->sz[lstrlen(lpqt->sz)], TEXT("%s < ? + 1 and "),
  3323.                         rgFields[i].szFieldName);
  3324.                     break;
  3325.                 default:
  3326.                     wsprintf(&lpqt->sz[lstrlen(lpqt->sz)], TEXT("%s = ? and "),
  3327.                     rgFields[i].szFieldName);
  3328.             }
  3329.  
  3330.             if(!fBindParameter){
  3331.                 rc = SQLSetParam(hstmt, w,
  3332.                     SQL_C_TCHAR, rgFields[i].wSQLType,
  3333.                     rgFields[i].precision, rgFields[i].scale,
  3334.                     (LPTSTR)(UDWORD)i, &sdw);
  3335.                 RETCHECK(SQL_SUCCESS, rc, szSQLSETPARAM);
  3336.                 }
  3337.             else{
  3338.                 rc = SQLBindParameter(hstmt, w, SQL_PARAM_INPUT,
  3339.                     SQL_C_TCHAR, rgFields[i].wSQLType,
  3340.                     rgFields[i].precision, rgFields[i].scale,
  3341.                     (LPTSTR)((UDWORD)i+BIND_PARM_OFFSET), 0, &sdw);
  3342.                 RETCHECK(SQL_SUCCESS, rc, szSQLBINDPARAMETER);
  3343.                 }
  3344.  
  3345.             ind++;
  3346.         }
  3347.     }
  3348.     /* remove the final "and " */
  3349.     lpqt->sz[lstrlen(lpqt->sz) - 5] = TEXT('\0');
  3350.     lstrcpy(lpqt->szParamQuery, lpqt->sz);
  3351.  
  3352.     rc = SQLPrepare(hstmt, lpqt->sz, SQL_NTS);
  3353.     RETCHECK(SQL_SUCCESS, rc, szSQLPREPARE);
  3354.  
  3355.     rc = SQLExecute(hstmt);
  3356.     RETCHECK(SQL_NEED_DATA, rc, szSQLEXECUTE);
  3357.  
  3358.     udw = cTypes;
  3359.  
  3360.     for(i = 0; ; i++) 
  3361.         {
  3362.         rc = SQLParamData(hstmt, (PTR *)&udw);
  3363.         if(rc != SQL_NEED_DATA)
  3364.             break;
  3365.  
  3366.         if(udw-BIND_PARM_OFFSET < cTypes)
  3367.             pch = qtMakeData(cTypes, i,&rgFields[udw-BIND_PARM_OFFSET], lpqt->szDataItem);
  3368.         else
  3369.             DISPLAYERROR(szSQLPARAMDATA, TEXT("invalid rgbValue"));
  3370.  
  3371.         if(*pch) 
  3372.             {
  3373.             udw = lstrlen(pch);
  3374.             rc = SQLPutData(hstmt, pch, (SDWORD)lstrlen(pch));
  3375.             RETCHECK(SQL_SUCCESS, rc, szSQLPUTDATA);
  3376.             } 
  3377.         else
  3378.             {
  3379.             rc = SQLPutData(hstmt, (LPTSTR)IGNORED, SQL_NULL_DATA);
  3380.             RETCHECK(SQL_SUCCESS, rc, szSQLPUTDATA);
  3381.             }
  3382.         }
  3383.  
  3384.     RETCHECK(SQL_SUCCESS, rc, szSQLPARAMDATA);
  3385.  
  3386.     for(i = 0;; i++) 
  3387.         {
  3388.         rc = SQLFetch(hstmt);
  3389.  
  3390.         if(rc != SQL_SUCCESS)
  3391.             break;
  3392.         }
  3393.  
  3394.     RETCHECK(SQL_NO_DATA_FOUND, rc, szSQLFETCH);
  3395.  
  3396.     /* should have gotten 1 row back */
  3397.  
  3398.     if(i != 1)
  3399.         DISPLAYERROR(TEXT("Param/PutData"), TEXT("incorrect number of rows returned"));
  3400.  
  3401.     FreeStmt(SQL_CLOSE);
  3402.  
  3403. } //TestSearchedQuery()
  3404.  
  3405.  
  3406.  
  3407. //-----------------------------------------------------------------------
  3408. //      Function:               TestLargeQuery
  3409. //-----------------------------------------------------------------------
  3410.  
  3411. void  PASCAL TestLargeQuery(QTSTRUCT  *lpqt,FIELDINFO  *rgFields,
  3412.     UWORD cTypes,DSTRUCT  *lpd)
  3413. {
  3414.     RETCODE    rc=SQL_SUCCESS;
  3415.     UWORD        ind=0,
  3416.                 i;
  3417.     LPTSTR    pch=NULL;
  3418.     TCHAR        szQuery[2048];
  3419.  
  3420.  
  3421.     /* > 1K query */
  3422.     wsprintf(szQuery,TEXT("select %s from %s where "), lpqt->szColNames,
  3423.         lpqt->szTableName);
  3424.  
  3425.     for(i = 0; i < cTypes; i++) 
  3426.         {
  3427.         if (rgFields[i].fSearchable == SQL_SEARCHABLE ||
  3428.             rgFields[i].fSearchable == SQL_ALL_EXCEPT_LIKE)
  3429.             break;
  3430.         }
  3431.  
  3432.     pch = qtMakeData(cTypes, 1, &rgFields[i], lpqt->szDataItem);
  3433.     while(lstrlen(szQuery) < 1024L) 
  3434.         {
  3435.         int li=lstrlen(szQuery);
  3436.         switch(rgFields[i].wSQLType) 
  3437.             {
  3438.             case SQL_REAL:
  3439.             case SQL_FLOAT:
  3440.             case SQL_DOUBLE:
  3441.                 wsprintf(&szQuery[lstrlen(szQuery)],TEXT("%s < %s + 1 and "),
  3442.                     rgFields[i].szFieldName, pch);
  3443.                 break;
  3444.             default:
  3445.                 wsprintf(&szQuery[lstrlen(szQuery)],TEXT("%s = %s%s%s and "),
  3446.                 rgFields[i].szFieldName, rgFields[i].szPrefix, pch, rgFields[i].szSuffix);
  3447.                 break;
  3448.             }
  3449.         }
  3450.  
  3451.     /* remove the final "and " */
  3452.     szQuery[lstrlen(szQuery) - 5] = TEXT('\0');
  3453.                 
  3454.     rc = SQLExecDirect(hstmt, szQuery, SQL_NTS);
  3455.     RETCHECK(SQL_SUCCESS, rc,szSQLEXECDIRECT);
  3456.  
  3457.     if (RC_SUCCESSFUL(rc))
  3458.         {
  3459.         for(i = 0;; i++) 
  3460.             {
  3461.             rc = SQLFetch(hstmt);
  3462.  
  3463.             if(rc != SQL_SUCCESS)
  3464.                 break;
  3465.             }
  3466.  
  3467.         RETCHECK(SQL_NO_DATA_FOUND, rc,szSQLFETCH);
  3468.  
  3469.         /* should have gotten at least 1 row back */
  3470.  
  3471.         if(i < 1)
  3472.             DISPLAYERROR(TEXT("> 1K query"),TEXT("incorrect number of rows returned"));
  3473.  
  3474.         }
  3475.             
  3476.     /* SQLFreeStmt with SQL_CLOSE to re-use the hstmt */
  3477.  
  3478.     FreeStmt(SQL_CLOSE);
  3479.  
  3480. } //TestLargeQuery()
  3481.  
  3482.  
  3483.  
  3484. //-----------------------------------------------------------------------
  3485. //      Function:               TestSQLTables
  3486. //-----------------------------------------------------------------------
  3487.  
  3488. void  PASCAL TestSQLTables(QTSTRUCT  *lpqt)
  3489. {
  3490.     RETCODE    rc=SQL_SUCCESS;
  3491.     BOOL        fFoundTable=FALSE;    
  3492.     UWORD        i;
  3493.  
  3494.     /* this call may return many tables, as  */
  3495.     /* long as the one created earlier shows */
  3496.     /* up it will pass. */
  3497.         
  3498.     rc = SQLTables(hstmt, NULL, 0, NULL, 0,TEXT("q%"),SQL_NTS,TEXT("'TABLE'"), SQL_NTS); 
  3499.  
  3500.     RETCHECK(SQL_SUCCESS, rc,szSQLTABLES);
  3501.  
  3502.     for(i = 0;; i++) 
  3503.         {
  3504.         rc = SQLFetch(hstmt);
  3505.         if(rc != SQL_SUCCESS)
  3506.             break;
  3507.  
  3508.         /* column 3 is tablename */
  3509.         rc = SQLGetData(hstmt, 3, SQL_C_TCHAR, lpqt->sz, MAX_STRING_SIZE, NULL);
  3510.         RETCHECK(SQL_SUCCESS, rc,szSQLGETDATA); /* should not overflow
  3511.             and return SQL_SUCCESS_WITH_INFO because the buffer is larger than the
  3512.             table name */
  3513.         fFoundTable += 0 == lstrcmpi(lpqt->sz, lpqt->szTableName);
  3514.         }
  3515.  
  3516.     RETCHECK(SQL_NO_DATA_FOUND, rc,szSQLFETCH);
  3517.  
  3518.     if(1 != fFoundTable) {
  3519.         DISPLAYERROR(szSQLTABLES,TEXT("table not found"));
  3520.     }
  3521.  
  3522.     FreeStmt(SQL_CLOSE);
  3523.  
  3524. } //TestSQLTables()
  3525.  
  3526.  
  3527. //-----------------------------------------------------------------------
  3528. //      Function:               TestSQLSpecialCols
  3529. //-----------------------------------------------------------------------
  3530.  
  3531. void  PASCAL TestSQLSpecialCols(QTSTRUCT  *lpqt)
  3532. {
  3533.     RETCODE    rc=SQL_SUCCESS;
  3534.     UWORD        i;
  3535.  
  3536.     rc = SQLSpecialColumns(hstmt, SQL_BEST_ROWID, NULL, 0, NULL, 0,
  3537.         lpqt->szTableName, (SWORD)(lstrlen(lpqt->szTableName)), SQL_SCOPE_TRANSACTION,
  3538.         SQL_NULLABLE);
  3539.     RETCHECK(SQL_SUCCESS, rc,szSQLSPECIALCOLUMNS);
  3540.  
  3541.     for(i = 0;; i++)
  3542.         {
  3543.         rc = SQLFetch(hstmt);
  3544.         if(rc != SQL_SUCCESS)
  3545.             break;
  3546.         }
  3547.  
  3548.     RETCHECK(SQL_NO_DATA_FOUND, rc,szSQLFETCH);
  3549.  
  3550.     FreeStmt(SQL_CLOSE);
  3551.  
  3552. } //TestSQLSpecialCols()
  3553.  
  3554.  
  3555.  
  3556.  
  3557. //-----------------------------------------------------------------------
  3558. //      Function:               VerifyIndex
  3559. //-----------------------------------------------------------------------
  3560.  
  3561. void  PASCAL VerifyIndex(QTSTRUCT  *lpqt,UWORD fIndex)
  3562. {
  3563.     RETCODE    rc=SQL_SUCCESS;
  3564.     BOOL        fFoundTable=FALSE;
  3565.     UWORD        i;
  3566.     SDWORD    sdw;
  3567.  
  3568.     rc = SQLStatistics(hstmt, NULL, 0, NULL, 0, lpqt->szTableName,
  3569.     SQL_NTS, SQL_INDEX_ALL, SQL_ENSURE);
  3570.     RETCHECK(SQL_SUCCESS, rc,TEXT("SQLStatistics"));
  3571.  
  3572.     fFoundTable = 0;
  3573.     for(i = 0;; i++) 
  3574.         {
  3575.         rc = SQLFetch(hstmt);
  3576.         if(rc != SQL_SUCCESS)
  3577.             break;
  3578.  
  3579.         rc = SQLGetData(hstmt, 3, SQL_C_TCHAR, lpqt->sz, MAX_STRING_SIZE,
  3580.             &sdw);
  3581.         RETCHECK(SQL_SUCCESS, rc,szSQLGETDATA);
  3582.         if (lstrcmpi(lpqt->sz, lpqt->szTableName) == 0)
  3583.             {
  3584.             rc = SQLGetData(hstmt, 6, SQL_C_TCHAR, lpqt->sz, MAX_STRING_SIZE,
  3585.                 &sdw);
  3586.             RETCHECK(SQL_SUCCESS, rc,szSQLGETDATA);
  3587.             fFoundTable += 0 == lstrcmpi(lpqt->sz, lpqt->szDataItem);
  3588.             }
  3589.         }
  3590.  
  3591.     RETCHECK(SQL_NO_DATA_FOUND, rc,szSQLFETCH);
  3592.  
  3593.     if(1 != fFoundTable && fIndex)
  3594.         DISPLAYERROR(TEXT("SQLStatistics"),TEXT("index not returned"));
  3595.  
  3596.     /* one row represents original table, the */
  3597.     /* other represents the index                 */
  3598.     if(i > 2 || i < 1) 
  3599.         DISPLAYERROR(TEXT("SQLStatistics"),TEXT("too many rows"));
  3600.  
  3601.     FreeStmt(SQL_CLOSE);
  3602.  
  3603. } //VerifyIndex()
  3604.  
  3605. //-----------------------------------------------------------------------
  3606. //      Function:               TestSQLStatistics
  3607. //-----------------------------------------------------------------------
  3608.  
  3609. BOOL  PASCAL TestSQLStatistics(QTSTRUCT  *lpqt,FIELDINFO  *rgFields,
  3610.     UWORD cTypes,DSTRUCT  *lpd,UWORD fIndex)
  3611. {
  3612.     RETCODE    rc=SQL_SUCCESS;
  3613.     UWORD        i;
  3614.  
  3615.     lstrcpy(lpqt->szDataItem, lpqt->szTableName);
  3616.     lpqt->szDataItem[0] = TEXT('i');
  3617.     for(i = 1; i < cTypes; i++)
  3618.         if(rgFields[i].wSQLType == SQL_INTEGER ||
  3619.             rgFields[i].wSQLType == SQL_SMALLINT)
  3620.             break;
  3621.     if(i == cTypes)
  3622.         i = 0;
  3623.  
  3624.     lstrcpy(lpqt->buf, rgFields[i].szFieldName);
  3625.     wsprintf(lpqt->sz,TEXT("create unique index %s on %s (%s)"),
  3626.         lpqt->szDataItem, lpqt->szTableName, lpqt->buf);
  3627.  
  3628.     rc = SQLExecDirect(hstmt, lpqt->sz, SQL_NTS);
  3629.     if(fIndex < 1)
  3630.         /* if this is minimal grammar, don't count on indexes being available */
  3631.         fIndex = rc == SQL_SUCCESS;
  3632.     else
  3633.         RETCHECK(SQL_SUCCESS, rc,szSQLEXECDIRECT);
  3634.  
  3635.     VerifyIndex(lpqt,fIndex);
  3636.  
  3637.     return(fIndex);
  3638.  
  3639. } //TestSQLStatistics()
  3640.  
  3641.  
  3642. //-----------------------------------------------------------------------
  3643. //      Function:               TestLikeQuery
  3644. //-----------------------------------------------------------------------
  3645.  
  3646. void  PASCAL TestLikeQuery(QTSTRUCT  *lpqt,FIELDINFO  *rgFields,
  3647.     UWORD cTypes,DSTRUCT  *lpd)
  3648. {
  3649.     RETCODE    rc=SQL_SUCCESS;
  3650.     UWORD    i;
  3651.     SDWORD    cbValue=0;
  3652.  
  3653.     for(i = 0; i < cTypes; i++) 
  3654.         {
  3655.         if(rgFields[i].fSearchable == SQL_LIKE_ONLY ||
  3656.             rgFields[i].fSearchable == SQL_SEARCHABLE) 
  3657.             {
  3658.             lstrcpy(lpqt->buf, rgFields[i].szFieldName);
  3659.             break;
  3660.             }
  3661.     }
  3662.  
  3663.     if(i < cTypes) 
  3664.         {
  3665.  
  3666.         /* execute a query using like.  This query should return all records */
  3667.         /* this query should return all rows in the table                             */
  3668.  
  3669.         wsprintf(lpqt->sz,TEXT("select * from %s where %s not like 'a'"), lpqt->szTableName,
  3670.             lpqt->buf, lpqt->buf);
  3671.         rc = SQLExecDirect(hstmt, lpqt->sz, SQL_NTS);
  3672.         RETCHECK(SQL_SUCCESS, rc,szSQLEXECDIRECT);
  3673.  
  3674.         for(i = 0;; i++) 
  3675.             {
  3676.             rc = SQLFetch(hstmt);
  3677.             if(rc != SQL_SUCCESS)
  3678.                 break;
  3679.  
  3680.             rc = SQLGetData(hstmt, 1, SQL_C_TCHAR, lpqt->sz, MAX_STRING_SIZE,
  3681.                 &cbValue);
  3682.             if(rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO)
  3683.                 RETCHECK(SQL_SUCCESS, rc,szSQLGETDATA);
  3684.             }
  3685.  
  3686.         RETCHECK(SQL_NO_DATA_FOUND, rc,szSQLFETCH);
  3687.  
  3688.         if(i != cTypes)
  3689.             DISPLAYERROR(TEXT("'LIKE' query"),TEXT("incorrect number of result rows"));
  3690.  
  3691.         }
  3692.  
  3693.     FreeStmt(SQL_CLOSE);
  3694.  
  3695. } //TestLikeQuery()
  3696.  
  3697.  
  3698. //-----------------------------------------------------------------------
  3699. //      Function:               TestLikeQuery
  3700. //-----------------------------------------------------------------------
  3701.  
  3702. void  PASCAL TestOJCap(QTSTRUCT  *lpqt)
  3703. {
  3704.     RETCODE    rc=SQL_SUCCESS;
  3705.     UDWORD    udw;
  3706.  
  3707.     rc = SQLGetInfo(hdbc, (UWORD)SQL_OJ_CAPABILITIES, &udw, (SWORD)(sizeof(udw)), NULL);
  3708.     if(RETCHECK(SQL_SUCCESS, rc,szSQLGETINFO))
  3709.     {
  3710.         udw &= ~(SQL_OJ_LEFT | SQL_OJ_RIGHT | SQL_OJ_FULL | SQL_OJ_NESTED    |
  3711.                     SQL_OJ_NOT_ORDERED | SQL_OJ_INNER | SQL_OJ_ALL_COMPARISON_OPS);
  3712.         if(udw)
  3713.         {
  3714.             wsprintf(lpqt->buf,TEXT("Undefined flags return from SQLGetInfo(...SQL_OJ_CAPABILITIES...) = %lX"), udw);
  3715.             DISPLAYERROR(szSQLGETINFO, lpqt->buf);
  3716.         }
  3717.     }
  3718.  
  3719.     rc = SQLGetInfo(hdbc, SQL_OUTER_JOINS, lpqt->buf, MAX_STRING_SIZE, NULL);
  3720.     if(RETCHECK(SQL_SUCCESS, rc,szSQLGETINFO)){
  3721.         *lpqt->buf = toupper(*lpqt->buf);
  3722.         if((!_tcsnccmp(lpqt->buf,TEXT("Y"), 1)) && (!_tcsnccmp(lpqt->buf,TEXT("N"), 1)))
  3723.             DISPLAYERROR(szSQLGETINFO,TEXT("Driver returned an invalid value for SQLGetInfo(...SQL_OUTER_JOINS...).  The only valid values are \"Y\" and \"N\"."));
  3724.         }
  3725.  
  3726. } //TestOJCap()
  3727.  
  3728.  
  3729. /*-----------------------------------------------------------------------
  3730.  *      Function:               TestExtendedFetch
  3731.  *-----------------------------------------------------------------------*/
  3732.  
  3733. void  PASCAL TestExtendedFetch(QTSTRUCT  *lpqt, FIELDINFO  *rgFields, UWORD cTypes)
  3734. {
  3735.     RETCODE    rc=SQL_SUCCESS;
  3736.     WORD        fLevel2 = FALSE;
  3737.     DWORD        dwLen=0;
  3738.     SWORD        fSqlType;
  3739.     SDWORD    cbValue=0;
  3740.     UWORD        iTableCol,row,iCol,uwRowSetSize;
  3741.     TCHAR        szQuery[MAX_STRING_SIZE], szColName[SMALLBUFF];
  3742.     TCHAR*    rgbValue;
  3743.     DSTRUCT*    rgData;
  3744.     DSTRUCT*    pDataBuf;
  3745.     BOOL        fCol0Bound=TRUE;
  3746.  
  3747.     uwRowSetSize=5; /* Cinco seems like a good rowset size */
  3748.  
  3749.     /* Only col which might not be bound but might not be AutoUpdateable is col 0 */
  3750.     if(!qtMakeData(0, 0, &rgFields[0], szQuery))
  3751.         fCol0Bound = FALSE;
  3752.  
  3753.     SelectFromTable(lpqt);
  3754.  
  3755.     rc = SQLBindCol(hstmt, 1, SQL_C_BINARY, lpqt->sz, MAX_BIND_ARRAY_ELEMENT,
  3756.         &cbValue);
  3757.     RETCHECK(SQL_SUCCESS, rc,szSQLBINDCOL);
  3758.  
  3759.     if (!Supported(SQL_API_SQLEXTENDEDFETCH)) 
  3760.     {
  3761.         rc = SQLExtendedFetch(hstmt, SQL_FETCH_FIRST, IGNORED, NULL, NULL);
  3762.         if(!FindError(SQL_HANDLE_STMT,szIM001))
  3763.             DISPLAYERROR(szSQLEXTENDEDFETCH, szNotSupported);
  3764.         RETCHECK(SQL_ERROR, rc,szSQLEXTENDEDFETCH);
  3765.  
  3766.         FreeStmt(SQL_CLOSE);
  3767.         return;
  3768.     } 
  3769.  
  3770.     rc = SQLGetStmtOption(hstmt,SQL_CURSOR_TYPE,&dwLen);
  3771.     RETCHECK(SQL_SUCCESS, rc,szSQLGETSTMTOPTION);
  3772.  
  3773.     if(dwLen != SQL_CURSOR_FORWARD_ONLY)
  3774.         {
  3775.         rc = SQLExtendedFetch(hstmt, SQL_FETCH_FIRST, IGNORED, NULL, NULL);
  3776.         RETCHECK(SQL_SUCCESS, rc,szSQLEXTENDEDFETCH);
  3777.         }
  3778.     else
  3779.         {
  3780.         rc = SQLExtendedFetch(hstmt, SQL_FETCH_FIRST, IGNORED, NULL, NULL);
  3781.         RETCHECK(SQL_ERROR, rc,szSQLEXTENDEDFETCH);
  3782.         }
  3783.  
  3784.     rc = SQLFreeStmt(hstmt, SQL_CLOSE);
  3785.     RETCHECK(SQL_SUCCESS, rc, szSQLFREESTMT);
  3786.  
  3787.     rc = SQLFreeStmt(hstmt, SQL_UNBIND);
  3788.     RETCHECK(SQL_SUCCESS, rc, szSQLFREESTMT);
  3789.  
  3790.     rc = SQLFreeStmt(hstmt, SQL_RESET_PARAMS);
  3791.     RETCHECK(SQL_SUCCESS, rc, szSQLFREESTMT);
  3792.  
  3793.     /* Allocate an area for ExtendedFetch to take place */
  3794.     if (!(rgData = AllocateMemory(sizeof(DSTRUCT)*cTypes*uwRowSetSize))){
  3795.         DISPLAYERROR(szSQLEXTENDEDFETCH,TEXT("Insufficient Memory Available"));
  3796.         return;    
  3797.     }
  3798.  
  3799.     /* Allocate an area for test data */
  3800.     if (!(rgbValue = AllocateMemory(MAX_STRING_SIZE))){
  3801.         DISPLAYERROR(szSQLEXTENDEDFETCH,TEXT("Insufficient Memory Available"));
  3802.         ReleaseMemory(rgData);
  3803.         return;
  3804.     }
  3805.  
  3806.     /* Get column for "order by" clause: */
  3807.     wsprintf(szQuery,TEXT("select %s from %s"),lpqt->szColNames, lpqt->szTableName);
  3808.     rc = SQLExecDirect(hstmt, szQuery, SQL_NTS);
  3809.     if((SQL_SUCCESS!=rc) && (SQL_SUCCESS_WITH_INFO!=rc)){
  3810.         RETCHECK(SQL_SUCCESS_WITH_INFO, rc, szSQLEXECDIRECT);
  3811.         goto abortxfetch;
  3812.     }
  3813.     iCol=0;
  3814.     do    {
  3815.         iCol++;
  3816.         rc=SQLDescribeCol(hstmt, iCol, szColName, (SMALLBUFF*sizeof(TCHAR)), 
  3817.             NULL, &fSqlType, NULL, NULL, NULL);
  3818.         RETCHECK(SQL_SUCCESS, rc,szSQLDESCRIBECOL);
  3819.     } while(fSqlType!=SQL_CHAR && iCol<=cTypes);
  3820.  
  3821.     FreeStmt(SQL_CLOSE);
  3822.     if(iCol>cTypes){
  3823.         DISPLAYERROR(szSQLEXTENDEDFETCH, TEXT("\t\t\tSelect-order by  Failed"));
  3824.         goto abortxfetch;
  3825.     }
  3826.  
  3827.     /* Set rowset size and set to row-wise binding:  */
  3828.     rc = SQLSetStmtOption(hstmt, SQL_ROWSET_SIZE, (UDWORD)uwRowSetSize);
  3829.     if (SQL_SUCCESS != rc){
  3830.         DISPLAYERROR(TEXT("ExtendedFetch...SQLSetStmtOption(Rowset_Size)"),
  3831.             TEXT("SQLSetStmtOption Failed"));
  3832.         GetErrors(henv, hdbc,hstmt);
  3833.     }    
  3834.     rc = SQLSetStmtOption(hstmt, SQL_BIND_TYPE, (sizeof(DSTRUCT)*cTypes));
  3835.     if (SQL_SUCCESS != rc){
  3836.         DISPLAYERROR(TEXT("ExtendedFetch...SQLSetStmtOption(Bind_Type)"),
  3837.             TEXT("SQLSetStmtOption Failed"));
  3838.         GetErrors(henv, hdbc,hstmt);
  3839.     }
  3840.  
  3841.     if(SQL_SUCCESS != SelectFromTableFetch(lpqt, szColName)){
  3842.         DISPLAYERROR(szSQLEXTENDEDFETCH, TEXT("\t\t\tSelect-order by  Failed"));
  3843.         goto abortxfetch;
  3844.     }
  3845.     if (!BindFetchColumns(lpqt, rgFields, cTypes, rgData)){
  3846.         DISPLAYERROR(szSQLEXTENDEDFETCH, szSQLBINDCOL);
  3847.         goto abortxfetch;
  3848.     }
  3849.     /* Fetch into allocated area rowset to be tested */
  3850.     rc = SQLExtendedFetch(hstmt, SQL_FETCH_NEXT, 1, NULL, NULL);
  3851.     if (SQL_SUCCESS != rc){
  3852.         RETCHECK(SQL_SUCCESS, rc,szSQLEXTENDEDFETCH);
  3853.         DISPLAYERROR(szSQLEXTENDEDFETCH, TEXT("Fetch Failed"));
  3854.         goto abortxfetch;
  3855.     }
  3856.  
  3857.     rc = SQLFreeStmt(hstmt, SQL_CLOSE);
  3858.     RETCHECK(SQL_SUCCESS, rc, szSQLFREESTMT);
  3859.  
  3860.     rc = SQLFreeStmt(hstmt, SQL_UNBIND);
  3861.     RETCHECK(SQL_SUCCESS, rc, szSQLFREESTMT);
  3862.     
  3863.     /* Set rowset size to "1" to test each row of rowset independently:  */
  3864.     rc = SQLSetStmtOption(hstmt, SQL_ROWSET_SIZE, (UDWORD)(1));
  3865.     if (SQL_SUCCESS != rc){
  3866.         DISPLAYERROR(TEXT("ExtendedFetch...SQLSetStmtOption(Rowset_Size)"),
  3867.             TEXT("SQLSetStmtOption Failed"));
  3868.         GetErrors(henv, hdbc,hstmt);
  3869.     }    
  3870.  
  3871.      /* Check data in all rows of rowset */ 
  3872.     if(SQL_SUCCESS != SelectFromTableFetch(lpqt, szColName)){
  3873.         DISPLAYERROR(szSQLEXTENDEDFETCH, TEXT("\t\t\tSelect-order by  Failed"));
  3874.         goto abortxfetch;
  3875.     }
  3876.  
  3877.     // Need to change this loop if number of rows in table < uwRowSetSize
  3878.     for (row=0; row<uwRowSetSize; row++)
  3879.     {
  3880.         SWORD iResultSetCol=0;
  3881.         if (SQL_SUCCESS != (rc = SQLFetch(hstmt))){
  3882.             RETCHECK(SQL_SUCCESS, rc, szSQLFETCH);
  3883.             DISPLAYERROR(szSQLEXTENDEDFETCH, TEXT("Fetch Failed"));
  3884.             goto abortxfetch;
  3885.         }
  3886.             
  3887.         pDataBuf=rgData+row*cTypes;
  3888.         for (iTableCol=0; iTableCol<cTypes; iTableCol++)
  3889.         {
  3890.             /* Ignore columns which aren't bound as they aren't in the result set */
  3891.             if((!iTableCol && !fCol0Bound) || rgFields[iTableCol].fAutoUpdate)
  3892.                 continue;    
  3893.  
  3894.             iResultSetCol++;
  3895.             rc = SQLGetData(hstmt, iResultSetCol, SQL_C_TCHAR, rgbValue, MAX_STRING_SIZE,
  3896.                  &cbValue);
  3897.             if(rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO)
  3898.                 RETCHECK(SQL_SUCCESS, rc,szSQLGETDATA);
  3899.  
  3900.             if(!CheckDataResults(row, iTableCol, &rgFields[iTableCol], pDataBuf,cbValue,rgbValue))
  3901.             {
  3902.                 wsprintf(lpqt->buf, TEXT("Data Check Failed, Row %d, Table Col %d, DataType %d (%s)"),
  3903.                     row, iTableCol, rgFields[iTableCol].wSQLType, rgFields[iTableCol].szFieldName) ;
  3904.                 szWrite(lpqt->buf,FALSE);
  3905.                 rgbValue[MAX_STRING_SIZE-1]=TEXT('\0');
  3906.                 wsprintf(lpqt->buf, TEXT("Returned Data: (%s)"), rgbValue);
  3907.                 DISPLAYERROR(TEXT("ExtendedFetch"),lpqt->buf);
  3908.                 // goto abortxfetch;
  3909.             }
  3910.         }
  3911.     }
  3912.  
  3913. abortxfetch:
  3914.     FreeStmt(SQL_CLOSE);
  3915.     FreeStmt(SQL_UNBIND);
  3916.     ReleaseMemory(rgData);
  3917.     ReleaseMemory(rgbValue);
  3918. } /* TestExtendedFetch() */
  3919.  
  3920.  
  3921.  
  3922.  
  3923. /*------------------------------------------------------------------------------
  3924.  *      Function:       TestQuickRebind Feature 
  3925.  *      Purpose:        To test this specific feature, not the function(s) using it.
  3926.  *      Synopsis:
  3927.  *      An area large enough for 12 rows of QRDSTRUCTs will be created. There will 
  3928.  * be two rows of the result set per Rowset. Rowset 1 should be duplicated
  3929.  * in rows 0,1 and 3,4, while Rowset 2 should be duplicated in rows 6,7 and 9,10. 
  3930.  * Thus, rows 0 and 3 will contain the first row of the result set, rows 1 and 
  3931.  * 4 will contain the second row of the result set, etc.  Rows 2, 5, 8, and
  3932.  * 11 should have their preset condition of all zeroes remain unchanged.
  3933.  * ----------------------------------------------------------------------------*/
  3934.  
  3935. void  PASCAL TestQuickRebind(QTSTRUCT * lpqt, FIELDINFO  *rgFields, UWORD cTypes,
  3936.                                       DSTRUCT  *lpd)
  3937. {
  3938.     RETCODE    rc;
  3939.     UWORD        row,iCol,iRowset,uwRowsetSize,iRowsetRow,iTableCol;
  3940.     UDWORD    udwRowSize;
  3941.     SWORD        fSqlType;
  3942.     SDWORD    sdwOffset;
  3943.     DSTRUCT    *rgData, *pZeroRow;
  3944.     DSTRUCT    *pCurrentRowData;
  3945.     TCHAR        szQuery[MAX_STRING_SIZE], szColName[SMALLBUFF];
  3946.     SDWORD    cbValue;
  3947.     TCHAR*    rgbValue=NULL;
  3948.     BOOL        fCol0Bound=TRUE;
  3949.                                                                         
  3950.     udwRowSize = sizeof(DSTRUCT)*cTypes;
  3951.                         /* cNumResSetCols is set in BuildInsertStmt() */
  3952.     uwRowsetSize = 5;/* uwRowsetSize rows per Rowset */
  3953.  
  3954.     /* Only col which might not be bound but might not be AutoUpdateable is col 0 */
  3955.     if(!qtMakeData(0, 0, &rgFields[0], szQuery))
  3956.         fCol0Bound = FALSE;
  3957.  
  3958.     /* Allocate an area for QuickRebind to take place */
  3959.     if (!(rgData = AllocateMemory(NUM_QUIKREBIND_ROWSETS*(uwRowsetSize+1)*udwRowSize) )){
  3960.         DISPLAYERROR(szQUICKREBIND,TEXT("\t\t\tInsufficient Memory Available"));
  3961.         return;
  3962.     }
  3963.  
  3964.     /* Allocate an area for a row of zeroes to place between each Rowset. */
  3965.     if (!(pZeroRow = AllocateMemory(udwRowSize) )){
  3966.         DISPLAYERROR(szQUICKREBIND,TEXT("\t\t\tInsufficient Memory Available"));
  3967.         goto abortQuikRebind;
  3968.     }
  3969.  
  3970.     /* Allocate an area for test data */
  3971.     if (!(rgbValue = AllocateMemory(MAX_STRING_SIZE))){
  3972.         DISPLAYERROR(szSQLEXTENDEDFETCH,TEXT("Insufficient Memory Available"));
  3973.         goto abortQuikRebind;
  3974.     }
  3975.  
  3976.     ResetHstmt(&hstmt);
  3977.  
  3978.     /* Get column for "order by" clause: */
  3979.     wsprintf(szQuery,TEXT("select %s from %s"),lpqt->szColNames, lpqt->szTableName);
  3980.     rc = SQLExecDirect(hstmt, szQuery, SQL_NTS);
  3981.     if((SQL_SUCCESS!=rc) && (SQL_SUCCESS_WITH_INFO!=rc)){
  3982.         RETCHECK(SQL_SUCCESS_WITH_INFO, rc, szSQLEXECDIRECT);
  3983.         goto abortQuikRebind;
  3984.     }
  3985.     iCol=0;
  3986.     do    {
  3987.         iCol++;
  3988.         rc=SQLDescribeCol(hstmt, iCol, szColName, (SMALLBUFF*sizeof(TCHAR)), 
  3989.             NULL, &fSqlType, NULL, NULL, NULL);
  3990.         RETCHECK(SQL_SUCCESS, rc,szSQLDESCRIBECOL);
  3991.     } while(fSqlType!=SQL_CHAR && iCol<=cTypes);
  3992.  
  3993.     FreeStmt(SQL_CLOSE);
  3994.     if(iCol>=cTypes){
  3995.         DISPLAYERROR(szQUICKREBIND, TEXT("\t\t\tSelect-order by  Failed"));
  3996.         goto abortQuikRebind;
  3997.     }
  3998.  
  3999.     /* Set to row-wise binding and set Rowset size to uwRowsetSize:  */
  4000.     rc = SQLSetStmtAttr(hstmt,SQL_ATTR_ROW_BIND_TYPE,(PTR)udwRowSize,SQL_IS_INTEGER);
  4001.     if (SQL_SUCCESS != rc){
  4002.         _tcscpy(lpqt->buf,TEXT("\t\t\tQuick Rebind FAILED...SQLSetDescField(Bind_Type)"));
  4003.         szWrite(lpqt->buf, TRUE);
  4004.         goto abortQuikRebind;
  4005.     }
  4006.     rc = SQLSetStmtAttr(hstmt,SQL_ATTR_ROW_ARRAY_SIZE,(PTR)uwRowsetSize,SQL_IS_INTEGER);
  4007.     if (SQL_SUCCESS != rc){
  4008.             DISPLAYERROR(szQUICKREBIND,TEXT("\t\t\tSetStmtAttr(Rowset Size)"));
  4009.         goto abortQuikRebind;
  4010.     }        
  4011.  
  4012.     /* Define area storing Quikrebind offset value: */
  4013.     rc = SQLSetStmtAttr(hstmt, SQL_ATTR_ROW_BIND_OFFSET_PTR, &sdwOffset, SQL_IS_POINTER);
  4014.     if (SQL_SUCCESS != rc){
  4015.         if(FindError(SQL_HANDLE_STMT,szHYC00)){
  4016.             _tcscpy(lpqt->buf,TEXT("\t\t\tQuickRebind Not Supported"));
  4017.             szWrite(lpqt->buf, TRUE);
  4018.             goto abortQuikRebind;
  4019.         }
  4020.         _tcscpy(lpqt->buf,TEXT("\t\t\tQuick Rebind FAILED...QuickRebind Not Functional"));
  4021.         szWrite(lpqt->buf, TRUE);
  4022.         goto abortQuikRebind;
  4023.     }
  4024.  
  4025.     if(SQL_SUCCESS != SelectFromTableFetch(lpqt, szColName)){
  4026.         DISPLAYERROR(szQUICKREBIND, TEXT("\t\t\tSelect-order by  Failed"));
  4027.         goto abortQuikRebind;
  4028.     }
  4029.  
  4030.     if (!BindFetchColumns(lpqt, rgFields, cTypes, rgData)){
  4031.         DISPLAYERROR(szQUICKREBIND,szSQLBINDCOL);
  4032.         goto abortQuikRebind;
  4033.     }
  4034.  
  4035.     /* Test quick rebind feature with two pairs of Rowsets, all *
  4036.      * rowsets separated by a row of zeroes:                    */
  4037.     for (iRowset=0; iRowset<=1; iRowset++)
  4038.     {
  4039.         if(iRowset)
  4040.             if(SQL_SUCCESS != SelectFromTableFetch(lpqt, szColName)){
  4041.                 DISPLAYERROR(szQUICKREBIND, TEXT("\t\t\tSelect-order by  Failed"));
  4042.                 goto abortQuikRebind;
  4043.             }
  4044.  
  4045.         /* Set offset value (to 0 or 1  * uwRowsetSize * udwRowSize) for 1st rowset */
  4046.         sdwOffset = iRowset*((1+uwRowsetSize)*udwRowSize);
  4047.  
  4048.         /* Fetch rowset into desired area */
  4049.         rc = SQLFetchScroll(hstmt, SQL_FETCH_NEXT, 1);
  4050.         if (SQL_SUCCESS != rc){
  4051.             ERRSHANDLE(SQL_HANDLE_STMT, hstmt, SQL_SUCCESS, rc, szSQLFETCHSCROLL);
  4052.             DISPLAYERROR(szQUICKREBIND,TEXT("Fetch Failed"));
  4053.             goto abortQuikRebind;
  4054.         }                                                                                                                                                                
  4055.                                                                 
  4056.         /* Set offset value (to 2 or 3 * uwRowsetSize * udwRowSize) for 2nd rowset */
  4057.         sdwOffset = (iRowset+2)*(1+uwRowsetSize)*udwRowSize;
  4058.  
  4059.         rc = SQLFetchScroll(hstmt, SQL_FETCH_NEXT, 1);
  4060.         if (SQL_SUCCESS != rc){
  4061.             ERRSHANDLE(SQL_HANDLE_STMT, hstmt, SQL_SUCCESS, rc, szSQLFETCHSCROLL);
  4062.             DISPLAYERROR(szQUICKREBIND,TEXT("Fetch Failed"));
  4063.             goto abortQuikRebind;
  4064.         }
  4065.         FreeStmt(SQL_CLOSE);
  4066.     }
  4067.     
  4068.     rc = SQLFreeStmt(hstmt, SQL_UNBIND);
  4069.     RETCHECK(SQL_SUCCESS, rc, szSQLFREESTMT);
  4070.  
  4071.     rc = SQLSetStmtAttr(hstmt,SQL_ATTR_ROW_ARRAY_SIZE,(PTR)1,SQL_IS_INTEGER);
  4072.     if (SQL_SUCCESS != rc){
  4073.             DISPLAYERROR(szQUICKREBIND,TEXT("\t\t\tSetStmtAttr(Rowset Size)"));
  4074.         goto abortQuikRebind;
  4075.     }
  4076.  
  4077.     /* Check stored values: */
  4078.     for (iRowset=0; iRowset<=1; iRowset++)
  4079.     {
  4080.         if(SQL_SUCCESS != SelectFromTableFetch(lpqt, szColName)){
  4081.             DISPLAYERROR(szQUICKREBIND, TEXT("\t\t\tSelect-order by  Failed"));
  4082.             goto abortQuikRebind;
  4083.         }
  4084.  
  4085.         /* First Rowset starts either in Allocated Row 0 or 3 */
  4086.         iRowsetRow= iRowset*(1+uwRowsetSize);  
  4087.         //for (row=0; row<NUM_QUIKREBIND_ROWSETS  ;row++,iRowsetRow++)
  4088.         for (row=0; row<(uwRowsetSize*2)  ;row++,iRowsetRow++)
  4089.         {
  4090.             UWORD iResultSetCol=0;
  4091.             if(row==uwRowsetSize)     
  4092.                 iRowsetRow+= 2+uwRowsetSize; /* Jump to 2nd Rowset */
  4093.  
  4094.             /* Don't check data in "zero" row,     *
  4095.              * the spacer row between rowsets:    */
  4096.             if(iRowsetRow%(1+uwRowsetSize) == uwRowsetSize)
  4097.                 continue;
  4098.  
  4099.             /* Fetch next rowset */
  4100.             rc = SQLFetch(hstmt);
  4101.             if (SQL_SUCCESS != rc){
  4102.                 ERRSHANDLE(SQL_HANDLE_STMT, hstmt, SQL_SUCCESS, rc, szSQLFETCH);
  4103.                 DISPLAYERROR(szQUICKREBIND,TEXT("Fetch Failed"));
  4104.                 goto abortQuikRebind;
  4105.             }                      
  4106.         
  4107.             pCurrentRowData = rgData+iRowsetRow*cTypes;
  4108.             for(iTableCol=0; iTableCol<cTypes; iTableCol++)
  4109.             {
  4110.                 /* Ignore columns which aren't bound as they aren't in the result set */
  4111.                 if((!iTableCol && !fCol0Bound) || rgFields[iTableCol].fAutoUpdate)
  4112.                     continue;    
  4113.  
  4114.                 iResultSetCol++;
  4115.                 rc = SQLGetData(hstmt, iResultSetCol, SQL_C_TCHAR, rgbValue, MAX_STRING_SIZE,
  4116.                     &cbValue);
  4117.                 if(rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO)
  4118.                     RETCHECK(SQL_SUCCESS, rc,szSQLGETDATA);
  4119.  
  4120.                 if(!CheckDataResults(row, iTableCol, &rgFields[iTableCol], pCurrentRowData,cbValue,rgbValue))
  4121.                 {
  4122.                     wsprintf(lpqt->buf, TEXT("Data Check Failed, Row %d, Table Col %d, DataType %d (%s)"),
  4123.                         row, iTableCol, rgFields[iTableCol].wSQLType, rgFields[iTableCol].szFieldName) ;
  4124.                     szWrite(lpqt->buf,FALSE);
  4125.                     rgbValue[MAX_STRING_SIZE-1]=TEXT('\0');
  4126.                     wsprintf(lpqt->buf, TEXT("Returned Data: (%s)"), rgbValue);
  4127.                     DISPLAYERROR(szQUICKREBIND,lpqt->buf);
  4128.                     goto abortQuikRebind; 
  4129.                 }
  4130.             }/* end for(iTableCol) */
  4131.         } /* end for(row)              */
  4132.         FreeStmt(SQL_CLOSE);
  4133.     } /* end for (iRowset)  */
  4134.  
  4135.     /* Check Unused memory areas:    */
  4136.     for (iRowsetRow=uwRowsetSize; iRowsetRow<NUM_QUIKREBIND_ROWSETS*(uwRowsetSize+1);  )
  4137.     {
  4138.         pCurrentRowData = rgData+iRowsetRow*cTypes;
  4139.         if(memcmp(pCurrentRowData, pZeroRow, udwRowSize))
  4140.             DISPLAYERROR(szQUICKREBIND,
  4141.                     TEXT("Unused memory areas altered after Quick Rebind."));
  4142.         iRowsetRow+=(uwRowsetSize+1);
  4143.     }                                                        
  4144.                               
  4145.  
  4146. abortQuikRebind:
  4147.     ResetHstmt(&hstmt);
  4148.     if (rgbValue)                             
  4149.         ReleaseMemory(rgbValue);
  4150.     if (pZeroRow)                             
  4151.         ReleaseMemory(pZeroRow);
  4152.     ReleaseMemory(rgData);
  4153.  
  4154. } /* TestQuickRebind() */
  4155.  
  4156. //-----------------------------------------------------------------------
  4157. //      Function:               TestSQLForeignKeys
  4158. //-----------------------------------------------------------------------
  4159.  
  4160. void  PASCAL TestSQLForeignKeys(QTSTRUCT  *lpqt)
  4161. {
  4162.     RETCODE rc=SQL_SUCCESS;
  4163.  
  4164.     if (!Supported(SQL_API_SQLFOREIGNKEYS))
  4165.         {
  4166.         rc = SQLForeignKeys(hstmt, NULL, 0, NULL, 0, lpqt->szTableName, 
  4167.             SQL_NTS, NULL, 0, NULL, 0, NULL, 0);
  4168.  
  4169.         if(!FindError(SQL_HANDLE_STMT,szIM001))
  4170.             DISPLAYERROR(szSQLFOREIGNKEYS, szNotSupported);
  4171.         RETCHECK(SQL_ERROR, rc,szSQLFOREIGNKEYS);
  4172.         }
  4173.     else
  4174.         {
  4175.         rc = SQLForeignKeys(hstmt, NULL, 0, NULL, 0, lpqt->szTableName,
  4176.             SQL_NTS, NULL, 0, NULL, 0, NULL, 0);
  4177.  
  4178.         RETCHECK(SQL_SUCCESS, rc,szSQLFOREIGNKEYS);
  4179.  
  4180.         while(rc == SQL_SUCCESS) 
  4181.             rc = SQLFetch(hstmt);
  4182.  
  4183.         RETCHECK(SQL_NO_DATA_FOUND, rc,szSQLFETCH);
  4184.  
  4185.         FreeStmt(SQL_CLOSE);
  4186.  
  4187.         }
  4188.  
  4189. } //TestSQLForeignKeys()
  4190.  
  4191.  
  4192. //-----------------------------------------------------------------------
  4193. //      Function:               TestSQLBrowseConnect
  4194. //-----------------------------------------------------------------------
  4195.  
  4196. void  PASCAL TestSQLBrowseConnect(lpSERVERINFO lpSI)
  4197. {
  4198.     RETCODE    rc=SQL_SUCCESS;
  4199.     UWORD        cMaxConnections=0;
  4200.     TCHAR        szBCString[40];
  4201.     TCHAR        szDSN[40];
  4202.     HDBC        hdbcb=NULL;
  4203.  
  4204.     AllocHdbc(&hdbcb);
  4205.  
  4206.     rc = SQLGetInfo(hdbc, SQL_ACTIVE_CONNECTIONS, &cMaxConnections, sizeof(int), NULL);
  4207.     RETCHECK(SQL_SUCCESS, rc,szSQLGETINFO);
  4208.  
  4209.     if(cMaxConnections != 1) 
  4210.         {
  4211.         lstrcpy(szBCString,TEXT("DSN="));
  4212.         lstrcat(szBCString, lpSI->szValidServer0);
  4213.         
  4214.         if(lpSI->szValidServer0[0] == 0)
  4215.             {
  4216.             rc = SQLGetInfo(hdbc, SQL_DATA_SOURCE_NAME, &szDSN, 40, NULL);
  4217.             lstrcat(szBCString, szDSN);
  4218.             }
  4219.  
  4220.         if(!Supported(SQL_API_SQLBROWSECONNECT))
  4221.             {
  4222.             HDBC thdbc=NULL;
  4223.  
  4224.             rc = SQLBrowseConnect(hdbcb, szBCString, SQL_NTS, NULL, 0, NULL);
  4225.             thdbc = hdbc;
  4226.             hdbc = hdbcb;
  4227.             if(!FindError(SQL_HANDLE_DBC,szIM001))
  4228.                 DISPLAYERROR(szSQLBROWSECONNECT, szNotSupported);
  4229.             RETCHECK(SQL_ERROR, rc,szSQLBROWSECONNECT);
  4230.             hdbc = thdbc;
  4231.  
  4232.             rc = SQLFreeConnect(hdbcb);
  4233.             RETCHECK(SQL_SUCCESS, rc,szSQLFREECONNECT);
  4234.         
  4235.             }
  4236.         else
  4237.             {
  4238.             rc = SQLBrowseConnect(hdbcb, szBCString, SQL_NTS, NULL, 0, NULL);
  4239.             RETCHECK(SQL_NEED_DATA, rc,szSQLBROWSECONNECT);
  4240.  
  4241.             rc = SQLDisconnect(hdbcb);
  4242.             RETCHECK(SQL_SUCCESS, rc,szSQLDISCONNECT);
  4243.             rc = SQLFreeConnect(hdbcb);
  4244.             RETCHECK(SQL_SUCCESS, rc,szSQLFREECONNECT);
  4245.             }
  4246.         }
  4247.  
  4248. } //TestSQLBrowseConnect()
  4249.  
  4250.  
  4251. //-----------------------------------------------------------------------
  4252. //      Function:               TestSQLDataSources
  4253. //-----------------------------------------------------------------------
  4254.  
  4255. void  PASCAL TestSQLDataSources()
  4256. {
  4257.     RETCODE rc=SQL_SUCCESS;
  4258.  
  4259.     if (!Supported( SQL_API_SQLDATASOURCES))
  4260.         {
  4261.         rc = SQLDataSources(henv, SQL_FETCH_FIRST, NULL, 0, NULL, NULL, 0, NULL);
  4262.     
  4263.         if(!FindError(SQL_HANDLE_ENV,szIM001))
  4264.             DISPLAYERROR(TEXT("SQLDataSources"), szNotSupported);
  4265.     
  4266.         RETCHECK(SQL_ERROR, rc,TEXT("SQLDataSources"));
  4267.         } 
  4268.     else 
  4269.         {
  4270.         rc = SQLDataSources(henv, SQL_FETCH_FIRST, NULL, 0, NULL, NULL, 0, NULL);
  4271.         RETCHECK(SQL_SUCCESS, rc,TEXT("SQLDataSources"));
  4272.         }
  4273.  
  4274. } //TestSQLDataSources()
  4275.  
  4276.  
  4277. //-----------------------------------------------------------------------
  4278. //      Function:               TestSQLDataSources
  4279. //-----------------------------------------------------------------------
  4280.  
  4281. void  PASCAL TestSQLDrivers()
  4282. {
  4283.     RETCODE rc=SQL_SUCCESS;
  4284.  
  4285.     if(!Supported( SQL_API_SQLDRIVERS)) 
  4286.         {
  4287.         rc = SQLDrivers(henv, SQL_FETCH_FIRST, NULL, 0, NULL, NULL, 0, NULL);
  4288.         if(!FindError(SQL_HANDLE_ENV,szIM001))
  4289.             DISPLAYERROR(TEXT("SQLDrivers"), szNotSupported);
  4290.         RETCHECK(SQL_ERROR, rc,TEXT("SQLDataSources"));
  4291.         }
  4292.     else
  4293.         {
  4294.         rc = SQLDrivers(henv, SQL_FETCH_FIRST, NULL, 0, NULL, NULL, 0, NULL);
  4295.         if(rc != SQL_SUCCESS)
  4296.             RETCHECK(SQL_SUCCESS_WITH_INFO, rc,TEXT("SQLDrivers"));
  4297.         }
  4298.  
  4299. } //TestSQLDrivers()
  4300.  
  4301.  
  4302. //-----------------------------------------------------------------------
  4303. //      Function:               TestSQLMoreResults
  4304. //-----------------------------------------------------------------------
  4305.  
  4306. void  PASCAL TestSQLMoreResults(QTSTRUCT  *lpqt)
  4307. {
  4308.     RETCODE rc=SQL_SUCCESS;
  4309.  
  4310.     if(!Supported( SQL_API_SQLMORERESULTS)) 
  4311.         {
  4312.         SelectFromTable(lpqt);
  4313.  
  4314.         rc = SQLMoreResults(hstmt);
  4315.         if(!FindError(SQL_HANDLE_STMT,szIM001))
  4316.             DISPLAYERROR(TEXT("SQLMoreResults"), szNotSupported);
  4317.         RETCHECK(SQL_ERROR, rc,TEXT("SQLMoreResults"));
  4318.         }
  4319.     else
  4320.         {
  4321.         SelectFromTable(lpqt);
  4322.  
  4323.         rc = SQLMoreResults(hstmt);
  4324.         RETCHECK(SQL_NO_DATA_FOUND, rc,TEXT("SQLMoreResults"));
  4325.         }
  4326.  
  4327.     FreeStmt(SQL_CLOSE);
  4328.  
  4329. } //TestSQLMoreResults()
  4330.  
  4331.  
  4332. //-----------------------------------------------------------------------
  4333. //      Function:               TestSQLMoreResults
  4334. //-----------------------------------------------------------------------
  4335.  
  4336. void  PASCAL TestSQLNativeSQL(QTSTRUCT  *lpqt)
  4337. {
  4338.     RETCODE    rc=SQL_SUCCESS;
  4339.     TCHAR        szQuery[XLARGEBUFF];
  4340.     
  4341.     wsprintf(szQuery,TEXT("select * from %s were 0 > 1"),lpqt->szTableName);
  4342.  
  4343.     if(!Supported( SQL_API_SQLNATIVESQL))
  4344.         {
  4345.         rc = SQLNativeSql(hdbc, szQuery, SQL_NTS, NULL, 0, NULL);
  4346.         if(!FindError(SQL_HANDLE_DBC,szIM001))
  4347.             DISPLAYERROR(TEXT("SQLNativeSql"), szNotSupported);
  4348.         RETCHECK(SQL_ERROR, rc,TEXT("SQLNativeSql"));
  4349.         }
  4350.     else 
  4351.         {
  4352.         rc = SQLNativeSql(hdbc, szQuery, SQL_NTS, NULL, 0, NULL);
  4353.         RETCHECK(SQL_SUCCESS, rc,TEXT("SQLNativeSql"));
  4354.         }
  4355.  
  4356.     FreeStmt(SQL_CLOSE);
  4357.     
  4358. } //TestSQLNativeSQL()
  4359.  
  4360.  
  4361. //-----------------------------------------------------------------------
  4362. //      Function:               TestSQLDescribeParam
  4363. //-----------------------------------------------------------------------
  4364.  
  4365. void  PASCAL TestSQLDescribeParam(QTSTRUCT  *lpqt)
  4366. {
  4367.     RETCODE rc=SQL_SUCCESS;
  4368.  
  4369.     rc = SQLPrepare(hstmt, lpqt->szParamQuery, SQL_NTS);
  4370.     RETCHECK(SQL_SUCCESS, rc,szSQLPREPARE);
  4371.  
  4372.     if(!Supported( SQL_API_SQLDESCRIBEPARAM)) 
  4373.         {
  4374.         rc = SQLPrepare(hstmt, lpqt->szParamQuery, SQL_NTS);
  4375.         RETCHECK(SQL_SUCCESS, rc,szSQLPREPARE);
  4376.         rc = SQLDescribeParam(hstmt, 1, NULL, NULL, NULL, NULL);
  4377.         if(!FindError(SQL_HANDLE_STMT,szIM001))
  4378.             DISPLAYERROR(szSQLDESCRIBEPARAM, szNotSupported);
  4379.         RETCHECK(SQL_ERROR, rc,szSQLDESCRIBEPARAM);
  4380.         }
  4381.     else
  4382.         {
  4383.         rc = SQLPrepare(hstmt, lpqt->szParamQuery, SQL_NTS);
  4384.         RETCHECK(SQL_SUCCESS, rc,szSQLPREPARE);
  4385.         rc = SQLDescribeParam(hstmt, 1, NULL, NULL, NULL, NULL);
  4386.         RETCHECK(SQL_SUCCESS, rc,szSQLDESCRIBEPARAM);
  4387.         }
  4388.  
  4389.         FreeStmt(SQL_CLOSE);
  4390.  
  4391. } //TestSQLDescribeParam()
  4392.  
  4393.  
  4394.  
  4395. //-----------------------------------------------------------------------
  4396. //      Function:               TestSQLNumParams
  4397. //-----------------------------------------------------------------------
  4398.  
  4399. void  PASCAL TestSQLNumParams(QTSTRUCT  *lpqt)
  4400. {
  4401.     RETCODE rc=SQL_SUCCESS;
  4402.  
  4403.     rc = SQLPrepare(hstmt, lpqt->szParamQuery, SQL_NTS);
  4404.     RETCHECK(SQL_SUCCESS, rc,szSQLPREPARE);
  4405.  
  4406.     if(!Supported( SQL_API_SQLNUMPARAMS)) 
  4407.         {
  4408.         rc = SQLNumParams(hstmt, NULL);
  4409.         if(!FindError(SQL_HANDLE_STMT,szIM001))
  4410.             DISPLAYERROR(szSQLNUMPARAMS, szNotSupported);
  4411.         RETCHECK(SQL_ERROR, rc,szSQLNUMPARAMS);
  4412.         }
  4413.     else
  4414.         {
  4415.         rc = SQLNumParams(hstmt, NULL);
  4416.         RETCHECK(SQL_SUCCESS, rc,szSQLNUMPARAMS);
  4417.         }
  4418.  
  4419.     FreeStmt(SQL_CLOSE);
  4420.  
  4421. } //TestSQLNumParams()
  4422.  
  4423.  
  4424.  
  4425.  
  4426.  
  4427. //-----------------------------------------------------------------------
  4428. //      Function:               TestSQLParamOptions
  4429. //-----------------------------------------------------------------------
  4430.  
  4431. void  PASCAL TestSQLParamOptions(QTSTRUCT *lpqt)
  4432. {
  4433.     RETCODE rc=SQL_SUCCESS;
  4434.  
  4435.     rc = SQLPrepare(hstmt, lpqt->szParamQuery, SQL_NTS);
  4436.     RETCHECK(SQL_SUCCESS, rc,szSQLPREPARE);
  4437.  
  4438.     if(!Supported( SQL_API_SQLPARAMOPTIONS)) 
  4439.         {
  4440.         rc = SQLParamOptions(hstmt, 1, NULL);
  4441.         if(!FindError(SQL_HANDLE_STMT,szIM001))
  4442.             DISPLAYERROR(szSQLPARAMOPTIONS, szNotSupported);
  4443.         RETCHECK(SQL_ERROR, rc,szSQLPARAMOPTIONS);
  4444.         }
  4445.     else
  4446.         {
  4447.         rc = SQLParamOptions(hstmt, 1, NULL);
  4448.         RETCHECK(SQL_SUCCESS, rc,szSQLPARAMOPTIONS);
  4449.         }
  4450.  
  4451.     FreeStmt(SQL_CLOSE);
  4452.  
  4453. } //TestSQLParamOptions()
  4454.  
  4455.  
  4456.  
  4457.  
  4458. //-----------------------------------------------------------------------
  4459. //      Function:               TestSQLPrimaryKeys
  4460. //-----------------------------------------------------------------------
  4461.  
  4462. void  PASCAL TestSQLPrimaryKeys(QTSTRUCT *lpqt)
  4463. {
  4464.     RETCODE rc=SQL_SUCCESS;
  4465.  
  4466.     if (!Supported( SQL_API_SQLPRIMARYKEYS))
  4467.         {
  4468.         rc = SQLPrimaryKeys(hstmt, NULL, 0, NULL, 0, lpqt->szTableName, SQL_NTS);
  4469.         if(!FindError(SQL_HANDLE_STMT,szIM001))
  4470.             DISPLAYERROR(szSQLPRIMARYKEYS, szNotSupported);
  4471.         RETCHECK(SQL_ERROR, rc,szSQLPRIMARYKEYS);
  4472.         }
  4473.     else
  4474.         {
  4475.         rc = SQLPrimaryKeys(hstmt, NULL, 0, NULL, 0, lpqt->szTableName, SQL_NTS);
  4476.         RETCHECK(SQL_SUCCESS, rc,szSQLPRIMARYKEYS);
  4477.         while(rc == SQL_SUCCESS) 
  4478.             rc = SQLFetch(hstmt);
  4479.  
  4480.         RETCHECK(SQL_NO_DATA_FOUND, rc,szSQLFETCH);
  4481.  
  4482.         FreeStmt(SQL_CLOSE);
  4483.  
  4484.         }
  4485.  
  4486. } //TestSQLPrimaryKeys()
  4487.  
  4488.  
  4489.  
  4490. //-----------------------------------------------------------------------
  4491. //      Function:               TestSQLProcedureColumns
  4492. //-----------------------------------------------------------------------
  4493.  
  4494. void  PASCAL TestSQLProcedureColumns(QTSTRUCT  *lpqt)
  4495. {
  4496.     RETCODE rc=SQL_SUCCESS;
  4497.  
  4498.     if(!Supported( SQL_API_SQLPROCEDURECOLUMNS)) 
  4499.         {
  4500.         rc = SQLProcedureColumns(hstmt, NULL, 0, NULL, 0, NULL, 0, NULL, 0);
  4501.         if(!FindError(SQL_HANDLE_STMT,szIM001))
  4502.             DISPLAYERROR(TEXT("SQLProcedureColumns"), szNotSupported);
  4503.         RETCHECK(SQL_ERROR, rc,TEXT("SQLProcedureColumns"));
  4504.         }
  4505.     else 
  4506.         {
  4507.         rc = SQLProcedureColumns(hstmt, NULL, 0, NULL, 0, NULL, 0, NULL, 0);
  4508.         RETCHECK(SQL_SUCCESS, rc,TEXT("SQLProcedureColumns"));
  4509.         while(rc == SQL_SUCCESS)
  4510.             rc = SQLFetch(hstmt);
  4511.  
  4512.         RETCHECK(SQL_NO_DATA_FOUND, rc,szSQLFETCH);
  4513.  
  4514.         FreeStmt(SQL_CLOSE);
  4515.         }
  4516.  
  4517. } //TestSQLProcedureColumns()
  4518.  
  4519.  
  4520.  
  4521. //-----------------------------------------------------------------------
  4522. //      Function:               TestSQLProcedures
  4523. //-----------------------------------------------------------------------
  4524.  
  4525. void  PASCAL TestSQLProcedures()
  4526. {
  4527.     RETCODE rc=SQL_SUCCESS;
  4528.  
  4529.     if(!Supported( SQL_API_SQLPROCEDURES)) 
  4530.         {
  4531.         rc = SQLProcedures(hstmt, NULL, 0, NULL, 0, NULL, 0);
  4532.         if(!FindError(SQL_HANDLE_STMT,szIM001))
  4533.             DISPLAYERROR(TEXT("SQLProcedures"), szNotSupported);
  4534.         RETCHECK(SQL_ERROR, rc,TEXT("SQLProcedures"));
  4535.         }
  4536.     else
  4537.         {
  4538.         rc = SQLProcedures(hstmt, NULL, 0, NULL, 0, NULL, 0);
  4539.         RETCHECK(SQL_SUCCESS, rc,TEXT("SQLProcedures"));
  4540.         while(rc == SQL_SUCCESS)
  4541.             rc = SQLFetch(hstmt);
  4542.         RETCHECK(SQL_NO_DATA_FOUND, rc,szSQLFETCH);
  4543.  
  4544.         FreeStmt(SQL_CLOSE);
  4545.         }
  4546.  
  4547. } //TestSQLProcedures()
  4548.  
  4549.  
  4550. //-----------------------------------------------------------------------
  4551. //      Function:               TestSQLTablePrivileges
  4552. //-----------------------------------------------------------------------
  4553.  
  4554. void  PASCAL TestSQLTablePrivileges()
  4555. {
  4556.     RETCODE rc=SQL_SUCCESS;
  4557.  
  4558.     if(!Supported( SQL_API_SQLTABLEPRIVILEGES)) 
  4559.         {
  4560.         rc = SQLTablePrivileges(hstmt, NULL, 0, NULL, 0, NULL, 0);
  4561.         if(!FindError(SQL_HANDLE_STMT,szIM001))
  4562.             DISPLAYERROR(TEXT("SQLTablePrivileges"), szNotSupported);
  4563.         RETCHECK(SQL_ERROR, rc,TEXT("SQLTablePrivileges"));
  4564.         }
  4565.     else
  4566.         {
  4567.         rc = SQLTablePrivileges(hstmt, NULL, 0, NULL, 0, NULL, 0);
  4568.         RETCHECK(SQL_SUCCESS, rc,TEXT("SQLTablePrivileges"));
  4569.         while(rc == SQL_SUCCESS) 
  4570.             rc = SQLFetch(hstmt);
  4571.  
  4572.         RETCHECK(SQL_NO_DATA_FOUND, rc,szSQLFETCH);
  4573.  
  4574.         FreeStmt(SQL_CLOSE);
  4575.         }
  4576.  
  4577. } //TestSQLTablePrivileges()
  4578.  
  4579.  
  4580.  
  4581. //-----------------------------------------------------------------------
  4582. //      Function:               TestSQLColumnPrivileges
  4583. //-----------------------------------------------------------------------
  4584.  
  4585. void  PASCAL TestSQLColumnPrivileges(QTSTRUCT  *lpqt)
  4586. {
  4587.     RETCODE rc=SQL_SUCCESS;
  4588.  
  4589.     if(!Supported( SQL_API_SQLCOLUMNPRIVILEGES)) 
  4590.         {
  4591.         rc = SQLColumnPrivileges(hstmt, NULL, 0, NULL, 0, lpqt->szTableName, SQL_NTS,
  4592.             NULL, 0);
  4593.         if(!FindError(SQL_HANDLE_STMT,szIM001))
  4594.             DISPLAYERROR(TEXT("SQLColummPrivileges"), szNotSupported);
  4595.         RETCHECK(SQL_ERROR, rc,TEXT("SQLColumnPrivileges"));
  4596.         } 
  4597.     else
  4598.         {
  4599.         rc = SQLColumnPrivileges(hstmt, NULL, 0, NULL, 0, lpqt->szTableName, SQL_NTS,
  4600.             NULL, 0);
  4601.         RETCHECK(SQL_SUCCESS, rc,TEXT("SQLColumnPrivileges"));
  4602.         while(rc == SQL_SUCCESS)
  4603.             rc = SQLFetch(hstmt);
  4604.     
  4605.         RETCHECK(SQL_NO_DATA_FOUND, rc,szSQLFETCH);
  4606.  
  4607.         FreeStmt(SQL_CLOSE);
  4608.         }
  4609.  
  4610. } // TestSQLColumnPrivileges()
  4611.  
  4612.  
  4613. //-----------------------------------------------------------------------
  4614. //      Function:               TestSQLSetScrollOptions
  4615. //-----------------------------------------------------------------------
  4616.  
  4617. void  PASCAL TestSQLSetScrollOptions()
  4618. {
  4619.     RETCODE    rc=SQL_SUCCESS;
  4620.     UWORD        i,
  4621.                 j;
  4622.     UDWORD    fSupportedOpt;
  4623.     UDWORD    fSupportedCon;
  4624.     TCHAR        szState[100]=TEXT(""),
  4625.                 szErrMsg[XLARGEBUFF]=TEXT("");
  4626.  
  4627.     FreeStmt(SQL_CLOSE);
  4628.  
  4629.     if(!Supported( SQL_API_SQLSETSCROLLOPTIONS)) 
  4630.         {
  4631.         rc = SQLSetScrollOptions(hstmt, SQL_CONCUR_READ_ONLY, SQL_SCROLL_FORWARD_ONLY,
  4632.             1);
  4633.         if(!FindError(SQL_HANDLE_STMT,szIM001))
  4634.             DISPLAYERROR(szSQLSETSCROLLOPTIONS, szNotSupported);
  4635.         RETCHECK(SQL_ERROR, rc,szSQLSETSCROLLOPTIONS);
  4636.         } 
  4637.     else
  4638.         {
  4639.         rc = SQLGetInfo(hdbc, SQL_SCROLL_CONCURRENCY, &fSupportedCon, 4, NULL);
  4640.         RETCHECK(SQL_SUCCESS, rc,szSQLGETINFO);
  4641.         rc = SQLGetInfo(hdbc, SQL_SCROLL_OPTIONS, &fSupportedOpt, 4, NULL);
  4642.         RETCHECK(SQL_SUCCESS, rc,szSQLGETINFO);
  4643.  
  4644.         for(i = 0; i < sizeof(OptionList) / sizeof(SUPPORTOPTINFO); i ++) 
  4645.             {
  4646.             for(j = 0; j < sizeof(ConcurList) / sizeof(SUPPORTCONCURINFO); j++) 
  4647.                 {
  4648.                 if(fSupportedOpt & OptionList[i].Support && fSupportedCon & ConcurList[j].Support) 
  4649.                     {
  4650.                     if(!((ConcurList[j].Option == SQL_CONCUR_VALUES) && ((lpSI->vCursorLib == 
  4651.                             SQL_CUR_USE_IF_NEEDED) || (lpSI->vCursorLib == SQL_CUR_USE_ODBC))))
  4652.                         {
  4653.                         rc = SQLSetScrollOptions(hstmt, ConcurList[j].Option,OptionList[i].Option, 1);
  4654.                         RETCHECK(SQL_SUCCESS, rc,szSQLSETSCROLLOPTIONS);
  4655.                         }
  4656.  
  4657.                     }
  4658.                 }
  4659.             }
  4660.         }
  4661.  
  4662.     FreeStmt(SQL_CLOSE);
  4663.  
  4664. } //TestSQLSetScrollOptions()
  4665.  
  4666.  
  4667. //-----------------------------------------------------------------------------
  4668. //    Function:  TestConnectAttr
  4669. //-----------------------------------------------------------------------------
  4670.  
  4671. VOID PASCAL TestConnectAttr(HDBC hdbc,SDWORD fAttribute, UDWORD rgbValue,LPTSTR lpAttr,BOOL fReadOnlyAttr)
  4672. {
  4673.     RETCODE    rc=SQL_SUCCESS;
  4674.     TCHAR        szBuff[LARGEBUFF]=TEXT("");
  4675.     UDWORD    pvParam=0;
  4676.     RETCODE    rcExp=fReadOnlyAttr ? SQL_ERROR : SQL_SUCCESS;
  4677.  
  4678.     rc = SQLSetConnectAttr(hdbc,fAttribute,(PTR)rgbValue,sizeof(rgbValue));
  4679.  
  4680.     if(!FindError(SQL_HANDLE_DBC,szHYC00))
  4681.     {
  4682.  
  4683.         RETCHECK(rcExp,rc,szSQLSETCONNECTATTR);
  4684.     
  4685.         rc = SQLGetConnectAttr(hdbc,fAttribute,&pvParam,sizeof(pvParam),NULL);
  4686.  
  4687.         if(!FindError(SQL_HANDLE_DBC,szHYC00))
  4688.         {
  4689.             RETCHECK(SQL_SUCCESS,rc,szSQLGETCONNECTATTR);
  4690.  
  4691.             if(!fReadOnlyAttr && (pvParam != rgbValue))
  4692.             {
  4693.                 wsprintf(szBuff,TEXT("%s returned incorrect value"),lpAttr);
  4694.                 DISPLAYERROR(szSQLGETCONNECTATTR,szBuff);
  4695.             }
  4696.         }
  4697.         else
  4698.             RETCHECK(SQL_ERROR,rc,szSQLGETCONNECTATTR);
  4699.     }
  4700.     else
  4701.         RETCHECK(SQL_ERROR,rc,szSQLSETCONNECTATTR); 
  4702.  
  4703. } //TestConnectAttr()
  4704.  
  4705.  
  4706. //-----------------------------------------------------------------------------
  4707. //    Function:  TestSQLSetConnectAttr
  4708. //             This function tests both SQLSetConnectAttr and SQLGetConnectAttr
  4709. //-----------------------------------------------------------------------------
  4710.  
  4711. void  PASCAL TestSQLSetConnectAttr()
  4712. {
  4713.     RETCODE rc = SQL_SUCCESS;
  4714.     UDWORD    pvParam;
  4715.     UWORD    rgbValue;
  4716.     BOOL    fSupportSetConnectAttr = TRUE;
  4717.     BOOL    fSupportGetConnectAttr = TRUE;
  4718.  
  4719.     //make sure these APIs are supported before testing
  4720.     if(!Supported(SQL_API_SQLSETCONNECTATTR))
  4721.         {
  4722.         rgbValue = SQL_MODE_READ_WRITE;
  4723.         fSupportSetConnectAttr = FALSE;
  4724.         rc = SQLSetConnectAttr(hdbc,SQL_ACCESS_MODE,&rgbValue,sizeof(rgbValue));
  4725.         if(!FindError(SQL_HANDLE_DBC,szIM001))
  4726.             DISPLAYERROR(szSQLSETCONNECTATTR,TEXT("did not return Not supported message"));
  4727.         RETCHECK(SQL_ERROR,rc,szSQLSETCONNECTATTR);
  4728.         }
  4729.  
  4730.     if(!Supported(SQL_API_SQLGETCONNECTATTR))
  4731.         {
  4732.         fSupportGetConnectAttr = FALSE;
  4733.         rc = SQLGetConnectAttr(hdbc,SQL_ACCESS_MODE,&pvParam,sizeof(pvParam),NULL);
  4734.         if(!FindError(SQL_HANDLE_DBC,szIM001))
  4735.             DISPLAYERROR(szSQLGETCONNECTATTR,TEXT("did not return Not supported message"));
  4736.         RETCHECK(SQL_ERROR,rc,szSQLGETCONNECTATTR);
  4737.         }
  4738.  
  4739.     if(fSupportSetConnectAttr && (!fSupportGetConnectAttr))
  4740.         {
  4741.         //test SQL_ACCESS_MODE
  4742.         rgbValue = SQL_MODE_READ_WRITE;
  4743.         rc = SQLSetConnectAttr(hdbc,SQL_ACCESS_MODE,&rgbValue,sizeof(rgbValue));
  4744.         if(!FindError(SQL_HANDLE_DBC,szHYC00))
  4745.             RETCHECK(SQL_SUCCESS,rc,szSQLSETCONNECTATTR);
  4746.         else
  4747.             RETCHECK(SQL_ERROR,rc,szSQLSETCONNECTATTR);
  4748.         //test SQL_AUTOCOMMIT        
  4749.         rgbValue = SQL_AUTOCOMMIT_ON;
  4750.         rc = SQLSetConnectAttr(hdbc,SQL_AUTOCOMMIT,&rgbValue,sizeof(rgbValue));
  4751.         if(!FindError(SQL_HANDLE_DBC,szHYC00))
  4752.             RETCHECK(SQL_SUCCESS,rc,szSQLSETCONNECTATTR);
  4753.         else
  4754.             RETCHECK(SQL_ERROR,rc,szSQLSETCONNECTATTR);
  4755.         //test SQL_LOGIN_TIMEOUT
  4756.         //the choice of 15 seconds for timeout is arbitrary
  4757.         rgbValue = 15;
  4758.         rc = SQLSetConnectAttr(hdbc,SQL_LOGIN_TIMEOUT,&rgbValue,sizeof(rgbValue));
  4759.         if(!FindError(SQL_HANDLE_DBC,szHYC00))
  4760.             RETCHECK(SQL_SUCCESS,rc,szSQLSETCONNECTATTR);
  4761.         else
  4762.             RETCHECK(SQL_ERROR,rc,szSQLSETCONNECTATTR);
  4763.         }
  4764.  
  4765.     if((!fSupportSetConnectAttr) && fSupportGetConnectAttr)
  4766.     {
  4767.         //test SQL_ACCESS_MODE
  4768.         rc = SQLGetConnectAttr(hdbc,SQL_ACCESS_MODE,&pvParam,sizeof(pvParam),NULL);
  4769.         if(!FindError(SQL_HANDLE_DBC,szHYC00))
  4770.             RETCHECK(SQL_SUCCESS,rc,szSQLGETCONNECTATTR);
  4771.         else
  4772.             RETCHECK(SQL_ERROR,rc,szSQLGETCONNECTATTR);
  4773.         //test SQL_AUTOCOMMIT        
  4774.         rc = SQLGetConnectAttr(hdbc,SQL_AUTOCOMMIT,&pvParam,sizeof(pvParam),NULL);
  4775.         if(!FindError(SQL_HANDLE_DBC,szHYC00))
  4776.             RETCHECK(SQL_SUCCESS,rc,szSQLGETCONNECTATTR);
  4777.         else
  4778.             RETCHECK(SQL_ERROR,rc,szSQLGETCONNECTATTR);
  4779.         //test SQL_LOGIN_TIMEOUT
  4780.         rc = SQLGetConnectAttr(hdbc,SQL_LOGIN_TIMEOUT,&pvParam,sizeof(pvParam),NULL);
  4781.         if(!FindError(SQL_HANDLE_DBC,szHYC00))
  4782.             RETCHECK(SQL_SUCCESS,rc,szSQLGETCONNECTATTR);
  4783.         else
  4784.             RETCHECK(SQL_ERROR,rc,szSQLGETCONNECTATTR);
  4785.         //SQL_ATTR_AUTO_IPD is a read-only attribute        
  4786.         rc = SQLGetConnectAttr(hdbc,SQL_ATTR_AUTO_IPD,&pvParam,sizeof(pvParam),NULL);
  4787.         if(!FindError(SQL_HANDLE_DBC,szHYC00))
  4788.             RETCHECK(SQL_SUCCESS,rc,szSQLGETCONNECTATTR);
  4789.         else
  4790.             RETCHECK(SQL_ERROR,rc,szSQLGETCONNECTATTR);
  4791.     }
  4792.  
  4793.     if(fSupportSetConnectAttr && fSupportGetConnectAttr)
  4794.     {
  4795.         
  4796.         //test SQL_ACCESS_MODE
  4797.         TestConnectAttr(hdbc,SQL_ACCESS_MODE,SQL_MODE_READ_WRITE,TEXT("SQL_ACCESS_MODE"),FALSE);
  4798.         
  4799.         //test SQL_AUTOCOMMIT        
  4800.         TestConnectAttr(hdbc,SQL_AUTOCOMMIT,SQL_AUTOCOMMIT_ON,TEXT("SQL_AUTOCOMMIT"),FALSE);
  4801.             
  4802.         //test SQL_LOGIN_TIMEOUT
  4803.         //the choice of 15 seconds for timeout is arbitrary
  4804.         TestConnectAttr(hdbc,SQL_LOGIN_TIMEOUT,15,TEXT("SQL_LOGIN_TIMEOUT"),FALSE);
  4805.  
  4806.         //SQL_ATTR_AUTO_IPD is a read-only attribute        
  4807.         TestConnectAttr(hdbc,SQL_ATTR_AUTO_IPD,15,TEXT("SQL_ATTR_AUTO_IPD"),TRUE);
  4808.     }
  4809.  
  4810. } //TestSQLSetConnectAttr()
  4811.  
  4812.  
  4813.  
  4814. //-----------------------------------------------------------------------------
  4815. //    Function:  TestSQLSetStmtAttr
  4816. //             This function tests both SQLSetStmtAttr and SQLGetStmtAttr
  4817. //-----------------------------------------------------------------------------
  4818.  
  4819. void  PASCAL TestSQLSetStmtAttr()
  4820. {
  4821.     RETCODE rc = SQL_SUCCESS, rc2= SQL_SUCCESS;
  4822.     UDWORD    pvParam;
  4823.     UWORD    rgbValue;
  4824.     BOOL    fSupportSetStmtAttr = TRUE;
  4825.     BOOL    fSupportGetStmtAttr = TRUE;
  4826.  
  4827.     //make sure these APIs are supported before testing
  4828.     if(!Supported(SQL_API_SQLSETSTMTATTR))
  4829.         {
  4830.         //the choice of 300 for SQL_MAX_LENGTH is arbitrary
  4831.         rgbValue = 300;
  4832.         fSupportSetStmtAttr = FALSE;
  4833.         rc = SQLSetStmtAttr(hstmt,SQL_MAX_LENGTH,&rgbValue,sizeof(rgbValue));
  4834.         if(!FindError(SQL_HANDLE_STMT,szIM001))
  4835.             DISPLAYERROR(szSQLSETSTMTATTR,TEXT("did not return Not supported message"));
  4836.         RETCHECK(SQL_ERROR,rc,szSQLSETSTMTATTR);
  4837.         }
  4838.  
  4839.     if(!Supported(SQL_API_SQLGETSTMTATTR))
  4840.         {
  4841.         fSupportGetStmtAttr = FALSE;
  4842.         rc = SQLGetStmtAttr(hstmt,SQL_MAX_LENGTH,&pvParam,sizeof(pvParam),NULL);
  4843.         if(!FindError(SQL_HANDLE_STMT,szIM001))
  4844.             DISPLAYERROR(szSQLGETSTMTATTR,TEXT("did not return Not supported message"));
  4845.         RETCHECK(SQL_ERROR,rc,szSQLGETSTMTATTR);
  4846.         }
  4847.  
  4848.     if(fSupportSetStmtAttr && (!fSupportGetStmtAttr))
  4849.         {
  4850.         //test SQL_MAX_LENGTH
  4851.         rgbValue = 300;
  4852.         rc = SQLSetStmtAttr(hstmt,SQL_MAX_LENGTH,&rgbValue,sizeof(rgbValue));
  4853.         if(!FindError(SQL_HANDLE_STMT,szHYC00))
  4854.             RETCHECK(SQL_SUCCESS,rc,szSQLSETSTMTATTR);
  4855.         else
  4856.             RETCHECK(SQL_ERROR,rc,szSQLSETSTMTATTR);
  4857.         //test SQL_ATTR_METADATA_ID -- new in 3.0
  4858.         rgbValue = SQL_FALSE;
  4859.         rc = SQLSetStmtAttr(hstmt,SQL_ATTR_METADATA_ID,&rgbValue,sizeof(rgbValue));
  4860.         if(!FindError(SQL_HANDLE_STMT,szHYC00))
  4861.             RETCHECK(SQL_SUCCESS,rc,szSQLSETSTMTATTR);
  4862.         else
  4863.             RETCHECK(SQL_ERROR,rc,szSQLSETSTMTATTR);
  4864.         }
  4865.  
  4866.     if((!fSupportSetStmtAttr) && fSupportGetStmtAttr)
  4867.         {
  4868.         //test SQL_MAX_LENGTH
  4869.         rc = SQLGetStmtAttr(hstmt,SQL_MAX_LENGTH,&pvParam,sizeof(pvParam),NULL);
  4870.         if(!FindError(SQL_HANDLE_STMT,szHYC00))
  4871.             RETCHECK(SQL_SUCCESS,rc,szSQLGETSTMTATTR);
  4872.         else
  4873.             RETCHECK(SQL_ERROR,rc,szSQLGETSTMTATTR);
  4874.         //test SQL_ATTR_METADATA_ID -- new in 3.0
  4875.         rc = SQLGetStmtAttr(hstmt,SQL_ATTR_METADATA_ID,&pvParam,sizeof(pvParam),NULL);
  4876.         if(!FindError(SQL_HANDLE_STMT,szHYC00))
  4877.             RETCHECK(SQL_SUCCESS,rc,szSQLGETSTMTATTR);
  4878.         else
  4879.             RETCHECK(SQL_ERROR,rc,szSQLGETSTMTATTR);
  4880.         }
  4881.     
  4882.     if(fSupportSetStmtAttr && fSupportGetStmtAttr)
  4883.         {
  4884.         
  4885.         //test SQL_MAX_LENGTH
  4886.         rgbValue = 300;
  4887.         rc = SQLSetStmtAttr(hstmt,SQL_MAX_LENGTH,(PTR)rgbValue,sizeof(rgbValue));
  4888.         if(!FindError(SQL_HANDLE_STMT,szHYC00))
  4889.             {
  4890.             RETCHECK(SQL_SUCCESS,rc,szSQLSETSTMTATTR);
  4891.             rc = SQLGetStmtAttr(hstmt,SQL_MAX_LENGTH,&pvParam,sizeof(pvParam),NULL);
  4892.             if(!FindError(SQL_HANDLE_STMT,szHYC00))
  4893.                 {
  4894.                 RETCHECK(SQL_SUCCESS,rc,szSQLGETSTMTATTR);
  4895.                 if(pvParam != 300)
  4896.                     DISPLAYERROR(szSQLGETSTMTATTR,TEXT("SQL_MAX_LENGTH returned incorrect value"));
  4897.                 }
  4898.             else
  4899.                 RETCHECK(SQL_ERROR,rc,szSQLGETSTMTATTR);
  4900.             }
  4901.         else
  4902.             RETCHECK(SQL_ERROR,rc,szSQLSETSTMTATTR);
  4903.         
  4904.     
  4905.         //test SQL_ATTR_METADATA_ID -- new in 3.0
  4906.         rgbValue = SQL_FALSE;
  4907.         rc = SQLSetStmtAttr(hstmt,SQL_ATTR_METADATA_ID,(PTR)rgbValue,sizeof(rgbValue));
  4908.         if (!FindError(SQL_HANDLE_STMT,szHYC00) && !FindError(SQL_HANDLE_STMT,szHY092))
  4909.             RETCHECK(SQL_SUCCESS,rc,szSQLSETSTMTATTR);
  4910.  
  4911.         rc2 = SQLGetStmtAttr(hstmt,SQL_ATTR_METADATA_ID,&pvParam,sizeof(pvParam),NULL);
  4912.         if (!FindError(SQL_HANDLE_STMT,szHYC00) && !FindError(SQL_HANDLE_STMT,szHY092))
  4913.             RETCHECK(SQL_SUCCESS,rc,szSQLGETSTMTATTR);
  4914.  
  4915.         if (RC_SUCCESSFUL(rc) && RC_SUCCESSFUL(rc2) && pvParam != SQL_FALSE)
  4916.             DISPLAYERROR(szSQLGETSTMTATTR,TEXT("SQL_ATTR_METADATA_ID returned incorrect value"));
  4917.     }
  4918.  
  4919. } //TestSQLSetStmtAttr()
  4920.  
  4921. //--------------------------------------------------------------------------------
  4922. // FUNCTION:    TestOneThread
  4923. // PURPOSE:        This function allocates the statement handle, performs simple 
  4924. //                queries and deallocates the statement handle.  This function is called
  4925. //                by testthreading.
  4926. //--------------------------------------------------------------------------------
  4927. static int TestOneThread(THREAD_STRUCT *ptArg)
  4928. {
  4929.     HENV        henv0 = ptArg->henv;
  4930.     HDBC        hdbc0 = ptArg->hdbc;
  4931.     HSTMT        hstmt0 = NULL;
  4932.     //RETCODE    rc=SQL_SUCCESS;
  4933.  
  4934.     /* allocate new statment handle */
  4935.     if (RC_NOTSUCCESSFUL(SQLAllocHandle(SQL_HANDLE_STMT,hdbc0, &hstmt0)))
  4936.         return(FALSE);
  4937.  
  4938.     /* perform some simple catalog functions */
  4939.     if (RC_NOTSUCCESSFUL(SQLStatistics(hstmt0,NULL,SQL_NTS,NULL,SQL_NTS,NULL,SQL_NTS,SQL_INDEX_ALL,SQL_QUICK)))
  4940.         return(FALSE);
  4941.  
  4942.     if (RC_NOTSUCCESSFUL(SQLCloseCursor(hstmt0)))
  4943.         return(FALSE);
  4944.  
  4945.     /* Get some data */
  4946.     GetSomeData(hstmt0, ptArg->szTableName, TRUE,ptArg->rgFieldInfo);
  4947.  
  4948.     if (RC_NOTSUCCESSFUL(SQLGetTypeInfo(hstmt0,SQL_CHAR)))
  4949.         return(FALSE);
  4950.  
  4951.     // Cleanup
  4952.     if (RC_NOTSUCCESSFUL(SQLFreeHandle(SQL_HANDLE_STMT,hstmt0)))
  4953.         return(FALSE);
  4954.  
  4955.     return(TRUE);
  4956.  
  4957. } //end of TestOneThread
  4958.  
  4959. //--------------------------------------------------------------------------------
  4960. // FUNCTION:    ThreadLoop
  4961. // PURPOSE:        This is the main loop for the threads, and it's called by 
  4962. //                CreateThread() API.
  4963. //--------------------------------------------------------------------------------
  4964. DWORD WINAPI ThreadLoop(void *pArg)
  4965. {
  4966.  
  4967.     THREAD_STRUCT *ptArg = (THREAD_STRUCT *)pArg;
  4968.     int i;
  4969.     RETCODE    rc;
  4970.  
  4971.     for(i=0; i< NUM_THREAD; i++)
  4972.         TestOneThread(ptArg);
  4973.  
  4974.     // free connection handle for each thread
  4975.     rc=SQLDisconnect(ptArg->hdbc);
  4976.     RETCHECK(SQL_SUCCESS,rc,szSQLDISCONNECT);
  4977.     rc=SQLFreeHandle(SQL_HANDLE_DBC,ptArg->hdbc);
  4978.     RETCHECK(SQL_SUCCESS,rc,szSQLFREEHANDLE);
  4979.  
  4980.        return(0);
  4981. } //end of ThreadLoop
  4982.  
  4983.  
  4984. //-------------------------------------------------------------------------------
  4985. // FUNCTION:    TestThreading
  4986. // PURPOSE:        This function tests the multi-threading capabilities of the 
  4987. //                driver by creating multiple threads that connect to the same data
  4988. //                 source.  Once connected, each thread performs simple queries to 
  4989. //                test that the driver handles these queries successfully.
  4990. //                This function is to be called inside AutoTestFunc() in QuikTest.
  4991. //--------------------------------------------------------------------------------
  4992. void TestThreading(lpSERVERINFO lpSI,QTSTRUCT  *lpqt,FIELDINFO *rgFieldInfo)
  4993. {
  4994.     RETCODE rc=SQL_SUCCESS;
  4995.    THREAD_STRUCT *pArg;
  4996.    HANDLE hThread[NUM_THREAD];
  4997.     DWORD dwThreadId;
  4998.     UWORD i;
  4999.     HENV    henv1;
  5000.     HDBC    hdbc1;
  5001.     
  5002.  
  5003.     // allocate memory for the threads
  5004.     pArg = (THREAD_STRUCT *)AllocateMemory((NUM_THREAD) * sizeof(THREAD_STRUCT));
  5005.  
  5006.     if(!pArg)
  5007.     {
  5008.         szWrite(TEXT("\t\t\tMultiThreading Test interrupted due to error in memory allocation"), TRUE);
  5009.         return;
  5010.     }
  5011.     
  5012.     // only one environment handle will be needed for all threads
  5013.     rc = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &henv1);
  5014.     RETCHECK(SQL_SUCCESS, rc,szSQLALLOCHANDLE);
  5015.  
  5016.     // Set environment attribute, or we can't allocate connection
  5017.     rc = SQLSetEnvAttr(henv1, SQL_ATTR_ODBC_VERSION, (SQLPOINTER)SQL_OV_ODBC3,
  5018.         SQL_IS_UINTEGER);
  5019.     RETCHECK(SQL_SUCCESS, rc,szSQLSETENVATTR);
  5020.  
  5021.     for (i=0; i < NUM_THREAD; i++ ) 
  5022.     {
  5023.         // allocate connection handle for each thread
  5024.         rc=SQLAllocHandle(SQL_HANDLE_DBC,henv1, &hdbc1);
  5025.         RETCHECK(SQL_SUCCESS, rc,szSQLALLOCHANDLE);
  5026.  
  5027.         // create string to be used in connecting
  5028.         wsprintf(lpqt->sz,TEXT("dsn=%s;uid=%s;pwd=%s;"),
  5029.         lpSI->szValidServer0,
  5030.         lpSI->szValidLogin0,
  5031.         lpSI->szValidPassword0);
  5032.  
  5033.         SQLDriverConnect(hdbc1, lpSI->hwnd, lpqt->sz,
  5034.         SQL_NTS, lpqt->buf, MAX_STRING_SIZE, NULL, SQL_DRIVER_COMPLETE);
  5035.  
  5036.         // initialize thread structure
  5037.         pArg[i].henv = henv1;
  5038.         pArg[i].hdbc = hdbc1;
  5039.         lstrcpy(pArg[i].szTableName, lpqt->szTableName);
  5040.         pArg[i].rgFieldInfo=rgFieldInfo[0];
  5041.  
  5042.         // start thread
  5043.         hThread[i]= CreateThread(NULL,
  5044.                             0,
  5045.                             ThreadLoop,
  5046.                             &pArg[i],
  5047.                             0,
  5048.                             &dwThreadId);
  5049.  
  5050.         if(hThread[i]==0)
  5051.         {
  5052.             DISPLAYERROR(TEXT("TestThread failed:"),TEXT("cannot create thread"));
  5053.             break;
  5054.         }
  5055.     }
  5056.  
  5057.     // wait for thread completion
  5058.     WaitForMultipleObjects(NUM_THREAD,hThread,TRUE,INFINITE);
  5059.  
  5060.     for(i=0; i<NUM_THREAD; i++ )
  5061.         CloseHandle(hThread[i]);
  5062.  
  5063.     SQLFreeHandle(SQL_HANDLE_ENV,henv1);
  5064.     if (pArg)
  5065.         ReleaseMemory(pArg);
  5066. }    //end of TestThreading()
  5067.  
  5068.  
  5069. //-----------------------------------------------------------------------
  5070. //      Function:               CreateDescRecord
  5071. //-----------------------------------------------------------------------
  5072. SWORD CreateDescRecord(SQLHDESC hdesc, SQLHSTMT hstmt, UWORD uwDescType)
  5073. {
  5074.     UDWORD cbColDef;
  5075.     SWORD swColCount;
  5076.     SQLRETURN rc;
  5077.     SWORD fType, fSQLType;
  5078.     SWORD ibScale;
  5079.     TCHAR rgBuf[100];
  5080.  
  5081.     switch(uwDescType) {
  5082.         case SQL_ATTR_APP_ROW_DESC:
  5083.             rc = SQLSetDescField(hdesc, 1, SQL_DESC_TYPE, (SQLPOINTER)SQL_C_DEFAULT,
  5084.                 SQL_IS_SMALLINT);
  5085.             ERRSHANDLE(SQL_HANDLE_DESC, hdesc, SQL_SUCCESS, rc,szSQLSETDESCFIELD);
  5086.             
  5087.             if (SQL_SUCCEEDED(rc))
  5088.                 return 1;
  5089.  
  5090.             rc=SQLBindCol(hstmt, 1, SQL_C_TCHAR, rgBuf, sizeof(rgBuf), NULL);
  5091.             RETCHECK(SQL_SUCCESS, rc,szSQLBINDCOL);
  5092.             if (SQL_SUCCEEDED(rc))
  5093.                 return 1;    
  5094.             break;
  5095.         case SQL_ATTR_IMP_PARAM_DESC:
  5096.         case SQL_ATTR_APP_PARAM_DESC:
  5097.             // Select statement has already been done by this time
  5098.             rc=SQLDescribeCol(hstmt, 1, NULL, 0, NULL, &fSQLType, &cbColDef, 
  5099.                 &ibScale, NULL);
  5100.             RETCHECK(SQL_SUCCESS, rc,szSQLDESCRIBECOL);
  5101.             if (!SQL_SUCCEEDED(rc))
  5102.                 return 0;
  5103.  
  5104.             if (SQL_ATTR_APP_PARAM_DESC == uwDescType)
  5105.                 fType=SQL_C_TCHAR;
  5106.             else
  5107.                 fType=fSQLType;
  5108.  
  5109.             rc = SQLSetDescField(hdesc, 1, SQL_DESC_TYPE, (SQLPOINTER)fType,
  5110.                 SQL_IS_SMALLINT);
  5111.             ERRSHANDLE(SQL_HANDLE_DESC, hdesc, SQL_SUCCESS, rc,szSQLSETDESCFIELD);
  5112.             
  5113.             if (SQL_SUCCEEDED(rc))
  5114.                 return 1;
  5115.  
  5116.             rc=SQLBindParameter(hstmt, 1, SQL_PARAM_INPUT, SQL_C_TCHAR,
  5117.                 fSQLType, cbColDef, ibScale, rgBuf, sizeof(rgBuf), NULL);
  5118.             RETCHECK(SQL_SUCCESS, rc,szSQLDESCRIBECOL);
  5119.             if (SQL_SUCCEEDED(rc))
  5120.                 return 1;
  5121.             break;
  5122.         case SQL_ATTR_IMP_ROW_DESC:
  5123.             // Quiktest has already done the select for us
  5124.             // Need to find out how many cols in result set
  5125.             rc=SQLNumResultCols(hstmt, &swColCount);
  5126.             if (SQL_SUCCEEDED(rc))
  5127.                 return(swColCount);
  5128.             break;
  5129.     }
  5130.     return 0;
  5131. }    //CreateDescRecord
  5132.  
  5133. //-----------------------------------------------------------------------
  5134. //      Function:               CheckDescOp
  5135. //-----------------------------------------------------------------------
  5136. void CheckDescOp(SQLHDESC hdesc, SQLRETURN rc, SQLUSMALLINT uwDescIndex,
  5137.     SQLSMALLINT swDescRecCount, SQLSMALLINT swDescRec, SQLUSMALLINT iDescField,
  5138.     SQLINTEGER swUpdateMode)
  5139. {
  5140.     TCHAR * pszAPI, szOp[10];
  5141.     SQLSMALLINT fValidOp;    // Descriptor types operation is valid for
  5142.  
  5143.     if (DESC_UPDATE_MODE_READ == swUpdateMode)
  5144.     {
  5145.         pszAPI=szSQLGETDESCFIELD;
  5146.         lstrcpy(szOp, TEXT("read"));
  5147.         fValidOp=rgDescInfo[iDescField].fGettable;
  5148.     }
  5149.     else
  5150.     {
  5151.         pszAPI=szSQLSETDESCFIELD;
  5152.         lstrcpy(szOp, TEXT("write"));
  5153.         fValidOp=rgDescInfo[iDescField].fSettable;
  5154.     }
  5155.  
  5156.     // If we're reading beyond the last record, expect SQL_NO_DATA.
  5157.     if (swDescRec > swDescRecCount && DESC_UPDATE_MODE_READ == swUpdateMode)
  5158.     {
  5159.         wsprintf(buf,TEXT("%s: Able to %s descriptor field %s in the %s beyond last record."),
  5160.                 pszAPI, szOp, rgDescInfo[iDescField].szDescFieldName, DescTypes[uwDescIndex].szDescName);
  5161.         ERRSHANDLE(SQL_HANDLE_DESC, hdesc, SQL_NO_DATA, rc, buf);
  5162.     }
  5163.     else
  5164.     {
  5165.         if (fValidOp & DescTypes[uwDescIndex].uwTypeMask)
  5166.         {
  5167.             wsprintf(buf,TEXT("%s: Unable to %s descriptor field %s in the %s"),
  5168.                     pszAPI, szOp, rgDescInfo[iDescField].szDescFieldName, DescTypes[uwDescIndex].szDescName);
  5169.             ERRSHANDLE(SQL_HANDLE_DESC, hdesc, SQL_SUCCESS, rc, buf);
  5170.         }
  5171.         else
  5172.         {
  5173.             wsprintf(buf,TEXT("%s: Able to %s descriptor field %s in the %s"),
  5174.                     pszAPI, szOp, rgDescInfo[iDescField].szDescFieldName, DescTypes[uwDescIndex].szDescName);
  5175.             ERRSHANDLE(SQL_HANDLE_DESC, hdesc, SQL_ERROR, rc, buf);
  5176.         }
  5177.     }
  5178. }
  5179.  
  5180. //-----------------------------------------------------------------------
  5181. //
  5182. // Function: CompareDescField
  5183. //
  5184. // Compares two fields from the given descriptor, or to rgDescInfo if hdesc2
  5185. // is NULL.  uwDescField contains the entry in rgDescInfo for the desired field 
  5186. //-----------------------------------------------------------------------
  5187.  
  5188. void CompareDescField(SQLHDESC hdesc1, SQLHDESC hdesc2, SQLUSMALLINT uwDescIndex,
  5189.     SQLSMALLINT swDescRec, SQLSMALLINT swDescRecCount, SQLUSMALLINT uwDescField,
  5190.     TCHAR * pszAPI)
  5191. {
  5192.     SQLRETURN rc;
  5193.      SQLTCHAR DescBuf2[MAX_DESC_BUF];
  5194.     SQLINTEGER cbValue2; 
  5195.  
  5196.     // Make sure we've got a valid descriptor handle for hdesc1
  5197.     // (hdesc2 is allowed to be NULL)
  5198.     if (SQL_NULL_HDESC == hdesc1) {
  5199.         wsprintf(buf,TEXT("\t\tCompareDescriptor: hdesc1 handle was null!"));
  5200.         DISPLAYERROR(pszAPI, buf);
  5201.         return;
  5202.     }
  5203.  
  5204.     // Read the value from hdesc1
  5205.     rc = SQLGetDescField(hdesc1, swDescRec, rgDescInfo[uwDescField].uwDescField,
  5206.         &DescBuf, sizeof(DescBuf), &cbValue);
  5207.  
  5208.     CheckDescOp(hdesc1, rc, uwDescIndex, swDescRecCount, swDescRec, uwDescField, DESC_UPDATE_MODE_READ);
  5209.  
  5210.     cbValue2=rgDescInfo[uwDescField].cbValue;
  5211.  
  5212.     // Get the value to compare to
  5213.     if (SQL_NULL_HDESC == hdesc2) {
  5214.  
  5215.         // Compare to rgDescInfo if it's settable
  5216.         if (rgDescInfo[uwDescField].fSettable & DescTypes[uwDescIndex].uwTypeMask) {
  5217.             
  5218.             // Copy the set value into DescBuf2.  For char fields size is 0
  5219.             // (unknown), and the new value is actually the pointer to the start
  5220.             // of the string.
  5221.             SQLPOINTER pNewvalue = &(rgDescInfo[uwDescField].NewValue);
  5222.             
  5223.             if (!rgDescInfo[uwDescField].size)
  5224.             {
  5225.                 pNewvalue = (SQLPOINTER)rgDescInfo[uwDescField].NewValue;
  5226.                 cbValue2    = (lstrlen(pNewvalue)+1) * sizeof(TCHAR); 
  5227.             }
  5228.  
  5229.             memcpy(&DescBuf2, pNewvalue, cbValue2);
  5230.         }
  5231.     }
  5232.     else {
  5233.  
  5234.         // Compare to hdesc2
  5235.         rc = SQLGetDescField(hdesc2, swDescRec, rgDescInfo[uwDescField].uwDescField,
  5236.             &DescBuf2, sizeof(DescBuf2), &cbValue);
  5237.  
  5238.         // Since hdesc2 is an unassociated hdesc, treat it as an ARD
  5239.         // (uwDescIndex=0)
  5240.         CheckDescOp(hdesc2, rc, 0, swDescRecCount, swDescRec, uwDescField, DESC_UPDATE_MODE_READ);
  5241.     }
  5242.  
  5243.     // Perform the compare if settable in source desc and settable in
  5244.     // target desc (application descriptors) when using hdesc2
  5245.     if (rgDescInfo[uwDescField].fSettable & DescTypes[uwDescIndex].uwTypeMask)
  5246.     {
  5247.         if (!hdesc2 || (rgDescInfo[uwDescField].fSettable & DESC_ARD))
  5248.         {
  5249.             // IPD field SQL_DESC_TYPE is settable for consitency check, but set
  5250.             // value can't be retrieved, so skip compare in this case
  5251.             if (SQL_ATTR_IMP_PARAM_DESC != DescTypes[uwDescIndex].uwDescType ||
  5252.                 SQL_DESC_DATA_PTR != rgDescInfo[uwDescField].uwDescField)
  5253.             {
  5254.                 if (memcmp(DescBuf, DescBuf2, cbValue2)) {
  5255.                     // Compare error, print message
  5256.                     wsprintf(buf,TEXT("Compare error in %s field %s"),
  5257.                         DescTypes[uwDescIndex].szDescName,rgDescInfo[uwDescField].szDescFieldName);
  5258.                     DISPLAYERROR(pszAPI, buf);
  5259.                 }
  5260.             }
  5261.         }
  5262.     }
  5263. }
  5264.  
  5265.  
  5266. //-----------------------------------------------------------------------
  5267. //
  5268. // Function:  CheckDescriptor
  5269. //
  5270. // Checks all fields in all records of given descriptor.  If swUpdateMode is
  5271. // DESC_UPDATE_MODE_READ then all fields are read, otherwise all updatable
  5272. // fields are written.
  5273. //-----------------------------------------------------------------------
  5274. void CheckDescriptor(SQLHDESC hdesc, SQLINTEGER swUpdateMode, SQLHSTMT hstmt, UWORD uwDescIndex)
  5275. {
  5276.      SQLINTEGER cbValue2;
  5277.     SQLSMALLINT swDescRec=0, swDescRecCount, swAdditionalRecs=0;
  5278.     SQLUSMALLINT iDescField, iStartField=0;
  5279.     SQLRETURN rc;
  5280.  
  5281.     // Get the descriptor record count.
  5282.     rc = SQLGetDescField(hdesc, 0, SQL_DESC_COUNT, &swDescRecCount,
  5283.         sizeof(swDescRecCount), &cbValue);
  5284.  
  5285.     if (SQL_SUCCESS == rc) {
  5286.  
  5287.         // In read mode, try to read one past last record
  5288.         if (swUpdateMode == DESC_UPDATE_MODE_READ)
  5289.             swAdditionalRecs=1;
  5290.  
  5291.         // Check all records, including header
  5292.         for (swDescRec=0; swDescRec <= swDescRecCount+swAdditionalRecs; swDescRec++) {
  5293.  
  5294.             // Check all fields
  5295.             for (iDescField=iStartField; iDescField < sizeof(rgDescInfo)/sizeof(rgDescInfo[0]); iDescField++) {
  5296.  
  5297.                 // If we've gone past the header fields, then break out of loop to check record fields
  5298.                 if (0 == swDescRec && !rgDescInfo[iDescField].fHeader) {
  5299.                     iStartField=iDescField;
  5300.                     break;
  5301.                 }
  5302.  
  5303.                 if (DESC_UPDATE_MODE_READ == swUpdateMode)
  5304.                 {
  5305.                     // Read from the field
  5306.                     rc = SQLGetDescField(hdesc, swDescRec, rgDescInfo[iDescField].uwDescField,
  5307.                         &DescBuf, sizeof(DescBuf), &cbValue);
  5308.                     
  5309.                     CheckDescOp(hdesc, rc, uwDescIndex, swDescRecCount, swDescRec, iDescField, swUpdateMode);
  5310.  
  5311.                     if (RC_SUCCESSFUL(rc))
  5312.                     {
  5313.                         // Compare cbValue with expected
  5314.                         cbValue2=rgDescInfo[iDescField].cbValue; // For most fields
  5315.  
  5316.                         if (!rgDescInfo[iDescField].size)
  5317.                             cbValue2 = lstrlen((LPTSTR)DescBuf);  // For string fields
  5318.  
  5319.                         // Make sure cbValue and cbValue2 agree
  5320.                         if (cbValue != cbValue2)
  5321.                         {
  5322.                             wsprintf(buf,TEXT("Compare error in %s field %s, expected")\
  5323.                                 TEXT(" StringLength %d, received %d"), DescTypes[uwDescIndex].szDescName,
  5324.                                 rgDescInfo[iDescField].szDescFieldName, cbValue2, cbValue);
  5325.                             DISPLAYERROR(szSQLGETDESCFIELD, buf);
  5326.                         }
  5327.                     }
  5328.                 }
  5329.                 else
  5330.                 {
  5331.                     // Write to the field.  For char fields size is 0 (unknown),
  5332.                     // so compute the length of the string
  5333.                     rc = SQLSetDescField(hdesc, swDescRec, rgDescInfo[iDescField].uwDescField,
  5334.                         (SQLPOINTER)rgDescInfo[iDescField].NewValue,
  5335.                         (rgDescInfo[iDescField].size) ? rgDescInfo[iDescField].size :
  5336.                         lstrlen((LPTSTR)rgDescInfo[iDescField].NewValue)*sizeof(TCHAR));
  5337.  
  5338.                     CheckDescOp(hdesc, rc, uwDescIndex, swDescRecCount, swDescRec, iDescField, swUpdateMode);
  5339.  
  5340.                     if (RC_SUCCESSFUL(rc))
  5341.                         CompareDescField(hdesc, NULL, uwDescIndex, swDescRec, swDescRecCount,iDescField, szSQLSETDESCFIELD);
  5342.                 }
  5343.             }
  5344.         }
  5345.     }
  5346.     else {
  5347.         // Unable to read record count from descriptor header, can't proceed
  5348.         wsprintf(buf,TEXT("\t\tUnable to read record count from descriptor header."));
  5349.         ERRSHANDLE(SQL_HANDLE_DESC, hdesc, SQL_SUCCESS, rc, buf);
  5350.     }
  5351. }
  5352.  
  5353. //-----------------------------------------------------------------------
  5354. //
  5355. // Function:  CompareDescriptor
  5356. //
  5357. // Compares two descriptors, or if hdesc2 is NULL compares hdesc1 to rgDescInfo
  5358. // updatable columns
  5359. //-----------------------------------------------------------------------
  5360.  
  5361. void CompareDescriptor(SQLHDESC hdesc1, SQLHDESC hdesc2, UWORD uwDescIndex, TCHAR * pszAPI)
  5362. {
  5363.      SQLSMALLINT swDescRec, swDescRecCount;
  5364.     SQLUSMALLINT iDescField, iStartField=0;
  5365.     SQLRETURN rc;
  5366.  
  5367.     // Make sure we've got a valid descriptor handle for hdesc1
  5368.     // (hdesc2 is allowed to be NULL)
  5369.     if (SQL_NULL_HDESC == hdesc1) {
  5370.         wsprintf(buf,TEXT("\t\thCompareDescriptor: hdesc1 handle was null!"));
  5371.         DISPLAYERROR(szSQLGETDESCFIELD, buf);
  5372.         return;
  5373.     }
  5374.  
  5375.     // Get the descriptor record count.
  5376.     rc = SQLGetDescField(hdesc1, 0, SQL_DESC_COUNT, &swDescRecCount,
  5377.         sizeof(swDescRecCount), &cbValue);
  5378.  
  5379.     if (SQL_SUCCESS == rc) {
  5380.  
  5381.         // Check all records, including header
  5382.         for (swDescRec=0; swDescRec <= swDescRecCount; swDescRec++) {
  5383.  
  5384.             // Check all fields
  5385.             for (iDescField=iStartField; iDescField < sizeof(rgDescInfo)/sizeof(rgDescInfo[0]); iDescField++) {
  5386.  
  5387.                 // If we've gone past the header fields, then break out of loop to check record fields
  5388.                 if (0 == swDescRec && !rgDescInfo[iDescField].fHeader) {
  5389.                     iStartField=iDescField;
  5390.                     break;
  5391.                 }
  5392.  
  5393.                 CompareDescField(hdesc1, hdesc2, uwDescIndex, swDescRec, swDescRecCount, iDescField, pszAPI);
  5394.             }
  5395.         }
  5396.     }
  5397.     else {
  5398.         // Unable to read record count from descriptor header, can't proceed
  5399.         wsprintf(buf,TEXT("\t\tUnable to read record count from descriptor header."));
  5400.         ERRSHANDLE(SQL_HANDLE_DESC, hdesc1, SQL_SUCCESS, rc, buf);
  5401.     }
  5402. }
  5403.  
  5404.  
  5405. void CheckDescRecord(SQLHDESC hdesc, SQLSMALLINT swDescRec, SQLSMALLINT fType,
  5406.            SQLSMALLINT fSubType, SQLINTEGER cbLength, SQLSMALLINT ibPrecision, SQLSMALLINT ibScale,
  5407.            SQLPOINTER pData, SQLINTEGER *pcbValue, SQLINTEGER *pIndicator, SQLUSMALLINT iDescType)
  5408. {
  5409.     SQLINTEGER Length, * pIndicator2;
  5410.     PTR pDescPtr;
  5411.     SQLRETURN rc;
  5412.     SQLSMALLINT fType2, fSubType2, cbName, Precision, Scale, Nullable;
  5413.     TCHAR    szName[MAX_DESC_BUF]=TEXT("");
  5414.  
  5415.     // Write the record
  5416.     rc = SQLSetDescRec(hdesc, swDescRec, fType, fSubType, cbLength, ibPrecision, 
  5417.         ibScale, pData, pcbValue, pIndicator);
  5418.  
  5419.     // Can't set IRD, so it should error
  5420.     if (SQL_ATTR_IMP_ROW_DESC == DescTypes[iDescType].uwDescType)
  5421.         ERRSHANDLE(SQL_HANDLE_DESC, hdesc, SQL_ERROR, rc, szSQLSETDESCREC);
  5422.     else
  5423.     {
  5424.         wsprintf(buf,TEXT("%s: Unable to write record %d in %s"),
  5425.             szSQLSETDESCREC, swDescRec, DescTypes[iDescType].szDescName);
  5426.         ERRSHANDLE(SQL_HANDLE_DESC, hdesc, SQL_SUCCESS, rc, buf);
  5427.     }
  5428.  
  5429.     if (RC_SUCCESSFUL(rc))
  5430.     {
  5431.         // Read it again
  5432.         rc = SQLGetDescRec(hdesc, swDescRec, szName, sizeof(szName), &cbName, &fType2,
  5433.             &fSubType2, &Length, &Precision, &Scale, &Nullable);
  5434.  
  5435.         wsprintf(buf,TEXT("%s: Unable to read record %d in %s"),
  5436.             szSQLGETDESCREC, swDescRec, DescTypes[iDescType].szDescName);
  5437.         ERRSHANDLE(SQL_HANDLE_DESC, hdesc, SQL_SUCCESS, rc, buf);
  5438.  
  5439.         if (RC_SUCCESSFUL(rc))
  5440.         {
  5441.             // Compare values
  5442.             if (fType2 != fType)
  5443.                 DISPLAYERROR(szSQLSETDESCREC,TEXT("fType not set correctly"));
  5444.             
  5445.             if (Precision != ibPrecision)
  5446.                 DISPLAYERROR(szSQLSETDESCREC,TEXT("ibPrecision not set correctly"));
  5447.  
  5448.             switch(fType)
  5449.             {
  5450.                 case SQL_DECIMAL:
  5451.                 case SQL_NUMERIC:
  5452.                 case SQL_C_DOUBLE:
  5453.                 case SQL_C_FLOAT:
  5454.                     // Scale is only defined for NUMERIC or DECIMAL types
  5455.                     if (Scale != ibScale)
  5456.                         DISPLAYERROR(szSQLSETDESCREC,TEXT("ibScale not set correctly"));
  5457.                     break;
  5458.                 case SQL_DATETIME:
  5459.                 case SQL_INTEGER:
  5460.                     // Subtype is only valid for DATETIME or INTERVAL types
  5461.                     if (fSubType2 != fSubType)
  5462.                         DISPLAYERROR(szSQLSETDESCREC,TEXT("fSubType not set correctly"));
  5463.                     break;
  5464.             }
  5465.  
  5466.             // For application descriptors, compare the Length and get the
  5467.             // data ptr value to check for accuracy
  5468.             switch(DescTypes[iDescType].uwDescType)
  5469.             {
  5470.                 case SQL_ATTR_APP_ROW_DESC:
  5471.                 case SQL_ATTR_APP_PARAM_DESC:
  5472.  
  5473.                     if (Length != cbLength)
  5474.                         DISPLAYERROR(szSQLSETDESCREC,TEXT("cbLength not set correctly"));
  5475.  
  5476.                     rc = SQLGetDescField(hdesc, swDescRec, SQL_DESC_DATA_PTR,
  5477.                         &pDescPtr, sizeof(PTR), &cbValue);
  5478.                     ERRSHANDLE(SQL_HANDLE_DESC, hdesc, SQL_SUCCESS, rc, szSQLGETDESCFIELD);
  5479.  
  5480.                     if (pDescPtr != pData)
  5481.                         DISPLAYERROR(szSQLSETDESCREC,TEXT("rgbValue not set correctly"));
  5482.  
  5483.                     // Get the octet length ptr value and check for accuracy
  5484.                     rc = SQLGetDescField(hdesc, swDescRec, SQL_DESC_OCTET_LENGTH_PTR,
  5485.                         &pDescPtr, sizeof(PTR), &cbValue);
  5486.                     ERRSHANDLE(SQL_HANDLE_DESC, hdesc, SQL_SUCCESS, rc, szSQLGETDESCFIELD);
  5487.  
  5488.                     if (pDescPtr != pcbValue)
  5489.                         DISPLAYERROR(szSQLSETDESCREC,TEXT("cbValue not set correctly"));
  5490.  
  5491.                     rc = SQLGetDescField(hdesc, swDescRec, SQL_DESC_INDICATOR_PTR,
  5492.                         &pIndicator2, sizeof(PTR), &cbValue);
  5493.                     ERRSHANDLE(SQL_HANDLE_DESC, hdesc, SQL_SUCCESS, rc, szSQLGETDESCFIELD);
  5494.  
  5495.                     if (pIndicator2 != pIndicator)
  5496.                         DISPLAYERROR(szSQLSETDESCREC,TEXT("Indicator not set correctly"));
  5497.                     
  5498.                     break;
  5499.                 case SQL_ATTR_IMP_ROW_DESC:
  5500.                 case SQL_ATTR_IMP_PARAM_DESC:
  5501.                     break;
  5502.                 default:
  5503.                     DISPLAYERROR(szSQLSETDESCREC,TEXT("Unknown descriptor type."));
  5504.             }
  5505.         }
  5506.     }
  5507.  
  5508. }
  5509.  
  5510. SQLRETURN DescBindParameter(SQLHSTMT hstmt, SQLUSMALLINT ipar,
  5511.     SQLSMALLINT fParamType, SQLSMALLINT fCType, SQLSMALLINT fSqlType,
  5512.     SQLUINTEGER cbColDef, SQLSMALLINT ibScale, SQLPOINTER rgbValue,
  5513.     SQLINTEGER cbValueMax, SQLINTEGER  *pcbValue)
  5514. {
  5515.     SQLHDESC hdescAPD, hdescIPD;
  5516.     SQLRETURN rc;
  5517.  
  5518.     rc = SQLGetStmtAttr(hstmt, SQL_ATTR_APP_PARAM_DESC, &hdescAPD, sizeof(hdescAPD), NULL);  
  5519.     if (!RETCHECK(SQL_SUCCESS, rc,szSQLGETSTMTATTR))
  5520.         return rc;
  5521.  
  5522.     rc = SQLGetStmtAttr(hstmt, SQL_ATTR_IMP_PARAM_DESC, &hdescIPD, sizeof(hdescIPD), NULL);  
  5523.     if (!RETCHECK(SQL_SUCCESS, rc,szSQLGETSTMTATTR))
  5524.         return rc;
  5525.  
  5526.     // Parameter type
  5527.     rc = SQLSetDescField(hdescIPD, ipar, SQL_DESC_PARAMETER_TYPE, (SQLPOINTER)fParamType,
  5528.         SQL_IS_SMALLINT);        // Set ipar and fParamType for IPD
  5529.     if (!ERRSHANDLE(SQL_HANDLE_DESC, hdescIPD, SQL_SUCCESS, rc,szSQLSETDESCFIELD))
  5530.         return rc;
  5531.     
  5532.     // C type
  5533.     rc = SQLSetDescField(hdescAPD, ipar, SQL_DESC_CONCISE_TYPE, (SQLPOINTER)fCType,
  5534.         SQL_IS_SMALLINT);        // Set ipar and fCType of APD
  5535.     if (!ERRSHANDLE(SQL_HANDLE_DESC, hdescAPD, SQL_SUCCESS, rc,szSQLSETDESCFIELD))
  5536.         return rc;
  5537.  
  5538.     // Sql type
  5539.     rc = SQLSetDescField(hdescIPD, ipar, SQL_DESC_CONCISE_TYPE, (SQLPOINTER)fSqlType,
  5540.         SQL_IS_SMALLINT);        // Set fSqlType of IPD
  5541.     if (!ERRSHANDLE(SQL_HANDLE_DESC, hdescIPD, SQL_SUCCESS, rc,szSQLSETDESCFIELD))
  5542.         return rc;
  5543.  
  5544.     // Column Size (Length or Precision)
  5545.     if (fSqlType == SQL_CHAR ||
  5546.         fSqlType == SQL_VARCHAR ||
  5547.         fSqlType == SQL_LONGVARCHAR ||
  5548.         fSqlType == SQL_BINARY ||
  5549.         fSqlType == SQL_VARBINARY ||
  5550.         fSqlType == SQL_LONGVARBINARY ||
  5551.         fSqlType == SQL_TYPE_DATE ||
  5552.         fSqlType == SQL_TYPE_TIME ||
  5553.         fSqlType == SQL_TYPE_TIMESTAMP ||
  5554.         (fSqlType >= SQL_INTERVAL_YEAR &&
  5555.          fSqlType <= SQL_INTERVAL_MINUTE_TO_SECOND))
  5556.     {
  5557.         rc = SQLSetDescField(hdescIPD, ipar, SQL_DESC_LENGTH, (SQLPOINTER)cbColDef,
  5558.             SQL_IS_UINTEGER);        // Set cbColDef (Length) of IPD
  5559.         if (!ERRSHANDLE(SQL_HANDLE_DESC, hdescIPD, SQL_SUCCESS, rc,szSQLSETDESCFIELD))
  5560.             return rc;
  5561.     }
  5562.     else if (fSqlType == SQL_DECIMAL ||
  5563.              fSqlType == SQL_NUMERIC ||
  5564.              fSqlType == SQL_FLOAT ||
  5565.              fSqlType == SQL_REAL ||
  5566.              fSqlType == SQL_DOUBLE)
  5567.     {
  5568.         rc = SQLSetDescField(hdescIPD, ipar, SQL_DESC_PRECISION, (SQLPOINTER)cbColDef,
  5569.             SQL_IS_SMALLINT);        // Set cbColDef (Precision) of IPD
  5570.         if (!ERRSHANDLE(SQL_HANDLE_DESC, hdescIPD, SQL_SUCCESS, rc,szSQLSETDESCFIELD))
  5571.             return rc;
  5572.     }
  5573.  
  5574.     // Scale
  5575.     if (fSqlType == SQL_TYPE_DATE ||
  5576.         fSqlType == SQL_TYPE_TIME ||
  5577.         fSqlType == SQL_TYPE_TIMESTAMP ||
  5578.         (fSqlType >= SQL_INTERVAL_YEAR &&
  5579.          fSqlType <= SQL_INTERVAL_MINUTE_TO_SECOND))
  5580.     {
  5581.         switch(fSqlType)
  5582.         {
  5583.             case SQL_TYPE_TIME:
  5584.             case SQL_TYPE_TIMESTAMP:
  5585.             case SQL_INTERVAL_SECOND:
  5586.             case SQL_INTERVAL_DAY_TO_SECOND:
  5587.             case SQL_INTERVAL_HOUR_TO_SECOND:
  5588.             case SQL_INTERVAL_MINUTE_TO_SECOND:
  5589.                 rc = SQLSetDescField(hdescIPD, ipar, SQL_DESC_PRECISION, (SQLPOINTER)ibScale,
  5590.                     SQL_IS_SMALLINT);        // Set scale of IPD
  5591.                 if (!ERRSHANDLE(SQL_HANDLE_DESC, hdescIPD, SQL_SUCCESS, rc,szSQLSETDESCFIELD))
  5592.                     return rc;
  5593.                 break;
  5594.             default:
  5595.                 rc = SQLSetDescField(hdescIPD, ipar, SQL_DESC_PRECISION, (SQLPOINTER)0,
  5596.                     SQL_IS_SMALLINT);        // Set scale of IPD
  5597.                 if (!ERRSHANDLE(SQL_HANDLE_DESC, hdescIPD, SQL_SUCCESS, rc,szSQLSETDESCFIELD))
  5598.                     return rc;
  5599.         }
  5600.     }
  5601.     else
  5602.     {
  5603.         rc = SQLSetDescField(hdescIPD, ipar, SQL_DESC_SCALE, (SQLPOINTER)ibScale,
  5604.             SQL_IS_SMALLINT);        // Set scale of IPD
  5605.         if (!ERRSHANDLE(SQL_HANDLE_DESC, hdescIPD, SQL_SUCCESS, rc,szSQLSETDESCFIELD))
  5606.             return rc;
  5607.     }
  5608.  
  5609.     // cbValueMax
  5610.     rc = SQLSetDescField(hdescAPD, ipar, SQL_DESC_OCTET_LENGTH, (SQLPOINTER)cbValueMax,
  5611.         SQL_IS_INTEGER);        // Set cbValueMax of APD
  5612.     if (!ERRSHANDLE(SQL_HANDLE_DESC, hdescAPD, SQL_SUCCESS, rc,szSQLSETDESCFIELD))
  5613.         return rc;
  5614.  
  5615.     // pcbValue
  5616.     rc = SQLSetDescField(hdescAPD, ipar, SQL_DESC_OCTET_LENGTH_PTR, (SQLPOINTER)pcbValue,
  5617.         SQL_IS_POINTER);        // Set pcbValue/octet length
  5618.     if (!ERRSHANDLE(SQL_HANDLE_DESC, hdescAPD, SQL_SUCCESS, rc,szSQLSETDESCFIELD))
  5619.         return rc;
  5620.  
  5621.     rc = SQLSetDescField(hdescAPD, ipar, SQL_DESC_INDICATOR_PTR, (SQLPOINTER)pcbValue,
  5622.         SQL_IS_POINTER);        // Set pcbValue/indicator
  5623.     if (!ERRSHANDLE(SQL_HANDLE_DESC, hdescAPD, SQL_SUCCESS, rc,szSQLSETDESCFIELD))
  5624.         return rc;
  5625.  
  5626.     // Data ptr
  5627.     rc = SQLSetDescField(hdescAPD, ipar, SQL_DESC_DATA_PTR, (SQLPOINTER)rgbValue,
  5628.         SQL_IS_POINTER);        // Set rgbValue
  5629.     ERRSHANDLE(SQL_HANDLE_DESC, hdescAPD, SQL_SUCCESS, rc,szSQLSETDESCFIELD);
  5630.  
  5631.     return rc;
  5632.  
  5633. }
  5634.  
  5635. SQLRETURN DescBindCol(SQLHSTMT hstmt, SQLSMALLINT icol,
  5636.            SQLSMALLINT fCType, SQLPOINTER rgbValue,
  5637.            SQLINTEGER cbValueMax, SQLINTEGER *pcbValue)
  5638. {
  5639.     SQLHDESC hdesc;
  5640.     SQLRETURN rc;
  5641.  
  5642.     rc = SQLGetStmtAttr(hstmt, SQL_ATTR_APP_ROW_DESC, &hdesc, sizeof(hdesc), NULL);  
  5643.     if (!RETCHECK(SQL_SUCCESS, rc,szSQLGETSTMTATTR))
  5644.         return rc;
  5645.  
  5646.     rc = SQLSetDescField(hdesc, icol, SQL_DESC_CONCISE_TYPE, (SQLPOINTER)fCType,
  5647.         SQL_IS_SMALLINT);        // Set icol and fCType
  5648.     if (!ERRSHANDLE(SQL_HANDLE_DESC, hdesc, SQL_SUCCESS, rc,szSQLSETDESCFIELD))
  5649.         return rc;
  5650.     
  5651.     rc = SQLSetDescField(hdesc, icol, SQL_DESC_OCTET_LENGTH, (SQLPOINTER)cbValueMax,
  5652.         SQL_IS_INTEGER);        // Set cbValueMax
  5653.     if (!ERRSHANDLE(SQL_HANDLE_DESC, hdesc, SQL_SUCCESS, rc,szSQLSETDESCFIELD))
  5654.         return rc;
  5655.  
  5656.     rc = SQLSetDescField(hdesc, icol, SQL_DESC_OCTET_LENGTH_PTR, (SQLPOINTER)pcbValue,
  5657.         SQL_IS_POINTER);        // Set pcbValue/octet length
  5658.     if (!ERRSHANDLE(SQL_HANDLE_DESC, hdesc, SQL_SUCCESS, rc,szSQLSETDESCFIELD))
  5659.         return rc;
  5660.  
  5661.     rc = SQLSetDescField(hdesc, icol, SQL_DESC_INDICATOR_PTR, (SQLPOINTER)pcbValue,
  5662.         SQL_IS_POINTER);        // Set pcbValue/indicator
  5663.     if (!ERRSHANDLE(SQL_HANDLE_DESC, hdesc, SQL_SUCCESS, rc,szSQLSETDESCFIELD))
  5664.         return rc;
  5665.  
  5666.     rc = SQLSetDescField(hdesc, icol, SQL_DESC_DATA_PTR, (SQLPOINTER)rgbValue,
  5667.         SQL_IS_POINTER);        // Set rgbValue
  5668.     ERRSHANDLE(SQL_HANDLE_DESC, hdesc, SQL_SUCCESS, rc,szSQLSETDESCFIELD);
  5669.  
  5670.     return rc;
  5671. }
  5672.  
  5673. //-----------------------------------------------------------------------
  5674. //      Function:               TestGetDescField
  5675. //-----------------------------------------------------------------------
  5676.  
  5677. void  PASCAL TestGetDescField(QTSTRUCT * lpqt)
  5678. {
  5679.     SQLRETURN rc=SQL_SUCCESS;
  5680.     SQLUSMALLINT iDescType;
  5681.  
  5682.     SQLHDESC hdesc1=NULL, hdesc2=NULL;
  5683.     PTR rgbValue=NULL;
  5684.     SQLSMALLINT swDescRecCount, swExpRecCount;
  5685.     SQLINTEGER cbValue;
  5686.     TCHAR    szName[MAX_DESC_BUF]=TEXT("");
  5687.     TCHAR    szQuery[XLARGEBUFF]=TEXT("");
  5688.  
  5689.     if (!Supported(SQL_API_SQLGETDESCFIELD))
  5690.     {
  5691.         // Allocate a default descriptor
  5692.         rc = SQLAllocHandle(SQL_HANDLE_DESC, hdbc, &hdesc);  
  5693.  
  5694.         if (RC_SUCCESSFUL(rc))
  5695.         {
  5696.              rc = SQLGetDescField(hdesc, 0, SQL_DESC_COUNT, &DescBuf, sizeof(DescBuf),
  5697.                 &cbValue);
  5698.  
  5699.             if(!FindError(SQL_HANDLE_DESC,szIM001))
  5700.                 DISPLAYERROR(szSQLGETDESCFIELD, szNotSupported);
  5701.             RETCHECK(SQL_ERROR, rc,szSQLGETDESCFIELD);
  5702.         }
  5703.     }
  5704.     else
  5705.     {
  5706.         // Make sure all parameters and columns are unbound
  5707.         ResetHstmt(&hstmt);
  5708.  
  5709.         // Perform a select stmt
  5710.         wsprintf(szQuery,szSELECTSTAR,lpqt->szTableName);
  5711.         rc = SQLExecDirect(hstmt, szQuery, SQL_NTS);
  5712.         RETCHECK(SQL_SUCCESS, rc,szSQLEXECDIRECT);
  5713.  
  5714.         // For each descriptor type
  5715.         for (iDescType=0; iDescType < sizeof(DescTypes)/sizeof(DescTypes[0]); iDescType++)
  5716.         {
  5717.  
  5718.             // Get the handle for the automatically allocated descriptor
  5719.             rc = SQLGetStmtAttr(hstmt, DescTypes[iDescType].uwDescType, &hdesc1, sizeof(hdesc1), &cbValue);  
  5720.             RETCHECK(SQL_SUCCESS, rc,szSQLGETSTMTATTR);
  5721.  
  5722.             // Create a descriptor record so we have something to read besides header
  5723.             swExpRecCount=CreateDescRecord(hdesc1, hstmt, DescTypes[iDescType].uwDescType);
  5724.  
  5725.             // Get the count of descriptor records (iRecord ignored for header fields)
  5726.             rc = SQLGetDescField(hdesc1, 0, SQL_DESC_COUNT, &swDescRecCount,
  5727.                 sizeof(swDescRecCount), &cbValue);
  5728.  
  5729.             if (SQL_SUCCEEDED(rc)) 
  5730.             {
  5731.                 // Check count value for expected
  5732.                 if (swExpRecCount != swDescRecCount)
  5733.                 {
  5734.                     wsprintf(buf,TEXT("Expected record count %d, found %d"),
  5735.                         swExpRecCount, swDescRecCount);
  5736.                     DISPLAYERROR(szSQLGETDESCFIELD, buf);
  5737.                 }
  5738.  
  5739.                 CheckDescriptor(hdesc1, DESC_UPDATE_MODE_READ, hstmt, iDescType);
  5740.             }
  5741.             else
  5742.             {
  5743.                 // Unable to read record count from descriptor header, can't proceed
  5744.                 wsprintf(buf,TEXT("Unable to read record count from descriptor header for descriptor type %d"),
  5745.                     DescTypes[iDescType].szDescName);
  5746.                 ERRSHANDLE(SQL_HANDLE_DESC, hdesc1, SQL_SUCCESS, rc, buf);
  5747.             }
  5748.         }
  5749.  
  5750.         rc=SQLCloseCursor(hstmt);
  5751.         RETCHECK(SQL_SUCCESS, rc,szSQLCLOSECURSOR);
  5752.     }
  5753.  
  5754.  
  5755. } // TestGetDescField()
  5756.  
  5757. //-----------------------------------------------------------------------
  5758. //      Function:               TestSetDescField
  5759. //-----------------------------------------------------------------------
  5760.  
  5761. void  PASCAL TestSetDescField(QTSTRUCT * lpqt)
  5762. {
  5763.     SQLRETURN rc=SQL_SUCCESS;
  5764.     SQLUSMALLINT iDescType;
  5765.  
  5766.     SQLHDESC hdesc1=NULL, hdesc2=NULL;
  5767.     PTR rgbValue=NULL;
  5768.     SQLSMALLINT swDescRecCount, swExpRecCount;
  5769.     SQLINTEGER cbValue;
  5770.     TCHAR    szName[MAX_DESC_BUF]=TEXT("");
  5771.     TCHAR    szQuery[XLARGEBUFF]=TEXT("");
  5772.  
  5773.  
  5774.     if (!Supported(SQL_API_SQLSETDESCFIELD))
  5775.     {
  5776.         // Allocate a default descriptor
  5777.         rc = SQLAllocHandle(SQL_HANDLE_DESC, hdbc, &hdesc);  
  5778.  
  5779.         if (RC_SUCCESSFUL(rc))
  5780.         {
  5781.             rc = SQLSetDescField(hdesc, 0, SQL_DESC_COUNT, &swDescRecCount,
  5782.                 sizeof(swDescRecCount));
  5783.  
  5784.             if(!FindError(SQL_HANDLE_DESC,szIM001))
  5785.                 DISPLAYERROR(szSQLSETDESCFIELD, szNotSupported);
  5786.             RETCHECK(SQL_ERROR, rc,szSQLSETDESCFIELD);
  5787.         }
  5788.     }
  5789.     else
  5790.     {
  5791.         // Make sure all parameters and columns are unbound
  5792.         ResetHstmt(&hstmt);
  5793.         
  5794.         // Perform a select stmt
  5795.         wsprintf(szQuery,szSELECTSTAR,lpqt->szTableName);
  5796.         rc = SQLExecDirect(hstmt, szQuery, SQL_NTS);
  5797.         RETCHECK(SQL_SUCCESS, rc,szSQLEXECDIRECT);
  5798.  
  5799.         // For each descriptor type
  5800.         for (iDescType=0; iDescType < sizeof(DescTypes)/sizeof(DescTypes[0]); iDescType++)
  5801.         {
  5802.  
  5803.             // Get the handle for the automatically allocated descriptor
  5804.             rc = SQLGetStmtAttr(hstmt, DescTypes[iDescType].uwDescType, &hdesc1, sizeof(hdesc1), &cbValue);  
  5805.             RETCHECK(SQL_SUCCESS, rc,szSQLGETSTMTATTR);
  5806.  
  5807.             // Create a descriptor record so we have something to read besides header
  5808.             swExpRecCount=CreateDescRecord(hdesc1, hstmt, DescTypes[iDescType].uwDescType);
  5809.  
  5810.             // Update all descriptor records to new values
  5811.             CheckDescriptor(hdesc1, DESC_UPDATE_MODE_WRITE, hstmt, iDescType);
  5812.  
  5813.             // Compare the descriptor with the update values
  5814.             // CompareDescriptor(hdesc1, NULL, iDescType, szSQLSETDESCFIELD);
  5815.         }
  5816.  
  5817.         ResetHstmt(&hstmt);
  5818.     }
  5819.  
  5820. } //TestSetDescField()
  5821.  
  5822. //-----------------------------------------------------------------------
  5823. //      Function:               TestGetDescRec
  5824. //-----------------------------------------------------------------------
  5825.  
  5826. void  PASCAL TestGetDescRec(QTSTRUCT * lpqt)
  5827. {
  5828.     SQLRETURN rc=SQL_SUCCESS;
  5829.     SQLUSMALLINT iDescType;
  5830.  
  5831.     SQLHDESC hdesc1=NULL, hdesc2=NULL;
  5832.     PTR rgbValue=NULL;
  5833.     SQLSMALLINT swDescRec, swDescRecCount, iRecord, cbNameMax, cbName, fType, fSubType,
  5834.         Precision, Scale, Nullable, swExpRecCount;
  5835.     SQLINTEGER Length, cbValue;
  5836.     TCHAR    szName[MAX_DESC_BUF]=TEXT("");
  5837.     TCHAR    szQuery[XLARGEBUFF]=TEXT("");
  5838.  
  5839.  
  5840.     if (!Supported(SQL_API_SQLGETDESCREC))
  5841.     {
  5842.         // Allocate a default descriptor
  5843.         rc = SQLAllocHandle(SQL_HANDLE_DESC, hdbc, &hdesc);  
  5844.  
  5845.         if (RC_SUCCESSFUL(rc))
  5846.         {
  5847.             rc = SQLGetDescRec(hdesc, iRecord, szName, cbNameMax, &cbName, &fType,
  5848.                 &fSubType, &Length, &Precision, &Scale, &Nullable);
  5849.  
  5850.             if(!FindError(SQL_HANDLE_DESC,szIM001))
  5851.                 DISPLAYERROR(szSQLGETDESCREC, szNotSupported);
  5852.             RETCHECK(SQL_ERROR, rc,szSQLGETDESCREC);
  5853.         }
  5854.     }
  5855.     else
  5856.     {
  5857.         // Make sure all parameters and columns are unbound
  5858.         ResetHstmt(&hstmt);
  5859.  
  5860.         // Turn on bookmarks so we can retrieve from record 0 of ARD
  5861.         rc = SQLSetStmtAttr(hstmt, SQL_ATTR_USE_BOOKMARKS, (SQLPOINTER)SQL_UB_ON, SQL_IS_INTEGER);
  5862.         RETCHECK(SQL_SUCCESS, rc,szSQLSETSTMTATTR);
  5863.         
  5864.         // Perform a select stmt
  5865.         wsprintf(szQuery,szSELECTSTAR,lpqt->szTableName);
  5866.         rc = SQLExecDirect(hstmt, szQuery, SQL_NTS);
  5867.         RETCHECK(SQL_SUCCESS, rc,szSQLEXECDIRECT);
  5868.  
  5869.         // For each descriptor type
  5870.         for (iDescType=0; iDescType < sizeof(DescTypes)/sizeof(DescTypes[0]); iDescType++)
  5871.         {
  5872.  
  5873.             // Get the handle for the automatically allocated descriptor
  5874.             rc = SQLGetStmtAttr(hstmt, DescTypes[iDescType].uwDescType, &hdesc1, sizeof(hdesc1), &cbValue);  
  5875.             RETCHECK(SQL_SUCCESS, rc,szSQLGETSTMTATTR);
  5876.  
  5877.             // Create a descriptor record so we have something to read besides header
  5878.             swExpRecCount=CreateDescRecord(hdesc1, hstmt, DescTypes[iDescType].uwDescType);
  5879.  
  5880.             // Get the count of descriptor records
  5881.             // Count for automatically allocated descriptors is written in
  5882.             // SetDescField test.
  5883.             rc = SQLGetDescField(hdesc1, 0, SQL_DESC_COUNT, &swDescRecCount,
  5884.                 sizeof(swDescRecCount), &cbValue);
  5885.  
  5886.             if (SQL_SUCCESS == rc) 
  5887.             {
  5888.  
  5889.                 // For all descriptor records    
  5890.                 for (swDescRec=0; swDescRec <= swDescRecCount+1; swDescRec++)
  5891.                 {
  5892.                         // Read the record
  5893.                         rc = SQLGetDescRec(hdesc1, swDescRec, szName, sizeof(szName), &cbName, &fType,
  5894.                             &fSubType, &Length, &Precision, &Scale, &Nullable);
  5895.  
  5896.                         if (swDescRec <= swDescRecCount)
  5897.                         {
  5898.                             // Retrieving bookmark on IPD is an error
  5899.                             if (SQL_ATTR_IMP_PARAM_DESC == DescTypes[iDescType].uwDescType && 0 == swDescRec)
  5900.                             {
  5901.                                 wsprintf(buf,TEXT("%s: Able to read record %d from %s"),
  5902.                                     szSQLGETDESCREC, swDescRec, DescTypes[iDescType].szDescName);
  5903.                                 ERRSHANDLE(SQL_HANDLE_DESC, hdesc1, SQL_ERROR, rc, buf);
  5904.                             }
  5905.                             else
  5906.                             {
  5907.                                 wsprintf(buf,TEXT("%s: Unable to read record %d from %s"),
  5908.                                     szSQLGETDESCREC, swDescRec, DescTypes[iDescType].szDescName);
  5909.                                 ERRSHANDLE(SQL_HANDLE_DESC, hdesc1, SQL_SUCCESS, rc, buf);
  5910.                             }
  5911.                         }
  5912.                         else
  5913.                         {
  5914.                             wsprintf(buf,TEXT("%s: Did not receive SQL_NO_DATA reading record %d from %s"),
  5915.                                 szSQLGETDESCREC, swDescRec, DescTypes[iDescType].szDescName);
  5916.                             ERRSHANDLE(SQL_HANDLE_DESC, hdesc1, SQL_NO_DATA, rc, buf);
  5917.                         }
  5918.                 }
  5919.             }
  5920.             else
  5921.             {
  5922.                 // Unable to read record count from descriptor header, can't proceed
  5923.                 wsprintf(buf,TEXT("\t\tUnable to read record count from descriptor header for %s"),
  5924.                     DescTypes[iDescType].szDescName);
  5925.                 ERRSHANDLE(SQL_HANDLE_DESC, hdesc1, SQL_SUCCESS, rc, buf);
  5926.             }
  5927.         }
  5928.  
  5929.         rc=SQLCloseCursor(hstmt);
  5930.         RETCHECK(SQL_SUCCESS, rc,szSQLCLOSECURSOR);
  5931.  
  5932.     }
  5933.  
  5934. } //TestGetDescRec()
  5935.  
  5936. //-----------------------------------------------------------------------
  5937. //      Function:               TestSetDescRec
  5938. //-----------------------------------------------------------------------
  5939.  
  5940. void  PASCAL TestSetDescRec(QTSTRUCT * lpqt)
  5941. {
  5942.     SQLRETURN rc=SQL_SUCCESS;
  5943.     SQLINTEGER cbLength, cbValue, Indicator;
  5944.     SQLUSMALLINT iDescType;
  5945.  
  5946.     SQLHDESC hdesc1=NULL, hdesc2=NULL;
  5947.     PTR rgbValue=NULL;
  5948.     SQLSMALLINT swDescRec, swDescRecCount, swStartRec=1, iRecord, fType, fSubType,
  5949.         ibPrecision, ibScale;
  5950.     SQLSMALLINT swExpRecCount;
  5951.     TCHAR    szQuery[XLARGEBUFF]=TEXT("");
  5952.  
  5953.  
  5954.     if (!Supported(SQL_API_SQLSETDESCREC))
  5955.     {
  5956.         // Allocate a default descriptor
  5957.         rc = SQLAllocHandle(SQL_HANDLE_DESC, hdbc, &hdesc);  
  5958.  
  5959.         if (RC_SUCCESSFUL(rc))
  5960.         {
  5961.             rc = SQLSetDescRec(hdesc, iRecord, fType, fSubType, cbLength,
  5962.                 ibPrecision, ibScale, &DescBuf, &cbValue, &Indicator);
  5963.  
  5964.             if(!FindError(SQL_HANDLE_DESC,szIM001))
  5965.                 DISPLAYERROR(szSQLSETDESCREC, szNotSupported);
  5966.             RETCHECK(SQL_ERROR, rc,szSQLSETDESCREC);
  5967.         }
  5968.     }
  5969.     else
  5970.     {
  5971.         // Make sure all parameters and columns are unbound
  5972.         ResetHstmt(&hstmt);
  5973.         
  5974.         // Perform a select stmt
  5975.         wsprintf(szQuery,szSELECTSTAR,lpqt->szTableName);
  5976.         rc = SQLExecDirect(hstmt, szQuery, SQL_NTS);
  5977.         RETCHECK(SQL_SUCCESS, rc,szSQLEXECDIRECT);
  5978.  
  5979.         // If bookmarks are supported, then we want to try to set record 0
  5980.         rc = SQLSetStmtAttr(hstmt, SQL_ATTR_USE_BOOKMARKS,
  5981.             (PTR)SQL_UB_VARIABLE, SQL_IS_INTEGER);
  5982.         if (RC_SUCCESSFUL(rc))
  5983.             swStartRec=0;
  5984.  
  5985.         // For each descriptor type
  5986.         for (iDescType=0; iDescType < sizeof(DescTypes)/sizeof(DescTypes[0]); iDescType++)
  5987.         {
  5988.  
  5989.             // Get the handle for the automatically allocated descriptor
  5990.             rc = SQLGetStmtAttr(hstmt, DescTypes[iDescType].uwDescType, &hdesc1, sizeof(hdesc1), &cbValue);  
  5991.             RETCHECK(SQL_SUCCESS, rc,szSQLGETSTMTATTR);
  5992.  
  5993.             // Create a descriptor record so we have something to read besides header
  5994.             swExpRecCount=CreateDescRecord(hdesc1, hstmt, DescTypes[iDescType].uwDescType);
  5995.  
  5996.             // Get the count of descriptor records
  5997.             rc = SQLGetDescField(hdesc1, 0, SQL_DESC_COUNT, &swDescRecCount,
  5998.                 sizeof(swDescRecCount), &cbValue);
  5999.  
  6000.             if (SQL_SUCCESS == rc) 
  6001.             {
  6002.  
  6003.                 // For all descriptor records    
  6004.                 for (swDescRec=swStartRec; swDescRec <= swDescRecCount; swDescRec++)
  6005.                 {
  6006.                     // Test with a DATETIME record so we can check the subtype field.
  6007.                     SQLINTEGER Indicator=0;
  6008.                     fType=SQL_DATETIME;
  6009.                     fSubType=SQL_CODE_TIMESTAMP;
  6010.                     cbLength=sizeof(TIMESTAMP_STRUCT);
  6011.                     ibPrecision=5;     // For DATETIME, SQL_CODE_DATE data
  6012.                                             // precision defaults to 0, but it implies it can be set otherwise.
  6013.                     ibScale=0;        // Only used for DECIMAL or NUMERIC types, otherwise undefined
  6014.  
  6015.                     CheckDescRecord(hdesc1, swDescRec, fType, fSubType, cbLength, ibPrecision, 
  6016.                         ibScale, &tsval, &cbValue, &Indicator, iDescType);                    
  6017.  
  6018.                     // Test with a numeric record to test scale
  6019.                     Indicator=0;
  6020.                     fType=SQL_NUMERIC;
  6021.                     fSubType=SQL_CODE_TIMESTAMP;
  6022.                     cbLength=sizeof(TIMESTAMP_STRUCT);
  6023.                     ibPrecision=5;     // For DATETIME, SQL_CODE_DATE data
  6024.                                             // precision defaults to 0, but it implies it can be set otherwise.
  6025.                     ibScale=0;        // Only used for DECIMAL or NUMERIC types, otherwise undefined
  6026.  
  6027.                     CheckDescRecord(hdesc1, swDescRec, fType, fSubType, cbLength, ibPrecision, 
  6028.                         ibScale, &tsval, &cbValue, &Indicator, iDescType);
  6029.                 }
  6030.             }
  6031.             else
  6032.             {
  6033.                 // Unable to read record count from descriptor header,
  6034.                 // can't proceed
  6035.                 wsprintf(buf,TEXT("\t\tUnable to read record count from descriptor header for  %s"),
  6036.                     DescTypes[iDescType].szDescName);
  6037.                 ERRSHANDLE(SQL_HANDLE_DESC, hdesc1, SQL_SUCCESS, rc, buf);
  6038.             }
  6039.         }
  6040.         ResetHstmt(&hstmt);
  6041.     }
  6042.  
  6043. } //TestSetDescRec()
  6044.  
  6045. //-----------------------------------------------------------------------
  6046. //      Function:               TestCopyDesc
  6047. //-----------------------------------------------------------------------
  6048.  
  6049. void  PASCAL TestCopyDesc(QTSTRUCT * lpqt)
  6050. {
  6051.     SQLRETURN rc=SQL_SUCCESS;
  6052.     SQLUSMALLINT iDescType;
  6053.     SQLSMALLINT swExpRecCount;
  6054.  
  6055.     SQLHDESC hdesc1=NULL, hdesc2=NULL;
  6056.     PTR rgbValue=NULL;
  6057.     TCHAR    szName[MAX_DESC_BUF]=TEXT("");
  6058.     TCHAR    szQuery[XLARGEBUFF]=TEXT("");
  6059.  
  6060.  
  6061.     // Allocate a default descriptor
  6062.     rc = SQLAllocHandle(SQL_HANDLE_DESC, hdbc, &hdesc);  
  6063.  
  6064.     if (RC_SUCCESSFUL(rc))
  6065.     {
  6066.  
  6067.         if (!Supported(SQL_API_SQLCOPYDESC))
  6068.         {
  6069.             rc = SQLCopyDesc(hdesc, hdesc1);
  6070.  
  6071.             if(!FindError(SQL_HANDLE_DESC,szIM001))
  6072.                 DISPLAYERROR(szSQLCOPYDESC, szNotSupported);
  6073.             RETCHECK(SQL_ERROR, rc,szSQLCOPYDESC);
  6074.         }
  6075.         else
  6076.         {
  6077.             ResetHstmt(&hstmt);
  6078.             
  6079.             // Perform a select stmt
  6080.             wsprintf(szQuery,szSELECTSTAR,lpqt->szTableName);
  6081.             rc = SQLExecDirect(hstmt, szQuery, SQL_NTS);
  6082.             RETCHECK(SQL_SUCCESS, rc,szSQLEXECDIRECT);
  6083.  
  6084.             // For each descriptor type
  6085.             for (iDescType=0; iDescType < sizeof(DescTypes)/sizeof(DescTypes[0]); iDescType++)
  6086.             {
  6087.                 // Get the handle for the automatically allocated descriptor
  6088.                 rc = SQLGetStmtAttr(hstmt, DescTypes[iDescType].uwDescType, &hdesc1, sizeof(hdesc1), &cbValue);  
  6089.                 RETCHECK(SQL_SUCCESS, rc,szSQLGETSTMTATTR);
  6090.  
  6091.                 // Create a descriptor record so we have something to read besides header
  6092.                 swExpRecCount=CreateDescRecord(hdesc1, hstmt, DescTypes[iDescType].uwDescType);
  6093.  
  6094.                 // Update all descriptor records to new values
  6095.                 CheckDescriptor(hdesc1, DESC_UPDATE_MODE_WRITE, hstmt, iDescType);
  6096.  
  6097.                 // Copy the descriptor to the newly allocated descriptor
  6098.                 rc = SQLCopyDesc(hdesc1, hdesc);
  6099.                 ERRSHANDLE(SQL_HANDLE_DESC, hdesc1, SQL_SUCCESS, rc, szSQLCOPYDESC);
  6100.                 ERRSHANDLE(SQL_HANDLE_DESC, hdesc, SQL_SUCCESS, rc, szSQLCOPYDESC);
  6101.  
  6102.                 // Compare each field in the copied descriptor to the original
  6103.                 if (RC_SUCCESSFUL(rc))
  6104.                     CompareDescriptor(hdesc1, hdesc, iDescType, szSQLCOPYDESC);
  6105.             }
  6106.  
  6107.             ResetHstmt(&hstmt);
  6108.         }
  6109.  
  6110.         // Free descriptor handle
  6111.         if (hdesc)
  6112.         {
  6113.             rc = SQLFreeHandle(SQL_HANDLE_DESC, hdesc); 
  6114.             RETCHECK(SQL_SUCCESS, rc,szSQLFREEHANDLE);
  6115.         }
  6116.     }
  6117.  
  6118. } //TestCopyDesc()
  6119.  
  6120.  
  6121. //-----------------------------------------------------------------------
  6122. //      Function:               TestDescDefaults
  6123. //-----------------------------------------------------------------------
  6124. void  PASCAL TestDescDefaults(QTSTRUCT * lpqt)
  6125. {
  6126.     SQLRETURN rc=SQL_SUCCESS;
  6127.      SQLINTEGER cbValue;
  6128.     SQLSMALLINT swDescRec;
  6129.     SQLUSMALLINT iDescField, iStartField=0, iDescType;
  6130.  
  6131.     if (Supported(SQL_API_SQLGETDESCFIELD))
  6132.     {
  6133.  
  6134.         // Reallocate hstmt to check defaults against
  6135.         ResetHstmt(&hstmt);
  6136.  
  6137.         // For each descriptor type
  6138.         for (iDescType=0; iDescType < sizeof(DescTypes)/sizeof(DescTypes[0]); iDescType++)
  6139.         {
  6140.             // Get the handle for the descriptor
  6141.             rc = SQLGetStmtAttr(hstmt, DescTypes[iDescType].uwDescType, &hdesc, sizeof(hdesc), NULL);  
  6142.             RETCHECK(SQL_SUCCESS, rc,szSQLGETSTMTATTR);
  6143.  
  6144.             swDescRec=0;
  6145.  
  6146.             // For each descriptor field, read the value
  6147.             for (iDescField=iStartField; iDescField < sizeof(rgDescInfo)/sizeof(rgDescInfo[0]); iDescField++) {
  6148.  
  6149.                 // If we've gone past the header fields, then create a record and check record fields
  6150.                 if (0 == swDescRec && !rgDescInfo[iDescField].fHeader) {
  6151.                     iStartField=iDescField;
  6152.                     // Make sure we're not on the IRD, 'cause you can't modify an IRD
  6153.                     if (SQL_ATTR_IMP_ROW_DESC != DescTypes[iDescType].uwDescType)
  6154.                     {
  6155.                         // Create a record with all default values
  6156.                         rc = SQLSetDescField(hdesc, 0, SQL_DESC_COUNT, (SQLPOINTER)1,
  6157.                             SQL_IS_SMALLINT);
  6158.                         RETCHECK(SQL_SUCCESS, rc,szSQLSETDESCFIELD);
  6159.  
  6160.                         swDescRec++;
  6161.                     }
  6162.                     continue;
  6163.                 }
  6164.  
  6165.                 // If the field has a default value
  6166.                 if (rgDescInfo[iDescField].fDefault & DescTypes[iDescType].uwTypeMask)
  6167.                 {
  6168.                     // Read from the field
  6169.                     rc = SQLGetDescField(hdesc, swDescRec, rgDescInfo[iDescField].uwDescField,
  6170.                         &DescBuf, sizeof(DescBuf), &cbValue);
  6171.                     RETCHECK(SQL_SUCCESS, rc,szSQLGETDESCFIELD);
  6172.                     
  6173.                     if (RC_SUCCESSFUL(rc))
  6174.                     {
  6175.                         // Perform the compare
  6176.                         if (memcmp(DescBuf, &rgDescInfo[iDescField].DefaultVal, cbValue)) 
  6177.                         {
  6178.                             // Compare error, print message
  6179.                             wsprintf(buf,TEXT("Error in %s field %s default value"),
  6180.                                 DescTypes[iDescType].szDescName,rgDescInfo[iDescField].szDescFieldName);
  6181.                             DISPLAYERROR(szSQLGETDESCFIELD, buf);
  6182.                         }
  6183.                     }
  6184.                 }
  6185.             }
  6186.         }
  6187.     }
  6188. } // TestDescDefaults
  6189.  
  6190. //-----------------------------------------------------------------------
  6191. //      Function:               TestUseDesc
  6192. //-----------------------------------------------------------------------
  6193. void  PASCAL TestUseDesc(QTSTRUCT * lpqt, FIELDINFO  *rgFields)
  6194. {
  6195.     LPTSTR   pch=NULL;
  6196.     SDWORD crow=0;
  6197.     TCHAR    szQuery[XLARGEBUFF]=TEXT("");
  6198.     SQLRETURN rc;
  6199.     UWORD    row, icol, paramno;
  6200.     SWORD    ccol;
  6201.     TCHAR * rgbMemBuf=NULL, * rgbValue=NULL;
  6202.     SDWORD * pcbValueBuf=NULL, * pcbValue=NULL;
  6203.  
  6204.     if (Supported(SQL_API_SQLSETDESCFIELD))
  6205.     {
  6206.  
  6207.         // Test descriptor bindcol
  6208.         
  6209.         // Reallocate hstmt to set to defaults
  6210.         ResetHstmt(&hstmt);
  6211.         
  6212.         // Perform a select stmt
  6213.         wsprintf(szQuery,szSELECTSTAR,lpqt->szTableName);
  6214.         rc = SQLExecDirect(hstmt, szQuery, SQL_NTS);
  6215.         RETCHECK(SQL_SUCCESS, rc,szSQLEXECDIRECT);
  6216.  
  6217.         rc=SQLNumResultCols(hstmt, &ccol);
  6218.         RETCHECK(SQL_SUCCESS, rc, szSQLNUMRESULTCOLS);
  6219.  
  6220.         rc=SQLFreeStmt(hstmt, SQL_CLOSE); // Close the cursor so we can insert 
  6221.         RETCHECK(SQL_SUCCESS, rc,szSQLFREESTMT);
  6222.  
  6223.         rgbMemBuf=AllocateMemory(ccol*MAX_STRING_SIZE*sizeof(TCHAR));
  6224.  
  6225.         if (!rgbMemBuf)
  6226.         {
  6227.             DISPLAYERROR(TEXT("Simulate BindCol"),TEXT("Out of memory!"));
  6228.             goto ExitUseDesc;
  6229.         }
  6230.  
  6231.         pcbValueBuf=(SDWORD *)AllocateMemory(ccol*sizeof(SDWORD));
  6232.  
  6233.         if (!pcbValueBuf)
  6234.         {
  6235.             DISPLAYERROR(TEXT("Simulate BindCol"),TEXT("Out of memory!"));
  6236.             goto ExitUseDesc;
  6237.         }
  6238.  
  6239.         // Bind a parameter for each column in the result set using descriptors
  6240.         paramno=0;
  6241.         for (icol=1, rgbValue=rgbMemBuf, pcbValue=pcbValueBuf;
  6242.             icol <= ccol;
  6243.             icol++, rgbValue+=MAX_STRING_SIZE*sizeof(TCHAR), pcbValue++)
  6244.         {
  6245.             pch = qtMakeData(guwRowCount, icol-1, &rgFields[icol-1], rgbValue);
  6246.  
  6247.             // Field is not READ ONLY
  6248.             if(pch) 
  6249.             {
  6250.                  // Where row and column match and field is nullable, make NULL
  6251.                 if (icol == guwRowCount && rgFields[icol-1].nullable)
  6252.                     *pcbValue=SQL_NULL_DATA;
  6253.                 else
  6254.                     *pcbValue=SQL_NTS;
  6255.  
  6256.                 paramno++;
  6257. //                rc=SQLBindParameter(hstmt, paramno, SQL_PARAM_INPUT, SQL_C_CHAR, 
  6258.                 rc=DescBindParameter(hstmt, paramno, SQL_PARAM_INPUT, SQL_C_CHAR, 
  6259.                     rgFields[icol-1].wSQLType, rgFields[icol-1].precision,
  6260.                     rgFields[icol-1].scale, rgbValue, 0, pcbValue);
  6261.                 RETCHECK(SQL_SUCCESS, rc,TEXT("DescBindParameter"));
  6262.             }
  6263.         }
  6264.  
  6265.         // Insert the new row.  Note that the inserted row will be checked
  6266.         // for accuracy below.
  6267.         rc = SQLExecDirect(hstmt, szInsertStmt, SQL_NTS);
  6268.         ERRSHANDLE(SQL_HANDLE_STMT, hstmt, SQL_SUCCESS, rc, szSQLEXECDIRECT);
  6269.  
  6270.         if (RC_SUCCESSFUL(rc))
  6271.             guwRowCount++;
  6272.  
  6273.         // Perform the select stmt again
  6274.         wsprintf(szQuery,szSELECTSTAR,lpqt->szTableName);
  6275.         rc = SQLExecDirect(hstmt, szQuery, SQL_NTS);
  6276.         RETCHECK(SQL_SUCCESS, rc,szSQLEXECDIRECT);
  6277.  
  6278.         // Bind all the columns to char
  6279.         for (icol=1, rgbValue=rgbMemBuf, pcbValue=pcbValueBuf;
  6280.             icol <= ccol;
  6281.             icol++, rgbValue+=MAX_STRING_SIZE*sizeof(TCHAR), pcbValue++)
  6282.         {
  6283.             // Bind to next column
  6284.             rc = DescBindCol(hstmt, icol, SQL_C_CHAR, rgbValue, MAX_STRING_SIZE*sizeof(TCHAR), pcbValue);
  6285. //            rc = SQLBindCol(hstmt, icol, SQL_C_CHAR, rgbValue, MAX_STRING_SIZE*sizeof(TCHAR), pcbValue);
  6286.             RETCHECK(SQL_SUCCESS, rc, TEXT("DescBindCol"));
  6287.         }
  6288.  
  6289.         // Fetch all the rows and check the bound value with MakeAData for
  6290.         // each column
  6291.         for (row=1; rc == SQL_SUCCESS; row++)
  6292.         {
  6293.             rc=SQLFetch(hstmt); // Will return SQL_NO_DATA after last row
  6294.  
  6295.             if (SQL_SUCCESS == rc)
  6296.             {
  6297.  
  6298.                 // Compare all the columns
  6299.                 for (icol=1, rgbValue=rgbMemBuf, pcbValue=pcbValueBuf;
  6300.                     icol <= ccol;
  6301.                     icol++, rgbValue+=MAX_STRING_SIZE*sizeof(TCHAR), pcbValue++)
  6302.                 {
  6303.  
  6304.                     CompareWithExpected(rgbValue, pcbValue, row, icol, rgFields);
  6305.                 }
  6306.             }
  6307.             else
  6308.                 ERRSHANDLE(SQL_HANDLE_STMT, hstmt, SQL_NO_DATA, rc, szSQLFETCH);
  6309.  
  6310.         }
  6311.  
  6312.     }
  6313.  
  6314. ExitUseDesc:
  6315.     rc=SQLFreeStmt(hstmt, SQL_CLOSE);
  6316.     RETCHECK(SQL_SUCCESS, rc,szSQLFREESTMT);
  6317.  
  6318.     if (rgbMemBuf)
  6319.         ReleaseMemory(rgbMemBuf);
  6320.     if (pcbValueBuf)
  6321.         ReleaseMemory(pcbValueBuf);
  6322.  
  6323.  
  6324. } // TestUseDesc
  6325.  
  6326. //-----------------------------------------------------------------------
  6327. //      Function:               TestEnvAttr
  6328. //
  6329. // Note:    Only one environment attribute (SQL_ATTR_OUTPUT_NTS) exists at this
  6330. //         time.  The default value is SQL_TRUE.
  6331. //
  6332. //    For the Environment attributes we assume support if DM version >= 3.00
  6333. //-----------------------------------------------------------------------
  6334.  
  6335. void  PASCAL TestEnvAttr()
  6336. {
  6337.     SQLINTEGER    sdwEnvAttr;
  6338.     SQLRETURN    rc;
  6339.     HENV            tshenv;
  6340.     BOOL            fSetSupported = Supported(SQL_API_SQLSETENVATTR),
  6341.                     fGetSupported = Supported(SQL_API_SQLGETENVATTR);
  6342.  
  6343.  
  6344.     //allocate an enviroment handle
  6345.     rc = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &tshenv);
  6346.     RETCHECK(SQL_SUCCESS, rc,szSQLALLOCHANDLE);
  6347.  
  6348.  
  6349.     //-------------------------------
  6350.     //-------- SQLSetEnvAttr --------
  6351.     //-------------------------------
  6352.     // Set to SQL_FALSE
  6353.     rc = SQLSetEnvAttr(tshenv, SQL_ATTR_ODBC_VERSION, (PTR)SQL_OV_ODBC3,
  6354.         SQL_IS_UINTEGER);
  6355.  
  6356.     if(!fSetSupported)
  6357.     {
  6358.         if (!FindError(SQL_HANDLE_ENV,szIM001))
  6359.             DISPLAYERROR(szSQLSETENVATTR, szNotSupported);
  6360.  
  6361.         RETCHECK(SQL_ERROR, rc,szSQLSETENVATTR);
  6362.     }
  6363.     else
  6364.         RETCHECK(SQL_SUCCESS, rc,szSQLSETENVATTR);
  6365.  
  6366.     if (RC_SUCCESSFUL(rc))
  6367.     {
  6368.         // Read it again
  6369.         rc = SQLGetEnvAttr(tshenv, SQL_ATTR_ODBC_VERSION, &sdwEnvAttr,
  6370.             sizeof(sdwEnvAttr), NULL);
  6371.  
  6372.         if(!fGetSupported)
  6373.         {
  6374.             if (!FindError(SQL_HANDLE_ENV,szIM001))
  6375.                 DISPLAYERROR(szSQLGETENVATTR, szNotSupported);
  6376.  
  6377.             RETCHECK(SQL_ERROR, rc,szSQLGETENVATTR);
  6378.         }
  6379.         else
  6380.             RETCHECK(SQL_SUCCESS, rc,szSQLGETENVATTR);
  6381.  
  6382.         if (RC_SUCCESSFUL(rc) && (SQL_OV_ODBC3 != sdwEnvAttr))
  6383.         {
  6384.             // New value wrong
  6385.             DISPLAYERROR(szSQLSETENVATTR,TEXT("Unable to set environment attribute SQL_ATTR_ODBC_VERSION to SQL_OV_ODBC3."));
  6386.         }
  6387.     }
  6388.  
  6389.     rc = SQLFreeHandle(SQL_HANDLE_ENV,tshenv);
  6390.     RETCHECK(SQL_SUCCESS, rc,szSQLFREEHANDLE);
  6391.  
  6392.     //-------------------------------
  6393.     //-------- SQLGetEnvAttr --------
  6394.     //-------------------------------
  6395.     rc = SQLAllocEnv(&tshenv);
  6396.     RETCHECK(SQL_SUCCESS, rc,szSQLALLOCENV);
  6397.  
  6398.     rc = SQLGetEnvAttr(tshenv, SQL_ATTR_ODBC_VERSION, &sdwEnvAttr,
  6399.         sizeof(sdwEnvAttr), NULL);
  6400.  
  6401.     if(!fGetSupported)
  6402.     {
  6403.         if (!FindError(SQL_HANDLE_ENV,szIM001))
  6404.             DISPLAYERROR(szSQLGETENVATTR, szNotSupported);
  6405.  
  6406.         RETCHECK(SQL_ERROR, rc,szSQLGETENVATTR);
  6407.     }
  6408.     else
  6409.         RETCHECK(SQL_SUCCESS, rc,szSQLGETENVATTR);
  6410.  
  6411.     
  6412.     if (RC_SUCCESSFUL(rc) && (SQL_OV_ODBC2 != sdwEnvAttr))
  6413.     {
  6414.         // Default value wrong
  6415.         DISPLAYERROR(szSQLGETENVATTR,TEXT("Value was not SQL_OV_ODBC3!"));
  6416.     }
  6417.  
  6418.  
  6419.     rc = SQLFreeHandle(SQL_HANDLE_ENV,tshenv);
  6420.     RETCHECK(SQL_SUCCESS, rc,szSQLFREEHANDLE);
  6421.  
  6422. } //TestEnvAttr()
  6423.  
  6424.  
  6425. //-----------------------------------------------------------------------
  6426. //    Function: GetRowCnt
  6427. //
  6428. //        Get the row count of the table lpqt->szTalbeName
  6429. //-----------------------------------------------------------------------
  6430. SWORD  PASCAL GetRowCnt(QTSTRUCT  *lpqt)
  6431. {
  6432.      SWORD         sRowCnt;
  6433.     RETCODE        rc;
  6434.  
  6435.     // free the statment handle for a fresh start
  6436.     FreeStmt(SQL_DROP);
  6437.  
  6438.     AllocHstmt();
  6439.  
  6440.     //get row count for the table
  6441.     wsprintf(lpqt->sz,TEXT("select count(*) from %s"), lpqt->szTableName);
  6442.  
  6443.     rc = SQLExecDirect(hstmt, lpqt->sz, SQL_NTS);
  6444.     RETCHECK(SQL_SUCCESS, rc,szSQLEXECDIRECT);
  6445.  
  6446.     rc = SQLFetch(hstmt);
  6447.     RETCHECK(SQL_SUCCESS, rc,szSQLFETCH);
  6448.  
  6449.     rc = SQLGetData(hstmt,1, SQL_C_SSHORT, &sRowCnt, sizeof(sRowCnt), NULL);
  6450.     RETCHECK(SQL_SUCCESS, rc,szSQLGETDATA);
  6451.  
  6452.     FreeStmt(SQL_CLOSE);
  6453.  
  6454.     return sRowCnt;
  6455. }//GetRowCount
  6456.  
  6457.  
  6458. //-----------------------------------------------------------------------
  6459. //    Function: InsertOneRow
  6460. //
  6461. //        Insert one row into the table.
  6462. //
  6463. //            lpqt:            temp place to hold data genrated
  6464. //            rgFields:    hold info about each data type in the dbs
  6465. //            cTypes;        the count of data types
  6466. //            lpd:            buffer used for SQLBindParam
  6467. //            cSeed;        the seed used to generate data
  6468. //            fFreeHsmt:    if the hstmt should be freed       
  6469. //
  6470. //        Return TRUE: the insertion was successful
  6471. //                 FALSE: otherwise
  6472. //-----------------------------------------------------------------------
  6473.                                           
  6474. BOOL  PASCAL InsertOneRow(QTSTRUCT  *lpqt,FIELDINFO  *rgFields,UWORD cTypes,
  6475.                                         DSTRUCT  *lpd,UWORD cSeed,BOOL fFreeHstmt)
  6476. {
  6477.     RETCODE              rc;
  6478.     UWORD                w;
  6479.     UWORD                ind;
  6480.     LPTSTR                pch=NULL;
  6481.     SQLHDESC                hdesc;
  6482.    SQLSMALLINT          fParamType = SQL_PARAM_INPUT;
  6483.     TCHAR                    szDataItem[150];
  6484.  
  6485.  
  6486.     //prepare the insert statement
  6487.     rc = SQLPrepare(hstmt, szInsertStmt, SQL_NTS);
  6488.     RETCHECK(SQL_SUCCESS, rc,szSQLPREPARE);
  6489.  
  6490.     //going through each data type, call SQLBindParam
  6491.     for(ind = 0, w = 0; ind < cTypes; ind++) 
  6492.     {
  6493.  
  6494.         //make data according to data type description in rgFields[], cSeed is the seed
  6495.         pch = qtMakeData(cSeed,ind,&rgFields[ind], szDataItem);
  6496.  
  6497.         //if the data type is READ_ONLY, skip
  6498.         if(!pch) 
  6499.             continue;
  6500.  
  6501.         //populate the NULL data
  6502.         if(*pch) 
  6503.         {
  6504.             lstrcpy(lpd[w].data, pch);
  6505.             lpd[w].cb = SQL_NTS;
  6506.         }
  6507.         else 
  6508.         {
  6509.             lstrcpy(lpd[w].data,TEXT(""));
  6510.             lpd[w].cb = SQL_NULL_DATA;
  6511.         }
  6512.  
  6513.         if (g_f3XDriver && Supported(SQL_API_SQLSETDESCFIELD))
  6514. //        if (0)    //DEBUG
  6515.         {
  6516.             //bind the data buffer in lpd[] to each column of the table
  6517.             rc = SQLBindParam(hstmt, (SQLSMALLINT)(w+1),SQL_C_TCHAR, rgFields[ind].wSQLType,
  6518.                                     rgFields[ind].precision, rgFields[ind].scale,
  6519.                                     &lpd[w].data, &lpd[w].cb);
  6520.             RETCHECK(SQL_SUCCESS, rc,szSQLBINDPARAM);
  6521.  
  6522.             if(rc!= SQL_SUCCESS)
  6523.                 return FALSE;
  6524.  
  6525.             //get the driver parameter descriptor handle
  6526.             rc = SQLGetStmtAttr(hstmt,SQL_ATTR_IMP_PARAM_DESC, &hdesc, sizeof(hdesc),NULL);
  6527.             RETCHECK(SQL_SUCCESS, rc,szSQLGETSTMTATTR);
  6528.             if(rc!= SQL_SUCCESS)
  6529.                 return FALSE;
  6530.  
  6531.             //set the parameter type field in the descriptor
  6532.             rc = SQLSetDescField(hdesc, (SQLSMALLINT)(w+1), SQL_DESC_PARAMETER_TYPE, 
  6533.                                         (PTR)fParamType, sizeof(fParamType));
  6534.             RETCHECK(SQL_SUCCESS, rc,szSQLSETDESCFIELD);
  6535.  
  6536.         }
  6537.         else
  6538.         {
  6539.             rc = SQLBindParameter(hstmt, (UWORD)(w+1),SQL_PARAM_INPUT,SQL_C_TCHAR, 
  6540.                             rgFields[ind].wSQLType,    rgFields[ind].precision, 
  6541.                             rgFields[ind].scale,&lpd[w].data, 100, &lpd[w].cb);
  6542.                 
  6543.             RETCHECK(SQL_SUCCESS, rc,szSQLBINDPARAMETER);
  6544.  
  6545.             if(rc!= SQL_SUCCESS)
  6546.                 return FALSE;
  6547.         }
  6548.  
  6549.  
  6550.         //go on to next column
  6551.         w++;
  6552.     }
  6553.  
  6554.     // insert a row 
  6555.     rc = SQLExecute(hstmt); 
  6556.     RETCHECK(SQL_SUCCESS, rc,szSQLEXECUTE);
  6557.     if(rc!= SQL_SUCCESS)
  6558.         return FALSE;
  6559.  
  6560.     //free the hstmt if required
  6561.     if(fFreeHstmt)
  6562.     {
  6563.         if (FreeStmt(SQL_CLOSE))
  6564.             return FALSE;
  6565.  
  6566.     }
  6567.  
  6568.     return TRUE;
  6569.  
  6570. }    //InsertOneRow
  6571.  
  6572. //-----------------------------------------------------------------------
  6573. //    Function: ExecEndTran
  6574. //
  6575. //        Execute EndTran statement, return the row count of the table
  6576. //-----------------------------------------------------------------------
  6577. SWORD  PASCAL ExecEndTran(QTSTRUCT  *lpqt,FIELDINFO  *rgFields,UWORD cTypes,
  6578.                                 DSTRUCT  *lpd,SQLSMALLINT fHandleType, SQLSMALLINT fMode,
  6579.                                 UWORD cSeed)
  6580. {
  6581.           RETCODE rc;
  6582.  
  6583.         //does not free the hstmt
  6584.         if(!InsertOneRow(lpqt,rgFields,cTypes,lpd,cSeed, FALSE))
  6585.                 return (INSERT_FAIL);
  6586.  
  6587.         switch(fHandleType)
  6588.         {
  6589.             case SQL_HANDLE_ENV:
  6590.                 rc= SQLEndTran(fHandleType,henv,fMode);
  6591.                 break;
  6592.             case SQL_HANDLE_DBC:
  6593.                 rc= SQLEndTran(fHandleType,hdbc,fMode);
  6594.                 break;
  6595.             default:    
  6596.                 DISPLAYERROR(TEXT("ExecEndTran"),TEXT("Did not recieve correct handle type"));
  6597.                 break;
  6598.         }
  6599.         RETCHECK(SQL_SUCCESS, rc,szSQLENDTRAN);
  6600.  
  6601.         if (SQL_COMMIT == fMode && SQL_SUCCESS == rc)
  6602.             guwRowCount++;    // We inserted a row, increment global row count
  6603.  
  6604.         //free the hstmt handle
  6605.         FreeStmt(SQL_CLOSE);
  6606.  
  6607.         return(GetRowCnt(lpqt));
  6608. } //ExecEndTran
  6609.  
  6610. //-----------------------------------------------------------------------
  6611. //    Function: TestEndTran
  6612. //
  6613. //        Test the SQLEndTran for SDK 3.0
  6614. //-----------------------------------------------------------------------
  6615. void  PASCAL TestEndTran(QTSTRUCT  *lpqt,FIELDINFO  *rgFields,UWORD cTypes,
  6616.                                         DSTRUCT  *lpd)
  6617. {
  6618.     SWORD                i;
  6619.     RETCODE             rc;
  6620.     SWORD                sTXN;
  6621.     SWORD                sRowCnt_Pre;
  6622.     SWORD                sRowCnt_Aft;
  6623.     SQLSMALLINT         fHandleType[]={SQL_HANDLE_ENV, SQL_HANDLE_DBC};
  6624.     SDWORD            cbValue=0;
  6625.  
  6626.     //check if transaction is supported
  6627.     rc = SQLGetInfo(hdbc, SQL_TXN_CAPABLE, &sTXN, sizeof(sTXN), NULL);
  6628.     RETCHECK(SQL_SUCCESS, rc,szSQLGETINFO);
  6629.  
  6630.     //check both henv and hdbc handle
  6631.     for(i=0; i<=1; i++)
  6632.     { 
  6633.  
  6634.         //get the row count of the table
  6635.         sRowCnt_Pre = GetRowCnt(lpqt);
  6636.  
  6637.         //check if SQLEndTran is supported
  6638.         if(Supported(SQL_API_SQLENDTRAN))
  6639.         {
  6640.             if(sTXN != SQL_TC_NONE)
  6641.             {
  6642.                 //set the autocommit to off
  6643.                 SetConnectionAttributes(hdbc,SQL_AUTOCOMMIT, SQL_AUTOCOMMIT_OFF);
  6644.                 
  6645.                 //insert one row, and call SQLEndTran to roll back the transction
  6646.                 sRowCnt_Aft = ExecEndTran(lpqt,rgFields,cTypes,lpd,fHandleType[i],SQL_ROLLBACK,(UWORD)(guwRowCount));
  6647.                 
  6648.                 //the row count should be the same
  6649.                 if(sRowCnt_Aft != sRowCnt_Pre)
  6650.                     DISPLAYERROR(szSQLENDTRAN,TEXT("Did not Roll Back the insert transaction"));
  6651.             }
  6652.                 
  6653.             //insert one row, and call SQLEndTran to commit the transction
  6654.             sRowCnt_Aft = ExecEndTran(lpqt,rgFields,cTypes,lpd,fHandleType[i],SQL_COMMIT,(UWORD)(guwRowCount));
  6655.  
  6656.             //the row count should be increased by 1
  6657.             if(sRowCnt_Aft != (sRowCnt_Pre+1) )
  6658.                 DISPLAYERROR(szSQLENDTRAN,TEXT("Did not commit the insert transaction"));
  6659.  
  6660.             if( sTXN != SQL_TC_NONE)
  6661.             {
  6662.                 //set the autocommit to off
  6663.                 SetConnectionAttributes(hdbc,SQL_AUTOCOMMIT, SQL_AUTOCOMMIT_OFF);
  6664.             }
  6665.  
  6666.         }//end of the situation where SQLEndTran is supported
  6667.         else
  6668.         {
  6669.  
  6670.             switch(fHandleType[i])
  6671.             {
  6672.                 case SQL_HANDLE_ENV: 
  6673.                     rc= SQLEndTran(fHandleType[i],henv,SQL_COMMIT);
  6674.                     break;
  6675.                 case SQL_HANDLE_DBC: 
  6676.                     rc= SQLEndTran(fHandleType[i],hdbc,SQL_ROLLBACK);
  6677.                     break;
  6678.             }
  6679.  
  6680.             //check error msg
  6681.             if(!FindError(fHandleType[i],szIM001))
  6682.                 DISPLAYERROR(szSQLENDTRAN,TEXT("Did not return not Supported Message"));
  6683.  
  6684.             RETCHECK(SQL_ERROR, rc,szSQLENDTRAN);
  6685.  
  6686.             //free the hstmt handle
  6687.             FreeStmt(SQL_CLOSE);
  6688.  
  6689.         }//end of error msg checking
  6690.  
  6691.     }//end of the loop to check both henv and hdbc
  6692.  
  6693.     // Commit the transaction started in GetRowCnt inside ExecEndTran
  6694.     rc= SQLEndTran(SQL_HANDLE_ENV,henv,SQL_COMMIT);
  6695.     RETCHECK(SQL_SUCCESS, rc,szSQLENDTRAN);
  6696.  
  6697.     SetConnectionAttributes(hdbc,SQL_AUTOCOMMIT, SQL_AUTOCOMMIT_ON);
  6698.  
  6699.     //free the hstmt handle
  6700.     FreeStmt(SQL_CLOSE);
  6701.  
  6702. } // TestEndTran()
  6703.  
  6704.  
  6705. //-----------------------------------------------------------------------
  6706. //    Function: TestBindParam
  6707. //
  6708. //        Test the SQLBindParam for SDK 3.0
  6709. //-----------------------------------------------------------------------
  6710. void  PASCAL TestBindParam(QTSTRUCT  *lpqt,FIELDINFO  *rgFields,UWORD cTypes,
  6711.                                         DSTRUCT  *lpd)
  6712. {
  6713.      RETCODE             rc;
  6714.     SQLINTEGER        cbValue = SQL_NTS;
  6715.     TCHAR                szDataItem[150];
  6716.  
  6717.     if(Supported(SQL_API_SQLBINDPARAM))
  6718.     {
  6719.         //test SQLBindParam by inserting one row, do not free the hstmt handle
  6720.         if (InsertOneRow(lpqt,rgFields,cTypes,lpd,(UWORD)(guwRowCount),FALSE))
  6721.             guwRowCount++; // We've inserted a row
  6722.     }
  6723.     else
  6724.     {
  6725.          //prepare the insert statement
  6726.         rc = SQLPrepare(hstmt, szInsertStmt, SQL_NTS);
  6727.         RETCHECK(SQL_SUCCESS, rc,szSQLPREPARE);
  6728.  
  6729.         //make data according to data type description in rgFields[0], cSeed is the seed
  6730.         qtMakeData(cTypes+1,0,&rgFields[0],szDataItem);
  6731.  
  6732.         //try to bind lpqt->szDataItem to the first column of the table
  6733.         rc = SQLBindParam(hstmt,1,SQL_C_TCHAR, rgFields[0].wSQLType, rgFields[0].precision,
  6734.                                 rgFields[0].scale,lpqt->szDataItem, &cbValue);
  6735.  
  6736.         //check error msg
  6737.         if(!FindError(SQL_HANDLE_STMT,szIM001))
  6738.             DISPLAYERROR(szSQLBINDPARAM,TEXT("Did not return Not Supported Message"));
  6739.  
  6740.         RETCHECK(SQL_ERROR, rc,szSQLBINDPARAM);
  6741.     }
  6742.  
  6743.     //free the hstmt handle
  6744.     FreeStmt(SQL_CLOSE);
  6745.  
  6746. } // TestBindParam()
  6747.  
  6748.  
  6749.  
  6750.  
  6751.  
  6752.  
  6753. //-----------------------------------------------------------------------
  6754. //    Function: TestFetchScroll
  6755. //
  6756. //        Test the SQLFetchScroll for SDK 3.0
  6757. //-----------------------------------------------------------------------
  6758.  
  6759. void PASCAL TestFetchScroll(QTSTRUCT *lpqt)
  6760. {
  6761.     RETCODE    rc=SQL_SUCCESS;
  6762.     TCHAR        szSave[MAX_QUERY_SIZE];
  6763.     DWORD        dwLen=0;
  6764.     SDWORD    cbValue=0;
  6765.  
  6766.     /* check if SQLGetFunctions says your API is supported */
  6767.     if(!Supported( SQL_API_SQLFETCHSCROLL))
  6768.     {
  6769.         /* Call your 3.0 API here and verify that the correct state is returned */
  6770.         rc = SQLFetchScroll(hstmt,SQL_FETCH_FIRST, 0);
  6771.         if(!FindError(SQL_HANDLE_STMT,szIM001))
  6772.             DISPLAYERROR(szSQLFETCHSCROLL, szNotSupported);
  6773.         RETCHECK(SQL_ERROR, rc, szSQLFETCHSCROLL);
  6774.     }
  6775.     else
  6776.     {
  6777.         ResetHstmt(&hstmt);
  6778.  
  6779.         /* Valid Testing of SQLFetchScroll */
  6780.         SelectFromTable(lpqt);
  6781.  
  6782.         rc = SQLBindCol(hstmt, 1, SQL_C_TCHAR, lpqt->sz, MAX_BIND_ARRAY_ELEMENT,
  6783.             &cbValue);
  6784.         RETCHECK(SQL_SUCCESS, rc, szSQLBINDCOL);
  6785.  
  6786.         rc = SQLFetchScroll(hstmt, SQL_FETCH_NEXT, 3);
  6787.         RETCHECK(SQL_SUCCESS, rc, szSQLFETCHSCROLL);
  6788.         lstrcpy(szSave,lpqt->sz);
  6789.  
  6790.         rc = SQLFetchScroll(hstmt, SQL_FETCH_PRIOR, 1);
  6791.         RETCHECK(SQL_ERROR, rc, szSQLFETCHSCROLL);
  6792.  
  6793.         rc = SQLFetchScroll(hstmt, SQL_FETCH_FIRST, 0);
  6794.         RETCHECK(SQL_ERROR, rc, szSQLFETCHSCROLL);
  6795.  
  6796.         rc = SQLFetchScroll(hstmt, SQL_FETCH_LAST, 0);
  6797.         RETCHECK(SQL_ERROR, rc, szSQLFETCHSCROLL);
  6798.  
  6799.         rc = SQLFreeStmt(hstmt, SQL_CLOSE);
  6800.         RETCHECK(SQL_SUCCESS, rc, szSQLFREESTMT);
  6801.  
  6802.     }
  6803.  
  6804.     //free the hstmt handle
  6805.     FreeStmt(SQL_CLOSE);
  6806.  
  6807. } // TestFetchScroll()
  6808.  
  6809.  
  6810.  
  6811. /*-----------------------------------------------------------------------*/
  6812. /*      Function:               qtDisplayError                           */
  6813. /*-----------------------------------------------------------------------*/
  6814.  
  6815. void  PASCAL qtDisplayError(LPTSTR szFunction, LPTSTR buf, LPTSTR szFile, int iLine)
  6816. {
  6817.     TCHAR szTmp[MAX_STRING_SIZE];
  6818.  
  6819.     szWrite(TEXT(""), TRUE);
  6820.     szWrite(TEXT("\t\t\t"), FALSE);
  6821.     szWrite(szFunction, FALSE);
  6822.     szWrite(TEXT("  FAILED"), TRUE);
  6823.     szWrite(TEXT("\t\t\t"), FALSE);
  6824.     szWrite(buf, TRUE);
  6825.  
  6826.     wsprintf(szTmp,TEXT("\t\t\t%s: %d"), szFile, iLine);
  6827.     szWrite(szTmp, TRUE);
  6828.  
  6829.     szWrite(TEXT("\t\t\t  --------  "), TRUE);
  6830.  
  6831.     lpSI->failed++;
  6832.  
  6833.     return;
  6834. }
  6835.  
  6836.  
  6837. /*-----------------------------------------------------------------------*/
  6838. /*      Function:               qtMakeData                               */
  6839. /*-----------------------------------------------------------------------*/
  6840.  
  6841. LPTSTR  PASCAL qtMakeData(int row, int col,FIELDINFO  *rgField, LPTSTR buf)
  6842. {
  6843.     if(rgField->fAutoUpdate)
  6844.         return NULL;
  6845.  
  6846.     if(rgField->nullable && (row==col)) 
  6847.         {
  6848.         lstrcpy(buf,TEXT(""));
  6849.         return buf;
  6850.         }
  6851.  
  6852.     switch(rgField->wSQLType) {
  6853.         case SQL_CHAR:
  6854.         case SQL_VARCHAR:
  6855.         case SQL_LONGVARCHAR:
  6856.         case SQL_BINARY:
  6857.         case SQL_VARBINARY:
  6858.         case SQL_LONGVARBINARY:
  6859.             if(rgField->precision < 4)
  6860.                 wsprintf(buf,TEXT("%d"), 1);
  6861.             else
  6862.                 wsprintf(buf,TEXT("%d%d"), row, row);
  6863.             break;
  6864.         case SQL_DECIMAL:
  6865.         case SQL_NUMERIC:
  6866.         case SQL_REAL:
  6867.         case SQL_FLOAT:
  6868.         case SQL_DOUBLE:
  6869.             if(row == 2 && !rgField->fUnsigned) /* make the second row negative for variety */
  6870.                 wsprintf(buf,TEXT("-%d.%d"), row, row);
  6871.             else
  6872.                 wsprintf(buf,TEXT("%d.%d"), row, row);
  6873.             break;
  6874.  
  6875.         case SQL_BIT:
  6876.             if(row > 2)
  6877.                 wsprintf(buf,TEXT("%d"), 1);
  6878.             else
  6879.                 wsprintf(buf,TEXT("%d"), 0);
  6880.  
  6881.             break;
  6882.  
  6883.         case SQL_SMALLINT:
  6884.         case SQL_INTEGER:
  6885.         case SQL_TINYINT:
  6886.         case SQL_BIGINT:
  6887.             if(row == 2 && !rgField->fUnsigned) /* make the second row negative for variety */
  6888.                 wsprintf(buf,TEXT("-%d"), row);
  6889.             else
  6890.                 wsprintf(buf,TEXT("%d"), row);
  6891.             break;
  6892.  
  6893.         case SQL_TIME:
  6894.         case SQL_TYPE_TIME:
  6895.             wsprintf(buf,TEXT("{t '01:%02d:%02d'}"), row % 60, row % 60);
  6896.             break;
  6897.         case SQL_DATE:
  6898.         case SQL_TYPE_DATE:
  6899.             wsprintf(buf,TEXT("{d '1994-%02d-%02d'}"), (row % 12) + 1, (row % 30) + 1);
  6900.             break;
  6901.         case SQL_TIMESTAMP:
  6902.         case SQL_TYPE_TIMESTAMP:
  6903.             wsprintf(buf,TEXT("{ts '1994-%02d-%02d 01:%02d:%02d'}"), (row % 12) + 1, (row % 30) + 1, row % 60, row % 60);
  6904.             break;
  6905.     }
  6906.     return buf;
  6907. }
  6908.  
  6909.  
  6910.  
  6911.  
  6912. /*-----------------------------------------------------------------------*/
  6913. /*      Function:               TestNumResCols                           */
  6914. /*-----------------------------------------------------------------------*/
  6915.  
  6916. VOID PASCAL TestNumResCols(SDWORD cColsSelected,QTSTRUCT *lpqt)
  6917. {
  6918.     RETCODE    rc=SQL_SUCCESS;
  6919.     SWORD        wNum;
  6920.  
  6921.     SelectFromTable(lpqt);
  6922.  
  6923.     rc = SQLNumResultCols(hstmt, &wNum);
  6924.     RETCHECK(SQL_SUCCESS, rc,szSQLNUMRESULTCOLS);
  6925.  
  6926.     if(wNum != cColsSelected)
  6927.         DISPLAYERROR(szSQLNUMRESULTCOLS,TEXT("incorrect value returned"));
  6928.  
  6929.     FreeStmt(SQL_CLOSE);
  6930.  
  6931. } /* TestNumResCols() */
  6932.  
  6933.  
  6934.  
  6935. /*-----------------------------------------------------------------------*/
  6936. /*      Function:               TestNumResCols                           */
  6937. /*-----------------------------------------------------------------------*/
  6938.  
  6939. VOID PASCAL TestCursorName(QTSTRUCT *lpqt)
  6940. {
  6941.     RETCODE    rc=SQL_SUCCESS;
  6942.     TCHAR        szCursorName[MEDBUFF];
  6943.     SWORD        cb=0;
  6944.  
  6945.     SelectFromTable(lpqt);
  6946.  
  6947.     /* the cursor name should be created by the driver since one was    */
  6948.     /* not specified                                                                    */
  6949.  
  6950.     rc = SQLGetCursorName(hstmt, szCursorName, MAX_STRING_SIZE, &cb);
  6951.     RETCHECK(SQL_SUCCESS, rc,szSQLGETCURSORNAME);
  6952.  
  6953.     if(cb > MAX_STRING_SIZE)
  6954.     {
  6955.         DISPLAYERROR(szSQLGETCURSORNAME,TEXT("invalid cb"));
  6956.         cb = MAX_STRING_SIZE;
  6957.     }
  6958.  
  6959.     /* don't check the name itself, just make sure that    */
  6960.     /*    something was returned                                         */
  6961.     if(!*szCursorName) 
  6962.         DISPLAYERROR(szSQLGETCURSORNAME,TEXT("no name returned"));
  6963.  
  6964.     FreeStmt(SQL_CLOSE);
  6965.  
  6966. } /* TestCursorName() */
  6967.  
  6968.  
  6969. //-----------------------------------------------------------------------
  6970. //      Function:               GetDMVersion
  6971. //-----------------------------------------------------------------------
  6972.  
  6973. UWORD PASCAL GetDMVersion()
  6974. {
  6975.     RETCODE    rc=SQL_SUCCESS;
  6976.     TCHAR        szNum[MAX_NUM_BUFFER];
  6977.  
  6978.     rc = SQLGetInfo(hdbc, SQL_ODBC_VER, &szNum, MAX_NUM_BUFFER, NULL);
  6979.     RETCHECK(SQL_SUCCESS, rc,szSQLGETINFO);
  6980.     
  6981.     return((UWORD)_ttoi(_tcstok(szNum,TEXT("."))));
  6982.  
  6983. } /* GetDMVersion() */
  6984.  
  6985.  
  6986. //-----------------------------------------------------------------------
  6987. //      Function:               DisplayTestName
  6988. //-----------------------------------------------------------------------
  6989.  
  6990. VOID PASCAL DisplayTestName(UWORD i)
  6991. {
  6992.     szWrite(szBLANKLINE,TRUE);
  6993.     szWrite(szTAB,FALSE);
  6994.     szWrite(iTestNames[i-1], TRUE);
  6995.  
  6996. } /* DisplayTestName() */
  6997.  
  6998.  
  6999.  
  7000. /***************************  External Interfaces  *************************/
  7001. /*  These functions are called by Gator to envoke the tests.               */
  7002. /***************************************************************************/
  7003.  
  7004. BOOL CALLBACK AutoTestName(LPTSTR szName, UINT  * cbTestCases)
  7005. {
  7006.     static TCHAR szTestName[] = TEXT("Quick Test");
  7007.     
  7008.     lstrcpy(szName, szTestName);
  7009.     
  7010.     *cbTestCases = sizeof(iTestNames)/sizeof(LPTSTR);
  7011.  
  7012.     return TRUE;
  7013. }
  7014.  
  7015. //-----------------------------------------------------------------------
  7016. //      Function:               AutoTestDesc
  7017. //      Purpose:                        Provides gator with a list of tests which can be run.
  7018. //-----------------------------------------------------------------------
  7019. BOOL CALLBACK AutoTestDesc(UWORD iTest, LPTSTR szName, LPTSTR szDesc)
  7020. {
  7021.             
  7022.     UWORD len=0;
  7023.  
  7024.     if (iTest > (sizeof(iTestNames)/sizeof(LPTSTR)))
  7025.         return FALSE;
  7026.  
  7027.     if (szName)
  7028.          lstrcpy(szName,iTestNames[iTest-1]);
  7029.     
  7030.     if (szDesc)
  7031.         lstrcpy(szDesc,TEXT(" "));
  7032.     
  7033.     return TRUE;
  7034.  
  7035. }
  7036.  
  7037. //-----------------------------------------------------------------------
  7038. //      Function:               AutoTestFunc
  7039. //-----------------------------------------------------------------------
  7040.  
  7041. void CALLBACK AutoTestFunc(lpSERVERINFO pTestSource)
  7042. {
  7043.  
  7044.     RETCODE            rc;
  7045.     UWORD                cTypes;
  7046.     UDWORD            dwLen;
  7047.     UWORD                fIndex;
  7048.     SDWORD            cColsSelected;
  7049.     FIELDINFO        *rgFields = (FIELDINFO  *)AllocateMemory(sizeof(FIELDINFO) * MAX_TYPES_SUPPORTED);
  7050.     QTSTRUCT            *lpqt = (QTSTRUCT  *)AllocateMemory(sizeof (QTSTRUCT));
  7051.     DSTRUCT            *lpd = (DSTRUCT  *)AllocateMemory(sizeof (DSTRUCT) * MAX_TYPES_SUPPORTED);
  7052.     UWORD                uDMVer;
  7053.     SDWORD            cbValue=0;
  7054.     TCHAR                szAPI[MEDBUFF];
  7055.     UWORD                i;
  7056.     TCHAR        szState[100]=TEXT(""),
  7057.                 szErrMsg[XLARGEBUFF]=TEXT("");
  7058.  
  7059.  
  7060.     lpSI = pTestSource;
  7061.     lpSI->failed = 0;
  7062.     henv = NULL;
  7063.     hdbc = NULL;
  7064.     hstmt = NULL;
  7065.     hdesc = NULL;
  7066.  
  7067.     if(lpSI->szValidServer0)
  7068.     {
  7069.         if (Connect(lpSI,lpqt))
  7070.             goto ErrorRet;
  7071.     }
  7072.     else 
  7073.     {
  7074.         henv = lpSI->henv;
  7075.         hdbc = lpSI->hdbc;
  7076.         
  7077.         rc = SQLSetConnectOption(hdbc,SQL_ODBC_CURSORS,dwLen);
  7078.         lstrcpy(szAPI,szSQLSETCONNECTOPTION);
  7079.  
  7080.         if(RETCHECK(SQL_SUCCESS, rc,szAPI))
  7081.             lpSI->vCursorLib = dwLen;
  7082.     }
  7083.  
  7084.      uDMVer=GetDMVersion();
  7085.  
  7086.     fIndex=CheckConformanceLevel();
  7087.  
  7088.     fBindParameter=Supported(SQL_API_SQLBINDPARAMETER);
  7089.     fDiagRecSupported=Supported(SQL_API_SQLGETDIAGREC);
  7090.     fDiagFieldSupported=Supported(SQL_API_SQLGETDIAGFIELD);
  7091.  
  7092.  
  7093.     AllocHstmt();
  7094.  
  7095.     if (!(cTypes=GetTypeInfo(rgFields,lpqt)))
  7096.         goto ErrorRet;
  7097.  
  7098.     guwRowCount=cTypes+1;    // Extra row inserted with DAE.
  7099.  
  7100.     // cTypes=20;              //DEBUG
  7101.  
  7102.     /* build create statement */
  7103.     if (BuildCreateStmt(lpqt,rgFields,cTypes))
  7104.         goto ErrorRet;
  7105.  
  7106.     /* put together the insert statement, and set the parameters   */
  7107.     /* parameters are only set the first time through, after which */
  7108.     /* the contents of the pointers is changed                     */
  7109.     if (BuildInsertStmt(lpqt, rgFields,cTypes,lpd,&cColsSelected,fBindParameter))
  7110.         goto ErrorRet;
  7111.  
  7112.     CreateParamQuery(lpqt,rgFields,cTypes);
  7113.     
  7114.     for(i=1;i <= (sizeof(iTestNames)/sizeof(LPTSTR));i++)
  7115.     {
  7116.         lpqt->sz[0] = TEXT('\0');
  7117.  
  7118.         if(GETBIT(pTestSource->rglMask,i))
  7119.         {
  7120.             /* Display current Test */
  7121.             DisplayTestName(i);
  7122.  
  7123.             switch(i)
  7124.             {
  7125.                 case 1:
  7126.                     TestConnectionOptions();
  7127.                     break;
  7128.                 case 2:
  7129.                     TestStmtOptions();
  7130.                     break;
  7131.                 case 3:
  7132.                     TestCursorName(lpqt);
  7133.                     break;
  7134.                 case 4:
  7135.                     TestData(lpqt,rgFields,cTypes,lpd);
  7136.                     break;
  7137.                 case 5:
  7138.                     TestNumResCols(cColsSelected,lpqt);
  7139.                     break;
  7140.                 case 6:
  7141.                     TestMetaData(lpSI,lpqt,rgFields,cTypes);
  7142.                     break;
  7143.                 case 7:
  7144.                     TestSearchedQuery(lpqt,rgFields,cTypes,lpd,fBindParameter);
  7145.                     break;
  7146.                 case 8:
  7147.                     TestLargeQuery(lpqt,rgFields,cTypes,lpd);
  7148.                     break;
  7149.                 case 9:
  7150.                     TestSQLTables(lpqt);
  7151.                     break;
  7152.                 case 10:
  7153.                     TestSQLStatistics(lpqt,rgFields,cTypes,lpd,fIndex);
  7154.                     break;
  7155.                 case 11:
  7156.                     TestSQLSpecialCols(lpqt);
  7157.                     break;
  7158.                 case 12:
  7159.                     TestLikeQuery(lpqt,rgFields,cTypes,lpd);
  7160.                     break;
  7161.                 case 13:
  7162.                     TestSQLForeignKeys(lpqt);
  7163.                     break;
  7164.                 case 14:
  7165.                     TestSQLBrowseConnect(lpSI);
  7166.                     break;
  7167.                 case 15:
  7168.                     TestSQLDataSources();
  7169.                     break;
  7170.                 case 16:
  7171.                     TestSQLDrivers();
  7172.                     break;
  7173.                  case 17:
  7174.                     TestSQLMoreResults(lpqt);
  7175.                     break;
  7176.                  case 18:
  7177.                     TestSQLNativeSQL(lpqt);
  7178.                     break;
  7179.                 case 19:
  7180.                     TestSQLDescribeParam(lpqt);
  7181.                     break;
  7182.                 case 20:
  7183.                     TestSQLNumParams(lpqt);
  7184.                     break;
  7185.                 case 21:
  7186.                     TestSQLParamOptions(lpqt);
  7187.                     break;
  7188.                 case 22:
  7189.                     TestSQLPrimaryKeys(lpqt);
  7190.                     break;
  7191.                 case 23:
  7192.                     TestSQLProcedures();
  7193.                     break;
  7194.                 case 24:
  7195.                     TestSQLTablePrivileges();
  7196.                     break;
  7197.                 case 25:
  7198.                     TestSQLColumnPrivileges(lpqt);
  7199.                     break;
  7200.                 case 26:
  7201.                     TestSQLSetScrollOptions();
  7202.                     break;
  7203.                 case 27:
  7204.                     TestExtendedFetch(lpqt,rgFields,cTypes);
  7205.                     break;
  7206.                 case 28:
  7207.                     TestOJCap(lpqt);
  7208.                     break;
  7209.                 case 29:
  7210.                     TestSQLSetConnectAttr();
  7211.                     break;
  7212.                 case 30:
  7213.                     TestSQLSetStmtAttr();
  7214.                     break;
  7215.                 case 31:
  7216.                     TestThreading(lpSI,lpqt,rgFields);
  7217.                     break;
  7218.                 case 32:
  7219.                     TestGetDescField(lpqt);
  7220.                     break;
  7221.                 case 33:
  7222.                     TestSetDescField(lpqt);
  7223.                     break;
  7224.                 case 34:
  7225.                     TestGetDescRec(lpqt);
  7226.                     break;
  7227.                 case 35:
  7228.                     TestSetDescRec(lpqt);
  7229.                     break;
  7230.                 case 36:
  7231.                     TestCopyDesc(lpqt);
  7232.                     break;
  7233.                 case 37:
  7234.                     TestDescDefaults(lpqt);
  7235.                     break;
  7236.                 case 38:
  7237.                     TestUseDesc(lpqt, rgFields);
  7238.                     break;
  7239.                 case 39:
  7240.                     TestEnvAttr();
  7241.                     break;
  7242.                 case 40:
  7243.                     TestEndTran(lpqt,rgFields,cTypes,lpd);
  7244.                     break;
  7245.                 case 41:
  7246.                     TestBindParam(lpqt,rgFields,cTypes,lpd);
  7247.                     break;
  7248.                 case 42:
  7249.                     TestQuickRebind(lpqt,rgFields,cTypes,lpd);
  7250.                     break;
  7251.                 case 43:
  7252.                     TestFetchScroll(lpqt);
  7253.                     break;
  7254.                 case 44:
  7255.                     TestDiagRec();
  7256.                     break;
  7257.                 case 45:
  7258.                     TestDiagField();
  7259.                     break;
  7260.                 case 46:
  7261.                     TestMixedAnsiUnicode(lpqt);
  7262.                     break;
  7263.     
  7264.             } /* switch(i) */
  7265.  
  7266.         } /* if(GETBIT(pTestSource->rglMask,i)) */
  7267.     
  7268.     }
  7269.  
  7270.     //the end of test cases for ODBC SDK 3.0
  7271.  
  7272.     /* finished testing, clean up */
  7273.     CleanUp(lpd,lpqt,rgFields,lpqt->szTableName,FALSE,lpSI->szValidServer0);
  7274.  
  7275.     szWrite(szBLANKLINE,TRUE);
  7276.  
  7277.     lpSI->cErrors = lpSI->failed;
  7278.  
  7279.     return;
  7280.  
  7281. ErrorRet:
  7282.     /* a failure in an ODBC function that prevents completion of the    */
  7283.     /* test - for example, connect to the server                             */
  7284.  
  7285.     szWrite(TEXT("\t\t *** Unrecoverable Quick Test FAILURE ***"), TRUE);
  7286.  
  7287.     /* finished testing, clean up */
  7288.     CleanUp(lpd,lpqt,rgFields,lpqt->szTableName,FALSE,lpSI->szValidServer0);
  7289.  
  7290.     lpSI->cErrors = ABORT;
  7291.  
  7292.     return;
  7293. }
  7294.