home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Internet 2000 May / MICD_2000_05.iso / CBuilder5 / INSTALL / DATA1.CAB / Program_Built_Files / Include / Atl / atldbsch.h < prev    next >
Encoding:
C/C++ Source or Header  |  2000-02-01  |  37.4 KB  |  1,430 lines
  1. // This is a part of the Active Template Library.
  2. // Copyright (C) 1996-1998 Microsoft Corporation
  3. // All rights reserved.
  4. //
  5. // This source code is only intended as a supplement to the
  6. // Active Template Library Reference and related
  7. // electronic documentation provided with the library.
  8. // See these sources for detailed information regarding the
  9. // Active Template Library product.
  10.  
  11. ///////////////////////////////////////////////////////////////////////////
  12. // ATLDBSCH.H : Declarations for OLE DB Schema Rowset Consumer Support
  13. //
  14.  
  15. #ifndef __ATLDBSCH_H__
  16. #define __ATLDBSCH_H__
  17.  
  18. namespace ATL
  19. {
  20.  
  21. template <ULONG nRestrictions>
  22. class _CStoreRestrictions
  23. {
  24. public:
  25.     _CStoreRestrictions()
  26.     {
  27.         m_pvarRestrictions = NULL;
  28.         ATLTRY(m_pvarRestrictions = new CComVariant[nRestrictions]);
  29.     }
  30.     ~_CStoreRestrictions()
  31.     {
  32.         delete [] m_pvarRestrictions;
  33.     }
  34.     HRESULT GetRowset(const CSession& session, const GUID& guidSchema, IRowset** ppRowset)
  35.     {
  36.         ATLASSERT(session.m_spOpenRowset != NULL);
  37.         CComPtr<IDBSchemaRowset> spSchemaRowset;
  38.         HRESULT hr;
  39.  
  40.         hr = session.m_spOpenRowset->QueryInterface(IID_IDBSchemaRowset, (void**)&spSchemaRowset);
  41.         if (FAILED(hr))
  42.             return hr;
  43.  
  44.         return spSchemaRowset->GetRowset(NULL, guidSchema, nRestrictions,
  45.             m_pvarRestrictions, IID_IRowset, 0, NULL, (IUnknown**)ppRowset);
  46.     }
  47.  
  48.     CComVariant* m_pvarRestrictions;
  49. };
  50.  
  51. template <>
  52. class _CStoreRestrictions<0>
  53. {
  54. public:
  55.     HRESULT GetRowset(const CSession& session, const GUID& guidSchema, IRowset** ppRowset)
  56.     {
  57.         ATLASSERT(session.m_spOpenRowset != NULL);
  58.         CComPtr<IDBSchemaRowset> spSchemaRowset;
  59.         HRESULT hr;
  60.  
  61.         hr = session.m_spOpenRowset->QueryInterface(IID_IDBSchemaRowset, (void**)&spSchemaRowset);
  62.         if (FAILED(hr))
  63.             return hr;
  64.  
  65.         return spSchemaRowset->GetRowset(NULL, guidSchema, 0,
  66.             NULL, IID_IRowset, 0, NULL, (IUnknown**)ppRowset);
  67.     }
  68. };
  69.  
  70. ///////////////////////////////////////////////////////////////////////////
  71. // class CSchemaRowset
  72. template <class T, short nRestrictions>
  73. class CSchemaRowset :
  74.     public CAccessorRowset<T, CRowset>,
  75.     public _CStoreRestrictions<nRestrictions>
  76.  
  77. {
  78. public:
  79. // Operations
  80.     HRESULT Open(const CSession& session, const GUID& guidSchema)
  81.     {
  82.         HRESULT hr;
  83.  
  84.         hr = GetRowset(session, guidSchema, &m_spRowset);
  85.         if (SUCCEEDED(hr))
  86.             hr = Bind();
  87.  
  88.         return hr;
  89.     }
  90. };
  91.  
  92.  ///////////////////////////////////////////////////////////////////////////
  93. // class CRestrictions
  94.  
  95. template <class T, short nRestrictions, const GUID* pguid>
  96. class CRestrictions : public CSchemaRowset<T, nRestrictions>
  97. {
  98. public:
  99.     HRESULT Open(const CSession& session, LPCTSTR lpszParam1 = NULL, LPCTSTR lpszParam2 = NULL,
  100.             LPCTSTR lpszParam3 = NULL, LPCTSTR lpszParam4 = NULL,
  101.             LPCTSTR lpszParam5 = NULL, LPCTSTR lpszParam6 = NULL,
  102.             LPCTSTR lpszParam7 = NULL)
  103.     {
  104.         USES_CONVERSION;
  105.         CComVariant* pVariant;
  106.  
  107.         if (m_pvarRestrictions == NULL)
  108.             return E_OUTOFMEMORY;
  109.  
  110.         if (lpszParam1 != NULL)
  111.         {
  112.             m_pvarRestrictions->vt = VT_BSTR;
  113.             m_pvarRestrictions->bstrVal = ::SysAllocString(T2COLE(lpszParam1));
  114.         }
  115.  
  116.         if (lpszParam2 != NULL)
  117.         {
  118.             pVariant = m_pvarRestrictions + 1;
  119.             pVariant->vt = VT_BSTR;
  120.             pVariant->bstrVal = ::SysAllocString(T2COLE(lpszParam2));
  121.         }
  122.  
  123.         if (lpszParam3 != NULL)
  124.         {
  125.             pVariant = m_pvarRestrictions + 2;
  126.             pVariant->vt = VT_BSTR;
  127.             pVariant->bstrVal = ::SysAllocString(T2COLE(lpszParam3));
  128.         }
  129.  
  130.         if (lpszParam4 != NULL)
  131.         {
  132.             pVariant = m_pvarRestrictions + 3;
  133.             pVariant->vt = VT_BSTR;
  134.             pVariant->bstrVal = ::SysAllocString(T2COLE(lpszParam4));
  135.         }
  136.  
  137.         if (lpszParam5 != NULL)
  138.         {
  139.             pVariant = m_pvarRestrictions + 4;
  140.             pVariant->vt = VT_BSTR;
  141.             pVariant->bstrVal = ::SysAllocString(T2COLE(lpszParam5));
  142.         }
  143.  
  144.         if (lpszParam6 != NULL)
  145.         {
  146.             pVariant = m_pvarRestrictions + 5;
  147.             pVariant->vt = VT_BSTR;
  148.             pVariant->bstrVal = ::SysAllocString(T2COLE(lpszParam6));
  149.         }
  150.  
  151.         if (lpszParam7 != NULL)
  152.         {
  153.             pVariant = m_pvarRestrictions + 6;
  154.             pVariant->vt = VT_BSTR;
  155.             pVariant->bstrVal = ::SysAllocString(T2COLE(lpszParam7));
  156.         }
  157.  
  158.         return CSchemaRowset<T, nRestrictions>::Open(session, *pguid);
  159.     }
  160. };
  161.  
  162.  
  163. ///////////////////////////////////////////////////////////////////////////
  164. // CSchemas
  165.  
  166. class CSchemas
  167. {
  168. public:
  169.     CSchemas()
  170.     {
  171.         m_nSchemas          = 0;
  172.         m_pSchemaGuids      = NULL;
  173.         m_pulRestrictions   = NULL;
  174.     };
  175.  
  176.     ~CSchemas()
  177.     {
  178.         // Clean up allocated memory
  179.         if (m_pSchemaGuids != NULL)
  180.         {
  181.             CoTaskMemFree(m_pSchemaGuids);
  182.             CoTaskMemFree(m_pulRestrictions);
  183.         }
  184.     };
  185.  
  186. // Operations
  187.     HRESULT GetSchemas(const CSession& session)
  188.     {
  189.         CComPtr<IDBSchemaRowset> spSchemaRowset;
  190.         HRESULT hr;
  191.  
  192.         ATLASSERT(session.m_spOpenRowset != NULL);
  193.  
  194.         hr = session.m_spOpenRowset->QueryInterface(IID_IDBSchemaRowset,
  195.             (void**)&spSchemaRowset);
  196.         if (FAILED(hr))
  197.             return hr;
  198.  
  199.         return spSchemaRowset->GetSchemas(&m_nSchemas, &m_pSchemaGuids,
  200.                 &m_pulRestrictions);
  201.     };
  202.  
  203. // Attributes
  204.     ULONG   m_nSchemas;
  205.     LPGUID  m_pSchemaGuids;
  206.     ULONG*  m_pulRestrictions;
  207. };
  208.  
  209.  
  210. ///////////////////////////////////////////////////////////////////////////
  211. // CAssertionInfo
  212.  
  213. class CAssertionInfo
  214. {
  215. public:
  216.     CAssertionInfo()
  217.     {
  218.         memset(this, 0, sizeof(*this));
  219.     }
  220.  
  221. // Attributes
  222.     TCHAR           m_szCatalog[129];
  223.     TCHAR           m_szSchema[129];
  224.     TCHAR           m_szName[129];
  225.     VARIANT_BOOL    m_bIsDeferrable;
  226.     VARIANT_BOOL    m_bInitiallyDeferred;
  227.     TCHAR           m_szDescription[129];
  228.  
  229. // Binding Map
  230. BEGIN_COLUMN_MAP(CAssertionInfo)
  231.     COLUMN_ENTRY(1, m_szCatalog)
  232.     COLUMN_ENTRY(2, m_szSchema)
  233.     COLUMN_ENTRY(3, m_szName)
  234.     COLUMN_ENTRY(4, m_bIsDeferrable)
  235.     COLUMN_ENTRY(5, m_bInitiallyDeferred)
  236.     COLUMN_ENTRY(6, m_szDescription)
  237. END_COLUMN_MAP()
  238. };
  239.  
  240.  
  241. ///////////////////////////////////////////////////////////////////////////
  242. // class CCatalogInfo
  243.  
  244. class CCatalogInfo
  245. {
  246. public:
  247.     CCatalogInfo()
  248.     {
  249.         memset(this, 0, sizeof(*this));
  250.     }
  251.  
  252. // Attributes
  253.     TCHAR   m_szName[129];
  254.     TCHAR   m_szDescription[129];
  255.  
  256. // Binding Info
  257. BEGIN_COLUMN_MAP(CCatalogInfo)
  258.     COLUMN_ENTRY(1, m_szName)
  259.     COLUMN_ENTRY(2, m_szDescription)
  260. END_COLUMN_MAP()
  261. };
  262.  
  263.  
  264. ///////////////////////////////////////////////////////////////////////////
  265. // class CCharacterSetInfo
  266.  
  267. class CCharacterSetInfo
  268. {
  269. public:
  270.     CCharacterSetInfo()
  271.     {
  272.         memset(this, 0, sizeof(*this));
  273.     }
  274.  
  275. // Attributes
  276.     TCHAR           m_szCatalog[129];
  277.     TCHAR           m_szSchema[129];
  278.     TCHAR           m_szName[129];
  279.     TCHAR           m_szFormOfUse[129];
  280.     LARGE_INTEGER   m_nNumCharacters;
  281.     TCHAR           m_szCollateCatalog[129];
  282.     TCHAR           m_szCollateSchema[129];
  283.     TCHAR           m_szCollateName[129];
  284.  
  285. // Binding Info
  286. BEGIN_COLUMN_MAP(CCharacterSetInfo)
  287.     COLUMN_ENTRY(1, m_szCatalog)
  288.     COLUMN_ENTRY(2, m_szSchema)
  289.     COLUMN_ENTRY(3, m_szName)
  290.     COLUMN_ENTRY(4, m_szFormOfUse)
  291.     COLUMN_ENTRY(5, m_nNumCharacters)
  292.     COLUMN_ENTRY(6, m_szCollateCatalog)
  293.     COLUMN_ENTRY(7, m_szCollateSchema)
  294.     COLUMN_ENTRY(8, m_szCollateName)
  295. END_COLUMN_MAP()
  296. };
  297.  
  298.  
  299. ///////////////////////////////////////////////////////////////////////////
  300. // class CCheckConstraintInfo
  301.  
  302. class CCheckConstraintInfo
  303. {
  304. public:
  305.     CCheckConstraintInfo()
  306.     {
  307.         memset(this, 0, sizeof(*this));
  308.     }
  309.  
  310. // Attributes
  311.     TCHAR   m_szCatalog[129];
  312.     TCHAR   m_szSchema[129];
  313.     TCHAR   m_szName[129];
  314.     TCHAR   m_szCheckClause[129];
  315.     TCHAR   m_szDescription[129];
  316.  
  317. // Binding Maps
  318. BEGIN_COLUMN_MAP(CCheckConstraintInfo)
  319.     COLUMN_ENTRY(1, m_szCatalog)
  320.     COLUMN_ENTRY(2, m_szSchema)
  321.     COLUMN_ENTRY(3, m_szName)
  322.     COLUMN_ENTRY(4, m_szCheckClause)
  323.     COLUMN_ENTRY(5, m_szDescription)
  324. END_COLUMN_MAP()
  325. };
  326.  
  327.  
  328. ///////////////////////////////////////////////////////////////////////////
  329. // class CCollationInfo
  330.  
  331. class CCollationInfo
  332. {
  333. public:
  334. // Constructors
  335.     CCollationInfo()
  336.     {
  337.         memset(this, 0, sizeof(*this));
  338.     }
  339.  
  340. // Attributes
  341.     TCHAR   m_szCatalog[129];
  342.     TCHAR   m_szSchema[129];
  343.     TCHAR   m_szName[129];
  344.     TCHAR   m_szCharSetCatalog[129];
  345.     TCHAR   m_szCharSetSchema[129];
  346.     TCHAR   m_szCharSetName[129];
  347.     TCHAR   m_szPadAttribute[10];
  348.  
  349. // Binding Maps
  350. BEGIN_COLUMN_MAP(CCollationInfo)
  351.     COLUMN_ENTRY(1, m_szCatalog)
  352.     COLUMN_ENTRY(2, m_szSchema)
  353.     COLUMN_ENTRY(3, m_szName)
  354.     COLUMN_ENTRY(4, m_szCharSetCatalog)
  355.     COLUMN_ENTRY(5, m_szCharSetSchema)
  356.     COLUMN_ENTRY(6, m_szCharSetName)
  357.     COLUMN_ENTRY(7, m_szPadAttribute)
  358. END_COLUMN_MAP()
  359. };
  360.  
  361.  
  362. ///////////////////////////////////////////////////////////////////////////
  363. // class CColumnDomainUsageInfo
  364.  
  365. class CColumnDomainUsageInfo
  366. {
  367. public:
  368. // Constructor
  369.     CColumnDomainUsageInfo()
  370.     {
  371.         memset(this, 0, sizeof(*this));
  372.     }
  373.  
  374. // Attributes
  375.     TCHAR   m_szCatalog[129];
  376.     TCHAR   m_szSchema[129];
  377.     TCHAR   m_szName[129];
  378.     TCHAR   m_szTableCatalog[129];
  379.     TCHAR   m_szTableSchema[129];
  380.     TCHAR   m_szTableName[129];
  381.     TCHAR   m_szColumnName[129];
  382.     GUID    m_guidColumn;
  383.     ULONG   m_nColumnPropID;
  384.  
  385. // Binding Maps
  386. BEGIN_COLUMN_MAP(CColumnDomainUsageInfo)
  387.     COLUMN_ENTRY(1, m_szCatalog)
  388.     COLUMN_ENTRY(2, m_szSchema)
  389.     COLUMN_ENTRY(3, m_szName)
  390.     COLUMN_ENTRY(4, m_szTableCatalog)
  391.     COLUMN_ENTRY(5, m_szTableSchema)
  392.     COLUMN_ENTRY(6, m_szTableName)
  393.     COLUMN_ENTRY(7, m_szColumnName)
  394.     COLUMN_ENTRY(8, m_guidColumn)
  395.     COLUMN_ENTRY(9, m_nColumnPropID)
  396. END_COLUMN_MAP()
  397. };
  398.  
  399.  
  400. ///////////////////////////////////////////////////////////////////////////
  401. // class CColumnPrivilegeInfo
  402.  
  403. class CColumnPrivilegeInfo
  404. {
  405. public:
  406. // Constructor
  407.     CColumnPrivilegeInfo()
  408.     {
  409.         memset(this, 0, sizeof(*this));
  410.     }
  411.  
  412. // Attributes
  413.     TCHAR           m_szGrantor[129];
  414.     TCHAR           m_szGrantee[129];
  415.     TCHAR           m_szTableCatalog[129];
  416.     TCHAR           m_szTableSchema[129];
  417.     TCHAR           m_szTableName[129];
  418.     TCHAR           m_szColumnName[129];
  419.     GUID            m_guidColumn;
  420.     ULONG           m_nColumnPropID;
  421.     TCHAR           m_szPrivilegeType[20];
  422.     VARIANT_BOOL    m_bIsGrantable;
  423.  
  424. // Binding Maps
  425. BEGIN_COLUMN_MAP(CColumnPrivilegeInfo)
  426.     COLUMN_ENTRY(1,  m_szGrantor)
  427.     COLUMN_ENTRY(2,  m_szGrantee)
  428.     COLUMN_ENTRY(3,  m_szTableCatalog)
  429.     COLUMN_ENTRY(4,  m_szTableSchema)
  430.     COLUMN_ENTRY(5,  m_szTableName)
  431.     COLUMN_ENTRY(6,  m_szColumnName)
  432.     COLUMN_ENTRY(7,  m_guidColumn)
  433.     COLUMN_ENTRY(8,  m_nColumnPropID)
  434.     COLUMN_ENTRY(9,  m_szPrivilegeType)
  435.     COLUMN_ENTRY(10, m_bIsGrantable)
  436. END_COLUMN_MAP()
  437. };
  438.  
  439.  
  440. ///////////////////////////////////////////////////////////////////////////
  441. // class CColumnsInfo
  442.  
  443. class CColumnsInfo
  444. {
  445. public:
  446. // Constructors and Destructors
  447.     CColumnsInfo()
  448.     {
  449.         memset(this, 0, sizeof(*this));
  450.     }
  451.  
  452. // Operations
  453.     TCHAR           m_szTableCatalog[129];
  454.     TCHAR           m_szTableSchema[129];
  455.     TCHAR           m_szTableName[129];
  456.     TCHAR           m_szColumnName[129];
  457.     GUID            m_guidColumn;
  458.     ULONG           m_nColumnPropID;
  459.     ULONG           m_nOrdinalPosition;
  460.     VARIANT_BOOL    m_bColumnHasDefault;
  461.     TCHAR           m_szColumnDefault[129];
  462.     ULONG           m_nColumnFlags;
  463.     VARIANT_BOOL    m_bIsNullable;
  464.     USHORT          m_nDataType;
  465.     GUID            m_guidType;
  466.     ULONG           m_nMaxLength;
  467.     ULONG           m_nOctetLength;
  468.     USHORT          m_nNumericPrecision;
  469.     SHORT           m_nNumericScale;
  470.     ULONG           m_nDateTimePrecision;
  471.     TCHAR           m_szCharSetCatalog[129];
  472.     TCHAR           m_szCharSetSchema[129];
  473.     TCHAR           m_szCharSetName[129];
  474.     TCHAR           m_szCollationCatalog[129];
  475.     TCHAR           m_szCollationSchema[129];
  476.     TCHAR           m_szCollationName[129];
  477.     TCHAR           m_szDomainCatalog[129];
  478.     TCHAR           m_szDomainSchema[129];
  479.     TCHAR           m_szDomainName[129];
  480.     TCHAR           m_szDescription[129];
  481.  
  482. BEGIN_COLUMN_MAP(CColumnsInfo)
  483.     COLUMN_ENTRY(1, m_szTableCatalog)
  484.     COLUMN_ENTRY(2, m_szTableSchema)
  485.     COLUMN_ENTRY(3, m_szTableName)
  486.     COLUMN_ENTRY(4, m_szColumnName)
  487.     COLUMN_ENTRY(5, m_guidColumn)
  488.     COLUMN_ENTRY(6, m_nColumnPropID)
  489.     COLUMN_ENTRY(7, m_nOrdinalPosition)
  490.     COLUMN_ENTRY(8, m_bColumnHasDefault)
  491.     COLUMN_ENTRY(9, m_szColumnDefault)
  492.     COLUMN_ENTRY(10, m_nColumnFlags)
  493.     COLUMN_ENTRY(11, m_bIsNullable)
  494.     COLUMN_ENTRY(12, m_nDataType)
  495.     COLUMN_ENTRY(13, m_guidType)
  496.     COLUMN_ENTRY(14, m_nMaxLength)
  497.     COLUMN_ENTRY(15, m_nOctetLength)
  498.     COLUMN_ENTRY(16, m_nNumericPrecision)
  499.     COLUMN_ENTRY(17, m_nNumericScale)
  500.     COLUMN_ENTRY(18, m_nDateTimePrecision)
  501.     COLUMN_ENTRY(19, m_szCharSetCatalog)
  502.     COLUMN_ENTRY(20, m_szCharSetSchema)
  503.     COLUMN_ENTRY(21, m_szCharSetName)
  504.     COLUMN_ENTRY(22, m_szCollationCatalog)
  505.     COLUMN_ENTRY(23, m_szCollationSchema)
  506.     COLUMN_ENTRY(24, m_szCollationName)
  507.     COLUMN_ENTRY(25, m_szDomainCatalog)
  508.     COLUMN_ENTRY(26, m_szDomainSchema)
  509.     COLUMN_ENTRY(27, m_szDomainName)
  510.     COLUMN_ENTRY(28, m_szDescription)
  511. END_COLUMN_MAP()
  512. };
  513.  
  514.  
  515. ///////////////////////////////////////////////////////////////////////////
  516. // class CConstraintColumnUsageInfo
  517.  
  518. class CConstraintColumnUsageInfo
  519. {
  520. public:
  521. // Constructor
  522.     CConstraintColumnUsageInfo()
  523.     {
  524.         memset(this, 0, sizeof(*this));
  525.     }
  526.  
  527. // Attributes
  528.     TCHAR   m_szTableCatalog[129];
  529.     TCHAR   m_szTableSchema[129];
  530.     TCHAR   m_szTableName[129];
  531.     TCHAR   m_szColumnName[129];
  532.     GUID    m_guidColumn;
  533.     ULONG   m_nColumnPropID;
  534.     TCHAR   m_szConstraintCatalog[129];
  535.     TCHAR   m_szConstraintSchema[129];
  536.     TCHAR   m_szConstraintName[129];
  537.  
  538. // Binding Maps
  539. BEGIN_COLUMN_MAP(CConstraintColumnUsageInfo)
  540.     COLUMN_ENTRY(1, m_szTableCatalog)
  541.     COLUMN_ENTRY(2, m_szTableSchema)
  542.     COLUMN_ENTRY(3, m_szTableName)
  543.     COLUMN_ENTRY(4, m_szColumnName)
  544.     COLUMN_ENTRY(5, m_guidColumn)
  545.     COLUMN_ENTRY(6, m_nColumnPropID)
  546.     COLUMN_ENTRY(7, m_szConstraintCatalog)
  547.     COLUMN_ENTRY(8, m_szConstraintSchema)
  548.     COLUMN_ENTRY(9, m_szConstraintName)
  549. END_COLUMN_MAP()
  550. };
  551.  
  552. ///////////////////////////////////////////////////////////////////////////
  553. // class CConstraintColumnUsageInfo
  554.  
  555. class CConstraintTableUsageInfo
  556. {
  557. public:
  558. // Constructor
  559.     CConstraintTableUsageInfo()
  560.     {
  561.         memset(this, 0, sizeof(*this));
  562.     }
  563.  
  564. // Attributes
  565.     TCHAR   m_szTableCatalog[129];
  566.     TCHAR   m_szTableSchema[129];
  567.     TCHAR   m_szTableName[129];
  568.     TCHAR   m_szConstraintCatalog[129];
  569.     TCHAR   m_szConstraintSchema[129];
  570.     TCHAR   m_szConstraintName[129];
  571.  
  572. // Binding Maps
  573. BEGIN_COLUMN_MAP(CConstraintTableUsageInfo)
  574.     COLUMN_ENTRY(1, m_szTableCatalog)
  575.     COLUMN_ENTRY(2, m_szTableSchema)
  576.     COLUMN_ENTRY(3, m_szTableName)
  577.     COLUMN_ENTRY(4, m_szConstraintCatalog)
  578.     COLUMN_ENTRY(5, m_szConstraintSchema)
  579.     COLUMN_ENTRY(6, m_szConstraintName)
  580. END_COLUMN_MAP()
  581. };
  582.  
  583. ///////////////////////////////////////////////////////////////////////////
  584. // class CForeignKeysInfo
  585.  
  586. class CForeignKeysInfo
  587. {
  588. public:
  589. // Constructor
  590.     CForeignKeysInfo()
  591.     {
  592.         memset(this, 0, sizeof(*this));
  593.     }
  594.  
  595. // Attributes
  596.     TCHAR   m_szPKTableCatalog[129];
  597.     TCHAR   m_szPKTableSchema[129];
  598.     TCHAR   m_szPKTableName[129];
  599.     TCHAR   m_szPKColumnName[129];
  600.     GUID    m_guidPKColumn;
  601.     ULONG   m_nPKColumnPropID;
  602.     TCHAR   m_szFKTableCatalog[129];
  603.     TCHAR   m_szFKTableSchema[129];
  604.     TCHAR   m_szFKTableName[129];
  605.     TCHAR   m_szFKColumnName[129];
  606.     GUID    m_guidFKColumn;
  607.     ULONG   m_nFKColumnPropID;
  608.     ULONG   m_nOrdinal;
  609.     TCHAR   m_szUpdateRule[12];
  610.     TCHAR   m_szDeleteRule[12];
  611.  
  612. // Binding Info
  613. BEGIN_COLUMN_MAP(CForeignKeysInfo)
  614.     COLUMN_ENTRY(1, m_szPKTableCatalog)
  615.     COLUMN_ENTRY(2, m_szPKTableSchema)
  616.     COLUMN_ENTRY(3, m_szPKTableName)
  617.     COLUMN_ENTRY(4, m_szPKColumnName)
  618.     COLUMN_ENTRY(5, m_guidPKColumn)
  619.     COLUMN_ENTRY(6, m_nPKColumnPropID)
  620.     COLUMN_ENTRY(7, m_szFKTableCatalog)
  621.     COLUMN_ENTRY(8, m_szFKTableSchema)
  622.     COLUMN_ENTRY(9, m_szFKTableName)
  623.     COLUMN_ENTRY(10, m_szFKColumnName)
  624.     COLUMN_ENTRY(11, m_guidFKColumn)
  625.     COLUMN_ENTRY(12, m_nFKColumnPropID)
  626.     COLUMN_ENTRY(13, m_nOrdinal)
  627.     COLUMN_ENTRY(14, m_szUpdateRule)
  628.     COLUMN_ENTRY(15, m_szDeleteRule)
  629. END_COLUMN_MAP()
  630. };
  631.  
  632.  
  633. ///////////////////////////////////////////////////////////////////////////
  634. // class CIndexesInfo
  635.  
  636. class CIndexesInfo
  637. {
  638. public:
  639. // Constructors
  640.     CIndexesInfo()
  641.     {
  642.         memset(this, 0, sizeof(*this));
  643.     }
  644.  
  645. // Attributes
  646.     TCHAR           m_szTableCatalog[129];
  647.     TCHAR           m_szTableSchema[129];
  648.     TCHAR           m_szTableName[129];
  649.     TCHAR           m_szIndexCatalog[129];
  650.     TCHAR           m_szIndexSchema[129];
  651.     TCHAR           m_szIndexName[129];
  652.     VARIANT_BOOL    m_bPrimaryKey;
  653.     VARIANT_BOOL    m_bUnique;
  654.     VARIANT_BOOL    m_bClustered;
  655.     USHORT          m_nType;
  656.     LONG            m_nFillFactor;
  657.     LONG            m_nInitialSize;
  658.     LONG            m_nNulls;
  659.     VARIANT_BOOL    m_bSortBookmarks;
  660.     VARIANT_BOOL    m_bAutoUpdate;
  661.     LONG            m_nNullCollation;
  662.     ULONG           m_nOrdinalPosition;
  663.     TCHAR           m_szColumnName[129];
  664.     GUID            m_guidColumn;
  665.     ULONG           m_nColumnPropID;
  666.     SHORT           m_nCollation;
  667.     LONG            m_nCardinality;
  668.     LONG            m_nPages;
  669.     TCHAR           m_szFilterCondition[129];
  670.  
  671. // Binding Maps
  672. BEGIN_COLUMN_MAP(CIndexesInfo)
  673.     COLUMN_ENTRY(1, m_szTableCatalog)
  674.     COLUMN_ENTRY(2, m_szTableSchema)
  675.     COLUMN_ENTRY(3, m_szTableName)
  676.     COLUMN_ENTRY(4, m_szIndexCatalog)
  677.     COLUMN_ENTRY(5, m_szIndexSchema)
  678.     COLUMN_ENTRY(6, m_szIndexName)
  679.     COLUMN_ENTRY(7, m_bPrimaryKey)
  680.     COLUMN_ENTRY(8, m_bUnique)
  681.     COLUMN_ENTRY(9, m_bClustered)
  682.     COLUMN_ENTRY(10, m_nType)
  683.     COLUMN_ENTRY(11, m_nFillFactor)
  684.     COLUMN_ENTRY(12, m_nInitialSize)
  685.     COLUMN_ENTRY(13, m_nNulls)
  686.     COLUMN_ENTRY(14, m_bSortBookmarks)
  687.     COLUMN_ENTRY(15, m_bAutoUpdate)
  688.     COLUMN_ENTRY(16, m_nNullCollation)
  689.     COLUMN_ENTRY(17, m_nOrdinalPosition)
  690.     COLUMN_ENTRY(18, m_szColumnName)
  691.     COLUMN_ENTRY(19, m_guidColumn)
  692.     COLUMN_ENTRY(20, m_nColumnPropID)
  693.     COLUMN_ENTRY(21, m_nCollation)
  694.     COLUMN_ENTRY(22, m_nCardinality)
  695.     COLUMN_ENTRY(23, m_nPages)
  696.     COLUMN_ENTRY(25, m_szFilterCondition)
  697. END_COLUMN_MAP()
  698. };
  699.  
  700.  
  701. ///////////////////////////////////////////////////////////////////////////
  702. // class CKeyColumnUsageInfo
  703.  
  704. class CKeyColumnUsageInfo
  705. {
  706. public:
  707. // Constructors
  708.     CKeyColumnUsageInfo()
  709.     {
  710.         memset(this, 0, sizeof(*this));
  711.     }
  712.  
  713. // Attributes
  714.     TCHAR   m_szConstraintCatalog[129];
  715.     TCHAR   m_szConstraintSchema[129];
  716.     TCHAR   m_szConstraintName[129];
  717.     TCHAR   m_szTableCatalog[129];
  718.     TCHAR   m_szTableSchema[129];
  719.     TCHAR   m_szTableName[129];
  720.     TCHAR   m_szColumnName[129];
  721.     GUID    m_guidColumn;
  722.     ULONG   m_nColumnPropID;
  723.     ULONG   m_nOrdinalPosition;
  724.  
  725. // Binding Maps
  726. BEGIN_COLUMN_MAP(CKeyColumnUsageInfo)
  727.     COLUMN_ENTRY(1,  m_szConstraintCatalog)
  728.     COLUMN_ENTRY(2,  m_szConstraintSchema)
  729.     COLUMN_ENTRY(3,  m_szConstraintName)
  730.     COLUMN_ENTRY(4,  m_szTableCatalog)
  731.     COLUMN_ENTRY(5,  m_szTableSchema)
  732.     COLUMN_ENTRY(6,  m_szTableName)
  733.     COLUMN_ENTRY(7,  m_szColumnName)
  734.     COLUMN_ENTRY(8,  m_guidColumn)
  735.     COLUMN_ENTRY(9,  m_nColumnPropID)
  736.     COLUMN_ENTRY(10, m_nOrdinalPosition)
  737. END_COLUMN_MAP()
  738. };
  739.  
  740.  
  741. ///////////////////////////////////////////////////////////////////////////
  742. // class CPrimaryKeyInfo
  743.  
  744. class CPrimaryKeyInfo
  745. {
  746. public:
  747. // Constructors
  748.     CPrimaryKeyInfo()
  749.     {
  750.         memset(this, 0, sizeof(*this));
  751.     }
  752.  
  753. // Attributes
  754.     TCHAR   m_szTableCatalog[129];
  755.     TCHAR   m_szTableSchema[129];
  756.     TCHAR   m_szTableName[129];
  757.     TCHAR   m_szColumnName[129];
  758.     GUID    m_guidColumn;
  759.     ULONG   m_nColumnPropID;
  760.     ULONG   m_nOrdinal;
  761.  
  762. // Binding Maps
  763. BEGIN_COLUMN_MAP(CPrimaryKeyInfo)
  764.     COLUMN_ENTRY(1, m_szTableCatalog)
  765.     COLUMN_ENTRY(2, m_szTableSchema)
  766.     COLUMN_ENTRY(3, m_szTableName)
  767.     COLUMN_ENTRY(4, m_szColumnName)
  768.     COLUMN_ENTRY(5, m_guidColumn)
  769.     COLUMN_ENTRY(6, m_nColumnPropID)
  770.     COLUMN_ENTRY(7, m_nOrdinal)
  771. END_COLUMN_MAP()
  772. };
  773.  
  774.  
  775. ///////////////////////////////////////////////////////////////////////////
  776. // class CProcedureColumnInfo
  777.  
  778. class CProcedureColumnInfo
  779. {
  780. public:
  781. // Constructors
  782.     CProcedureColumnInfo()
  783.     {
  784.         memset(this, 0, sizeof(*this));
  785.     }
  786.  
  787. // Attributes
  788.     TCHAR           m_szCatalog[129];
  789.     TCHAR           m_szSchema[129];
  790.     TCHAR           m_szName[129];
  791.     TCHAR           m_szColumnName[129];
  792.     GUID            m_guidColumn;
  793.     ULONG           m_nColumnPropID;
  794.     ULONG           m_nRowsetNumber;
  795.     ULONG           m_nOrdinalPosition;
  796.     VARIANT_BOOL    m_bIsNullable;
  797.     USHORT          m_nDataType;
  798.     GUID            m_guidType;
  799.     ULONG           m_nMaxLength;
  800.     ULONG           m_nOctetLength;
  801.     USHORT          m_nPrecision;
  802.     SHORT           m_nScale;
  803.     TCHAR           m_szDescription[129];
  804.  
  805. // Binding Maps
  806. BEGIN_COLUMN_MAP(CProcedureColumnInfo)
  807.     COLUMN_ENTRY(1,  m_szCatalog)
  808.     COLUMN_ENTRY(2,  m_szSchema)
  809.     COLUMN_ENTRY(3,  m_szName)
  810.     COLUMN_ENTRY(4,  m_szColumnName)
  811.     COLUMN_ENTRY(5,  m_guidColumn)
  812.     COLUMN_ENTRY(6,  m_nColumnPropID)
  813.     COLUMN_ENTRY(7,  m_nRowsetNumber)
  814.     COLUMN_ENTRY(8,  m_nOrdinalPosition)
  815.     COLUMN_ENTRY(9,  m_bIsNullable)
  816.     COLUMN_ENTRY(10, m_nDataType)
  817.     COLUMN_ENTRY(11, m_guidType)
  818.     COLUMN_ENTRY(12, m_nMaxLength)
  819.     COLUMN_ENTRY(13, m_nOctetLength)
  820.     COLUMN_ENTRY(14, m_nPrecision)
  821.     COLUMN_ENTRY(15, m_nScale)
  822.     COLUMN_ENTRY(16, m_szDescription)
  823. END_COLUMN_MAP()
  824. };
  825.  
  826.  
  827. ///////////////////////////////////////////////////////////////////////////
  828. // class CProcedureParameterInfo
  829.  
  830. class CProcedureParameterInfo
  831. {
  832. public:
  833. // Constructors
  834.     CProcedureParameterInfo()
  835.     {
  836.         memset(this, 0, sizeof(*this));
  837.     }
  838.  
  839. // Attributes
  840.     TCHAR           m_szCatalog[129];
  841.     TCHAR           m_szSchema[129];
  842.     TCHAR           m_szName[129];
  843.     TCHAR           m_szParameterName[129];
  844.     USHORT          m_nOrdinalPosition;
  845.     USHORT          m_nType;
  846.     VARIANT_BOOL    m_bHasDefault;
  847.     TCHAR           m_szDefault[129];
  848.     VARIANT_BOOL    m_bIsNullable;
  849.     USHORT          m_nDataType;
  850.     ULONG           m_nMaxLength;
  851.     ULONG           m_nOctetLength;
  852.     USHORT          m_nPrecision;
  853.     SHORT           m_nScale;
  854.     TCHAR           m_szDescription[129];
  855.  
  856. // Binding Maps
  857. BEGIN_COLUMN_MAP(CProcedureParameterInfo)
  858.     COLUMN_ENTRY(1, m_szCatalog)
  859.     COLUMN_ENTRY(2, m_szSchema)
  860.     COLUMN_ENTRY(3, m_szName)
  861.     COLUMN_ENTRY(4, m_szParameterName)
  862.     COLUMN_ENTRY(5, m_nOrdinalPosition)
  863.     COLUMN_ENTRY(6, m_nType)
  864.     COLUMN_ENTRY(7, m_bHasDefault)
  865.     COLUMN_ENTRY(8, m_szDefault)
  866.     COLUMN_ENTRY(9, m_bIsNullable)
  867.     COLUMN_ENTRY(10, m_nDataType)
  868.     COLUMN_ENTRY(11, m_nMaxLength)
  869.     COLUMN_ENTRY(12, m_nOctetLength)
  870.     COLUMN_ENTRY(13, m_nPrecision)
  871.     COLUMN_ENTRY(14, m_nScale)
  872.     COLUMN_ENTRY(15, m_szDescription)
  873. END_COLUMN_MAP()
  874. };
  875.  
  876.  
  877. ///////////////////////////////////////////////////////////////////////////
  878. // class CProcedureInfo
  879.  
  880. class CProcedureInfo
  881. {
  882. public:
  883. // Constructors
  884.     CProcedureInfo()
  885.     {
  886.         memset(this, 0, sizeof(*this));
  887.     }
  888.  
  889. // Attributes
  890.     TCHAR   m_szCatalog[129];
  891.     TCHAR   m_szSchema[129];
  892.     TCHAR   m_szName[129];
  893.     SHORT   m_nType;
  894.     TCHAR   m_szDefinition[129];
  895.     TCHAR   m_szDescription[129];
  896.  
  897. // Binding Maps
  898. BEGIN_COLUMN_MAP(CProcedureInfo)
  899.     COLUMN_ENTRY(1, m_szCatalog)
  900.     COLUMN_ENTRY(2, m_szSchema)
  901.     COLUMN_ENTRY(3, m_szName)
  902.     COLUMN_ENTRY(4, m_nType)
  903.     COLUMN_ENTRY(5, m_szDefinition)
  904.     COLUMN_ENTRY(6, m_szDescription)
  905. END_COLUMN_MAP()
  906. };
  907.  
  908.  
  909. ///////////////////////////////////////////////////////////////////////////
  910. // class CProviderTypeInfo
  911.  
  912. class CProviderTypeInfo
  913. {
  914. public:
  915. // Constructors
  916.     CProviderTypeInfo()
  917.     {
  918.         memset(this, 0, sizeof(*this));
  919.     }
  920.  
  921. // Attributes
  922.     TCHAR           m_szTypeName[129];
  923.     USHORT          m_nDataType;
  924.     ULONG           m_nColumnSize;
  925.     TCHAR           m_szLiteralPrefix[129];
  926.     TCHAR           m_szLiteralSuffix[129];
  927.     TCHAR           m_szCreateParams[129];
  928.     VARIANT_BOOL    m_bIsNullable;
  929.     VARIANT_BOOL    m_bCaseSensitive;
  930.     ULONG           m_nSearchable;
  931.     VARIANT_BOOL    m_bUnsignedAttribute;
  932.     VARIANT_BOOL    m_bFixedPrecScale;
  933.     VARIANT_BOOL    m_bAutoUniqueValue;
  934.     TCHAR           m_szLocalTypeName[129];
  935.     SHORT           m_nMinScale;
  936.     SHORT           m_nMaxScale;
  937.     GUID            m_guidType;
  938.     TCHAR           m_szTypeLib[129];
  939.     TCHAR           m_szVersion[129];
  940.     VARIANT_BOOL    m_bIsLong;
  941.     VARIANT_BOOL    m_bBestMatch;
  942.  
  943. // Binding Maps
  944. BEGIN_COLUMN_MAP(CProviderTypeInfo)
  945.     COLUMN_ENTRY(1, m_szTypeName)
  946.     COLUMN_ENTRY(2, m_nDataType)
  947.     COLUMN_ENTRY(3, m_nColumnSize)
  948.     COLUMN_ENTRY(4, m_szLiteralPrefix)
  949.     COLUMN_ENTRY(5, m_szLiteralSuffix)
  950.     COLUMN_ENTRY(6, m_szCreateParams)
  951.     COLUMN_ENTRY(7, m_bIsNullable)
  952.     COLUMN_ENTRY(8, m_bCaseSensitive)
  953.     COLUMN_ENTRY(9, m_nSearchable)
  954.     COLUMN_ENTRY(10, m_bUnsignedAttribute)
  955.     COLUMN_ENTRY(11, m_bFixedPrecScale)
  956.     COLUMN_ENTRY(12, m_bAutoUniqueValue)
  957.     COLUMN_ENTRY(13, m_szLocalTypeName)
  958.     COLUMN_ENTRY(14, m_nMinScale)
  959.     COLUMN_ENTRY(15, m_nMaxScale)
  960.     COLUMN_ENTRY(16, m_guidType)
  961.     COLUMN_ENTRY(17, m_szTypeLib)
  962.     COLUMN_ENTRY(18, m_szVersion)
  963.     COLUMN_ENTRY(19, m_bIsLong)
  964.     COLUMN_ENTRY(20, m_bBestMatch)
  965. END_COLUMN_MAP()
  966. };
  967.  
  968.  
  969. ///////////////////////////////////////////////////////////////////////////
  970. // class CReferentialConstraintInfo
  971.  
  972. class CReferentialConstraintInfo
  973. {
  974. public:
  975. // Constructors
  976.     CReferentialConstraintInfo()
  977.     {
  978.         memset(this, 0, sizeof(*this));
  979.     }
  980.  
  981. // Attributes
  982.     TCHAR   m_szCatalog[129];
  983.     TCHAR   m_szSchema[129];
  984.     TCHAR   m_szName[129];
  985.     TCHAR   m_szUniqueCatalog[129];
  986.     TCHAR   m_szUniqueSchema[129];
  987.     TCHAR   m_szUniqueName[129];
  988.     TCHAR   m_szMatchOption[8];
  989.     TCHAR   m_szUpdateRule[12];
  990.     TCHAR   m_szDeleteRule[12];
  991.     TCHAR   m_szDescription[129];
  992.  
  993. // Binding Maps
  994. BEGIN_COLUMN_MAP(CReferentialConstraintInfo)
  995.     COLUMN_ENTRY(1,  m_szCatalog)
  996.     COLUMN_ENTRY(2,  m_szSchema)
  997.     COLUMN_ENTRY(3,  m_szName)
  998.     COLUMN_ENTRY(4,  m_szUniqueCatalog)
  999.     COLUMN_ENTRY(5,  m_szUniqueSchema)
  1000.     COLUMN_ENTRY(6,  m_szUniqueName)
  1001.     COLUMN_ENTRY(7,  m_szMatchOption)
  1002.     COLUMN_ENTRY(8,  m_szUpdateRule)
  1003.     COLUMN_ENTRY(9,  m_szDeleteRule)
  1004.     COLUMN_ENTRY(10, m_szDescription)
  1005. END_COLUMN_MAP()
  1006. };
  1007.  
  1008.  
  1009. ///////////////////////////////////////////////////////////////////////////
  1010. // class CSchemataInfo
  1011.  
  1012. class CSchemataInfo
  1013. {
  1014. public:
  1015. // Constructors
  1016.     CSchemataInfo()
  1017.     {
  1018.         memset(this, 0, sizeof(*this));
  1019.     }
  1020.  
  1021. // Attributes
  1022.     TCHAR   m_szCatalog[129];
  1023.     TCHAR   m_szName[129];
  1024.     TCHAR   m_szOwner[129];
  1025.     TCHAR   m_szCharCatalog[129];
  1026.     TCHAR   m_szCharSchema[129];
  1027.     TCHAR   m_szCharName[129];
  1028.  
  1029. // Binding Maps
  1030. BEGIN_COLUMN_MAP(CSchemataInfo)
  1031.     COLUMN_ENTRY(1, m_szCatalog)
  1032.     COLUMN_ENTRY(2, m_szName)
  1033.     COLUMN_ENTRY(3, m_szOwner)
  1034.     COLUMN_ENTRY(4, m_szCharCatalog)
  1035.     COLUMN_ENTRY(5, m_szCharSchema)
  1036.     COLUMN_ENTRY(6, m_szCharName)
  1037. END_COLUMN_MAP()
  1038. };
  1039.  
  1040.  
  1041. ///////////////////////////////////////////////////////////////////////////
  1042. // class CSQLLangugageInfo
  1043.  
  1044. class CSQLLanguageInfo
  1045. {
  1046. public:
  1047. // Constructors
  1048.     CSQLLanguageInfo()
  1049.     {
  1050.         memset(this, 0, sizeof(*this));
  1051.     }
  1052.  
  1053. // Attributes
  1054.     TCHAR   m_szSource[10];
  1055.     TCHAR   m_szYear[5];
  1056.     TCHAR   m_szConformance[13];
  1057.     TCHAR   m_szIntegrity[4];
  1058.     TCHAR   m_szImplementation[24];
  1059.     TCHAR   m_szBindingStyle[10];
  1060.     TCHAR   m_szProgrammingLanguage[10];
  1061.  
  1062. // Binding Maps
  1063. BEGIN_COLUMN_MAP(CSQLLanguageInfo)
  1064.     COLUMN_ENTRY(1, m_szSource)
  1065.     COLUMN_ENTRY(2, m_szYear)
  1066.     COLUMN_ENTRY(3, m_szConformance)
  1067.     COLUMN_ENTRY(4, m_szIntegrity)
  1068.     COLUMN_ENTRY(5, m_szImplementation)
  1069.     COLUMN_ENTRY(6, m_szBindingStyle)
  1070.     COLUMN_ENTRY(7, m_szProgrammingLanguage)
  1071. END_COLUMN_MAP()
  1072. };
  1073.  
  1074.  
  1075. ///////////////////////////////////////////////////////////////////////////
  1076. // class CStatisticInfo
  1077.  
  1078. class CStatisticInfo
  1079. {
  1080. public:
  1081. // Constructors
  1082.     CStatisticInfo()
  1083.     {
  1084.         memset(this, 0, sizeof(*this));
  1085.     }
  1086.  
  1087. // Attributes
  1088.     TCHAR   m_szTableCatalog[129];
  1089.     TCHAR   m_szTableSchema[129];
  1090.     TCHAR   m_szTableName[129];
  1091.     LONG    m_nCardinality;
  1092.  
  1093. // Binding Maps
  1094. BEGIN_COLUMN_MAP(CStatisticInfo)
  1095.     COLUMN_ENTRY(1, m_szTableCatalog)
  1096.     COLUMN_ENTRY(2, m_szTableSchema)
  1097.     COLUMN_ENTRY(3, m_szTableName)
  1098.     COLUMN_ENTRY(4, m_nCardinality)
  1099. END_COLUMN_MAP()
  1100. };
  1101.  
  1102.  
  1103. ///////////////////////////////////////////////////////////////////////////
  1104. // class CTableConstraintInfo
  1105.  
  1106. class CTableConstraintInfo
  1107. {
  1108. public:
  1109. // Constructors
  1110.     CTableConstraintInfo()
  1111.     {
  1112.         memset(this, 0, sizeof(*this));
  1113.     }
  1114.  
  1115. // Attributes
  1116.     TCHAR           m_szCatalog[129];
  1117.     TCHAR           m_szSchema[129];
  1118.     TCHAR           m_szName[129];
  1119.     TCHAR           m_szTableCatalog[129];
  1120.     TCHAR           m_szTableSchema[129];
  1121.     TCHAR           m_szTableName[129];
  1122.     TCHAR           m_szType[12];
  1123.     VARIANT_BOOL    m_bIsDeferrable;
  1124.     VARIANT_BOOL    m_bInitiallyDeferred;
  1125.     TCHAR           m_szDescription[129];
  1126.  
  1127. // Binding Maps
  1128. BEGIN_COLUMN_MAP(CTableConstraintInfo)
  1129.     COLUMN_ENTRY(1,  m_szCatalog)
  1130.     COLUMN_ENTRY(2,  m_szSchema)
  1131.     COLUMN_ENTRY(3,  m_szName)
  1132.     COLUMN_ENTRY(4,  m_szTableCatalog)
  1133.     COLUMN_ENTRY(5,  m_szTableSchema)
  1134.     COLUMN_ENTRY(6,  m_szTableName)
  1135.     COLUMN_ENTRY(7,  m_szType)
  1136.     COLUMN_ENTRY(8,  m_bIsDeferrable)
  1137.     COLUMN_ENTRY(9,  m_bInitiallyDeferred)
  1138.     COLUMN_ENTRY(10, m_szDescription)
  1139. END_COLUMN_MAP()
  1140. };
  1141.  
  1142.  
  1143. ///////////////////////////////////////////////////////////////////////////
  1144. // class CTablePrivilegeInfo
  1145.  
  1146. class CTablePrivilegeInfo
  1147. {
  1148. public:
  1149. // Constructors
  1150.     CTablePrivilegeInfo()
  1151.     {
  1152.         memset(this, 0, sizeof(*this));
  1153.     }
  1154.  
  1155. // Attributes
  1156.     TCHAR           m_szGrantor[129];
  1157.     TCHAR           m_szGrantee[129];
  1158.     TCHAR           m_szCatalog[129];
  1159.     TCHAR           m_szSchema[129];
  1160.     TCHAR           m_szName[129];
  1161.     TCHAR           m_szType[12];
  1162.     VARIANT_BOOL    m_bIsGrantable;
  1163.  
  1164. // Binding Maps
  1165. BEGIN_COLUMN_MAP(CTablePrivilegeInfo)
  1166.     COLUMN_ENTRY(1, m_szGrantor)
  1167.     COLUMN_ENTRY(2, m_szGrantee)
  1168.     COLUMN_ENTRY(3, m_szCatalog)
  1169.     COLUMN_ENTRY(4, m_szSchema)
  1170.     COLUMN_ENTRY(5, m_szName)
  1171.     COLUMN_ENTRY(6, m_szType)
  1172.     COLUMN_ENTRY(7, m_bIsGrantable)
  1173. END_COLUMN_MAP()
  1174. };
  1175.  
  1176.  
  1177.  
  1178. ///////////////////////////////////////////////////////////////////////////
  1179. // class CTableInfo
  1180.  
  1181. class CTableInfo
  1182. {
  1183. public:
  1184. // Constructors
  1185.     CTableInfo()
  1186.     {
  1187.         memset(this, 0, sizeof(*this));
  1188.     }
  1189.  
  1190. // Attributes
  1191.     TCHAR   m_szCatalog[129];
  1192.     TCHAR   m_szSchema[129];
  1193.     TCHAR   m_szName[129];
  1194.     TCHAR   m_szType[129];
  1195.     GUID    m_guidTable;
  1196.     TCHAR   m_szDescription[129];
  1197.  
  1198.  
  1199. // Binding Map
  1200. BEGIN_COLUMN_MAP(CTableInfo)
  1201.     COLUMN_ENTRY(1, m_szCatalog)
  1202.     COLUMN_ENTRY(2, m_szSchema)
  1203.     COLUMN_ENTRY(3, m_szName)
  1204.     COLUMN_ENTRY(4, m_szType)
  1205.     COLUMN_ENTRY(5, m_guidTable)
  1206.     COLUMN_ENTRY(6, m_szDescription)
  1207. END_COLUMN_MAP()
  1208. };
  1209.  
  1210.  
  1211. ///////////////////////////////////////////////////////////////////////////
  1212. // class CTranslationInfo
  1213.  
  1214. class CTranslationInfo
  1215. {
  1216. public:
  1217. // Constructors
  1218.     CTranslationInfo()
  1219.     {
  1220.         memset(this, 0, sizeof(*this));
  1221.     }
  1222.  
  1223. // Attributes
  1224.     TCHAR   m_szCatalog[129];
  1225.     TCHAR   m_szSchema[129];
  1226.     TCHAR   m_szName[129];
  1227.     TCHAR   m_szSourceCatalog[129];
  1228.     TCHAR   m_szSourceSchema[129];
  1229.     TCHAR   m_szSourceName[129];
  1230.     TCHAR   m_szTargetCatalog[129];
  1231.     TCHAR   m_szTargetSchema[129];
  1232.     TCHAR   m_szTargetName[129];
  1233.  
  1234. // Binding Maps
  1235. BEGIN_COLUMN_MAP(CTranslationInfo)
  1236.     COLUMN_ENTRY(1, m_szCatalog)
  1237.     COLUMN_ENTRY(2, m_szSchema)
  1238.     COLUMN_ENTRY(3, m_szName)
  1239.     COLUMN_ENTRY(4, m_szSourceCatalog)
  1240.     COLUMN_ENTRY(5, m_szSourceSchema)
  1241.     COLUMN_ENTRY(6, m_szSourceName)
  1242.     COLUMN_ENTRY(7, m_szTargetCatalog)
  1243.     COLUMN_ENTRY(8, m_szTargetSchema)
  1244.     COLUMN_ENTRY(9, m_szTargetName)
  1245. END_COLUMN_MAP()
  1246. };
  1247.  
  1248.  
  1249. ///////////////////////////////////////////////////////////////////////////
  1250. // class CUsagePrivilegeInfo
  1251.  
  1252. class CUsagePrivilegeInfo
  1253. {
  1254. public:
  1255. // Constructors
  1256.     CUsagePrivilegeInfo()
  1257.     {
  1258.         memset(this, 0, sizeof(*this));
  1259.     }
  1260.  
  1261. // Attributes
  1262.     TCHAR   m_szGrantor[129];
  1263.     TCHAR   m_szGrantee[129];
  1264.     TCHAR   m_szObjectCatalog[129];
  1265.     TCHAR   m_szObjectSchema[129];
  1266.     TCHAR   m_szObjectName[129];
  1267.     TCHAR   m_szObjectType[12];
  1268.     TCHAR   m_szPrivilegeType[6];
  1269.     VARIANT_BOOL    m_bIsGrantable;
  1270.  
  1271. // Binding Maps
  1272. BEGIN_COLUMN_MAP(CUsagePrivilegeInfo)
  1273.     COLUMN_ENTRY(1, m_szGrantor)
  1274.     COLUMN_ENTRY(2, m_szGrantee)
  1275.     COLUMN_ENTRY(3, m_szObjectCatalog)
  1276.     COLUMN_ENTRY(4, m_szObjectSchema)
  1277.     COLUMN_ENTRY(5, m_szObjectName)
  1278.     COLUMN_ENTRY(6, m_szObjectType)
  1279.     COLUMN_ENTRY(7, m_szPrivilegeType)
  1280.     COLUMN_ENTRY(8, m_bIsGrantable)
  1281. END_COLUMN_MAP()
  1282. };
  1283.  
  1284.  
  1285. ///////////////////////////////////////////////////////////////////////////
  1286. // class CViewColumnUsageInfo
  1287.  
  1288. class CViewColumnUsageInfo
  1289. {
  1290. public:
  1291. // Constructors
  1292.     CViewColumnUsageInfo()
  1293.     {
  1294.         memset(this, 0, sizeof(*this));
  1295.     }
  1296.  
  1297. // Attributes
  1298.     TCHAR   m_szCatalog[129];
  1299.     TCHAR   m_szSchema[129];
  1300.     TCHAR   m_szName[129];
  1301.     TCHAR   m_szTableCatalog[129];
  1302.     TCHAR   m_szTableSchema[129];
  1303.     TCHAR   m_szTableName[129];
  1304.     TCHAR   m_szColumnName[129];
  1305.     GUID    m_guidColumn;
  1306.     ULONG   m_nColumnPropID;
  1307.  
  1308. // Binding Maps
  1309. BEGIN_COLUMN_MAP(CViewColumnUsageInfo)
  1310.     COLUMN_ENTRY(1, m_szCatalog)
  1311.     COLUMN_ENTRY(2, m_szSchema)
  1312.     COLUMN_ENTRY(3, m_szName)
  1313.     COLUMN_ENTRY(4, m_szTableCatalog)
  1314.     COLUMN_ENTRY(5, m_szTableSchema)
  1315.     COLUMN_ENTRY(6, m_szTableName)
  1316.     COLUMN_ENTRY(7, m_szColumnName)
  1317.     COLUMN_ENTRY(8, m_guidColumn)
  1318.     COLUMN_ENTRY(9, m_nColumnPropID)
  1319. END_COLUMN_MAP()
  1320. };
  1321.  
  1322.  
  1323. ///////////////////////////////////////////////////////////////////////////
  1324. // class CViewTableUsageInfo
  1325.  
  1326. class CViewTableUsageInfo
  1327. {
  1328. public:
  1329. // Constructors
  1330.     CViewTableUsageInfo()
  1331.     {
  1332.         memset(this, 0, sizeof(*this));
  1333.     }
  1334.  
  1335. // Attributes
  1336.     TCHAR   m_szCatalog[129];
  1337.     TCHAR   m_szSchema[129];
  1338.     TCHAR   m_szName[129];
  1339.     TCHAR   m_szTableCatalog[129];
  1340.     TCHAR   m_szTableSchema[129];
  1341.     TCHAR   m_szTableName[129];
  1342.  
  1343. // Binding Maps
  1344. BEGIN_COLUMN_MAP(CViewTableUsageInfo)
  1345.     COLUMN_ENTRY(1, m_szCatalog)
  1346.     COLUMN_ENTRY(2, m_szSchema)
  1347.     COLUMN_ENTRY(3, m_szName)
  1348.     COLUMN_ENTRY(4, m_szTableCatalog)
  1349.     COLUMN_ENTRY(5, m_szTableSchema)
  1350.     COLUMN_ENTRY(6, m_szTableName)
  1351. END_COLUMN_MAP()
  1352. };
  1353.  
  1354.  
  1355. ///////////////////////////////////////////////////////////////////////////
  1356. // class CViewInfo
  1357.  
  1358. class CViewInfo
  1359. {
  1360. public:
  1361. // Constructors
  1362.     CViewInfo()
  1363.     {
  1364.         memset(this, 0, sizeof(*this));
  1365.     }
  1366.  
  1367. // Attributes
  1368.     TCHAR           m_szTableCatalog[129];
  1369.     TCHAR           m_szTableSchema[129];
  1370.     TCHAR           m_szTableName[129];
  1371.     TCHAR           m_szDefinition[129];
  1372.     VARIANT_BOOL    m_bCheckOption;
  1373.     VARIANT_BOOL    m_bIsUpdatable;
  1374.     TCHAR           m_szDescription[129];
  1375.  
  1376. // Binding Maps
  1377. BEGIN_COLUMN_MAP(CViewInfo)
  1378.     COLUMN_ENTRY(1, m_szTableCatalog)
  1379.     COLUMN_ENTRY(2, m_szTableSchema)
  1380.     COLUMN_ENTRY(3, m_szTableName)
  1381.     COLUMN_ENTRY(4, m_szDefinition)
  1382.     COLUMN_ENTRY(5, m_bCheckOption)
  1383.     COLUMN_ENTRY(6, m_bIsUpdatable)
  1384.     COLUMN_ENTRY(7, m_szDescription)
  1385. END_COLUMN_MAP()
  1386. };
  1387.  
  1388.  
  1389. ///////////////////////////////////////////////////////////////////////////
  1390. // typedefs
  1391.  
  1392. typedef CRestrictions<CAccessor<CAssertionInfo>,            3, &DBSCHEMA_ASSERTIONS>                CAssertions;
  1393. typedef CRestrictions<CAccessor<CCatalogInfo>,              1, &DBSCHEMA_CATALOGS >                 CCatalogs;
  1394. typedef CRestrictions<CAccessor<CCharacterSetInfo>,         3, &DBSCHEMA_CHARACTER_SETS>            CCharacterSets;
  1395. typedef CRestrictions<CAccessor<CCheckConstraintInfo>,      3, &DBSCHEMA_CHECK_CONSTRAINTS>         CCheckConstraints;
  1396. typedef CRestrictions<CAccessor<CCollationInfo>,            3, &DBSCHEMA_COLLATIONS>                CCollations;
  1397. typedef CRestrictions<CAccessor<CColumnDomainUsageInfo>,    4, &DBSCHEMA_COLUMN_DOMAIN_USAGE>       CColumnDomainUsage;
  1398. typedef CRestrictions<CAccessor<CColumnPrivilegeInfo>,      6, &DBSCHEMA_COLUMN_PRIVILEGES>         CColumnPrivileges;
  1399. typedef CRestrictions<CAccessor<CColumnsInfo>,              4, &DBSCHEMA_COLUMNS>                   CColumns;
  1400. typedef CRestrictions<CAccessor<CConstraintColumnUsageInfo>,4, &DBSCHEMA_CONSTRAINT_COLUMN_USAGE>   CConstraintColumnUsage;
  1401. typedef CRestrictions<CAccessor<CConstraintTableUsageInfo>, 3, &DBSCHEMA_CONSTRAINT_TABLE_USAGE>    CConstraintTableUsage;
  1402. typedef CRestrictions<CAccessor<CForeignKeysInfo>,          6, &DBSCHEMA_FOREIGN_KEYS>              CForeignKeys;
  1403. typedef CRestrictions<CAccessor<CIndexesInfo>,              5, &DBSCHEMA_INDEXES>                   CIndexes;
  1404. typedef CRestrictions<CAccessor<CKeyColumnUsageInfo>,       7, &DBSCHEMA_KEY_COLUMN_USAGE>          CKeyColumnUsage;
  1405. typedef CRestrictions<CAccessor<CPrimaryKeyInfo>,           3, &DBSCHEMA_PRIMARY_KEYS>              CPrimaryKeys;
  1406. typedef CRestrictions<CAccessor<CProcedureColumnInfo>,      4, &DBSCHEMA_PROCEDURE_COLUMNS>         CProcedureColumns;
  1407. typedef CRestrictions<CAccessor<CProcedureParameterInfo>,   4, &DBSCHEMA_PROCEDURE_PARAMETERS>      CProcedureParameters;
  1408. typedef CRestrictions<CAccessor<CProcedureInfo>,            4, &DBSCHEMA_PROCEDURES>                CProcedures;
  1409. typedef CRestrictions<CAccessor<CProviderTypeInfo>,         2, &DBSCHEMA_PROVIDER_TYPES>            CProviderTypes;
  1410. typedef CRestrictions<CAccessor<CReferentialConstraintInfo>,3, &DBSCHEMA_REFERENTIAL_CONSTRAINTS>   CReferentialConstraints;
  1411. typedef CRestrictions<CAccessor<CSchemataInfo>,             3, &DBSCHEMA_SCHEMATA>                  CSchemata;
  1412. typedef CRestrictions<CAccessor<CSQLLanguageInfo>,          0, &DBSCHEMA_SQL_LANGUAGES>             CSQLLanguages;
  1413. typedef CRestrictions<CAccessor<CStatisticInfo>,            3, &DBSCHEMA_STATISTICS>                CStatistics ;
  1414. typedef CRestrictions<CAccessor<CTableConstraintInfo>,      7, &DBSCHEMA_TABLE_CONSTRAINTS>         CTableConstraints;
  1415. typedef CRestrictions<CAccessor<CTablePrivilegeInfo>,       5, &DBSCHEMA_TABLE_PRIVILEGES>          CTablePrivileges;
  1416. typedef CRestrictions<CAccessor<CTableInfo>,                4, &DBSCHEMA_TABLES>                    CTables;
  1417. typedef CRestrictions<CAccessor<CTranslationInfo>,          3, &DBSCHEMA_TRANSLATIONS>              CTranslations;
  1418. typedef CRestrictions<CAccessor<CUsagePrivilegeInfo>,       6, &DBSCHEMA_USAGE_PRIVILEGES>          CUsagePrivileges;
  1419. typedef CRestrictions<CAccessor<CViewColumnUsageInfo>,      3, &DBSCHEMA_VIEW_COLUMN_USAGE>         CViewColumnUsage;
  1420. typedef CRestrictions<CAccessor<CViewTableUsageInfo>,       3, &DBSCHEMA_VIEW_TABLE_USAGE>          CViewTableUsage;
  1421. typedef CRestrictions<CAccessor<CViewInfo>,                 3, &DBSCHEMA_VIEWS>                     CViews;
  1422.  
  1423. ///////////////////////////////////////////////////////////////////////////
  1424.  
  1425. }; //namespace ATL
  1426.  
  1427. #endif // __ATLDBSCH_H__
  1428.  
  1429. ///////////////////////////////////////////////////////////////////////////
  1430.