2333 lines
83 KiB
C++
2333 lines
83 KiB
C++
// 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
|