|
|
//+-------------------------------------------------------------------------
//
// 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;}
|
