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);

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


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 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 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 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 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 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 IRowsetFind {
HRESULT FindNextRow (
HCHAPTER         hChapter,
HACCESSOR      hAccessor,
void *         pFindValue,
DBCOMPAREOP      CompareOp,
ULONG            cbBookmark,
const BYTE *   pBookmark,
BOOL            fSkipStartRow,
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 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 ISessionProperties {
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 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 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[]);
};