lyfz_repos/经典版源码/旧的后台处理/LYFZIPManage/LYFZIPReceive/mysqldata.cpp

// MySqlData.cpp : implementation file
// 

#include "stdafx.h"
#include "mysqldata.h"
#include "LYFZIPReceive.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
extern CDatabase *g_curdb;
extern CDatabase g_db;
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
// CRstSPLB
IMPLEMENT_DYNAMIC(CRstSPLB, CRecordset)

CRstSPLB::CRstSPLB(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstSPLB)
	m_name = _T("");
	m_nFields = 1;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
}


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

CString CRstSPLB::GetDefaultSQL()
{
	return _T("[shangpinlb]");
}

void CRstSPLB::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstSPLB)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[name]"), m_name);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstSPLB diagnostics

#ifdef _DEBUG
void CRstSPLB::AssertValid() const
{
	CRecordset::AssertValid();
}

void CRstSPLB::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG


/////////////////////////////////////////////////////////////////////////////
// CRstBuMen

IMPLEMENT_DYNAMIC(CRstBuMen, CRecordset)

CRstBuMen::CRstBuMen(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstBuMen)
	m_name = _T("");
	m_nFields = 1;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
}


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

CString CRstBuMen::GetDefaultSQL()
{
	return _T("[bumen]");
}

void CRstBuMen::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstBuMen)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[name]"), m_name);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstBuMen diagnostics

#ifdef _DEBUG
void CRstBuMen::AssertValid() const
{
	CRecordset::AssertValid();
}

void CRstBuMen::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG

IMPLEMENT_DYNAMIC(CRstPayOutSet, CRecordset)

CRstPayOutSet::CRstPayOutSet(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstPayOutSet)
	xiangmu = _T("");
	m_nFields = 1;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
}


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

CString CRstPayOutSet::GetDefaultSQL()
{
	return _T("[gudingfeiyongxiangmu]");
}

void CRstPayOutSet::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstPayOutSet)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[xiangmu]"), xiangmu);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstPayOutSet diagnostics

#ifdef _DEBUG
void CRstPayOutSet::AssertValid() const
{
	CRecordset::AssertValid();
}

void CRstPayOutSet::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CRstShangPin

IMPLEMENT_DYNAMIC(CRstShangPin, CRecordset)

CRstShangPin::CRstShangPin(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstShangPin)
	spid = _T("");
	spname = _T("");
	spdanwei = _T("");
	spjiaga1 = _T("");
	spjiage2 = _T("");
	splb = _T("");
	spbz = _T("");
	m_nFields = 7;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
//	m_strSort="spid desc";
}


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

CString CRstShangPin::GetDefaultSQL()
{
	return _T("[shangpin]");
}

void CRstShangPin::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstShangPin)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[spid]"), spid);
	RFX_Text(pFX, _T("[spname]"), spname);
	RFX_Text(pFX, _T("[spdanwei]"), spdanwei);
	RFX_Text(pFX, _T("[spjiaga1]"), spjiaga1);
	RFX_Text(pFX, _T("[spjiage2]"), spjiage2);
	RFX_Text(pFX, _T("[splb]"), splb);
	RFX_Text(pFX, _T("[spbz]"), spbz);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstShangPin diagnostics

#ifdef _DEBUG
void CRstShangPin::AssertValid() const
{
	CRecordset::AssertValid();
}

void CRstShangPin::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG


/////////////////////////////////////////////////////////////////////////////
// CRstRenYuan

IMPLEMENT_DYNAMIC(CRstRenYuan, CRecordset)
CRstRenYuan::CRstRenYuan(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstRenYuan)
	bm = _T("");
	id = _T("");
	name = _T("");
	sex = _T("");
	phone = _T("");
	address = _T("");
	bz = _T("");
	m_nFields = 7;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
	m_strSort="bm desc,name desc";
}


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

CString CRstRenYuan::GetDefaultSQL()
{
	return _T("[renyuan]");
}

void CRstRenYuan::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstRenYuan)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[bm]"), bm);
	RFX_Text(pFX, _T("[id]"), id);
	RFX_Text(pFX, _T("[name]"), name);
	RFX_Text(pFX, _T("[sex]"), sex);
	RFX_Text(pFX, _T("[phone]"), phone);
	RFX_Text(pFX, _T("[address]"), address);
	RFX_Text(pFX, _T("[bz]"), bz, 1024);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstRenYuan diagnostics

#ifdef _DEBUG
void CRstRenYuan::AssertValid() const
{
	CRecordset::AssertValid();
}

void CRstRenYuan::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG

IMPLEMENT_DYNAMIC(CRstTaoXi, CRecordset)
CRstTaoXi::CRstTaoXi(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstTaoXi)
	taoxiid = _T("");
	taoxiname = _T("");
	taoxijiage = _T("");
	zs = _T("");
	m_nFields = 4;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
}


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

CString CRstTaoXi::GetDefaultSQL()
{
	return _T("[taoxi]");
}

void CRstTaoXi::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstTaoXi)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[taoxiid]"), taoxiid);
	RFX_Text(pFX, _T("[taoxiname]"), taoxiname);
	RFX_Text(pFX, _T("[taoxijiage]"), taoxijiage);
	RFX_Text(pFX, _T("[zs]"), zs);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstTaoXi diagnostics

#ifdef _DEBUG
void CRstTaoXi::AssertValid() const
{
	CRecordset::AssertValid();
}

void CRstTaoXi::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG


IMPLEMENT_DYNAMIC(CRstTaoXiSP1, CRecordset)
CRstTaoXiSP1::CRstTaoXiSP1(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstTaoXiSP1)
	taoxiid = _T("");
	spid1 = _T("");
	shuliang = _T("");
	m_nFields = 3;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
}


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

CString CRstTaoXiSP1::GetDefaultSQL()
{
	return _T("[taoxishangpin1]");
}

void CRstTaoXiSP1::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstTaoXiSP1)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[taoxiid]"), taoxiid);
	RFX_Text(pFX, _T("[spid1]"), spid1);
	RFX_Text(pFX, _T("[shuliang]"), shuliang);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstTaoXiSP1 diagnostics

#ifdef _DEBUG
void CRstTaoXiSP1::AssertValid() const
{
	CRecordset::AssertValid();
}

void CRstTaoXiSP1::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG

IMPLEMENT_DYNAMIC(CRstTaoXiSP2, CRecordset)
CRstTaoXiSP2::CRstTaoXiSP2(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstTaoXiSP2)
	taoxiid = _T("");
	spid2 = _T("");
	shuliang = _T("");
	m_nFields = 3;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
}


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

CString CRstTaoXiSP2::GetDefaultSQL()
{
	return _T("[taoxishangpin2]");
}

void CRstTaoXiSP2::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstTaoXiSP2)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[taoxiid]"), taoxiid);
	RFX_Text(pFX, _T("[spid2]"), spid2);
	RFX_Text(pFX, _T("[shuliang]"), shuliang);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstTaoXiSP2 diagnostics

#ifdef _DEBUG
void CRstTaoXiSP2::AssertValid() const
{
	CRecordset::AssertValid();
}

void CRstTaoXiSP2::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG

IMPLEMENT_DYNAMIC(CRstProvider, CRecordset)
CRstProvider::CRstProvider(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstProvider)
	gyid = _T("");
	gyname = _T("");
	addr = _T("");
	tel = _T("");
	fax = _T("");
	netaddress = _T("");
	bz = _T("");
	m_nFields = 7;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
}


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

CString CRstProvider::GetDefaultSQL()
{
	return _T("[gongyingshang]");
}

void CRstProvider::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstProvider)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[gyid]"), gyid);
	RFX_Text(pFX, _T("[gyname]"), gyname);
	RFX_Text(pFX, _T("[addr]"), addr);
	RFX_Text(pFX, _T("[tel]"), tel);
	RFX_Text(pFX, _T("[fax]"), fax);
	RFX_Text(pFX, _T("[netaddress]"), netaddress);
	RFX_Text(pFX, _T("[bz]"), bz, 1024);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstProvider diagnostics

#ifdef _DEBUG
void CRstProvider::AssertValid() const
{
	CRecordset::AssertValid();
}

void CRstProvider::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG

IMPLEMENT_DYNAMIC(CRstBooking, CRecordset)
CRstBooking::CRstBooking(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstBooking)
	id = _T("");
	money1 = _T("");
	money2 = _T("");
	money3 = _T("");
	name1 = _T("");
	name2 = _T("");
	taoxiid = _T("");
	taoxiname = _T("");
 	taoxijiage = _T("");
 	taoxizs = _T("");
	time1 = _T("");
	time2 = _T("");
	time3 = _T("");
	bm = _T("");
	ren = _T("");
 	discount = _T("");
	payed1 = _T("");
 	payed2 = _T("");
	payed3 = _T("");
 	payed4 = _T("");
	payed5 = _T("");
 	time4 = _T("");
	time5 = _T("");
 	takezs = _T("");
	choosezs = _T("");
	status = _T("");
	clothescount = _T("");
	clothescount2 = _T("");
 	outside = _T("");
	outside2 = _T("");
	style = _T("");
	payed4time = _T("");
	status2 = _T("");
	status3 = _T("");
	waiter1 = _T("");
	waiter2 = _T("");
	waiter3 = _T("");
	waiter4 = _T("");
	bz = _T("");
	bz3 = _T("");
	urgent = _T("");
	waiter6 = _T("");
	waiter5 = _T("");
	waiter7 = _T("");
	status4 = _T("");
	status5 = _T("");
	status6 = _T("");
	m_nFields = 47;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
	m_strSort="id desc";
}


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

CString CRstBooking::GetDefaultSQL()
{
	return _T("[dindan]");
}

void CRstBooking::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstBooking)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[id]"), id);
	RFX_Text(pFX, _T("[money1]"), money1);
	RFX_Text(pFX, _T("[money2]"), money2);
	RFX_Text(pFX, _T("[money3]"), money3);
	RFX_Text(pFX, _T("[name1]"), name1);
	RFX_Text(pFX, _T("[name2]"), name2);
	RFX_Text(pFX, _T("[taoxiid]"), taoxiid);
	RFX_Text(pFX, _T("[taoxiname]"), taoxiname);
	RFX_Text(pFX, _T("[taoxijiage]"), taoxijiage);
 	RFX_Text(pFX, _T("[taoxizs]"), taoxizs);
 	RFX_Text(pFX, _T("[time1]"), time1);
	RFX_Text(pFX, _T("[time2]"), time2);
 	RFX_Text(pFX, _T("[time3]"), time3);
	RFX_Text(pFX, _T("[bm]"), bm);
	RFX_Text(pFX, _T("[ren]"), ren);
	RFX_Text(pFX, _T("[discount]"), discount);
	RFX_Text(pFX, _T("[payed1]"), payed1);
	RFX_Text(pFX, _T("[payed2]"), payed2);
	RFX_Text(pFX, _T("[payed3]"), payed3);
	RFX_Text(pFX, _T("[payed4]"), payed4);	
	RFX_Text(pFX, _T("[payed5]"), payed5);
	RFX_Text(pFX, _T("[time4]"), time4);
	RFX_Text(pFX, _T("[time5]"), time5);
	RFX_Text(pFX, _T("[takezs]"), takezs);	
	RFX_Text(pFX, _T("[choosezs]"), choosezs);
	RFX_Text(pFX, _T("[status]"), status);
	RFX_Text(pFX, _T("[clothescount]"), clothescount);
	RFX_Text(pFX, _T("[clothescount2]"),clothescount2);
	RFX_Text(pFX, _T("[outside]"), outside);
	RFX_Text(pFX, _T("[outside2]"),outside2);
	RFX_Text(pFX, _T("[style]"), style);
	RFX_Text(pFX, _T("[payed4time]"),payed4time);
	RFX_Text(pFX, _T("[status2]"),status2);
	RFX_Text(pFX, _T("[status3]"),status3);
	RFX_Text(pFX, _T("[waiter1]"),waiter1);
	RFX_Text(pFX, _T("[waiter2]"),waiter2);
	RFX_Text(pFX, _T("[waiter3]"),waiter3);
	RFX_Text(pFX, _T("[waiter4]"),waiter4);
	RFX_Text(pFX, _T("[bz]"),bz, 1024);
	RFX_Text(pFX, _T("[bz3]"),bz3, 1024);
	RFX_Text(pFX, _T("[urgent]"),urgent);
	RFX_Text(pFX, _T("[waiter6]"),waiter6);
	RFX_Text(pFX, _T("[waiter5]"),waiter5);
	RFX_Text(pFX, _T("[waiter7]"),waiter7);
	RFX_Text(pFX, _T("[status4]"),status4);
	RFX_Text(pFX, _T("[status5]"),status5);
	RFX_Text(pFX, _T("[status6]"),status6);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstBooking diagnostics

#ifdef _DEBUG
void CRstBooking::AssertValid() const
{
	CRecordset::AssertValid();
}

void CRstBooking::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG


IMPLEMENT_DYNAMIC(CRstBooking2, CRecordset)
CRstBooking2::CRstBooking2(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstBooking2)
	name1 = _T("");
	name2 = _T("");
	money1 = _T("");
	payed1 = _T("");
 	time1 = _T("");
	m_nFields = 5;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
	m_strSort="id desc";
}


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

CString CRstBooking2::GetDefaultSQL()
{
	return _T("[dindan]");
}

void CRstBooking2::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstBooking2)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[name1]"), name1);
	RFX_Text(pFX, _T("[name2]"), name2);
	RFX_Text(pFX, _T("[money1]"), money1);
 	RFX_Text(pFX, _T("[time1]"), time1);
	RFX_Text(pFX, _T("[payed1]"), payed1);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstBooking2 diagnostics

#ifdef _DEBUG
void CRstBooking2::AssertValid() const
{
	CRecordset::AssertValid();
}

void CRstBooking2::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG

IMPLEMENT_DYNAMIC(CRstDinDanSP, CRecordset)
CRstDinDanSP::CRstDinDanSP(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstDinDanSP)
	id = _T("");
	spid = _T("");
	price = _T("");
	shuliang = _T("");
	kind = _T("");
	name = _T("");
	no = _T("");
	autoid = _T("");
	m_nFields = 8;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
}

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

CString CRstDinDanSP::GetDefaultSQL()
{
	return _T("[dindansp]");
}

void CRstDinDanSP::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstDinDanSP)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[id]"), id);
	RFX_Text(pFX, _T("[spid]"), spid);
	RFX_Text(pFX, _T("[price]"), price);
	RFX_Text(pFX, _T("[shuliang]"), shuliang);
	RFX_Text(pFX, _T("[kind]"), kind);
	RFX_Text(pFX, _T("[name]"), name);
	RFX_Text(pFX, _T("[no]"), no, 2048);
	RFX_Text(pFX, _T("[autoid]"), autoid);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstDinDanSP diagnostics

#ifdef _DEBUG
void CRstDinDanSP::AssertValid() const
{
	CRecordset::AssertValid();
}

void CRstDinDanSP::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG


IMPLEMENT_DYNAMIC(CRstDinDanSP2, CRecordset)
CRstDinDanSP2::CRstDinDanSP2(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstDinDanSP2)
	id = _T("");
	shuliang = _T("");
	name = _T("");
	status1 = _T("");
	status2 = _T("");
	status3 = _T("");
	status4 = _T("");
	kind = _T("");
	no = _T("");
	autoid = _T("");
	spid = _T("");
	date1 = _T("");
	date2 = _T("");
	date3 = _T("");
	date4 = _T("");
	name1 = _T("");
	name2 = _T("");
	name3 = _T("");
	name4 = _T("");
	m_nFields = 19;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
}


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

CString CRstDinDanSP2::GetDefaultSQL()
{
	return _T("[dindansp]");
}

void CRstDinDanSP2::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstDinDanSP2)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[id]"), id);
	RFX_Text(pFX, _T("[shuliang]"), shuliang);
	RFX_Text(pFX, _T("[status1]"), status1);
	RFX_Text(pFX, _T("[name]"), name);
	RFX_Text(pFX, _T("[status2]"), status2);
	RFX_Text(pFX, _T("[status3]"), status3);
	RFX_Text(pFX, _T("[status4]"), status4);
	RFX_Text(pFX, _T("[kind]"), kind);
	RFX_Text(pFX, _T("[no]"), no, 2048);
	RFX_Text(pFX, _T("[autoid]"), autoid);
	RFX_Text(pFX, _T("[spid]"), spid);
	RFX_Text(pFX, _T("[date1]"), date1);
	RFX_Text(pFX, _T("[date2]"), date2);
	RFX_Text(pFX, _T("[date3]"), date3);
	RFX_Text(pFX, _T("[date4]"), date4);
	RFX_Text(pFX, _T("[name1]"), name1);
 	RFX_Text(pFX, _T("[name2]"), name2);
	RFX_Text(pFX, _T("[name3]"), name3);
	RFX_Text(pFX, _T("[name4]"), name4);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstDinDanSP2 diagnostics

#ifdef _DEBUG
void CRstDinDanSP2::AssertValid() const
{
	CRecordset::AssertValid();
}

void CRstDinDanSP2::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG


IMPLEMENT_DYNAMIC(CRstPayOutInput, CRecordset)
CRstPayOutInput::CRstPayOutInput(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstPayOutInput)
	id = _T("");
	name = _T("");
	money = _T("");
	date = _T("");
	renyuan1 = _T("");
	renyuan2 = _T("");
	bz = _T("");
	m_nFields = 7;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb;
	m_strSort="dat desc";
}


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

CString CRstPayOutInput::GetDefaultSQL()
{
	return _T("[gudingfeiyong]");
}

void CRstPayOutInput::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstPayOutInput)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[id]"), id);
	RFX_Text(pFX, _T("[name]"), name);
	RFX_Text(pFX, _T("[money]"), money);
	RFX_Text(pFX, _T("[dat]"), date);
	RFX_Text(pFX, _T("[renyuan1]"), renyuan1);
	RFX_Text(pFX, _T("[renyuan2]"), renyuan2);
	RFX_Text(pFX, _T("[bz]"), bz, 1024);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstPayOutInput diagnostics

#ifdef _DEBUG
void CRstPayOutInput::AssertValid() const
{
	CRecordset::AssertValid();
}

void CRstPayOutInput::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG


IMPLEMENT_DYNAMIC(CRstIncomeInput, CRecordset)
CRstIncomeInput::CRstIncomeInput(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstIncomeInput)
	id = _T("");
	name = _T("");
	money = _T("");
	date = _T("");
	renyuan1 = _T("");
	renyuan2 = _T("");
	renyuan3 = _T("");
	bz = _T("");
	m_nFields = 8;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
	m_strSort="dat desc";
}


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

CString CRstIncomeInput::GetDefaultSQL()
{
	return _T("[singleincome]");
}

void CRstIncomeInput::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstIncomeInput)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[id]"), id);
	RFX_Text(pFX, _T("[name]"), name);
	RFX_Text(pFX, _T("[money]"), money);
	RFX_Text(pFX, _T("[dat]"), date);
	RFX_Text(pFX, _T("[renyuan1]"), renyuan1);
	RFX_Text(pFX, _T("[renyuan2]"), renyuan2);
	RFX_Text(pFX, _T("[renyuan3]"), renyuan3);
	RFX_Text(pFX, _T("[bz]"), bz, 1024);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstIncomeInput diagnostics

#ifdef _DEBUG
void CRstIncomeInput::AssertValid() const
{
	CRecordset::AssertValid();
}

void CRstIncomeInput::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG

IMPLEMENT_DYNAMIC(CRstClient, CRecordset)
CRstClient::CRstClient(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstClient)
	id = _T("");
	name1 = _T("");
	name2 = _T("");
	phone1 = _T("");
	phone2 = _T("");
	qq1 = _T("");
	qq2 = _T("");
	addr1 = _T("");
	addr2 = _T("");
	occupation1 = _T("");
	occupation2 = _T("");
	birthday1 = _T("");
	birthday2 = _T("");
	m_nFields = 13;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
}


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

CString CRstClient::GetDefaultSQL()
{
	return _T("[client]");
}

void CRstClient::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstClient)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[id]"), id);
	RFX_Text(pFX, _T("[name1]"), name1);
	RFX_Text(pFX, _T("[name2]"), name2);
	RFX_Text(pFX, _T("[phone1]"), phone1);
	RFX_Text(pFX, _T("[phone2]"), phone2);
	RFX_Text(pFX, _T("[qq1]"), qq1);
	RFX_Text(pFX, _T("[qq2]"), qq2);
 	RFX_Text(pFX, _T("[addr1]"), addr1);
	RFX_Text(pFX, _T("[addr2]"), addr2);
 	RFX_Text(pFX, _T("[occupation1]"), occupation1);
	RFX_Text(pFX, _T("[occupation2]"), occupation2);
	RFX_Text(pFX, _T("[birthday1]"), birthday1);
	RFX_Text(pFX, _T("[birthday2]"), birthday2);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstClient diagnostics

#ifdef _DEBUG
void CRstClient::AssertValid() const
{
	CRecordset::AssertValid();
}

void CRstClient::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG

IMPLEMENT_DYNAMIC(CRstDinDanClient, CRecordset)
CRstDinDanClient::CRstDinDanClient(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstDinDanClient)
	id = _T("");
	name1 = _T("");
	name2 = _T("");
	phone1 = _T("");
	phone2 = _T("");
	qq1 = _T("");
	qq2 = _T("");
	addr1 = _T("");
	addr2 = _T("");
	occupation1 = _T("");
	occupation2 = _T("");
	birthday1 = _T("");
	birthday2 = _T("");
	taoxiname = _T("");
	taoxijiage = _T("");
	time1 = _T("");
	time3 = _T("");
	pinyin1 = _T("");
	pinyin2 = _T("");
	m_nFields = 19;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
	m_strSort="id desc";
}


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

CString CRstDinDanClient::GetDefaultSQL()
{
	return _T("[dindanclient]");
}

void CRstDinDanClient::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstDinDanClient)
	pFX->SetFieldType(CFieldExchange::outputColumn);
 	RFX_Text(pFX, _T("[id]"), id);
	RFX_Text(pFX, _T("[name1]"), name1);
	RFX_Text(pFX, _T("[name2]"), name2);
	RFX_Text(pFX, _T("[phone1]"), phone1);
	RFX_Text(pFX, _T("[phone2]"), phone2);
	RFX_Text(pFX, _T("[qq1]"), qq1);
	RFX_Text(pFX, _T("[qq2]"), qq2);
 	RFX_Text(pFX, _T("[addr1]"), addr1);
	RFX_Text(pFX, _T("[addr2]"), addr2);
 	RFX_Text(pFX, _T("[occupation1]"), occupation1);
	RFX_Text(pFX, _T("[occupation2]"), occupation2);
	RFX_Text(pFX, _T("[birthday1]"), birthday1);
	RFX_Text(pFX, _T("[birthday2]"), birthday2);
	RFX_Text(pFX, _T("[taoxiname]"), taoxiname);
 	RFX_Text(pFX, _T("[taoxijiage]"), taoxijiage);
	RFX_Text(pFX, _T("[time1]"), time1);
	RFX_Text(pFX, _T("[time3]"), time3);
	RFX_Text(pFX, _T("[pinyin1]"), pinyin1);
	RFX_Text(pFX, _T("[pinyin2]"), pinyin2);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstDinDanClient diagnostics

#ifdef _DEBUG
void CRstDinDanClient::AssertValid() const
{
	CRecordset::AssertValid();
}

void CRstDinDanClient::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG

IMPLEMENT_DYNAMIC(CRstDinDanBuKuan, CRecordset)
CRstDinDanBuKuan::CRstDinDanBuKuan(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstDinDanBuKuan)
	id = _T("");
	money = _T("");
	ren = _T("");
	date = _T("");
	bz = _T("");
	kind = _T("");
	m_nFields = 6;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
}


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

CString CRstDinDanBuKuan::GetDefaultSQL()
{
	return _T("[dindanbukuan]");
}

void CRstDinDanBuKuan::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstDinDanBuKuan)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[id]"), id);
	RFX_Text(pFX, _T("[money]"), money);
	RFX_Text(pFX, _T("[ren]"), ren);
	RFX_Text(pFX, _T("[date]"), date);
	RFX_Text(pFX, _T("[bz]"), bz, 1024);
	RFX_Text(pFX, _T("[kind]"), kind);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstDinDanBuKuan diagnostics

#ifdef _DEBUG
void CRstDinDanBuKuan::AssertValid() const
{
	CRecordset::AssertValid();
}

void CRstDinDanBuKuan::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG

IMPLEMENT_DYNAMIC(CRstDinDanBuKuanDaily, CRecordset)
CRstDinDanBuKuanDaily::CRstDinDanBuKuanDaily(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstDinDanBuKuanDaily)
	id = _T("");
	name1 = _T("");
	name2 = _T("");
	ren = _T("");
	money = _T("");
	bz = _T("");
	kind = _T("");
	date = _T("");
	m_nFields = 8;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
}


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

CString CRstDinDanBuKuanDaily::GetDefaultSQL()
{
	return _T("[dindanbukuandaily]");
}

void CRstDinDanBuKuanDaily::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstDinDanBuKuanDaily)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[id]"), id);
	RFX_Text(pFX, _T("[name1]"), name1);
	RFX_Text(pFX, _T("[name2]"), name2);
	RFX_Text(pFX, _T("[ren]"), ren);
	RFX_Text(pFX, _T("[money]"), money);
	RFX_Text(pFX, _T("[bz]"), bz, 1024);
	RFX_Text(pFX, _T("[kind]"), kind);
	RFX_Text(pFX, _T("[date]"), date);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstDinDanBuKuanDaily diagnostics

#ifdef _DEBUG
void CRstDinDanBuKuanDaily::AssertValid() const
{
	CRecordset::AssertValid();
}

void CRstDinDanBuKuanDaily::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG

IMPLEMENT_DYNAMIC(CRstTodayForm, CRecordset)
CRstTodayForm::CRstTodayForm(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstTodayForm)
	id = _T("");
	name1 = _T("");
	name2 = _T("");
	phone1 = _T("");
	phone2 = _T("");
	taoxiname = _T("");
 	taoxijiage = _T("");
 	status2 = _T("");
	status3 = _T("");
	time2 = _T("");
 	time4 = _T("");
	time5 = _T("");
	ren = _T("");
	waiter1 = _T("");
	waiter2 = _T("");
	status = _T("");
	waiter4 = _T("");
	m_nFields = 17;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
	m_strSort="id desc";
}


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

CString CRstTodayForm::GetDefaultSQL()
{
	return _T("[dindan]");
}

void CRstTodayForm::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstTodayForm)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[id]"), id);
	RFX_Text(pFX, _T("[name1]"), name1);
	RFX_Text(pFX, _T("[name2]"), name2);
	RFX_Text(pFX, _T("[phone1]"), phone1);
	RFX_Text(pFX, _T("[phone2]"), phone2);
	RFX_Text(pFX, _T("[taoxiname]"), taoxiname);
	RFX_Text(pFX, _T("[taoxijiage]"), taoxijiage);
 	RFX_Text(pFX, _T("[status2]"), status2);
 	RFX_Text(pFX, _T("[status3]"), status3);
 	RFX_Text(pFX, _T("[time2]"), time2);
	RFX_Text(pFX, _T("[time4]"), time4);
	RFX_Text(pFX, _T("[time5]"), time5);
	RFX_Text(pFX, _T("[ren]"), ren);
	RFX_Text(pFX, _T("[waiter1]"),waiter1);
	RFX_Text(pFX, _T("[waiter2]"),waiter2);
	RFX_Text(pFX, _T("[status]"),status);
	RFX_Text(pFX, _T("[waiter4]"),waiter4);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstTodayForm diagnostics

#ifdef _DEBUG
void CRstTodayForm::AssertValid() const
{
	CRecordset::AssertValid();
}

void CRstTodayForm::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG

IMPLEMENT_DYNAMIC(CRstUser, CRecordset)
CRstUser::CRstUser(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstUser)
	account = _T("");
	name = _T("");
 	psw = _T("");
	rights = _T("");
	m_nFields = 4;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
}


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

CString CRstUser::GetDefaultSQL()
{
	return _T("[user]");
}

void CRstUser::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstUser)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[account]"), account);
	RFX_Text(pFX, _T("[name]"), name);
	RFX_Text(pFX, _T("[psw]"), psw);
	RFX_Text(pFX, _T("[rights]"), rights);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstUser diagnostics

#ifdef _DEBUG
void CRstUser::AssertValid() const
{
	CRecordset::AssertValid();
}

void CRstUser::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG

IMPLEMENT_DYNAMIC(CRstRenYuan2, CRecordset)
CRstRenYuan2::CRstRenYuan2(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstRenYuan2)
	name = _T("");
 	base = _T("");
	rate1 = _T("");
	rate2 = _T("");
	bz = _T("");
	bm = _T("");
	m_nFields = 6;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
	m_strSort="bm desc,name desc";
}


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

CString CRstRenYuan2::GetDefaultSQL()
{
	return _T("[renyuan]");
}

void CRstRenYuan2::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstRenYuan2)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[name]"), name);
	RFX_Text(pFX, _T("[base]"), base);
	RFX_Text(pFX, _T("[rate1]"), rate1);
	RFX_Text(pFX, _T("[rate2]"), rate2);
	RFX_Text(pFX, _T("[bz2]"), bz, 1024);
	RFX_Text(pFX, _T("[bm]"), bm);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstRenYuan2 diagnostics

#ifdef _DEBUG
void CRstRenYuan2::AssertValid() const
{
	CRecordset::AssertValid();
}

void CRstRenYuan2::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG
IMPLEMENT_DYNAMIC(CRstUpdate, CRecordset)
CRstUpdate::CRstUpdate(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstUpdate)
	m_nFields = 7;
	//}}AFX_FIELD_INIT	
	this->m_pDatabase = g_curdb; 
//	m_nDefaultType = snapshot;
	m_nDefaultType = dynaset;
}


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

CString CRstUpdate::GetDefaultSQL()
{
	return _T("[update]");
}

void CRstUpdate::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstUpdate)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_LongBinary(pFX, _T("[data]"), data);
	RFX_LongBinary(pFX, _T("[data2]"), data2);
	RFX_LongBinary(pFX, _T("[data3]"), data3);
	RFX_LongBinary(pFX, _T("[data4]"), data4);
	RFX_LongBinary(pFX, _T("[data5]"), data5);
	RFX_LongBinary(pFX, _T("[data6]"), data6);
	RFX_LongBinary(pFX, _T("[data7]"), data7);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstUpdate diagnostics

#ifdef _DEBUG
void CRstUpdate::AssertValid() const
{
	CRecordset::AssertValid();
}

void CRstUpdate::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG

IMPLEMENT_DYNAMIC(CRstDindanForm, CRecordset)
CRstDindanForm::CRstDindanForm(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstDindanForm)
	id = _T("");
	name1 = _T("");
	name2 = _T("");
	taoxiname = _T("");
 	taoxijiage = _T("");
	time1 = _T("");
	time2 = _T("");
	ren = _T("");
 	time4 = _T("");
	time5 = _T("");
 
	status = _T("");
	status2 = _T("");
	status3 = _T("");
	status4 = _T("");
	status5 = _T("");
	waiter1 = _T("");
	waiter2 = _T("");
 
	waiter4 = _T("");
 
	phone1 = _T("");
	phone2 = _T("");
	taketime = _T("");
	pinyin1 = _T("");
	pinyin2 = _T("");
	status6 = _T("");
	waiter3 = _T("");
	waiter5 = _T("");
	waiter7 = _T("");
	waiter6 = _T("");
	m_nFields = 28;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
	m_strSort="id desc";
}


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

CString CRstDindanForm::GetDefaultSQL()
{
	return _T("[dindan]");
}

void CRstDindanForm::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstDindanForm)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[id]"), id);
	RFX_Text(pFX, _T("[name1]"), name1);
	RFX_Text(pFX, _T("[name2]"), name2);
	RFX_Text(pFX, _T("[taoxiname]"), taoxiname);
	RFX_Text(pFX, _T("[taoxijiage]"), taoxijiage);
 	RFX_Text(pFX, _T("[time1]"), time1);
	RFX_Text(pFX, _T("[time2]"), time2);
	RFX_Text(pFX, _T("[ren]"), ren);
	RFX_Text(pFX, _T("[time4]"), time4);
	RFX_Text(pFX, _T("[time5]"), time5);
	RFX_Text(pFX, _T("[status]"), status);
	RFX_Text(pFX, _T("[status2]"),status2);
	RFX_Text(pFX, _T("[status3]"),status3);
	RFX_Text(pFX, _T("[status4]"),status4);
	RFX_Text(pFX, _T("[status5]"),status5);
	RFX_Text(pFX, _T("[waiter1]"),waiter1);
	RFX_Text(pFX, _T("[waiter2]"),waiter2);
	RFX_Text(pFX, _T("[waiter4]"),waiter4);
	RFX_Text(pFX, _T("[phone1]"),phone1);
	RFX_Text(pFX, _T("[phone2]"),phone2);
	RFX_Text(pFX, _T("[taketime]"),taketime);
	RFX_Text(pFX, _T("[pinyin1]"),pinyin1);
	RFX_Text(pFX, _T("[pinyin2]"),pinyin2);
	RFX_Text(pFX, _T("[status6]"),status6);
	RFX_Text(pFX, _T("[waiter3]"),waiter3);
	RFX_Text(pFX, _T("[waiter5]"),waiter5);
	RFX_Text(pFX, _T("[waiter6]"),waiter6);
	RFX_Text(pFX, _T("[waiter7]"),waiter7);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstDindanForm diagnostics

#ifdef _DEBUG
void CRstDindanForm::AssertValid() const
{
	CRecordset::AssertValid();
}

void CRstDindanForm::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG


IMPLEMENT_DYNAMIC(CRstDindanForm2, CRecordset)
CRstDindanForm2::CRstDindanForm2(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstDindanForm2)
	id = _T("");
	name1 = _T("");
	name2 = _T("");
	status4 = _T("");
	status2 = _T("");
 	time4 = _T("");
 	urgent = _T("");
 	time5 = _T("");
	ren = _T("");
	waiter3 = _T("");
	taoxiname = _T("");
 	taoxijiage = _T("");
	phone1 = _T("");
	phone2 = _T("");
	pinyin1 = _T("");
	pinyin2 = _T("");
	m_nFields = 16;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
	m_strSort="id desc";
}


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

CString CRstDindanForm2::GetDefaultSQL()
{
	return _T("[dindan]");
}

void CRstDindanForm2::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstDindanForm2)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[id]"), id);
	RFX_Text(pFX, _T("[name1]"), name1);
	RFX_Text(pFX, _T("[name2]"), name2);
	RFX_Text(pFX, _T("[status4]"),status4);
	RFX_Text(pFX, _T("[status2]"),status2);
	RFX_Text(pFX, _T("[time4]"), time4);
	RFX_Text(pFX, _T("[urgent]"), urgent);
	RFX_Text(pFX, _T("[time5]"), time5);
	RFX_Text(pFX, _T("[ren]"), ren);
	RFX_Text(pFX, _T("[waiter3]"),waiter3);
	RFX_Text(pFX, _T("[taoxiname]"), taoxiname);
	RFX_Text(pFX, _T("[taoxijiage]"), taoxijiage);
	RFX_Text(pFX, _T("[phone1]"),phone1);
	RFX_Text(pFX, _T("[phone2]"),phone2);
	RFX_Text(pFX, _T("[pinyin1]"),pinyin1);
	RFX_Text(pFX, _T("[pinyin2]"),pinyin2);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstDindanForm2 diagnostics

#ifdef _DEBUG
void CRstDindanForm2::AssertValid() const
{
	CRecordset::AssertValid();
}

void CRstDindanForm2::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG

IMPLEMENT_DYNAMIC(CRstDindanForm7, CRecordset)
CRstDindanForm7::CRstDindanForm7(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstDindanForm7)
	id = _T("");
	name1 = _T("");
	name2 = _T("");
	status3 = _T("");
	taoxiname = _T("");
 	taoxijiage = _T("");
	phone1 = _T("");
	phone2 = _T("");
	pinyin1 = _T("");
	pinyin2 = _T("");
 	m_payed4 = _T("");
 	m_payed5 = _T("");
	m_nFields = 12;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
	m_strSort="id desc";
}

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

CString CRstDindanForm7::GetDefaultSQL()
{
	return _T("[dindan]");
}

void CRstDindanForm7::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstDindanForm7)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[id]"), id);
	RFX_Text(pFX, _T("[name1]"), name1);
	RFX_Text(pFX, _T("[name2]"), name2);
	RFX_Text(pFX, _T("[status3]"),status3);
	RFX_Text(pFX, _T("[taoxiname]"), taoxiname);
	RFX_Text(pFX, _T("[taoxijiage]"), taoxijiage);
	RFX_Text(pFX, _T("[phone1]"),phone1);
	RFX_Text(pFX, _T("[phone2]"),phone2);
	RFX_Text(pFX, _T("[pinyin1]"),pinyin1);
	RFX_Text(pFX, _T("[pinyin2]"),pinyin2);
	RFX_Text(pFX, _T("[payed4]"),m_payed4);
	RFX_Text(pFX, _T("[payed5]"),m_payed5);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstDindanForm7 diagnostics

#ifdef _DEBUG
void CRstDindanForm7::AssertValid() const
{
	CRecordset::AssertValid();
}

void CRstDindanForm7::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG

IMPLEMENT_DYNAMIC(CRstDindanForm4, CRecordset)
CRstDindanForm4::CRstDindanForm4(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstDindanForm4)
	id = _T("");
	name1 = _T("");
	name2 = _T("");
	status6 = _T("");
 	status5 = _T("");
 	urgent = _T("");
 	time5 = _T("");
 	bz2 = _T("");
	ren = _T("");
	waiter3 = _T("");
	waiter4 = _T("");
	taoxiname = _T("");
 	taoxijiage = _T("");
	phone1 = _T("");
	phone2 = _T("");
	pinyin1 = _T("");
	pinyin2 = _T("");
	m_nFields = 17;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
	m_strSort="id desc";
}


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

CString CRstDindanForm4::GetDefaultSQL()
{
	return _T("[dindan]");
}

void CRstDindanForm4::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstDindanForm4)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[id]"), id);
	RFX_Text(pFX, _T("[name1]"), name1);
	RFX_Text(pFX, _T("[name2]"), name2);
	RFX_Text(pFX, _T("[status6]"),status6);
	RFX_Text(pFX, _T("[status5]"), status5);
	RFX_Text(pFX, _T("[urgent]"), urgent);
	RFX_Text(pFX, _T("[time5]"), time5);
	RFX_Text(pFX, _T("[bz2]"), bz2, 1024);
	RFX_Text(pFX, _T("[ren]"), ren);
	RFX_Text(pFX, _T("[waiter3]"),waiter3);
	RFX_Text(pFX, _T("[waiter4]"),waiter4);
	RFX_Text(pFX, _T("[taoxiname]"), taoxiname);
	RFX_Text(pFX, _T("[taoxijiage]"), taoxijiage);
	RFX_Text(pFX, _T("[phone1]"),phone1);
	RFX_Text(pFX, _T("[phone2]"),phone2);
	RFX_Text(pFX, _T("[pinyin1]"),pinyin1);
	RFX_Text(pFX, _T("[pinyin2]"),pinyin2);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstDindanForm4 diagnostics

#ifdef _DEBUG
void CRstDindanForm4::AssertValid() const
{
	CRecordset::AssertValid();
}

void CRstDindanForm4::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG

IMPLEMENT_DYNAMIC(CRstDindanForm6, CRecordset)
CRstDindanForm6::CRstDindanForm6(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstDindanForm6)
	id = _T("");
	name1 = _T("");
	name2 = _T("");
	status7 = _T("");
 	urgent = _T("");
 	time5 = _T("");
	ren = _T("");
	taoxiname = _T("");
 	taoxijiage = _T("");
	phone1 = _T("");
	phone2 = _T("");
	pinyin1 = _T("");
	pinyin2 = _T("");
	m_nFields = 13;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
	m_strSort="id desc";
}


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

CString CRstDindanForm6::GetDefaultSQL()
{
	return _T("[dindan]");
}

void CRstDindanForm6::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstDindanForm6)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[id]"), id);
	RFX_Text(pFX, _T("[name1]"), name1);
	RFX_Text(pFX, _T("[name2]"), name2);
	RFX_Text(pFX, _T("[status7]"),status7);
	RFX_Text(pFX, _T("[urgent]"), urgent);
	RFX_Text(pFX, _T("[time5]"), time5);
	RFX_Text(pFX, _T("[ren]"), ren);
	RFX_Text(pFX, _T("[taoxiname]"), taoxiname);
	RFX_Text(pFX, _T("[taoxijiage]"), taoxijiage);
	RFX_Text(pFX, _T("[phone1]"),phone1);
	RFX_Text(pFX, _T("[phone2]"),phone2);
	RFX_Text(pFX, _T("[pinyin1]"),pinyin1);
	RFX_Text(pFX, _T("[pinyin2]"),pinyin2);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstDindanForm6 diagnostics

#ifdef _DEBUG
void CRstDindanForm6::AssertValid() const
{
	CRecordset::AssertValid();
}

void CRstDindanForm6::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG


IMPLEMENT_DYNAMIC(CRstDindanForm3, CRecordset)
CRstDindanForm3::CRstDindanForm3(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstDindanForm3)
	id = _T("");
	name1 = _T("");
	name2 = _T("");
	status = _T("");
	status4 = _T("");
	urgent = _T("");
	time5 = _T("");
	taoxiname = _T("");
 	taoxijiage = _T("");
	waiter1 = _T("");
	waiter5 = _T("");
	ren = _T("");
	phone1 = _T("");
	phone2 = _T("");
	pinyin1 = _T("");
	pinyin2 = _T("");
	m_nFields = 16;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
	m_strSort="id desc";
}

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

CString CRstDindanForm3::GetDefaultSQL()
{
	return _T("[dindan]");
}

void CRstDindanForm3::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstDindanForm3)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[id]"), id);
	RFX_Text(pFX, _T("[name1]"), name1);
	RFX_Text(pFX, _T("[name2]"), name2);
	RFX_Text(pFX, _T("[status]"), status);
	RFX_Text(pFX, _T("[status4]"), status4);
	RFX_Text(pFX, _T("[taoxiname]"), taoxiname);
	RFX_Text(pFX, _T("[taoxijiage]"), taoxijiage);
	RFX_Text(pFX, _T("[waiter1]"), waiter1);
	RFX_Text(pFX, _T("[waiter5]"), waiter5);
	RFX_Text(pFX, _T("[ren]"), ren);
	RFX_Text(pFX, _T("[phone1]"),phone1);
	RFX_Text(pFX, _T("[phone2]"),phone2);
	RFX_Text(pFX, _T("[pinyin1]"),pinyin1);
	RFX_Text(pFX, _T("[pinyin2]"),pinyin2);
	RFX_Text(pFX, _T("[urgent]"),urgent);
	RFX_Text(pFX, _T("[time5]"),time5);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstDindanForm3 diagnostics

#ifdef _DEBUG
void CRstDindanForm3::AssertValid() const
{
	CRecordset::AssertValid();
}

void CRstDindanForm3::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG

IMPLEMENT_DYNAMIC(CRstTakeControl, CRecordset)
CRstTakeControl::CRstTakeControl(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstTakeControl)
	m_time2 = _T("");
	m_taketime = _T("");
	m_id = _T("");
	m_name1 = _T("");
	m_name2 = _T("");
	m_phone1 = _T("");
	m_phone2 = _T("");
	m_taoxiname = _T("");
	m_waiter1 = _T("");
	m_waiter2 = _T("");
	m_clothescount = _T("");
	m_outside = _T("");
	m_ren = _T("");
	m_bz2 = _T("");
	pinyin1 = _T("");
	pinyin2 = _T("");
	m_nFields = 16;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
	m_strSort="time2 desc,taketime desc,id desc";
}


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

CString CRstTakeControl::GetDefaultSQL()
{
	return _T("[dindan]");
}

void CRstTakeControl::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstTakeControl)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[time2]"), m_time2);
	RFX_Text(pFX, _T("[taketime]"), m_taketime);
	RFX_Text(pFX, _T("[id]"), m_id);
	RFX_Text(pFX, _T("[name1]"), m_name1);
	RFX_Text(pFX, _T("[name2]"), m_name2);
	RFX_Text(pFX, _T("[phone1]"), m_phone1);
	RFX_Text(pFX, _T("[phone2]"), m_phone2);
	RFX_Text(pFX, _T("[taoxiname]"), m_taoxiname);
	RFX_Text(pFX, _T("[waiter1]"), m_waiter1);
	RFX_Text(pFX, _T("[waiter2]"), m_waiter2);
	RFX_Text(pFX, _T("[clothescount]"), m_clothescount);
	RFX_Text(pFX, _T("[outside]"), m_outside);
	RFX_Text(pFX, _T("[ren]"), m_ren);
	RFX_Text(pFX, _T("[bz2]"), m_bz2, 1024);
	RFX_Text(pFX, _T("[pinyin1]"), pinyin1);
	RFX_Text(pFX, _T("[pinyin2]"), pinyin2);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstTakeControl diagnostics

#ifdef _DEBUG
void CRstTakeControl::AssertValid() const
{
	CRecordset::AssertValid();
}

void CRstTakeControl::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG


IMPLEMENT_DYNAMIC(CRstBuKuan, CRecordset)

CRstBuKuan::CRstBuKuan(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstBuKuan)
	m_autoid = 0;
	m_id = _T("");
	m_money = _T("");
	m_ren = _T("");
	m_ren2 = _T("");
	m_date = _T("");
	m_bz = _T("");
	m_kind = _T("");
	m_nFields = 8;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
}


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

CString CRstBuKuan::GetDefaultSQL()
{
	return _T("[dindanbukuan]");
}

void CRstBuKuan::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstBuKuan)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Long(pFX, _T("[autoid]"), m_autoid);
	RFX_Text(pFX, _T("[id]"), m_id);
	RFX_Text(pFX, _T("[money]"), m_money);
	RFX_Text(pFX, _T("[ren]"), m_ren);
	RFX_Text(pFX, _T("[ren2]"), m_ren2);
	RFX_Text(pFX, _T("[date]"), m_date);
	RFX_Text(pFX, _T("[bz]"), m_bz, 1024);
	RFX_Text(pFX, _T("[kind]"), m_kind);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstBuKuan diagnostics

#ifdef _DEBUG
void CRstBuKuan::AssertValid() const
{
	CRecordset::AssertValid();
}

void CRstBuKuan::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG

IMPLEMENT_DYNAMIC(CRstBuKuan2, CRecordset)

CRstBuKuan2::CRstBuKuan2(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstBuKuan2)
	m_autoid = 0;
	m_id = _T("");
	m_money = _T("");
	m_ren = _T("");
	m_ren2 = _T("");
	m_date = _T("");
	m_bz = _T("");
	m_kind = _T("");
	m_nFields = 8;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
}


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

CString CRstBuKuan2::GetDefaultSQL()
{
	return _T("[dindanbukuan2]");
}

void CRstBuKuan2::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstBuKuan2)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Long(pFX, _T("[autoid]"), m_autoid);
	RFX_Text(pFX, _T("[id]"), m_id);
	RFX_Text(pFX, _T("[money]"), m_money);
	RFX_Text(pFX, _T("[ren]"), m_ren);
	RFX_Text(pFX, _T("[ren2]"), m_ren2);
	RFX_Text(pFX, _T("[date]"), m_date);
	RFX_Text(pFX, _T("[bz]"), m_bz, 1024);
	RFX_Text(pFX, _T("[kind]"), m_kind);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstBuKuan2 diagnostics

#ifdef _DEBUG
void CRstBuKuan2::AssertValid() const
{
	CRecordset::AssertValid();
}

void CRstBuKuan2::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG

IMPLEMENT_DYNAMIC(CRstPath, CRecordset)

CRstPath::CRstPath(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstPath)
	path1 = _T("");
	path2 = _T("");
	path3 = _T("");
	path4 = _T("");
	m_nFields = 4;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
}


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

CString CRstPath::GetDefaultSQL()
{
	return _T("[path]");
}

void CRstPath::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstPath)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[path1]"), path1);
	RFX_Text(pFX, _T("[path2]"), path2);
	RFX_Text(pFX, _T("[path3]"), path3);
	RFX_Text(pFX, _T("[path4]"), path4);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstPath diagnostics

#ifdef _DEBUG
void CRstPath::AssertValid() const
{
	CRecordset::AssertValid();
}

void CRstPath::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG

IMPLEMENT_DYNAMIC(CRstoutsourcing, CRecordset)

CRstoutsourcing::CRstoutsourcing(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstoutsourcing)
	m_id = _T("");
	m_name1 = _T("");
	m_name2 = _T("");
	m_status5 = _T("");
	m_urgent = _T("");
	m_time5 = _T("");
	m_ren = _T("");
	m_name = _T("");
	m_status3 = _T("");
	m_status4 = _T("");
	m_status1 = _T("");
	m_status2 = _T("");
	m_phone1 = _T("");
	m_phone2 = _T("");
	pinyin1 = _T("");
	pinyin2 = _T("");
	qjstatus = _T("");
	m_nFields = 17;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
	m_strSort="id desc";
}


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

CString CRstoutsourcing::GetDefaultSQL()
{
	return _T("[outsourcing]");
}

void CRstoutsourcing::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstoutsourcing)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[id]"), m_id);
	RFX_Text(pFX, _T("[name1]"), m_name1);
	RFX_Text(pFX, _T("[name2]"), m_name2);
	RFX_Text(pFX, _T("[status5]"), m_status5);
	RFX_Text(pFX, _T("[urgent]"), m_urgent);
	RFX_Text(pFX, _T("[time5]"), m_time5);
	RFX_Text(pFX, _T("[ren]"), m_ren);
	RFX_Text(pFX, _T("[name]"), m_name);
	RFX_Text(pFX, _T("[status3]"), m_status3);
	RFX_Text(pFX, _T("[status4]"), m_status4);
	RFX_Text(pFX, _T("[status1]"), m_status1);
	RFX_Text(pFX, _T("[status2]"), m_status2);
	RFX_Text(pFX, _T("[phone1]"), m_phone1);
	RFX_Text(pFX, _T("[phone2]"), m_phone2);
	RFX_Text(pFX, _T("[pinyin1]"), pinyin1);
	RFX_Text(pFX, _T("[pinyin2]"), pinyin2);
	RFX_Text(pFX, _T("[qjstatus]"), qjstatus);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstoutsourcing diagnostics

#ifdef _DEBUG
void CRstoutsourcing::AssertValid() const
{
	CRecordset::AssertValid();
}

void CRstoutsourcing::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG
IMPLEMENT_DYNAMIC(CRstmysalary, CRecordset)

CRstmysalary::CRstmysalary(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstmysalary)
	m_money = _T("");
	m_date = _T("");
	m_kind = _T("");
	m_name1 = _T("");
	m_name2 = _T("");
	m_id = _T("");
	m_ren = _T("");
	m_nFields = 7;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
	m_strSort="kind desc,id desc";
}


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

CString CRstmysalary::GetDefaultSQL()
{
	return _T("[mysalary]");
}

void CRstmysalary::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstmysalary)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[money]"), m_money);
	RFX_Text(pFX, _T("[date]"), m_date);
	RFX_Text(pFX, _T("[kind]"), m_kind);
	RFX_Text(pFX, _T("[name1]"), m_name1);
	RFX_Text(pFX, _T("[name2]"), m_name2);
	RFX_Text(pFX, _T("[id]"), m_id);
	RFX_Text(pFX, _T("[ren]"), m_ren);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstmysalary diagnostics

#ifdef _DEBUG
void CRstmysalary::AssertValid() const
{
	CRecordset::AssertValid();
}

void CRstmysalary::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG

IMPLEMENT_DYNAMIC(CRstmysalary2, CRecordset)

CRstmysalary2::CRstmysalary2(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstmysalary2)
	m_money = _T("");
	m_date = _T("");
	m_kind = _T("");
	m_name1 = _T("");
	m_name2 = _T("");
	m_id = _T("");
	m_ren = _T("");
	m_nFields = 7;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
	m_strSort="kind desc,id desc";
}


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

CString CRstmysalary2::GetDefaultSQL()
{
	return _T("[mysalary2]");
}

void CRstmysalary2::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstmysalary2)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[money]"), m_money);
	RFX_Text(pFX, _T("[date]"), m_date);
	RFX_Text(pFX, _T("[kind]"), m_kind);
	RFX_Text(pFX, _T("[name1]"), m_name1);
	RFX_Text(pFX, _T("[name2]"), m_name2);
	RFX_Text(pFX, _T("[id]"), m_id);
	RFX_Text(pFX, _T("[ren]"), m_ren);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstmysalary2 diagnostics

#ifdef _DEBUG
void CRstmysalary2::AssertValid() const
{
	CRecordset::AssertValid();
}

void CRstmysalary2::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG


IMPLEMENT_DYNAMIC(CRstDindanForm5, CRecordset)
CRstDindanForm5::CRstDindanForm5(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstDindanForm5)
	m_id = _T("");
	m_name1 = _T("");
	m_name2 = _T("");
	m_status4 = _T("");
	m_status2 = _T("");
	m_status6 = _T("");
	m_ren = _T("");
	m_taoxiname = _T("");
	m_taoxijiage = _T("");
	m_phone1 = _T("");
	m_phone2 = _T("");
	m_waiter5 = _T("");
	m_waiter7 = _T("");
	m_pinyin1 = _T("");
	m_pinyin2 = _T("");
	m_urgent = _T("");
	m_time5 = _T("");
	m_nFields = 17;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
	m_strSort="id desc";
}


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

CString CRstDindanForm5::GetDefaultSQL()
{
	return _T("[dindan]");
}

void CRstDindanForm5::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstDindanForm5)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[id]"), m_id);
	RFX_Text(pFX, _T("[name1]"), m_name1);
	RFX_Text(pFX, _T("[name2]"), m_name2);
	RFX_Text(pFX, _T("[status4]"), m_status4);
	RFX_Text(pFX, _T("[status2]"), m_status2);
	RFX_Text(pFX, _T("[status6]"), m_status6);
	RFX_Text(pFX, _T("[ren]"), m_ren);
	RFX_Text(pFX, _T("[taoxiname]"), m_taoxiname);
	RFX_Text(pFX, _T("[taoxijiage]"), m_taoxijiage);
	RFX_Text(pFX, _T("[phone1]"), m_phone1);
	RFX_Text(pFX, _T("[phone2]"), m_phone2);
	RFX_Text(pFX, _T("[waiter5]"), m_waiter5);
	RFX_Text(pFX, _T("[waiter7]"), m_waiter7);
	RFX_Text(pFX, _T("[pinyin1]"), m_pinyin1);
	RFX_Text(pFX, _T("[pinyin2]"), m_pinyin2);
	RFX_Text(pFX, _T("[urgent]"), m_urgent);
	RFX_Text(pFX, _T("[time5]"), m_time5);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstDindanForm5 diagnostics

#ifdef _DEBUG
void CRstDindanForm5::AssertValid() const
{
	CRecordset::AssertValid();
}

void CRstDindanForm5::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG

IMPLEMENT_DYNAMIC(CRstPhotoPrint, CRecordset)
CRstPhotoPrint::CRstPhotoPrint(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstPhotoPrint)
	m_count = _T("");
	m_id = _T("");
	m_name = _T("");
	m_status1 = _T("");
	m_status2 = _T("");
	m_nFields = 5;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
	m_strSort="id desc,name desc";
}


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

CString CRstPhotoPrint::GetDefaultSQL()
{
	return _T("[photoprint]");
}

void CRstPhotoPrint::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstPhotoPrint)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[id]"), m_id);
	RFX_Text(pFX, _T("[count]"), m_count);
	RFX_Text(pFX, _T("[name]"), m_name);
	RFX_Text(pFX, _T("[status1]"), m_status1);
	RFX_Text(pFX, _T("[status2]"), m_status2);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstPhotoPrint diagnostics

#ifdef _DEBUG
void CRstPhotoPrint::AssertValid() const
{
	CRecordset::AssertValid();
}

void CRstPhotoPrint::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG


IMPLEMENT_DYNAMIC(CRstPhotoPrintForm, CRecordset)

CRstPhotoPrintForm::CRstPhotoPrintForm(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstPhotoPrintForm)
	m_id = _T("");
	m_name1 = _T("");
	m_name2 = _T("");
	m_phone1 = _T("");
	m_phone2 = _T("");
	m_pinyin1 = _T("");
	m_pinyin2 = _T("");
	m_name = _T("");
	m_count = _T("");
	m_status1 = _T("");
	m_status2 = _T("");
	m_nFields = 11;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
	m_strSort="id desc,name desc";
}


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

CString CRstPhotoPrintForm::GetDefaultSQL()
{
	return _T("[photoprintform]");
}

void CRstPhotoPrintForm::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstPhotoPrintForm)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[id]"), m_id);
	RFX_Text(pFX, _T("[name1]"), m_name1);
	RFX_Text(pFX, _T("[name2]"), m_name2);
	RFX_Text(pFX, _T("[phone1]"), m_phone1);
	RFX_Text(pFX, _T("[phone2]"), m_phone2);
	RFX_Text(pFX, _T("[pinyin1]"), m_pinyin1);
	RFX_Text(pFX, _T("[pinyin2]"), m_pinyin2);
	RFX_Text(pFX, _T("[name]"), m_name);
	RFX_Text(pFX, _T("[count]"), m_count);
	RFX_Text(pFX, _T("[status1]"), m_status1);
	RFX_Text(pFX, _T("[status2]"), m_status2);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstPhotoPrintForm diagnostics

#ifdef _DEBUG
void CRstPhotoPrintForm::AssertValid() const
{
	CRecordset::AssertValid();
}

void CRstPhotoPrintForm::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG

IMPLEMENT_DYNAMIC(CRstHistorydb, CRecordset)

CRstHistorydb::CRstHistorydb(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstHistorydb)
	year = _T("");
	m_nFields = 1;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
	m_strSort="year desc";
}


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

CString CRstHistorydb::GetDefaultSQL()
{
	return _T("[historydb]");
}

void CRstHistorydb::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstHistorydb)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[year]"), year);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstHistorydb diagnostics

#ifdef _DEBUG
void CRstHistorydb::AssertValid() const
{
	CRecordset::AssertValid();
}

void CRstHistorydb::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG


IMPLEMENT_DYNAMIC(CRstFlowChart, CRecordset)

CRstFlowChart::CRstFlowChart(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstFlowChart)
	m_id = _T("");
	m_name1 = _T("");
	m_name2 = _T("");
	m_phone1 = _T("");
	m_phone2 = _T("");
	m_urgent = _T("");
	m_time2 = _T("");
	m_time4 = _T("");
	m_time5 = _T("");
	m_takezs = _T("");
	m_taoxizs = _T("");
	m_choosezs = _T("");
	m_ren = _T("");
	m_waiter3 = _T("");
	m_waiter1 = _T("");
	m_waiter2 = _T("");
	m_waiter4 = _T("");
	m_bz3 = _T("");
	m_money3 = _T("");
	m_nFields = 19;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
 
}


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

CString CRstFlowChart::GetDefaultSQL()
{
	return _T("[dindan]");
}

void CRstFlowChart::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstFlowChart)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[id]"), m_id);
	RFX_Text(pFX, _T("[name1]"), m_name1);
	RFX_Text(pFX, _T("[name2]"), m_name2);
	RFX_Text(pFX, _T("[phone1]"), m_phone1);
	RFX_Text(pFX, _T("[phone2]"), m_phone2);
	RFX_Text(pFX, _T("[urgent]"), m_urgent);
	RFX_Text(pFX, _T("[time2]"), m_time2);
	RFX_Text(pFX, _T("[time4]"), m_time4);
	RFX_Text(pFX, _T("[time5]"), m_time5);
	RFX_Text(pFX, _T("[takezs]"), m_takezs);
	RFX_Text(pFX, _T("[taoxizs]"), m_taoxizs);
	RFX_Text(pFX, _T("[choosezs]"), m_choosezs);
	RFX_Text(pFX, _T("[ren]"), m_ren);
	RFX_Text(pFX, _T("[waiter3]"), m_waiter3);
	RFX_Text(pFX, _T("[waiter1]"), m_waiter1);
	RFX_Text(pFX, _T("[waiter2]"), m_waiter2);
	RFX_Text(pFX, _T("[waiter4]"), m_waiter4);
	RFX_Text(pFX, _T("[bz3]"), m_bz3);
	RFX_Text(pFX, _T("[money3]"), m_money3);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstFlowChart diagnostics

#ifdef _DEBUG
void CRstFlowChart::AssertValid() const
{
	CRecordset::AssertValid();
}

void CRstFlowChart::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG


IMPLEMENT_DYNAMIC(CRstAlumb, CRecordset)

CRstAlumb::CRstAlumb(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstAlumb)
	m_id = _T("");
	m_date = _T("");
	m_name = _T("");
	m_size = _T("");
	m_count = _T("");
	m_inside = _T("");
	m_cover = _T("");
	m_bz = _T("");
	m_nFields = 8;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_strSort="id desc,date desc";
	m_nDefaultType = snapshot;
}


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

CString CRstAlumb::GetDefaultSQL()
{
	return _T("[alumb]");
}

void CRstAlumb::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstAlumb)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[id]"), m_id);
	RFX_Text(pFX, _T("[date]"), m_date);
	RFX_Text(pFX, _T("[name]"), m_name);
	RFX_Text(pFX, _T("[size]"), m_size);
	RFX_Text(pFX, _T("[count]"), m_count);
	RFX_Text(pFX, _T("[inside]"), m_inside);
	RFX_Text(pFX, _T("[cover]"), m_cover);
	RFX_Text(pFX, _T("[bz]"), m_bz, 1024);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstAlumb diagnostics

#ifdef _DEBUG
void CRstAlumb::AssertValid() const
{
	CRecordset::AssertValid();
}

void CRstAlumb::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG



IMPLEMENT_DYNAMIC(CRstClientInfo, CRecordset)

CRstClientInfo::CRstClientInfo(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstClientInfo)
	m_account = _T("");
	m_balance = _T("");
	m_name = _T("");
	m_phone = _T("");
	m_qq = _T("");
	m_addr = _T("");
	m_remark = _T("");
	m_applydate = _T("");
	m_psw = _T("");
	m_nFields = 9;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_strSort="applydate desc";
	m_nDefaultType = forwardOnly;
}


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

CString CRstClientInfo::GetDefaultSQL()
{
	return _T("[clientinfo]");
}

void CRstClientInfo::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstClientInfo)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[account]"), m_account);
	RFX_Text(pFX, _T("[balance]"), m_balance);
	RFX_Text(pFX, _T("[name]"), m_name);
	RFX_Text(pFX, _T("[phone]"), m_phone);
	RFX_Text(pFX, _T("[qq]"), m_qq);
	RFX_Text(pFX, _T("[addr]"), m_addr);
	RFX_Text(pFX, _T("[remark]"), m_remark, 1024);
	RFX_Text(pFX, _T("[applydate]"), m_applydate);
	RFX_Text(pFX, _T("[psw]"), m_psw);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstClientInfo diagnostics

#ifdef _DEBUG
void CRstClientInfo::AssertValid() const
{
	CRecordset::AssertValid();
}

void CRstClientInfo::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG

IMPLEMENT_DYNAMIC(CRstClientIP, CRecordset)

CRstClientIP::CRstClientIP(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstClientIP)
	m_name = _T("");
	m_name2 = _T("");
	m_ip = _T("");
	m_datetime = _T("");
	m_bz = _T("");
	m_enterprisename = _T("");
	m_applydate = _T("");
	m_bmain = _T("");
	m_branchname = _T("");
	m_rights = _T("");
	regcode2 = _T("");
	m_nFields = 11;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
	m_strSort="enterprisename desc,modifydate desc";
}


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

CString CRstClientIP::GetDefaultSQL()
{
	return _T("[clientip]");
}

void CRstClientIP::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstClientIP)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[name]"), m_name);
	RFX_Text(pFX, _T("[name2]"), m_name2);
	RFX_Text(pFX, _T("[ip]"), m_ip);
	RFX_Text(pFX, _T("[datetime]"), m_datetime);
	RFX_Text(pFX, _T("[enterprisename]"), m_enterprisename);
	RFX_Text(pFX, _T("[applydate]"), m_applydate);
	RFX_Text(pFX, _T("[bmain]"), m_bmain);
	RFX_Text(pFX, _T("[regcode2]"), regcode2);
	RFX_Text(pFX, _T("[branchname]"), m_branchname);
	RFX_Text(pFX, _T("[rights]"), m_rights, 1024);
	RFX_Text(pFX, _T("[bz]"), m_bz, 1024);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstClientIP diagnostics

#ifdef _DEBUG
void CRstClientIP::AssertValid() const
{
	CRecordset::AssertValid();
}

void CRstClientIP::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG

IMPLEMENT_DYNAMIC(RstReCharge, CRecordset)

RstReCharge::RstReCharge(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(RstReCharge)
	m_account = _T("");
	m_money = _T("");
	m_count = _T("");
	m_timestamp = _T("");
	m_nFields = 4;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_strSort="timestamp desc";
	m_nDefaultType = forwardOnly;
}


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

CString RstReCharge::GetDefaultSQL()
{
	return _T("[recharge]");
}

void RstReCharge::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(RstReCharge)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[account]"), m_account);
	RFX_Text(pFX, _T("[money]"), m_money);
	RFX_Text(pFX, _T("[count]"), m_count);
	RFX_Text(pFX, _T("[timestamp]"), m_timestamp);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// RstReCharge diagnostics

#ifdef _DEBUG
void RstReCharge::AssertValid() const
{
	CRecordset::AssertValid();
}

void RstReCharge::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG


IMPLEMENT_DYNAMIC(RstSendReg, CRecordset)

RstSendReg::RstSendReg(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(RstSendReg)
	m_account = _T("");
	m_phones = _T("");
	m_content = _T("");
	m_timestamp = _T("");
	m_msgcount = _T("");
	m_msgcount2 = _T("");
	m_id = _T("");
	m_nFields = 7;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
	m_strSort="account desc,timestamp desc,phones desc";
}


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

CString RstSendReg::GetDefaultSQL()
{
	return _T("[sendreg]");
}

void RstSendReg::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(RstSendReg)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[autoid]"), m_id);
	RFX_Text(pFX, _T("[account]"), m_account);
	RFX_Text(pFX, _T("[phones]"), m_phones, 102400);
	RFX_Text(pFX, _T("[content]"), m_content, 102400);
	RFX_Text(pFX, _T("[timestamp]"), m_timestamp);
	RFX_Text(pFX, _T("[msgcount]"), m_msgcount);
	RFX_Text(pFX, _T("[msgcount2]"), m_msgcount2);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// RstSendReg diagnostics

#ifdef _DEBUG
void RstSendReg::AssertValid() const
{
	CRecordset::AssertValid();
}

void RstSendReg::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG


IMPLEMENT_DYNAMIC(RstSendRegForm, CRecordset)

RstSendRegForm::RstSendRegForm(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(RstSendRegForm)
	m_account = _T("");
	m_phones = _T("");
	m_content = _T("");
	m_timestamp = _T("");
	m_msgcount = _T("");
	m_msgcount2 = _T("");
	m_name = _T("");
	m_log = _T("");
	m_id = _T("");
	m_nFields = 9;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
    m_strSort="autoid desc";
}


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

CString RstSendRegForm::GetDefaultSQL()
{
	return _T("[sendregform]");
}

void RstSendRegForm::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(RstSendRegForm)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[account]"), m_account);
	RFX_Text(pFX, _T("[phones]"), m_phones, 102400);
	RFX_Text(pFX, _T("[content]"), m_content, 102400);
	RFX_Text(pFX, _T("[timestamp]"), m_timestamp);
	RFX_Text(pFX, _T("[msgcount]"), m_msgcount);
	RFX_Text(pFX, _T("[msgcount2]"), m_msgcount2);
	RFX_Text(pFX, _T("[name]"), m_name);
	RFX_Text(pFX, _T("[log]"), m_log);
	RFX_Text(pFX, _T("[autoid]"), m_id);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// RstSendRegForm diagnostics

#ifdef _DEBUG
void RstSendRegForm::AssertValid() const
{
	CRecordset::AssertValid();
}

void RstSendRegForm::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG