//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1995 - 2000
//
// File: ScrlSort.cxx
//
// Contents: Sorted, fully scrollable, distributed rowset.
//
// Classes: CScrollableSorted
//
// History: 05-Jun-95 KyleP Created
// 14-JAN-97 KrishnaN Brought it back to conform to 1.0 spec
//
// 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.
//
//----------------------------------------------------------------------------
#include <pch.cxx>
#pragma hdrstop
#include "scrlsort.hxx"
#include "disacc.hxx"
#include "disbmk.hxx"
// Rowset object Interfaces that support Ole DB error objects
static const IID * apRowsetErrorIFs[] =
{
&IID_IAccessor,
&IID_IColumnsInfo,
&IID_IConvertType,
&IID_IRowset,
&IID_IRowsetInfo,
&IID_IDBAsynchStatus,
&IID_IRowsetWatchRegion,
&IID_IRowsetAsynch,
&IID_IRowsetQueryStatus,
//&IID_IColumnsRowset,
&IID_IConnectionPointContainer,
&IID_IRowsetIdentity,
&IID_IRowsetLocate,
//&IID_IRowsetResynch,
&IID_IRowsetScroll,
//&IID_IRowsetUpdate,
//&IID_ISupportErrorInfo
};
static const ULONG cRowsetErrorIFs = sizeof(apRowsetErrorIFs)/sizeof(apRowsetErrorIFs[0]);
//
// IUnknown methods.
//
//+-------------------------------------------------------------------------
//
// Method: CScrollableSorted::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 CScrollableSorted::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_IRowsetLocate )
{
*ppiuk = (void *)((IRowsetLocate *)this);
}
else if ( riid == IID_IRowsetScroll )
{
*ppiuk = (void *)((IRowsetScroll *)this);
}
else if ( riid == IID_IRowsetExactScroll )
{
*ppiuk = (void *)((IRowsetExactScroll *)this);
}
else if ( riid == IID_IColumnsInfo )
{
*ppiuk = (void *)((IColumnsInfo *)this);
}
else if ( riid == IID_IAccessor )
{
*ppiuk = (void *)((IAccessor *)this);
}
else if ( riid == IID_IRowsetIdentity )
{
*ppiuk = (void *)((IRowsetIdentity *)this);
}
else if ( riid == IID_IRowsetInfo )
{
*ppiuk = (void *)((IRowsetInfo *)this);
}
else if ( riid == IID_IRowsetAsynch )
{
sc = E_NOINTERFACE;
//
// Support IRowsetAsynch if any of the child rowsets do.
//
IRowsetAsynch * pra = 0;
for (unsigned iChild=0; iChild < _rowset._cChild; iChild++ )
{
sc = Get(iChild)->QueryInterface (IID_IRowsetAsynch, (void**) &pra);
if (SUCCEEDED(sc))
{
pra->Release();
*ppiuk = (void *)((IRowsetAsynch *)this);
break;
}
}
}
else if ( riid == IID_IRowsetWatchRegion )
{
*ppiuk = (void *) (IRowsetWatchRegion *) this;
}
else if ( riid == IID_IRowsetWatchAll )
{
*ppiuk = (void *) (IRowsetWatchAll *) this;
}
else if ( riid == IID_IDBAsynchStatus )
{
*ppiuk = (void *) (IDBAsynchStatus *) this;
}
else if ( riid == IID_IConnectionPointContainer )
{
sc = _rowset._SetupConnectionPointContainer( this, ppiuk );
}
else if ( riid == IID_IRowsetQueryStatus )
{
*ppiuk = (void *)((IRowsetQueryStatus *)this);
}
else
{
sc = E_NOINTERFACE;
}
return sc;
}
//+---------------------------------------------------------------------------
//
// Member: CScrollableSorted::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: This method is virtually identical to the one in its base
// class. The difference is that this class tracks HROWs
// for all child cursors, to use as bookmark hints.
//
// Notes: Need to have Ole DB error handling here because an exception could
// happen, resulting in a local error.
//
//----------------------------------------------------------------------------
SCODE CScrollableSorted::GetData( HROW hRow,
HACCESSOR hAccessor,
void * pData )
{
_DBErrorObj.ClearErrorInfo();
SCODE sc;
TRY
{
unsigned iChild;
HROW * ahrow = _rowset._RowManager.GetChildAndHROWs( hRow, iChild );
CDistributedAccessor * pAcc = (CDistributedAccessor *)_rowset._aAccessors.Convert(hAccessor);
sc = pAcc->GetData( iChild, ahrow, pData );
}
CATCH( CException, e )
{
vqDebugOut(( DEB_ERROR, "CScrollableSorted::GetData -- caught 0x%x\n", e.GetErrorCode() ));
sc = e.GetErrorCode();
}
END_CATCH
if (FAILED(sc))
_DBErrorObj.PostHResult(sc, IID_IRowset);
return sc;
}
//
// IRowsetLocate methods
//
//+---------------------------------------------------------------------------
//
// Member: CScrollableSorted::Compare, public
//
// Synopsis: Compare bookmarks.
//
// Arguments: [hChapter] -- Chapter.
// [cbBM1] -- Size of [pBM1].
// [pBM1] -- First bookmark.
// [cbBM2] -- Size of [pBM2].
// [pBM2] -- Second bookmark.
// [pdwComparison] -- Result of comparison returned here.
//
// History: 03-Apr-95 KyleP Created.
//
// Notes: Only equality test supported.
//
// Notes: Need to have Ole DB error handling here because an exception could
// happen, resulting in a local error.
//
//----------------------------------------------------------------------------
STDMETHODIMP CScrollableSorted::Compare( HCHAPTER hChapter,
DBBKMARK cbBM1,
const BYTE * pBM1,
DBBKMARK cbBM2,
const BYTE * pBM2,
DBCOMPARE * pdwComparison )
{
_DBErrorObj.ClearErrorInfo();
SCODE sc = S_OK;
TRY
{
CDistributedBookmark bmk1( cbBM1,
(BYTE const *)pBM1,
_rowset._cbBookmark,
_rowset._cChild );
CDistributedBookmark bmk2( cbBM2,
(BYTE const *)pBM2,
_rowset._cbBookmark,
_rowset._cChild );
if ( bmk1.Index() != bmk2.Index() )
*pdwComparison = DBCOMPARE_NE;
else
{
sc = Get( bmk1.Index() )->Compare( hChapter,
bmk1.GetSize(),
bmk1.Get(),
bmk2.GetSize(),
bmk2.Get(),
pdwComparison );
if ( SUCCEEDED(sc) )
{
if ( *pdwComparison != DBCOMPARE_EQ &&
*pdwComparison != DBCOMPARE_NOTCOMPARABLE )
{
*pdwComparison = DBCOMPARE_NE;
}
}
}
}
CATCH( CException, e )
{
sc = e.GetErrorCode();
vqDebugOut(( DEB_ERROR, "CScrollableSorted::Compare returned 0x%x\n", sc ));
}
END_CATCH
if (FAILED(sc))
_DBErrorObj.PostHResult(sc, IID_IRowsetLocate);
return sc;
}
//+---------------------------------------------------------------------------
//
// Member: CScrollableSorted::GetRowsAt, public
//
// Synopsis: Fetch rows from specified starting location.
//
// Arguments: [hChapter] -- Chapter.
// [cbBookmark] -- Size of [pBookmark]
// [pBookmark] -- Bookmark of starting fetch position.
// [lRowsOffset] -- Offset from bookmark to start fetch.
// [cRows] -- Count of rows requested
// [pcRowsObtained] -- Count of rows in [rrghRows] returned here.
// [rrghRows] -- HROWs returned here.
//
// History: 03-Apr-95 KyleP Created.
//
// Notes: Backwards fetch not supported.
//
// Notes: Need to have Ole DB error handling here because an exception could
// happen, resulting in a local error.
//
//----------------------------------------------------------------------------
STDMETHODIMP CScrollableSorted::GetRowsAt( HWATCHREGION hRegion,
HCHAPTER hChapter,
DBBKMARK cbBookmark,
const BYTE * pBookmark,
DBROWOFFSET lRowsOffset,
DBROWCOUNT cRows,
DBCOUNTITEM * pcRowsObtained,
HROW * rrghRows[])
{
_DBErrorObj.ClearErrorInfo();
SCODE sc = S_OK;
BOOL fAllocated = FALSE;
ULONG cTotalRowsObtained = 0;
Win4Assert( 0 == hChapter && "Chapter support not yet implemented" );
if (0 == cRows) // nothing to fetch
return S_OK;
// Underlying routines are not checking for these errors, so have to
if (0 == cbBookmark || 0 == pBookmark || 0 == pcRowsObtained || 0 == rrghRows )
{
vqDebugOut((DEB_IERROR, "CScrollableSorted::GetRowsAt: Invalid Argument(s)\n"));
return _DBErrorObj.PostHResult(E_INVALIDARG, IID_IRowsetLocate);
}
*pcRowsObtained = 0;
TRY
{
fAllocated = SetupFetch( cRows, rrghRows );
//
// Seek to position. Special cases are beginning and end of rowset.
//
sc = Seek( cbBookmark, pBookmark, lRowsOffset );
if ( SUCCEEDED( sc ) )
{
sc = StandardFetch( cRows, pcRowsObtained, *rrghRows );
if ( SUCCEEDED( sc ) &&
!_rowset._xChildNotify.IsNull() &&
*pcRowsObtained != 0 )
{
_rowset._xChildNotify->OnRowChange( *pcRowsObtained,
*rrghRows,
DBREASON_ROW_ACTIVATE,
DBEVENTPHASE_DIDEVENT,
TRUE);
}
}
else if ( DB_E_BADSTARTPOSITION == sc )
{
// According to OLE DB 2.0 spec we should return the following
sc = DB_S_ENDOFROWSET;
}
}
CATCH( CException, e )
{
sc = e.GetErrorCode();
vqDebugOut(( DEB_ERROR, "Exception 0x%x calling IRowset::GetRowsAt\n", sc ));
//
// If we already have some rows, then we can't 'unfetch' them, so we have
// to mask this error. Presumably it won't be transient and we'll get it
// again later.
//
if ( *pcRowsObtained > 0 )
{
if ( FAILED(sc) )
sc = DB_S_ROWLIMITEXCEEDED;
}
else if ( fAllocated )
CoTaskMemFree( *rrghRows );
}
END_CATCH
if (FAILED(sc))
_DBErrorObj.PostHResult(sc, IID_IRowsetLocate);
return( sc );
}
//+---------------------------------------------------------------------------
//
// Member: CScrollableSorted::GetRowsByBookmark, public
//
// Synopsis: Fetch rows at specified location(s).
//
// Arguments: [hChapter] -- Chapter.
// [cRows] -- Number of input bookmarks.
// [rgcbBookmarks] -- Count of element(s) in [ppBookmarks]
// [ppBookmarks] -- Bookmarks.
// [pcRowsObtained] -- Count of rows in [rrghRows] returned here.
// [rghRows] -- HROWs returned here.
// [rgRowStatus] -- Row fetch statuses returned here
//
// History: 03-Apr-95 KyleP Created.
//
// Notes: Need to have Ole DB error handling here because errors are being
// translated.
//
//----------------------------------------------------------------------------
STDMETHODIMP CScrollableSorted::GetRowsByBookmark( HCHAPTER hChapter,
DBCOUNTITEM cRows,
const DBBKMARK rgcbBookmarks [],
const BYTE * ppBookmarks[],
HROW rghRows[],
DBROWSTATUS rgRowStatus[]
)
{
_DBErrorObj.ClearErrorInfo();
SCODE sc = S_OK;
ULONG cRowsObtained = 0;
Win4Assert( 0 == hChapter && "Chapter support not yet implemented" );
if (0 == rgcbBookmarks || 0 == ppBookmarks || 0 == rghRows)
{
vqDebugOut((DEB_IERROR, "CScrollableSorted::GetRowsByBookmark: Invalid Argument(s)\n"));
return _DBErrorObj.PostHResult(E_INVALIDARG, IID_IRowsetLocate);
}
SetupFetch( cRows, &rghRows );
//
// Note: This code could be optimized to fetch more bookmarks at
// once, but only by complicating the logic. Until we find
// it's worth the pain, let's keep it simple!
//
unsigned cRowsProcessed;
for ( cRowsProcessed = 0; cRowsProcessed < cRows; cRowsProcessed++ )
{
CDistributedBookmark bmk( rgcbBookmarks[cRowsProcessed],
ppBookmarks[cRowsProcessed],
_rowset._cbBookmark,
_rowset._cChild );
DBBKMARK cbBookmark = bmk.GetSize();
BYTE const * pbBookmark = bmk.Get();
sc = Get( bmk.Index() )->GetRowsByBookmark( hChapter,
1,
&cbBookmark,
(BYTE const **)&pbBookmark,
&rghRows[cRowsProcessed],
(0 == rgRowStatus) ? 0 : &rgRowStatus[cRowsProcessed]
);
if ( FAILED(sc) )
{
continue;
}
else
{
rghRows[cRowsProcessed] = _rowset._RowManager.Add( bmk.Index(), rghRows[cRowsProcessed] );
cRowsObtained++;
}
}
if (cRowsProcessed == cRowsObtained)
sc = S_OK;
else if (cRowsObtained > 0) // and not all rows were successfully processed
sc = DB_S_ERRORSOCCURRED;
else // no rows were successfully processed
sc = DB_E_ERRORSOCCURRED;
if ( SUCCEEDED( sc ) &&
cRowsObtained > 0 &&
!_rowset._xChildNotify.IsNull() )
{
_rowset._xChildNotify->OnRowChange( cRowsObtained,
rghRows,
DBREASON_ROW_ACTIVATE,
DBEVENTPHASE_DIDEVENT,
TRUE);
}
return ( S_OK == sc ?
S_OK : _DBErrorObj.PostHResult(sc, IID_IRowsetLocate) );
}
//+---------------------------------------------------------------------------
//
// Member: CScrollableSorted::Hash, public
//
// Synopsis: Hash bookmark
//
// Arguments: [hChapter] -- Chapter.
// [cBookmarks] -- Number of bookmarks.
// [rgcbBookmarks] -- Size of bookmark(s)
// [rgpBookmarks] -- Bookmark(s) to hash.
// [rgHashedValues] -- Hash(s) returned here.
// [rgRowStatus] -- Row fetch statuses returned here
//
// History: 03-Apr-95 KyleP Created.
//
// Notes: Need to have Ole DB error handling here because errors are being
// translated.
//
//----------------------------------------------------------------------------
STDMETHODIMP CScrollableSorted::Hash( HCHAPTER hChapter,
DBBKMARK cBookmarks,
const DBBKMARK rgcbBookmarks[],
const BYTE * rgpBookmarks[],
DBHASHVALUE rgHashedValues[],
DBROWSTATUS rgRowStatus[] )
{
_DBErrorObj.ClearErrorInfo();
SCODE sc = S_OK;
ULONG cSuccessfulHashes = 0;
Win4Assert( 0 == hChapter && "Chapter support not yet implemented" );
Win4Assert( rgHashedValues != 0 );
// We ignore error conditions returned on calls to individual bookmarks to be
// able to process all the bookmarks. That means invalid arguments will never
// be detected and reported without this explicit validation.
if (0 == rgHashedValues || (cBookmarks && (0 == rgcbBookmarks || 0 == rgpBookmarks )))
{
vqDebugOut((DEB_IERROR, "CScrollableSorted::Hash: Invalid Argument(s)\n"));
return _DBErrorObj.PostHResult(E_INVALIDARG, IID_IRowsetLocate);
}
TRY
{
ULONG partition = 0xFFFFFFFF / _rowset._cChild;
for ( ULONG i = 0; i < cBookmarks; i++ )
{
//
// Special bookmarks hash 'as-is'.
//
if ( rgcbBookmarks[i] == 1 )
{
rgHashedValues[i] = (ULONG)*rgpBookmarks[i];
continue;
}
// This throws, so we need the try/catch around it
CDistributedBookmark bmk( rgcbBookmarks[i],
rgpBookmarks[i],
_rowset._cbBookmark,
_rowset._cChild );
BYTE const * pBmk = bmk.Get();
DBBKMARK cbBmk = bmk.GetSize();
DBHASHVALUE hash;
ULONG cErrs = 0;
DBROWSTATUS * pErr = 0;
sc = Get(bmk.Index())->Hash( 0, 1, &cbBmk, &pBmk, &hash,
(rgRowStatus == 0) ? 0 : &rgRowStatus[i]
);
if ( FAILED(sc) )
{
continue; // continue processing other bookmarks
}
rgHashedValues[i] = hash % partition + partition * bmk.Index();
cSuccessfulHashes++;
}
}
CATCH( CException, e )
{
sc = e.GetErrorCode();
vqDebugOut(( DEB_ERROR, "CScrollableSorted::Hash caught exception 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_IRowsetLocate);
if (cSuccessfulHashes == cBookmarks)
return S_OK;
if (cSuccessfulHashes > 0) // and not all bookmarks were successfully processed
sc = DB_S_ERRORSOCCURRED;
else // no hashes were successfully processed
sc = DB_E_ERRORSOCCURRED;
return _DBErrorObj.PostHResult(sc, IID_IRowsetLocate);
}
//
// IRowsetScroll methods
//
//+---------------------------------------------------------------------------
//
// Member: CScrollableSorted::GetApproximatePosition, public
//
// Synopsis: Determine approximate position of bookmark.
//
// Arguments: [hChapter] -- Chapter.
// [cbBookmark] -- Size of [pBookmark]
// [pBookmark] -- Bookmark of starting fetch position.
// [pulPosition] -- Approximate offset from beginning returned
// here.
// [pulRows] -- Approximate count of rows in table
// returned here.
//
// History: 03-Apr-95 KyleP Created.
//
// Notes: Need to have Ole DB error handling here because an exception
// could result in a local error.
//
//----------------------------------------------------------------------------
STDMETHODIMP CScrollableSorted::GetApproximatePosition( HCHAPTER hChapter,
DBBKMARK cbBookmark,
const BYTE * pBookmark,
DBCOUNTITEM * pulPosition,
DBCOUNTITEM * pulRows )
{
_DBErrorObj.ClearErrorInfo();
SCODE sc = S_OK;
Win4Assert( 0 == hChapter && "Chapter support not yet implemented" );
if (cbBookmark !=0 && 0 == pBookmark )
{
vqDebugOut((DEB_IERROR,
"CScrollableSorted::GetApproximatePosition: Invalid Argument(s)\n"));
return _DBErrorObj.PostHResult(E_INVALIDARG, IID_IRowsetScroll);
}
TRY
{
CDistributedBookmark bmk( cbBookmark,
(BYTE const *)pBookmark,
_rowset._cbBookmark,
_rowset._cChild );
if ( 0 != pulPosition )
*pulPosition = 0;
if ( 0 != pulRows )
*pulRows = 0;
DBCOUNTITEM ulTotalRows = 0;
DBCOUNTITEM ulValidRows = 0;
unsigned cValidBmk = 0;
for ( unsigned i = 0; i < _rowset._cChild; i++ )
{
DBCOUNTITEM ulPosition = 0;
DBCOUNTITEM ulRows;
BOOL fValid;
DBBKMARK cb;
if ( bmk.IsValid( i ) )
{
cValidBmk++;
fValid = TRUE;
cb = bmk.GetSize();
}
else
{
fValid = FALSE;
cb = 0;
}
sc = Get(i)->GetApproximatePosition( hChapter,
cb,
bmk.Get(i),
(0 == pulPosition) ? 0 : &ulPosition,
&ulRows );
if ( FAILED(sc) )
{
vqDebugOut(( DEB_ERROR,
"CScrollableSorted: GetApproximatePosition(%u) returned 0x%x\n",
i, sc ));
break;
}
if ( 0 != pulPosition )
{
Win4Assert( ulPosition <= ulRows );
*pulPosition += fValid ? ulPosition : ulRows; // If not valid bookmark,
// assume its at end
}
ulTotalRows += ulRows;
if ( fValid )
ulValidRows += ulRows;
}
if ( pulPosition && cValidBmk > 1 )
{
*pulPosition -= ( cValidBmk - 1 );
}
//
// Special cases (speced in doc)
//
if ( cbBookmark == 1 && *(BYTE *)pBookmark == DBBMK_FIRST && 0 != pulPosition )
*pulPosition = 1;
else if ( cbBookmark == 1 && *(BYTE *)pBookmark == DBBMK_LAST && 0 != pulPosition )
*pulPosition = ulTotalRows;
//else if ( 0 != pulPosition && cValidBmk < _rowset._cChild )
//{
// *pulPosition += *pulPosition * (ulTotalRows - ulValidRows) / ulValidRows;
//}
if ( 0 != pulRows )
*pulRows = ulTotalRows;
}
CATCH( CException, e )
{
sc = e.GetErrorCode();
vqDebugOut(( DEB_ERROR,
"CScrollableSorted::GetApproximatePosition caught exception 0x%x\n", sc ));
}
END_CATCH
if (FAILED(sc))
_DBErrorObj.PostHResult(sc, IID_IRowsetScroll);
return sc;
}
//+---------------------------------------------------------------------------
//
// Member: CScrollableSorted::GetExactPosition, public
//
// Synopsis: Returns the exact position of a bookmark
//
// Arguments: [hChapter] -- chapter
// [cbBookmark] -- size of bookmark
// [pBookmark] -- bookmark
// [pulPosition] -- return approx row number of bookmark
// [pulRows] -- returns approx # of rows in cursor or
// 1 + approx rows if not at quiescence
//
// Returns: SCODE - the status of the operation.
//
// Notes: We don't distinguish between exact and approximate position.
// IRowsetExactScroll is implemented only because ADO 1.5
// started QI'ing for it.
//
//--------------------------------------------------------------------------
STDMETHODIMP CScrollableSorted::GetExactPosition(
HCHAPTER hChapter,
DBBKMARK cbBookmark,
const BYTE * pBookmark,
DBCOUNTITEM * pulPosition,
DBCOUNTITEM * pulRows) /*const*/
{
return GetApproximatePosition( hChapter,
cbBookmark,
pBookmark,
pulPosition,
pulRows );
}
//+---------------------------------------------------------------------------
//
// Member: CScrollableSorted::GetRowsAtRatio, public
//
// Synopsis: Fetch rows from approximate position.
//
// Arguments: [hRegion] -- Watch region
// Arguments: [hChapter] -- Chapter.
// [ulNumerator] -- Numerator of position.
// [ulDenominator] -- Denominator of position.
// [cRows] -- Count of rows requested
// [pcRowsObtained] -- Count of rows in [rrghRows] returned here.
// [rrghRows] -- HROWs returned here.
//
// History: 03-Apr-95 KyleP Created.
//
// Notes: Need to have Ole DB error handling here because an exception
// could result in a local error.
//
//----------------------------------------------------------------------------
STDMETHODIMP CScrollableSorted::GetRowsAtRatio( HWATCHREGION hRegion,
HCHAPTER hChapter,
DBCOUNTITEM ulNumerator,
DBCOUNTITEM ulDenominator,
DBROWCOUNT cRows,
DBCOUNTITEM * pcRowsObtained,
HROW ** rrghRows )
{
_DBErrorObj.ClearErrorInfo();
SCODE sc = S_OK;
BOOL fAllocated = FALSE;
Win4Assert( 0 == hChapter && "Chapter support not yet implemented" );
if (0 == pcRowsObtained || 0 == rrghRows )
{
vqDebugOut((DEB_IERROR, "CScrollableSorted::GetRowsAtRatio: Invalid Argument(s)"));
return _DBErrorObj.PostHResult(E_INVALIDARG, IID_IRowsetScroll);
}
TRY
{
*pcRowsObtained = 0;
fAllocated = SetupFetch( cRows, rrghRows );
//
// Seek to position. Special cases are beginning and end of rowset.
//
Seek( ulNumerator, ulDenominator );
sc = StandardFetch( cRows, pcRowsObtained, *rrghRows );
if ( SUCCEEDED( sc ) &&
!_rowset._xChildNotify.IsNull() &&
*pcRowsObtained != 0 )
{
_rowset._xChildNotify->OnRowChange( *pcRowsObtained,
*rrghRows,
DBREASON_ROW_ACTIVATE,
DBEVENTPHASE_DIDEVENT,
TRUE);
}
}
CATCH( CException, e )
{
sc = e.GetErrorCode();
vqDebugOut(( DEB_ERROR, "CScrollableSorted::GetRowsAtRatio: Exception 0x%x\n", sc ));
//
// If we already have some rows, then we can't 'unfetch' them, so we have
// to mask this error. Presumably it won't be transient and we'll get it
// again later.
//
if ( *pcRowsObtained > 0 )
{
if (FAILED(sc))
sc = DB_S_ROWLIMITEXCEEDED;
}
else if ( fAllocated )
{
CoTaskMemFree( *rrghRows );
*rrghRows = 0;
}
}
END_CATCH
if (FAILED(sc))
_DBErrorObj.PostHResult(sc, IID_IRowsetScroll);
return( sc );
}
//+---------------------------------------------------------------------------
//
// Member: CScrollableSorted::CScrollableSorted, public
//
// Synopsis: Initialize rowset.
//
// Arguments: [pUnkOuter] -- outer unknown
// [ppMyUnk] -- OUT: on return, filled with pointer to my
// non-delegating IUnknown
// [aChild] -- Array of child cursors (rowsets).
// [cChild] -- Count of elements in [aChild].
// [Props] -- Rowset properties.
// [cCol] -- Number of original columns.
// [Sort] -- Sort specification.
//
// History: 03-Apr-95 KyleP Created.
//
//----------------------------------------------------------------------------
CScrollableSorted::CScrollableSorted( IUnknown * pUnkOuter,
IUnknown ** ppMyUnk,
IRowsetScroll ** aChild,
unsigned cChild,
CMRowsetProps const & Props,
unsigned cCol,
CSort const & Sort,
CAccessorBag & aAccessors ) :
_rowset( 0, ppMyUnk,
(IRowset **)aChild, cChild, Props, cCol + 1, // Add 1 col. for bookmark
Sort, aAccessors ),
_apPosCursor(cChild),
_heap( cChild ),
#pragma warning(disable : 4355) // 'this' in a constructor
_impIUnknown(this),
_DBErrorObj( * ((IUnknown *) (IRowset *) this), _mutex )
#pragma warning(default : 4355) // 'this' in a constructor
{
unsigned iChild = 0;
TRY
{
_DBErrorObj.SetInterfaceArray(cRowsetErrorIFs, apRowsetErrorIFs);
_rowset._RowManager.TrackSiblings( cChild );
if (pUnkOuter)
_pControllingUnknown = pUnkOuter;
else
_pControllingUnknown = (IUnknown * )&_impIUnknown;
//
// Create accessors
//
for ( ; iChild < _rowset._cChild; iChild++ )
{
_apPosCursor[iChild] = new CMiniPositionableCache( iChild,
Get(iChild),
Sort.Count(),
_rowset._bindSort.GetPointer(),
_rowset._cbSort,
_rowset._iColumnBookmark,
_rowset._cbBookmark );
}
//
// Initialize heap
//
_heap.Init( &_rowset._Comparator, GetCacheArray() );
*ppMyUnk = ((IUnknown *)&_impIUnknown);
(*ppMyUnk)->AddRef();
}
CATCH( CException, e )
{
long lChild = iChild;
for ( lChild--; lChild >= 0; lChild-- )
delete _apPosCursor[lChild];
RETHROW();
}
END_CATCH
END_CONSTRUCTION( CScrollableSorted );
}
//+---------------------------------------------------------------------------
//
// Member: CScrollableSorted::~CScrollableSorted, private
//
// Synopsis: Destructor.
//
// History: 03-Apr-95 KyleP Created.
//
//----------------------------------------------------------------------------
CScrollableSorted::~CScrollableSorted()
{
unsigned ii;
for ( ii = _rowset._cChild ; ii > 0; ii-- )
{
delete _apPosCursor[ii-1];
}
}
//+---------------------------------------------------------------------------
//
// Member: CScrollableSorted::_GetMaxPrevRowChild, private
//
// Synopsis: From all the child cursors, return the index which has the
// max. prev. row. If none of the cursor has a prev. row (they are
// all at the top), the index returned is the total no. of cursors.
//
// Arguments: none
//
// History: 10-Sep-98 VikasMan Created.
//
//----------------------------------------------------------------------------
unsigned CScrollableSorted::_GetMaxPrevRowChild()
{
unsigned iMaxRowChild = _rowset._cChild;
unsigned iChild;
BYTE * pMaxPrevData;
BYTE * pPrevData;
for ( iChild = 0; iChild < _rowset._cChild; iChild++ )
{
pMaxPrevData = _apPosCursor[iChild]->GetPrevData();
if ( pMaxPrevData )
{
iMaxRowChild = iChild;
break;
}
}
for ( iChild++; iChild < _rowset._cChild; iChild++ )
{
pPrevData = _apPosCursor[iChild]->GetPrevData();
if ( pPrevData )
{
if ( _rowset._Comparator.IsLT(
pMaxPrevData,
_apPosCursor[iMaxRowChild]->DataLength(),
_apPosCursor[iMaxRowChild]->Index(),
pPrevData,
_apPosCursor[iChild]->DataLength(),
_apPosCursor[iChild]->Index() ) )
{
iMaxRowChild = iChild;
pMaxPrevData = pPrevData;
}
}
}
return iMaxRowChild;
}
//+---------------------------------------------------------------------------
//
// Member: CScrollableSorted::Seek, private
//
// Synopsis: Position heap to specified bookmark + offset.
//
// Arguments: [cbBookmark] -- Size of [pbBookmark].
// [pbBookmark] -- Bookmark.
// [lOffset] -- Offset from bookmark.
//
// History: 03-Apr-95 KyleP Created.
//
//----------------------------------------------------------------------------
SCODE CScrollableSorted::Seek( DBBKMARK cbBookmark, BYTE const * pbBookmark, DBROWOFFSET lOffset )
{
unsigned cValid = _rowset._cChild;
unsigned i;
SCODE sc = S_OK;
//
// Special case: Beginning of table
//
if ( cbBookmark == 1 && *pbBookmark == DBBMK_FIRST )
{
//
// Seek all cursors to beginning of table.
//
for ( i = 0; i < cValid; i++ )
_apPosCursor[ i ]->Seek( cbBookmark, pbBookmark );
}
else if (cbBookmark == 1 && *pbBookmark == DBBMK_LAST)
{
//
// First Seek all cursors to end of table.
//
for ( i = 0; i < cValid; i++ )
_apPosCursor[ i ]->Seek( cbBookmark, pbBookmark );
for ( i = 0; i < cValid; i++ )
{
if ( _apPosCursor[i]->IsAtEnd() )
{
_apPosCursor[i]->Seek(1); // pushes it beyond the end
//
// Move unseekable cursor to end of array.
//
cValid--;
SwapCursor(i, cValid);
i--;
}
}
// Find the cursor with the maximum value
unsigned iCurWithMaxVal = 0;
for (i = 1; i < cValid; i++)
{
if ( _rowset._Comparator.IsLT( _apPosCursor[iCurWithMaxVal]-> GetData(),
_apPosCursor[iCurWithMaxVal]->DataLength(),
_apPosCursor[iCurWithMaxVal]->Index(),
_apPosCursor[i]->GetData(),
_apPosCursor[i]->DataLength(),
_apPosCursor[i]->Index() )
)
iCurWithMaxVal = i;
}
// Now set all cursors except _apPosCursor[iCurWithMaxVal] to end of table
for (i = 0; i < cValid; i++)
if (i != iCurWithMaxVal)
_apPosCursor[i]->Seek(1); // pushes it beyond the end
}
else
{
CDistributedBookmark bmk( cbBookmark,
pbBookmark,
_rowset._cbBookmark,
_rowset._cChild );
//
// Seek target cursor. We have to do this one first.
//
for ( unsigned iTarget = 0; iTarget < _rowset._cChild; iTarget++ )
{
if ( _apPosCursor[iTarget]->Index() == (int)bmk.Index() )
{
_apPosCursor[ iTarget ]->Seek( bmk.GetSize(), bmk.Get() );
break;
}
}
//
// Seek child cursor(s), other than target.
//
for ( i = 0; i < cValid; i++ )
{
//
// Ignore target cursor
//
if ( i == iTarget )
continue;
//
// Seek to 'hint' position.
//
_apPosCursor[i]->FlushCache();
_apPosCursor[i]->SetCacheSize( 1 );
PMiniRowCache::ENext next;
if ( bmk.IsValid( _apPosCursor[i]->Index() ) )
next = _apPosCursor[i]->Seek( bmk.GetSize(), bmk.Get( _apPosCursor[i]->Index() ) );
else
{
BYTE bStart = DBBMK_FIRST;
next = _apPosCursor[i]->Seek( sizeof(bStart), &bStart );
}
//
// And adjust so that the cursor is positioned just after the target cursor.
//
if ( next != PMiniRowCache::Ok ||
AdjustPosition( i, iTarget ) != PMiniRowCache::Ok )
{
BYTE bEnd = DBBMK_LAST;
_apPosCursor[i]->Seek( sizeof(bEnd), &bEnd );
_apPosCursor[i]->Seek(1); // pushes it beyond the end
//
// Move unseekable cursor to end of array.
//
cValid--;
SwapCursor(i, cValid);
if ( cValid == iTarget )
{
iTarget = i;
}
i--;
}
}
}
for ( i = 0; i<cValid; i++ )
{
if ( _apPosCursor[i]->IsAtEnd() )
{
_apPosCursor[i]->Seek(1); // pushes it beyond the end
//
// Move unseekable cursor to end of array.
//
cValid--;
SwapCursor(i, cValid);
i--;
}
}
_heap.ReInit( cValid );
if ( lOffset < 0 )
{
cValid = _rowset._cChild;
// Load Previous rows from all valid
for ( i = 0; i < cValid; i++ )
{
_apPosCursor[i]->LoadPrevRowData();
}
unsigned iMaxRowChild;
BOOL fReInit = FALSE;
for( ;; )
{
// Find out which rowset has the max. prev. row
iMaxRowChild = _GetMaxPrevRowChild();
if ( iMaxRowChild >= _rowset._cChild )
{
break;
// no previous row
}
fReInit = TRUE;
// Move the rowset with the max. prev. row back
_apPosCursor[iMaxRowChild]->MovePrev();
if ( 0 == ++lOffset )
{
break;
}
// Reload prev. row for the rowset which we moved back
_apPosCursor[iMaxRowChild]->LoadPrevRowData();
}
if ( fReInit)
{
for ( i = 0; i<cValid; i++ )
{
if ( _apPosCursor[i]->IsAtEnd() )
{
_apPosCursor[i]->Seek(1); // pushes it beyond the end
//
// Move unseekable cursor to end of array.
//
cValid--;
SwapCursor(i, cValid);
i--;
}
}
_heap.ReInit( cValid );
}
if ( lOffset < 0 )
{
// NTRAID#DB-NTBUG9-84055-2000/07/31-dlee Failed distribued query row fetches don't restore previous seek position
// Do we need to reset the position of rowset back to
// where it was before call to Seek ?
sc = DB_E_BADSTARTPOSITION;
}
}
else
{
for ( ; lOffset > 0; lOffset-- )
{
//
// Release top HROW.
//
HROW hrow = _heap.Top()->GetHROW();
SCODE sc2 = Get( _heap.Top()->Index() )->ReleaseRows( 1, &hrow, 0, 0, 0 );
Win4Assert( SUCCEEDED(sc2) );
PMiniRowCache::ENext next = _heap.Next();
Win4Assert( PMiniRowCache::NotNow != next );
if ( PMiniRowCache::EndOfRows == next )
break;
}
}
return sc;
}
//+---------------------------------------------------------------------------
//
// Member: CScrollableSorted::AdjustPosition, private
//
// Synopsis: Adjust position of iChild-th cursor to just after the
// iTarget-th cursor.
//
// Arguments: [iChild] -- Index of child in _apPosCursor.
// [iTarget] -- Index of target in _apPosCursor.
//
// Returns: Seek result.
//
// History: 03-Apr-95 KyleP Created.
//
//----------------------------------------------------------------------------
PMiniRowCache::ENext CScrollableSorted::AdjustPosition( unsigned iChild, int iTarget )
{
vqDebugOut(( DEB_ITRACE, "Child: %d data = 0x%x, size = %u\n",
_apPosCursor[iChild]->Index(),
_apPosCursor[iChild]-> GetData(),
_apPosCursor[iChild]->DataLength() ));
vqDebugOut(( DEB_ITRACE, "Target: %d data = 0x%x, size = %u\n",
_apPosCursor[iTarget]->Index(),
_apPosCursor[iTarget]-> GetData(),
_apPosCursor[iTarget]->DataLength() ));
PMiniRowCache::ENext next; // Used to report error states.
int iJump; // Seek offset (positive or negative) from starting point.
int iNextInc; // Next seek increment.
int iDirection; // Direction of seek from initial position to target.
if ( _rowset._Comparator.IsLT( _apPosCursor[iTarget]-> GetData(),
_apPosCursor[iTarget]->DataLength(),
_apPosCursor[iTarget]->Index(),
_apPosCursor[iChild]->GetData(),
_apPosCursor[iChild]->DataLength(),
_apPosCursor[iChild]->Index() ) )
{
next = InitialSeek( iChild, iTarget, -1, iJump, iNextInc, iDirection );
//
// Running into end (actually beginning) here is ok.
//
if ( next == PMiniRowCache::EndOfRows )
return PMiniRowCache::Ok;
}
else
next = InitialSeek( iChild, iTarget, 1, iJump, iNextInc, iDirection );
if ( next != PMiniRowCache::Ok )
return next;
//
// At this point, iChild is at least 1 row < iTarget (or 1 row > iTarget).
//
vqDebugOut(( DEB_ITRACE, "Final positioning:\n" ));
while ( iNextInc > 0 )
{
iJump += (iNextInc * iDirection);
vqDebugOut(( DEB_ITRACE, "Backward %d\n", -iJump ));
PMiniRowCache::ENext next = _apPosCursor[iChild]->Seek( iJump );
iNextInc /= 2;
if ( _rowset._Comparator.IsLT( _apPosCursor[iTarget]-> GetData(),
_apPosCursor[iTarget]->DataLength(),
_apPosCursor[iTarget]->Index(),
_apPosCursor[iChild]->GetData(),
_apPosCursor[iChild]->DataLength(),
_apPosCursor[iChild]->Index() ) )
iDirection = -1;
else
iDirection = 1;
}
//
// Either the row we are on is correct, or off by one.
//
if ( _rowset._Comparator.IsLT( _apPosCursor[iChild]-> GetData(),
_apPosCursor[iChild]->DataLength(),
_apPosCursor[iChild]->Index(),
_apPosCursor[iTarget]->GetData(),
_apPosCursor[iTarget]->DataLength(),
_apPosCursor[iTarget]->Index() ) )
return _apPosCursor[iChild]->Seek( iJump + 1 );
else
return PMiniRowCache::Ok;
}
//+---------------------------------------------------------------------------
//
// Member: CScrollableSorted::InitialSeek, private
//
// Synopsis: Worker routine for AdjustPosition. Binary searches until
// iChild is at least one row on the opposite side of iTarget
// from where it started.
//
// Arguments: [iChild] -- Index of child in _apPosCursor.
// [iTarget] -- Index of target in _apPosCursor.
// [InitialDirection] -- Direction to start moving.
// [iJump] -- Offset from starting point returned
// here.
// [iNextInc] -- Size of last jump returned here.
// [iDirection] -- Direction of last jump returned here.
//
// Returns: Seek result.
//
// History: 03-Apr-95 KyleP Created.
//
//----------------------------------------------------------------------------
PMiniRowCache::ENext CScrollableSorted::InitialSeek( unsigned iChild,
int iTarget,
int InitialDirection,
int & iJump,
int & iNextInc,
int & iDirection )
{
//
// If the child starts out > target, then go backward until we pass
// the target, and then forward until *just* after target, otherwise
// do the opposite. The goal is to go a known distance past the target
// so we can seek back towards it logarithmically.
//
iJump = 1 * InitialDirection;
iNextInc = 1 * InitialDirection;
int LTa;
int LTb;
if ( InitialDirection == 1 )
{
LTa = iChild;
LTb = iTarget;
}
else
{
LTa = iTarget;
LTb = iChild;
}
vqDebugOut(( DEB_ITRACE, "Initial positioning:\n" ));
PMiniRowCache::ENext next = PMiniRowCache::EndOfRows;
while ( iNextInc != 0 )
{
do
{
vqDebugOut(( DEB_ITRACE, "%s %u\n", iJump < 0 ? "Backward" : "Forward",
iJump < 0 ? -iJump : iJump ));
next = _apPosCursor[iChild]->Seek( iJump );
if ( 0 == iNextInc )
{
Win4Assert( next != PMiniRowCache::EndOfRows );
next = PMiniRowCache::EndOfRows;
break;
}
switch ( next )
{
case PMiniRowCache::Ok:
iNextInc *= 2;
break;
case PMiniRowCache::EndOfRows:
iJump -= iNextInc;
iNextInc /= 2;
iJump += iNextInc;
break;
default:
return next;
}
} while ( next == PMiniRowCache::EndOfRows );
Win4Assert( iJump * InitialDirection >= 0 );
//if ( iJump * InitialDirection > 0 &&
if ( iJump != 0 &&
_rowset._Comparator.IsLT( _apPosCursor[LTa]-> GetData(),
_apPosCursor[LTa]->DataLength(),
_apPosCursor[LTa]->Index(),
_apPosCursor[LTb]->GetData(),
_apPosCursor[LTb]->DataLength(),
_apPosCursor[LTb]->Index() ) )
iJump += iNextInc;
else
break;
}
iNextInc = ((iJump*InitialDirection) / 2) + 1;
iDirection = -InitialDirection;
return next;
}
//+---------------------------------------------------------------------------
//
// Member: CScrollableSorted::Seek, private
//
// Synopsis: Position heap to approximate position.
//
// Arguments: [ulNumerator] -- Numerator.
// [ulDenominator] -- Denominator.
//
// History: 03-Apr-95 KyleP Created.
//
//----------------------------------------------------------------------------
void CScrollableSorted::Seek( DBCOUNTITEM ulNumerator, DBCOUNTITEM ulDenominator )
{
unsigned cValid = _rowset._cChild;
//
// Special case: Beginning of table
//
if ( 0 == ulNumerator )
{
//
// Seek all cursors to beginning of table.
//
BYTE bmkStart = DBBMK_FIRST;
for ( unsigned i = 0; i < _rowset._cChild; i++ )
_apPosCursor[ i ]->Seek( sizeof(bmkStart), &bmkStart );
_heap.ReInit( cValid );
}
//
// Special case: End of table
//
else if ( ulNumerator == ulDenominator )
{
//
// Seek all cursors to end of table.
//
BYTE bmkEnd = DBBMK_LAST;
for ( unsigned i = 0; i < _rowset._cChild; i++ )
_apPosCursor[ i ]->Seek( sizeof(bmkEnd), &bmkEnd );
_heap.ReInit( cValid );
}
//
// Normal case: Middle of table
//
else
{
//
// Seek all cursors to ratio.
//
// Get the total # of rows
DBCOUNTITEM ulRows = 0;
SCODE sc = GetApproximatePosition( NULL,
0,
NULL,
NULL,
&ulRows );
if ( SUCCEEDED (sc ) && ulRows > 0 )
{
DBROWOFFSET lSeekPos = (( ulNumerator * ulRows ) / ulDenominator );
BYTE bmk;
if ( (lSeekPos * 100 / ulRows) > 50 )
{
// seek from bottom
bmk = DBBMK_LAST;
lSeekPos = lSeekPos - (LONG) ulRows + 1;
}
else
{
// seek from top
bmk = DBBMK_FIRST;
}
sc = Seek( sizeof(bmk), &bmk, lSeekPos );
}
#if 0
for ( unsigned i = 0; i < _rowset._cChild; i++ )
{
_apPosCursor[ i ]->FlushCache();
_apPosCursor[ i ]->SetCacheSize( 1 );
_apPosCursor[ i ]->Seek( ulNumerator, ulDenominator );
}
//
// Heapify, then pick the cursor ulNumerator / ulDenominator from
// top of the heap.
//
_heap.ReInit( _rowset._cChild );
_heap.NthToTop( _rowset._cChild * ulNumerator / ulDenominator );
unsigned iTarget = 0;
//
// Adjust position of all other cursors to follow target.
//
for ( i = 0; i < cValid; i++ )
{
//
// Ignore target cursor
//
if ( i == iTarget )
continue;
if ( AdjustPosition( i, iTarget ) != PMiniRowCache::Ok )
{
//
// Move unseekable cursor to end of array.
//
cValid--;
SwapCursor(i, cValid);
i--;
}
}
#endif
}
}
//+---------------------------------------------------------------------------
//
// Member: CScrollableSorted::SetupFetch, private
//
// Synopsis: Common operations before seek in Get* routines.
//
// Arguments: [cRows] -- Number of rows requested.
// [rrghRows] -- Rows returned here. May have to allocate.
//
// Returns: TRUE if *rrghRows was allocated.
//
// History: 03-Apr-95 KyleP Created.
//
//----------------------------------------------------------------------------
BOOL CScrollableSorted::SetupFetch( DBROWCOUNT cRows, HROW * rrghRows[] )
{
//
// We may have reached some temporary condition such as
// DB_S_ROWLIMITEXCEEDED on the last pass. Iterate until we
// have a valid heap.
//
PMiniRowCache::ENext next = _heap.Validate();
if ( next == PMiniRowCache::NotNow )
{
THROW( CException( DB_E_ROWLIMITEXCEEDED ) );
}
//
// We may have to allocate memory, if the caller didn't.
//
BOOL fAllocated = FALSE;
if ( 0 == *rrghRows )
{
*rrghRows = (HROW *)CoTaskMemAlloc( (ULONG) ( abs(((LONG) cRows)) * sizeof(HROW) ) );
fAllocated = TRUE;
}
if ( 0 == *rrghRows )
{
vqDebugOut(( DEB_ERROR, "CScrollableSorted::SetupFetch: Out of memory.\n" ));
THROW( CException( E_OUTOFMEMORY ) );
}
return fAllocated;
}
//+---------------------------------------------------------------------------
//
// Member: CScrollableSorted::SetupFetch, private
//
// Synopsis: Common operations before seek in Get* routines.
//
// Arguments: [cRows] -- Number of rows requested.
// [pcRowsObtained] -- Count actually fetched.
// [rghRows] -- Rows returned here. Already allocated
// if needed.
//
// Returns: Status code.
//
// History: 03-Apr-95 KyleP Created.
//
//----------------------------------------------------------------------------
SCODE CScrollableSorted::StandardFetch( DBROWCOUNT cRows,
DBCOUNTITEM * pcRowsObtained,
HROW rghRows[] )
{
SCODE sc = S_OK;
int iDir = 1;
if ( cRows < 0 )
{
cRows = -cRows;
iDir = -1;
}
unsigned ucRows = (unsigned) cRows;
//
// Adjust cache size if necessary.
//
_heap.AdjustCacheSize( ucRows );
//
// Fetch from top of heap.
//
while ( *pcRowsObtained < ucRows )
{
//
// We may be entirely out of rows.
//
if ( _heap.IsHeapEmpty() )
{
sc = DB_S_ENDOFROWSET;
break;
}
(rghRows)[*pcRowsObtained] =
_rowset._RowManager.Add( _heap.Top()->Index(),
_heap.TopHROWs() );
(*pcRowsObtained)++;
//
// Fetch the next row.
//
PMiniRowCache::ENext next = _heap.Next( iDir );
if ( CMiniRowCache::NotNow == next )
{
sc = DB_S_ROWLIMITEXCEEDED;
break;
}
}
return sc;
}
//+---------------------------------------------------------------------------
//
// Member: CScrollableSorted::RatioFinished, public
//
// Synopsis: Ratio finished for asynchronously populated rowsets.
//
// Arguments: [pulDenominator] -- Denominator returned here.
// [pulNumerator] -- Numerator returned here.
// [pcRows] -- Count of rows returned here
// [pfNewRows] -- TRUE if rows added since last call.
//
// History: 03-Apr-95 KyleP Created.
//
// Notes: Need to have Ole DB error handling here because an exception
// could result in a local error.
//
//----------------------------------------------------------------------------
STDMETHODIMP CScrollableSorted::RatioFinished( DBCOUNTITEM * pulDenominator,
DBCOUNTITEM * pulNumerator,
DBCOUNTITEM * pcRows,
BOOL * pfNewRows )
{
_DBErrorObj.ClearErrorInfo();
IRowsetAsynch * pra = 0;
SCODE scResult = S_OK;
*pulDenominator = 0;
*pulNumerator = 0;
*pcRows = 0;
*pfNewRows = FALSE;
for ( unsigned iChild = 0; iChild < _rowset._cChild; iChild++ )
{
DBCOUNTITEM ulDenom;
DBCOUNTITEM ulNum;
DBCOUNTITEM cRows;
BOOL fNew;
SCODE sc = Get(iChild)->QueryInterface( IID_IRowsetAsynch, (void **) &pra );
if ( SUCCEEDED(sc) )
{
sc = pra->RatioFinished( &ulDenom, &ulNum, &cRows, &fNew );
pra->Release();
}
if ( FAILED(sc) && E_NOTIMPL != sc && E_NOINTERFACE != sc )
{
vqDebugOut(( DEB_ERROR,
"IRowsetAsynch::RatioFinished(child %d) returned 0x%x\n",
iChild, sc ));
scResult = sc;
break;
}
if ( SUCCEEDED(sc) )
{
Win4Assert( *pulDenominator + ulDenom > *pulDenominator );
*pulDenominator += ulDenom;
*pulNumerator += ulNum;
*pcRows += cRows;
*pfNewRows = *pfNewRows || fNew;
}
}
if ( 0 == *pulDenominator )
scResult = E_NOTIMPL;
if (FAILED(scResult))
_DBErrorObj.PostHResult(scResult, IID_IRowsetAsynch);
return( scResult );
}
//+---------------------------------------------------------------------------
//
// Member: CScrollableSorted::Stop, public
//
// Synopsis: Stop population of asynchronously populated rowsets.
//
// Arguments: - None -
//
// History: 16 Jun 95 Alanw Created.
//
// Notes: Need to have Ole DB error handling here because errors are
// being translated.
//
//----------------------------------------------------------------------------
STDMETHODIMP CScrollableSorted::Stop( )
{
_DBErrorObj.ClearErrorInfo();
IRowsetAsynch * pra = 0;
SCODE scResult = S_OK;
for ( unsigned iChild = 0; iChild < _rowset._cChild; iChild++ )
{
SCODE sc = Get(iChild)->QueryInterface( IID_IRowsetAsynch,
(void **) &pra );
if ( SUCCEEDED(sc) )
{
sc = pra->Stop( );
pra->Release();
}
if ( FAILED(sc) && (S_OK == scResult ||
E_NOTIMPL != sc ||
E_NOINTERFACE != sc))
{
vqDebugOut(( DEB_ERROR,
"IRowsetAsynch::Stop (child %d) returned 0x%x\n",
iChild, sc ));
scResult = sc;
}
}
if (FAILED(scResult))
_DBErrorObj.PostHResult(scResult, IID_IRowsetAsynch);
return( scResult );
}
//
// IDbAsynchStatus methods
//
//+---------------------------------------------------------------------------
//
// Member: CScrollableSorted::Abort, public
//
// Synopsis: Cancels an asynchronously executing operation.
//
// Arguments: [hChapter] -- chapter which should restart
// [ulOperation] -- operation for which status is being requested
//
// Returns: SCODE error code
//
// History: 03 Sep 1998 VikasMan Created
//
//----------------------------------------------------------------------------
STDMETHODIMP CScrollableSorted::Abort(
HCHAPTER hChapter,
ULONG ulOperation )
{
_DBErrorObj.ClearErrorInfo();
SCODE scResult = S_OK;
XInterface<IDBAsynchStatus> xIDBAsynchStatus;
for ( unsigned iChild = 0; iChild < _rowset._cChild; iChild++ )
{
SCODE sc = Get(iChild)->QueryInterface( IID_IDBAsynchStatus,
xIDBAsynchStatus.GetQIPointer() );
if ( SUCCEEDED( sc ) )
{
sc = xIDBAsynchStatus->Abort( hChapter, ulOperation );
if ( S_OK == scResult )
{
scResult = sc;
}
}
xIDBAsynchStatus.Free();
}
return scResult;
}
//+---------------------------------------------------------------------------
//
// Member: CScrollableSorted::GetStatus, public
//
// Synopsis: Returns the status of an asynchronously executing operation.
//
// Arguments: [hChapter] -- chapter which should restart
// [ulOperation] -- operation for which status is being requested
//
// Returns: SCODE error code
//
// History: 03 Sep 1998 VikasMan Created
//
//----------------------------------------------------------------------------
STDMETHODIMP CScrollableSorted::GetStatus(
HCHAPTER hChapter,
DBASYNCHOP ulOperation,
DBCOUNTITEM * pulProgress,
DBCOUNTITEM * pulProgressMax,
DBASYNCHPHASE * pulAsynchPhase,
LPOLESTR * ppwszStatusText )
{
_DBErrorObj.ClearErrorInfo();
SCODE scResult = S_OK;
XInterface<IDBAsynchStatus> xIDBAsynchStatus;
if ( pulProgress )
*pulProgress = 0;
if ( pulProgressMax )
*pulProgressMax = 0;
if ( pulAsynchPhase )
*pulAsynchPhase = DBASYNCHPHASE_COMPLETE;
if ( ppwszStatusText )
*ppwszStatusText = 0;
XCoMem<OLECHAR> xStatusText;
double dRatio = 0;
for ( unsigned iChild = 0; iChild < _rowset._cChild; iChild++ )
{
SCODE sc = Get(iChild)->QueryInterface( IID_IDBAsynchStatus,
xIDBAsynchStatus.GetQIPointer() );
if ( SUCCEEDED( sc ) )
{
DBCOUNTITEM ulProgress, ulProgressMax;
DBASYNCHPHASE ulAsynchPhase;
scResult = xIDBAsynchStatus->GetStatus ( hChapter,
ulOperation,
&ulProgress,
&ulProgressMax,
&ulAsynchPhase,
0 == iChild ?
ppwszStatusText : 0 );
if ( S_OK != scResult )
{
return scResult;
}
if ( 0 == iChild && ppwszStatusText )
{
xStatusText.Set( *ppwszStatusText );
}
if ( ulProgressMax )
{
dRatio += ( (double)ulProgress / (double)ulProgressMax );
}
if ( pulAsynchPhase && *pulAsynchPhase != DBASYNCHPHASE_POPULATION )
*pulAsynchPhase = ulAsynchPhase;
}
xIDBAsynchStatus.Free();
}
DWORD dwNum = 0;
DWORD dwDen = 0;
if ( dRatio )
{
Win4Assert( _rowset._cChild );
dRatio /= _rowset._cChild;
dwDen = 1;
while ( dRatio < 1.0 )
{
dRatio *= 10;
dwDen *= 10;
}
dwNum = (DWORD)dRatio;
}
if ( pulProgress )
*pulProgress = dwNum;
if ( pulProgressMax )
*pulProgressMax = dwDen;
if ( SUCCEEDED( scResult ) )
{
// Let memory pass thru to the client
xStatusText.Acquire();
}
return scResult;
}
//
// IRowsetWatchRegion methods
//
//+---------------------------------------------------------------------------
//
// Member: CScrollableSorted::Refresh, public
//
// Synopsis: Implementation of IRowsetWatchRegion::Refresh. Calls refresh on
// all the child rowsets
//
// Arguments: pChangesObtained
// prgChanges
//
// Returns: Always returns DB_S_TOOMAYCHANGES
//
// History: 03 Sep 1998 VikasMan Created
//
//----------------------------------------------------------------------------
STDMETHODIMP CScrollableSorted::Refresh(
DBCOUNTITEM* pChangesObtained,
DBROWWATCHCHANGE** prgChanges )
{
_DBErrorObj.ClearErrorInfo();
for ( unsigned iChild = 0; iChild < _rowset._cChild; iChild++ )
{
if ( _rowset._xArrChildRowsetWatchRegion[iChild].GetPointer() )
{
_rowset._xArrChildRowsetWatchRegion[iChild]->Refresh( pChangesObtained, prgChanges );
}
}
*pChangesObtained = 0;
return DB_S_TOOMANYCHANGES;
}