665 lines
21 KiB
C++
665 lines
21 KiB
C++
//-----------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1992 - 1995.
|
|
//
|
|
// File: CRSEmbed.cxx
|
|
//
|
|
// Contents: IUnknown embedder for temptable.
|
|
//
|
|
// Functions:
|
|
//
|
|
// Notes:
|
|
//
|
|
//
|
|
// History: 08/30/96 | RenatoB | Created
|
|
//----------------------------------------------------------------------------
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// @class CRowsetInfo | embedding of Rowset,
|
|
// to give our IrowsetInfo interface
|
|
//
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
// Includes
|
|
#include "oleds.hxx"
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: CRowsetInfo::QueryInterface
|
|
//
|
|
// Synopsis: @mfunc QueryInterface.
|
|
// IUknown implementation.
|
|
// IID_IUnknown and IID_IRowsetInfo are not delegated
|
|
// All other IID's are delegated to _pRowset
|
|
//
|
|
//-----------------------------------------------------------------------.
|
|
HRESULT
|
|
CRowsetInfo::QueryInterface(
|
|
REFIID riid,
|
|
LPVOID *ppv
|
|
)
|
|
{
|
|
HRESULT hr;
|
|
if (ppv == NULL)
|
|
RRETURN(E_INVALIDARG);
|
|
|
|
*ppv = NULL;
|
|
|
|
if (riid == IID_IUnknown) {
|
|
*ppv = (IRowsetInfo FAR *) this;
|
|
AddRef();
|
|
}
|
|
|
|
if (riid == IID_IRowsetInfo) {
|
|
*ppv = (IRowsetInfo FAR *) this;
|
|
AddRef();
|
|
}
|
|
|
|
//delegate all the rest to the TempTable Rowset
|
|
if (_pRowset == NULL)
|
|
RRETURN(E_UNEXPECTED);
|
|
hr=((LPUNKNOWN)_pRowset)->QueryInterface(riid, ppv);
|
|
|
|
RRETURN(hr);
|
|
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: CRowsetInfo::CRowsetInfo
|
|
//
|
|
// Synopsis: @mfunc Ctor
|
|
//
|
|
// Arguments:
|
|
//
|
|
//
|
|
// Returns: @rdesc NONE
|
|
//
|
|
// Modifies:
|
|
//
|
|
// History: 08/30/96 RenatoB Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
CRowsetInfo::CRowsetInfo(
|
|
IUnknown *pUnkOuter, // controlling unknown)
|
|
IUnknown *pParentObject, // RowProvider
|
|
CSessionObject *pCSession, // Session that created rowset
|
|
CCommandObject *pCCommand // Command object that created rowset
|
|
)
|
|
|
|
{
|
|
_pUnkOuter= (pUnkOuter == NULL) ? this : pUnkOuter;
|
|
_pRowset = NULL;
|
|
_pParentObject = pParentObject;
|
|
_pCSession= pCSession;
|
|
_pCCommand = pCCommand;
|
|
|
|
_pMalloc = NULL;
|
|
_dwStatus = 0;
|
|
_cPropertySets = 0;
|
|
_pPropertySets = NULL;
|
|
|
|
if (_pCCommand !=NULL)
|
|
_pCCommand->IncrementOpenRowsets();
|
|
|
|
//this section is for IRowsetInfo and IUnknown methods.
|
|
|
|
InitializeCriticalSection(&_csRowsetInfo);
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: CRowsetInfo::~CRowsetInfo
|
|
//
|
|
// Synopsis: @mfunc Dtor
|
|
//
|
|
// Arguments:
|
|
//
|
|
//
|
|
// Returns: @rdesc NONE
|
|
//
|
|
// Modifies:
|
|
//
|
|
// History: 08/30/96 RenatoB Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
CRowsetInfo::~CRowsetInfo()
|
|
{
|
|
// release _pPropertySets
|
|
FreePropertySets(_cPropertySets, _pPropertySets);
|
|
if (_pMalloc!= NULL) _pMalloc->Release();
|
|
|
|
if (_pCCommand !=NULL) {
|
|
_pCCommand->DecrementOpenRowsets();
|
|
_pCCommand->Release();
|
|
_pCCommand = NULL;
|
|
}
|
|
|
|
if (_pCSession != NULL) {
|
|
_pCSession->Release();
|
|
_pCSession = NULL;
|
|
}
|
|
|
|
if (_pParentObject != NULL){
|
|
_pParentObject->Release();
|
|
_pParentObject=NULL;
|
|
}
|
|
|
|
if (_pRowset != NULL){
|
|
((LPUNKNOWN)_pRowset)->Release();
|
|
_pRowset=NULL;
|
|
}
|
|
|
|
if ( _pCRowsetInfo!= NULL) {
|
|
delete _pCRowsetInfo;
|
|
_pCRowsetInfo = NULL;
|
|
}
|
|
|
|
DeleteCriticalSection(&_csRowsetInfo);
|
|
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: CRowsetInfo::FInit
|
|
//
|
|
// Synopsis: @mfunc Initializer
|
|
//
|
|
// Called by: CreateTempTable
|
|
// Called when: After calling pIServiceProvider->ProvideService
|
|
// Synopsis: @mfunc Initializer
|
|
//
|
|
// Arguments:
|
|
//
|
|
//
|
|
// Returns: @rdesc NONE
|
|
// @flag S_OK | Interface is supported
|
|
// @flag E_OUTOFMEMORY | Interface is not supported by the TempTable
|
|
// @flag E_INVALIDARG | One or more arguments are invalid.
|
|
//
|
|
// Modifies:
|
|
//
|
|
// History: 08/30/96 RenatoB Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
HRESULT
|
|
CRowsetInfo::FInit(
|
|
IUnknown *pRowset) // TmpTable interface
|
|
{
|
|
HRESULT hr;
|
|
hr = S_OK;
|
|
_pRowset = pRowset;
|
|
|
|
RRETURN(hr);
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: CRowsetInfo::GetReferencedRowset
|
|
//
|
|
// Synopsis: @mfunc Returns an interface pointer to the rowset to which a bookmark applies
|
|
//
|
|
// Called by: Client
|
|
// Called when: Any time
|
|
//
|
|
// Arguments:
|
|
// iOrdinal [in] Bookmark column for which to get related rowset. Must be 0 in this impl.
|
|
// riid [in] IID of the interface pointer to return in *ppReferencedRowset.
|
|
// ppReferencedRowset[out] pointer to Rowset object referenced by Bookmark
|
|
//
|
|
//
|
|
// Returns: @rdesc NONE
|
|
// S_OK | Interface is supported
|
|
// E_INVALIDARG | ppReferencedRowset was a NULL pointer
|
|
// E_FAIL | provider specific error
|
|
// E_NOINTERFACE | Rowset does not support interface
|
|
// DB_E_NOTAREFENCEDCOLUMN | iOrdinal was not 0
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
HRESULT
|
|
CRowsetInfo::GetReferencedRowset(
|
|
DBORDINAL iOrdinal,
|
|
REFIID riid,
|
|
IUnknown** ppReferencedRowset
|
|
)
|
|
{
|
|
CAutoBlock(&(_csRowsetInfo));
|
|
|
|
if (ppReferencedRowset == NULL)
|
|
RRETURN(E_INVALIDARG);
|
|
|
|
if (iOrdinal != 0)
|
|
RRETURN(DB_E_BADORDINAL);
|
|
|
|
RRETURN(QueryInterface(
|
|
riid,
|
|
(void**)ppReferencedRowset)
|
|
);
|
|
|
|
};
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: CRowsetInfo::GetSpecificaton
|
|
//
|
|
// Synopsis: @mfunc Returns an interface pointer to the command that created the rowset
|
|
//
|
|
// Called by: Client
|
|
// Called when: Any time
|
|
//
|
|
// Arguments:
|
|
// riid [in] IID of the interface pointer to return in *ppSpecification.
|
|
// ppSpecification [out] pointer to command
|
|
//
|
|
//
|
|
// Returns: @rdesc NONE
|
|
// S_OK | Interface is supported
|
|
// E_INVALIDARG | ppSpecification was a NULL pointer
|
|
// E_FAIL | provider specific error
|
|
// E_NOINTERFACE | Command does not support interface
|
|
// S_FALSE | Rowset does not have command that created it
|
|
//----------------------------------------------------------------------------
|
|
HRESULT
|
|
CRowsetInfo::GetSpecification(
|
|
REFIID riid,
|
|
IUnknown** ppSpecification
|
|
)
|
|
{
|
|
CAutoBlock(&(_csRowsetInfo));
|
|
|
|
if (ppSpecification == NULL)
|
|
RRETURN(E_INVALIDARG);
|
|
|
|
if ( _pParentObject == NULL)
|
|
RRETURN(S_FALSE);
|
|
|
|
RRETURN(_pParentObject->QueryInterface(riid, (void**)ppSpecification));
|
|
};
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: CRowsetInfo::GetProperties
|
|
//
|
|
// Synopsis: @mfunc GetProperties
|
|
// Overloads the TempTable's IRowsetInfo::GetProperties.
|
|
// The first time this function is called, it calls the
|
|
// TmpTable IRowsetInfo::GetProperties with cPropertyIdSets == 0
|
|
//
|
|
// Called by: Client.
|
|
// Called when: Any time.
|
|
//
|
|
// Arguments:
|
|
// cPropertyIDSets[in] The number of DBPROPIDSET structures in rgProperttySets
|
|
// rgPropertyIDSets[in] Array of cPropertyIDSets of DBPROIDSET structs.
|
|
// pcPropertySets[out] number of DBPROPSET returned in *prgPropertySets
|
|
// prgPropertySets[out] pointer to array of DBPROPSET structures, having the
|
|
// value and status of requested properties
|
|
//
|
|
// Returns: @rdesc HRESULT
|
|
// S_OK Success
|
|
// DB_S_ERRORSOCCURRED Values were not supported for some properties
|
|
// E_FAIL A provider-specific error occurred
|
|
// E_INVALIDARG cPropertyIDSets > 0 and rgPropertyIdSEts = NULL
|
|
// pcPropertySets or prgPropertySets was NULL pointer
|
|
// In al element of rgPropertyIDSets, cPropertyIDs was not zero
|
|
// and rgPropertyIDs was a Null pointer
|
|
// E_OUTOFMEMORY Provider could not allocate memory
|
|
// DB_E_ERRORSOCCURRED Values were not returned for any properties
|
|
//-----------------------------------------------------------------------.
|
|
HRESULT
|
|
CRowsetInfo::GetProperties(
|
|
const ULONG cPropertyIDSets,
|
|
const DBPROPIDSET rgPropertyIDSets[],
|
|
ULONG* pcPropertySets,
|
|
DBPROPSET** prgPropertySets
|
|
)
|
|
{
|
|
CAutoBlock(&(_csRowsetInfo));
|
|
|
|
// mplPropertyIDsets maps the position of a property set in rgPropertyIDSets[]
|
|
// within _pPropertySets. It has (-1) if not mappable
|
|
LONG mplPropertyIDSets[50];
|
|
// mplPropertySets maps the position of a property within its corresponding
|
|
// rgProperties in _pPropertySets. It has (-1) if not mappable.
|
|
LONG position;
|
|
|
|
HRESULT hr = S_OK;
|
|
ULONG i;
|
|
ULONG j;
|
|
ULONG ibPropertyIDsets;
|
|
ULONG ibPropertySets;
|
|
BOOL bPartialSuccess = FALSE;
|
|
BOOL bErrorsOccurred = FALSE;
|
|
//validate arguments
|
|
if ( ((cPropertyIDSets > 0) && ( rgPropertyIDSets == NULL)) ||
|
|
(pcPropertySets == NULL) ||
|
|
(prgPropertySets == NULL) )
|
|
RRETURN(E_INVALIDARG);
|
|
|
|
for (i = 0; i< cPropertyIDSets; i++) {
|
|
if ((rgPropertyIDSets[i].cPropertyIDs > 0) &&
|
|
(rgPropertyIDSets[i].rgPropertyIDs ==NULL))
|
|
RRETURN(E_INVALIDARG);
|
|
}
|
|
|
|
//Initializate, if needed
|
|
if (_dwStatus == 0) InitProperties();
|
|
|
|
if (_dwStatus & STAT_INITERROR) //initialization was unsuccessful
|
|
RRETURN(E_FAIL);
|
|
|
|
// If CPropertyIDSets == 0, just copy
|
|
*pcPropertySets = 0;
|
|
*prgPropertySets = NULL;
|
|
//case when cPropertyIDSets == 0
|
|
if (cPropertyIDSets == 0) {
|
|
//allocate memory for the property sets
|
|
*prgPropertySets = (DBPROPSET*) _pMalloc->Alloc(
|
|
_cPropertySets*sizeof(DBPROPSET)
|
|
);
|
|
if (*prgPropertySets == NULL) {
|
|
hr = E_OUTOFMEMORY;
|
|
goto error;
|
|
};
|
|
|
|
*pcPropertySets = _cPropertySets;
|
|
|
|
// copy the array of property sets and make rgProperties equal to NULL
|
|
memcpy(
|
|
(void*) *prgPropertySets,
|
|
(void*) _pPropertySets,
|
|
_cPropertySets*sizeof(DBPROPSET)
|
|
);
|
|
|
|
for (i = 0; i< _cPropertySets; i++)
|
|
(*prgPropertySets)[i].rgProperties = NULL;
|
|
|
|
// make copies of each of the rgProperties contained in _pPropertySets
|
|
for (i = 0; i< _cPropertySets ; i++) {
|
|
(*prgPropertySets)[i].rgProperties=
|
|
(DBPROP*)_pMalloc->Alloc(
|
|
_pPropertySets[i].cProperties*sizeof(DBPROP)
|
|
);
|
|
|
|
if ((*prgPropertySets)[i].rgProperties == NULL) {
|
|
hr = E_OUTOFMEMORY;
|
|
goto error;
|
|
};
|
|
|
|
memcpy(
|
|
(void*)((*prgPropertySets)[i].rgProperties),
|
|
(void*) (_pPropertySets[i].rgProperties),
|
|
_pPropertySets[i].cProperties*sizeof(DBPROP)
|
|
);
|
|
|
|
};
|
|
|
|
RRETURN(S_OK);
|
|
};
|
|
// This is the case when cPropertyIDSets != 0
|
|
// First, allocate memory
|
|
*prgPropertySets = (DBPROPSET*) _pMalloc->Alloc(
|
|
cPropertyIDSets*sizeof(DBPROPSET)
|
|
);
|
|
|
|
if (*prgPropertySets == NULL) {
|
|
hr = E_OUTOFMEMORY;
|
|
goto error;
|
|
};
|
|
memset((void*)*prgPropertySets, 0, sizeof(DBPROPSET)*cPropertyIDSets );
|
|
*pcPropertySets= cPropertyIDSets;
|
|
memset(mplPropertyIDSets, 0, sizeof(LONG)*cPropertyIDSets );
|
|
|
|
for (i=0; i<cPropertyIDSets; i++) {
|
|
(*prgPropertySets)[i].guidPropertySet =
|
|
rgPropertyIDSets[i].guidPropertySet;
|
|
mplPropertyIDSets[i] = SearchGuid(
|
|
rgPropertyIDSets[i].guidPropertySet
|
|
);
|
|
|
|
if (mplPropertyIDSets[i] < 0) {
|
|
bErrorsOccurred = TRUE;
|
|
(*prgPropertySets)[i].cProperties = 0;
|
|
(*prgPropertySets)[i].rgProperties = NULL;
|
|
|
|
(*prgPropertySets)[i].guidPropertySet =
|
|
rgPropertyIDSets[i].guidPropertySet;
|
|
}
|
|
|
|
else {
|
|
//The PropertySet is supported. Remember its position in ibPropertyIDsets
|
|
ibPropertyIDsets = mplPropertyIDSets[i];
|
|
//We write the property-set's GUID
|
|
(*prgPropertySets)[i].guidPropertySet =
|
|
rgPropertyIDSets[i].guidPropertySet;
|
|
|
|
if (rgPropertyIDSets[i].cPropertyIDs == 0) {
|
|
//the client is asking for all properties
|
|
bPartialSuccess = TRUE;
|
|
(*prgPropertySets)[i].rgProperties=
|
|
(DBPROP*)_pMalloc->Alloc(
|
|
_pPropertySets[ibPropertyIDsets].cProperties*sizeof(DBPROP)
|
|
);
|
|
|
|
if ((*prgPropertySets)[i].rgProperties == NULL) {
|
|
hr = E_OUTOFMEMORY;
|
|
goto error;
|
|
};
|
|
|
|
(*prgPropertySets)[i].cProperties=
|
|
_pPropertySets[ibPropertyIDsets].cProperties;
|
|
|
|
memcpy(
|
|
(void*) ((*prgPropertySets)[i].rgProperties),
|
|
(void*) _pPropertySets[ibPropertyIDsets].rgProperties,
|
|
_pPropertySets[ibPropertyIDsets].cProperties*sizeof(DBPROP)
|
|
);
|
|
|
|
}
|
|
else {
|
|
//the client asks for some properties only. Alloc and clear memory
|
|
(*prgPropertySets)[i].rgProperties=
|
|
(DBPROP*)_pMalloc->Alloc(rgPropertyIDSets[i].cPropertyIDs
|
|
*sizeof(DBPROP));
|
|
|
|
if ((*prgPropertySets)[i].rgProperties == NULL) {
|
|
hr = E_OUTOFMEMORY;
|
|
goto error;
|
|
};
|
|
|
|
(*prgPropertySets)[i].cProperties =
|
|
rgPropertyIDSets[i].cPropertyIDs;
|
|
|
|
memset(
|
|
((*prgPropertySets)[i].rgProperties),
|
|
0,
|
|
rgPropertyIDSets[i].cPropertyIDs*sizeof(DBPROP)
|
|
);
|
|
|
|
//iterate and set values
|
|
for (j=0; j <rgPropertyIDSets[i].cPropertyIDs; j++) {
|
|
position =
|
|
SearchPropid(
|
|
ibPropertyIDsets,
|
|
rgPropertyIDSets[i].rgPropertyIDs[j]
|
|
);
|
|
|
|
if (position < 0) {
|
|
//could not find a property
|
|
bErrorsOccurred = TRUE;
|
|
(*prgPropertySets)[i].rgProperties[j].dwPropertyID =
|
|
rgPropertyIDSets[i].rgPropertyIDs[j];
|
|
|
|
(*prgPropertySets)[i].rgProperties[j].dwStatus =
|
|
DBPROPSTATUS_NOTSUPPORTED;
|
|
}
|
|
|
|
else {
|
|
bPartialSuccess= TRUE;
|
|
ibPropertySets = position;
|
|
memcpy(
|
|
(void*)&((*prgPropertySets)[i].rgProperties[j] ),
|
|
(void*)&(_pPropertySets[ibPropertyIDsets].
|
|
rgProperties[ibPropertySets]),
|
|
sizeof(DBPROP));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ((bPartialSuccess == TRUE) && (bErrorsOccurred == FALSE))
|
|
RRETURN(S_OK);
|
|
|
|
if (bPartialSuccess == TRUE)
|
|
RRETURN(DB_S_ERRORSOCCURRED);
|
|
|
|
hr = DB_E_ERRORSOCCURRED;
|
|
goto error;
|
|
|
|
error:
|
|
|
|
FreePropertySets( *pcPropertySets, *prgPropertySets);
|
|
*pcPropertySets = NULL;
|
|
*prgPropertySets = NULL;
|
|
RRETURN(hr);
|
|
|
|
};
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: CRowsetInfo::FreePropertySets
|
|
//
|
|
// Synopsis: @mfunc releases the memory of property sets
|
|
//
|
|
// Arguments:
|
|
// cPropertySets [in] number of property sets to be freed
|
|
// rgPropertySets [in/out] array with the property sets to be released
|
|
// Called by: Provider
|
|
// Called when: By the destructor, or for method that needs cleanup
|
|
// of property sets
|
|
//----------------------------------------------------------------------------
|
|
void
|
|
CRowsetInfo::FreePropertySets(
|
|
ULONG cPropertySets,
|
|
DBPROPSET *rgPropertySets
|
|
)
|
|
{
|
|
ULONG i;
|
|
if ((cPropertySets > 0) && (rgPropertySets == NULL)) {
|
|
return;
|
|
}
|
|
if (cPropertySets == 0) return;
|
|
if (_pMalloc == NULL) {
|
|
return;
|
|
}
|
|
//Free the individual arrays of properties
|
|
for (i=0; i< cPropertySets; i++) {
|
|
if ((rgPropertySets[i].cProperties > 0) &&
|
|
(rgPropertySets[i].rgProperties != NULL))
|
|
_pMalloc->Free(rgPropertySets[i].rgProperties);
|
|
};
|
|
//Free the array of propertysets
|
|
_pMalloc->Free(rgPropertySets);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: CRowsetInfo::InitProperties
|
|
//
|
|
// Synopsis: @mfunc initilizes _cPropertySets and _pPropertySets from
|
|
// _pRowset
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
HRESULT CRowsetInfo::InitProperties(void)
|
|
{
|
|
HRESULT hr;
|
|
IRowsetInfo* pRowsetInfo = NULL;
|
|
hr = CoGetMalloc(MEMCTX_TASK, &_pMalloc);
|
|
if (FAILED(hr)) {
|
|
goto error;
|
|
}
|
|
|
|
if (_pRowset == NULL) {
|
|
hr = E_FAIL;
|
|
goto error;
|
|
};
|
|
hr = _pRowset->QueryInterface(IID_IRowsetInfo, (void**) &pRowsetInfo);
|
|
if (FAILED (hr)) {
|
|
goto error;
|
|
};
|
|
hr= pRowsetInfo->GetProperties(0, NULL, &_cPropertySets, &_pPropertySets);
|
|
if (FAILED(hr)) {
|
|
goto error;
|
|
}
|
|
_dwStatus =STAT_DIDINIT;
|
|
pRowsetInfo->Release();
|
|
RRETURN(S_OK);
|
|
error:
|
|
|
|
_dwStatus = STAT_INITERROR;
|
|
if (_pMalloc != NULL) {
|
|
_pMalloc->Release();
|
|
_pMalloc = NULL;
|
|
}
|
|
if (pRowsetInfo != NULL)
|
|
pRowsetInfo->Release();
|
|
;
|
|
RRETURN(hr);
|
|
};
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: CRowsetInfo::SearchGuid
|
|
//
|
|
// Synopsis: @mfunc
|
|
//
|
|
// Arguments: riid [in] GUID to be searched for
|
|
//
|
|
// Returns:
|
|
// The position of the GUID withing _pPropertySets. Returns -1
|
|
// if not found
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
LONG CRowsetInfo::SearchGuid(GUID riid)
|
|
{
|
|
ULONG i;
|
|
for (i = 0; i < _cPropertySets; i++) {
|
|
if (_pPropertySets[i].guidPropertySet == riid) return (i);
|
|
};
|
|
return -1;
|
|
};
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: CRowsetInfo::SearchPropid
|
|
//
|
|
// Synopsis: @mfunc Searchs for a Propid within _PropertySets
|
|
//
|
|
// Arguments:
|
|
// ibPropertySet [in] The index, within _pPropertySets,
|
|
// of the DBPROPSET to be searched
|
|
// dwPropertyID [in] The propid to be searched
|
|
// Returns:
|
|
// The position of the DBPROP with propid=dwPropertyID
|
|
// within _pPropertySets[ibPropertySet]. Returns -1
|
|
// if not found
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
LONG CRowsetInfo::SearchPropid(
|
|
ULONG ibPropertySet,
|
|
DWORD dwPropertyID)
|
|
|
|
{
|
|
ULONG i;
|
|
for (i = 0; i < _pPropertySets[ibPropertySet].cProperties; i++) {
|
|
if (_pPropertySets[ibPropertySet].rgProperties[i].dwPropertyID ==dwPropertyID )
|
|
return (i);
|
|
};
|
|
return -1;
|
|
};
|