daocore.cpp

c语言编程软件vc6.0中文绿色版_vc6.0官方下载

{
	ASSERT_VALID(this);
	ASSERT(IsOpen() || m_bNew);
	ASSERT(m_pDAOTableDef != NULL);

	COleVariant var(lpszConnect, VT_BSTRT);
	DAO_CHECK(m_pDAOTableDef->put_Connect(V_BSTR(&var)));
}

CString CDaoTableDef::GetConnect()
{
	ASSERT_VALID(this);
	ASSERT(IsOpen());
	ASSERT(m_pDAOTableDef != NULL);

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

void CDaoTableDef::SetAttributes(long lAttributes)
{
	ASSERT_VALID(this);
	ASSERT(IsOpen() || m_bNew);
	ASSERT(m_pDAOTableDef != NULL);

	DAO_CHECK(m_pDAOTableDef->put_Attributes(lAttributes));
}

long CDaoTableDef::GetAttributes()
{
	ASSERT_VALID(this);
	ASSERT(IsOpen());
	ASSERT(m_pDAOTableDef != NULL);

	long lAttributes;
	DAO_CHECK(m_pDAOTableDef->get_Attributes(&lAttributes));
	return lAttributes;
}

COleDateTime CDaoTableDef::GetDateCreated()
{
	ASSERT_VALID(this);
	ASSERT(IsOpen());
	ASSERT(m_pDAOTableDef != NULL);

	COleVariant varDate;
	DAO_CHECK(m_pDAOTableDef->get_DateCreated(&varDate));
	return varDate.date;
}

COleDateTime CDaoTableDef::GetDateLastUpdated()
{
	ASSERT_VALID(this);
	ASSERT(IsOpen());
	ASSERT(m_pDAOTableDef != NULL);

	COleVariant varDate;
	DAO_CHECK(m_pDAOTableDef->get_LastUpdated(&varDate));
	return varDate.date;
}

void CDaoTableDef::SetValidationRule(
	LPCTSTR lpszValidationRule)
{
	ASSERT_VALID(this);
	ASSERT(IsOpen() || m_bNew);
	ASSERT(m_pDAOTableDef != NULL);

	COleVariant var(lpszValidationRule, VT_BSTRT);
	DAO_CHECK(m_pDAOTableDef->put_ValidationRule(
		V_BSTR(&var)));
}

CString CDaoTableDef::GetValidationRule()
{
	ASSERT_VALID(this);
	ASSERT(IsOpen());
	ASSERT(m_pDAOTableDef != NULL);

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

void CDaoTableDef::SetValidationText(
	LPCTSTR lpszValidationText)
{
	ASSERT_VALID(this);
	ASSERT(IsOpen() || m_bNew);
	ASSERT(m_pDAOTableDef != NULL);

	COleVariant var(lpszValidationText, VT_BSTRT);
	DAO_CHECK(m_pDAOTableDef->put_ValidationText(
		V_BSTR(&var)));
}

CString CDaoTableDef::GetValidationText()
{
	ASSERT_VALID(this);
	ASSERT(IsOpen());
	ASSERT(m_pDAOTableDef != NULL);

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

long CDaoTableDef::GetRecordCount()
{
	ASSERT_VALID(this);
	ASSERT(IsOpen());
	ASSERT(m_pDAOTableDef != NULL);

	long lRecordCount;
	DAO_CHECK(m_pDAOTableDef->get_RecordCount(&lRecordCount));
	return lRecordCount;
}

void CDaoTableDef::CreateField(LPCTSTR lpszName, short nType, long lSize,
	long lAttributes)
{
	ASSERT_VALID(this);

	CDaoFieldInfo fieldinfo;

	// Initialize everything so only correct properties will be set
	fieldinfo.m_strName = lpszName;
	fieldinfo.m_nType = nType;
	fieldinfo.m_lSize = lSize;
	fieldinfo.m_lAttributes = lAttributes;
	fieldinfo.m_nOrdinalPosition = 0;
	fieldinfo.m_bRequired = FALSE;
	fieldinfo.m_bAllowZeroLength = FALSE;
	fieldinfo.m_lCollatingOrder = 0;

	CreateField(fieldinfo);
}

void CDaoTableDef::CreateField(CDaoFieldInfo& fieldinfo)
{
	ASSERT_VALID(this);

	DAOField* pDAOField;

	// Create the DAO field object (setting basic properties)
	DAO_CHECK(m_pDAOTableDef->CreateField(
		COleVariant(fieldinfo.m_strName, VT_BSTRT),
		COleVariant(fieldinfo.m_nType),
		COleVariant(fieldinfo.m_lSize), &pDAOField));

	TRY
	{
		// Basic properties already set, so set the rest
		AfxSetFieldInfo(pDAOField, fieldinfo);

		// Append the field object to the fields collection
		if (m_pDAOFields == NULL)
			InitFieldsCollection();
		DAO_CHECK(m_pDAOFields->Append(pDAOField));
	}
	CATCH_ALL(e)
	{
		pDAOField->Release();
		THROW_LAST();
	}
	END_CATCH_ALL

	pDAOField->Release();
}

void CDaoTableDef::DeleteField(LPCTSTR lpszName)
{
	ASSERT_VALID(this);

	ASSERT(lpszName != NULL);

	if (m_pDAOFields == NULL)
		InitFieldsCollection();

	COleVariant var(lpszName, VT_BSTRT);
	DAO_CHECK(m_pDAOFields->Delete(V_BSTR(&var)));
}

void CDaoTableDef::DeleteField(int nIndex)
{
	ASSERT_VALID(this);

	CDaoFieldInfo fieldinfo;
	GetFieldInfo(nIndex, fieldinfo, AFX_DAO_PRIMARY_INFO);
	DeleteField((LPCTSTR)fieldinfo.m_strName);
}

void CDaoTableDef::CreateIndex(CDaoIndexInfo& indexinfo)
{
	ASSERT_VALID(this);

	DAOIndex* pDAOIndex;

	DAO_CHECK(m_pDAOTableDef->CreateIndex(
		COleVariant(indexinfo.m_strName, VT_BSTRT), &pDAOIndex));

	TRY
	{
		// Set the index info
		AfxSetIndexInfo(pDAOIndex, indexinfo);

		// Append the field object to the fields collection
		if (m_pDAOIndexes == NULL)
			InitIndexesCollection();
		DAO_CHECK(m_pDAOIndexes->Append(pDAOIndex));
	}
	CATCH_ALL(e)
	{
		pDAOIndex->Release();
		THROW_LAST();
	}
	END_CATCH_ALL

	pDAOIndex->Release();
}

void CDaoTableDef::DeleteIndex(LPCTSTR lpszName)
{
	ASSERT_VALID(this);
	ASSERT(lpszName != NULL);

	if (m_pDAOIndexes == NULL)
		InitIndexesCollection();

	COleVariant var(lpszName, VT_BSTRT);
	DAO_CHECK(m_pDAOIndexes->Delete(V_BSTR(&var)));
}

void CDaoTableDef::DeleteIndex(int nIndex)
{
	ASSERT_VALID(this);

	CDaoIndexInfo indexinfo;
	GetIndexInfo(nIndex, indexinfo, AFX_DAO_PRIMARY_INFO);
	DeleteIndex((LPCTSTR)indexinfo.m_strName);
}

short CDaoTableDef::GetFieldCount()
{
	ASSERT_VALID(this);

	short nFields;

	if (m_pDAOFields == NULL)
		InitFieldsCollection();

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

void CDaoTableDef::GetFieldInfo(int nIndex, CDaoFieldInfo& fieldinfo,
	DWORD dwInfoOptions)
{
	ASSERT_VALID(this);

	if (m_pDAOFields == NULL)
		InitFieldsCollection();

	// Get DAOField object and fill in field info struct
	DAOField* pDAOField;
	DAO_CHECK(m_pDAOFields->get_Item(
		COleVariant((long)nIndex), &pDAOField));
	AfxGetFieldInfo(pDAOField, fieldinfo, dwInfoOptions);

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

void CDaoTableDef::GetFieldInfo(LPCTSTR lpszName,
	CDaoFieldInfo& fieldinfo, DWORD dwInfoOptions)
{
	ASSERT_VALID(this);

	if (m_pDAOFields == NULL)
		InitFieldsCollection();

	// Get DAOField object and fill in field info struct
	DAOField* pDAOField;
	DAO_CHECK(m_pDAOFields->get_Item(
		COleVariant(lpszName, VT_BSTRT), &pDAOField));
	AfxGetFieldInfo(pDAOField, fieldinfo, dwInfoOptions);

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

short CDaoTableDef::GetIndexCount()
{
	ASSERT_VALID(this);

	short nIndexes;

	if (m_pDAOIndexes == NULL)
		InitIndexesCollection();

	DAO_CHECK(m_pDAOIndexes->get_Count(&nIndexes));
	return nIndexes;
}

void CDaoTableDef::GetIndexInfo(int nIndex, CDaoIndexInfo& indexinfo,
	DWORD dwInfoOptions)
{
	ASSERT_VALID(this);

	if (m_pDAOIndexes == NULL)
		InitIndexesCollection();

	// Get DAOField object and fill in field info struct
	DAOIndex* pDAOIndex;
	DAO_CHECK(m_pDAOIndexes->get_Item(
		COleVariant((long)nIndex), &pDAOIndex));
	AfxGetIndexInfo(pDAOIndex, indexinfo, dwInfoOptions);

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

void CDaoTableDef::GetIndexInfo(LPCTSTR lpszName,
	CDaoIndexInfo& indexinfo, DWORD dwInfoOptions)
{
	ASSERT_VALID(this);

	if (m_pDAOIndexes == NULL)
		InitIndexesCollection();

	// Get DAOField object and fill in field info struct
	DAOIndex* pDAOIndex;
	DAO_CHECK(m_pDAOIndexes->get_Item(
		COleVariant(lpszName, VT_BSTRT), &pDAOIndex));
	AfxGetIndexInfo(pDAOIndex, indexinfo, dwInfoOptions);

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

void CDaoTableDef::RefreshLink()
{
	ASSERT_VALID(this);
	ASSERT(IsOpen());
	ASSERT(m_pDAOTableDef != NULL);

	DAO_CHECK(m_pDAOTableDef->RefreshLink());
}

//Implementation functions
void CDaoTableDef::InitFieldsCollection()
{
	ASSERT_VALID(this);

	DAO_CHECK(m_pDAOTableDef->get_Fields(&m_pDAOFields));
}

void CDaoTableDef::InitIndexesCollection()
{
	ASSERT_VALID(this);

	DAO_CHECK(m_pDAOTableDef->get_Indexes(&m_pDAOIndexes));
}

void CDaoTableDef::ThrowDaoException(int nAfxDaoError)
{
	ASSERT_VALID(this);

	AfxThrowDaoException(nAfxDaoError);
}

#ifdef _DEBUG
void CDaoTableDef::AssertValid() const
{
	CObject::AssertValid();
}

void CDaoTableDef::Dump(CDumpContext& dc) const
{
	ASSERT_VALID(this);

	CObject::Dump(dc);

	dc << "m_bOpen = " << m_bOpen;
	dc << "\nm_bNew = " << m_bNew;

	dc << "\n";
}
#endif //_DEBUG

//////////////////////////////////////////////////////////////////////////
// CDaoQueryDef
IMPLEMENT_DYNAMIC(CDaoQueryDef, CObject)

CDaoQueryDef::CDaoQueryDef(CDaoDatabase* pDatabase)
{
	m_bOpen = FALSE;
	m_bNew = FALSE;

	m_pDatabase = pDatabase;
	m_pDAOQueryDef = NULL;
	m_pDAOParameters = NULL;
	m_pDAOFields = NULL;
}

CDaoQueryDef::~CDaoQueryDef()
{
	if (IsOpen())
		Close();
	else if (m_bNew)
	{
		// Remove the querydef from the CDaoDatabase's map
		m_pDatabase->m_mapQueryDefs.RemoveKey(this);
	}
}

void CDaoQueryDef::Create(LPCTSTR lpszName, LPCTSTR lpszSQL)
{
	ASSERT_VALID(this);
	ASSERT(!IsOpen());

	// Create a temp querydef if lpszName is NULL or empty string
	if (lpszName == NULL || *lpszName == '\0')
	{
		DAO_CHECK(m_pDatabase->m_pDAODatabase->CreateQueryDef(
			COleVariant(_T(""), VT_BSTRT),
			COleVariant(lpszSQL, VT_BSTRT),
			&m_pDAOQueryDef));
		m_bOpen = TRUE;
	}
	else
	{
		// Create a template querydef
		// (preventing automatic append to QueryDefs collection)
		DAO_CHECK(m_pDatabase->m_pDAODatabase->CreateQueryDef(
			_afxOptionalVariant, _afxOptionalVariant, &m_pDAOQueryDef));
		m_bNew = TRUE;

		// Now set the name and SQL if necessary
		SetName(lpszName);
		if (lpszSQL != NULL)
			SetSQL(lpszSQL);
	}

	// Add the querydef to map of Open/New CDaoQueryDefs
	m_pDatabase->m_mapQueryDefs.SetAt(this, this);
}

void CDaoQueryDef::Append()
{
	ASSERT_VALID(this);
	ASSERT(m_bNew);
	ASSERT(m_pDAOQueryDef != NULL);

	DAOQueryDefs* pDAOQueryDefs;
	DAO_CHECK(m_pDatabase->m_pDAODatabase->get_QueryDefs(
		&pDAOQueryDefs));

	TRY
	{
		DAO_CHECK(pDAOQueryDefs->Append(m_pDAOQueryDef));
	}
	CATCH_ALL(e)
	{
		pDAOQueryDefs->Release();
		THROW_LAST();
	}
	END_CATCH_ALL

	pDAOQueryDefs->Release();

	m_bNew = FALSE;
	m_bOpen = TRUE;
}

// Open a pre-defined query or create a temp query
void CDaoQueryDef::Open(LPCTSTR lpszName)
{
	ASSERT_VALID(this);
	ASSERT(!m_bNew);

	// Re-open is not allowed
	if (IsOpen())
	{
		ASSERT(FALSE);
		return;
	}

	// Null lpszName implies create a temp query
	if (lpszName == NULL)
	{
		DAO_CHECK(m_pDatabase->m_pDAODatabase->CreateQueryDef(
			COleVariant(_T(""), VT_BSTRT), _afxOptionalVariant, &m_pDAOQueryDef));
	}
	else
	{
		COleVariant varName(lpszName, VT_BSTRT);
		DAO_CHECK(m_pDatabase->m_pDAODatabase->OpenQueryDef(
			V_BSTR(&varName), &m_pDAOQueryDef));
	}

	m_bOpen = TRUE;

	// Add the querydef to map of Open/New CDaoQueryDefs
	m_pDatabase->m_mapQueryDefs.SetAt(this, this);
}

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

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

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

	if (m_pDAOQueryDef != NULL)
	{
		// DAO Close is a no op, but call it anyway
		DAO_TRACE(m_pDAOQueryDef->Close());
		m_pDAOQueryDef->Release();
		m_pDAOQueryDef = NULL;
	}

	m_bOpen = FALSE;
	m_bNew = FALSE;

	// Remove the querydef from the CDaoDatabase's map
	m_pDatabase->m_mapQueryDefs.RemoveKey(this);
}

BOOL CDaoQueryDef::CanUpdate()
{
	ASSERT_VALID(this);
	ASSERT(IsOpen());

	short nUpdatable;
	DAO_CHECK(m_pDAOQueryDef->get_Updatable(&nUpdatable));
	return nU