Leaked source code of windows server 2003
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.
 
 
 
 
 
 

540 lines
11 KiB

//------------------------------------------------------------------------------
//
// Microsoft Sidewalk
// Copyright (C) Microsoft Corporation, 1997.
//
// File: oledbhelp.h
//
// Contents: OLE DB helper methods
//
// Owner: BassamT
//
// History: 11/30/97 BassamT Created.
//
//------------------------------------------------------------------------------
#if (!defined(BUILD_FOR_NT40))
#pragma once
//
// typedefs
//
// Column Number (cn). This number starts at 1.
typedef ULONG CNUM;
// Row number (rn). These numbers start at 0.
typedef ULONG RNUM;
// Offset (in bytes) into a structure or buffer (ob)
typedef DWORD OFFSET;
// Bookmark data type (bmk)
typedef ULONG BOOKMARK;
//
// constants that can be tuned for performance
//
// The maximum number of bytes to store inline for variable size data types.
const UINT k_cbInlineMax = 100;
// the number of rows to fetch at once.
const ULONG k_RowFetchCount = 20;
// Column alignment within a row.
// TODO : Should this be sizeof(DWORD) instead ?
const DWORD k_ColumnAlign = 8;
//
// constants
//
// invalid row number
const CNUM CNUM_INVALID = 0xFFFFFFFF;
// invalid row number
const RNUM RNUM_INVALID = 0xFFFFFFFF;
//
// conversion helpers
//
const UINT k_cchUCHARAsDecimalString = sizeof("255") - 1;
const UINT k_cchUSHORTAsDecimalString = sizeof("32767") - 1;
const UINT k_cchUINTAsDecimalString = sizeof("4294967294") - 1;
const UINT k_cchUINTAsHexString = sizeof("FFFFFFFF") - 1;
const UINT k_cchINTAsDecimalString = sizeof("-2147483648") - 1;
const UINT k_cchBOOLAsDecimalString = sizeof("1") - 1;
const UINT k_cchDOUBLEAsDecimalString = sizeof("2.2250738585072014 E + 308") - 1;
//
// macros
//
#define static_wcslen(pwsz) ((sizeof(pwsz) / sizeof(WCHAR)) - 1)
#define inrange(z,zmin,zmax) ( (zmin) <= (z) && (z) <= (zmax) )
#define DBID_USE_GUID_OR_PGUID(e) \
((1<<(e)) & \
( 1<<DBKIND_GUID \
| 1<<DBKIND_GUID_NAME \
| 1<<DBKIND_GUID_PROPID \
| 1<<DBKIND_PGUID_NAME \
| 1<<DBKIND_PGUID_PROPID ))
#define DBID_USE_GUID(e) \
((1<<(e)) & \
( 1<<DBKIND_GUID \
| 1<<DBKIND_GUID_NAME \
| 1<<DBKIND_GUID_PROPID ))
#define DBID_USE_PGUID(e) \
((1<<(e)) & \
( 1<<DBKIND_PGUID_NAME \
| 1<<DBKIND_PGUID_PROPID ))
#define DBID_USE_NAME(e) \
((1<<(e)) & \
( 1<<DBKIND_NAME \
| 1<<DBKIND_GUID_NAME \
| 1<<DBKIND_PGUID_NAME ))
#define DBID_USE_PROPID(e) \
((1<<(e)) & \
( 1<<DBKIND_PROPID \
| 1<<DBKIND_GUID_PROPID \
| 1<<DBKIND_PGUID_PROPID ))
#define DBID_IS_BOOKMARK(dbid) \
( DBID_USE_GUID(dbid.eKind) && dbid.uGuid.guid == DBCOL_SPECIALCOL \
|| DBID_USE_PGUID(dbid.eKind) && *dbid.uGuid.pguid == DBCOL_SPECIALCOL )
#define SET_DBID_FROM_NAME(dbid, pwsz) \
dbid.eKind = DBKIND_NAME;\
dbid.uName.pwszName = pwsz;
#define IsBadPointer(v) (IsBadReadPtr((void*)hAccessor, sizeof(void*)))
//
// functions
//
inline DWORD RoundDown(DWORD dwSize, DWORD dwAmount)
{
return dwSize & ~(dwAmount - 1);
}
inline DWORD RoundUp(DWORD dwSize, DWORD dwAmount)
{
return (dwSize + (dwAmount - 1)) & ~(dwAmount - 1);
}
#define CLIENT_MALLOC(cb) (CoTaskMemAlloc(cb))
#define CLIENT_FREE(x) (CoTaskMemFree(x), x = NULL)
HRESULT CopyDBIDs(DBID * pdbidDest, const DBID *pdbidSrc);
BOOL CompareDBIDs(const DBID *pdbid1, const DBID *pdbid2);
HRESULT IsValidDBID(const DBID *pdbid);
void FreeDBID(DBID *pdbid);
INT CompareOLEDBTypes(DBTYPE wType, void * pvValue1, void * pvValue2);
inline BOOL IsColumnVarLength
//------------------------------------------------------------------------------
// return TRUE if the column is of a variable length type
(
DBTYPE wType
)
{
if (wType == DBTYPE_BSTR ||
wType == DBTYPE_STR ||
wType == DBTYPE_WSTR ||
wType == DBTYPE_BYTES)
{
return TRUE;
}
return FALSE;
}
inline DWORD AdjustVariableTypesLength
//------------------------------------------------------------------------------
// adjusts the length of variable length data types
(
DBTYPE wType,
DWORD cb
)
{
if (wType == DBTYPE_STR)
{
return cb + 1;
}
if (wType == DBTYPE_WSTR)
{
return cb + sizeof(WCHAR);
}
return cb;
}
inline USHORT GetColumnMaxPrecision
//------------------------------------------------------------------------------
// returns the maximium possible precision of a column, given its type.
// Do not pass a byref, array, or vector column type.
(
DBTYPE wType
// [in] the OLE DB data type
)
{
if ((wType & DBTYPE_BYREF) ||
(wType & DBTYPE_ARRAY) ||
(wType & DBTYPE_VECTOR))
{
Assert (FALSE);
return 0;
}
switch( wType )
{
case DBTYPE_I1:
case DBTYPE_UI1:
return 3;
case DBTYPE_I2:
case DBTYPE_UI2:
return 5;
case DBTYPE_I4:
case DBTYPE_UI4:
return 10;
case DBTYPE_R4:
return 7;
case DBTYPE_I8:
return 19;
case DBTYPE_UI8:
return 20;
case DBTYPE_R8:
return 16;
case DBTYPE_DATE:
return 8;
case DBTYPE_CY:
return 19;
case DBTYPE_DECIMAL:
return 28;
case DBTYPE_NUMERIC:
return 38;
case DBTYPE_EMPTY:
case DBTYPE_NULL:
case DBTYPE_ERROR:
case DBTYPE_BOOL:
case DBTYPE_BSTR:
case DBTYPE_IDISPATCH:
case DBTYPE_IUNKNOWN:
case DBTYPE_VARIANT:
case DBTYPE_GUID:
case DBTYPE_BYTES:
case DBTYPE_STR:
case DBTYPE_WSTR:
case DBTYPE_DBDATE:
case DBTYPE_DBTIME:
case DBTYPE_DBTIMESTAMP:
case DBTYPE_HCHAPTER:
return 0;
default:
Assert (FALSE && "Unsupported data type");
return 0;
}
}
inline ULONG GetColumnSize
//------------------------------------------------------------------------------
// returns the size of the column in bytes
(
DBTYPE wType,
// [in] the OLE DB data type
DWORD cchMaxLength
// [in] if this is a variable size field then this is the max length
// if there is one defined. Otherwise this is 0xFFFFFFFF
)
{
// Handle BYREF destination separately
if ((wType & DBTYPE_BYREF) ||
(wType & DBTYPE_ARRAY) ||
(wType & DBTYPE_VECTOR))
{
return sizeof(void*);
}
switch( wType )
{
case DBTYPE_EMPTY:
case DBTYPE_NULL:
return 0;
case DBTYPE_I2:
case DBTYPE_UI2:
return 2;
case DBTYPE_I4:
case DBTYPE_R4:
case DBTYPE_UI4:
return 4;
case DBTYPE_I8:
case DBTYPE_R8:
case DBTYPE_DATE:
case DBTYPE_UI8:
return 8;
case DBTYPE_ERROR:
return sizeof(SCODE);
case DBTYPE_BOOL:
return sizeof(VARIANT_BOOL);
case DBTYPE_CY:
return sizeof(CY);
case DBTYPE_BSTR:
return sizeof(BSTR);
case DBTYPE_IDISPATCH:
return sizeof(IDispatch*);
case DBTYPE_IUNKNOWN:
return sizeof(IUnknown*);
case DBTYPE_VARIANT:
return sizeof(VARIANT);
case DBTYPE_DECIMAL:
return sizeof(DECIMAL);
case DBTYPE_I1:
case DBTYPE_UI1:
return 1;
case DBTYPE_GUID:
return sizeof(GUID);
case DBTYPE_BYTES:
return cchMaxLength;
case DBTYPE_STR:
return cchMaxLength * sizeof(char);
case DBTYPE_WSTR:
return cchMaxLength * sizeof(WCHAR);
case DBTYPE_NUMERIC:
return sizeof(DB_NUMERIC);
case DBTYPE_DBDATE:
return sizeof(DBDATE);
case DBTYPE_DBTIME:
return sizeof(DBTIME);
case DBTYPE_DBTIMESTAMP:
return sizeof(DBTIMESTAMP);
case DBTYPE_HCHAPTER:
return sizeof(HCHAPTER);
default:
Assert (FALSE && "Unsupported data type");
return 0;
}
}
//
// IUnknown Macros
//
// put this macros in your class definition. Make sure that
// you inherit from IUnknown and that you use the
// INIT_IUNKNOWN macro in your class constructor
#define DEFINE_IUNKNOWN \
private:\
LONG _cRefs;\
public:\
STDMETHOD(InternalQueryInterface)(REFIID riid, void ** ppv);\
STDMETHOD(QueryInterface)(REFIID riid, void ** ppv)\
{\
return InternalQueryInterface(riid, ppv);\
}\
STDMETHOD_(ULONG,AddRef)() \
{\
return InterlockedIncrement(&_cRefs);\
}\
STDMETHOD_(ULONG,Release)()\
{\
if (InterlockedDecrement(&_cRefs) == 0)\
{\
delete this;\
return 0;\
}\
return _cRefs;\
}
#define INIT_IUNKNOWN _cRefs = 1;
#define DEFINE_IUNKNOWN_WITH_CALLBACK(x) \
private:\
LONG _cRefs;\
public:\
STDMETHOD(InternalQueryInterface)(REFIID riid, void ** ppv);\
STDMETHOD(QueryInterface)(REFIID riid, void ** ppv)\
{\
return InternalQueryInterface(riid, ppv);\
}\
STDMETHOD_(ULONG,AddRef)() \
{\
return InterlockedIncrement(&_cRefs);\
}\
STDMETHOD_(ULONG,Release)()\
{\
if (InterlockedDecrement(&_cRefs) == 0)\
{\
x();\
return 0;\
}\
return _cRefs;\
}
// put this macros in your class definition. Make sure that
// you inherit from IUnknown and that you use the
// INIT_AGGREGATE_IUNKNOWN macro in your class constructor.
// Also make sure that you use SET_OUTER_IUNKNOWN in wherever
// you get a pointer to the Outer IUnknown
interface INonDelegatingUnknown
{
virtual HRESULT STDMETHODCALLTYPE NonDelegatingQueryInterface
(
REFIID riid,
void __RPC_FAR *__RPC_FAR *ppvObject
) = 0;
virtual ULONG STDMETHODCALLTYPE NonDelegatingAddRef(void) = 0;
virtual ULONG STDMETHODCALLTYPE NonDelegatingRelease(void) = 0;
};
#define DEFINE_AGGREGATE_IUNKNOWN \
private:\
IUnknown * _punkOuter;\
LONG _cRefs;\
public:\
STDMETHOD(InternalQueryInterface)(REFIID riid, void ** ppv);\
STDMETHOD(NonDelegatingQueryInterface)(REFIID riid, void ** ppv)\
{\
if (ppv == NULL) return E_INVALIDARG;\
if (riid != IID_IUnknown)\
{\
return InternalQueryInterface(riid, ppv);\
}\
else\
{\
*ppv = static_cast<INonDelegatingUnknown*>(this);\
NonDelegatingAddRef();\
return NOERROR;\
}\
}\
STDMETHOD_(ULONG,NonDelegatingAddRef)() \
{\
return InterlockedIncrement(&_cRefs);\
}\
STDMETHOD_(ULONG,NonDelegatingRelease)()\
{\
if (InterlockedDecrement(&_cRefs) == 0)\
{\
delete this;\
return 0;\
}\
return _cRefs;\
}\
STDMETHOD(QueryInterface)(REFIID riid, void ** ppv)\
{\
return _punkOuter->QueryInterface(riid, ppv);\
}\
STDMETHOD_(ULONG,AddRef)() \
{\
return _punkOuter->AddRef();\
}\
STDMETHOD_(ULONG,Release)()\
{\
return _punkOuter->Release();\
}
#define INIT_AGGREGATE_IUNKNOWN \
_punkOuter = reinterpret_cast<IUnknown*>(static_cast<INonDelegatingUnknown*>(this)); \
_cRefs = 1;
#define SET_OUTER_IUNKNOWN(punk) if (punk != NULL) _punkOuter = punk;
#define DEFINE_AGGREGATE_IUNKNOWN_WITH_CALLBACKS(_AddRef, _Release) \
private:\
IUnknown * _punkOuter;\
LONG _cRefs;\
public:\
STDMETHOD(InternalQueryInterface)(REFIID riid, void ** ppv);\
STDMETHOD(NonDelegatingQueryInterface)(REFIID riid, void ** ppv)\
{\
if (ppv == NULL) return E_INVALIDARG;\
if (riid != IID_IUnknown)\
{\
return InternalQueryInterface(riid, ppv);\
}\
else\
{\
*ppv = static_cast<INonDelegatingUnknown*>(this);\
NonDelegatingAddRef();\
return NOERROR;\
}\
}\
STDMETHOD_(ULONG,NonDelegatingAddRef)() \
{\
_AddRef();\
return InterlockedIncrement(&_cRefs);\
}\
STDMETHOD_(ULONG,NonDelegatingRelease)()\
{\
_Release();\
if (InterlockedDecrement(&_cRefs) == 0)\
{\
delete this;\
return 0;\
}\
return _cRefs;\
}\
STDMETHOD(QueryInterface)(REFIID riid, void ** ppv)\
{\
return _punkOuter->QueryInterface(riid, ppv);\
}\
STDMETHOD_(ULONG,AddRef)() \
{\
return _punkOuter->AddRef();\
}\
STDMETHOD_(ULONG,Release)()\
{\
return _punkOuter->Release();\
}
#endif