2130 lines
66 KiB
C++
2130 lines
66 KiB
C++
//
|
|
// 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;
|
|
}
|
|
|