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 / admndemo / info.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-10-08  |  99.8 KB  |  2,509 lines
  1. //*---------------------------------------------------------------------------------
  2. //|  ODBC System Administrator
  3. //|
  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. //|   Title:   INFO.C
  8. //|      This module contains the functions which handle the Info menu items.
  9. //|         This module relies on RESULTS and EXECUTE to 
  10. //|      This file contains the actual code to execute SQL Statements and
  11. //|         display them.  This file is dependent on the SA Tool data structures
  12. //|         and the independent module RESULTS.
  13. //|
  14. //|      NOTE:  Due to the timing of this sample, only the 1.0 GetInfo constants
  15. //|         are shown.  To see all GetInfo constants for a 2.0 driver, use the
  16. //|         ODBC Test Tool which comes with this SDK.
  17. //*---------------------------------------------------------------------------------
  18. #include "info.h"
  19. #include "ini.h"
  20. #include "sql.h"
  21. #include "sqlext.h"
  22. #include "stdlib.h"
  23. #include "strings.h"
  24. VSZFile;
  25.  
  26. //*---------------------------------------------------------------------------------
  27. //|   Defines and macros
  28. //*---------------------------------------------------------------------------------
  29. #define MAXNAME            35
  30. #define MAXPARMS           18
  31. #define MAXSQL             300
  32.  
  33. #define szCOMMA            ","
  34. #define szBLANK            " "
  35.  
  36. typedef struct tagNEWPIPE {
  37.    HWND        hwnd;
  38.    HINSTANCE   hInst;
  39.    char        szName[MAXNAME];
  40.    BOOL        fSuccess;
  41. } NEWPIPE;
  42.  
  43. //*---------------------------------------------------------------------------------
  44. //|   Local Function Prototypes
  45. //*---------------------------------------------------------------------------------
  46. BOOL EXTFUN EditPipeWndProc(HWND hDlg, unsigned msg, WPARAM wParam, LPARAM lParam);
  47. void NewPipe(NEWPIPE FAR * np);
  48. BOOL EXTFUN NewPipeWndProc(HWND hDlg, unsigned msg, WPARAM wParam, LPARAM lParam);
  49. BOOL EXTFUN DoPipeWndProc(HWND hDlg, unsigned msg, WPARAM wParam, LPARAM lParam);
  50. void DoPipe(RESULTSSET FAR * rs, CHILDINFO FAR * ci, LPSTR szPipeName,
  51.          int FAR xPipes[], int cbCnt);
  52. void DoPipeByValue(RESULTSSET FAR * rs, CHILDINFO FAR * ci, LPSTR sqlpsql,
  53.       LPSTR szparms, int FAR xPipes[], int cbCnt, LPSTR szPipeName);
  54. void PrepareParmList(LPSTR str);
  55. SDWORD RefreshList(HWND hDlg, RESULTSSET FAR * rs, CHILDINFO FAR * ci, int state, 
  56.          LPSTR szQual, LPSTR szOwner, LPSTR szName, int cbCols);
  57. SDWORD RefreshPipeList(HWND hDlg);
  58.  
  59.  
  60. //*---------------------------------------------------------------------------------
  61. //|   Global variables
  62. //*---------------------------------------------------------------------------------
  63. extern dCSEG(char) szMSSansSerif[];
  64. extern dCSEG(char) szPIPES[];
  65. extern dCSEG(char) szFONT[];
  66. extern char        OutStr[MAXBUFF];
  67. extern dCSEG(char) szVALUE[];
  68.  
  69. dCSEG(char) szISO92[]            =  "ISO 92";
  70. dCSEG(char) szXOpen[]            =  "X/Open";
  71. dCSEG(char) szODBC[]             =  "ODBC";
  72. dCSEG(char) szDepr[]             =  "Deprecated";
  73.  
  74. dCSEG(char) szCore[]             =  "Core";
  75. dCSEG(char) szLvl1[]             =  "Level 1";
  76. dCSEG(char) szLvl2[]             =  "Level 2";
  77.  
  78. dCSEG(char) szYes[]              =  "Yes";
  79. dCSEG(char) szNo[]               =  "No";
  80.  
  81. dCSEG(char) szODBCFunctions[]    =  "Functions";
  82. dCSEG(char) szODBCDataSources[]  =  "Data Sources";
  83. dCSEG(char) szODBCDataTypes[]    =  "Data Types";
  84. dCSEG(char) szGetInfoTitle[]     =  "Get Info";
  85. dCSEG(char) szQualifier[]        =  "Qualifier";
  86. dCSEG(char) szOwner[]            =  "Owner";
  87. dCSEG(char) szName[]             =  "Name";
  88. dCSEG(char) szType[]             =  "Type";
  89. dCSEG(char) szSQL[]              =  "Sql";
  90. dCSEG(char) szPARMS[]            =  "Parms";
  91. dCSEG(char) szPARMOPT[]          =  "ParmOpt";
  92. dCSEG(char) szDELETEOPT[]        =  "Delete";
  93. dCSEG(char) szBothTypes[]        =  "'%s','%s'";
  94. dCSEG(char) szOneType[]          =  "'%s'";
  95. dCSEG(char) szBlank[]            =  " ";
  96. dCSEG(char) szTABLETYPE[]        =  "TABLE";
  97. dCSEG(char) szVIEWTYPE[]         =  "VIEW";
  98. dCSEG(char) szVALUE[]            =  "value";
  99. dCSEG(char) szADDRESS[]          =  "address";
  100. dCSEG(char) szDeletePipe[]       =  "Delete pipe %s?";
  101. dCSEG(char) szEditPipe[]         =  "Edit Pipe";
  102. dCSEG(char) szDuplicatePipe[]    =  "Pipe already exists";
  103. dCSEG(char) szInstalled[]        =  "Installed";
  104. dCSEG(char) szDROPPROCSEMI[]     =  "Drop Procedure (with semi-colon)";
  105.  
  106. static char szErrorMsgTitle[]    =  "Error";
  107.  
  108.  
  109.  
  110. struct {
  111.    UWORD          fFunction;                 // Identifier for SQLGetFunctions
  112.    LPSTR          szLevel;                   // Conformance Level
  113.    int            idFunction;                // String table identifier for function name
  114.    } ODBCFunctions[] = {
  115.  
  116. // fFunction                        szLevel           idFunction
  117. // -------------------------------  ---------------   --------------------------------
  118.  
  119. // ---- ISO 92 Conformance -----------------------------------
  120.    {SQL_API_SQLALLOCHANDLE,          (LPSTR)szISO92,    idsSQLAllocHandle},
  121.    {SQL_API_SQLBINDCOL,              (LPSTR)szISO92,    idsSQLBindCol},
  122.    {SQL_API_SQLCANCEL,               (LPSTR)szISO92,    idsSQLCancel},
  123.    {SQL_API_SQLCLOSECURSOR,          (LPSTR)szISO92,    idsSQLCloseCursor},
  124.    {SQL_API_SQLCOLATTRIBUTE,         (LPSTR)szISO92,    idsSQLColAttribute},
  125.    {SQL_API_SQLCONNECT,              (LPSTR)szISO92,    idsSQLConnect},
  126.    {SQL_API_SQLCOPYDESC,             (LPSTR)szISO92,    idsSQLCopyDesc},
  127.    {SQL_API_SQLDATASOURCES,          (LPSTR)szISO92,    idsSQLDataSources},
  128.    {SQL_API_SQLDESCRIBECOL,          (LPSTR)szISO92,    idsSQLDescribeCol},
  129.    {SQL_API_SQLDISCONNECT,           (LPSTR)szISO92,    idsSQLDisconnect},
  130.    {SQL_API_SQLENDTRAN,              (LPSTR)szISO92,    idsSQLEndTran},
  131.    {SQL_API_SQLEXECDIRECT,           (LPSTR)szISO92,    idsSQLExecDirect},
  132.    {SQL_API_SQLEXECUTE,              (LPSTR)szISO92,    idsSQLExecute},
  133.    {SQL_API_SQLFETCH,                (LPSTR)szISO92,    idsSQLFetch},
  134.    {SQL_API_SQLFETCHSCROLL,          (LPSTR)szISO92,    idsSQLFetchScroll},
  135.    {SQL_API_SQLFREEHANDLE,           (LPSTR)szISO92,    idsSQLFreeHandle},
  136.    {SQL_API_SQLFREESTMT,             (LPSTR)szISO92,    idsSQLFreeStmt},
  137.    {SQL_API_SQLGETCONNECTATTR,       (LPSTR)szISO92,    idsSQLGetConnectAttr},
  138.    {SQL_API_SQLGETCURSORNAME,        (LPSTR)szISO92,    idsSQLGetCursorName},
  139.    {SQL_API_SQLGETDATA,              (LPSTR)szISO92,    idsSQLGetData},
  140.    {SQL_API_SQLGETDESCFIELD,         (LPSTR)szISO92,    idsSQLGetDescField},
  141.    {SQL_API_SQLGETDESCREC,           (LPSTR)szISO92,    idsSQLGetDescRec},
  142.    {SQL_API_SQLGETDIAGFIELD,         (LPSTR)szISO92,    idsSQLGetDiagField},
  143.    {SQL_API_SQLGETDIAGREC,           (LPSTR)szISO92,    idsSQLGetDiagRec},
  144.    {SQL_API_SQLGETFUNCTIONS,         (LPSTR)szISO92,    idsSQLGetFunctions},
  145.    {SQL_API_SQLGETINFO,              (LPSTR)szISO92,    idsSQLGetInfo},
  146.    {SQL_API_SQLGETSTMTATTR,          (LPSTR)szISO92,    idsSQLGetStmtAttr},
  147.    {SQL_API_SQLGETTYPEINFO,          (LPSTR)szISO92,    idsSQLGetTypeInfo},
  148.    {SQL_API_SQLGETSTMTATTR,          (LPSTR)szISO92,    idsSQLGetStmtAttr},
  149.    {SQL_API_SQLNUMRESULTCOLS,        (LPSTR)szISO92,    idsSQLNumResultCols},
  150.    {SQL_API_SQLPREPARE,              (LPSTR)szISO92,    idsSQLPrepare},
  151.    {SQL_API_SQLPUTDATA,              (LPSTR)szISO92,    idsSQLPutData},
  152.    {SQL_API_SQLROWCOUNT,             (LPSTR)szISO92,    idsSQLRowCount},
  153.    {SQL_API_SQLSETCONNECTATTR,       (LPSTR)szISO92,    idsSQLGetConnectAttr},
  154.    {SQL_API_SQLSETCURSORNAME,        (LPSTR)szISO92,    idsSQLSetCursorName},
  155.    {SQL_API_SQLSETDESCFIELD,         (LPSTR)szISO92,    idsSQLSetDescField},
  156.    {SQL_API_SQLSETDESCREC,           (LPSTR)szISO92,    idsSQLSetDescRec},
  157.    {SQL_API_SQLSETENVATTR,           (LPSTR)szISO92,    idsSQLSetEnvAttr},
  158.    {SQL_API_SQLSETSTMTATTR,          (LPSTR)szISO92,    idsSQLSetStmtAttr},
  159.  
  160.    //---- X/Open Conformance -----------------------------------  
  161.    {SQL_API_SQLCOLUMNS,              (LPSTR)szXOpen,   idsSQLColumns},
  162.    {SQL_API_SQLGETENVATTR,           (LPSTR)szXOpen,   idsSQLGetEnvAttr},
  163.    {SQL_API_SQLSPECIALCOLUMNS,       (LPSTR)szXOpen,   idsSQLSpecialColumns},
  164.    {SQL_API_SQLSTATISTICS,           (LPSTR)szXOpen,   idsSQLStatistics},
  165.    {SQL_API_SQLTABLES,               (LPSTR)szXOpen,   idsSQLTables},
  166.  
  167.    //---- ODBC Conformance -------------------------------------
  168.    {SQL_API_SQLBINDPARAMETER,        (LPSTR)szODBC,    idsSQLBindParameter},
  169.    {SQL_API_SQLBROWSECONNECT,        (LPSTR)szODBC,    idsSQLBrowseConnect},
  170.    {SQL_API_SQLBULKOPERATIONS,       (LPSTR)szODBC,    idsSQLBulkOperations},
  171.    {SQL_API_SQLCOLUMNPRIVILEGES,     (LPSTR)szODBC,    idsSQLColumnPrivileges},
  172.    {SQL_API_SQLDESCRIBEPARAM,        (LPSTR)szODBC,    idsSQLDescribeParam},
  173.    {SQL_API_SQLDRIVERCONNECT,        (LPSTR)szODBC,    idsSQLDriverConnect},
  174.    {SQL_API_SQLFOREIGNKEYS,          (LPSTR)szODBC,    idsSQLForeignKeys},
  175.    {SQL_API_SQLMORERESULTS,          (LPSTR)szODBC,    idsSQLMoreResults},
  176.    {SQL_API_SQLNATIVESQL,            (LPSTR)szODBC,    idsSQLNativeSQL},
  177.    {SQL_API_SQLNUMPARAMS,            (LPSTR)szODBC,    idsSQLNumParams},
  178.    {SQL_API_SQLPRIMARYKEYS,          (LPSTR)szODBC,    idsSQLPrimaryKeys},
  179.    {SQL_API_SQLPROCEDURECOLUMNS,     (LPSTR)szODBC,    idsSQLProcedureColumns},
  180.    {SQL_API_SQLPROCEDURES,           (LPSTR)szODBC,    idsSQLProcedures},
  181.    {SQL_API_SQLSETPOS,               (LPSTR)szODBC,    idsSQLSetPos},
  182.    {SQL_API_SQLTABLEPRIVILEGES,      (LPSTR)szODBC,    idsSQLTablePrivileges},
  183.  
  184.    //---- Deprecated ----------------------------------------
  185.    {SQL_API_SQLALLOCCONNECT,         (LPSTR)szDepr,    idsSQLAllocConnect},
  186.    {SQL_API_SQLALLOCENV,             (LPSTR)szDepr,    idsSQLAllocEnv},
  187.    {SQL_API_SQLALLOCSTMT,            (LPSTR)szDepr,    idsSQLAllocStmt},
  188.    {SQL_API_SQLBINDPARAM,            (LPSTR)szDepr,    idsSQLBindParam},
  189.    {SQL_API_SQLCOLATTRIBUTES,        (LPSTR)szDepr,    idsSQLColAttributes},
  190.    {SQL_API_SQLERROR,                (LPSTR)szDepr,    idsSQLError},
  191.    {SQL_API_SQLEXTENDEDFETCH,        (LPSTR)szDepr,    idsSQLExtendedFetch},
  192.    {SQL_API_SQLFREECONNECT,          (LPSTR)szDepr,    idsSQLFreeConnect},
  193.    {SQL_API_SQLFREEENV,              (LPSTR)szDepr,    idsSQLFreeEnv},
  194.    {SQL_API_SQLGETCONNECTOPTION,     (LPSTR)szDepr,    idsSQLGetConnectOption},
  195.    {SQL_API_SQLGETSTMTOPTION,        (LPSTR)szDepr,    idsSQLGetStmtOption},
  196.    {SQL_API_SQLPARAMOPTIONS,         (LPSTR)szDepr,    idsSQLParamOptions},
  197.    {SQL_API_SQLSETCONNECTOPTION,     (LPSTR)szDepr,    idsSQLSetConnectOption},
  198.    {SQL_API_SQLSETPARAM,             (LPSTR)szDepr,    idsSQLSetParam},
  199.    {SQL_API_SQLSETSCROLLOPTIONS,     (LPSTR)szDepr,    idsSQLSetScrollOptions},
  200.    {SQL_API_SQLSETSTMTOPTION,        (LPSTR)szDepr,    idsSQLSetStmtOption},
  201.    {SQL_API_SQLTRANSACT,             (LPSTR)szDepr,    idsSQLTransact},
  202.    };
  203.  
  204.  
  205. //
  206. // Generic prototype for bitmap and value lists
  207. // 
  208. // This structure is used for to locate both bitmap and enumeration values.
  209. // Values may appear in the list in any order.  If a value is aliased, the
  210. // second value in an enumeration list will not be found; however, a bitmap
  211. // entry would show both aliases as being set.
  212. //
  213. typedef struct tagINFOSTRUCT {
  214.    UDWORD         fVal;                      // Which constant
  215.    LPSTR          szStr;                     // Print String
  216.    } INFOSTRUCT;
  217. typedef INFOSTRUCT FAR * lpINFOSTRUCT;
  218.  
  219. //
  220. // This macro is used to build rows of the INFOSTRUCT arrays
  221. // guaranteeing that the "print" string is the same as the
  222. // INFO manifest constant.
  223. //
  224. #define INFO_VALUE_ROW(tag) {tag, #tag}
  225.  
  226.  
  227.  
  228. //
  229. // Structure for SQL_ALTER_DOMAIN
  230. //
  231. static INFOSTRUCT GetInfoAlterDomain[] = {
  232. INFO_VALUE_ROW( SQL_AD_ADD_DOMAIN_CONSTRAINT               ),
  233. INFO_VALUE_ROW( SQL_AD_DROP_DOMAIN_CONSTRAINT              ),
  234. INFO_VALUE_ROW( SQL_AD_ADD_DOMAIN_DEFAULT                  ),
  235. INFO_VALUE_ROW( SQL_AD_DROP_DOMAIN_DEFAULT                 ),
  236. INFO_VALUE_ROW( SQL_AD_ADD_CONSTRAINT_INITIALLY_DEFERRED   ),
  237. INFO_VALUE_ROW( SQL_AD_ADD_CONSTRAINT_INITIALLY_IMMEDIATE  ),
  238. INFO_VALUE_ROW( SQL_AD_ADD_CONSTRAINT_DEFERRABLE           ),
  239. INFO_VALUE_ROW( SQL_AD_ADD_CONSTRAINT_NON_DEFERRABLE       ),
  240. };
  241.  
  242. //
  243. // Structure for SQL_ALTER_TABLE
  244. //
  245. static INFOSTRUCT GetInfoAlterTable[] = {
  246. INFO_VALUE_ROW( SQL_AT_ADD_COLUMN_SINGLE                   ),
  247. INFO_VALUE_ROW( SQL_AT_ADD_CONSTRAINT                      ),
  248. INFO_VALUE_ROW( SQL_AT_ADD_COLUMN_DEFAULT                  ),
  249. INFO_VALUE_ROW( SQL_AT_ADD_COLUMN_COLLATION                ),
  250. INFO_VALUE_ROW( SQL_AT_SET_COLUMN_DEFAULT                  ),
  251. INFO_VALUE_ROW( SQL_AT_DROP_COLUMN_DEFAULT                 ),
  252. INFO_VALUE_ROW( SQL_AT_DROP_COLUMN_CASCADE                 ),
  253. INFO_VALUE_ROW( SQL_AT_DROP_COLUMN_RESTRICT                ),
  254. INFO_VALUE_ROW( SQL_AT_ADD_TABLE_CONSTRAINT                ),
  255. INFO_VALUE_ROW( SQL_AT_DROP_TABLE_CONSTRAINT_CASCADE       ),
  256. INFO_VALUE_ROW( SQL_AT_DROP_TABLE_CONSTRAINT_RESTRICT      ),
  257. INFO_VALUE_ROW( SQL_AT_CONSTRAINT_NAME_DEFINITION          ),
  258. INFO_VALUE_ROW( SQL_AT_CONSTRAINT_INITIALLY_DEFERRED       ),
  259. INFO_VALUE_ROW( SQL_AT_CONSTRAINT_INITIALLY_IMMEDIATE      ),
  260. INFO_VALUE_ROW( SQL_AT_CONSTRAINT_DEFERRABLE               ),
  261. INFO_VALUE_ROW( SQL_AT_CONSTRAINT_NON_DEFERRABLE           ),
  262. };
  263.  
  264. //
  265. // Structure for SQL_ANSI_ASYNC_MODE
  266. //
  267. static INFOSTRUCT GetInfoAsyncMode[] = {
  268. INFO_VALUE_ROW( SQL_AM_NONE                                ),
  269. INFO_VALUE_ROW( SQL_AM_CONNECTION                          ),
  270. INFO_VALUE_ROW( SQL_AM_STATEMENT                           ),
  271. };
  272.  
  273.  
  274.  
  275. //
  276. // Structure for SQL_BATCH_ROW_COUNT
  277. //
  278. static INFOSTRUCT GetInfoBatchRowCount[] = {
  279. INFO_VALUE_ROW( SQL_BRC_ROLLED_UP                          ),
  280. INFO_VALUE_ROW( SQL_BRC_PROCEDURES                         ),
  281. INFO_VALUE_ROW( SQL_BRC_EXPLICIT                           ),
  282. };
  283.  
  284. //
  285. // Structure for SQL_BATCH_SUPPORT
  286. //
  287. static INFOSTRUCT GetInfoBatchSupport[] = {
  288. INFO_VALUE_ROW( SQL_BS_SELECT_EXPLICIT                     ),
  289. INFO_VALUE_ROW( SQL_BS_ROW_COUNT_EXPLICIT                  ),
  290. INFO_VALUE_ROW( SQL_BS_SELECT_PROC                         ),
  291. INFO_VALUE_ROW( SQL_BS_ROW_COUNT_PROC                      ),
  292. };
  293.  
  294. //
  295. // Structure for SQL_BOOKMARK_PERSISTENCE
  296. //
  297. static INFOSTRUCT GetInfoBookmarkPersist[] = {
  298. INFO_VALUE_ROW( SQL_BP_CLOSE                               ),
  299. INFO_VALUE_ROW( SQL_BP_DELETE                              ),
  300. INFO_VALUE_ROW( SQL_BP_DROP                                ),
  301. INFO_VALUE_ROW( SQL_BP_TRANSACTION                         ),
  302. INFO_VALUE_ROW( SQL_BP_UPDATE                              ),
  303. INFO_VALUE_ROW( SQL_BP_OTHER_HSTMT                         ),
  304. };
  305.  
  306. //
  307. // Structure for SQL_CATALOG_LOCATION
  308. //
  309. static INFOSTRUCT GetInfoCatLocation[] = {
  310. INFO_VALUE_ROW( SQL_CL_START                               ),
  311. INFO_VALUE_ROW( SQL_CL_END                                 ),
  312. };
  313.  
  314.  
  315.  
  316. //
  317. // Structure for SQL_CATALOG_USAGE
  318. //
  319. static INFOSTRUCT GetInfoCatUsage[] = {
  320. INFO_VALUE_ROW( SQL_CU_DML_STATEMENTS                      ),
  321. INFO_VALUE_ROW( SQL_CU_PROCEDURE_INVOCATION                ),
  322. INFO_VALUE_ROW( SQL_CU_TABLE_DEFINITION                    ),
  323. INFO_VALUE_ROW( SQL_CU_INDEX_DEFINITION                    ),
  324. INFO_VALUE_ROW( SQL_CU_PRIVILEGE_DEFINITION                ),
  325. };
  326.  
  327. //
  328. // Structure for SQL_CONCAT_NULL_BEHAVIOR
  329. //
  330. static INFOSTRUCT GetInfoConcat[] = {
  331. INFO_VALUE_ROW( SQL_CB_NULL                                ),
  332. INFO_VALUE_ROW( SQL_CB_NON_NULL                            ),
  333. };
  334.  
  335. //
  336. // Structure for SQL_CONVERT_xxxx
  337. //
  338. static INFOSTRUCT GetInfoConvertTypes[] = {
  339. INFO_VALUE_ROW( SQL_CVT_BIGINT                             ),
  340. INFO_VALUE_ROW( SQL_CVT_BINARY                             ),
  341. INFO_VALUE_ROW( SQL_CVT_BIT                                ),
  342. INFO_VALUE_ROW( SQL_CVT_CHAR                               ),
  343. INFO_VALUE_ROW( SQL_CVT_DATE                               ),
  344. INFO_VALUE_ROW( SQL_CVT_DECIMAL                            ),
  345. INFO_VALUE_ROW( SQL_CVT_DOUBLE                             ),
  346. INFO_VALUE_ROW( SQL_CVT_FLOAT                              ),
  347. INFO_VALUE_ROW( SQL_CVT_INTEGER                            ),
  348. INFO_VALUE_ROW( SQL_CVT_INTERVAL_YEAR_MONTH                ),
  349. INFO_VALUE_ROW( SQL_CVT_INTERVAL_DAY_TIME                  ),
  350. INFO_VALUE_ROW( SQL_CVT_LONGVARBINARY                      ),
  351. INFO_VALUE_ROW( SQL_CVT_LONGVARCHAR                        ),
  352. INFO_VALUE_ROW( SQL_CVT_NUMERIC                            ),
  353. INFO_VALUE_ROW( SQL_CVT_REAL                               ),
  354. INFO_VALUE_ROW( SQL_CVT_SMALLINT                           ),
  355. INFO_VALUE_ROW( SQL_CVT_TIME                               ),
  356. INFO_VALUE_ROW( SQL_CVT_TIMESTAMP                          ),
  357. INFO_VALUE_ROW( SQL_CVT_TINYINT                            ),
  358. INFO_VALUE_ROW( SQL_CVT_VARBINARY                          ),
  359. INFO_VALUE_ROW( SQL_CVT_VARCHAR                            ),
  360. INFO_VALUE_ROW( SQL_CVT_WCHAR                              ),
  361. INFO_VALUE_ROW( SQL_CVT_WLONGVARCHAR                       ),
  362. INFO_VALUE_ROW( SQL_CVT_WVARCHAR                           ),
  363. };
  364.  
  365. //
  366. // Structure for SQL_CONVERT_FUNCTIONS
  367. //
  368. static INFOSTRUCT GetInfoConvertFunctions[] = {
  369. INFO_VALUE_ROW( SQL_FN_CVT_CAST                            ),
  370. INFO_VALUE_ROW( SQL_FN_CVT_CONVERT                         ),
  371. };
  372.  
  373. //
  374. // Structure for SQL_CORRELATION_NAME
  375. //
  376. static INFOSTRUCT GetInfoCorrelationName[] = {
  377. INFO_VALUE_ROW( SQL_CN_NONE                                ),
  378. INFO_VALUE_ROW( SQL_CN_DIFFERENT                           ),
  379. INFO_VALUE_ROW( SQL_CN_ANY                                 ),
  380. };
  381.  
  382. //
  383. // Structure for SQL_CREATE_ASSERTION
  384. //
  385. static INFOSTRUCT GetInfoCreateAssertion[] = {
  386. INFO_VALUE_ROW( SQL_CA_CREATE_ASSERTION                    ),
  387. INFO_VALUE_ROW( SQL_CA_CONSTRAINT_INITIALLY_DEFERRED       ),
  388. INFO_VALUE_ROW( SQL_CA_CONSTRAINT_INITIALLY_IMMEDIATE      ),
  389. INFO_VALUE_ROW( SQL_CA_CONSTRAINT_DEFERRABLE               ),
  390. INFO_VALUE_ROW( SQL_CA_CONSTRAINT_NON_DEFERRABLE           ),
  391. };
  392.  
  393. //
  394. // Structure for SQL_CREATE_CHARACTER_SET
  395. //
  396. static INFOSTRUCT GetInfoCreateCharset[] = {
  397. INFO_VALUE_ROW( SQL_CCS_CREATE_CHARACTER_SET               ),
  398. INFO_VALUE_ROW( SQL_CCS_COLLATE_CLAUSE                     ),
  399. INFO_VALUE_ROW( SQL_CCS_LIMITED_COLLATION                  ),
  400. };
  401.  
  402. //
  403. // Structure for SQL_CREATE_COLLATION
  404. //
  405. static INFOSTRUCT GetInfoCreateCollation[] = {
  406. INFO_VALUE_ROW( SQL_CCOL_CREATE_COLLATION                  ),
  407. };
  408.  
  409. //
  410. // Structure for SQL_CREATE_DOMAIN
  411. //
  412. static INFOSTRUCT GetInfoCreateDomain[] = {
  413. INFO_VALUE_ROW( SQL_CDO_CREATE_DOMAIN                      ),
  414. INFO_VALUE_ROW( SQL_CDO_CONSTRAINT                         ),
  415. INFO_VALUE_ROW( SQL_CDO_DEFAULT                            ),
  416. INFO_VALUE_ROW( SQL_CDO_COLLATION                          ),
  417. INFO_VALUE_ROW( SQL_CDO_CONSTRAINT_NAME_DEFINITION         ),
  418. INFO_VALUE_ROW( SQL_CDO_CONSTRAINT_INITIALLY_DEFERRED      ),
  419. INFO_VALUE_ROW( SQL_CDO_CONSTRAINT_INITIALLY_IMMEDIATE     ),
  420. INFO_VALUE_ROW( SQL_CDO_CONSTRAINT_DEFERRABLE              ),
  421. INFO_VALUE_ROW( SQL_CDO_CONSTRAINT_NON_DEFERRABLE          ),
  422. };
  423.  
  424. //
  425. // Structure for SQL_CREATE_SCHEMA
  426. //
  427. static INFOSTRUCT GetInfoCreateSchema[] = {
  428. INFO_VALUE_ROW( SQL_CS_CREATE_SCHEMA                       ),
  429. INFO_VALUE_ROW( SQL_CS_AUTHORIZATION                       ),
  430. INFO_VALUE_ROW( SQL_CS_DEFAULT_CHARACTER_SET               ),
  431. };
  432.  
  433. //
  434. // Structure for SQL_CREATE_TABLE
  435. //
  436. static INFOSTRUCT GetInfoCreateTable[] = {
  437. INFO_VALUE_ROW( SQL_CT_COMMIT_PRESERVE                     ),
  438. INFO_VALUE_ROW( SQL_CT_COMMIT_DELETE                       ),
  439. INFO_VALUE_ROW( SQL_CT_GLOBAL_TEMPORARY                    ),
  440. INFO_VALUE_ROW( SQL_CT_LOCAL_TEMPORARY                     ),
  441. INFO_VALUE_ROW( SQL_CT_CONSTRAINT_INITIALLY_DEFERRED       ),
  442. INFO_VALUE_ROW( SQL_CT_CONSTRAINT_INITIALLY_IMMEDIATE      ),
  443. INFO_VALUE_ROW( SQL_CT_CONSTRAINT_DEFERRABLE               ),
  444. INFO_VALUE_ROW( SQL_CT_CONSTRAINT_NON_DEFERRABLE           ),
  445. };
  446.  
  447. //
  448. // Structure for SQL_CREATE_TRANSLATION
  449. //
  450. static INFOSTRUCT GetInfoCreateXlation[] = {
  451. INFO_VALUE_ROW( SQL_CTR_CREATE_TRANSLATION                 ),
  452. };
  453.  
  454. //
  455. // Structure for SQL_CREATE_VIEW
  456. //
  457. static INFOSTRUCT GetInfoCreateView[] = {
  458. INFO_VALUE_ROW( SQL_CV_CREATE_VIEW                         ),
  459. INFO_VALUE_ROW( SQL_CV_CHECK_OPTION                        ),
  460. INFO_VALUE_ROW( SQL_CV_CASCADED                            ),
  461. INFO_VALUE_ROW( SQL_CV_LOCAL                               ),
  462. };
  463.  
  464. //
  465. // Structure for SQL_CURSOR_COMMIT_BEHAVIOR,
  466. //               SQL_CURSOR_ROLLBACK_BEHAVIOR
  467. //
  468. static INFOSTRUCT GetInfoCommit[] = {
  469. INFO_VALUE_ROW( SQL_CB_DELETE                              ),
  470. INFO_VALUE_ROW( SQL_CB_CLOSE                               ),
  471. INFO_VALUE_ROW( SQL_CB_PRESERVE                            ),
  472. };
  473.  
  474. //
  475. // Structure for SQL_CURSOR_SENSITIVITY
  476. //
  477. static INFOSTRUCT GetInfoCursorSensitiv[] = {
  478. INFO_VALUE_ROW( SQL_INSENSITIVE                            ),
  479. INFO_VALUE_ROW( SQL_UNSPECIFIED                            ),
  480. INFO_VALUE_ROW( SQL_SENSITIVE                              ),
  481. };
  482.  
  483. //
  484. // Structure for SQL_DEFAULT_TXN_ISOLATION
  485. //
  486. static INFOSTRUCT GetInfoTXNIsolation[] = {
  487. INFO_VALUE_ROW( SQL_TXN_READ_UNCOMMITTED                   ),
  488. INFO_VALUE_ROW( SQL_TXN_READ_COMMITTED                     ),
  489. INFO_VALUE_ROW( SQL_TXN_REPEATABLE_READ                    ),
  490. INFO_VALUE_ROW( SQL_TXN_SERIALIZABLE                       ),
  491. };
  492.  
  493. //
  494. // Structure for SQL_*_CURSOR_ATTRIBUTES1
  495. //
  496. static INFOSTRUCT GetInfoCurAttrs1[] = {
  497. INFO_VALUE_ROW( SQL_CA1_NEXT                               ),
  498. INFO_VALUE_ROW( SQL_CA1_ABSOLUTE                           ),
  499. INFO_VALUE_ROW( SQL_CA1_RELATIVE                           ),
  500. INFO_VALUE_ROW( SQL_CA1_BOOKMARK                           ),
  501. INFO_VALUE_ROW( SQL_CA1_LOCK_NO_CHANGE                     ),
  502. INFO_VALUE_ROW( SQL_CA1_LOCK_UNLOCK                        ),
  503. INFO_VALUE_ROW( SQL_CA1_POS_POSITION                       ),
  504. INFO_VALUE_ROW( SQL_CA1_POS_UPDATE                         ),
  505. INFO_VALUE_ROW( SQL_CA1_POS_DELETE                         ),
  506. INFO_VALUE_ROW( SQL_CA1_POS_REFRESH                        ),
  507. INFO_VALUE_ROW( SQL_CA1_POSITIONED_UPDATE                  ),
  508. INFO_VALUE_ROW( SQL_CA1_POSITIONED_DELETE                  ),
  509. INFO_VALUE_ROW( SQL_CA1_SELECT_FOR_UPDATE                  ),
  510. INFO_VALUE_ROW( SQL_CA1_BULK_ADD                           ),
  511. INFO_VALUE_ROW( SQL_CA1_BULK_UPDATE_BY_BOOKMARK            ),
  512. INFO_VALUE_ROW( SQL_CA1_BULK_DELETE_BY_BOOKMARK            ),
  513. INFO_VALUE_ROW( SQL_CA1_BULK_FETCH_BY_BOOKMARK             ),
  514. };
  515.  
  516. //
  517. // Structure for SQL_*_CURSOR_ATTRIBUTES2
  518. //
  519. static INFOSTRUCT GetInfoCurAttrs2[] = {
  520. INFO_VALUE_ROW( SQL_CA2_READ_ONLY_CONCURRENCY              ),
  521. INFO_VALUE_ROW( SQL_CA2_LOCK_CONCURRENCY                   ),
  522. INFO_VALUE_ROW( SQL_CA2_OPT_ROWVER_CONCURRENCY             ),
  523. INFO_VALUE_ROW( SQL_CA2_OPT_VALUES_CONCURRENCY             ),
  524. INFO_VALUE_ROW( SQL_CA2_SENSITIVITY_ADDITIONS              ),
  525. INFO_VALUE_ROW( SQL_CA2_SENSITIVITY_DELETIONS              ),
  526. INFO_VALUE_ROW( SQL_CA2_SENSITIVITY_UPDATES                ),
  527. INFO_VALUE_ROW( SQL_CA2_MAX_ROWS_SELECT                    ),
  528. INFO_VALUE_ROW( SQL_CA2_MAX_ROWS_INSERT                    ),
  529. INFO_VALUE_ROW( SQL_CA2_MAX_ROWS_UPDATE                    ),
  530. INFO_VALUE_ROW( SQL_CA2_MAX_ROWS_DELETE                    ),
  531. INFO_VALUE_ROW( SQL_CA2_MAX_ROWS_CATALOG                   ),
  532. INFO_VALUE_ROW( SQL_CA2_MAX_ROWS_AFFECTS_ALL               ),
  533. INFO_VALUE_ROW( SQL_CA2_CRC_EXACT                          ),
  534. INFO_VALUE_ROW( SQL_CA2_CRC_APPROXIMATE                    ),
  535. INFO_VALUE_ROW( SQL_CA2_SIMULATE_NON_UNIQUE                ),
  536. INFO_VALUE_ROW( SQL_CA2_SIMULATE_TRY_UNIQUE                ),
  537. INFO_VALUE_ROW( SQL_CA2_SIMULATE_UNIQUE                    ),
  538. };
  539.  
  540. //
  541. // Structure for SQL_DATETIME_LITERALS
  542. //
  543. static INFOSTRUCT GetInfoSQLDateLit[] = {
  544. INFO_VALUE_ROW( SQL_DL_SQL92_DATE                          ),
  545. INFO_VALUE_ROW( SQL_DL_SQL92_TIME                          ),
  546. INFO_VALUE_ROW( SQL_DL_SQL92_TIMESTAMP                     ),
  547. INFO_VALUE_ROW( SQL_DL_SQL92_INTERVAL_YEAR                 ),
  548. INFO_VALUE_ROW( SQL_DL_SQL92_INTERVAL_MONTH                ),
  549. INFO_VALUE_ROW( SQL_DL_SQL92_INTERVAL_DAY                  ),
  550. INFO_VALUE_ROW( SQL_DL_SQL92_INTERVAL_HOUR                 ),
  551. INFO_VALUE_ROW( SQL_DL_SQL92_INTERVAL_MINUTE               ),
  552. INFO_VALUE_ROW( SQL_DL_SQL92_INTERVAL_SECOND               ),
  553. INFO_VALUE_ROW( SQL_DL_SQL92_INTERVAL_YEAR_TO_MONTH        ),
  554. INFO_VALUE_ROW( SQL_DL_SQL92_INTERVAL_DAY_TO_HOUR          ),
  555. INFO_VALUE_ROW( SQL_DL_SQL92_INTERVAL_DAY_TO_MINUTE        ),
  556. INFO_VALUE_ROW( SQL_DL_SQL92_INTERVAL_DAY_TO_SECOND        ),
  557. INFO_VALUE_ROW( SQL_DL_SQL92_INTERVAL_HOUR_TO_MINUTE       ),
  558. INFO_VALUE_ROW( SQL_DL_SQL92_INTERVAL_HOUR_TO_SECOND       ),
  559. INFO_VALUE_ROW( SQL_DL_SQL92_INTERVAL_MINUTE_TO_SECOND     ),
  560. };
  561.  
  562. //
  563. // Structure for SQL_DROP_ASSERTION
  564. //
  565. static INFOSTRUCT GetInfoDropAssertion[] = {
  566. INFO_VALUE_ROW( SQL_DA_DROP_ASSERTION                      ),
  567. };
  568.  
  569. //
  570. // Structure for SQL_DROP_CHARACTER_SET
  571. //
  572. static INFOSTRUCT GetInfoDropCharset[] = {
  573. INFO_VALUE_ROW( SQL_DCS_DROP_CHARACTER_SET                 ),
  574. };
  575.  
  576. //
  577. // Structure for SQL_DROP_COLLATION
  578. //
  579. static INFOSTRUCT GetInfoDropCollation[] = {
  580. INFO_VALUE_ROW( SQL_DC_DROP_COLLATION                      ),
  581. };
  582.  
  583. //
  584. // Structure for SQL_DROP_DOMAIN
  585. //
  586. static INFOSTRUCT GetInfoDropDomain[] = {
  587. INFO_VALUE_ROW( SQL_DD_DROP_DOMAIN                         ),
  588. INFO_VALUE_ROW( SQL_DD_CASCADE                             ),
  589. INFO_VALUE_ROW( SQL_DD_RESTRICT                            ),
  590. };
  591.  
  592. //
  593. // Structure for SQL_DROP_SCHEMA
  594. //
  595. static INFOSTRUCT GetInfoDropSchema[] = {
  596. INFO_VALUE_ROW( SQL_DS_DROP_SCHEMA                         ),
  597. INFO_VALUE_ROW( SQL_DS_CASCADE                             ),
  598. INFO_VALUE_ROW( SQL_DS_RESTRICT                            ),
  599. };
  600.  
  601. //
  602. // Structure for SQL_DROP_TABLE
  603. //
  604. static INFOSTRUCT GetInfoDropTable[] = {
  605. INFO_VALUE_ROW( SQL_DT_DROP_TABLE                          ),
  606. INFO_VALUE_ROW( SQL_DT_CASCADE                             ),
  607. INFO_VALUE_ROW( SQL_DT_RESTRICT                            ),
  608. };
  609.  
  610. //
  611. // Structure for SQL_DROP_TRANSLATION
  612. //
  613. static INFOSTRUCT GetInfoDropXlation[] = {
  614. INFO_VALUE_ROW( SQL_DTR_DROP_TRANSLATION                   ),
  615. };
  616.  
  617. //
  618. // Structure for SQL_DROP_VIEW
  619. //
  620. static INFOSTRUCT GetInfoDropView[] = {
  621. INFO_VALUE_ROW( SQL_DV_DROP_VIEW                           ),
  622. INFO_VALUE_ROW( SQL_DV_CASCADE                             ),
  623. INFO_VALUE_ROW( SQL_DV_RESTRICT                            ),
  624. };
  625.  
  626. //
  627. // Structure for SQL_FILE_USAGE
  628. //
  629. static INFOSTRUCT GetInfoFileUsage[] = {
  630. INFO_VALUE_ROW( SQL_FILE_NOT_SUPPORTED                     ),
  631. INFO_VALUE_ROW( SQL_FILE_TABLE                             ),
  632. INFO_VALUE_ROW( SQL_FILE_CATALOG                           ),
  633. };
  634.  
  635. //
  636. // Structure for SQL_GETDATA_EXTENSIONS
  637. //
  638. static INFOSTRUCT GetInfoGetdataExt[] = {
  639. INFO_VALUE_ROW( SQL_GD_ANY_COLUMN                          ),
  640. INFO_VALUE_ROW( SQL_GD_ANY_ORDER                           ),
  641. INFO_VALUE_ROW( SQL_GD_BLOCK                               ),
  642. INFO_VALUE_ROW( SQL_GD_BOUND                               ),
  643. };
  644.  
  645. //
  646. // Structure for SQL_GROUP_BY
  647. //
  648. static INFOSTRUCT GetInfoGroupBy[] = {
  649. INFO_VALUE_ROW( SQL_GB_NOT_SUPPORTED                       ),
  650. INFO_VALUE_ROW( SQL_GB_GROUP_BY_EQUALS_SELECT              ),
  651. INFO_VALUE_ROW( SQL_GB_GROUP_BY_CONTAINS_SELECT            ),
  652. INFO_VALUE_ROW( SQL_GB_NO_RELATION                         ),
  653. INFO_VALUE_ROW( SQL_GB_COLLATE                             ),
  654. };
  655.  
  656. //
  657. // Structure for SQL_INDEX_KEYWORDS
  658. //
  659. static INFOSTRUCT GetInfoIndexKeywords[] = {
  660. INFO_VALUE_ROW( SQL_IK_NONE                                ),
  661. INFO_VALUE_ROW( SQL_IK_ASC                                 ),
  662. INFO_VALUE_ROW( SQL_IK_DESC                                ),
  663. INFO_VALUE_ROW( SQL_IK_ALL                                 ),
  664. };
  665.  
  666. //
  667. // Structure for SQL_INFO_SCHEMA_VIEWS
  668. //
  669. static INFOSTRUCT GetInfoInfoSchemaViews[] = {
  670. INFO_VALUE_ROW( SQL_ISV_ASSERTIONS                         ),
  671. INFO_VALUE_ROW( SQL_ISV_CHARACTER_SETS                     ),
  672. INFO_VALUE_ROW( SQL_ISV_CHECK_CONSTRAINTS                  ),
  673. INFO_VALUE_ROW( SQL_ISV_COLLATIONS                         ),
  674. INFO_VALUE_ROW( SQL_ISV_COLUMN_DOMAIN_USAGE                ),
  675. INFO_VALUE_ROW( SQL_ISV_COLUMN_PRIVILEGES                  ),
  676. INFO_VALUE_ROW( SQL_ISV_COLUMNS                            ),
  677. INFO_VALUE_ROW( SQL_ISV_CONSTRAINT_COLUMN_USAGE            ),
  678. INFO_VALUE_ROW( SQL_ISV_CONSTRAINT_TABLE_USAGE             ),
  679. INFO_VALUE_ROW( SQL_ISV_ASSERTIONS                         ),
  680. INFO_VALUE_ROW( SQL_ISV_DOMAIN_CONSTRAINTS                 ),
  681. INFO_VALUE_ROW( SQL_ISV_DOMAINS                            ),
  682. INFO_VALUE_ROW( SQL_ISV_KEY_COLUMN_USAGE                   ),
  683. INFO_VALUE_ROW( SQL_ISV_REFERENTIAL_CONSTRAINTS            ),
  684. INFO_VALUE_ROW( SQL_ISV_SQL_LANGUAGES                      ),
  685. INFO_VALUE_ROW( SQL_ISV_TABLE_CONSTRAINTS                  ),
  686. INFO_VALUE_ROW( SQL_ISV_TABLE_PRIVILEGES                   ),
  687. INFO_VALUE_ROW( SQL_ISV_TABLES                             ),
  688. INFO_VALUE_ROW( SQL_ISV_TRANSLATIONS                       ),
  689. INFO_VALUE_ROW( SQL_ISV_USAGE_PRIVILEGES                   ),
  690. INFO_VALUE_ROW( SQL_ISV_VIEW_COLUMN_USAGE                  ),
  691. INFO_VALUE_ROW( SQL_ISV_VIEW_TABLE_USAGE                   ),
  692. INFO_VALUE_ROW( SQL_ISV_VIEWS                              ),
  693. };
  694.  
  695. //
  696. // Structure for SQL_NON_NULLABLE_COLUMNS
  697. //
  698. static INFOSTRUCT GetInfoNonNullCols[] = {
  699. INFO_VALUE_ROW( SQL_NNC_NULL                               ),
  700. INFO_VALUE_ROW( SQL_NNC_NON_NULL                           ),
  701. };
  702.  
  703. //
  704. // Structure for SQL_NULL_COLLATION
  705. //
  706. static INFOSTRUCT GetInfoNullCollation[] = {
  707. INFO_VALUE_ROW( SQL_NC_END                                 ),
  708. INFO_VALUE_ROW( SQL_NC_HIGH                                ),
  709. INFO_VALUE_ROW( SQL_NC_LOW                                 ),
  710. INFO_VALUE_ROW( SQL_NC_START                               ),
  711. };
  712.  
  713. //
  714. // Structure for SQL_PARAM_ARRAY_ROW_COUNTS
  715. //
  716. static INFOSTRUCT GetInfoParamRowCounts[] = {
  717. INFO_VALUE_ROW( SQL_PARC_BATCH                             ),
  718. INFO_VALUE_ROW( SQL_PARC_NO_BATCH                          ),
  719. };
  720.  
  721. //
  722. // Structure for SQL_PARAM_ARRAY_SELECTS
  723. //
  724. static INFOSTRUCT GetInfoParamSelects[] = {
  725. INFO_VALUE_ROW( SQL_PAS_BATCH                              ),
  726. INFO_VALUE_ROW( SQL_PAS_NO_BATCH                           ),
  727. INFO_VALUE_ROW( SQL_PAS_NO_SELECT                          ),
  728. };
  729.  
  730. //
  731. // Structure for SQL_SCHEMA_USAGE
  732. //
  733. static INFOSTRUCT GetInfoSchemaUsage[] = {
  734. INFO_VALUE_ROW( SQL_SU_DML_STATEMENTS                      ),
  735. INFO_VALUE_ROW( SQL_SU_PROCEDURE_INVOCATION                ),
  736. INFO_VALUE_ROW( SQL_SU_TABLE_DEFINITION                    ),
  737. INFO_VALUE_ROW( SQL_SU_INDEX_DEFINITION                    ),
  738. INFO_VALUE_ROW( SQL_SU_PRIVILEGE_DEFINITION                ),
  739. };
  740.  
  741. //
  742. // Structure for SQL_SCROLL_OPTIONS
  743. //
  744. static INFOSTRUCT GetInfoScrollOptions[] = {
  745. INFO_VALUE_ROW( SQL_SO_FORWARD_ONLY                        ),
  746. INFO_VALUE_ROW( SQL_SO_KEYSET_DRIVEN                       ),
  747. INFO_VALUE_ROW( SQL_SO_DYNAMIC                             ),
  748. INFO_VALUE_ROW( SQL_SO_MIXED                               ),
  749. };
  750.  
  751. //
  752. // Structure for SQL_SQL_CONFORMANCE
  753. //
  754. static INFOSTRUCT GetInfoSQLConform[] = {
  755. INFO_VALUE_ROW( SQL_SC_SQL92_ENTRY                         ),
  756. INFO_VALUE_ROW( SQL_SC_FIPS127_2_TRANSITIONAL              ),
  757. INFO_VALUE_ROW( SQL_SC_SQL92_FULL                          ),
  758. INFO_VALUE_ROW( SQL_SC_SQL92_INTERMEDIATE                  ),
  759. };
  760.  
  761. //
  762. // Structure for SQL_SQL92_DATETIME_FUNCTIONS
  763. //
  764. static INFOSTRUCT GetInfoS92DatetimeFns[] = {
  765. INFO_VALUE_ROW( SQL_SDF_CURRENT_DATE                       ),
  766. INFO_VALUE_ROW( SQL_SDF_CURRENT_TIME                       ),
  767. INFO_VALUE_ROW( SQL_SDF_CURRENT_TIMESTAMP                  ),
  768. };
  769.  
  770. //
  771. // Structure for SQL_SQL92_FOREIGN_KEY_DELETE_RULE
  772. //
  773. static INFOSTRUCT GetInfoS92FKeyDelRule[] = {
  774. INFO_VALUE_ROW( SQL_SFKD_CASCADE                           ),
  775. INFO_VALUE_ROW( SQL_SFKD_NO_ACTION                         ),
  776. INFO_VALUE_ROW( SQL_SFKD_SET_DEFAULT                       ),
  777. INFO_VALUE_ROW( SQL_SFKD_SET_NULL                          ),
  778. };
  779.  
  780. //
  781. // Structure for SQL_SQL92_FOREIGN_KEY_UPDATE_RULE
  782. //
  783. static INFOSTRUCT GetInfoS92FKeyUpdRule[] = {
  784. INFO_VALUE_ROW( SQL_SFKU_CASCADE                           ),
  785. INFO_VALUE_ROW( SQL_SFKU_NO_ACTION                         ),
  786. INFO_VALUE_ROW( SQL_SFKU_SET_DEFAULT                       ),
  787. INFO_VALUE_ROW( SQL_SFKU_SET_NULL                          ),
  788. };
  789.  
  790. //
  791. // Structure for SQL_SQL92_GRANT
  792. //
  793. static INFOSTRUCT GetInfoS92Grant[] = {
  794. INFO_VALUE_ROW( SQL_SG_USAGE_ON_DOMAIN                     ),
  795. INFO_VALUE_ROW( SQL_SG_USAGE_ON_CHARACTER_SET              ),
  796. INFO_VALUE_ROW( SQL_SG_USAGE_ON_COLLATION                  ),
  797. INFO_VALUE_ROW( SQL_SG_USAGE_ON_TRANSLATION                ),
  798. INFO_VALUE_ROW( SQL_SG_WITH_GRANT_OPTION                   ),
  799. };
  800.  
  801. //
  802. // Structure for SQL_NUMERIC_FUNCTIONS
  803. //
  804. static INFOSTRUCT GetInfoNumeric[] = {
  805. INFO_VALUE_ROW( SQL_FN_NUM_ABS                             ),
  806. INFO_VALUE_ROW( SQL_FN_NUM_ACOS                            ),
  807. INFO_VALUE_ROW( SQL_FN_NUM_ASIN                            ),
  808. INFO_VALUE_ROW( SQL_FN_NUM_ATAN                            ),
  809. INFO_VALUE_ROW( SQL_FN_NUM_ATAN2                           ),
  810. INFO_VALUE_ROW( SQL_FN_NUM_CEILING                         ),
  811. INFO_VALUE_ROW( SQL_FN_NUM_COS                             ),
  812. INFO_VALUE_ROW( SQL_FN_NUM_COT                             ),
  813. INFO_VALUE_ROW( SQL_FN_NUM_EXP                             ),
  814. INFO_VALUE_ROW( SQL_FN_NUM_FLOOR                           ),
  815. INFO_VALUE_ROW( SQL_FN_NUM_LOG                             ),
  816. INFO_VALUE_ROW( SQL_FN_NUM_MOD                             ),
  817. INFO_VALUE_ROW( SQL_FN_NUM_RAND                            ),
  818. INFO_VALUE_ROW( SQL_FN_NUM_PI                              ),
  819. INFO_VALUE_ROW( SQL_FN_NUM_SIGN                            ),
  820. INFO_VALUE_ROW( SQL_FN_NUM_SIN                             ),
  821. INFO_VALUE_ROW( SQL_FN_NUM_SQRT                            ),
  822. INFO_VALUE_ROW( SQL_FN_NUM_TAN                             ),
  823. };
  824.  
  825. //
  826. // Structure for SQL_SQL92_NUMERIC_VALUE_FUNCTIONS
  827. //
  828. static INFOSTRUCT GetInfoS92NumValFns[] = {
  829. INFO_VALUE_ROW( SQL_SNVF_BIT_LENGTH                        ),
  830. INFO_VALUE_ROW( SQL_SNVF_CHAR_LENGTH                       ),
  831. INFO_VALUE_ROW( SQL_SNVF_CHARACTER_LENGTH                  ),
  832. INFO_VALUE_ROW( SQL_SNVF_EXTRACT                           ),
  833. INFO_VALUE_ROW( SQL_SNVF_OCTET_LENGTH                      ),
  834. INFO_VALUE_ROW( SQL_SNVF_POSITION                          ),
  835. };
  836.  
  837. //
  838. // Structure for SQL_SQL92_PREDICATES
  839. //
  840. static INFOSTRUCT GetInfoS92Predicates[] = {
  841. INFO_VALUE_ROW( SQL_SP_EXISTS                              ),
  842. INFO_VALUE_ROW( SQL_SP_ISNOTNULL                           ),
  843. INFO_VALUE_ROW( SQL_SP_ISNULL                              ),
  844. INFO_VALUE_ROW( SQL_SP_MATCH_FULL                          ),
  845. INFO_VALUE_ROW( SQL_SP_MATCH_PARTIAL                       ),
  846. INFO_VALUE_ROW( SQL_SP_MATCH_UNIQUE_FULL                   ),
  847. INFO_VALUE_ROW( SQL_SP_MATCH_UNIQUE_PARTIAL                ),
  848. INFO_VALUE_ROW( SQL_SP_OVERLAPS                            ),
  849. INFO_VALUE_ROW( SQL_SP_UNIQUE                              ),
  850. INFO_VALUE_ROW( SQL_SP_LIKE                                ),
  851. INFO_VALUE_ROW( SQL_SP_IN                                  ),
  852. INFO_VALUE_ROW( SQL_SP_BETWEEN                             ),
  853. INFO_VALUE_ROW( SQL_SP_COMPARISON                          ),
  854. INFO_VALUE_ROW( SQL_SP_QUANTIFIED_COMPARISON               ),
  855. };
  856.  
  857. //
  858. // Structure for SQL_SQL92_RELATIONAL_JOIN_OPERATORS
  859. //
  860. static INFOSTRUCT GetInfoS92RelJoinOps[] = {
  861. INFO_VALUE_ROW( SQL_SRJO_CORRESPONDING_CLAUSE              ),
  862. INFO_VALUE_ROW( SQL_SRJO_CROSS_JOIN                        ),
  863. INFO_VALUE_ROW( SQL_SRJO_EXCEPT_JOIN                       ),
  864. INFO_VALUE_ROW( SQL_SRJO_FULL_OUTER_JOIN                   ),
  865. INFO_VALUE_ROW( SQL_SRJO_INNER_JOIN                        ),
  866. INFO_VALUE_ROW( SQL_SRJO_INTERSECT_JOIN                    ),
  867. INFO_VALUE_ROW( SQL_SRJO_LEFT_OUTER_JOIN                   ),
  868. INFO_VALUE_ROW( SQL_SRJO_NATURAL_JOIN                      ),
  869. INFO_VALUE_ROW( SQL_SRJO_RIGHT_OUTER_JOIN                  ),
  870. INFO_VALUE_ROW( SQL_SRJO_UNION_JOIN                        ),
  871. };
  872.  
  873. //
  874. // Structure for SQL_SQL92_REVOKE
  875. //
  876. static INFOSTRUCT GetInfoS92Revoke[] = {
  877. INFO_VALUE_ROW( SQL_SR_USAGE_ON_DOMAIN                     ),
  878. INFO_VALUE_ROW( SQL_SR_USAGE_ON_CHARACTER_SET              ),
  879. INFO_VALUE_ROW( SQL_SR_USAGE_ON_COLLATION                  ),
  880. INFO_VALUE_ROW( SQL_SR_USAGE_ON_TRANSLATION                ),
  881. INFO_VALUE_ROW( SQL_SR_GRANT_OPTION_FOR                    ),
  882. };
  883.  
  884. //
  885. // Structure for SQL_SQL92_ROW_VALUE_CONSTRUCTOR
  886. //
  887. static INFOSTRUCT GetInfoS92RowValConstr[] = {
  888. INFO_VALUE_ROW( SQL_SRVC_VALUE_EXPRESSION                  ),
  889. INFO_VALUE_ROW( SQL_SRVC_NULL                              ),
  890. INFO_VALUE_ROW( SQL_SRVC_DEFAULT                           ),
  891. INFO_VALUE_ROW( SQL_SRVC_ROW_SUBQUERY                      ),
  892. };
  893.  
  894. //
  895. // Structure for SQL_SQL92_STRING_FUNCTIONS
  896. //
  897. static INFOSTRUCT GetInfoS92StringFns[] = {
  898. INFO_VALUE_ROW( SQL_SSF_CONVERT                            ),
  899. INFO_VALUE_ROW( SQL_SSF_LOWER                              ),
  900. INFO_VALUE_ROW( SQL_SSF_UPPER                              ),
  901. INFO_VALUE_ROW( SQL_SSF_SUBSTRING                          ),
  902. INFO_VALUE_ROW( SQL_SSF_TRANSLATE                          ),
  903. INFO_VALUE_ROW( SQL_SSF_TRIM_BOTH                          ),
  904. INFO_VALUE_ROW( SQL_SSF_TRIM_LEADING                       ),
  905. INFO_VALUE_ROW( SQL_SSF_TRIM_TRAILING                      ),
  906. };
  907.  
  908. //
  909. // Structure for SQL_SQL92_VALUE_EXPRESSIONS
  910. //
  911. static INFOSTRUCT GetInfoS92ValueExprs[] = {
  912. INFO_VALUE_ROW( SQL_SVE_CASE                               ),
  913. INFO_VALUE_ROW( SQL_SVE_CAST                               ),
  914. INFO_VALUE_ROW( SQL_SVE_COALESCE                           ),
  915. INFO_VALUE_ROW( SQL_SVE_NULLIF                             ),
  916. };
  917.  
  918. //
  919. // Structure for SQL_SQL92_STANDARD_CLI_CONFORMANCE
  920. //
  921. static INFOSTRUCT GetInfoS92StdCLIConf[] = {
  922. INFO_VALUE_ROW( SQL_SCC_XOPEN_CLI_VERSION1                 ),
  923. INFO_VALUE_ROW( SQL_SCC_ISO92_CLI                          ),
  924. };
  925.  
  926. //
  927. // Structure for SQL_SUBQUERUIES
  928. //
  929. static INFOSTRUCT GetInfoSubqueries[] = {
  930. INFO_VALUE_ROW( SQL_SQ_CORRELATED_SUBQUERIES               ),
  931. INFO_VALUE_ROW( SQL_SQ_COMPARISON                          ),
  932. INFO_VALUE_ROW( SQL_SQ_EXISTS                              ),
  933. INFO_VALUE_ROW( SQL_SQ_IN                                  ),
  934. INFO_VALUE_ROW( SQL_SQ_QUANTIFIED                          ),
  935. };
  936.  
  937. //
  938. // Structure for SQL_STRING_FUNCTIONS
  939. //
  940. static INFOSTRUCT GetInfoStrings[] = {
  941. INFO_VALUE_ROW( SQL_FN_STR_ASCII                                         ),
  942. INFO_VALUE_ROW( SQL_FN_STR_CHAR                            ),
  943. INFO_VALUE_ROW( SQL_FN_STR_CONCAT                          ),
  944. INFO_VALUE_ROW( SQL_FN_STR_INSERT                          ),
  945. INFO_VALUE_ROW( SQL_FN_STR_LCASE                           ),
  946. INFO_VALUE_ROW( SQL_FN_STR_LEFT                            ),
  947. INFO_VALUE_ROW( SQL_FN_STR_LENGTH                          ),
  948. INFO_VALUE_ROW( SQL_FN_STR_LOCATE                          ),
  949. INFO_VALUE_ROW( SQL_FN_STR_LTRIM                           ),
  950. INFO_VALUE_ROW( SQL_FN_STR_REPEAT                          ),
  951. INFO_VALUE_ROW( SQL_FN_STR_REPLACE                         ),
  952. INFO_VALUE_ROW( SQL_FN_STR_RIGHT                           ),
  953. INFO_VALUE_ROW( SQL_FN_STR_RTRIM                           ),
  954. INFO_VALUE_ROW( SQL_FN_STR_SUBSTRING                       ),
  955. INFO_VALUE_ROW( SQL_FN_STR_UCASE                           ),
  956. };
  957.  
  958. //
  959. // Structure for SQL_SYSTEM_FUNCTIONS
  960. //
  961. static INFOSTRUCT GetInfoSystem[] = {
  962. INFO_VALUE_ROW( SQL_FN_SYS_DBNAME                          ),
  963. INFO_VALUE_ROW( SQL_FN_SYS_IFNULL                          ),
  964. INFO_VALUE_ROW( SQL_FN_SYS_USERNAME                        ),
  965. };
  966.  
  967. //
  968. // Structure for SQL_TIMEDATE_FUNCTIONS
  969. //
  970. static INFOSTRUCT GetInfoTimeDate[] = {
  971. INFO_VALUE_ROW( SQL_FN_TD_CURDATE                          ),
  972. INFO_VALUE_ROW( SQL_FN_TD_CURRENT_DATE                     ),
  973. INFO_VALUE_ROW( SQL_FN_TD_CURRENT_TIME                     ),
  974. INFO_VALUE_ROW( SQL_FN_TD_CURRENT_TIMESTAMP                ),
  975. INFO_VALUE_ROW( SQL_FN_TD_CURTIME                          ),
  976. INFO_VALUE_ROW( SQL_FN_TD_DAYOFMONTH                       ),
  977. INFO_VALUE_ROW( SQL_FN_TD_DAYOFWEEK                        ),
  978. INFO_VALUE_ROW( SQL_FN_TD_DAYOFYEAR                        ),
  979. INFO_VALUE_ROW( SQL_FN_TD_EXTRACT                          ),
  980. INFO_VALUE_ROW( SQL_FN_TD_HOUR                             ),
  981. INFO_VALUE_ROW( SQL_FN_TD_MINUTE                           ),
  982. INFO_VALUE_ROW( SQL_FN_TD_MONTH                            ),
  983. INFO_VALUE_ROW( SQL_FN_TD_NOW                              ),
  984. INFO_VALUE_ROW( SQL_FN_TD_QUARTER                          ),
  985. INFO_VALUE_ROW( SQL_FN_TD_SECOND                           ),
  986. INFO_VALUE_ROW( SQL_FN_TD_WEEK                             ),
  987. INFO_VALUE_ROW( SQL_FN_TD_YEAR                             ),
  988. };
  989.  
  990. //
  991. // Structure for SQL_TIMEDATE_ADD_INTERVALS,
  992. //               SQL_TIMEDATE_DIFF_INTERVALS,
  993. //
  994. static INFOSTRUCT GetInfoTimeDateIvls[] = {
  995. INFO_VALUE_ROW( SQL_FN_TSI_FRAC_SECOND                     ),
  996. INFO_VALUE_ROW( SQL_FN_TSI_SECOND                          ),
  997. INFO_VALUE_ROW( SQL_FN_TSI_MINUTE                          ),
  998. INFO_VALUE_ROW( SQL_FN_TSI_HOUR                            ),
  999. INFO_VALUE_ROW( SQL_FN_TSI_DAY                             ),
  1000. INFO_VALUE_ROW( SQL_FN_TSI_WEEK                            ),
  1001. INFO_VALUE_ROW( SQL_FN_TSI_MONTH                           ),
  1002. INFO_VALUE_ROW( SQL_FN_TSI_QUARTER                         ),
  1003. INFO_VALUE_ROW( SQL_FN_TSI_YEAR                            ),
  1004. };
  1005.  
  1006. //
  1007. // Structure for SQL_ODBC_API_CONFORMANCE
  1008. //
  1009. static INFOSTRUCT GetInfoAPIConform[] = {
  1010. INFO_VALUE_ROW( SQL_OIC_CORE                               ),
  1011. INFO_VALUE_ROW( SQL_OIC_LEVEL1                             ),
  1012. INFO_VALUE_ROW( SQL_OIC_LEVEL2                             ),
  1013. };
  1014.  
  1015. //
  1016. // Structure for SQL_ODBC_SQL_CONFORMANCE
  1017. //
  1018. static INFOSTRUCT GetInfoODBCSQL[] = {
  1019. INFO_VALUE_ROW( SQL_OSC_MINIMUM                            ),
  1020. INFO_VALUE_ROW( SQL_OSC_CORE                               ),
  1021. INFO_VALUE_ROW( SQL_OSC_EXTENDED                           ),
  1022. };
  1023.  
  1024. //
  1025. // Structure for SQL_IDENTIFIER_CASE
  1026. //
  1027. static INFOSTRUCT GetInfoIDCase[] = {
  1028. INFO_VALUE_ROW( SQL_IC_UPPER                               ),
  1029. INFO_VALUE_ROW( SQL_IC_LOWER                               ),
  1030. INFO_VALUE_ROW( SQL_IC_SENSITIVE                           ),
  1031. INFO_VALUE_ROW( SQL_IC_MIXED                               ),
  1032. };
  1033.  
  1034. //
  1035. // Structure for SQL_TXN_CAPABLE
  1036. //
  1037. static INFOSTRUCT GetInfoTxnCapable[] = {
  1038. INFO_VALUE_ROW( SQL_TC_NONE                                ),
  1039. INFO_VALUE_ROW( SQL_TC_DML                                 ),
  1040. INFO_VALUE_ROW( SQL_TC_DDL_COMMIT                          ),
  1041. INFO_VALUE_ROW( SQL_TC_DDL_IGNORE                          ),
  1042. INFO_VALUE_ROW( SQL_TC_ALL                                 ),
  1043. };
  1044.  
  1045. //
  1046. // Structure for SQL_TXN_ISOLATION_OPTIONS
  1047. //
  1048. static INFOSTRUCT GetInfoTxnIsoOptions[] = {
  1049. INFO_VALUE_ROW( SQL_TXN_READ_UNCOMMITTED                   ),
  1050. INFO_VALUE_ROW( SQL_TXN_READ_COMMITTED                     ),
  1051. INFO_VALUE_ROW( SQL_TXN_REPEATABLE_READ                    ),
  1052. INFO_VALUE_ROW( SQL_TXN_SERIALIZABLE                       ),
  1053. };
  1054.  
  1055. //
  1056. // Structure for SQL_UNION
  1057. //
  1058. static INFOSTRUCT GetInfoUnion[] = {
  1059. INFO_VALUE_ROW( SQL_U_UNION                                ),
  1060. INFO_VALUE_ROW( SQL_U_UNION_ALL                            ),
  1061. };
  1062.  
  1063.  
  1064. //
  1065. // The following structure is used to retrieve information about the driver.  There
  1066. //    are 5 types of GetInfo structures:
  1067. //          INT16       16-bit value
  1068. //          INT32       32-bit value
  1069. //          STRVAL      String value
  1070. //          DEXVAL      Indexed item (eg: 0-x)
  1071. //          BITVAL      Bit-mask value
  1072. //
  1073. char           szGetInfo[MAXBUFF];
  1074. UWORD          cb16;
  1075. UDWORD         cb32;
  1076. #define        INT16             1
  1077. #define        INT32             2
  1078. #define        STRVAL            3
  1079. #define        DEXVAL            4
  1080. #define        BITVAL            5
  1081.  
  1082. #define INFOROW(name, string, type, addr, varsize, ptr, size) {name, string, type, addr, varsize, ptr, size}
  1083.  
  1084. #define INT16_ITEM(name)        INFOROW(name, #name, INT16,  &cb16,      sizeof(cb16), NULL, 0)
  1085. #define INT32_ITEM(name)        INFOROW(name, #name, INT32,  &cb32,      sizeof(cb32), NULL, 0)
  1086. #define STRNG_ITEM(name)        INFOROW(name, #name, STRVAL, szGetInfo,  sizeof(szGetInfo), NULL, 0)
  1087. #define BIT32_ITEM(name, list)  INFOROW(name, #name, BITVAL, &cb32,      sizeof(cb32), list, NumItems(list))
  1088. #define DEX32_ITEM(name, list)  INFOROW(name, #name, DEXVAL, &cb32,      sizeof(cb32), list, NumItems(list))
  1089.  
  1090.  
  1091. struct {
  1092.  
  1093.    UWORD          fInfoType;                 // What we're looking for
  1094.    LPSTR          szInfoName;                // Print name of the GetInfo item
  1095.    int            fOutType;                  // string, 16-bit or 32-bit
  1096.    PTR            rgbInfoValue;              // Output buffer
  1097.    SWORD          cbInfoMax;                 // Size of output buffer
  1098.    void FAR *     ptr;                       // Generic constant structure
  1099.    int            cbNum;                     // Count of items in ptr
  1100.  
  1101. } GetInfo[] = {
  1102.  
  1103.  
  1104.    // Out Type  fInfoType                          List of Values
  1105.    // --------  -------------------------          ---------------------------
  1106.    STRNG_ITEM(  SQL_ACCESSIBLE_PROCEDURES                                      ),
  1107.    STRNG_ITEM(  SQL_ACCESSIBLE_TABLES                                          ),
  1108.    INT16_ITEM(  SQL_ACTIVE_ENVIRONMENTS                                        ),
  1109.    BIT32_ITEM(  SQL_ALTER_DOMAIN,                  GetInfoAlterDomain          ),
  1110.    BIT32_ITEM(  SQL_ALTER_TABLE,                   GetInfoAlterTable           ),
  1111.    DEX32_ITEM(  SQL_ASYNC_MODE,                    GetInfoAsyncMode            ),
  1112.  
  1113.    BIT32_ITEM(  SQL_BATCH_ROW_COUNT,               GetInfoBatchRowCount        ),
  1114.    BIT32_ITEM(  SQL_BATCH_SUPPORT,                 GetInfoBatchSupport         ),
  1115.    BIT32_ITEM(  SQL_BOOKMARK_PERSISTENCE,          GetInfoBookmarkPersist      ),
  1116.  
  1117.    DEX32_ITEM(  SQL_CATALOG_LOCATION,              GetInfoCatLocation          ),
  1118.    STRNG_ITEM(  SQL_CATALOG_NAME                                               ),
  1119.    STRNG_ITEM(  SQL_CATALOG_NAME_SEPARATOR                                     ),
  1120.    STRNG_ITEM(  SQL_CATALOG_TERM                                               ),
  1121.    BIT32_ITEM(  SQL_CATALOG_USAGE,                 GetInfoCatUsage             ),
  1122.    STRNG_ITEM(  SQL_COLLATION_SEQ                                              ),
  1123.    STRNG_ITEM(  SQL_COLUMN_ALIAS                                               ),
  1124.    DEX32_ITEM(  SQL_CONCAT_NULL_BEHAVIOR,          GetInfoConcat               ),
  1125.    BIT32_ITEM(  SQL_CONVERT_BIGINT,                GetInfoConvertTypes         ),
  1126.    BIT32_ITEM(  SQL_CONVERT_BINARY,                GetInfoConvertTypes         ),
  1127.    BIT32_ITEM(  SQL_CONVERT_BIT,                   GetInfoConvertTypes         ),
  1128.    BIT32_ITEM(  SQL_CONVERT_CHAR,                  GetInfoConvertTypes         ),
  1129.    BIT32_ITEM(  SQL_CONVERT_DATE,                  GetInfoConvertTypes         ),
  1130.    BIT32_ITEM(  SQL_CONVERT_DECIMAL,               GetInfoConvertTypes         ),
  1131.    BIT32_ITEM(  SQL_CONVERT_DOUBLE,                GetInfoConvertTypes         ),
  1132.    BIT32_ITEM(  SQL_CONVERT_FLOAT,                 GetInfoConvertTypes         ),
  1133.    BIT32_ITEM(  SQL_CONVERT_FUNCTIONS,             GetInfoConvertTypes         ),
  1134.    BIT32_ITEM(  SQL_CONVERT_INTEGER,               GetInfoConvertTypes         ),
  1135.    BIT32_ITEM(  SQL_CONVERT_LONGVARBINARY,         GetInfoConvertTypes         ),
  1136.    BIT32_ITEM(  SQL_CONVERT_LONGVARCHAR,           GetInfoConvertTypes         ),
  1137.    BIT32_ITEM(  SQL_CONVERT_NUMERIC,               GetInfoConvertTypes         ),
  1138.    BIT32_ITEM(  SQL_CONVERT_REAL,                  GetInfoConvertTypes         ),
  1139.    BIT32_ITEM(  SQL_CONVERT_SMALLINT,              GetInfoConvertTypes         ),
  1140.    BIT32_ITEM(  SQL_CONVERT_TIME,                  GetInfoConvertTypes         ),
  1141.    BIT32_ITEM(  SQL_CONVERT_TIMESTAMP,             GetInfoConvertTypes         ),
  1142.    BIT32_ITEM(  SQL_CONVERT_TINYINT,               GetInfoConvertTypes         ),
  1143.    BIT32_ITEM(  SQL_CONVERT_VARBINARY,             GetInfoConvertTypes         ),
  1144.    BIT32_ITEM(  SQL_CONVERT_VARCHAR,               GetInfoConvertTypes         ),
  1145.    BIT32_ITEM(  SQL_CONVERT_FUNCTIONS,             GetInfoConvertFunctions     ),
  1146.    BIT32_ITEM(  SQL_CORRELATION_NAME,              GetInfoCorrelationName      ),
  1147.    BIT32_ITEM(  SQL_CREATE_ASSERTION,              GetInfoCreateAssertion      ),
  1148.    BIT32_ITEM(  SQL_CREATE_CHARACTER_SET,          GetInfoCreateCharset        ),
  1149.    BIT32_ITEM(  SQL_CREATE_COLLATION,              GetInfoCreateCollation      ),
  1150.    BIT32_ITEM(  SQL_CREATE_DOMAIN,                 GetInfoCreateDomain         ),
  1151.    BIT32_ITEM(  SQL_CREATE_SCHEMA,                 GetInfoCreateSchema         ),
  1152.    BIT32_ITEM(  SQL_CREATE_TABLE,                  GetInfoCreateTable          ),
  1153.    BIT32_ITEM(  SQL_CREATE_TRANSLATION,            GetInfoCreateXlation        ),
  1154.    BIT32_ITEM(  SQL_CREATE_VIEW,                   GetInfoCreateView           ),
  1155.    DEX32_ITEM(  SQL_CURSOR_COMMIT_BEHAVIOR,        GetInfoCommit               ),
  1156.    DEX32_ITEM(  SQL_CURSOR_ROLLBACK_BEHAVIOR,      GetInfoCommit               ),
  1157.    DEX32_ITEM(  SQL_CURSOR_SENSITIVITY,            GetInfoCursorSensitiv       ),
  1158.  
  1159.    STRNG_ITEM(  SQL_DATA_SOURCE_NAME                                           ),
  1160.    STRNG_ITEM(  SQL_DATA_SOURCE_READ_ONLY                                      ),
  1161.    STRNG_ITEM(  SQL_DATABASE_NAME                                              ),
  1162.    BIT32_ITEM(  SQL_DATETIME_LITERALS,             GetInfoSQLDateLit           ),
  1163.    STRNG_ITEM(  SQL_DBMS_NAME                                                  ),
  1164.    STRNG_ITEM(  SQL_DBMS_VER                                                   ),
  1165.    BIT32_ITEM(  SQL_DEFAULT_TXN_ISOLATION,         GetInfoTXNIsolation         ),
  1166.    STRNG_ITEM(  SQL_DESCRIBE_PARAMETER                                         ),
  1167.    INT32_ITEM(  SQL_DRIVER_HDBC                                                ),
  1168.    INT32_ITEM(  SQL_DRIVER_HENV                                                ),
  1169.    INT32_ITEM(  SQL_DRIVER_HLIB                                                ),
  1170.    INT32_ITEM(  SQL_DRIVER_HSTMT                                               ),
  1171.    STRNG_ITEM(  SQL_DRIVER_NAME                                                ),
  1172.    STRNG_ITEM(  SQL_DRIVER_ODBC_VER                                            ),
  1173.    STRNG_ITEM(  SQL_DRIVER_VER                                                 ),
  1174.    BIT32_ITEM(  SQL_DROP_ASSERTION,                GetInfoDropAssertion        ),
  1175.    BIT32_ITEM(  SQL_DROP_CHARACTER_SET,            GetInfoDropCharset          ),
  1176.    BIT32_ITEM(  SQL_DROP_COLLATION,                GetInfoDropCollation        ),
  1177.    BIT32_ITEM(  SQL_DROP_DOMAIN,                   GetInfoDropDomain           ),
  1178.    BIT32_ITEM(  SQL_DROP_SCHEMA,                   GetInfoDropSchema           ),
  1179.    BIT32_ITEM(  SQL_DROP_TABLE,                    GetInfoDropTable            ),
  1180.    BIT32_ITEM(  SQL_DROP_TRANSLATION,              GetInfoDropXlation          ),
  1181.    BIT32_ITEM(  SQL_DROP_VIEW,                     GetInfoDropView             ),
  1182.    BIT32_ITEM(  SQL_DYNAMIC_CURSOR_ATTRIBUTES1,    GetInfoCurAttrs1            ),
  1183.    BIT32_ITEM(  SQL_DYNAMIC_CURSOR_ATTRIBUTES2,    GetInfoCurAttrs2            ),
  1184.  
  1185.    STRNG_ITEM(  SQL_EXPRESSIONS_IN_ORDERBY                                     ),
  1186.  
  1187.    DEX32_ITEM(  SQL_FILE_USAGE,                    GetInfoFileUsage            ),
  1188.    BIT32_ITEM(  SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES1, GetInfoCurAttrs1          ),
  1189.    BIT32_ITEM(  SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES2, GetInfoCurAttrs2          ),
  1190.  
  1191.    BIT32_ITEM(  SQL_GETDATA_EXTENSIONS,            GetInfoGetdataExt           ),
  1192.    BIT32_ITEM(  SQL_GROUP_BY,                      GetInfoGroupBy              ),
  1193.  
  1194.    DEX32_ITEM(  SQL_IDENTIFIER_CASE,               GetInfoIDCase               ),
  1195.    INT16_ITEM(  SQL_IDENTIFIER_QUOTE_CHAR                                      ),
  1196.    BIT32_ITEM(  SQL_INDEX_KEYWORDS,                GetInfoIndexKeywords        ),
  1197.    BIT32_ITEM(  SQL_INFO_SCHEMA_VIEWS,             GetInfoInfoSchemaViews      ),
  1198.    STRNG_ITEM(  SQL_INTEGRITY                                                  ),
  1199.  
  1200.    BIT32_ITEM(  SQL_KEYSET_CURSOR_ATTRIBUTES1,     GetInfoCurAttrs1            ),
  1201.    BIT32_ITEM(  SQL_KEYSET_CURSOR_ATTRIBUTES2,     GetInfoCurAttrs2            ),
  1202.    STRNG_ITEM(  SQL_KEYWORDS                                                   ),
  1203.  
  1204.    STRNG_ITEM(  SQL_LIKE_ESCAPE_CLAUSE                                         ),
  1205.  
  1206.    INT32_ITEM(  SQL_MAX_ASYNC_CONCURRENT_STATEMENTS                            ),
  1207.    INT32_ITEM(  SQL_MAX_BINARY_LITERAL_LEN                                     ),
  1208.    INT16_ITEM(  SQL_MAX_CATALOG_NAME_LEN                                       ),
  1209.    INT32_ITEM(  SQL_MAX_CHAR_LITERAL_LEN                                       ),
  1210.    INT16_ITEM(  SQL_MAX_COLUMN_NAME_LEN                                        ),
  1211.    INT16_ITEM(  SQL_MAX_COLUMNS_IN_GROUP_BY                                    ),
  1212.    INT16_ITEM(  SQL_MAX_COLUMNS_IN_INDEX                                       ),
  1213.    INT16_ITEM(  SQL_MAX_COLUMNS_IN_ORDER_BY                                    ),
  1214.    INT16_ITEM(  SQL_MAX_COLUMNS_IN_SELECT                                      ),
  1215.    INT16_ITEM(  SQL_MAX_COLUMNS_IN_TABLE                                       ),
  1216.    INT16_ITEM(  SQL_MAX_CONCURRENT_ACTIVITIES                                  ),
  1217.    INT16_ITEM(  SQL_MAX_CURSOR_NAME_LEN                                        ),
  1218.    INT16_ITEM(  SQL_MAX_DRIVER_CONNECTIONS                                     ),
  1219.    INT16_ITEM(  SQL_MAX_IDENTIFIER_LEN                                         ),
  1220.    INT32_ITEM(  SQL_MAX_INDEX_SIZE                                             ),
  1221.    INT16_ITEM(  SQL_MAX_PROCEDURE_NAME_LEN                                     ),
  1222.    INT32_ITEM(  SQL_MAX_ROW_SIZE                                               ),
  1223.    STRNG_ITEM(  SQL_MAX_ROW_SIZE_INCLUDES_LONG                                 ),
  1224.    INT16_ITEM(  SQL_MAX_SCHEMA_NAME_LEN                                        ),
  1225.    INT16_ITEM(  SQL_MAX_STATEMENT_LEN                                          ),
  1226.    INT16_ITEM(  SQL_MAX_TABLE_NAME_LEN                                         ),
  1227.    INT16_ITEM(  SQL_MAX_TABLES_IN_SELECT                                       ),
  1228.    INT16_ITEM(  SQL_MAX_USER_NAME_LEN                                          ),
  1229.    STRNG_ITEM(  SQL_MULTIPLE_ACTIVE_TXN                                        ),
  1230.    STRNG_ITEM(  SQL_MULT_RESULT_SETS                                           ),
  1231.  
  1232.    STRNG_ITEM(  SQL_NEED_LONG_DATA_LEN                                         ),
  1233.    DEX32_ITEM(  SQL_NON_NULLABLE_COLUMNS,          GetInfoNonNullCols          ),
  1234.    DEX32_ITEM(  SQL_NULL_COLLATION,                GetInfoNullCollation        ),
  1235.    BIT32_ITEM(  SQL_NUMERIC_FUNCTIONS,             GetInfoNumeric              ),
  1236.  
  1237.    DEX32_ITEM(  SQL_ODBC_INTERFACE_CONFORMANCE,    GetInfoAPIConform           ),
  1238.    DEX32_ITEM(  SQL_ODBC_SQL_CONFORMANCE,          GetInfoODBCSQL              ),
  1239.    STRNG_ITEM(  SQL_ODBC_VER                                                   ),
  1240.    STRNG_ITEM(  SQL_ORDER_BY_COLUMNS_IN_SELECT                                 ),
  1241.    STRNG_ITEM(  SQL_OUTER_JOINS                                                ),
  1242.  
  1243.    DEX32_ITEM(  SQL_PARAM_ARRAY_ROW_COUNTS,        GetInfoParamRowCounts       ),
  1244.    DEX32_ITEM(  SQL_PARAM_ARRAY_SELECTS,           GetInfoParamSelects         ),
  1245.    STRNG_ITEM(  SQL_PROCEDURES                                                 ),
  1246.    STRNG_ITEM(  SQL_PROCEDURE_TERM                                             ),
  1247.  
  1248.    DEX32_ITEM(  SQL_QUOTED_IDENTIFIER_CASE,        GetInfoIDCase               ),
  1249.  
  1250.    STRNG_ITEM(  SQL_ROW_UPDATES                                                ),
  1251.  
  1252.    STRNG_ITEM(  SQL_SCHEMA_TERM                                                ),
  1253.    BIT32_ITEM(  SQL_SCHEMA_USAGE,                  GetInfoSchemaUsage          ),
  1254.    BIT32_ITEM(  SQL_SCROLL_OPTIONS,                GetInfoScrollOptions        ),
  1255.    STRNG_ITEM(  SQL_SEARCH_PATTERN_ESCAPE                                      ),
  1256.    STRNG_ITEM(  SQL_SERVER_NAME                                                ),
  1257.    STRNG_ITEM(  SQL_SPECIAL_CHARACTERS                                         ),
  1258.    BIT32_ITEM(  SQL_SQL_CONFORMANCE,               GetInfoSQLConform           ),
  1259.    BIT32_ITEM(  SQL_SQL92_DATETIME_FUNCTIONS,      GetInfoS92DatetimeFns       ),
  1260.    BIT32_ITEM(  SQL_SQL92_FOREIGN_KEY_DELETE_RULE, GetInfoS92FKeyDelRule       ),
  1261.    BIT32_ITEM(  SQL_SQL92_FOREIGN_KEY_UPDATE_RULE, GetInfoS92FKeyUpdRule       ),
  1262.    BIT32_ITEM(  SQL_SQL92_GRANT,                   GetInfoS92Grant             ),
  1263.    BIT32_ITEM(  SQL_SQL92_NUMERIC_VALUE_FUNCTIONS, GetInfoS92NumValFns         ),
  1264.    BIT32_ITEM(  SQL_SQL92_PREDICATES,              GetInfoS92Predicates        ),
  1265.    BIT32_ITEM(  SQL_SQL92_RELATIONAL_JOIN_OPERATORS, GetInfoS92RelJoinOps      ),
  1266.    BIT32_ITEM(  SQL_SQL92_REVOKE,                  GetInfoS92Revoke            ),
  1267.    BIT32_ITEM(  SQL_SQL92_ROW_VALUE_CONSTRUCTOR,   GetInfoS92RowValConstr      ),
  1268.    BIT32_ITEM(  SQL_SQL92_STRING_FUNCTIONS,        GetInfoS92StringFns         ),
  1269.    BIT32_ITEM(  SQL_SQL92_VALUE_EXPRESSIONS,       GetInfoS92ValueExprs        ),
  1270.    BIT32_ITEM(  SQL_STANDARD_CLI_CONFORMANCE,      GetInfoS92StdCLIConf        ),
  1271.    BIT32_ITEM(  SQL_STATIC_CURSOR_ATTRIBUTES1,     GetInfoCurAttrs1            ),
  1272.    BIT32_ITEM(  SQL_STATIC_CURSOR_ATTRIBUTES2,     GetInfoCurAttrs2            ),
  1273.    BIT32_ITEM(  SQL_STRING_FUNCTIONS,              GetInfoStrings              ),
  1274.    BIT32_ITEM(  SQL_SUBQUERIES,                    GetInfoSubqueries           ),
  1275.    BIT32_ITEM(  SQL_SYSTEM_FUNCTIONS,              GetInfoSystem               ),
  1276.  
  1277.    STRNG_ITEM(  SQL_TABLE_TERM                                                 ),
  1278.    BIT32_ITEM(  SQL_TIMEDATE_ADD_INTERVALS,        GetInfoTimeDateIvls         ),
  1279.    BIT32_ITEM(  SQL_TIMEDATE_DIFF_INTERVALS,       GetInfoTimeDateIvls         ),
  1280.    BIT32_ITEM(  SQL_TIMEDATE_FUNCTIONS,            GetInfoTimeDate             ),
  1281.    DEX32_ITEM(  SQL_TXN_CAPABLE,                   GetInfoTxnCapable           ),
  1282.    BIT32_ITEM(  SQL_TXN_ISOLATION_OPTION,          GetInfoTxnIsoOptions        ),
  1283.  
  1284.    BIT32_ITEM(  SQL_UNION,                         GetInfoUnion                ),
  1285.    STRNG_ITEM(  SQL_USER_NAME                                                  ),
  1286.  
  1287.    STRNG_ITEM(  SQL_XOPEN_CLI_YEAR                                             ),
  1288. };
  1289.    
  1290.    
  1291. //*---------------------------------------------------------------------------------
  1292. //| GetBitVal:
  1293. //|   Call this function to retrieve the string values for all items which meet
  1294. //|   the bitwise and condition.
  1295. //| Parms:
  1296. //|   in       rs                   Pointer to the results set
  1297. //|   in       szInfoName           The info value being retrieved
  1298. //|   in       is                   Structure with resource ids and values
  1299. //|   in       maxdex               Number of items in struct
  1300. //|   in       mask                 The value to compare against
  1301. //|   in       szOut                Output buffer for retrieval
  1302. //|   in       cbOut                Size of output buffer
  1303. //| Returns:              
  1304. //|   Nothing
  1305. //*---------------------------------------------------------------------------------
  1306. BOOL GetBitVal
  1307.    (RESULTSSET FAR * rs,
  1308.     LPSTR szInfoName,
  1309.     lpINFOSTRUCT is,
  1310.     int maxdex,
  1311.     UDWORD mask,
  1312.     LPSTR szVal,
  1313.     int cbVal)
  1314. {
  1315.    int            tdex;
  1316.    ROWDATA FAR *  rd;
  1317.    COLORREF       rgbDft=GetDefaultRGB();
  1318.  
  1319.    if (mask != 0) {
  1320.       for(tdex=0;  tdex<maxdex;  tdex++) 
  1321.          if(is[tdex].fVal & mask) {
  1322.             rd = AllocateRowData(rs, rgbDft, RDATA_DEFAULT_BKGRND);
  1323.             SetColumnData(0, rd, szInfoName);
  1324.             SetColumnData(1, rd, is[tdex].szStr);
  1325.             if(AddRowData(rs, rd) == LB_ERRSPACE)
  1326.                return FALSE;
  1327.          }
  1328.    }
  1329.    else {
  1330.       rd = AllocateRowData(rs, rgbDft, RDATA_DEFAULT_BKGRND);
  1331.       SetColumnData(0, rd, szInfoName);
  1332.       SetColumnData(1, rd, "0");
  1333.       if(AddRowData(rs, rd) == LB_ERRSPACE)
  1334.          return FALSE;
  1335.    }
  1336.  
  1337.    return TRUE;
  1338. }
  1339.  
  1340.    
  1341. //*---------------------------------------------------------------------------------
  1342. //| GetIndexVal:
  1343. //|   Call this function to retrieve the string value for a constant.
  1344. //| Parms:
  1345. //|   in       rs                   Pointer to the results set
  1346. //|   in       szInfoName           The info value being retrieved
  1347. //|   in       is                   Structure with resource ids and values
  1348. //|   in       maxdex               Number of items in struct
  1349. //|   in       dex                  String index value 
  1350. //|   in       szOut                Output buffer for retrieval
  1351. //|   in       cbOut                Size of output buffer
  1352. //| Returns:              
  1353. //|   FALSE if there is an error
  1354. //| No error is posted if matching value is not found.
  1355. //*---------------------------------------------------------------------------------
  1356. BOOL GetIndexVal
  1357.    (RESULTSSET FAR * rs,
  1358.     LPSTR szInfoName, 
  1359.     lpINFOSTRUCT is,
  1360.     int maxdex,
  1361.     int dex,
  1362.     LPSTR szOut,
  1363.     int cbOut)
  1364. {
  1365.    int tdex;
  1366.    ROWDATA FAR *  rd;
  1367.    COLORREF       rgbDft=GetDefaultRGB();
  1368.  
  1369.    for (tdex = 0; tdex<maxdex; tdex++)
  1370.       if (is[tdex].fVal == (UDWORD) dex) {
  1371.          rd = AllocateRowData(rs, rgbDft, RDATA_DEFAULT_BKGRND);
  1372.          SetColumnData(0, rd, szInfoName);
  1373.          SetColumnData(1, rd, is[tdex].szStr);
  1374.          if(AddRowData(rs, rd) == LB_ERRSPACE)
  1375.             return FALSE;
  1376.       }
  1377.  
  1378.    return TRUE;
  1379. }
  1380.  
  1381.    
  1382. //*---------------------------------------------------------------------------------
  1383. //| DisplayGetInfo:
  1384. //|   This function goes through all of the SQLGetInfo constants defined in the
  1385. //|   ODBC reference guide and displays them in a results set.
  1386. //| Parms:
  1387. //|   in       ci                   CHILDINFO information
  1388. //| Returns:              
  1389. //|   TRUE if successful,
  1390. //|   FALSE on error
  1391. //*---------------------------------------------------------------------------------
  1392. BOOL DisplayGetInfo(CHILDINFO FAR * ci)
  1393. {
  1394.    char                 szTitle[MAXBUFF];
  1395.    char                 szVal[MAXBUFF];
  1396.    int                  dex;
  1397.    lpINFOSTRUCT         lpINFS;
  1398.    RESULTSSET FAR *     rs;
  1399.    ROWDATA FAR *        rd;
  1400.    RETCODE              retcode;
  1401.    COLORREF             rgbDft=GetDefaultRGB();
  1402.  
  1403.    //
  1404.    // Create a hard coded results set with 2 columns
  1405.    //
  1406.    lstrcpy((LPSTR)szTitle, (LPSTR)ci->szClientTitle);
  1407.    lstrcat((LPSTR)szTitle, (LPSTR)szDash);
  1408.    lstrcat((LPSTR)szTitle, (LPSTR)szGetInfoTitle);
  1409.    rs = GetConnectWindowResultsNode(ci);
  1410.    if(!CreateResultsSet(rs, ci->hwndClient, ci->hInst, 2, (LPSTR)szTitle))
  1411.       return FALSE;  
  1412.  
  1413.    //
  1414.    // Set the meta data
  1415.    //
  1416.    SetMetaDataColumn(rs, 0, (LPSTR)"fInfoType", 
  1417.                      GetTypeName(SQL_TYPE, SQL_CHAR), SQL_CHAR, 40, 0,
  1418.                      45, TA_LEFT);
  1419.    SetMetaDataColumn(rs, 1, (LPSTR)"Value", 
  1420.                      GetTypeName(SQL_TYPE, SQL_CHAR), SQL_CHAR, 70, 0,
  1421.                      70, TA_LEFT);
  1422.  
  1423.    //
  1424.    // Now create the MDI child window which will hold the results.
  1425.    //
  1426.    if(!CreateResultsWindow(ci, rs)) 
  1427.       goto exit00;
  1428.  
  1429.    
  1430.    //
  1431.    // Loop through the control structure and check each fInfoType.  Certain
  1432.    //    types require extra processing.
  1433.    //
  1434.    Busy(TRUE);
  1435.    for(dex=0;  dex<NumItems(GetInfo);  dex++) {
  1436.       if(GetInfo[dex].fInfoType == SQL_DRIVER_HSTMT)           // Input arg also
  1437.          *(HSTMT FAR *)GetInfo[dex].rgbInfoValue = ci->hstmt;
  1438.  
  1439.       memset(GetInfo[dex].rgbInfoValue, 0, GetInfo[dex].cbInfoMax);
  1440.  
  1441.       retcode = SQLGetInfo(ci->hdbc, 
  1442.                            GetInfo[dex].fInfoType, 
  1443.                            GetInfo[dex].rgbInfoValue, 
  1444.                            GetInfo[dex].cbInfoMax, 
  1445.                            NULL);
  1446.       if(retcode != SQL_SUCCESS)
  1447.          PrintErrors(ci, SQL_HANDLE_DBC);
  1448.  
  1449.       switch(GetInfo[dex].fInfoType) {
  1450.         case SQL_DRIVER_HENV:
  1451.         case SQL_DRIVER_HDBC:
  1452.         case SQL_DRIVER_HSTMT:
  1453.          rd = AllocateRowData(rs, rgbDft, RDATA_DEFAULT_BKGRND);
  1454.          SetColumnData(0, rd, GetInfo[dex].szInfoName);
  1455.          wsprintf(szVal, "%04X:%04X", HIWORD(cb32), LOWORD(cb32));
  1456.          SetColumnData(1, rd, (LPSTR)szVal);
  1457.          if(AddRowData(rs, rd) == LB_ERRSPACE)
  1458.             goto exit00;
  1459.          break;
  1460.          
  1461.          //
  1462.          // The default action is taken when we only need to display the
  1463.          //    value as is.  We can use the structure to figure out what
  1464.          //    format it is in.
  1465.          //
  1466.         default:
  1467.          rd = AllocateRowData(rs, rgbDft, RDATA_DEFAULT_BKGRND);
  1468.          SetColumnData(0, rd, GetInfo[dex].szInfoName);
  1469.          switch(GetInfo[dex].fOutType) {
  1470.            case INT16:
  1471.             wsprintf(szVal, "%d", cb16);
  1472.             SetColumnData(1, rd, (LPSTR)szVal);
  1473.             if(AddRowData(rs, rd) == LB_ERRSPACE)
  1474.                goto exit00;
  1475.             break;
  1476.             
  1477.            case INT32:
  1478.             wsprintf(szVal, "%ld", cb32);
  1479.             SetColumnData(1, rd, (LPSTR)szVal);
  1480.             if(AddRowData(rs, rd) == LB_ERRSPACE)
  1481.                goto exit00;
  1482.             break;
  1483.  
  1484.            case DEXVAL:
  1485.             lpINFS = (lpINFOSTRUCT)GetInfo[dex].ptr;
  1486.             if(!GetIndexVal(rs, GetInfo[dex].szInfoName,
  1487.                             lpINFS, GetInfo[dex].cbNum,
  1488.                             cb32,
  1489.                             (LPSTR)szVal, sizeof(szVal)))
  1490.                goto exit00;
  1491.             break;
  1492.             
  1493.            case BITVAL:
  1494.             lpINFS = (lpINFOSTRUCT)GetInfo[dex].ptr;
  1495.             if(!GetBitVal(rs, GetInfo[dex].szInfoName,
  1496.                           lpINFS, GetInfo[dex].cbNum,
  1497.                           cb32,
  1498.                           (LPSTR)szVal, sizeof(szVal)))
  1499.                goto exit00;
  1500.             break;
  1501.             
  1502.            default: 
  1503.             szGetInfo[69] = '\0'; // truncate long string...
  1504.             SetColumnData(1, rd, (LPSTR)GetInfo[dex].rgbInfoValue);
  1505.             if(AddRowData(rs, rd) == LB_ERRSPACE)
  1506.                goto exit00;
  1507.             break;
  1508.          }
  1509.       }
  1510.       
  1511.    }
  1512.    
  1513.    Busy(FALSE);
  1514.    return TRUE;
  1515.    
  1516.   exit00:
  1517.    Busy(FALSE);
  1518.    return FALSE;
  1519. }
  1520.  
  1521.    
  1522. //*---------------------------------------------------------------------------------
  1523. //| DisplayODBCFunctions:
  1524. //|   This function will enumerate all of the ODBC functions in a results set
  1525. //|      and indicate which ones are supported.  The results set is attatched
  1526. //|      as a valid results window on the current child.
  1527. //| Parms:
  1528. //|   in       ci                   CHILDINFO information
  1529. //| Returns:              
  1530. //|   TRUE if successful,
  1531. //|   FALSE on error
  1532. //*---------------------------------------------------------------------------------
  1533. BOOL DisplayODBCFunctions(CHILDINFO FAR * ci)
  1534. {
  1535.    UWORD                fSupport;
  1536.    char                 szFuncName[35];
  1537.    char                 szTitle[MAXBUFF];
  1538.    int                  dex;
  1539.    RESULTSSET FAR *     rs;
  1540.    ROWDATA FAR *        rd;
  1541.    RETCODE              retcode;
  1542.    COLORREF             rgbDft=GetDefaultRGB();
  1543.    //
  1544.    // Create a hard coded results set with 3 columns
  1545.    //
  1546.    lstrcpy((LPSTR)szTitle, (LPSTR)ci->szClientTitle);
  1547.    lstrcat((LPSTR)szTitle, (LPSTR)szDash);
  1548.    lstrcat((LPSTR)szTitle, (LPSTR)szODBCFunctions);
  1549.    rs = GetConnectWindowResultsNode(ci);
  1550.    if(!CreateResultsSet(rs, ci->hwndClient, ci->hInst, 3, (LPSTR)szTitle))
  1551.       return FALSE;  
  1552.  
  1553.    //
  1554.    // Set the meta data
  1555.    //
  1556.    SetMetaDataColumn(rs, 0, (LPSTR)"Function", 
  1557.                      GetTypeName(SQL_TYPE, SQL_CHAR), SQL_CHAR, 20, 0,
  1558.                      25, TA_LEFT);
  1559.    SetMetaDataColumn(rs, 1, (LPSTR)"Conformance", 
  1560.                      GetTypeName(SQL_TYPE, SQL_CHAR), SQL_CHAR, 10, 0,
  1561.                      10, TA_LEFT);
  1562.    SetMetaDataColumn(rs, 2, (LPSTR)"Supported", 
  1563.                      GetTypeName(SQL_TYPE, SQL_CHAR), SQL_CHAR, 10, 0,
  1564.                      10, TA_LEFT);
  1565.  
  1566.    //
  1567.    // Now create the MDI child window which will hold the results.
  1568.    //
  1569.    if(!CreateResultsWindow(ci, rs)) 
  1570.       goto exit00;
  1571.  
  1572.    
  1573.    //
  1574.    // Loop through the control structure and check each function.  For each row
  1575.    //    add a record with the function name, conformance level, and Yes if
  1576.    //    supported, No if not.
  1577.    //
  1578.    for(dex=0;  dex<NumItems(ODBCFunctions);  dex++) {
  1579.       retcode = SQLGetFunctions(ci->hdbc, 
  1580.                                 ODBCFunctions[dex].fFunction, &fSupport);
  1581.       if(retcode != SQL_SUCCESS)
  1582.          PrintErrors(ci, SQL_HANDLE_DBC);
  1583.       iLoadString(ODBCFunctions[dex].idFunction, (LPSTR)szFuncName, sizeof(szFuncName));
  1584.       rd = AllocateRowData(rs, rgbDft, RDATA_DEFAULT_BKGRND);
  1585.       SetColumnData(0, rd, szFuncName);
  1586.       SetColumnData(1, rd, ODBCFunctions[dex].szLevel);
  1587.       SetColumnData(2, rd, (fSupport) ? (LPSTR)szYes : (LPSTR)szNo);
  1588.       AddRowData(rs, rd);
  1589.    }
  1590.    
  1591.    return TRUE;
  1592.    
  1593.   exit00:
  1594.    SQLFreeStmt(ci->hstmt, SQL_CLOSE);
  1595.    return FALSE;
  1596. }
  1597.  
  1598.  
  1599. //*---------------------------------------------------------------------------------
  1600. //| DisplayODBCDataSources:
  1601. //|   This function will enumerate all of the ODBC Data sources.
  1602. //| Parms:
  1603. //|   in       ci                   CHILDINFO information
  1604. //| Returns:              
  1605. //|   TRUE if successful,
  1606. //|   FALSE on error
  1607. //*---------------------------------------------------------------------------------
  1608. BOOL DisplayODBCDataSources(CHILDINFO FAR * ci)
  1609. {  
  1610.    HENV                 henv;
  1611.    RESULTSSET FAR *     rs;
  1612.    ROWDATA FAR *        rd;
  1613.    RETCODE              retcode;
  1614.    char                 szDSN[SQL_MAX_DSN_LENGTH + 1];
  1615.    char                 szDesc[MAXBUFF];
  1616.    char                 szTitle[MAXBUFF];
  1617.    COLORREF             rgbDft=GetDefaultRGB();
  1618.  
  1619.    //
  1620.    // Create a hard coded results set with 2 columns
  1621.    //
  1622.    lstrcpy((LPSTR)szTitle, (LPSTR)ci->szClientTitle);
  1623.    lstrcat((LPSTR)szTitle, (LPSTR)szDash);
  1624.    lstrcat((LPSTR)szTitle, (LPSTR)szODBCDataSources);
  1625.    rs = GetConnectWindowResultsNode(ci);
  1626.    if(!CreateResultsSet(rs, ci->hwndClient, ci->hInst, 2, (LPSTR)szTitle))
  1627.       return FALSE;  
  1628.  
  1629.    //
  1630.    // Set the meta data
  1631.    //
  1632.    SetMetaDataColumn(rs, 0, (LPSTR)"Driver", 
  1633.                      GetTypeName(SQL_TYPE, SQL_CHAR), SQL_CHAR, 15, 0,
  1634.                      15, TA_LEFT);
  1635.    SetMetaDataColumn(rs, 1, (LPSTR)"Description", 
  1636.                      GetTypeName(SQL_TYPE, SQL_CHAR), SQL_CHAR, 35, 0,
  1637.                      35, TA_LEFT);
  1638.  
  1639.    //
  1640.    // Now create the MDI child window which will hold the results.
  1641.    //
  1642.    if(!CreateResultsWindow(ci, rs)) 
  1643.       goto exit00;
  1644.  
  1645.    
  1646.    //
  1647.    // Loop through each data source and add it to the results set.
  1648.    //
  1649.    if (SQL_SUCCESS != SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HENV, &henv) )
  1650.     {
  1651.          PrintErrors(ci, SQL_HANDLE_ENV);
  1652.          goto exit00;
  1653.     }
  1654.     if (SQL_SUCCESS != SQLSetEnvAttr(henv,SQL_ATTR_ODBC_VERSION,
  1655.         (SQLPOINTER)SQL_OV_ODBC3,SQL_IS_INTEGER))
  1656.     {
  1657.          PrintErrors(ci, SQL_HANDLE_ENV);
  1658.          goto exit00;
  1659.     }
  1660.     
  1661.    retcode = SQLDataSources(henv, SQL_FETCH_FIRST, szDSN, sizeof(szDSN),
  1662.                             NULL, szDesc, sizeof(szDesc), NULL);
  1663.    while(retcode != SQL_NO_DATA) {
  1664.       if(retcode != SQL_SUCCESS )
  1665.         {
  1666.          PrintErrors(ci, SQL_HANDLE_ENV);
  1667.             if (retcode != SQL_SUCCESS_WITH_INFO)
  1668.                 goto exit00;
  1669.         }
  1670.       rd = AllocateRowData(rs, rgbDft, RDATA_DEFAULT_BKGRND);
  1671.       SetColumnData(0, rd, szDSN);
  1672.       SetColumnData(1, rd, szDesc);
  1673.       AddRowData(rs, rd);
  1674.       retcode = SQLDataSources(henv, SQL_FETCH_NEXT, szDSN, sizeof(szDSN),
  1675.                                NULL, szDesc, sizeof(szDesc), NULL);
  1676.    }
  1677.    SQLFreeHandle(SQL_HANDLE_ENV, henv); 
  1678.  
  1679.    return TRUE;
  1680.    
  1681.   exit00:
  1682.  
  1683.    return FALSE;
  1684. }
  1685.  
  1686.  
  1687.  
  1688. //*---------------------------------------------------------------------------------
  1689. //| DisplayODBCDataTypes:
  1690. //|   This function will enumerate data type information.
  1691. //| Parms:
  1692. //|   in       ci                   CHILDINFO information
  1693. //| Returns:              
  1694. //|   TRUE if successful,
  1695. //|   FALSE on error
  1696. //*---------------------------------------------------------------------------------
  1697. BOOL DisplayODBCDataTypes(CHILDINFO FAR * ci)
  1698. {  
  1699.    RESULTSSET FAR *     rs;
  1700.    RETCODE              retcode;
  1701.    SWORD                cbCols;
  1702.    char                 szTitle[MAXBUFF];
  1703.  
  1704.    //
  1705.    // We'll use SQLGetTypeInfo for this query.  Since this function can return more
  1706.    //    than the standard types, we must first execute the query and then create
  1707.    //    the results set.
  1708.    //
  1709.    lstrcpy((LPSTR)szTitle, (LPSTR)ci->szClientTitle);
  1710.    lstrcat((LPSTR)szTitle, (LPSTR)szDash);
  1711.    lstrcat((LPSTR)szTitle, (LPSTR)szODBCDataTypes);
  1712.    retcode = SQLGetTypeInfo(ci->hstmt, SQL_ALL_TYPES);
  1713.    if(retcode != SQL_SUCCESS) {
  1714.       PrintErrors(ci, SQL_HANDLE_STMT);
  1715.       return FALSE;
  1716.    }
  1717.  
  1718.    if(!(cbCols = GetNumResultsCols(ci->hstmt)))
  1719.       return FALSE;
  1720.  
  1721.    rs = GetConnectWindowResultsNode(ci);
  1722.    if(!CreateResultsSet(rs, ci->hwndClient, ci->hInst, cbCols, (LPSTR)szTitle))
  1723.       return FALSE;  
  1724.  
  1725.    //
  1726.    // Set the meta data
  1727.    //
  1728.    SetMetaDataFromSql(ci->hwndOut, ci->hstmt, rs, cbCols);
  1729.  
  1730.    //
  1731.    // Now create the MDI child window which will hold the results.
  1732.    //
  1733.    if(!CreateResultsWindow(ci, rs)) 
  1734.       goto exit00;
  1735.  
  1736.    
  1737.    //
  1738.    // Loop through each data source and add it to the results set.
  1739.    //
  1740.    FetchAllRecordsToResults(ci->hwndOut, ci->hstmt, rs, cbCols, TRUE);
  1741.    SQLFreeStmt(ci->hstmt, SQL_CLOSE);
  1742.  
  1743.    return TRUE;
  1744.    
  1745.   exit00:
  1746.    return FALSE;
  1747. }
  1748.  
  1749.  
  1750.  
  1751. //*---------------------------------------------------------------------------------
  1752. //| EditPipe:
  1753. //|   This function allows the user to create a new pipe.
  1754. //| Parms:
  1755. //|   in       ci                   CHILDINFO information
  1756. //| Returns:              
  1757. //|   TRUE if successful,
  1758. //|   FALSE on error
  1759. //*---------------------------------------------------------------------------------
  1760. void EditPipe(CHILDINFO FAR * ci)
  1761. {
  1762.    HWND     fHwnd=GetFocus();
  1763.  
  1764.    if(-1 == DialogBoxParam(ci->hInst, 
  1765.                            MAKEINTRESOURCE(IDD_EDIT_PIPE),
  1766.                            ci->hwnd, 
  1767.                            (DLGPROC) EditPipeWndProc, (LPARAM)ci))
  1768.       MessageBox(NULL, "Could not open dialog box.",
  1769.                  "Pipe", MB_ICONEXCLAMATION);
  1770.    
  1771.    if(fHwnd)
  1772.       SetFocus(fHwnd);
  1773. }
  1774.  
  1775.  
  1776.  
  1777. //*------------------------------------------------------------------------
  1778. //| IsValidParms:
  1779. //|   Verify that the parameters specified are the correct comma
  1780. //|   separated format.
  1781. //| Parms:
  1782. //|   hwnd              Window handle for errors
  1783. //|   szParms           The null terminated list of parms
  1784. //| Returns:              
  1785. //|   TRUE if they are valid, FALSE on error
  1786. //*------------------------------------------------------------------------
  1787. BOOL WINAPI IsValidParms(HWND hwnd, LPSTR szParms)
  1788. {
  1789.    LPSTR       str=szParms, nstr;
  1790.    char        sztmp[MAXSQL];
  1791.    int         iNum, iCnt=0;
  1792.  
  1793.    lstrcpy(sztmp, szParms);
  1794.    nstr = str = strtok(sztmp, szCOMMA);
  1795.    while(str) {
  1796.       ++iCnt;
  1797.       if(!(strlen(str) == 1 && *str == '0')) {
  1798.          iNum = atoi(str);
  1799.          while(*str) {
  1800.             if(*str < '0' ||
  1801.                *str > '9')
  1802.                goto invalidint;
  1803.             ++str;
  1804.          }
  1805.          
  1806.          // It was not 0, so if atoi returned 0 it was invalid
  1807.          if(!iNum)
  1808.             goto invalidint;
  1809.       }
  1810.       
  1811.       nstr = str = strtok(NULL, szCOMMA);
  1812.    }
  1813.    
  1814.    if(iCnt <= MAXPARMS)
  1815.       return TRUE;
  1816.    else {
  1817.       szMessageBox(hwnd,
  1818.                    MB_ICONEXCLAMATION | MB_OK,
  1819.                    (LPSTR)szErrorMsgTitle,
  1820.                    iLoadString(idsTooManyParms, OutStr, MAXBUFF),
  1821.                    iCnt,
  1822.                    MAXPARMS);
  1823.       return FALSE;
  1824.    }
  1825.  
  1826.   invalidint:
  1827.    szMessageBox(hwnd, 
  1828.                 MB_ICONEXCLAMATION | MB_OK,
  1829.                 (LPSTR)szErrorMsgTitle,
  1830.                 iLoadString(idsInvalidInt, OutStr, MAXBUFF),
  1831.                 nstr);
  1832.    
  1833.    return FALSE;
  1834. }
  1835.  
  1836.  
  1837. //*------------------------------------------------------------------------
  1838. //| EditPipeWndProc:
  1839. //|   Message handler for creating a new pipe.
  1840. //| Parms:
  1841. //|   in       Standard window parms
  1842. //| Returns:              
  1843. //|   Depends on message
  1844. //*------------------------------------------------------------------------
  1845. BOOL EXTFUN EditPipeWndProc(HWND hDlg, unsigned msg, WPARAM wParam, LPARAM lParam)
  1846. {
  1847.    static CHILDINFO FAR *     ci;
  1848.    static                     cbNames;
  1849.    static char                szName[MAXNAME];
  1850.  
  1851.    switch(msg) {
  1852.      case WM_INITDIALOG:
  1853.       {
  1854.          ci = (CHILDINFO FAR *)lParam;
  1855.          CenterDialog(hDlg);
  1856.  
  1857.          SendMessage(GetDlgItem(hDlg, IDC_NAME), CB_LIMITTEXT, MAXPARMS, 0L);
  1858.          SendMessage(GetDlgItem(hDlg, IDE_SQL), EM_LIMITTEXT, MAXSQL, 0L);
  1859.          SendMessage(GetDlgItem(hDlg, IDE_PARMS), EM_LIMITTEXT, (MAXNAME*2), 0L);
  1860.          CheckRadioButton(hDlg, IDR_VALUE, IDR_ADDRESS, IDR_VALUE);
  1861.          SendMessage(hDlg, USER_RESETLIST, 0, 0L);
  1862.          SendMessage(hDlg, USER_SETSTATES, 0, 0L);
  1863.       }
  1864.       return TRUE;      
  1865.  
  1866.  
  1867.       // This user message is sent when the list needs to be refreshed
  1868.      case USER_RESETLIST:
  1869.       {
  1870.          LPSTR       str, addstr;
  1871.  
  1872.          addstr = str = (LPSTR)GetMemory(1000);
  1873.          if(!addstr)
  1874.             return TRUE;
  1875.          cbNames = 0;
  1876.          if(str) {
  1877.             SendMessage(GetDlgItem(hDlg, IDC_NAME), CB_RESETCONTENT, 0, 0L);
  1878.             if(GetPrivateProfileString((LPSTR)szPIPES, NULL, NULL,
  1879.                                        str, 1000, szLABINI)) 
  1880.                while(*addstr) {
  1881.                   ++cbNames;
  1882.                   SendMessage(GetDlgItem(hDlg, IDC_NAME),
  1883.                               CB_ADDSTRING, 0,
  1884.                               (LPARAM)(LPSTR)addstr);
  1885.                   addstr = addstr + lstrlen(addstr) + 1;
  1886.                }
  1887.          }
  1888.          ReleaseMemory(str);
  1889.          if(cbNames) 
  1890.             SendMessage(GetDlgItem(hDlg, IDC_NAME), CB_SETCURSEL, 0, 0L);
  1891.          SendMessage(hDlg, USER_SETDEFAULTS, 0, 0L);
  1892.          SendMessage(hDlg, USER_SETSTATES, 0, 0L);
  1893.       }
  1894.       return TRUE;
  1895.       
  1896.       // This user defined message will set the state of controls
  1897.      case USER_SETSTATES:
  1898.       EnableWindow(GetDlgItem(hDlg, IDB_DELETE), cbNames);
  1899.       EnableWindow(GetDlgItem(hDlg, IDE_SQL), cbNames);
  1900.       EnableWindow(GetDlgItem(hDlg, IDR_VALUE), cbNames);
  1901.       EnableWindow(GetDlgItem(hDlg, IDR_ADDRESS), cbNames);
  1902.       EnableWindow(GetDlgItem(hDlg, IDE_PARMS), cbNames);
  1903.       EnableWindow(GetDlgItem(hDlg, IDOK), cbNames);
  1904.       return TRUE;
  1905.  
  1906.       // This user defined message is for setting default values
  1907.      case USER_SETDEFAULTS: 
  1908.       {
  1909.          char  szParmType[10];
  1910.          char  szSql[MAXSQL];
  1911.          char  szParms[MAXBUFF];
  1912.          
  1913.          HWND  hName = GetDlgItem(hDlg, IDC_NAME);
  1914.          
  1915.          if(cbNames == 0) {               // No current driver
  1916.             SetDlgItemText(hDlg, IDE_SQL, "");
  1917.             SetDlgItemText(hDlg, IDE_PARMS, "");
  1918.             return TRUE;
  1919.          }
  1920.          SendMessage(hName, CB_GETLBTEXT,
  1921.                      (WPARAM)SendMessage(hName, CB_GETCURSEL, 0, 0L),
  1922.                      (LPARAM)(LPSTR)szName);
  1923.          if(GetPrivateProfileString(szName, szSQL, NULL, szSql, sizeof(szSql), szLABINI))
  1924.             SetDlgItemText(hDlg, IDE_SQL, szSql);
  1925.          else
  1926.             SetDlgItemText(hDlg, IDE_SQL, "");
  1927.          if(GetPrivateProfileString(szName, szPARMS, NULL, szParms, sizeof(szParms), szLABINI))
  1928.             SetDlgItemText(hDlg, IDE_PARMS, szParms);
  1929.          else
  1930.             SetDlgItemText(hDlg, IDE_PARMS, "");
  1931.          if(GetPrivateProfileString(szName, szPARMOPT, NULL, szParmType, sizeof(szParmType), szLABINI))
  1932.             if(lstrcmpi(szVALUE, szParmType) == 0)
  1933.                CheckRadioButton(hDlg, IDR_VALUE, IDR_ADDRESS, IDR_VALUE);
  1934.             else
  1935.                CheckRadioButton(hDlg, IDR_VALUE, IDR_ADDRESS, IDR_ADDRESS);
  1936.          CheckDlgButton(hDlg, IDX_DELETE, GetPrivateProfileInt(szName, szDELETEOPT, 0, szLABINI));
  1937.       }
  1938.       return TRUE;
  1939.       
  1940.      case WM_COMMAND:
  1941.       switch(GET_WM_COMMAND_ID(wParam, lParam)) {
  1942.         case IDB_NEW:
  1943.          {
  1944.             NEWPIPE  np;
  1945.             
  1946.             np.hwnd = hDlg;
  1947.             np.hInst = ci->hInst;
  1948.             NewPipe(&np);
  1949.             if(np.fSuccess) {
  1950.                lstrcpy(szName, np.szName);
  1951.                SendMessage(GetDlgItem(hDlg, IDC_NAME), CB_SETCURSEL,
  1952.                            (WPARAM)SendMessage(GetDlgItem(hDlg, IDC_NAME), CB_ADDSTRING, 
  1953.                                                0, (LPARAM)(LPSTR)szName), 0L);
  1954.                if(cbNames)
  1955.                   SendMessage(hDlg, USER_SETDEFAULTS, 0, 0L);
  1956.                else
  1957.                   SendMessage(hDlg, USER_RESETLIST, 0, 0L);
  1958.             }
  1959.          }              
  1960.          return TRUE;
  1961.          
  1962.         case IDB_DELETE:
  1963.          GetText(GetDlgItem(hDlg, IDC_NAME), szName);
  1964.          wsprintf(OutStr, szDeletePipe, (LPSTR)szName);
  1965.          if(IDOK == MessageBox(hDlg, OutStr, szEditPipe, MB_OKCANCEL)) {
  1966.             WritePrivateProfileString(szName, NULL, NULL, szLABINI);
  1967.             WritePrivateProfileString(szPIPES, szName, NULL, szLABINI);
  1968.             SendMessage(hDlg, USER_RESETLIST, 0, 0L);
  1969.          }
  1970.          return TRUE;
  1971.          
  1972.          //
  1973.          // Read in the info from the dialog, validate the parms, write to file
  1974.          //
  1975.         case IDOK:
  1976.          {
  1977.             char  szSql[MAXSQL];
  1978.             char  szParms[MAXBUFF];
  1979.  
  1980.             GetDlgItemText(hDlg, IDC_NAME, (LPSTR)szName, sizeof(szName));
  1981.  
  1982.             GetDlgItemText(hDlg, IDE_PARMS, szParms, sizeof(szParms));
  1983.             if(IsValidParms(hDlg, szParms)) {
  1984.                WritePrivateProfileString(szName, szPARMS, szParms, szLABINI);
  1985.                
  1986.                GetDlgItemText(hDlg, IDE_SQL, szSql, sizeof(szSql));
  1987.                WritePrivateProfileString(szName, szSQL, szSql, szLABINI);
  1988.  
  1989.                if(IsDlgButtonChecked(hDlg, IDR_VALUE))                   
  1990.                   WritePrivateProfileString(szName, szPARMOPT, szVALUE, szLABINI);
  1991.                else
  1992.                   WritePrivateProfileString(szName, szPARMOPT, szADDRESS, szLABINI);
  1993.  
  1994.                WritePrivateProfileString(szName, szDELETEOPT, 
  1995.                                          (IsDlgButtonChecked(hDlg, IDX_DELETE)) ? (LPSTR)"1" : (LPSTR)"0",
  1996.                                          szLABINI);
  1997.             }
  1998.          }
  1999.          return TRUE;
  2000.          
  2001.         case IDCANCEL:
  2002.          EndDialog(hDlg, IDCANCEL);;
  2003.          return TRUE;
  2004.       }
  2005.       // Now check for control notification messages
  2006.       switch(HIWORD(lParam)) {
  2007.         case CBN_SELENDOK:
  2008.         case CBN_KILLFOCUS:
  2009.          SendMessage(hDlg, USER_SETDEFAULTS, TRUE, 0L);
  2010.          return TRUE;
  2011.          
  2012.         default:
  2013.          break;
  2014.       }
  2015.       break;
  2016.  
  2017.  
  2018.      default:
  2019.       return FALSE;
  2020.    }
  2021.    return FALSE;
  2022. }
  2023.  
  2024.  
  2025. //*---------------------------------------------------------------------------------
  2026. //| NewPipe:
  2027. //|   This function allows the user to create a new pipe.
  2028. //| Parms:
  2029. //|   in       ci                   CHILDINFO information
  2030. //| Returns:              
  2031. //|   Nothing
  2032. //*---------------------------------------------------------------------------------
  2033. void NewPipe(NEWPIPE FAR * np)
  2034. {
  2035.    HWND     fHwnd=GetFocus();
  2036.  
  2037.    if(-1 == DialogBoxParam(np->hInst, 
  2038.                            MAKEINTRESOURCE(IDD_NEW_PIPE),
  2039.                            np->hwnd, 
  2040.                            (DLGPROC) NewPipeWndProc, (LPARAM)np))
  2041.       MessageBox(NULL, "Could not open dialog box.",
  2042.                  "Pipe", MB_ICONEXCLAMATION);
  2043.    
  2044.    if(fHwnd)
  2045.       SetFocus(fHwnd);
  2046. }
  2047.  
  2048.  
  2049. //*------------------------------------------------------------------------
  2050. //| NewPipeWndProc:
  2051. //|   Message handler for creating a new pipe.
  2052. //| Parms:
  2053. //|   in       Standard window parms
  2054. //| Returns:              
  2055. //|   Depends on message
  2056. //*------------------------------------------------------------------------
  2057. BOOL EXTFUN NewPipeWndProc(HWND hDlg, unsigned msg, WPARAM wParam, LPARAM lParam)
  2058. {
  2059.    char                       szName[MAXNAME];
  2060.    static NEWPIPE FAR *       np;
  2061.  
  2062.    switch(msg) {
  2063.      case WM_INITDIALOG:
  2064.       {
  2065.          np = (NEWPIPE FAR *)lParam;
  2066.          CenterDialog(hDlg);
  2067.          SendMessage(GetDlgItem(hDlg, IDE_NAME), EM_LIMITTEXT, MAXNAME, 0L);
  2068.       }
  2069.       return TRUE;      
  2070.  
  2071.  
  2072.      case WM_COMMAND:
  2073.       switch(GET_WM_COMMAND_ID(wParam, lParam)) {
  2074.         case IDOK:
  2075.          {
  2076.             char szTmp[MAXNAME];
  2077.  
  2078.             //
  2079.             // Don't allow names with [,], or = in them, nor any
  2080.             // reserved section names
  2081.             //
  2082.             GetText(GetDlgItem(hDlg, IDE_NAME), (LPSTR)szName);
  2083.             if(!ValidName((LPSTR)szName) ||
  2084.                !*szName ||
  2085.                !lstrcmpi((LPSTR)szName, szSCREEN) ||
  2086.                !lstrcmpi((LPSTR)szName, szFONT) ||
  2087.                !lstrcmpi((LPSTR)szName, szCONNECTOPTIONS) ||
  2088.                !lstrcmpi((LPSTR)szName, szPIPES)) {
  2089.  
  2090.                szMessageBox(hDlg,
  2091.                             MB_ICONEXCLAMATION | MB_OK,
  2092.                             (LPSTR)szErrorMsgTitle,
  2093.                             iLoadString(idsInvalidName, OutStr, MAXBUFF),
  2094.                             (LPSTR)szName);
  2095.                return TRUE;
  2096.             }
  2097.             if(GetPrivateProfileString(szPIPES, szName, NULL,
  2098.                                        szTmp, sizeof(szTmp), szLABINI)) 
  2099.                MessageBox(hDlg, szDuplicatePipe, szEditPipe, MB_OK);
  2100.             else {
  2101.                lstrcpy(np->szName, szName);
  2102.                np->fSuccess = TRUE;
  2103.                WritePrivateProfileString(szPIPES, szName, szInstalled, szLABINI);
  2104.                EndDialog(hDlg, IDOK);
  2105.             }
  2106.          }
  2107.          return TRUE;
  2108.          
  2109.         case IDCANCEL:
  2110.          np->fSuccess = FALSE;
  2111.          EndDialog(hDlg, IDCANCEL);
  2112.          return TRUE;
  2113.       }
  2114.       break;
  2115.  
  2116.      default:
  2117.       return FALSE;
  2118.    }
  2119.    return FALSE;
  2120. }
  2121.  
  2122.  
  2123.  
  2124. //*---------------------------------------------------------------------------------
  2125. //| HandlePipe:
  2126. //|   This function will use the active results set and run use pipes against it.
  2127. //| Parms:
  2128. //|   lpci              Connection window information
  2129. //|   lpri              Ative results set
  2130. //| Returns:              
  2131. //|   Nothing.
  2132. //*---------------------------------------------------------------------------------
  2133. void INTFUN HandlePipe(lpCHILDINFO lpci, lpRESULTSINFO lpri)
  2134. {
  2135.    HWND                 fHwnd=GetFocus();
  2136.  
  2137.    if(-1 == DialogBoxParam(lpci->hInst, 
  2138.                            MAKEINTRESOURCE(IDD_DO_PIPE),
  2139.                            lpci->hwnd, 
  2140.                            (DLGPROC) DoPipeWndProc, (LPARAM)(lpRESULTSINFO)lpri))
  2141.       MessageBox(NULL, "Could not open dialog box.",
  2142.                  "HandlePipe", MB_ICONEXCLAMATION);
  2143.    
  2144.    if(fHwnd)
  2145.       SetFocus(fHwnd);
  2146. }
  2147.  
  2148.  
  2149. //*------------------------------------------------------------------------
  2150. //| DoPipeWndProc:
  2151. //|   Handle dialog messages for IDD_DO_PIPE.
  2152. //| Parms:
  2153. //|   in       Standard window parms
  2154. //| Returns:              
  2155. //|   Depends on message
  2156. //*------------------------------------------------------------------------
  2157. BOOL EXTFUN DoPipeWndProc(HWND hDlg, unsigned msg, WPARAM wParam, LPARAM lParam)
  2158. {
  2159.    static CHILDINFO FAR *     ci;
  2160.    static RESULTSSET FAR *    rs;
  2161.    static SDWORD              cbPipes;
  2162.  
  2163.    switch(msg) {
  2164.      case WM_INITDIALOG:
  2165.       {
  2166.          lpRESULTSINFO rwi;
  2167.          rwi = (lpRESULTSINFO)lParam;
  2168.          ci = rwi->ci;
  2169.          rs = rwi->rs;
  2170.          CenterDialog(hDlg);
  2171.          cbPipes = RefreshPipeList(GetDlgItem(hDlg, IDL_PIPES));
  2172.          EnableWindow(GetDlgItem(hDlg, IDL_PIPES), (int)(cbPipes));
  2173.          EnableWindow(GetDlgItem(hDlg, IDOK), (int)(cbPipes));
  2174.       }
  2175.       return TRUE;      
  2176.  
  2177.  
  2178.      case WM_COMMAND:
  2179.       switch(GET_WM_COMMAND_ID(wParam, lParam)) {
  2180.          // User has clicked OK.  Retrieve an array of the selected indexes
  2181.          // and run the current pipe against each.  Finally see if this
  2182.          // pipe wants to delete items.
  2183.         case IDOK:
  2184.          {
  2185.             int         cbCnt;
  2186.             int FAR *   xSel;
  2187.             int         dex;
  2188.             char        szPipeName[MAXBUFF];
  2189.  
  2190.             Busy(TRUE);
  2191.             cbCnt = (int)SendMessage(rs->hwndList, LB_GETSELCOUNT, 0, 0L);
  2192.             xSel = (int FAR *)GetMemory(sizeof(int) * cbCnt);
  2193.             if(!xSel) {
  2194.                Busy(FALSE);
  2195.                return TRUE;
  2196.             }
  2197.             SendMessage(rs->hwndList, LB_GETSELITEMS, cbCnt, (LPARAM)(int FAR *)xSel);
  2198.             SendMessage(GetDlgItem(hDlg, IDL_PIPES), LB_GETTEXT,
  2199.                         (WPARAM)SendMessage(GetDlgItem(hDlg, IDL_PIPES), LB_GETCURSEL, 0, 0L),
  2200.                         (LPARAM)(LPSTR)szPipeName);
  2201.             DoPipe(rs, ci, (LPSTR)szPipeName, xSel, cbCnt);
  2202.             if(GetPrivateProfileInt(szPipeName, szDELETEOPT, 0, szLABINI))
  2203.                for(dex=cbCnt-1;  dex>=0;  dex--)
  2204.                   SendMessage(rs->hwndList, LB_DELETESTRING, xSel[dex], 0L);
  2205.             Busy(FALSE);
  2206.             ReleaseMemory(xSel);
  2207.          }
  2208.          return TRUE;
  2209.          
  2210.         case IDCANCEL:
  2211.          EndDialog(hDlg, IDCANCEL);
  2212.          return TRUE;
  2213.       }
  2214.       return TRUE;
  2215.  
  2216.      default:
  2217.       return FALSE;
  2218.    }
  2219.    return FALSE;
  2220. }
  2221.  
  2222.  
  2223.  
  2224.  
  2225. //*---------------------------------------------------------------------------------
  2226. //| RefreshPipeList:
  2227. //|   This function will reset the list of pipes based on the values returned
  2228. //|      from GetPipeName.  Having this extra level of abstraction allows us
  2229. //|      to change the location of the pipes without affecting this code.
  2230. //| Parms:
  2231. //|   in       hwnd                 Window handle to list box to fill
  2232. //| Returns:              
  2233. //|   Number of items selected
  2234. //*---------------------------------------------------------------------------------
  2235. SDWORD RefreshPipeList(HWND hDlg)
  2236. {
  2237. #define MAX_PIPE_SIZE 4000
  2238.    LPSTR    szPipes, str;
  2239.    SDWORD count=0;
  2240.    
  2241.    szPipes = (LPSTR)GetMemory(MAX_PIPE_SIZE);
  2242.    if(!szPipes) 
  2243.       return 0;
  2244.    
  2245.    SendMessage(hDlg, LB_RESETCONTENT, 0, 0L);
  2246.    GetPipeNames((LPSTR)szPipes, MAX_PIPE_SIZE);
  2247.    str = szPipes;
  2248.    while(*str) {
  2249.       SendMessage(hDlg, LB_ADDSTRING, 0, (LPARAM)(LPSTR)str);
  2250.       str += lstrlen(str) + 1;
  2251.       ++count;
  2252.    }
  2253.    if(count)
  2254.       SendMessage(hDlg, LB_SETCURSEL, 0, 0L);
  2255.  
  2256.    ReleaseMemory(szPipes);
  2257.    return count;
  2258. }
  2259.  
  2260.  
  2261. //*---------------------------------------------------------------------------------
  2262. //| DoPipe:
  2263. //|   This function will implement a pipe against the object which is passed in.
  2264. //| Parms:
  2265. //|   in       rs                   Pointer to results set describing data
  2266. //|   in       ci                   Connection window information
  2267. //|   in       szPipeName           Name of pipe to use
  2268. //|   in       xPipes               Array of items to pipe
  2269. //|   in       cbCnt                Number of items
  2270. //| Returns:              
  2271. //|   Nothing.
  2272. //*---------------------------------------------------------------------------------
  2273. void DoPipe(RESULTSSET FAR * rs, CHILDINFO FAR * ci, LPSTR szPipeName,
  2274.             int FAR xPipes[], int cbCnt)
  2275. {
  2276.    SDWORD            cbDataAtExec=SQL_DATA_AT_EXEC;
  2277.    int               dex;
  2278.    int               cParm;
  2279.    char              szpsql[200];
  2280.    char              szparms[35];
  2281.    char              parmopt[10];
  2282.    UWORD             cParmCnt=0;
  2283.    LPSTR             str=szparms;
  2284.    LPSTR             numstr=szparms;
  2285.    ROWDATA FAR *     rd;
  2286.    RETCODE           retcode;
  2287.  
  2288.    //
  2289.    // Make sure we can retrieve the pipe from the .ini file.  Also get the parameter
  2290.    //    values if they are available.
  2291.    //
  2292.    if(!GetPrivateProfileString(szPipeName, szSQL, NULL, szpsql, sizeof(szpsql), szLABINI)) {
  2293.       szWrite(ci->hwndOut, 
  2294.               GetidsString(idsPipeNotFound, OutStr, MAXBUFF), 
  2295.               (LPSTR)szPipeName);
  2296.       return;
  2297.    }
  2298.    GetPrivateProfileString(szPipeName, szPARMS, NULL, szparms, sizeof(szparms), szLABINI);
  2299.    GetPrivateProfileString(szPipeName, szPARMOPT, NULL, parmopt, sizeof(parmopt), szLABINI);
  2300.  
  2301.    //
  2302.    // If there are parameters to set, set each one based on user desription
  2303.    //
  2304.    if(str && *str)
  2305.       PrepareParmList(str);
  2306.    SQLFreeStmt(ci->hstmt, SQL_CLOSE);
  2307.    
  2308.    //
  2309.    // What type of parameter passing to do?  value means substitue text and execute,
  2310.    //    address means use parameter data.  The following will handle the former, the
  2311.    //    next more complicated routine will pass parameters.
  2312.    //
  2313.    if(lstrcmpi(parmopt, szVALUE) == 0) {
  2314.       DoPipeByValue(rs, ci, szpsql, str, xPipes, cbCnt, (LPSTR)szPipeName);
  2315.       return;
  2316.    }
  2317.    
  2318.    //
  2319.    // Now prepare the user's statement, return on error
  2320.    //
  2321.    retcode = SQLPrepare(ci->hstmt, szpsql, SQL_NTS);
  2322.    if(retcode != SQL_SUCCESS) {
  2323.       PrintErrors(ci, SQL_HANDLE_STMT);
  2324.       return;
  2325.    }
  2326.    
  2327.    //
  2328.    // For each parameter, make sure it's in our range, then see which mode we want,
  2329.    //    address (param data) or value (textual substitution).
  2330.    //
  2331.    while(*str) {
  2332.       ++cParmCnt;
  2333.       cParm = lpatoi(str);
  2334.       if(cParm > rs->cbColumns) 
  2335.          szWrite(ci->hwndOut, 
  2336.                  GetidsString(idsInvalidParamValue, OutStr, MAXBUFF), 
  2337.                  cParm, (LPSTR)szPipeName);
  2338.       else {
  2339.          retcode = SQLBindParameter(ci->hstmt, 
  2340.                                     cParmCnt, SQL_PARAM_INPUT,
  2341.                                     SQL_C_CHAR, SQL_CHAR, 
  2342.                                     rs->md[cParm-1].precision,
  2343.                                     rs->md[cParm-1].scale, 
  2344.                                     (PTR FAR *)(cParm - 1), 
  2345.                                     rs->md[cParm-1].precision,
  2346.                                     &cbDataAtExec);
  2347.          if(retcode != SQL_SUCCESS) 
  2348.             PrintErrors(ci, SQL_HANDLE_STMT);
  2349.       }
  2350.       str += lstrlen(str) + 1;
  2351.    }  
  2352.  
  2353.  
  2354.    //
  2355.    // For each row selected, retrieve the row data structure associated with it,
  2356.    //    then do an execute.  When prompted for SQL_NEED_DATA, substitute the
  2357.    //    correct parameter address.
  2358.    //
  2359.    for(dex=0;  dex<cbCnt;  dex++) { 
  2360.       int      cNeedParm;
  2361.       rd = (ROWDATA FAR *)SendMessage(rs->hwndList, LB_GETITEMDATA, (WPARAM)xPipes[dex], 0L);
  2362.       retcode = SQLExecute(ci->hstmt);
  2363.       switch(retcode) {
  2364.          //
  2365.          // User had parameter data which we are being prompted for.  Since we
  2366.          //    did the SQLSetParam using the index number, we simply use that
  2367.          //    value to index into our column data and give the driver what
  2368.          //    it requires.
  2369.          //
  2370.         case SQL_NEED_DATA:
  2371.          retcode = SQLParamData(ci->hstmt, (PTR FAR *)&cNeedParm);
  2372.          while(retcode == SQL_NEED_DATA) {
  2373.             retcode = SQLPutData(ci->hstmt, rd->cd[cNeedParm].szCols, SQL_NTS);
  2374.             retcode = SQLParamData(ci->hstmt, (PTR FAR *)&cNeedParm);
  2375.          }
  2376.          break;
  2377.          
  2378.         case SQL_SUCCESS:
  2379.          CheckForResults(ci);
  2380.          break;
  2381.          
  2382.         default:
  2383.          PrintErrors(ci, SQL_HANDLE_STMT);
  2384.          break;
  2385.       }
  2386.    }
  2387.    
  2388.    SQLFreeStmt(ci->hstmt, SQL_CLOSE);
  2389.    return;
  2390. }
  2391.  
  2392.  
  2393.  
  2394. //*---------------------------------------------------------------------------------
  2395. //| PrepareParmList:
  2396. //|   The user will enter a list of numbers separated by columns which will
  2397. //|   designate which parms go for what marker.  We will turn this list into
  2398. //|   a double-null terminated list which can be used later for retrieval.
  2399. //| Parms:
  2400. //|   in       str                  Pointer to string to work on
  2401. //| Returns:              
  2402. //|   Nothing.
  2403. //*---------------------------------------------------------------------------------
  2404. void PrepareParmList(LPSTR str)
  2405. {
  2406.    LPSTR tmpstr=str;
  2407.    LPSTR lststr=tmpstr;
  2408.  
  2409.    //
  2410.    // Convert parm list into a double-null terminated list
  2411.    //
  2412.    while(tmpstr) {
  2413.       if((tmpstr = _fstrchr(str, ','))) {
  2414.          lststr = tmpstr + 1;
  2415.          *tmpstr++ = '\0';
  2416.       }
  2417.       else {
  2418.          lststr += lstrlen(lststr) + 1;
  2419.          *lststr = '\0';
  2420.       }
  2421.    }
  2422. }        
  2423.  
  2424.  
  2425.  
  2426. //*---------------------------------------------------------------------------------
  2427. //| DoPipeByValue:
  2428. //|   This function will process all of the selcted values by creating a
  2429. //|   statement which has all parameters embedded in it.
  2430. //|
  2431. //|   Note:    There are some servers which use a semi-colon for the name of
  2432. //|            a stored procedure, but which cannot handle doing a drop of the
  2433. //|            object with this name.  If the pipe name is the reserved name
  2434. //|            of "Drop Procedure (with semi-colon)" then we will strip off the
  2435. //|            name since this can't really be done any other way.
  2436. //| Parms:
  2437. //|   in       rs                   Results set pointer
  2438. //|   in       ci                   Child information
  2439. //|   in       szUserSQL               Statement with parameter markers
  2440. //|   in       szParms              Parameter list, double null terminated
  2441. //|   in       xPipes               Array of indexes to use for param data
  2442. //|   in       cbCnt                Number of records to process
  2443. //|   in       szPipeName           Pipe names
  2444. //| Returns:              
  2445. //|   Nothing.
  2446. //*---------------------------------------------------------------------------------
  2447. void DoPipeByValue(RESULTSSET FAR * rs, CHILDINFO FAR * ci, LPSTR szUserSQL,
  2448.                    LPSTR szParms, int FAR xPipes[], int cbCnt, LPSTR szPipeName)
  2449. {
  2450.    char              szUserSQLCopy[300];
  2451.    char              sqlstmt[300];
  2452.    LPSTR             szParmStrOut;
  2453.    LPSTR             szParmStrIn;
  2454.    LPSTR             szParmStrLast;
  2455.    LPSTR             str=szParms;
  2456.    int               dex;
  2457.    int               cParm;
  2458.    ROWDATA FAR *     rd;
  2459.    BOOL              fSemiProc=FALSE;
  2460.    
  2461.    // Handle special case of a procedure name with a semi-colon
  2462.    if(lstrcmp(szPipeName, szDROPPROCSEMI) == 0)
  2463.       fSemiProc = TRUE;
  2464.    
  2465.    //
  2466.    // For each record selected, create a statement which can be executed by finding
  2467.    //    parameter markers and replacing them at run time.
  2468.    //
  2469.    for(dex=0;  dex<cbCnt;  dex++) {
  2470.       _fmemset(sqlstmt, 0, sizeof(sqlstmt));
  2471.       _fmemset(szUserSQLCopy, 0, sizeof(szUserSQLCopy));
  2472.       lstrcpy(szUserSQLCopy, szUserSQL);
  2473.       szParmStrOut = sqlstmt;
  2474.       szParmStrIn = szUserSQLCopy;
  2475.       szParmStrLast = szParmStrIn;
  2476.       str = szParms;
  2477.       rd = (ROWDATA FAR *)SendMessage(rs->hwndList, LB_GETITEMDATA, (WPARAM)xPipes[dex], 0L);
  2478.       while(*str) {
  2479.          cParm = lpatoi(str);
  2480.          if(cParm > rs->cbColumns) 
  2481.             szWrite(ci->hwndOut, 
  2482.                     GetidsString(idsInvalidParamValue, OutStr, MAXBUFF), 
  2483.                     cParm, (LPSTR)szPipeName);
  2484.          else if(szParmStrIn && *szParmStrIn) {
  2485.             if((szParmStrIn = _fstrchr(szParmStrIn, '?'))) {
  2486.                *szParmStrIn++ = '\0';
  2487.                lstrcpy(szParmStrOut, szParmStrLast);
  2488.                _fstrcat(szParmStrOut, rd->cd[cParm-1].szCols);
  2489.                // Remove semi-colon for special case of drop procedure
  2490.                if(fSemiProc) {
  2491.                   LPSTR    str = _fstrchr(szParmStrOut, ';');
  2492.                   if(str)
  2493.                      *str = '\0';
  2494.                }
  2495.                szParmStrLast = szParmStrIn; 
  2496.             }
  2497.             else
  2498.                lstrcpy(szParmStrOut, szParmStrLast);              // end of list
  2499.          }
  2500.          str += lstrlen(str) + 1;
  2501.       }
  2502.       if(*szParmStrLast)
  2503.          _fstrcat(szParmStrOut, szParmStrLast);
  2504.       ExecuteCmds(ci, sqlstmt);
  2505.    }
  2506.    
  2507.    return;
  2508. }
  2509.