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.h < prev    next >
Encoding:
C/C++ Source or Header  |  1996-08-21  |  12.1 KB  |  385 lines
  1. //****************************************************************************
  2. //|   Title:   quiktest.h
  3. //| 
  4. //|   (c) Copyright 1991, 1992, 1993, 1994, 1995
  5. //|       by Microsoft Corp.
  6. //| 
  7. //******************************************************************************
  8. #ifndef quiktest_defs
  9. #define quiktest_defs
  10.  
  11.  
  12. /*-----------------------------------------------------------------------------------*/
  13. /*    constants defines                                                                                         */
  14. /*-----------------------------------------------------------------------------------*/
  15. #define MAX_QUERY_SIZE                        2048
  16. #define MAX_BIND_ELEMENTS                    100
  17. #define MAX_BIND_ARRAY_ELEMENT            MAX_QUERY_SIZE / MAX_BIND_ELEMENTS
  18. #define MAX_STRING_SIZE                        350          // Increased from 255 due to overwrite
  19. #define MAX_PARAM_SIZE                        129
  20. #define MAX_DATA_SIZE                        45
  21. #define MAX_COLUMN_LIST_SIZE                200
  22. #define MAX_COLUMN_NAME_SIZE                100
  23. #define MAX_INSERT_VALUES_SIZE            200
  24. #define MAX_TYPES_SUPPORTED                25
  25. #define MAX_TYPE_NAME                        129
  26. #define MAX_FIELD                                40
  27. #define MAX_PREFIX                            129
  28. #define MAX_SUFFIX                            129
  29. #define MAX_TABLE_NAME                        60
  30. #define MAX_NUM_BUFFER                        60
  31. #define MAX_ERROR_SIZE                        200
  32. #define MAX_ROW_ITEM_LIMIT                    4
  33.  
  34. #define PREFIX_SIZE                            3
  35. #define IGNORED                                999
  36. #define TEST_CONNECT_OPTION                15
  37. #define TEST_STMT_OPTION                    300
  38. #define SCALEDIFF                                4
  39. #define ABORT                                    -1
  40. #define TYPE_PORTION                            4
  41. #define MAXUDWORD                                ((UDWORD)(-1))
  42. #define MINSDWORD                                (-(SDWORD)((MAXUDWORD / 2) + 1))
  43. #define MAXSDWORD                                ((SDWORD)(MAXUDWORD / 2))
  44.  
  45. #define SMALLBUFF                                100
  46. #define MEDBUFF                                200
  47. #define LARGEBUFF                                300
  48. #define XLARGEBUFF                            1024
  49. #define STATE_SIZE                            6
  50. #define COMBINED_SIZE                        MAX_ERROR_SIZE + 30
  51.  
  52. // Descriptor type defines
  53. #define DESC_NONE                    0        // No descriptor type
  54. #define DESC_APD                    1        // APD only
  55. #define DESC_IPD                    2        // IPD only
  56. #define DESC_ARD                    4        // ARD only
  57. #define DESC_IRD                    8        // IRD only
  58. #define DESC_PD                    DESC_APD|DESC_IPD        //    Parameter descriptors
  59. #define DESC_RD                    DESC_ARD|DESC_IRD        // Row descriptors
  60. #define DESC_ID                    DESC_IPD|DESC_IRD        // Implementation descriptors
  61. #define DESC_AD                    DESC_APD|DESC_ARD        // Application descriptors
  62. #define DESC_MOST                    DESC_AD|DESC_IPD    // This is the most common settable combination
  63. #define DESC_ALL                    DESC_APD|DESC_IPD|DESC_ARD|DESC_IRD    // All descriptor types
  64.  
  65. #define STATUS_ARRAY_SIZE        5        // Array size to use for row and param arrays
  66. #define BIND_SIZE                    12        // Bind type size value
  67.  
  68. /* NUM_THREAD is the number of threads that will be created for multi-thread test */
  69. #define NUM_THREAD                            5
  70. #define NUM_QUIKREBIND_ROWSETS            6
  71.  
  72. /* BIND_PARM_OFFSET specifies the parameter base for DAE bindings. Either 0 */
  73. /* or 1 based.  */
  74. #define BIND_PARM_OFFSET                    0
  75.  
  76. // COLNAME_START specifies the beginning number used in colnames, i.e. c00bit 
  77. // vs. c01bit.
  78. #define COLNAME_START                        1
  79.                                                     
  80. /*constants for Descriptor tests */
  81. #define MAX_DESC_BUF                            200
  82. #define DESC_UPDATE_MODE_READ                0
  83. #define DESC_UPDATE_MODE_WRITE            1
  84. #define REC_COUNT_UNK                        -1        // Unkown record count
  85. // #define DESC_LOCATE_FAIL                    -1
  86.  
  87. /* constants for TestBindParam */
  88. #define INSERT_FAIL                              -1
  89.  
  90. #define UNTOUCHED 0xCA
  91.  
  92. /*------------------------------------------------------------------------------------*/
  93. /*    macros                                                                             */
  94. /*------------------------------------------------------------------------------------*/
  95.  
  96. #define RC_SUCCESSFUL(rc)    ((rc) == SQL_SUCCESS || \
  97.     (rc) == SQL_SUCCESS_WITH_INFO)
  98.  
  99. #define RC_NOTSUCCESSFUL(rc) (!(RC_SUCCESSFUL(rc)))
  100.  
  101. #define RETCHECK(exp, rec, buf) ReturnCheck(exp, rec, buf, TEXT(__FILE__), __LINE__,FALSE)
  102.  
  103. #define ERRSHANDLE(type, handle, exp, rec, buf) ErrsHandle(type, handle, exp, rec, buf, TEXT(__FILE__), __LINE__,FALSE)
  104.  
  105. #define DIAGRETCHECK(exp, rec, buf) ReturnCheck(exp, rec, buf, TEXT(__FILE__), __LINE__,TRUE)
  106.  
  107. #define DISPLAYERROR(func, string) qtDisplayError(func, string, TEXT(__FILE__), __LINE__)
  108.  
  109. /*--------------------------------------------------------------------------------------*/
  110. /*    Structure definitions                                                                                    */
  111. /*--------------------------------------------------------------------------------------*/
  112.  
  113. /* Number of Cols in result set of a query: */
  114. UWORD cNumResSetCols;
  115.  
  116. /* used to store information from GetTypeInfo for table creation */
  117. typedef struct FieldInfo {
  118.         int iField;
  119.         TCHAR szType[MAX_TYPE_NAME];
  120.         TCHAR szFieldName[MAX_FIELD];
  121.         SWORD  wSQLType;
  122.         TCHAR szParams[MAX_PARAM_SIZE];
  123.         TCHAR szLength[MAX_FIELD];
  124.         TCHAR szPrefix[MAX_PREFIX];
  125.         TCHAR szSuffix[MAX_SUFFIX];
  126.         SDWORD precision;
  127.         SWORD scale;
  128.         SWORD nullable;
  129.         UDWORD length;
  130.         int   fAutoUpdate;
  131.         SWORD fSearchable;
  132.         SDWORD fUnsigned;
  133.         SWORD autoinc;
  134.         } FIELDINFO;
  135.  
  136.  
  137.  
  138. /* large buffers allocated as a global used for queries and other*/
  139. /* returned information                                          */
  140. typedef struct  tagQtStruct {
  141.     TCHAR        buf[MAX_STRING_SIZE];
  142.     TCHAR        sz[MAX_QUERY_SIZE];
  143.     TCHAR        szParamQuery[MAX_QUERY_SIZE];
  144.     TCHAR        szParam[MAX_PARAM_SIZE];
  145.     TCHAR        szDataItem[MAX_DATA_SIZE];
  146.     TCHAR        szTableName[MAX_TABLE_NAME];
  147.     TCHAR        szColNames[MAX_COLUMN_LIST_SIZE];
  148.     TCHAR        szColName[MAX_COLUMN_NAME_SIZE];
  149.     TCHAR        szValues[MAX_INSERT_VALUES_SIZE];
  150. }       QTSTRUCT;
  151.  
  152. /* the storage used for data retreived using bind/fetch sequence  */
  153. /* and data for BindParameter                                     */
  154. /* only cb and one of the types will be used for each entry       */
  155. typedef struct tagDataStruct {
  156.     SDWORD cb;
  157.     TCHAR data[MAX_STRING_SIZE];
  158.     SDWORD sdword;
  159.     UDWORD udword;
  160.     SWORD sword;
  161.     UWORD uword;
  162.     TCHAR    sChar;
  163.     SQLTCHAR uChar;
  164.     SDOUBLE sdouble;
  165.     SFLOAT sfloat;
  166.     TIME_STRUCT time;
  167.     DATE_STRUCT date;
  168.     TIMESTAMP_STRUCT timestamp;
  169. } DSTRUCT;
  170.  
  171. /* These declarations used to reside locally, but the structures didn't get initialized correctly */
  172. typedef struct SupportOptList {
  173.     UDWORD Support;
  174.     SDWORD Option;
  175.     } SUPPORTOPTINFO;
  176.  
  177. typedef struct SupportConcurList {
  178.     UDWORD Support;
  179.     UWORD Option;
  180.     } SUPPORTCONCURINFO;
  181.  
  182.  
  183.  
  184. /* Each thread will contain the following information */
  185. typedef struct {
  186.     HENV        henv;
  187.     HDBC        hdbc;
  188.     TCHAR        szTableName[MAX_TABLE_NAME];
  189.     FIELDINFO rgFieldInfo;
  190.  
  191. } THREAD_STRUCT;
  192.  
  193.  
  194. static union
  195. {
  196.     BYTE rgb[max(max(max(sizeof (HENV),sizeof (HDBC)),
  197.                     max(sizeof (HSTMT), sizeof (SQLHDESC))),sizeof (UDWORD))];
  198.     SWORD sw;
  199.     UWORD uw;
  200.     SDWORD sdw;
  201.     UDWORD udw;
  202.     HENV henv;
  203.     HDBC hdbc;
  204.     HSTMT hstmt;
  205.     SQLHDESC hdesc;
  206. } Untouched = {UNTOUCHED, UNTOUCHED, UNTOUCHED, UNTOUCHED};
  207.                                                          
  208.  
  209.  
  210. int  PASCAL ReturnCheck(RETCODE retExpected, RETCODE retReceived, LPTSTR szFunction, 
  211.                                 LPTSTR szFile, int iLine,BOOL fDiag);
  212. void PASCAL qtDisplayError(LPTSTR szFunction, LPTSTR buf, LPTSTR szFile, int iLine);
  213. LPTSTR PASCAL qtMakeData(int row, int col,FIELDINFO * rgField, LPTSTR buf);
  214.  
  215. BOOL PASCAL CmpODBCtoCHAR(DSTRUCT * rgTestValue, TCHAR * szTrueValue,
  216.     SWORD fSqlType, SWORD iResSetCol);
  217.  
  218. void* PASCAL CvtCHARtoODBC(void * odbcValue, TCHAR * buf, SWORD fSqlType)
  219. {
  220.     if(!buf)
  221.         return NULL;
  222.  
  223.     switch (fSqlType) {
  224.         case SQL_DATE: 
  225.         case SQL_TYPE_DATE: 
  226.         {
  227.             TCHAR szDATEDELIM[] = TEXT("d{}'- ");
  228.             TCHAR szTempBuff[30];
  229.             LPTSTR   tmpstr=szTempBuff;
  230.             _tcscpy((LPTSTR) szTempBuff, buf);
  231.  
  232.             ((DATE_STRUCT *)odbcValue)->year = _ttoi(_tcstok(tmpstr, szDATEDELIM));
  233.             ((DATE_STRUCT *)odbcValue)->month = _ttoi(_tcstok(NULL, szDATEDELIM));
  234.             ((DATE_STRUCT *)odbcValue)->day = _ttoi(_tcstok(NULL, szDATEDELIM));
  235.             break;
  236.         }
  237.  
  238.  
  239.         case SQL_TIME: 
  240.         case SQL_TYPE_TIME: 
  241.         {
  242.             TCHAR szTIMEDELIM[] = TEXT("t{}': ");
  243.             TCHAR szTempBuff[30];
  244.             LPTSTR   tmpstr=szTempBuff;
  245.             _tcscpy((LPTSTR) szTempBuff, buf);
  246.  
  247.             ((TIME_STRUCT *)odbcValue)->hour = _ttoi(_tcstok(tmpstr, szTIMEDELIM));
  248.             ((TIME_STRUCT *)odbcValue)->minute = _ttoi(_tcstok(NULL, szTIMEDELIM));
  249.             ((TIME_STRUCT *)odbcValue)->second = _ttoi(_tcstok(NULL, szTIMEDELIM));
  250.  
  251.             break;
  252.         }
  253.  
  254.         case SQL_TIMESTAMP:
  255.         case SQL_TYPE_TIMESTAMP:
  256.         {
  257.             TCHAR szDATETIMEDELIM[] = TEXT("ts'{}-:. ");
  258.             TCHAR szTempBuff[30];
  259.             LPTSTR   tmpstr=szTempBuff;
  260.             LPTSTR    endstr, frstr;
  261.             _tcscpy((LPTSTR) szTempBuff, buf);
  262.  
  263.             /* First the date */
  264.             ((TIMESTAMP_STRUCT *)odbcValue)->year = _ttoi(_tcstok(tmpstr, szDATETIMEDELIM));
  265.             ((TIMESTAMP_STRUCT *)odbcValue)->month = _ttoi(_tcstok(NULL, szDATETIMEDELIM));
  266.             ((TIMESTAMP_STRUCT *)odbcValue)->day = _ttoi(_tcstok(NULL, szDATETIMEDELIM));
  267.             /* Then the complete time */
  268.             ((TIMESTAMP_STRUCT *)odbcValue)->hour = _ttoi(_tcstok(NULL, szDATETIMEDELIM));
  269.             ((TIMESTAMP_STRUCT *)odbcValue)->minute = _ttoi(_tcstok(NULL, szDATETIMEDELIM));
  270.             ((TIMESTAMP_STRUCT *)odbcValue)->second = _ttoi(_tcstok(NULL, szDATETIMEDELIM));
  271.             if(frstr = _tcstok(NULL, szDATETIMEDELIM))
  272.                 ((TIMESTAMP_STRUCT *)odbcValue)->fraction = (_tcstoul(frstr, &endstr, 10) * 1000000);
  273.             else
  274.                 ((TIMESTAMP_STRUCT *)odbcValue)->fraction = 0;
  275.  
  276.             break;
  277.         }
  278.  
  279.     }
  280.     return odbcValue;
  281. }
  282.  
  283.  
  284. /* Compares the value stored at location (row,col) in the array of 
  285.  * DSTRUCT's with the value created by qtMakeData                            */
  286. BOOL PASCAL CmpODBCtoCHAR(DSTRUCT * rgTestValue, TCHAR * szTrueValue,
  287.     SWORD fSqlType, SWORD iCol)
  288. {
  289.     BOOL fTestPass=TRUE;
  290.     SWORD test1,test2;
  291.     TCHAR    *pStop=NULL;
  292.  
  293.     switch (fSqlType) {
  294.         case SQL_BIGINT:
  295.         case SQL_INTEGER:
  296.             if(_ttoi(szTrueValue) == (int)rgTestValue[iCol].sdword) 
  297.                 return TRUE;
  298.             return FALSE;
  299.  
  300.         case SQL_DECIMAL:
  301.         case SQL_NUMERIC:
  302.                 return  (_tcstod(szTrueValue,&pStop) == 
  303.                     (float)_tcstod(rgTestValue[iCol].data,&pStop));
  304.         case SQL_TINYINT:
  305.         case SQL_SMALLINT:
  306.             if(_ttoi(szTrueValue) == (int)rgTestValue[iCol].sword)
  307.                 return TRUE;
  308.             return FALSE;
  309.  
  310.         case SQL_FLOAT:
  311.         case SQL_DOUBLE: 
  312.                 return  (_tcstod(szTrueValue,&pStop) == (float)rgTestValue[iCol].sdouble);
  313.  
  314.         case SQL_REAL:
  315.                 /* Need to account for round-off errors in _tcstod conversions: */
  316.                 test1 = (SWORD)(1000*_tcstod(szTrueValue,&pStop));
  317.                 test1 = (SWORD)((test1>0) ? (test1+5)/10 : (test1-5)/10);
  318.                 test2 = (SWORD)(1000*rgTestValue[iCol].sfloat);
  319.                 test2 = (SWORD)((test2>0) ? (test2+5)/10 : (test2-5)/10);
  320.                 return  (test1 == test2);
  321.  
  322.         case SQL_TIMESTAMP: 
  323.         case SQL_TYPE_TIMESTAMP: 
  324.         {
  325.             TIMESTAMP_STRUCT tss;
  326.             CvtCHARtoODBC(&tss, szTrueValue, SQL_TYPE_TIMESTAMP);
  327.  
  328.             fTestPass= ((rgTestValue[iCol].timestamp.month == tss.month)
  329.                 && (rgTestValue[iCol].timestamp.day == tss.day)
  330.                 && (rgTestValue[iCol].timestamp.year == tss.year)
  331.                 && (rgTestValue[iCol].timestamp.hour == tss.hour)
  332.                 && (rgTestValue[iCol].timestamp.minute == tss.minute)
  333.                 && (rgTestValue[iCol].timestamp.fraction ==
  334.                     tss.fraction));
  335.             /* Seconds value is zero for small timestamp, so to keep it from always failing... */
  336.             if(0 != rgTestValue[iCol].timestamp.second)
  337.                 fTestPass= (fTestPass && rgTestValue[iCol].timestamp.second == tss.second);
  338.             return fTestPass;
  339.         }
  340.  
  341.         case SQL_TIME: 
  342.         case SQL_TYPE_TIME: 
  343.         {
  344.             TIME_STRUCT tss;
  345.  
  346.             CvtCHARtoODBC(&tss, szTrueValue, SQL_TYPE_TIME);
  347.             fTestPass=  ((rgTestValue[iCol].time.hour == tss.hour)
  348.                 && (rgTestValue[iCol].time.minute == tss.minute));
  349.             /* Seconds value is zero for small timestamp, so to keep it from always failing... */
  350.             if(0 != rgTestValue[iCol].time.second)
  351.                 fTestPass= (fTestPass && rgTestValue[iCol].time.second == tss.second);
  352.             return fTestPass;
  353.         }
  354.  
  355.         case SQL_DATE: 
  356.         case SQL_TYPE_DATE: 
  357.         {
  358.             DATE_STRUCT tss;
  359.             CvtCHARtoODBC(&tss, szTrueValue, SQL_TYPE_DATE);
  360.  
  361.             return ((rgTestValue[iCol].date.month == tss.month)
  362.                 && (rgTestValue[iCol].date.day == tss.day)
  363.                 && (rgTestValue[iCol].date.year == tss.year));
  364.         }
  365.  
  366.          case SQL_BIT: 
  367.          case SQL_CHAR: 
  368.         case SQL_VARCHAR:
  369.         case SQL_LONGVARCHAR:
  370.         case SQL_BINARY:                                  
  371.         case SQL_VARBINARY:                      
  372.         case SQL_LONGVARBINARY: 
  373.         default:
  374.             return !(_tcsncmp(szTrueValue, rgTestValue[iCol].data, 
  375.                 _tcslen(szTrueValue)));
  376.  
  377.     }
  378. }
  379.  
  380.  
  381. #endif                                                 
  382.                                                         
  383.                                                         
  384.                                                         
  385.