myrecordset.cpp

魔域的服务端源代码。Visual C++编译的版本

{	m_bEdit = true;
	if (! m_bIsOpen ) return;
	m_nEditMode = modeAddNew;
}

///////////////////////////////////////////////////////////////////////
void CMyRecordset::Delete()
{	m_bEdit = true;
	if (! m_bIsOpen ) return;
	m_nEditMode = modeDelete;
}

///////////////////////////////////////////////////////////////////////
// 数据集游标移动
void CMyRecordset::MoveFirst()
{	
	if(m_bEdit)
		::OutputDebugString("*DATABASE* warning: MoveFirst() in edit state.");

	m_bEdit = false;				//★ 有没有先存盘呀？下同
	if (! m_bIsOpen ) return;
	if (!m_bBOF) 
	{	m_ulCursor = 0;
		m_bBOF = true;
		assert( m_bIsOpen );
		mysql_data_seek(m_Recordset,0);
		m_Row=mysql_fetch_row( m_Recordset );
		GetAllField();
	}
	m_bEOF = false;		//paled - 数据库必须至少有一行数据，下同
}

///////////////////////////////////////////////////////////////////////
void CMyRecordset::MovePrev()
{
	if(m_bEdit)
		::OutputDebugString("*DATABASE* warning: MovePrev() in edit state.");

	m_bEdit = false;
	if (! m_bIsOpen ) return;
	m_bEOF=false;
	if (m_ulCursor > 0)
	{	m_ulCursor -- ;
		mysql_data_seek(m_Recordset,m_ulCursor);
		m_Row=mysql_fetch_row( m_Recordset );
		GetAllField();
	}
	else 
		m_bBOF = true;
}

///////////////////////////////////////////////////////////////////////
void CMyRecordset::MoveLast()
{	
	if(m_bEdit)
		::OutputDebugString("*DATABASE* warning: MoveLast() in edit state.");

	m_bEdit = false;
	if (! m_bIsOpen ) return;
	if (!m_bEOF)
	{	m_ulCursor = m_ulRowsCount-1;
		mysql_data_seek(m_Recordset,m_ulCursor);
		m_Row=mysql_fetch_row( m_Recordset );
		GetAllField();
		m_bBOF = false;
		m_bEOF = true;
	}
}

///////////////////////////////////////////////////////////////////////
void CMyRecordset::Move(ULONG ulIndex)
{	
	if(m_bEdit)
		::OutputDebugString("*DATABASE* warning: Move() in edit state.");

	m_bEdit = false;
	if (! m_bIsOpen ) return;
	if (ulIndex < m_ulRowsCount ) 
	{	mysql_data_seek(m_Recordset,ulIndex);
		m_ulCursor = ulIndex;
		m_Row=mysql_fetch_row( m_Recordset );
		GetAllField();
	}

	m_bBOF = (m_ulCursor == 0);
	m_bEOF = (m_ulCursor == m_ulRowsCount-1);
}


///////////////////////////////////////////////////////////////////////
// SQL
bool CMyRecordset::Query(char * strSQL, MYSQL_RES * * res)
{
	if (!CMyDatabase::CheckSQL(strSQL))
		return false;

	try {
		if (!m_bIsOpen) return false;

		time_t	tStart = clock();
#ifdef	NO_MUTEX
		if(true)
#else
		if (WAIT_OBJECT_0 ==::WaitForSingleObject(m_pMyDatabase->m_hDbMutex, _MAX_DBACCESSTIME))
#endif
		{
			CTimeCostChk chk("CMyRecordset::Query", 1000);

			MYSQL * hdbc = m_pMyDatabase->m_hdbc;
			if (mysql_query(hdbc, strSQL)!=NULL)
			{	
				LOCKADD_TIMESUM;
				//error
				RELEASE_MUTEX(m_pMyDatabase->m_hDbMutex);

				// log error sql
				::MsgLogSave("gmlog/DbError", "%s", strSQL);
				return false;
			}
			else 
			{	
				LOCKADD_TIMESUM;
				*res=mysql_store_result(hdbc);			//paled - 当仅有INSERT、DELETE、UPDATE等查询时，可使用 mysql_affected_rows() 检查是否成功
				if (*res == NULL)
				{	
					if (mysql_field_count(hdbc) >0 )
					{
						//error
						RELEASE_MUTEX(m_pMyDatabase->m_hDbMutex);
						return false;
					}
					else 
					{
						RELEASE_MUTEX(m_pMyDatabase->m_hDbMutex);
						return true;		
					}
				}
				else
				{
					RELEASE_MUTEX(m_pMyDatabase->m_hDbMutex);
					return true;
				}
			}
		}
		else
		{
			::LogSave("*DATABASE* WARNING: Qurey() overtime");
			return false;
		}
	}
	catch(...)
	{
		char szMsg[1024];
		sprintf(szMsg, "Mysql Query error: %s", strSQL);
		::OutputDebugString(szMsg);

		return false;
	}
}

// 基本属性
///////////////////////////////////////////////////////////////////////
bool CMyRecordset::IsBOF()
{	return m_bBOF;
}

///////////////////////////////////////////////////////////////////////
bool CMyRecordset::IsEOF()
{	return m_bEOF;
}

///////////////////////////////////////////////////////////////////////
bool CMyRecordset::IsOpen()
{
	//assert(this);
	return (m_bIsOpen);
}

///////////////////////////////////////////////////////////////////////
int CMyRecordset::FieldsCount()
{
	if (m_bIsOpen)
		return m_uiFieldsCount;
	else 
		return -1;

}

///////////////////////////////////////////////////////////////////////
bool CMyRecordset::CanUpdate() const     // Can Edit/AddNew/Delete be called?
{	
	if (!m_bIsOpen ) return false; 
	return m_bCanUpdate; 
}

///////////////////////////////////////////////////////////////////////
// 
CMyField CMyRecordset::Fields(UINT uiIndex)
{	
	if (uiIndex >= m_uiFieldsCount) 
	{
		::LogSave("*DATABASE* ERROR: Illegal Fields() parameter[%u].", uiIndex);
		uiIndex=0;			//★ 0号对象是非法对象么?
	}
	
	if (m_bEdit)
	{	m_pbDirty[uiIndex] = true;
		CMyField MyField = m_objFields[uiIndex];
		MyField.m_pMyField = &m_objFields[uiIndex];	//paled
		MyField.m_nIndex = uiIndex;
		MyField.m_szVal = m_objFields[uiIndex].m_szVal;
		return MyField;				//★ BUG: 没有初始化 m_Field 成员变量。没有初始化数值类成员变量
	}

//@	m_pbDirty[uiIndex] = false;
	GetFieldValue(uiIndex);
	return m_objFields[uiIndex];
}

///////////////////////////////////////////////////////////////////////
CMyField CMyRecordset::Fields(char * szField)
{
	int nIndex = -1 ;
	for (UINT i=0; i < m_uiFieldsCount; i++)
	{	
		if ( stricmp(szField, m_Fields[i].name) == 0)
		{	
			nIndex = i;
			break;
		}
	}

	if (nIndex != -1)	
		return Fields(nIndex);
	else 
	{
		::LogSave("Error: field %s not found in CMyRecordset::Fields", szField);
		return Fields((unsigned int)0);
	}
}

///////////////////////////////////////////////////////////////////////
void CMyRecordset::ClsEditFlag()
{
	for ( int i=0; i<(int)m_uiFieldsCount; i++ )
		m_pbDirty[i] = false;
}

///////////////////////////////////////////////////////////////////////
int CMyRecordset::UpdateFieldsCount()
{
	int nCount	=0;
	for ( int i=0; i<(int)m_uiFieldsCount; i++ )
	{
		if (m_pbDirty[i])
			nCount++;
	}

	return nCount;
}

///////////////////////////////////////////////////////////////////////
bool CMyRecordset::AddField(LPCTSTR szField, int nData)
{	
	sprintf(m_szUpdateSQL, "UPDATE %s SET %s=%s+%d WHERE %s=%s LIMIT 1", 
				m_szTableName, szField, szField, nData, m_szKey, m_Row[m_uiKeyIndex]);

	MYSQL_RES * res;
	bool ret = Query(m_szUpdateSQL, &res);
	if(ret && res)
		mysql_free_result(res);
	return	ret;
}

///////////////////////////////////////////////////////////////////////
// recordset
///////////////////////////////////////////////////////////////////////
UINT CMyRecordset::RecordCount()		// return -1: error
{
	if (!m_bIsOpen)  return -1;
	return (UINT)m_ulRowsCount;
}

///////////////////////////////////////////////////////////////////////
bool CMyRecordset::MoveNext()
{
	m_bEdit = false;
	if(! m_bIsOpen )
		return false;

	if ( m_ulCursor < m_ulRowsCount-1 )
	{
		m_bBOF = false;

		m_ulCursor ++ ;
		m_Row=mysql_fetch_row( m_Recordset );			//paled - 不必调用 mysql_data_seek()
		GetAllField();

		return true;
	}
	else 
	{
		m_bEOF = true;
		return false;
	}

}

///////////////////////////////////////////////////////////////////////
// record
///////////////////////////////////////////////////////////////////////
IRecord* CMyRecordset::CreateNewRecord(DWORD idNewKey /*= NEWKEY_NONE*/) 
{
	CMyRecord* pRecord = CMyRecord::CreateNew(m_pMyDatabase);		//VVVVVVVVVVVVVV
	if(pRecord)
	{
		if(pRecord->Open(this, idNewKey))
			return (IRecord*)pRecord;

		delete pRecord;
	}

	return NULL;
}

///////////////////////////////////////////////////////////////////////
IRecord* CMyRecordset::CreateNewConstRecord(DWORD idNewKey /*= NEWKEY_NONE*/) 
{
	CMyConstRecord* pRecord = CMyConstRecord::CreateNew(m_pMyDatabase);		//VVVVVVVVVVVVVV
	if(pRecord)
	{
		if(pRecord->Open(this, idNewKey))
			return (IRecord*)pRecord;

		delete pRecord;
	}

	return NULL;
}

///////////////////////////////////////////////////////////////////////
DWORD CMyRecordset::InsertRecord()
{
	if (!m_bIsOpen || !m_bCanUpdate)
		return false;

	m_bEdit		= false;
	m_nEditMode	= modeAddNew;

	bool ret	=true;
	if (this->UpdateFieldsCount() > 0)
	{
		// build sql
		this->BuildUpdateSQL();

		// need change the local row;
		MYSQL_RES * res;
		ret = Query(m_szUpdateSQL, &res);
		if(ret && res)
			mysql_free_result(res);
	}

	// clear edit flag
	this->ClsEditFlag();

	if(ret)
		return m_pMyDatabase->GetInsertId();
	else
		return 0;
}

///////////////////////////////////////////////////////////////////////
bool CMyRecordset::UpdateRecord()
{
	if (!m_bIsOpen || !m_bCanUpdate)
		return false;

	m_bEdit		= false;
	m_nEditMode	= modeEdit;

	bool ret	=true;
	if (this->UpdateFieldsCount() > 0)
	{
		// build sql
		this->BuildUpdateSQL();

		// need change the local row;
		MYSQL_RES * res;
		ret = Query(m_szUpdateSQL, &res);
		if(ret && res)
			mysql_free_result(res);
	}

	// clear edit flag
	this->ClsEditFlag();

	return	ret;
}

///////////////////////////////////////////////////////////////////////
bool CMyRecordset::DeleteRecord()
{
	if (!m_bIsOpen || !m_bCanUpdate)
		return false;

	m_bEdit		= false;
	m_nEditMode	= modeDelete;

	bool ret	=true;

	// build sql
	this->BuildUpdateSQL();

	// need change the local row;
	MYSQL_RES * res;
	ret = Query(m_szUpdateSQL, &res);
	if(ret && res)
		mysql_free_result(res);

	// clear edit flag
	this->ClsEditFlag();

	return	ret;
}

///////////////////////////////////////////////////////////////////////
// new interface
///////////////////////////////////////////////////////////////////////
int CMyRecordset::LoadInt		(LPCTSTR szField)
{
	IF_NOT(szField)
		return INT_NONE;

	for (UINT i=0; i < m_uiFieldsCount; i++)
	{	
		if (stricmp(szField, m_Fields[i].name) == 0)
		{
			return GetInt(i);
		}
	}

	return INT_NONE;
}

///////////////////////////////////////////////////////////////////////
void CMyRecordset::SetInt		(LPCTSTR szField, int nData)
{
	IF_NOT(szField)
		return;

	for (UINT i=0; i < m_uiFieldsCount; i++)
	{	
		if (stricmp(szField, m_Fields[i].name) == 0)
		{
			SetInt(i, nData);
			return;
		}
	}
}

///////////////////////////////////////////////////////////////////////
void CMyRecordset::LoadString	(char* szData, LPCTSTR szField, int nSize)	
{
	IF_NOT(szField && szData)
		return;

	for (UINT i=0; i < m_uiFieldsCount; i++)
	{	
		if (stricmp(szField, m_Fields[i].name) == 0)
		{
			SafeCopy(szData, GetStr(i), nSize);
			return;
		}
	}
}

///////////////////////////////////////////////////////////////////////
void CMyRecordset::SetString	(LPCTSTR szField, LPCTSTR szData, int nSize)
{
	IF_NOT(szField && szData)
		return;

	for (UINT i=0; i < m_uiFieldsCount; i++)
	{	
		if (stricmp(szField, m_Fields[i].name) == 0)
		{
			SetStr(i, szData, nSize);
			return;
		}
	}
}

///////////////////////////////////////////////////////////////////////
int CMyRecordset::GetInt		(int idx)							
{
	IF_NOT(idx>=0 && idx<(int)m_uiFieldsCount) 
		return INT_NONE;

	if (!m_objFields[idx].m_szVal)			// 非串类型
		return m_objFields[idx].m_iVal;
	else 
		return INT_NONE; 
}

///////////////////////////////////////////////////////////////////////
LPCTSTR CMyRecordset::GetStr		(int idx)							
{
	IF_NOT(idx>=0 && idx<(int)m_uiFieldsCount) 
		return STR_NONE;

	if (m_objFields[idx].m_szVal)			// 串类型
		return (m_objFields[idx].m_szVal);
	else 
		return STR_NONE;
}

///////////////////////////////////////////////////////////////////////
void CMyRecordset::SetInt		(int idx, int nData)				
{
	IF_NOT(idx>=0 && idx<(int)m_uiFieldsCount) 
		return;

	m_pbDirty[idx] = true;
	if (!m_objFields[idx].m_szVal)			// 非串类型
		m_objFields[idx].m_iVal = nData;

	return;
}

///////////////////////////////////////////////////////////////////////
void CMyRecordset::SetStr		(int idx, LPCTSTR szData, int nSize)
{
	IF_NOT(idx>=0 && idx<(int)m_uiFieldsCount) 
		return;
	IF_NOT(nSize <= (int)m_Fields[idx].length+1)
		return;

	m_pbDirty[idx] = true;
	if (m_objFields[idx].m_szVal)			// 串类型
		SafeCopy(m_objFields[idx].m_szVal, szData, nSize);

	return;
}