//-------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1992 - 1995
//
//  File:  caccess.cxx
//
//  Contents:  Microsoft OleDB/OleDS Data Source Object for ADSI
//
//             CImpIAccessor object implementing the IAccessor interface.
//
//  History:   10-01-96     shanksh    Created.
//-------------------------------------------------------------------------

#include "oleds.hxx"
#pragma hdrstop

//-------------------------------------------------------------------------
// CImpIAccessor::CImpIAccessor
//
// CImpIAccessor constructor.
//
//-------------------------------------------------------------------------

CImpIAccessor::CImpIAccessor (
    void      *pParentObj,        //@parm IN | Parent object pointer
    LPUNKNOWN pUnkOuter            //@parm IN | Outer Unknown pointer
    )
{
    //    Initialize simple member vars
    _pUnkOuter   = pUnkOuter;
    _pObj        = pParentObj;
    _pextbuffer  = NULL;
    _dwStatus    = 0;
    _pIDC        = NULL;
    _fCriticalSectionInitialized = FALSE;
    _pIMalloc = NULL;

    ENLIST_TRACKING(CImpIAccessor);

    return;
}


//-------------------------------------------------------------------------
// CImpIAccessor::~CImpIAccessor
//
// @mfunc CImpIAccessor destructor.
//
// @rdesc NONE
//-------------------------------------------------------------------------

CImpIAccessor::~CImpIAccessor (
    void
    )
{
    ULONG_PTR         hAccessor,   hAccessorLast;
    PADSACCESSOR pADsaccessor, pADsaccessorBadHandle;

    // Cleanup only if there's anything to clean.
    if( _pextbuffer ) {
        // Get a pointer to the special "BadHandle" accessor.
        _pextbuffer->GetItemOfExtBuffer(hAccessorBadHandle, &pADsaccessorBadHandle);

        // Get the number of available accessor handles.
        _pextbuffer->GetLastItemHandle(hAccessorLast);

        // Loop through the reminding accessor handles deleting those which
        // are referenced only by this object and refcount decrementing the
        // other ones
        for (hAccessor =1; hAccessor <=hAccessorLast; hAccessor++) {
            // Get a pointer to the next accessor.
            _pextbuffer->GetItemOfExtBuffer(hAccessor, &pADsaccessor);

            // For valid accessors just delete them.
            if( pADsaccessor != pADsaccessorBadHandle )
                DeleteADsAccessor(pADsaccessor);
        }
        // Now delete the buffer which holds accessor handles.
        delete _pextbuffer;
    }

    if( _pIMalloc )
        _pIMalloc->Release();

    if( _pIDC )
        _pIDC->Release();

    // Get rid of the critical section.
    if (_fCriticalSectionInitialized)
    {
        DeleteCriticalSection(&_criticalsectionAccessor);
    }

    return;
}


//-------------------------------------------------------------------------
// CImpIAccessor::FInit
//
// @mfunc Initialize the Accessor implementation object.
//
// @rdesc Did the Initialization Succeed
//         @flag S_OK               initialization succeeded,
//         @flag E_OUTOFMEMORY      initialization failed because of
//                                  memory allocation problem,
//-------------------------------------------------------------------------

STDMETHODIMP
CImpIAccessor::FInit (
    void
    )
{
    HRESULT hr;
    PADSACCESSOR pADsaccessorBadHandle;

    // Prepare a special, "Bad Handle" accessor.
    pADsaccessorBadHandle = (PADSACCESSOR)((BYTE *)&_dwGetDataTypeBadHandle);
    _dwGetDataTypeBadHandle = ACCESSORTYPE_INERROR;

    // Create the ExtBuffer array to hold pointers to malloc'd accessors.
    _pextbuffer = (LPEXTBUFF) new CExtBuff;
    if (_pextbuffer == NULL    ||
        !(_pextbuffer->FInit(
              sizeof(PADSACCESSOR),
              &pADsaccessorBadHandle
              ) ))
                RRETURN( E_OUTOFMEMORY );

    if( !_pIDC ) {
        hr = CoCreateInstance(
                 CLSID_OLEDB_CONVERSIONLIBRARY,
                 NULL,
                 CLSCTX_INPROC_SERVER,
                 IID_IDataConvert,
                 (void **)&_pIDC
                 );
        if ( FAILED(hr) ) {
            RRETURN (hr);
                }
    }

    hr = CoGetMalloc(MEMCTX_TASK, &_pIMalloc);

    if (SUCCEEDED(hr))
    {
        try
        {
            // This section is for serializing &CreateAccessor.
            InitializeCriticalSection(&_criticalsectionAccessor);

            _fCriticalSectionInitialized = TRUE;
        }
        catch(...)
        {
            hr = E_FAIL;
        }
    }

    RRETURN (hr);
}



//-------------------------------------------------------------------------
// CImpIAccessor::AddRefAccessor
//
// @mfunc Adds a reference count to an existing accessor.
//
// @rdesc Did release of the accessor Succeed
//         @flag S_OK                   | accessor addrefed successfully,
//         @flag DB_E_BADACCESSORHANDLE | accessor could not be addrefed
//                                        because its handle was invalid.
//-------------------------------------------------------------------------

STDMETHODIMP CImpIAccessor::AddRefAccessor(
    HACCESSOR   hAccessor,    //@parm IN  | handle of the accessor to release
    DBREFCOUNT *pcRefCounts    //@parm OUT | count of references
    )
{
    PADSACCESSOR pADsaccessor, pADsaccessorBadHandle;
    HRESULT hr;

    // Clear in case of error below.
    if( pcRefCounts )
        *pcRefCounts = 0;

    CAutoBlock     cab( &(_criticalsectionAccessor) );

    // Get a pointer to the accessor.
    _pextbuffer->GetItemOfExtBuffer(hAccessor, &pADsaccessor);

    // Get a pointer to the special "BadHandle" accessor.
    _pextbuffer->GetItemOfExtBuffer(hAccessorBadHandle, &pADsaccessorBadHandle);

    // If the handle is valid
    if (pADsaccessor != pADsaccessorBadHandle) {
        if (pADsaccessor->cRef <= 0)
            BAIL_ON_FAILURE( hr = E_FAIL );

        pADsaccessor->cRef++;

        if (pcRefCounts)
            *pcRefCounts = pADsaccessor->cRef;

        RRETURN( S_OK );
    }
    // otherwise complain about a bad handle.
    else
        RRETURN( DB_E_BADACCESSORHANDLE );

error:

    RRETURN( hr );
}



//-------------------------------------------------------------------------
// CImpIAccessor::CreateAccessor
//
// @mfunc Creates an accessor, which is a set of bindings that can be used to
// send data to or retrieve data from the data cache. The method performs
// extensive validations on the input bindings which include verification of
// the access type requested, column availability, data conversions involved,
// etc.
//
// @rdesc Returns one of the following values:
//    S_OK                    | creation of the accessor succeeded,
//    E_INVALIDARG            | creation of the accessor failed because
//                              phAccessor was a NULL pointer,
//    E_OUTOFMEMORY           | creation of the accessor failed because of
//                              memory allocation problem,
//    DB_E_CANTCREATEACCESSOR | DBROWSETFLAGS_MULTIPLEACCESSOR flag was not
//                              set and a row-fetching method has already
//                              been called.
//    OTHER                   | other result codes returned by called functions.
//-------------------------------------------------------------------------

STDMETHODIMP CImpIAccessor::CreateAccessor(
    DBACCESSORFLAGS dwAccessorFlags,
    DBCOUNTITEM     cBindings,
    const DBBINDING rgBindings[],
    DBLENGTH        cbRowSize,
    HACCESSOR       *phAccessor,
    DBBINDSTATUS    rgStatus[]
    )
{
    PADSACCESSOR pADsaccessor;
    ULONG_PTR hADsaccessor;
    HRESULT hr;
    ULONG dwGetDataType, dwSetDataType;
    DBCOUNTITEM ibind;
    BOOL fProviderOwned;
    DBBINDSTATUS bindstatus;
    ULONG wMask, wBaseType;

    if (phAccessor)
        *phAccessor = (HACCESSOR)0;

    // At the creation of the CAutoBlock object a critical section
    // is entered. Concurrent calls to CreateAccessor are entirely
    // legal but their interleaving cannot be allowed. The critical
    // section is left when this method terminate and the destructor
    // for CAutoBlock is called.
    CAutoBlock     cab( &(_criticalsectionAccessor) );

    // phAccessor must never be NULL, non-zero bindings count implies a
    // non-NULL array of bindings.
    if( phAccessor == NULL || (cBindings && rgBindings == NULL) )
        RRETURN( E_INVALIDARG );

    // cBindings is 0 and was called on the Command.
    if( cBindings == 0 )
        RRETURN( DB_E_NULLACCESSORNOTSUPPORTED );

    // dwAccessorFlags cannot take any other values than those legal.
    if( dwAccessorFlags & (~DBACCESSOR_VALID_FLAGS) )
        RRETURN( DB_E_BADACCESSORFLAGS );

    // Compute internal types for use by methods using accessors,
    DetermineTypes(
        dwAccessorFlags,
        &dwGetDataType,
        &dwSetDataType
        );

    // and detect possible inconsistencies in AccessorFlags.
    if( dwGetDataType == GD_ACCESSORTYPE_INERROR ||
        dwSetDataType == SD_ACCESSORTYPE_INERROR )
        RRETURN( DB_E_BADACCESSORFLAGS );

    // fix conformance test failure. If BYREF accessors are not supported,
    // (indicated by DBPROP_BYREFACCESSORS being FALSE), we should return 
    // the right error
    else if( (DB_E_BYREFACCESSORNOTSUPPORTED == dwGetDataType) ||
             (DB_E_BYREFACCESSORNOTSUPPORTED == dwSetDataType) )
        RRETURN( DB_E_BYREFACCESSORNOTSUPPORTED );

    // Initialize the status array to DBBINDSTATUS_OK.
    if( rgStatus )
        memset(rgStatus, 0x00, (size_t)(cBindings*sizeof(DBBINDSTATUS)));

    hr             = S_OK;
    fProviderOwned = FALSE;

    // Perform validations that apply to all types of accessors.
    for (ibind=0; ibind < cBindings; ibind++) {
        bindstatus = DBBINDSTATUS_OK;

        if( rgBindings[ibind].dwMemOwner != DBMEMOWNER_PROVIDEROWNED &&
                        rgBindings[ibind].dwMemOwner != DBMEMOWNER_CLIENTOWNED )
            bindstatus = DBBINDSTATUS_BADBINDINFO;

        // The part to be bound must specify one or more out of three values, and
        if( (rgBindings[ibind].dwPart &
            (DBPART_VALUE |DBPART_LENGTH |DBPART_STATUS)) == 0 ||
             // nothing else.
            (rgBindings[ibind].dwPart &
             ~(DBPART_VALUE |DBPART_LENGTH |DBPART_STATUS)) ||
             // Is it a good type to bind to?
            !IsGoodBindingType(rgBindings[ibind].wType) )
            bindstatus = DBBINDSTATUS_BADBINDINFO;

        // DBTYPE_BYREF, DBTYPE_VECTOR and DBTYPE_ARRAY cannot be combined.
        else if( (wMask = (rgBindings[ibind].wType & TYPE_MODIFIERS)) &&
                        wMask != DBTYPE_BYREF &&
                        wMask != DBTYPE_VECTOR &&
                        wMask != DBTYPE_ARRAY )
                        bindstatus = DBBINDSTATUS_BADBINDINFO;

        else if ((wBaseType = (rgBindings[ibind].wType & ~TYPE_MODIFIERS)) ==
                  DBTYPE_EMPTY ||
                 wBaseType == DBTYPE_NULL)
            bindstatus = DBBINDSTATUS_BADBINDINFO;

        // DBTYPE_ARRAY and DBTYPE_VECTOR are not supported types
        else if( (rgBindings[ibind].wType & DBTYPE_ARRAY) ||
                 (rgBindings[ibind].wType & DBTYPE_VECTOR) )
            bindstatus = DBBINDSTATUS_UNSUPPORTEDCONVERSION;

        // dwFlags was DBBINDFLAG_HTML and the type was not a String
        else if ( rgBindings[ibind].dwFlags &&
                  (rgBindings[ibind].dwFlags != DBBINDFLAG_HTML ||
                   (wBaseType != DBTYPE_STR  &&
                    wBaseType != DBTYPE_WSTR &&
                    wBaseType != DBTYPE_BSTR)) )
        {
            // Set Bind status to DBBINDSTATUS_BADBINDINFO
            bindstatus = DBBINDSTATUS_BADBINDINFO;
        }
        else if( rgBindings[ibind].wType == (DBTYPE_RESERVED | DBTYPE_BYREF) )
            bindstatus = DBBINDSTATUS_BADBINDINFO;

        else if( rgBindings[ibind].dwMemOwner == DBMEMOWNER_PROVIDEROWNED ) {
            if( (rgBindings[ibind].wType & TYPE_MODIFIERS) == 0
                && rgBindings[ibind].wType != DBTYPE_BSTR )
                bindstatus = DBBINDSTATUS_BADBINDINFO;
            else
                fProviderOwned = TRUE;
        }

        if( bindstatus != DBBINDSTATUS_OK )
            hr = DB_E_ERRORSOCCURRED;

        if( rgStatus )
            rgStatus[ibind] = bindstatus;
    }

    // Check for errors in the bindings
    BAIL_ON_FAILURE( hr );

    if( fProviderOwned &&
        (dwGetDataType == GD_ACCESSORTYPE_READ ||
         dwGetDataType == GD_ACCESSORTYPE_READ_OPTIMIZED) )
        dwGetDataType = GD_ACCESSORTYPE_READ_COLS_BYREF;

    // Allocate space for the accessor structure.
    pADsaccessor = (ADSACCESSOR *) new BYTE
                                     [(size_t)(sizeof(ADSACCESSOR) + (cBindings ? (cBindings-1) : 0)*
                                                                                           sizeof(DBBINDING))];

        if( pADsaccessor == NULL )
        RRETURN( E_OUTOFMEMORY );

    if( cBindings )
        memcpy(
            &(pADsaccessor->rgBindings[0]),
            &rgBindings[0],
            (size_t)(cBindings*sizeof(DBBINDING))
            );
    pADsaccessor->cBindings = cBindings;

    // For accessors valid for writing fill out a list of columns
    // so that notifications about their changes can be properly issued.
    if( dwSetDataType == SD_ACCESSORTYPE_READWRITE && cBindings ) {
        pADsaccessor->rgcol = new DBORDINAL [ (size_t)cBindings ];
        if( pADsaccessor->rgcol == NULL ) {
            dwSetDataType = SD_ACCESSORTYPE_INERROR;
        }
        else
            for (ibind =0; ibind <cBindings; ibind++)
                (pADsaccessor->rgcol)[ibind] = rgBindings[ibind].iOrdinal;
    }
    else
        pADsaccessor->rgcol = NULL;

    // Allocate DBOBJECT structures supporting IUnknown types.
    for (ibind =0; ibind <cBindings; ibind++)
        pADsaccessor->rgBindings[ibind].pObject = NULL;

    // Set accessor flags now, so that possible accessor cleanup routine would
    // know about additional structures for IUnknown types support.
    pADsaccessor->dwFlags = dwAccessorFlags;

    // Insert the new accessor pointer into the extensible buffer in which
    // accessors are stored.
    if( FAILED(hr = _pextbuffer->InsertIntoExtBuffer(
                         &pADsaccessor,
                         hADsaccessor
                         )) ) {
        DeleteADsAccessor(pADsaccessor);
        RRETURN (hr);
    }

    pADsaccessor->cRef = 1;

    // Fill out the new accessor structure with the binding info.
    //pADsaccessor->obRowData = obRowData;
    pADsaccessor->cbRowSize = cbRowSize;

    // Return the accessor index in the extensible buffer as the accessor
    // handle.
    *phAccessor = (HACCESSOR) hADsaccessor;

    // Now can safely leave.
    RRETURN( NOERROR );

error:

    RRETURN( hr );
}


//-------------------------------------------------------------------------
// CImpIAccessor::DetermineTypes
//
// @mfunc Determines internal accessor type classification for use by GetData,
// SetData and parameter handling code. Each of these has a separate type indicator
// variable and a separate set of defined types. This allows a very efficient
// handling of different accessors by methods that utilize them.
// Types are determined on the basis of AccessorFlags. Incorrect combinations of
// flags result in assignment of INERROR types.
//
// @rdesc NONE
//-------------------------------------------------------------------------

STDMETHODIMP_(void)
CImpIAccessor::DetermineTypes(
    DBACCESSORFLAGS    dwAccessorFlags,
    ULONG            *pdwGetDataType,
    ULONG            *pdwSetDataType
    )
{
    if( dwAccessorFlags & DBACCESSOR_PASSBYREF )
    {
        *pdwGetDataType = (ULONG) DB_E_BYREFACCESSORNOTSUPPORTED;
        *pdwSetDataType = (ULONG) DB_E_BYREFACCESSORNOTSUPPORTED;

        return;
    }
    else if( dwAccessorFlags & DBACCESSOR_PARAMETERDATA )
    {
         *pdwGetDataType = GD_ACCESSORTYPE_INERROR;
         *pdwSetDataType = GD_ACCESSORTYPE_INERROR;
         return;
    }

    // Determine types used in row data manipulations.
    if( dwAccessorFlags & DBACCESSOR_ROWDATA ) {
        // Determine accessor type from the point of
        // view of GetData.
        if( dwAccessorFlags & DBACCESSOR_OPTIMIZED )
            *pdwGetDataType = GD_ACCESSORTYPE_READ_OPTIMIZED;
        else
            *pdwGetDataType = GD_ACCESSORTYPE_READ;

        // Determine accessor type from the point of
        // view of SetData. PASSBYREF is disallowed.
        *pdwSetDataType = SD_ACCESSORTYPE_READWRITE;
    }
    else {
        *pdwGetDataType = GD_ACCESSORTYPE_INERROR;
        *pdwSetDataType = GD_ACCESSORTYPE_INERROR;
    }

    return;
}


//-------------------------------------------------------------------------
// CImpIAccessor::GetBindings
//
// @mfunc Returns bindings of an accessor.
//
// @rdesc Returns one of the following values:
//         S_OK           | getting bindings succeeded,
//         E_INVALIDARG   | getting bindings failed because
//                          pdwAccessorFlags or pcBindings or
//                          prgBindings was a NULL pointer,
//         E_OUTOFMEMORY  | getting bindings failed because memory
//                          allocation for the bindings array failed,
//         OTHER          | other result codes stored on the accessor
//                          object and singifying invalid accessor handle.
//-------------------------------------------------------------------------

STDMETHODIMP CImpIAccessor::GetBindings
(
HACCESSOR         hAccessor,            // IN  | accessor handle
DBACCESSORFLAGS    *pdwAccessorFlags,   // OUT | stores accessor flags
DBCOUNTITEM       *pcBindings,          // OUT | stores # of bindings
DBBINDING        **prgBindings          // OUT | stores array of bindings
)
{
    PADSACCESSOR  pADsaccessor;
    PADSACCESSOR  pADsaccessorBadHandle;
    DBCOUNTITEM   ibind;
    DBOBJECT     *pObject;

    if( pcBindings )
       *pcBindings = 0;

    if( prgBindings )
        *prgBindings = NULL;

    if( pdwAccessorFlags )
        *pdwAccessorFlags = DBACCESSOR_INVALID;

    // Are arguments valid?
    if( pdwAccessorFlags == NULL || pcBindings == NULL || prgBindings == NULL )
        RRETURN( E_INVALIDARG );

    // Obtain pointer to the accessor to be used.
    _pextbuffer->GetItemOfExtBuffer(hAccessor, &pADsaccessor);

    // Get a pointer to the special "BadHandle" accessor.
    _pextbuffer->GetItemOfExtBuffer(hAccessorBadHandle, &pADsaccessorBadHandle);

    // Recognize bad accessor handles and return appropriate HRESULT.
    if( pADsaccessor == pADsaccessorBadHandle )
        return DB_E_BADACCESSORHANDLE;

    // If necessary allocate the array of binding structures.
    if( pADsaccessor->cBindings ) {
        *prgBindings = (DBBINDING *) _pIMalloc->Alloc((ULONG)(
                           pADsaccessor->cBindings*sizeof(DBBINDING) ));

        if( *prgBindings == NULL )
            RRETURN ( E_OUTOFMEMORY );

        // Copy bindings.
        memcpy(
            *prgBindings,
            pADsaccessor->rgBindings,
            (size_t)(pADsaccessor->cBindings*sizeof(DBBINDING))
            );

        // Loop through bindings and allocate and copy DBOBJECT structs.
        for (ibind=0; ibind <pADsaccessor->cBindings; ibind++) {
            // If the accessor had failed bindings for SetData, we have
            // overloaded an unused structure member with status info, and
            // this needs to be cleaned now.
            (*prgBindings)[ibind].pTypeInfo = NULL;

            if( (*prgBindings)[ibind].pObject ) {
                pObject = (DBOBJECT *) _pIMalloc->Alloc( sizeof(DBOBJECT) );
                if( pObject ) {
                    memcpy(
                        pObject,
                        (*prgBindings)[ibind].pObject,
                        sizeof(DBOBJECT)
                        );
                    (*prgBindings)[ibind].pObject = pObject;
                }
                else {
                    while (ibind--)
                        if( (*prgBindings)[ibind].pObject )
                            _pIMalloc->Free((*prgBindings)[ibind].pObject);

                    _pIMalloc->Free( *prgBindings );
                    *prgBindings = NULL;
                    RRETURN( E_OUTOFMEMORY );
                }
            }
        }
    }

    // Return the count of bindings,
    *pcBindings = pADsaccessor->cBindings;
    // and accessor flags.
    *pdwAccessorFlags = (pADsaccessor->dwFlags & ~DBACCESSOR_REFERENCES_BLOB);

    return S_OK;
}



//-------------------------------------------------------------------------
// CImpIAccessor::ReleaseAccessor
//
// @mfunc Releases accessor. If accessor handle is valid the corresponding accessor
// is either freed (if no one else is using it) or its ref count is decremented.
//
// @rdesc Did release of the accessor Succeed
//         @flag S_OK                      | accessor released successfully,
//         @flag DB_E_BADACCESSORHANDLE | accessor could not be released because its
//                                     | handle was invalid.
//-------------------------------------------------------------------------

STDMETHODIMP CImpIAccessor::ReleaseAccessor
(
HACCESSOR    hAccessor,        //@parm IN  | handle of the accessor to release
DBREFCOUNT  *pcRefCounts    //@parm OUT | ref count of the released accessor
)
{
    PADSACCESSOR pADsaccessor, pADsaccessorBadHandle;

    if( pcRefCounts )
        *pcRefCounts = 0;

    CAutoBlock     cab( &(_criticalsectionAccessor) );

    // Get a pointer to the accessor.
    _pextbuffer->GetItemOfExtBuffer(hAccessor, &pADsaccessor);

    // Get a pointer to the special "BadHandle" accessor.
    _pextbuffer->GetItemOfExtBuffer(hAccessorBadHandle, &pADsaccessorBadHandle);

    // If the handle is valid
    if( pADsaccessor != pADsaccessorBadHandle ) {
        ADsAssert(pADsaccessor->cRef > 0);

        // Delete if no one else is    using it, otherwise
        if( pADsaccessor->cRef == 1 ) {
            // Delete the accessor structure itself, as well as allocations
            // hanging off this structure.
            DeleteADsAccessor(pADsaccessor);

            // Make sure this handle is marked as "Bad" for future.
            _pextbuffer->DeleteFromExtBuffer(hAccessor);
        }
        // decrement the refcount.
        else {
            pADsaccessor->cRef--;

            if( pcRefCounts )
                *pcRefCounts = pADsaccessor->cRef;
        }

        return NOERROR;
    }
    // otherwise complain about a bad handle.
    else
                RRETURN( DB_E_BADACCESSORHANDLE );
}

//-------------------------------------------------------------------------
// CImpIAccessor::DeleteADsAccessor
//
// @mfunc Deletes structures hanging off the ADSACCESSOR and then deletes the
// accessor structure itself.
//
// @rdesc NONE
//-------------------------------------------------------------------------

STDMETHODIMP_(void) CImpIAccessor::DeleteADsAccessor
(
PADSACCESSOR   pADsaccessor        //@parm IN  | Kagera accessor ptr
)
{
    DBCOUNTITEM ibind;

    // Delete the list of affected columns.
    if( pADsaccessor->rgcol )
        delete [] pADsaccessor->rgcol;

    // If the accessor references BLOBS then DBOBJECT structures describing
    // objects dealing with BLOBS need to be deallocated.
    for (ibind =0; ibind <pADsaccessor->cBindings; ibind++)
        if( pADsaccessor->rgBindings[ibind].pObject )
            delete pADsaccessor->rgBindings[ibind].pObject;

    delete [] pADsaccessor;
}


STDMETHODIMP
CImpIAccessor::QueryInterface(REFIID iid, LPVOID FAR* ppv)
{
    // Is the pointer bad?
    if( ppv == NULL )
        RRETURN( E_INVALIDARG );

    //  Place NULL in *ppv in case of failure
    *ppv = NULL;

    if( IsEqualIID(iid, IID_IUnknown) ) {
        *ppv = (IAccessor FAR *) this;
    }
    else if( IsEqualIID(iid, IID_IAccessor) ) {
        *ppv = (IAccessor FAR *) this;
    }
    else {
        RRETURN( E_NOINTERFACE );
    }

    AddRef();
    return S_OK;
}

//---------------------------------------------------------------------------
// CreateBadAccessor
//
// Inserts a bad accessor into the array of accessors (indexed by accessor
// handles). This is required so that inheritance of accessors from commands
// works correctly. If there are any 'holes' in the command's array of 
// accessors, then a rowset created from the command should also inherit these 
// 'holes' i,e, the array of accessor handles should not be compacted to
// eliminate these holes. This is done using this function.
//
//--------------------------------------------------------------------------- 
HRESULT
CImpIAccessor::CreateBadAccessor(void)
{
    PADSACCESSOR pADsaccessorBadHandle;
    ULONG_PTR        hADsaccessor;
    HRESULT      hr;

    // Get a pointer to the special "BadHandle" accessor.
    _pextbuffer->GetItemOfExtBuffer(hAccessorBadHandle, &pADsaccessorBadHandle);

    // ignore the returned accessor handle
    hr = _pextbuffer->InsertIntoExtBuffer(
                       &pADsaccessorBadHandle, hADsaccessor);

    RRETURN( hr );
}

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