MDAC 2.5 SDK - OLE DB Programmer's Reference
Appendix E: Interface Summary


 

Appendix E: Interface Summary

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

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

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

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

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


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


interface IAlterTable {
   HRESULT AlterColumn (
      DBID *              pTableID,
      DBID *              pColumnID,
      DBCOLUMNDESCFLAGS   ColumnDescFlags,
      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,
      ULONG *    pcRefCount);

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


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

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

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

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

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


interface ICommand {
   HRESULT Cancel();

   HRESULT Execute (
      IUnknown *    pUnkOuter,
      REFIID        riid,
      DBPARAMS *    pParams,
      LONG *        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 ICommandText : ICommand {
   HRESULT GetCommandText (
      GUID *       pguidDialect,
      LPOLESTR *   ppwszCommand);

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


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

   HRESULT MapParameterNames (
      ULONG             cParamNames,
      const OLECHAR *   rgParamNames[],
      LONG              rgParamOrdinals[]);

   HRESULT SetParameterInfo (
      ULONG                      cParams,
      const ULONG                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 (
      DWORD   dwReserved);

   HRESULT OnProgress (
      HCHAPTER   hChapter,
      ULONG      ulOperation,
      ULONG      ulProgress,
      ULONG      ulProgressMax,
      ULONG      ulAsynchPhase,
      LPOLESTR   pwszStatusText);

   HRESULT OnStop (
      HCHAPTER   hChapter,
      ULONG      ulOperation,
      HRESULT    hrStatus,
      LPOLESTR   pwszStatusText);
};


interface IDBAsynchStatus {
   HRESULT Abort (
      HCHAPTER   hChapter,
      ULONG      ulOperation);

   HRESULT GetStatus (
      HCHAPTER     hChapter,
      ULONG        ulOperation,
      ULONG *      pulProgress,
      ULONG *      pulProgressMax,
      ULONG *      pulAsynchPhase,
      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,
      ULONG                     cIndexColumnDescs,
      const DBINDEXCOLUMNDESC   rgIndexColumnDescs[],
      ULONG                     cPropertySets,
      DBPROPSET                 rgPropertySets[],
      DBID **                   ppIndexID);

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


interface IMultipleResults {
   HRESULT GetResult(
      IUnknown *    pUnkOuter,
      LONG          lReserved,
      REFIID        riid,
      LONG *        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,
   ULONG         iOrdinal,
   REFIID        riid,
   IUnknown **   ppRowset);
};

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

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

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

interface IRow {
   HRESULT GetColumns(
      ULONG            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(
      ULONG            cColumns,
      DBCOLUMNACCESS   rgColumns[ ]);
};

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

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

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

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

   HRESULT GetNextRows (
      HCHAPTER   hChapter,
      LONG       lRowsOffset,
      LONG       cRows,
      ULONG *    pcRowsObtained,
      HROW **    prghRows);

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

   HRESULT RestartPosition (
      HCHAPTER   hChapter);
};


interface IRowsetChange {
   HRESULT DeleteRows (
      HCHAPTER      hChapter,
      ULONG         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,
      ULONG          cbBookmark,
      const BYTE *   pBookmark,
      LONG           lRowsOffset,
      LONG           cRows,
      ULONG *        pcRowsObtained,
      HROW **        prghRows);
};


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


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

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

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


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

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

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


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

   HRESULT GetRowsAt (
      HWATCHREGION   hReserved1,
      HCHAPTER       hChapter
      ULONG          cbBookmark,
      const BYTE *   pBookmark,
      LONG           lRowsOffset,
      LONG           cRows,
      ULONG *        pcRowsObtained,
      HROW **        prghRows);

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

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


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

   HRESULT OnRowChange (
      IRowset *      pRowset,
      ULONG          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,
      ULONG            cRows,
      const HROW       rghRows[],
      BOOL             fOverWrite,
      ULONG *          pcRowsRefreshed,
      HROW **          prghRowsRefreshed,
      DBROWSTATUS **   prgRowStatus);
};

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

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

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

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


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

   HRESULT GetPendingRows (
      HCHAPTER             hChapter,
      DBPENDINGSTATUS      dwRowStatus,
      ULONG *              pcPendingRows,
      HROW **              prgPendingRows,
      DBPENDINGSTATUS **   prgPendingStatus);

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

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

   HRESULT Update (
      HCHAPTER        hChapter,
      ULONG           cRows,
      const HROW      rghRows[],
      ULONG *         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 (
      ULONG             cRows,
      LPCOLESTR         rgpwszSourceURLs[ ],
      LPCOLESTR         rgpwszDestURLs[ ],
      DWORD             dwCopyFlags,
      IAuthenticate *   pAuthenticate,
      DBSTATUS          rgdwStatus[ ],
      LPOLESTR          rgpwszNewURLs[ ],
      OLECHAR **        ppStringsBuffer);

   HRESULT Delete (
      ULONG       cRows,
      LPCOLESTR   rgpwszURLs[ ],
      DWORD       dwDeleteFlags,
      DBSTATUS    rgdwStatus[ ]);

   HRESULT Move (
      ULONG             cRows,
      LPCOLESTR         rgpwszSourceURLs[ ],
      LPCOLESTR         rgpwszDestURLs[ ],
      DWORD             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 Read( 
   void *    pv,
   ULONG     cb, 
   ULONG *   pcbRead);

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

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

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


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,
   ULONG *              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,
      ULONG          cColumnDescs,
      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,
   ULONG              cColumnDescs,
   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,
      ULONG *         pcRows,
      DBCOMPAREOP *   pCompareOps[],
      void *          pCriteriaData);

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

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


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

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


interface IViewSort {
   HRESULT GetSort (
      ULONG *    pcColumns,
      ULONG *    prgColumns[],
      DBSORT *   prgOrders[]);

   HRESULT SetSort (
      ULONG          cColumns,
      const ULONG    rgColumns[],
      const DBSORT   rgOrders[]);
};