adorecordset.cpp

这是一个学校管理系统

	_variant_t vt;
	vt.vt = VT_CY;
	vt.cyVal = value.m_cur;
	return PutCollect(index, vt);
}

BOOL CAdoRecordSet::PutCollect(LPCTSTR strFieldName, const COleCurrency &value)
{
	ASSERT(m_pRecordset != NULL);
	#ifdef _DEBUG
	if (GetFieldType(strFieldName) != adCurrency){
		m_errormessage.Format(_T("Warning: 你要存贮的字段与变量的数据类型不符; 文件: %s; 行: %d\n"), __FILE__, __LINE__);
		AfxMessageBox(m_errormessage);
	}
	#endif

	if (value.m_status == COleCurrency::invalid) return FALSE;

	_variant_t vt;
	vt.vt = VT_CY;
	vt.cyVal = value.m_cur;
	return PutCollect(strFieldName, vt);
}

BOOL CAdoRecordSet::PutCollect(long index, const CString &value)
{
	ASSERT(m_pRecordset != NULL);
	#ifdef _DEBUG
	if (! (GetFieldType(index) == adVarChar
		|| GetFieldType(index) == adChar
		|| GetFieldType(index) == adLongVarChar
		|| GetFieldType(index) == adVarWChar
		|| GetFieldType(index) == adWChar
		|| GetFieldType(index) == adLongVarWChar)){
			m_errormessage.Format(_T("Warning: 你要存贮的字段与变量的数据类型不符; 文件: %s; 行: %d\n"), __FILE__, __LINE__);
			AfxMessageBox(m_errormessage);
		}
	#endif

	_variant_t vt;
	vt.vt = value.IsEmpty() ? VT_NULL : VT_BSTR;
	vt.bstrVal = value.AllocSysString();
	return PutCollect(index, vt);
}

BOOL CAdoRecordSet::PutCollect(LPCTSTR strFieldName, const CString &value)
{
	ASSERT(m_pRecordset != NULL);
	#ifdef _DEBUG
	if (! (GetFieldType(strFieldName) == adVarChar
		|| GetFieldType(strFieldName) == adChar
		|| GetFieldType(strFieldName) == adLongVarChar
		|| GetFieldType(strFieldName) == adVarWChar
		|| GetFieldType(strFieldName) == adWChar
		|| GetFieldType(strFieldName) == adLongVarWChar)){
			m_errormessage.Format(_T("Warning: 你要存贮的字段与变量的数据类型不符; 文件: %s; 行: %d\n"), __FILE__, __LINE__);
			AfxMessageBox(m_errormessage);
		}
	#endif

	_variant_t vt;
	vt.vt = value.IsEmpty() ? VT_NULL : VT_BSTR;
	vt.bstrVal = value.AllocSysString();
	return PutCollect(strFieldName, vt);
}


/*------------------------------------------------
							    读取字段的值
			  ------------------------------------------------*/
BOOL CAdoRecordSet::GetCollect(long index, COleDateTime &value)
{
	ASSERT(m_pRecordset != NULL);
	
	try
	{
		value = vartodate(m_pRecordset->GetCollect(_variant_t(index)));
		return TRUE;
	}
	catch (_com_error e)
	{
		value.SetStatus(COleDateTime::null);
		return FALSE;
	}
}

BOOL CAdoRecordSet::GetCollect(LPCTSTR strFieldName, COleDateTime &value)
{
	ASSERT(m_pRecordset != NULL);
	
	try
	{
		value = vartodate(m_pRecordset->GetCollect(_variant_t(strFieldName)));
		return TRUE;
	}
	catch (_com_error e)
	{
		value.SetStatus(COleDateTime::null);
		return FALSE;
	}
}

BOOL CAdoRecordSet::GetCollect(long index, COleCurrency &value)
{
	ASSERT(m_pRecordset != NULL);

	try
	{
		value = vartocy(m_pRecordset->GetCollect(_variant_t(index)));
		return TRUE;
	}
	catch (_com_error e)
	{
		value.m_status = COleCurrency::null;
		return FALSE;
	}
}

BOOL CAdoRecordSet::GetCollect(LPCTSTR strFieldName, COleCurrency &value)
{
	ASSERT(m_pRecordset != NULL);

	try
	{
		value = vartocy(m_pRecordset->GetCollect(_variant_t(strFieldName)));
		return TRUE;
	}
	catch (_com_error e)
	{
		value.m_status = COleCurrency::null;
		return FALSE;
	}
}

BOOL CAdoRecordSet::GetCollect(long index,  bool &value)
{
	ASSERT(m_pRecordset != NULL);

	try
	{
		value = vartobool(m_pRecordset->GetCollect(_variant_t(index)));
		return TRUE;
	}
	catch (_com_error e)
	{
		value = false;
		return FALSE;
	} 	
}

BOOL CAdoRecordSet::GetCollect(LPCSTR strFieldName,  bool &value)
{
	ASSERT(m_pRecordset != NULL);

	try
	{
		value = vartobool(m_pRecordset->GetCollect(_variant_t(strFieldName)));
		return TRUE;
	}
	catch (_com_error e)
	{
		value = false;
		return FALSE;
	} 	
}


BOOL CAdoRecordSet::GetCollect(long index,  BYTE &value)
{
	ASSERT(m_pRecordset != NULL);

	try
	{
		value = vartoby(m_pRecordset->GetCollect(_variant_t(index)));
		return TRUE;
	}
	catch (_com_error e)
	{
		value = 0;
		return FALSE;
	} 	
}

BOOL CAdoRecordSet::GetCollect(LPCSTR strFieldName,  BYTE &value)
{
	ASSERT(m_pRecordset != NULL);

	try
	{
		value = vartoby(m_pRecordset->GetCollect(_variant_t(strFieldName)));
		return TRUE;
	}
	catch (_com_error e)
	{
		value = 0;
		return FALSE;
	} 	
}

BOOL CAdoRecordSet::GetCollect(long index,  short &value)
{
	ASSERT(m_pRecordset != NULL);

	try
	{
		value = vartoi(m_pRecordset->GetCollect(_variant_t(index)));
		return TRUE;
	}
	catch (_com_error e)
	{
		value = 0;
		return FALSE;
	} 	
}

BOOL CAdoRecordSet::GetCollect(LPCSTR strFieldName,  short &value)
{
	ASSERT(m_pRecordset != NULL);

	try
	{
		value = vartoi(m_pRecordset->GetCollect(_variant_t(strFieldName)));
		return TRUE;
	}
	catch (_com_error e)
	{
		value = 0;
		return FALSE;
	} 	
}

BOOL CAdoRecordSet::GetCollect(long index,  int &value)
{
	ASSERT(m_pRecordset != NULL);

	try
	{
		value = (int)vartol(m_pRecordset->GetCollect(_variant_t(index)));
		return TRUE;
	}
	catch (_com_error e)
	{
		value = 0;
		return FALSE;
	} 	
	return FALSE;
}

BOOL CAdoRecordSet::GetCollect(LPCSTR strFieldName,  int &value)
{
	ASSERT(m_pRecordset != NULL);

	try
	{
		value = (int)vartol(m_pRecordset->GetCollect(_variant_t(strFieldName)));
		return TRUE;
	}
	catch (_com_error e)
	{
		value = 0;
		return FALSE;
	} 	
}

BOOL CAdoRecordSet::GetCollect(long index,  long &value)
{
	ASSERT(m_pRecordset != NULL);

	try
	{
		value = vartol(m_pRecordset->GetCollect(_variant_t(index)));
		return TRUE;
	}
	catch (_com_error e)
	{
		value = 0;
		return FALSE;
	} 	
}

BOOL CAdoRecordSet::GetCollect(LPCSTR strFieldName,  long &value)
{
	ASSERT(m_pRecordset != NULL);

	try
	{
		value = vartol(m_pRecordset->GetCollect(_variant_t(strFieldName)));
		return TRUE;
	}
	catch (_com_error e)
	{
		value = 0;
		return FALSE;
	} 	
	return FALSE;
}

BOOL CAdoRecordSet::GetCollect(long index,  DWORD &value)
{
	ASSERT(m_pRecordset != NULL);

	try
	{
		_variant_t result = m_pRecordset->GetCollect(_variant_t(index));
		switch (result.vt)
		{
		case VT_UI4:
		case VT_I4:
			value = result.ulVal;
			break;
		case VT_NULL:
		case VT_EMPTY:
			value = 0;
			break;
		default:{
			m_errormessage.Format(_T("Warning: 无法读取相应的字段, 数据类型不匹配; 文件: %s; 行: %d\n"), __FILE__, __LINE__);
			AfxMessageBox(m_errormessage);
			return FALSE;
				}
		}		
		return TRUE;
	}
	catch (_com_error e)
	{
		value = 0;
		return FALSE;
	} 	
}

BOOL CAdoRecordSet::GetCollect(LPCSTR strFieldName,  DWORD &value)
{
	ASSERT(m_pRecordset != NULL);

	try
	{
		_variant_t result = m_pRecordset->GetCollect(_variant_t(strFieldName));
		switch (result.vt)
		{
		case VT_UI4:
		case VT_I4:
			value = result.ulVal;
			break;
		case VT_NULL:
		case VT_EMPTY:
			value = 0;
			break;
		default:{
			m_errormessage.Format(_T("Warning: 无法读取相应的字段, 数据类型不匹配; 文件: %s; 行: %d\n"), __FILE__, __LINE__);
			AfxMessageBox(m_errormessage);
			return FALSE;
				}
		}		
		return TRUE;
	}
	catch (_com_error e)
	{
		value = 0;
		return FALSE;
	} 	
}

BOOL CAdoRecordSet::GetCollect(long index,  float &value)
{
	ASSERT(m_pRecordset != NULL);

	try
	{
		_variant_t result = m_pRecordset->GetCollect(_variant_t(index));
		switch (result.vt)
		{
		case VT_R4:
			value = result.fltVal;
			break;
		case VT_UI1:
		case VT_I1:
			value = result.bVal;
			break;
		case VT_UI2:
		case VT_I2:
			value = result.iVal;
			break;
		case VT_NULL:
		case VT_EMPTY:
			value = 0;
			break;
		default:{
			m_errormessage.Format(_T("Warning: 无法读取相应的字段, 数据类型不匹配; 文件: %s; 行: %d\n"), __FILE__, __LINE__);
			AfxMessageBox(m_errormessage);
			return FALSE;
				}
		}		
		return TRUE;
	}
	catch (_com_error e)
	{
		value = 0;
		return FALSE;
	} 	
}