2172 lines
70 KiB
C++
2172 lines
70 KiB
C++
//+---------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1995 - 2000.
|
|
//
|
|
// File: Distrib.cxx
|
|
//
|
|
// Contents: Top level distribution API
|
|
//
|
|
// Classes: CDistributedRowset
|
|
//
|
|
// History: 23-Feb-95 KyleP Created
|
|
// 14-JAN-97 KrishnaN Undefined CI_INETSRV and related changes
|
|
// 29-Mar-2000 KLam Fixed Bookmarks
|
|
//
|
|
// Notes: Some of the distributed versions of the Ole DB interfaces simply
|
|
// call into the regular implementations. In such cases, we'll avoid
|
|
// posting oledb errors because the underlying call had already done
|
|
// that.
|
|
//
|
|
// NTRAID#DB-NTBUG9-84041-2000/07/31-dlee Distributed queries don't supported hierarcical rowsets
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
#include <pch.cxx>
|
|
#pragma hdrstop
|
|
|
|
#include "distrib.hxx"
|
|
#include "disacc.hxx"
|
|
#include "seqser.hxx"
|
|
#include "seqsort.hxx"
|
|
#include "scrlsort.hxx"
|
|
|
|
//
|
|
// IUnknown methods.
|
|
//
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Method: CDistributedRowset::RealQueryInterface
|
|
//
|
|
// Synopsis: Rebind to other interface
|
|
//
|
|
// Arguments: [riid] -- IID of new interface
|
|
// [ppiuk] -- New interface * returned here
|
|
//
|
|
// Returns: S_OK if bind succeeded, E_NOINTERFACE if bind failed
|
|
//
|
|
// History: 10-Apr-1995 KyleP Created
|
|
//
|
|
// Notes: ref count is incremented inside QueryInterface
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
SCODE CDistributedRowset::RealQueryInterface( REFIID riid, VOID **ppiuk )
|
|
{
|
|
SCODE sc = S_OK;
|
|
*ppiuk = 0;
|
|
|
|
// note -- IID_IUnknown covered in QueryInterface
|
|
|
|
if ( riid == IID_IRowset )
|
|
{
|
|
*ppiuk = (void *)((IRowset *)this);
|
|
}
|
|
else if (IID_ISupportErrorInfo == riid)
|
|
{
|
|
*ppiuk = (void *) ((IUnknown *) (ISupportErrorInfo *) &_DBErrorObj);
|
|
}
|
|
else if ( riid == IID_IRowsetInfo )
|
|
{
|
|
*ppiuk = (void *)((IRowsetInfo *)this);
|
|
}
|
|
else if ( riid == IID_IAccessor )
|
|
{
|
|
*ppiuk = (void *)((IAccessor *)this);
|
|
}
|
|
else if ( riid == IID_IColumnsInfo )
|
|
{
|
|
*ppiuk = (void *)((IColumnsInfo *)this);
|
|
}
|
|
else if ( riid == IID_IRowsetIdentity )
|
|
{
|
|
*ppiuk = (void *)((IRowsetIdentity *)this);
|
|
}
|
|
else if ( riid == IID_IConvertType )
|
|
{
|
|
*ppiuk = (void *)((IConvertType *)this);
|
|
}
|
|
else if ( riid == IID_IRowsetQueryStatus )
|
|
{
|
|
*ppiuk = (void *)((IRowsetQueryStatus *)this);
|
|
}
|
|
else if ( riid == IID_IConnectionPointContainer )
|
|
{
|
|
sc = _SetupConnectionPointContainer( this, ppiuk );
|
|
}
|
|
else
|
|
{
|
|
sc = E_NOINTERFACE;
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|
|
|
|
//
|
|
// IRowset methods
|
|
//
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CDistributedRowset::CreateAccessor, public
|
|
//
|
|
// Synopsis: Creates accessor
|
|
//
|
|
// Arguments: [dwAccessorFlags] -- Read/Write/ReadWrite
|
|
// [cBindings] -- # Columns (bindings)
|
|
// [rgBindings] -- Bindings
|
|
// [cbRowWidth] -- row width (for IReadData)
|
|
// [phAccessor] -- Accessor returned here
|
|
// [rgStatus ] -- Set to index of failed binding
|
|
//
|
|
// History: 28-Mar-95 KyleP Created.
|
|
// 22-Apr-97 EmilyB Changed to use accessorbag _aAccessors
|
|
//
|
|
// Notes: Need to have Ole DB error handling here because the error from the
|
|
// underlying call is translated.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CDistributedRowset::CreateAccessor( DBACCESSORFLAGS dwAccessorFlags,
|
|
DBCOUNTITEM cBindings,
|
|
const DBBINDING rgBindings[],
|
|
DBLENGTH cbRowWidth,
|
|
HACCESSOR * phAccessor,
|
|
DBBINDSTATUS * rgStatus )
|
|
{
|
|
_DBErrorObj.ClearErrorInfo();
|
|
|
|
if (0 == phAccessor || (0 != cBindings && 0 == rgBindings))
|
|
return _DBErrorObj.PostHResult(E_INVALIDARG, IID_IAccessor);
|
|
|
|
if ( 0 == cBindings )
|
|
return _DBErrorObj.PostHResult(DB_E_NULLACCESSORNOTSUPPORTED, IID_IAccessor);
|
|
|
|
SCODE sc = S_OK;
|
|
LONG iFirstValidBookmark = -1;
|
|
unsigned iBinding;
|
|
XArray<DBBINDSTATUS> xStatusCopy;
|
|
|
|
TRY
|
|
{
|
|
BOOL fCreateCopy = FALSE;
|
|
BOOL fHasBookmark = FALSE;
|
|
|
|
ULONG iMinColOrdinal = 1,
|
|
iMaxColOrdinal = _cColumns;
|
|
|
|
if ( -1 != _iColumnBookmark )
|
|
{
|
|
iMinColOrdinal--;
|
|
iMaxColOrdinal--;
|
|
}
|
|
|
|
if ( rgStatus )
|
|
{
|
|
Win4Assert( 0 == DBSTATUS_S_OK );
|
|
RtlZeroMemory( rgStatus, sizeof( rgStatus[0] ) * cBindings );
|
|
}
|
|
|
|
//
|
|
// Create a copy of bindings iff it has bookmark column or
|
|
// if it has invalid column, so that we can then mess around
|
|
// with them ;-)
|
|
//
|
|
|
|
for ( iBinding = 0; iBinding < cBindings; iBinding++ )
|
|
{
|
|
fHasBookmark = ( _iColumnBookmark == rgBindings[iBinding].iOrdinal );
|
|
|
|
if ( fHasBookmark ||
|
|
rgBindings[iBinding].iOrdinal > iMaxColOrdinal ||
|
|
rgBindings[iBinding].iOrdinal < iMinColOrdinal )
|
|
{
|
|
fCreateCopy = TRUE;
|
|
break;
|
|
}
|
|
|
|
}
|
|
const DBBINDING * pActualBindings = rgBindings;
|
|
DBCOUNTITEM cActualBindings = cBindings;
|
|
|
|
XArray<DBBINDING> xBindingCopy;
|
|
|
|
if ( fCreateCopy )
|
|
{
|
|
unsigned iBindingCopy = 0;
|
|
|
|
xBindingCopy.Init( (unsigned) cBindings );
|
|
|
|
for ( iBinding = 0; iBinding < cBindings; iBinding++ )
|
|
{
|
|
// check for a valid bookmark
|
|
if ( _iColumnBookmark == rgBindings[iBinding].iOrdinal &&
|
|
DBTYPE_BYTES == ( rgBindings[iBinding].wType & ~DBTYPE_BYREF ) &&
|
|
DBMEMOWNER_CLIENTOWNED == rgBindings[iBinding].dwMemOwner )
|
|
{
|
|
if ( -1 == iFirstValidBookmark )
|
|
{
|
|
iFirstValidBookmark = iBinding;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
xBindingCopy[iBindingCopy] = rgBindings[iBinding];
|
|
|
|
if ( rgBindings[iBinding].iOrdinal > iMaxColOrdinal ||
|
|
rgBindings[iBinding].iOrdinal < iMinColOrdinal ||
|
|
_iColumnBookmark == rgBindings[iBinding].iOrdinal )
|
|
{
|
|
// Invalid column -> set it to DB_INVALIDCOLUMN so
|
|
// that we an appropriate error is returned
|
|
xBindingCopy[iBindingCopy].iOrdinal = DB_INVALIDCOLUMN;
|
|
}
|
|
iBindingCopy++;
|
|
}
|
|
|
|
pActualBindings = xBindingCopy.GetPointer();
|
|
cActualBindings = iBindingCopy;
|
|
}
|
|
|
|
if ( -1 != iFirstValidBookmark )
|
|
{
|
|
if ( rgStatus )
|
|
{
|
|
xStatusCopy.Init( (unsigned) cActualBindings );
|
|
}
|
|
// Create the bookmark accessors if needed
|
|
if ( _xDistBmkAcc.IsNull() )
|
|
{
|
|
_xDistBmkAcc.Set( new CDistributedBookmarkAccessor(
|
|
_aChild,
|
|
_cChild,
|
|
dwAccessorFlags,
|
|
rgStatus ? &rgStatus[iFirstValidBookmark] : NULL,
|
|
_iColumnBookmark,
|
|
_cbBookmark ) );
|
|
}
|
|
|
|
Win4Assert( _xDistBmkAcc.GetPointer() );
|
|
|
|
|
|
}
|
|
|
|
*phAccessor = (HACCESSOR)new
|
|
CDistributedAccessor( _aChild,
|
|
_cChild,
|
|
dwAccessorFlags,
|
|
cActualBindings,
|
|
pActualBindings,
|
|
cbRowWidth,
|
|
-1 != iFirstValidBookmark ?
|
|
xStatusCopy.GetPointer() :
|
|
rgStatus,
|
|
(IUnknown *) (IRowset *) this,
|
|
rgBindings,
|
|
cBindings );
|
|
|
|
CLock lock( _mutex );
|
|
_aAccessors.Add( (CAccessorBase *)*phAccessor );
|
|
|
|
if ( -1 != iFirstValidBookmark )
|
|
{
|
|
if ( rgStatus )
|
|
{
|
|
unsigned iBindingCopy = 0;
|
|
for( iBinding = 0; iBinding < cBindings; iBinding++ )
|
|
{
|
|
if ( _iColumnBookmark != rgBindings[iBinding].iOrdinal )
|
|
{
|
|
rgStatus[iBinding] = xStatusCopy[iBindingCopy++];
|
|
}
|
|
}
|
|
}
|
|
((CDistributedAccessor *)*phAccessor)->SetupBookmarkAccessor(
|
|
_xDistBmkAcc.GetPointer(),
|
|
rgStatus,
|
|
_iColumnBookmark,
|
|
_cbBookmark );
|
|
}
|
|
}
|
|
CATCH( CException, e )
|
|
{
|
|
if ( -1 != iFirstValidBookmark )
|
|
{
|
|
if ( rgStatus )
|
|
{
|
|
unsigned iBindingCopy = 0;
|
|
for( iBinding = 0; iBinding < cBindings; iBinding++ )
|
|
{
|
|
if ( _iColumnBookmark != rgBindings[iBinding].iOrdinal )
|
|
{
|
|
rgStatus[iBinding] = xStatusCopy[iBindingCopy++];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
sc = e.GetErrorCode();
|
|
|
|
vqDebugOut(( DEB_ERROR, "CDistributedRowset::CreateAccessor caught exception 0x%x\n", sc ));
|
|
}
|
|
END_CATCH
|
|
|
|
if (FAILED(sc))
|
|
_DBErrorObj.PostHResult(sc, IID_IAccessor);
|
|
return( sc );
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CDistributedRowset::GetBindings, public
|
|
//
|
|
// Synopsis: Creates accessor
|
|
//
|
|
// Arguments: [hAccessor] -- Handle to Accessor
|
|
// [pdwAccessorFlags] -- Type of binding returned here (read/write)
|
|
// [pcBindings] -- Count of bindings in [prgBindings] retuned
|
|
// here.
|
|
// [prgBindings] -- Bindings returned here.
|
|
//
|
|
// History: 03-Apr-95 KyleP Created.
|
|
// 22-Apr-97 EmilyB Changed to use accessorbag _aAccessors
|
|
//
|
|
// Notes: Need to have Ole DB error handling here because the error from the
|
|
// underlying call is translated.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CDistributedRowset::GetBindings( HACCESSOR hAccessor,
|
|
DBACCESSORFLAGS * pdwAccessorFlags,
|
|
DBCOUNTITEM * pcBindings,
|
|
DBBINDING * prgBindings[])
|
|
{
|
|
_DBErrorObj.ClearErrorInfo();
|
|
|
|
SCODE sc;
|
|
|
|
TRY
|
|
{
|
|
CLock lock( _mutex );
|
|
|
|
CDistributedAccessor * pAcc = (CDistributedAccessor *)_aAccessors.Convert(hAccessor);
|
|
|
|
sc = pAcc->GetBindings( pdwAccessorFlags, pcBindings, prgBindings );
|
|
}
|
|
CATCH( CException, e )
|
|
{
|
|
vqDebugOut((DEB_ERROR, "CDistributedRowset: GetBindings caught exception 0x%x\n",
|
|
e.GetErrorCode()) );
|
|
// The reason we have an exception here is 'cos pAcc is invalid
|
|
sc = DB_E_BADACCESSORHANDLE;
|
|
}
|
|
END_CATCH
|
|
|
|
if (FAILED(sc))
|
|
_DBErrorObj.PostHResult(sc, IID_IAccessor);
|
|
|
|
return sc;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CDistributedRowset::GetData, public
|
|
//
|
|
// Synopsis: Fetch data for a row.
|
|
//
|
|
// Arguments: [hRow] -- Handle to row
|
|
// [hAccessor] -- Accessor to use for fetch.
|
|
// [pData] -- Data goes here.
|
|
//
|
|
// History: 03-Apr-95 KyleP Created.
|
|
//
|
|
// Notes: Need to have Ole DB error handling here because an exception could
|
|
// happen.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CDistributedRowset::GetData( HROW hRow,
|
|
HACCESSOR hAccessor,
|
|
void * pData )
|
|
{
|
|
_DBErrorObj.ClearErrorInfo();
|
|
|
|
SCODE sc = S_OK;
|
|
|
|
TRY
|
|
{
|
|
HROW hrowChild;
|
|
|
|
int iChild = _RowManager.GetChildAndHROW( hRow, hrowChild );
|
|
|
|
CLock lock( _mutex );
|
|
CDistributedAccessor * pAcc = (CDistributedAccessor *)_aAccessors.Convert(hAccessor);
|
|
|
|
sc = pAcc->GetData( iChild, hrowChild, pData );
|
|
}
|
|
CATCH( CException, e )
|
|
{
|
|
sc = e.GetErrorCode();
|
|
|
|
vqDebugOut(( DEB_ERROR, "CDistributedRowset::GetData caught exception 0x%x\n", sc ));
|
|
}
|
|
END_CATCH
|
|
|
|
if (FAILED(sc))
|
|
_DBErrorObj.PostHResult(sc, IID_IRowset);
|
|
|
|
return sc;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CDistributedRowset::GetReferencedRowset, public
|
|
//
|
|
// Synopsis: Traverse 'link' to associated rowset.
|
|
//
|
|
// Arguments: [iColumn] -- Column of 'link'.
|
|
// [ppReferencedRowset] -- Link target goes here.
|
|
//
|
|
// History: 03-Apr-95 KyleP Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CDistributedRowset::GetReferencedRowset( DBORDINAL iColumn,
|
|
REFIID riid,
|
|
IUnknown ** ppReferencedRowset )
|
|
{
|
|
_DBErrorObj.ClearErrorInfo();
|
|
|
|
// NTRAID#DB-NTBUG9-84041-2000/07/31-dlee Distributed queries don't supported hierarcical rowsets
|
|
// This can only be implemented when the distributed rowset gains
|
|
// support for hierarchical rowsets.
|
|
//
|
|
|
|
Win4Assert( !"CDistributedRowset::GetReferencedRowset not yet implemented" );
|
|
return _DBErrorObj.PostHResult(E_NOTIMPL, IID_IRowsetInfo);
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CDistributedRowset::GetProperties, public
|
|
//
|
|
// Synopsis: Return information about the capabilities of the rowset
|
|
//
|
|
// Arguments: [cProperties] - number of desired properties or 0
|
|
// [rgProperties] - array of desired properties or NULL
|
|
// [pcProperties] - number of properties returned
|
|
// [prgProperties] - array of returned properties
|
|
//
|
|
// Returns: SCODE
|
|
//
|
|
// History: 20 Nov 1995 AlanW Created.
|
|
//
|
|
// Notes: Need to have Ole DB error handling here because the underlying
|
|
// call doesn't provide that.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CDistributedRowset::GetProperties(
|
|
const ULONG cProperties,
|
|
const DBPROPIDSET rgPropertyIDSets[],
|
|
ULONG * pcProperties,
|
|
DBPROPSET ** prgProperties)
|
|
{
|
|
_DBErrorObj.ClearErrorInfo();
|
|
|
|
// inner layer doesn't validate params...
|
|
if ( (0 != cProperties && 0 == rgPropertyIDSets) ||
|
|
0 == pcProperties ||
|
|
0 == prgProperties )
|
|
{
|
|
vqDebugOut((DEB_IERROR, "CDistributedRowset::GetProperties: Invalid Argument(s)\n"));
|
|
|
|
if (pcProperties)
|
|
*pcProperties = 0;
|
|
if (prgProperties)
|
|
*prgProperties = 0;
|
|
return _DBErrorObj.PostHResult(E_INVALIDARG, IID_IRowsetInfo);
|
|
}
|
|
|
|
SCODE scResult = S_OK;
|
|
*pcProperties = 0;
|
|
*prgProperties = 0;
|
|
|
|
TRY
|
|
{
|
|
//
|
|
// Update ROWSETQUERYSTATUS property
|
|
//
|
|
|
|
DWORD dwStatus;
|
|
scResult = GetStatus( & dwStatus );
|
|
|
|
if ( FAILED( scResult ) )
|
|
THROW( CException( scResult ) );
|
|
|
|
_Props.SetValLong( CMRowsetProps::eid_DBPROPSET_MSIDXS_ROWSET_EXT,
|
|
CMRowsetProps::eid_MSIDXSPROPVAL_ROWSETQUERYSTATUS,
|
|
dwStatus );
|
|
|
|
scResult = _Props.GetProperties( cProperties,
|
|
rgPropertyIDSets,
|
|
pcProperties,
|
|
prgProperties );
|
|
}
|
|
CATCH( CException, e )
|
|
{
|
|
scResult = GetOleError(e);
|
|
vqDebugOut(( DEB_ERROR, "CDistributedRowset::GetProperties -- caught 0x%x\n", scResult ));
|
|
}
|
|
END_CATCH;
|
|
|
|
if (FAILED(scResult))
|
|
_DBErrorObj.PostHResult(scResult, IID_IRowsetInfo);
|
|
|
|
return scResult;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CDistributedRowset::GetSpecification, public
|
|
//
|
|
// Synopsis: Fetch query object corresponding to rowset.
|
|
//
|
|
// Arguments: [riid] -- Bind spec to this interface.
|
|
// [ppSpecification] -- Spec returned here.
|
|
//
|
|
// History: 03-Apr-95 KyleP Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CDistributedRowset::GetSpecification( REFIID riid,
|
|
IUnknown ** ppSpecification )
|
|
{
|
|
_DBErrorObj.ClearErrorInfo();
|
|
|
|
//
|
|
// NTRAID#DB-NTBUG9-84043-2000/07/31-dlee Distributed rowset doesn't implement GetSpecification()
|
|
//
|
|
// This is now implemented by the base rowset. We need to pass it on
|
|
// through in a distributed fasion.
|
|
//
|
|
|
|
Win4Assert( !"CDistributedRowset::GetSpecification not yet implemented" );
|
|
return _DBErrorObj.PostHResult(E_NOTIMPL, IID_IAccessor);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CDistributedRowset::MapColumnIDs, public
|
|
//
|
|
// Synopsis: Maps DBID to column ordinal.
|
|
//
|
|
// Arguments: [cColumnIDs] -- Count of elements in [rgColumnIDs]
|
|
// [rgColumnIDs] -- DBID to be mapped.
|
|
// [rgColumns] -- Output column ordinals.
|
|
//
|
|
// History: 03-Apr-95 KyleP Created.
|
|
//
|
|
// Notes: No need to have Ole DB error handling here because the underlying
|
|
// call provides that.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CDistributedRowset::MapColumnIDs( DBORDINAL cColumnIDs,
|
|
DBID const rgColumnIDs[],
|
|
DBORDINAL rgColumns[] )
|
|
{
|
|
_DBErrorObj.ClearErrorInfo();
|
|
|
|
IColumnsInfo * pci = 0;
|
|
|
|
SCODE sc = _aChild[0]->QueryInterface( IID_IColumnsInfo, (void **) &pci );
|
|
|
|
if ( SUCCEEDED(sc) )
|
|
{
|
|
sc = pci->MapColumnIDs( cColumnIDs, rgColumnIDs, rgColumns );
|
|
pci->Release();
|
|
}
|
|
|
|
ULONG iMaxColOrdinal = _cColumns;
|
|
|
|
if ( -1 != _iColumnBookmark )
|
|
{
|
|
iMaxColOrdinal--;
|
|
}
|
|
|
|
//
|
|
// Be sure none of the potentially added columns was returned.
|
|
//
|
|
unsigned cErrors = 0;
|
|
if ( SUCCEEDED(sc) )
|
|
{
|
|
for (unsigned i=0; i<cColumnIDs; i++)
|
|
{
|
|
if (DB_INVALIDCOLUMN == rgColumns[i])
|
|
{
|
|
cErrors++;
|
|
}
|
|
else if ( rgColumns[i] > iMaxColOrdinal )
|
|
{
|
|
rgColumns[i] = DB_INVALIDCOLUMN;
|
|
cErrors++;
|
|
}
|
|
}
|
|
sc = cErrors == 0 ? S_OK :
|
|
(cErrors != cColumnIDs) ? DB_S_ERRORSOCCURRED :
|
|
DB_E_ERRORSOCCURRED;
|
|
}
|
|
|
|
if (FAILED(sc))
|
|
_DBErrorObj.PostHResult(sc, IID_IColumnsInfo);
|
|
return sc;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CDistributedRowset::ReleaseAccessor, public
|
|
//
|
|
// Synopsis: Releases accessor(s)
|
|
//
|
|
// Arguments: [hAccessor] -- Handle of accessor,
|
|
// [pcRefCount] -- Ptr to ref count.
|
|
//
|
|
// History: 28-Mar-95 KyleP Created.
|
|
// 22-Apr-97 EmilyB Changed to use accessorbag _aAccessors
|
|
//
|
|
// Notes: Need to have Ole DB error handling here because the underlying call
|
|
// doesn't provide that.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CDistributedRowset::ReleaseAccessor( HACCESSOR hAccessor,
|
|
ULONG * pcRefCount)
|
|
{
|
|
_DBErrorObj.ClearErrorInfo();
|
|
|
|
SCODE sc = S_OK;
|
|
TRY
|
|
{
|
|
CLock lock( _mutex );
|
|
_aAccessors.Release(hAccessor, pcRefCount);
|
|
}
|
|
CATCH(CException, e)
|
|
{
|
|
vqDebugOut((DEB_ERROR, "CDistributedRowset::ReleaseAccessor caught exception 0x%x\n",
|
|
e.GetErrorCode()) );
|
|
// The reason we have an exception here is 'cos the accessor is invalid
|
|
sc = DB_E_BADACCESSORHANDLE;
|
|
}
|
|
END_CATCH
|
|
|
|
if (FAILED(sc))
|
|
_DBErrorObj.PostHResult(sc, IID_IAccessor);
|
|
|
|
return sc;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CDistributedRowset::AddRefAccessor, public
|
|
//
|
|
// Synopsis: AddRef accessor(s)
|
|
//
|
|
// Arguments: [hAccessor] -- Handle of accessor,
|
|
// [pcRefCount] -- Ptr to ref count.
|
|
//
|
|
// History: 16-Jan-97 KrishnaN Created.
|
|
// 22-Apr-97 EmilyB Changed to use accessorbag
|
|
// _aAccessors
|
|
// Notes: Need to have Ole DB error handling here because the underlying call
|
|
// doesn't provide that.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CDistributedRowset::AddRefAccessor( HACCESSOR hAccessor,
|
|
ULONG * pcRefCount)
|
|
{
|
|
_DBErrorObj.ClearErrorInfo();
|
|
|
|
SCODE sc = S_OK;
|
|
|
|
TRY
|
|
{
|
|
CLock lock( _mutex );
|
|
_aAccessors.AddRef(hAccessor, pcRefCount);
|
|
}
|
|
CATCH(CException, e)
|
|
{
|
|
vqDebugOut((DEB_ERROR, "CDistributedRowset::AddRefAccessor caught exception 0x%x\n",
|
|
e.GetErrorCode()) );
|
|
// The reason we have an exception here is 'cos the accessor is invalid.
|
|
sc = DB_E_BADACCESSORHANDLE;
|
|
}
|
|
END_CATCH;
|
|
|
|
if (FAILED(sc))
|
|
_DBErrorObj.PostHResult(sc, IID_IAccessor);
|
|
|
|
return sc;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CDistributedRowset::ReleaseChapter, public
|
|
//
|
|
// Synopsis: Release chapter.
|
|
//
|
|
// Arguments: [hChapter] -- Chapter
|
|
//
|
|
// History: 03-Apr-95 KyleP Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CDistributedRowset::ReleaseChapter( HCHAPTER hChapter )
|
|
{
|
|
_DBErrorObj.ClearErrorInfo();
|
|
|
|
// NTRAID#DB-NTBUG9-84041-2000/07/31-dlee Distributed queries don't supported hierarcical rowsets
|
|
// Currently there is no support for chapters.
|
|
|
|
Win4Assert( !"CDistributedRowset::ReleaseChapter not yet implemented" );
|
|
return _DBErrorObj.PostHResult(E_NOTIMPL, IID_IRowset);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CDistributedRowset::RestartPosition, public
|
|
//
|
|
// Synopsis: Reset cursor for GetNextRows
|
|
//
|
|
// Arguments: [hChapter] -- Chapter
|
|
//
|
|
// History: 16 Jun 95 AlanW Created.
|
|
//
|
|
// Notes: NO need to have Ole DB error handling here because the underlying
|
|
// call provides that.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CDistributedRowset::RestartPosition( HCHAPTER hChapter )
|
|
{
|
|
SCODE sc = S_OK;
|
|
BOOL fNotified = FALSE;
|
|
|
|
TRY
|
|
{
|
|
_iCurrentRow = 0;
|
|
|
|
if ( !_xChildNotify.IsNull() )
|
|
{
|
|
sc = _xChildNotify->OnRowsetChange( DBREASON_ROWSET_FETCHPOSITIONCHANGE,
|
|
DBEVENTPHASE_OKTODO,
|
|
FALSE );
|
|
|
|
if ( S_FALSE == sc )
|
|
THROW(CException(DB_E_CANCELED));
|
|
fNotified = TRUE;
|
|
}
|
|
|
|
for ( unsigned i = 0; i < _cChild; i++ )
|
|
{
|
|
sc = _aChild[i]->RestartPosition( hChapter);
|
|
|
|
if ( FAILED(sc) )
|
|
{
|
|
vqDebugOut(( DEB_ERROR, "IRowset::RestartPosition returned 0x%x\n", sc ));
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( fNotified )
|
|
{
|
|
_xChildNotify->OnRowsetChange( DBREASON_ROWSET_FETCHPOSITIONCHANGE,
|
|
DBEVENTPHASE_DIDEVENT,
|
|
TRUE );
|
|
}
|
|
}
|
|
CATCH( CException, e )
|
|
{
|
|
sc = e.GetErrorCode();
|
|
}
|
|
END_CATCH
|
|
|
|
if ( fNotified && FAILED(sc) )
|
|
{
|
|
_xChildNotify->OnRowsetChange( DBREASON_ROWSET_FETCHPOSITIONCHANGE,
|
|
DBEVENTPHASE_FAILEDTODO,
|
|
TRUE );
|
|
}
|
|
return sc;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CDistributedRowset::AddRefRows, public
|
|
//
|
|
// Synopsis: Incs ref. count on row(s)
|
|
//
|
|
// Arguments: [cRows] -- Number of HROWs in rghRows.
|
|
// [rghRows] -- Rows to be refcounted.
|
|
// [pcRefCounted] -- Count of rows *successfully* refcounted.
|
|
// [rgRefCounts] -- Remaining refcounts on HROWs.
|
|
//
|
|
// History: 10-Apr-95 KyleP Created.
|
|
//
|
|
// Notes: Need to have Ole DB error handling here because the underlying
|
|
// errors are being translated.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CDistributedRowset::AddRefRows( DBCOUNTITEM cRows,
|
|
const HROW rghRows[],
|
|
DBREFCOUNT rgRefCounts[],
|
|
DBROWSTATUS rgRowStatus[] )
|
|
{
|
|
_DBErrorObj.ClearErrorInfo();
|
|
|
|
SCODE sc = S_OK;
|
|
ULONG cRefCounted, cSuccessfullyRefCounted;
|
|
|
|
if (cRows > 0 && 0 == rghRows)
|
|
{
|
|
vqDebugOut((DEB_IERROR, "CDistributedRowset::AddRefRows: Invalid Argument(s)\n"));
|
|
return _DBErrorObj.PostHResult(E_INVALIDARG, IID_IRowset);
|
|
}
|
|
|
|
TRY
|
|
{
|
|
for ( cRefCounted = cSuccessfullyRefCounted = 0; cRefCounted < cRows; cRefCounted++ )
|
|
{
|
|
HROW hrowChild;
|
|
|
|
int iChild = _RowManager.GetChildAndHROW( rghRows[cRefCounted], hrowChild );
|
|
|
|
sc = _aChild[iChild]->AddRefRows( 1,
|
|
&hrowChild,
|
|
0,
|
|
(0 == rgRefCounts) ? 0 : &rgRefCounts[cRefCounted] );
|
|
|
|
if ( FAILED(sc) )
|
|
{
|
|
vqDebugOut(( DEB_ERROR, "IRowset::AddRefRows returned 0x%x\n", sc ));
|
|
continue;
|
|
}
|
|
|
|
_RowManager.AddRef( rghRows[cRefCounted] );
|
|
|
|
cSuccessfullyRefCounted++;
|
|
}
|
|
|
|
if ( 0 != rgRefCounts )
|
|
rgRefCounts[0] = cRefCounted;
|
|
|
|
}
|
|
CATCH( CException, e )
|
|
{
|
|
sc = e.GetErrorCode();
|
|
vqDebugOut(( DEB_ERROR, "CDistributedRowset::AddRefRows -- caught 0x%x\n", sc ));
|
|
}
|
|
END_CATCH
|
|
|
|
// if we see an error other than DB_E_ERRORSOCCURRED, pass it straight through
|
|
if (FAILED(sc) && sc != DB_E_ERRORSOCCURRED)
|
|
return _DBErrorObj.PostHResult(sc, IID_IRowset);
|
|
|
|
if (cSuccessfullyRefCounted == cRefCounted)
|
|
return S_OK;
|
|
|
|
if (cSuccessfullyRefCounted > 0)
|
|
sc = DB_S_ERRORSOCCURRED;
|
|
else
|
|
sc = DB_E_ERRORSOCCURRED;
|
|
|
|
return _DBErrorObj.PostHResult(sc, IID_IRowset);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CDistributedRowset::ReleaseRows, public
|
|
//
|
|
// Synopsis: Releases row(s)
|
|
//
|
|
// Arguments: [cRows] -- Number of HROWs in rghRows.
|
|
// [rghRows] -- Rows to be released.
|
|
// [rgRowOptions]-- row options
|
|
// [rgRefCounts] -- Remaining refcounts on HROWs.
|
|
// [rgRowStatus] -- Status values.
|
|
//
|
|
// History: 10-Apr-95 KyleP Created.
|
|
// 30-Jan-97 KrishnaN Modified to conform with 1.0 spec
|
|
//
|
|
// Notes: Need to have Ole DB error handling here because the underlying
|
|
// errors are being translated.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CDistributedRowset::ReleaseRows( DBCOUNTITEM cRows,
|
|
const HROW rghRows[],
|
|
DBROWOPTIONS rgRowOptions[],
|
|
DBREFCOUNT rgRefCounts[],
|
|
DBROWSTATUS rgRowStatus[])
|
|
{
|
|
_DBErrorObj.ClearErrorInfo();
|
|
|
|
SCODE sc = S_OK;
|
|
ULONG cReleased, cSuccessfullyReleased;
|
|
DBROWSTATUS rowStatus;
|
|
|
|
TRY
|
|
{
|
|
BOOL fNotify = FALSE;
|
|
ULONG * pRefCounts = rgRefCounts;
|
|
DBROWSTATUS * pRowStatus = rgRowStatus;
|
|
|
|
XArray<ULONG> xrgRefCounts;
|
|
XArray<DBROWSTATUS> xrgRowStatus;
|
|
|
|
if ( !_xChildNotify.IsNull() )
|
|
{
|
|
fNotify = TRUE;
|
|
if ( 0 == pRefCounts )
|
|
{
|
|
xrgRefCounts.Init( (unsigned) cRows );
|
|
pRefCounts = xrgRefCounts.GetPointer();
|
|
}
|
|
if ( 0 == pRowStatus )
|
|
{
|
|
xrgRowStatus.Init( (unsigned) cRows );
|
|
pRowStatus = xrgRowStatus.GetPointer();
|
|
}
|
|
}
|
|
|
|
for ( cReleased = cSuccessfullyReleased = 0; cReleased < cRows; cReleased++ )
|
|
{
|
|
HROW hrowChild;
|
|
|
|
Win4Assert( DB_NULL_HROW != rghRows[cReleased] );
|
|
|
|
if ( DB_NULL_HROW != rghRows[cReleased] )
|
|
{
|
|
int iChild = _RowManager.GetChildAndHROW( rghRows[cReleased], hrowChild );
|
|
|
|
sc = _aChild[iChild]->ReleaseRows( 1,
|
|
&hrowChild,
|
|
(0 == rgRowOptions) ? 0 : &rgRowOptions[cReleased],
|
|
(0 == rgRefCounts) ? 0 : &rgRefCounts[cReleased],
|
|
&rowStatus
|
|
);
|
|
}
|
|
// At this time, there is no need to translate the error returned by the child.
|
|
|
|
if (rgRowStatus)
|
|
rgRowStatus[cReleased] = rowStatus;
|
|
|
|
if ( FAILED(sc) )
|
|
{
|
|
vqDebugOut(( DEB_ERROR, "IRowset::ReleaseRows returned 0x%x\n", sc ));
|
|
continue;
|
|
}
|
|
|
|
if ( DB_NULL_HROW != rghRows[cReleased] )
|
|
_RowManager.Release( rghRows[cReleased] );
|
|
|
|
cSuccessfullyReleased++;
|
|
}
|
|
|
|
if ( fNotify )
|
|
{
|
|
ULONG cRowsToNotify = 0;
|
|
for (ULONG i=0; i<cRows; i++)
|
|
if ( 0 == pRefCounts[i] && DBROWSTATUS_S_OK == pRowStatus[i] )
|
|
cRowsToNotify++;
|
|
|
|
if (cRowsToNotify)
|
|
{
|
|
XGrowable<HROW,20> xrghRows(cRowsToNotify);
|
|
|
|
for (cRowsToNotify=0, i=0; i<cRows; i++)
|
|
if ( 0 == pRefCounts[i] && DBROWSTATUS_S_OK == pRowStatus[i] )
|
|
{
|
|
xrghRows[cRowsToNotify] = rghRows[i];
|
|
cRowsToNotify++;
|
|
}
|
|
|
|
_xChildNotify->OnRowChange( cRowsToNotify,
|
|
xrghRows.Get(),
|
|
DBREASON_ROW_RELEASE,
|
|
DBEVENTPHASE_DIDEVENT,
|
|
TRUE);
|
|
}
|
|
}
|
|
}
|
|
CATCH( CException, e )
|
|
{
|
|
sc = e.GetErrorCode();
|
|
vqDebugOut(( DEB_ERROR, "CDistributedRowset::ReleaseRows -- caught 0x%x\n", sc ));
|
|
}
|
|
END_CATCH
|
|
|
|
// if we see an error other than DB_E_ERRORSOCCURRED, pass it straight through
|
|
if (FAILED(sc) && sc != DB_E_ERRORSOCCURRED)
|
|
return _DBErrorObj.PostHResult(sc, IID_IRowset);
|
|
|
|
if (cSuccessfullyReleased == cReleased)
|
|
return S_OK;
|
|
else if (cSuccessfullyReleased > 0)
|
|
sc = DB_S_ERRORSOCCURRED;
|
|
else
|
|
sc = DB_E_ERRORSOCCURRED;
|
|
|
|
return _DBErrorObj.PostHResult(sc, IID_IRowset);
|
|
}
|
|
|
|
|
|
//
|
|
// IColumnsInfo methods
|
|
//
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: IsEqual, private
|
|
//
|
|
// Arguments: [col1] -- First DBID
|
|
// [col2] -- Second DBID
|
|
//
|
|
// Returns: TRUE if col1 == col2
|
|
//
|
|
// History: 03-Apr-95 KyleP Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
BOOL IsEqual( DBID const & col1, DBID const & col2 )
|
|
{
|
|
if ( col1.eKind != col2.eKind )
|
|
return( FALSE );
|
|
|
|
switch ( col1.eKind )
|
|
{
|
|
case DBKIND_GUID_PROPID:
|
|
return ( col1.uGuid.guid == col2.uGuid.guid &&
|
|
col1.uName.ulPropid == col2.uName.ulPropid );
|
|
|
|
case DBKIND_GUID_NAME:
|
|
return( col1.uGuid.guid == col2.uGuid.guid &&
|
|
_wcsicmp( col1.uName.pwszName, col2.uName.pwszName ) == 0);
|
|
|
|
case DBKIND_NAME:
|
|
return( _wcsicmp( col1.uName.pwszName, col2.uName.pwszName ) == 0 );
|
|
|
|
case DBKIND_PGUID_PROPID:
|
|
return ( *col1.uGuid.pguid == *col2.uGuid.pguid &&
|
|
col1.uName.ulPropid == col2.uName.ulPropid );
|
|
|
|
case DBKIND_PGUID_NAME:
|
|
return( *col1.uGuid.pguid == *col2.uGuid.pguid &&
|
|
_wcsicmp( col1.uName.pwszName, col2.uName.pwszName ) == 0 );
|
|
|
|
default:
|
|
Win4Assert( !"Unknown eKind" );
|
|
return( FALSE );
|
|
}
|
|
|
|
Win4Assert( !"How did we get here?" );
|
|
return( TRUE );
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CDistributedRowset::_GetFullColumnInfo, protected
|
|
//
|
|
// Synopsis: Returns basic info about columns in table.
|
|
//
|
|
// Arguments: [pcColumns] -- Count returned here.
|
|
// [ppColInfo] -- Array of column descriptors returned here.
|
|
// [ppwchInfo] -- Pointer to storage for all string values.
|
|
//
|
|
// History: 02-Mar-95 KyleP Created.
|
|
// 24-Jan-97 KrishnaN Modified to conform to 1.0 spec
|
|
//
|
|
// Notes: Since each child cursor was given the same initial query,
|
|
// we know all the columnid and column ordinals must be the
|
|
// same. Other fields will vary, and will need to be set
|
|
// to the most relaxed value from any child cursor.
|
|
//
|
|
// Need to have Ole DB error handling here because the underlying
|
|
// errors are being translated.
|
|
//
|
|
// This implementation returns all the columns including the columns
|
|
// that we added for sorting. The client will always call
|
|
// GetColumnInfo, which trims out these extra columns
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CDistributedRowset::_GetFullColumnInfo( DBORDINAL * pcColumns,
|
|
DBCOLUMNINFO ** ppColInfo,
|
|
WCHAR ** ppwchInfo)
|
|
{
|
|
_DBErrorObj.ClearErrorInfo();
|
|
|
|
if (0 == pcColumns || 0 == ppColInfo || 0 == ppwchInfo)
|
|
{
|
|
vqDebugOut((DEB_IERROR, "CDistributedRowset::GetColumnInfo: Invalid Argument(s)\n"));
|
|
return _DBErrorObj.PostHResult(E_INVALIDARG, IID_IColumnsInfo);
|
|
}
|
|
SCODE sc = S_OK;
|
|
|
|
//
|
|
// Get rid of cached copy, if any.
|
|
//
|
|
|
|
if ( 0 != _aColInfo )
|
|
{
|
|
*pcColumns = _cColInfo;
|
|
*ppColInfo = _aColInfo;
|
|
*ppwchInfo = _awchInfo;
|
|
|
|
_aColInfo = 0;
|
|
_awchInfo = 0;
|
|
}
|
|
else
|
|
{
|
|
*ppColInfo = 0;
|
|
*ppwchInfo = 0;
|
|
*pcColumns = 0;
|
|
|
|
TRY
|
|
{
|
|
//
|
|
// Fetch from first child. We'll use this allocation for return, and
|
|
// modify fields as needed.
|
|
//
|
|
|
|
IColumnsInfo * pci = 0;
|
|
|
|
sc = _aChild[0]->QueryInterface( IID_IColumnsInfo, (void **) &pci );
|
|
|
|
|
|
if ( FAILED(sc) )
|
|
{
|
|
vqDebugOut(( DEB_ERROR, "CDistributedRowset: QI to IColumnsInfo returned 0x%x\n", sc ));
|
|
THROW( CException(sc) );
|
|
}
|
|
|
|
XInterface<IColumnsInfo> pColInfo(pci);
|
|
|
|
DBCOLUMNINFO * paColTemp;
|
|
WCHAR * pwchTemp;
|
|
sc = pColInfo->GetColumnInfo( pcColumns, &paColTemp, &pwchTemp );
|
|
|
|
XCoMem<DBCOLUMNINFO> pBaseline(paColTemp);
|
|
XCoMem<WCHAR> pBaseStr(pwchTemp);
|
|
|
|
if ( FAILED(sc) )
|
|
{
|
|
vqDebugOut(( DEB_ERROR, "IColumnsInfo::GetColumnInfo returned 0x%x\n", sc ));
|
|
THROW( CException(sc) );
|
|
}
|
|
|
|
//
|
|
// Now go through remaining cursors and adjust values. The same
|
|
// columns must be in the same ordinal positions, but some values
|
|
// (ex: cbMaxLength) may differ between providers.
|
|
//
|
|
// Any string data is just taken from the first returned value.
|
|
//
|
|
|
|
for ( unsigned i = 1; i < _cChild; i++ )
|
|
{
|
|
sc = _aChild[i]->QueryInterface( IID_IColumnsInfo, (void **) &pci );
|
|
|
|
if ( FAILED(sc) )
|
|
{
|
|
vqDebugOut(( DEB_ERROR, "CDistributedRowset: QI to IColumnsInfo returned 0x%x\n", sc ));
|
|
THROW( CException(sc) );
|
|
}
|
|
|
|
XInterface<IColumnsInfo> pColInfo(pci);
|
|
|
|
DBCOLUMNINFO * pTempCols = 0;
|
|
WCHAR * pwchTemp2 = 0;
|
|
DBORDINAL cCols;
|
|
|
|
sc = pColInfo->GetColumnInfo( &cCols, &pTempCols, &pwchTemp2 );
|
|
|
|
if ( FAILED(sc) )
|
|
{
|
|
vqDebugOut(( DEB_ERROR, "IColumnsInfo::GetColumnInfo returned 0x%x\n", sc ));
|
|
THROW( CException(sc) );
|
|
}
|
|
|
|
XCoMem<DBCOLUMNINFO> pCols( pTempCols );
|
|
XCoMem<WCHAR> pStr( pwchTemp2 );
|
|
|
|
if ( cCols != *pcColumns )
|
|
{
|
|
Win4Assert( cCols == *pcColumns );
|
|
THROW( CException( E_FAIL ) );
|
|
}
|
|
|
|
//
|
|
// Review all columns.
|
|
//
|
|
|
|
for ( unsigned j = 0; j < cCols; j++ )
|
|
{
|
|
//
|
|
// DBID has to match.
|
|
//
|
|
|
|
if ( !IsEqual( pBaseline[j].columnid, pCols[j].columnid ) )
|
|
{
|
|
Win4Assert( !"Mismatched columns" );
|
|
THROW( CException( E_FAIL ) );
|
|
}
|
|
|
|
//
|
|
// pwszName should be returned if all names are the same.
|
|
//
|
|
|
|
if ( 0 != pBaseline[j].pwszName && 0 != pCols[j].pwszName &&
|
|
wcscmp( pBaseline[j].pwszName, pCols[j].pwszName ) != 0 )
|
|
pBaseline[j].pwszName = 0;
|
|
|
|
//
|
|
// iOrdinal must match.
|
|
//
|
|
|
|
if ( pBaseline[j].iOrdinal != pCols[j].iOrdinal )
|
|
{
|
|
Win4Assert( !"Mismatched columns" );
|
|
THROW( CException( E_FAIL ) );
|
|
}
|
|
|
|
//
|
|
// If dwType doesn't match, we go to DBTYPE_VARIANT
|
|
//
|
|
|
|
if ( pBaseline[j].wType != pCols[j].wType )
|
|
pBaseline[j].wType = DBTYPE_VARIANT;
|
|
|
|
//
|
|
// Take the maximum cbMaxLength, except for bookmark where we sum
|
|
// the lengths.
|
|
//
|
|
|
|
Win4Assert( 0 == (pBaseline[j].dwFlags & DBCOLUMNFLAGS_ISBOOKMARK) ||
|
|
( pBaseline[j].ulColumnSize == pCols[j].ulColumnSize &&
|
|
pBaseline[j].dwFlags & DBCOLUMNFLAGS_ISFIXEDLENGTH ) );
|
|
|
|
if ( pBaseline[j].dwFlags & DBCOLUMNFLAGS_ISBOOKMARK && i == (_cChild - 1) )
|
|
{
|
|
//
|
|
// Last pass through, add room for child id and give room
|
|
// to store ulColumnSize for *each* child.
|
|
//
|
|
|
|
pBaseline[j].ulColumnSize *= _cChild;
|
|
pBaseline[j].ulColumnSize += sizeof(ULONG);
|
|
}
|
|
else
|
|
if ( pBaseline[j].ulColumnSize < pCols[j].ulColumnSize )
|
|
pBaseline[j].ulColumnSize = pCols[j].ulColumnSize;
|
|
|
|
if ( pBaseline[j].wType == DBTYPE_NUMERIC )
|
|
{
|
|
//
|
|
// Precision and scale have to match?
|
|
//
|
|
|
|
if ( pBaseline[j].bPrecision != pCols[j].bPrecision ||
|
|
pBaseline[j].bScale != pCols[j].bScale )
|
|
{
|
|
Win4Assert( !"Mismatched columns" );
|
|
THROW( CException( E_FAIL ) );
|
|
}
|
|
}
|
|
|
|
//
|
|
// All the conditions in dwFlags are positive (e.g. IsXXX), so the
|
|
// final flag is the bitwise and of all children.
|
|
//
|
|
|
|
#if CIDBG == 1
|
|
if ( pBaseline[j].dwFlags != pCols[j].dwFlags )
|
|
{
|
|
vqDebugOut(( DEB_WARN,
|
|
"GetColumnInfo: Mismatched dwFlags 0x%x, 0x%x\n",
|
|
pBaseline[j].dwFlags, pCols[j].dwFlags ));
|
|
}
|
|
#endif // CIDBG == 1
|
|
|
|
pBaseline[j].dwFlags &= pCols[j].dwFlags;
|
|
|
|
} // for each column
|
|
} // for each cursor
|
|
|
|
*ppColInfo = pBaseline.Acquire(); // Allow memory to pass back to client.
|
|
*ppwchInfo = pBaseStr.Acquire();
|
|
}
|
|
CATCH( CException, e )
|
|
{
|
|
sc = e.GetErrorCode();
|
|
|
|
if ( sc != E_INVALIDARG && sc != E_OUTOFMEMORY )
|
|
{
|
|
vqDebugOut(( DEB_ERROR, "CDistributedRowset::GetColumnInfo: bogus error code 0x%x\n", sc ));
|
|
sc = E_FAIL;
|
|
}
|
|
}
|
|
END_CATCH
|
|
}
|
|
|
|
if (FAILED(sc))
|
|
_DBErrorObj.PostHResult(sc, IID_IColumnsInfo);
|
|
|
|
return( sc );
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CDistributedRowset::GetColumnInfo, public
|
|
//
|
|
// Synopsis: Returns basic info about columns in table.
|
|
//
|
|
// Arguments: [pcColumns] -- Count returned here.
|
|
// [ppColInfo] -- Array of column descriptors returned here.
|
|
// [ppwchInfo] -- Pointer to storage for all string values.
|
|
//
|
|
// History: 27-Sep-98 VikasMan Created
|
|
//
|
|
// Notes: Calls _GetFullColumnInfo and then trims out the extra columns
|
|
// that we added for sorting
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CDistributedRowset::GetColumnInfo( DBORDINAL * pcColumns,
|
|
DBCOLUMNINFO ** ppColInfo,
|
|
WCHAR ** ppwchInfo)
|
|
{
|
|
SCODE sc = _GetFullColumnInfo( pcColumns, ppColInfo, ppwchInfo );
|
|
|
|
if ( SUCCEEDED( sc ) && pcColumns && *pcColumns )
|
|
{
|
|
if ( *pcColumns < _cColumns )
|
|
return E_INVALIDARG;
|
|
|
|
Win4Assert( *pcColumns >= _cColumns );
|
|
|
|
*pcColumns = _cColumns;
|
|
}
|
|
|
|
return( sc );
|
|
}
|
|
|
|
|
|
//
|
|
// IRowsetIdentity methods
|
|
//
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CDistributedRowset::IsSameRow, public
|
|
//
|
|
// Arguments: [hThisRow] -- First row.
|
|
// [hThatRow] -- Second row.
|
|
//
|
|
// Returns: S_OK if the rows are the same, else S_FALSE.
|
|
//
|
|
// History: 02-Mar-95 KyleP Created.
|
|
//
|
|
// Notes: Assumes child rowset(s) support DBROWSETFLAGS_TRUEIDENTITY.
|
|
//
|
|
// Notes: Need to have Ole DB error handling here because the underlying
|
|
// errors are being translated.
|
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CDistributedRowset::IsSameRow( HROW hThisRow, HROW hThatRow )
|
|
{
|
|
_DBErrorObj.ClearErrorInfo();
|
|
|
|
SCODE sc = S_OK;
|
|
|
|
TRY
|
|
{
|
|
HROW hrowChild1, hrowChild2;
|
|
|
|
int iChild1 = _RowManager.GetChildAndHROW( hThisRow, hrowChild1 );
|
|
int iChild2 = _RowManager.GetChildAndHROW( hThatRow, hrowChild2 );
|
|
|
|
if ( iChild1 == iChild2 && hrowChild1 == hrowChild2 )
|
|
sc = S_OK;
|
|
else
|
|
sc = S_FALSE;
|
|
}
|
|
CATCH( CException, e )
|
|
{
|
|
sc = e.GetErrorCode();
|
|
vqDebugOut(( DEB_ERROR, "Exception 0x%x caught in CDistributedRowset::IsSameRow\n", sc ));
|
|
}
|
|
END_CATCH
|
|
|
|
if (FAILED(sc))
|
|
_DBErrorObj.PostHResult(sc, IID_IRowsetIdentity);
|
|
|
|
return sc;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CDistributedRowset::CDistributedRowset, public
|
|
//
|
|
// Synopsis: Initialize distributed rowset.
|
|
//
|
|
// Arguments: [pUnkOuter] -- outer unknown
|
|
// [ppMyUnk] -- OUT: on return, filled with pointer to my
|
|
// non-delegating IUnknown
|
|
// [aChild] -- Array of child rowsets.
|
|
// [cChild] -- Count of [aChild].
|
|
// [Props] -- Rowset properties
|
|
// [cColumns] -- Number of original columns
|
|
// [aAccessors] -- Bag of accessors which rowsets need to inherit
|
|
//
|
|
// History: 03-Apr-95 KyleP Created.
|
|
//
|
|
// Notes: Ownership of aChild is transferred.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
CDistributedRowset::CDistributedRowset(
|
|
IUnknown * pUnkOuter,
|
|
IUnknown ** ppMyUnk,
|
|
IRowset ** aChild,
|
|
unsigned cChild,
|
|
CMRowsetProps const & Props,
|
|
unsigned cColumns,
|
|
CAccessorBag & aAccessors,
|
|
CCIOleDBError & DBErrorObj)
|
|
:
|
|
#pragma warning(disable : 4355) // 'this' in a constructor
|
|
_aAccessors( (IUnknown *) (IRowset *)this ),
|
|
_impIUnknown(this),
|
|
#pragma warning(default : 4355) // 'this' in a constructor
|
|
_aChild( aChild ),
|
|
_cChild( cChild ),
|
|
_cColumns( cColumns ),
|
|
_aColInfo( 0 ),
|
|
_awchInfo( 0 ),
|
|
_iColumnBookmark( -1 ),
|
|
_cbBookmark( 0 ),
|
|
_Props( Props ),
|
|
_DBErrorObj( DBErrorObj ),
|
|
_cMaxResults( _Props.GetMaxResults() ),
|
|
_cFirstRows( _Props.GetFirstRows() ),
|
|
_iCurrentRow( 0 )
|
|
{
|
|
// NTRAID#DB-NTBUG9-84049-2000/07/31-dlee Distributed queries need to support MaxResults for scrollable sorted rowsets
|
|
|
|
Win4Assert( _cChild > 0 );
|
|
|
|
if (pUnkOuter)
|
|
_pControllingUnknown = pUnkOuter;
|
|
else
|
|
_pControllingUnknown = (IUnknown * )&_impIUnknown;
|
|
|
|
//
|
|
// We need to get column info once in order to figure out which column (if any)
|
|
// is the bookmark column. We'll cache the column info in _aColInfo just in
|
|
// case the client also needs it.
|
|
//
|
|
|
|
SCODE sc = _GetFullColumnInfo( &_cColInfo, &_aColInfo, &_awchInfo );
|
|
|
|
if ( FAILED(sc) )
|
|
{
|
|
vqDebugOut(( DEB_ERROR,
|
|
"CDistributedRowset: Error 0x%x fetching column info\n", sc ));
|
|
THROW( CException( sc ) );
|
|
}
|
|
|
|
for ( unsigned i = 0; i < _cColInfo; i++ )
|
|
{
|
|
if ( _aColInfo[i].dwFlags & DBCOLUMNFLAGS_ISBOOKMARK )
|
|
{
|
|
_iColumnBookmark = _aColInfo[i].iOrdinal;
|
|
_cbBookmark = _aColInfo[i].ulColumnSize;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// GetBindings for each accessor in bag, and use them to create accessor
|
|
// in IRowset
|
|
//
|
|
// only CAccessors can be used by commands
|
|
|
|
CAccessorBase * pAccBase = (CAccessorBase *)aAccessors.First();
|
|
while ( 0 != pAccBase )
|
|
{
|
|
DBCOUNTITEM cBindings;
|
|
DBBINDING * rgBindings;
|
|
DBACCESSORFLAGS dwAccessorFlags;
|
|
|
|
SCODE sc = pAccBase->GetBindings(&dwAccessorFlags, &cBindings, &rgBindings);
|
|
if (FAILED(sc))
|
|
THROW(CException(sc));
|
|
|
|
HACCESSOR hAccessor;
|
|
sc = CreateAccessor(dwAccessorFlags, cBindings, rgBindings, 0, &hAccessor, 0);
|
|
CoTaskMemFree(rgBindings); //cleanup from GetBindings
|
|
if (FAILED(sc))
|
|
THROW(CException(sc));
|
|
|
|
//
|
|
// inherited accessors are accessed through same hAccessor as original.
|
|
// Set parent of newly created accessor so that we can link the 2 copies.
|
|
// Client never knows the direct HACESSOR for the inherited accessor.
|
|
// All accessor methods check bag for an accessor with a match on
|
|
// the parent or the creator.
|
|
//
|
|
((CAccessorBase *)hAccessor)->SetParent(pAccBase);
|
|
|
|
//
|
|
// Increment inheritor count for parent accessor
|
|
//
|
|
pAccBase->IncInheritors();
|
|
|
|
pAccBase = (CDistributedAccessor *)aAccessors.Next();
|
|
}
|
|
#if CIDBG == 1
|
|
for ( i++; i < _cColInfo; i++ )
|
|
{
|
|
Win4Assert( 0 == (_aColInfo[i].dwFlags & DBCOLUMNFLAGS_ISBOOKMARK) );
|
|
}
|
|
#endif
|
|
|
|
*ppMyUnk = ((IUnknown *)&_impIUnknown);
|
|
(*ppMyUnk)->AddRef();
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CDistributedRowset::~CDistributedRowset, public
|
|
//
|
|
// Synopsis: Destructor
|
|
//
|
|
// History: 03-Apr-95 KyleP Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
CDistributedRowset::~CDistributedRowset()
|
|
{
|
|
unsigned ii;
|
|
|
|
if ( !_xChildNotify.IsNull() )
|
|
{
|
|
_xChildNotify->OnRowsetChange( DBREASON_ROWSET_RELEASE,
|
|
DBEVENTPHASE_DIDEVENT,
|
|
TRUE);
|
|
}
|
|
|
|
for ( ii = _xArrChildAsynchCP.Count(); ii > 0; ii-- )
|
|
{
|
|
if ( _xArrChildAsynchCP[ii-1].GetPointer() )
|
|
{
|
|
_xArrChildAsynchCP[ii-1]->Unadvise( _xArrAsynchAdvise[ii-1] );
|
|
}
|
|
}
|
|
|
|
for ( ii = _xArrChildWatchCP.Count(); ii > 0; ii-- )
|
|
{
|
|
if ( _xArrChildWatchCP[ii-1].GetPointer() )
|
|
{
|
|
_xArrChildWatchCP[ii-1]->Unadvise( _xArrWatchAdvise[ii-1] );
|
|
}
|
|
}
|
|
|
|
_xServerCPC.Free();
|
|
|
|
if ( 0 != _aColInfo )
|
|
CoTaskMemFree( _aColInfo );
|
|
|
|
if ( 0 != _awchInfo )
|
|
CoTaskMemFree( _awchInfo );
|
|
|
|
for ( unsigned i = 0; i < _cChild; i++ )
|
|
{
|
|
if ( 0 != _aChild[i] )
|
|
_aChild[i]->Release();
|
|
}
|
|
|
|
delete [] _aChild;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CDistributedRowset::CanConvertType, public
|
|
//
|
|
// Synopsis: Gives info. on the availability of type conversions.
|
|
//
|
|
// History: 29-Jan-97 KrishnaN Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CDistributedRowset::CanConvert( DBTYPE wFromType,
|
|
DBTYPE wToType,
|
|
DBCONVERTFLAGS dwConvertFlags)
|
|
{
|
|
_DBErrorObj.ClearErrorInfo();
|
|
|
|
SCODE sc;
|
|
|
|
for (unsigned iChild = 0; iChild < _cChild; iChild++)
|
|
{
|
|
|
|
IConvertType* pIConvertType = 0;
|
|
sc = _aChild[iChild]->QueryInterface( IID_IConvertType, (void **) &pIConvertType );
|
|
|
|
if (SUCCEEDED( sc ))
|
|
{
|
|
sc = pIConvertType->CanConvert(wFromType, wToType, dwConvertFlags);
|
|
pIConvertType->Release();
|
|
}
|
|
|
|
if (sc != S_OK)
|
|
return _DBErrorObj.PostHResult(sc, IID_IConvertType);
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
//
|
|
// Helper function used by GetStatus and GetStatusEx
|
|
//
|
|
inline void ParseQueryFillStatus( DWORD dwQueryFillStatus,
|
|
DWORD & dwError,
|
|
DWORD & dwBusy,
|
|
DWORD & dwRefresh,
|
|
DWORD & dwDone )
|
|
{
|
|
if ( STAT_ERROR == dwQueryFillStatus )
|
|
{
|
|
dwError = 1;
|
|
dwDone = 0;
|
|
}
|
|
else if ( STAT_BUSY == dwQueryFillStatus )
|
|
{
|
|
dwBusy = 1;
|
|
dwDone = 0;
|
|
}
|
|
else if ( STAT_REFRESH == dwQueryFillStatus )
|
|
{
|
|
dwRefresh = 1;
|
|
dwDone = 0;
|
|
}
|
|
else if ( STAT_DONE == dwQueryFillStatus )
|
|
{
|
|
dwDone &= 1;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Helper function used by GetStatus and GetStatusEx
|
|
//
|
|
inline void SetQueryFillStatus( DWORD & dwStatus,
|
|
DWORD dwError,
|
|
DWORD dwBusy,
|
|
DWORD dwRefresh,
|
|
DWORD dwDone )
|
|
{
|
|
if ( dwError )
|
|
{
|
|
dwStatus |= STAT_ERROR;
|
|
}
|
|
else if ( dwBusy )
|
|
{
|
|
dwStatus |= STAT_BUSY;
|
|
}
|
|
else if ( dwRefresh )
|
|
{
|
|
dwStatus |= STAT_REFRESH;
|
|
}
|
|
else if ( dwDone )
|
|
{
|
|
dwStatus |= STAT_DONE;
|
|
}
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CDistributedRowset::GetStatus, public
|
|
//
|
|
// Synopsis: Return query status
|
|
//
|
|
// Arguments: [pdwStatus] -- pointer to where query status is returned
|
|
//
|
|
// Returns: SCODE error code
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CDistributedRowset::GetStatus( DWORD * pdwStatus )
|
|
{
|
|
_DBErrorObj.ClearErrorInfo();
|
|
|
|
SCODE scResult = S_OK;
|
|
|
|
if ( pdwStatus )
|
|
{
|
|
*pdwStatus = 0;
|
|
|
|
DWORD dwBusy = 0;
|
|
DWORD dwError = 0;
|
|
DWORD dwRefresh = 0;
|
|
DWORD dwDone = 1;
|
|
|
|
XInterface<IRowsetQueryStatus> xIRowsetQueryStatus;
|
|
|
|
for (unsigned iChild = 0; iChild < _cChild; iChild++)
|
|
{
|
|
scResult = _aChild[iChild]->QueryInterface( IID_IRowsetQueryStatus,
|
|
xIRowsetQueryStatus.GetQIPointer() );
|
|
|
|
DWORD dwChildStatus;
|
|
|
|
if ( SUCCEEDED( scResult ) )
|
|
scResult = xIRowsetQueryStatus->GetStatus( &dwChildStatus );
|
|
|
|
xIRowsetQueryStatus.Free();
|
|
|
|
if (scResult != S_OK)
|
|
return scResult;
|
|
|
|
// OR the query reliability status
|
|
|
|
*pdwStatus |= QUERY_RELIABILITY_STATUS(dwChildStatus);
|
|
|
|
ParseQueryFillStatus( QUERY_FILL_STATUS( dwChildStatus ),
|
|
dwError, dwBusy, dwRefresh, dwDone );
|
|
}
|
|
|
|
// Now set the QUERY_FILL_STATUS. If we have at in the following order:
|
|
// ERROR > BUSY > REFRESH > DONE
|
|
|
|
SetQueryFillStatus( *pdwStatus, dwError, dwBusy, dwRefresh, dwDone );
|
|
}
|
|
|
|
return scResult;
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CDistributedRowset::GetStatusEx, public
|
|
//
|
|
// Synopsis: Return query status
|
|
//
|
|
// Arguments: [pdwStatus] - returns query status
|
|
// [pcFilteredDocuments] - # of documents filtered
|
|
// [pcDocumentsToFilter] - # of docsuments yet to filter
|
|
// [pdwRatioFinishedDenominator] - ratio finished denominator
|
|
// [pdwRatioFinishedNumerator] - ratio finished numerator
|
|
// [cbBmk] - # of bytes in pBmk
|
|
// [pBmk] - bookmark for piRowBmk
|
|
// [piRowBmk] - returns index of bookmark in table
|
|
// [pcRowsTotal] - current # of rows in table
|
|
//
|
|
// Returns: SCODE error code
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CDistributedRowset::GetStatusEx(
|
|
DWORD * pdwStatus,
|
|
DWORD * pcFilteredDocuments,
|
|
DWORD * pcDocumentsToFilter,
|
|
DBCOUNTITEM * pdwRatioFinishedDenominator,
|
|
DBCOUNTITEM * pdwRatioFinishedNumerator,
|
|
DBBKMARK cbBmk,
|
|
const BYTE * pBmk,
|
|
DBCOUNTITEM * piRowBmk,
|
|
DBCOUNTITEM * pcRowsTotal )
|
|
{
|
|
_DBErrorObj.ClearErrorInfo();
|
|
|
|
SCODE scResult = S_OK;
|
|
|
|
if ( pdwStatus )
|
|
*pdwStatus = 0;
|
|
|
|
if ( pcFilteredDocuments )
|
|
*pcFilteredDocuments = 0;
|
|
|
|
*pcDocumentsToFilter = 0;
|
|
|
|
if ( pdwRatioFinishedDenominator )
|
|
*pdwRatioFinishedDenominator = 0;
|
|
|
|
if ( pdwRatioFinishedNumerator )
|
|
*pdwRatioFinishedNumerator = 0;
|
|
|
|
if ( piRowBmk )
|
|
*piRowBmk = 0;
|
|
|
|
if ( pcRowsTotal )
|
|
*pcRowsTotal = 0;
|
|
|
|
DWORD dwBusy = 0;
|
|
DWORD dwError = 0;
|
|
DWORD dwRefresh = 0;
|
|
DWORD dwDone = 1;
|
|
|
|
ULONG iBmkCursor = 0;
|
|
BYTE const * pChildBmk = NULL;
|
|
|
|
// Parse bookmark
|
|
if ( cbBmk != 0 )
|
|
{
|
|
iBmkCursor = *( (ULONG*)pBmk );
|
|
pChildBmk = pBmk + sizeof( ULONG ) + ( iBmkCursor * sizeof( ULONG ) );
|
|
cbBmk = sizeof( ULONG );
|
|
}
|
|
|
|
double dRatio = 0;
|
|
|
|
XInterface<IRowsetQueryStatus> xIRowsetQueryStatus;
|
|
for (unsigned iChild = 0; iChild < _cChild; iChild++)
|
|
{
|
|
scResult = _aChild[iChild]->QueryInterface( IID_IRowsetQueryStatus,
|
|
xIRowsetQueryStatus.GetQIPointer() );
|
|
|
|
DWORD dwChildStatus;
|
|
DWORD cFilteredDocuments;
|
|
DWORD cDocumentsToFilter;
|
|
DBCOUNTITEM dwRatioFinishedDenominator;
|
|
DBCOUNTITEM dwRatioFinishedNumerator;
|
|
DBCOUNTITEM iRowBmk;
|
|
DBCOUNTITEM cRowsTotal;
|
|
|
|
if ( SUCCEEDED( scResult ) )
|
|
{
|
|
scResult = xIRowsetQueryStatus->GetStatusEx( &dwChildStatus,
|
|
&cFilteredDocuments,
|
|
&cDocumentsToFilter,
|
|
&dwRatioFinishedDenominator,
|
|
&dwRatioFinishedNumerator,
|
|
( cbBmk > 0 && iBmkCursor == iChild ) ?
|
|
cbBmk : 0,
|
|
( cbBmk > 0 && iBmkCursor == iChild ) ?
|
|
pChildBmk : 0,
|
|
&iRowBmk,
|
|
&cRowsTotal );
|
|
}
|
|
xIRowsetQueryStatus.Free();
|
|
|
|
if (scResult != S_OK)
|
|
{
|
|
return scResult;
|
|
}
|
|
|
|
// OR the query reliability status
|
|
if ( pdwStatus )
|
|
{
|
|
*pdwStatus |= QUERY_RELIABILITY_STATUS(dwChildStatus);
|
|
}
|
|
|
|
ParseQueryFillStatus( QUERY_FILL_STATUS( dwChildStatus ),
|
|
dwError, dwBusy, dwRefresh, dwDone );
|
|
|
|
if ( pcFilteredDocuments )
|
|
*pcFilteredDocuments += cFilteredDocuments;
|
|
|
|
if ( pcDocumentsToFilter )
|
|
*pcDocumentsToFilter += cDocumentsToFilter;
|
|
|
|
if ( dwRatioFinishedDenominator )
|
|
{
|
|
dRatio += ( (double)dwRatioFinishedNumerator / (double)dwRatioFinishedDenominator );
|
|
}
|
|
|
|
if ( pcRowsTotal )
|
|
*pcRowsTotal += cRowsTotal;
|
|
}
|
|
|
|
DWORD dwNum = 0;
|
|
DWORD dwDen = 0;
|
|
|
|
if ( dRatio )
|
|
{
|
|
Win4Assert( _cChild );
|
|
|
|
dRatio /= _cChild;
|
|
dwDen = 1;
|
|
|
|
while ( dRatio < 1.0 )
|
|
{
|
|
dRatio *= 10;
|
|
dwDen *= 10;
|
|
}
|
|
dwNum = (DWORD)dRatio;
|
|
}
|
|
|
|
if ( pdwRatioFinishedDenominator )
|
|
*pdwRatioFinishedDenominator = dwNum;
|
|
|
|
if ( pdwRatioFinishedNumerator )
|
|
*pdwRatioFinishedNumerator = dwDen;
|
|
|
|
// Now set the QUERY_FILL_STATUS. If we have at in the following order:
|
|
// ERROR > BUSY > REFRESH > DONE
|
|
|
|
if ( pdwStatus )
|
|
SetQueryFillStatus( *pdwStatus, dwError, dwBusy, dwRefresh, dwDone );
|
|
|
|
return scResult;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CDistributedRowset::_SetupChildNotifications, private
|
|
//
|
|
// Synopsis: Set up connection points to receive notifications from the
|
|
// child rowsets
|
|
//
|
|
// Arguments: fAsynchOnly - TRUE if Asynch only,
|
|
// FLASE if Asynch and Watchable
|
|
//
|
|
// Returns: void
|
|
//
|
|
// History: 03 Sep 1998 VikasMan Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
void CDistributedRowset::_SetupChildNotifications( BOOL fAsynchOnly )
|
|
{
|
|
SCODE sc;
|
|
XInterface<IConnectionPointContainer> xChildCPC;
|
|
|
|
// various arrays for the child rowsets
|
|
_xArrAsynchAdvise.Init( _cChild );
|
|
_xArrChildAsynchCP.Init( _cChild );
|
|
|
|
if ( !fAsynchOnly )
|
|
{
|
|
_xArrWatchAdvise.Init( _cChild );
|
|
_xArrChildWatchCP.Init( _cChild );
|
|
}
|
|
|
|
_xArrChildRowsetWatchRegion.Init( _cChild );
|
|
|
|
for (unsigned iChild = 0; iChild < _cChild; iChild++)
|
|
{
|
|
sc = _aChild[iChild]->QueryInterface( IID_IConnectionPointContainer,
|
|
xChildCPC.GetQIPointer() );
|
|
if ( SUCCEEDED( sc ) )
|
|
{
|
|
sc = xChildCPC->FindConnectionPoint( IID_IDBAsynchNotify,
|
|
(IConnectionPoint**)_xArrChildAsynchCP[iChild].GetQIPointer() );
|
|
|
|
if (SUCCEEDED(sc))
|
|
{
|
|
sc = _xArrChildAsynchCP[iChild]->Advise( (IUnknown *)(void*)(_xChildNotify.GetPointer()),
|
|
&_xArrAsynchAdvise[iChild] );
|
|
}
|
|
|
|
if ( !fAsynchOnly )
|
|
{
|
|
sc = xChildCPC->FindConnectionPoint( IID_IRowsetWatchNotify,
|
|
(IConnectionPoint**)_xArrChildWatchCP[iChild].GetQIPointer() );
|
|
|
|
if (SUCCEEDED(sc))
|
|
{
|
|
sc = _xArrChildWatchCP[iChild]->Advise( (IUnknown *)(void*)(_xChildNotify.GetPointer()),
|
|
&_xArrWatchAdvise[iChild] );
|
|
}
|
|
}
|
|
|
|
xChildCPC.Free();
|
|
|
|
_aChild[iChild]->QueryInterface( IID_IRowsetWatchRegion,
|
|
_xArrChildRowsetWatchRegion[iChild].GetQIPointer() );
|
|
}
|
|
}
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CDistributedRowset::_SetupConnectionPointContainer, private
|
|
//
|
|
// Synopsis: Setups the connection point conatiner and other notification stuff
|
|
// for the distributed rowset. Handles both asynchronous ( for
|
|
// scrollable sorted rowset ) and synchronous ( for sequential rowset )
|
|
// cases.
|
|
//
|
|
// Arguments: pRowset - Rowset for which notifications are to be handled
|
|
// ppiuk - IConnectionPointContainer interface is returned here
|
|
//
|
|
// Returns: SCODE
|
|
//
|
|
// History: 22 Sep 1998 VikasMan Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
SCODE CDistributedRowset::_SetupConnectionPointContainer( IRowset * pRowset, VOID * * ppiuk )
|
|
{
|
|
SCODE sc = S_OK;
|
|
|
|
BOOL fWatchable = (_Props.GetPropertyFlags() & eWatchable) != 0;
|
|
BOOL fAsynchronous = (_Props.GetPropertyFlags() & eAsynchronous) != 0;
|
|
|
|
if ( _xServerCPC.IsNull() )
|
|
{
|
|
TRY
|
|
{
|
|
_xServerCPC.Set( new CConnectionPointContainer(
|
|
fAsynchronous ? 3 : 1,
|
|
* ((IUnknown *) pRowset),
|
|
_DBErrorObj ) );
|
|
|
|
// Create an instance of CDistributedRowsetWatchNotify which acts as
|
|
// sink for the child rowsets and connection point for this rowset's clients
|
|
_xChildNotify.Set( new CDistributedRowsetWatchNotify( pRowset, _cChild ) );
|
|
|
|
if ( fWatchable || fAsynchronous )
|
|
{
|
|
// set up to recieve notifications from all child rowsets
|
|
_SetupChildNotifications( !fWatchable );
|
|
}
|
|
|
|
_xChildNotify->AddConnectionPoints( _xServerCPC.GetPointer(),
|
|
fAsynchronous,
|
|
fWatchable );
|
|
|
|
}
|
|
CATCH( CException, e )
|
|
{
|
|
sc = GetOleError( e );
|
|
}
|
|
END_CATCH;
|
|
}
|
|
|
|
if ( S_OK == sc )
|
|
{
|
|
Win4Assert( _xServerCPC.GetPointer() );
|
|
*ppiuk = (void *) (IConnectionPointContainer *)
|
|
_xServerCPC.GetPointer();
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CDistributedRowset::GetNextRows, public
|
|
//
|
|
// Synopsis: Calls _GetNextRows(which is overridden by derived classes)
|
|
// and handles notifications
|
|
//
|
|
// Arguments: [hChapter] -- Chapter
|
|
// [cRowsToSkip] -- Skip this many rows before beginning.
|
|
// [cRows] -- Try to fetch this many rows.
|
|
// [pcRowsObtained] -- Actually fetched this many.
|
|
// [pphRows] -- Store HROWs here. Allocate memory if
|
|
// [pphRows] is zero.
|
|
//
|
|
// History: 22-Sep-98 VikasMan Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
SCODE CDistributedRowset::GetNextRows( HCHAPTER hChapter,
|
|
DBROWOFFSET cRowsToSkip,
|
|
DBROWCOUNT cRows,
|
|
DBCOUNTITEM * pcRowsObtained,
|
|
HROW * * pphRows )
|
|
{
|
|
SCODE scResult = S_OK;
|
|
BOOL fNotified = FALSE;
|
|
|
|
TRY
|
|
{
|
|
Win4Assert( pcRowsObtained );
|
|
|
|
*pcRowsObtained = 0;
|
|
|
|
DBROWCOUNT cRowLimit = _cFirstRows > 0 ? _cFirstRows : _cMaxResults;
|
|
|
|
// check for max rows
|
|
if ( cRowLimit )
|
|
{
|
|
if ( _iCurrentRow + cRowsToSkip > cRowLimit )
|
|
{
|
|
return DB_S_ROWLIMITEXCEEDED;
|
|
}
|
|
|
|
if ( _iCurrentRow + cRowsToSkip + cRows > cRowLimit )
|
|
{
|
|
cRows = cRowLimit - (_iCurrentRow + cRowsToSkip);
|
|
|
|
if ( 0 == cRows )
|
|
{
|
|
return DB_S_ROWLIMITEXCEEDED;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( !_xChildNotify.IsNull() )
|
|
{
|
|
scResult = _xChildNotify->OnRowsetChange( DBREASON_ROWSET_FETCHPOSITIONCHANGE,
|
|
DBEVENTPHASE_OKTODO,
|
|
FALSE);
|
|
if ( S_FALSE == scResult )
|
|
THROW(CException(DB_E_CANCELED));
|
|
fNotified = TRUE;
|
|
}
|
|
scResult = _GetNextRows( hChapter,
|
|
cRowsToSkip,
|
|
cRows,
|
|
pcRowsObtained,
|
|
pphRows );
|
|
|
|
if ( SUCCEEDED( scResult ) && *pcRowsObtained )
|
|
{
|
|
_iCurrentRow += *pcRowsObtained;
|
|
}
|
|
|
|
if ( fNotified )
|
|
{
|
|
if ( SUCCEEDED(scResult) )
|
|
{
|
|
if ( *pcRowsObtained != 0 )
|
|
{
|
|
_xChildNotify->OnRowChange( *pcRowsObtained,
|
|
*pphRows,
|
|
DBREASON_ROW_ACTIVATE,
|
|
DBEVENTPHASE_DIDEVENT,
|
|
TRUE);
|
|
}
|
|
_xChildNotify->OnRowsetChange( DBREASON_ROWSET_FETCHPOSITIONCHANGE,
|
|
DBEVENTPHASE_DIDEVENT,
|
|
TRUE);
|
|
}
|
|
}
|
|
}
|
|
CATCH( CException, e )
|
|
{
|
|
scResult = GetOleError(e);
|
|
}
|
|
END_CATCH;
|
|
|
|
if ( fNotified && FAILED(scResult) )
|
|
{
|
|
_xChildNotify->OnRowsetChange( DBREASON_ROWSET_FETCHPOSITIONCHANGE,
|
|
DBEVENTPHASE_FAILEDTODO,
|
|
TRUE);
|
|
}
|
|
return scResult;
|
|
}
|
|
|