You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1351 lines
44 KiB
1351 lines
44 KiB
//+-------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1994 - 2000.
|
|
//
|
|
// File: colinfo.cxx
|
|
//
|
|
// Contents: Column information for rowsets
|
|
//
|
|
// Classes: CColumnsInfo
|
|
//
|
|
// Notes: Designed as an aggregated class of an IRowset or an
|
|
// IQuery implementation.
|
|
//
|
|
// History: 04 Feb 1995 AlanW Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
#include "pch.cxx"
|
|
#pragma hdrstop
|
|
|
|
#include <colinfo.hxx>
|
|
#include <query.hxx>
|
|
#include <tblvarnt.hxx>
|
|
|
|
#include "tblrowal.hxx"
|
|
#include "tabledbg.hxx"
|
|
|
|
// Always bind as DBTYPE_VARIANT, so we can use provider-owned memory
|
|
|
|
#define ALWAYS_USE_VARIANT_BINDING
|
|
|
|
ULONG CColumnsInfo::_nUnique = 0;
|
|
|
|
const static GUID guidBmk = DBBMKGUID;
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Method: CColumnsInfo::QueryInterface, public
|
|
//
|
|
// Synopsis: Invokes QueryInterface on controlling unknown object
|
|
//
|
|
// Arguments: [riid] -- interface ID
|
|
// [ppvObject] -- returned interface pointer
|
|
//
|
|
// Returns: SCODE
|
|
//
|
|
// History: 04 Feb 1995 AlanW Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CColumnsInfo::QueryInterface(
|
|
REFIID riid,
|
|
void **ppvObject)
|
|
{
|
|
return _rUnknown.QueryInterface(riid,ppvObject);
|
|
} //QueryInterface
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Method: CColumnsInfo::AddRef, public
|
|
//
|
|
// Synopsis: Invokes AddRef on controlling unknown object
|
|
//
|
|
// Returns: ULONG
|
|
//
|
|
// History: 04 Feb 1995 AlanW Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP_(ULONG) CColumnsInfo::AddRef()
|
|
{
|
|
return _rUnknown.AddRef();
|
|
} //AddRef
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Method: CColumnsInfo::Release, public
|
|
//
|
|
// Synopsis: Invokes Release on controlling unknown object
|
|
//
|
|
// Returns: ULONG
|
|
//
|
|
// History: 04 Feb 1995 AlanW Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP_(ULONG) CColumnsInfo::Release()
|
|
{
|
|
return _rUnknown.Release();
|
|
} //Release
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CColumnsInfo::CColumnsInfo, public
|
|
//
|
|
// Synopsis: Creates a column information class
|
|
//
|
|
// Arguments: [cols] -- a reference to the output column set, pidmapped
|
|
// [pidmap] -- property IDs and names for the columns
|
|
// [ErrorObject] -- a reference to enclosing object's error obj.
|
|
// [rUnknown] -- a reference to the controlling IUnknown
|
|
// [fSequential] -- TRUE if the query is sequential
|
|
//
|
|
// Notes:
|
|
//
|
|
// History: 04 Feb 1995 AlanW Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
CColumnsInfo::CColumnsInfo(
|
|
CColumnSet const & cols,
|
|
CPidMapperWithNames const & pidmap,
|
|
CCIOleDBError & ErrorObject,
|
|
IUnknown & rUnknown,
|
|
BOOL fSequential ) :
|
|
_idUnique(0),
|
|
_rUnknown(rUnknown),
|
|
_fSequential(fSequential),
|
|
_fChaptered(FALSE),
|
|
_cbRowWidth(0),
|
|
_cColumns( cols.Count() ),
|
|
_cBoundColumns(0),
|
|
_iColRowId(pidInvalid),
|
|
_pColumns(0),
|
|
_pidmap( cols.Count()+1 ),
|
|
_ErrorObject( ErrorObject ),
|
|
_fNotPrepared(FALSE)
|
|
{
|
|
_SetColumns(cols, pidmap, fSequential);
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CColumnsInfo::CColumnsInfo, public
|
|
//
|
|
// Synopsis: Creates an empty column information class
|
|
//
|
|
// Arguments: [rUnknown] -- a reference to the controlling IUnknown
|
|
// [ErrorObject] -- a reference to enclosing object's error obj.
|
|
//
|
|
// Notes: Used in the command object where column information may
|
|
// change, depending upon the command.
|
|
//
|
|
// History: 11 Aug 1997 AlanW Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
CColumnsInfo::CColumnsInfo(
|
|
IUnknown & rUnknown,
|
|
CCIOleDBError & ErrorObject,
|
|
BOOL fNotPrepared) :
|
|
_idUnique(_GetNewId()),
|
|
_rUnknown(rUnknown),
|
|
_fSequential(FALSE),
|
|
_fChaptered(FALSE),
|
|
_cbRowWidth(0),
|
|
_cColumns( 0 ),
|
|
_cBoundColumns(0),
|
|
_iColRowId(pidInvalid),
|
|
_pColumns(0),
|
|
_pidmap( 0 ),
|
|
_ErrorObject( ErrorObject ),
|
|
_fNotPrepared(fNotPrepared)
|
|
{
|
|
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CColumnsInfo::~CColumnsInfo, public
|
|
//
|
|
// Synopsis: Destroys a column information class
|
|
//
|
|
// Notes:
|
|
//
|
|
// History: 12 Feb 1995 AlanW Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
CColumnsInfo::~CColumnsInfo( )
|
|
{
|
|
delete _pColumns;
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CColumnsInfo::InitColumns, public
|
|
//
|
|
// Synopsis: Initializes or reinitializes columns.
|
|
//
|
|
// Arguments: [cols] -- a reference to the output column set, pidmapped
|
|
// [pidmap] -- property IDs and names for the columns
|
|
// [fSequential] -- TRUE if the query is sequential
|
|
//
|
|
// Notes:
|
|
//
|
|
// History: 11 Aug 1997 AlanW Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void CColumnsInfo::InitColumns (
|
|
CColumnSet const & cols,
|
|
CPidMapperWithNames const & pidmap,
|
|
BOOL fSequential )
|
|
{
|
|
_pidmap.Clear();
|
|
_cColumns = cols.Count();
|
|
_fSequential = fSequential;
|
|
_SetColumns(cols, pidmap, fSequential);
|
|
_fChaptered = FALSE;
|
|
_fNotPrepared = FALSE;
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CColumnsInfo::InitColumns, public
|
|
//
|
|
// Synopsis: Reinitializes columns to be null.
|
|
//
|
|
// Arguments: [fNotPrepared] - TRUE if GetColumnInfo and MapColumnIDs should
|
|
// return DB_E_NOTPREPARED for a command object
|
|
//
|
|
// Notes:
|
|
//
|
|
// History: 11 Aug 1997 AlanW Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void CColumnsInfo::InitColumns ( BOOL fNotPrepared )
|
|
{
|
|
_pidmap.Clear();
|
|
_cColumns = 0;
|
|
_fSequential = FALSE;
|
|
_fChaptered = FALSE;
|
|
_fNotPrepared = fNotPrepared;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CColumnsInfo::_SetColumns, private
|
|
//
|
|
// Synopsis: Initializes or reinitializes columns.
|
|
//
|
|
// Arguments: [cols] -- a reference to the output column set, pidmapped
|
|
// [pidmap] -- property IDs and names for the columns
|
|
// [fSequential] -- TRUE if the query is sequential
|
|
//
|
|
// Notes:
|
|
//
|
|
// History: 11 Aug 1997 AlanW Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void CColumnsInfo::_SetColumns (
|
|
CColumnSet const & cols,
|
|
CPidMapperWithNames const & pidmap,
|
|
BOOL fSequential )
|
|
{
|
|
Win4Assert( 0 == _pColumns && 0 == _cbRowWidth );
|
|
_idUnique = _GetNewId();
|
|
|
|
//
|
|
// We want the PidMapper to give back 1-based column numbers;
|
|
// add either a null propspec or the bookmark column as its first element.
|
|
//
|
|
|
|
if (fSequential)
|
|
{
|
|
CFullPropSpec nullCol;
|
|
_pidmap.NameToPid( nullCol );
|
|
}
|
|
else
|
|
{
|
|
CFullPropSpec bmkCol( guidBmk, PROPID_DBBMK_BOOKMARK );
|
|
_pidmap.NameToPid( bmkCol );
|
|
}
|
|
|
|
for (unsigned i = 0; i < _cColumns; i++)
|
|
{
|
|
PROPID pidTmp = cols.Get(i);
|
|
const CFullPropSpec & ColId = *pidmap.Get(pidTmp);
|
|
|
|
if (ColId.IsPropertyPropid() &&
|
|
ColId.GetPropSet() == guidBmk)
|
|
{
|
|
Win4Assert( !fSequential );
|
|
if (ColId.GetPropertyPropid() == PROPID_DBBMK_BOOKMARK)
|
|
{
|
|
if (0 != pidmap.GetFriendlyName(pidTmp))
|
|
{
|
|
_pidmap.SetFriendlyName( 0, pidmap.GetFriendlyName(pidTmp) );
|
|
}
|
|
continue;
|
|
}
|
|
else if (ColId.GetPropertyPropid() == PROPID_DBBMK_CHAPTER)
|
|
{
|
|
_fChaptered = TRUE;
|
|
}
|
|
}
|
|
PROPID pidNew = _pidmap.NameToPid( ColId );
|
|
if (0 != pidmap.GetFriendlyName(pidTmp))
|
|
{
|
|
_pidmap.SetFriendlyName( pidNew, pidmap.GetFriendlyName(pidTmp) );
|
|
}
|
|
}
|
|
|
|
// In case of duplicate columns, _cColumns needs to be adjusted.
|
|
Win4Assert( _pidmap.Count() > 1 );
|
|
_cColumns = _pidmap.Count() - 1;
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CColumnsInfo::MapColumnID, private
|
|
//
|
|
// Synopsis: Map a column identifier to its column number in the
|
|
// cursor.
|
|
//
|
|
// Arguments: [pColumnId] - A pointer to the column identifier.
|
|
//
|
|
// Returns: The column number (1-based). Returns DB_INVALIDCOLUMN
|
|
// on error.
|
|
//
|
|
// History: 04 Feb 1995 AlanW Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
ULONG CColumnsInfo::MapColumnID(
|
|
const DBID * pColumnId
|
|
) {
|
|
PROPID pid = pidInvalid;
|
|
|
|
if (pColumnId->eKind == DBKIND_PGUID_PROPID ||
|
|
pColumnId->eKind == DBKIND_PGUID_NAME)
|
|
{
|
|
DBID dbcolMapped = *pColumnId;
|
|
dbcolMapped.uGuid.guid = *pColumnId->uGuid.pguid;
|
|
|
|
if (pColumnId->eKind == DBKIND_PGUID_PROPID)
|
|
dbcolMapped.eKind = DBKIND_GUID_PROPID;
|
|
else
|
|
dbcolMapped.eKind = DBKIND_GUID_NAME;
|
|
|
|
pid = _pidmap.NameToPid(dbcolMapped);
|
|
}
|
|
else
|
|
{
|
|
pid = _pidmap.NameToPid(*pColumnId);
|
|
}
|
|
|
|
tbDebugOut(( DEB_ITRACE, "pid: 0x%x, _cColumns: %d\n",
|
|
pid, _cColumns ));
|
|
|
|
if (pid == pidInvalid || pid > _cColumns || (pid == 0 && _fSequential) )
|
|
return (ULONG) DB_INVALIDCOLUMN;
|
|
|
|
return pid;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CColumnsInfo::MapColumnIDs, public
|
|
//
|
|
// Synopsis: Map a column identifier to its column number in the
|
|
// rowset.
|
|
//
|
|
// Arguments: [cColumnIDs] -- # of elements in the arrays
|
|
// [rgColumnIDs] -- A pointer to the column identifiers
|
|
// [rgColumns] -- an array in which to return the column numbers.
|
|
//
|
|
// Returns: SCODE - DB_S_ERRORSOCCURRED, an element of rgColumnIDs was
|
|
// invalid
|
|
//
|
|
// Notes: Column numbers are 1-based.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CColumnsInfo::MapColumnIDs(
|
|
DBORDINAL cColumnIDs,
|
|
const DBID rgColumnIDs[],
|
|
DBORDINAL rgColumns[])
|
|
{
|
|
_ErrorObject.ClearErrorInfo();
|
|
|
|
SCODE sc = S_OK;
|
|
|
|
if ((0 != cColumnIDs && 0 == rgColumnIDs) ||
|
|
0 == rgColumns)
|
|
return _ErrorObject.PostHResult(E_INVALIDARG, IID_IColumnsInfo);
|
|
|
|
if ( 0 == cColumnIDs )
|
|
return S_OK;
|
|
|
|
if ( _fNotPrepared )
|
|
return _ErrorObject.PostHResult(DB_E_NOTPREPARED, IID_IColumnsInfo);
|
|
|
|
if ( 0 == _cColumns )
|
|
return _ErrorObject.PostHResult(DB_E_NOCOMMAND, IID_IColumnsInfo);
|
|
|
|
unsigned cBadMapping = 0;
|
|
TRY
|
|
{
|
|
for (ULONG i = 0; i < cColumnIDs; i++)
|
|
{
|
|
ULONG ulColID = MapColumnID( &rgColumnIDs[i] );
|
|
rgColumns[i] = ulColID;
|
|
if (ulColID == DB_INVALIDCOLUMN)
|
|
cBadMapping++;
|
|
}
|
|
}
|
|
CATCH( CException, e )
|
|
{
|
|
_ErrorObject.PostHResult(e.GetErrorCode(), IID_IColumnsInfo);
|
|
sc = GetOleError(e);
|
|
}
|
|
END_CATCH;
|
|
|
|
if (SUCCEEDED(sc) && cBadMapping)
|
|
sc = (cBadMapping == cColumnIDs) ? DB_E_ERRORSOCCURRED :
|
|
DB_S_ERRORSOCCURRED;
|
|
|
|
return sc;
|
|
} //MapColumnIDs
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CColumnsInfo::GetColumnInfo, public
|
|
//
|
|
// Synopsis: Return information about the columns in the rowset.
|
|
//
|
|
// Arguments: [pcColumns] - A pointer to where the number of columns
|
|
// will be returned.
|
|
// [prgInfo] - A pointer to where a pointer to an array of
|
|
// DBCOLUMNINFO structures describing the columns
|
|
// will be returned. This must be freed by the
|
|
// caller.
|
|
// [ppStringsBuffer] - A pointer to where extra data for strings
|
|
// will be returned. This must be freed by the
|
|
// caller if non-null.
|
|
//
|
|
// Returns: SCODE
|
|
//
|
|
// Notes: Some columns are standard columns available for all file
|
|
// stores. For these columns, full information about data
|
|
// type and sizes can be returned. For any other columns,
|
|
// we can only say that it has a variant type.
|
|
//
|
|
// History: 07 Nov 1994 AlanW Created
|
|
// 04 Feb 1995 AlanW Moved to CColumnsInfo and rewritten
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CColumnsInfo::GetColumnInfo(
|
|
DBORDINAL * pcColumns,
|
|
DBCOLUMNINFO * * prgInfo,
|
|
WCHAR * * ppStringsBuffer)
|
|
{
|
|
_ErrorObject.ClearErrorInfo();
|
|
|
|
SCODE scResult = S_OK;
|
|
|
|
//
|
|
// Initialize arguments before returning errors
|
|
//
|
|
if ( pcColumns)
|
|
*pcColumns = 0;
|
|
if ( prgInfo )
|
|
*prgInfo = 0;
|
|
if (ppStringsBuffer )
|
|
*ppStringsBuffer = 0;
|
|
|
|
if (0 == pcColumns ||
|
|
0 == prgInfo ||
|
|
0 == ppStringsBuffer)
|
|
return _ErrorObject.PostHResult(E_INVALIDARG, IID_IColumnsInfo);
|
|
|
|
if ( _fNotPrepared )
|
|
return _ErrorObject.PostHResult(DB_E_NOTPREPARED, IID_IColumnsInfo);
|
|
|
|
if ( 0 == _cColumns )
|
|
return _ErrorObject.PostHResult(DB_E_NOCOMMAND, IID_IColumnsInfo);
|
|
|
|
TRY
|
|
{
|
|
unsigned iFirstCol = _fSequential ? 1 : 0;
|
|
unsigned cColumns = GetColumnCount() + 1 - iFirstCol;
|
|
|
|
//
|
|
// The total size required for the output array depends upon
|
|
// the size of variable data discovered in the column information.
|
|
// Although we could reallocate the memory we'll be writing into,
|
|
// we'll just run through the loop twice, once to compute the
|
|
// needed space, and the second time to copy the data out after
|
|
// doing our allocation.
|
|
//
|
|
ULONG cchNames = 0;
|
|
|
|
for (unsigned iCol = iFirstCol; iCol <= GetColumnCount(); iCol++)
|
|
{
|
|
const CFullPropSpec & ColId = *_pidmap.Get(iCol);
|
|
|
|
if (ColId.IsPropertyName())
|
|
{
|
|
cchNames += wcslen(ColId.GetPropertyName()) + 1;
|
|
}
|
|
|
|
WCHAR const * pwszColName = _pidmap.GetFriendlyName(iCol);
|
|
if (0 == pwszColName)
|
|
pwszColName = _FindColumnInfo(ColId).pwszName;
|
|
|
|
if (pwszColName)
|
|
{
|
|
cchNames += wcslen(pwszColName) + 1;
|
|
}
|
|
}
|
|
|
|
XArrayOLE<DBCOLUMNINFO> ColumnInfo( cColumns );
|
|
XArrayOLE<WCHAR> StringBuf( cchNames );
|
|
|
|
DBCOLUMNINFO *pColInfo = ColumnInfo.GetPointer();
|
|
WCHAR * pwcNames = StringBuf.GetPointer();
|
|
|
|
for (iCol = iFirstCol; iCol <= GetColumnCount(); iCol++, pColInfo++)
|
|
{
|
|
const CFullPropSpec & ColId = *_pidmap.Get(iCol);
|
|
const DBCOLUMNINFO & rColumnInfo = _FindColumnInfo( ColId );
|
|
|
|
//
|
|
// Copy the prototype column information, then update
|
|
// specific fields in the column info:
|
|
// column number
|
|
// column ID
|
|
// copies of strings
|
|
//
|
|
*pColInfo = rColumnInfo;
|
|
|
|
pColInfo->iOrdinal = iCol;
|
|
|
|
pColInfo->columnid.uGuid.guid = ColId.GetPropSet();
|
|
if (ColId.IsPropertyName())
|
|
{
|
|
pColInfo->columnid.eKind = DBKIND_GUID_NAME;
|
|
ULONG cch = wcslen(ColId.GetPropertyName()) + 1;
|
|
RtlCopyMemory(pwcNames, ColId.GetPropertyName(),
|
|
cch * sizeof (WCHAR));
|
|
pColInfo->columnid.uName.pwszName = pwcNames;
|
|
pwcNames += cch;
|
|
}
|
|
else
|
|
{
|
|
Win4Assert(ColId.IsPropertyPropid());
|
|
pColInfo->columnid.eKind = DBKIND_GUID_PROPID;
|
|
pColInfo->columnid.uName.ulPropid = ColId.GetPropertyPropid();
|
|
}
|
|
|
|
WCHAR const * pwszColName = _pidmap.GetFriendlyName(iCol);
|
|
if (0 == pwszColName)
|
|
pwszColName = _FindColumnInfo(ColId).pwszName;
|
|
|
|
if (pwszColName)
|
|
{
|
|
ULONG cch = wcslen(pwszColName) + 1;
|
|
RtlCopyMemory(pwcNames, pwszColName, cch * sizeof (WCHAR));
|
|
pColInfo->pwszName = pwcNames;
|
|
pwcNames += cch;
|
|
}
|
|
}
|
|
|
|
Win4Assert( (unsigned)(pColInfo - ColumnInfo.GetPointer()) == cColumns );
|
|
|
|
*prgInfo = ColumnInfo.Acquire();
|
|
if (cchNames > 0)
|
|
*ppStringsBuffer = StringBuf.Acquire();
|
|
|
|
*pcColumns = cColumns;
|
|
}
|
|
CATCH( CException, e )
|
|
{
|
|
scResult = e.GetErrorCode();
|
|
_ErrorObject.PostHResult(scResult, IID_IColumnsInfo);
|
|
if (scResult != E_OUTOFMEMORY)
|
|
scResult = E_FAIL;
|
|
}
|
|
END_CATCH;
|
|
|
|
return scResult;
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CColumnsInfo::SetColumnBindings, public
|
|
//
|
|
// Synopsis: Set current column bindings on the cursor. Save in
|
|
// member variables. Workid is always added to the
|
|
// bindings for movable rowsets for use with bookmarks
|
|
// and hRows. Space for a USHORT reserved for row buffer
|
|
// refcounting is always allocated.
|
|
//
|
|
// Arguments: [rpQuery] - a reference to the PQuery for the query
|
|
// [hCursor] - a reference to the hCursor to have column
|
|
// bindings set on.
|
|
// [obRowRefcount] - on return, offset into the row buffer
|
|
// where a USHORT reference count can be stored.
|
|
// [obRowId] - on return, offset into the row buffer where
|
|
// the row identifier is stored. Not valid for
|
|
// sequential rowsets.
|
|
//
|
|
// Returns: Nothing. Throws on errors.
|
|
//
|
|
// Notes: Initializes the private members _cbRowWidth and _pColumns.
|
|
//
|
|
// History: 04 Feb 1995 AlanW Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void CColumnsInfo::SetColumnBindings(
|
|
PQuery & rpQuery,
|
|
ULONG hCursor,
|
|
ULONG &obRowRefcount,
|
|
ULONG &obRowId,
|
|
ULONG &obChaptRefcount,
|
|
ULONG &obChaptId
|
|
) {
|
|
CTableRowAlloc RowMap( 0 );
|
|
USHORT maxAlignment = sizeof (USHORT);
|
|
|
|
obRowRefcount = RowMap.AllocOffset( sizeof (USHORT),
|
|
sizeof (USHORT),
|
|
TRUE );
|
|
|
|
if (_fChaptered)
|
|
obChaptRefcount = RowMap.AllocOffset( sizeof (USHORT),
|
|
sizeof (USHORT),
|
|
TRUE );
|
|
else
|
|
obChaptRefcount = 0xFFFFFFFF;
|
|
|
|
obRowId = 0xFFFFFFFF;
|
|
obChaptId = 0xFFFFFFFF;
|
|
BOOL fAddedWorkId = FALSE;
|
|
BOOL fMayDefer = FALSE;
|
|
|
|
// +1 In case WorkID or Path is added for rowid
|
|
|
|
XPtr<CTableColumnSet> XColumns( new CTableColumnSet( GetColumnCount() + 1 ));
|
|
|
|
unsigned cBoundColumns = 0;
|
|
|
|
tbDebugOut(( DEB_ITRACE, "original column count: %d\n", GetColumnCount() ));
|
|
for (unsigned iCol = 1; iCol <= GetColumnCount(); iCol++)
|
|
{
|
|
const CFullPropSpec & ColId = *_pidmap.Get( iCol );
|
|
const DBCOLUMNINFO & rColumnInfo = _FindColumnInfo( ColId );
|
|
|
|
tbDebugOut(( DEB_ITRACE, "colinfo::set, top of loop, cBoundColumns: %d\n",
|
|
cBoundColumns ));
|
|
tbDebugOut(( DEB_ITRACE, "adding '%ws'\n", rColumnInfo.pwszName ));
|
|
|
|
//
|
|
// If this is bookmark column, it will be mapped to the row ID
|
|
// column. It's only valid for locatable rowsets.
|
|
//
|
|
if ( (rColumnInfo.dwFlags & DBCOLUMNFLAGS_ISBOOKMARK) &&
|
|
ColId.IsPropertyPropid() &&
|
|
ColId.GetPropertyPropid() == PROPID_DBBMK_BOOKMARK)
|
|
{
|
|
tbDebugOut(( DEB_ITRACE, "skipping bookmark column\n" ));
|
|
|
|
Win4Assert(! _fSequential );
|
|
if (_fSequential)
|
|
THROW(CException(E_FAIL));
|
|
continue;
|
|
}
|
|
|
|
// the self columns is resolved in the accessor -- no binding needed
|
|
|
|
if ( ( ColId.IsPropertyPropid() ) &&
|
|
( ColId.GetPropertyPropid() == PROPID_DBSELF_SELF ) &&
|
|
( ColId.GetPropSet() == DBCOL_SELFCOLUMNS ) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Create the new column. Note that its PropID is the
|
|
// 1-based column ID.
|
|
//
|
|
XPtr<CTableColumn> TableCol(new CTableColumn( iCol ));
|
|
|
|
#ifndef ALWAYS_USE_VARIANT_BINDING
|
|
VARTYPE vt = rColumnInfo.wType;
|
|
|
|
switch (vt)
|
|
{
|
|
case DBTYPE_VARIANT:
|
|
{
|
|
#endif // ndef ALWAYS_USE_VARIANT_BINDING
|
|
|
|
fMayDefer = TRUE;
|
|
|
|
TableCol->SetValueField( DBTYPE_VARIANT,
|
|
RowMap.AllocOffset( sizeof (PROPVARIANT),
|
|
sizeof (LONGLONG),
|
|
TRUE ),
|
|
sizeof (PROPVARIANT));
|
|
|
|
// The status column is interesting for all columns
|
|
|
|
TableCol->SetStatusField( RowMap.AllocOffset( sizeof (BYTE),
|
|
sizeof (BYTE),
|
|
TRUE ),
|
|
sizeof (BYTE));
|
|
|
|
// Length is interesting, especially when the value is deferred
|
|
|
|
TableCol->SetLengthField( RowMap.AllocOffset( sizeof (ULONG),
|
|
sizeof (ULONG),
|
|
TRUE ),
|
|
sizeof (ULONG));
|
|
|
|
USHORT cbData, cbAlignment, rgfFlags;
|
|
CTableVariant::VartypeInfo(DBTYPE_VARIANT, cbData, cbAlignment, rgfFlags);
|
|
|
|
if ( cbAlignment > maxAlignment)
|
|
maxAlignment = cbAlignment;
|
|
|
|
#ifndef ALWAYS_USE_VARIANT_BINDING
|
|
break;
|
|
}
|
|
|
|
case DBTYPE_DATE:
|
|
case DBTYPE_WSTR:
|
|
case DBTYPE_STR:
|
|
//
|
|
// Adjust DBTYPEs from the column info into ones that are
|
|
// better for binding.
|
|
//
|
|
if (vt == DBTYPE_DATE)
|
|
vt = VT_FILETIME;
|
|
else if (vt == DBTYPE_WSTR)
|
|
vt = VT_LPWSTR;
|
|
else if (vt == DBTYPE_STR)
|
|
vt = VT_LPSTR;
|
|
|
|
// NOTE: fall through
|
|
|
|
default:
|
|
|
|
USHORT cbData, cbAlignment, rgfFlags;
|
|
CTableVariant::VartypeInfo(vt, cbData, cbAlignment, rgfFlags);
|
|
|
|
if (rgfFlags & CTableVariant::MultiSize)
|
|
cbData = (USHORT) rColumnInfo.ulColumnSize;
|
|
|
|
Win4Assert(cbData != 0 || vt == VT_EMPTY);
|
|
|
|
if (cbData == 0 && vt != VT_EMPTY)
|
|
{
|
|
tbDebugOut(( DEB_WARN,
|
|
"CColumnInfo::SetColumnBindings - Unknown variant type %4x\n",
|
|
vt));
|
|
}
|
|
|
|
if (cbAlignment)
|
|
{
|
|
if (cbAlignment > maxAlignment)
|
|
{
|
|
maxAlignment = cbAlignment;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cbAlignment = 1;
|
|
}
|
|
|
|
if (cbData != 0)
|
|
{
|
|
TableCol->SetValueField( vt,
|
|
RowMap.AllocOffset( cbData,
|
|
cbAlignment,
|
|
TRUE ),
|
|
cbData);
|
|
|
|
Win4Assert( 0 == ( (TableCol->GetValueOffset()) % cbAlignment ) );
|
|
|
|
//
|
|
// The status column is interesting for almost all columns,
|
|
// even inline columns, since a summary catalog might have
|
|
// VT_EMPTY data for these columns (eg storage props).
|
|
//
|
|
TableCol->SetStatusField( RowMap.AllocOffset( sizeof (BYTE),
|
|
sizeof (BYTE),
|
|
TRUE ),
|
|
sizeof (BYTE));
|
|
}
|
|
}
|
|
#endif // ndef ALWAYS_USE_VARIANT_BINDING
|
|
|
|
//
|
|
// If this is the row ID column, save its offset in the row.
|
|
//
|
|
if (rColumnInfo.dwFlags & DBCOLUMNFLAGS_ISROWID)
|
|
{
|
|
#ifdef ALWAYS_USE_VARIANT_BINDING
|
|
Win4Assert(TableCol->GetStoredType() == VT_VARIANT &&
|
|
TableCol->IsValueStored() &&
|
|
TableCol->GetValueSize() == sizeof (PROPVARIANT));
|
|
PROPVARIANT prop;
|
|
obRowId = TableCol->GetValueOffset() +
|
|
(DWORD)((BYTE *) &prop.lVal - (BYTE *)&prop);
|
|
#else // ndef ALWAYS_USE_VARIANT_BINDING
|
|
Win4Assert(TableCol->GetStoredType() == VT_I4 &&
|
|
TableCol->IsValueStored() &&
|
|
TableCol->GetValueSize() == sizeof (ULONG));
|
|
obRowId = TableCol->GetValueOffset();
|
|
#endif // ndef ALWAYS_USE_VARIANT_BINDING
|
|
_iColRowId = iCol;
|
|
fAddedWorkId = TRUE;
|
|
}
|
|
|
|
//
|
|
// If this is the chapter column, save its offset in the row.
|
|
//
|
|
if (rColumnInfo.dwFlags & DBCOLUMNFLAGS_ISCHAPTER)
|
|
{
|
|
Win4Assert( _fChaptered );
|
|
#ifdef ALWAYS_USE_VARIANT_BINDING
|
|
Win4Assert(TableCol->GetStoredType() == VT_VARIANT &&
|
|
TableCol->IsValueStored() &&
|
|
TableCol->GetValueSize() == sizeof (PROPVARIANT));
|
|
PROPVARIANT prop;
|
|
obChaptId = TableCol->GetValueOffset() +
|
|
(DWORD)((BYTE *) &prop.lVal - (BYTE *)&prop);
|
|
#else // ndef ALWAYS_USE_VARIANT_BINDING
|
|
Win4Assert(TableCol->GetStoredType() == VT_I4 &&
|
|
TableCol->IsValueStored() &&
|
|
TableCol->GetValueSize() == sizeof (ULONG));
|
|
obChaptId = TableCol->GetValueOffset();
|
|
#endif // ndef ALWAYS_USE_VARIANT_BINDING
|
|
}
|
|
|
|
XColumns->Add(TableCol.GetPointer(), cBoundColumns++);
|
|
TableCol.Acquire();
|
|
}
|
|
|
|
tbDebugOut(( DEB_ITRACE, "colinfo::set, after loop, cBoundColumns: %d\n",
|
|
cBoundColumns ));
|
|
|
|
// Need to add workid for non-sequential queries so that bookmarks
|
|
// work, and either workid or path so that deferred values work.
|
|
|
|
if ( ( ( !_fSequential ) ||
|
|
( fMayDefer && rpQuery.CanDoWorkIdToPath() ) ) &&
|
|
( !fAddedWorkId ) )
|
|
{
|
|
tbDebugOut(( DEB_ITRACE, "colinfo::set, adding WID column\n" ));
|
|
|
|
//
|
|
// Need to add the row ID column to the bindings, so that bookmarks
|
|
// work, and deferred values can be loaded.
|
|
//
|
|
const DBCOLUMNINFO & rColumnInfo = _GetRowIdColumnInfo( );
|
|
|
|
unsigned iCol = _pidmap.NameToPid( rColumnInfo.columnid );
|
|
XPtr<CTableColumn> TableCol(new CTableColumn( iCol ));
|
|
_iColRowId = iCol;
|
|
|
|
Win4Assert (VT_I4 == rColumnInfo.wType);
|
|
|
|
if (sizeof (ULONG) > maxAlignment)
|
|
maxAlignment = sizeof (ULONG);
|
|
|
|
TableCol->SetValueField( VT_I4,
|
|
RowMap.AllocOffset( sizeof (ULONG),
|
|
sizeof (ULONG),
|
|
TRUE ),
|
|
sizeof (ULONG));
|
|
obRowId = TableCol->GetValueOffset();
|
|
|
|
TableCol->SetStatusField( RowMap.AllocOffset( sizeof (BYTE),
|
|
sizeof (BYTE),
|
|
TRUE ),
|
|
sizeof (BYTE));
|
|
|
|
XColumns->Add(TableCol.GetPointer(), cBoundColumns++);
|
|
TableCol.Acquire();
|
|
}
|
|
|
|
ULONG rem = RowMap.GetRowWidth() % maxAlignment;
|
|
|
|
if ( 0 == rem )
|
|
_cbRowWidth = RowMap.GetRowWidth();
|
|
else
|
|
_cbRowWidth = RowMap.GetRowWidth() + maxAlignment - rem;
|
|
|
|
rpQuery.SetBindings( hCursor,
|
|
_cbRowWidth,
|
|
XColumns.GetReference(),
|
|
_pidmap );
|
|
|
|
tbDebugOut(( DEB_ITRACE, "colinfo::set, old # cols %d, new # cols %d\n",
|
|
_cColumns, cBoundColumns ));
|
|
|
|
_cBoundColumns = cBoundColumns;
|
|
_pColumns = XColumns.Acquire();
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CColumnsInfo::Get1ColumnInfo, public
|
|
//
|
|
// Synopsis: Return information about a single column in the rowset.
|
|
//
|
|
// Arguments: [iColumn] - the column number whose column info is to be
|
|
// returned.
|
|
//
|
|
// Returns: DBCOLUMNINFO & - a pointer to column info for the column
|
|
//
|
|
// Notes:
|
|
//
|
|
// History: 29 Mar 1995 AlanW Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
const DBCOLUMNINFO & CColumnsInfo::Get1ColumnInfo(
|
|
ULONG iColumn
|
|
) /*const*/
|
|
{
|
|
const CFullPropSpec & ColId = *_pidmap.Get(iColumn);
|
|
|
|
return _FindColumnInfo( ColId );
|
|
}
|
|
|
|
|
|
#ifdef INCLUDE_COLUMNS_ROWSET_IMPLEMENTATION
|
|
STDMETHODIMP CRowset::GetColumnsRowset(
|
|
ULONG cSelections,
|
|
DBID rgColumnSelection[],
|
|
IRowset ** ppColCursor
|
|
) /*const*/ {
|
|
_ErrorObject.ClearErrorInfo();
|
|
return _ErrorObject.PostHResult(E_NOTIMPL, IID_IColumnsRowset);
|
|
}
|
|
|
|
STDMETHODIMP CRowset::GetAvailableColumns(
|
|
ULONG * pcSelections,
|
|
DBID ** rgColumnSelection
|
|
) /*const*/ {
|
|
_ErrorObject.ClearErrorInfo();
|
|
return _ErrorObject.PostHResult(E_NOTIMPL, IID_IColumnsRowset);
|
|
}
|
|
#endif // INCLUDE_COLUMNS_ROWSET_IMPLEMENTATION
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////
|
|
//
|
|
// Data declarations for _FindColumnInfo
|
|
//
|
|
// Notes: These arrays of structures are prototype column info.
|
|
// structures returned by _FindColumnInfo.
|
|
//
|
|
////////////////////////////////////////////////////////////
|
|
|
|
static const DBCOLUMNINFO aStoragePropDescs[] = {
|
|
{ L"FileDirectoryName", 0, 0,
|
|
DBCOLUMNFLAGS_ISNULLABLE, MAX_PATH, // storage props are never deferred
|
|
DBTYPE_WSTR, 0xff, 0xff,
|
|
{ PSGUID_STORAGE, DBKIND_GUID_PROPID, (LPWSTR) UIntToPtr( PID_STG_DIRECTORY ) }
|
|
},
|
|
|
|
{ L"ClassID", 0, 0,
|
|
DBCOLUMNFLAGS_ISNULLABLE|DBCOLUMNFLAGS_ISFIXEDLENGTH, sizeof (GUID),
|
|
DBTYPE_GUID, 0xff, 0xff,
|
|
{ PSGUID_STORAGE, DBKIND_GUID_PROPID, (LPWSTR) UIntToPtr( PID_STG_CLASSID ) }
|
|
},
|
|
|
|
{ L"FileStorageType", 0, 0,
|
|
DBCOLUMNFLAGS_ISNULLABLE|DBCOLUMNFLAGS_ISFIXEDLENGTH, sizeof (ULONG),
|
|
DBTYPE_UI4, 0xff, 0xff,
|
|
{ PSGUID_STORAGE, DBKIND_GUID_PROPID, (LPWSTR) UIntToPtr( PID_STG_STORAGETYPE ) }
|
|
},
|
|
|
|
{ L"FileIndex", 0, 0,
|
|
DBCOLUMNFLAGS_ISNULLABLE|DBCOLUMNFLAGS_ISFIXEDLENGTH, sizeof (LONGLONG),
|
|
DBTYPE_I8, 0xff, 0xff,
|
|
{ PSGUID_STORAGE, DBKIND_GUID_PROPID, (LPWSTR) UIntToPtr( PID_STG_FILEINDEX ) }
|
|
},
|
|
|
|
{ L"FileUSN", 0, 0,
|
|
DBCOLUMNFLAGS_ISNULLABLE|DBCOLUMNFLAGS_ISFIXEDLENGTH, sizeof (LONGLONG),
|
|
DBTYPE_I8, 0xff, 0xff,
|
|
{ PSGUID_STORAGE, DBKIND_GUID_PROPID, (LPWSTR) UIntToPtr( PID_STG_LASTCHANGEUSN ) }
|
|
},
|
|
|
|
{ L"FileName", 0, 0,
|
|
DBCOLUMNFLAGS_ISNULLABLE, MAX_PATH, // storage props are never deferred
|
|
DBTYPE_WSTR, 0xff, 0xff,
|
|
{ PSGUID_STORAGE, DBKIND_GUID_PROPID, (LPWSTR) UIntToPtr( PID_STG_NAME ) }
|
|
},
|
|
|
|
{ L"FilePathName", 0, 0,
|
|
DBCOLUMNFLAGS_ISNULLABLE, MAX_PATH, // storage props are never deferred
|
|
DBTYPE_WSTR, 0xff, 0xff,
|
|
{ PSGUID_STORAGE, DBKIND_GUID_PROPID, (LPWSTR) UIntToPtr( PID_STG_PATH ) }
|
|
},
|
|
|
|
{ L"FileSize", 0, 0,
|
|
DBCOLUMNFLAGS_ISNULLABLE|DBCOLUMNFLAGS_ISFIXEDLENGTH, sizeof (LONGLONG),
|
|
DBTYPE_I8, 0xff, 0xff,
|
|
{ PSGUID_STORAGE, DBKIND_GUID_PROPID, (LPWSTR) UIntToPtr( PID_STG_SIZE ) }
|
|
},
|
|
|
|
{ L"FileAttributes", 0, 0,
|
|
DBCOLUMNFLAGS_ISNULLABLE|DBCOLUMNFLAGS_ISFIXEDLENGTH, sizeof (ULONG),
|
|
DBTYPE_UI4, 0xff, 0xff,
|
|
{ PSGUID_STORAGE, DBKIND_GUID_PROPID, (LPWSTR) UIntToPtr( PID_STG_ATTRIBUTES ) }
|
|
},
|
|
|
|
// NOTE: file times are typed as DBTYPE_DATE, but are bound to the
|
|
// table as VT_FILETIME.
|
|
{ L"FileWriteTime", 0, 0,
|
|
DBCOLUMNFLAGS_ISNULLABLE|DBCOLUMNFLAGS_ISFIXEDLENGTH, sizeof (LONGLONG),
|
|
DBTYPE_DATE, 0xff, 0xff,
|
|
{ PSGUID_STORAGE, DBKIND_GUID_PROPID, (LPWSTR) UIntToPtr( PID_STG_WRITETIME ) }
|
|
},
|
|
|
|
{ L"FileCreateTime", 0, 0,
|
|
DBCOLUMNFLAGS_ISNULLABLE|DBCOLUMNFLAGS_ISFIXEDLENGTH, sizeof (LONGLONG),
|
|
DBTYPE_DATE, 0xff, 0xff,
|
|
{ PSGUID_STORAGE, DBKIND_GUID_PROPID, (LPWSTR) UIntToPtr( PID_STG_CREATETIME ) }
|
|
},
|
|
|
|
{ L"FileAccessTime", 0, 0,
|
|
DBCOLUMNFLAGS_ISNULLABLE|DBCOLUMNFLAGS_ISFIXEDLENGTH, sizeof (LONGLONG),
|
|
DBTYPE_DATE, 0xff, 0xff,
|
|
{ PSGUID_STORAGE, DBKIND_GUID_PROPID, (LPWSTR) UIntToPtr( PID_STG_ACCESSTIME ) }
|
|
},
|
|
|
|
{ L"FileShortName", 0, 0,
|
|
DBCOLUMNFLAGS_ISNULLABLE, 13, // storage props are never deferred
|
|
DBTYPE_WSTR, 0xff, 0xff,
|
|
{ PSGUID_STORAGE, DBKIND_GUID_PROPID, (LPWSTR) UIntToPtr( PID_STG_SHORTNAME ) }
|
|
},
|
|
};
|
|
|
|
const ULONG cStoragePropDescs =
|
|
sizeof aStoragePropDescs /
|
|
sizeof aStoragePropDescs[0];
|
|
|
|
|
|
//
|
|
// Standard query properties.
|
|
// Does not include pidAll or pidContent, those are used only in restrictions.
|
|
//
|
|
|
|
static const DBCOLUMNINFO aQueryPropDescs[] = {
|
|
{ L"QueryRankvector", 0, 0,
|
|
DBCOLUMNFLAGS_ISNULLABLE|DBCOLUMNFLAGS_ISFIXEDLENGTH, sizeof(PROPVARIANT),
|
|
DBTYPE_VARIANT, 0xff, 0xff,
|
|
{ DBQUERYGUID, DBKIND_GUID_PROPID, (LPWSTR) UIntToPtr( DISPID_QUERY_RANKVECTOR ) }
|
|
},
|
|
|
|
{ L"QueryRank", 0, 0,
|
|
DBCOLUMNFLAGS_ISNULLABLE|DBCOLUMNFLAGS_ISFIXEDLENGTH, sizeof (LONG),
|
|
DBTYPE_I4, 0xff, 0xff,
|
|
{ DBQUERYGUID, DBKIND_GUID_PROPID, (LPWSTR) UIntToPtr( DISPID_QUERY_RANK ) }
|
|
},
|
|
|
|
{ L"QueryHitCount", 0, 0,
|
|
DBCOLUMNFLAGS_ISNULLABLE|DBCOLUMNFLAGS_ISFIXEDLENGTH, sizeof (LONG),
|
|
DBTYPE_I4, 0xff, 0xff,
|
|
{ DBQUERYGUID, DBKIND_GUID_PROPID, (LPWSTR) UIntToPtr( DISPID_QUERY_HITCOUNT ) }
|
|
},
|
|
|
|
{ L"WorkID", 0, 0,
|
|
DBCOLUMNFLAGS_ISFIXEDLENGTH|DBCOLUMNFLAGS_ISROWID, sizeof (LONG),
|
|
DBTYPE_I4, 0xff, 0xff,
|
|
{ DBQUERYGUID, DBKIND_GUID_PROPID, (LPWSTR) UIntToPtr( DISPID_QUERY_WORKID ) }
|
|
},
|
|
|
|
{ L"QueryUnfiltered", 0, 0,
|
|
DBCOLUMNFLAGS_ISNULLABLE|DBCOLUMNFLAGS_ISFIXEDLENGTH, sizeof(BOOL),
|
|
DBTYPE_BOOL, 0xff, 0xff,
|
|
{ DBQUERYGUID, DBKIND_GUID_PROPID, (LPWSTR) UIntToPtr( DISPID_QUERY_UNFILTERED ) }
|
|
},
|
|
|
|
{ L"QueryVirtualPath", 0, 0,
|
|
DBCOLUMNFLAGS_ISNULLABLE, MAX_PATH,
|
|
DBTYPE_WSTR, 0xff, 0xff,
|
|
{ DBQUERYGUID, DBKIND_GUID_PROPID, (LPWSTR) UIntToPtr( DISPID_QUERY_VIRTUALPATH ) }
|
|
},
|
|
|
|
#if defined( DISPID_QUERY_NLIRRANK )
|
|
{ L"NLIRRank", 0, 0,
|
|
DBCOLUMNFLAGS_ISNULLABLE|DBCOLUMNFLAGS_ISFIXEDLENGTH, sizeof (LONG),
|
|
DBTYPE_I4, 0xff, 0xff,
|
|
{ DBQUERYGUID, DBKIND_GUID_PROPID, (LPWSTR) UIntToPtr( DISPID_QUERY_NLIRRANK ) }
|
|
},
|
|
#endif // defined( DISPID_QUERY_NLIRRANK )
|
|
};
|
|
|
|
const ULONG cQueryPropDescs =
|
|
sizeof aQueryPropDescs /
|
|
sizeof aQueryPropDescs[0];
|
|
|
|
|
|
static DBCOLUMNINFO const aBmkPropDescs[] = {
|
|
{ L"Bookmark", 0, 0,
|
|
DBCOLUMNFLAGS_ISBOOKMARK|DBCOLUMNFLAGS_ISFIXEDLENGTH,
|
|
sizeof (CI_TBL_BMK),
|
|
DBTYPE_BYTES, 0xff, 0xff,
|
|
{ DBBMKGUID, DBKIND_GUID_PROPID, (LPWSTR) UIntToPtr( PROPID_DBBMK_BOOKMARK ) }
|
|
},
|
|
{ L"Chapter", 0, 0,
|
|
DBCOLUMNFLAGS_ISCHAPTER|DBCOLUMNFLAGS_ISBOOKMARK|DBCOLUMNFLAGS_ISFIXEDLENGTH,
|
|
sizeof (CI_TBL_CHAPT),
|
|
DBTYPE_BYTES, 0xff, 0xff,
|
|
{ DBBMKGUID, DBKIND_GUID_PROPID, (LPWSTR) UIntToPtr( PROPID_DBBMK_CHAPTER ) }
|
|
},
|
|
};
|
|
|
|
const ULONG cBmkPropDescs =
|
|
sizeof aBmkPropDescs /
|
|
sizeof aBmkPropDescs[0];
|
|
|
|
|
|
// CLEANCODE: ole-db spec bug #1271 - const GUID init. less than useful
|
|
|
|
#ifndef DBSELFGUID
|
|
#define DBSELFGUID {0xc8b52231,0x5cf3,0x11ce,{0xad,0xe5,0x00,0xaa,0x00,0x44,0x77,0x3d}}
|
|
#endif // ndef DBSELFGUID
|
|
|
|
static DBCOLUMNINFO const aSelfPropDescs[] = {
|
|
{ L"Self", 0, 0,
|
|
DBCOLUMNFLAGS_ISFIXEDLENGTH,
|
|
sizeof( int ),
|
|
DBTYPE_I4, 0xff, 0xff,
|
|
{ DBSELFGUID, DBKIND_GUID_PROPID, (LPWSTR) UIntToPtr( PROPID_DBSELF_SELF ) }
|
|
},
|
|
};
|
|
|
|
const ULONG cSelfPropDescs =
|
|
sizeof aSelfPropDescs /
|
|
sizeof aSelfPropDescs[0];
|
|
|
|
#ifdef INCLUDE_COLUMNS_ROWSET_IMPLEMENTATION
|
|
|
|
static const DBCOLUMNINFO aColInfoPropDescs[] = {
|
|
|
|
{ L"ColumnId", 0, 0,
|
|
DBCOLUMNFLAGS_ISFIXEDLENGTH, 3 * sizeof(PROPVARIANT),
|
|
DBTYPE_VARIANT|DBTYPE_VECTOR, 0xff, 0xff,
|
|
{ DBCIDGUID, DBKIND_GUID_PROPID, (LPWSTR)1 }
|
|
},
|
|
|
|
{ L"ColumnName", 0, 0,
|
|
0, 20,
|
|
DBTYPE_WSTR, 0xff, 0xff,
|
|
{ DBCIDGUID, DBKIND_GUID_PROPID, (LPWSTR)2 }
|
|
},
|
|
|
|
{ L"ColumnNumber", 0, 0,
|
|
DBCOLUMNFLAGS_ISFIXEDLENGTH, sizeof (LONG),
|
|
DBTYPE_I4, 0xff, 0xff,
|
|
{ DBCIDGUID, DBKIND_GUID_PROPID, (LPWSTR)3 }
|
|
},
|
|
|
|
{ L"ColumnType", 0, 0,
|
|
DBCOLUMNFLAGS_ISFIXEDLENGTH, sizeof(USHORT),
|
|
DBTYPE_I2, 0xff, 0xff,
|
|
{ DBCIDGUID, DBKIND_GUID_PROPID, (LPWSTR)4 }
|
|
},
|
|
|
|
{ L"ColumnLength", 0, 0,
|
|
DBCOLUMNFLAGS_ISFIXEDLENGTH, sizeof (LONG),
|
|
DBTYPE_I4, 0xff, 0xff,
|
|
{ DBCIDGUID, DBKIND_GUID_PROPID, (LPWSTR)5 }
|
|
},
|
|
|
|
{ L"ColumnPrecision", 0, 0,
|
|
DBCOLUMNFLAGS_ISFIXEDLENGTH, sizeof (LONG),
|
|
DBTYPE_I4, 0xff, 0xff,
|
|
{ DBCIDGUID, DBKIND_GUID_PROPID, (LPWSTR)6 }
|
|
},
|
|
|
|
{ L"ColumnScale", 0, 0,
|
|
DBCOLUMNFLAGS_ISFIXEDLENGTH, sizeof (LONG),
|
|
DBTYPE_I4, 0xff, 0xff,
|
|
{ DBCIDGUID, DBKIND_GUID_PROPID, (LPWSTR)7 }
|
|
},
|
|
|
|
{ L"ColumnFlags", 0, 0,
|
|
DBCOLUMNFLAGS_ISFIXEDLENGTH, sizeof (LONG),
|
|
DBTYPE_I4, 0xff, 0xff,
|
|
{ DBCIDGUID, DBKIND_GUID_PROPID, (LPWSTR)8 }
|
|
},
|
|
};
|
|
|
|
const ULONG cColInfoPropDescs =
|
|
sizeof aColInfoPropDescs /
|
|
sizeof aColInfoPropDescs[0];
|
|
#endif // INCLUDE_COLUMNS_ROWSET_IMPLEMENTATION
|
|
|
|
//
|
|
// Array of column descriptions per known propset
|
|
// Each referenced array must have the same Guid for each element in
|
|
// the array.
|
|
//
|
|
|
|
const CColumnsInfo::SPropSetInfo CColumnsInfo::aPropSets [ ] = {
|
|
#define IPROPSET_STORAGE 0 // Storage property set index
|
|
{ cStoragePropDescs, aStoragePropDescs },
|
|
{ cQueryPropDescs, aQueryPropDescs },
|
|
{ cBmkPropDescs, aBmkPropDescs },
|
|
{ cSelfPropDescs, aSelfPropDescs },
|
|
|
|
#ifdef INCLUDE_COLUMNS_ROWSET_IMPLEMENTATION
|
|
{ cColInfoPropDescs, aColInfoPropDescs },
|
|
#endif // INCLUDE_COLUMNS_ROWSET_IMPLEMENTATION
|
|
};
|
|
|
|
const ULONG CColumnsInfo::cPropSets =
|
|
sizeof CColumnsInfo::aPropSets /
|
|
sizeof CColumnsInfo::aPropSets[0];
|
|
|
|
DBCOLUMNINFO const DefaultColumnInfo = {
|
|
0, 0, 0,
|
|
DBCOLUMNFLAGS_ISNULLABLE | DBCOLUMNFLAGS_MAYDEFER | DBCOLUMNFLAGS_ISFIXEDLENGTH, sizeof (PROPVARIANT),
|
|
DBTYPE_VARIANT, 0xff, 0xff,
|
|
{ {0,0,0,{0,0,0,0,0,0,0,0}}, DBKIND_GUID_PROPID, (LPWSTR)0 }
|
|
};
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CColumnsInfo::_FindColumnInfo, static
|
|
//
|
|
// Synopsis: Return information about a particular column ID.
|
|
//
|
|
// Arguments: [ColId] - Column ID to be looked up.
|
|
//
|
|
// Returns: DBCOLUMNINFO - the column information for the row looked up.
|
|
//
|
|
// Notes: Some columns are standard columns available for all file
|
|
// stores. For these columns, full information about data
|
|
// type and sizes can be returned. For any other columns,
|
|
// a generic column information structure is returned.
|
|
//
|
|
// History: 10 Feb 1995 AlanW Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
DBCOLUMNINFO const & CColumnsInfo::_FindColumnInfo(
|
|
const CFullPropSpec & ColId
|
|
) {
|
|
DBCOLUMNINFO const * pColInfo = &DefaultColumnInfo;
|
|
|
|
//
|
|
// All custom information we return has propids, not prop names.
|
|
// Valid property IDs start at 2
|
|
//
|
|
|
|
if (ColId.IsPropertyPropid())
|
|
{
|
|
for (unsigned iPropSet = 0; iPropSet < cPropSets; iPropSet++)
|
|
{
|
|
if (ColId.GetPropSet() ==
|
|
aPropSets[iPropSet].aPropDescs[0].columnid.uGuid.guid)
|
|
{
|
|
//
|
|
// Found the guid for the propset, now try to find the
|
|
// propid.
|
|
//
|
|
ULONG ulPropId = ColId.GetPropertyPropid();
|
|
|
|
Win4Assert( ulPropId != PID_CODEPAGE &&
|
|
ulPropId != PID_DICTIONARY);
|
|
|
|
for (unsigned iDesc = 0;
|
|
iDesc < aPropSets[iPropSet].cProps;
|
|
iDesc++)
|
|
{
|
|
if (ulPropId ==
|
|
aPropSets[iPropSet].aPropDescs[iDesc].columnid.uName.ulPropid)
|
|
{
|
|
pColInfo = &aPropSets[iPropSet].aPropDescs[iDesc];
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return *pColInfo;
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CColumnsInfo::_GetRowIdColumnInfo, static
|
|
//
|
|
// Synopsis: Return information about the row ID column
|
|
//
|
|
// Arguments: - None -
|
|
//
|
|
// Returns: DBCOLUMNINFO - the column information for the row looked up.
|
|
//
|
|
// Notes: It is assumed that there is only one row ID column in the
|
|
// standard column info. This may need to change for chaptered
|
|
// rowsets.
|
|
//
|
|
// History: 15 Mar 1995 AlanW Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
DBCOLUMNINFO const & CColumnsInfo::_GetRowIdColumnInfo(
|
|
) {
|
|
DBCOLUMNINFO const * pColInfo = 0;
|
|
|
|
for (unsigned iPropSet = 0;
|
|
iPropSet < cPropSets && pColInfo == 0;
|
|
iPropSet++)
|
|
{
|
|
for (unsigned iDesc = 0;
|
|
iDesc < aPropSets[iPropSet].cProps;
|
|
iDesc++)
|
|
{
|
|
if ( aPropSets[iPropSet].aPropDescs[iDesc].dwFlags &
|
|
DBCOLUMNFLAGS_ISROWID)
|
|
{
|
|
pColInfo = &aPropSets[iPropSet].aPropDescs[iDesc];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
Win4Assert(pColInfo != 0);
|
|
return *pColInfo;
|
|
}
|