Appendix E: Interface Summary

This appendix lists the prototypes of all interfaces in OLE DB.

interface IAccessor {
   HRESULT AddRefAccessor (
      HACCESSOR   hAccessor,
      DBREFCOUNT *pcRefCount);

   HRESULT CreateAccessor (
      DBACCESSORFLAGS   dwAccessorFlags,
      DBCOUNTITEM       cBindings,
      const DBBINDING   rgBindings[],
      DBLENGTH          cbRowSize,
      HACCESSOR        *phAccessor,
      DBBINDSTATUS      rgStatus[]);

   HRESULT GetBindings (
      HACCESSOR           hAccessor,
      DBACCESSORFLAGS    *pdwAccessorFlags,
      DBCOUNTITEM        *pcBindings,
      DBBINDING         **prgBindings);

   HRESULT ReleaseAccessor (
      HACCESSOR   hAccessor,
      DBREFCOUNT *pcRefCount);
};


interface IAlterIndex {
   HRESULT AlterIndex (
      DBID *      pTableID,
      DBID *      pIndexID,
      DBID *      pNewIndexID,
      ULONG       cPropertySets,
      DBPROPSET   rgPropertySet[]);
};


interface IAlterTable {
   HRESULT AlterColumn (
      DBID *              pTableID,
      DBID *              pColumnID,
      DBCOLUMNDESCFLAGS   dwColumnDescFlags,
      DBCOLUMNDESC *      pColumnDesc);

   HRESULT AlterTable (
      DBID *      pTableID,
      DBID *      pNewTableID,
      ULONG       cPropertySets,
      DBPROPSET   rgPropertySet[]);
};

interface IBindResource {
   HRESULT Bind(
      IUnknown *           pUnkOuter,
      LPCOLESTR            pwszURL,
      DBBINDURLFLAG        dwBindURLFlags,
      REFGUID              rguid,
      REFIID               riid,
      IAuthenticate *       pAuthenticate,
      DBIMPLICITSESSION *   pImplSession,
      DBBINDURLSTATUS *     pdwBindStatus,
      IUnknown **           ppUnk);
};

interface IChapteredRowset {
   HRESULT AddRefChapter (
      HCHAPTER    hChapter,
      DBREFCOUNT *pcRefCount);

   HRESULT ReleaseChapter (
      HCHAPTER    hChapter,
      DBREFCOUNT *pcRefCount);
};


interface IColumnsInfo {
   HRESULT GetColumnInfo (
      DBORDINAL     *pcColumns,
      DBCOLUMNINFO **prgInfo,
      OLECHAR      **ppStringsBuffer);

   HRESULT MapColumnIDs (
      DBORDINAL    cColumnIDs,
      const DBID   rgColumnIDs[],
      DBORDINAL    rgColumns[]);
};

interface IColumnsInfo2 {
HRESULT GetRestrictedColumnInfo(
      DBORDINAL         cColumnIDMasks,
      const DBID        rgColumnIDMasks[ ],
      DWORD             dwFlags,
      DBORDINAL        *pcColumns,
      DBID            **prgColumnIDs,
      DBCOLUMNINFO    **prgColumnInfo,
      OLECHAR         **ppStringsBuffer);
};

interface IColumnsRowset {
   HRESULT GetAvailableColumns (
      DBORDINAL   *pcOptColumns,
      DBID       **prgOptColumns);

   HRESULT GetColumnsRowset (
      IUnknown     *pUnkOuter,
      DBORDINAL     cOptColumns,
      const DBID    rgOptColumns[],
      REFIID        riid,
      ULONG         cPropertySets,
      DBPROPSET     rgPropertySets[],
      IUnknown    **ppColRowset);

};


interface ICommand {
   HRESULT Cancel();

   HRESULT Execute (
      IUnknown     *pUnkOuter,
      REFIID        riid,
      DBPARAMS     *pParams,
      DBROWCOUNT   *pcRowsAffected,
      IUnknown    **ppRowset);

   HRESULT GetDBSession (
      REFIID        riid,
      IUnknown **   ppSession);
};


interface ICommandPersist {
   HRESULT DeleteCommand(
      DBID *   pCommandID);

   HRESULT GetCurrentCommand(
      DBID *   pCommandID);

   HRESULT LoadCommand(
      DBID *   pCommandID,
      DWORD    dwFlags);

   HRESULT SaveCommand(
      DBID *   pCommandID,
      DWORD    dwFlags);
};


interface ICommandPrepare {
   HRESULT Prepare (
      ULONG   cExpectedRuns);

   HRESULT Unprepare();
};


interface ICommandProperties {
   HRESULT GetProperties (
      const ULONG         cPropertyIDSets,
      const DBPROPIDSET   rgPropertyIDSets[],
      ULONG *             pcPropertySets,
      DBPROPSET **        prgPropertySets);

   HRESULT SetProperties (
      ULONG       cPropertySets,
      DBPROPSET   rgPropertySets[]);
};

interface ICommandStream {
   HRESULT GetCommandStream (
      IID         *piid,
      GUID        *pguidDialect,
      IUnknown   **ppCommandStream);

   HRESULT SetCommandStream (
      REFIID      riid,
      REFGUID     rguidDialect,
      IUnknown   *pCommandStream);
};

interface ICommandText : ICommand {
   HRESULT GetCommandText (
      GUID *       pguidDialect,
      LPOLESTR *   ppwszCommand);

   HRESULT SetCommandText (
      REFGUID     rguidDialect,
      LPCOLESTR   pwszCommand);
};


interface ICommandWithParameters {
   HRESULT GetParameterInfo (
      DB_UPARAMS      *pcParams,
      DBPARAMINFO    **prgParamInfo,
      OLECHAR        **ppNamesBuffer);

   HRESULT MapParameterNames (
      DB_UPARAMS        cParamNames,
      const OLECHAR    *rgParamNames[],
      DB_LPARAMS        rgParamOrdinals[]);

   HRESULT SetParameterInfo (
      DB_UPARAMS              cParams,
      const DB_UPARAMS        rgParamOrdinals[],
      const DBPARAMBINDINFO   rgParamBindInfo[]);
};


interface IConvertType {
   HRESULT CanConvert (
      DBTYPE           wFromType,
      DBTYPE           wToType,
      DBCONVERTFLAGS   dwConvertFlags);
};

interface ICreateRow {
   HRESULT CreateRow(
      IUnknown *           pUnkOuter,
      LPCOLESTR            pwszURL,
      DBBINDURLFLAG        dwBindURLFlags,
      REFGUID              rguid,
      REFIID               riid,
      IAuthenticate *       pAuthenticate,
      DBIMPLICITSESSION *   pImplSession,
      DBBINDURLSTATUS *     pdwBindStatus,
      LPOLESTR *            ppwszNewURL,
      IUnknown **           ppUnk);
};

interface IDBAsynchNotify {
   HRESULT OnLowResource (
      DB_DWRESERVE dwReserved);

   HRESULT OnProgress (
      HCHAPTER      hChapter,
      DBASYNCHOP    eOperation,
      DBCOUNTITEM   ulProgress,
      DBCOUNTITEM   ulProgressMax,
      DBASYNCHPHASE eAsynchPhase,
      LPOLESTR      pwszStatusText);

   HRESULT OnStop (
      HCHAPTER   hChapter,
      DBASYNCHOP eOperation,
      HRESULT    hrStatus,
      LPOLESTR   pwszStatusText);
};


interface IDBAsynchStatus {
   HRESULT Abort (
      HCHAPTER      hChapter,
      DBASYNCHOP    eOperation);

   HRESULT GetStatus (
      HCHAPTER       hChapter,
      DBASYNCHOP     eOperation,
      DBCOUNTITEM   *pulProgress,
      DBCOUNTITEM   *pulProgressMax,
      DBASYNCHPHASE *peAsynchPhase,
      LPOLESTR      *ppwszStatusText);
};

interface IDBBinderProperties {
   HRESULT Reset();
};

interface IDBCreateCommand {
   HRESULT CreateCommand(
      IUnknown *    pUnkOuter,
      REFIID        riid,
      IUnknown **   ppCommand);
};


interface IDBCreateSession {
   HRESULT CreateSession (
      IUnknown *    pUnkOuter,
      REFIID        riid,
      IUnknown **   ppDBSession);
};


interface IDBDataSourceAdmin {
   HRESULT CreateDataSource(
      ULONG         cPropertySets,
      DBPROPSET     rgPropertySets[],
      IUnknown *    pUnkOuter,
      REFIID        riid,
      IUnknown **   ppSession);

   HRESULT DestroyDataSource ();

   HRESULT GetCreationProperties (
      ULONG               cPropertyIDSets,
      const DBPROPIDSET   rgPropertyIDSets[],
      ULONG *             pcPropertyInfoSets,
      DBPROPINFOSET **    prgPropertyInfoSets,
      OLECHAR **          ppDescBuffer);

   HRESULT ModifyDataSource (
      ULONG       cPropertySets,
      DBPROPSET   rgPropertySets[]);
};


interface IDBInfo {
   HRESULT GetKeywords(
      LPOLESTR *   ppwszKeywords);

   HRESULT GetLiteralInfo(
      ULONG              cLiterals,
      const DBLITERAL    rgLiterals[],
      ULONG *            pcLiteralInfo,
      DBLITERALINFO **   prgLiteralInfo,
      OLECHAR **         ppCharBuffer);
};


interface IDBInitialize {
   HRESULT Initialize();

   HRESULT Uninitialize();
};


interface IDBProperties {
   HRESULT GetProperties (
      ULONG               cPropertyIDSets,
      const DBPROPIDSET   rgPropertyIDSets[],
      ULONG *             pcPropertySets,
      DBPROPSET **        prgPropertySets);

   HRESULT GetPropertyInfo(
      ULONG               cPropertyIDSets,
      const DBPROPIDSET   rgPropertyIDSets[],
      ULONG *             pcPropertyInfoSets,
      DBPROPINFOSET **    prgPropertyInfoSets,
      OLECHAR **          ppDescBuffer);

   HRESULT SetProperties (
      ULONG       cPropertySets,
      DBPROPSET   rgPropertySets[]);
};


interface IDBSchemaRowset {
   HRESULT GetRowset (
      IUnknown *      punkOuter,
      REFGUID         rguidSchema,
      ULONG           cRestrictions,
      const VARIANT   rgRestrictions[],
      REFIID          riid,
      ULONG           cPropertySets,
      DBPROPSET       rgPropertySets[],
      IUnknown **     ppRowset);

   HRESULT GetSchemas (
      ULONG *   pcSchemas,
      GUID **   prgSchemas,
      ULONG **  prgRestrictionSupport);
};


interface IErrorInfo {
   HRESULT GetDescription (
      BSTR *   pbstrDescription);

   HRESULT GetGUID (
      GUID *   pguid);

   HRESULT GetHelpContext (
      DWORD *   pdwHelpContext);

   HRESULT GetHelpFile (
      BSTR *   pbstrHelpFile);

   HRESULT GetSource (
      BSTR *   pbstrSource);
};


interface IErrorLookup {
   HRESULT GetErrorDescription (
      HRESULT        hrError,
      DWORD          dwLookupID,
      DISPPARAMS *   pdispparams,
      LCID           lcid,
      BSTR *         pbstrSource,
      BSTR *         pbstrDescription);

   HRESULT GetHelpInfo (
      HRESULT   hrError,
      DWORD     dwLookupID,
      LCID      lcid,
      BSTR *    pbstrHelpFile,
      DWORD *   pdwHelpContext);

   HRESULT ReleaseErrors (
      const DWORD   dwDynamicErrorID);
};


interface IErrorRecords {
   HRESULT AddErrorRecord (
      ERRORINFO *    pErrorInfo,
      DWORD          dwLookupID,
      DISPPARAMS *   pdispparams,
      IUnknown *     punkCustomError,
      DWORD          dwDynamicErrorID);

   HRESULT GetBasicErrorInfo (
      ULONG         ulRecordNum,
      ERRORINFO *   pErrorInfo);

   HRESULT GetCustomErrorObject (
      ULONG         ulRecordNum,
      REFIID        riid,
      IUnknown **   ppObject);

   HRESULT GetErrorInfo (
      ULONG           ulRecordNum,
      LCID            lcid,
      IErrorInfo **   ppErrorInfo);

   HRESULT GetErrorParameters (
      ULONG          ulRecordNum,
      DISPPARAMS *   pdispparams);

   HRESULT GetRecordCount (
      ULONG *   pcRecords);
};


interface IGetDataSource {
   HRESULT GetDataSource (
      REFIID        riid,
      IUnknown **   ppDataSource);
};

interface IGetRow {
   HRESULT GetRowFromHROW(
      IUnknown *    pUnkOuter,
      HROW          hRow,
      REFIID        riid,
      IUnknown **   ppUnk);

   HRESULT GetURLFromHROW(
      HROW         hRow,
      LPOLESTR *   ppwszURL);
};

interface IGetSession {
   HRESULT GetSession(
      REFIID        riid,
      IUnknown **   ppSession);
};

interface IGetSourceRow {
   HRESULT GetSourceRow(
      REFIID        riid,
      IUnknown **   ppRow);
};

interface IIndexDefinition {
   HRESULT CreateIndex(
      DBID                     *pTableID,
      DBID                     *pIndexID,
      DBORDINAL                 cIndexColumnDescs,
      const DBINDEXCOLUMNDESC   rgIndexColumnDescs[],
      ULONG                     cPropertySets,
      DBPROPSET                 rgPropertySets[],
      DBID                    **ppIndexID);

   HRESULT DropIndex(
      DBID *   pTableID,
      DBID *   pIndexID);
};


interface IMultipleResults {
   HRESULT GetResult(
      IUnknown      *pUnkOuter,
      DBRESULTFLAG   lResultFlag,
      REFIID         riid,
      DBROWCOUNT    *pcRowsAffected,
      IUnknown     **ppRowset);
};


interface IOpenRowset {
   HRESULT OpenRowset(
      IUnknown *    pUnkOuter,
      DBID *        pTableID,
      DBID *        pIndexID,
      REFIID        riid,
      ULONG         cPropertySets,
      DBPROPSET     rgPropertySets[],
      IUnknown **   ppRowset);
};

interface IParentRowset {
   HRESULT GetChildRowset(
      IUnknown     *pUnkOuter,
      DBORDINAL     iOrdinal,
      REFIID        riid,
      IUnknown    **ppRowset);
};

interface IRegisterProvider {
   HRESULT GetURLMapping(
      LPCOLESTR      pwszURL,
      DB_DWRESERVE   dwReserved,
      CLSID         *pclsidProvider);

   HRESULT SetURLMapping(
      LPCOLESTR      pwszURL,
      DB_DWRESERVE   dwReserved,
      REFCLSID       rclsidProvider);

   HRESULT UnregisterProvider(
      LPCOLESTR      pwszURL,
      DB_DWRESERVE   dwReserved,
      REFCLSID       rclsidProvider);
};


interface IRow {
   HRESULT GetColumns(
      DBORDINAL        cColumns,
      DBCOLUMNACCESS   rgColumns[ ]);

   HRESULT GetSourceRowset(
      REFIID        riid,
      IUnknown **   ppRowset,
      HROW *        phRow);

   HRESULT Open(
      IUnknown *    pUnkOuter,
      DBID *        pColumnID,
      REFGUID       rguidColumnType,
      DWORD         dwFlags,
      REFIID        riid,
      IUnknown **   ppUnk);
};

interface IRowChange {
   HRESULT SetColumns(
      DBORDINAL        cColumns,
      DBCOLUMNACCESS   rgColumns[ ]);
};

interface IRowSchemaChange {
   HRESULT AddColumns(
      DBORDINAL            cColumns,
      const DBCOLUMNINFO   rgNewColumnInfo[ ],
      DBCOLUMNACCESS       rgColumns[ ]);

   HRESULT DeleteColumns(
      DBORDINAL    cColumns,
      const DBID   rgColumnIDs[ ],
      DBSTATUS     rgdwStatus[ ]);
};

interface IRowset {
   HRESULT AddRefRows(
      DBCOUNTITEM   cRows,
      const HROW    rghRows[],
      DBREFCOUNT    rgRefCounts[],
      DBROWSTATUS   rgRowStatus[]);

   HRESULT GetData (
      HROW        hRow,
      HACCESSOR   hAccessor,
      void *      pData);

   HRESULT GetNextRows (
      HCHAPTER       hChapter,
      DBROWOFFSET    lRowsOffset,
      DBROWCOUNT     cRows,
      DBCOUNTITEM   *pcRowsObtained,
      HROW         **prghRows);

   HRESULT ReleaseRows (
      DBCOUNTITEM    cRows,
      const HROW     rghRows[],
      DBROWOPTIONS   rgRowOptions[],
      DBREFCOUNT     rgRefCounts[],
      DBROWSTATUS    rgRowStatus[]);

   HRESULT RestartPosition (
      HCHAPTER   hChapter);
};

interface IRowsetBookmark {
   HRESULT PositionOnBookmark (
      HCHAPTER      hChapter,
      DBBKMARK      cbBookmark,
      const BYTE   *pBookmark);
};

interface IRowsetChange {
   HRESULT DeleteRows (
      HCHAPTER      hChapter,
      DBCOUNTITEM   cRows,
      const HROW    rghRows[],
      DBROWSTATUS   rgRowStatus[]);

   HRESULT InsertRow (
      HCHAPTER    hChapter,
      HACCESSOR   hAccessor,
      void *      pData,
      HROW *      phRow);

   HRESULT SetData (
      HROW        hRow,
      HACCESSOR   hAccessor,
      void *      pData);
};


interface IRowsetChapterMember {
   HRESULT IsRowInChapter (
      HCHAPTER   hChapter,
      HROW       hRow);
};


interface IRowsetCurrentIndex {
   HRESULT GetIndex (
      DBID **   ppIndexID);

   HRESULT SetIndex (
      DBID *    pIndexID);
};


interface IRowsetFind {
   HRESULT FindNextRow (
      HCHAPTER            hChapter,
      HACCESSOR           hAccessor,
      void               *pFindValue,
      DBCOMPAREOP         CompareOp,
      DBBKMARK            cbBookmark,
      const BYTE         *pBookmark,
      DBROWOFFSET         lRowsOffset,
      DBROWCOUNT          cRows,
      DBCOUNTITEM        *pcRowsObtained,
      HROW              **prghRows);
};


interface IRowsetIdentity {
   HRESULT IsSameRow (
      HROW   hThisRow,
      HROW   hThatRow);
};


interface IRowsetIndex {
   HRESULT GetIndexInfo (
      DBORDINAL             *pcKeyColumns,
      DBINDEXCOLUMNDESC    **prgIndexColumnDesc,
      ULONG                 *pcIndexProperties,
      DBPROPSET            **prgIndexProperties);

   HRESULT Seek (
      HACCESSOR   hAccessor,
      DBORDINAL   cKeyValues,
      void       *pData,
      DBSEEK      dwSeekOptions);


   HRESULT SetRange (
      HACCESSOR   hAccessor,
      DBORDINAL   cStartKeyColumns,
      void       *pStartData,
      DBORDINAL   cEndKeyColumns,
      void       *pEndData,
      DBRANGE     dwRangeOptions);
};


interface IRowsetInfo {
   HRESULT GetProperties (
      const ULONG         cPropertyIDSets,
      const DBPROPIDSET   rgPropertyIDSets[],
      ULONG *             pcPropertySets,
      DBPROPSET **        prgPropertySets);

   HRESULT GetReferencedRowset (
      DBORDINAL     iOrdinal,
      REFIID        riid,
      IUnknown    **ppReferencedRowset);

   HRESULT GetSpecification (
      REFIID        riid,
      IUnknown **   ppSpecification);
};


interface IRowsetLocate : IRowset {
   HRESULT Compare (
      HCHAPTER       hChapter,
      DBBKMARK       cbBookmark1,
      const BYTE    *pBookmark1,
      DBBKMARK       cbBookmark2,
      const BYTE    *pBookmark2,
      DBCOMPARE     *pComparison);

   HRESULT GetRowsAt (
      HWATCHREGION   hReserved1,
      HCHAPTER       hChapter,
      DBBKMARK       cbBookmark,
      const BYTE    *pBookmark,
      DBROWOFFSET    lRowsOffset,
      DBROWCOUNT     cRows,
      DBCOUNTITEM   *pcRowsObtained,
      HROW         **prghRows);

   HRESULT GetRowsByBookmark (
      HCHAPTER       hChapter,
      DBCOUNTITEM    cRows,
      const DBBKMARK rgcbBookmarks[],
      const BYTE    *rgpBookmarks[],
      HROW           rghRows[],
      DBROWSTATUS    rgRowStatus[]);

   HRESULT Hash (
      HCHAPTER       hChapter,
      DBBKMARK       cBookmarks,
      const DBBKMARK rgcbBookmarks[],
      const BYTE    *rgpBookmarks[],
      DBHASHVALUE    rgHashedValues[],
      DBROWSTATUS    rgBookmarkStatus[]);
};


interface IRowsetNotify {
   HRESULT OnFieldChange (
      IRowset       *pRowset,
      HROW           hRow,
      DBORDINAL      cColumns,
      DBORDINAL      rgColumns[],
      DBREASON       eReason,
      DBEVENTPHASE   ePhase,
      BOOL           fCantDeny);

   HRESULT OnRowChange (
      IRowset       *pRowset,
      DBCOUNTITEM    cRows,
      const HROW     rghRows[],
      DBREASON       eReason,
      DBEVENTPHASE   ePhase,
      BOOL           fCantDeny);

   HRESULT OnRowsetChange (
      IRowset *      pRowset,
      DBREASON       eReason,
      DBEVENTPHASE   ePhase,
      BOOL           fCantDeny);
};


interface IRowsetRefresh {
   HRESULT GetLastVisibleData (
      HROW        hRow,
      HACCESSOR   hAccessor,
      void *      pData);

   HRESULT RefreshVisibleData (
      HCHAPTER         hChapter,
      DBCOUNTITEM      cRows,
      const HROW       rghRows[],
      BOOL             fOverwrite,
      DBCOUNTITEM     *pcRowsRefreshed,
      HROW           **prghRowsRefreshed,
      DBROWSTATUS    **prgRowStatus);
};

interface IRowsetResynch {
HRESULT GetVisibleData
   (HROW       hRow,
   HACCESSOR   hAccessor,
   void *      pData);

HRESULT ResynchRows (
   DBCOUNTITEM    cRows,
   const HROW     rghRows[],
   DBCOUNTITEM    *pcRowsResynched,
   HROW           **prghRowsResynched,
   DBROWSTATUS    **prgRowStatus);
};

interface IRowsetScroll : IRowsetLocate {
   HRESULT GetApproximatePosition (
      HCHAPTER       hChapter,
      DBBKMARK       cbBookmark,
      const BYTE    *pBookmark,
      DBCOUNTITEM   *pulPosition,
      DBCOUNTITEM   *pcRows);

   HRESULT GetRowsAtRatio (
      HWATCHREGION   hReserved1,
      HCHAPTER       hChapter,
      DBCOUNTITEM    ulNumerator,
      DBCOUNTITEM    ulDenominator,
      DBROWCOUNT     cRows,
      DBCOUNTITEM   *pcRowsObtained,
      HROW         **prghRows);
};


interface IRowsetUpdate : IRowsetChange {
   HRESULT GetOriginalData (
      HROW        hRow,
      HACCESSOR   hAccessor,
      void *      pData);

   HRESULT GetPendingRows (
      HCHAPTER             hReserved,
      DBPENDINGSTATUS      dwRowStatus,
      DBCOUNTITEM         *pcPendingRows,
      HROW               **prgPendingRows,
      DBPENDINGSTATUS    **prgPendingStatus);

   HRESULT GetRowStatus(
      HCHAPTER          hChapter,
      DBCOUNTITEM       cRows,
      const HROW        rghRows[],
      DBPENDINGSTATUS   rgPendingStatus[]);

   HRESULT Undo (
      HCHAPTER         hReserved,
      DBCOUNTITEM      cRows,
      const HROW       rghRows[],
      DBCOUNTITEM     *pcRows,
      HROW           **prgRows,
      DBROWSTATUS    **prgRowStatus);


   HRESULT Update (
      HCHAPTER        hReserved,
      DBCOUNTITEM     cRows,
      const HROW      rghRows[],
      DBCOUNTITEM    *pcRows,
      HROW          **prgRows,
      DBROWSTATUS   **prgRowStatus);
};


interface IRowsetView {
   HRESULT CreateView (
      IUnknown *    pUnkOuter,
      REFIID        riid,
      IUnknown **   ppView);

   HRESULT GetView (
      HCHAPTER      hChapter,
      REFIID        riid,
      HCHAPTER *    phChapterSource,
      IUnknown **   ppView);
};

interface IScopedOperations {
   HRESULT Copy (
      DBCOUNTITEM       cRows,
      LPCOLESTR         rgpwszSourceURLs[ ],
      LPCOLESTR         rgpwszDestURLs[ ],
      DBCOPYFLAGS       dwCopyFlags,
      IAuthenticate    *pAuthenticate,
      DBSTATUS          rgdwStatus[ ],
      LPOLESTR          rgpwszNewURLs[ ],
      OLECHAR         **ppStringsBuffer);

   HRESULT Delete (
      DBCOUNTITEM     cRows,
      LPCOLESTR       rgpwszURLs[ ],
      DBDELETEFLAGS   dwDeleteFlags,
      DBSTATUS        rgdwStatus[ ]);

   HRESULT Move (
      DBCOUNTITEM       cRows,
      LPCOLESTR         rgpwszSourceURLs[ ],
      LPCOLESTR         rgpwszDestURLs[ ],
      DBMOVEFLAGS       dwMoveFlags,
      IAuthenticate    *pAuthenticate,
      DBSTATUS          rgdwStatus[ ],
      LPOLESTR          rgpwszNewURLs[ ],
      OLECHAR         **ppStringsBuffer);

   HRESULT OpenRowset (
      IUnknown *    pUnkOuter,
      DBID *        pTableID,
      DBID *        pIndexID,
      REFIID        riid,
      ULONG         cPropertySets,
      DBPROPSET     rgPropertySets[ ],
      IUnknown **   ppRowset);
};

interface ISessionProperties {
   HRESULT GetProperties (
      ULONG               cPropertyIDSets,
      const DBPROPIDSET   rgPropertyIDSets[],
      ULONG *             pcPropertySets,
      DBPROPSET **        prgPropertySets);

   HRESULT SetProperties (
      ULONG       cPropertySets,
      DBPROPSET   rgPropertySets[]);
};

interface ISequentialStream {
HRESULT Read(
   void *    pv,
   ULONG     cb,
   ULONG *   pcbRead);

HRESULT Write(
   void const *   pv,
   ULONG          cb,
   ULONG *        pcbWritten);
};

interface ISourcesRowset {
   HRESULT GetSourcesRowset(
      IUnknown      *pUnkOuter,
      REFIID        riid,
      ULONG         cPropertySets,
      DBPROPSET     rgPropertySets[],
      IUnknown **   ppSourcesRowset);
};


interface ISQLErrorInfo {
   HRESULT GetSQLInfo (
      BSTR *   pbstrSQLState,
      LONG *   plNativeError);
};


interface ISupportErrorInfo {
   HRESULT InterfaceSupportsErrorInfo (
      REFIID   riid);
};

interface ITableCreation {
   HRESULT GetTableDefinition(
      DBID               *pTableID,
      DBORDINAL          *pcColumnDescs,
      DBCOLUMNDESC       *prgColumnDescs[],
      ULONG              *pcPropertySets,
      DBPROPSET          *prgPropertySets[],
      ULONG              *pcConstraintDescs,
      DBCONSTRAINTDESC   *prgConstraintDescs[],
      OLECHAR           **ppwszStringBuffer);
};

interface ITableDefinition {
   HRESULT AddColumn(
      DBID *           pTableID,
      DBCOLUMNDESC *   pColumnDesc,
      DBID **          ppColumnID);

   HRESULT CreateTable(
      IUnknown            *pUnkOuter,
      DBID                *pTableID,
      DBORDINAL            cColumnDescs,
      const DBCOLUMNDESC   rgColumnDescs[],
      REFIID               riid,
      ULONG                cPropertySets,
      DBPROPSET            rgPropertySets[],
      DBID               **ppTableID,
      IUnknown           **ppRowset);

   HRESULT DropColumn(
      DBID *   pTableID,
      DBID *   pColumnID);

   HRESULT DropTable (
      DBID *   pTableID);
};

interface ITableDefinitionWithConstraints {
HRESULT AddConstraint(
   DBID *               pTableID,
   DBCONSTRAINTDESC *   pConstraintDesc);

   HRESULT CreateTableWithConstraints(
      IUnknown             *pUnkOuter,
      DBID                 *pTableID,
      DBORDINAL             cColumnDescs,
      const DBCOLUMNDESC    rgColumnDescs[],
      ULONG                 cConstraintDescs,
      DBCONSTRAINTDESC      rgConstraintDescs[],
      REFIID                riid,
      ULONG                 cPropertySets,
      DBPROPSET             rgPropertySets[],
      DBID                **ppTableID,
      IUnknown            **ppRowset);

HRESULT DropConstraint(
   DBID * pTableID,
   DBID * pConstraintID);
};

interface ITransaction {
   HRESULT Abort(
      BOID *   pboidReason,
      BOOL     fRetaining,
      BOOL     fAsync);

   HRESULT Commit(
      BOOL    fRetaining,
      DWORD   grfTC,
      DWORD   grfRM);

   HRESULT GetTransactionInfo(
      XACTTRANSINFO *   pInfo);
};


interface ITransactionJoin {
   HRESULT GetOptionsObject (
      ITransactionOptions **   ppOptions);

   HRESULT JoinTransaction (
      IUnknown *              punkTransactionCoord,
      ISOLEVEL                isoLevel,
      ULONG                   isoFlags,
      ITransactionOptions *   pOtherOptions);
};


interface ITransactionLocal : ITransaction {
   HRESULT GetOptionsObject (
      ITransactionOptions **   ppOptions);

   HRESULT StartTransaction (
      ISOLEVEL                isoLevel,
      ULONG                   isoFlags,
      ITransactionOptions *   pOtherOptions,
      ULONG *                 pulTransactionLevel);
};


interface ITransactionObject {
   HRESULT GetTransactionObject (
      ULONG             ulTransactionLevel,
      ITransaction **   ppTransactionObject);
};


interface ITransactionOptions {
   HRESULT GetOptions(
      XACTOPT *   pOptions);

   HRESULT SetOptions(
      XACTOPT *   pOptions);
};


interface IViewChapter {
   HRESULT GetSpecification (
      REFIID        riid,
      IUnknown **   ppRowset);

   HRESULT OpenViewChapter (
      HCHAPTER     hSource,
      HCHAPTER *   phViewChapter);
};


interface IViewFilter {
   HRESULT GetFilter (
      HACCESSOR       hAccessor,
      DBCOUNTITEM    *pcRows,
      DBCOMPAREOP    *pCompareOps[],
      void           *pCriteriaData);

   HRESULT GetFilterBindings(
      DBCOUNTITEM   *pcBindings,
      DBBINDING    **prgBindings);

   HRESULT SetFilter (
      HACCESSOR     hAccessor,
      DBCOUNTITEM   cRows,
      DBCOMPAREOP   CompareOps[],
      void         *pCriteriaData);
};


interface IViewRowset {
   HRESULT GetSpecification (
      REFIID        riid,
      IUnknown **   ppObject);

   HRESULT OpenViewRowset (
      IUnknown *    pUnkOuter,
      REFIID        riid,
      IUnknown **   ppRowset);
};


interface IViewSort {
   HRESULT GetSortOrder (
      DBORDINAL   *pcColumns,
      DBORDINAL   *prgColumns[],
      DBSORT      *prgOrders[]);

   HRESULT SetSortOrder (
      DBORDINAL         cColumns,
      const DBORDINAL   rgColumns[],
      const DBSORT      rgOrders[]);
};

This topic is a part of:

• Microsoft OLE DB