windows-xp/Source/XPSP1/NT/ds/adsi/router/crowset.cxx

//-----------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1992 - 1995.
//
//  File:       crowset.cxx
//
//  Contents:   IRowset implementation for ADSI OLEDB provider
//
//--------------------------------------------------------------------------

#include "oleds.hxx"

//-----------------------------------------------------------------------------
// Note on nomenclature
//
// Index - index within the rowset cache.
// 0 <= (Index <= m_cNumRowsCached - 1)
//
// Row - index within the entire rowset (not just the cache).
// 0 <= Row <= #rows in rowset - 1
//
// Bookmark - a unique value associated with each row. Currently, this is the
// same as the row value.
//
// Row handle - handle to a row in the rowset cache that is returned to the
// user. This value has to be unique across all rows currently in the cache
// (rows that the user has a reference on). Although we could use the index
// as this unique value, we will use the row (+1, since 0 == DB_NULL_HROW and
// hence row 0 cannot have a handle of 0). Using the row has the advantage
// that we will be able to detect stale row handles passed in by the user in
// most cases. This would be more difficult with the index as the index can
// be reused.
//
// The rowset cache contains a fixed number of rows, specified by the
// DBPROP_MAXOPENROWS property (if this property is set to 0, the rowset may
// contain as many rows as possble). A row remains in the cache as long as the
// consumer has a reference to the row. A row is removed from the cache when
// its reference count goes to 0, as a result of a call to ReleaseRows. If the
// cache becomes full, subsequent calls to fetch more rows in to the cache will
// return DB_S_ROWLIMITEXCEEDED. The rows in the cache need not be contiguous.
// For example, the consumer might fetch rows 1,2,3 and then call ReleaseRows
// only on 2. In this case, 1 and 3 would still be in the cache. Each row in
// the cache contains its "row" value. Currently, this value is also used as
// the bookmark to the row.
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
// CreateRowset
//
// Creates and initializes a rowset object. Called by a command or session
// object. The rows are brought in only on demand.
//
//-----------------------------------------------------------------------------
HRESULT
CRowset::CreateRowset(
    CRowProvider   *pIRowProvider,  // The Row provider
    IUnknown       *pParentObj,     // parent object, a command or a session
    CSessionObject *pCSession,      // Session Object
    CCommandObject *pCCommand,      // Command Object
    ULONG          cPropertySets,   // # property sets in rowset property group
    DBPROPSET      rgPropertySets[],// properties in rowset property group
    ULONG          cAccessors,      // accessor count
    HACCESSOR      rgAccessors[],   // accessors on command object
    BOOL           fadsPathPresent, // Is ADsPath present in query
    BOOL           fAllAttrs,       // Return all attrs from row object?
    REFIID         riid,            // Interface desired
    IUnknown       **ppIRowset      // pointer to desired interface
    )
{
    HRESULT        hr;
    CRowset        *pCRowset = NULL;
    BOOL           fGotWarning = FALSE, fRowObjRequested;
    DBCOUNTITEM    cRowsObtained;
    HROW           *phRow = NULL;

    if( ppIRowset != NULL)
        *ppIRowset = NULL;

    pCRowset = new CRowset();
    if( NULL == pCRowset )
        BAIL_ON_FAILURE( hr = E_OUTOFMEMORY );

    hr = pCRowset->FInit(
            pIRowProvider,
            pParentObj,
            pCSession,
            pCCommand,
            cPropertySets,
            rgPropertySets,
            cAccessors,
            rgAccessors,
            fadsPathPresent,
            fAllAttrs
            );
    BAIL_ON_FAILURE(hr);
    if( hr != S_OK )
        fGotWarning = TRUE;

    if( ppIRowset != NULL )
    {
#if (!defined(BUILD_FOR_NT40))
        // If the client requested IRow, create a rowset and get a row object
        // off the rowset. Once we make the provider read/write, we should add
        // IRowChange and IRowSchmaChange here in addition to IRow. If the
        // client set the DBPROP_IRow property, then we always create a row
        // object by default.
        hr = pCRowset->IsRowObjRequested(&fRowObjRequested);
        BAIL_ON_FAILURE( hr );

        if( IsEqualIID(riid, IID_IRow) || (fRowObjRequested) )
        {
            hr = pCRowset->GetNextRows(NULL, 0, 1, &cRowsObtained, &phRow);
            BAIL_ON_FAILURE(hr);

            if( DB_S_ENDOFROWSET == hr )
                BAIL_ON_FAILURE( hr = DB_E_NOTFOUND );

            if( hr != S_OK )
                BAIL_ON_FAILURE( E_FAIL );

            ADsAssert( (1 == cRowsObtained ) && (phRow != NULL) &&
                       (*phRow != DB_NULL_HROW) );

            // Bump up reference count of rowset. This is to avoid the
            // destruction of the rowset if the call below fails. Artificially
            // incrementing the reference count by one will ensure that any
            // call to Release() on the rowset (say, from the destructor of
            // the row object) will not end up in the rowset object being
            // deleted.
            pCRowset->m_cRef++;

            hr = pCRowset->m_pCRowsetInfo->GetRowFromHROW(
                         NULL,
                         *phRow,
                         riid,
                         ppIRowset,
                         FALSE, // this is not a tear-off
                         pCRowset->m_fAllAttrs
                         );

            // Restore reference count
            pCRowset->m_cRef--;

            BAIL_ON_FAILURE(hr);

            // Release the row handle since the row object now has a reference
            // to it. The reference count of the rowset is at 1 now since the
            // row object stored off a pointer to the rowset. The rowset will
            // be freed when the row is released.
            hr = pCRowset->ReleaseRows(1, phRow, NULL, NULL, NULL);
            BAIL_ON_FAILURE(hr);

            // we won't bother returning DB_S_NOTSINGLETON if there are more
            // rows in the rowset since the spec doesn't require it.
        }
        else
#endif
        {
            hr = pCRowset->QueryInterface(riid, (void **)ppIRowset);
            BAIL_ON_FAILURE(hr);
        }
    }
    else // OpenRowset may pass in NULL as ppIRowset
        delete pCRowset;

    if( fGotWarning )
        RRETURN( DB_S_ERRORSOCCURRED );
    else
        RRETURN( S_OK );

error:

    if( pCRowset )
        delete pCRowset;

    RRETURN(hr);
}

//-----------------------------------------------------------------------------
// IsRowObjRequested
//
// From the properties specified by the client, check if DBPROP_IRow is set
//
//-----------------------------------------------------------------------------
HRESULT
CRowset::IsRowObjRequested(BOOL *pfRowObjRequested)
{
#if (!defined(BUILD_FOR_NT40))
    DBPROPIDSET rgPropertyIDSets;
    DBPROPID    dbPropId;
    ULONG       cPropSets;
    DBPROPSET   *prgPropertySets;
    VARIANT     *pVariant;
    HRESULT     hr;
    int         i, j;

    if( NULL == pfRowObjRequested )
        BAIL_ON_FAILURE( hr = E_INVALIDARG );

    dbPropId = DBPROP_IRow;
    cPropSets = 0;
    prgPropertySets = NULL;

    rgPropertyIDSets.cPropertyIDs = 1;
    rgPropertyIDSets.rgPropertyIDs = &dbPropId;
    rgPropertyIDSets.guidPropertySet = DBPROPSET_ROWSET;

    hr = m_pCUtilProp->GetProperties(1,
                                     &rgPropertyIDSets,
                                     &cPropSets,
                                     &prgPropertySets,
                                     PROPSET_COMMAND
                                    );
    BAIL_ON_FAILURE( hr );

    ADsAssert( (1 == cPropSets) && (prgPropertySets != NULL) );
    ADsAssert( (1 == prgPropertySets->cProperties) &&
                       (prgPropertySets->rgProperties != NULL) );

    pVariant = &(prgPropertySets->rgProperties[0].vValue);
    *pfRowObjRequested =  V_BOOL( pVariant );

    // Free memory allocated by GetProperties
    for (i = 0; i < cPropSets; i++)
    {
        for (j = 0; j < prgPropertySets[i].cProperties; j++)
        {
            DBPROP *pProp = &(prgPropertySets[i].rgProperties[j]);
            ADsAssert(pProp);

            // We should free the DBID in pProp, but we know that
            // GetProperties always returns DB_NULLID and FreeDBID doesn't
            //  handle DB_NULLID. So, DBID is not freed here.

            VariantClear(&pProp->vValue);
        }

        CoTaskMemFree(prgPropertySets[i].rgProperties);
    }
    CoTaskMemFree(prgPropertySets);

    RRETURN( S_OK );

error:

    RRETURN( hr );
#else
    RRETURN(E_FAIL);
#endif
}

//-----------------------------------------------------------------------------
// CRowset
//
// Constructor initializes all fields to NULL
//
//-----------------------------------------------------------------------------
CRowset::CRowset(void)
{
    m_pCRowsetInfo = NULL;
    m_pCAccessor = NULL;
    m_pCRowProvider = NULL;
    m_pCUtilProp = NULL;

    m_pIDataConvert = NULL;
    m_pIColumnsInfo = NULL;
    m_pIRowProvider = NULL;
    m_pIMalloc = NULL;

    m_lLastFetchRow = RESET_ROW;
    m_cRowBytes = 0;
    m_cCol = 0;

    m_pColData = NULL;

    m_fCritSectionInitialized = FALSE;
    m_fEndOfRowset = FALSE;
    m_fadsPathPresent = TRUE;
    m_fAllAttrs = FALSE;

    m_cNumRowsCached = 0;
    m_LastFetchDir = FORWARD;

    m_pRowsPtr = NULL;
    m_dwRowCacheSize = 0;
    m_lCurrentRow = 0;

    m_cRef = 0;
}

//-----------------------------------------------------------------------------
// ~Crowset
//
// Destructor releases all resources
//
//-----------------------------------------------------------------------------
CRowset::~CRowset(void)
{
    if( m_pRowsPtr )
    {
        int iRow;

        for(iRow = 0; iRow < m_cNumRowsCached; iRow++)
        {
            ADsAssert(m_pRowsPtr[iRow] != NULL);
            FreeRow(m_pRowsPtr[iRow]);
        }

        FreeADsMem(m_pRowsPtr);
    }

    if( m_pCRowsetInfo )
        delete m_pCRowsetInfo;
    if( m_pCAccessor )
        delete m_pCAccessor;
    if( m_pCUtilProp )
        delete m_pCUtilProp;
    // Shouldn't delete m_pCRowProvider since we didn't allocate it

    if( m_pIDataConvert )
        m_pIDataConvert->Release();
    if( m_pIColumnsInfo )
        m_pIColumnsInfo->Release();
    if( m_pIMalloc )
        m_pIMalloc->Release();
    // Shouldn't release m_pIRowProvider since we didn't AddRef it

    if( m_pColData )
        FreeADsMem(m_pColData);

    if( m_fCritSectionInitialized )
        DeleteCriticalSection(&m_RowsetCritSection);
}

//-----------------------------------------------------------------------------
// FInit
//
// Initializes rowset object
//
//-----------------------------------------------------------------------------
STDMETHODIMP
CRowset::FInit(
    CRowProvider   *pIRowProvider,  // The Row provider
    IUnknown       *pParentObj,     // parent object, a command or a session
    CSessionObject *pCSession,      // Session Object
    CCommandObject *pCCommand,      // Command Object
    ULONG          cPropertySets,   // # property sets in rowset property group
    DBPROPSET      rgPropertySets[],// properties in rowset property group
    ULONG          cAccessors,      // accessor count
    HACCESSOR      rgAccessors[],   // accessors on command object
    BOOL           fadsPathPresent, // Is ADsPath present in query
    BOOL           fAllAttrs        // Return all attrs from row object?
    )
{
    HRESULT        hr;
    BOOL           fGotWarning = FALSE;

    InitializeCriticalSection(&m_RowsetCritSection);
    m_fCritSectionInitialized = TRUE;

    m_pCRowsetInfo = new CRowsetInfo(NULL, pParentObj, pCSession, pCCommand,
                                           pIRowProvider);

    if( NULL == m_pCRowsetInfo )
        BAIL_ON_FAILURE( hr = E_OUTOFMEMORY );
    hr = m_pCRowsetInfo->FInit( (IUnknown *) ((IAccessor *)this) );
    BAIL_ON_FAILURE(hr);

    m_pCAccessor = new CImpIAccessor(this, NULL);
    if( NULL == m_pCAccessor )
        BAIL_ON_FAILURE( hr = E_OUTOFMEMORY );
    hr = m_pCAccessor->FInit();
    BAIL_ON_FAILURE(hr);

    m_pCRowProvider = pIRowProvider;

    m_pCUtilProp = new CUtilProp();
    if( NULL == m_pCUtilProp )
        BAIL_ON_FAILURE( hr = E_OUTOFMEMORY );
    hr = m_pCUtilProp->FInit(NULL);
    BAIL_ON_FAILURE(hr);

    // Set the properties. Use PROPSET_COMMAND as we only want to set
    // properties in the rowset property group. Any other properties
    // should return error.
    hr = m_pCUtilProp->SetProperties(cPropertySets,
                                     rgPropertySets,
                                     PROPSET_COMMAND
                                     );

    // On session object, we need to check DBPROPOPTIONS to really decide if
    // there was a serious error. See comment before SetSearchPrefs in
    // csession.cxx
    if( pCSession &&
              ((DB_E_ERRORSOCCURRED == hr) || (DB_S_ERRORSOCCURRED == hr)) )
    {
        ULONG i, j;

        for(i = 0; i < cPropertySets; i++)
            for(j = 0; j < rgPropertySets[i].cProperties; j++)
                if( rgPropertySets[i].rgProperties[j].dwStatus !=
                               DBPROPSTATUS_OK )
                    if( rgPropertySets[i].rgProperties[j].dwOptions !=
                               DBPROPOPTIONS_OPTIONAL )
                    {
                        BAIL_ON_FAILURE( hr = DB_E_ERRORSOCCURRED );
                    }
                    else
                        fGotWarning = TRUE;

        // if we get here, then there was all required properties were set
        // successfully. However, hr could still be DB_ERRORSOCCURRED if all
        // properties were optional and all of them could not be set. This
        // condition is not an error for OpenRowset as noted in the comment
        // in csession.cxx. Hence reset hr to S_OK.

        hr = S_OK;
    }

    BAIL_ON_FAILURE(hr);
    if( hr != S_OK ) // warning needs to be returned to user
        fGotWarning = TRUE;

    // Get the maximum number of rows the rowset cache should support
    hr = GetMaxCacheSize();
    BAIL_ON_FAILURE(hr);

    // Get IDataConvert interface for later use by IRowset->GetData
    hr = CoCreateInstance(
            CLSID_OLEDB_CONVERSIONLIBRARY,
            NULL,
            CLSCTX_INPROC_SERVER,
            IID_IDataConvert,
            (void **)&m_pIDataConvert
            );
    BAIL_ON_FAILURE(hr);

    // Get IColumnsInfo interface pointer from row provider
    hr = pIRowProvider->QueryInterface(
            IID_IColumnsInfo,
            (void **)&m_pIColumnsInfo
            );
    BAIL_ON_FAILURE(hr);

    // No need to AddRef below since row provider is contained in CRowsetInfo
    // and CRowsetInfo's lifetime is within CRowset.
    m_pIRowProvider = pIRowProvider;

    // Copy inherited accessors from the command object
    hr = CopyAccessors(cAccessors, pCCommand, rgAccessors);
    BAIL_ON_FAILURE(hr);

    hr = CoGetMalloc(MEMCTX_TASK, &m_pIMalloc);
    BAIL_ON_FAILURE(hr);

    // get the column offsets from the row provider
    hr = GetColOffsets();
    BAIL_ON_FAILURE(hr);

    m_fadsPathPresent = fadsPathPresent;
    m_fAllAttrs = fAllAttrs;

    if( fGotWarning )
        RRETURN( DB_S_ERRORSOCCURRED );
    else
        RRETURN( S_OK );

error:

    if( m_pCRowsetInfo != NULL )
        delete m_pCRowsetInfo; // Releases pParentObj, pCCommand, pCSession and
                               // pIRowProvider

    if( m_pCAccessor != NULL )
        delete m_pCAccessor;
    if( m_pCUtilProp != NULL )
        delete m_pCUtilProp;
    if( m_pIDataConvert != NULL )
        m_pIDataConvert->Release();
    if( m_pIColumnsInfo != NULL )
        m_pIColumnsInfo->Release();
    if( m_pIMalloc )
        m_pIMalloc->Release();
    if( m_fCritSectionInitialized )
        DeleteCriticalSection(&m_RowsetCritSection);

    m_pCRowsetInfo = NULL;
    m_pCAccessor = NULL;
    m_pCRowProvider = NULL;
    m_pCUtilProp = NULL;
    m_pIDataConvert = NULL;
    m_pIColumnsInfo = NULL;
    m_pIRowProvider = NULL;
    m_pIMalloc = NULL;

    m_fCritSectionInitialized = FALSE;

    RRETURN( hr );
}

//-----------------------------------------------------------------------------
// GetMaxCacheSize
//
// From the properties specified by the client, get the maximum number of rows
// that the rowset cache should support.
//
//-----------------------------------------------------------------------------
HRESULT
CRowset::GetMaxCacheSize(void)
{
    DBPROPIDSET rgPropertyIDSets;
    DBPROPID    dbPropId;
    ULONG       cPropSets;
    DBPROPSET   *prgPropertySets;
    VARIANT     *pVariant;
    HRESULT     hr;
    ULONG       i, j;

    dbPropId = DBPROP_MAXOPENROWS;
    cPropSets = 0;
    prgPropertySets = NULL;

    rgPropertyIDSets.cPropertyIDs = 1;
    rgPropertyIDSets.rgPropertyIDs = &dbPropId;
    rgPropertyIDSets.guidPropertySet = DBPROPSET_ROWSET;

    hr = m_pCUtilProp->GetProperties(1,
                                     &rgPropertyIDSets,
                                     &cPropSets,
                                     &prgPropertySets,
                                     PROPSET_COMMAND
                                    );
    BAIL_ON_FAILURE( hr );

    ADsAssert( (1 == cPropSets) && (prgPropertySets != NULL) );
    ADsAssert( (1 == prgPropertySets->cProperties) &&
                       (prgPropertySets->rgProperties != NULL) );

    pVariant = &(prgPropertySets->rgProperties[0].vValue);
    m_dwMaxCacheSize =  V_I4( pVariant );

    // Free memory allocated by GetProperties
    for (i = 0; i < cPropSets; i++)
    {
        for (j = 0; j < prgPropertySets[i].cProperties; j++)
        {
            DBPROP *pProp = &(prgPropertySets[i].rgProperties[j]);
            ADsAssert(pProp);

            // We should free the DBID in pProp, but we know that
            // GetProperties always returns DB_NULLID and FreeDBID doesn't
            //  handle DB_NULLID. So, DBID is not freed here.

            VariantClear(&pProp->vValue);
        }

        CoTaskMemFree(prgPropertySets[i].rgProperties);
    }
    CoTaskMemFree(prgPropertySets);

    RRETURN( S_OK );

error:

    RRETURN( hr );
}

//-----------------------------------------------------------------------------
// CopyAccessors
//
// Copies inherited accessors from the command object to the rowset object. If
// the rowset is being created by a session object, nothing has to be done.
//
//-----------------------------------------------------------------------------
HRESULT
CRowset::CopyAccessors(
    ULONG          cAccessors,      // accessor count
    CCommandObject *pCCommand,      // Command Object
    HACCESSOR      rgAccessors[]    // accessors on command object
    )
{
    HRESULT        hr = S_OK;
    IAccessor      *pIAccessorCommand = NULL; // Command's IAccessor
    IAccessor      *pIAccessorRowset = NULL;  // Rowset's IAccessor

    // Bump up reference count so that call to Release at the end of this
    // function doesn't delete rowset object.
    CAutoBlock cab(&m_RowsetCritSection);
    ++m_cRef;

    if( (cAccessors > 0) && (pCCommand != NULL) )
    {
        hr = pCCommand->QueryInterface(
                    IID_IAccessor,
                    (void **)&pIAccessorCommand
                    );
        BAIL_ON_FAILURE(hr);

        hr = this->QueryInterface(
                    IID_IAccessor,
                    (void **)&pIAccessorRowset
                    );
        BAIL_ON_FAILURE(hr);

        hr = CpAccessors2Rowset(
                    pIAccessorCommand,
                    pIAccessorRowset,
                    cAccessors,
                    rgAccessors,
                    m_pCAccessor);
        BAIL_ON_FAILURE(hr);
    }

error:

    if( pIAccessorCommand )
        pIAccessorCommand->Release();
    if( pIAccessorRowset )
        pIAccessorRowset->Release();

    --m_cRef;

    RRETURN( hr );
}

//-----------------------------------------------------------------------------
// GetColOffsets
//
// Decides the offets of the columns in thr row buffer based on the column
// info from the row provider
//
//-----------------------------------------------------------------------------
HRESULT
CRowset::GetColOffsets(void)
{
    HRESULT      hr;
    DBCOLUMNINFO *pColInfo = NULL;
    OLECHAR      *pColNames = NULL;
    DWORD        dwOffset, i;

    hr = m_pIColumnsInfo->GetColumnInfo(&m_cCol, &pColInfo, &pColNames);
    BAIL_ON_FAILURE( hr );

    // we don't need the column names
    m_pIMalloc->Free(pColNames);

    m_pColData = (COLDATA *) AllocADsMem(sizeof(COLDATA) * m_cCol);
    if( NULL == m_pColData )
        BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);

    // Account for fields such as the row reference count that occur
    // before all columns in the row buffer
    dwOffset = sizeof(ROWBUFFER);

    for(i = 0; i < m_cCol; i++)
    {
        dwOffset = ColumnAlign(dwOffset);
        m_pColData[i].dwColOffset = dwOffset;

        // Account for the length and status fields of OLEDB data
        dwOffset += FIELD_OFFSET(OLEDBDATA, OledbValue);

        // Row provider returns all variable-length data types as BYREF
        if( pColInfo[i].wType & DBTYPE_BYREF )
            dwOffset += sizeof(char *);
        else
            dwOffset += (DWORD)pColInfo[i].ulColumnSize;

        m_pColData[i].wType = pColInfo[i].wType;
    }

    m_cRowBytes = dwOffset;
    m_pIMalloc->Free(pColInfo);

    RRETURN( S_OK );

error:

    if( pColInfo != NULL )
        m_pIMalloc->Free(pColInfo);
    if( m_pColData != NULL )
    {
        FreeADsMem(m_pColData);
        m_pColData = NULL;
    }
    m_cCol = m_cRowBytes = 0;

    RRETURN( hr );
}

//-----------------------------------------------------------------------------
// GetNextRows
//
// Gets rows using the row provider into the rowset's cache. Handles for these
// rows are returned to the caller. The caller then retrieves the rows using
// GetData.
//
//-----------------------------------------------------------------------------
STDMETHODIMP
CRowset::GetNextRows(
    HCHAPTER    hChapter, // ignored since this is not a chaptered rowset
    DBROWOFFSET lRowsOffset,
    DBROWCOUNT  cRows,
    DBCOUNTITEM *pcRowsObtained,
    HROW        **prghRows
    )
{
    HRESULT   hr;
    RBOOKMARK StartRowBmk;                 // bookmark of first row to fetch
    ULONG     cbBookmark = ADSI_BMK_SIZE;  // size in bytes of the bookmark

    if( (NULL == pcRowsObtained) || (NULL == prghRows) )
    {
        if( pcRowsObtained != NULL )
            *pcRowsObtained = 0;
        RRETURN( E_INVALIDARG );
    }

    *pcRowsObtained = 0;

    if( 0 == cRows )
        RRETURN( S_OK );

    CAutoBlock cab(&m_RowsetCritSection);

    if( RESET_ROW == m_lLastFetchRow )
    // this is the first fetch OR RestartPosition was called prior to this
    {
        if( (lRowsOffset > 0) || ((0 == lRowsOffset) && (cRows > 0)) )
        {
            StartRowBmk = DBBMK_FIRST;
            cbBookmark = STD_BMK_SIZE;
        }
        else if( (lRowsOffset < 0) || ((0 == lRowsOffset) && (cRows < 0)) )
        {
            // can't set StartRowBmk to DBBMK_LAST as we want to set it one
            // beyond the end of the rowset

            // Seek to end of rowset
            hr = SeekToEnd();
            if( FAILED(hr) )
                RRETURN( hr );

            // m_lCurrentRow is now 2 off the last row of the rowset
            StartRowBmk = RowToBmk(m_lCurrentRow - 1);
        }

        if( cRows < 0 )
        // the first row we want to fetch is one before that specified by
        // the combination of StartRowBmk and lRowsOffset
            lRowsOffset--;
    }
    else // we have fetched rows before OR RestartPosition was not called
    {
        // except in the 3rd case below, it is possible that StartRowBmk
        // will end up pointing to a row that is outside the rowset
        if( (FORWARD == m_LastFetchDir) && (cRows > 0) )
                StartRowBmk = RowToBmk(m_lLastFetchRow + 1);
        else if( (BACKWARD == m_LastFetchDir) && (cRows < 0) )
                StartRowBmk = RowToBmk(m_lLastFetchRow - 1);
        else // first row returned will be same as last row returned previously
                StartRowBmk = RowToBmk(m_lLastFetchRow);
    }

    hr = GetRowsAt(NULL, hChapter, cbBookmark, (BYTE *) &StartRowBmk,
                         lRowsOffset, cRows, pcRowsObtained, prghRows);

    if( SUCCEEDED(hr) )
    {
        // If we return DB_S_ENDOFROWSET because lRowsOffset indicated a
        // position outside the rowset, then we do not modify m_lLastFetchRow.
        // Only if we walked off either end of the rowset AND fetched at least
        // a row is m_lLastFetchRow updated. If no rows are returned due to
        // lack of space in the rowset cache, we do not modify m_lLastFetchRow.
        if( *pcRowsObtained )
        {
            m_LastFetchDir = (cRows > 0) ? FORWARD:BACKWARD;
            m_lLastFetchRow = HROWToRow( (*prghRows)[*pcRowsObtained - 1] );
        }
    }

    RRETURN( hr );
}

//-----------------------------------------------------------------------------
// GetRowsAt
//
// Fetches rows starting from a given offset from a bookmark. Handles for
// rows fetched are returned to the caller. The caller may send in an invalid
// bookmark i.e, a bookmark that was not returned by a previous invocation of
// GetData. Although, this is an error, the spec does not require the provider
// to detect this condition. So, the user can send in a random bookmark and the
// provider will return the correct row if there is a row that corresponds to
// the bookmark and DB_S_ENDOFROWSET otherwise. We make use of this fact when
// GetNextRows calls GetRowsAt. The bookmark passed in by GetNextRows may be
// for a row that is not yet in the provider's cache.
//
//-----------------------------------------------------------------------------
STDMETHODIMP
CRowset::GetRowsAt(
    HWATCHREGION hReserved, // Reserved for future use. Ignored.
    HCHAPTER     hChapter,  // ignored as this is not a chaptered rowset
    DBBKMARK     cbBookmark,
    const BYTE   *pBookmark,
    DBROWOFFSET  lRowsOffset,
    DBROWCOUNT   cRows,
    DBCOUNTITEM  *pcRowsObtained,
    HROW         **prghRows
    )
{
    LONG         lStartRow, // first row returned
                 lBmkRow,   // row corresponding to bookmark
                 lNextRow,
                 lRowIndex;
    int          iStep;
    HROW         *phRow;
    ROWBUFFER    *pRowBuffer;
    HRESULT      hr;
    BOOL         fMemAllocated = FALSE;
    DBCOUNTITEM  iRow;
    ULONG_PTR    ulRowsOffset;

    if( (0 == cbBookmark) || (NULL == pBookmark) ||
        (NULL == pcRowsObtained) || (NULL == prghRows) )
    {
        if( pcRowsObtained != NULL )
            *pcRowsObtained = 0;

        RRETURN( E_INVALIDARG );
    }

    *pcRowsObtained = 0;

    if( (cbBookmark != STD_BMK_SIZE) && (cbBookmark != ADSI_BMK_SIZE) )
        RRETURN( DB_E_BADBOOKMARK );

    if( 0 == cRows )
        RRETURN( S_OK ); // don't have to check for any errors

    CAutoBlock cab(&m_RowsetCritSection);

    // rowset can't have more than 2^32 rows. So, if offset points to beyond
    // that return eof.
    ulRowsOffset = (lRowsOffset > 0) ? lRowsOffset : -lRowsOffset;
    if( ulRowsOffset & 0xffffffff00000000 )
        RRETURN( DB_S_ENDOFROWSET );

    // Get first row to fetch
    hr = BmkToRow(cbBookmark, pBookmark, &lBmkRow);
    if( FAILED(hr) )
        RRETURN( hr );
    lStartRow = lBmkRow + lRowsOffset;

    if( lStartRow < FIRST_ROW )
        RRETURN( DB_S_ENDOFROWSET );

    lNextRow = lStartRow;
    if( NULL == *prghRows ) // provider has to allocate memory for handles
    {
        ULONG_PTR cNumHandles, cRowsAbs;

        // not sure if there is an abs64
        if(cRows < 0)
            cRowsAbs = -cRows;
        else
            cRowsAbs = cRows;

        // Guard against user requesting too many rows - maximum we can
        // return is the size of the rowset cache
        if( m_dwMaxCacheSize > 0 ) // user specified some max value
            cNumHandles = Min(cRowsAbs, (ULONG_PTR) m_dwMaxCacheSize);
        else
            cNumHandles = cRowsAbs;

        if( 0 == (cNumHandles * sizeof(HROW)) ) // numeric overflow
            *prghRows = NULL;
        else
            *prghRows = (HROW *) m_pIMalloc->Alloc(cNumHandles * sizeof(HROW));

        if( NULL == *prghRows )
            RRETURN( E_OUTOFMEMORY );
        fMemAllocated = TRUE;
    }

    iStep = (cRows > 0) ? 1 : -1;
    phRow = *prghRows;

    // fetch rows
    while( cRows )
    {
        hr = SeekToRow(lNextRow);
        BAIL_ON_FAILURE(hr);

        if( DB_S_ENDOFROWSET == hr )
        // we reached the end of the rowset OR we have reached the end of
        // whatever portion of the results set that ADSI has cached (depends
        // on the ADSIPROP_CACHE_RESULTS property)
        {
            if( (0 == *pcRowsObtained) && fMemAllocated )
            {
                m_pIMalloc->Free(*prghRows);
                *prghRows = NULL;
            }

            RRETURN( DB_S_ENDOFROWSET );
        }

        // Bring in the row that we just seeked to
        hr = BringInRow();

        BAIL_ON_FAILURE(hr);

        if( (DB_S_ROWLIMITEXCEEDED == hr) || (DB_S_ENDOFROWSET == hr) )
        // no more space in rowset cache OR end of rowset. We will hit end
        // of rowset only if m_lCurrentRow was one/two beyond the end of the
        // rowset when SeekToRow was called above AND lNextRow == m_lCurrentRow
        // (in which case, SeekToRow would just return without doing anything).
        {
            if( (0 == *pcRowsObtained) && fMemAllocated )
            {
                m_pIMalloc->Free(*prghRows);
                *prghRows = NULL;
            }

            RRETURN( hr );
        }

        // Get the index of the row within the rowset cache
        *phRow = RowToHROW(lNextRow);
        lRowIndex = HROWToIndex(*phRow);

        // Increment reference count of row
        pRowBuffer = m_pRowsPtr[lRowIndex];
        ADsAssert(pRowBuffer != NULL);
        IncrRefCount(pRowBuffer);

        phRow++;
        (*pcRowsObtained)++;
        lNextRow += iStep;
        cRows += (-iStep);

    } // while (cRows)

    RRETURN( S_OK );

error:
    // release any rows that were brought into the cache
    phRow = *prghRows;
    for(iRow = 0; iRow < *pcRowsObtained; iRow++)
    {
        ULONG ulRefCount;

        ReleaseRows(1, phRow, NULL, &ulRefCount, NULL); //ignore ret value

        phRow++;
    }

    if( fMemAllocated )
    {
        m_pIMalloc->Free(*prghRows);
        *prghRows = NULL;
    }

    *pcRowsObtained = 0;

    RRETURN(hr);
}

//-----------------------------------------------------------------------------
// BmkToRow
//
// Converts a bookmark to a row within the rowset.
//
//-----------------------------------------------------------------------------
HRESULT
CRowset::BmkToRow(
    ULONG      cbBookmark, // number of bytes in the bookmark
    const BYTE *pBookmark, //  pointer to bookmark
    LONG       *plRow
    )
{
    HRESULT    hr;

    ADsAssert( plRow != NULL );

    if( STD_BMK_SIZE == cbBookmark )
    {
        // If pBookmark is a pointer passed in from GetNextRows, then it is
        // actually a LONG *. Accessing *pBookmark to get the LSByte of the
        // bookmark below assumes LITTLE ENDIAN format.

        if( DBBMK_FIRST == *pBookmark )
            *plRow = FIRST_ROW;
        else if( DBBMK_LAST == *pBookmark )
        {
            CAutoBlock cab(&m_RowsetCritSection); // protect access to m_ fields

            // Seek to end of rowset
            hr = SeekToEnd();

            if( FAILED(hr) )
                RRETURN( hr );
            
            // should have reached end of rowset
            ADsAssert( DB_S_ENDOFROWSET == hr );

            // Seeking to end of rowset sets current row to MAX + 2, if there
            // is at least one row in the result. If the result is empty, we
            // will return -1 in *plRow below, but that's OK as -1 implies
            // DB_S_ENDOFROWSET in GetRowsAt()
            *plRow = m_lCurrentRow - 2;
        }
        else
            RRETURN( DB_E_BADBOOKMARK );
    }
    else if( ADSI_BMK_SIZE == cbBookmark )
        *plRow = *((LONG *) pBookmark);

    else // should never get in here
        ADsAssert( FALSE );

    RRETURN( S_OK );
}

//-----------------------------------------------------------------------------
// SeekToRow
//
// Positions the IDirectorySearch cursor such that the next call to GetNextRow
// will fetch the row lTargetRow. If we hit the end of the rowset before
// seeking to lTargetRow, returns DB_S_ENDOFROWSET.
//
//-----------------------------------------------------------------------------
HRESULT
CRowset::SeekToRow(LONG lTargetRow)
{
    HRESULT hr;

    CAutoBlock cab(&m_RowsetCritSection);

    if( lTargetRow == m_lCurrentRow ) // already at the right row
        RRETURN( S_OK );

    if( lTargetRow < m_lCurrentRow )
    {
        while( lTargetRow != m_lCurrentRow )
        {
            hr = m_pCRowProvider->SeekToPreviousRow();
            BAIL_ON_FAILURE(hr);

            // m_fEndOfRowset is set to TRUE only if we hit the end of the
            // rowset while moving forward
            m_fEndOfRowset = FALSE;

            if( m_lCurrentRow > 0 )
                m_lCurrentRow--;

            if( S_ADS_NOMORE_ROWS == hr )
                if( m_lCurrentRow != lTargetRow )
                    RRETURN( DB_S_ENDOFROWSET );
        }
    }
    else
    {
        while( lTargetRow != m_lCurrentRow )
        {
            hr = m_pCRowProvider->SeekToNextRow();
            BAIL_ON_FAILURE(hr);

            m_lCurrentRow++;

            if( S_ADS_NOMORE_ROWS == hr )
            {
                // if we were already at the end of the rowset, then reset
                // m_lCurrentRow to its original value
                if( m_fEndOfRowset)
                    m_lCurrentRow--;
                else
                    m_fEndOfRowset = TRUE;

                RRETURN( DB_S_ENDOFROWSET );
            }
        }

        m_fEndOfRowset = FALSE;

    }

    RRETURN( S_OK );

error:

    RRETURN( hr );
}

//-----------------------------------------------------------------------------
// SeekToEnd
//
// Moves the IDirectorySearch cursor forward till it hits the end of the
// rowset.
//
//-----------------------------------------------------------------------------
HRESULT
CRowset::SeekToEnd(void)
{
    HRESULT hr = S_OK;

    CAutoBlock cab(&m_RowsetCritSection);

    while(1) // till we reach end of rowset
    {
        hr = m_pCRowProvider->SeekToNextRow();

        BAIL_ON_FAILURE(hr);

        m_lCurrentRow++;

        if( S_ADS_NOMORE_ROWS == hr )
        {
            // if we were already at the end of the rowset, then reset
            // m_lCurrentRow to its original value
            if( m_fEndOfRowset)
                m_lCurrentRow--;
            else
                m_fEndOfRowset = TRUE;

            RRETURN( DB_S_ENDOFROWSET );
        }
    }

error:

    RRETURN( hr );
}

//-----------------------------------------------------------------------------
// BringInRow
//
// Brings in the row that we seeked to last. Only one row is brought in.
//
//-----------------------------------------------------------------------------
HRESULT
CRowset::BringInRow(void)
{
    HRESULT   hr;
    ROWBUFFER *pRowBuffer = NULL;
    DWORD     cColErrors; // #columns in a row that had an error when retrieved
    int       iCol, iRow;
    HROW      hRow;
    LONG      lIndex;
    DBSTATUS  *pdbStatus;

    CAutoBlock cab(&m_RowsetCritSection);

    // check if the row is already in the cache

    hRow = RowToHROW(m_lCurrentRow);
    lIndex = HROWToIndex(hRow);

    if(lIndex != -1)
    // row is already in cache
    {
        pRowBuffer = m_pRowsPtr[lIndex];
        ADsAssert(pRowBuffer != NULL);

        if( pRowBuffer->cColErrors )
            RRETURN( DB_S_ERRORSOCCURRED );
        else
            RRETURN( S_OK );
    }

    // check if we have room in the cache
    if( (m_dwMaxCacheSize > 0) && ((DWORD)m_cNumRowsCached == m_dwMaxCacheSize) )
        RRETURN( DB_S_ROWLIMITEXCEEDED );

    // Allocate more space in the cache, if we have run out
    if( (DWORD)m_cNumRowsCached == m_dwRowCacheSize ) // no more space for rows
    {
        DWORD     dwTmpSize;
        ROWBUFFER **pTmpRowsPtr;

        dwTmpSize = (0 == m_dwRowCacheSize) ? 1 : (m_dwRowCacheSize*2);

        // make sure we don't overflow the cache
        if( (m_dwMaxCacheSize > 0) && (dwTmpSize > m_dwMaxCacheSize) )
            dwTmpSize = m_dwMaxCacheSize;

        pTmpRowsPtr = (ROWBUFFER **) ReallocADsMem(m_pRowsPtr,
                                      m_dwRowCacheSize*sizeof(ROWBUFFER *),
                                      dwTmpSize*sizeof(ROWBUFFER *));
        if( NULL == pTmpRowsPtr )
            BAIL_ON_FAILURE( hr = E_OUTOFMEMORY );

        m_dwRowCacheSize = dwTmpSize;
        m_pRowsPtr = pTmpRowsPtr;
    }

    // Allocate memory for a new row
    pRowBuffer = (ROWBUFFER *) AllocADsMem(m_cRowBytes);
    if( NULL == pRowBuffer )
        BAIL_ON_FAILURE( hr = E_OUTOFMEMORY );
    // initialize row to 0 (reference count initialized to 0 here)
    memset((char *) pRowBuffer, 0, m_cRowBytes);

    pRowBuffer->lRow = m_lCurrentRow;

    // use row provider to get the next row
    hr = m_pIRowProvider->NextRow();

    BAIL_ON_FAILURE(hr);

    m_lCurrentRow++;

    if( DB_S_ENDOFROWSET == hr )
    {
        if( m_fEndOfRowset )
            m_lCurrentRow--;
        else
            m_fEndOfRowset = TRUE;
        FreeADsMem(pRowBuffer);
        RRETURN( DB_S_ENDOFROWSET );
    }
    else
        m_fEndOfRowset = FALSE;

    cColErrors = 0;

    for(iCol = 1; (DBORDINAL)iCol < m_cCol; iCol++)
    {
        hr = m_pIRowProvider->GetColumn(
            iCol,
            (DBSTATUS *) ( m_pColData[iCol].dwColOffset +
                     FIELD_OFFSET(OLEDBDATA, dbStatus) + (char *)pRowBuffer ),
            (ULONG *) ( m_pColData[iCol].dwColOffset +
                     FIELD_OFFSET(OLEDBDATA, dwLength) + (char *)pRowBuffer ),
            (BYTE *) ( m_pColData[iCol].dwColOffset +
                     FIELD_OFFSET(OLEDBDATA, OledbValue) + (char *)pRowBuffer )
        );

        if( FAILED(hr) )
            cColErrors++;

        // store the ADS_SEARCH_COLUMN if the DS returned any data. Even if
        // GetColumn fails, this has to be done to ensure that the
        // ADS_SEARCH_COLUMN structure is freed later.
        pdbStatus = (DBSTATUS *) ( m_pColData[iCol].dwColOffset +
                    FIELD_OFFSET(OLEDBDATA, dbStatus) + (char *)pRowBuffer );
        if( *pdbStatus != DBSTATUS_S_ISNULL )
            memcpy((void *) ((char *)pRowBuffer + m_pColData[iCol].dwColOffset
                              + FIELD_OFFSET(OLEDBDATA, adsSearchCol)),
                   (void *) (&(m_pCRowProvider->_pdbSearchCol[iCol].adsColumn)),
                   sizeof(ADS_SEARCH_COLUMN) );
    }

    // Copy over the ADsPath search column, if required
    if( FALSE == m_fadsPathPresent )
        memcpy( (void *) (&(pRowBuffer->adsSearchCol)),
                (void *) (&(m_pCRowProvider->_pdbSearchCol[iCol].adsColumn)),
                sizeof(ADS_SEARCH_COLUMN) );

    if( cColErrors == (m_cCol - 1) ) // all columns were in error
    {
        // any failure after this point should do this
        FreeRow(pRowBuffer);
        pRowBuffer = NULL; // so that we don't try to free again later

        BAIL_ON_FAILURE( hr = DB_E_ERRORSOCCURRED );
    }

    // fill in the bookmark column
    *( (DBSTATUS *) (m_pColData[0].dwColOffset +
       FIELD_OFFSET(OLEDBDATA, dbStatus)+(char *)pRowBuffer) ) = DBSTATUS_S_OK;
    *( (ULONG *) (m_pColData[0].dwColOffset +
       FIELD_OFFSET(OLEDBDATA, dwLength)+(char *)pRowBuffer) ) = ADSI_BMK_SIZE;
    // bookmark value is same as row
    *( (ULONG *) (m_pColData[0].dwColOffset +
       FIELD_OFFSET(OLEDBDATA, OledbValue)+(char *)pRowBuffer) ) =
                                                m_lCurrentRow - 1;

    // Store pointer to new row
    m_pRowsPtr[m_cNumRowsCached] = pRowBuffer;

    m_cNumRowsCached++;

    if( cColErrors )
    {
        pRowBuffer->cColErrors = cColErrors;
        RRETURN( DB_S_ERRORSOCCURRED );
    }

    RRETURN( S_OK );

error:
    if( pRowBuffer )
        FreeADsMem(pRowBuffer);

    RRETURN( hr );
}

//----------------------------------------------------------------------------- // GetData
//
// Returns the data from the rowset cache in the format requested by the
// client. This routine performs deferred accessor validation i.e, checks that
// could not be done when the accessor was created due to lack of info. about
// the rowset.
//
//-----------------------------------------------------------------------------
STDMETHODIMP
CRowset::GetData(
    HROW      hRow,
    HACCESSOR hAccessor,
    void      *pData
    )
{
    HRESULT         hr;
    LONG            lRowIndex;
    DBACCESSORFLAGS dwAccessorFlags;
    DBCOUNTITEM     cBindings = 0, cErrors = 0;
    DBBINDING       *prgBindings = NULL;
    ROWBUFFER       *pRowBuffer;
    int             iBind;
    ULONG           ulCol;
    ULONG           *pulProvLength;
    DBLENGTH        *pulConsLength;
    DBSTATUS        *pdbConsStatus, *pdbProvStatus;
    void            *pConsValue, *pProvValue;
    OLEDBDATA       *pProvOledbData;

    if( NULL == pData ) // we don't supprt NULL accessor. So, this is an error
        RRETURN( E_INVALIDARG );

    CAutoBlock cab(&m_RowsetCritSection);

    lRowIndex = HROWToIndex(hRow);
    if( (lRowIndex < FIRST_ROW) || (lRowIndex >= m_cNumRowsCached) )
        RRETURN( DB_E_BADROWHANDLE );

    // Get pointer to the specified row
    pRowBuffer = m_pRowsPtr[lRowIndex];
    ADsAssert( pRowBuffer != NULL );
    if( RefCount(pRowBuffer) <= 0 )
        RRETURN( DB_E_BADROWHANDLE );

    ADsAssert( m_pCAccessor );

    hr = m_pCAccessor->GetBindings( // this call validates hAccessor
                hAccessor,
                &dwAccessorFlags,
                &cBindings,
                &prgBindings
                );

    if( FAILED(hr) )
        RRETURN( hr );

    ADsAssert( cBindings ); // NULL accessor is disallowed

    for(iBind = 0; (DBCOUNTITEM)iBind < cBindings; iBind++)
    {
        // Free pObject in the binding, if any
        if( prgBindings[iBind].pObject )
            m_pIMalloc->Free(prgBindings[iBind].pObject);

        // these types are disallowed
        ADsAssert( !((prgBindings[iBind].wType & DBTYPE_VECTOR) ||
                   (prgBindings[iBind].wType & DBTYPE_ARRAY)) );

        // Get pointers to consumer's OLEDB data using the bindings
        if( prgBindings[iBind].dwPart & DBPART_STATUS )
            pdbConsStatus = (DBSTATUS *) ( (char *)pData +
                                          prgBindings[iBind].obStatus );
        else
            pdbConsStatus = NULL;

        if( prgBindings[iBind].dwPart & DBPART_LENGTH )
            pulConsLength = (DBLENGTH *) ( (char *)pData +
                                          prgBindings[iBind].obLength );
        else
            pulConsLength = NULL;

        if( prgBindings[iBind].dwPart & DBPART_VALUE )
            pConsValue = (void *) ( (char *)pData +
                                          prgBindings[iBind].obValue );
        else
            pConsValue = NULL;

        // Check if accessor points to a valid column
        ulCol = prgBindings[iBind].iOrdinal;
        if( ulCol >= m_cCol )
        {
            if( pdbConsStatus )
                *pdbConsStatus = DBSTATUS_E_BADACCESSOR;
            cErrors++;
            continue;
        }

        // Get pointers to providers OLEDB data from the row buffer cache
        pProvOledbData = (OLEDBDATA *) ((char *)pRowBuffer +
                                         m_pColData[ulCol].dwColOffset);
        pdbProvStatus = &(pProvOledbData->dbStatus);
        pulProvLength = &(pProvOledbData->dwLength);
        pProvValue = &(pProvOledbData->OledbValue);

        if( DBMEMOWNER_PROVIDEROWNED == prgBindings[iBind].dwMemOwner )
        {
            if( pdbConsStatus )
                *pdbConsStatus = *pdbProvStatus;
            if( pulConsLength )
                *pulConsLength = *pulProvLength;

            if( prgBindings[iBind].wType & DBTYPE_BYREF )
            {
                // If a binding specifies provider owned memory, and specifies
                // type X | BYREF, and the provider's copy is not X or
                // X | BYREF, return error
                if( (prgBindings[iBind].wType & (~DBTYPE_BYREF)) !=
                        (m_pColData[ulCol].wType & (~DBTYPE_BYREF)) )
                {
                    if( pdbConsStatus )
                        *pdbConsStatus = DBSTATUS_E_BADACCESSOR;
                    cErrors++;
                    continue;
                }

                if( m_pColData[ulCol].wType & DBTYPE_BYREF )
                // provider's type exactly matches consumer's type
                {
                    if( pConsValue )
                        *(void **) pConsValue = *(void **) pProvValue;
                }
                else
                // provider actually has the data, not a pointer to the data
                {
                    if( pConsValue )
                        *(void **) pConsValue = pProvValue;
                }
            }
            else if( DBTYPE_BSTR == prgBindings[iBind].wType )
            {
                if( DBTYPE_BSTR != m_pColData[ulCol].wType )
                {
                    if( pdbConsStatus )
                        *pdbConsStatus = DBSTATUS_E_BADACCESSOR;
                    cErrors++;
                    continue;
                }

                if( pConsValue )
                    *(void **) pConsValue = *(void **) pProvValue;
            }
            else // we should never get here
                ADsAssert( FALSE );
        }
        else // binding specified client-owned memory
        {
            // workaround for bug in IDataConvert. Variant to Variant
            // conversions may not always work (depending on the type in the
            // variant). So, handle that case separately.

            DBTYPE dbSrcType, dbDstType;

            dbSrcType = m_pColData[ulCol].wType & (~DBTYPE_BYREF);
            dbDstType = prgBindings[iBind].wType & (~DBTYPE_BYREF);

            if( (DBTYPE_VARIANT == dbSrcType) &&
                (DBTYPE_VARIANT == dbDstType) )
            {
                PVARIANT pSrcVariant, pDstVariant = NULL;

                if( (*pdbProvStatus != DBSTATUS_S_OK) &&
                    (*pdbProvStatus != DBSTATUS_S_ISNULL) )
                // provider wasn't able to get value from DS. Return bad
                // status to consumer
                {
                    if( pdbConsStatus )
                        *pdbConsStatus = *pdbProvStatus;
                    if( pulConsLength )
                        *pulConsLength = 0;
                    // value will not be set

                    cErrors++;
                    continue; // to next binding
                }

                if( m_pColData[ulCol].wType & DBTYPE_BYREF )
                    pSrcVariant = *(PVARIANT *)pProvValue;
                else
                    pSrcVariant = (PVARIANT)pProvValue;

                if( (prgBindings[iBind].wType & DBTYPE_BYREF) && pConsValue )
                {
                    pDstVariant = (PVARIANT)m_pIMalloc->Alloc(sizeof(VARIANT));
                    if( NULL == pDstVariant )
                        hr = E_OUTOFMEMORY;
                }
                else
                    pDstVariant = (PVARIANT)pConsValue;

                if( pdbConsStatus )
                   *pdbConsStatus = *pdbProvStatus;
                if( pulConsLength )
                   *pulConsLength = *pulProvLength;

                if( pDstVariant )
                {
                    VariantInit(pDstVariant);

                    if( DBSTATUS_S_ISNULL == *pdbProvStatus )
                    // provider couldn't get this column from DS (probably
                    // because there was no attribute with this name)
                    {
                        if( prgBindings[iBind].wType & DBTYPE_BYREF )
                        // don't allocate anything if returning NULL status
                            m_pIMalloc->Free(pDstVariant);
                        else
                            V_VT(pDstVariant) = VT_EMPTY;

                        hr = S_OK;
                    }
                    else
                    {
                        hr = VariantCopy(pDstVariant, pSrcVariant);
                        if( SUCCEEDED(hr) )
                        {
                            if( pConsValue &&
                                (prgBindings[iBind].wType & DBTYPE_BYREF) )
                                *(void **) pConsValue = pDstVariant;
                        }
                        else if( prgBindings[iBind].wType & DBTYPE_BYREF )
                            m_pIMalloc->Free(pDstVariant);
                    } // else
                } // if( pDstvariant)
            } // if( DBTYPE_VARIANT == ...)
            else
            {
                DBLENGTH dbTmpLen = 0;

                hr = m_pIDataConvert->DataConvert(
                    m_pColData[ulCol].wType,
                    prgBindings[iBind].wType,
                    *pulProvLength,
                    &dbTmpLen,
                    pProvValue,
                    pConsValue,
                    prgBindings[iBind].cbMaxLen,
                    *pdbProvStatus,
                    pdbConsStatus,
                    prgBindings[iBind].bPrecision,
                    prgBindings[iBind].bScale,
                    DBDATACONVERT_DEFAULT
                    );
                if( pulConsLength )
                    *pulConsLength = dbTmpLen;

                // if the binding specified DBTYPE_VARIANT | DBTYPE_BYREF, then
                // IDataConvert does not allocate a VT_NULL variant. Instead it
                // returns nothing in pConsValue. If it is not BYREF, then
                // return VT_EMPTY instead of VT_NULL.
                if( SUCCEEDED(hr) && (DBSTATUS_S_ISNULL == *pdbProvStatus) &&
                    (prgBindings[iBind].wType == DBTYPE_VARIANT) &&
                     pConsValue )
                {
                    PVARIANT pVariant;

                    pVariant = (PVARIANT)pConsValue;

                    V_VT(pVariant) = VT_EMPTY;
                }

            }

            if( FAILED(hr) )
            {
                if( pdbConsStatus )
                    *pdbConsStatus = DBSTATUS_E_CANTCONVERTVALUE;
                cErrors++;
                continue;
            }
        } // client-owned memory
    }

    m_pIMalloc->Free(prgBindings);

    if( cErrors )
        if( cErrors != cBindings ) // not all columns had error
            RRETURN( DB_S_ERRORSOCCURRED );
        else
            RRETURN( DB_E_ERRORSOCCURRED );
    else
        RRETURN( S_OK );
}

//-----------------------------------------------------------------------------
// AddRefRows
//
// Increments reference count of specified rows
//
//-----------------------------------------------------------------------------
STDMETHODIMP
CRowset::AddRefRows(
    DBCOUNTITEM  cRows,
    const HROW   rghRows[],
    ULONG        rgRefCounts[],
    DBROWSTATUS  rgRowStatus[]
    )
{
    int       iRow;
    LONG      lRowIndex;
    ROWBUFFER *pRowBuffer;
    DBCOUNTITEM cErrors = 0;

    if( (NULL == rghRows) && (cRows != 0) )
        RRETURN( E_INVALIDARG );

    CAutoBlock cab(&m_RowsetCritSection);

    for(iRow = 0; (DBCOUNTITEM)iRow < cRows; iRow++)
    {
        lRowIndex = HROWToIndex(rghRows[iRow]);
        if( (lRowIndex < 0) || (lRowIndex >= m_cNumRowsCached) )
        {
            if( rgRowStatus )
                rgRowStatus[iRow] = DBROWSTATUS_E_INVALID;
            if( rgRefCounts )
                rgRefCounts[iRow] = 0;
            cErrors++;
            continue;
        }

        // Get pointer to the specified row
        pRowBuffer = m_pRowsPtr[lRowIndex];
        ADsAssert( pRowBuffer != NULL );
        if( RefCount(pRowBuffer) <= 0 )
        {
            if( rgRowStatus )
                rgRowStatus[iRow] = DBROWSTATUS_E_INVALID;
            if( rgRefCounts )
                rgRefCounts[iRow] = 0;
            cErrors++;
            continue;
        }

        IncrRefCount(pRowBuffer);

        if( rgRefCounts )
            rgRefCounts[iRow] = RefCount(pRowBuffer);
        if( rgRowStatus )
            rgRowStatus[iRow] = DBROWSTATUS_S_OK;
    }

    if( cErrors )
        if( cErrors == cRows )
            RRETURN( DB_E_ERRORSOCCURRED );
        else
            RRETURN( DB_S_ERRORSOCCURRED );

    RRETURN( S_OK );
}

//----------------------------------------------------------------------------
// ReleaseRows
//
// Decrements reference count of specified rows. The rows are not freed even
// if the reference count goes down to 0.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CRowset::ReleaseRows(
    DBCOUNTITEM  cRows,
    const HROW   rghRows[],
    DBROWOPTIONS rgRowOptions[], // ignored
    ULONG        rgRefCounts[],
    DBROWSTATUS  rgRowStatus[]
    )
{
    int       iRow;
    LONG      lRowIndex;
    ROWBUFFER *pRowBuffer;
    DBCOUNTITEM cErrors = 0;

    if( (NULL == rghRows) && (cRows != 0) )
        RRETURN( E_INVALIDARG );

    CAutoBlock cab(&m_RowsetCritSection);

    for(iRow = 0; (DBCOUNTITEM)iRow < cRows; iRow++)
    {
        lRowIndex = HROWToIndex(rghRows[iRow]);
        if( (lRowIndex < 0) || (lRowIndex >= m_cNumRowsCached) )
        {
            if( rgRowStatus )
                rgRowStatus[iRow] = DBROWSTATUS_E_INVALID;
            if( rgRefCounts )
                rgRefCounts[iRow] = 0;
            cErrors++;
            continue;
        }

        // Get pointer to the specified row
        pRowBuffer = m_pRowsPtr[lRowIndex];
        ADsAssert( pRowBuffer != NULL );
        if( RefCount(pRowBuffer) <= 0 )
        {
            if( rgRowStatus )
                rgRowStatus[iRow] = DBROWSTATUS_E_INVALID;
            if( rgRefCounts )
                rgRefCounts[iRow] = 0;
            cErrors++;
            continue;
        }

        DecrRefCount(pRowBuffer);

        if( rgRefCounts )
            rgRefCounts[iRow] = RefCount(pRowBuffer);
        if( rgRowStatus )
            rgRowStatus[iRow] = DBROWSTATUS_S_OK;

        // Free the row's memory
        if( 0 == RefCount(pRowBuffer) )
        {
            int i;

            FreeRow(pRowBuffer);
            m_cNumRowsCached--;

            // compact the cache
            for(i = lRowIndex; i < m_cNumRowsCached; i++)
                m_pRowsPtr[i] = m_pRowsPtr[i+1];
        }
    }

    if( cErrors )
        if( cErrors == cRows )
            RRETURN( DB_E_ERRORSOCCURRED );
        else
            RRETURN( DB_S_ERRORSOCCURRED );

    RRETURN( S_OK );
}

//----------------------------------------------------------------------------
// RestartPosition
//
// Repositions the next fetch poition to the initial position
//
//----------------------------------------------------------------------------
STDMETHODIMP
CRowset::RestartPosition(
    HCHAPTER hChapter // ignored
    )
{
    CAutoBlock cab(&m_RowsetCritSection);

    m_lLastFetchRow = RESET_ROW;

    RRETURN( S_OK );
}

//----------------------------------------------------------------------------
// FreeRow
//
// Frees the memory used by a row in the rowset cache. Also frees the ADsColumn
// structures contained within the row.
//
//----------------------------------------------------------------------------
void
CRowset::FreeRow(
    ROWBUFFER *pRowBuffer
    )
{
    int               iCol;
    ADS_SEARCH_COLUMN *pADsCol;
    DBSTATUS          *pdbStatus;
    PVARIANT          pVariant;

    CAutoBlock cab(&m_RowsetCritSection);

    // start with column 1. Bookmark column is ignored.
    for(iCol = 1; (DBORDINAL)iCol < m_cCol; iCol++)
    {
        pADsCol = (ADS_SEARCH_COLUMN *) ((char *)pRowBuffer +
                       m_pColData[iCol].dwColOffset +
                       FIELD_OFFSET(OLEDBDATA, ,adsSearchCol));
        pdbStatus = (DBSTATUS *) ( m_pColData[iCol].dwColOffset +
                       FIELD_OFFSET(OLEDBDATA, dbStatus) +
                       (char *)pRowBuffer );

        if( *pdbStatus != DBSTATUS_S_ISNULL )
        {
            if( (DBSTATUS_S_OK == *pdbStatus) &&
                ((m_pColData[iCol].wType & (~DBTYPE_BYREF)) == DBTYPE_VARIANT) )
            // variant (or variant array) needs to be freed
            {
                pVariant = *(PVARIANT *) ( (m_pColData[iCol].dwColOffset +
                               FIELD_OFFSET(OLEDBDATA, OledbValue) +
                               (char *)pRowBuffer) );

                if( V_VT(pVariant) & VT_ARRAY )
                    SafeArrayDestroy(V_ARRAY(pVariant));
                else
                    VariantClear(pVariant);

                FreeADsMem(pVariant);
            }

            // ignore error return
            m_pCRowProvider->_pDSSearch->FreeColumn(pADsCol);
        }
    }

    if( FALSE == m_fadsPathPresent )
        // ignore error return
        m_pCRowProvider->_pDSSearch->FreeColumn(&(pRowBuffer->adsSearchCol));

    FreeADsMem(pRowBuffer);

    return;
}

//-----------------------------------------------------------------------------
// GetADsPathFromHROW
//
// Gets the ADsPath corresponding to a HROW. This function is called by
// GetURLFromHROW, only if m_fadsPathPresent is FALSE.
//
//-----------------------------------------------------------------------------
HRESULT
CRowset::GetADsPathFromHROW(
    HROW hRow,
    ADS_CASE_IGNORE_STRING *padsPath
    )
{
    LONG      lRowIndex;
    ROWBUFFER *pRowBuffer;

    ADsAssert(FALSE == m_fadsPathPresent);

    CAutoBlock cab(&m_RowsetCritSection);

    lRowIndex = HROWToIndex(hRow);
    if( (lRowIndex < 0) || (lRowIndex >= m_cNumRowsCached) )
        RRETURN(E_HANDLE);

    // Get pointer to the specified row
    pRowBuffer = m_pRowsPtr[lRowIndex];
    ADsAssert( pRowBuffer != NULL );
    if( RefCount(pRowBuffer) <= 0 )
        RRETURN(E_HANDLE);

    if( NULL == padsPath )
        RRETURN(E_INVALIDARG);
    *padsPath =
        pRowBuffer->adsSearchCol.pADsValues[0].CaseIgnoreString;

    RRETURN( S_OK );
}

//-----------------------------------------------------------------------------
// IUnknown methods
//-----------------------------------------------------------------------------

STDMETHODIMP
CRowset::QueryInterface(
    THIS_ REFIID riid,
    LPVOID FAR* ppvObj
    )
{
    if( NULL == ppvObj )
        RRETURN( E_INVALIDARG );

    *ppvObj = NULL;

    if( IsEqualIID(riid, IID_IUnknown) )
        *ppvObj = (IUnknown FAR *) ((IAccessor *) this);
    else if( IsEqualIID(riid, IID_IAccessor) )
        *ppvObj = (IAccessor FAR *) this;
    else if( IsEqualIID(riid, IID_IColumnsInfo) )
        *ppvObj = (IColumnsInfo FAR *) this;
    else if( IsEqualIID(riid, IID_IConvertType) )
        *ppvObj = (IConvertType FAR *) this;
#if (!defined(BUILD_FOR_NT40))
    else if( IsEqualIID(riid, IID_IGetRow) )
        *ppvObj = (IGetRow FAR *) this;
#endif
    else if( IsEqualIID(riid, IID_IRowset) )
        *ppvObj = (IRowset FAR *) this;
    else if( IsEqualIID(riid, IID_IRowsetIdentity) )
        *ppvObj = (IRowsetIdentity FAR *) this;
    else if( IsEqualIID(riid, IID_IRowsetInfo) )
        *ppvObj = (IRowsetInfo FAR *) this;
    else if( IsEqualIID(riid, IID_IRowsetLocate) )
        *ppvObj = (IRowsetLocate FAR *) this;
    else if( IsEqualIID(riid, IID_IRowsetScroll) )
        *ppvObj = (IRowsetScroll FAR *) this;
    else
         RRETURN( E_NOINTERFACE );

    AddRef();
    RRETURN( S_OK );
}

//-----------------------------------------------------------------------------
// AddRef
//
// Increments reference count of this object
//
//-----------------------------------------------------------------------------
STDMETHODIMP_(ULONG)
CRowset::AddRef(
    void
    )
{
    CAutoBlock cab(&m_RowsetCritSection);

    ADsAssert(((LONG)m_cRef) >= 0);

    return ++m_cRef;
}

//-----------------------------------------------------------------------------
// Release
//
// Decrements reference count of this object
//
//-----------------------------------------------------------------------------
STDMETHODIMP_(ULONG)
CRowset::Release(
    void
    )
{
    CAutoBlock cab(&m_RowsetCritSection);

    ADsAssert(m_cRef > 0);

    m_cRef--;

    if( 0 == m_cRef )
    {
        cab.UnBlock();
        delete this;

        return 0;
    }

    return m_cRef;
}

//-----------------------------------------------------------------------------
// IAccessor methods
//-----------------------------------------------------------------------------
STDMETHODIMP
CRowset::AddRefAccessor(
    HACCESSOR  hAccessor,
    DBREFCOUNT *pcRefCount
    )
{
    ADsAssert(m_pCAccessor);

    RRETURN( m_pCAccessor->AddRefAccessor(hAccessor, pcRefCount) );
}

STDMETHODIMP
CRowset::CreateAccessor(
    DBACCESSORFLAGS dwAccessorFlags,
    DBCOUNTITEM     cBindings,
    const DBBINDING rgBindings[],
    DBLENGTH        cbRowSize,
    HACCESSOR *     phAccessor,
    DBBINDSTATUS    rgStatus[]
    )
{
    ADsAssert(m_pCAccessor);

    RRETURN(m_pCAccessor->CreateAccessor(
                    dwAccessorFlags,
                    cBindings,
                    rgBindings,
                    cbRowSize,
                    phAccessor,
                    rgStatus)
                    );
}

STDMETHODIMP
CRowset::ReleaseAccessor(
     HACCESSOR  hAccessor,
     DBREFCOUNT *pcRefCount
     )
{
    ADsAssert(m_pCAccessor);

    RRETURN( m_pCAccessor->ReleaseAccessor(
                    hAccessor,
                    pcRefCount)
                    );
}

STDMETHODIMP
CRowset::GetBindings(
    HACCESSOR         hAccessor,
    DBACCESSORFLAGS * pdwAccessorFlags,
    DBCOUNTITEM *     pcBindings,
    DBBINDING **      prgBindings
    )
{
    ADsAssert(m_pCAccessor);

    RRETURN( m_pCAccessor->GetBindings(
                    hAccessor,
                    pdwAccessorFlags,
                    pcBindings,
                    prgBindings)
                    );
}

//-----------------------------------------------------------------------------
// IColumnsInfo methods
//-----------------------------------------------------------------------------
STDMETHODIMP
CRowset::GetColumnInfo(
    DBORDINAL       *pcColumns,
    DBCOLUMNINFO    **pprgInfo,
    WCHAR **        ppStringBuffer
    )
{
    ADsAssert(m_pIColumnsInfo);

    RRETURN( m_pIColumnsInfo->GetColumnInfo(
                    pcColumns,
                    pprgInfo,
                    ppStringBuffer)
                    );
}

STDMETHODIMP
CRowset::MapColumnIDs(
    DBORDINAL  cColumnIDs,
    const DBID rgColumnIDs[],
    DBORDINAL  rgColumns[]
    )
{
    ADsAssert(m_pIColumnsInfo);

    RRETURN( m_pIColumnsInfo->MapColumnIDs(
                    cColumnIDs,
                    rgColumnIDs,
                    rgColumns)
                    );
}

//-----------------------------------------------------------------------------
// IConvertType methods (mandatory for IRowset)
//-----------------------------------------------------------------------------
STDMETHODIMP
CRowset::CanConvert(
    DBTYPE         wFromType,
    DBTYPE         wToType,
    DBCONVERTFLAGS dwConvertFlags
    )
{
    HRESULT hr;

    if( dwConvertFlags & DBCONVERTFLAGS_PARAMETER ) // not allowed on rowset
        RRETURN( DB_E_BADCONVERTFLAG );

    if( (dwConvertFlags & (~(DBCONVERTFLAGS_ISLONG |
                            DBCONVERTFLAGS_ISFIXEDLENGTH |
                            DBCONVERTFLAGS_FROMVARIANT))) !=
                            DBCONVERTFLAGS_COLUMN )
        RRETURN( DB_E_BADCONVERTFLAG );

    if( dwConvertFlags & DBCONVERTFLAGS_ISLONG )
    {
        DBTYPE wType;

        wType = wFromType & (~(DBTYPE_BYREF | DBTYPE_ARRAY | DBTYPE_VECTOR));

        // wType has to be variable-length DBTYPE
        if( (wType != DBTYPE_STR) && (wType != DBTYPE_WSTR) &&
            (wType != DBTYPE_BYTES) && (wType != DBTYPE_VARNUMERIC) )
            RRETURN( DB_E_BADCONVERTFLAG );
    }

    // CreateAccessor returns error for ARRAY and VECTOR types. So we cannot
    // convert to these types.
    if( (wToType & DBTYPE_ARRAY) || (wToType & DBTYPE_VECTOR) )
        RRETURN( S_FALSE );

    if( dwConvertFlags & DBCONVERTFLAGS_FROMVARIANT )
    {
        DBTYPE dbTmpType, wVtType;

        wVtType = wFromType & VT_TYPEMASK;

        // Take out all of the Valid VT_TYPES (36 is VT_RECORD in VC 6)
        if( (wVtType > VT_DECIMAL && wVtType < VT_I1) ||
            ((wVtType > VT_LPWSTR && wVtType < VT_FILETIME) && wVtType !=36) ||
            (wVtType > VT_CLSID) )
            RRETURN( DB_E_BADTYPE );

        dbTmpType = wToType & (~DBTYPE_BYREF);
        if( DBTYPE_VARIANT == dbTmpType )
        // GetData will do the right thing, so return TRUE.
            RRETURN( S_OK );
    }

    // GetData handles VARIANT to VARIANT conversions, so special check here
    if( (DBTYPE_VARIANT == (wFromType & (~DBTYPE_BYREF))) &&
        (DBTYPE_VARIANT == (wToType & (~DBTYPE_BYREF))) )
        RRETURN( S_OK );

    ADsAssert( m_pIDataConvert != NULL );

    hr = m_pIDataConvert->CanConvert(wFromType, wToType);

    RRETURN( (E_INVALIDARG == hr)? S_FALSE : hr );
}

//-----------------------------------------------------------------------------
// IGetRow methods
//-----------------------------------------------------------------------------
STDMETHODIMP
CRowset::GetRowFromHROW(
    IUnknown  *pUnkOuter,
    HROW      hRow,
    REFIID    riid,
    IUnknown  **ppUnk
    )
{
    ADsAssert(m_pCRowsetInfo);

    RRETURN( m_pCRowsetInfo->GetRowFromHROW(
                     pUnkOuter,
                     hRow,
                     riid,
                     ppUnk,
                     TRUE, // this ia tear-off row
                     m_fAllAttrs)
                     );
}

STDMETHODIMP
CRowset::GetURLFromHROW(
    HROW     hRow,
    LPOLESTR *ppwszURL
    )
{
    ADsAssert(m_pCRowsetInfo);

    RRETURN( m_pCRowsetInfo->GetURLFromHROW(hRow, ppwszURL) );
}

//-----------------------------------------------------------------------------
// IRowsetIdentity methods
//-----------------------------------------------------------------------------
STDMETHODIMP
CRowset::IsSameRow(
    HROW hRow1,
    HROW hRow2
    )
{
    LONG      lIndex1, lIndex2;
    ROWBUFFER *pRowBuffer1, *pRowBuffer2;

    lIndex1 = HROWToIndex(hRow1);
    lIndex2 = HROWToIndex(hRow2);

    if( (lIndex1 < 0) || (lIndex1 >= m_cNumRowsCached) ||
        (lIndex2 < 0) || (lIndex2 >= m_cNumRowsCached) )
        RRETURN( DB_E_BADROWHANDLE );

    // Get pointer to the specified row
    pRowBuffer1 = m_pRowsPtr[lIndex1];
    pRowBuffer2 = m_pRowsPtr[lIndex2];
    ADsAssert( (pRowBuffer1 != NULL) && (pRowBuffer2 != NULL) );
    if( (RefCount(pRowBuffer1) <= 0) || (RefCount(pRowBuffer2) <= 0) )
        RRETURN( DB_E_BADROWHANDLE );

    if( lIndex1 == lIndex2 )
        RRETURN( S_OK );
    else
        RRETURN( S_FALSE );
}

//-----------------------------------------------------------------------------
// IRowsetInfo methods
//-----------------------------------------------------------------------------
STDMETHODIMP
CRowset::GetProperties(
    const ULONG       cPropertyIDSets,
    const DBPROPIDSET rgPropertyIDSets[],
    ULONG             *pcPropertySets,
    DBPROPSET         **pprgPropertySets
    )
{
    ADsAssert( m_pCUtilProp );

    // Check arguments for error
    HRESULT hr = m_pCUtilProp->GetPropertiesArgChk(
                            cPropertyIDSets,
                            rgPropertyIDSets,
                            pcPropertySets,
                            pprgPropertySets,
                            PROPSET_COMMAND);

    if( FAILED(hr) )
        RRETURN( hr );

    RRETURN( m_pCUtilProp->GetProperties(
                            cPropertyIDSets,
                            rgPropertyIDSets,
                            pcPropertySets,
                            pprgPropertySets,
                            PROPSET_COMMAND) );
}

STDMETHODIMP
CRowset::GetReferencedRowset(
    DBORDINAL   iOrdinal,
    REFIID      riid,
    IUnknown    **ppReferencedRowset
    )
{
    ADsAssert(m_pCRowsetInfo);

    RRETURN( m_pCRowsetInfo->GetReferencedRowset(
                iOrdinal,
                riid,
                ppReferencedRowset)
                );
}

STDMETHODIMP
CRowset::GetSpecification(
    REFIID      riid,
    IUnknown    **ppSpecification
    )
{
    ADsAssert(m_pCRowsetInfo);

    RRETURN( m_pCRowsetInfo->GetSpecification(
                riid,
                ppSpecification)
                );
}

//----------------------------------------------------------------------------- // IRowsetLocate methods
//-----------------------------------------------------------------------------
STDMETHODIMP
CRowset::Compare(
    HCHAPTER   hChapter,
    DBBKMARK   cbBookmark1,
    const BYTE *pBookmark1,
    DBBKMARK   cbBookmark2,
    const BYTE *pBookmark2,
    DBCOMPARE  *pComparison
    )
{
    if( (0 == cbBookmark1) || (0 == cbBookmark2) || (NULL == pComparison) ||
        (NULL == pBookmark1) || (NULL == pBookmark2) )
        RRETURN( E_INVALIDARG );

    if( STD_BMK_SIZE == cbBookmark1 )
    {
        if( (*pBookmark1 != DBBMK_FIRST) && (*pBookmark1 != DBBMK_LAST) )
            RRETURN( DB_E_BADBOOKMARK );
    }
    else
        if( ADSI_BMK_SIZE != cbBookmark1 )
            RRETURN( DB_E_BADBOOKMARK );

    if( STD_BMK_SIZE == cbBookmark2 )
    {
        if( (*pBookmark2 != DBBMK_FIRST) && (*pBookmark2 != DBBMK_LAST) )
            RRETURN( DB_E_BADBOOKMARK );
    }
    else
        if( ADSI_BMK_SIZE != cbBookmark2 )
            RRETURN( DB_E_BADBOOKMARK );

    if( (STD_BMK_SIZE == cbBookmark1) || (STD_BMK_SIZE == cbBookmark2) )
    // standard bookmarks can only be compared for equality (not for <, >)
    {
        if( cbBookmark1 != cbBookmark2 )
            *pComparison = DBCOMPARE_NE;
        else if( *pBookmark1 == *pBookmark2 )
            *pComparison = DBCOMPARE_EQ;
        else
            *pComparison = DBCOMPARE_NE;
    }
    else
    {
        if( (*((RBOOKMARK *)pBookmark1)) <  (*((RBOOKMARK *)pBookmark2)) )
            *pComparison = DBCOMPARE_LT;
        else if( (*((RBOOKMARK *)pBookmark1)) >  (*((RBOOKMARK *)pBookmark2)) )
            *pComparison = DBCOMPARE_GT;
        else
            *pComparison = DBCOMPARE_EQ;
    }

    RRETURN( S_OK );
}

STDMETHODIMP
CRowset::Hash(
    HCHAPTER        hChapter,
    DBBKMARK        cBookmarks,
    const DBBKMARK  rgcbBookmarks[],
    const BYTE      *rgpBookmarks[],
    DBHASHVALUE     rgHashedValues[],
    DBROWSTATUS     rgBookmarkStatus[]
    )
{
    int  i;
    HRESULT hr;
    DBBKMARK cErrors = 0;

    if( (NULL == rgHashedValues) || ((cBookmarks != 0) &&
                  ((NULL == rgpBookmarks) || (NULL == rgcbBookmarks))) )
        RRETURN( E_INVALIDARG );

    if( 0 == cBookmarks )
        RRETURN( S_OK );

    for(i = 0; (DBBKMARK)i < cBookmarks; i++)
    {
        if( (rgcbBookmarks[i] != ADSI_BMK_SIZE) || (NULL == rgpBookmarks[i]) )
        {
            cErrors++;
            if( rgBookmarkStatus )
                rgBookmarkStatus[i] = DBROWSTATUS_E_INVALID;
        }
        else
        {
            LONG lRow;

            hr = BmkToRow(rgcbBookmarks[i], rgpBookmarks[i], &lRow);
            if( FAILED(hr) )
            {
                cErrors++;
                if( rgBookmarkStatus )
                    rgBookmarkStatus[i] = DBROWSTATUS_E_INVALID;

                continue;
            }

            rgHashedValues[i] = (DWORD) lRow;
            if( rgBookmarkStatus )
                rgBookmarkStatus[i] = DBROWSTATUS_S_OK;
        }
    }

    if( cErrors )
    {
        if( cErrors == cBookmarks )
            RRETURN( DB_E_ERRORSOCCURRED );
        else
            RRETURN( DB_S_ERRORSOCCURRED );
    }
    else
        RRETURN( S_OK );
}

STDMETHODIMP
CRowset::GetRowsByBookmark(
    HCHAPTER       hChapter,
    DBCOUNTITEM    cRows,
    const DBBKMARK rgcbBookmarks[],
    const BYTE     *rgpBookmarks[],
    HROW           rghRows[],
    DBROWSTATUS    rgRowStatus[]
    )
{
    int           i;
    HRESULT       hr;
    DBCOUNTITEM   cRowsObtained = 0, cErrors = 0;

    if( (NULL == rghRows) || (NULL == rgcbBookmarks) || (NULL== rgpBookmarks) )
        RRETURN( E_INVALIDARG );

    if( 0 == cRows )
        RRETURN( S_OK );

    for(i = 0; (DBCOUNTITEM)i < cRows; i++)
    {
        if( (rgcbBookmarks[i] != ADSI_BMK_SIZE) || (NULL == rgpBookmarks[i]) )
        {
            cErrors++;
            if( rgRowStatus )
                rgRowStatus[i] = DBROWSTATUS_E_INVALID;
            rghRows[i] = DB_NULL_HROW;
        }
        else
        {
            HROW *phRow;

            phRow = &rghRows[i];
            hr = GetRowsAt(NULL, hChapter, rgcbBookmarks[i],
                           (BYTE *) rgpBookmarks[i], 0, 1, &cRowsObtained,
                           &phRow
                          );
            if( 1 == cRowsObtained )
            {
                if( rgRowStatus )
                    rgRowStatus[i] = DBROWSTATUS_S_OK;
            }
            else
            {
                cErrors++;
                rghRows[i] = DB_NULL_HROW;
                if( rgRowStatus )
                {
                    if( DB_S_ROWLIMITEXCEEDED == hr )
                        rgRowStatus[i] = DBROWSTATUS_E_LIMITREACHED;
                    else if ( E_OUTOFMEMORY == hr )
                        rgRowStatus[i] = DBROWSTATUS_E_OUTOFMEMORY;
                    else
                       rgRowStatus[i] = DBROWSTATUS_E_INVALID;
                 }
             } // else
        } // else
    } // for

    if( cErrors )
    {
        if( cErrors == cRows )
            RRETURN( DB_E_ERRORSOCCURRED );
        else
            RRETURN( DB_S_ERRORSOCCURRED );
    }
    else
        RRETURN( S_OK );
}

//----------------------------------------------------------------------------
// IRowsetScroll methods
//----------------------------------------------------------------------------
STDMETHODIMP
CRowset::GetApproximatePosition(
    HCHAPTER      hChapter,
    DBBKMARK      cbBookmark,
    const BYTE    *pBookmark,
    DBCOUNTITEM   *pulPosition,
    DBCOUNTITEM   *pcRows
    )
{
    LONG    cRows = 0;
    HRESULT hr;

    if( (cbBookmark != 0) && ( NULL == pBookmark) )
        RRETURN( E_INVALIDARG );

    CAutoBlock cab(&m_RowsetCritSection);

    if( pcRows )
    // get the total number of rows in the rowset
    {
        hr = SeekToEnd();
        if( FAILED(hr) )
            RRETURN( E_FAIL );

        cRows = m_lCurrentRow - 1;
    }

    if( 0 == cbBookmark )
    {
        if( pcRows )
            *pcRows = cRows;
        RRETURN( S_OK );
    }
    else if( (cbBookmark != ADSI_BMK_SIZE) && (cbBookmark != STD_BMK_SIZE) )
        RRETURN( DB_E_BADBOOKMARK );
    else
    {
        LONG lRow;

        hr = BmkToRow(cbBookmark, pBookmark, &lRow);
        if( FAILED(hr) )
        {
            if( DB_E_BADBOOKMARK == hr )
                RRETURN( DB_E_BADBOOKMARK );
            else
                RRETURN( E_FAIL );
        }

        if( pulPosition )
        {
            *pulPosition = lRow + 1;   // this number is 1-based
            if( pcRows && (*pulPosition > (DBCOUNTITEM)cRows) ) // bookmark was bad
                *pulPosition = cRows;  // make sure *pulPosition <= *pcRows
        }

        if( pcRows )
            *pcRows = cRows;
    }

    RRETURN( S_OK );
}

STDMETHODIMP
CRowset::GetRowsAtRatio(
    HWATCHREGION hReserved1,
    HCHAPTER     hChapter,
    DBCOUNTITEM  ulNumerator,
    DBCOUNTITEM  ulDenominator,
    DBROWCOUNT   cRows,
    DBCOUNTITEM  *pcRowsObtained,
    HROW         **prghRows
    )
{
    HRESULT   hr;
    LONG      lStartRow, cTotalRows;
    RBOOKMARK StartRowBmk;

    if( (NULL == pcRowsObtained) || (NULL == prghRows) )
    {
        if( pcRowsObtained != NULL )
            *pcRowsObtained = 0;
        RRETURN( E_INVALIDARG );
    }

    *pcRowsObtained = 0;

    if( (ulNumerator > ulDenominator) || (0 == ulDenominator) )
        RRETURN( DB_E_BADRATIO );

    if( ((ulNumerator == ulDenominator) && (cRows > 0)) ||
        ((0 == ulNumerator) && (cRows < 0)) )
        RRETURN( DB_S_ENDOFROWSET );

    if( 0 == cRows )
        RRETURN( S_OK );

    CAutoBlock cab(&m_RowsetCritSection);

    // get total number of rows
    hr = SeekToEnd();
    if( FAILED(hr) )
        RRETURN( E_FAIL );

    cTotalRows = m_lCurrentRow - 1;

    // Make sure ratio of 1 sets lStartRow to cTotalRows -1 (last row)
    lStartRow = (long)((((double) ulNumerator)/ulDenominator) *
                                                        (cTotalRows - 1));
    StartRowBmk = RowToBmk(lStartRow);

    hr = GetRowsAt(NULL, hChapter, ADSI_BMK_SIZE, (BYTE *) &StartRowBmk,
                         0, cRows, pcRowsObtained, prghRows);

    RRETURN( hr );
}

//----------------------------------------------------------------------------