home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / mfc / database / catalog2 / catsets.h < prev    next >
Encoding:
C/C++ Source or Header  |  1998-03-27  |  10.3 KB  |  341 lines
  1. // catsets.h
  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. #ifndef CATSETS_H
  14. #define CATSETS_H
  15.  
  16. //---------------------------------------------------------------------
  17. // CColumnPrivileges - results from SQLColumnPrivileges()
  18.  
  19. class CColumnPrivileges : public CRecordset
  20. {
  21.     virtual CString GetDefaultConnect() { return ""; }
  22.     virtual CString GetDefaultSQL() { return ""; }
  23.  
  24. public:
  25.                     CColumnPrivileges(CDatabase* pDatabase);
  26.     BOOL            Open(LPCSTR pszTableQualifier = NULL,
  27.                          LPCSTR pszTableOwner = NULL,
  28.                          LPCSTR pszTableName = NULL,
  29.                          LPCSTR pszColumnName = NULL,
  30.                          UINT   nOpenType = forwardOnly);
  31.  
  32.     CString         m_strTableQualifier;
  33.     CString         m_strTableOwner;
  34.     CString         m_strTableName;
  35.     CString         m_strColumnName;
  36.     CString         m_strGrantor;
  37.     CString         m_strGrantee;
  38.     CString         m_strPrivilege;
  39.     CString         m_strIsGrantable;
  40.  
  41.     virtual void    DoFieldExchange(CFieldExchange*);
  42. };
  43.  
  44. //---------------------------------------------------------------------
  45. // CColumns - results from SQLColumns()
  46.  
  47. class CColumns : public CRecordset
  48. {
  49.     virtual CString GetDefaultConnect() { return ""; }
  50.     virtual CString GetDefaultSQL() { return ""; }
  51.  
  52. public:
  53.                     CColumns(CDatabase* pDatabase);
  54.     BOOL            Open(LPCSTR pszTableQualifier = NULL,
  55.                          LPCSTR pszTableOwner = NULL,
  56.                          LPCSTR pszTableName = NULL,
  57.                          LPCSTR pszColumnName = NULL,
  58.                          UINT   nOpenType = forwardOnly);
  59.  
  60.     CString         m_strTableQualifier;
  61.     CString         m_strTableOwner;
  62.     CString         m_strTableName;
  63.     CString         m_strColumnName;
  64.     int             m_nDataType;
  65.     CString         m_strTypeName;
  66.     long            m_nPrecision;
  67.     long            m_nLength;
  68.     int             m_nScale;
  69.     int             m_nRadix;
  70.     int             m_fNullable;
  71.     CString         m_strRemarks;
  72.  
  73.     virtual void    DoFieldExchange(CFieldExchange*);
  74. };
  75.  
  76. //---------------------------------------------------------------------
  77. // CForeignKeys - results from SQLForeignKeys()
  78.  
  79. class CForeignKeys : public CRecordset
  80. {
  81.     virtual CString GetDefaultConnect() { return ""; }
  82.     virtual CString GetDefaultSQL() { return ""; }
  83.  
  84. public:
  85.                     CForeignKeys(CDatabase* pDatabase);
  86.     BOOL            Open(LPCSTR pszPkTableQualifier,
  87.                          LPCSTR pszPkTableOwner,
  88.                          LPCSTR pszPkTableName,
  89.                          LPCSTR pszFkTableQualifier = NULL,
  90.                          LPCSTR pszFkTableOwner = NULL,
  91.                          LPCSTR pszFkTableName = NULL,
  92.                          UINT   nOpenType = forwardOnly);
  93.  
  94.     CString         m_strPkTableQualifier;
  95.     CString         m_strPkTableOwner;
  96.     CString         m_strPkTableName;
  97.     CString         m_strPkColumnName;
  98.     CString         m_strFkTableQualifier;
  99.     CString         m_strFkTableOwner;
  100.     CString         m_strFkTableName;
  101.     CString         m_strFkColumnName;
  102.     int             m_nKeySeq;
  103.     int             m_fUpdateRule;
  104.     int             m_fDeleteRule;
  105.     CString         m_strFkName;
  106.     CString         m_strPkName;
  107.  
  108.     virtual void    DoFieldExchange(CFieldExchange*);
  109. };
  110.  
  111. //---------------------------------------------------------------------
  112. // CGetTypeInfo - results from SQLGetTypeInfo()
  113.  
  114. class CGetTypeInfo : public CRecordset
  115. {
  116.     virtual CString GetDefaultConnect() { return ""; }
  117.     virtual CString GetDefaultSQL() { return ""; }
  118.  
  119. public:
  120.                     CGetTypeInfo(CDatabase* pDatabase);
  121.     BOOL            Open(short fSqlType = SQL_ALL_TYPES,
  122.                          UINT  nOpenType = forwardOnly);
  123.  
  124.     CString         m_strTypeName;
  125.     int             m_fDataType;
  126.     long            m_nPrecision;
  127.     CString         m_strLiteralPrefix;
  128.     CString         m_strLiteralSuffix;
  129.     CString         m_strCreateParams;
  130.     int             m_fNullable;
  131.     BOOL            m_bCaseSensitive;
  132.     int             m_fSearchable;
  133.     int             m_fUnsignedAttribute;
  134.     BOOL            m_bMoney;
  135.     int             m_fAutoIncrement;
  136.     CString         m_strLocalTypeName;
  137.     int             m_nMinimumScale;
  138.     int             m_nMaximumScale;
  139.  
  140.     virtual void    DoFieldExchange(CFieldExchange*);
  141. };
  142.  
  143. //---------------------------------------------------------------------
  144. // CPrimaryKeys - results from SQLPrimaryKeys()
  145.  
  146. class CPrimaryKeys : public CRecordset
  147. {
  148.     virtual CString GetDefaultConnect() { return ""; }
  149.     virtual CString GetDefaultSQL() { return ""; }
  150.  
  151. public:
  152.                     CPrimaryKeys(CDatabase* pDatabase);
  153.     BOOL            Open(LPCSTR pszTableQualifier = NULL,
  154.                          LPCSTR pszTableOwner = NULL,
  155.                          LPCSTR pszTableName = NULL,
  156.                          UINT   nOpenType = forwardOnly);
  157.  
  158.     CString         m_strTableQualifier;
  159.     CString         m_strTableOwner;
  160.     CString         m_strTableName;
  161.     CString         m_strColumnName;
  162.     int             m_nKeySeq;
  163.     CString         m_strPkName;
  164.  
  165.     virtual void    DoFieldExchange(CFieldExchange*);
  166. };
  167.  
  168. //---------------------------------------------------------------------
  169. // CProcedureColumns - results from SQLProcedureColumns()
  170.  
  171. class CProcedureColumns : public CRecordset
  172. {
  173.     virtual CString GetDefaultConnect() { return ""; }
  174.     virtual CString GetDefaultSQL() { return ""; }
  175.  
  176. public:
  177.                     CProcedureColumns(CDatabase* pDatabase);
  178.     BOOL            Open(LPCSTR pszProcQualifier = NULL,
  179.                          LPCSTR pszProcOwner = NULL,
  180.                          LPCSTR pszProcName = NULL,
  181.                          LPCSTR pszColumnName = NULL,
  182.                          UINT   nOpenType = forwardOnly);
  183.  
  184.     CString         m_strProcedureQualifier;
  185.     CString         m_strProcedureOwner;
  186.     CString         m_strProcedureName;
  187.     CString         m_strColumnName;
  188.     int             m_fColumnType;
  189.     int             m_nDataType;
  190.     CString         m_strTypeName;
  191.     long            m_nPrecision;
  192.     long            m_nLength;
  193.     int             m_nScale;
  194.     int             m_nRadix;
  195.     int             m_fNullable;
  196.     CString         m_strRemarks;
  197.  
  198.     virtual void    DoFieldExchange(CFieldExchange*);
  199. };
  200.  
  201. //---------------------------------------------------------------------
  202. // CProcedures - results from SQLProcedures()
  203.  
  204. class CProcedures : public CRecordset
  205. {
  206.     virtual CString GetDefaultConnect() { return ""; }
  207.     virtual CString GetDefaultSQL() { return ""; }
  208.  
  209. public:
  210.                     CProcedures(CDatabase* pDatabase);
  211.     BOOL            Open(LPCSTR pszProcQualifier = NULL,
  212.                          LPCSTR pszProcOwner = NULL,
  213.                          LPCSTR pszProcName = NULL,
  214.                          UINT   nOpenType = forwardOnly);
  215.  
  216.     CString         m_strProcedureQualifier;
  217.     CString         m_strProcedureOwner;
  218.     CString         m_strProcedureName;
  219.     CString         m_strRemarks;
  220.     int             m_fProcedureType;
  221.  
  222.     virtual void    DoFieldExchange(CFieldExchange*);
  223. };
  224.  
  225. //---------------------------------------------------------------------
  226. // CSpecialColumns - results from SQLSpecialColumns()
  227.  
  228. class CSpecialColumns : public CRecordset
  229. {
  230.     virtual CString GetDefaultConnect() { return ""; }
  231.     virtual CString GetDefaultSQL() { return ""; }
  232.  
  233. public:
  234.                     CSpecialColumns(CDatabase* pDatabase);
  235.     BOOL            Open(short fColType = SQL_BEST_ROWID,
  236.                          LPCSTR pszTableQualifier = NULL,
  237.                          LPCSTR pszTableOwner = NULL,
  238.                          LPCSTR pszTableName = NULL,
  239.                          short fScope = SQL_SCOPE_SESSION,
  240.                          short fNullable = SQL_NULLABLE,
  241.                          UINT  nOpenType = forwardOnly);
  242.  
  243.     int             m_fScope;
  244.     CString         m_strColumnName;
  245.     int             m_nDataType;
  246.     CString         m_strTypeName;
  247.     long            m_nPrecision;
  248.     long            m_nLength;
  249.     int             m_nScale;
  250.     int             m_fPseudoColumn;
  251.  
  252.     virtual void    DoFieldExchange(CFieldExchange*);
  253. };
  254.  
  255. //---------------------------------------------------------------------
  256. // CStatistics - results from SQLStatistics()
  257.  
  258. class CStatistics : public CRecordset
  259. {
  260.     virtual CString GetDefaultConnect() { return ""; }
  261.     virtual CString GetDefaultSQL() { return ""; }
  262.  
  263. public:
  264.                     CStatistics(CDatabase* pDatabase);
  265.     BOOL            Open(LPCSTR pszTableQualifier = NULL,
  266.                          LPCSTR pszTableOwner = NULL,
  267.                          LPCSTR pszTableName = NULL,
  268.                          short fUnique = SQL_INDEX_ALL,
  269.                          short fAccuracy = SQL_ENSURE,
  270.                          UINT  nOpenType = forwardOnly);
  271.  
  272.     CString         m_strTableQualifier;
  273.     CString         m_strTableOwner;
  274.     CString         m_strTableName;
  275.     int             m_fNonUnique;
  276.     CString         m_strIndexQualifier;
  277.     CString         m_strIndexName;
  278.     int             m_fType;
  279.     int             m_nSeqInIndex;
  280.     CString         m_strColumnName;
  281.     CString         m_strCollation;
  282.     long            m_nCardinality;
  283.     long            m_nPages;
  284.     CString         m_strFilterCondition;
  285.  
  286.     virtual void    DoFieldExchange(CFieldExchange*);
  287. };
  288.  
  289. //---------------------------------------------------------------------
  290. // CTablePrivileges - results from SQLTablePrivileges()
  291.  
  292. class CTablePrivileges : public CRecordset
  293. {
  294.     virtual CString GetDefaultConnect() { return ""; }
  295.     virtual CString GetDefaultSQL() { return ""; }
  296.  
  297. public:
  298.                     CTablePrivileges(CDatabase* pDatabase);
  299.     BOOL            Open(LPCSTR pszTableQualifier = NULL,
  300.                          LPCSTR pszTableOwner = NULL,
  301.                          LPCSTR pszTableName = NULL,
  302.                          UINT   nOpenType = forwardOnly);
  303.  
  304.     CString         m_strTableQualifier;
  305.     CString         m_strTableOwner;
  306.     CString         m_strTableName;
  307.     CString         m_strGrantor;
  308.     CString         m_strGrantee;
  309.     CString         m_strPrivilege;
  310.     CString         m_strIsGrantable;
  311.  
  312.     virtual void    DoFieldExchange(CFieldExchange*);
  313. };
  314.  
  315. //---------------------------------------------------------------------
  316. // CTables - results from SQLTables
  317.  
  318. class CTables : public CRecordset
  319. {
  320.     virtual CString GetDefaultConnect() { return ""; }
  321.     virtual CString GetDefaultSQL() { return ""; }
  322.  
  323. public:
  324.                     CTables(CDatabase* pDatabase);
  325.     BOOL            Open(LPCSTR pszTableQualifier = NULL,
  326.                          LPCSTR pszTableOwner = NULL,
  327.                          LPCSTR pszTableName = NULL,
  328.                          LPCSTR pszTableType = NULL,
  329.                          UINT   nOpenType = forwardOnly);
  330.  
  331.     CString         m_strTableQualifier;
  332.     CString         m_strTableOwner;
  333.     CString         m_strTableName;
  334.     CString         m_strTableType;
  335.     CString         m_strRemarks;
  336.  
  337.     virtual void    DoFieldExchange(CFieldExchange*);
  338. };
  339.  
  340. #endif
  341.