home *** CD-ROM | disk | FTP | other *** search
/ Supercompiler 1997 / SUPERCOMPILER97.iso / MS_DAO.SDK / DISK4 / DAOSDK.1 / dbdao.h < prev    next >
Encoding:
C/C++ Source or Header  |  1996-02-09  |  50.8 KB  |  1,198 lines
  1. /************************************************************************
  2. **      D B D A O . H                                                                                                           *
  3. **                                                                                                                                              *
  4. *************************************************************************
  5. ** Copyright (C) 1995 by Microsoft Corporation                                                  *
  6. **                 All Rights Reserved                                                                                  *
  7. ************************************************************************/
  8. /*
  9.     DBDAO.H
  10.  
  11.     Class definitions for dbdao SDK.  
  12.  
  13. This is a part of the Microsoft Data Access Objects SDK library.
  14. See the daosdk.hlp file for detailed information regarding the
  15. Microsoft Data Access Objects SDK product.
  16.  
  17. */
  18.  
  19. #ifndef _DBDAO_H_
  20. #define _DBDAO_H_
  21.  
  22. // Ignore warning "non dll-interface class 'X' used as base for dll-interface class 'Y'
  23. #pragma warning( disable : 4275 )
  24.  
  25. #include <dbdaoint.h>
  26. #include <daogetrw.h>
  27. #include <dbdaoid.h>
  28.  
  29. // Decorations
  30. #define CONSTRUCTOR
  31. #define DESTRUCTOR
  32.  
  33. //Disable export
  34. #ifndef DLLEXPORT
  35. #define DLLEXPORT  
  36. #endif
  37.  
  38. //Macro to convert HRESULT to IDA 
  39. #define DBERR(x) SCODE_CODE(GetScode(x))
  40.  
  41. // Include internal DAO definitions
  42. #include <_dbdao.h>
  43.  
  44. //      DAO Recordset::GetRowsEx() binding definitions
  45.  
  46. #define dbBindIndexINT  1
  47. #define dbBindIndexSTR  2
  48.  
  49. #define dbBindI2                DAO_I2                  // long
  50. #define dbBindI4                DAO_I4                  // short
  51. #define dbBindR4                DAO_R4                  // float
  52. #define dbBindR8                DAO_R8                  // double
  53. #define dbBindCY                DAO_CURRENCY    // Currency
  54. #define dbBindDATE              DAO_DATE                // DATE
  55. #define dbBindBOOL              DAO_BOOL                // VARIANT_BOOL
  56. #define dbBindUI1               DAO_CHAR                // unsigned char
  57. #define dbBindVARIANT   DAO_ANYVARIANT  // VARIANT
  58. #define dbBindWCHAR             DAO_WCHAR               // wchar_t[] (inline)
  59.  
  60. #define dbBindBookmark            DAO_BOOKMARK            // bookmark psuedo field
  61. #define dbBindLPSTR                DAO_LPSTR                // \0 string in pvVarBuffer
  62. #define dbBindLPWSTR            DAO_LPWSTR                // wide string in pvVarBuffer
  63. #define dbBindBlob                DAO_BLOB                // 
  64.  
  65. #ifdef _UNICODE
  66. #define dbBindSTRING    dbBindWCHAR     
  67. #define dbBindLPSTRING    dbBindLPWSTR
  68. #else
  69. #define dbBindSTRING    dbBindUI1
  70. #define dbBindLPSTRING    dbBindLPSTR
  71. #endif
  72.  
  73. //      Binding structure (Used with GetRowsEX)
  74.  
  75. typedef struct
  76.     {
  77.     DWORD   dwBindIndexType;
  78.     union
  79.         {
  80.         LONG    i;
  81.         LPCTSTR pstr;
  82.         };
  83.  
  84.     DWORD   dwType;
  85.     DWORD   dwOffset;
  86.     DWORD   cb;
  87.  
  88.     } DAORSETBINDING, *LPDAORSETBINDING;
  89.  
  90.  
  91.  
  92. /*****************************************************************************
  93. * Forwards
  94. */
  95. class COleVariant;
  96. class CdbBookmark;
  97. class CdbException;
  98. class CdbOleObject;
  99. class CdbObject;
  100. class CdbError;
  101. class CdbProperty;
  102. class CdbDBEngine;
  103. class CdbWorkspace;
  104. class CdbDatabase;
  105. class CdbRecordset;
  106. class CdbGetRowsEx;
  107. class CdbQueryDef;
  108. class CdbTableDef;
  109. class CdbField;
  110. class CdbRelation;
  111. class CdbIndex;
  112. class CdbUser;
  113. class CdbGroup;
  114. class CdbDocument;
  115. class CdbContainer;
  116. class CdbParameter;
  117. class CdbCollection;
  118. class CdbErrors;
  119. class CdbProperties;
  120. class CdbWorkspaces;
  121. class CdbDatabases;
  122. class CdbRecordsets;
  123. class CdbQueryDefs;
  124. class CdbTableDefs;
  125. class CdbFields;
  126. class CdbRelations;
  127. class CdbIndexes;
  128. class CdbUsers;
  129. class CdbGroups;
  130. class CdbDocuments;
  131. class CdbContainers;
  132. class CdbParameters;
  133.  
  134.  
  135. /*****************************************************************************
  136. * CdbException
  137. */
  138. class DLLEXPORT CdbException 
  139.     {
  140.     public:
  141.     CONSTRUCTOR                     CdbException            (HRESULT hr);
  142.  
  143.     HRESULT                         m_hr;
  144.     };
  145.  
  146.  
  147. /*****************************************************************************
  148. * CdbBookmark
  149. */
  150. class DLLEXPORT CdbBookmark : public COleVariant
  151.     {
  152.     public:
  153.  
  154.     CONSTRUCTOR                             CdbBookmark                     (LPSAFEARRAY psa);
  155.     CONSTRUCTOR                             CdbBookmark                     ();
  156.     operator                                LPSAFEARRAY                     (VOID);
  157.     };
  158.  
  159. /*****************************************************************************
  160. * CdbOleObject
  161. */
  162. class DLLEXPORT CdbOleObject : public CObject
  163.     {
  164.     public:
  165.     CONSTRUCTOR                             CdbOleObject            (VOID);
  166.     virtual DESTRUCTOR              ~CdbOleObject           (VOID);
  167.     BOOL                                    Exists                          (VOID);
  168.     CdbOleObject &                  operator =                      (CdbOleObject &o);
  169.  
  170.     VOID                                    SetInterface            (LPUNKNOWN punk, BOOL bAddRef=FALSE);
  171.     VOID                                    SetInterface            (REFIID riidClass, REFIID riidInterface);
  172.     VOID                                    SetInterfaceLic         (REFIID riidClass, REFIID riidInterface);
  173.     LPUNKNOWN                               GetInterface            (BOOL bAddRef=FALSE, BOOL bThrowException=TRUE) const;
  174.  
  175.     virtual VOID                    OnInterfaceChange       (VOID);
  176.     VOID                                    SetRichErrorInfo        (LPOLESTR pstrSource, LPOLESTR pstrDescription, LPOLESTR pstrHelpFile, ULONG ulHelpID) const;
  177.  
  178.     private:
  179.     BOOL                                    StartOLE                        (VOID);
  180.     LPUNKNOWN                               m_punkInterface;
  181.     };
  182.  
  183. /*****************************************************************************
  184. * CdbCollection
  185. */
  186. class DLLEXPORT CdbCollection : public CdbOleObject
  187.     {
  188.     public:
  189.  
  190.     // Methods
  191.     virtual CdbObject               ObItem                  (LONG i) = 0;
  192.     virtual CdbObject               ObItem                  (LPCTSTR pstr) = 0;
  193.     virtual LONG                    GetCount                (VOID) = 0;
  194.     virtual VOID                    ObAppend                (CdbObject &obj) = 0;
  195.     virtual VOID                    Delete                  (LPCTSTR pstr) = 0;
  196.     virtual VOID                    Refresh                 (VOID) = 0;
  197.     };
  198.  
  199. class DLLEXPORT CdbStaticCollection : public CdbCollection
  200.     {
  201.     public:
  202.     CdbObject                               ObItem                  (LONG i);
  203.     CdbObject                               ObItem                  (LPCTSTR pstr);
  204.     LONG                                    GetCount                (VOID);
  205.     VOID                                    ObAppend                (CdbObject &obj);
  206.     VOID                                    Delete                  (LPCTSTR pstr);
  207.     VOID                                    Refresh                 (VOID) ;
  208.     };
  209.  
  210. class DLLEXPORT CdbDynamicCollection : public CdbCollection
  211.     {
  212.     public:
  213.     CdbObject                               ObItem                  (LONG i);
  214.     CdbObject                               ObItem                  (LPCTSTR pstr);
  215.     LONG                                    GetCount                (VOID);
  216.     VOID                                    ObAppend                (CdbObject &obj);
  217.     VOID                                    Delete                  (LPCTSTR pstr);
  218.     VOID                                    Refresh                 (VOID);
  219.     };
  220.  
  221. #define DAOMFC_STATIC_COLLECTION_DECL(objColl, objSingle, intSingle)    \
  222.     class DLLEXPORT objColl : public CdbStaticCollection                                                    \
  223.         {                                                                                                                               \
  224.         public:                                                                                                                 \
  225.                                                                         \
  226.         objSingle                       Item                            (LONG i);                               \
  227.         objSingle                       Item                            (LPCTSTR pstr);                 \
  228.         objSingle                       operator[]                      (LONG i);                               \
  229.         objSingle                       operator[]                      (LPCTSTR pstr);                 \
  230.         }
  231.  
  232. #define DAOMFC_DYNAMIC_COLLECTION_DECL(objColl, objSingle, intSingle)   \
  233.     class DLLEXPORT objColl : public CdbDynamicCollection                                                   \
  234.         {                                                                                                                               \
  235.         public:                                                                                                                 \
  236.                                                                         \
  237.         objSingle                       Item                            (LONG i);                               \
  238.         objSingle                       Item                            (LPCTSTR pstr);                 \
  239.         VOID                            Append                          (objSingle &o);                 \
  240.         objSingle                       operator[]                      (LONG i);                               \
  241.         objSingle                       operator[]                      (LPCTSTR pstr);                 \
  242.         }
  243.  
  244. DAOMFC_STATIC_COLLECTION_DECL(CdbErrors, CdbError, DAOError);
  245. DAOMFC_STATIC_COLLECTION_DECL(CdbDatabases, CdbDatabase, DAODatabase);
  246. DAOMFC_STATIC_COLLECTION_DECL(CdbRecordsets, CdbRecordset, DAORecordset);
  247. DAOMFC_STATIC_COLLECTION_DECL(CdbParameters, CdbParameter, DAOParameter);
  248. DAOMFC_STATIC_COLLECTION_DECL(CdbDocuments, CdbDocument, DAODocument);
  249. DAOMFC_STATIC_COLLECTION_DECL(CdbContainers, CdbContainer, DAOContainer);
  250.  
  251. DAOMFC_DYNAMIC_COLLECTION_DECL(CdbProperties, CdbProperty, DAOProperty);
  252. DAOMFC_DYNAMIC_COLLECTION_DECL(CdbWorkspaces, CdbWorkspace, DAOWorkspace);
  253. DAOMFC_DYNAMIC_COLLECTION_DECL(CdbFields, CdbField, DAOField);
  254. DAOMFC_DYNAMIC_COLLECTION_DECL(CdbQueryDefs, CdbQueryDef, DAOQueryDef);
  255. DAOMFC_DYNAMIC_COLLECTION_DECL(CdbTableDefs, CdbTableDef, DAOTableDef);
  256. DAOMFC_DYNAMIC_COLLECTION_DECL(CdbIndexes, CdbIndex, DAOIndex);
  257. DAOMFC_DYNAMIC_COLLECTION_DECL(CdbRelations, CdbRelation, DAORelation);
  258. DAOMFC_DYNAMIC_COLLECTION_DECL(CdbUsers, CdbUser, DAOUser);
  259. DAOMFC_DYNAMIC_COLLECTION_DECL(CdbGroups, CdbGroup, DAOGroup);
  260.  
  261. /*****************************************************************************
  262. * CdbIndexFields (special case for index fields)
  263. */
  264. class DLLEXPORT CdbIndexFields : public CdbFields
  265.     {
  266.     public:
  267.     CdbField                                Item                            (LPCTSTR pstr);
  268.     CdbField                                Item                            (LONG i);
  269.     CdbObject                               ObItem                          (LPCTSTR pstr);
  270.     CdbObject                               ObItem                          (LONG i);
  271.     };
  272.  
  273. /*****************************************************************************
  274. * CdbObject
  275. */
  276. class DLLEXPORT CdbObject : public CdbOleObject
  277.     {
  278.     public:
  279.     CONSTRUCTOR                             CdbObject                       (VOID);
  280.     CONSTRUCTOR                             CdbObject                       (LPUNKNOWN punk, BOOL bAddRef=FALSE);
  281.  
  282.     virtual CString                 GetName                         (VOID); 
  283.     virtual VOID                    SetName                         (LPCTSTR pstr);
  284.  
  285.     CdbProperties                   Properties;
  286.     };
  287.  
  288. /*****************************************************************************
  289. * CdbLastOLEError
  290. */
  291. class DLLEXPORT CdbLastOLEError : public CdbOleObject
  292.     {
  293.     public:
  294.  
  295.     CONSTRUCTOR                             CdbLastOLEError         (VOID);
  296.  
  297.     CString                                 GetSource                       (VOID);
  298.     CString                                 GetDescription          (VOID);
  299.     CString                                 GetHelpFile                     (VOID);
  300.     DWORD                                   GetHelpContext          (VOID);
  301.     };
  302.  
  303. /*****************************************************************************
  304. * CdbDBEngine
  305. */
  306. class DLLEXPORT CdbDBEngine : public CdbObject
  307.     {
  308.     public:
  309.  
  310.     // Administration
  311.     CONSTRUCTOR                     CdbDBEngine                     (DAODBEngine *peng, BOOL bAddRef=FALSE);
  312.     CONSTRUCTOR                     CdbDBEngine                     (BOOL bPrivate=FALSE, BOOL bStart=TRUE, LPCTSTR pstrIniPath=NULL, LPCTSTR pstrDefUser=NULL, LPCTSTR pstrDefPW=NULL);
  313.     CONSTRUCTOR                     CdbDBEngine                     (const CdbDBEngine &);
  314.     CdbDBEngine &           operator =                      (const CdbDBEngine &);
  315.     inline CdbWorkspace     operator []                     (LONG lIndex);
  316.     inline CdbWorkspace     operator []                     (LPCTSTR pstrIndex);
  317.     VOID                            OnInterfaceChange       (VOID);
  318.  
  319.     // Properties
  320.     VOID                            SetDefaultPassword      (LPCTSTR pstr);
  321.     VOID                            SetDefaultUser          (LPCTSTR pstr);
  322.     VOID                            SetIniPath                      (LPCTSTR pstr);
  323.     CString                         GetIniPath                      (VOID);
  324.     VOID                            SetLoginTimeout         (SHORT s);
  325.     SHORT                           GetLoginTimeout         (VOID);
  326.     CString                         GetVersion                      (VOID);
  327.     CString                         GetSystemDB                     (VOID);
  328.     VOID                            SetSystemDB                     (LPCTSTR pstr);
  329.  
  330.     // Methods
  331.     CdbWorkspace            CreateWorkspace         (LPCTSTR pstrName, LPCTSTR pstrUser, LPCTSTR pstrPassword);
  332.     CdbDatabase                     OpenDatabase            (LPCTSTR pstrName, BOOL bExclusive=FALSE, BOOL bReadOnly=FALSE, LPCTSTR pstrConnect=NULL);
  333.     VOID                            CompactDatabase (LPCTSTR pstrOldDatabase, LPCTSTR pstrNewDatabase, LPCTSTR pstrDstConnect = NULL, LONG lOptions=-1, LPCTSTR pstrSrcConnect = NULL);
  334.     VOID                            RepairDatabase          (LPCTSTR pstrDatabase);
  335.     VOID                            RegisterDatabase        (LPCTSTR pstrDatabase, LPCTSTR pstrDriver, BOOL bSilent, LPCTSTR pstrAttributes);
  336.     VOID                            Idle                            (LONG lOptions=-1);
  337.     VOID                            Start                           (VOID);
  338.     
  339.     // Collections
  340.     CdbWorkspaces           Workspaces;
  341.     CdbErrors                       Errors;
  342.  
  343.     private:
  344.     BOOL                            m_bStarted;
  345.     };
  346.  
  347. /*****************************************************************************
  348. * CdbWorkspace
  349. */
  350. class DLLEXPORT CdbWorkspace : public CdbObject
  351.     {
  352.     public:
  353.  
  354.     // Administration
  355.     CONSTRUCTOR                     CdbWorkspace            (VOID);
  356.     CONSTRUCTOR                     CdbWorkspace            (DAOWorkspace *pwrk, BOOL bAddRef=FALSE);
  357.     CONSTRUCTOR                     CdbWorkspace            (const CdbWorkspace &);
  358.     CdbWorkspace &          operator =                      (const CdbWorkspace &);
  359.     inline CdbDatabase      operator []                     (LONG lIndex);
  360.     inline CdbDatabase      operator []                     (LPCTSTR pstrIndex);
  361.     VOID                            OnInterfaceChange       (VOID);
  362.  
  363.     // Properties
  364.     CString                         GetName                         (VOID);
  365.     VOID                            SetName                         (LPCTSTR pstr);
  366.     CString                         GetUserName                     (VOID);
  367.     BOOL                            GetIsolateODBCTrans     (VOID);
  368.     VOID                            SetIsolateODBCTrans     (BOOL b);
  369.  
  370.     // Methods
  371.     VOID                            BeginTrans                      (VOID);
  372.     VOID                            CommitTrans                     (VOID);
  373.     VOID                            Close                           (VOID);
  374.     VOID                            Rollback                        (VOID);
  375.     CdbDatabase                     OpenDatabase            (LPCTSTR pstrName, BOOL bExclusive=FALSE, BOOL bReadOnly=FALSE, LPCTSTR pstrConnect=NULL);
  376.     CdbDatabase                     CreateDatabase          (LPCTSTR pstrName, LPCTSTR pstrConnect, LONG lOption=-1);
  377.     CdbUser                         CreateUser                      (LPCTSTR pstrName=NULL, LPCTSTR pstrPID=NULL, LPCTSTR pstrPassword=NULL);
  378.     CdbGroup                        CreateGroup                     (LPCTSTR pstrName=NULL, LPCTSTR pstrPID=NULL);
  379.  
  380.     // Collections
  381.     CdbDatabases            Databases;
  382.     CdbUsers                        Users;
  383.     CdbGroups                       Groups;
  384.     };
  385.  
  386. /*****************************************************************************
  387. * CdbDatabase
  388. */
  389. class DLLEXPORT CdbDatabase : public CdbObject
  390.     {
  391.     public:
  392.  
  393.     // Administration
  394.     CONSTRUCTOR                     CdbDatabase                     (VOID);
  395.     CONSTRUCTOR                     CdbDatabase                     (DAODatabase *pdb, BOOL bAddRef=FALSE);
  396.     CONSTRUCTOR                     CdbDatabase                     (const CdbDatabase &);
  397.     CdbDatabase &           operator =                      (const CdbDatabase &);
  398.     inline CdbTableDef      operator []                     (LONG lIndex);
  399.     inline CdbTableDef      operator []                     (LPCTSTR pstrIndex);
  400.     VOID                            OnInterfaceChange       (VOID);
  401.  
  402.     // Properties
  403.     LONG                            GetCollatingOrder       (VOID);
  404.     CString                         GetConnect                      (VOID);
  405.     CString                         GetName                         (VOID);
  406.     SHORT                           GetQueryTimeout         (VOID);
  407.     VOID                            SetQueryTimeout         (SHORT s);
  408.     BOOL                            GetTransactions         (VOID);
  409.     BOOL                            GetUpdatable            (VOID);
  410.     CString                         GetVersion                      (VOID);
  411.     LONG                            GetRecordsAffected      (VOID);
  412.  
  413.     // Methods
  414.     VOID                            Close                           (VOID);
  415.     VOID                            Execute                         (LPCTSTR pstrQuery, LONG lOption=-1);
  416.     CdbRecordset            OpenRecordset           (LPCTSTR pstrName, LONG lType=-1, LONG lOptions=-1);
  417.     CdbProperty             CreateProperty          (LPCTSTR pstrName=NULL, LONG lType=-1, LPVARIANT pvValue=NULL, BOOL bDDL=FALSE);
  418.     CdbRelation             CreateRelation          (LPCTSTR pstrName=NULL, LPCTSTR pstrTable=NULL, LPCTSTR pstrForiegn=NULL, LONG lAttributes=-1);
  419.     CdbTableDef             CreateTableDef          (LPCTSTR pstrName=NULL, LONG lAttributes=-1, LPCTSTR pstrSource=NULL, LPCTSTR pstrConnect=NULL);
  420.     CdbQueryDef             CreateQueryDef          (LPCTSTR pstrName=NULL, LPCTSTR pstrSQL=NULL);
  421.  
  422.     // Collections
  423.     CdbTableDefs            TableDefs;
  424.     CdbQueryDefs            QueryDefs;
  425.     CdbRelations            Relations;
  426.     CdbContainers           Containers;
  427.     CdbRecordsets           Recordsets;
  428.     };
  429.  
  430. /*****************************************************************************
  431. * CdbGetRowsEx  (holds GetRowsEx for Recordset)
  432. */
  433. class DLLEXPORT CdbGetRowsEx : public CdbObject
  434.     {
  435.     public:
  436.  
  437.     // Administration
  438.     CONSTRUCTOR                     CdbGetRowsEx            (VOID);
  439.     CONSTRUCTOR                     CdbGetRowsEx            (ICDAORecordset *pGetRows, BOOL bAddRef=FALSE);
  440.     CONSTRUCTOR                     CdbGetRowsEx            (const CdbGetRowsEx &);
  441.     CdbGetRowsEx &          operator =                      (const CdbGetRowsEx &);
  442.     VOID                            OnInterfaceChange       (VOID);
  443.  
  444.     };
  445.  
  446. /*****************************************************************************
  447. * CdbRecordset
  448. */
  449. class DLLEXPORT CdbRecordset : public CdbObject
  450.     {
  451.     public:
  452.  
  453.     // Administration
  454.     CONSTRUCTOR                     CdbRecordset            (VOID);
  455.     CONSTRUCTOR                     CdbRecordset            (DAORecordset *prs, BOOL bAddRef=FALSE);
  456.     CONSTRUCTOR                     CdbRecordset            (const CdbRecordset &);
  457.     CdbRecordset &          operator =                      (const CdbRecordset &);
  458.     inline CdbField     operator []                     (LONG lIndex);
  459.     inline CdbField     operator []                     (LPCTSTR pstrIndex);
  460.     VOID                            OnInterfaceChange       (VOID);
  461.     VOID                            SetGetRowsExInt            (VOID);
  462.  
  463.     // Properties
  464.     BOOL                            GetBOF                          (VOID);
  465.     CdbBookmark                     GetBookmark                     (VOID);
  466.     VOID                            SetBookmark                     (class CdbBookmark &);
  467.     BOOL                            GetBookmarkable         (VOID);
  468.     COleDateTime                     GetDateCreated          (VOID);
  469.     COleDateTime                     GetLastUpdated          (VOID);
  470.     BOOL                            GetEOF                          (VOID);
  471.     CString                         GetFilter                       (VOID);
  472.     VOID                            SetFilter                       (LPCTSTR pstr);
  473.     CString                         GetIndex                        (VOID);
  474.     VOID                            SetIndex                        (LPCTSTR pstr);
  475.     CdbBookmark                     GetLastModified         (VOID);
  476.     BOOL                            GetLockEdits            (VOID);
  477.     VOID                            SetLockEdits            (BOOL b);
  478.     CString                         GetName                         (VOID);
  479.     BOOL                            GetNoMatch                      (VOID);
  480.     CString                         GetSort                         (VOID);
  481.     VOID                            SetSort                         (LPCTSTR pstr);
  482.     BOOL                            GetTransactions         (VOID);
  483.     SHORT                           GetType                         (VOID);
  484.     LONG                            GetRecordCount          (VOID);
  485.     BOOL                            GetUpdatable            (VOID);
  486.     BOOL                            GetRestartable          (VOID);
  487.     CString                         GetValidationText       (VOID);
  488.     CString                         GetValidationRule       (VOID);
  489.     CdbBookmark                     GetCacheStart           (VOID);
  490.     VOID                            SetCacheStart           (CdbBookmark &pbm);
  491.     LONG                            GetCacheSize            (VOID);
  492.     VOID                            SetCacheSize            (LONG l);
  493.     FLOAT                           GetPercentPosition      (VOID);
  494.     VOID                            SetPercentPosition      (FLOAT f);
  495.     LONG                            GetAbsolutePosition     (VOID);
  496.     VOID                            SetAbsolutePosition     (LONG l);
  497.     SHORT                           GetEditMode                     (VOID);
  498.  
  499.     // Methods
  500.     VOID                            CancelUpdate            (VOID);
  501.     VOID                            AddNew                          (VOID);
  502.     VOID                            Close                           (VOID);
  503.     CdbRecordset                    OpenRecordset           (LONG lType=-1, LONG lOption=-1);
  504.     VOID                            Delete                          (VOID);
  505.     VOID                            Edit                            (VOID);
  506.     VOID                            FindFirst                       (LPCTSTR pstrCriteria);
  507.     VOID                            FindLast                        (LPCTSTR pstrCriteria);
  508.     VOID                            FindNext                        (LPCTSTR pstrCriteria);
  509.     VOID                            FindPrevious            (LPCTSTR pstrCriteria);
  510.     VOID                            MoveFirst                       (VOID);
  511.     VOID                            MoveLast                        (VOID);
  512.     VOID                            MoveNext                        (VOID);
  513.     VOID                            MovePrevious            (VOID);
  514.     VOID                            Seek                            (LPCTSTR pstrComparison, LONG lNumFields, COleVariant cKey, ...);
  515.     VOID                            Update                          (VOID);
  516.     CdbRecordset            Clone                           (VOID);
  517.     VOID                            Requery                         (CdbQueryDef *pq = NULL);
  518.     VOID                            Move                            (LONG lRows, CdbBookmark *bm=NULL);
  519.     VOID                            FillCache                       (LONG lRows=-1, CdbBookmark *pbm=NULL);
  520.     CdbQueryDef                     CopyQueryDef            (VOID);
  521.     COleVariant                     GetRows                         (LONG lRows=-1);
  522.     LONG                            GetRowsEx                       (LPVOID pvBuffer, LONG cbRow, LPDAORSETBINDING prb, LONG cBinding, LPVOID pvVarBuffer = NULL, LONG cbVarBuffer = 0, LONG lRows = -1);
  523.  
  524.     inline VOID                        GetFieldV                       (COleVariant &vIndex, COleVariant &vValue);
  525.     inline VOID                     SetFieldV                       (COleVariant &vIndex, LPVARIANT pv);
  526.  
  527.     COleVariant                     GetField                        (LPCTSTR pstrIndex);
  528.     COleVariant                     GetField                        (LONG lIndex);
  529.     VOID                            SetField                        (LPCTSTR pstrIndex, LPVARIANT pv);
  530.     VOID                            SetField                        (LONG lIndex, LPVARIANT pv);
  531.  
  532.     // Collections
  533.     CdbFields                       Fields;
  534. protected:
  535.     // GetRowsEx interface
  536.     CdbGetRowsEx            m_GetRowsInt;
  537.     };
  538.  
  539.  
  540. /*****************************************************************************
  541. * CdbField
  542. */
  543. class DLLEXPORT CdbField : public CdbObject
  544.     {
  545.     public:
  546.  
  547.     // Administration
  548.     CONSTRUCTOR                     CdbField                        (VOID);
  549.     CONSTRUCTOR                     CdbField                        (DAOField *pfld, BOOL bAddRef=FALSE);
  550.     CONSTRUCTOR                     CdbField                        (const CdbField &);
  551.     CdbField &                      operator =                      (const CdbField &);
  552.     VOID                            OnInterfaceChange       (VOID);
  553.  
  554.     // Properties
  555.     LONG                            GetCollatingOrder       (VOID);
  556.     SHORT                           GetType                         (VOID);
  557.     VOID                            SetType                         (SHORT s);
  558.     CString                         GetName                         (VOID);
  559.     VOID                            SetName                         (LPCTSTR pstr);
  560.     LONG                            GetSize                         (VOID);
  561.     VOID                            SetSize                         (LONG l);
  562.     CString                         GetSourceField          (VOID);
  563.     CString                         GetSourceTable          (VOID);
  564.     COleVariant                     GetValue                        (VOID);
  565.  
  566.     VOID                            SetValue                        (LPVARIANT pv);
  567.     LONG                            GetAttributes           (VOID);
  568.     VOID                            SetAttributes           (LONG l);
  569.     SHORT                           GetOrdinalPosition      (VOID);
  570.     VOID                            SetOrdinalPosition      (SHORT s);
  571.     CString                         GetValidationText       (VOID);
  572.     VOID                            SetValidationText       (LPCTSTR pstr);
  573.     BOOL                            GetValidateOnSet        (VOID);
  574.     VOID                            SetValidateOnSet        (BOOL b);
  575.     CString                         GetValidationRule       (VOID);
  576.     VOID                            SetValidationRule       (LPCTSTR pstr);
  577.     CString                         GetDefaultValue         (VOID);
  578.     VOID                            SetDefaultValue         (LPCTSTR pstr);
  579.     BOOL                            GetRequired                     (VOID);
  580.     VOID                            SetRequired                     (BOOL b);
  581.     BOOL                            GetAllowZeroLength      (VOID);
  582.     VOID                            SetAllowZeroLength      (BOOL b);
  583.     BOOL                            GetDataUpdatable        (VOID);
  584.     CString                         GetForeignName          (VOID);
  585.     VOID                            SetForeignName          (LPCTSTR pstr);
  586.  
  587.     // Methods
  588.     VOID                            AppendChunk                     (LPVARIANT pv);
  589.     COleVariant                     GetChunk                        (LONG lOffset, LONG lBytes);
  590.     LONG                            FieldSize                       (VOID);
  591.     CdbProperty                     CreateProperty          (LPCTSTR pstrName=NULL, LONG lType=-1, LPVARIANT pvValue=NULL, BOOL bDDL=FALSE);
  592.     };
  593.  
  594. /*****************************************************************************
  595. * CdbQueryDef
  596. */
  597. class DLLEXPORT CdbQueryDef : public CdbObject
  598.     {
  599.     public:
  600.  
  601.     // Administration
  602.     CONSTRUCTOR                     CdbQueryDef                     (VOID);
  603.     CONSTRUCTOR                     CdbQueryDef                     (DAOQueryDef *pqd, BOOL bAddRef=FALSE);
  604.     CONSTRUCTOR                     CdbQueryDef                     (const CdbQueryDef &);
  605.     CdbQueryDef &           operator =                      (const CdbQueryDef &);
  606.     inline CdbField         operator []                     (LONG lIndex);
  607.     inline CdbField         operator []                     (LPCTSTR pstrIndex);
  608.     VOID                            OnInterfaceChange       (VOID);
  609.  
  610.     // Properties
  611.     COleDateTime                     GetDateCreated          (VOID);
  612.     COleDateTime                     GetLastUpdated          (VOID);
  613.     CString                         GetName                         (VOID);
  614.     VOID                            SetName                         (LPCTSTR pstr);
  615.     SHORT                           GetODBCTimeout          (VOID);
  616.     VOID                            SetODBCTimeout          (SHORT s);
  617.     SHORT                           GetType                         (VOID);
  618.     CString                         GetSQL                          (VOID);
  619.     VOID                            SetSQL                          (LPCTSTR pstr);
  620.     BOOL                            GetUpdatable            (VOID);
  621.     CString                         GetConnect                      (VOID);
  622.     VOID                            SetConnect                      (LPCTSTR pstr);
  623.     BOOL                            GetReturnsRecords       (VOID);
  624.     VOID                            SetReturnsRecords       (BOOL b);
  625.     LONG                            GetRecordsAffected      (VOID);
  626.  
  627.     // Methods
  628.     CdbRecordset            OpenRecordset           (LONG lType=-1, LONG lOption=-1);
  629.     VOID                            Execute                         (LONG lOption=-1);
  630.     CdbProperty                     CreateProperty          (LPCTSTR pstrName=NULL, LONG lType=-1, LPVARIANT pvValue=NULL, BOOL bDDL=FALSE);
  631.  
  632.     // Collections
  633.     CdbFields                       Fields;
  634.     CdbParameters           Parameters;
  635.     };
  636.  
  637. /*****************************************************************************
  638. * CdbTableDef
  639. */
  640. class DLLEXPORT CdbTableDef : public CdbObject
  641.     {
  642.     public:
  643.  
  644.     // Administration
  645.     CONSTRUCTOR                     CdbTableDef                     (VOID);
  646.     CONSTRUCTOR                     CdbTableDef                     (DAOTableDef *ptd, BOOL bAddRef=FALSE);
  647.     CONSTRUCTOR                     CdbTableDef                     (const CdbTableDef &);
  648.     CdbTableDef &           operator =                      (const CdbTableDef &);
  649.     inline CdbField         operator []                     (LONG lIndex);
  650.     inline CdbField         operator []                     (LPCTSTR pstrIndex);
  651.     VOID                            OnInterfaceChange       (VOID);
  652.  
  653.     // Properties
  654.     LONG                            GetAttributes           (VOID);
  655.     VOID                            SetAttributes           (LONG l);
  656.     CString                         GetConnect                      (VOID);
  657.     VOID                            SetConnect                      (LPCTSTR pstr);
  658.     COleDateTime                     GetDateCreated          (VOID);
  659.     COleDateTime                     GetLastUpdated          (VOID);
  660.     CString                         GetName                         (VOID);
  661.     VOID                            SetName                         (LPCTSTR pstr);
  662.     CString                         GetSourceTableName      (VOID);
  663.     VOID                            SetSourceTableName      (LPCTSTR pstr);
  664.     BOOL                            GetUpdatable            (VOID);
  665.     CString                         GetValidationText       (VOID);
  666.     VOID                            SetValidationText       (LPCTSTR pstr);
  667.     CString                         GetValidationRule       (VOID);
  668.     VOID                            SetValidationRule       (LPCTSTR pstr);
  669.     LONG                            GetRecordCount          (VOID);
  670.  
  671.     // Methods
  672.     CdbRecordset            OpenRecordset           (LONG lType=-1, LONG lOption=-1);
  673.     VOID                            RefreshLink                     (VOID);
  674.     CdbField                        CreateField                     (LPCTSTR pstrName=NULL, LONG lType=-1, LONG lSize=-1);
  675.     CdbIndex                        CreateIndex                     (LPCTSTR pstrName=NULL);
  676.     CdbProperty                     CreateProperty          (LPCTSTR pstrName=NULL, LONG lType=-1, LPVARIANT pvValue=NULL, BOOL bDDL=FALSE);
  677.  
  678.     // Collections
  679.     CdbFields                       Fields;
  680.     CdbIndexes                      Indexes;
  681.     };
  682.  
  683. /*****************************************************************************
  684. * CdbIndex
  685. */
  686. class DLLEXPORT CdbIndex : public CdbObject
  687.     {
  688.     public:
  689.  
  690.     // Administration
  691.     CONSTRUCTOR                     CdbIndex                        (VOID);
  692.     CONSTRUCTOR                     CdbIndex                        (DAOIndex *pidx, BOOL bAddRef=FALSE);
  693.     CONSTRUCTOR                     CdbIndex                        (const CdbIndex &);
  694.     CdbIndex &                      operator =                      (const CdbIndex &);
  695.     inline CdbField         operator []             (LONG lIndex);
  696.     inline CdbField         operator []             (LPCTSTR pstrIndex);
  697.     VOID                            OnInterfaceChange       (VOID);
  698.  
  699.     // Properties
  700.     CString                         GetName                         (VOID);
  701.     VOID                            SetName                         (LPCTSTR pstr);
  702.     BOOL                            GetForeign                      (VOID);
  703.     BOOL                            GetUnique                       (VOID);
  704.     VOID                            SetUnique                       (BOOL b);
  705.     BOOL                            GetClustered            (VOID);
  706.     VOID                            SetClustered            (BOOL b);
  707.     BOOL                            GetRequired                     (VOID);
  708.     VOID                            SetRequired                     (BOOL b);
  709.     BOOL                            GetIgnoreNulls          (VOID);
  710.     VOID                            SetIgnoreNulls          (BOOL b);
  711.     BOOL                            GetPrimary                      (VOID);
  712.     VOID                            SetPrimary                      (BOOL b);
  713.     LONG                            GetDistinctCount        (VOID);
  714.  
  715.     // Methods
  716.     CdbField                        CreateField                     (LPCTSTR pstrName=NULL, LONG lType=-1, LONG lSize=-1);
  717.     CdbProperty                     CreateProperty          (LPCTSTR pstrName=NULL, LONG lType=-1, LPVARIANT pvValue=NULL, BOOL bDDL=FALSE);
  718.  
  719.     // Collections
  720.     CdbIndexFields          Fields;
  721.     };
  722.  
  723. /*****************************************************************************
  724. * CdbParameter
  725. */
  726. class DLLEXPORT CdbParameter : public CdbObject
  727.     {
  728.     public:
  729.  
  730.     // Administration
  731.     CONSTRUCTOR                     CdbParameter            (VOID);
  732.     CONSTRUCTOR                     CdbParameter            (DAOParameter *pprm, BOOL bAddRef=FALSE);
  733.     CONSTRUCTOR                     CdbParameter            (const CdbParameter &);
  734.     CdbParameter &          operator =                      (const CdbParameter &);
  735.     VOID                            OnInterfaceChange       (VOID);
  736.  
  737.     // Properties
  738.     CString                         GetName                         (VOID);
  739.     COleVariant                     GetValue                        (VOID);
  740.     VOID                            SetValue                        (LPVARIANT pv);
  741.     SHORT                           GetType                         (VOID);
  742.     };
  743.  
  744. /*****************************************************************************
  745. * CdbRelation
  746. */
  747. class DLLEXPORT CdbRelation : public CdbObject
  748.     {
  749.     public:
  750.  
  751.     // Administration
  752.     CONSTRUCTOR                     CdbRelation                     (VOID);
  753.     CONSTRUCTOR                     CdbRelation                     (DAORelation *prl, BOOL bAddRef=FALSE);
  754.     CONSTRUCTOR                     CdbRelation                     (const CdbRelation &);
  755.     CdbRelation &           operator =                      (const CdbRelation &);
  756.     inline CdbField         operator []                     (LONG lIndex);
  757.     inline CdbField         operator []                     (LPCTSTR pstrIndex);
  758.     VOID                            OnInterfaceChange       (VOID);
  759.  
  760.     // Properties
  761.     CString                         GetName                         (VOID);
  762.     VOID                            SetName                         (LPCTSTR pstr);
  763.     CString                         GetTable                        (VOID);
  764.     VOID                            SetTable                        (LPCTSTR pstr);
  765.     CString                         GetForeignTable         (VOID);
  766.     VOID                            SetForeignTable         (LPCTSTR pstr);
  767.     LONG                            GetAttributes           (VOID);
  768.     VOID                            SetAttributes           (LONG);
  769.  
  770.     // Methods
  771.     CdbField                        CreateField                     (LPCTSTR pstrName=NULL, LONG lType=-1, LONG lSize=-1);
  772.  
  773.     // Collections
  774.     CdbFields                       Fields;
  775.     };
  776.  
  777. /*****************************************************************************
  778. * CdbUser
  779. */
  780. class DLLEXPORT CdbUser : public CdbObject
  781.     {
  782.     public:
  783.  
  784.     // Administration
  785.     CONSTRUCTOR                     CdbUser                         (VOID);
  786.     CONSTRUCTOR                     CdbUser                         (DAOUser *pusr, BOOL bAddRef=FALSE);
  787.     CONSTRUCTOR                     CdbUser                         (const CdbUser &);
  788.     CdbUser &                       operator =                      (const CdbUser &);
  789.     inline CdbGroup         operator []                     (LONG lIndex);
  790.     inline CdbGroup         operator []                     (LPCTSTR pstrIndex);
  791.     VOID                            OnInterfaceChange       (VOID);
  792.  
  793.     // Properties
  794.     CString                         GetName                         (VOID);
  795.     VOID                            SetName                         (LPCTSTR pstr);
  796.     VOID                            SetPID                          (LPCTSTR pstr);
  797.     VOID                            SetPassword                     (LPCTSTR pstr);
  798.  
  799.     // Methods
  800.     VOID                            NewPassword                     (LPCTSTR pstrOld, LPCTSTR pstrNew);
  801.     CdbGroup                        CreateGroup                     (LPCTSTR pstrName=NULL, LPCTSTR pstrPID=NULL);
  802.  
  803.     // Collections
  804.     CdbGroups                       Groups;
  805.     };
  806.  
  807. /*****************************************************************************
  808. * CdbGroup
  809. */
  810. class DLLEXPORT CdbGroup : public CdbObject
  811.     {
  812.     public:
  813.  
  814.     // Administration
  815.     CONSTRUCTOR                     CdbGroup                        (VOID);
  816.     CONSTRUCTOR                     CdbGroup                        (DAOGroup *pgrp, BOOL bAddRef=FALSE);
  817.     CONSTRUCTOR                     CdbGroup                        (const CdbGroup &);
  818.     CdbGroup &                      operator =                      (const CdbGroup &);
  819.     inline CdbUser          operator []                     (LONG lIndex);
  820.     inline CdbUser          operator []                     (LPCTSTR pstrIndex);
  821.     VOID                            OnInterfaceChange       (VOID);
  822.  
  823.     // Properties
  824.     CString                         GetName                         (VOID);
  825.     VOID                            SetName                         (LPCTSTR pstr);
  826.     VOID                            SetPID                          (LPCTSTR pstr);
  827.  
  828.     // Methods
  829.     CdbUser                         CreateUser                      (LPCTSTR pstrName=NULL, LPCTSTR pstrPID=NULL, LPCTSTR pstrPassword=NULL);
  830.  
  831.     // Collections
  832.     CdbUsers                        Users;
  833.     };
  834.  
  835. /*****************************************************************************
  836. * CdbDocument
  837. */
  838. class DLLEXPORT CdbDocument : public CdbObject
  839.     {
  840.     public:
  841.  
  842.     // Administration
  843.     CONSTRUCTOR                     CdbDocument                     (VOID);
  844.     CONSTRUCTOR                     CdbDocument                     (DAODocument *pdoc, BOOL bAddRef=FALSE);
  845.     CONSTRUCTOR                     CdbDocument                     (const CdbDocument &);
  846.     CdbDocument &           operator =                      (const CdbDocument &);
  847.     VOID                            OnInterfaceChange       (VOID);
  848.  
  849.     // Properties
  850.     CString                         GetName                         (VOID);
  851.     CString                         GetOwner                        (VOID);
  852.     VOID                            SetOwner                        (LPCTSTR pstr);
  853.     CString                         GetContainer            (VOID);
  854.     CString                         GetUserName                     (VOID);
  855.     VOID                            SetUserName                     (LPCTSTR pstr);
  856.     LONG                            GetPermissions          (VOID);
  857.     VOID                            SetPermissions          (LONG l);
  858.     COleDateTime                     GetDateCreated          (VOID);
  859.     COleDateTime                     GetLastUpdated          (VOID);
  860.     };
  861.  
  862. /*****************************************************************************
  863. * CdbContainer
  864. */
  865. class DLLEXPORT CdbContainer : public CdbObject
  866.     {
  867.     public:
  868.  
  869.     // Administration
  870.     CONSTRUCTOR                     CdbContainer            (VOID);
  871.     CONSTRUCTOR                     CdbContainer            (DAOContainer *pctn, BOOL bAddRef=FALSE);
  872.     CONSTRUCTOR                     CdbContainer            (const CdbContainer &);
  873.     CdbContainer &          operator =                      (const CdbContainer &);
  874.     inline CdbDocument      operator []                     (LONG lIndex);
  875.     inline CdbDocument      operator []                     (LPCTSTR pstrIndex);
  876.     VOID                            OnInterfaceChange       (VOID);
  877.  
  878.     // Properties
  879.     CString                         GetName                         (VOID);
  880.     CString                         GetOwner                        (VOID);
  881.     VOID                            SetOwner                        (LPCTSTR pstr);
  882.     CString                         GetUserName                     (VOID);
  883.     VOID                            SetUserName                     (LPCTSTR pstr);
  884.     LONG                            GetPermissions          (VOID);
  885.     VOID                            SetPermissions          (LONG l);
  886.     BOOL                            GetInherit                      (VOID);
  887.     VOID                            SetInherit                      (BOOL b);
  888.  
  889.     // Collections
  890.     CdbDocuments            Documents;
  891.     };
  892.  
  893. /*****************************************************************************
  894. * CdbError
  895. */
  896. class DLLEXPORT CdbError : public CdbObject
  897.     {
  898.     public:
  899.  
  900.     // Administration
  901.     CONSTRUCTOR                     CdbError                        (VOID);
  902.     CONSTRUCTOR                     CdbError                        (DAOError *perr, BOOL bAddRef=FALSE);
  903.     CONSTRUCTOR                     CdbError                        (const CdbError &);
  904.     CdbError &                      operator =                      (const CdbError &);
  905.     VOID                            OnInterfaceChange       (VOID);
  906.  
  907.     // Properties
  908.     LONG                            GetNumber                       (VOID);
  909.     CString                         GetSource                       (VOID);
  910.     CString                         GetDescription          (VOID);
  911.     CString                         GetHelpFile                     (VOID);
  912.     LONG                            GetHelpContext          (VOID);
  913.     };
  914.  
  915. /*****************************************************************************
  916. * CdbProperty
  917. */
  918. class DLLEXPORT CdbProperty : public CdbObject
  919.     {
  920.     public:
  921.  
  922.     // Administration
  923.     CONSTRUCTOR                     CdbProperty                     (VOID);
  924.     CONSTRUCTOR                     CdbProperty                     (DAOProperty *pprp, BOOL bAddRef=FALSE);
  925.     CONSTRUCTOR                     CdbProperty                     (const CdbProperty &);
  926.     CdbProperty &           operator =                      (const CdbProperty &);
  927.  
  928.     // Properties
  929.     COleVariant                     GetValue                        (VOID);
  930.     VOID                            SetValue                        (LPVARIANT pv);
  931.     CString                         GetName                         (VOID);
  932.     VOID                            SetName                         (LPCTSTR pstrName);
  933.     SHORT                           GetType                         (VOID);
  934.     VOID                            SetType                         (SHORT sType);
  935.     BOOL                            GetInherited            (VOID);
  936.     };
  937.  
  938.  
  939. /*****************************************************************************
  940. *  Inline functions
  941. */
  942. inline BOOL    CdbOleObject::Exists(void)
  943.     { 
  944.     return (m_punkInterface ? TRUE : FALSE);
  945.     }
  946.  
  947. /*****************************************************************************
  948. *  Recordset GetField functions
  949. */
  950.  
  951. inline VOID                CdbRecordset::GetFieldV(
  952.     COleVariant &vIndex,
  953.     COleVariant &vValue)
  954. {
  955.     DAORecordset *  prs     = (DAORecordset *)GetInterface();
  956.  
  957.     if (!prs)
  958.         {
  959.         DAOVINIT(vValue);
  960.         return;
  961.         }
  962.  
  963.     DAOMFC_CALL(prs->get_Collect(vIndex, &vValue));
  964.  
  965.     return;
  966. }
  967.  
  968. inline VOID                CdbRecordset::SetFieldV(
  969.     COleVariant &vIndex, 
  970.     LPVARIANT pv)
  971. {
  972.     DAORecordset *  prs     = (DAORecordset *)GetInterface();
  973.  
  974.     if (!prs)
  975.         return;
  976.  
  977.     DAOMFC_CALL(prs->put_Collect(vIndex, *pv));
  978. }
  979.  
  980.  
  981. /*****************************************************************************
  982. * Default collection operators
  983. */
  984. inline CdbWorkspace CdbDBEngine::operator []
  985.     (LONG lIndex)
  986. {
  987. return Workspaces[lIndex];
  988. }
  989.  
  990. inline CdbWorkspace CdbDBEngine::operator []
  991.     (LPCTSTR pstrIndex)
  992. {
  993. return Workspaces[pstrIndex];
  994. }
  995.  
  996.  
  997. inline CdbDatabase CdbWorkspace::operator []
  998.     (LONG lIndex)
  999. {
  1000. return Databases[lIndex];
  1001. }
  1002.  
  1003. inline CdbDatabase CdbWorkspace::operator []
  1004.     (LPCTSTR pstrIndex)
  1005. {
  1006. return Databases[pstrIndex];
  1007. }
  1008.  
  1009. inline CdbTableDef      CdbDatabase::operator []
  1010.     (LONG lIndex)
  1011. {
  1012. return TableDefs[lIndex];
  1013. }
  1014.  
  1015. inline CdbTableDef      CdbDatabase::operator []
  1016.     (LPCTSTR pstrIndex)
  1017. {
  1018. return TableDefs[pstrIndex];
  1019. }
  1020.  
  1021. inline CdbField      CdbRecordset::operator []
  1022.     (LONG lIndex)
  1023. {
  1024. return Fields[lIndex];
  1025. }
  1026.  
  1027. inline CdbField      CdbRecordset::operator []
  1028.     (LPCTSTR pstrIndex)
  1029. {
  1030. return Fields[pstrIndex];
  1031. }
  1032.  
  1033.  
  1034.  
  1035. inline CdbField CdbTableDef::operator []        
  1036.     (LONG lIndex)
  1037. {
  1038. return Fields[lIndex];
  1039. }
  1040.  
  1041. inline CdbField CdbTableDef::operator []        
  1042.     (LPCTSTR pstrIndex)
  1043. {
  1044. return Fields[pstrIndex];
  1045. }
  1046.  
  1047. inline CdbField CdbQueryDef::operator []        
  1048.     (LONG lIndex)
  1049. {
  1050. return Fields[lIndex];
  1051. }
  1052.  
  1053. inline CdbField CdbQueryDef::operator []        
  1054.     (LPCTSTR pstrIndex)
  1055. {
  1056. return Fields[pstrIndex];
  1057. }
  1058.  
  1059. inline CdbField CdbIndex::operator []   
  1060.     (LONG lIndex)
  1061. {
  1062. return Fields[lIndex];
  1063. }
  1064.  
  1065. inline CdbField CdbIndex::operator []   
  1066.     (LPCTSTR pstrIndex)
  1067. {
  1068. return Fields[pstrIndex];
  1069. }
  1070.  
  1071. inline CdbField CdbRelation::operator []
  1072.     (LONG lIndex)
  1073. {
  1074. return Fields[lIndex];
  1075. }
  1076.  
  1077. inline CdbField CdbRelation::operator []
  1078.     (LPCTSTR pstrIndex)
  1079. {
  1080. return Fields[pstrIndex];
  1081. }
  1082.  
  1083. inline CdbGroup CdbUser::operator []
  1084.     (LONG lIndex)
  1085. {
  1086. return Groups[lIndex];
  1087. }
  1088.  
  1089. inline CdbGroup CdbUser::operator []
  1090.     (LPCTSTR pstrIndex)
  1091. {
  1092. return Groups[pstrIndex];
  1093. }
  1094.  
  1095. inline CdbUser CdbGroup::operator []
  1096.     (LONG lIndex)
  1097. {
  1098. return Users[lIndex];
  1099. }
  1100.  
  1101. inline CdbUser CdbGroup::operator []
  1102.     (LPCTSTR pstrIndex)
  1103. {
  1104. return Users[pstrIndex];
  1105. }
  1106.  
  1107. inline CdbDocument CdbContainer::operator []
  1108.     (LONG lIndex)
  1109. {
  1110. return Documents[lIndex];
  1111. }
  1112.  
  1113. inline CdbDocument CdbContainer::operator []
  1114.     (LPCTSTR pstrIndex)
  1115. {
  1116. return Documents[pstrIndex];
  1117. }
  1118.  
  1119. /*****************************************************************************
  1120. *  Use different DAO interface for wide (UNICODE) versions
  1121. */
  1122.  
  1123. #ifdef _UNICODE
  1124.  
  1125. #define dbIID_IDAODBEngine IID_IDAODBEngineW
  1126. #define dbIID_IDAOError IID_IDAOErrorW
  1127. #define dbIID_IDAOErrors IID_IDAOErrorsW
  1128. #define dbIID_IDAOProperty IID_IDAOPropertyW
  1129. #define dbIID_IDAOProperties IID_IDAOPropertiesW
  1130. #define dbIID_IDAORecordset IID_IDAORecordsetW
  1131. #define dbIID_IDAORecordsets IID_IDAORecordsetsW
  1132. #define dbIID_IDAOWorkspace IID_IDAOWorkspaceW
  1133. #define dbIID_IDAOWorkspaces IID_IDAOWorkspacesW
  1134. #define dbIID_IDAOTableDef IID_IDAOTableDefW
  1135. #define dbIID_IDAOTableDefs IID_IDAOTableDefsW
  1136. #define dbIID_IDAOField IID_IDAOFieldW
  1137. #define dbIID_IDAOFields IID_IDAOFieldsW
  1138. #define dbIID_IDAOIndex IID_IDAOIndexW
  1139. #define dbIID_IDAOIndexes IID_IDAOIndexesW
  1140. #define dbIID_IDAOIndexFields IID_IDAOIndexFieldsW
  1141. #define dbIID_IDAOGroup IID_IDAOGroupW
  1142. #define dbIID_IDAOGroups IID_IDAOGroupsW
  1143. #define dbIID_IDAOUser IID_IDAOUserW
  1144. #define dbIID_IDAOUsers IID_IDAOUsersW
  1145. #define dbIID_IDAODatabase IID_IDAODatabaseW
  1146. #define dbIID_IDAODatabases IID_IDAODatabasesW
  1147. #define dbIID_IDAOQueryDef IID_IDAOQueryDefW
  1148. #define dbIID_IDAOQueryDefs IID_IDAOQueryDefsW
  1149. #define dbIID_IDAOParameter IID_IDAOParameterW
  1150. #define dbIID_IDAOParameters IID_IDAOParametersW
  1151. #define dbIID_IDAORelation IID_IDAORelationW
  1152. #define dbIID_IDAORelations IID_IDAORelationsW
  1153. #define dbIID_IDAOContainer IID_IDAOContainerW
  1154. #define dbIID_IDAOContainers IID_IDAOContainersW
  1155. #define dbIID_IDAODocument IID_IDAODocumentW
  1156. #define dbIID_IDAODocuments IID_IDAODocumentsW
  1157.  
  1158. #else
  1159.  
  1160. #define dbIID_IDAODBEngine IID_IDAODBEngine
  1161. #define dbIID_IDAOError IID_IDAOError
  1162. #define dbIID_IDAOErrors IID_IDAOErrors
  1163. #define dbIID_IDAOProperty IID_IDAOProperty
  1164. #define dbIID_IDAOProperties IID_IDAOProperties
  1165. #define dbIID_IDAORecordset IID_IDAORecordset
  1166. #define dbIID_IDAORecordsets IID_IDAORecordsets
  1167. #define dbIID_IDAOWorkspace IID_IDAOWorkspace
  1168. #define dbIID_IDAOWorkspaces IID_IDAOWorkspaces
  1169. #define dbIID_IDAOTableDef IID_IDAOTableDef
  1170. #define dbIID_IDAOTableDefs IID_IDAOTableDefs
  1171. #define dbIID_IDAOField IID_IDAOField
  1172. #define dbIID_IDAOFields IID_IDAOFields
  1173. #define dbIID_IDAOIndex IID_IDAOIndex
  1174. #define dbIID_IDAOIndexes IID_IDAOIndexes
  1175. #define dbIID_IDAOIndexFields IID_IDAOIndexFields
  1176. #define dbIID_IDAOGroup IID_IDAOGroup
  1177. #define dbIID_IDAOGroups IID_IDAOGroups
  1178. #define dbIID_IDAOUser IID_IDAOUser
  1179. #define dbIID_IDAOUsers IID_IDAOUsers
  1180. #define dbIID_IDAODatabase IID_IDAODatabase
  1181. #define dbIID_IDAODatabases IID_IDAODatabases
  1182. #define dbIID_IDAOQueryDef IID_IDAOQueryDef
  1183. #define dbIID_IDAOQueryDefs IID_IDAOQueryDefs
  1184. #define dbIID_IDAOParameter IID_IDAOParameter
  1185. #define dbIID_IDAOParameters IID_IDAOParameters
  1186. #define dbIID_IDAORelation IID_IDAORelation
  1187. #define dbIID_IDAORelations IID_IDAORelations
  1188. #define dbIID_IDAOContainer IID_IDAOContainer
  1189. #define dbIID_IDAOContainers IID_IDAOContainers
  1190. #define dbIID_IDAODocument IID_IDAODocument
  1191. #define dbIID_IDAODocuments IID_IDAODocuments
  1192.  
  1193. #endif
  1194.  
  1195.  
  1196.  
  1197. #endif // _DBDAO_H_ 
  1198.