daocore.cpp

一个集分词、词性标注和格式转换的强大的工具包

CDaoWorkspace::CDaoWorkspace()
{
	m_pDAOWorkspaces = NULL;
	m_pDAOWorkspace = NULL;
	m_pDAODatabases = NULL;

	m_bOpen = FALSE;
	m_bNew = FALSE;
	m_nStatus = 0;
}

CDaoWorkspace::~CDaoWorkspace()
{
	if (IsOpen())
	{
		m_nStatus |= AFX_DAO_IMPLICIT_CLOSE;
		Close();
	}
	else if (m_bNew)
	{
		// Remove the workspace from the AFX_DAO_STATE's map
		_AFX_DAO_STATE* pDaoState = AfxGetDaoState();
		pDaoState->m_mapWorkspaces.RemoveKey(this);
	}
}

void CDaoWorkspace::Create(LPCTSTR lpszName, LPCTSTR lpszUserName,
	LPCTSTR lpszPassword)
{
	ASSERT_VALID(this);
	ASSERT(!IsOpen());
	ASSERT(lpszUserName != NULL);
	ASSERT(lpszPassword != NULL);

	// Get the DAODBEngine interface and initialize if necessary
	_AFX_DAO_STATE* pDaoState = AfxGetDaoState();
	if (pDaoState->m_pDAODBEngine == NULL)
		InitializeEngine();

	COleVariant varName(lpszName, VT_BSTRT);
	COleVariant varUserName(lpszUserName, VT_BSTRT);
	COleVariant varPassword(lpszPassword, VT_BSTRT);

	DAO_CHECK(pDaoState->m_pDAODBEngine->_30_CreateWorkspace(
		V_BSTR(&varName), V_BSTR(&varUserName),
		V_BSTR(&varPassword), &m_pDAOWorkspace));

	m_bNew = TRUE;

	// Add the workspace to map of Open/New CDaoWorkspaces
	pDaoState->m_mapWorkspaces.SetAt(this, this);
}

void CDaoWorkspace::Append()
{
	ASSERT_VALID(this);
	ASSERT(m_bNew);
	ASSERT(m_pDAOWorkspace != NULL);

	DAOWorkspaces* pDAOWorkspaces;

	// Get the DAODBEngine interface and initialize if necessary
	_AFX_DAO_STATE* pDaoState = AfxGetDaoState();
	if (pDaoState->m_pDAODBEngine == NULL)
		InitializeEngine();

	DAO_CHECK(pDaoState->m_pDAODBEngine->get_Workspaces(&pDAOWorkspaces));

	TRY
	{
		DAO_CHECK(pDAOWorkspaces->Append(m_pDAOWorkspace));
	}
	CATCH_ALL(e)
	{
		pDAOWorkspaces->Release();
		THROW_LAST();
	}
	END_CATCH_ALL

	pDAOWorkspaces->Release();

	m_bNew = FALSE;
	m_bOpen = TRUE;
}

void CDaoWorkspace::Open(LPCTSTR lpszWorkspaceName)
{
	ASSERT_VALID(this);
	ASSERT(m_pDAOWorkspaces == NULL);
	ASSERT(m_pDAOWorkspace == NULL);

	// Re-Opening is invalid.
	if (IsOpen())
	{
		ASSERT(FALSE);
		return;
	}

	// Set the workspace name (or use 0 if opening default)
	COleVariant var(lpszWorkspaceName, VT_BSTRT);
	if (lpszWorkspaceName == NULL)
	{
		var = 0L;

		// Set status to prevent DAO Workspace Close call
		m_nStatus |= AFX_DAO_DEFAULT_WS;
	}

	// Get the DAODBEngine interface and initialize if necessary
	_AFX_DAO_STATE* pDaoState = AfxGetDaoState();
	if (pDaoState->m_pDAODBEngine == NULL)
		InitializeEngine();

	// Get the workspace from the workspaces collection
	DAO_CHECK(pDaoState->m_pDAODBEngine->get_Workspaces(
		&m_pDAOWorkspaces));
	DAO_CHECK(m_pDAOWorkspaces->get_Item(var, &m_pDAOWorkspace));

	m_bOpen = TRUE;
	m_pDAOWorkspaces->Release();
	m_pDAOWorkspaces = NULL;

	// Add the workspace to map of Open/New CDaoWorkspaces
	pDaoState->m_mapWorkspaces.SetAt(this, this);
}

void CDaoWorkspace::Close()
{
	ASSERT_VALID(this);

	if (m_pDAODatabases != NULL)
	{
		m_pDAODatabases->Release();
		m_pDAODatabases = NULL;
	}

	// Close any Open CDaoDatabases
	void* pvKey;
	void* pvObject;
	POSITION pos = m_mapDatabases.GetStartPosition();
	while (pos != NULL)
	{
		m_mapDatabases.GetNextAssoc(pos, pvKey, pvObject);
		((CDaoDatabase*)pvObject)->Close();
	}
	m_mapDatabases.RemoveAll();

	if (m_pDAOWorkspace != NULL)
	{
		// If implicit workspace or close, don't call DAO close.
		// It will be automatically closed when ref count 0.
		if (!(m_nStatus & (AFX_DAO_IMPLICIT_WS | AFX_DAO_IMPLICIT_CLOSE |
			AFX_DAO_DEFAULT_WS)))
		{
			DAO_TRACE(m_pDAOWorkspace->Close());
		}

		m_pDAOWorkspace->Release();
		m_pDAOWorkspace = NULL;
	}

	if (m_pDAOWorkspaces != NULL)
	{
		m_pDAOWorkspaces->Release();
		m_pDAOWorkspaces = NULL;
	}

	m_bOpen = FALSE;
	m_bNew = FALSE;
	m_nStatus &= ~AFX_DAO_DEFAULT_WS;

	// Remove the workspace from the AFX_DAO_STATE's map
	_AFX_DAO_STATE* pDaoState = AfxGetDaoState();
	pDaoState->m_mapWorkspaces.RemoveKey(this);
}

CString PASCAL CDaoWorkspace::GetVersion()
{
	COleVariant var;

	_AFX_DAO_STATE* pDaoState = AfxGetDaoState();
	if (pDaoState->m_pDAODBEngine == NULL)
		InitializeEngine();

	DAO_CHECK(pDaoState->m_pDAODBEngine->get_Version(&V_BSTR(&var)));
	var.vt = VT_BSTR;
	return V_BSTRT(&var);
}

CString PASCAL CDaoWorkspace::GetIniPath()
{
	COleVariant var;
	_AFX_DAO_STATE* pDaoState = AfxGetDaoState();
	if (pDaoState->m_pDAODBEngine == NULL)
		InitializeEngine();

	DAO_CHECK(pDaoState->m_pDAODBEngine->get_IniPath(&V_BSTR(&var)));
	var.vt = VT_BSTR;
	return V_BSTRT(&var);
}

void PASCAL CDaoWorkspace::SetIniPath(LPCTSTR lpszRegistrySubKey)
{
	COleVariant var(lpszRegistrySubKey, VT_BSTRT);

	_AFX_DAO_STATE* pDaoState = AfxGetDaoState();
	if (pDaoState->m_pDAODBEngine == NULL)
		InitializeEngine();

	DAO_CHECK(pDaoState->m_pDAODBEngine->put_IniPath(V_BSTR(&var)));
}

void PASCAL CDaoWorkspace::SetDefaultUser(LPCTSTR lpszDefaultUser)
{
	COleVariant var(lpszDefaultUser, VT_BSTRT);

	_AFX_DAO_STATE* pDaoState = AfxGetDaoState();
	if (pDaoState->m_pDAODBEngine == NULL)
		InitializeEngine();

	DAO_CHECK(pDaoState->m_pDAODBEngine->put_DefaultUser(V_BSTR(&var)));
}

void PASCAL CDaoWorkspace::SetDefaultPassword(LPCTSTR lpszPassword)
{
	COleVariant var(lpszPassword, VT_BSTRT);

	_AFX_DAO_STATE* pDaoState = AfxGetDaoState();
	if (pDaoState->m_pDAODBEngine == NULL)
		InitializeEngine();

	DAO_CHECK(pDaoState->m_pDAODBEngine->put_DefaultPassword(
		V_BSTR(&var)));
}

short PASCAL CDaoWorkspace::GetLoginTimeout()
{
	short nSeconds;

	_AFX_DAO_STATE* pDaoState = AfxGetDaoState();
	if (pDaoState->m_pDAODBEngine == NULL)
		InitializeEngine();

	DAO_CHECK(pDaoState->m_pDAODBEngine->get_LoginTimeout(&nSeconds));
	return nSeconds;
}

void PASCAL CDaoWorkspace::SetLoginTimeout(short nSeconds)
{
	_AFX_DAO_STATE* pDaoState = AfxGetDaoState();
	if (pDaoState->m_pDAODBEngine == NULL)
		InitializeEngine();

	DAO_CHECK(pDaoState->m_pDAODBEngine->put_LoginTimeout(nSeconds));
}


CString CDaoWorkspace::GetName()
{
	ASSERT_VALID(this);
	ASSERT(m_pDAOWorkspace != NULL);

	COleVariant var;
	DAO_CHECK(m_pDAOWorkspace->get_Name(&V_BSTR(&var)));
	var.vt = VT_BSTR;
	return V_BSTRT(&var);
}

CString CDaoWorkspace::GetUserName()
{
	ASSERT_VALID(this);
	ASSERT(m_pDAOWorkspace != NULL);

	COleVariant var;
	DAO_CHECK(m_pDAOWorkspace->get_UserName(&V_BSTR(&var)));
	var.vt = VT_BSTR;
	return V_BSTRT(&var);
}

void CDaoWorkspace::SetIsolateODBCTrans(BOOL bIsolateODBCTrans)
{
	ASSERT_VALID(this);
	ASSERT(m_pDAOWorkspace != NULL);

	DAO_CHECK(m_pDAOWorkspace->put_IsolateODBCTrans(
		(short)(bIsolateODBCTrans ? AFX_DAO_TRUE : AFX_DAO_FALSE)));
}

BOOL CDaoWorkspace::GetIsolateODBCTrans()
{
	ASSERT_VALID(this);
	ASSERT(m_pDAOWorkspace != NULL);

	short nIsolateODBCTrans;
	DAO_CHECK(m_pDAOWorkspace->get_IsolateODBCTrans(&nIsolateODBCTrans));
	return nIsolateODBCTrans == AFX_DAO_TRUE;
}

void PASCAL CDaoWorkspace::CompactDatabase(LPCTSTR lpszSrcName,
	LPCTSTR lpszDestName, LPCTSTR lpszLocale, int nOptions,
	LPCTSTR lpszPassword)
{
	COleVariant varSrcName(lpszSrcName, VT_BSTRT);
	COleVariant varDestName(lpszDestName, VT_BSTRT);

	_AFX_DAO_STATE* pDaoState = AfxGetDaoState();
	if (pDaoState->m_pDAODBEngine == NULL)
		InitializeEngine();

	DAO_CHECK(pDaoState->m_pDAODBEngine->CompactDatabase(
		V_BSTR(&varSrcName), V_BSTR(&varDestName),
		COleVariant(lpszLocale, VT_BSTRT), COleVariant((long)nOptions),
		lpszPassword != NULL ? (VARIANT)COleVariant(lpszPassword, VT_BSTRT) :
		_afxOptionalVariant));
}

void PASCAL CDaoWorkspace::CompactDatabase(LPCTSTR lpszSrcName,
	LPCTSTR lpszDestName, LPCTSTR lpszLocale, int nOptions)
{
	CompactDatabase(lpszSrcName, lpszDestName, lpszLocale, nOptions, NULL);
}

void PASCAL CDaoWorkspace::RepairDatabase(LPCTSTR lpszName)
{
	COleVariant varName(lpszName, VT_BSTRT);

	_AFX_DAO_STATE* pDaoState = AfxGetDaoState();
	if (pDaoState->m_pDAODBEngine == NULL)
		InitializeEngine();

	DAO_CHECK(pDaoState->m_pDAODBEngine->RepairDatabase(
		V_BSTR(&varName)));
}

void PASCAL CDaoWorkspace::Idle(int nAction)
{
	_AFX_DAO_STATE* pDaoState = AfxGetDaoState();
	if (pDaoState->m_pDAODBEngine == NULL)
		InitializeEngine();

	DAO_CHECK(pDaoState->m_pDAODBEngine->Idle(
		COleVariant((long)nAction)));
}

short CDaoWorkspace::GetWorkspaceCount()
{
	ASSERT_VALID(this);

	short nFields;

	if (m_pDAOWorkspaces == NULL)
		InitWorkspacesCollection();

	DAO_CHECK(m_pDAOWorkspaces->get_Count(&nFields));
	return nFields;
}

void CDaoWorkspace::GetWorkspaceInfo(int nIndex,
	CDaoWorkspaceInfo& wsinfo, DWORD dwInfoOptions)
{
	ASSERT_VALID(this);

	if (m_pDAOWorkspaces == NULL)
		InitWorkspacesCollection();

	// Get DAOWorkspace object and fill in workspace info struct
	DAOWorkspace* pDAOWorkspace;
	DAO_CHECK(m_pDAOWorkspaces->get_Item(
		COleVariant((long)nIndex), &pDAOWorkspace));
	FillWorkspaceInfo(pDAOWorkspace, wsinfo, dwInfoOptions);

	// Clean up
	pDAOWorkspace->Release();
}

void CDaoWorkspace::GetWorkspaceInfo(
	LPCTSTR lpszName, CDaoWorkspaceInfo& wsinfo,
	DWORD dwInfoOptions)
{
	ASSERT_VALID(this);

	if (m_pDAOWorkspaces == NULL)
		InitWorkspacesCollection();

	// Get DAOWorkspace object and fill in workspace info struct
	DAOWorkspace* pDAOWorkspace;
	DAO_CHECK(m_pDAOWorkspaces->get_Item(
		COleVariant(lpszName, VT_BSTRT), &pDAOWorkspace));
	FillWorkspaceInfo(pDAOWorkspace, wsinfo, dwInfoOptions);

	// Clean up
	pDAOWorkspace->Release();
}

short CDaoWorkspace::GetDatabaseCount()
{
	ASSERT_VALID(this);

	if (m_pDAODatabases == NULL)
		InitDatabasesCollection();

	short nFields;
	DAO_CHECK(m_pDAODatabases->get_Count(&nFields));
	return nFields;
}

void CDaoWorkspace::GetDatabaseInfo(int nIndex, CDaoDatabaseInfo& dbinfo,
	DWORD dwInfoOptions)
{
	ASSERT_VALID(this);

	if (m_pDAODatabases == NULL)
		InitDatabasesCollection();

	// Get DAODatabase object and fill in database info struct
	DAODatabase* pDAODatabase;
	DAO_CHECK(m_pDAODatabases->get_Item(
		COleVariant((long)nIndex), &pDAODatabase));
	FillDatabaseInfo(pDAODatabase, dbinfo, dwInfoOptions);

	// Clean up
	pDAODatabase->Release();
}

void CDaoWorkspace::GetDatabaseInfo(LPCTSTR lpszName,
	CDaoDatabaseInfo& dbinfo, DWORD dwInfoOptions)
{
	ASSERT_VALID(this);

	if (m_pDAODatabases == NULL)
		InitDatabasesCollection();

	// Get DAODatabase object and fill in database info struct
	DAODatabase* pDAODatabase;
	DAO_CHECK(m_pDAODatabases->get_Item(
		COleVariant(lpszName, VT_BSTRT), &pDAODatabase));
	FillDatabaseInfo(pDAODatabase, dbinfo, dwInfoOptions);

	// Clean up
	pDAODatabase->Release();
}

void CDaoWorkspace::BeginTrans()
{
	ASSERT_VALID(this);
	ASSERT(IsOpen());
	ASSERT(m_pDAOWorkspace != NULL);

	DAO_CHECK(m_pDAOWorkspace->BeginTrans());
}

// Determine whether to use DAO 3.6, 3.5, or 3.0
// Use DAO 3.0 if DLL build and not built with MFC 4.21 or later
// Use DAO 3.6 if MFC 6.01 or later
// otherwise, DAO 3.5

#ifndef _AFXDLL
#if _MFC_VER >= 0x0601
#define _AfxDetermineDaoVersion()   (36)
#else
#define _AfxDetermineDaoVersion()   (35)
#endif
#else // dynamically because of DLL
static inline BYTE _AfxDetermineDaoVersion()
{
	BYTE bReturn = 35;

#ifdef _AFXDLL
	AFX_MODULE_STATE* pModuleState = AfxGetModuleState();
	if (pModuleState->m_dwVersion < 0x421)
		bReturn = 30;
	else if (pModuleState->m_dwVersion >= 0x0601)
		bReturn = 36;
#endif // _AFXDLL

	return bReturn;
}
#endif

void CDaoWorkspace::CommitTrans()
{
	ASSERT_VALID(this);
	ASSERT(IsOpen());
	ASSERT(m_pDAOWorkspace != NULL);

   BYTE bUseDao = _AfxDetermineDaoVersion();

	if (bUseDao == 35 || bUseDao == 36)
	{
		// Call DAO 3.5 or 3.6 method with no option set.
		// CommitTrans option parameter not yet supported.
		DAO_CHECK(m_pDAOWorkspace->CommitTrans(0));
	}
	else
	{
		// Call DAO 3.0 method
		// The DAO 3.0 version of CommitTrans takes no params
		// so cast CommitTrans to method that takes no params.
		HRESULT (STDMETHODCALLTYPE DAOWorkspace::*pMethod)() = (HRESULT (STDMETHODCALLTYPE DAOWorkspace::*)())m_pDAOWorkspace->CommitTrans;
		DAO_CHECK((m_pDAOWorkspace->*pMethod)());
	}
}

void CDaoWorkspace::Rollback()
{
	ASSERT_VALID(this);
	ASSERT(IsOpen());
	ASSERT(m_pDAOWorkspace != NULL);

	DAO_CHECK(m_pDAOWorkspace->Rollback());
}

//Implementation
void AFX_CDECL CDaoWorkspace::InitializeEngine()
{
	AfxDaoInit();
}

void CDaoWorkspace::InitWorkspacesCollection()
{
	ASSERT_VALID(this);

	_AFX_DAO_STATE* pDaoState = AfxGetDaoState();
	if (pDaoState->m_pDAODBEngine == NULL)
		InitializeEngine();

	DAO_CHECK(pDaoState->m_pDAODBEngine->get_Workspaces(
		&m_pDAOWorkspaces));
}

void CDaoWorkspace::FillWorkspaceInfo(DAOWorkspace* pDAOWorkspace,
	CDaoWorkspaceInfo& wsinfo, DWORD dwOptions)
{
	ASSERT_VALID(this);
	ASSERT(pDAOWorkspace != NULL);
	ASSERT(dwOptions != 0);

	COleVariant var;
	short nBool;

	if (dwOptions & AFX_DAO_FETCH_PRIMARY_PROPERTIES)
	{
		DAO_CHECK(pDAOWorkspace->get_Name(&V_BSTR(&var)));
		var.vt = VT_BSTR;
		wsinfo.m_strName = V_BSTRT(&var);
		var.Clear();
	}

	if (dwOptions & AFX_DAO_FETCH_SECONDARY_PROPERTIES)
	{
		DAO_CHECK(pDAOWorkspace->get_UserName(&V_BSTR(&var)));
		var.vt = VT_BSTR;
		wsinfo.m_strUserName = V_BSTRT(&var);