//+---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1992 - 2000.
//
// File: datasrc.cxx
//
// Contents: Class factory description
//
// History: 3-30-97 MohamedN Created
//
//----------------------------------------------------------------------------
#include <pch.cxx>
#pragma hdrstop
#include <datasrc.hxx>
#include <session.hxx>
#include <cidbprop.hxx> // CDbProperties
#include <dbprpini.hxx> // CGetDbInitProps
// Datasource object interfaces that support ISupportErrorInfo
static const GUID* apDataSrcErrInt[] =
{
&IID_IDBCreateSession,
&IID_IDBInitialize,
&IID_IDBProperties,
&IID_IPersist,
&IID_IDBInfo,
};
static const ULONG cDataSrcErrInt = NUMELEM( apDataSrcErrInt );
//+---------------------------------------------------------------------------
//
// Method: CDataSrc::CDataSrc
//
// Synopsis: ctor
//
// Arguments: pUnkOuter - outer unknown
//
// History: 3-30-97 mohamedn Created
// 10-05-97 danleg _ErrorInfo
// 10-30-97 danleg Prop info for Initialize/Uninitialize
// Notes:
//
//----------------------------------------------------------------------------
CDataSrc::CDataSrc( IUnknown * pUnkOuter,
IUnknown ** ppUnkInner )
: _cSessionCount(0),
_fDSOInitialized(FALSE),
_fGlobalViewsCreated(FALSE),
_xIPVerify(new CImpIParserVerify()),
_UtlProps(_xIPVerify.GetPointer()),
#pragma warning(disable : 4355)
_impIUnknown(this),
_ErrorInfo( * ((IUnknown *) (IDBInitialize *) this), _mtxDSO )
#pragma warning(default : 4355)
{
_pUnkOuter = pUnkOuter ? pUnkOuter : (IUnknown *) &_impIUnknown;
_ErrorInfo.SetInterfaceArray( cDataSrcErrInt, apDataSrcErrInt );
// SQL Text Parser
// @devnote: The following is allocated since its existence is controlled
// by AddRef and Release.
SCODE sc = MakeIParser(((IParser**)_xIParser.GetQIPointer()));
if( FAILED(sc) )
THROW( CException(sc) );
_UtlPropInfo.ExposeMinimalSets();
_UtlProps.ExposeMinimalSets();
*ppUnkInner = (IUnknown *) &_impIUnknown;
(*ppUnkInner)->AddRef();
}
//+---------------------------------------------------------------------------
//
// Method: CDataSrc::~CDataSrc
//
// Synopsis: d-ctor
//
// Arguments:
//
// History: 3-30-97 mohamedn Created
// 10-30-97 danleg Prop info for Initialize/Uninitialize
//----------------------------------------------------------------------------
CDataSrc::~CDataSrc()
{
_UtlPropInfo.ExposeMaximalSets();
_UtlProps.ExposeMaximalSets();
}
//+---------------------------------------------------------------------------
//
// Member: CDataSrc::RealQueryInterface
//
// Synopsis: Supports IID_IUnknown,
// IID_IDBInitialize,
// IID_IDBProperties,
// IID_IDBIPersist,
// IID_IDBCreateSession
// IID_IDBInfo
//
// History: 03-30-97 mohamedn created
// 09-05-97 danleg added IDBInfo & ISupportErrorInfo
// 01-29-98 danleg non delegating QI when not aggregated
//
//----------------------------------------------------------------------------
STDMETHODIMP CDataSrc::RealQueryInterface(REFIID riid, void **ppvObj )
{
SCODE sc = S_OK;
if ( !ppvObj )
return E_INVALIDARG;
if ( riid == IID_IUnknown )
{
*ppvObj = (void *) ( (IUnknown *) (IDBInitialize *) this );
}
else if ( riid == IID_IDBInitialize )
{
*ppvObj = (void *) (IDBInitialize *) this;
}
else if ( riid == IID_IDBProperties )
{
*ppvObj = (void *) (IDBProperties *) this;
}
else if ( riid == IID_IPersist )
{
*ppvObj = (void *) (IPersist *) this;
}
else if ( riid == IID_IDBCreateSession )
{
//
// The following interfaces are supported only if DSO is initialized
//
// Make sure we don't get uninitialized
if ( _fDSOInitialized )
{
*ppvObj = (void *) (IDBCreateSession *) this;
}
else
{
*ppvObj = 0;
sc = E_UNEXPECTED; // per OLE DB spec.
}
}
else if ( riid == IID_IDBInfo )
{
*ppvObj = (void *) (IDBInfo *) this;
}
else if ( riid == IID_ISupportErrorInfo )
{
*ppvObj = (void *) ((IUnknown *) (ISupportErrorInfo *) &_ErrorInfo);
}
else
{
*ppvObj = 0;
sc = E_NOINTERFACE;
}
return sc;
} // QueryInterface
//+---------------------------------------------------------------------------
//
// Method: CDataSrc::Initialize
//
// Synopsis: changes the DSO state to Initialized.
//
// Arguments:
//
// History: 3-30-97 mohamedn Created
//
//----------------------------------------------------------------------------
STDMETHODIMP CDataSrc::Initialize()
{
SCODE sc = S_OK;
// Clear previous Error Object for this thread
_ErrorInfo.ClearErrorInfo();
TRANSLATE_EXCEPTIONS;
TRY
{
CLock lck( _mtxDSO );
if ( !_fDSOInitialized )
{
// Expose non-init propsets
sc = _UtlProps.ExposeMaximalSets();
if ( SUCCEEDED(sc) )
{
// Expose propinfo for non-init propsets
_UtlPropInfo.ExposeMaximalSets();
// OK, now we're initialized.
_fDSOInitialized = TRUE;
}
else
{
THROW( CException(sc) );
}
}
else
{
THROW( CException(DB_E_ALREADYINITIALIZED) );
}
}
CATCH( CException, e )
{
sc = _ErrorInfo.PostHResult( e, IID_IDBInitialize );
}
END_CATCH;
UNTRANSLATE_EXCEPTIONS;
return sc;
}
//+---------------------------------------------------------------------------
//
// Method: CDataSrc::Uninitialize
//
// Synopsis: changes the DSO state to Uninitialized.
//
// Arguments:
//
// History: 3-30-97 mohamedn Created
//
//----------------------------------------------------------------------------
STDMETHODIMP CDataSrc::Uninitialize()
{
SCODE sc = S_OK;
// Clear previous Error Object for this thread
_ErrorInfo.ClearErrorInfo();
TRANSLATE_EXCEPTIONS;
TRY
{
CLock lck( _mtxDSO );
if ( 0 == _cSessionCount )
{
// Hide non-init propsets
_UtlProps.ExposeMinimalSets();
_UtlPropInfo.ExposeMinimalSets();
// Mark DSO as uninitialized
_fDSOInitialized = FALSE;
}
else
{
THROW( CException(DB_E_OBJECTOPEN) );
}
}
CATCH( CException, e )
{
sc = _ErrorInfo.PostHResult( e, IID_IDBInitialize );
}
END_CATCH;
UNTRANSLATE_EXCEPTIONS;
return sc;
}
//+-------------------------------------------------------------------------
//
// Function: CDataSrc::GetProperties
//
// Synopsis: gets IDBProperties
//
// Arguments: [cPropertyIDSets] - number of desired property set IDs or 0
// [pPropIDSets] - array of desired property set IDs or NULL
// [pcPropertySets] - number of property sets returned
// [prgPropertySets] - array of returned property sets
//
// Returns: SCODE - result code indicating error return status. One of
// S_OK, DB_S_ERRORSOCCURRED, E_INVALIDARG.
//
// History: 3-30-97 mohamedn Created
// 10-30-97 danleg Chaned to use the Monarch prop code
//
//--------------------------------------------------------------------------
STDMETHODIMP CDataSrc::GetProperties
(
ULONG cPropertySets,
const DBPROPIDSET rgPropertySets[],
ULONG * pcProperties,
DBPROPSET ** prgProperties
)
{
SCODE sc = S_OK;
// Clear previous Error Object for this thread
_ErrorInfo.ClearErrorInfo();
TRANSLATE_EXCEPTIONS;
TRY
{
CLock lck( _mtxDSO );
// Check Arguments
_UtlProps.GetPropertiesArgChk( cPropertySets,
rgPropertySets,
pcProperties,
prgProperties );
// Note that CUtlProps knows about initialization,
// so we don't have to here.
sc = _UtlProps.GetProperties( cPropertySets,
rgPropertySets,
pcProperties,
prgProperties );
if ( FAILED(sc) )
THROW( CException(sc) );
}
CATCH( CException, e )
{
sc = _ErrorInfo.PostHResult( e, IID_IDBProperties );
}
END_CATCH;
UNTRANSLATE_EXCEPTIONS;
return sc;
}
//+---------------------------------------------------------------------------
//
// Function: CDataSrc::SetProperties
//
// Synopsis: sets IDBProperties
//
// Arguments: [cPropertySets] - number of property sets
// [rgPropertySets] - array of property sets
//
// Returns: SCODE - result code indicating error return status. One of
// S_OK, DB_S_ERRORSOCCURRED, E_INVALIDARG.
//
// History: 03-30-97 mohamedn created
// 10-30-97 danleg Changed to use Monarch's prop code
//
//----------------------------------------------------------------------------
STDMETHODIMP CDataSrc::SetProperties
(
ULONG cPropertySets,
DBPROPSET rgPropertySets[]
)
{
// Clear previous Error Object for this thread
_ErrorInfo.ClearErrorInfo();
// Quick return if the Count of Properties is 0
if( cPropertySets == 0 )
return S_OK;
SCODE sc = S_OK;
TRANSLATE_EXCEPTIONS;
TRY
{
XArray<DBPROPSET> xaDbPropSet;
ULONG iNewSet, iSet, iProp;
CLock lck( _mtxDSO );
_UtlProps.SetPropertiesArgChk( cPropertySets, rgPropertySets );
// We need to handle the DBINIT properties specially after being initialized.
// - they should be treated as NOTSETTABLE at this point.
if( _fDSOInitialized )
{
Win4Assert( cPropertySets );
bool fFoundDBINIT = false;
// Allocate a DBPROPSET structure of equal size
xaDbPropSet.Init( cPropertySets );
for( iNewSet=0,iSet=0; iSet<cPropertySets; iSet++ )
{
// Remove any DBPROPSET_DBINIT values and mark them all
// as not settable
if( rgPropertySets[iSet].guidPropertySet == DBPROPSET_DBINIT )
{
fFoundDBINIT = true;
for(iProp=0; iProp<rgPropertySets[iSet].cProperties; iProp++)
{
rgPropertySets[iSet].rgProperties[iProp].dwStatus = DBPROPSTATUS_NOTSETTABLE;
}
}
else
{
// If not DBPROPSET_DBINIT then copy the DBPROPSET values
RtlCopyMemory( &(xaDbPropSet[iNewSet++]), &rgPropertySets[iSet], sizeof(DBPROPSET) );
}
}
// If we have no propertyset to pass on to the property handler,
// we can exit
if( 0 == iNewSet )
{
sc = DB_E_ERRORSOCCURRED;
}
else
{
sc = _UtlProps.SetProperties( iNewSet, xaDbPropSet.GetPointer() );
// If we have determined that one of the property sets was DBINIT, we may
// need to fixup the returned hr value.
if( fFoundDBINIT && (sc == S_OK) )
sc = DB_S_ERRORSOCCURRED;
}
}
else
{
// Note that CUtlProps knows about initialization, so we don't
// have to here. This sets members _bstrCatalog and _bstrMachine
// in CMDSProps
sc = _UtlProps.SetProperties( cPropertySets, rgPropertySets );
}
if ( FAILED(sc) )
THROW( CException(sc) );
}
CATCH( CException, e )
{
sc = _ErrorInfo.PostHResult( e, IID_IDBProperties );
}
END_CATCH;
UNTRANSLATE_EXCEPTIONS;
return sc;
} // CDatasrc::SetProperties
//+---------------------------------------------------------------------------
//
// Function: CDataSrc::GetPropertyInfo
//
// Synopsis: sets IDBProperties
//
// Arguments: [cPropertyIDSets] - number of property sets
// [rgPropertyIDSets] - array of property sets
// [pcPropertyInfoSets] - count of properties returned
// [prgPropertyInfoSets] - property information returned
// [ppDescBuffer] - buffer for returned descriptions
//
// Returns:
//
// History: 10-28-97 danleg created from Monarch
//
//----------------------------------------------------------------------------
STDMETHODIMP CDataSrc::GetPropertyInfo
(
ULONG cPropertyIDSets,
const DBPROPIDSET rgPropertyIDSets[],
ULONG * pcPropertyInfoSets,
DBPROPINFOSET ** prgPropertyInfoSets,
OLECHAR ** ppDescBuffer
)
{
ULONG ul;
ULONG cSpecialPropertySets = 0;
// Clear previous Error Object for this thread
_ErrorInfo.ClearErrorInfo();
// Initialize
if( pcPropertyInfoSets )
*pcPropertyInfoSets = 0;
if( prgPropertyInfoSets )
*prgPropertyInfoSets = 0;
if( ppDescBuffer )
*ppDescBuffer = 0;
// Check Arguments, on failure post HRESULT to error queue
if( ((cPropertyIDSets > 0) && !rgPropertyIDSets ) ||
!pcPropertyInfoSets || !prgPropertyInfoSets )
return _ErrorInfo.PostHResult( E_INVALIDARG, IID_IDBProperties );
// New argument check for > 1 cPropertyIDs and NULL pointer for
// array of property ids.
for(ul=0; ul<cPropertyIDSets; ul++)
{
if( rgPropertyIDSets[ul].cPropertyIDs &&
!(rgPropertyIDSets[ul].rgPropertyIDs) )
return _ErrorInfo.PostHResult( E_INVALIDARG, IID_IDBProperties );
}
//check the count of special propertySets
for(ul=0; ul<cPropertyIDSets; ul++)
{
if( (rgPropertyIDSets[ul].guidPropertySet ==DBPROPSET_DATASOURCEALL) ||
(rgPropertyIDSets[ul].guidPropertySet ==DBPROPSET_DATASOURCEINFOALL) ||
(rgPropertyIDSets[ul].guidPropertySet ==DBPROPSET_DBINITALL) ||
(rgPropertyIDSets[ul].guidPropertySet ==DBPROPSET_ROWSETALL) ||
(rgPropertyIDSets[ul].guidPropertySet ==DBPROPSET_SESSIONALL) )
cSpecialPropertySets++;
}
// if used SpecialPropertySets with non-special Propertysets
if ((cSpecialPropertySets > 0) && (cSpecialPropertySets < cPropertyIDSets))
{
return _ErrorInfo.PostHResult( E_INVALIDARG, IID_IDBProperties );
}
SCODE sc = S_OK;
TRANSLATE_EXCEPTIONS;
TRY
{
CLock lck( _mtxDSO );
sc = _UtlPropInfo.GetPropertyInfo( cPropertyIDSets,
rgPropertyIDSets,
pcPropertyInfoSets,
prgPropertyInfoSets,
ppDescBuffer );
if ( FAILED(sc) )
THROW( CException(sc) );
}
CATCH( CException, e )
{
sc = _ErrorInfo.PostHResult( e, IID_IDBProperties );
}
END_CATCH;
UNTRANSLATE_EXCEPTIONS;
return sc;
}
//+---------------------------------------------------------------------------
//
// Method: CDataSrc::CreateGlobalViews
//
// Synopsis: Creates global views (FILEINFO, WEBINFO etc.). These views
// are removed when the IParser object goes away.
//
// Arguments:
//
// History: 01-09-98 danleg Created
//
//----------------------------------------------------------------------------
void CDataSrc::CreateGlobalViews( IParserSession * pIPSession )
{
SCODE sc = S_OK;
extern const LPWSTR s_pwszPredefinedViews;
DBCOMMANDTREE * pDBCOMMANDTREE = 0;
XInterface<IParserTreeProperties> xIPTProperties;
LCID lcid = GetDSPropsPtr()->GetValLong( CMDSProps::eid_DBPROPSET_DBINIT,
CMDSProps::eid_INIT_LCID );
sc = pIPSession->ToTree( lcid,
s_pwszPredefinedViews,
&pDBCOMMANDTREE,
xIPTProperties.GetPPointer() );
if ( FAILED(sc) )
THROW( CException(sc) );
_fGlobalViewsCreated = TRUE;
}
//+---------------------------------------------------------------------------
//
// Method: CDataSrc::DupImpersonationToken, public
//
// Synopsis: Clients calling CreateSession can be impersonated. One such
// client, SQL Server's Distributed Query Processor, stays
// impersonated only for the duration of the call to CreateSession.
//
// This routine is called from CreateSession and caches the
// impersonation token. This token is used to get back the security
// context of the client during CreateCommand/OpenRowset.
//
// Arguments:
//
// History: 09-01-98 danleg Created
//
// Notes: Revisit if OLE DB defines "Integrated Security" differently in
// the future, or defines a better security scheme.
//
//----------------------------------------------------------------------------
void CDataSrc::DupImpersonationToken
(
HANDLE & hToken
)
{
DWORD dwLength = 0;
NTSTATUS status = STATUS_SUCCESS;
TOKEN_STATISTICS TokenInformation;
HANDLE hTempToken;
status = NtOpenThreadToken( GetCurrentThread(),
TOKEN_QUERY |
TOKEN_DUPLICATE |
TOKEN_IMPERSONATE,
TRUE,
&hTempToken );
if ( !NT_SUCCESS(status) )
{
if ( STATUS_NO_TOKEN == status )
{
status = NtOpenProcessToken( GetCurrentProcess(),
TOKEN_QUERY |
TOKEN_DUPLICATE |
TOKEN_IMPERSONATE,
&hTempToken );
}
if ( !NT_SUCCESS(status) )
{
vqDebugOut(( DEB_ERROR,
"DupImpersonationToken failed to get token, %x\n",
status ));
THROW( CException(status) );
}
}
SHandle xHandle( hTempToken );
HANDLE hNewToken = INVALID_HANDLE_VALUE;
OBJECT_ATTRIBUTES ObjAttr;
SECURITY_QUALITY_OF_SERVICE qos;
qos.Length = sizeof( SECURITY_QUALITY_OF_SERVICE );
qos.ImpersonationLevel = SecurityImpersonation;
qos.ContextTrackingMode = SECURITY_DYNAMIC_TRACKING;
qos.EffectiveOnly = FALSE;
InitializeObjectAttributes( &ObjAttr,
NULL,
0,
NULL,
NULL );
ObjAttr.SecurityQualityOfService = &qos;
status = NtDuplicateToken( hTempToken,
TOKEN_IMPERSONATE |
TOKEN_QUERY |
TOKEN_DUPLICATE,
&ObjAttr,
FALSE,
TokenImpersonation,
&hNewToken );
if ( !NT_SUCCESS(status) )
{
vqDebugOut(( DEB_ERROR,
"DupImpersonationToken failed to duplicate token, %x\n",
status ));
THROW( CException(HRESULT_FROM_WIN32(status)) );
}
hToken = hNewToken;
}
//+---------------------------------------------------------------------------
//
// Method: CDataSrc::CreateSession
//
// Synopsis: Associates a session with the DSO.
//
// Arguments: [pUnkOuter] - controlling unknown
// [riid] - interface requested
// [ppDBSession] - contains returned interface pointer
//
// History: 3-30-97 mohamedn Created
// 1-10-98 danleg Added global views
//
//----------------------------------------------------------------------------
STDMETHODIMP CDataSrc::CreateSession( IUnknown * pUnkOuter,
REFIID riid,
IUnknown ** ppDBSession )
{
_ErrorInfo.ClearErrorInfo();
if ( !ppDBSession )
return _ErrorInfo.PostHResult( E_INVALIDARG, IID_IDBCreateSession );
else
*ppDBSession = 0;
if ( !_fDSOInitialized )
return _ErrorInfo.PostHResult( E_UNEXPECTED, IID_IDBCreateSession );
if (0 != pUnkOuter && riid != IID_IUnknown)
return _ErrorInfo.PostHResult( DB_E_NOAGGREGATION, IID_IDBCreateSession );
SCODE sc = S_OK;
HANDLE hToken = INVALID_HANDLE_VALUE;
TRANSLATE_EXCEPTIONS;
TRY
{
XInterface<IColumnMapperCreator> xColMapCreator;
XInterface<IParserSession> xIPSession;
CLock lck( _mtxDSO );
DupImpersonationToken( hToken );
//
// Service Components set DBPROP_RESETDATASOURCE to indicate that the DSO has been
// pooled. We need to reset the IParser object because it maintains state valid
// across sessions (eg. views)
//
LONG lResetVal = _UtlProps.GetValLong( CMDSProps::eid_DBPROPSET_DATASOURCE,
CMDSProps::eid_DBPROPVAL_RESETDATASOURCE);
if ( DBPROPVAL_RD_RESETALL == lResetVal )
{
// make sure there aren't any outstanding sessions when doing this.
if ( 0 != _cSessionCount )
THROW( CException( E_INVALIDARG ) );
_xIParser.Free();
sc = MakeIParser( _xIParser.GetPPointer() );
if ( FAILED(sc) )
THROW( CException(sc) );
_UtlProps.SetValLong( CMDSProps::eid_DBPROPSET_DATASOURCE,
CMDSProps::eid_DBPROPVAL_RESETDATASOURCE,
0L );
}
//
// Create an IParserSession object to pass to the session
//
_xIPVerify->GetColMapCreator( xColMapCreator.GetPPointer() );
sc = _xIParser->CreateSession( &DBGUID_MSSQLTEXT,
GetDSPropsPtr()->GetValString(
CMDSProps::eid_DBPROPSET_DBINIT,
CMDSProps::eid_DBPROPVAL_INIT_LOCATION),
_xIPVerify.GetPointer(),
xColMapCreator.GetPointer(),
xIPSession.GetPPointer() );
if ( FAILED(sc) )
THROW( CException(sc) );
LPCWSTR pwszCatalog = 0;
pwszCatalog = GetDSPropsPtr()->GetValString(
CMDSProps::eid_DBPROPSET_DATASOURCE,
CMDSProps::eid_DBPROPVAL_CURRENTCATALOG);
sc = xIPSession->SetCatalog( pwszCatalog );
if( FAILED(sc) )
THROW( CException(sc) );
//
// Predefined views -- only once per DSO
//
if ( !_fGlobalViewsCreated )
CreateGlobalViews( xIPSession.GetPointer() );
//
// Create the session object
//
XInterface<IUnknown> xUnkInner;
CDBSession *pDBSession = new CDBSession( *this,
pUnkOuter,
xUnkInner.GetPPointer(),
xIPSession.GetPointer(),
hToken );
// NOTE: pDBSession is the same object as xUnkInner.
sc = xUnkInner->QueryInterface( riid, (void **) ppDBSession );
if ( FAILED(sc) )
THROW( CException(sc) );
}
CATCH(CException, e)
{
sc = _ErrorInfo.PostHResult( e, IID_IDBCreateSession );
}
END_CATCH;
UNTRANSLATE_EXCEPTIONS;
return sc;
}
//+---------------------------------------------------------------------------
//
// Method: CDataSrc::GetClassID
//
// Synopsis: Return the CLSID for this server object
//
// Arguments: [pClassID]
//
// History: 3-30-97 mohamedn Created
// 10-28-97 danleg added _ErrorInfo
//
//----------------------------------------------------------------------------
STDMETHODIMP CDataSrc::GetClassID ( CLSID *pClassID )
{
_ErrorInfo.ClearErrorInfo();
if (pClassID)
{
RtlCopyMemory( pClassID, &CLSID_CiFwDSO, sizeof(CLSID) );
return S_OK;
}
else
return _ErrorInfo.PostHResult( E_FAIL, IID_IPersist );
}
//============================================================================
// LITERAL INFO Constants
//============================================================================
// The following are constants that define literals that don't change.. When the buffer
// to return literal information is allocated, it is initialized with this string and
// then when a particular literal is asked for; a pointer in these values is used.
static const LPWSTR LIT_BUFFER = L"\"\0.\0%\0_\0[]\0[]\0";
static const ULONG LIT_QUOTE_VALID_OFFSET = 0;
static const ULONG LIT_CATALOG_SEP_VALID_OFFSET = LIT_QUOTE_VALID_OFFSET + NUMELEM(L"\"");
static const ULONG LIT_PERCENT_VALID_OFFSET = LIT_CATALOG_SEP_VALID_OFFSET + NUMELEM(L".");
static const ULONG LIT_UNDERSCORE_VALID_OFFSET = LIT_PERCENT_VALID_OFFSET + NUMELEM(L"%");
static const ULONG LIT_ESCAPE_PERCENT_OFFSET = LIT_UNDERSCORE_VALID_OFFSET + NUMELEM(L"_");
static const ULONG LIT_ESCAPE_UNDERSCORE_OFFSET = LIT_ESCAPE_PERCENT_OFFSET + NUMELEM(L"[]");
static const ULONG LIT_CCH_INITIAL_BUFFER = LIT_ESCAPE_UNDERSCORE_OFFSET + NUMELEM(L"[]");
static const ULONG LIT_CB_INITIAL_BUFFER = LIT_CCH_INITIAL_BUFFER * sizeof(WCHAR);
// List of unique Keywords that OLE DB does not define.
static const WCHAR s_pwszKeyWords[] = {L"ARRAY,COERCE,CONTAINS,DEEP,DERIVATIONAL,"
L"EXCLUDE,FORMSOF,FREETEXT,INFLECTIONAL,"
L"ISABOUT,MATCHES,NEAR,PARAGRAPH,PASSTHROUGH,"
L"PROPERTYNAME,PROPID,RANKMETHOD,SENTENCE,"
L"SCOPE,SEARCH,SHALLOW,SOUNDEX,THESAURUS,"
L"TRAVERSAL,TYPE,WEIGHT,WORD"};
//+---------------------------------------------------------------------------
//
// Function: CDataSrc::GetKeywords
//
// Synopsis: returns a list of provider specific keywords
//
// Arguments: [ppwszKeywords] - string containing returned list of comma
// separated keywords
//
// Returns: HRESULT indicating the status of the method
// S_OK | Keyword list retrieved
// E_FAIL | Provider specific error (ODBC call failed)
// E_OUTOFMEMORY | Buffer could not be allocated for the keywords.
// E_INVALIDARG | Arguments did not match specification
//
// History: 09-05-97 danleg created from Monarch project
//
//----------------------------------------------------------------------------
STDMETHODIMP CDataSrc::GetKeywords(LPOLESTR* ppwszKeywords)
{
SCODE sc = S_OK;
// Clear previous Error Object for this thread
_ErrorInfo.ClearErrorInfo();
TRANSLATE_EXCEPTIONS;
TRY
{
CLock lck( _mtxDSO );
// Check arguments
if( ppwszKeywords )
{
*ppwszKeywords = 0;
// Check that object is initialized
if( _fDSOInitialized )
{
XArrayOLE<WCHAR> xpwszKeyWords( NUMELEM(s_pwszKeyWords) );
RtlCopyMemory( xpwszKeyWords.GetPointer(),
s_pwszKeyWords,
sizeof(s_pwszKeyWords) );
*ppwszKeywords = xpwszKeyWords.Acquire();
}
else
{
vqDebugOut(( DEB_TRACE, "Initialization must occur before IDBInfo can be called\n" ));
sc = E_UNEXPECTED;
}
}
else
{
sc = E_INVALIDARG;
}
if ( FAILED(sc) )
THROW( CException(sc) );
}
CATCH( CException, e )
{
sc = _ErrorInfo.PostHResult( e, IID_IDBInfo );
}
END_CATCH;
UNTRANSLATE_EXCEPTIONS;
return sc;
}
//+---------------------------------------------------------------------------
//
// Function: CDataSrc::GetLiteralInfo
//
// Synopsis: Retreives information about literals. Their length, and special
// characters and whether they are actually supported.
//
// Arguments: [cLiterals] - Number of literals being asked about
// [rgLiterals] - Array of literals being asked about
// [pcLiteralInfo] - Contains returned number of literals
// [prgLiteralInfo] - Contains returned literal information
// [ppCharBuffer] - Buffer for returned string values
//
// Returns: HRESULT indicating the status of the method
// S_OK | Keyword list retrieved
// E_FAIL | Provider specific error (ODBC call failed)
// E_OUTOFMEMORY | Buffer could not be allocated for the keywords.
// E_INVALIDARG | Arguments did not match specification
//
// History: 09-05-97 danleg created from Monarch project
//
//----------------------------------------------------------------------------
STDMETHODIMP CDataSrc::GetLiteralInfo
(
ULONG cLiterals,
const DBLITERAL rgLiterals[],
ULONG* pcLiteralInfo,
DBLITERALINFO** prgLiteralInfo,
OLECHAR** ppCharBuffer
)
{
SCODE sc = S_OK;
const DWORD LITERAL_NORESTRICTIONS = 0x00000001;
const DWORD LITERAL_FAILURE = 0x00000002;
const DWORD LITERAL_SUCCESS = 0x00000004;
const static DBLITERAL s_rgSupportedLiterals[] = {
DBLITERAL_BINARY_LITERAL, DBLITERAL_CATALOG_NAME, DBLITERAL_CATALOG_SEPARATOR,
DBLITERAL_CHAR_LITERAL, DBLITERAL_COLUMN_NAME, DBLITERAL_CORRELATION_NAME,
DBLITERAL_ESCAPE_PERCENT, DBLITERAL_ESCAPE_UNDERSCORE,
DBLITERAL_LIKE_PERCENT, DBLITERAL_LIKE_UNDERSCORE, DBLITERAL_TABLE_NAME,
DBLITERAL_TEXT_COMMAND, DBLITERAL_VIEW_NAME, DBLITERAL_QUOTE_PREFIX,
DBLITERAL_QUOTE_SUFFIX
};
// Clear previous Error Object for this thread
_ErrorInfo.ClearErrorInfo();
// Initialize
if( pcLiteralInfo )
*pcLiteralInfo = 0;
if( prgLiteralInfo )
*prgLiteralInfo = 0;
if( ppCharBuffer )
*ppCharBuffer = 0;
// Check Arguments
if( ((cLiterals > 0) && !rgLiterals) ||
!pcLiteralInfo ||
!ppCharBuffer ||
!prgLiteralInfo )
{
return _ErrorInfo.PostHResult( E_INVALIDARG, IID_IDBInfo );
}
TRANSLATE_EXCEPTIONS;
TRY
{
ULONG ulDex,
ulNew;
DWORD dwStatus = 0;
DBLITERALINFO* pdbLitInfo;
CLock lck( _mtxDSO );
// We must be initialized
if( !_fDSOInitialized )
{
vqDebugOut(( DEB_TRACE, "Initialization must occur before IDBInfo can be called\n" ));
return _ErrorInfo.PostHResult( E_UNEXPECTED, IID_IDBInfo );
}
// Allocate Memory for literal information
if( cLiterals == 0 )
{
dwStatus |= LITERAL_NORESTRICTIONS;
cLiterals = NUMELEM( s_rgSupportedLiterals );
rgLiterals = s_rgSupportedLiterals;
}
XArrayOLE<DBLITERALINFO> xaLiteralInfo( cLiterals );
XArrayOLE<WCHAR> xaCharBuffer( LIT_CCH_INITIAL_BUFFER );
// Initialize the first part of the buffer with our
// static set of literal information
RtlCopyMemory( xaCharBuffer.GetPointer(), LIT_BUFFER, LIT_CB_INITIAL_BUFFER );
// Process each of the DBLITERAL values that are in the
// restriction array or that we potentially could support
for(ulDex=0, ulNew=0; ulDex<cLiterals; ulDex++)
{
pdbLitInfo = &(xaLiteralInfo[ulNew]);
pdbLitInfo->lt = rgLiterals[ulDex];
pdbLitInfo->fSupported = TRUE;
pdbLitInfo->pwszLiteralValue = 0;
pdbLitInfo->pwszInvalidChars = 0;
pdbLitInfo->pwszInvalidStartingChars = 0;
switch( rgLiterals[ulDex] )
{
case DBLITERAL_TEXT_COMMAND:
case DBLITERAL_CHAR_LITERAL:
case DBLITERAL_BINARY_LITERAL:
case DBLITERAL_TABLE_NAME:
pdbLitInfo->cchMaxLen = ~0;
break;
case DBLITERAL_CATALOG_NAME:
case DBLITERAL_COLUMN_NAME:
case DBLITERAL_CORRELATION_NAME:
case DBLITERAL_VIEW_NAME:
pdbLitInfo->cchMaxLen = 128;
break;
case DBLITERAL_CATALOG_SEPARATOR:
pdbLitInfo->cchMaxLen = 1; // L'.';
pdbLitInfo->pwszLiteralValue = xaCharBuffer.GetPointer() + LIT_CATALOG_SEP_VALID_OFFSET;
break;
case DBLITERAL_ESCAPE_PERCENT:
pdbLitInfo->cchMaxLen = 2; // L"[]";
pdbLitInfo->pwszLiteralValue = xaCharBuffer.GetPointer() + LIT_ESCAPE_PERCENT_OFFSET;
break;
case DBLITERAL_ESCAPE_UNDERSCORE:
pdbLitInfo->cchMaxLen = 2; // L"[]";
pdbLitInfo->pwszLiteralValue = xaCharBuffer.GetPointer() + LIT_ESCAPE_UNDERSCORE_OFFSET;
break;
case DBLITERAL_LIKE_PERCENT:
pdbLitInfo->cchMaxLen = 1; // L'%';
pdbLitInfo->pwszLiteralValue = xaCharBuffer.GetPointer() + LIT_PERCENT_VALID_OFFSET;
break;
case DBLITERAL_LIKE_UNDERSCORE:
pdbLitInfo->cchMaxLen = 1; // L'_';
pdbLitInfo->pwszLiteralValue = xaCharBuffer.GetPointer() + LIT_UNDERSCORE_VALID_OFFSET;
break;
case DBLITERAL_QUOTE_PREFIX:
case DBLITERAL_QUOTE_SUFFIX:
pdbLitInfo->cchMaxLen = 1; // L'"';
pdbLitInfo->pwszLiteralValue = xaCharBuffer.GetPointer() + LIT_QUOTE_VALID_OFFSET;
break;
default:
pdbLitInfo->cchMaxLen = 0;
// If we are given a dbLiteral that we do not
// support, just set the fSupport flag false
// and continue on.
pdbLitInfo->fSupported = FALSE;
break;
}
// If we are returning all the supported literals, then
// we need to drop any that are fSupported = FALSE;
if( dwStatus & LITERAL_NORESTRICTIONS )
{
if( pdbLitInfo->fSupported == FALSE )
continue;
}
else
{
if( pdbLitInfo->fSupported == FALSE )
dwStatus |= LITERAL_FAILURE;
else
dwStatus |= LITERAL_SUCCESS;
}
ulNew++;
}
sc = (dwStatus & LITERAL_FAILURE) ?
((dwStatus & LITERAL_SUCCESS) ? DB_S_ERRORSOCCURRED : DB_E_ERRORSOCCURRED) :
S_OK;
*pcLiteralInfo = ulNew;
// We only want to return the string buffer if it
// is a success
if ( SUCCEEDED(sc) )
*ppCharBuffer = xaCharBuffer.Acquire();
// We want to return the LiteralInfo on success and on
// a DB_E_ERRORSOCCURRED failure
if ( SUCCEEDED(sc) || (sc == DB_E_ERRORSOCCURRED) )
*prgLiteralInfo = xaLiteralInfo.Acquire();
if ( FAILED(sc) )
THROW( CException(sc) );
}
CATCH( CException, e )
{
sc = _ErrorInfo.PostHResult( e, IID_IDBInfo );
}
END_CATCH;
UNTRANSLATE_EXCEPTIONS;
return sc;
}