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