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

// Row.cxx : Implementation of CRow
#include "oleds.hxx"

#if (!defined(BUILD_FOR_NT40))
#include "atl.h"
#include "row.hxx"
#include "cstream.h"

HRESULT PackLargeInteger(LARGE_INTEGER *plargeint, PVARIANT pVarDestObject);
#define ARRAYSIZE(x)    sizeof((x))/sizeof((x)[0])

extern const WCHAR g_cwszSpecialColumnURL[] = L"RESOURCE_ABSOLUTE_PARSENAME";
extern const WCHAR g_cwszAdsPath[]                      = L"ADsPath";

//----------------------------------------------------------------------------
// Note on m_fIsTearOff and m_fGetColInfoFromRowset
//
// m_fIsTearOff is set to TRUE when the row is a tear-off from a rowset from 
// the client's point of view i.e, the client created a rowset and got a row
// off the rowset. Thus, a call to GetSourceRowset returns a rowset interface
// pointer only if m_fIsTearOff is TRUE. 
// m_fGetColInfoFromRowset is set to TRUE if the row should get the column
// info and the column values from the rowset. If FALSE, this information is 
// obtained through ADSI calls.
//
// There are 4 cases of interest.
//
// 1) The row is obtained directly from a command object using a query which
// doesn't specify "SELECT *" i.e, not all attributes are requested OR the row
// is obtained directly from a session object (defaults to no "SELECT *"). This 
// is implemented by actually creating a rowset and getting its first row.
// In this case m_fIsTearOff is FALSE, m_fGetColInfoFromRowset is
// TRUE and m_pSourceRowset is non-NULL. Thus, if the client called 
// GetSourceRowset on the row, no interface pointer is returned. However, there
// is a rowset backing up this row and this is used for getting column info and
// column values. 
//
// 2) The row is obtained directly from a command object using SELECT *
// as the query. In this case, m_fIsTearOff is FALSE, m_fGetColInfoFromRowset 
// is FALSE and m_pSourceRowset is non-NULL. Though m_pSourceRowset is 
// non-NULL, it is not used.
// 
// An alternative scheme would be to to call CSession::Bind directly in this 
// case which would obviate the need for keeping a rowset around.
//
// 3) The row is obtained from a rowset using GetRowFromHROW. In this case,
// m_fIsTearOff is TRUE. However, if the rowset was created from a command 
// object using a SELECT * query, then m_fGetColInfoFromRowset is FALSE.
// Otherwise, fGetColInfoFromRowset is TRUE. m_pSourceRowset is non-NULL.
//
// 4) The row is created using IBindResource::Bind. In this case, m_fIsTearOff 
// is FALSE, m_fGetColInfoFromRowset is FALSE and m_pSourceRowset is NULL.
//
// The following table summarizes the above 4 cases.
//
// m_fIsTearOff m_fGetColInfoFromRowset             Description
// ------------ -----------------------             ------------
//     T                T                   GetRowFromHROW, not SELECT *
//     F                F                   Row obtained from command object
//                                          using SELECT * OR 
//                                          Row got using IBindResource::Bind
//     T                F                   GetRowFromHROW, SELECT *
//     F                T                   Row obtained from command object
//                                          without a SELECT * query OR
//                                          Row obtained from session object 
//
// Every row object has a special URL column. The URL column (and any row
// columns that are not in the source rowset) should appear after all the
// source rowset columns.
//
// ADsPath needs to be treated as a special case. If m_fGetColInfoFromRowset
// is TRUE, then we will get the ADsPath just by using the rowset's copy
// of the column. However, if m_fGetColInfoFromRowset is FALSE, then
// the row should return ADsPath if it is a tear-off AND ADsPath is one of the 
// columns of the source rowset. This is required by the OLEDB spec
// since the row's columns should be a superset of the rowset's columns. 
// Currently, the only case where this would happen is a SELECT * query that
// requests a rowset and then a row is obtained from that rowset. In this case,
// the row adds ADsPath to the columns it returns. To be consistent, if a row  
// is obtained from a command object using a SELECT * query OR the row is
// obtained using IBindResource::Bind(), then ADsPath is added to the columns
// returned by the row.
//
//----------------------------------------------------------------------------
// 

//////////////////////////////////////////////////////////////////////////////
//helper functions
//
//+---------------------------------------------------------------------------
//
//  Function:  GetIDataConvert
//
//  Synopsis: Create OLE DB conversion library and store it in static.
//
//  Arguments:
//              [out] pointer to pointer to IDataConvert
//
//  Returns:    HRESULT
//----------------------------------------------------------------------------
HRESULT GetIDataConvert(IDataConvert** ppDataConvert)
{
    HRESULT                                                 hr = S_OK;
    auto_rel<IDataConvert> pIDataConvert;
    auto_rel<IDCInfo>                               pIDCInfo;
    DCINFO          rgInfo[] = {{DCINFOTYPE_VERSION, {VT_UI4, 0, 0, 0, 0x0200}}};
    
    ADsAssert(ppDataConvert);
    
    hr = CoCreateInstance(CLSID_OLEDB_CONVERSIONLIBRARY,
            NULL,
            CLSCTX_INPROC_SERVER,
            IID_IDataConvert,
            (void **) &pIDataConvert);
    if (FAILED(hr))
        goto exit;
        
    // Tell data convert our OLE DB version
    hr = pIDataConvert->QueryInterface(IID_IDCInfo,
            (void **)&pIDCInfo);
    if( SUCCEEDED(hr) )
        hr = pIDCInfo->SetInfo(ARRAYSIZE(rgInfo), rgInfo);
        
    // auto_rel operator = does the release
    if( FAILED(hr) )
            pIDataConvert = NULL;
    
    if (pIDataConvert)
        pIDataConvert->AddRef();
    *ppDataConvert = pIDataConvert;

exit:
    RRETURN(hr);
}

/////////////////////////////////////////////////////////////////////////////
//Internal methods
//

//+---------------------------------------------------------------------------
//
//  Function: CRow::Initialize
//
//  Synopsis: Initializes a directly bound CRow object as opposed to a row
//            created from a rowset. See the other overloaded Initialize below.
//
//  Returns:    HRESULT
//----------------------------------------------------------------------------
STDMETHODIMP CRow::Initialize(PWSTR                     pwszURL,
                              IUnknown              *pSession,
                              IAuthenticate *pAuthenticate,
                              DWORD                 dwBindFlags,
                              BOOL                  fIsTearOff,
                              BOOL                  fGetColInfoFromRowset,
                              CCredentials          *pSessCreds,
                              bool                  fBind)
{
    HRESULT                 hr = S_OK;
    auto_leave              cs_auto_leave(m_autocs);
    DWORD                   fAuthFlags;
 
    //Make sure we have a valid session.
    ADsAssert(pSession);
    
	TRYBLOCK
    
		cs_auto_leave.EnterCriticalSection();
        
        m_dwBindFlags = dwBindFlags;
        m_objURL = pwszURL;
        m_pSession = pSession;
        m_pSession->AddRef();
        
        if (!fBind) //no need to bind. Just return.
            RRETURN(S_OK);

        m_fIsTearOff = fIsTearOff;
        m_fGetColInfoFromRowset = fGetColInfoFromRowset;
   
        // Any changes made below should also be made in the overloaded
        // Initialize() below for consistency.

        // Fix for 351040. Use explicit credentials first, then credentials in
        // session object, then default credentials. Credential in session
        // object will be the default credentials if we come in through the
        // binder. But, if IBindResource is obtained from the session object,
        // then the credentials may not be the default credentials. From ADO,
        // using Open without specifying an active connection causes the 
        // binder to be invoked. If an active connection is specified, then 
        // IBindResource is obtained from the session object.
       
        if(pAuthenticate)
        {
            hr = GetCredentialsFromIAuthenticate(pAuthenticate, 
                     m_objCredentials);
            if(FAILED(hr))
               BAIL_ON_FAILURE(E_INVALIDARG);

            fAuthFlags = m_objCredentials.GetAuthFlags();
            m_objCredentials.SetAuthFlags(fAuthFlags |
                        ADS_SECURE_AUTHENTICATION);

            hr = GetDSInterface(
                pwszURL,
                m_objCredentials,
                IID_IADs,
                (void **)&m_pADsObj
                );
        }

        if( (!pAuthenticate) || (INVALID_CREDENTIALS_ERROR(hr)) )
        // try credentials in session object
        {
            m_objCredentials = *pSessCreds;

            hr = GetDSInterface(
                pwszURL,
                m_objCredentials,
                IID_IADs,
                (void **)&m_pADsObj
                );
        }

        if(INVALID_CREDENTIALS_ERROR(hr))
        // try default credentials
        {
            CCredentials TmpCreds; // default credentials

            m_objCredentials = TmpCreds;
            fAuthFlags = m_objCredentials.GetAuthFlags();
            m_objCredentials.SetAuthFlags(fAuthFlags | 
                        ADS_SECURE_AUTHENTICATION);                        

            hr = GetDSInterface(
                pwszURL,
                m_objCredentials,
                IID_IADs,
                (void **)&m_pADsObj
                );
        }

        BAIL_ON_FAILURE(hr);
        
        //Get the Schema Root and store it in m_bstrSchemaRoot
        hr = GetSchemaRoot();
        BAIL_ON_FAILURE(hr);
        
        // Get the data. without the GetRestrictedColunInfo will no return column information.
        hr = m_pADsObj->GetInfo();
        BAIL_ON_FAILURE(hr);
        
	CATCHBLOCKBAIL(hr)    

error:
    RRETURN(hr);
}

//+---------------------------------------------------------------------------
//
//  Function: CRow::Initialize
//
//  Synopsis: Initializes a row object that represents a row in a rowset as
//                        as opposed to a directly bound row object.
//            See the other overloaded Initialize above.
//
//  Returns:    HRESULT
//----------------------------------------------------------------------------
STDMETHODIMP CRow::Initialize(
                              PWSTR                   pwszURL,
                              IUnknown                *pSession,
                              IUnknown                *pSourceRowset,
                              HROW                    hRow,
                              PWSTR                   pwszUser,
                              PWSTR                   pwszPassword,
                              DWORD                   dwBindFlags,
                              BOOL                    fIsTearOff,
                              BOOL                    fGetColInfoFromRowset,
                              CRowProvider            *pRowProvider
                              )
{
    HRESULT                                 hr = S_OK;
    auto_leave                              cs_auto_leave(m_autocs);
    DWORD                                   fAuthFlags;
    auto_rel<IRowset>               pRowset;
    auto_rel<IColumnsInfo>  pRowsetColumnsInfo;
    
    //Make sure we have valid arguments
    ADsAssert(pSession);
    ADsAssert(pSourceRowset);
    ADsAssert(hRow != DB_NULL_HROW);
    
	TRYBLOCK
    
		cs_auto_leave.EnterCriticalSection();
        
        if (pRowProvider == NULL)
            BAIL_ON_FAILURE(hr = E_INVALIDARG);
        
        m_pRowProvider = pRowProvider;
        m_dwBindFlags = dwBindFlags;
        m_pSession = pSession;
        m_pSession->AddRef();
        m_pSourceRowset = pSourceRowset;
        m_hRow = hRow;
        m_fIsTearOff = fIsTearOff;
        m_fGetColInfoFromRowset = fGetColInfoFromRowset; 
        pSourceRowset->AddRef();
        
        //Get IRowset pointer
        hr = pSourceRowset->QueryInterface(__uuidof(IRowset),
            (void **)&pRowset);
        BAIL_ON_FAILURE(hr);
        
        //Get Rowset columns info and store it. Spec says a row's columns
        //are always a superset of those of the source rowset. To make
        //sure we return proper columns info from row object,
        //we need the rowset's column info.
        hr = pSourceRowset->QueryInterface(
            __uuidof(IColumnsInfo),
            (void **)&pRowsetColumnsInfo);
        BAIL_ON_FAILURE(hr);
        hr = pRowsetColumnsInfo->GetColumnInfo(
            &m_cSourceRowsetColumns,
            &m_pSourceRowsetColumnInfo,
            &m_pSourceRowsetStringsBuffer);
        BAIL_ON_FAILURE(hr);
        
        //Get username, password and authFlags from Credentials.
        hr = m_objCredentials.SetUserName(pwszUser);
        BAIL_ON_FAILURE(hr);
        hr = m_objCredentials.SetPassword(pwszPassword);
        BAIL_ON_FAILURE(hr);
        
        //Store the URL and AddRef row handle.
        m_objURL = pwszURL;
        hr = pRowset->AddRefRows(1, &m_hRow, NULL, NULL);
        BAIL_ON_FAILURE(hr);

        //check  if the column info is to be obtained thruogh ADSI
        if( !fGetColInfoFromRowset )
        {
             // code below should be consistent with the Initialize() call
             // (overloaded function above) used for direct binding

             DWORD fAuthFlags = m_objCredentials.GetAuthFlags();
             m_objCredentials.SetAuthFlags(fAuthFlags | 
                                           ADS_SECURE_AUTHENTICATION);

             hr = GetDSInterface(
                  pwszURL,
                  m_objCredentials,
                  IID_IADs,
                  (void **)&m_pADsObj
                  );

             BAIL_ON_FAILURE(hr);

            //Get the Schema Root and store it in m_bstrSchemaRoot
            hr = GetSchemaRoot();
            BAIL_ON_FAILURE(hr);

            // Get the data. without it GetRestrictedColunInfo will not return 
            // column info.
            hr = m_pADsObj->GetInfo();
            BAIL_ON_FAILURE(hr);            
        } 
	
	CATCHBLOCKBAIL(hr)

error:
    RRETURN(hr);
}

//+---------------------------------------------------------------------------
//
//  Function: CRow::fMatchesMaskCriteria
//
//  Synopsis: Tells if the given column name matches any mask criteria
//            for column ids.
//
//  Returns:  true if matches, false otherwise
//----------------------------------------------------------------------------
bool CRow::fMatchesMaskCriteria(PWCHAR pwszColumnName,
                                ULONG cColumnIDMasks,
                                const DBID rgColumnIDMasks[  ])
{
    //if there are no masks, the name is a match.
    if (cColumnIDMasks == 0)
        return true;
    
    ULONG ulStrLen = 0;
    for (int j = 0; j < cColumnIDMasks; j++)
    {
        if( (rgColumnIDMasks[j].eKind != DBKIND_NAME) ||
            (NULL == rgColumnIDMasks[j].uName.pwszName) )
            continue;

        ulStrLen = wcslen(rgColumnIDMasks[j].uName.pwszName);
        if (_wcsnicmp(  rgColumnIDMasks[j].uName.pwszName,
            pwszColumnName,
            ulStrLen ) == 0)
        {
            // Matches criterion
            return true;
        }
    }
    //doesn't match.
    return false;
}

//+---------------------------------------------------------------------------
//
//  Function: CRow::fMatchesMaskCriteria (OVERLOADED)
//
//  Synopsis: Tells if the given column id matches any mask criteria
//            for column ids.
//
//  Returns:  true if matches, false otherwise
//----------------------------------------------------------------------------
bool CRow::fMatchesMaskCriteria(DBID columnid,
                                ULONG cColumnIDMasks,
                                const DBID rgColumnIDMasks[  ])
{
    //if there are no masks, the name is a match.
    if (cColumnIDMasks == 0)
        return true;
    
    ULONG ulStrLen = 0;
    for (int j = 0; j < cColumnIDMasks; j++)
    {
        if (TRUE == CompareDBIDs(&columnid, &rgColumnIDMasks[j]))
        {
            // Matches criterion
            return true;
        }
    }
    //doesn't match.
    return false;
}

//+---------------------------------------------------------------------------
//
//  Function: CRow::GetSchemaAttributes
//
//  Synopsis: Gets MultiValued and MaxRange Attributes of an ADS Property.
//                        Any of these can be NULL indicating the caller is not interested
//            in getting the attribute.
//
//  Returns:  HRESULT
//----------------------------------------------------------------------------
HRESULT CRow::GetSchemaAttributes(
                                  PWCHAR                  pwszColumnName,
                                  VARIANT_BOOL    *pfMultiValued,
                                  long                    *plMaxRange
                                  )
{
    HRESULT                                         hr = S_OK;
    auto_rel<IADsProperty>          pProperty;
    CComBSTR                                        bstrSchemaName;
    
    ADsAssert(m_bstrSchemaRoot.Length());
    ADsAssert(pwszColumnName != NULL);
    
    //Does the caller want at least one attribute?
    if (!pfMultiValued && !plMaxRange)
        return S_OK;
    
    //Append a '/' and property name to root schema name
    //to make the Schema ADsPath for this property.
    bstrSchemaName = m_bstrSchemaRoot;
    bstrSchemaName.Append(L"/");
    bstrSchemaName.Append(pwszColumnName);
    
    //Bind to the schema entry and get IADsProperty interface.
    hr = GetDSInterface(
        bstrSchemaName,
        m_objCredentials,
        __uuidof(IADsProperty),
        (void **)&pProperty
        );
    BAIL_ON_FAILURE(hr);
    
    if (pfMultiValued != NULL)
    {
        //Get multivalued attribute.
        hr = pProperty->get_MultiValued(pfMultiValued);
        BAIL_ON_FAILURE(hr);
    }
    
    // The following call get_MaxRange seems to create perf problems
    // because it apparently requires a round-trip to the server.
    // This is not critical and we cn live without asking
    // for max range here.
    
    //if (plMaxRange != NULL)
    //{
    //        //Get MaxSize attribute. Ignore error
    //        //since some properties may not have
    //        //this attribute set.
    //        pProperty->get_MaxRange(plMaxRange);
    //}
    
error:
    RRETURN(hr);
}

//+---------------------------------------------------------------------------
//
//  Function: CRow::GetTypeAndSize
//
//  Synopsis: Gets the type and size of a property
//
//  Returns:  HRESULT
//----------------------------------------------------------------------------
HRESULT CRow::GetTypeAndSize(
                             ADSTYPE                      dwADsType,
                             CComBSTR&                    bstrPropName,
                             DBTYPE                               *pdbType,
                             ULONG                                *pulSize
                             )
{
    ADsAssert(pdbType != NULL);
    ADsAssert(pulSize != NULL);
    
    long                                    lAdsType = dwADsType;
    VARIANT_BOOL                    fMultiValued = VARIANT_FALSE;
    HRESULT                                 hr = S_OK;
    
    //Initialize out params
    *pdbType = DBTYPE_ERROR;
    *pulSize = ~0;
    
    hr = GetSchemaAttributes(bstrPropName, &fMultiValued, (long *)pulSize);
    BAIL_ON_FAILURE(hr);
    
    //Give our best shot at determining type and size.
    if (fMultiValued == VARIANT_TRUE)
        *pdbType = DBTYPE_BYREF | DBTYPE_VARIANT;
    else if  (lAdsType < g_cMapADsTypeToDBType2)
        *pdbType = g_MapADsTypeToDBType2[lAdsType].wType;
    else
        *pdbType = DBTYPE_ERROR;
    
    // If we could not determine the size from schema information,
    // set the size from the mapping table.
    if (*pulSize == ~0)
        *pulSize = g_MapADsTypeToDBType2[lAdsType].ulSize;
    
error:
    RRETURN (hr);
}

//+---------------------------------------------------------------------------
//
//  Function: CRow::GetSchemaRoot
//
//  Synopsis: Gets the root schema path and stores it in m_bstrSchemaRoot
//
//  Returns:  HRESULT
//----------------------------------------------------------------------------
HRESULT CRow::GetSchemaRoot()
{
    HRESULT                 hr = S_OK;
    CComBSTR                bstrSchema;
    auto_rel<IADs>  pADsSchema;
    
    Assert(m_pADsObj.get());
    
    hr = m_pADsObj->get_Schema(&bstrSchema);
    BAIL_ON_FAILURE(hr);
    
    hr = GetDSInterface(
        bstrSchema,
        m_objCredentials,
        __uuidof(IADs),
        (void **)&pADsSchema
        );
    BAIL_ON_FAILURE(hr);
    
    hr = pADsSchema->get_Parent(&m_bstrSchemaRoot);
    BAIL_ON_FAILURE(hr);
    
error:
    
    RRETURN(hr);
}

//+---------------------------------------------------------------------------
//
//  Function: CRow::GetSourceRowsetColumns
//
//  Synopsis: Gets the requested column data from the source rowset.
//
//  Returns:  HRESULT
//----------------------------------------------------------------------------
HRESULT CRow::GetSourceRowsetColumns(
                                     ULONG cColumns,
                                     DBCOLUMNACCESS rgColumns[],
                                     ULONG *pcErrors )
{
    // Make sure there is a rowset backing this row (this doesn't imply that
    // the row is a tear-off (see comment at the beginning).
    ADsAssert(m_pSourceRowset.get() != NULL);
    ADsAssert(m_pRowProvider != NULL);
    ADsAssert(m_fGetColInfoFromRowset == TRUE);
    
    HRESULT                             hr = S_OK;
    auto_rel<IAccessor>         pAccessor;
    auto_rel<IRowset>       pRowset;
    auto_rel<IColumnsInfo>  pColumnsInfo;
    HACCESSOR                           hAccessor;
    ULONG                               iCol;
    ULONG                               ulRefCount = 0;
    DBBINDING               binding = {0};
    DBBINDSTATUS            bindStatus = {0};
    int                     iRowsetIndex;
    DBID                    dbidRowUrl = DBROWCOL_ROWURL;
    
    ADsAssert(pcErrors != NULL);
    
    *pcErrors = 0;
    hr = m_pSourceRowset->QueryInterface(&pRowset);
    BAIL_ON_FAILURE(hr);
    
    hr = m_pSourceRowset->QueryInterface(&pAccessor);
    BAIL_ON_FAILURE(hr);
    
    hr = m_pSourceRowset->QueryInterface(&pColumnsInfo);
    BAIL_ON_FAILURE(hr);
    
    for (iCol = 0; iCol < cColumns; iCol++)
    {
        rgColumns[iCol].dwStatus = DBSTATUS_S_OK;
        if( (rgColumns[iCol].pData != NULL) &&
                (!IgnorecbMaxLen(rgColumns[iCol].wType)) )
            ZeroMemory(rgColumns[iCol].pData, rgColumns[iCol].cbMaxLen);

        //Is this the special URL column.
        if(TRUE == CompareDBIDs(&dbidRowUrl, &rgColumns[iCol].columnid))
        {
            CComVariant varTemp;

            varTemp.Clear();
            varTemp = m_objURL;
            //Set max length of column. 256 is consistent with 2.0 code.
            rgColumns[iCol].cbDataLen = 256;
            rgColumns[iCol].dwStatus = DBSTATUS_S_OK;

            //Does the caller want pData?
            if (rgColumns[iCol].pData != NULL)
            {
                //Get IDataConvert interface pointer.
                auto_rel<IDataConvert> pDataConvert;
                hr = GetIDataConvert(&pDataConvert);

                if(SUCCEEDED(hr))
                    hr = pDataConvert->DataConvert(
                            DBTYPE_VARIANT,
                            rgColumns[iCol].wType,
                            sizeof(VARIANT),
                            &rgColumns[iCol].cbDataLen,
                            &varTemp,
                            rgColumns[iCol].pData,
                            rgColumns[iCol].cbMaxLen,
                            DBSTATUS_S_OK,
                            &rgColumns[iCol].dwStatus,
                            rgColumns[iCol].bPrecision,
                            rgColumns[iCol].bScale,
                            DBDATACONVERT_DEFAULT
                            );

                if(FAILED(hr)) 
                {
                    hr = S_OK;

                    // rgColumns[iCol].dwStatus already set above by 
                    // DataConvert().

                    (*pcErrors)++;
                    continue;
                }
            }
            continue; // on to next column
        }
        
        //Is this the bookmark column?
        if (rgColumns[iCol].columnid.eKind == DBKIND_GUID_PROPID &&
            rgColumns[iCol].columnid.uGuid.guid == DBCOL_SPECIALCOL &&
            rgColumns[iCol].columnid.uName.ulPropid == 2 )
        {
            iRowsetIndex = 0;  // bookmark is first column

        }
        else
        {
        
            // Is column id of DBKIND_NAME?
            if (rgColumns[iCol].columnid.eKind != DBKIND_NAME)
            {
                rgColumns[iCol].dwStatus = DBSTATUS_E_DOESNOTEXIST;
                (*pcErrors)++;
                continue;
            }
        
            iRowsetIndex = 0;
            hr = m_pRowProvider->GetIndex(
                pColumnsInfo,
                rgColumns[iCol].columnid.uName.pwszName,
                iRowsetIndex
            );
            if (FAILED(hr) || 0 == iRowsetIndex) // failure or name not found
            {
                hr = S_OK;
                if(FAILED(hr))
                    rgColumns[iCol].dwStatus = DBSTATUS_E_UNAVAILABLE;
                else
                    rgColumns[iCol].dwStatus = DBSTATUS_E_DOESNOTEXIST;
                (*pcErrors)++;
                continue;
            }
        } // else
        
        binding.dwPart = DBPART_VALUE;
        binding.obLength = 0;
        binding.bPrecision = rgColumns[iCol].bPrecision;
        binding.bScale = rgColumns[iCol].bScale;
        binding.pTypeInfo = 0;
        binding.pObject = NULL;
        binding.iOrdinal = iRowsetIndex;
        binding.cbMaxLen = rgColumns[iCol].cbMaxLen;
        binding.dwMemOwner = DBMEMOWNER_CLIENTOWNED;
        binding.wType =  rgColumns[iCol].wType;
        
        hr = pAccessor->CreateAccessor(
            DBACCESSOR_ROWDATA,
            1,
            &binding,
            0,
            &hAccessor,
            &bindStatus
            );
        if (FAILED(hr))
        {
            rgColumns[iCol].dwStatus = DBSTATUS_E_CANTCONVERTVALUE;
            (*pcErrors)++;
            hr = S_OK;
            continue;
        }
       
        if(rgColumns[iCol].pData != NULL)
        { 
            hr = pRowset->GetData(m_hRow, hAccessor, rgColumns[iCol].pData);
            if (FAILED(hr))
            {
                rgColumns[iCol].dwStatus = StatusFromHRESULT(hr);
                (*pcErrors)++;
                hr = S_OK;
                pAccessor->ReleaseAccessor(hAccessor, &ulRefCount);
                continue;
            }
        }

        hr = pAccessor->ReleaseAccessor(hAccessor, &ulRefCount);

        // now get the status and length
        binding.dwPart = DBPART_LENGTH | DBPART_STATUS;
        binding.obStatus = FIELD_OFFSET(DBCOLUMNACCESS, dwStatus);
        binding.obLength = FIELD_OFFSET(DBCOLUMNACCESS, cbDataLen);

        hr = pAccessor->CreateAccessor(
                DBACCESSOR_ROWDATA,
                1,
                &binding,
                0,
                &hAccessor,
                &bindStatus
                );
        if (FAILED(hr))
        {
            rgColumns[iCol].dwStatus = DBSTATUS_E_CANTCONVERTVALUE;
            (*pcErrors)++;
            hr = S_OK;
            continue;
        }

        hr = pRowset->GetData(m_hRow, hAccessor, &(rgColumns[iCol]));
        if (FAILED(hr))
        {
            rgColumns[iCol].dwStatus = StatusFromHRESULT(hr);
            (*pcErrors)++;
        }

        hr = pAccessor->ReleaseAccessor(hAccessor, &ulRefCount);
        // We have set the dwStatus to reflect any problems, so clear error.
        hr = S_OK;
    }
    
error:
    if (FAILED(hr))
    {
        for (iCol = 0; iCol < cColumns; iCol++)
            rgColumns[iCol].dwStatus = DBSTATUS_E_UNAVAILABLE;
        
        *pcErrors = cColumns;
    }
    
    RRETURN (hr);
}

//+---------------------------------------------------------------------------
//
//  Function: CRow::StatusFromHRESULT
//
//  Synopsis: Gets DBSTATUS from a given HRESULT.
//
//  Returns:  DBSTATUS
//----------------------------------------------------------------------------
DBSTATUS CRow::StatusFromHRESULT(HRESULT hr)
{
    if (SUCCEEDED(hr))
        RRETURN(DBSTATUS_S_OK);

    switch(hr)
    {
        case (E_INVALIDARG):
            RRETURN(DBSTATUS_E_CANTCREATE);
            
        case (DB_E_BADACCESSORHANDLE):
        case (DB_E_BADACCESSORTYPE):
        case (DB_E_BADBINDINFO):
        case (DB_E_BADORDINAL):
        case (DB_E_BADSTORAGEFLAGS):
            RRETURN(DBSTATUS_E_CANTCONVERTVALUE);

        case (DB_E_UNSUPPORTEDCONVERSION):
            RRETURN(DBSTATUS_E_CANTCONVERTVALUE);

        case (DB_E_BADROWHANDLE):
        case (DB_E_DELETEDROW):
            RRETURN(DBSTATUS_E_UNAVAILABLE);

        default:
            RRETURN(DBSTATUS_E_BADSTATUS);
     }
}

//////////////////////////////////////////////////////////////////////////////
//ISupportErrorInfo
//
//+---------------------------------------------------------------------------
//
//  Function:  CRow::InterfaceSupportsErrorInfo
//
//  Synopsis: Given an interface ID, tells if that interface supports
//            the interface ISupportErrorInfo
//
//  Arguments:
//              REFIID riid
//
//  Returns:    HRESULT
//              S_OK             yes, the interface supports ISupportErrorInfo
//              S_FALSE                  no, the interface doesn't support it.
//----------------------------------------------------------------------------
STDMETHODIMP CRow::InterfaceSupportsErrorInfo(REFIID riid)
{
    static const IID* arr[] =
    {
        &IID_IRow,
            &IID_IColumnsInfo,
            &IID_IColumnsInfo2,
            &IID_IConvertType,
            &IID_IGetSession
    };
    for (int i=0; i < sizeof(arr) / sizeof(arr[0]); i++)
    {
        if (InlineIsEqualGUID(*arr[i],riid))
            RRETURN(S_OK);
    }
    RRETURN(S_FALSE);
}

//////////////////////////////////////////////////////////////////////////////
//IRow methods
//
//+---------------------------------------------------------------------------
//
//  Function:   CRow::GetColumns
//
//  Synopsis:   Gets Columns from a Row.
//
//  Returns:    HRESULT
//
//  For more info see OLE DB 2.5 spec.
//----------------------------------------------------------------------------
STDMETHODIMP CRow::GetColumns(
                              /* [in] */ DBORDINAL cColumns,
                              /* [size_is][out][in] */ DBCOLUMNACCESS rgColumns[ ])
{
    HRESULT                                         hr;
    DWORD                                           cErrors = 0;
    auto_leave                                      cs_auto_leave(m_autocs);
    int                                             i;
    DBID                                            dbidRowUrl = DBROWCOL_ROWURL;
    
    if ( cColumns == 0 )
    {
        // Nothing to do:
        RRETURN(S_OK);
    }
    
    if (!rgColumns)
        RRETURN(E_INVALIDARG);
    
	TRYBLOCK
    
		cs_auto_leave.EnterCriticalSection();
        
        // We must have a valid ADs object or a valid Source Rowset
        ADsAssert(m_pADsObj.get() || m_pSourceRowset.get());
    
        if( m_fGetColInfoFromRowset )    
        {
            ADsAssert(m_pSourceRowset.get() != NULL);
            hr = GetSourceRowsetColumns(cColumns, rgColumns, &cErrors);
        }
        else
        {
            //Get IDataConvert interface pointer.
            auto_rel<IDataConvert> pDataConvert;
            hr = GetIDataConvert(&pDataConvert);
            if (FAILED(hr))
                BAIL_ON_FAILURE(hr = DB_E_ERRORSOCCURRED);
            
            for (i = 0; i < cColumns; i++)
            {
                // DBKIND is DBKIND_NAME and null or zero length column name
                if ( rgColumns[i].columnid.eKind == DBKIND_NAME &&
                     (rgColumns[i].columnid.uName.pwszName == NULL ||
                      wcslen(rgColumns[i].columnid.uName.pwszName) == 0))
                {
                    rgColumns[i].dwStatus = DBSTATUS_E_DOESNOTEXIST;
                    cErrors++;
                    continue;
                }
                
                CComVariant varTemp;
                DBTYPE      propType = DBTYPE_VARIANT;
                
                varTemp.Clear();
                
                hr = S_OK;
                //Check if this is the special URL column or the ADsPath 
                //column. If so, assign the URL to varTemp and proceed to data 
                //conversion.
                if (  (rgColumns[i].columnid.eKind == DBKIND_NAME && 
                       _wcsicmp(rgColumns[i].columnid.uName.pwszName, g_cwszAdsPath) == 0) ||
                      (TRUE == CompareDBIDs(&dbidRowUrl, &rgColumns[i].columnid))
                   )
                     
                {
                    varTemp = m_objURL;
                    //Set max length of column.
                    //MaxLen=256 is consistent with 2.0 provider code.
                    rgColumns[i].cbDataLen = 256;
                }
                // check if this is the bookmark column
                else if (rgColumns[i].columnid.eKind == DBKIND_GUID_PROPID &&
                         rgColumns[i].columnid.uGuid.guid == DBCOL_SPECIALCOL &&
                         rgColumns[i].columnid.uName.ulPropid == 2 )
                {
                    UINT uBmk;

                    if( m_hRow != DB_NULL_HROW )
                    // get the bookmark associated with this row handle
                    {
                        auto_rel<IRowset> pRowset;
                        CRowset *pCRowset;
                        LONG lRow;
                        RBOOKMARK bmk;

                        hr = m_pSourceRowset->QueryInterface(__uuidof(IRowset),
                                   (void **)&pRowset);
                        if( SUCCEEDED(hr) )
                        {    
                            pCRowset = (CRowset *) ((IRowset *) pRowset);
                            lRow = pCRowset->HROWToRow(m_hRow);
                            bmk = pCRowset->RowToBmk(lRow);
           
                            uBmk = (UINT) bmk;
                        }
                    }
                    else // use any value for bookmark
                        uBmk = 0;
    
                    if( SUCCEEDED(hr) )
                    {
                        VARIANT vTmpVariant;

                        V_VT(&vTmpVariant) = VT_UI4;
                        V_UI4(&vTmpVariant) = uBmk;

                        varTemp = vTmpVariant;
                    }
                    // else we will fail below and continue to next iteration 
                }
                else if (rgColumns[i].columnid.eKind == DBKIND_NAME)
                {
                    //Find out if property is multivalued and its size.
                    VARIANT_BOOL    fMultiValued;
                    long                    lSize = ~0;
                    hr = GetSchemaAttributes(
                        rgColumns[i].columnid.uName.pwszName,
                        &fMultiValued,
                        &lSize
                        );
                    if (SUCCEEDED(hr))
                    {
                        // if security descriptor is requested as a variant,
                        // then we return a variant with an octet string
                        // inside. This would always be the case with ADO as
                        // it requests all columns as variants. If it is 
                        // requested as an octet string, we return an octet
                        // string. If it is  requested as some other 
                        // type from C++ (say DBTYPE_IDISPATCH), then we will
                        // call Get/GetEx and try to convert the resulting 
                        // variant to the appropriate type. Returning security
                        // descriptor as an octet string is much cheaper as
                        // there is no network traffic for ACE conversion.
                        if( (!_wcsicmp(rgColumns[i].columnid.uName.pwszName,
                                               NT_SEC_DESC_ATTR)) &&
                                      ((rgColumns[i].wType & DBTYPE_VARIANT) ||
                                        (rgColumns[i].wType & DBTYPE_BYTES)) )
                        {
                            hr = GetSecurityDescriptor(&rgColumns[i],
                                                       fMultiValued);
                            if(FAILED(hr)) 
                            {
                                // Clear error. Status has already been set
                                // in rgColumns[i]
                                hr = S_OK;
                                cErrors++;
                            }
                            
                            //Nothing more to do, continue with next column.
                            continue;
                        }
                            
                        if (fMultiValued)
                        {
                            //multi-valued column. Use GetEx.
                            hr = m_pADsObj->GetEx(
                                rgColumns[i].columnid.uName.pwszName,
                                &varTemp
                                );
                            
                            propType = DBTYPE_BYREF | DBTYPE_VARIANT;
                        }
                        else
                        {
                            //single-valued. Use Get.
                            hr = m_pADsObj->Get(
                                rgColumns[i].columnid.uName.pwszName,
                                &varTemp
                                );
                        }
                    }
                    
                    rgColumns[i].cbDataLen = lSize;
                }
                else
                {
                    rgColumns[i].dwStatus = DBSTATUS_E_UNAVAILABLE;
                    cErrors++;
                    continue;
                }
                
                if (FAILED(hr))
                {
                    //Clear error. dwStatus below will reflect
                    //the error for this column.
                    hr = S_OK;
                    
                    rgColumns[i].dwStatus = DBSTATUS_E_UNAVAILABLE;
                    
                    cErrors++; //Increment error count.
                    
                    //Nothing more to do, continue with next column.
                    continue;
                }
                
                //Does the caller want pData?
                if (rgColumns[i].pData != NULL)
                {
                    rgColumns[i].dwStatus = DBSTATUS_S_OK;
                    
                    //Convert data into requested type
                    if (propType == (DBTYPE_VARIANT | DBTYPE_BYREF)) //multi-valued
                    {
                        if( !(rgColumns[i].wType & DBTYPE_VARIANT) )
                        // can't convert a multi-valued attr. to anything else
                        {
                            rgColumns[i].dwStatus = DBSTATUS_E_CANTCONVERTVALUE;
                            cErrors++;
                            continue;
                        }
                        else
                        {
                            DWORD dwRequiredLen;
                            PVARIANT pVar;

                            if((rgColumns[i].wType & (~DBTYPE_BYREF)) != 
                                                         DBTYPE_VARIANT)
                            {
                                // bad type
                                rgColumns[i].dwStatus =
                                        DBSTATUS_E_CANTCONVERTVALUE;
                                cErrors++;
                                continue;
                            }

                            if(rgColumns[i].wType & DBTYPE_BYREF)
                                dwRequiredLen = sizeof(VARIANT *);
                            else
                                dwRequiredLen = sizeof(VARIANT);

                            if(rgColumns[i].cbMaxLen < dwRequiredLen)
                            {
                                rgColumns[i].dwStatus =
                                    DBSTATUS_E_CANTCONVERTVALUE;
                                cErrors++;
                                continue;
                            }

                            if(rgColumns[i].wType & DBTYPE_BYREF)
                            { 
                                pVar = (PVARIANT)
                                          CoTaskMemAlloc(sizeof(VARIANT));
                                if (pVar == NULL)
                                {
                                    rgColumns[i].dwStatus = 
                                          DBSTATUS_E_CANTCREATE;
                                    cErrors++;
                                    continue;
                                }
                            }
                            else
                                pVar = (PVARIANT) rgColumns[i].pData;

                            VariantInit(pVar);
                            hr = VariantCopy(pVar, &varTemp);
                            if(FAILED(hr))
                            {
                                hr = S_OK;
                                rgColumns[i].dwStatus = DBSTATUS_E_CANTCREATE;
                                cErrors++;
                                if(rgColumns[i].wType & DBTYPE_BYREF)
                                    CoTaskMemFree(pVar); 
                                continue;
                            }

                            if(rgColumns[i].wType & DBTYPE_BYREF)
                            {
                                *(PVARIANT *)rgColumns[i].pData = pVar;
                                rgColumns[i].cbDataLen = sizeof(PVARIANT);
                            }
                            else
                                rgColumns[i].cbDataLen = sizeof(VARIANT);
                        }
                    }
                    else //single valued
                    {
                        hr = pDataConvert->DataConvert(
                            propType,
                            rgColumns[i].wType,
                            sizeof(VARIANT),
                            &rgColumns[i].cbDataLen,
                            &varTemp,
                            rgColumns[i].pData,
                            rgColumns[i].cbMaxLen,
                            DBSTATUS_S_OK,
                            &rgColumns[i].dwStatus,
                            rgColumns[i].bPrecision,
                            rgColumns[i].bScale,
                            DBDATACONVERT_DEFAULT
                            );
                    }
                    if (FAILED(hr))
                    {
                        hr = S_OK;
                        rgColumns[i].dwStatus = DBSTATUS_E_CANTCONVERTVALUE;
                        cErrors++;
                    }
                }
            }
        }
	
	    CATCHBLOCKBAIL(hr)        
        
		if (cErrors == 0)
            RRETURN(S_OK);
        else if (cErrors < cColumns)
            RRETURN(DB_S_ERRORSOCCURRED);
        else
            RRETURN(DB_E_ERRORSOCCURRED);
        
error:
        RRETURN(hr);
        
}

//+---------------------------------------------------------------------------
//
//  Function:   CRow::GetSourceRowset
//
//  Synopsis:   Returns interface pointer on the Source Rowset from which this
//              Row was created.
//
//  Returns:    HRESULT
//
//  For more info see OLE DB 2.5 spec.
//----------------------------------------------------------------------------
STDMETHODIMP CRow::GetSourceRowset(
                                   /* [in] */ REFIID riid,
                                   /* [iid_is][out] */ IUnknown **ppRowset,
                                   /* [out] */ HROW *phRow)
                                   
{
    if (ppRowset == NULL && phRow == NULL)
        RRETURN(E_INVALIDARG);
    
    HRESULT         hr;
    auto_leave      cs_auto_leave(m_autocs);
    
    if (ppRowset)
        *ppRowset = NULL;
    if (phRow)
        *phRow = DB_NULL_HROW;
    
	TRYBLOCK
    
		cs_auto_leave.EnterCriticalSection();
        if( m_fIsTearOff )
        {
            ADsAssert(m_pSourceRowset.get());
            if (ppRowset)
            {
                hr = m_pSourceRowset->QueryInterface(riid, (void**)ppRowset);
                if (FAILED(hr))
                    BAIL_ON_FAILURE(hr = E_NOINTERFACE);
            }
            
            if (phRow)
            {
                // increment reference count of row handle

                auto_rel<IRowset> pRowset;

                hr = m_pSourceRowset->QueryInterface(__uuidof(IRowset),
                          (void **)&pRowset);
                BAIL_ON_FAILURE(hr);

                hr = pRowset->AddRefRows(1, &m_hRow, NULL, NULL);
                BAIL_ON_FAILURE(hr);

                *phRow = m_hRow;
            }
        }
        else
        {
            BAIL_ON_FAILURE(hr = DB_E_NOSOURCEOBJECT);
        }
	
	CATCHBLOCKBAIL(hr)    
    
	RRETURN(S_OK);
    
error:
    if(ppRowset && (*ppRowset != NULL))
    {
        (*ppRowset)->Release();
        *ppRowset = NULL;
    }

    RRETURN(hr);
}

//+---------------------------------------------------------------------------
//
//  Function:   CRow::Open
//
//  Synopsis:   Opens a column of a row and returns the requested
//              interface on it.
//
//  Returns:    HRESULT
//
//  For more info see OLE DB 2.5 spec.
//----------------------------------------------------------------------------
STDMETHODIMP CRow::Open(
                        /* [unique][in] */ IUnknown *pUnkOuter,
                        /* [in] */ DBID *pColumnID,
                        /* [in] */ REFGUID rguidColumnType,
                        /* [in] */ DWORD dwBindFlags,
                        /* [in] */ REFIID riid,
                        /* [iid_is][out] */ IUnknown **ppUnk)
{
    HRESULT                                 hr = S_OK;
    CComVariant                             varData;
    CComObject<CStreamMem>* pMemoryStream = NULL;
    auto_rel<IStream>               pStreamDelete;
    DBCOLUMNACCESS                  rgColumns[1];
    DBID                    dbidRowUrl = DBROWCOL_ROWURL;
    
	TRYBLOCK
    
		//General validation checks. dwBindFlags is reserved and must be 0.
        if (ppUnk == NULL || pColumnID == NULL || dwBindFlags != 0)
            RRETURN(E_INVALIDARG);

        *ppUnk = NULL;
       
        // columnID has to be URL, bookmark or DBKIND_NAME  
        if ((pColumnID->eKind != DBKIND_NAME) &&
            (FALSE == CompareDBIDs(&dbidRowUrl, pColumnID)) &&
            (!((pColumnID->eKind == DBKIND_GUID_PROPID) &&
               (pColumnID->uGuid.guid == DBCOL_SPECIALCOL) &&
               (pColumnID->uName.ulPropid == 2))
            )
           )
            RRETURN(DB_E_BADCOLUMNID);
        
        if ((pColumnID->eKind == DBKIND_NAME) &&
                (pColumnID->uName.pwszName == NULL))
            RRETURN(DB_E_BADCOLUMNID);
        
        if (pUnkOuter != NULL && !InlineIsEqualGUID(riid, IID_IUnknown))
            RRETURN(DB_E_NOAGGREGATION);
        
        //we don't support aggregation
        if (pUnkOuter != NULL)
            RRETURN(DB_E_NOAGGREGATION);
       
        // riid has to be one of the interfaces that can be QIed from
        // IStream, need not necessarily be IID_IStream 

        hr = CopyDBIDs(&rgColumns[0].columnid, pColumnID);
        if (FAILED(hr))
            BAIL_ON_FAILURE(hr = DB_E_BADCOLUMNID);
        
        //fill relevant fields of rgColumns[0]
        rgColumns[0].wType = DBTYPE_VARIANT;
        rgColumns[0].pData = (VARIANT *)&varData;
        rgColumns[0].cbMaxLen = sizeof(VARIANT);
        
        //get column data
        hr = GetColumns(1, rgColumns);
        if (FAILED(hr))
            BAIL_ON_FAILURE(hr = DB_E_BADCOLUMNID);

        if (rguidColumnType != DBGUID_STREAM)
            //we currently support only streams
            RRETURN(DB_E_OBJECTMISMATCH);
        
        //Check if the returned data is of type binary -
        //Note: ADSI returns binary data as type VT_ARRAY | VT_UI1.
        if (V_VT(&varData) != (VT_ARRAY | VT_UI1))
            BAIL_ON_FAILURE(hr = DB_E_OBJECTMISMATCH);
        
        hr = CComObject<CStreamMem>::CreateInstance(&pMemoryStream);
        if (FAILED(hr))
            BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
        
        //To make sure we delete the CStreamMem object in case we ecounter
        //errors after this point.
        pMemoryStream->AddRef();
        pStreamDelete = pMemoryStream;
        
        hr = pMemoryStream->Initialize(&varData, (IRow *)this, m_hRow);
        if (FAILED(hr))
            BAIL_ON_FAILURE(hr = DB_E_OBJECTMISMATCH);
        
        hr = pMemoryStream->QueryInterface(riid, (void **)ppUnk);
        if (FAILED(hr))
            BAIL_ON_FAILURE(hr = E_NOINTERFACE);
	
	CATCHBLOCKBAIL(hr);    

error:
    
    FreeDBID(&rgColumns[0].columnid);
    RRETURN(hr);
}

///////////////////////////////////////////////////////////////////////////////
//IColumnsInfo2 : IColumnsInfo
//
//+---------------------------------------------------------------------------
//
//  Function:   CRow::GetColumnInfo
//
//  Synopsis:   returns column information on a row. Column 0 is the URL column.
//
//  Returns:    HRESULT
//
//  For more info see OLE DB 2.5 spec.
//----------------------------------------------------------------------------
STDMETHODIMP CRow::GetColumnInfo(
                                 /* [out][in] */ DBORDINAL *pcColumns,
                                 /* [size_is][size_is][out] */ DBCOLUMNINFO **prgInfo,
                                 /* [out] */ OLECHAR **ppStringsBuffer)
{
    if( pcColumns )
        *pcColumns = 0;
    
    if( prgInfo )
        *prgInfo = NULL;
    
    if( ppStringsBuffer )
        *ppStringsBuffer = NULL;
    
    if( !pcColumns || !prgInfo || !ppStringsBuffer )
        RRETURN( E_INVALIDARG );
    
    RRETURN(GetRestrictedColumnInfo (
        0,
        NULL,
        0,
        pcColumns,
        NULL,
        prgInfo,
        ppStringsBuffer
        ));
}

//+---------------------------------------------------------------------------
//
//  Function:   CRow::MapColumnIDs
//
//  Synopsis:   Maps column IDs
//
//  Returns:    HRESULT
//
//  For more info see OLE DB 2.5 spec.
//----------------------------------------------------------------------------
STDMETHODIMP CRow::MapColumnIDs(
                                /* [in] */ DBORDINAL cColumnIDs,
                                /* [size_is][in] */ const DBID rgColumnIDs[  ],
                                /* [size_is][out] */ DBORDINAL rgColumns[  ])
{
	HRESULT hr;
	ULONG cValidCols = 0;
    
    //
    // check in-params and NULL out-params in case of error
    //
	if( cColumnIDs == 0 )
        RRETURN( S_OK );

    if( !rgColumnIDs || !rgColumns )
        RRETURN( E_INVALIDARG );

    //
	// Get the ColumnsInfo
	//
    DBORDINAL      ulColumns;
	DBCOLUMNINFO * rgColumnInfo = NULL;
	OLECHAR *	   pStringBuffer = NULL;

	hr=GetColumnInfo((DBORDINAL *)&ulColumns, &rgColumnInfo, &pStringBuffer);
	if( FAILED(hr) )
		RRETURN( hr );

    for(ULONG iCol=0; iCol < cColumnIDs; iCol++)
    {
        // Initialize the column ordinal to invalid column
        rgColumns[iCol] = DB_INVALIDCOLUMN;

        for (ULONG iOrdinal = 0; iOrdinal < ulColumns; iOrdinal++)
        {
            if (TRUE == CompareDBIDs( 
                                    &rgColumnIDs[iCol],
                                    &rgColumnInfo[iOrdinal].columnid))
            {
				rgColumns[iCol] = rgColumnInfo[iOrdinal].iOrdinal;
				cValidCols++;
				break;
			}
		}
	}

	//
	// Free the ColumnsInfo
	//
	if( rgColumnInfo )
		CoTaskMemFree(rgColumnInfo);

	if( pStringBuffer )
		CoTaskMemFree(pStringBuffer);

	//
	// Return the HRESULT
	//
	if( cValidCols == 0 )
        RRETURN( DB_E_ERRORSOCCURRED );
    else if( cValidCols < cColumnIDs )
        RRETURN( DB_S_ERRORSOCCURRED );
    else
        RRETURN( S_OK );
}

//+---------------------------------------------------------------------------
//
//  Function:   CRow::GetRestrictedColumnInfo
//
//  Synopsis:   returns column information for those columns which match given
//                              mask criteria.
//
//  Returns:    HRESULT
//
//  For more info see OLE DB 2.5 spec.
//----------------------------------------------------------------------------
STDMETHODIMP CRow::GetRestrictedColumnInfo(
                                           /* [in] */ DBORDINAL cColumnIDMasks,
                                           /* [in] */ const DBID rgColumnIDMasks[  ],
                                           /* [in] */ DWORD dwFlags,
                                           /* [out][in] */ DBORDINAL *pcColumns,
                                           /* [size_is][size_is][out] */ DBID **prgColumnIDs,
                                           /* [size_is][size_is][out] */ DBCOLUMNINFO **prgColumnInfo,
                                           /* [out] */ OLECHAR **ppStringsBuffer)
{
    HRESULT                     hr = S_OK;
    ULONG                       ulNumColumns = 0, ulStartColumn;
    int                         iColumn = 0;
    int                         i = 0, j=0, iMask = 0;
    auto_leave                  cs_auto_leave(m_autocs);
    DWORD                       cMaxColumns ;
    auto_rel<IDirectoryObject>  pIDirObj;
    DBID                        bookMarkColid;
    bool                        bAddBookMark = false;

    
    //
    //      Zero the out params:
    //
    
    if (pcColumns)
        *pcColumns  = 0;
    
    if (prgColumnIDs)
        *prgColumnIDs   = NULL;
    
    if (prgColumnInfo)
        *prgColumnInfo  = NULL;
    
    if (ppStringsBuffer)
        *ppStringsBuffer = NULL;
    
    // Validate arguments.
    if ((dwFlags) || (pcColumns == NULL) || (ppStringsBuffer == NULL) )
        RRETURN( E_INVALIDARG);
    
    // Either column info or column ids should be available.
    if ((NULL == prgColumnIDs) && (NULL == prgColumnInfo))
        RRETURN( E_INVALIDARG);
    
    //Validate the mask
    if (cColumnIDMasks && !rgColumnIDMasks)
        RRETURN( E_INVALIDARG);
    
    for (iMask = 0; iMask < cColumnIDMasks; iMask++)
        if (S_FALSE == IsValidDBID(&rgColumnIDMasks[iMask]))
            RRETURN( DB_E_BADCOLUMNID );
        
	TRYBLOCK
    { 
		cs_auto_leave.EnterCriticalSection();
            
        // We must have a valid ADs object or a valid Source Rowset
        ADsAssert(m_pADsObj.get() || m_pSourceRowset.get());
            
        // Calculate maximum number of columns that we will return,
        // excluding the bookmark column. We will add bookmark later.
        if (m_fGetColInfoFromRowset)
        {
            ADsAssert(m_pSourceRowset.get() != NULL);

            // m_cSourceRowsetColumns includes the bookmark column.
            cMaxColumns = m_cSourceRowsetColumns - 1;
        }
        else
        {
            if(m_cMaxColumns != -1)
                cMaxColumns = m_cMaxColumns;
            else
            {
                hr = m_pADsObj->QueryInterface(__uuidof(IDirectoryObject),
                    (void**)&pIDirObj);
                BAIL_ON_FAILURE(hr);
                
                hr = pIDirObj->GetObjectAttributes(NULL, -1, &m_pAttrInfo,
                      &cMaxColumns);
                BAIL_ON_FAILURE(hr);
                
                // Add one for ADsPath. ADsPath is returned if the query was a 
                // SELECT * query (irrespective of whether the row was obtained
                // from a rowset or directly from a command object) OR if 
                // IBindResource::Bind was used to get the row.
                cMaxColumns += 1;
             
                m_cMaxColumns = cMaxColumns;
            }
        }

        // Add one for URL (for all rows)
        cMaxColumns++;
            
        BSTR                    bstrName;
        auto_prg<CComBSTR>      propStrings;
        auto_prg<DBTYPE>        propTypes;
        auto_prg<ULONG>         propSizes;
            
        propStrings = new CComBSTR[cMaxColumns];
          
        if (!propStrings)
        {
            hr = E_OUTOFMEMORY;
            BAIL_ON_FAILURE(hr);
        }
            
        // If client asked for columns info. allocate DBTYPE array
        if (prgColumnInfo)
        {
            propTypes = new DBTYPE[cMaxColumns];
            propSizes = new ULONG[cMaxColumns];
            if (!propTypes || !propSizes)
                BAIL_ON_FAILURE(E_OUTOFMEMORY);
        }
        
        int totalLen = 0;
        ulNumColumns = 0;
        BOOL fURLMatchesMask = FALSE; 

        if (m_fGetColInfoFromRowset)
        {
            ADsAssert(m_pSourceRowset.get() != NULL);

            // start with 1 because column # 0 in source rowset
            // is always a bookmark column.
            
            for (i = 1; i < m_cSourceRowsetColumns; i++)
            {
                //We need to check if this column matches mask criteria. Use
                // the column name for comparison since we should have a match
                // even if a substring of the column name is specified by the
                // client. Comparing column ID won't work in this case.
                // We know that all columns other than the bookmark (column 0)
                // are of type DBKIND_NAME. So we can access pwszName safely.
                if (fMatchesMaskCriteria(
                    m_pSourceRowsetColumnInfo[i].columnid.uName.pwszName,
                    cColumnIDMasks,
                    rgColumnIDMasks) == false)
                    continue;
                
                //matches the criteria, add to list and
                //update totalLen for strings buffer.
                propStrings[(int)ulNumColumns] =
                    m_pSourceRowsetColumnInfo[i].pwszName;
                totalLen += SysStringLen(propStrings[(int)ulNumColumns]) + 1;
                
                //add type and size to list if columninfo is requested.
                if (prgColumnInfo)
                {
                    propTypes[(int)ulNumColumns] =
                        m_pSourceRowsetColumnInfo[i].wType;
                    
                    propSizes[(int)ulNumColumns] =
                        m_pSourceRowsetColumnInfo[i].ulColumnSize;
                }
                
                ulNumColumns++;
            }

            // Finally, check if URL column is requested
            if (fMatchesMaskCriteria(DBROWCOL_ROWURL, cColumnIDMasks,
                       rgColumnIDMasks) == true)
            {
                //matches the criteria, add to list and
                //update totalLen for strings buffer.
                bstrName = SysAllocString(g_cwszAdsPath);
                propStrings[(int)ulNumColumns].Attach(bstrName);
                bstrName = NULL;
                totalLen += SysStringLen(propStrings[(int)ulNumColumns]) + 1;

                // we know the type and size of the URL column

                ulNumColumns++;
                fURLMatchesMask = TRUE;
            }
        }
        else
        {
            for (i = 0; i < cMaxColumns; i++)
            {
                if ((cMaxColumns-1) == i)  // special URL column
                {
                    if (fMatchesMaskCriteria(DBROWCOL_ROWURL, cColumnIDMasks,
                                   rgColumnIDMasks) == true)
                    {
                        bstrName = SysAllocString(g_cwszAdsPath);
                        fURLMatchesMask = TRUE;
                    }
                    else
                        continue;
                }
                else 
                {
                    if (0 == i)  //ADsPath
                        bstrName = SysAllocString(g_cwszAdsPath);
                    else
                    {
                        bstrName =SysAllocString(m_pAttrInfo[i-1].pszAttrName); 
                    }
                
                    // If property doesn't match
                    // mask criteria, continue with next property.
                
                    if (
                        (fMatchesMaskCriteria(bstrName,
                        cColumnIDMasks,
                        rgColumnIDMasks) == false)
                        )
                    {
                        SysFreeString(bstrName);
                        bstrName = NULL;
                        continue;
                    }
                } // else
                
                // OK Matches the criterion add to the list and
                // update toalLen for strings buffer.
                propStrings[(int)ulNumColumns].Attach(bstrName);
                bstrName = NULL;
                totalLen += SysStringLen(propStrings[(int)ulNumColumns]) + 1;
                
                //Get Type and size of column if ColumnInfo is requested.
                //For the special URL column and the ADsPath column, we already 
                //know the type.
                if ((i > 0) && (i < (cMaxColumns-1)) && (prgColumnInfo != NULL))
                {
                    hr = GetTypeAndSize(
                        m_pAttrInfo[i-1].dwADsType,
                        propStrings[(int)ulNumColumns],
                        &propTypes[(int)ulNumColumns],
                        &propSizes[(int)ulNumColumns]
                        );
                    BAIL_ON_FAILURE(hr);
                }
                
                // Increment number of columns count
                ulNumColumns++;
            }
        }
        
        if (ulNumColumns == 0)
            BAIL_ON_FAILURE(hr = DB_E_NOCOLUMN);
        
        //We will add a bookmark column to the list that we are going to return.
        bookMarkColid.eKind = DBKIND_GUID_PROPID;
        bookMarkColid.uGuid.guid = DBCOL_SPECIALCOL;
        bookMarkColid.uName.ulPropid = 2;
        
        if (fMatchesMaskCriteria(bookMarkColid, cColumnIDMasks, rgColumnIDMasks))
        {
            bAddBookMark = true;
            ulNumColumns += 1;
        }
        
        *pcColumns = ulNumColumns;
        
        // Does the caller want column IDS?
        if ( prgColumnIDs )
        {
            *prgColumnIDs =
                (DBID *) CoTaskMemAlloc( (ulNumColumns) * sizeof (DBID) );
            if (NULL == *prgColumnIDs)
                BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
            
            ZeroMemory ( *prgColumnIDs, (ulNumColumns) * sizeof (DBID));
        }
        
        // Does the caller want COLUMNINFO?
        if ( prgColumnInfo )
        {
            *prgColumnInfo  = (DBCOLUMNINFO *)
                CoTaskMemAlloc( (ulNumColumns) *  sizeof (DBCOLUMNINFO) );
            if (NULL == *prgColumnInfo)
                BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
            
            ZeroMemory ( *prgColumnInfo,
                (ulNumColumns)  * sizeof (DBCOLUMNINFO) );
        }
        
        // get the string buffer allocated.
        *ppStringsBuffer = (OLECHAR *)CoTaskMemAlloc(sizeof(OLECHAR)*totalLen);
        if (NULL ==*ppStringsBuffer)
            BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
        
        OLECHAR *pwChar = *ppStringsBuffer;
        
        //First fill bookmark column information.
        if (prgColumnIDs && bAddBookMark) 
        {
            (*prgColumnIDs)[0] = bookMarkColid;
        }
        
        if (prgColumnInfo && bAddBookMark)
        {
            (*prgColumnInfo)[0].pwszName                = NULL;
            (*prgColumnInfo)[0].pTypeInfo               = NULL;
            (*prgColumnInfo)[0].iOrdinal                = 0;
            (*prgColumnInfo)[0].ulColumnSize            = sizeof(ULONG);
            (*prgColumnInfo)[0].wType                   = DBTYPE_UI4;
            (*prgColumnInfo)[0].bPrecision              = 10;
            (*prgColumnInfo)[0].bScale                  = (BYTE) ~ 0;
            (*prgColumnInfo)[0].columnid.eKind          = DBKIND_GUID_PROPID;
            (*prgColumnInfo)[0].columnid.uGuid.guid     = DBCOL_SPECIALCOL;
            (*prgColumnInfo)[0].columnid.uName.ulPropid = 2;
            (*prgColumnInfo)[0].dwFlags                 = DBCOLUMNFLAGS_ISBOOKMARK |
                DBCOLUMNFLAGS_ISFIXEDLENGTH;
        }
        
        // Fill the rest of the columns.
        if (bAddBookMark)
            ulStartColumn = 1;
        else
            ulStartColumn = 0;
        
        for (iColumn= ulStartColumn, i = 0; iColumn < ulNumColumns; iColumn++, i++)
        {
            wcscpy(pwChar, propStrings[i]);
            
            //Is this the special URL column (has to be last column) 
            if( fURLMatchesMask && (iColumn == (ulNumColumns -1)) &&
                 (_wcsicmp(pwChar, g_cwszAdsPath)) == 0 )
            {
                if ( prgColumnIDs )
                {
                    // Add a new DBID for this column:
                    //
                    (*prgColumnIDs)[iColumn]    = DBROWCOL_ROWURL;
                }
                if ( prgColumnInfo )
                {
                    (*prgColumnInfo)[iColumn].pwszName     = pwChar;
                    (*prgColumnInfo)[iColumn].pTypeInfo    = NULL;
                    (*prgColumnInfo)[iColumn].iOrdinal     = iColumn;
                    (*prgColumnInfo)[iColumn].dwFlags      = DBCOLUMNFLAGS_ISROWURL;
                    //Rowset code sets ulColumnSize for Adspath to 256.
                    //We do the same thing for consistency.
                    (*prgColumnInfo)[iColumn].ulColumnSize = 256;
                    (*prgColumnInfo)[iColumn].wType        = DBTYPE_WSTR;
                    (*prgColumnInfo)[iColumn].bPrecision   = ~0;
                    (*prgColumnInfo)[iColumn].bScale       = ~0;
                    
                    (*prgColumnInfo)[iColumn].columnid     = DBROWCOL_ROWURL;
                }
            }
            // Is this the ADsPath column (if it has the name ADsPath and it
            // is not URL, it has to be the ADsPath column)
            else if(_wcsicmp(pwChar, g_cwszAdsPath) == 0)
            {
                if ( prgColumnIDs )
                {
                    // Add DBID for ADsPath
                    (*prgColumnIDs)[iColumn].eKind = DBKIND_NAME;
                    (*prgColumnIDs)[iColumn].uGuid.guid = GUID_NULL;
                    (*prgColumnIDs)[iColumn].uName.pwszName    = pwChar;
                }
                if ( prgColumnInfo )
                {
                    // Add a DBCOLUMNINFO for ADsPath

                    DBTYPE  wType = DBTYPE_WSTR | DBTYPE_BYREF;

                    (*prgColumnInfo)[iColumn].pwszName              = pwChar;
                    (*prgColumnInfo)[iColumn].pTypeInfo             = NULL;
                    (*prgColumnInfo)[iColumn].iOrdinal              = iColumn;

                    // OLEDB 2.0 code sets ulColumnsSize to 256 for ADsPath
                    (*prgColumnInfo)[iColumn].ulColumnSize          = 256; 
                    (*prgColumnInfo)[iColumn].wType                 = wType; 

                    // the code below has to be identical to the code in
                    // GetColumnsInfo2 in ccommand.cxx
                    wType = wType & (~DBTYPE_BYREF);
                    if( (wType == DBTYPE_STR)  ||
                        (wType == DBTYPE_WSTR) ||
                        (wType == DBTYPE_BYTES) )
                        (*prgColumnInfo)[iColumn].dwFlags =
                         DBCOLUMNFLAGS_ISNULLABLE;
                    else
                        (*prgColumnInfo)[iColumn].dwFlags =
                         DBCOLUMNFLAGS_ISNULLABLE | DBCOLUMNFLAGS_ISFIXEDLENGTH;


                    (*prgColumnInfo)[iColumn].bPrecision = SetPrecision(wType);

                    (*prgColumnInfo)[iColumn].bScale                = ~0;
                    (*prgColumnInfo)[iColumn].columnid.eKind    = DBKIND_NAME;
                    (*prgColumnInfo)[iColumn].columnid.uGuid.guid   = GUID_NULL;
                    (*prgColumnInfo)[iColumn].columnid.uName.pwszName= pwChar;
                }
            }
            else
            {
                if ( prgColumnIDs )
                {
                    // Add a new DBID for this column:
                    //
                    (*prgColumnIDs)[iColumn].eKind    = DBKIND_NAME;
                    (*prgColumnIDs)[iColumn].uGuid.guid = GUID_NULL;
                    (*prgColumnIDs)[iColumn].uName.pwszName    = pwChar;
                   
                }
                if ( prgColumnInfo )
                {
                    //      Add a new DBCOLUMNINFO for this column:
                    //
                    
                    DBTYPE  wType = propTypes[i];
                    
                    (*prgColumnInfo)[iColumn].pwszName              = pwChar;
                    (*prgColumnInfo)[iColumn].pTypeInfo             = NULL;
                    (*prgColumnInfo)[iColumn].iOrdinal              = iColumn;
                    (*prgColumnInfo)[iColumn].ulColumnSize          = propSizes[i];                                           ;
                    (*prgColumnInfo)[iColumn].wType                 = wType;
                    
                    // the code below has to be identical to the code in
                    // GetColumnsInfo2 in ccommand.cxx
                    wType = wType & (~DBTYPE_BYREF);
                    if( (wType == DBTYPE_STR)  ||
                        (wType == DBTYPE_WSTR) ||
                        (wType == DBTYPE_BYTES) )
                        (*prgColumnInfo)[iColumn].dwFlags = 
                         DBCOLUMNFLAGS_ISNULLABLE;
                    else
                        (*prgColumnInfo)[iColumn].dwFlags =
                         DBCOLUMNFLAGS_ISNULLABLE | DBCOLUMNFLAGS_ISFIXEDLENGTH; 

                    (*prgColumnInfo)[iColumn].bPrecision = SetPrecision(wType);
                    
                    (*prgColumnInfo)[iColumn].bScale                = ~0;
                    (*prgColumnInfo)[iColumn].columnid.eKind        = DBKIND_NAME;
                    (*prgColumnInfo)[iColumn].columnid.uGuid.guid   = GUID_NULL;
                    (*prgColumnInfo)[iColumn].columnid.uName.pwszName= pwChar;
                }
            }
            
            //Position the pointer in strings buffer
            //for writing next column name.
            pwChar += SysStringLen(propStrings[i]) + 1;
        }
	
    }		
	CATCHBLOCKBAIL(hr)    

	RRETURN(S_OK);
    
error:
    if ((prgColumnIDs) && (*prgColumnIDs))
    {
        CoTaskMemFree(*prgColumnIDs);
        *prgColumnIDs = NULL;
    }
    if ((prgColumnInfo) && (*prgColumnInfo))
    {
        CoTaskMemFree(*prgColumnInfo);
        *prgColumnInfo = NULL;
    }
    if ((ppStringsBuffer) && (*ppStringsBuffer))
    {
        CoTaskMemFree(*ppStringsBuffer);
        *ppStringsBuffer = NULL;
    }

    if (pcColumns)
        *pcColumns  = 0;

    RRETURN(hr);
}

/////////////////////////////////////////////////////////////////////////////
//IConvertType
//
//+---------------------------------------------------------------------------
//
//  Function:   CRow::ConvertType
//
//  Synopsis:   Converts one DBTYPE to another using data conversion library.
//
//  Returns:    HRESULT
//
//  For more info see OLE DB 2.0 spec.
//----------------------------------------------------------------------------
STDMETHODIMP CRow::CanConvert(
                              /* [in] */ DBTYPE wFromType,
                              /* [in] */ DBTYPE wToType,
                              /* [in] */ DBCONVERTFLAGS dwConvertFlags)
{
    auto_rel<IDataConvert> pDataConvert;
    
    HRESULT hr = GetIDataConvert(&pDataConvert);
    BAIL_ON_FAILURE(hr);
    
    ADsAssert(pDataConvert.get());

    if( dwConvertFlags & DBCONVERTFLAGS_PARAMETER ) // not allowed on row
        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 );
    }

    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 );
    }

    RRETURN(pDataConvert->CanConvert(wFromType, wToType));
    
error:
    RRETURN(hr);
}

///////////////////////////////////////////////////////////////////////////////
//IGetSession
//
//+---------------------------------------------------------------------------
//
//  Function:   CRow::GetSession
//
//  Synopsis:   Gets the Session interface through which this row has been
//              created.
//
//  Returns:    HRESULT
//
//  For more info see OLE DB 2.5 spec.
//----------------------------------------------------------------------------
STDMETHODIMP CRow::GetSession(
                              REFIID riid,
                              IUnknown **ppunkSession)
{
    if (ppunkSession == NULL)
        RRETURN(E_INVALIDARG);
    
    *ppunkSession = NULL;
    
    if (!m_pSession.get())
        RRETURN(DB_E_NOSOURCEOBJECT);
    
    HRESULT hr = m_pSession->QueryInterface(riid, (void**)ppunkSession);
    if (FAILED(hr))
        RRETURN(E_NOINTERFACE);
    
    RRETURN(S_OK);
}

//----------------------------------------------------------------------------
// GetSecurityDescriptor
//
// Returns the security descriptor as an octet string.
//
//----------------------------------------------------------------------------
HRESULT CRow::GetSecurityDescriptor(
    DBCOLUMNACCESS *pColumn,
    BOOL fMultiValued
    )
{
    HRESULT hr;
    auto_rel<IDirectoryObject>  pIDirObj;
    PVARIANT pVariant = NULL, pVarArray = NULL;
    SAFEARRAY *aList = NULL;
    SAFEARRAYBOUND aBound;
    VARTYPE vType;
    DWORD dwRequiredLen;
    int iAttr, j;

    // multivalued attributes are always returned as variants. Single-valued
    // security descriptor has to be returned as either variant or octet 
    // string.
    if( ((pColumn->wType != (DBTYPE_VARIANT | DBTYPE_BYREF)) &&
        (pColumn->wType != DBTYPE_VARIANT)) && 
        (fMultiValued || ((fMultiValued == FALSE) && 
         (pColumn->wType != DBTYPE_BYTES) &&
         (pColumn->wType != (DBTYPE_BYTES | DBTYPE_BYREF)))) )
    {
        pColumn->dwStatus = DBSTATUS_E_CANTCONVERTVALUE;    
        BAIL_ON_FAILURE(hr = DB_E_CANTCONVERTVALUE);
    }

    pColumn->dwStatus = DBSTATUS_S_OK;
    pColumn->cbDataLen = 0;

    if(pColumn->pData == NULL) // client doesn't want any data returned
        RRETURN(S_OK);

    if(m_cMaxColumns == -1) // GetObjectAttributes has not been called
    {
        hr = m_pADsObj->QueryInterface(__uuidof(IDirectoryObject),
             (void**)&pIDirObj);
        BAIL_ON_FAILURE(hr);

        hr = pIDirObj->GetObjectAttributes(NULL, -1, &m_pAttrInfo,
            (DWORD *) &m_cMaxColumns);
        BAIL_ON_FAILURE(hr);

        m_cMaxColumns++; // include ADsPath
    }

    // get the index of security descriptor in the attribute array
    for(iAttr = 0; iAttr < (m_cMaxColumns-1); iAttr++)
        if(!_wcsicmp(m_pAttrInfo[iAttr].pszAttrName, NT_SEC_DESC_ATTR))
            break;

    if(iAttr == (m_cMaxColumns-1))
    {
        pColumn->dwStatus = DBSTATUS_E_UNAVAILABLE; 
        BAIL_ON_FAILURE(hr = DB_E_NOTFOUND);
    }

    ADsAssert(m_pAttrInfo[iAttr].dwADsType == ADSTYPE_NT_SECURITY_DESCRIPTOR);
 
    if(fMultiValued)
    {
        // check if the client has enough space to copy over the variant
        if(pColumn->wType & DBTYPE_BYREF)
            dwRequiredLen = sizeof(VARIANT *);
        else
            dwRequiredLen = sizeof(VARIANT);

        if(pColumn->cbMaxLen < dwRequiredLen)
        {
            pColumn->dwStatus = DBSTATUS_E_CANTCONVERTVALUE;
            BAIL_ON_FAILURE(hr = DB_E_CANTCONVERTVALUE);
        }

        aBound.lLbound = 0;
        aBound.cElements = m_pAttrInfo[iAttr].dwNumValues;

        if(pColumn->wType & DBTYPE_BYREF)
        {
            pVariant = (PVARIANT) AllocADsMem(sizeof(VARIANT));
            if(NULL == pVariant)
                BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
        }
        else
            pVariant = (PVARIANT) pColumn->pData;

        VariantInit(pVariant);

        aList = SafeArrayCreate( VT_VARIANT, 1, &aBound );
        if (aList == NULL)
            BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);        

        hr = SafeArrayAccessData( aList, (void **) &pVarArray );
        BAIL_ON_FAILURE(hr);

        vType = g_MapADsTypeToVarType[m_pAttrInfo[iAttr].dwADsType];

        for (j=0; j<aBound.cElements; j++)
        {
            VariantInit(pVarArray+j);
            V_VT(pVarArray+j) = vType;

            hr = BinaryToVariant(
               m_pAttrInfo[iAttr].pADsValues[j].SecurityDescriptor.dwLength,
               m_pAttrInfo[iAttr].pADsValues[j].SecurityDescriptor.lpValue,
               pVarArray+j);

            if(FAILED(hr))
            {
                int k;

                for(k = 0; k < j; k++)
                    VariantClear(pVarArray+k);
            }

            BAIL_ON_FAILURE(hr);
        }

        SafeArrayUnaccessData( aList );

        V_VT((PVARIANT)pVariant) = VT_ARRAY | VT_VARIANT;
        V_ARRAY((PVARIANT)pVariant) = aList;

        if(pColumn->wType & DBTYPE_BYREF)
            *(PVARIANT *)pColumn->pData = pVariant;

        pColumn->cbDataLen = sizeof(VARIANT); 
    }
    else // single valued
    {
        // check if the client has enough space to copy over the octet string 
        if(pColumn->wType & DBTYPE_VARIANT)
        {
            if(pColumn->wType & DBTYPE_BYREF)       
                dwRequiredLen = sizeof(VARIANT *);
            else
                dwRequiredLen = sizeof(VARIANT);
        }
        else if(pColumn->wType & DBTYPE_BYTES)
        {
            if(pColumn->wType & DBTYPE_BYREF)
                dwRequiredLen = sizeof(BYTE *);
            else
                dwRequiredLen =
                  m_pAttrInfo[iAttr].pADsValues[0].SecurityDescriptor.dwLength;
        }

        if(pColumn->cbMaxLen < dwRequiredLen)
        {
            pColumn->dwStatus = DBSTATUS_E_CANTCONVERTVALUE;
            BAIL_ON_FAILURE(hr = DB_E_CANTCONVERTVALUE);
        }

        if(pColumn->wType & DBTYPE_VARIANT)
        {
            if(pColumn->wType & DBTYPE_BYREF)
            {
                pVariant = (PVARIANT) AllocADsMem(sizeof(VARIANT));
                if(NULL == pVariant)
                    BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
            }
            else
                pVariant = (PVARIANT) pColumn->pData;

            VariantInit(pVariant);

            vType = g_MapADsTypeToVarType[m_pAttrInfo[iAttr].dwADsType];
            V_VT(pVariant) = vType;

            hr = BinaryToVariant(
               m_pAttrInfo[iAttr].pADsValues[0].SecurityDescriptor.dwLength,
               m_pAttrInfo[iAttr].pADsValues[0].SecurityDescriptor.lpValue,
               pVariant);
            BAIL_ON_FAILURE(hr);

            if(pColumn->wType & DBTYPE_BYREF)
                *(PVARIANT *)pColumn->pData = pVariant;

            pColumn->cbDataLen = sizeof(VARIANT);
        }
        else if(pColumn->wType & DBTYPE_BYTES)
        {
            if(pColumn->wType & DBTYPE_BYREF)
                *(BYTE **)pColumn->pData =
                   m_pAttrInfo[iAttr].pADsValues[0].SecurityDescriptor.lpValue;
            else
                memcpy(pColumn->pData,
                 m_pAttrInfo[iAttr].pADsValues[0].SecurityDescriptor.lpValue,
                 m_pAttrInfo[iAttr].pADsValues[0].SecurityDescriptor.dwLength); 

            pColumn->cbDataLen =
                 m_pAttrInfo[iAttr].pADsValues[0].SecurityDescriptor.dwLength;
        }
    }

    RRETURN(S_OK);

error:

    if(aList)
        SafeArrayDestroy(aList);
    if((pVariant) && (pColumn->wType & DBTYPE_BYREF))
        FreeADsMem(pVariant);

    RRETURN(hr);
}

//---------------------------------------------------------------------------
// IgnorecbMaxLen
//
// This function returns 1 if the cbMaxLen field of DBCOLUMNACCESS structure
// should be ignored and 0 otherwise. cbMaxLen should be ignored for fixed
// length data types and data types combined with DBTYPE_BYREF, DBTYPE_VECTOR
// and DBTYPE_ARRAY (page 107, OLEDB 2.0 spec)
//
//---------------------------------------------------------------------------
int CRow::IgnorecbMaxLen(DBTYPE wType)
{
    if( (wType & DBTYPE_BYREF) ||
        (wType & DBTYPE_VECTOR) ||
        (wType & DBTYPE_ARRAY) )
        return 1;

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

    // check if it is a variable length data type
    if( (DBTYPE_STR == wType) ||
        (DBTYPE_BYTES == wType) ||
        (DBTYPE_WSTR == wType) ||
        (DBTYPE_VARNUMERIC == wType) )
        return 0;

    // must be fixed length data type
    return 1;
} 
 
//-----------------------------------------------------------------------------           

#endif