hopekingrecordset.cpp

一个多线程

// HopeKingRecordset.cpp : implementation file
//

#include "stdafx.h"
#include "HopeKingRecordset.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CHopeKingRecordset

IMPLEMENT_DYNAMIC(CHopeKingRecordset, CRecordset)

CHopeKingRecordset::CHopeKingRecordset(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CHopeKingRecordset)
	//}}AFX_FIELD_INIT
	m_nDefaultType = snapshot;
	m_pDefaultColum=NULL;
	m_pParam=NULL;
	m_Ret.SetFieldType(3);
	m_Ret.SetType(9);
	m_iCmdType=0;//0:predefine procedure
				//1:t-sql clause
	m_iPreDefColNum=-1;
	m_bHasRet=FALSE;
	m_iParamNum=0;
	m_iMaxDefaultColumns=0;
	m_iMaxDefaultParam=0;
}

CString CHopeKingRecordset::GetDefaultConnect()
{
	return _T("ODBC;DSN=");
}

CString CHopeKingRecordset::GetDefaultSQL()
{
	return _T("");
}

BOOL CHopeKingRecordset::SetFileExchange(CFieldExchange* pFX,COdbcData & Data,BOOL bSet)
{
	try{
		if(bSet){
			switch(Data.m_iFieldType){
			case 0:
				pFX->SetFieldType(CFieldExchange::outputColumn);
				break;
			case 1:
				pFX->SetFieldType(CFieldExchange::inputParam);
				break;
			case 2:
				pFX->SetFieldType(CFieldExchange::param);
				break;
			case 3:
				pFX->SetFieldType(CFieldExchange::outputParam);
				break;
			case 4:
				pFX->SetFieldType(CFieldExchange::inoutParam);
				break;
			default:
				return FALSE;
			}
		}
		switch(Data.m_iType){
		case 0:
			if(!Data.m_szName)
				RFX_Text(pFX, _T(""), *Data.m_Data.m_pString);
			else
				RFX_Text(pFX, Data.m_szName, *Data.m_Data.m_pString);
			break;
		case 1:
			if(!Data.m_szName)
				RFX_Byte(pFX, _T(""), *Data.m_Data.m_pByte);
			else
				RFX_Byte(pFX, Data.m_szName, *Data.m_Data.m_pByte);
			break;
		case 2:
			if(!Data.m_szName)
				RFX_Int(pFX, _T(""), *Data.m_Data.m_pInt);
			else
				RFX_Int(pFX, Data.m_szName, *Data.m_Data.m_pInt);
			break;
		case 3:
			if(!Data.m_szName)
				RFX_Single(pFX, _T(""), *Data.m_Data.m_pFloat);
			else
				RFX_Single(pFX, Data.m_szName, *Data.m_Data.m_pFloat);
			break;
		case 4:
			if(!Data.m_szName)
				RFX_Double(pFX, Data.m_szName, *Data.m_Data.m_pDouble);
			else
				RFX_Double(pFX, Data.m_szName, *Data.m_Data.m_pDouble);
			break;
		case 5:
			if(!Data.m_szName)
				RFX_Date(pFX, Data.m_szName, *Data.m_Data.m_pTime);
			else
				RFX_Date(pFX, Data.m_szName, *Data.m_Data.m_pTime);
			break;
		case 6:
			if(!Data.m_szName)
				RFX_Binary(pFX, _T(""), *Data.m_Data.m_pByteArray);
			else
				RFX_Binary(pFX, Data.m_szName, *Data.m_Data.m_pByteArray);
			break;
		case 7:
			if(!Data.m_szName)
				RFX_LongBinary(pFX, _T(""), *Data.m_Data.m_pLongBinary);
			else
				RFX_LongBinary(pFX, Data.m_szName, *Data.m_Data.m_pLongBinary);
			break;
		case 8:
			if(!Data.m_szName)
				RFX_Bool(pFX, _T(""), *Data.m_Data.m_pBool);
			else
				RFX_Bool(pFX, Data.m_szName, *Data.m_Data.m_pBool);
			break;
		case 9:
			if(!Data.m_szName)
				RFX_Long(pFX, _T(""), *Data.m_Data.m_pLong);
			else
				RFX_Long(pFX, Data.m_szName, *Data.m_Data.m_pLong);
			break;
		default:
			return FALSE;
		}
		return TRUE;
	}
	catch(...){
		return FALSE;
	}
}

void CHopeKingRecordset::PreBindFields()
{
	// called before data fields are bound
	if(m_nResultCols>0){
		if(m_iPreDefColNum>=0){
			if(m_nFields==0){
				m_nFields=m_nResultCols;
				m_iPreDefColNum=m_nResultCols;
				AllocStatusArrays();
			}
			else{
				if(m_iPreDefColNum>m_nResultCols){
					m_nFields=m_nResultCols;
					m_iPreDefColNum=m_nResultCols;
					AllocStatusArrays();
				}
			}
		}
	}
}

void CHopeKingRecordset::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CHopeKingRecordset)
	//}}AFX_FIELD_MAP
	if(m_nResultCols>0&&m_iPreDefColNum>0){
		try{
			int i;
			if(!m_pDefaultColum||m_iMaxDefaultColumns<m_iPreDefColNum){
				if(m_pDefaultColum)
					delete [] m_pDefaultColum;
				m_iMaxDefaultColumns=m_iPreDefColNum+10;
				m_pDefaultColum=new COdbcData[m_iMaxDefaultColumns];
				for(i=0;i<m_iMaxDefaultColumns;i++){
					m_pDefaultColum[i].SetType(0);//string
				}
			}
			pFX->SetFieldType(CFieldExchange::outputColumn);
			for(i=0;i<m_iPreDefColNum;i++){
				SetFileExchange(pFX,m_pDefaultColum[i]);
			}
		}
		catch(...){
		}
	}
	if(m_nResultCols<=0){
		if(m_bHasRet){
			pFX->SetFieldType(CFieldExchange::outputParam);
			SetFileExchange(pFX,m_Ret);
		}
		if(m_iParamNum){
			try{
				for(int i=0;i<m_iParamNum;i++){
					SetFileExchange(pFX,m_pParam[i],TRUE);
				}
			}
			catch(...){
			}
		}
	}
}

BOOL CHopeKingRecordset::ExcuteSql(LPCTSTR lpszSql,int iCmdType)
{
	m_iCmdType=iCmdType;
	m_bHasRet=FALSE;
	CString szSql="";
	DWORD dwOpenType=CRecordset::forwardOnly;
	DWORD dwOption=CRecordset::executeDirect;
	m_nParams=0;
	switch(iCmdType){
	case 0:
		//?=call xxx ?,?,...
		szSql.Format("?=call %s",lpszSql);
		if(m_iParamNum){
			szSql+=" ?";
			for(int i=1;i<m_iParamNum;i++){
				szSql+=",?";
			}
		}
		m_bHasRet=TRUE;
		m_nParams=1+m_iParamNum;
		break;
	case 1:
		//call xxx ?,?,...
		szSql.Format("call %s",lpszSql);
		if(m_iParamNum){
			szSql+=" ?";
			for(int i=1;i<m_iParamNum;i++){
				szSql+=",?";
			}
		}
		m_nParams=m_iParamNum;
		break;
	case 2:
		//database name
		szSql.Format("select * from %s",lpszSql);
		m_iPreDefColNum=0;
		break;
	case 3:
		//t-sql
		szSql=lpszSql;
		m_nParams=m_iParamNum;
		break;
	case 4:
		//edit a dabase
		//from a name
		//dwOpenType=CRecordset::dynamic
		//dwOption=CRecordset::none;
		break;
	case 5:
		//database name
		CString csWhere="";
		CString csField="";
		if(m_iParamNum>0){
			csWhere=GetParamValueS(0);
			CString csTemp;
			for(int i=0;i<m_iParamNum-1;i++){
				csTemp==GetParamValueS(i+1);
				if(csTemp.IsEmpty()){
					csField="";
					break;
				}
				csField+=csTemp;
				if(i+1<m_iParamNum-1){
					csField+=",";
				}
				else {
					break;
				}
			}
			m_iParamNum=0;
		}
		if(csField.IsEmpty()){
			csField="*";
		}
		szSql.Format("select %s from %s %s",csField,lpszSql,csWhere);
		m_iPreDefColNum=0;
		break;
	}
	if(szSql.IsEmpty())return FALSE;
	if(m_iPreDefColNum==0){
		m_nFields=0;
		for(int i=0;i<m_iMaxDefaultColumns;i++){
			m_pDefaultColum[i].SetType(0);
		}
	}
	else if(m_iPreDefColNum>0){
		m_nFields=m_iPreDefColNum;
	}
	TRY{
		if(IsOpen()){
			Close();
		}
		return Open(dwOpenType,szSql,dwOption);
	}
	CATCH(CDBException, e)
	{
		Close();
		return FALSE;
	}
	END_CATCH
}

void CHopeKingRecordset::RealCloseSql()
{
	if(m_pDefaultColum){
		delete [] m_pDefaultColum;
		m_pDefaultColum=NULL;
	}
	if(m_pParam){
		delete [] m_pParam;
		m_pParam=NULL;
	}
	CloseSql();
}

void CHopeKingRecordset::CloseSql()
{
	if(IsOpen())
		Close();
}

void CHopeKingRecordset::SetParaNum(int iNum)
{
	m_iParamNum=iNum;
	if(m_iMaxDefaultParam<m_iParamNum||!m_pParam){
		if(m_pParam)
			delete [] m_pParam;
		m_iMaxDefaultParam=m_iParamNum+10;
		m_pParam=new COdbcData[m_iMaxDefaultParam];
	}
}

void CHopeKingRecordset::SetParamValue(int i,LPCTSTR lpszValue)
{
	if(i>=0&&i<m_iParamNum){
		m_pParam[i].SetType(0);
		if(lpszValue)
			*m_pParam[i].m_Data.m_pString=lpszValue;
		else
			*m_pParam[i].m_Data.m_pString="";
	}
}

void CHopeKingRecordset::SetParamValue(int i,int iValue)
{
	if(i>=0&&i<m_iParamNum){
		m_pParam[i].SetType(2);
		*m_pParam[i].m_Data.m_pInt=iValue;
	}
}

void CHopeKingRecordset::SetParamValue(int i,bool bValue)
{
	if(i>=0&&i<m_iParamNum){
		m_pParam[i].SetType(8);
		*m_pParam[i].m_Data.m_pInt=bValue;
	}
}

void CHopeKingRecordset::SetParamValue(int i,long lValue)
{
	if(i>=0&&i<m_iParamNum){
		m_pParam[i].SetType(9);
		*m_pParam[i].m_Data.m_pInt=lValue;
	}
}

void CHopeKingRecordset::SetParamValue(int i,float fValue)
{
	if(i>=0&&i<m_iParamNum){
		m_pParam[i].SetType(3);
		*m_pParam[i].m_Data.m_pFloat=fValue;
	}
}

void CHopeKingRecordset::SetParamValue(int i,double dValue)
{
	if(i>=0&&i<m_iParamNum){
		m_pParam[i].SetType(4);
		*m_pParam[i].m_Data.m_pDouble=dValue;
	}
}