home *** CD-ROM | disk | FTP | other *** search
/ QBasic & Borland Pascal & C / Delphi5.iso / C / BC_502 / CATALG2.PAK / CATSETS.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1997-05-06  |  24.1 KB  |  979 lines
  1. // catsets.cpp
  2.  
  3. // This is a part of the Microsoft Foundation Classes C++ library.
  4. // Copyright (C) 1992-1995 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 "catsets.h"
  15.  
  16. //---------------------------------------------------------------------
  17. // CColumnPrivileges
  18.  
  19. CColumnPrivileges::CColumnPrivileges(CDatabase* pDatabase)
  20.     : CRecordset(pDatabase)
  21. {
  22.     m_strTableQualifier    = _T("");
  23.     m_strTableOwner        = _T("");
  24.     m_strTableName        = _T("");
  25.     m_strColumnName        = _T("");
  26.     m_strGrantor        = _T("");
  27.     m_strGrantee        = _T("");
  28.     m_strPrivilege        = _T("");
  29.     m_strIsGrantable    = _T("");
  30.     m_nFields = 8;
  31. }
  32.  
  33. BOOL CColumnPrivileges::Open(LPCSTR pszTableQualifier,
  34.     LPCSTR pszTableOwner,LPCSTR pszTableName,LPCSTR pszColumnName,
  35.     UINT nOpenType)
  36. {
  37.     RETCODE    nRetCode;
  38.     UWORD    bFunctionExists;
  39.  
  40.     // make sure SQLColumnPrivileges is supported
  41.     AFX_SQL_SYNC(::SQLGetFunctions(m_pDatabase->m_hdbc,
  42.         SQL_API_SQLCOLUMNPRIVILEGES,&bFunctionExists));
  43.     if (!Check(nRetCode) || !bFunctionExists)
  44.     {
  45.         if (!bFunctionExists)
  46.             TRACE(_T("SQLColumnPrivileges not supported\n"));
  47.         return FALSE;
  48.     }
  49.  
  50.     m_nOpenType = nOpenType;
  51.     m_bUpdatable = FALSE;
  52.  
  53.     // make sure hstmt is allocated
  54.     if (m_hstmt == SQL_NULL_HSTMT)
  55.     {
  56.         AFX_SQL_SYNC(::SQLAllocStmt(m_pDatabase->m_hdbc,&m_hstmt));
  57.         if (!Check(nRetCode))
  58.             ThrowDBException(nRetCode,m_hstmt);
  59.     }
  60.  
  61.     OnSetOptions(m_hstmt);
  62.  
  63.     // call the ODBC function
  64.     AFX_SQL_ASYNC(this,::SQLColumnPrivileges(m_hstmt,
  65.         (UCHAR FAR*)pszTableQualifier,SQL_NTS,
  66.         (UCHAR FAR*)pszTableOwner,SQL_NTS,
  67.         (UCHAR FAR*)pszTableName,SQL_NTS,
  68.         (UCHAR FAR*)pszColumnName,SQL_NTS));
  69.  
  70.      if (!Check(nRetCode))
  71.         ThrowDBException(nRetCode,m_hstmt);
  72.  
  73.     TRY
  74.     {
  75.         MoveFirst();
  76.     }
  77.     CATCH_ALL(e)
  78.     {
  79.         Close();
  80.         THROW_LAST();
  81.     }
  82.     END_CATCH_ALL
  83.  
  84.     return TRUE;
  85. }
  86.  
  87. void CColumnPrivileges::DoFieldExchange(CFieldExchange* pFX)
  88. {
  89.     pFX->SetFieldType(CFieldExchange::outputColumn);
  90.     RFX_Text(pFX,_T("TABLE_QUALIFIER"),m_strTableQualifier);
  91.     RFX_Text(pFX,_T("TABLE_OWNER"),m_strTableOwner);
  92.     RFX_Text(pFX,_T("TABLE_NAME"),m_strTableName);
  93.     RFX_Text(pFX,_T("COLUMN_NAME"),m_strColumnName);
  94.     RFX_Text(pFX,_T("GRANTOR"),m_strGrantor);
  95.     RFX_Text(pFX,_T("GRANTEE"),m_strGrantee);
  96.     RFX_Text(pFX,_T("PRIVILEGE"),m_strPrivilege);
  97.     RFX_Text(pFX,_T("IS_GRANTABLE"),m_strIsGrantable);
  98. }
  99.  
  100. //---------------------------------------------------------------------
  101. // CColumns
  102.  
  103. CColumns::CColumns(CDatabase* pDatabase)
  104.     : CRecordset(pDatabase)
  105. {
  106.     m_strTableQualifier    = _T("");
  107.     m_strTableOwner        = _T("");
  108.     m_strTableName        = _T("");
  109.     m_strColumnName        = _T("");
  110.     m_nDataType            = 0;
  111.     m_strTypeName        = _T("");
  112.     m_nPrecision        = 0;
  113.     m_nLength            = 0;
  114.     m_nScale            = 0;
  115.     m_nRadix            = 0;
  116.     m_fNullable            = 0;
  117.     m_strRemarks        = _T("");
  118.     m_nFields = 12;
  119. }
  120.  
  121. BOOL CColumns::Open(LPCSTR pszTableQualifier,
  122.     LPCSTR pszTableOwner,LPCSTR pszTableName,LPCSTR pszColumnName,
  123.     UINT nOpenType)
  124. {
  125.     RETCODE    nRetCode;
  126.     UWORD    bFunctionExists;
  127.  
  128.     // make sure SQLColumns is supported
  129.     AFX_SQL_SYNC(::SQLGetFunctions(m_pDatabase->m_hdbc,
  130.         SQL_API_SQLCOLUMNS,&bFunctionExists));
  131.     if (!Check(nRetCode) || !bFunctionExists)
  132.     {
  133.         if (!bFunctionExists)
  134.             TRACE(_T("SQLColumns not supported\n"));
  135.         return FALSE;
  136.     }
  137.  
  138.     m_nOpenType = nOpenType;
  139.     m_bUpdatable = FALSE;
  140.  
  141.     // make sure hstmt is allocated
  142.     if (m_hstmt == SQL_NULL_HSTMT)
  143.     {
  144.         AFX_SQL_SYNC(::SQLAllocStmt(m_pDatabase->m_hdbc,&m_hstmt));
  145.         if (!Check(nRetCode))
  146.             ThrowDBException(nRetCode,m_hstmt);
  147.     }
  148.  
  149.     OnSetOptions(m_hstmt);
  150.  
  151.     // call the ODBC function
  152.     AFX_SQL_ASYNC(this,::SQLColumns(m_hstmt,
  153.         (UCHAR FAR*)pszTableQualifier,SQL_NTS,
  154.         (UCHAR FAR*)pszTableOwner,SQL_NTS,
  155.         (UCHAR FAR*)pszTableName,SQL_NTS,
  156.         (UCHAR FAR*)pszColumnName,SQL_NTS));
  157.  
  158.      if (!Check(nRetCode))
  159.         ThrowDBException(nRetCode,m_hstmt);
  160.  
  161.     TRY
  162.     {
  163.         MoveFirst();
  164.     }
  165.     CATCH_ALL(e)
  166.     {
  167.         Close();
  168.         THROW_LAST();
  169.     }
  170.     END_CATCH_ALL
  171.  
  172.     return TRUE;
  173. }
  174.  
  175. void CColumns::DoFieldExchange(CFieldExchange* pFX)
  176. {
  177.     pFX->SetFieldType(CFieldExchange::outputColumn);
  178.     RFX_Text(pFX,_T("TABLE_QUALIFIER"),m_strTableQualifier);
  179.     RFX_Text(pFX,_T("TABLE_OWNER"),m_strTableOwner);
  180.     RFX_Text(pFX,_T("TABLE_NAME"),m_strTableName);
  181.     RFX_Text(pFX,_T("COLUMN_NAME"),m_strColumnName);
  182.     RFX_Int(pFX,_T("DATA_TYPE"),m_nDataType);
  183.     RFX_Text(pFX,_T("TYPE_NAME"),m_strTypeName);
  184.     RFX_Long(pFX,_T("PRECISION"),m_nPrecision);
  185.     RFX_Long(pFX,_T("LENGTH"),m_nLength);
  186.     RFX_Int(pFX,_T("SCALE"),m_nScale);
  187.     RFX_Int(pFX,_T("RADIX"),m_nRadix);
  188.     RFX_Int(pFX,_T("NULLABLE"),m_fNullable);
  189.     RFX_Text(pFX,_T("REMARKS"),m_strRemarks);
  190. }
  191.  
  192. //---------------------------------------------------------------------
  193. // CForeignKeys
  194.  
  195. CForeignKeys::CForeignKeys(CDatabase* pDatabase)
  196.     : CRecordset(pDatabase)
  197. {
  198.  
  199.     m_strPkTableQualifier    = _T("");
  200.     m_strPkTableOwner        = _T("");
  201.     m_strPkTableName        = _T("");
  202.     m_strPkColumnName        = _T("");
  203.     m_strFkTableQualifier    = _T("");
  204.     m_strFkTableOwner        = _T("");
  205.     m_strFkTableName        = _T("");
  206.     m_strFkColumnName        = _T("");
  207.     m_nKeySeq                = 0;
  208.     m_fUpdateRule            = 0;
  209.     m_fDeleteRule            = 0;
  210.     m_strFkName                = _T("");
  211.     m_strPkName                = _T("");
  212.     m_nFields = 13;
  213. }
  214.  
  215. BOOL CForeignKeys::Open(LPCSTR pszPkTableQualifier,
  216.     LPCSTR pszPkTableOwner,LPCSTR pszPkTableName,LPCSTR pszFkTableQualifier,
  217.     LPCSTR pszFkTableOwner,LPCSTR pszFkTableName,
  218.     UINT nOpenType)
  219. {
  220.     RETCODE    nRetCode;
  221.     UWORD    bFunctionExists;
  222.  
  223.     // make sure SQLForeignKeys is supported
  224.     AFX_SQL_SYNC(::SQLGetFunctions(m_pDatabase->m_hdbc,
  225.         SQL_API_SQLFOREIGNKEYS,&bFunctionExists));
  226.     if (!Check(nRetCode) || !bFunctionExists)
  227.     {
  228.         if (!bFunctionExists)
  229.             TRACE(_T("SQLForeignKeys not supported\n"));
  230.         return FALSE;
  231.     }
  232.  
  233.     m_nOpenType = nOpenType;
  234.     m_bUpdatable = FALSE;
  235.  
  236.     // make sure hstmt is allocated
  237.     if (m_hstmt == SQL_NULL_HSTMT)
  238.     {
  239.         AFX_SQL_SYNC(::SQLAllocStmt(m_pDatabase->m_hdbc,&m_hstmt));
  240.         if (!Check(nRetCode))
  241.             ThrowDBException(nRetCode,m_hstmt);
  242.     }
  243.  
  244.     OnSetOptions(m_hstmt);
  245.  
  246.     // call the ODBC function
  247.     AFX_SQL_ASYNC(this,::SQLForeignKeys(m_hstmt,
  248.         (UCHAR FAR*)pszPkTableQualifier,SQL_NTS,
  249.         (UCHAR FAR*)pszPkTableOwner,SQL_NTS,
  250.         (UCHAR FAR*)pszPkTableName,SQL_NTS,
  251.         (UCHAR FAR*)pszFkTableQualifier,SQL_NTS,
  252.         (UCHAR FAR*)pszFkTableOwner,SQL_NTS,
  253.         (UCHAR FAR*)pszFkTableName,SQL_NTS));
  254.  
  255.      if (!Check(nRetCode))
  256.         ThrowDBException(nRetCode,m_hstmt);
  257.  
  258.     TRY
  259.     {
  260.         MoveFirst();
  261.     }
  262.     CATCH_ALL(e)
  263.     {
  264.         Close();
  265.         THROW_LAST();
  266.     }
  267.     END_CATCH_ALL
  268.  
  269.     return TRUE;
  270. }
  271.  
  272. void CForeignKeys::DoFieldExchange(CFieldExchange* pFX)
  273. {
  274.     pFX->SetFieldType(CFieldExchange::outputColumn);
  275.     RFX_Text(pFX,_T("PKTABLE_QUALIFIER"),m_strPkTableQualifier);
  276.     RFX_Text(pFX,_T("PKTABLE_OWNER"),m_strPkTableOwner);
  277.     RFX_Text(pFX,_T("PKTABLE_NAME"),m_strPkTableName);
  278.     RFX_Text(pFX,_T("PKCOLUMN_NAME"),m_strPkColumnName);
  279.     RFX_Text(pFX,_T("FKTABLE_QUALIFIER"),m_strFkTableQualifier);
  280.     RFX_Text(pFX,_T("FKTABLE_OWNER"),m_strFkTableOwner);
  281.     RFX_Text(pFX,_T("FKTABLE_NAME"),m_strFkTableName);
  282.     RFX_Text(pFX,_T("FKCOLUMN_NAME"),m_strFkColumnName);
  283.     RFX_Int(pFX,_T("KEY_SEQ"),m_nKeySeq);
  284.     RFX_Int(pFX,_T("UPDATE_RULE"),m_fUpdateRule);
  285.     RFX_Int(pFX,_T("DELETE_RULE"),m_fDeleteRule);
  286.     RFX_Text(pFX,_T("FK_NAME"),m_strFkName);
  287.     RFX_Text(pFX,_T("PK_NAME"),m_strPkName);
  288. }
  289.  
  290. //---------------------------------------------------------------------
  291. // CGetTypeInfo
  292.  
  293. CGetTypeInfo::CGetTypeInfo(CDatabase* pDatabase)
  294.     : CRecordset(pDatabase)
  295. {
  296.     m_strTypeName            = _T("");
  297.     m_fDataType                = 0;
  298.     m_nPrecision            = 0;
  299.     m_strLiteralPrefix        = _T("");
  300.     m_strLiteralSuffix        = _T("");
  301.     m_strCreateParams        = _T("");
  302.     m_fNullable                = 0;
  303.     m_bCaseSensitive        = 0;
  304.     m_fSearchable            = 0;
  305.     m_fUnsignedAttribute    = 0;
  306.     m_bMoney                = 0;
  307.     m_fAutoIncrement        = 0;
  308.     m_strLocalTypeName        = _T("");
  309.     m_nMinimumScale            = 0;
  310.     m_nMaximumScale            = 0;
  311.     m_nFields = 15;
  312. }
  313.  
  314. BOOL CGetTypeInfo::Open(short fSqlType,
  315.     UINT nOpenType)
  316. {
  317.     RETCODE    nRetCode;
  318.     UWORD    bFunctionExists;
  319.  
  320.     // make suer SQLGetTypeInfo exists
  321.     AFX_SQL_SYNC(::SQLGetFunctions(m_pDatabase->m_hdbc,
  322.         SQL_API_SQLGETTYPEINFO,&bFunctionExists));
  323.     if (!Check(nRetCode) || !bFunctionExists)
  324.     {
  325.         if (!bFunctionExists)
  326.             TRACE(_T("SQLGetTypeInfo not supported\n"));
  327.         return FALSE;
  328.     }
  329.  
  330.     m_nOpenType = nOpenType;
  331.     m_bUpdatable = FALSE;
  332.  
  333.     // make sure hstmt is allocated
  334.     if (m_hstmt == SQL_NULL_HSTMT)
  335.     {
  336.         AFX_SQL_SYNC(::SQLAllocStmt(m_pDatabase->m_hdbc,&m_hstmt));
  337.         if (!Check(nRetCode))
  338.             ThrowDBException(nRetCode,m_hstmt);
  339.     }
  340.  
  341.     OnSetOptions(m_hstmt);
  342.  
  343.     // call the ODBC function
  344.     AFX_SQL_ASYNC(this,::SQLGetTypeInfo(m_hstmt,fSqlType));
  345.  
  346.      if (!Check(nRetCode))
  347.         ThrowDBException(nRetCode,m_hstmt);
  348.  
  349.     TRY
  350.     {
  351.         MoveFirst();
  352.     }
  353.  
  354.     CATCH_ALL(e)
  355.     {
  356.         Close();
  357.         THROW_LAST();
  358.     }
  359.     END_CATCH_ALL
  360.  
  361.     return TRUE;
  362. }
  363.  
  364. void CGetTypeInfo::DoFieldExchange(CFieldExchange* pFX)
  365. {
  366.     pFX->SetFieldType(CFieldExchange::outputColumn);
  367.     RFX_Text(pFX,_T("TYPE_NAME"),m_strTypeName);
  368.     RFX_Int(pFX,_T("DATA_TYPE"),m_fDataType);
  369.     RFX_Long(pFX,_T("PRECISION"),m_nPrecision);
  370.     RFX_Text(pFX,_T("LITERAL_PREFIX"),m_strLiteralPrefix);
  371.     RFX_Text(pFX,_T("LITERAL_SUFFIX"),m_strLiteralSuffix);
  372.     RFX_Text(pFX,_T("CREATE_PARAMS"),m_strCreateParams);
  373.     RFX_Int(pFX,_T("NULLABLE"),m_fNullable);
  374.     RFX_Bool(pFX,_T("CASE_SENSITIVE"),m_bCaseSensitive);
  375.     RFX_Int(pFX,_T("SEARCHABLE"),m_fSearchable);
  376.     RFX_Int(pFX,_T("UNSIGNED_ATTRIBUTE"),m_fUnsignedAttribute);
  377.     RFX_Bool(pFX,_T("MONEY"),m_bMoney);
  378.     RFX_Int(pFX,_T("AUTO_INCREMENT"),m_fAutoIncrement);
  379.     RFX_Text(pFX,_T("LOCAL_TYPE_NAME"),m_strLocalTypeName);
  380.     RFX_Int(pFX,_T("MINIMUM_SCALE"),m_nMinimumScale);
  381.     RFX_Int(pFX,_T("MAXIMUM_SCALE"),m_nMaximumScale);
  382. }
  383.  
  384. //---------------------------------------------------------------------
  385. // CPrimaryKeys
  386.  
  387. CPrimaryKeys::CPrimaryKeys(CDatabase* pDatabase)
  388.     : CRecordset(pDatabase)
  389. {
  390.     m_strTableQualifier    = _T("");
  391.     m_strTableOwner        = _T("");
  392.     m_strTableName        = _T("");
  393.     m_strColumnName        = _T("");
  394.     m_nKeySeq            = 0;
  395.     m_strPkName            = _T("");
  396.     m_nFields = 6;
  397. }
  398.  
  399. BOOL CPrimaryKeys::Open(LPCSTR pszTableQualifier,
  400.     LPCSTR pszTableOwner,LPCSTR pszTableName,
  401.     UINT nOpenType)
  402. {
  403.     RETCODE    nRetCode;
  404.     UWORD    bFunctionExists;
  405.  
  406.     // make sure SQLPrimaryKeys exists
  407.     AFX_SQL_SYNC(::SQLGetFunctions(m_pDatabase->m_hdbc,
  408.         SQL_API_SQLPRIMARYKEYS,&bFunctionExists));
  409.     if (!Check(nRetCode) || !bFunctionExists)
  410.     {
  411.         if (!bFunctionExists)
  412.             TRACE(_T("SQLPrimaryKeys not supported\n"));
  413.         return FALSE;
  414.     }
  415.  
  416.     m_nOpenType = nOpenType;
  417.     m_bUpdatable = FALSE;
  418.  
  419.     // make sure hstmt is allocated
  420.     if (m_hstmt == SQL_NULL_HSTMT)
  421.     {
  422.         AFX_SQL_SYNC(::SQLAllocStmt(m_pDatabase->m_hdbc,&m_hstmt));
  423.         if (!Check(nRetCode))
  424.             ThrowDBException(nRetCode,m_hstmt);
  425.     }
  426.  
  427.     OnSetOptions(m_hstmt);
  428.  
  429.     // call the ODBC function
  430.     AFX_SQL_ASYNC(this,::SQLPrimaryKeys(m_hstmt,
  431.         (UCHAR FAR*)pszTableQualifier,SQL_NTS,
  432.         (UCHAR FAR*)pszTableOwner,SQL_NTS,
  433.         (UCHAR FAR*)pszTableName,SQL_NTS));
  434.  
  435.      if (!Check(nRetCode))
  436.         ThrowDBException(nRetCode,m_hstmt);
  437.  
  438.     TRY
  439.     {
  440.         MoveFirst();
  441.     }
  442.  
  443.     CATCH_ALL(e)
  444.     {
  445.         Close();
  446.         THROW_LAST();
  447.     }
  448.     END_CATCH_ALL
  449.  
  450.     return TRUE;
  451. }
  452.  
  453. void CPrimaryKeys::DoFieldExchange(CFieldExchange* pFX)
  454. {
  455.     pFX->SetFieldType(CFieldExchange::outputColumn);
  456.     RFX_Text(pFX,_T("TABLE_QUALIFIER"),m_strTableQualifier);
  457.     RFX_Text(pFX,_T("TABLE_OWNER"),m_strTableOwner);
  458.     RFX_Text(pFX,_T("TABLE_NAME"),m_strTableName);
  459.     RFX_Text(pFX,_T("COLUMN_NAME"),m_strColumnName);
  460.     RFX_Int(pFX,_T("KEY_SEQ"),m_nKeySeq);
  461.     RFX_Text(pFX,_T("PK_NAME"),m_strPkName);
  462. }
  463.  
  464. //---------------------------------------------------------------------
  465. // CProcedureColumns
  466.  
  467. CProcedureColumns::CProcedureColumns(CDatabase* pDatabase)
  468.     : CRecordset(pDatabase)
  469. {
  470.     m_strProcedureQualifier    = _T("");
  471.     m_strProcedureOwner        = _T("");
  472.     m_strProcedureName        = _T("");
  473.     m_strColumnName            = _T("");
  474.     m_fColumnType            = 0;
  475.     m_nDataType                = 0;
  476.     m_strTypeName            = _T("");
  477.     m_nPrecision            = 0;
  478.     m_nLength                = 0;
  479.     m_nScale                = 0;
  480.     m_nRadix                = 0;
  481.     m_fNullable                = 0;
  482.     m_strRemarks            = _T("");
  483.     m_nFields = 13;
  484. }
  485.  
  486. BOOL CProcedureColumns::Open(LPCSTR pszProcQualifier,
  487.     LPCSTR pszProcOwner,LPCSTR pszProcName,LPCSTR pszColumnName,
  488.     UINT nOpenType)
  489. {
  490.     RETCODE    nRetCode;
  491.     UWORD    bFunctionExists;
  492.  
  493.     // make sure SQLProcedureColumns exists
  494.     AFX_SQL_SYNC(::SQLGetFunctions(m_pDatabase->m_hdbc,
  495.         SQL_API_SQLPROCEDURECOLUMNS,&bFunctionExists));
  496.     if (!Check(nRetCode) || !bFunctionExists)
  497.     {
  498.         if (!bFunctionExists)
  499.             TRACE(_T("SQLProcedureColumns not supported\n"));
  500.         return FALSE;
  501.     }
  502.  
  503.     m_nOpenType = nOpenType;
  504.     m_bUpdatable = FALSE;
  505.  
  506.     // make sure hstmt is allocated 
  507.     if (m_hstmt == SQL_NULL_HSTMT)
  508.     {
  509.         AFX_SQL_SYNC(::SQLAllocStmt(m_pDatabase->m_hdbc,&m_hstmt));
  510.         if (!Check(nRetCode))
  511.             ThrowDBException(nRetCode,m_hstmt);
  512.     }
  513.  
  514.     OnSetOptions(m_hstmt);
  515.  
  516.     // call the ODBC function
  517.     AFX_SQL_ASYNC(this,::SQLProcedureColumns(m_hstmt,
  518.         (UCHAR FAR*)pszProcQualifier,SQL_NTS,
  519.         (UCHAR FAR*)pszProcOwner,SQL_NTS,
  520.         (UCHAR FAR*)pszProcName,SQL_NTS,
  521.         (UCHAR FAR*)pszColumnName,SQL_NTS));
  522.  
  523.      if (!Check(nRetCode))
  524.         ThrowDBException(nRetCode,m_hstmt);
  525.  
  526.     TRY
  527.     {
  528.         MoveFirst();
  529.     }
  530.  
  531.     CATCH_ALL(e)
  532.     {
  533.         Close();
  534.         THROW_LAST();
  535.     }
  536.     END_CATCH_ALL
  537.  
  538.     return TRUE;
  539. }
  540.  
  541. void CProcedureColumns::DoFieldExchange(CFieldExchange* pFX)
  542. {
  543.     pFX->SetFieldType(CFieldExchange::outputColumn);
  544.     RFX_Text(pFX,_T("PROCEDURE_QUALIFIER"),m_strProcedureQualifier);
  545.     RFX_Text(pFX,_T("PROCEDURE_OWNER"),m_strProcedureOwner);
  546.     RFX_Text(pFX,_T("PROCEDURE_NAME"),m_strProcedureName);
  547.     RFX_Text(pFX,_T("COLUMN_NAME"),m_strColumnName);
  548.     RFX_Int(pFX,_T("COLUMN_TYPE"),m_fColumnType);
  549.     RFX_Int(pFX,_T("DATA_TYPE"),m_nDataType);
  550.     RFX_Text(pFX,_T("TYPE_NAME"),m_strTypeName);
  551.     RFX_Long(pFX,_T("PRECISION"),m_nPrecision);
  552.     RFX_Long(pFX,_T("LENGTH"),m_nLength);
  553.     RFX_Int(pFX,_T("SCALE"),m_nScale);
  554.     RFX_Int(pFX,_T("RADIX"),m_nRadix);
  555.     RFX_Int(pFX,_T("NULLABLE"),m_fNullable);
  556.     RFX_Text(pFX,_T("REMARKS"),m_strRemarks);
  557. }
  558.  
  559. //---------------------------------------------------------------------
  560. // CProcedures
  561.  
  562. CProcedures::CProcedures(CDatabase* pDatabase)
  563.     : CRecordset(pDatabase)
  564. {
  565.     m_strProcedureQualifier    = _T("");
  566.     m_strProcedureOwner        = _T("");
  567.     m_strProcedureName        = _T("");
  568.     m_strRemarks            = _T("");
  569.     m_fProcedureType        = 0;
  570.     m_nFields = 5;
  571. }
  572.  
  573. BOOL CProcedures::Open(LPCSTR pszProcQualifier,
  574.     LPCSTR pszProcOwner,LPCSTR pszProcName,
  575.     UINT nOpenType)
  576. {
  577.     RETCODE    nRetCode;
  578.     UWORD    bFunctionExists;
  579.  
  580.     // make sure SQLProcedures is supported
  581.     AFX_SQL_SYNC(::SQLGetFunctions(m_pDatabase->m_hdbc,
  582.         SQL_API_SQLPROCEDURES,&bFunctionExists));
  583.     if (!Check(nRetCode) || !bFunctionExists)
  584.     {
  585.         if (!bFunctionExists)
  586.             TRACE(_T("SQLProcedures not supported\n"));
  587.         return FALSE;
  588.     }
  589.  
  590.     m_nOpenType = nOpenType;
  591.     m_bUpdatable = FALSE;
  592.  
  593.     // make sure hstmt is allocated
  594.     if (m_hstmt == SQL_NULL_HSTMT)
  595.     {
  596.         AFX_SQL_SYNC(::SQLAllocStmt(m_pDatabase->m_hdbc,&m_hstmt));
  597.         if (!Check(nRetCode))
  598.             ThrowDBException(nRetCode,m_hstmt);
  599.     }
  600.  
  601.     OnSetOptions(m_hstmt);
  602.  
  603.     // call the ODBC function
  604.     AFX_SQL_ASYNC(this,::SQLProcedures(m_hstmt,
  605.         (UCHAR FAR*)pszProcQualifier,SQL_NTS,
  606.         (UCHAR FAR*)pszProcOwner,SQL_NTS,
  607.         (UCHAR FAR*)pszProcName,SQL_NTS));
  608.  
  609.      if (!Check(nRetCode))
  610.         ThrowDBException(nRetCode,m_hstmt);
  611.  
  612.     TRY
  613.     {
  614.         MoveFirst();
  615.     }
  616.  
  617.     CATCH_ALL(e)
  618.     {
  619.         Close();
  620.         THROW_LAST();
  621.     }
  622.     END_CATCH_ALL
  623.  
  624.     return TRUE;
  625. }
  626.  
  627. void CProcedures::DoFieldExchange(CFieldExchange* pFX)
  628. {
  629.     pFX->SetFieldType(CFieldExchange::outputColumn);
  630.     RFX_Text(pFX,_T("PROCEDURE_QUALIFIER"),m_strProcedureQualifier);
  631.     RFX_Text(pFX,_T("PROCEDURE_OWNER"),m_strProcedureOwner);
  632.     RFX_Text(pFX,_T("PROCEDURE_NAME"),m_strProcedureName);
  633.     RFX_Text(pFX,_T("REMARKS"),m_strRemarks);
  634.     RFX_Int(pFX,_T("PROCEDURE_TYPE"),m_fProcedureType);
  635. }
  636.  
  637. //---------------------------------------------------------------------
  638. // CSpecialColumns
  639.  
  640. CSpecialColumns::CSpecialColumns(CDatabase* pDatabase)
  641.     : CRecordset(pDatabase)
  642. {
  643.     m_fScope        = 0;
  644.     m_strColumnName    = _T("");
  645.     m_nDataType        = 0;
  646.     m_strTypeName    = _T("");
  647.     m_nPrecision    = 0;
  648.     m_nLength        = 0;
  649.     m_nScale        = 0;
  650.     m_fPseudoColumn    = 0;
  651.     m_nFields = 8;
  652. }
  653.  
  654. BOOL CSpecialColumns::Open(short fColType,LPCSTR pszTableQualifier,
  655.     LPCSTR pszTableOwner,LPCSTR pszTableName,short fScope,short fNullable,
  656.     UINT nOpenType)
  657. {
  658.     RETCODE    nRetCode;
  659.     UWORD    bFunctionExists;
  660.  
  661.     // make sure SQLSpecialColumns is supported
  662.     AFX_SQL_SYNC(::SQLGetFunctions(m_pDatabase->m_hdbc,
  663.         SQL_API_SQLSPECIALCOLUMNS,&bFunctionExists));
  664.     if (!Check(nRetCode) || !bFunctionExists)
  665.     {
  666.         if (!bFunctionExists)
  667.             TRACE(_T("SQLSpecialColumns not supported\n"));
  668.         return FALSE;
  669.     }
  670.  
  671.     m_nOpenType = nOpenType;
  672.     m_bUpdatable = FALSE;
  673.  
  674.     // make sure hstmt is allocated
  675.     if (m_hstmt == SQL_NULL_HSTMT)
  676.     {
  677.         AFX_SQL_SYNC(::SQLAllocStmt(m_pDatabase->m_hdbc,&m_hstmt));
  678.         if (!Check(nRetCode))
  679.             ThrowDBException(nRetCode,m_hstmt);
  680.     }
  681.  
  682.     OnSetOptions(m_hstmt);
  683.  
  684.     // call the ODBC function
  685.     AFX_SQL_ASYNC(this,::SQLSpecialColumns(m_hstmt,
  686.         (UWORD)fColType,
  687.         (UCHAR FAR*)pszTableQualifier,SQL_NTS,
  688.         (UCHAR FAR*)pszTableOwner,SQL_NTS,
  689.         (UCHAR FAR*)pszTableName,SQL_NTS,
  690.         (UWORD)fScope,
  691.         (UWORD)fNullable));
  692.  
  693.      if (!Check(nRetCode))
  694.         ThrowDBException(nRetCode,m_hstmt);
  695.  
  696.     TRY
  697.     {
  698.         MoveFirst();
  699.     }
  700.  
  701.     CATCH_ALL(e)
  702.     {
  703.         Close();
  704.         THROW_LAST();
  705.     }
  706.     END_CATCH_ALL
  707.  
  708.     return TRUE;
  709. }
  710.  
  711. void CSpecialColumns::DoFieldExchange(CFieldExchange* pFX)
  712. {
  713.     pFX->SetFieldType(CFieldExchange::outputColumn);
  714.     RFX_Int(pFX,_T("SCOPE"),m_fScope);
  715.     RFX_Text(pFX,_T("COLUMN_NAME"),m_strColumnName);
  716.     RFX_Int(pFX,_T("DATA_TYPE"),m_nDataType);
  717.     RFX_Text(pFX,_T("TYPE_NAME"),m_strTypeName);
  718.     RFX_Long(pFX,_T("PRECISION"),m_nPrecision);
  719.     RFX_Long(pFX,_T("LENGTH"),m_nLength);
  720.     RFX_Int(pFX,_T("SCALE"),m_nScale);
  721.     RFX_Int(pFX,_T("PSEUDO_COLUMN"),m_fPseudoColumn);
  722. }
  723.  
  724. //---------------------------------------------------------------------
  725. // CStatistics
  726.  
  727. CStatistics::CStatistics(CDatabase* pDatabase)
  728.     : CRecordset(pDatabase)
  729. {
  730.     m_strTableQualifier        = _T("");
  731.     m_strTableOwner            = _T("");
  732.     m_strTableName            = _T("");
  733.     m_fNonUnique            = 0;
  734.     m_strIndexQualifier        = _T("");
  735.     m_strIndexName            = _T("");
  736.     m_fType                    = 0;
  737.     m_nSeqInIndex            = 0;
  738.     m_strColumnName            = _T("");
  739.     m_strCollation            = _T("");
  740.     m_nCardinality            = 0;
  741.     m_nPages                = 0;
  742.     m_strFilterCondition    = _T("");
  743.     m_nFields = 13;
  744. }
  745.  
  746. BOOL CStatistics::Open(LPCSTR pszTableQualifier,
  747.     LPCSTR pszTableOwner,LPCSTR pszTableName,short fUnique,short fAccuracy,
  748.     UINT nOpenType)
  749. {
  750.     RETCODE    nRetCode;
  751.     UWORD    bFunctionExists;
  752.  
  753.     // make sure SQLStatistics is supported
  754.     AFX_SQL_SYNC(::SQLGetFunctions(m_pDatabase->m_hdbc,
  755.         SQL_API_SQLSTATISTICS,&bFunctionExists));
  756.     if (!Check(nRetCode) || !bFunctionExists)
  757.     {
  758.         if (!bFunctionExists)
  759.             TRACE(_T("SQLStatistics not supported\n"));
  760.         return FALSE;
  761.     }
  762.  
  763.     m_nOpenType = nOpenType;
  764.     m_bUpdatable = FALSE;
  765.  
  766.     // make sure hstmt is allocated
  767.     if (m_hstmt == SQL_NULL_HSTMT)
  768.     {
  769.         AFX_SQL_SYNC(::SQLAllocStmt(m_pDatabase->m_hdbc,&m_hstmt));
  770.         if (!Check(nRetCode))
  771.             ThrowDBException(nRetCode,m_hstmt);
  772.     }
  773.     OnSetOptions(m_hstmt);
  774.  
  775.     // call the ODBC function
  776.     AFX_SQL_ASYNC(this,::SQLStatistics(m_hstmt,
  777.         (UCHAR FAR*)pszTableQualifier,SQL_NTS,
  778.         (UCHAR FAR*)pszTableOwner,SQL_NTS,
  779.         (UCHAR FAR*)pszTableName,SQL_NTS,
  780.         (UWORD)fUnique,
  781.         (UWORD)fAccuracy));
  782.  
  783.      if (!Check(nRetCode))
  784.         ThrowDBException(nRetCode,m_hstmt);
  785.  
  786.     TRY
  787.     {
  788.         MoveFirst();
  789.     }
  790.  
  791.     CATCH_ALL(e)
  792.     {
  793.         Close();
  794.         THROW_LAST();
  795.     }
  796.     END_CATCH_ALL
  797.  
  798.     return TRUE;
  799. }
  800.  
  801. void CStatistics::DoFieldExchange(CFieldExchange* pFX)
  802. {
  803.     pFX->SetFieldType(CFieldExchange::outputColumn);
  804.     RFX_Text(pFX,_T("TABLE_QUALIFIER"),m_strTableQualifier);
  805.     RFX_Text(pFX,_T("TABLE_OWNER"),m_strTableOwner);
  806.     RFX_Text(pFX,_T("TABLE_NAME"),m_strTableName);
  807.     RFX_Int(pFX,_T("NON_UNIQUE"),m_fNonUnique);
  808.     RFX_Text(pFX,_T("INDEX_QUALIFIER"),m_strIndexQualifier);
  809.     RFX_Text(pFX,_T("INDEX_NAME"),m_strIndexName);
  810.     RFX_Int(pFX,_T("TYPE"),m_fType);
  811.     RFX_Int(pFX,_T("SEQ_IN_INDEX"),m_nSeqInIndex);
  812.     RFX_Text(pFX,_T("COLUMN_NAME"),m_strColumnName);
  813.     RFX_Text(pFX,_T("COLLATION"),m_strCollation);
  814.     RFX_Long(pFX,_T("CARDINALITY"),m_nCardinality);
  815.     RFX_Long(pFX,_T("PAGES"),m_nPages);
  816.     RFX_Text(pFX,_T("FILTER_CONDITION"),m_strFilterCondition);
  817. }
  818.  
  819. //---------------------------------------------------------------------
  820. // CTablePrivileges
  821.  
  822. CTablePrivileges::CTablePrivileges(CDatabase* pDatabase)
  823.     : CRecordset(pDatabase)
  824. {
  825.     m_strTableQualifier    = _T("");
  826.     m_strTableOwner        = _T("");
  827.     m_strTableName        = _T("");
  828.     m_strGrantor        = _T("");
  829.     m_strGrantee        = _T("");
  830.     m_strPrivilege        = _T("");
  831.     m_strIsGrantable    = _T("");
  832.     m_nFields = 7;
  833. }
  834.  
  835. BOOL CTablePrivileges::Open(LPCSTR pszTableQualifier,
  836.     LPCSTR pszTableOwner,LPCSTR pszTableName,
  837.     UINT nOpenType)
  838. {
  839.     RETCODE    nRetCode;
  840.     UWORD    bFunctionExists;
  841.  
  842.     // make sure SQLTablePrivileges exists
  843.     AFX_SQL_SYNC(::SQLGetFunctions(m_pDatabase->m_hdbc,
  844.         SQL_API_SQLTABLEPRIVILEGES,&bFunctionExists));
  845.     if (!Check(nRetCode) || !bFunctionExists)
  846.     {
  847.         if (!bFunctionExists)
  848.             TRACE(_T("SQLTablePrivileges not supported\n"));
  849.         return FALSE;
  850.     }
  851.  
  852.     m_nOpenType = nOpenType;
  853.     m_bUpdatable = FALSE;
  854.  
  855.     // make sure hstmt is allocated
  856.     if (m_hstmt == SQL_NULL_HSTMT)
  857.     {
  858.         AFX_SQL_SYNC(::SQLAllocStmt(m_pDatabase->m_hdbc,&m_hstmt));
  859.         if (!Check(nRetCode))
  860.             ThrowDBException(nRetCode,m_hstmt);
  861.     }
  862.  
  863.     OnSetOptions(m_hstmt);
  864.  
  865.     // call the ODBC function
  866.     AFX_SQL_ASYNC(this,::SQLTablePrivileges(m_hstmt,
  867.         (UCHAR FAR*)pszTableQualifier,SQL_NTS,
  868.         (UCHAR FAR*)pszTableOwner,SQL_NTS,
  869.         (UCHAR FAR*)pszTableName,SQL_NTS));
  870.  
  871.      if (!Check(nRetCode))
  872.         ThrowDBException(nRetCode,m_hstmt);
  873.  
  874.     TRY
  875.     {
  876.         MoveFirst();
  877.     }
  878.  
  879.     CATCH_ALL(e)
  880.     {
  881.         Close();
  882.         THROW_LAST();
  883.     }
  884.     END_CATCH_ALL
  885.  
  886.     return TRUE;
  887. }
  888.  
  889. void CTablePrivileges::DoFieldExchange(CFieldExchange* pFX)
  890. {
  891.     pFX->SetFieldType(CFieldExchange::outputColumn);
  892.     RFX_Text(pFX,_T("TABLE_QUALIFIER"),m_strTableQualifier);
  893.     RFX_Text(pFX,_T("TABLE_OWNER"),m_strTableOwner);
  894.     RFX_Text(pFX,_T("TABLE_NAME"),m_strTableName);
  895.     RFX_Text(pFX,_T("GRANTOR"),m_strGrantor);
  896.     RFX_Text(pFX,_T("GRANTEE"),m_strGrantee);
  897.     RFX_Text(pFX,_T("PRIVILEGE"),m_strPrivilege);
  898.     RFX_Text(pFX,_T("IS_GRANTABLE"),m_strIsGrantable);
  899. }
  900.  
  901. //---------------------------------------------------------------------
  902. // CTables
  903.  
  904. CTables::CTables(CDatabase* pDatabase)
  905.     : CRecordset(pDatabase)
  906. {
  907.     m_strTableQualifier    = _T("");
  908.     m_strTableOwner        = _T("");
  909.     m_strTableName        = _T("");
  910.     m_strTableType        = _T("");
  911.     m_strRemarks        = _T("");
  912.     m_nFields = 5;
  913. }
  914.  
  915. BOOL CTables::Open(LPCSTR pszTableQualifier,
  916.     LPCSTR pszTableOwner,LPCSTR pszTableName,LPCSTR pszTableType,
  917.     UINT nOpenType)
  918. {
  919.     RETCODE    nRetCode;
  920.     UWORD    bFunctionExists;
  921.  
  922.     // make sure SQLTables exists
  923.     AFX_SQL_SYNC(::SQLGetFunctions(m_pDatabase->m_hdbc,
  924.         SQL_API_SQLTABLES,&bFunctionExists));
  925.     if (!Check(nRetCode) || !bFunctionExists)
  926.     {
  927.         if (!bFunctionExists)
  928.             TRACE(_T("SQLTables not supported\n"));
  929.         return FALSE;
  930.     }
  931.  
  932.     m_nOpenType = nOpenType;
  933.     m_bUpdatable = FALSE;
  934.  
  935.     // make sure hstmt is allocated
  936.     if (m_hstmt == SQL_NULL_HSTMT)
  937.     {
  938.         AFX_SQL_SYNC(::SQLAllocStmt(m_pDatabase->m_hdbc,&m_hstmt));
  939.         if (!Check(nRetCode))
  940.             ThrowDBException(nRetCode,m_hstmt);
  941.     }
  942.  
  943.     OnSetOptions(m_hstmt);
  944.  
  945.     // call the ODBC function
  946.     AFX_SQL_ASYNC(this,::SQLTables(m_hstmt,
  947.         (UCHAR FAR*)pszTableQualifier,SQL_NTS,
  948.         (UCHAR FAR*)pszTableOwner,SQL_NTS,
  949.         (UCHAR FAR*)pszTableName,SQL_NTS,
  950.         (UCHAR FAR*)pszTableType,SQL_NTS));
  951.  
  952.      if (!Check(nRetCode))
  953.         ThrowDBException(nRetCode,m_hstmt);
  954.  
  955.     TRY
  956.     {
  957.         MoveFirst();
  958.     }
  959.  
  960.     CATCH_ALL(e)
  961.     {
  962.         Close();
  963.         THROW_LAST();
  964.     }
  965.     END_CATCH_ALL
  966.  
  967.     return TRUE;
  968. }
  969.  
  970. void CTables::DoFieldExchange(CFieldExchange* pFX)
  971. {
  972.     pFX->SetFieldType(CFieldExchange::outputColumn);
  973.     RFX_Text(pFX,_T("TABLE_QUALIFIER"),m_strTableQualifier);
  974.     RFX_Text(pFX,_T("TABLE_OWNER"),m_strTableOwner);
  975.     RFX_Text(pFX,_T("TABLE_NAME"),m_strTableName);
  976.     RFX_Text(pFX,_T("TABLE_TYPE"),m_strTableType);
  977.     RFX_Text(pFX,_T("REMARKS"),m_strRemarks);
  978. }
  979.