home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / mfc / database / odbcinfo / drvinfo.cpp < prev    next >
C/C++ Source or Header  |  1998-03-26  |  105KB  |  3,692 lines
  1. // DrvInfo.cpp : implementation file
  2. //
  3. // This is a part of the Microsoft Foundation Classes C++ library.
  4. // Copyright (C) 1992-1998 Microsoft Corporation
  5. // All rights reserved.
  6. //
  7. // This source code is only intended as a supplement to the
  8. // Microsoft Foundation Classes Reference and related
  9. // electronic documentation provided with the library.
  10. // See these sources for detailed information regarding the
  11. // Microsoft Foundation Classes product.
  12.  
  13. #include "stdafx.h"
  14. #include "OdbcInfo.h"
  15. #include "catsets.h"
  16. #include "DrvInfo.h"
  17.  
  18. #ifdef _DEBUG
  19. #define new DEBUG_NEW
  20. #undef THIS_FILE
  21. static char THIS_FILE[] = __FILE__;
  22. #endif
  23.  
  24. /////////////////////////////////////////////////////////////////////////////
  25. // CMyPage property page - base class for all other pages
  26.  
  27. // static members
  28.  
  29. CDatabase* CMyPage::m_pDatabase = 0;
  30. CImageList* CMyPage::m_pImageList = 0;
  31. int CMyPage::m_nClients = 0;
  32.  
  33. // SQLGetInfo helpers
  34. //
  35. CString CMyPage::SQLGetInfoString(UWORD fInfoType)
  36. {
  37.     UCHAR   buffer[200];
  38.     SWORD   cbData;
  39.  
  40.     ::SQLGetInfo(m_pDatabase->m_hdbc,fInfoType,
  41.         (PTR)buffer,200,&cbData);
  42.     return CString(buffer);
  43. }
  44.  
  45. UWORD CMyPage::SQLGetInfoShort(UWORD fInfoType)
  46. {
  47.     UWORD   value;
  48.     SWORD   cbData;
  49.  
  50.     ::SQLGetInfo(m_pDatabase->m_hdbc,fInfoType,
  51.         (PTR)&value,2,&cbData);
  52.     return value;
  53. }
  54.  
  55. UDWORD CMyPage::SQLGetInfoLong(UWORD fInfoType)
  56. {
  57.     UDWORD  value;
  58.     SWORD   cbData;
  59.  
  60.     ::SQLGetInfo(m_pDatabase->m_hdbc,fInfoType,
  61.         (PTR)&value,4,&cbData);
  62.     return value;
  63. }
  64.  
  65. // formatting helpers
  66. //
  67. void CMyPage::ZeroIsNoneLong(CString& string,UWORD fInfoType)
  68. {
  69.     UDWORD value = SQLGetInfoLong(fInfoType);
  70.     if (value)
  71.         string.Format(_T("%d"),value);
  72.     else
  73.         string = _T("<none>");
  74. }
  75.  
  76. void CMyPage::ZeroIsNoneShort(CString& string,UWORD fInfoType)
  77. {
  78.     UWORD value = SQLGetInfoShort(fInfoType);
  79.     if (value)
  80.         string.Format(_T("%d"),value);
  81.     else
  82.         string = _T("<none>");
  83. }
  84.  
  85. void CMyPage::YIsYes(CString& string,UWORD fInfoType)
  86. {
  87.     string = SQLGetInfoString(fInfoType);
  88.     if (string == _T("Y"))
  89.         string = _T("Yes");
  90.     else if (string == _T("N"))
  91.         string = _T("No");
  92. }
  93.  
  94. void CMyPage::YIsSupported(CString& string,UWORD fInfoType)
  95. {
  96.     string = SQLGetInfoString(fInfoType);
  97.     if (string == _T("Y"))
  98.         string = _T("Supported");
  99.     else if (string == _T("N"))
  100.         string = _T("Not Supported");
  101. }
  102.  
  103. // CMyPage construction and destruction
  104.  
  105. CMyPage::CMyPage(CDatabase* pDatabase, UINT nIdTemplate)
  106.     : CPropertyPage(nIdTemplate)
  107. {
  108.     // if no other page has set the database, set it
  109.     if (!m_pDatabase)
  110.         m_pDatabase = pDatabase;
  111.  
  112.     // if no other page has created the image list, create it
  113.     if (!m_pImageList)
  114.     {
  115.         m_pImageList = new CImageList;
  116.         m_pImageList->Create(IDB_IMAGELIST,16,0,RGB(255,255,255));
  117.     }
  118.     m_nClients++;
  119. }
  120.  
  121. CMyPage::~CMyPage()
  122. {
  123.     // decrement imagelist client count, delete if it becomes 0
  124.     m_nClients--;
  125.     if (!m_nClients)
  126.         delete m_pImageList;
  127. }
  128.  
  129. /////////////////////////////////////////////////////////////////////////////
  130. // CDriverInfo property page
  131.  
  132. IMPLEMENT_DYNCREATE(CDriverInfo, CPropertyPage)
  133.  
  134. CDriverInfo::CDriverInfo(CDatabase* pDatabase)
  135.  : CMyPage(pDatabase,CDriverInfo::IDD)
  136. {
  137.     //{{AFX_DATA_INIT(CDriverInfo)
  138.     m_strSqlUserName = _T("");
  139.     m_strSqlServerName = _T("");
  140.     m_strSqlDbmsName = _T("");
  141.     m_strSqlDbmsVer = _T("");
  142.     m_strSqlDriverName = _T("");
  143.     m_strSqlDriverOdbcVer = _T("");
  144.     m_strSqlDriverVer = _T("");
  145.     m_strSqlOdbcVer = _T("");
  146.     m_strSqlOdbcApiConformance = _T("");
  147.     m_strSqlOdbcSagCliConformance = _T("");
  148.     m_strSqlOdbcSqlConformance = _T("");
  149.     m_strSqlOdbcSqlOptIef = _T("");
  150.     m_strSqlActiveConnections = _T("");
  151.     m_strSqlActiveStatements = _T("");
  152.     m_strSqlMultResultSets = _T("");
  153.     m_strSqlFileUsage = _T("");
  154.     m_strSqlDataSourceReadOnly = _T("");
  155.     m_strSqlDataSourceName = _T("");
  156.     m_strSqlAccessibleProcedures = _T("");
  157.     m_strSqlAccessibleTables = _T("");
  158.     m_strSqlDatabaseName = _T("");
  159.     //}}AFX_DATA_INIT
  160.  
  161.     OnNewDSN();
  162. }
  163.  
  164. CDriverInfo::~CDriverInfo()
  165. {
  166. }
  167.  
  168. void CDriverInfo::DumpToFile(CStdioFile& file)
  169. {
  170.     if (m_pDatabase->IsOpen())
  171.     {
  172.         CString string;
  173.         file.WriteString(_T("Driver Info\n-----------\n"));
  174.         string.Format(_T("     Data Source Name - %s\n"),m_strSqlDataSourceName);
  175.         file.WriteString(string);
  176.         string.Format(_T("        Database Name - %s\n"),m_strSqlDatabaseName);
  177.         file.WriteString(string);
  178.         string.Format(_T("            User Name - %s\n"),m_strSqlUserName);
  179.         file.WriteString(string);
  180.         string.Format(_T("          Server Name - %s\n"),m_strSqlServerName);
  181.         file.WriteString(string);
  182.         string.Format(_T("                 DBMS - %s version %s\n"),
  183.             m_strSqlDbmsName,m_strSqlDbmsVer);
  184.         file.WriteString(string);
  185.         string.Format(_T("               Driver - %s version %s\n"),
  186.             m_strSqlDriverName,m_strSqlDriverVer);
  187.         file.WriteString(string);
  188.         string.Format(_T("     Driver ODBC Ver. - %s\n"),m_strSqlDriverOdbcVer);
  189.         file.WriteString(string);
  190.         string.Format(_T("         ODBC Version - %s\n"),m_strSqlOdbcVer);
  191.         file.WriteString(string);
  192.         string.Format(_T("      API Conformance - %s\n"),m_strSqlOdbcApiConformance);
  193.         file.WriteString(string);
  194.         string.Format(_T("      SQL Conformance - %s\n"),m_strSqlOdbcSqlConformance);
  195.         file.WriteString(string);
  196.         string.Format(_T("  SAG CLI Conformance - %s\n"),m_strSqlOdbcSagCliConformance);
  197.         file.WriteString(string);
  198.         string.Format(_T("     Optional SQL IEF - %s\n"),m_strSqlOdbcSqlOptIef);
  199.         file.WriteString(string);
  200.         string.Format(_T("   Active Connections - %s\n"),m_strSqlActiveConnections);
  201.         file.WriteString(string);
  202.         string.Format(_T("    Active Statements - %s\n"),m_strSqlActiveStatements);
  203.         file.WriteString(string);
  204.         string.Format(_T(" Multiple Result Sets - %s\n"),m_strSqlMultResultSets);
  205.         file.WriteString(string);
  206.         string.Format(_T("           File Usage - %s\n"),m_strSqlFileUsage);
  207.         file.WriteString(string);
  208.         string.Format(_T("    Read/Write Status - %s\n"),m_strSqlDataSourceReadOnly);
  209.         file.WriteString(string);
  210.         string.Format(_T("Accessible Procedures - %s\n"),m_strSqlAccessibleProcedures);
  211.         file.WriteString(string);
  212.         string.Format(_T("    Accessible Tables - %s\n\n"),m_strSqlAccessibleTables);
  213.         file.WriteString(string);
  214.     }
  215. }
  216.  
  217. void CDriverInfo::DoDataExchange(CDataExchange* pDX)
  218. {
  219.     CPropertyPage::DoDataExchange(pDX);
  220.     //{{AFX_DATA_MAP(CDriverInfo)
  221.     DDX_Text(pDX, IDC_SQL_USER_NAME, m_strSqlUserName);
  222.     DDX_Text(pDX, IDC_SQL_SERVER_NAME, m_strSqlServerName);
  223.     DDX_Text(pDX, IDC_SQL_DBMS_NAME, m_strSqlDbmsName);
  224.     DDX_Text(pDX, IDC_SQL_DBMS_VER, m_strSqlDbmsVer);
  225.     DDX_Text(pDX, IDC_SQL_DRIVER_NAME, m_strSqlDriverName);
  226.     DDX_Text(pDX, IDC_SQL_DRIVER_ODBC_VER, m_strSqlDriverOdbcVer);
  227.     DDX_Text(pDX, IDC_SQL_DRIVER_VER, m_strSqlDriverVer);
  228.     DDX_Text(pDX, IDC_SQL_ODBC_VER, m_strSqlOdbcVer);
  229.     DDX_Text(pDX, IDC_SQL_ODBC_API_CONFORMANCE, m_strSqlOdbcApiConformance);
  230.     DDX_Text(pDX, IDC_SQL_ODBC_SAG_CLI_CONFORMANCE, m_strSqlOdbcSagCliConformance);
  231.     DDX_Text(pDX, IDC_SQL_ODBC_SQL_CONFORMANCE, m_strSqlOdbcSqlConformance);
  232.     DDX_Text(pDX, IDC_SQL_ODBC_SQL_OPT_IEF, m_strSqlOdbcSqlOptIef);
  233.     DDX_Text(pDX, IDC_SQL_ACTIVE_CONNECTIONS, m_strSqlActiveConnections);
  234.     DDX_Text(pDX, IDC_SQL_ACTIVE_STATEMENTS, m_strSqlActiveStatements);
  235.     DDX_Text(pDX, IDC_SQL_MULT_RESULT_SETS, m_strSqlMultResultSets);
  236.     DDX_Text(pDX, IDC_SQL_FILE_USAGE, m_strSqlFileUsage);
  237.     DDX_Text(pDX, IDC_SQL_DATA_SOURCE_READ_ONLY, m_strSqlDataSourceReadOnly);
  238.     DDX_Text(pDX, IDC_DSN, m_strSqlDataSourceName);
  239.     DDX_Text(pDX, IDC_SQL_ACCESSIBLE_PROCEDURES, m_strSqlAccessibleProcedures);
  240.     DDX_Text(pDX, IDC_SQL_ACCESSIBLE_TABLES, m_strSqlAccessibleTables);
  241.     DDX_Text(pDX, IDC_SQL_DATABASE_NAME, m_strSqlDatabaseName);
  242.     //}}AFX_DATA_MAP
  243. }
  244.  
  245. BEGIN_MESSAGE_MAP(CDriverInfo, CPropertyPage)
  246.     //{{AFX_MSG_MAP(CDriverInfo)
  247.     //}}AFX_MSG_MAP
  248. END_MESSAGE_MAP()
  249.  
  250. /////////////////////////////////////////////////////////////////////////////
  251. // CDriverInfo message handlers
  252.  
  253. void CDriverInfo::OnNewDSN()
  254. {
  255.     if (m_pDatabase->IsOpen())
  256.     {
  257.         SWORD   value;
  258.         CString string;
  259.  
  260.         m_strSqlDataSourceName = SQLGetInfoString(SQL_DATA_SOURCE_NAME);
  261.         m_strSqlUserName = SQLGetInfoString(SQL_USER_NAME);
  262.         m_strSqlServerName = SQLGetInfoString(SQL_SERVER_NAME);
  263.         m_strSqlDatabaseName = SQLGetInfoString(SQL_DATABASE_NAME);
  264.         m_strSqlDbmsName = SQLGetInfoString(SQL_DBMS_NAME);
  265.         m_strSqlDbmsVer = SQLGetInfoString(SQL_DBMS_VER);
  266.         m_strSqlDriverName = SQLGetInfoString(SQL_DRIVER_NAME);
  267.         m_strSqlDriverVer = SQLGetInfoString(SQL_DRIVER_VER);
  268.         m_strSqlDriverOdbcVer = SQLGetInfoString(SQL_DRIVER_ODBC_VER);
  269.         m_strSqlOdbcVer = SQLGetInfoString(SQL_ODBC_VER);
  270.         switch (SQLGetInfoShort(SQL_ODBC_API_CONFORMANCE))
  271.         {
  272.         case SQL_OAC_NONE:
  273.             m_strSqlOdbcApiConformance = _T("Core");
  274.             break;
  275.         case SQL_OAC_LEVEL1:
  276.             m_strSqlOdbcApiConformance = _T("Level 1");
  277.             break;
  278.         case SQL_OAC_LEVEL2:
  279.             m_strSqlOdbcApiConformance = _T("Level 2");
  280.             break;
  281.         }
  282.         switch (SQLGetInfoShort(SQL_ODBC_SQL_CONFORMANCE))
  283.         {
  284.         case SQL_OSC_MINIMUM:
  285.             m_strSqlOdbcSqlConformance = _T("Minimum");
  286.             break;
  287.         case SQL_OSC_CORE:
  288.             m_strSqlOdbcSqlConformance = _T("Core");
  289.             break;
  290.         case SQL_OSC_EXTENDED:
  291.             m_strSqlOdbcSqlConformance = _T("Extended");
  292.             break;
  293.         }
  294.         switch (SQLGetInfoShort(SQL_ODBC_SAG_CLI_CONFORMANCE))
  295.         {
  296.         case SQL_OSCC_NOT_COMPLIANT:
  297.             m_strSqlOdbcSagCliConformance = _T("No");
  298.             break;
  299.         case SQL_OSCC_COMPLIANT:
  300.             m_strSqlOdbcSagCliConformance = _T("Yes");
  301.             break;
  302.         }
  303.         YIsSupported(m_strSqlOdbcSqlOptIef,SQL_ODBC_SQL_OPT_IEF);
  304.         if (value = SQLGetInfoShort(SQL_ACTIVE_CONNECTIONS))
  305.             m_strSqlActiveConnections.Format(_T("%d"),value);
  306.         else
  307.             m_strSqlActiveConnections = _T("No Limit");
  308.         if (value = SQLGetInfoShort(SQL_ACTIVE_STATEMENTS))
  309.             m_strSqlActiveStatements.Format(_T("%d"),value);
  310.         else
  311.             m_strSqlActiveStatements = _T("No Limit");
  312.         YIsSupported(m_strSqlMultResultSets,SQL_MULT_RESULT_SETS);
  313.         switch (SQLGetInfoShort(SQL_FILE_USAGE))
  314.         {
  315.         case SQL_FILE_NOT_SUPPORTED:
  316.             m_strSqlFileUsage = _T("<n/a>, Driver not single-tier");
  317.             break;
  318.         case SQL_FILE_TABLE:
  319.             m_strSqlFileUsage = _T("Files are Tables");
  320.             break;
  321.         case SQL_FILE_QUALIFIER:
  322.             m_strSqlFileUsage = _T("Files are Qualifiers");
  323.             break;
  324.         }
  325.  
  326.         string = SQLGetInfoString(SQL_DATA_SOURCE_READ_ONLY);
  327.         if (string == _T("Y"))
  328.             m_strSqlDataSourceReadOnly = _T("Data source is read-only");
  329.         else if (string == _T("N"))
  330.             m_strSqlDataSourceReadOnly = _T("Data source is read-write");
  331.  
  332.         YIsYes(m_strSqlAccessibleProcedures,SQL_ACCESSIBLE_PROCEDURES);
  333.         YIsYes(m_strSqlAccessibleTables,SQL_ACCESSIBLE_TABLES);
  334.  
  335.         if (IsWindow(m_hWnd))
  336.             UpdateData(FALSE);
  337.     }
  338. }
  339.  
  340. BOOL CDriverInfo::OnInitDialog()
  341. {
  342.     CPropertyPage::OnInitDialog();
  343.  
  344.     UpdateData(FALSE);
  345.  
  346.     return TRUE;  // return TRUE unless you set the focus to a control
  347.                   // EXCEPTION: OCX Property Pages should return FALSE
  348. }
  349.  
  350. /////////////////////////////////////////////////////////////////////////////
  351. // CFunctions property page
  352.  
  353. IMPLEMENT_DYNCREATE(CFunctions, CPropertyPage)
  354.  
  355. #define CONVERSIONS_START           0
  356. #define NUM_CONVERSIONS             1
  357.  
  358. #define NUMERIC_START               1
  359. #define NUM_NUMERICS                24
  360.  
  361. #define STRINGS_START               25
  362. #define NUM_STRINGS                 19
  363.  
  364. #define SYSTEMS_START               44
  365. #define NUM_SYSTEMS                 3
  366.  
  367. #define TIMEDATES_START             47
  368. #define NUM_TIMEDATES               17
  369.  
  370. SDWORD  CFunctions::m_dwConversionsMasks[] =
  371. {
  372.     SQL_FN_CVT_CONVERT
  373. };
  374.  
  375. SDWORD  CFunctions::m_dwNumericMasks[] =
  376. {
  377.     SQL_FN_NUM_ABS,
  378.     SQL_FN_NUM_ACOS,
  379.     SQL_FN_NUM_ASIN,
  380.     SQL_FN_NUM_ATAN,
  381.     SQL_FN_NUM_ATAN2,
  382.     SQL_FN_NUM_CEILING,
  383.     SQL_FN_NUM_COS,
  384.     SQL_FN_NUM_COT,
  385.     SQL_FN_NUM_DEGREES,
  386.     SQL_FN_NUM_EXP,
  387.     SQL_FN_NUM_FLOOR,
  388.     SQL_FN_NUM_LOG,
  389.     SQL_FN_NUM_LOG10,
  390.     SQL_FN_NUM_MOD,
  391.     SQL_FN_NUM_PI,
  392.     SQL_FN_NUM_POWER,
  393.     SQL_FN_NUM_RADIANS,
  394.     SQL_FN_NUM_RAND,
  395.     SQL_FN_NUM_ROUND,
  396.     SQL_FN_NUM_SIGN,
  397.     SQL_FN_NUM_SIN,
  398.     SQL_FN_NUM_SQRT,
  399.     SQL_FN_NUM_TAN,
  400.     SQL_FN_NUM_TRUNCATE
  401. };
  402.  
  403. SDWORD  CFunctions::m_dwStringsMasks[] =
  404. {
  405.     SQL_FN_STR_ASCII,
  406.     SQL_FN_STR_CHAR,
  407.     SQL_FN_STR_CONCAT,
  408.     SQL_FN_STR_DIFFERENCE,
  409.     SQL_FN_STR_INSERT,
  410.     SQL_FN_STR_LCASE,
  411.     SQL_FN_STR_LEFT,
  412.     SQL_FN_STR_LENGTH,
  413.     SQL_FN_STR_LOCATE,
  414.     SQL_FN_STR_LOCATE_2,
  415.     SQL_FN_STR_LTRIM,
  416.     SQL_FN_STR_REPEAT,
  417.     SQL_FN_STR_REPLACE,
  418.     SQL_FN_STR_RIGHT,
  419.     SQL_FN_STR_RTRIM,
  420.     SQL_FN_STR_SOUNDEX,
  421.     SQL_FN_STR_SPACE,
  422.     SQL_FN_STR_SUBSTRING,
  423.     SQL_FN_STR_UCASE
  424. };
  425.  
  426. SDWORD  CFunctions::m_dwSystemsMasks[] =
  427. {
  428.     SQL_FN_SYS_DBNAME,
  429.     SQL_FN_SYS_IFNULL,
  430.     SQL_FN_SYS_USERNAME,
  431. };
  432.  
  433. SDWORD  CFunctions::m_dwTimeDatesMasks[] =
  434. {
  435.     SQL_FN_TD_CURDATE,
  436.     SQL_FN_TD_CURTIME,
  437.     SQL_FN_TD_DAYNAME,
  438.     SQL_FN_TD_DAYOFMONTH,
  439.     SQL_FN_TD_DAYOFWEEK,
  440.     SQL_FN_TD_DAYOFYEAR,
  441.     SQL_FN_TD_HOUR,
  442.     SQL_FN_TD_MINUTE,
  443.     SQL_FN_TD_MONTH,
  444.     SQL_FN_TD_MONTHNAME,
  445.     SQL_FN_TD_NOW,
  446.     SQL_FN_TD_QUARTER,
  447.     SQL_FN_TD_SECOND,
  448.     SQL_FN_TD_TIMESTAMPADD,
  449.     SQL_FN_TD_TIMESTAMPDIFF,
  450.     SQL_FN_TD_WEEK,
  451.     SQL_FN_TD_YEAR,
  452. };
  453.  
  454. char*   CFunctions::m_szSqlFunctions[] =
  455. {
  456.     _T("Convert()"),    // conversion
  457.     _T("Abs()"),        // numeric
  458.     _T("Acos()"),
  459.     _T("Asin()"),
  460.     _T("Atan()"),
  461.     _T("Atan2()"),
  462.     _T("Ceiling()"),
  463.     _T("Cos()"),
  464.     _T("Cot()"),
  465.     _T("Degrees()"),
  466.     _T("Exp()"),
  467.     _T("Floor()"),
  468.     _T("Log()"),
  469.     _T("Log10()"),
  470.     _T("Mod()"),
  471.     _T("Pi()"),
  472.     _T("Power()"),
  473.     _T("Radians()"),
  474.     _T("Rand()"),
  475.     _T("Round()"),
  476.     _T("Sign()"),
  477.     _T("Sin()"),
  478.     _T("Sqrt()"),
  479.     _T("Tan()"),
  480.     _T("Truncate()"),
  481.     _T("Ascii()"),
  482.     _T("Char()"),
  483.     _T("Concat()"),
  484.     _T("Difference()"),
  485.     _T("Insert()"),
  486.     _T("LCase()"),
  487.     _T("Left()"),
  488.     _T("Lenght()"),
  489.     _T("Locate()"),
  490.     _T("Locate2()"),
  491.     _T("LTrim()"),
  492.     _T("Repeat()"),
  493.     _T("Replace()"),
  494.     _T("Right()"),
  495.     _T("RTrim()"),
  496.     _T("Soundex()"),
  497.     _T("Space()"),
  498.     _T("Substring()"),
  499.     _T("UCase()"),
  500.     _T("DBName()"),
  501.     _T("IfNull()"),
  502.     _T("UserName()"),
  503.     _T("CurDate()"),
  504.     _T("CurTime()"),
  505.     _T("DayName()"),
  506.     _T("DayOfMonth()"),
  507.     _T("DayOfWeek()"),
  508.     _T("DayOfYear()"),
  509.     _T("Hour()"),
  510.     _T("Minute()"),
  511.     _T("Month()"),
  512.     _T("MonthName()"),
  513.     _T("Now()"),
  514.     _T("Quarter()"),
  515.     _T("Second()"),
  516.     _T("TimeStampAdd()"),
  517.     _T("TimeStampDiff()"),
  518.     _T("Week()"),
  519.     _T("Year()")
  520. };
  521.  
  522. char* CFunctions::m_szSqlCategories[] =
  523. {
  524.     _T("Conversion"),
  525.     _T("Numeric"),
  526.     _T("Numeric"),
  527.     _T("Numeric"),
  528.     _T("Numeric"),
  529.     _T("Numeric"),
  530.     _T("Numeric"),
  531.     _T("Numeric"),
  532.     _T("Numeric"),
  533.     _T("Numeric"),
  534.     _T("Numeric"),
  535.     _T("Numeric"),
  536.     _T("Numeric"),
  537.     _T("Numeric"),
  538.     _T("Numeric"),
  539.     _T("Numeric"),
  540.     _T("Numeric"),
  541.     _T("Numeric"),
  542.     _T("Numeric"),
  543.     _T("Numeric"),
  544.     _T("Numeric"),
  545.     _T("Numeric"),
  546.     _T("Numeric"),
  547.     _T("Numeric"),
  548.     _T("Numeric"),
  549.     _T("String"),
  550.     _T("String"),
  551.     _T("String"),
  552.     _T("String"),
  553.     _T("String"),
  554.     _T("String"),
  555.     _T("String"),
  556.     _T("String"),
  557.     _T("String"),
  558.     _T("String"),
  559.     _T("String"),
  560.     _T("String"),
  561.     _T("String"),
  562.     _T("String"),
  563.     _T("String"),
  564.     _T("String"),
  565.     _T("String"),
  566.     _T("String"),
  567.     _T("String"),
  568.     _T("System"),
  569.     _T("System"),
  570.     _T("System"),
  571.     _T("TimeDate"),
  572.     _T("TimeDate"),
  573.     _T("TimeDate"),
  574.     _T("TimeDate"),
  575.     _T("TimeDate"),
  576.     _T("TimeDate"),
  577.     _T("TimeDate"),
  578.     _T("TimeDate"),
  579.     _T("TimeDate"),
  580.     _T("TimeDate"),
  581.     _T("TimeDate"),
  582.     _T("TimeDate"),
  583.     _T("TimeDate"),
  584.     _T("TimeDate"),
  585.     _T("TimeDate"),
  586.     _T("TimeDate"),
  587.     _T("TimeDate")
  588. };
  589.  
  590. char* CFunctions::m_szFunctions[] =
  591. {
  592.     _T("SQLAllocConnect"),
  593.     _T("SQLAllocEnv"),
  594.     _T("SQLAllocStmt"),
  595.     _T("SQLBindCol"),
  596.     _T("SQLCancel"),
  597.     _T("SQLColAttributes"),
  598.     _T("SQLConnect"),
  599.     _T("SQLDescribeCol"),
  600.     _T("SQLDisconnect"),
  601.     _T("SQLError"),
  602.     _T("SQLExecDirect"),
  603.     _T("SQLExecute"),
  604.     _T("SQLFetch"),
  605.     _T("SQLFreeConnect"),
  606.     _T("SQLFreeEnv"),
  607.     _T("SQLFreeStmt"),
  608.     _T("SQLGetCursorName"),
  609.     _T("SQLNumResultCols"),
  610.     _T("SQLPrepare"),
  611.     _T("SQLRowCount"),
  612.     _T("SQLSetCursorName"),
  613.     _T("SQLSetParam"),
  614.     _T("SQLTransact"),
  615.     _T(""),
  616.     _T(""),
  617.     _T(""),
  618.     _T(""),
  619.     _T(""),
  620.     _T(""),
  621.     _T(""),
  622.     _T(""),
  623.     _T(""),
  624.     _T(""),
  625.     _T(""),
  626.     _T(""),
  627.     _T(""),
  628.     _T(""),
  629.     _T(""),
  630.     _T(""),
  631.     _T("SQLColumns"),
  632.     _T("SQLDriverConnect"),
  633.     _T("SQLGetConnectOption"),
  634.     _T("SQLGetData"),
  635.     _T("SQLGetFunctions"),
  636.     _T("SQLGetInfo"),
  637.     _T("SQLGetStmtOption"),
  638.     _T("SQLGetTypeInfo"),
  639.     _T("SQLParamData"),
  640.     _T("SQLPutData"),
  641.     _T("SQLSetConnectOption"),
  642.     _T("SQLSetStmtOption"),
  643.     _T("SQLSpecialColumns"),
  644.     _T("SQLStatistics"),
  645.     _T("SQLTables"),
  646.     _T("SQLBrowseConnect"),
  647.     _T("SQLColumnPrivileges"),
  648.     _T("SQLDataSources"),
  649.     _T("SQLDescribeParam"),
  650.     _T("SQLExtendedFetch"),
  651.     _T("SQLForeignKeys"),
  652.     _T("SQLMoreResults"),
  653.     _T("SQLNativeSql"),
  654.     _T("SQLNumParams"),
  655.     _T("SQLParamOptions"),
  656.     _T("SQLPrimaryKeys"),
  657.     _T("SQLProcedureColumns"),
  658.     _T("SQLProcedures"),
  659.     _T("SQLSetPos"),
  660.     _T("SQLSetScrollOptions"),
  661.     _T("SQLTablePrivileges"),
  662.     _T("SQLDrivers"),
  663.     _T("SQLBindParameter")
  664.     _T(""),
  665.     _T(""),
  666.     _T(""),
  667.     _T(""),
  668.     _T(""),
  669.     _T(""),
  670.     _T(""),
  671.     _T(""),
  672.     _T(""),
  673.     _T(""),
  674.     _T(""),
  675.     _T(""),
  676.     _T(""),
  677.     _T(""),
  678.     _T(""),
  679.     _T(""),
  680.     _T(""),
  681.     _T(""),
  682.     _T(""),
  683.     _T(""),
  684.     _T(""),
  685.     _T(""),
  686.     _T(""),
  687.     _T(""),
  688.     _T(""),
  689.     _T(""),
  690.     _T(""),
  691.     _T(""),
  692. };
  693.  
  694. CFunctions::CFunctions(CDatabase* pDatabase)
  695.  : CMyPage(pDatabase, CFunctions::IDD)
  696. {
  697.     //{{AFX_DATA_INIT(CFunctions)
  698.     //}}AFX_DATA_INIT
  699. }
  700.  
  701. CFunctions::~CFunctions()
  702. {
  703. }
  704.  
  705. void CFunctions::DumpToFile(CStdioFile& file)
  706. {
  707.     if (m_pDatabase->IsOpen())
  708.     {
  709.         int     i,j;
  710.         CString string;
  711.         CString padString;
  712.         UWORD   aFunctions[100];
  713.         SDWORD  value;
  714.  
  715.         file.WriteString(_T("ODBC API Functions\n------------------\n"));
  716.         ::SQLGetFunctions(m_pDatabase->m_hdbc,
  717.                 SQL_API_ALL_FUNCTIONS,aFunctions);
  718.         for (i = 0; i < SQL_NUM_FUNCTIONS; i++)
  719.         {
  720.             if (aFunctions[i + 1])
  721.                 string.Format(_T("%s - Supported\n"),m_szFunctions[i]);
  722.             else
  723.                 string.Format(_T("%s - Not Supported\n"),m_szFunctions[i]);
  724.             padString = _T("");
  725.             int nLimit = 21 - lstrlen(m_szFunctions[i]) / sizeof(TCHAR);
  726.             if (nLimit > 0)
  727.             {
  728.                 for (j = 0; j < nLimit; j++)
  729.                     padString += ' ';
  730.                 file.WriteString(padString);
  731.             }
  732.             file.WriteString(string);
  733.         }
  734.         for (i = 0; i < SQL_EXT_API_LAST - SQL_EXT_API_START + 1; i++)
  735.         {
  736.             if (aFunctions[i + SQL_EXT_API_START])
  737.                 string.Format(_T("%s - Supported\n"),m_szFunctions[i + SQL_EXT_API_START - 1]);
  738.             else
  739.                 string.Format(_T("%s - Not Supported\n"),m_szFunctions[i + SQL_EXT_API_START - 1]);
  740.             padString = _T("");
  741.             int nLimit = 21 - lstrlen(m_szFunctions[i + SQL_EXT_API_START - 1]) / sizeof(TCHAR);
  742.             if (nLimit > 0)
  743.             {
  744.                 for (j = 0; j < nLimit; j++)
  745.                     padString += ' ';
  746.                 file.WriteString(padString);
  747.             }
  748.             file.WriteString(string);
  749.         }
  750.         file.WriteString(_T("\n"));
  751.  
  752.         file.WriteString(_T("SQL Conversion Functions\n------------------------\n"));
  753.         value = SQLGetInfoLong(SQL_CONVERT_FUNCTIONS);
  754.         for (i = 0; i < NUM_CONVERSIONS; i++)
  755.         {
  756.             if (value & m_dwConversionsMasks[i])
  757.                 string.Format(_T("%s - Supported\n"),m_szSqlFunctions[CONVERSIONS_START + i]);
  758.             else
  759.                 string.Format(_T("%s - Not Supported\n"),m_szSqlFunctions[CONVERSIONS_START + i]);
  760.             padString = _T("");
  761.             int nLimit = 21 - lstrlen(m_szSqlFunctions[CONVERSIONS_START + i]) / sizeof(TCHAR);
  762.             if (nLimit > 0)
  763.             {
  764.                 for (j = 0; j < nLimit; j++)
  765.                     padString += ' ';
  766.                 file.WriteString(padString);
  767.             }
  768.             file.WriteString(string);
  769.         }
  770.         file.WriteString(_T("\n"));
  771.  
  772.         file.WriteString(_T("SQL Numeric Functions\n---------------------\n"));
  773.         value = SQLGetInfoLong(SQL_NUMERIC_FUNCTIONS);
  774.         for (i = 0; i < NUM_NUMERICS; i++)
  775.         {
  776.             if (value & m_dwNumericMasks[i])
  777.                 string.Format(_T("%s - Supported\n"),m_szSqlFunctions[NUMERIC_START + i]);
  778.             else
  779.                 string.Format(_T("%s - Not Supported\n"),m_szSqlFunctions[NUMERIC_START + i]);
  780.             padString = _T("");
  781.             int nLimit = 21 - lstrlen(m_szSqlFunctions[NUMERIC_START + i]) / sizeof(TCHAR);
  782.             if (nLimit > 0)
  783.             {
  784.                 for (j = 0; j < nLimit; j++)
  785.                     padString += ' ';
  786.                 file.WriteString(padString);
  787.             }
  788.             file.WriteString(string);
  789.         }
  790.         file.WriteString(_T("\n"));
  791.  
  792.         file.WriteString(_T("SQL String Functions\n--------------------\n"));
  793.         value = SQLGetInfoLong(SQL_STRING_FUNCTIONS);
  794.         for (i = 0; i < NUM_STRINGS; i++)
  795.         {
  796.             if (value & m_dwStringsMasks[i])
  797.                 string.Format(_T("%s - Supported\n"),m_szSqlFunctions[STRINGS_START + i]);
  798.             else
  799.                 string.Format(_T("%s - Not Supported\n"),m_szSqlFunctions[STRINGS_START + i]);
  800.             padString = _T("");
  801.             int nLimit = 21 - lstrlen(m_szSqlFunctions[STRINGS_START + i]) / sizeof(TCHAR);
  802.             if (nLimit > 0)
  803.             {
  804.                 for (j = 0; j < nLimit; j++)
  805.                     padString += ' ';
  806.                 file.WriteString(padString);
  807.             }
  808.             file.WriteString(string);
  809.         }
  810.         file.WriteString(_T("\n"));
  811.  
  812.         file.WriteString(_T("SQL System Functions\n--------------------\n"));
  813.         value = SQLGetInfoLong(SQL_SYSTEM_FUNCTIONS);
  814.         for (i = 0; i < NUM_SYSTEMS; i++)
  815.         {
  816.             if (value & m_dwSystemsMasks[i])
  817.                 string.Format(_T("%s - Supported\n"),m_szSqlFunctions[SYSTEMS_START + i]);
  818.             else
  819.                 string.Format(_T("%s - Not Supported\n"),m_szSqlFunctions[SYSTEMS_START + i]);
  820.             padString = _T("");
  821.             int nLimit = 21 - lstrlen(m_szSqlFunctions[SYSTEMS_START + i]) / sizeof(TCHAR);
  822.             if (nLimit > 0)
  823.             {
  824.                 for (j = 0; j < nLimit; j++)
  825.                     padString += ' ';
  826.                 file.WriteString(padString);
  827.             }
  828.             file.WriteString(string);
  829.         }
  830.         file.WriteString(_T("\n"));
  831.  
  832.         file.WriteString(_T("SQL Time/Date Functions\n-----------------------\n"));
  833.         value = SQLGetInfoLong(SQL_TIMEDATE_FUNCTIONS);
  834.         for (i = 0; i < NUM_TIMEDATES; i++)
  835.         {
  836.             if (value & m_dwTimeDatesMasks[i])
  837.                 string.Format(_T("%s - Supported\n"),m_szSqlFunctions[TIMEDATES_START + i]);
  838.             else
  839.                 string.Format(_T("%s - Not Supported\n"),m_szSqlFunctions[TIMEDATES_START + i]);
  840.             padString = _T("");
  841.             int nLimit = 21 - lstrlen(m_szSqlFunctions[TIMEDATES_START + i]) / sizeof(TCHAR);
  842.             if (nLimit > 0)
  843.             {
  844.                 for (j = 0; j < nLimit; j++)
  845.                     padString += ' ';
  846.                 file.WriteString(padString);
  847.             }
  848.             file.WriteString(string);
  849.         }
  850.         file.WriteString(_T("\n"));
  851.     }
  852. }
  853.  
  854. void CFunctions::DoDataExchange(CDataExchange* pDX)
  855. {
  856.     CPropertyPage::DoDataExchange(pDX);
  857.     //{{AFX_DATA_MAP(CFunctions)
  858.     DDX_Control(pDX, IDC_SQL_FUNCTIONS, m_SqlListControl);
  859.     DDX_Control(pDX, IDC_API_FUNCTIONS, m_ApiListControl);
  860.     //}}AFX_DATA_MAP
  861. }
  862.  
  863.  
  864. BEGIN_MESSAGE_MAP(CFunctions, CPropertyPage)
  865.     //{{AFX_MSG_MAP(CFunctions)
  866.     //}}AFX_MSG_MAP
  867. END_MESSAGE_MAP()
  868.  
  869. /////////////////////////////////////////////////////////////////////////////
  870. // CFunctions message handlers
  871. void CFunctions::OnNewDSN()
  872. {
  873.     if (::IsWindow(m_hWnd))
  874.     {
  875.         UWORD       aFunctions[100];
  876.         BOOL        bOpen = m_pDatabase->IsOpen();
  877.  
  878.         SDWORD      value;
  879.         int         nNewItem;
  880.  
  881.         m_ApiListControl.DeleteAllItems();
  882.         if (bOpen)
  883.             ::SQLGetFunctions(m_pDatabase->m_hdbc,
  884.                 SQL_API_ALL_FUNCTIONS,aFunctions);
  885.         for (int i = 0; i < SQL_NUM_FUNCTIONS; i++)
  886.         {
  887.             if (bOpen && aFunctions[i + 1])
  888.                 m_ApiListControl.InsertItem(i,m_szFunctions[i],1);
  889.             else
  890.                 m_ApiListControl.InsertItem(i,m_szFunctions[i],0);
  891.         }
  892.  
  893.         for (i = 0; i < SQL_EXT_API_LAST - SQL_EXT_API_START + 1; i++)
  894.         {
  895.             if (bOpen && aFunctions[i+SQL_EXT_API_START])
  896.                 m_ApiListControl.InsertItem(i+SQL_NUM_FUNCTIONS,
  897.                     m_szFunctions[i+SQL_EXT_API_START-1],1);
  898.             else
  899.                 m_ApiListControl.InsertItem(i+SQL_NUM_FUNCTIONS,
  900.                     m_szFunctions[i+SQL_EXT_API_START-1],0);
  901.         }
  902.  
  903.         m_SqlListControl.DeleteAllItems();
  904.  
  905.         // conversion function
  906.         if (bOpen)
  907.             value = SQLGetInfoLong(SQL_CONVERT_FUNCTIONS);
  908.         for (i = 0; i < NUM_CONVERSIONS; i++)
  909.         {
  910.             if (bOpen && (value & m_dwConversionsMasks[i]))
  911.                 nNewItem = m_SqlListControl.InsertItem(CONVERSIONS_START + i,
  912.                     m_szSqlFunctions[CONVERSIONS_START + i],1);
  913.             else
  914.                 nNewItem = m_SqlListControl.InsertItem(CONVERSIONS_START + i,
  915.                     m_szSqlFunctions[CONVERSIONS_START + i],0);
  916.             m_SqlListControl.SetItem(nNewItem,1,LVIF_TEXT,
  917.                 m_szSqlCategories[CONVERSIONS_START + i],0,0,0,0);
  918.         }
  919.  
  920.         // numeric functions
  921.         if (bOpen)
  922.             value = SQLGetInfoLong(SQL_NUMERIC_FUNCTIONS);
  923.         for (i = 0; i < NUM_NUMERICS; i++)
  924.         {
  925.             if (bOpen && (value & m_dwNumericMasks[i]))
  926.                 nNewItem = m_SqlListControl.InsertItem(NUMERIC_START + i,
  927.                     m_szSqlFunctions[NUMERIC_START + i],1);
  928.             else
  929.                 nNewItem = m_SqlListControl.InsertItem(NUMERIC_START + i,
  930.                     m_szSqlFunctions[NUMERIC_START + i],0);
  931.             m_SqlListControl.SetItem(nNewItem,1,LVIF_TEXT,
  932.                 m_szSqlCategories[NUMERIC_START + i],0,0,0,0);
  933.         }
  934.  
  935.         // string functions
  936.         if (bOpen)
  937.             value = SQLGetInfoLong(SQL_STRING_FUNCTIONS);
  938.         for (i = 0; i < NUM_STRINGS; i++)
  939.         {
  940.             if (bOpen && (value & m_dwStringsMasks[i]))
  941.                 nNewItem = m_SqlListControl.InsertItem(STRINGS_START + i,
  942.                     m_szSqlFunctions[STRINGS_START + i],1);
  943.             else
  944.                 nNewItem = m_SqlListControl.InsertItem(STRINGS_START + i,
  945.                     m_szSqlFunctions[STRINGS_START + i],0);
  946.             m_SqlListControl.SetItem(nNewItem,1,LVIF_TEXT,
  947.                 m_szSqlCategories[STRINGS_START + i],0,0,0,0);
  948.         }
  949.  
  950.         // system functions
  951.         if (bOpen)
  952.             value = SQLGetInfoLong(SQL_SYSTEM_FUNCTIONS);
  953.         for (i = 0; i < NUM_SYSTEMS; i++)
  954.         {
  955.             if (bOpen && (value & m_dwSystemsMasks[i]))
  956.                 nNewItem = m_SqlListControl.InsertItem(SYSTEMS_START + i,
  957.                     m_szSqlFunctions[SYSTEMS_START + i],1);
  958.             else
  959.                 nNewItem = m_SqlListControl.InsertItem(SYSTEMS_START + i,
  960.                     m_szSqlFunctions[SYSTEMS_START + i],0);
  961.             m_SqlListControl.SetItem(nNewItem,1,LVIF_TEXT,
  962.                 m_szSqlCategories[SYSTEMS_START + i],0,0,0,0);
  963.         }
  964.  
  965.         // timedate functions
  966.         if (bOpen)
  967.             value = SQLGetInfoLong(SQL_TIMEDATE_FUNCTIONS);
  968.         for (i = 0; i < NUM_TIMEDATES; i++)
  969.         {
  970.             if (bOpen && (value & m_dwTimeDatesMasks[i]))
  971.                 nNewItem = m_SqlListControl.InsertItem(TIMEDATES_START + i,
  972.                     m_szSqlFunctions[TIMEDATES_START + i],1);
  973.             else
  974.                 nNewItem = m_SqlListControl.InsertItem(TIMEDATES_START + i,
  975.                     m_szSqlFunctions[TIMEDATES_START + i],0);
  976.             m_SqlListControl.SetItem(nNewItem,1,LVIF_TEXT,
  977.                 m_szSqlCategories[TIMEDATES_START + i],0,0,0,0);
  978.         }
  979.     }
  980. }
  981.  
  982. BOOL CFunctions::OnInitDialog()
  983. {
  984.     CPropertyPage::OnInitDialog();
  985.  
  986.     m_ApiListControl.SetImageList(m_pImageList,LVSIL_SMALL);
  987.     m_SqlListControl.SetImageList(m_pImageList,LVSIL_SMALL);
  988.  
  989.     m_ApiListControl.InsertColumn(0,"",LVCFMT_LEFT,130);
  990.     m_SqlListControl.InsertColumn(0,"Function",LVCFMT_LEFT,120);
  991.     m_SqlListControl.InsertColumn(1,"Category",LVCFMT_LEFT,120);
  992.  
  993.     OnNewDSN();
  994.  
  995.     return TRUE;  // return TRUE unless you set the focus to a control
  996.                   // EXCEPTION: OCX Property Pages should return FALSE
  997. }
  998.  
  999. /////////////////////////////////////////////////////////////////////////////
  1000. // CSupportedSQL property page
  1001.  
  1002. IMPLEMENT_DYNCREATE(CSupportedSQL, CPropertyPage)
  1003.  
  1004. CSupportedSQL::CSupportedSQL(CDatabase* pDatabase)
  1005.  : CMyPage(pDatabase,CSupportedSQL::IDD)
  1006. {
  1007.     //{{AFX_DATA_INIT(CSupportedSQL)
  1008.     m_bSqlAlterTableAdd = FALSE;
  1009.     m_bSqlAlterTableDrop = FALSE;
  1010.     m_strSqlExpressionsInOrderby = _T("");
  1011.     m_strSqlGroupBy = _T("");
  1012.     m_strSqlOrderByColumnsInSelect = _T("");
  1013.     m_strSqlOuterJoins = _T("");
  1014.     m_bSqlSqComparison = FALSE;
  1015.     m_bSqlSqCorrelatedSubqueries = FALSE;
  1016.     m_bSqlSqExists = FALSE;
  1017.     m_bSqlSqIn = FALSE;
  1018.     m_bSqlSqQuantified = FALSE;
  1019.     m_bSqlUUnion = FALSE;
  1020.     m_bSqlUUnionAll = FALSE;
  1021.     m_strSqlColumnAlias = _T("");
  1022.     m_strSqlLikeEscapeClause = _T("");
  1023.     m_bSqlPsPositionedDelete = FALSE;
  1024.     m_bSqlPsPositionedUpdate = FALSE;
  1025.     m_bSqlPsSelectForUpdate = FALSE;
  1026.     m_strSqlCorrelationName = _T("");
  1027.     //}}AFX_DATA_INIT
  1028.  
  1029.     OnNewDSN();
  1030. }
  1031.  
  1032. CSupportedSQL::~CSupportedSQL()
  1033. {
  1034. }
  1035.  
  1036. void CSupportedSQL::DumpToFile(CStdioFile& file)
  1037. {
  1038.     if (m_pDatabase->IsOpen())
  1039.     {
  1040.         BOOL    b;
  1041.         CString string;
  1042.  
  1043.         file.WriteString(_T("Supported SQL\n-------------\n"));
  1044.         b = FALSE;
  1045.         file.WriteString(_T("  ALTER TABLE Support -"));
  1046.         if (m_bSqlAlterTableAdd)
  1047.         {
  1048.             file.WriteString(_T("ADD"));
  1049.             b = TRUE;
  1050.         }
  1051.         if (m_bSqlAlterTableDrop)
  1052.         {
  1053.             if (b)
  1054.                 file.WriteString(_T(","));
  1055.             file.WriteString(_T("DROP"));
  1056.             b = TRUE;
  1057.         }
  1058.         if (!b)
  1059.             file.WriteString(_T(" <none>"));
  1060.         file.WriteString(_T("\n"));
  1061.         string.Format(_T("       Column Aliases - %s\n"),m_strSqlColumnAlias);
  1062.         file.WriteString(string);
  1063.         string.Format(_T("    Correlation Names - %s\n"),m_strSqlCorrelationName);
  1064.         file.WriteString(string);
  1065.         string.Format(_T(" ORDER BY Expressions - %s\n"),m_strSqlExpressionsInOrderby);
  1066.         file.WriteString(string);
  1067.         string.Format(_T("GROUP BY NonAggregate - %s\n"),m_strSqlGroupBy);
  1068.         file.WriteString(string);
  1069.         string.Format(_T("LIKE Escape Character - %s\n"),m_strSqlLikeEscapeClause);
  1070.         file.WriteString(string);
  1071.         string.Format(_T("   ORDER BY in SELECT - %s\n"),m_strSqlOrderByColumnsInSelect);
  1072.         file.WriteString(string);
  1073.         string.Format(_T("   Outer Join Support - %s\n"),m_strSqlOuterJoins);
  1074.         file.WriteString(string);
  1075.  
  1076.         file.WriteString(_T("Positioned Statements -"));
  1077.         b = FALSE;
  1078.         if (m_bSqlPsPositionedDelete)
  1079.         {
  1080.             file.WriteString(_T("Delete"));
  1081.             b = TRUE;
  1082.         }
  1083.         if (m_bSqlPsPositionedUpdate)
  1084.         {
  1085.             if (b)
  1086.                 file.WriteString(_T(","));
  1087.             file.WriteString(_T("Update"));
  1088.             b = TRUE;
  1089.         }
  1090.         if (m_bSqlPsSelectForUpdate)
  1091.         {
  1092.             if (b)
  1093.                 file.WriteString(_T(","));
  1094.             file.WriteString(_T("Select for Update"));
  1095.             b = TRUE;
  1096.         }
  1097.         if (!b)
  1098.             file.WriteString(_T("<none>"));
  1099.         file.WriteString(_T("\n"));
  1100.  
  1101.         file.WriteString(_T("     Subquery Support -"));
  1102.         b = FALSE;
  1103.         if (m_bSqlSqCorrelatedSubqueries)
  1104.         {
  1105.             file.WriteString(_T("Correlated"));
  1106.             b = TRUE;
  1107.         }
  1108.         if (m_bSqlSqComparison)
  1109.         {
  1110.             if (b)
  1111.                 file.WriteString(_T(","));
  1112.             file.WriteString(_T("Comparison"));
  1113.             b = TRUE;
  1114.         }
  1115.         if (m_bSqlSqExists)
  1116.         {
  1117.             if (b)
  1118.                 file.WriteString(_T(","));
  1119.             file.WriteString(_T("EXISTS"));
  1120.             b = TRUE;
  1121.         }
  1122.         if (m_bSqlSqIn)
  1123.         {
  1124.             if (b)
  1125.                 file.WriteString(_T(","));
  1126.             file.WriteString(_T("IN"));
  1127.             b = TRUE;
  1128.         }
  1129.         if (m_bSqlSqQuantified)
  1130.         {
  1131.             if (b)
  1132.                 file.WriteString(_T(","));
  1133.             file.WriteString(_T("Quantified"));
  1134.             b = TRUE;
  1135.         }
  1136.         if (!b)
  1137.             file.WriteString(_T("<none>"));
  1138.         file.WriteString(_T("\n"));
  1139.  
  1140.         file.WriteString(_T("        UNION Support -"));
  1141.         b = FALSE;
  1142.         if (m_bSqlUUnion)
  1143.         {
  1144.             file.WriteString(_T("UNION"));
  1145.             b = TRUE;
  1146.         }
  1147.         if (m_bSqlUUnionAll)
  1148.         {
  1149.             if (b)
  1150.                 file.WriteString(_T(","));
  1151.             file.WriteString(_T("UNION with ALL"));
  1152.             b = TRUE;
  1153.         }
  1154.         if (!b)
  1155.             file.WriteString(_T("<none>"));
  1156.         file.WriteString(_T("\n\n"));
  1157.     }
  1158. }
  1159.  
  1160. void CSupportedSQL::DoDataExchange(CDataExchange* pDX)
  1161. {
  1162.     CPropertyPage::DoDataExchange(pDX);
  1163.     //{{AFX_DATA_MAP(CSupportedSQL)
  1164.     DDX_Check(pDX, IDC_AT_ADD, m_bSqlAlterTableAdd);
  1165.     DDX_Check(pDX, IDC_AT_DROP, m_bSqlAlterTableDrop);
  1166.     DDX_Text(pDX, IDC_SQL_EXPRESSIONS_IN_ORDERBY, m_strSqlExpressionsInOrderby);
  1167.     DDX_Text(pDX, IDC_SQL_GROUP_BY, m_strSqlGroupBy);
  1168.     DDX_Text(pDX, IDC_SQL_ORDER_BY_COLUMNS_IN_SELECT, m_strSqlOrderByColumnsInSelect);
  1169.     DDX_Text(pDX, IDC_SQL_OUTER_JOINS, m_strSqlOuterJoins);
  1170.     DDX_Check(pDX, IDC_SQL_SQ_COMPARISON, m_bSqlSqComparison);
  1171.     DDX_Check(pDX, IDC_SQL_SQ_CORRELATED_SUBQUERIES, m_bSqlSqCorrelatedSubqueries);
  1172.     DDX_Check(pDX, IDC_SQL_SQ_EXISTS, m_bSqlSqExists);
  1173.     DDX_Check(pDX, IDC_SQL_SQ_IN, m_bSqlSqIn);
  1174.     DDX_Check(pDX, IDC_SQL_SQ_QUANTIFIED, m_bSqlSqQuantified);
  1175.     DDX_Check(pDX, IDC_SQL_U_UNION, m_bSqlUUnion);
  1176.     DDX_Check(pDX, IDC_SQL_U_UNION_ALL, m_bSqlUUnionAll);
  1177.     DDX_Text(pDX, IDC_SQL_COLUMN_ALIAS, m_strSqlColumnAlias);
  1178.     DDX_Text(pDX, IDC_SQL_LIKE_ESCAPE_CLAUSE, m_strSqlLikeEscapeClause);
  1179.     DDX_Check(pDX, IDC_SQL_PS_POSITIONED_DELETE, m_bSqlPsPositionedDelete);
  1180.     DDX_Check(pDX, IDC_SQL_PS_POSITIONED_UPDATE, m_bSqlPsPositionedUpdate);
  1181.     DDX_Check(pDX, IDC_SQL_PS_SELECT_FOR_UPDATE, m_bSqlPsSelectForUpdate);
  1182.     DDX_Text(pDX, IDC_SQL_CORRELATION_NAME, m_strSqlCorrelationName);
  1183.     //}}AFX_DATA_MAP
  1184. }
  1185.  
  1186.  
  1187. BEGIN_MESSAGE_MAP(CSupportedSQL, CPropertyPage)
  1188.     //{{AFX_MSG_MAP(CSupportedSQL)
  1189.     //}}AFX_MSG_MAP
  1190. END_MESSAGE_MAP()
  1191.  
  1192. /////////////////////////////////////////////////////////////////////////////
  1193. // CSupportedSQL message handlers
  1194.  
  1195. void CSupportedSQL::OnNewDSN()
  1196. {
  1197.     if (m_pDatabase->IsOpen())
  1198.     {
  1199.         CString string;
  1200.         SDWORD  longValue;
  1201.  
  1202.         longValue = SQLGetInfoLong(SQL_ALTER_TABLE);
  1203.         if (longValue & SQL_AT_ADD_COLUMN)
  1204.             m_bSqlAlterTableAdd = TRUE;
  1205.         else
  1206.             m_bSqlAlterTableAdd = FALSE;
  1207.         if (longValue & SQL_AT_DROP_COLUMN)
  1208.             m_bSqlAlterTableDrop = TRUE;
  1209.         else
  1210.             m_bSqlAlterTableDrop = FALSE;
  1211.         YIsSupported(m_strSqlColumnAlias,SQL_COLUMN_ALIAS);
  1212.         switch (SQLGetInfoShort(SQL_CORRELATION_NAME))
  1213.         {
  1214.         case SQL_CN_NONE:
  1215.             m_strSqlCorrelationName = _T("Not Supported");
  1216.             break;
  1217.         case SQL_CN_DIFFERENT:
  1218.             m_strSqlCorrelationName = _T("Supported, table names must be different");
  1219.             break;
  1220.         case SQL_CN_ANY:
  1221.             m_strSqlCorrelationName = _T("Supported");
  1222.             break;
  1223.         }
  1224.         YIsSupported(m_strSqlExpressionsInOrderby,SQL_EXPRESSIONS_IN_ORDERBY);
  1225.         switch (SQLGetInfoShort(SQL_GROUP_BY))
  1226.         {
  1227.         case SQL_GB_NOT_SUPPORTED:
  1228.             m_strSqlGroupBy = _T("GROUP BY Not Supported");
  1229.             break;
  1230.         case SQL_GB_GROUP_BY_EQUALS_SELECT:
  1231.             m_strSqlGroupBy = _T("GROUP BY Equals SELECT");
  1232.             break;
  1233.         case SQL_GB_GROUP_BY_CONTAINS_SELECT:
  1234.             m_strSqlGroupBy = _T("GROUP BY Contains SELECT");
  1235.             break;
  1236.         case SQL_GB_NO_RELATION:
  1237.             m_strSqlGroupBy = _T("No Relation");
  1238.             break;
  1239.         }
  1240.         YIsSupported(m_strSqlLikeEscapeClause,SQL_LIKE_ESCAPE_CLAUSE);
  1241.         YIsYes(m_strSqlOrderByColumnsInSelect,SQL_ORDER_BY_COLUMNS_IN_SELECT);
  1242.         string = SQLGetInfoString(SQL_OUTER_JOINS);
  1243.         if (string == _T("N"))
  1244.             m_strSqlOuterJoins = _T("No");
  1245.         else if (string == _T("Y"))
  1246.             m_strSqlOuterJoins = _T("Yes");
  1247.         else if (string == _T("P"))
  1248.             m_strSqlOuterJoins = _T("Partial");
  1249.         else if (string == _T("F"))
  1250.             m_strSqlOuterJoins = _T("Full");
  1251.         longValue = SQLGetInfoLong(SQL_POSITIONED_STATEMENTS);
  1252.         if (longValue & SQL_PS_POSITIONED_DELETE)
  1253.             m_bSqlPsPositionedDelete = TRUE;
  1254.         else
  1255.             m_bSqlPsPositionedDelete = FALSE;
  1256.         if (longValue & SQL_PS_POSITIONED_UPDATE)
  1257.             m_bSqlPsPositionedUpdate = TRUE;
  1258.         else
  1259.             m_bSqlPsPositionedUpdate = FALSE;
  1260.         if (longValue & SQL_PS_SELECT_FOR_UPDATE)
  1261.             m_bSqlPsSelectForUpdate = TRUE;
  1262.         else
  1263.             m_bSqlPsSelectForUpdate = FALSE;
  1264.         longValue = SQLGetInfoLong(SQL_SUBQUERIES);
  1265.         if (longValue & SQL_SQ_CORRELATED_SUBQUERIES)
  1266.             m_bSqlSqCorrelatedSubqueries = TRUE;
  1267.         else
  1268.             m_bSqlSqCorrelatedSubqueries = FALSE;
  1269.         if (longValue & SQL_SQ_COMPARISON)
  1270.             m_bSqlSqComparison = TRUE;
  1271.         else
  1272.             m_bSqlSqComparison = FALSE;
  1273.         if (longValue & SQL_SQ_EXISTS)
  1274.             m_bSqlSqExists = TRUE;
  1275.         else
  1276.             m_bSqlSqExists = FALSE;
  1277.         if (longValue & SQL_SQ_IN)
  1278.             m_bSqlSqIn = TRUE;
  1279.         else
  1280.             m_bSqlSqIn = FALSE;
  1281.         if (longValue & SQL_SQ_QUANTIFIED)
  1282.             m_bSqlSqQuantified = TRUE;
  1283.         else
  1284.             m_bSqlSqQuantified = FALSE;
  1285.         longValue = SQLGetInfoLong(SQL_UNION);
  1286.         if (longValue & SQL_U_UNION)
  1287.             m_bSqlUUnion = TRUE;
  1288.         else
  1289.             m_bSqlUUnion = FALSE;
  1290.         if (longValue & SQL_U_UNION_ALL)
  1291.             m_bSqlUUnionAll = TRUE;
  1292.         else
  1293.             m_bSqlUUnionAll = FALSE;
  1294.  
  1295.         if (IsWindow(m_hWnd))
  1296.             UpdateData(FALSE);
  1297.     }
  1298. }
  1299.  
  1300. BOOL CSupportedSQL::OnInitDialog()
  1301. {
  1302.     CPropertyPage::OnInitDialog();
  1303.  
  1304.     UpdateData(FALSE);
  1305.  
  1306.     return TRUE;  // return TRUE unless you set the focus to a control
  1307.                   // EXCEPTION: OCX Property Pages should return FALSE
  1308. }
  1309.  
  1310. /////////////////////////////////////////////////////////////////////////////
  1311. // CDataTypes property page
  1312.  
  1313. IMPLEMENT_DYNCREATE(CDataTypes, CPropertyPage)
  1314.  
  1315. CDataTypes::CDataTypes(CDatabase* pDatabase)
  1316.     : m_pGetTypeInfo(0),CMyPage(pDatabase,CDataTypes::IDD),
  1317.     m_pTypeDataHead(0),m_pTypeDataTail(0)
  1318. {
  1319.     //{{AFX_DATA_INIT(CDataTypes)
  1320.     m_strSqlType = _T("");
  1321.     m_strPrecision = _T("");
  1322.     m_strPrefixSuffix = _T("");
  1323.     m_strCreateParams = _T("");
  1324.     m_strNullable = _T("");
  1325.     m_strCaseSensitive = _T("");
  1326.     m_strSearchable = _T("");
  1327.     m_strMoney = _T("");
  1328.     m_strUnsigned = _T("");
  1329.     m_strAutoIncrement = _T("");
  1330.     m_strMaximumScale = _T("");
  1331.     m_strMinimumScale = _T("");
  1332.     //}}AFX_DATA_INIT
  1333. }
  1334.  
  1335. CDataTypes::~CDataTypes()
  1336. {
  1337.     if (m_pGetTypeInfo)
  1338.     {
  1339.         if (m_pGetTypeInfo->IsOpen())
  1340.             m_pGetTypeInfo->Close();
  1341.         delete m_pGetTypeInfo;
  1342.     }
  1343.  
  1344.     // delete type data list
  1345.     TYPEDATA*   p1 = m_pTypeDataHead;
  1346.     TYPEDATA*   p2;
  1347.     while (p1)
  1348.     {
  1349.         p2 = p1;
  1350.         p1 = p1->pNext;
  1351.         delete p2;
  1352.     }
  1353. }
  1354.  
  1355. void CDataTypes::DumpToFile(CStdioFile& file)
  1356. {
  1357.     if (m_pDatabase->IsOpen())
  1358.     {
  1359.         CString string;
  1360.         CString workString;
  1361.         SDWORD  value;
  1362.  
  1363.         file.WriteString(_T("Data Types\n----------\n\n"));
  1364.         file.WriteString(_T("Native type         SQL Type          Precision   Min Scale  Max Scale\n"));
  1365.         file.WriteString(_T("-----------         --------          ---------   ---------  ---------\n"));
  1366.         if (m_pGetTypeInfo)
  1367.         {
  1368.             if (m_pGetTypeInfo->IsOpen())
  1369.                 m_pGetTypeInfo->Close();
  1370.             delete m_pGetTypeInfo;
  1371.         }
  1372.  
  1373.         m_pGetTypeInfo = new CGetTypeInfo(m_pDatabase);
  1374.         m_pGetTypeInfo->Open();
  1375.  
  1376.         while (!m_pGetTypeInfo->IsEOF())
  1377.         {
  1378.             string = m_pGetTypeInfo->m_strTypeName;
  1379.             while (string.GetLength() < 20)
  1380.                 string += ' ';
  1381.             switch (m_pGetTypeInfo->m_fDataType)
  1382.             {
  1383.             case SQL_BIGINT:
  1384.                 string += _T("SQL_BIGINT        ");
  1385.                 break;
  1386.             case SQL_BINARY:
  1387.                 string += _T("SQL_BINARY        ");
  1388.                 break;
  1389.             case SQL_BIT:
  1390.                 string += _T("SQL_BIT           ");
  1391.                 break;
  1392.             case SQL_CHAR:
  1393.                 string += _T("SQL_CHAR          ");
  1394.                 break;
  1395.             case SQL_DATE:
  1396.                 string += _T("SQL_DATE          ");
  1397.                 break;
  1398.             case SQL_DECIMAL:
  1399.                 string += _T("SQL_DECIMAL       ");
  1400.                 break;
  1401.             case SQL_DOUBLE:
  1402.                 string += _T("SQL_DOUBLE        ");
  1403.                 break;
  1404.             case SQL_FLOAT:
  1405.                 string += _T("SQL_FLOAT         ");
  1406.                 break;
  1407.             case SQL_INTEGER:
  1408.                 string += _T("SQL_INTEGER       ");
  1409.                 break;
  1410.             case SQL_LONGVARBINARY:
  1411.                 string += _T("SQL_LONGVARBINARY ");
  1412.                 break;
  1413.             case SQL_LONGVARCHAR:
  1414.                 string += _T("SQL_LONGVARCHAR   ");
  1415.                 break;
  1416.             case SQL_NUMERIC:
  1417.                 string += _T("SQL_NUMERIC       ");
  1418.                 break;
  1419.             case SQL_REAL:
  1420.                 string += _T("SQL_REAL          ");
  1421.                 break;
  1422.             case SQL_SMALLINT:
  1423.                 string += _T("SQL_SMALLINT      ");
  1424.                 break;
  1425.             case SQL_TIME:
  1426.                 string += _T("SQL_TIME          ");
  1427.                 break;
  1428.             case SQL_TIMESTAMP:
  1429.                 string += _T("SQL_TIMESTAMP     ");
  1430.                 break;
  1431.             case SQL_TINYINT:
  1432.                 string += _T("SQL_TINYINT       ");
  1433.                 break;
  1434.             case SQL_VARBINARY:
  1435.                 string += _T("SQL_VARBINARY     ");
  1436.                 break;
  1437.             case SQL_VARCHAR:
  1438.                 string += _T("SQL_VARCHAR       ");
  1439.                 break;
  1440.             default:
  1441.                 string += _T("<unknown type>    ");
  1442.                 break;
  1443.             }
  1444.             if (m_pGetTypeInfo->IsFieldNull(&(m_pGetTypeInfo->m_nPrecision)))
  1445.                 string += _T("<n/a>       ");
  1446.             else
  1447.             {
  1448.                 workString.Format(_T("%-11d "),m_pGetTypeInfo->m_nPrecision);
  1449.                 string += workString;
  1450.             }
  1451.             if (m_pGetTypeInfo->IsFieldNull(&(m_pGetTypeInfo->m_nMinimumScale)))
  1452.                 string += _T("<n/a>      ");
  1453.             else
  1454.             {
  1455.                 workString.Format(_T("%-5d      "),m_pGetTypeInfo->m_nMinimumScale);
  1456.                 string += workString;
  1457.             }
  1458.             if (m_pGetTypeInfo->IsFieldNull(&(m_pGetTypeInfo->m_nMaximumScale)))
  1459.  
  1460.                 string += _T("<n/a>      \n");
  1461.             else
  1462.             {
  1463.                 workString.Format(_T("%-5d\n"),m_pGetTypeInfo->m_nMaximumScale);
  1464.                 string += workString;
  1465.             }
  1466.  
  1467.             file.WriteString(string);
  1468.  
  1469.             m_pGetTypeInfo->MoveNext();
  1470.         }
  1471.         file.WriteString(_T("\n"));
  1472.         m_pGetTypeInfo->Close();
  1473.         delete m_pGetTypeInfo;
  1474.  
  1475.         file.WriteString(_T("Native type         Nullable  Unsigned  Auto Inc  Money  Case Sensitive\n"));
  1476.         file.WriteString(_T("-----------         --------  --------  --------  -----  --------------\n"));
  1477.         m_pGetTypeInfo = new CGetTypeInfo(m_pDatabase);
  1478.         m_pGetTypeInfo->Open();
  1479.  
  1480.         while (!m_pGetTypeInfo->IsEOF())
  1481.         {
  1482.             string = m_pGetTypeInfo->m_strTypeName;
  1483.             while (string.GetLength() < 20)
  1484.                 string += ' ';
  1485.             switch (m_pGetTypeInfo->m_fNullable)
  1486.             {
  1487.             case SQL_NO_NULLS:
  1488.                 string += _T("No        ");
  1489.                 break;
  1490.             case SQL_NULLABLE:
  1491.                 string += _T("Yes       ");
  1492.                 break;
  1493.             case SQL_NULLABLE_UNKNOWN:
  1494.             default:
  1495.                 string += _T("Unknown   ");
  1496.                 break;
  1497.             }
  1498.  
  1499.             if (m_pGetTypeInfo->IsFieldNull(&(m_pGetTypeInfo->m_fUnsignedAttribute)))
  1500.                 string += _T("<n/a>     ");
  1501.             else if (m_pGetTypeInfo->m_fUnsignedAttribute)
  1502.                 string += _T("Yes       ");
  1503.             else
  1504.                 string += _T("No        ");
  1505.  
  1506.             if (m_pGetTypeInfo->IsFieldNull(&(m_pGetTypeInfo->m_fAutoIncrement)))
  1507.                 string += _T("<n/a>     ");
  1508.             else if (m_pGetTypeInfo->m_fAutoIncrement)
  1509.                 string += _T("Yes       ");
  1510.             else
  1511.                 string += _T("No        ");
  1512.  
  1513.             if (m_pGetTypeInfo->m_bMoney)
  1514.                 string += _T("Yes    ");
  1515.             else
  1516.                 string += _T("No     ");
  1517.  
  1518.             if (m_pGetTypeInfo->m_bCaseSensitive)
  1519.                 string += _T("Yes\n");
  1520.             else
  1521.                 string += _T("No\n");
  1522.  
  1523.             file.WriteString(string);
  1524.  
  1525.             m_pGetTypeInfo->MoveNext();
  1526.         }
  1527.         file.WriteString(_T("\n"));
  1528.         m_pGetTypeInfo->Close();
  1529.         delete m_pGetTypeInfo;
  1530.  
  1531.         file.WriteString(_T("Native type         Lit. Prefix,Suffix  Create Params    Searchable\n"));
  1532.         file.WriteString(_T("-----------         ------------------  -------------    ----------\n"));
  1533.         m_pGetTypeInfo = new CGetTypeInfo(m_pDatabase);
  1534.         m_pGetTypeInfo->Open();
  1535.  
  1536.         while (!m_pGetTypeInfo->IsEOF())
  1537.         {
  1538.             string = m_pGetTypeInfo->m_strTypeName;
  1539.             while (string.GetLength() < 20)
  1540.                 string += ' ';
  1541.  
  1542.             if (m_pGetTypeInfo->IsFieldNull(&(m_pGetTypeInfo->m_strLiteralPrefix)))
  1543.                 workString = _T("<n/a>");
  1544.             else
  1545.                 workString = m_pGetTypeInfo->m_strLiteralPrefix;
  1546.             workString += ',';
  1547.             if (m_pGetTypeInfo->IsFieldNull(&(m_pGetTypeInfo->m_strLiteralSuffix)))
  1548.                 workString += _T("<n/a>");
  1549.             else
  1550.                 workString += m_pGetTypeInfo->m_strLiteralSuffix;
  1551.             while (workString.GetLength() < 20)
  1552.                 workString += ' ';
  1553.             string += workString;
  1554.             if (m_pGetTypeInfo->IsFieldNull(&(m_pGetTypeInfo->m_strCreateParams)))
  1555.                 string += _T("<none>           ");
  1556.             else
  1557.             {
  1558.                 workString = m_pGetTypeInfo->m_strCreateParams;
  1559.                 while (workString.GetLength() < 17)
  1560.                     workString += ' ';
  1561.                 string += workString;
  1562.             }
  1563.             switch (m_pGetTypeInfo->m_fSearchable)
  1564.             {
  1565.             case SQL_UNSEARCHABLE:
  1566.                 string += _T("No\n");
  1567.                 break;
  1568.             case SQL_LIKE_ONLY:
  1569.                 string += _T("Only with LIKE\n");
  1570.                 break;
  1571.             case SQL_ALL_EXCEPT_LIKE:
  1572.                 string += _T("with all except LIKE\n");
  1573.                 break;
  1574.             case SQL_SEARCHABLE:
  1575.                 string += _T("Yes\n");
  1576.                 break;
  1577.             }
  1578.  
  1579.             file.WriteString(string);
  1580.  
  1581.             m_pGetTypeInfo->MoveNext();
  1582.         }
  1583.         file.WriteString(_T("\n"));
  1584.         m_pGetTypeInfo->Close();
  1585.         delete m_pGetTypeInfo;
  1586.  
  1587.         file.WriteString(_T("Native type         Convert() Conversions\n"));
  1588.         file.WriteString(_T("-----------         ---------------------\n"));
  1589.         m_pGetTypeInfo = new CGetTypeInfo(m_pDatabase);
  1590.         m_pGetTypeInfo->Open();
  1591.  
  1592.         while (!m_pGetTypeInfo->IsEOF())
  1593.         {
  1594.             string = m_pGetTypeInfo->m_strTypeName;
  1595.             while (string.GetLength() < 20)
  1596.                 string += ' ';
  1597.  
  1598.             switch (m_pGetTypeInfo->m_fDataType)
  1599.             {
  1600.             case SQL_BIGINT:
  1601.                 value = SQLGetInfoLong(SQL_CONVERT_BIGINT);
  1602.                 break;
  1603.             case SQL_BINARY:
  1604.                 value = SQLGetInfoLong(SQL_CONVERT_BINARY);
  1605.                 break;
  1606.             case SQL_BIT:
  1607.                 value = SQLGetInfoLong(SQL_CONVERT_BIT);
  1608.                 break;
  1609.             case SQL_CHAR:
  1610.                 value = SQLGetInfoLong(SQL_CONVERT_CHAR);
  1611.                 break;
  1612.             case SQL_DATE:
  1613.                 value = SQLGetInfoLong(SQL_CONVERT_DATE);
  1614.                 break;
  1615.             case SQL_DECIMAL:
  1616.                 value = SQLGetInfoLong(SQL_CONVERT_DECIMAL);
  1617.                 break;
  1618.             case SQL_DOUBLE:
  1619.                 value = SQLGetInfoLong(SQL_CONVERT_DOUBLE);
  1620.                 break;
  1621.             case SQL_FLOAT:
  1622.                 value = SQLGetInfoLong(SQL_CONVERT_FLOAT);
  1623.                 break;
  1624.             case SQL_INTEGER:
  1625.                 value = SQLGetInfoLong(SQL_CONVERT_INTEGER);
  1626.                 break;
  1627.             case SQL_LONGVARBINARY:
  1628.                 value = SQLGetInfoLong(SQL_CONVERT_LONGVARBINARY);
  1629.                 break;
  1630.             case SQL_LONGVARCHAR:
  1631.                 value = SQLGetInfoLong(SQL_CONVERT_LONGVARCHAR);
  1632.                 break;
  1633.             case SQL_NUMERIC:
  1634.                 value = SQLGetInfoLong(SQL_CONVERT_NUMERIC);
  1635.                 break;
  1636.             case SQL_REAL:
  1637.                 value = SQLGetInfoLong(SQL_CONVERT_REAL);
  1638.                 break;
  1639.             case SQL_SMALLINT:
  1640.                 value = SQLGetInfoLong(SQL_CONVERT_SMALLINT);
  1641.                 break;
  1642.             case SQL_TIME:
  1643.                 value = SQLGetInfoLong(SQL_CONVERT_TIME);
  1644.                 break;
  1645.             case SQL_TIMESTAMP:
  1646.                 value = SQLGetInfoLong(SQL_CONVERT_TIMESTAMP);
  1647.                 break;
  1648.             case SQL_TINYINT:
  1649.                 value = SQLGetInfoLong(SQL_CONVERT_TINYINT);
  1650.                 break;
  1651.             case SQL_VARBINARY:
  1652.                 value = SQLGetInfoLong(SQL_CONVERT_VARBINARY);
  1653.                 break;
  1654.             case SQL_VARCHAR:
  1655.                 value = SQLGetInfoLong(SQL_CONVERT_VARCHAR);
  1656.                 break;
  1657.             default:
  1658.                 value = 0;
  1659.                 break;
  1660.             }
  1661.             if (!value)
  1662.                 string += _T("<none>");
  1663.             else
  1664.             {
  1665.                 BOOL    b = FALSE;
  1666.                 PrintConversions(b,value,SQL_CVT_BIGINT,string,_T("SQL_BIGINT"),file);
  1667.                 PrintConversions(b,value,SQL_CVT_BINARY,string,_T("SQL_BINARY"),file);
  1668.                 PrintConversions(b,value,SQL_CVT_BIT,string,_T("SQL_BIT"),file);
  1669.                 PrintConversions(b,value,SQL_CVT_CHAR,string,_T("SQL_CHAR"),file);
  1670.                 PrintConversions(b,value,SQL_CVT_DATE,string,_T("SQL_DATE"),file);
  1671.                 PrintConversions(b,value,SQL_CVT_DECIMAL,string,_T("SQL_DECIMAL"),file);
  1672.                 PrintConversions(b,value,SQL_CVT_DOUBLE,string,_T("SQL_DOUBLE"),file);
  1673.                 PrintConversions(b,value,SQL_CVT_FLOAT,string,_T("SQL_FLOAT"),file);
  1674.                 PrintConversions(b,value,SQL_CVT_INTEGER,string,_T("SQL_INTEGER"),file);
  1675.                 PrintConversions(b,value,SQL_CVT_LONGVARBINARY,string,_T("SQL_LONGVARBINARY"),file);
  1676.                 PrintConversions(b,value,SQL_CVT_LONGVARCHAR,string,_T("SQL_LONGVARCHAR"),file);
  1677.                 PrintConversions(b,value,SQL_CVT_NUMERIC,string,_T("SQL_NUMERIC"),file);
  1678.                 PrintConversions(b,value,SQL_CVT_REAL,string,_T("SQL_REAL"),file);
  1679.                 PrintConversions(b,value,SQL_CVT_SMALLINT,string,_T("SQL_SMALLINT"),file);
  1680.                 PrintConversions(b,value,SQL_CVT_TIME,string,_T("SQL_TIME"),file);
  1681.                 PrintConversions(b,value,SQL_CVT_TIMESTAMP,string,_T("SQL_TIMESTAMP"),file);
  1682.                 PrintConversions(b,value,SQL_CVT_TINYINT,string,_T("SQL_TINYINT"),file);
  1683.                 PrintConversions(b,value,SQL_CVT_VARBINARY,string,_T("SQL_VARBINARY"),file);
  1684.                 PrintConversions(b,value,SQL_CVT_VARCHAR,string,_T("SQL_VARCHAR"),file);
  1685.             }
  1686.             string += _T("\n\n");
  1687.  
  1688.             file.WriteString(string);
  1689.  
  1690.             m_pGetTypeInfo->MoveNext();
  1691.         }
  1692.         file.WriteString(_T("\n"));
  1693.         m_pGetTypeInfo->Close();
  1694.  
  1695.         delete m_pGetTypeInfo;
  1696.         m_pGetTypeInfo = 0;
  1697.         file.WriteString(_T("\n"));
  1698.  
  1699.     }
  1700. }
  1701.  
  1702. void CDataTypes::PrintConversions(BOOL& flag,SDWORD value,SDWORD mask,
  1703.                       CString& string,const CString& strType,CStdioFile& file)
  1704. {
  1705.     CString workString;
  1706.     if (value & mask)
  1707.     {
  1708.         if (string.GetLength() + strType.GetLength() > 75)
  1709.         {
  1710.             string += _T("\n");
  1711.             file.WriteString(string);
  1712.             string = _T("                    ") + strType;
  1713.         }
  1714.         else
  1715.         {
  1716.             if (flag)
  1717.                 string += _T(",");
  1718.             string += strType;
  1719.         }
  1720.         flag = TRUE;
  1721.     }
  1722. }
  1723.  
  1724. void CDataTypes::DoDataExchange(CDataExchange* pDX)
  1725. {
  1726.     CPropertyPage::DoDataExchange(pDX);
  1727.     //{{AFX_DATA_MAP(CDataTypes)
  1728.     DDX_Control(pDX, IDC_CONVERSIONS, m_lbConversions);
  1729.     DDX_Control(pDX, IDC_DATA_TYPE_LIST, m_lbDataTypes);
  1730.     DDX_Text(pDX, IDC_SQL_TYPE, m_strSqlType);
  1731.     DDX_Text(pDX, IDC_PRECISION, m_strPrecision);
  1732.     DDX_Text(pDX, IDD_PREFIX_SUFFIX, m_strPrefixSuffix);
  1733.     DDX_Text(pDX, IDD_CREATE_PARAMS, m_strCreateParams);
  1734.     DDX_Text(pDX, IDC_NULLABLE, m_strNullable);
  1735.     DDX_Text(pDX, IDC_CASE_SENSITIVE, m_strCaseSensitive);
  1736.     DDX_Text(pDX, IDC_SEARCHABLE, m_strSearchable);
  1737.     DDX_Text(pDX, IDC_MONEY, m_strMoney);
  1738.     DDX_Text(pDX, IDC_UNSIGNED, m_strUnsigned);
  1739.     DDX_Text(pDX, IDC_AUTO_INCREMENT, m_strAutoIncrement);
  1740.     DDX_Text(pDX, IDC_MAXIMUM_SCALE, m_strMaximumScale);
  1741.     DDX_Text(pDX, IDC_MINIMUM_SCALE, m_strMinimumScale);
  1742.     //}}AFX_DATA_MAP
  1743. }
  1744.  
  1745.  
  1746. BEGIN_MESSAGE_MAP(CDataTypes, CPropertyPage)
  1747.     //{{AFX_MSG_MAP(CDataTypes)
  1748.     ON_LBN_SELCHANGE(IDC_DATA_TYPE_LIST, OnSelchangeDataTypeList)
  1749.     //}}AFX_MSG_MAP
  1750. END_MESSAGE_MAP()
  1751.  
  1752. /////////////////////////////////////////////////////////////////////////////
  1753. // CDataTypes message handlers
  1754.  
  1755. void CDataTypes::OnNewDSN()
  1756. {
  1757.     if (IsWindow(m_hWnd) && m_pDatabase->IsOpen())
  1758.     {
  1759.         if (m_pGetTypeInfo)
  1760.         {
  1761.             if (m_pGetTypeInfo->IsOpen())
  1762.                 m_pGetTypeInfo->Close();
  1763.             delete m_pGetTypeInfo;
  1764.         }
  1765.  
  1766.         // delete type data list
  1767.         TYPEDATA*   p1 = m_pTypeDataHead;
  1768.         TYPEDATA*   p2;
  1769.         while (p1)
  1770.         {
  1771.             p2 = p1;
  1772.             p1 = p1->pNext;
  1773.             delete p2;
  1774.         }
  1775.         m_pTypeDataHead = m_pTypeDataTail = 0;
  1776.  
  1777.         m_lbDataTypes.ResetContent();
  1778.         m_pGetTypeInfo = new CGetTypeInfo(m_pDatabase);
  1779.         m_pGetTypeInfo->Open();
  1780.         while (!m_pGetTypeInfo->IsEOF())
  1781.         {
  1782.             TYPEDATA*   pTypeData = new TYPEDATA;
  1783.             pTypeData->strTypeName = m_pGetTypeInfo->m_strTypeName;
  1784.             pTypeData->nSqlType = m_pGetTypeInfo->m_fDataType;
  1785.             if (m_pGetTypeInfo->IsFieldNull(&(m_pGetTypeInfo->m_nPrecision)))
  1786.                 pTypeData->nPrecision = -1;
  1787.             else
  1788.                 pTypeData->nPrecision = m_pGetTypeInfo->m_nPrecision;
  1789.             if (m_pGetTypeInfo->IsFieldNull(&(m_pGetTypeInfo->m_strLiteralPrefix)))
  1790.                 pTypeData->strLiteralPrefix = "";
  1791.             else
  1792.                 pTypeData->strLiteralPrefix = m_pGetTypeInfo->m_strLiteralPrefix;
  1793.             if (m_pGetTypeInfo->IsFieldNull(&(m_pGetTypeInfo->m_strLiteralSuffix)))
  1794.                 pTypeData->strLiteralSuffix = "";
  1795.             else
  1796.                 pTypeData->strLiteralSuffix = m_pGetTypeInfo->m_strLiteralSuffix;
  1797.             if (m_pGetTypeInfo->IsFieldNull(&(m_pGetTypeInfo->m_strCreateParams)))
  1798.                 pTypeData->strCreateParams = "";
  1799.             else
  1800.                 pTypeData->strCreateParams = m_pGetTypeInfo->m_strCreateParams;
  1801.             pTypeData->nNullable = m_pGetTypeInfo->m_fNullable;
  1802.             pTypeData->bCaseSensitive = m_pGetTypeInfo->m_bCaseSensitive;
  1803.             pTypeData->nSearchable = m_pGetTypeInfo->m_fSearchable;
  1804.             if (m_pGetTypeInfo->IsFieldNull(
  1805.                 &(m_pGetTypeInfo->m_fUnsignedAttribute)))
  1806.             {
  1807.                 pTypeData->nUnsigned = -1;
  1808.             }
  1809.             else if (m_pGetTypeInfo->m_fUnsignedAttribute)
  1810.                 pTypeData->nUnsigned = 1;
  1811.             else
  1812.                 pTypeData->nUnsigned = 0;
  1813.             pTypeData->bMoney = m_pGetTypeInfo->m_bMoney;
  1814.             if (m_pGetTypeInfo->IsFieldNull(
  1815.                 &(m_pGetTypeInfo->m_fAutoIncrement)))
  1816.             {
  1817.                 pTypeData->nAutoIncrement = -1;
  1818.             }
  1819.             else if (m_pGetTypeInfo->m_fAutoIncrement)
  1820.                 pTypeData->nAutoIncrement = 1;
  1821.             else
  1822.                 pTypeData->nAutoIncrement = 0;
  1823.             if (m_pGetTypeInfo->IsFieldNull(&(m_pGetTypeInfo->m_nMinimumScale)))
  1824.                 pTypeData->nMinimumScale = -1;
  1825.             else
  1826.                 pTypeData->nMinimumScale = m_pGetTypeInfo->m_nMinimumScale;
  1827.             if (m_pGetTypeInfo->IsFieldNull(&(m_pGetTypeInfo->m_nMaximumScale)))
  1828.                 pTypeData->nMaximumScale = -1;
  1829.             else
  1830.                 pTypeData->nMaximumScale = m_pGetTypeInfo->m_nMaximumScale;
  1831.  
  1832.             pTypeData->pNext = 0;
  1833.             InsertTypeData(pTypeData);
  1834.             m_lbDataTypes.AddString(m_pGetTypeInfo->m_strTypeName);
  1835.             m_pGetTypeInfo->MoveNext();
  1836.         }
  1837.         m_pGetTypeInfo->Close();
  1838.         delete m_pGetTypeInfo;
  1839.         m_pGetTypeInfo = 0;
  1840.  
  1841.         if (m_lbDataTypes.GetCount())
  1842.         {
  1843.             m_lbDataTypes.SetCurSel(0);
  1844.             OnSelchangeDataTypeList();
  1845.         }
  1846.     }
  1847. }
  1848.  
  1849. void CDataTypes::InsertTypeData(TYPEDATA* pTypeData)
  1850. {
  1851.     TYPEDATA*   p1 = m_pTypeDataTail;
  1852.     if (!p1)
  1853.         m_pTypeDataHead = m_pTypeDataTail = pTypeData;
  1854.     else
  1855.     {
  1856.         p1->pNext = pTypeData;
  1857.         m_pTypeDataTail = pTypeData;
  1858.     }
  1859. }
  1860.  
  1861. BOOL CDataTypes::OnInitDialog()
  1862. {
  1863.     CPropertyPage::OnInitDialog();
  1864.  
  1865.     OnNewDSN();
  1866.  
  1867.     return TRUE;  // return TRUE unless you set the focus to a control
  1868.                   // EXCEPTION: OCX Property Pages should return FALSE
  1869. }
  1870.  
  1871. void CDataTypes::OnSelchangeDataTypeList()
  1872. {
  1873.     if (m_pTypeDataHead)
  1874.     {
  1875.         CString string;
  1876.         m_lbDataTypes.GetText(m_lbDataTypes.GetCurSel(),string);
  1877.  
  1878.         TYPEDATA* pTypeData = m_pTypeDataHead;
  1879.         while (pTypeData)
  1880.         {
  1881.             if (pTypeData->strTypeName == string)
  1882.                 break;
  1883.             pTypeData = pTypeData->pNext;
  1884.         }
  1885.         if (pTypeData)
  1886.         {
  1887.             // note: table lookup would be bettter here
  1888.             switch (pTypeData->nSqlType)
  1889.             {
  1890.             case SQL_BIGINT:
  1891.                 m_strSqlType = _T("SQL_BIGINT");
  1892.                 ShowConversions(SQLGetInfoLong(SQL_CONVERT_BIGINT));
  1893.                 break;
  1894.             case SQL_BINARY:
  1895.                 m_strSqlType = _T("SQL_BINARY");
  1896.                 ShowConversions(SQLGetInfoLong(SQL_CONVERT_BINARY));
  1897.                 break;
  1898.             case SQL_BIT:
  1899.                 m_strSqlType = _T("SQL_BIT");
  1900.                 ShowConversions(SQLGetInfoLong(SQL_CONVERT_BIT));
  1901.                 break;
  1902.             case SQL_CHAR:
  1903.                 m_strSqlType = _T("SQL_CHAR");
  1904.                 ShowConversions(SQLGetInfoLong(SQL_CONVERT_CHAR));
  1905.                 break;
  1906.             case SQL_DATE:
  1907.                 m_strSqlType = _T("SQL_DATE");
  1908.                 ShowConversions(SQLGetInfoLong(SQL_CONVERT_DATE));
  1909.                 break;
  1910.             case SQL_DECIMAL:
  1911.                 m_strSqlType = _T("SQL_DECIMAL");
  1912.                 ShowConversions(SQLGetInfoLong(SQL_CONVERT_DECIMAL));
  1913.                 break;
  1914.             case SQL_DOUBLE:
  1915.                 m_strSqlType = _T("SQL_DOUBLE");
  1916.                 ShowConversions(SQLGetInfoLong(SQL_CONVERT_DOUBLE));
  1917.                 break;
  1918.             case SQL_FLOAT:
  1919.                 m_strSqlType = _T("SQL_FLOAT");
  1920.                 ShowConversions(SQLGetInfoLong(SQL_CONVERT_FLOAT));
  1921.                 break;
  1922.             case SQL_INTEGER:
  1923.                 m_strSqlType = _T("SQL_INTEGER");
  1924.                 ShowConversions(SQLGetInfoLong(SQL_CONVERT_INTEGER));
  1925.                 break;
  1926.             case SQL_LONGVARBINARY:
  1927.                 m_strSqlType = _T("SQL_LONGVARBINARY");
  1928.                 ShowConversions(SQLGetInfoLong(SQL_CONVERT_LONGVARBINARY));
  1929.                 break;
  1930.             case SQL_LONGVARCHAR:
  1931.                 m_strSqlType = _T("SQL_LONGVARCHAR");
  1932.                 ShowConversions(SQLGetInfoLong(SQL_CONVERT_LONGVARCHAR));
  1933.                 break;
  1934.             case SQL_NUMERIC:
  1935.                 m_strSqlType = _T("SQL_NUMERIC");
  1936.                 ShowConversions(SQLGetInfoLong(SQL_CONVERT_NUMERIC));
  1937.                 break;
  1938.             case SQL_REAL:
  1939.                 m_strSqlType = _T("SQL_REAL");
  1940.                 ShowConversions(SQLGetInfoLong(SQL_CONVERT_REAL));
  1941.                 break;
  1942.             case SQL_SMALLINT:
  1943.                 m_strSqlType = _T("SQL_SMALLINT");
  1944.                 ShowConversions(SQLGetInfoLong(SQL_CONVERT_SMALLINT));
  1945.                 break;
  1946.             case SQL_TIME:
  1947.                 m_strSqlType = _T("SQL_TIME");
  1948.                 ShowConversions(SQLGetInfoLong(SQL_CONVERT_TIME));
  1949.                 break;
  1950.             case SQL_TIMESTAMP:
  1951.                 m_strSqlType = _T("SQL_TIMESTAMP");
  1952.                 ShowConversions(SQLGetInfoLong(SQL_CONVERT_TIMESTAMP));
  1953.                 break;
  1954.             case SQL_TINYINT:
  1955.                 m_strSqlType = _T("SQL_TINYINT");
  1956.                 ShowConversions(SQLGetInfoLong(SQL_CONVERT_TINYINT));
  1957.                 break;
  1958.             case SQL_VARBINARY:
  1959.                 m_strSqlType = _T("SQL_VARBINARY");
  1960.                 ShowConversions(SQLGetInfoLong(SQL_CONVERT_VARBINARY));
  1961.                 break;
  1962.             case SQL_VARCHAR:
  1963.                 m_strSqlType = _T("SQL_VARCHAR");
  1964.                 ShowConversions(SQLGetInfoLong(SQL_CONVERT_VARCHAR));
  1965.                 break;
  1966.             default:
  1967.                 m_strSqlType = _T("<new or driver-specific type>");
  1968.                 ShowConversions(0);
  1969.                 break;
  1970.             }
  1971.             if (pTypeData->nPrecision == -1)
  1972.                 m_strPrecision = _T("<n/a>");
  1973.             else
  1974.                 m_strPrecision.Format("%d",pTypeData->nPrecision);
  1975.             if (pTypeData->strLiteralPrefix == "")
  1976.                 m_strPrefixSuffix = _T("<n/a>");
  1977.             else
  1978.                 m_strPrefixSuffix = pTypeData->strLiteralPrefix;
  1979.             m_strPrefixSuffix += ",";
  1980.             if (pTypeData->strLiteralSuffix == "")
  1981.                 m_strPrefixSuffix += _T("<n/a>");
  1982.             else
  1983.                 m_strPrefixSuffix += pTypeData->strLiteralSuffix;
  1984.             if (pTypeData->strCreateParams == "")
  1985.                 m_strCreateParams = _T("<none>");
  1986.             else
  1987.                 m_strCreateParams = pTypeData->strCreateParams;
  1988.             switch (pTypeData->nNullable)
  1989.             {
  1990.             case SQL_NO_NULLS:
  1991.                 m_strNullable = _T("No");
  1992.                 break;
  1993.             case SQL_NULLABLE:
  1994.                 m_strNullable = _T("Yes");
  1995.                 break;
  1996.             case SQL_NULLABLE_UNKNOWN:
  1997.                 m_strNullable = _T("Unknown");
  1998.                 break;
  1999.             }
  2000.             if (pTypeData->bCaseSensitive)
  2001.                 m_strCaseSensitive = _T("Yes");
  2002.             else
  2003.                 m_strCaseSensitive = _T("No");
  2004.  
  2005.             switch (pTypeData->nSearchable)
  2006.             {
  2007.             case SQL_UNSEARCHABLE:
  2008.                 m_strSearchable = _T("No");
  2009.                 break;
  2010.             case SQL_LIKE_ONLY:
  2011.                 m_strSearchable = _T("Only with LIKE");
  2012.                 break;
  2013.             case SQL_ALL_EXCEPT_LIKE:
  2014.                 m_strSearchable = _T("with all except LIKE");
  2015.                 break;
  2016.             case SQL_SEARCHABLE:
  2017.                 m_strSearchable = _T("Yes");
  2018.                 break;
  2019.             }
  2020.  
  2021.             switch (pTypeData->nUnsigned)
  2022.             {
  2023.             case -1:
  2024.                 m_strUnsigned = _T("<n/a>");
  2025.                 break;
  2026.             case 0:
  2027.                 m_strUnsigned = _T("No");
  2028.                 break;
  2029.             case 1:
  2030.                 m_strUnsigned = _T("Yes");
  2031.                 break;
  2032.             }
  2033.  
  2034.             if (pTypeData->bMoney)
  2035.                 m_strMoney = _T("Yes");
  2036.             else
  2037.                 m_strMoney = _T("No");
  2038.  
  2039.             switch (pTypeData->nAutoIncrement)
  2040.             {
  2041.             case -1:
  2042.                 m_strAutoIncrement = _T("<n/a>");
  2043.                 break;
  2044.             case 0:
  2045.                 m_strAutoIncrement = _T("No");
  2046.                 break;
  2047.             case 1:
  2048.                 m_strAutoIncrement = _T("Yes");
  2049.                 break;
  2050.             }
  2051.  
  2052.             if (pTypeData->nMinimumScale == -1)
  2053.                 m_strMinimumScale = _T("<n/a>");
  2054.             else
  2055.                 m_strMinimumScale.Format(_T("%d"),pTypeData->nMinimumScale);
  2056.  
  2057.             if (pTypeData->nMaximumScale == -1)
  2058.                 m_strMaximumScale = _T("<n/a>");
  2059.             else
  2060.                 m_strMaximumScale.Format(_T("%d"),pTypeData->nMaximumScale);
  2061.  
  2062.         }
  2063.         else
  2064.             m_strSqlType = _T("<n/a>?");
  2065.     }
  2066.     else
  2067.         m_strSqlType = _T("<n/a>");
  2068.  
  2069.     UpdateData(FALSE);
  2070. }
  2071.  
  2072. void CDataTypes::ShowConversions(SDWORD dwDataType)
  2073. {
  2074.     m_lbConversions.ResetContent();
  2075.     if (!dwDataType)
  2076.         m_lbConversions.AddString(_T("<none>"));
  2077.     else
  2078.     {
  2079.         if (dwDataType & SQL_CVT_BIGINT)
  2080.             m_lbConversions.AddString(_T("SQL_BIGINT"));
  2081.         if (dwDataType & SQL_CVT_BINARY)
  2082.             m_lbConversions.AddString(_T("SQL_BINARY"));
  2083.         if (dwDataType & SQL_CVT_BIT)
  2084.             m_lbConversions.AddString(_T("SQL_BIT"));
  2085.         if (dwDataType & SQL_CVT_CHAR)
  2086.             m_lbConversions.AddString(_T("SQL_CHAR"));
  2087.         if (dwDataType & SQL_CVT_DATE)
  2088.             m_lbConversions.AddString(_T("SQL_DATE"));
  2089.         if (dwDataType & SQL_CVT_DECIMAL)
  2090.             m_lbConversions.AddString(_T("SQL_DECIMAL"));
  2091.         if (dwDataType & SQL_CVT_DOUBLE)
  2092.             m_lbConversions.AddString(_T("SQL_DOUBLE"));
  2093.         if (dwDataType & SQL_CVT_FLOAT)
  2094.             m_lbConversions.AddString(_T("SQL_FLOAT"));
  2095.         if (dwDataType & SQL_CVT_INTEGER)
  2096.             m_lbConversions.AddString(_T("SQL_INTEGER"));
  2097.         if (dwDataType & SQL_CVT_LONGVARBINARY)
  2098.             m_lbConversions.AddString(_T("SQL_LONGVARBINARY"));
  2099.         if (dwDataType & SQL_CVT_LONGVARCHAR)
  2100.             m_lbConversions.AddString(_T("SQL_LONGVARCHAR"));
  2101.         if (dwDataType & SQL_CVT_NUMERIC)
  2102.             m_lbConversions.AddString(_T("SQL_NUMERIC"));
  2103.         if (dwDataType & SQL_CVT_REAL)
  2104.             m_lbConversions.AddString(_T("SQL_REAL"));
  2105.         if (dwDataType & SQL_CVT_SMALLINT)
  2106.             m_lbConversions.AddString(_T("SQL_SMALLINT"));
  2107.         if (dwDataType & SQL_CVT_TIME)
  2108.             m_lbConversions.AddString(_T("SQL_TIME"));
  2109.         if (dwDataType & SQL_CVT_TIMESTAMP)
  2110.             m_lbConversions.AddString(_T("SQL_TIMESTAMP"));
  2111.         if (dwDataType & SQL_CVT_TINYINT)
  2112.             m_lbConversions.AddString(_T("SQL_TINYINT"));
  2113.         if (dwDataType & SQL_CVT_VARBINARY)
  2114.             m_lbConversions.AddString(_T("SQL_VARBINARY"));
  2115.         if (dwDataType & SQL_CVT_VARCHAR)
  2116.             m_lbConversions.AddString(_T("SQL_VARCHAR"));
  2117.     }
  2118. }
  2119.  
  2120. /////////////////////////////////////////////////////////////////////////////
  2121. // CIdentifiers property page
  2122.  
  2123. IMPLEMENT_DYNCREATE(CIdentifiers, CPropertyPage)
  2124.  
  2125. CIdentifiers::CIdentifiers(CDatabase* pDatabase)
  2126.  : CMyPage(pDatabase,CIdentifiers::IDD)
  2127. {
  2128.     //{{AFX_DATA_INIT(CIdentifiers)
  2129.     m_strSqlIdentifierCase = _T("");
  2130.     m_strSqlIdentifierQuoteChar = _T("");
  2131.     m_strSqlOwnerTerm = _T("");
  2132.     m_strSqlProcedureTerm = _T("");
  2133.     m_strSqlQualifierLocation = _T("");
  2134.     m_strSqlQualifierNameSeparator = _T("");
  2135.     m_strSqlQualifierTerm = _T("");
  2136.     m_strSqlQuotedIdentifierCase = _T("");
  2137.     m_strSqlSearchPatternEscape = _T("");
  2138.     m_strSqlTableTerm = _T("");
  2139.     m_strSqlSpecialCharacters = _T("");
  2140.     //}}AFX_DATA_INIT
  2141.  
  2142.     OnNewDSN();
  2143. }
  2144.  
  2145. CIdentifiers::~CIdentifiers()
  2146. {
  2147. }
  2148.  
  2149. void CIdentifiers::DumpToFile(CStdioFile& file)
  2150. {
  2151.     if (m_pDatabase->IsOpen())
  2152.     {
  2153.         CString bufferString;
  2154.         CString string;
  2155.         CString workString;
  2156.  
  2157.         file.WriteString(_T("Identifiers\n-----------\n\n"));
  2158.         file.WriteString(_T("Driver-Specific Keywords:\n-------------------------\n"));
  2159.  
  2160.         char    buffer[32000];
  2161.         SWORD   cbData;
  2162.         ::SQLGetInfo(m_pDatabase->m_hdbc,SQL_KEYWORDS,
  2163.             (PTR)buffer,32000,&cbData);
  2164.         bufferString = buffer;
  2165.         int     n;
  2166.         string = "";
  2167.         BOOL    b = FALSE;
  2168.         while ((n = bufferString.Find(',')) != -1)
  2169.         {
  2170.             workString = bufferString.Left(n);
  2171.             bufferString = bufferString.Right(bufferString.GetLength() - n - 1);
  2172.             if (string.GetLength() + workString.GetLength() > 75)
  2173.             {
  2174.                 string += _T("\n");
  2175.                 file.WriteString(string);
  2176.                 string = workString;
  2177.             }
  2178.             else
  2179.             {
  2180.                 if (b)
  2181.                     string += _T(",");
  2182.                 string += workString;
  2183.             }
  2184.             b = TRUE;
  2185.         }
  2186.         string += _T("\n\n");
  2187.         file.WriteString(string);
  2188.  
  2189.         string.Format(_T("          Identifier Case - %s\n"),m_strSqlIdentifierCase);
  2190.         file.WriteString(string);
  2191.         string.Format(_T("   Quoted Identifier Case - %s\n"),m_strSqlQuotedIdentifierCase);
  2192.         file.WriteString(string);
  2193.         string.Format(_T("    Search Pattern Escape - %s\n"),m_strSqlSearchPatternEscape);
  2194.         file.WriteString(string);
  2195.         string.Format(_T("    Identifier Quote Char - %s\n"),m_strSqlIdentifierQuoteChar);
  2196.         file.WriteString(string);
  2197.         string.Format(_T("       Qualifier Location - %s\n"),m_strSqlQualifierLocation);
  2198.         file.WriteString(string);
  2199.         string.Format(_T("      Qualifier Separator - %s\n"),m_strSqlQualifierNameSeparator);
  2200.         file.WriteString(string);
  2201.         string.Format(_T("               Owner Term - %s\n"),m_strSqlOwnerTerm);
  2202.         file.WriteString(string);
  2203.         string.Format(_T("           Procedure Term - %s\n"),m_strSqlProcedureTerm);
  2204.         file.WriteString(string);
  2205.         string.Format(_T("           Qualifier Term - %s\n"),m_strSqlQualifierTerm);
  2206.         file.WriteString(string);
  2207.         string.Format(_T("                TableTerm - %s\n\n"),m_strSqlTableTerm);
  2208.         file.WriteString(string);
  2209.  
  2210.         file.WriteString(_T("Special Characters:\n-------------------\n"));
  2211.         if (m_strSqlSpecialCharacters.GetLength() == 0)
  2212.             file.WriteString(_T("<none>\n\n"));
  2213.         else
  2214.         {
  2215.             string = m_strSqlSpecialCharacters;
  2216.             while (string.GetLength() > 75)
  2217.             {
  2218.                 workString = string.Left(75);
  2219.                 string = string.Right(string.GetLength() - n - 1);
  2220.                 workString += _T("\n");
  2221.                 file.WriteString(workString);
  2222.             }
  2223.             string += _T("\n");
  2224.             file.WriteString(string);
  2225.         }
  2226.         file.WriteString(_T("\n"));
  2227.     }
  2228. }
  2229.  
  2230. void CIdentifiers::DoDataExchange(CDataExchange* pDX)
  2231. {
  2232.     CPropertyPage::DoDataExchange(pDX);
  2233.     //{{AFX_DATA_MAP(CIdentifiers)
  2234.     DDX_Control(pDX, IDC_DRIVER_KEYWORDS, m_lbDriverKeywords);
  2235.     DDX_Control(pDX, IDC_ODBC_KEYWORDS, m_lbOdbcKeywords);
  2236.     DDX_Text(pDX, IDC_SQL_IDENTIFIER_CASE, m_strSqlIdentifierCase);
  2237.     DDX_Text(pDX, IDC_SQL_IDENTIFIER_QUOTE_CHAR, m_strSqlIdentifierQuoteChar);
  2238.     DDX_Text(pDX, IDC_SQL_OWNER_TERM, m_strSqlOwnerTerm);
  2239.     DDX_Text(pDX, IDC_SQL_PROCEDURE_TERM, m_strSqlProcedureTerm);
  2240.     DDX_Text(pDX, IDC_SQL_QUALIFIER_LOCATION, m_strSqlQualifierLocation);
  2241.     DDX_Text(pDX, IDC_SQL_QUALIFIER_NAME_SEPARATOR, m_strSqlQualifierNameSeparator);
  2242.     DDX_Text(pDX, IDC_SQL_QUALIFIER_TERM, m_strSqlQualifierTerm);
  2243.     DDX_Text(pDX, IDC_SQL_QUOTED_IDENTIFIER_CASE, m_strSqlQuotedIdentifierCase);
  2244.     DDX_Text(pDX, IDC_SQL_SEARCH_PATTERN_ESCAPE, m_strSqlSearchPatternEscape);
  2245.     DDX_Text(pDX, IDC_SQL_TABLE_TERM, m_strSqlTableTerm);
  2246.     DDX_Text(pDX, IDC_SQL_SPECIAL_CHARACTERS, m_strSqlSpecialCharacters);
  2247.     //}}AFX_DATA_MAP
  2248. }
  2249.  
  2250.  
  2251. BEGIN_MESSAGE_MAP(CIdentifiers, CPropertyPage)
  2252.     //{{AFX_MSG_MAP(CIdentifiers)
  2253.     //}}AFX_MSG_MAP
  2254. END_MESSAGE_MAP()
  2255.  
  2256. /////////////////////////////////////////////////////////////////////////////
  2257. // CIdentifiers message handlers
  2258.  
  2259. void CIdentifiers::OnNewDSN()
  2260. {
  2261.     if (m_pDatabase->IsOpen())
  2262.     {
  2263.         switch (SQLGetInfoShort(SQL_IDENTIFIER_CASE))
  2264.         {
  2265.         case SQL_IC_UPPER:
  2266.             m_strSqlIdentifierCase = _T("Upper");
  2267.             break;
  2268.         case SQL_IC_LOWER:
  2269.             m_strSqlIdentifierCase = _T("Lower");
  2270.             break;
  2271.         case SQL_IC_SENSITIVE:
  2272.             m_strSqlIdentifierCase = _T("Sensitive");
  2273.             break;
  2274.         case SQL_IC_MIXED:
  2275.             m_strSqlIdentifierCase = _T("Mixed");
  2276.             break;
  2277.         }
  2278.         m_strSqlIdentifierQuoteChar = SQLGetInfoString(SQL_IDENTIFIER_QUOTE_CHAR);
  2279.         m_strSqlOwnerTerm = SQLGetInfoString(SQL_OWNER_TERM);
  2280.         m_strSqlProcedureTerm = SQLGetInfoString(SQL_PROCEDURE_TERM);
  2281.         switch (SQLGetInfoShort(SQL_QUALIFIER_LOCATION))
  2282.         {
  2283.         case SQL_QL_START:
  2284.             m_strSqlQualifierLocation = _T("Start");
  2285.             break;
  2286.         case SQL_QL_END:
  2287.             m_strSqlQualifierLocation = _T("End");
  2288.             break;
  2289.         }
  2290.         m_strSqlQualifierNameSeparator = SQLGetInfoString(SQL_QUALIFIER_NAME_SEPARATOR);
  2291.         m_strSqlQualifierTerm = SQLGetInfoString(SQL_QUALIFIER_TERM);
  2292.         switch (SQLGetInfoShort(SQL_QUOTED_IDENTIFIER_CASE))
  2293.         {
  2294.         case SQL_IC_UPPER:
  2295.             m_strSqlQuotedIdentifierCase = _T("Upper");
  2296.             break;
  2297.         case SQL_IC_LOWER:
  2298.             m_strSqlQuotedIdentifierCase = _T("Lower");
  2299.             break;
  2300.         case SQL_IC_SENSITIVE:
  2301.             m_strSqlQuotedIdentifierCase = _T("Sensitive");
  2302.             break;
  2303.         case SQL_IC_MIXED:
  2304.             m_strSqlQuotedIdentifierCase = _T("Mixed");
  2305.             break;
  2306.         }
  2307.         m_strSqlSearchPatternEscape = SQLGetInfoString(SQL_SEARCH_PATTERN_ESCAPE);
  2308.         m_strSqlSpecialCharacters = SQLGetInfoString(SQL_SPECIAL_CHARACTERS);
  2309.         m_strSqlTableTerm = SQLGetInfoString(SQL_TABLE_TERM);
  2310.         if (IsWindow(m_hWnd))
  2311.         {
  2312.             char    buffer[32000];
  2313.             SWORD   cbData;
  2314.             ::SQLGetInfo(m_pDatabase->m_hdbc,SQL_KEYWORDS,
  2315.                 (PTR)buffer,32000,&cbData);
  2316.             CString string = buffer;
  2317.             int     n;
  2318.             m_lbDriverKeywords.ResetContent();
  2319.             while ((n = string.Find(',')) != -1)
  2320.             {
  2321.                 m_lbDriverKeywords.AddString(string.Left(n));
  2322.                 string = string.Right(string.GetLength() - n - 1);
  2323.             }
  2324.  
  2325.             UpdateData(FALSE);
  2326.         }
  2327.     }
  2328. }
  2329.  
  2330. BOOL CIdentifiers::OnInitDialog()
  2331. {
  2332.     CPropertyPage::OnInitDialog();
  2333.  
  2334.     m_lbOdbcKeywords.ResetContent();
  2335.     CString string = SQL_ODBC_KEYWORDS;
  2336.     int     n;
  2337.     while ((n = string.Find(',')) != -1)
  2338.     {
  2339.         m_lbOdbcKeywords.AddString(string.Left(n));
  2340.         string = string.Right(string.GetLength() - n - 1);
  2341.     }
  2342.  
  2343.     char    buffer[32000];
  2344.     SWORD   cbData;
  2345.     ::SQLGetInfo(m_pDatabase->m_hdbc,SQL_KEYWORDS,
  2346.         (PTR)buffer,32000,&cbData);
  2347.     string = buffer;
  2348.     m_lbDriverKeywords.ResetContent();
  2349.     while ((n = string.Find(',')) != -1)
  2350.     {
  2351.         m_lbDriverKeywords.AddString(string.Left(n));
  2352.         string = string.Right(string.GetLength() - n - 1);
  2353.     }
  2354.  
  2355.     UpdateData(FALSE);
  2356.  
  2357.     return TRUE;  // return TRUE unless you set the focus to a control
  2358.                   // EXCEPTION: OCX Property Pages should return FALSE
  2359. }
  2360.  
  2361. /////////////////////////////////////////////////////////////////////////////
  2362. // CLimits property page
  2363.  
  2364. #define NUM_INTERVALS   9
  2365.  
  2366. IMPLEMENT_DYNCREATE(CLimits, CPropertyPage)
  2367.  
  2368. UWORD CLimits::m_nIntervalMasks[] =
  2369. {
  2370.     SQL_FN_TSI_FRAC_SECOND,
  2371.     SQL_FN_TSI_SECOND,
  2372.     SQL_FN_TSI_MINUTE,
  2373.     SQL_FN_TSI_HOUR,
  2374.     SQL_FN_TSI_DAY,
  2375.     SQL_FN_TSI_WEEK,
  2376.     SQL_FN_TSI_MONTH,
  2377.     SQL_FN_TSI_QUARTER,
  2378.     SQL_FN_TSI_YEAR
  2379. };
  2380.  
  2381. char* CLimits::m_szIntervalNames[] =
  2382. {
  2383.     _T("Second Fraction"),
  2384.     _T("Second"),
  2385.     _T("Minute"),
  2386.     _T("Hour"),
  2387.     _T("Day"),
  2388.     _T("Week"),
  2389.     _T("Month"),
  2390.     _T("Quarter"),
  2391.     _T("Year")
  2392. };
  2393.  
  2394. CLimits::CLimits(CDatabase* pDatabase)
  2395.  : CMyPage(pDatabase,CLimits::IDD)
  2396. {
  2397.     //{{AFX_DATA_INIT(CLimits)
  2398.     m_strSqlMaxBinaryLiteralLen = _T("");
  2399.     m_strSqlMaxCharLiteralLen = _T("");
  2400.     m_strSqlMaxColumnNameLen = _T("");
  2401.     m_strSqlMaxColumnsInGroupBy = _T("");
  2402.     m_strSqlMaxColumnsInIndex = _T("");
  2403.     m_strSqlMaxColumnsInOrderBy = _T("");
  2404.     m_strSqlMaxColumnsInSelect = _T("");
  2405.     m_strSqlMaxColumnsInTable = _T("");
  2406.     m_strSqlMaxCursorNameLen = _T("");
  2407.     m_strSqlMaxIndexSize = _T("");
  2408.     m_strSqlMaxOwnerNameLen = _T("");
  2409.     m_strSqlMaxProcedureNameLen = _T("");
  2410.     m_strSqlMaxQualifierNameLen = _T("");
  2411.     m_strSqlMaxRowSize = _T("");
  2412.     m_strSqlMaxRowSizeIncludesLong = _T("");
  2413.     m_strSqlMaxStatementLen = _T("");
  2414.     m_strSqlMaxTableNameLen = _T("");
  2415.     m_strSqlMaxTablesInSelect = _T("");
  2416.     m_strSqlMaxUserNameLen = _T("");
  2417.     //}}AFX_DATA_INIT
  2418.  
  2419.     OnNewDSN();
  2420. }
  2421.  
  2422. CLimits::~CLimits()
  2423. {
  2424. }
  2425.  
  2426. void CLimits::DumpToFile(CStdioFile& file)
  2427. {
  2428.     if (m_pDatabase->IsOpen())
  2429.     {
  2430.         CString string;
  2431.         BOOL    b;
  2432.  
  2433.         file.WriteString(_T("Limits\n------\n\n"));
  2434.         string.Format(_T("Max Binary Literal Length - %s\n"),m_strSqlMaxBinaryLiteralLen);
  2435.         file.WriteString(string);
  2436.         string.Format(_T("  Max Char Literal Length - %s\n"),m_strSqlMaxCharLiteralLen);
  2437.         file.WriteString(string);
  2438.         string.Format(_T("   Max Column Name Length - %s\n"),m_strSqlMaxColumnNameLen);
  2439.         file.WriteString(string);
  2440.         string.Format(_T("  Max Columns in GROUP BY - %s\n"),m_strSqlMaxColumnsInGroupBy);
  2441.         file.WriteString(string);
  2442.         string.Format(_T("     Max Columns in Index - %s\n"),m_strSqlMaxColumnsInIndex);
  2443.         file.WriteString(string);
  2444.         string.Format(_T("  Max Columns in ORDER BY - %s\n"),m_strSqlMaxColumnsInOrderBy);
  2445.         file.WriteString(string);
  2446.         string.Format(_T("    Max Columns in SELECT - %s\n"),m_strSqlMaxColumnsInSelect);
  2447.         file.WriteString(string);
  2448.         string.Format(_T("     Max Columns in Table - %s\n"),m_strSqlMaxColumnsInTable);
  2449.         file.WriteString(string);
  2450.         string.Format(_T("   Max Cursor Name Length - %s\n"),m_strSqlMaxCursorNameLen);
  2451.         file.WriteString(string);
  2452.         string.Format(_T("           Max Index Size - %s\n"),m_strSqlMaxIndexSize);
  2453.         file.WriteString(string);
  2454.         string.Format(_T("    Max Owner Name Length - %s\n"),m_strSqlMaxOwnerNameLen);
  2455.         file.WriteString(string);
  2456.         string.Format(_T("Max Procedure Name Length - %s\n"),m_strSqlMaxProcedureNameLen);
  2457.         file.WriteString(string);
  2458.         string.Format(_T("Max Qualifier Name Length - %s\n"),m_strSqlMaxQualifierNameLen);
  2459.         file.WriteString(string);
  2460.         string.Format(_T("             Max Row Size - %s\n"),m_strSqlMaxRowSize);
  2461.         file.WriteString(string);
  2462.         string.Format(_T("Max Rowsize Includes Long - %s\n"),m_strSqlMaxRowSizeIncludesLong);
  2463.         file.WriteString(string);
  2464.         string.Format(_T("     Max Statement Length - %s\n"),m_strSqlMaxStatementLen);
  2465.         file.WriteString(string);
  2466.         string.Format(_T("    Max Table Name Length - %s\n"),m_strSqlMaxTableNameLen);
  2467.         file.WriteString(string);
  2468.         string.Format(_T("     Max Tables In SELECT - %s\n"),m_strSqlMaxTablesInSelect);
  2469.         file.WriteString(string);
  2470.         string.Format(_T("     Max User Name Length - %s\n\n"),m_strSqlMaxUserNameLen);
  2471.         file.WriteString(string);
  2472.  
  2473.         if (!(SQLGetInfoLong(SQL_TIMEDATE_FUNCTIONS) & SQL_FN_TD_TIMESTAMPADD))
  2474.             file.WriteString(_T("Timestamp Add Intervals: <n/a>\n\n"));
  2475.         else
  2476.         {
  2477.             file.WriteString(_T("Timestamp Add Intervals:\n"));
  2478.             UDWORD  fAddIntervals = SQLGetInfoLong(SQL_TIMEDATE_ADD_INTERVALS);
  2479.             b = FALSE;
  2480.             for (int i = 0; i < NUM_INTERVALS; i++)
  2481.             {
  2482.                 if (m_nIntervalMasks[i] & fAddIntervals)
  2483.                 {
  2484.                     if (b)
  2485.                         file.WriteString(_T(","));
  2486.                     file.WriteString(m_szIntervalNames[i]);
  2487.                     b = TRUE;
  2488.                 }
  2489.             }
  2490.             file.WriteString(_T("\n\n"));
  2491.         }
  2492.         if (!(SQLGetInfoLong(SQL_TIMEDATE_FUNCTIONS) & SQL_FN_TD_TIMESTAMPDIFF))
  2493.             file.WriteString(_T("Timestamp Diff Intervals: <n/a>\n\n"));
  2494.         else
  2495.         {
  2496.             file.WriteString(_T("Timestamp Diff Intervals:\n"));
  2497.             UDWORD  fDiffIntervals = SQLGetInfoLong(SQL_TIMEDATE_DIFF_INTERVALS);
  2498.             b = FALSE;
  2499.             for (int i = 0; i < NUM_INTERVALS; i++)
  2500.             {
  2501.                 if (m_nIntervalMasks[i] & fDiffIntervals)
  2502.                 {
  2503.                     if (b)
  2504.                         file.WriteString(_T(","));
  2505.                     file.WriteString(m_szIntervalNames[i]);
  2506.                     b = TRUE;
  2507.                 }
  2508.             }
  2509.             file.WriteString(_T("\n\n"));
  2510.         }
  2511.  
  2512.         file.WriteString(_T("\n"));
  2513.     }
  2514. }
  2515.  
  2516. void CLimits::DoDataExchange(CDataExchange* pDX)
  2517. {
  2518.     CPropertyPage::DoDataExchange(pDX);
  2519.     //{{AFX_DATA_MAP(CLimits)
  2520.     DDX_Control(pDX, IDC_SQL_TIMEDATE_DIFF_INTERVALS, m_lcSqlTimedateDiffIntervals);
  2521.     DDX_Control(pDX, IDC_SQL_TIMEDATE_ADD_INTERVALS, m_lcSqlTimedateAddIntervals);
  2522.     DDX_Text(pDX, IDC_SQL_MAX_BINARY_LITERAL_LEN, m_strSqlMaxBinaryLiteralLen);
  2523.     DDX_Text(pDX, IDC_SQL_MAX_CHAR_LITERAL_LEN, m_strSqlMaxCharLiteralLen);
  2524.     DDX_Text(pDX, IDC_SQL_MAX_COLUMN_NAME_LEN, m_strSqlMaxColumnNameLen);
  2525.     DDX_Text(pDX, IDC_SQL_MAX_COLUMNS_IN_GROUP_BY, m_strSqlMaxColumnsInGroupBy);
  2526.     DDX_Text(pDX, IDC_SQL_MAX_COLUMNS_IN_INDEX, m_strSqlMaxColumnsInIndex);
  2527.     DDX_Text(pDX, IDC_SQL_MAX_COLUMNS_IN_ORDER_BY, m_strSqlMaxColumnsInOrderBy);
  2528.     DDX_Text(pDX, IDC_SQL_MAX_COLUMNS_IN_SELECT, m_strSqlMaxColumnsInSelect);
  2529.     DDX_Text(pDX, IDC_SQL_MAX_COLUMNS_IN_TABLE, m_strSqlMaxColumnsInTable);
  2530.     DDX_Text(pDX, IDC_SQL_MAX_CURS0R_NAME_LEN, m_strSqlMaxCursorNameLen);
  2531.     DDX_Text(pDX, IDC_SQL_MAX_INDEX_SIZE, m_strSqlMaxIndexSize);
  2532.     DDX_Text(pDX, IDC_SQL_MAX_OWNER_NAME_LEN, m_strSqlMaxOwnerNameLen);
  2533.     DDX_Text(pDX, IDC_SQL_MAX_PROCEDURE_NAME_LEN, m_strSqlMaxProcedureNameLen);
  2534.     DDX_Text(pDX, IDC_SQL_MAX_QUALIFIER_NAME_LEN, m_strSqlMaxQualifierNameLen);
  2535.     DDX_Text(pDX, IDC_SQL_MAX_ROW_SIZE, m_strSqlMaxRowSize);
  2536.     DDX_Text(pDX, IDC_SQL_MAX_ROW_SIZE_INCLUDES_LONG, m_strSqlMaxRowSizeIncludesLong);
  2537.     DDX_Text(pDX, IDC_SQL_MAX_STATEMENT_LEN, m_strSqlMaxStatementLen);
  2538.     DDX_Text(pDX, IDC_SQL_MAX_TABLE_NAME_LEN, m_strSqlMaxTableNameLen);
  2539.     DDX_Text(pDX, IDC_SQL_MAX_TABLES_IN_SELECT, m_strSqlMaxTablesInSelect);
  2540.     DDX_Text(pDX, IDC_SQL_MAX_USER_NAME_LEN, m_strSqlMaxUserNameLen);
  2541.     //}}AFX_DATA_MAP
  2542. }
  2543.  
  2544.  
  2545. BEGIN_MESSAGE_MAP(CLimits, CPropertyPage)
  2546.     //{{AFX_MSG_MAP(CLimits)
  2547.     //}}AFX_MSG_MAP
  2548. END_MESSAGE_MAP()
  2549.  
  2550. /////////////////////////////////////////////////////////////////////////////
  2551. // CLimits message handlers
  2552.  
  2553. void CLimits::OnNewDSN()
  2554. {
  2555.     if (m_pDatabase->IsOpen())
  2556.     {
  2557.         ZeroIsNoneLong(m_strSqlMaxBinaryLiteralLen,SQL_MAX_BINARY_LITERAL_LEN);
  2558.         ZeroIsNoneLong(m_strSqlMaxCharLiteralLen,SQL_MAX_CHAR_LITERAL_LEN);
  2559.         ZeroIsNoneShort(m_strSqlMaxColumnNameLen,SQL_MAX_COLUMN_NAME_LEN);
  2560.         ZeroIsNoneShort(m_strSqlMaxColumnsInGroupBy,SQL_MAX_COLUMNS_IN_GROUP_BY);
  2561.         ZeroIsNoneShort(m_strSqlMaxColumnsInIndex,SQL_MAX_COLUMNS_IN_INDEX);
  2562.         ZeroIsNoneShort(m_strSqlMaxColumnsInOrderBy,SQL_MAX_COLUMNS_IN_ORDER_BY);
  2563.         ZeroIsNoneShort(m_strSqlMaxColumnsInSelect,SQL_MAX_COLUMNS_IN_SELECT);
  2564.         ZeroIsNoneShort(m_strSqlMaxColumnsInTable,SQL_MAX_COLUMNS_IN_TABLE);
  2565.         ZeroIsNoneShort(m_strSqlMaxCursorNameLen,SQL_MAX_CURSOR_NAME_LEN);
  2566.         ZeroIsNoneLong(m_strSqlMaxIndexSize,SQL_MAX_INDEX_SIZE);
  2567.         ZeroIsNoneShort(m_strSqlMaxOwnerNameLen,SQL_MAX_OWNER_NAME_LEN);
  2568.         ZeroIsNoneShort(m_strSqlMaxProcedureNameLen,SQL_MAX_PROCEDURE_NAME_LEN);
  2569.         ZeroIsNoneShort(m_strSqlMaxQualifierNameLen,SQL_MAX_QUALIFIER_NAME_LEN);
  2570.         ZeroIsNoneLong(m_strSqlMaxRowSize,SQL_MAX_ROW_SIZE);
  2571.         YIsYes(m_strSqlMaxRowSizeIncludesLong,SQL_MAX_ROW_SIZE_INCLUDES_LONG);
  2572.         ZeroIsNoneLong(m_strSqlMaxStatementLen,SQL_MAX_STATEMENT_LEN);
  2573.         ZeroIsNoneShort(m_strSqlMaxTableNameLen,SQL_MAX_TABLE_NAME_LEN);
  2574.         ZeroIsNoneShort(m_strSqlMaxTablesInSelect,SQL_MAX_TABLES_IN_SELECT);
  2575.         ZeroIsNoneShort(m_strSqlMaxUserNameLen,SQL_MAX_USER_NAME_LEN);
  2576.  
  2577.         if (IsWindow(m_hWnd))
  2578.         {
  2579.             UDWORD  fAddIntervals = SQLGetInfoLong(SQL_TIMEDATE_ADD_INTERVALS);
  2580.             UDWORD  fDiffIntervals = SQLGetInfoLong(SQL_TIMEDATE_DIFF_INTERVALS);
  2581.  
  2582.             m_lcSqlTimedateAddIntervals.DeleteAllItems();
  2583.             if (!(SQLGetInfoLong(SQL_TIMEDATE_FUNCTIONS) & SQL_FN_TD_TIMESTAMPADD))
  2584.                 m_lcSqlTimedateAddIntervals.InsertItem(0,_T("<n/a>"));
  2585.             else
  2586.             {
  2587.                 for (int i = 0; i < NUM_INTERVALS; i++)
  2588.                 {
  2589.                     int nCheck = 0;
  2590.                     if (m_nIntervalMasks[i] & fAddIntervals)
  2591.                         nCheck = 1;
  2592.                     m_lcSqlTimedateAddIntervals.InsertItem(
  2593.                         i,m_szIntervalNames[i],nCheck);
  2594.                 }
  2595.             }
  2596.  
  2597.             m_lcSqlTimedateDiffIntervals.DeleteAllItems();
  2598.             if (!(SQLGetInfoLong(SQL_TIMEDATE_FUNCTIONS) & SQL_FN_TD_TIMESTAMPDIFF))
  2599.                 m_lcSqlTimedateDiffIntervals.InsertItem(0,_T("<n/a>"));
  2600.             else
  2601.             {
  2602.                 for (int i = 0; i < NUM_INTERVALS; i++)
  2603.                 {
  2604.                     int nCheck = 0;
  2605.                     if (m_nIntervalMasks[i] & fDiffIntervals)
  2606.                         nCheck = 1;
  2607.                     m_lcSqlTimedateDiffIntervals.InsertItem(
  2608.                         i,m_szIntervalNames[i],nCheck);
  2609.                 }
  2610.             }
  2611.  
  2612.             UpdateData(FALSE);
  2613.         }
  2614.     }
  2615. }
  2616.  
  2617. BOOL CLimits::OnInitDialog()
  2618. {
  2619.     CPropertyPage::OnInitDialog();
  2620.  
  2621.     m_lcSqlTimedateDiffIntervals.SetImageList(m_pImageList,LVSIL_SMALL);
  2622.     m_lcSqlTimedateAddIntervals.SetImageList(m_pImageList,LVSIL_SMALL);
  2623.  
  2624.     m_lcSqlTimedateDiffIntervals.InsertColumn(0,"",LVCFMT_LEFT,100);
  2625.     m_lcSqlTimedateAddIntervals.InsertColumn(0,"",LVCFMT_LEFT,100);
  2626.  
  2627.     UDWORD  fAddIntervals = SQLGetInfoLong(SQL_TIMEDATE_ADD_INTERVALS);
  2628.     UDWORD  fDiffIntervals = SQLGetInfoLong(SQL_TIMEDATE_DIFF_INTERVALS);
  2629.  
  2630.     m_lcSqlTimedateAddIntervals.DeleteAllItems();
  2631.     if (!(SQLGetInfoLong(SQL_TIMEDATE_FUNCTIONS) & SQL_FN_TD_TIMESTAMPADD))
  2632.         m_lcSqlTimedateAddIntervals.InsertItem(0,_T("<n/a>"));
  2633.     else
  2634.     {
  2635.         for (int i = 0; i < NUM_INTERVALS; i++)
  2636.         {
  2637.             int nCheck = 0;
  2638.             if (m_nIntervalMasks[i] & fAddIntervals)
  2639.                 nCheck = 1;
  2640.             m_lcSqlTimedateAddIntervals.InsertItem(
  2641.                 i,m_szIntervalNames[i],nCheck);
  2642.         }
  2643.     }
  2644.  
  2645.     m_lcSqlTimedateDiffIntervals.DeleteAllItems();
  2646.     if (!(SQLGetInfoLong(SQL_TIMEDATE_FUNCTIONS) & SQL_FN_TD_TIMESTAMPDIFF))
  2647.         m_lcSqlTimedateDiffIntervals.InsertItem(0,_T("<n/a>"));
  2648.     else
  2649.     {
  2650.         for (int i = 0; i < NUM_INTERVALS; i++)
  2651.         {
  2652.             int nCheck = 0;
  2653.             if (m_nIntervalMasks[i] & fDiffIntervals)
  2654.                 nCheck = 1;
  2655.             m_lcSqlTimedateDiffIntervals.InsertItem(
  2656.                 i,m_szIntervalNames[i],nCheck);
  2657.         }
  2658.     }
  2659.  
  2660.     UpdateData(FALSE);
  2661.  
  2662.     return TRUE;  // return TRUE unless you set the focus to a control
  2663.                   // EXCEPTION: OCX Property Pages should return FALSE
  2664. }
  2665.  
  2666. /////////////////////////////////////////////////////////////////////////////
  2667. // CMisc1 property page
  2668.  
  2669. IMPLEMENT_DYNCREATE(CMisc1, CPropertyPage)
  2670.  
  2671. CMisc1::CMisc1(CDatabase* pDatabase)
  2672.  : CMyPage(pDatabase,CMisc1::IDD)
  2673. {
  2674.     //{{AFX_DATA_INIT(CMisc1)
  2675.     m_strSqlTxnCapable = _T("");
  2676.     m_strSqlCursorCommitBehavior = _T("");
  2677.     m_strSqlCursorRollbackBehavior = _T("");
  2678.     m_bSqlTxnReadCommitted = FALSE;
  2679.     m_bSqlTxnReadUncommitted = FALSE;
  2680.     m_bSqlTxnRepeatableRead = FALSE;
  2681.     m_bSqlTxnSerializable = FALSE;
  2682.     m_strSqlDefaultTxnIsolation = _T("");
  2683.     m_strSqlMultipleActiveTxn = _T("");
  2684.     m_bSqlBpClose = FALSE;
  2685.     m_bSqlBpDelete = FALSE;
  2686.     m_bSqlBpDrop = FALSE;
  2687.     m_bSqlBpOtherHstmt = FALSE;
  2688.     m_bSqlBpScroll = FALSE;
  2689.     m_bSqlBpTransaction = FALSE;
  2690.     m_bSqlBpUpdate = FALSE;
  2691.     m_bSqlLckExclusive = FALSE;
  2692.     m_bSqlLckNoChange = FALSE;
  2693.     m_bSqlLckUnlock = FALSE;
  2694.     m_bSqlSsAdditions = FALSE;
  2695.     m_bSqlSsDeletions = FALSE;
  2696.     m_bSqlSsUpdates = FALSE;
  2697.     //}}AFX_DATA_INIT
  2698.  
  2699.     OnNewDSN();
  2700. }
  2701.  
  2702. CMisc1::~CMisc1()
  2703. {
  2704. }
  2705.  
  2706. void CMisc1::DumpToFile(CStdioFile& file)
  2707. {
  2708.     if (m_pDatabase->IsOpen())
  2709.     {
  2710.         CString string;
  2711.         CString workString;
  2712.         BOOL    b;
  2713.  
  2714.         file.WriteString(_T("Miscellaneous\n-------------\n\n"));
  2715.  
  2716.         string.Format(_T(" Transaction Capabilities - %s\n"),m_strSqlTxnCapable);
  2717.         file.WriteString(string);
  2718.         string.Format(_T("   Cursor Commit Behavior - %s\n"),m_strSqlCursorCommitBehavior);
  2719.         file.WriteString(string);
  2720.         string.Format(_T(" Cursor Rollback Behavior - %s\n"),m_strSqlCursorRollbackBehavior);
  2721.         file.WriteString(string);
  2722.         file.WriteString(_T("  Trans. Isolation Levels - "));
  2723.         b = FALSE;
  2724.         if (m_bSqlTxnReadCommitted)
  2725.         {
  2726.             file.WriteString(_T("Read Commit"));
  2727.             b = TRUE;
  2728.         }
  2729.         if (m_bSqlTxnReadUncommitted)
  2730.         {
  2731.             if (b)
  2732.                 file.WriteString(_T(","));
  2733.             file.WriteString(_T("Read Uncommit"));
  2734.             b = TRUE;
  2735.         }
  2736.         if (m_bSqlTxnRepeatableRead)
  2737.         {
  2738.             if (b)
  2739.                 file.WriteString(_T(","));
  2740.             file.WriteString(_T("Repeat Read"));
  2741.             b = TRUE;
  2742.         }
  2743.         if (m_bSqlTxnSerializable)
  2744.         {
  2745.             if (b)
  2746.                 file.WriteString(_T(","));
  2747.             file.WriteString(_T("Serializable"));
  2748.             b = TRUE;
  2749.         }
  2750.  
  2751.         if (!b)
  2752.             file.WriteString(_T("<none>"));
  2753.         file.WriteString(_T("\n"));
  2754.         string.Format(_T(" Default Trans. Isolation - %s\n"),m_strSqlDefaultTxnIsolation);
  2755.         file.WriteString(string);
  2756.         string.Format(_T("   Multiple Active Trans. - %s\n"),m_strSqlMultipleActiveTxn);
  2757.         file.WriteString(string);
  2758.         file.WriteString(_T("     Bookmark Persistance - "));
  2759.         b = FALSE;
  2760.         if (m_bSqlBpClose)
  2761.         {
  2762.             file.WriteString(_T("Close"));
  2763.             b = TRUE;
  2764.         }
  2765.         if (m_bSqlBpDelete)
  2766.         {
  2767.             if (b)
  2768.                 file.WriteString(_T(","));
  2769.             file.WriteString(_T("Delete"));
  2770.             b = TRUE;
  2771.         }
  2772.         if (m_bSqlBpDrop)
  2773.         {
  2774.             if (b)
  2775.                 file.WriteString(_T(","));
  2776.             file.WriteString(_T("Drop"));
  2777.             b = TRUE;
  2778.         }
  2779.         if (m_bSqlBpOtherHstmt)
  2780.         {
  2781.             if (b)
  2782.                 file.WriteString(_T(","));
  2783.             file.WriteString(_T("Other HSTMT"));
  2784.             b = TRUE;
  2785.         }
  2786.         if (m_bSqlBpScroll)
  2787.         {
  2788.             if (b)
  2789.                 file.WriteString(_T(","));
  2790.             file.WriteString(_T("Scroll"));
  2791.             b = TRUE;
  2792.         }
  2793.         if (m_bSqlBpTransaction)
  2794.         {
  2795.             if (b)
  2796.                 file.WriteString(_T(","));
  2797.             file.WriteString(_T("Transaction"));
  2798.             b = TRUE;
  2799.         }
  2800.         if (m_bSqlBpUpdate)
  2801.         {
  2802.             if (b)
  2803.                 file.WriteString(_T(","));
  2804.             file.WriteString(_T("Update"));
  2805.             b = TRUE;
  2806.         }
  2807.         if (!b)
  2808.             file.WriteString(_T("<none>"));
  2809.         file.WriteString(_T("\n"));
  2810.  
  2811.         file.WriteString(_T("               Lock Types - "));
  2812.         b = FALSE;
  2813.         if (m_bSqlLckExclusive)
  2814.         {
  2815.             file.WriteString(_T("Exclusive"));
  2816.             b = TRUE;
  2817.         }
  2818.         if (m_bSqlLckNoChange)
  2819.         {
  2820.             if (b)
  2821.                 file.WriteString(_T(","));
  2822.             file.WriteString(_T("No Change"));
  2823.             b = TRUE;
  2824.         }
  2825.         if (m_bSqlLckUnlock)
  2826.         {
  2827.             if (b)
  2828.                 file.WriteString(_T(","));
  2829.             file.WriteString(_T("Unlock"));
  2830.             b = TRUE;
  2831.         }
  2832.         if (!b)
  2833.             file.WriteString(_T("<none>"));
  2834.         file.WriteString(_T("\n"));
  2835.  
  2836.         file.WriteString(_T("       Static Sensitivity - "));
  2837.         b = FALSE;
  2838.         if (m_bSqlSsAdditions)
  2839.         {
  2840.             file.WriteString(_T("Additions"));
  2841.             b = TRUE;
  2842.         }
  2843.         if (m_bSqlSsDeletions)
  2844.         {
  2845.             if (b)
  2846.                 file.WriteString(_T(","));
  2847.             file.WriteString(_T("Deletions"));
  2848.             b = TRUE;
  2849.         }
  2850.         if (m_bSqlSsUpdates)
  2851.         {
  2852.             if (b)
  2853.                 file.WriteString(_T(","));
  2854.             file.WriteString(_T("Updates"));
  2855.             b = TRUE;
  2856.         }
  2857.         if (!b)
  2858.             file.WriteString(_T("<none>"));
  2859.         file.WriteString(_T("\n\n"));
  2860.     }
  2861. }
  2862.  
  2863. void CMisc1::DoDataExchange(CDataExchange* pDX)
  2864. {
  2865.     CPropertyPage::DoDataExchange(pDX);
  2866.     //{{AFX_DATA_MAP(CMisc1)
  2867.     DDX_Text(pDX, IDC_SQL_TXN_CAPABLE, m_strSqlTxnCapable);
  2868.     DDX_Text(pDX, IDC_SQL_CURSOR_COMMIT_BEHAVIOR, m_strSqlCursorCommitBehavior);
  2869.     DDX_Text(pDX, IDC_SQL_CURSOR_ROLLBACK_BEHAVIOR, m_strSqlCursorRollbackBehavior);
  2870.     DDX_Check(pDX, IDC_SQL_TXN_READ_COMMITTED, m_bSqlTxnReadCommitted);
  2871.     DDX_Check(pDX, IDC_SQL_TXN_READ_UNCOMMITTED, m_bSqlTxnReadUncommitted);
  2872.     DDX_Check(pDX, IDC_SQL_TXN_REPEATABLE_READ, m_bSqlTxnRepeatableRead);
  2873.     DDX_Check(pDX, IDC_SQL_TXN_SERIALIZABLE, m_bSqlTxnSerializable);
  2874.     DDX_Text(pDX, IDC_SQL_DEFAULT_TXN_ISOLATION, m_strSqlDefaultTxnIsolation);
  2875.     DDX_Text(pDX, IDC_SQL_MULTIPLE_ACTIVE_TXN, m_strSqlMultipleActiveTxn);
  2876.     DDX_Check(pDX, IDC_SQL_BP_CLOSE, m_bSqlBpClose);
  2877.     DDX_Check(pDX, IDC_SQL_BP_DELETE, m_bSqlBpDelete);
  2878.     DDX_Check(pDX, IDC_SQL_BP_DROP, m_bSqlBpDrop);
  2879.     DDX_Check(pDX, IDC_SQL_BP_OTHER_HSTMT, m_bSqlBpOtherHstmt);
  2880.     DDX_Check(pDX, IDC_SQL_BP_SCROLL, m_bSqlBpScroll);
  2881.     DDX_Check(pDX, IDC_SQL_BP_TRANSACTION, m_bSqlBpTransaction);
  2882.     DDX_Check(pDX, IDC_SQL_BP_UPDATE, m_bSqlBpUpdate);
  2883.     DDX_Check(pDX, IDC_SQL_LCK_EXCLUSIVE, m_bSqlLckExclusive);
  2884.     DDX_Check(pDX, IDC_SQL_LCK_NO_CHANGE, m_bSqlLckNoChange);
  2885.     DDX_Check(pDX, IDC_SQL_LCK_UNLOCK, m_bSqlLckUnlock);
  2886.     DDX_Check(pDX, IDC_SQL_SS_ADDITIONS, m_bSqlSsAdditions);
  2887.     DDX_Check(pDX, IDC_SQL_SS_DELETIONS, m_bSqlSsDeletions);
  2888.     DDX_Check(pDX, IDC_SQL_SS_UPDATES, m_bSqlSsUpdates);
  2889.     //}}AFX_DATA_MAP
  2890. }
  2891.  
  2892. BEGIN_MESSAGE_MAP(CMisc1, CPropertyPage)
  2893.     //{{AFX_MSG_MAP(CMisc1)
  2894.     //}}AFX_MSG_MAP
  2895. END_MESSAGE_MAP()
  2896.  
  2897. /////////////////////////////////////////////////////////////////////////////
  2898. // CMisc1 message handlers
  2899.  
  2900. void CMisc1::OnNewDSN()
  2901. {
  2902.     if (m_pDatabase->IsOpen())
  2903.     {
  2904.         SDWORD  longValue;
  2905.  
  2906.         switch (SQLGetInfoShort(SQL_TXN_CAPABLE))
  2907.         {
  2908.         case SQL_TC_NONE:
  2909.             m_strSqlTxnCapable = _T("None");
  2910.             m_strSqlCursorCommitBehavior = _T("<n/a>");
  2911.             m_strSqlCursorRollbackBehavior = _T("<n/a>");
  2912.             m_bSqlTxnReadUncommitted = FALSE;
  2913.             m_bSqlTxnReadCommitted = FALSE;
  2914.             m_bSqlTxnRepeatableRead = FALSE;
  2915.             m_bSqlTxnSerializable = FALSE;
  2916.             m_strSqlDefaultTxnIsolation = _T("<n/a>");
  2917.             m_strSqlMultipleActiveTxn = _T("<n/a>");
  2918.             if (IsWindow(m_hWnd))
  2919.                 UpdateData(FALSE);
  2920.             return;
  2921.         case SQL_TC_DML:
  2922.             m_strSqlTxnCapable = _T("DDL statements cause an error");
  2923.             break;
  2924.         case SQL_TC_DDL_COMMIT:
  2925.             m_strSqlTxnCapable = _T("DDL statements cause a commit");
  2926.             break;
  2927.         case SQL_TC_DDL_IGNORE:
  2928.             m_strSqlTxnCapable = _T("DDL statements are ignored");
  2929.             break;
  2930.         case SQL_TC_ALL:
  2931.             m_strSqlTxnCapable = _T("DDL and DML statements supported");
  2932.             break;
  2933.         }
  2934.  
  2935.         switch (SQLGetInfoShort(SQL_CURSOR_COMMIT_BEHAVIOR))
  2936.         {
  2937.         case SQL_CB_DELETE:
  2938.             m_strSqlCursorCommitBehavior = _T("Close Cursors, Delete Statements");
  2939.             break;
  2940.         case SQL_CB_CLOSE:
  2941.             m_strSqlCursorCommitBehavior = _T("Close Cursors");
  2942.             break;
  2943.         case SQL_CB_PRESERVE:
  2944.             m_strSqlCursorCommitBehavior = _T("Preserve Cursors");
  2945.             break;
  2946.         }
  2947.  
  2948.         switch (SQLGetInfoShort(SQL_CURSOR_ROLLBACK_BEHAVIOR))
  2949.         {
  2950.         case SQL_CB_DELETE:
  2951.             m_strSqlCursorRollbackBehavior = _T("Close Cursors, Delete Statements");
  2952.             break;
  2953.         case SQL_CB_CLOSE:
  2954.             m_strSqlCursorRollbackBehavior = _T("Close Cursors");
  2955.             break;
  2956.         case SQL_CB_PRESERVE:
  2957.             m_strSqlCursorRollbackBehavior = _T("Preserve Cursors");
  2958.             break;
  2959.         }
  2960.  
  2961.         longValue = SQLGetInfoLong(SQL_TXN_ISOLATION_OPTION);
  2962.         if (longValue & SQL_TXN_READ_UNCOMMITTED)
  2963.             m_bSqlTxnReadUncommitted = TRUE;
  2964.         else
  2965.             m_bSqlTxnReadUncommitted = FALSE;
  2966.         if (longValue & SQL_TXN_READ_COMMITTED)
  2967.             m_bSqlTxnReadCommitted = TRUE;
  2968.         else
  2969.             m_bSqlTxnReadCommitted = FALSE;
  2970.         if (longValue & SQL_TXN_REPEATABLE_READ)
  2971.             m_bSqlTxnRepeatableRead = TRUE;
  2972.         else
  2973.             m_bSqlTxnRepeatableRead = FALSE;
  2974.         if (longValue & SQL_TXN_SERIALIZABLE)
  2975.             m_bSqlTxnSerializable = TRUE;
  2976.         else
  2977.             m_bSqlTxnSerializable = FALSE;
  2978.  
  2979.         switch (SQLGetInfoLong(SQL_DEFAULT_TXN_ISOLATION))
  2980.         {
  2981.         case SQL_TXN_READ_UNCOMMITTED:
  2982.             m_strSqlDefaultTxnIsolation = _T("Read Uncommitted");
  2983.             break;
  2984.         case SQL_TXN_READ_COMMITTED:
  2985.             m_strSqlDefaultTxnIsolation = _T("Read Committed");
  2986.             break;
  2987.         case SQL_TXN_REPEATABLE_READ:
  2988.             m_strSqlDefaultTxnIsolation = _T("Repeatable Read");
  2989.             break;
  2990.         case SQL_TXN_SERIALIZABLE:
  2991.             m_strSqlDefaultTxnIsolation = _T("Serializable");
  2992.             break;
  2993.         }
  2994.         YIsSupported(m_strSqlMultipleActiveTxn,SQL_MULTIPLE_ACTIVE_TXN);
  2995.         longValue = SQLGetInfoLong(SQL_BOOKMARK_PERSISTENCE);
  2996.         if (longValue & SQL_BP_CLOSE)
  2997.             m_bSqlBpClose = TRUE;
  2998.         else
  2999.             m_bSqlBpClose = FALSE;
  3000.         if (longValue & SQL_BP_DELETE)
  3001.             m_bSqlBpDelete = TRUE;
  3002.         else
  3003.             m_bSqlBpDelete = FALSE;
  3004.         if (longValue & SQL_BP_DROP)
  3005.             m_bSqlBpDrop = TRUE;
  3006.         else
  3007.             m_bSqlBpDrop = FALSE;
  3008.         if (longValue & SQL_BP_SCROLL)
  3009.             m_bSqlBpScroll = TRUE;
  3010.         else
  3011.             m_bSqlBpScroll = FALSE;
  3012.         if (longValue & SQL_BP_TRANSACTION)
  3013.             m_bSqlBpTransaction = TRUE;
  3014.         else
  3015.             m_bSqlBpTransaction = FALSE;
  3016.         if (longValue & SQL_BP_UPDATE)
  3017.             m_bSqlBpUpdate = TRUE;
  3018.         else
  3019.             m_bSqlBpUpdate = FALSE;
  3020.         if (longValue & SQL_BP_OTHER_HSTMT)
  3021.             m_bSqlBpOtherHstmt = TRUE;
  3022.         else
  3023.             m_bSqlBpOtherHstmt = FALSE;
  3024.  
  3025.         longValue = SQLGetInfoLong(SQL_LOCK_TYPES);
  3026.         if (longValue & SQL_LCK_NO_CHANGE)
  3027.             m_bSqlLckNoChange = TRUE;
  3028.         else
  3029.             m_bSqlLckNoChange = FALSE;
  3030.         if (longValue & SQL_LCK_EXCLUSIVE)
  3031.             m_bSqlLckExclusive = TRUE;
  3032.         else
  3033.             m_bSqlLckExclusive = FALSE;
  3034.         if (longValue & SQL_LCK_UNLOCK)
  3035.             m_bSqlLckUnlock = TRUE;
  3036.         else
  3037.             m_bSqlLckUnlock = FALSE;
  3038.  
  3039.         longValue = SQLGetInfoLong(SQL_STATIC_SENSITIVITY);
  3040.         if (longValue & SQL_SS_ADDITIONS)
  3041.             m_bSqlSsAdditions = TRUE;
  3042.         else
  3043.             m_bSqlSsAdditions = FALSE;
  3044.         if (longValue & SQL_SS_DELETIONS)
  3045.             m_bSqlSsDeletions = TRUE;
  3046.         else
  3047.             m_bSqlSsDeletions = FALSE;
  3048.         if (longValue & SQL_SS_UPDATES)
  3049.             m_bSqlSsUpdates = TRUE;
  3050.         else
  3051.             m_bSqlSsUpdates = FALSE;
  3052.  
  3053.         if (IsWindow(m_hWnd))
  3054.             UpdateData(FALSE);
  3055.     }
  3056. }
  3057.  
  3058. BOOL CMisc1::OnInitDialog()
  3059. {
  3060.     CPropertyPage::OnInitDialog();
  3061.  
  3062.     UpdateData(FALSE);
  3063.  
  3064.     return TRUE;  // return TRUE unless you set the focus to a control
  3065.                   // EXCEPTION: OCX Property Pages should return FALSE
  3066. }
  3067.  
  3068. /////////////////////////////////////////////////////////////////////////////
  3069. // CMisc2 property page
  3070.  
  3071. IMPLEMENT_DYNCREATE(CMisc2, CPropertyPage)
  3072.  
  3073. CMisc2::CMisc2(CDatabase* pDatabase)
  3074.     : CMyPage(pDatabase,CMisc2::IDD)
  3075.  {
  3076.     //{{AFX_DATA_INIT(CMisc2)
  3077.     m_bSqlOuDmlStatements = FALSE;
  3078.     m_bSqlOuIndexDefinition = FALSE;
  3079.     m_bSqlOuPrivilegeDefinition = FALSE;
  3080.     m_bSqlOuProcedureInvocation = FALSE;
  3081.     m_bSqlOuTableDefinition = FALSE;
  3082.     m_bSqlQuDmlStatements = FALSE;
  3083.     m_bSqlQuIndexDefinition = FALSE;
  3084.     m_bSqlQuPrivilegeDefinition = FALSE;
  3085.     m_bSqlQuProcedureInvocation = FALSE;
  3086.     m_bSqlQuTableDefinition = FALSE;
  3087.     m_bSqlSoDynamic = FALSE;
  3088.     m_bSqlSoForwardOnly = FALSE;
  3089.     m_bSqlSoKeysetDriven = FALSE;
  3090.     m_bSqlSoMixed = FALSE;
  3091.     m_bSqlSoStatic = FALSE;
  3092.     m_bSqlSccoLock = FALSE;
  3093.     m_bSqlSccoOptRowver = FALSE;
  3094.     m_bSqlSccoOptValues = FALSE;
  3095.     m_bSqlSccoReadOnly = FALSE;
  3096.     m_bSqlPosAdd = FALSE;
  3097.     m_bSqlPosDelete = FALSE;
  3098.     m_bSqlPosPosition = FALSE;
  3099.     m_bSqlPosRefresh = FALSE;
  3100.     m_bSqlPosUpdate = FALSE;
  3101.     m_bSqlFdFetchAbsolute = FALSE;
  3102.     m_bSqlFdFetchBookmark = FALSE;
  3103.     m_bSqlFdFetchFirst = FALSE;
  3104.     m_bSqlFdFetchLast = FALSE;
  3105.     m_bSqlFdFetchNext = FALSE;
  3106.     m_bSqlFdFetchPrior = FALSE;
  3107.     m_bSqlFdFetchRelative = FALSE;
  3108.     m_bSqlGdAnyColumn = FALSE;
  3109.     m_bSqlGdAnyOrder = FALSE;
  3110.     m_bSqlGdBlock = FALSE;
  3111.     m_bSqlGdBound = FALSE;
  3112.     m_strSqlConcatNullBehavior = _T("");
  3113.     m_strSqlNeedLongDataLen = _T("");
  3114.     m_strSqlNonNullableColumns = _T("");
  3115.     m_strSqlNullCollation = _T("");
  3116.     m_strSqlProcedures = _T("");
  3117.     m_strSqlRowUpdates = _T("");
  3118.     //}}AFX_DATA_INIT
  3119.  
  3120.     OnNewDSN();
  3121. }
  3122.  
  3123. CMisc2::~CMisc2()
  3124. {
  3125. }
  3126.  
  3127. void CMisc2::DumpToFile(CStdioFile& file)
  3128. {
  3129.     if (m_pDatabase->IsOpen())
  3130.     {
  3131.         CString string;
  3132.         BOOL    b;
  3133.  
  3134.         string.Format(_T("    Need Long Data Length - %s\n"),m_strSqlNeedLongDataLen);
  3135.         file.WriteString(string);
  3136.         string.Format(_T("     Non-Nullable Columns - %s\n"),m_strSqlNonNullableColumns);
  3137.         file.WriteString(string);
  3138.         string.Format(_T("       Null Concatenation - %s\n"),m_strSqlConcatNullBehavior);
  3139.         file.WriteString(string);
  3140.         string.Format(_T("           Null Collation - %s\n"),m_strSqlNullCollation);
  3141.         file.WriteString(string);
  3142.         string.Format(_T("               Procedures - %s\n"),m_strSqlProcedures);
  3143.         file.WriteString(string);
  3144.         string.Format(_T("              Row Updates - %s\n"),m_strSqlRowUpdates);
  3145.         file.WriteString(string);
  3146.  
  3147.         file.WriteString(_T("          Fetch Direction - "));
  3148.         b = FALSE;
  3149.         if (m_bSqlFdFetchAbsolute)
  3150.         {
  3151.             file.WriteString(_T("Absolute"));
  3152.             b = TRUE;
  3153.         }
  3154.         if (m_bSqlFdFetchBookmark)
  3155.         {
  3156.             if (b)
  3157.                 file.WriteString(_T(","));
  3158.             file.WriteString(_T("Bookmark"));
  3159.             b = TRUE;
  3160.         }
  3161.         if (m_bSqlFdFetchFirst)
  3162.         {
  3163.             if (b)
  3164.                 file.WriteString(_T(","));
  3165.             file.WriteString(_T("First"));
  3166.             b = TRUE;
  3167.         }
  3168.         if (m_bSqlFdFetchLast)
  3169.         {
  3170.             if (b)
  3171.                 file.WriteString(_T(","));
  3172.             file.WriteString(_T("Last"));
  3173.             b = TRUE;
  3174.         }
  3175.         if (m_bSqlFdFetchNext)
  3176.         {
  3177.             if (b)
  3178.                 file.WriteString(_T(","));
  3179.             file.WriteString(_T("Next"));
  3180.             b = TRUE;
  3181.         }
  3182.         if (m_bSqlFdFetchPrior)
  3183.         {
  3184.             if (b)
  3185.                 file.WriteString(_T(","));
  3186.             file.WriteString(_T("Prior"));
  3187.             b = TRUE;
  3188.         }
  3189.         if (m_bSqlFdFetchRelative)
  3190.         {
  3191.             if (b)
  3192.                 file.WriteString(_T(","));
  3193.             file.WriteString(_T("Relative"));
  3194.             b = TRUE;
  3195.         }
  3196.         if (!b)
  3197.             file.WriteString(_T("<none>"));
  3198.         file.WriteString(_T("\n"));
  3199.  
  3200.         file.WriteString(_T("      Get Data Extensions - "));
  3201.         b = FALSE;
  3202.         if (m_bSqlGdAnyColumn)
  3203.         {
  3204.             file.WriteString(_T("Any Column"));
  3205.             b = TRUE;
  3206.         }
  3207.         if (m_bSqlGdAnyOrder)
  3208.         {
  3209.             if (b)
  3210.                 file.WriteString(_T(","));
  3211.             file.WriteString(_T("Any Order"));
  3212.             b = TRUE;
  3213.         }
  3214.         if (m_bSqlGdBlock)
  3215.         {
  3216.             if (b)
  3217.                 file.WriteString(_T(","));
  3218.             file.WriteString(_T("Block"));
  3219.             b = TRUE;
  3220.         }
  3221.         if (m_bSqlGdBound)
  3222.         {
  3223.             if (b)
  3224.                 file.WriteString(_T(","));
  3225.             file.WriteString(_T("Bound"));
  3226.             b = TRUE;
  3227.         }
  3228.         if (!b)
  3229.             file.WriteString(_T("<none>"));
  3230.         file.WriteString(_T("\n"));
  3231.  
  3232.         file.WriteString(_T("    Positioned Operations - "));
  3233.         b = FALSE;
  3234.         if (m_bSqlPosAdd)
  3235.         {
  3236.             file.WriteString(_T("Add"));
  3237.             b = TRUE;
  3238.         }
  3239.         if (m_bSqlPosDelete)
  3240.         {
  3241.             if (b)
  3242.                 file.WriteString(_T(","));
  3243.             file.WriteString(_T("Delete"));
  3244.             b = TRUE;
  3245.         }
  3246.         if (m_bSqlPosPosition)
  3247.         {
  3248.             if (b)
  3249.                 file.WriteString(_T(","));
  3250.             file.WriteString(_T("Position"));
  3251.             b = TRUE;
  3252.         }
  3253.         if (m_bSqlPosRefresh)
  3254.         {
  3255.             if (b)
  3256.                 file.WriteString(_T(","));
  3257.             file.WriteString(_T("Refresh"));
  3258.             b = TRUE;
  3259.         }
  3260.         if (m_bSqlPosUpdate)
  3261.         {
  3262.             if (b)
  3263.                 file.WriteString(_T(","));
  3264.             file.WriteString(_T("Update"));
  3265.             b = TRUE;
  3266.         }
  3267.         if (!b)
  3268.             file.WriteString(_T("<none>"));
  3269.         file.WriteString(_T("\n"));
  3270.  
  3271.         file.WriteString(_T("       Scroll Concurrency - "));
  3272.         b = FALSE;
  3273.         if (m_bSqlSccoLock)
  3274.         {
  3275.             file.WriteString(_T("Lock"));
  3276.             b = TRUE;
  3277.         }
  3278.         if (m_bSqlSccoOptRowver)
  3279.         {
  3280.             if (b)
  3281.                 file.WriteString(_T(","));
  3282.             file.WriteString(_T("Opt/RowVer"));
  3283.             b = TRUE;
  3284.         }
  3285.         if (m_bSqlSccoOptValues)
  3286.         {
  3287.             if (b)
  3288.                 file.WriteString(_T(","));
  3289.             file.WriteString(_T("Opt/Values"));
  3290.             b = TRUE;
  3291.         }
  3292.         if (m_bSqlSccoReadOnly)
  3293.         {
  3294.             if (b)
  3295.                 file.WriteString(_T(","));
  3296.             file.WriteString(_T("Read Only"));
  3297.             b = TRUE;
  3298.         }
  3299.         if (!b)
  3300.             file.WriteString(_T("<none>"));
  3301.         file.WriteString(_T("\n"));
  3302.  
  3303.         file.WriteString(_T("           Scroll Options - "));
  3304.         b = FALSE;
  3305.         if (m_bSqlSoDynamic)
  3306.         {
  3307.             file.WriteString(_T("Dynamic"));
  3308.             b = TRUE;
  3309.         }
  3310.         if (m_bSqlSoForwardOnly)
  3311.         {
  3312.             if (b)
  3313.                 file.WriteString(_T(","));
  3314.             file.WriteString(_T("Forward Only"));
  3315.             b = TRUE;
  3316.         }
  3317.         if (m_bSqlSoKeysetDriven)
  3318.         {
  3319.             if (b)
  3320.                 file.WriteString(_T(","));
  3321.             file.WriteString(_T("Keyset Driven"));
  3322.             b = TRUE;
  3323.         }
  3324.         if (m_bSqlSoMixed)
  3325.         {
  3326.             if (b)
  3327.                 file.WriteString(_T(","));
  3328.             file.WriteString(_T("Mixed"));
  3329.             b = TRUE;
  3330.         }
  3331.         if (m_bSqlSoStatic)
  3332.         {
  3333.             if (b)
  3334.                 file.WriteString(_T(","));
  3335.             file.WriteString(_T("Static"));
  3336.             b = TRUE;
  3337.         }
  3338.         if (!b)
  3339.             file.WriteString(_T("<none>"));
  3340.         file.WriteString(_T("\n"));
  3341.  
  3342.         file.WriteString(_T("              Owner Usage - "));
  3343.         b = FALSE;
  3344.         if (m_bSqlOuDmlStatements)
  3345.         {
  3346.             file.WriteString(_T("DML Stmt"));
  3347.             b = TRUE;
  3348.         }
  3349.         if (m_bSqlOuIndexDefinition)
  3350.         {
  3351.             if (b)
  3352.                 file.WriteString(_T(","));
  3353.             file.WriteString(_T("Index Def"));
  3354.             b = TRUE;
  3355.         }
  3356.         if (m_bSqlOuPrivilegeDefinition)
  3357.         {
  3358.             if (b)
  3359.                 file.WriteString(_T(","));
  3360.             file.WriteString(_T("Priv Def"));
  3361.             b = TRUE;
  3362.         }
  3363.         if (m_bSqlOuProcedureInvocation)
  3364.         {
  3365.             if (b)
  3366.                 file.WriteString(_T(","));
  3367.             file.WriteString(_T("Proc Invoke"));
  3368.             b = TRUE;
  3369.         }
  3370.         if (m_bSqlOuTableDefinition)
  3371.         {
  3372.             if (b)
  3373.                 file.WriteString(_T(","));
  3374.             file.WriteString(_T("Table Def"));
  3375.             b = TRUE;
  3376.         }
  3377.         if (!b)
  3378.             file.WriteString(_T("<none>"));
  3379.         file.WriteString(_T("\n"));
  3380.  
  3381.         file.WriteString(_T("          Qualifier Usage - "));
  3382.         b = FALSE;
  3383.         if (m_bSqlQuDmlStatements)
  3384.         {
  3385.             file.WriteString(_T("DML Stmt"));
  3386.             b = TRUE;
  3387.         }
  3388.         if (m_bSqlQuIndexDefinition)
  3389.         {
  3390.             if (b)
  3391.                 file.WriteString(_T(","));
  3392.             file.WriteString(_T("Index Def"));
  3393.             b = TRUE;
  3394.         }
  3395.         if (m_bSqlQuPrivilegeDefinition)
  3396.         {
  3397.             if (b)
  3398.                 file.WriteString(_T(","));
  3399.             file.WriteString(_T("Priv Def"));
  3400.             b = TRUE;
  3401.         }
  3402.         if (m_bSqlQuProcedureInvocation)
  3403.         {
  3404.             if (b)
  3405.                 file.WriteString(_T(","));
  3406.             file.WriteString(_T("Proc Invoke"));
  3407.             b = TRUE;
  3408.         }
  3409.         if (m_bSqlQuTableDefinition)
  3410.         {
  3411.             if (b)
  3412.                 file.WriteString(_T(","));
  3413.             file.WriteString(_T("Table Def"));
  3414.             b = TRUE;
  3415.         }
  3416.         if (!b)
  3417.             file.WriteString(_T("<none>"));
  3418.         file.WriteString(_T("\n"));
  3419.  
  3420.  
  3421.  
  3422.     }
  3423. }
  3424.  
  3425. void CMisc2::DoDataExchange(CDataExchange* pDX)
  3426. {
  3427.     CPropertyPage::DoDataExchange(pDX);
  3428.     //{{AFX_DATA_MAP(CMisc2)
  3429.     DDX_Check(pDX, IDC_SQL_OU_DML_STATEMENTS, m_bSqlOuDmlStatements);
  3430.     DDX_Check(pDX, IDC_SQL_OU_INDEX_DEFINITION, m_bSqlOuIndexDefinition);
  3431.     DDX_Check(pDX, IDC_SQL_OU_PRIVILEGE_DEFINITION, m_bSqlOuPrivilegeDefinition);
  3432.     DDX_Check(pDX, IDC_SQL_OU_PROCEDURE_INVOCATION, m_bSqlOuProcedureInvocation);
  3433.     DDX_Check(pDX, IDC_SQL_OU_TABLE_DEFINITION, m_bSqlOuTableDefinition);
  3434.     DDX_Check(pDX, IDC_SQL_QU_DML_STATEMENTS, m_bSqlQuDmlStatements);
  3435.     DDX_Check(pDX, IDC_SQL_QU_INDEX_DEFINITION, m_bSqlQuIndexDefinition);
  3436.     DDX_Check(pDX, IDC_SQL_QU_PRIVILEGE_DEFINITION, m_bSqlQuPrivilegeDefinition);
  3437.     DDX_Check(pDX, IDC_SQL_QU_PROCEDURE_INVOCATION, m_bSqlQuProcedureInvocation);
  3438.     DDX_Check(pDX, IDC_SQL_QU_TABLE_DEFINITION, m_bSqlQuTableDefinition);
  3439.     DDX_Check(pDX, IDC_SQL_SO_DYNAMIC, m_bSqlSoDynamic);
  3440.     DDX_Check(pDX, IDC_SQL_SO_FORWARD_ONLY, m_bSqlSoForwardOnly);
  3441.     DDX_Check(pDX, IDC_SQL_SO_KEYSET_DRIVEN, m_bSqlSoKeysetDriven);
  3442.     DDX_Check(pDX, IDC_SQL_SO_MIXED, m_bSqlSoMixed);
  3443.     DDX_Check(pDX, IDC_SQL_SO_STATIC, m_bSqlSoStatic);
  3444.     DDX_Check(pDX, IDC_SQL_SCCO_LOCK, m_bSqlSccoLock);
  3445.     DDX_Check(pDX, IDC_SQL_SCCO_OPT_ROWVER, m_bSqlSccoOptRowver);
  3446.     DDX_Check(pDX, IDC_SQL_SCCO_OPT_VALUES, m_bSqlSccoOptValues);
  3447.     DDX_Check(pDX, IDC_SQL_SCCO_READ_ONLY, m_bSqlSccoReadOnly);
  3448.     DDX_Check(pDX, IDC_SQL_POS_ADD, m_bSqlPosAdd);
  3449.     DDX_Check(pDX, IDC_SQL_POS_DELETE, m_bSqlPosDelete);
  3450.     DDX_Check(pDX, IDC_SQL_POS_POSITION, m_bSqlPosPosition);
  3451.     DDX_Check(pDX, IDC_SQL_POS_REFRESH, m_bSqlPosRefresh);
  3452.     DDX_Check(pDX, IDC_SQL_POS_UPDATE, m_bSqlPosUpdate);
  3453.     DDX_Check(pDX, IDC_SQL_FD_FETCH_ABSOLUTE, m_bSqlFdFetchAbsolute);
  3454.     DDX_Check(pDX, IDC_SQL_FD_FETCH_BOOKMARK, m_bSqlFdFetchBookmark);
  3455.     DDX_Check(pDX, IDC_SQL_FD_FETCH_FIRST, m_bSqlFdFetchFirst);
  3456.     DDX_Check(pDX, IDC_SQL_FD_FETCH_LAST, m_bSqlFdFetchLast);
  3457.     DDX_Check(pDX, IDC_SQL_FD_FETCH_NEXT, m_bSqlFdFetchNext);
  3458.     DDX_Check(pDX, IDC_SQL_FD_FETCH_PRIOR, m_bSqlFdFetchPrior);
  3459.     DDX_Check(pDX, IDC_SQL_FD_FETCH_RELATIVE, m_bSqlFdFetchRelative);
  3460.     DDX_Check(pDX, IDC_SQL_GD_ANY_COLUMN, m_bSqlGdAnyColumn);
  3461.     DDX_Check(pDX, IDC_SQL_GD_ANY_ORDER, m_bSqlGdAnyOrder);
  3462.     DDX_Check(pDX, IDC_SQL_GD_BLOCK, m_bSqlGdBlock);
  3463.     DDX_Check(pDX, IDC_SQL_GD_BOUND, m_bSqlGdBound);
  3464.     DDX_Text(pDX, IDC_SQL_CONCAT_NULL_BEHAVIOR, m_strSqlConcatNullBehavior);
  3465.     DDX_Text(pDX, IDC_SQL_NEED_LONG_DATA_LEN, m_strSqlNeedLongDataLen);
  3466.     DDX_Text(pDX, IDC_SQL_NON_NULLABLE_COLUMNS, m_strSqlNonNullableColumns);
  3467.     DDX_Text(pDX, IDC_SQL_NULL_COLLATION, m_strSqlNullCollation);
  3468.     DDX_Text(pDX, IDC_SQL_PROCEDURES, m_strSqlProcedures);
  3469.     DDX_Text(pDX, IDC_SQL_ROW_UPDATES, m_strSqlRowUpdates);
  3470.     //}}AFX_DATA_MAP
  3471. }
  3472.  
  3473.  
  3474. BEGIN_MESSAGE_MAP(CMisc2, CPropertyPage)
  3475.     //{{AFX_MSG_MAP(CMisc2)
  3476.     //}}AFX_MSG_MAP
  3477. END_MESSAGE_MAP()
  3478.  
  3479. /////////////////////////////////////////////////////////////////////////////
  3480. // CMisc2 message handlers
  3481.  
  3482. void CMisc2::OnNewDSN()
  3483. {
  3484.     if (m_pDatabase->IsOpen())
  3485.     {
  3486.         SDWORD  longValue;
  3487.  
  3488.         YIsYes(m_strSqlNeedLongDataLen,SQL_NEED_LONG_DATA_LEN);
  3489.         switch (SQLGetInfoShort(SQL_NON_NULLABLE_COLUMNS))
  3490.         {
  3491.         case SQL_NNC_NULL:
  3492.             m_strSqlNonNullableColumns = _T("Not Supported");
  3493.             break;
  3494.         case SQL_NNC_NON_NULL:
  3495.             m_strSqlNonNullableColumns = _T("Supported");
  3496.             break;
  3497.         }
  3498.         switch (SQLGetInfoShort(SQL_CONCAT_NULL_BEHAVIOR))
  3499.         {
  3500.         case SQL_CB_NULL:
  3501.             m_strSqlConcatNullBehavior = _T("Result is NULL");
  3502.             break;
  3503.         case SQL_CB_NON_NULL:
  3504.             m_strSqlConcatNullBehavior = _T("Result is not NULL");
  3505.             break;
  3506.         }
  3507.         switch (SQLGetInfoShort(SQL_NULL_COLLATION))
  3508.         {
  3509.         case SQL_NC_END:
  3510.             m_strSqlNullCollation = _T("End");
  3511.             break;
  3512.         case SQL_NC_HIGH:
  3513.             m_strSqlNullCollation = _T("High");
  3514.             break;
  3515.         case SQL_NC_LOW:
  3516.             m_strSqlNullCollation = _T("Low");
  3517.             break;
  3518.         case SQL_NC_START:
  3519.             m_strSqlNullCollation = _T("Start");
  3520.             break;
  3521.         }
  3522.         YIsSupported(m_strSqlProcedures,SQL_PROCEDURES);
  3523.         YIsYes(m_strSqlRowUpdates,SQL_ROW_UPDATES);
  3524.         longValue = SQLGetInfoLong(SQL_FETCH_DIRECTION);
  3525.         if (longValue & SQL_FD_FETCH_NEXT)
  3526.             m_bSqlFdFetchNext = TRUE;
  3527.         else
  3528.             m_bSqlFdFetchNext = FALSE;
  3529.         if (longValue & SQL_FD_FETCH_FIRST)
  3530.             m_bSqlFdFetchFirst = TRUE;
  3531.         else
  3532.             m_bSqlFdFetchFirst = FALSE;
  3533.         if (longValue & SQL_FD_FETCH_LAST)
  3534.             m_bSqlFdFetchLast = TRUE;
  3535.         else
  3536.             m_bSqlFdFetchLast = FALSE;
  3537.         if (longValue & SQL_FD_FETCH_PRIOR)
  3538.             m_bSqlFdFetchPrior = TRUE;
  3539.         else
  3540.             m_bSqlFdFetchPrior = FALSE;
  3541.         if (longValue & SQL_FD_FETCH_ABSOLUTE)
  3542.             m_bSqlFdFetchAbsolute = TRUE;
  3543.         else
  3544.             m_bSqlFdFetchAbsolute = FALSE;
  3545.         if (longValue & SQL_FD_FETCH_RELATIVE)
  3546.             m_bSqlFdFetchRelative = TRUE;
  3547.         else
  3548.             m_bSqlFdFetchRelative = FALSE;
  3549.         if (longValue & SQL_FD_FETCH_BOOKMARK)
  3550.             m_bSqlFdFetchBookmark = TRUE;
  3551.         else
  3552.             m_bSqlFdFetchBookmark = FALSE;
  3553.  
  3554.         longValue = SQLGetInfoLong(SQL_GETDATA_EXTENSIONS);
  3555.         if (longValue & SQL_GD_ANY_COLUMN)
  3556.             m_bSqlGdAnyColumn = TRUE;
  3557.         else
  3558.             m_bSqlGdAnyColumn = FALSE;
  3559.         if (longValue & SQL_GD_ANY_ORDER)
  3560.             m_bSqlGdAnyOrder = TRUE;
  3561.         else
  3562.             m_bSqlGdAnyOrder = FALSE;
  3563.         if (longValue & SQL_GD_BLOCK)
  3564.             m_bSqlGdBlock = TRUE;
  3565.         else
  3566.             m_bSqlGdBlock = FALSE;
  3567.         if (longValue & SQL_GD_BOUND)
  3568.             m_bSqlGdBound = TRUE;
  3569.         else
  3570.             m_bSqlGdBound = FALSE;
  3571.  
  3572.         longValue = SQLGetInfoLong(SQL_POS_OPERATIONS);
  3573.         if (longValue & SQL_POS_POSITION)
  3574.             m_bSqlPosPosition = TRUE;
  3575.         else
  3576.             m_bSqlPosPosition = FALSE;
  3577.         if (longValue & SQL_POS_REFRESH)
  3578.             m_bSqlPosRefresh = TRUE;
  3579.         else
  3580.             m_bSqlPosRefresh = FALSE;
  3581.         if (longValue & SQL_POS_UPDATE)
  3582.             m_bSqlPosUpdate = TRUE;
  3583.         else
  3584.             m_bSqlPosUpdate = FALSE;
  3585.         if (longValue & SQL_POS_DELETE)
  3586.             m_bSqlPosDelete = TRUE;
  3587.         else
  3588.             m_bSqlPosDelete = FALSE;
  3589.         if (longValue & SQL_POS_ADD)
  3590.             m_bSqlPosAdd = TRUE;
  3591.         else
  3592.             m_bSqlPosAdd = FALSE;
  3593.  
  3594.         longValue = SQLGetInfoLong(SQL_SCROLL_CONCURRENCY);
  3595.         if (longValue & SQL_SCCO_READ_ONLY)
  3596.             m_bSqlSccoReadOnly = TRUE;
  3597.         else
  3598.             m_bSqlSccoReadOnly = FALSE;
  3599.         if (longValue & SQL_SCCO_LOCK)
  3600.             m_bSqlSccoLock = TRUE;
  3601.         else
  3602.             m_bSqlSccoLock = FALSE;
  3603.         if (longValue & SQL_SCCO_OPT_ROWVER)
  3604.             m_bSqlSccoOptRowver = TRUE;
  3605.         else
  3606.             m_bSqlSccoOptRowver = FALSE;
  3607.         if (longValue & SQL_SCCO_OPT_VALUES)
  3608.             m_bSqlSccoOptValues = TRUE;
  3609.         else
  3610.             m_bSqlSccoOptValues = FALSE;
  3611.  
  3612.         longValue = SQLGetInfoLong(SQL_SCROLL_OPTIONS);
  3613.         if (longValue & SQL_SO_FORWARD_ONLY)
  3614.             m_bSqlSoForwardOnly = TRUE;
  3615.         else
  3616.             m_bSqlSoForwardOnly = FALSE;
  3617.         if (longValue & SQL_SO_STATIC)
  3618.             m_bSqlSoStatic = TRUE;
  3619.         else
  3620.             m_bSqlSoStatic = FALSE;
  3621.         if (longValue & SQL_SO_KEYSET_DRIVEN)
  3622.             m_bSqlSoKeysetDriven = TRUE;
  3623.         else
  3624.             m_bSqlSoKeysetDriven = FALSE;
  3625.         if (longValue & SQL_SO_DYNAMIC)
  3626.             m_bSqlSoDynamic = TRUE;
  3627.         else
  3628.             m_bSqlSoDynamic = FALSE;
  3629.         if (longValue & SQL_SO_MIXED)
  3630.             m_bSqlSoMixed = TRUE;
  3631.         else
  3632.             m_bSqlSoMixed = FALSE;
  3633.  
  3634.         longValue = SQLGetInfoLong(SQL_OWNER_USAGE);
  3635.         if (longValue & SQL_OU_DML_STATEMENTS)
  3636.             m_bSqlOuDmlStatements = TRUE;
  3637.         else
  3638.             m_bSqlOuDmlStatements = FALSE;
  3639.         if (longValue & SQL_OU_PROCEDURE_INVOCATION)
  3640.             m_bSqlOuProcedureInvocation = TRUE;
  3641.         else
  3642.             m_bSqlOuProcedureInvocation = FALSE;
  3643.         if (longValue & SQL_OU_TABLE_DEFINITION)
  3644.             m_bSqlOuTableDefinition = TRUE;
  3645.         else
  3646.             m_bSqlOuTableDefinition = FALSE;
  3647.         if (longValue & SQL_OU_INDEX_DEFINITION)
  3648.             m_bSqlOuIndexDefinition = TRUE;
  3649.         else
  3650.             m_bSqlOuIndexDefinition = FALSE;
  3651.         if (longValue & SQL_OU_PRIVILEGE_DEFINITION)
  3652.             m_bSqlOuPrivilegeDefinition = TRUE;
  3653.         else
  3654.             m_bSqlOuPrivilegeDefinition = FALSE;
  3655.  
  3656.         longValue = SQLGetInfoLong(SQL_QUALIFIER_USAGE);
  3657.         if (longValue & SQL_QU_DML_STATEMENTS)
  3658.             m_bSqlQuDmlStatements = TRUE;
  3659.         else
  3660.             m_bSqlQuDmlStatements = FALSE;
  3661.         if (longValue & SQL_QU_PROCEDURE_INVOCATION)
  3662.             m_bSqlQuProcedureInvocation = TRUE;
  3663.         else
  3664.             m_bSqlQuProcedureInvocation = FALSE;
  3665.         if (longValue & SQL_QU_TABLE_DEFINITION)
  3666.             m_bSqlQuTableDefinition = TRUE;
  3667.         else
  3668.             m_bSqlQuTableDefinition = FALSE;
  3669.         if (longValue & SQL_QU_INDEX_DEFINITION)
  3670.             m_bSqlQuIndexDefinition = TRUE;
  3671.         else
  3672.             m_bSqlQuIndexDefinition = FALSE;
  3673.         if (longValue & SQL_QU_PRIVILEGE_DEFINITION)
  3674.             m_bSqlQuPrivilegeDefinition = TRUE;
  3675.         else
  3676.             m_bSqlQuPrivilegeDefinition = FALSE;
  3677.  
  3678.         if (IsWindow(m_hWnd))
  3679.             UpdateData(FALSE);
  3680.     }
  3681. }
  3682.  
  3683. BOOL CMisc2::OnInitDialog()
  3684. {
  3685.     CPropertyPage::OnInitDialog();
  3686.  
  3687.     UpdateData(FALSE);
  3688.  
  3689.     return TRUE;  // return TRUE unless you set the focus to a control
  3690.                   // EXCEPTION: OCX Property Pages should return FALSE
  3691. }
  3692.