lyfz_repos/经典版源码/lyfzddfServer/trunk/Services Trunk1/mysqldata.cpp

// MySqlData.cpp : implementation file
// 

#include "stdafx.h"
#include "mysqldata.h"
#include "DBServer.h"
#include <math.h>
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////delphotos

/////////////////////////////////////////////////////////////////////////////
// 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

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


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

CString CRstJD::GetDefaultSQL()
{
	return _T("[jd]");
}

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

/////////////////////////////////////////////////////////////////////////////
// CRstJD diagnostics

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

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

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


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

CString CRstTXLB::GetDefaultSQL()
{
	return _T("[txlb]");
}

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

/////////////////////////////////////////////////////////////////////////////
// CRstTXLB diagnostics

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

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

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


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

CString CRstGrowthTX::GetDefaultSQL()
{
	return _T("[growthtx]");
}

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

/////////////////////////////////////////////////////////////////////////////
// CRstGrowthTX diagnostics

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

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

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


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

CString CRstWorkType::GetDefaultSQL()
{
	return _T("[worktype]");
}

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

/////////////////////////////////////////////////////////////////////////////
// CRstWorkType diagnostics

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

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

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


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

CString CRstExpendType::GetDefaultSQL()
{
	return _T("[expendtype]");
}

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

/////////////////////////////////////////////////////////////////////////////
// CRstExpendType diagnostics

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

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

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


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

CString CRstBaseExpendType::GetDefaultSQL()
{
	return _T("[baseexpendtype]");
}

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

/////////////////////////////////////////////////////////////////////////////
// CRstBaseExpendType diagnostics

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

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

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


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

CString CRstjdd::GetDefaultSQL()
{
	return _T("[jdd]");
}

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

/////////////////////////////////////////////////////////////////////////////
// CRstjdd diagnostics

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

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

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


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

CString CRstdressarea::GetDefaultSQL()
{
	return _T("[dressarea]");
}

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

/////////////////////////////////////////////////////////////////////////////
// CRstdressarea diagnostics

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

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

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


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

CString CRsttxlb2::GetDefaultSQL()
{
	return _T("[txlb2]");
}

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

/////////////////////////////////////////////////////////////////////////////
// CRsttxlb2 diagnostics

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

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

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


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

CString CRstsale2type::GetDefaultSQL()
{
	return _T("[sale2type]");
}

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

/////////////////////////////////////////////////////////////////////////////
// CRstsale2type diagnostics

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

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

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


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

CString CRstclientfrom::GetDefaultSQL()
{
	return _T("[clientfrom]");
}

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

/////////////////////////////////////////////////////////////////////////////
// CRstclientfrom diagnostics

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

void CRstclientfrom::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG
IMPLEMENT_DYNAMIC(CRstclientreason, CRecordset)
CRstclientreason::CRstclientreason(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstclientreason)
	m_name = _T("");
	m_nFields = 1;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
}


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

CString CRstclientreason::GetDefaultSQL()
{
	return _T("[clientreason]");
}

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

/////////////////////////////////////////////////////////////////////////////
// CRstclientreason diagnostics

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

void CRstclientreason::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG
IMPLEMENT_DYNAMIC(CRstArea, CRecordset)
CRstArea::CRstArea(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstArea)
	m_name = _T("");
	m_nFields = 1;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
}


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

CString CRstArea::GetDefaultSQL()
{
	return _T("[area]");
}

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

/////////////////////////////////////////////////////////////////////////////
// CRstArea diagnostics

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

void CRstArea::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("");
	spjiage3 = _T("");
	splb = _T("");
	spbz = _T("");
	hide = _T("");
	m_nFields = 9;
	//}}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("[spjiage3]"), spjiage3);
	RFX_Text(pFX, _T("[splb]"), splb);
	RFX_Text(pFX, _T("[hide]"), hide);
	RFX_Text(pFX, _T("[spbz]"), spbz, 4096);
	//}}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("");
	address2 = _T("");
	idno = _T("");
	marry = _T("");
	dimission = _T("");
	loginno1 = _T("");
	loginno2 = _T("");
	m_nFields = 14;
	//}}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, 4096);
	RFX_Text(pFX, _T("[address2]"), address2);
	RFX_Text(pFX, _T("[idno]"), idno);
	RFX_Text(pFX, _T("[marry]"), marry);
	RFX_Text(pFX, _T("[dimission]"), dimission);
	RFX_Text(pFX, _T("[loginno1]"), loginno1);
	RFX_Text(pFX, _T("[loginno2]"), loginno2);	RFX_Text(pFX, _T("[level]"), level);
	//}}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(CRstRenYuanPhoto, CRecordset)
CRstRenYuanPhoto::CRstRenYuanPhoto(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstRenYuanPhoto)
	m_nFields = 1;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = dynamic;
}


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

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

void CRstRenYuanPhoto::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstRenYuanPhoto)
	pFX->SetFieldType(CFieldExchange::outputColumn);
    RFX_LongBinary(pFX, _T("[photo]"), photo);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstRenYuanPhoto diagnostics

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

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

IMPLEMENT_DYNAMIC(CRstClientPhoto, CRecordset)
CRstClientPhoto::CRstClientPhoto(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstClientPhoto)
	m_nFields = 1;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = dynamic;
}


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

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

void CRstClientPhoto::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstClientPhoto)
	pFX->SetFieldType(CFieldExchange::outputColumn);
    RFX_LongBinary(pFX, _T("[photo]"), photo);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstClientPhoto diagnostics

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

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

IMPLEMENT_DYNAMIC(CRstclientcontract, CRecordset)
CRstclientcontract::CRstclientcontract(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstclientcontract)
	m_nFields = 3;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = dynamic;
}


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

CString CRstclientcontract::GetDefaultSQL()
{
	return _T("[clientcontract]");
}

void CRstclientcontract::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstclientcontract)
	pFX->SetFieldType(CFieldExchange::outputColumn);
    RFX_LongBinary(pFX, _T("[photo]"), photo);
	RFX_Text(pFX, _T("[date]"), date);	RFX_Text(pFX, _T("[id]"), id);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstclientcontract diagnostics

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

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

IMPLEMENT_DYNAMIC(CRstclientcontract2, CRecordset)
CRstclientcontract2::CRstclientcontract2(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstclientcontract2)
	m_nFields = 1;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
	m_strSort="date";
}


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

CString CRstclientcontract2::GetDefaultSQL()
{
	return _T("[clientcontract]");
}

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

/////////////////////////////////////////////////////////////////////////////
// CRstclientcontract2 diagnostics

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

void CRstclientcontract2::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG
IMPLEMENT_DYNAMIC(CRstgudingfeiyongPhoto, CRecordset)
CRstgudingfeiyongPhoto::CRstgudingfeiyongPhoto(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstgudingfeiyongPhoto)
	m_nFields = 1;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = dynamic;
}


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

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

void CRstgudingfeiyongPhoto::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstgudingfeiyongPhoto)
	pFX->SetFieldType(CFieldExchange::outputColumn);
    RFX_LongBinary(pFX, _T("[photo]"), photo);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstgudingfeiyongPhoto diagnostics

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

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

IMPLEMENT_DYNAMIC(CRstinsidemsgFile, CRecordset)
CRstinsidemsgFile::CRstinsidemsgFile(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstinsidemsgFile)
	m_nFields = 1;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = dynamic;
}


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

CString CRstinsidemsgFile::GetDefaultSQL()
{
	return _T("[insidemsg]");
}

void CRstinsidemsgFile::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstinsidemsgFile)
	pFX->SetFieldType(CFieldExchange::outputColumn);
    RFX_LongBinary(pFX, _T("[files]"), files);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstinsidemsgFile diagnostics

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

void CRstinsidemsgFile::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG
 
 
IMPLEMENT_DYNAMIC(CRstversion2, CRecordset)
CRstversion2::CRstversion2(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstversion2)
	m_nFields = 1;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = dynamic;
}


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

CString CRstversion2::GetDefaultSQL()
{
	return _T("[version]");
}

void CRstversion2::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstversion2)
	pFX->SetFieldType(CFieldExchange::outputColumn);
    RFX_LongBinary(pFX, _T("[photo]"), photo);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstversion2 diagnostics

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

void CRstversion2::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("");
	type = _T("");
	show = _T("");
	m_nFields = 6;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
	m_strSort="type,taoxiname";
}


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);
	RFX_Text(pFX, _T("[type]"), type);
	RFX_Text(pFX, _T("[show]"), show);
	//}}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, 4096);
	//}}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(CRstdindanclientview, CRecordset)
CRstdindanclientview::CRstdindanclientview(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstdindanclientview)
	m_nFields = 14;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
}


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

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

void CRstdindanclientview::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstdindanclientview)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	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("[birthday1]"), birthday1);
	RFX_Text(pFX, _T("[birthday2]"), birthday2);
	RFX_Text(pFX, _T("[check1]"), check1);
	RFX_Text(pFX, _T("[check2]"), check2);
	RFX_Text(pFX, _T("[check3]"), check3);
	RFX_Text(pFX, _T("[time3]"), time3);
 	RFX_Text(pFX, _T("[time1]"), time1);
	RFX_Text(pFX, _T("[taoxiname]"), taoxiname);
	RFX_Text(pFX, _T("[taoxijiage]"), taoxijiage);
	RFX_Text(pFX, _T("[payed4]"), payed4);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstdindanclientview diagnostics

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

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

IMPLEMENT_DYNAMIC(CRstalarmview, CRecordset)
CRstalarmview::CRstalarmview(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstalarmview)
	//m_nFields = 14; // modify at 2014.06.12
	m_nFields = 16;	  // modify at 2014.06.12	
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
	m_strSort="id";
}


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

CString CRstalarmview::GetDefaultSQL()
{
	return _T("[alarmview]");
}

void CRstalarmview::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstalarmview)
	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("[time1]"), time1);
	RFX_Text(pFX, _T("[time2]"), time2);	// Jeff add at 2014.06.12:拍照时间;
	RFX_Text(pFX, _T("[time4]"), time4);	// Jeff add at 2014.06.12:选片时间;
	RFX_Text(pFX, _T("[status]"), status);
	RFX_Text(pFX, _T("[status2]"), status2);
	RFX_Text(pFX, _T("[status8]"), status8);
	RFX_Text(pFX, _T("[cot1]"), cot1);
	RFX_Text(pFX, _T("[cot2]"), cot2);
	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
}

/////////////////////////////////////////////////////////////////////////////
// CRstalarmview diagnostics

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

void CRstalarmview::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG
IMPLEMENT_DYNAMIC(CRstBooking, CRecordset)
CRstBooking::CRstBooking(CDatabase* pdb)
	: CRecordset(pdb)
{
	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("");
	bz2 = _T("");
	bz3 = _T("");
	urgent = _T("");
	waiter6 = _T("");
	waiter5 = _T("");
	waiter7 = _T("");
	waiter8 = _T("");	// add by Jeff;
	status4 = _T("");
	status5 = _T("");
	status6 = _T("");
	memberno = _T("");
	time6 = _T("");
	waiter12 = _T("");
	waiter22 = _T("");
	waiter1rate = _T("");
	waiter2rate = _T("");
	txtype = _T("");
	ren2 = _T("");
	delphotos = _T("");
	delphotos2 = _T("");
	status8 = _T("");
	growthtxselname = _T("");
	designno = _T("");
	designreplaceno = _T("");
	size = _T("");
	phone1 = _T("");
	phone2 = _T("");

	dindantype = _T("");
	contractno1 = _T("");
	contractno2 = _T("");
	cfno = _T("");
	from = _T("");
	reason = _T("");
	time7 = _T("");
	waiter13 = _T("");
	waiter14 = _T("");
	time8 = _T("");
	time9 = _T("");
	time10 = _T("");
	
	//m_nFields = 78;
	m_nFields = 79;		// modify by Jeff,添加了新的字段waiter8:看设计人;

	//}}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)
{
	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, 4096);
	RFX_Text(pFX, _T("[bz2]"),bz2, 4096);
	RFX_Text(pFX, _T("[bz3]"),bz3, 4096);
	RFX_Text(pFX, _T("[bz4]"),bz4, 4096);
	RFX_Text(pFX, _T("[size]"),size, 4096);
	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);
	RFX_Text(pFX, _T("[memberno]"),memberno);
	RFX_Text(pFX, _T("[time6]"),time6);
	RFX_Text(pFX, _T("[waiter12]"),waiter12);
	RFX_Text(pFX, _T("[waiter22]"),waiter22);
	RFX_Text(pFX, _T("[waiter1rate]"),waiter1rate);
	RFX_Text(pFX, _T("[waiter2rate]"),waiter2rate);
	RFX_Text(pFX, _T("[ren2]"),ren2);
	RFX_Text(pFX, _T("[txtype]"),txtype);
	RFX_Text(pFX, _T("[status8]"),status8);
	RFX_Text(pFX, _T("[phone1]"),phone1);
	RFX_Text(pFX, _T("[phone2]"),phone2);
	RFX_Text(pFX, _T("[delphotos]"),delphotos, 10240);
	RFX_Text(pFX, _T("[delphotos2]"),delphotos2, 10240);
	RFX_Text(pFX, _T("[growthtxselname]"),growthtxselname, 4096);
	RFX_Text(pFX, _T("[designno]"),designno, 4096);
	RFX_Text(pFX, _T("[designreplaceno]"),designreplaceno, 4096);
	RFX_Text(pFX, _T("[dindantype]"),dindantype);
	RFX_Text(pFX, _T("[contractno1]"),contractno1);
	RFX_Text(pFX, _T("[contractno2]"),contractno2);
	RFX_Text(pFX, _T("[cfno]"),cfno);
	RFX_Text(pFX, _T("[from]"),from);
	RFX_Text(pFX, _T("[reason]"),reason);
	RFX_Text(pFX, _T("[time7]"),time7);
	RFX_Text(pFX, _T("[waiter13]"),waiter13);
	RFX_Text(pFX, _T("[waiter14]"),waiter14);
 	RFX_Text(pFX, _T("[time8]"),time8);
	RFX_Text(pFX, _T("[time9]"),time9);
	RFX_Text(pFX, _T("[time10]"),time10);
	RFX_Text(pFX, _T("[waiter8]"),waiter8);		// add by Jeff;
	//}}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("");
	no2 = _T("");
	autoid = _T("");
	m_nFields = 11;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
	m_strSort="id desc,kind,name";
}

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, 4096);
	RFX_Text(pFX, _T("[no2]"), no2, 4096);
	RFX_Text(pFX, _T("[autoid]"), autoid);	
	RFX_Text(pFX, _T("[ps]"), ps);
	RFX_Text(pFX, _T("[zs]"), zs);
	//}}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(CRstDinDanSPView2, CRecordset)
CRstDinDanSPView2::CRstDinDanSPView2(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstDinDanSPView2)
	id = _T("");
	spid = _T("");
	price = _T("");
	shuliang = _T("");
	kind = _T("");
	name = _T("");
	no = _T("");
	no2 = _T("");
	autoid = _T("");
	m_nFields = 12;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
	m_strSort="splb desc,name desc";
}

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

CString CRstDinDanSPView2::GetDefaultSQL()
{
	return _T("[dindanspview2]");
}

void CRstDinDanSPView2::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstDinDanSPView2)
	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, 4096);
	RFX_Text(pFX, _T("[no2]"), no2, 4096);
	RFX_Text(pFX, _T("[autoid]"), autoid);	
	RFX_Text(pFX, _T("[ps]"), ps);
	RFX_Text(pFX, _T("[zs]"), zs);	
	RFX_Text(pFX, _T("[splb]"), splb);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstDinDanSPView2 diagnostics

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

void CRstDinDanSPView2::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG
IMPLEMENT_DYNAMIC(CRstDinDanSP3, CRecordset)
CRstDinDanSP3::CRstDinDanSP3(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstDinDanSP3)
	kind = _T("");
	name = _T("");
	hqdate = _T("");
	hqtime = _T("");
	id = _T("");
	m_nFields = 10;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
	m_strSort="id desc,name";
}

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

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

void CRstDinDanSP3::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstDinDanSP3)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[kind]"), kind);
	RFX_Text(pFX, _T("[name]"), name);
	RFX_Text(pFX, _T("[hqdate]"), hqdate);
	RFX_Text(pFX, _T("[hqtime]"), hqtime);
	RFX_Text(pFX, _T("[id]"), id);
	RFX_Text(pFX, _T("[ren1]"), ren1);
	RFX_Text(pFX, _T("[ren2]"), ren2);	
	RFX_Text(pFX, _T("[hqstatus]"), hqstatus);
	RFX_Text(pFX, _T("[autoid]"), autoid);	RFX_Text(pFX, _T("[bz]"), bz, 200);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstDinDanSP3 diagnostics

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

void CRstDinDanSP3::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("");
	no2 = _T("");
	autoid = _T("");
	spid = _T("");
	date1 = _T("");
	date2 = _T("");
	date3 = _T("");
	date4 = _T("");
	name1 = _T("");
	name2 = _T("");
	name3 = _T("");
	name4 = _T("");
	price = _T("");
	urgent = _T("");
	taketime = _T("");
	growthtxname = _T("");
	m_nFields = 32;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
	m_strSort="id desc,name";
}


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, 4096);
	RFX_Text(pFX, _T("[no2]"), no2, 4096);
	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);
	RFX_Text(pFX, _T("[price]"), price);
	RFX_Text(pFX, _T("[urgent]"), urgent);
	RFX_Text(pFX, _T("[taketime]"), taketime);
	RFX_Text(pFX, _T("[growthtxname]"), growthtxname);
	RFX_Text(pFX, _T("[status5]"), status5);
	RFX_Text(pFX, _T("[status6]"), status6);
	RFX_Text(pFX, _T("[date5]"), date5);
	RFX_Text(pFX, _T("[date6]"), date6);
	RFX_Text(pFX, _T("[name5]"), name5);
 	RFX_Text(pFX, _T("[name6]"), name6);
	RFX_Text(pFX, _T("[ps]"), ps);
 	RFX_Text(pFX, _T("[zs]"), zs);
	//}}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("");
	financecheck = _T("");
	m_nFields = 12;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb;
	m_strSort="name";
}


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("[financecheck]"), financecheck);
	RFX_Text(pFX, _T("[financecheck2]"), financecheck2);
	RFX_Text(pFX, _T("[financecheck3]"), financecheck3);	
	RFX_Text(pFX, _T("[hasphoto]"), hasphoto);
	RFX_Text(pFX, _T("[bz]"), bz, 4096);
	RFX_Text(pFX, _T("[time]"), time);
	//}}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("");
	pinyin = _T("");
	date = _T("");
	renyuan1 = _T("");
	renyuan2 = _T("");
	renyuan3 = _T("");
	bz = _T("");
	sale2type = _T("");
	paytype = _T("");
	phone = _T("");
	payed = _T("");
	balance = _T("");
	financecheck = _T("");
	m_nFields = 17;
	//}}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("[sale2type]"), sale2type);
	RFX_Text(pFX, _T("[paytype]"), paytype);
	RFX_Text(pFX, _T("[bz]"), bz, 4096);
	RFX_Text(pFX, _T("[phone]"), phone);
	RFX_Text(pFX, _T("[payed]"), payed);
	RFX_Text(pFX, _T("[balance]"), balance);
	RFX_Text(pFX, _T("[pinyin]"), pinyin);
	RFX_Text(pFX, _T("[financecheck]"), financecheck);
	RFX_Text(pFX, _T("[count]"), count);
	RFX_Text(pFX, _T("[time]"), time);
	//}}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("");
	area = _T("");
	area2 = _T("");
	check1 = _T("");
	check2 = _T("");
	check3 = _T("");
	sex = _T("");
	zodiac = _T("");
	time3 = _T("");
	m_nFields = 21;
	//}}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);
	RFX_Text(pFX, _T("[area]"), area);
	RFX_Text(pFX, _T("[area2]"), area2);
	RFX_Text(pFX, _T("[check1]"), check1);
	RFX_Text(pFX, _T("[check2]"), check2);
	RFX_Text(pFX, _T("[check3]"), check3);
	RFX_Text(pFX, _T("[sex]"), sex);
	RFX_Text(pFX, _T("[zodiac]"), zodiac);
	RFX_Text(pFX, _T("[time3]"), time3);
	//}}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(CRstClient2, CRecordset)
CRstClient2::CRstClient2(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstClient2)
	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("");
	area = _T("");
	area2 = _T("");
	check1 = _T("");
	check2 = _T("");
	check3 = _T("");
	sex = _T("");
    zodiac = _T("");
	m_nFields = 20;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
}


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

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

void CRstClient2::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstClient2)
	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("[area]"), area);
	RFX_Text(pFX, _T("[area2]"), area2);
	RFX_Text(pFX, _T("[check1]"), check1);
	RFX_Text(pFX, _T("[check2]"), check2);
	RFX_Text(pFX, _T("[check3]"), check3);
	RFX_Text(pFX, _T("[sex]"), sex);
	RFX_Text(pFX, _T("[zodiac]"), zodiac);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstClient2 diagnostics

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

void CRstClient2::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(CRstDinDanClient2, CRecordset)
CRstDinDanClient2::CRstDinDanClient2(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstDinDanClient2)
	id = _T("");
	name1 = _T("");
	name2 = _T("");
	phone1 = _T("");
	phone2 = _T("");
	qq1 = _T("");
	qq2 = _T("");
	addr1 = _T("");
	addr2 = _T("");
	area1 = _T("");
	area2 = _T("");
	birthday1 = _T("");
	birthday2 = _T("");
	m_nFields = 13;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
	m_strSort="id desc";
}


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

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

void CRstDinDanClient2::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstDinDanClient2)
	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("[area]"), area1);
	RFX_Text(pFX, _T("[area2]"), area2);
	RFX_Text(pFX, _T("[birthday1]"), birthday1);
	RFX_Text(pFX, _T("[birthday2]"), birthday2);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstDinDanClient2 diagnostics

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

void CRstDinDanClient2::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, 4096);
	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, 4096);
	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("");
	time1 = _T("");
	time2 = _T("");
	time3 = _T("");
	taketime = _T("");
 	time4 = _T("");
	time5 = _T("");
	time6 = _T("");
 	datetime4 = _T("");
	datetime5 = _T("");
	datetime6 = _T("");
	ren = _T("");
	waiter1 = _T("");
	waiter2 = _T("");
	waiter3 = _T("");
	status = _T("");
	waiter8 = _T("");
	status8 = _T("");
	status5 = _T("");
	pinyin1 = _T("");
	pinyin2 = _T("");
	// Jeff add waiter6 = _T("");
	xplrr = _T("");
	xplrtime = _T("");
	//m_nFields = 31;
	m_nFields = 33;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
}


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("[time1]"), time1);
	RFX_Text(pFX, _T("[time2]"), time2);
 	RFX_Text(pFX, _T("[time3]"), time3);
	RFX_Text(pFX, _T("[taketime]"), taketime);
	RFX_Text(pFX, _T("[time4]"), time4);
	RFX_Text(pFX, _T("[time5]"), time5);
	RFX_Text(pFX, _T("[time6]"), time6);
	RFX_Text(pFX, _T("[datetime4]"), datetime4);
	RFX_Text(pFX, _T("[datetime5]"), datetime5);
	RFX_Text(pFX, _T("[datetime6]"), datetime6);
	RFX_Text(pFX, _T("[ren]"), ren);
	RFX_Text(pFX, _T("[waiter1]"),waiter1);
	RFX_Text(pFX, _T("[waiter2]"),waiter2);
	RFX_Text(pFX, _T("[waiter3]"),waiter3);
	RFX_Text(pFX, _T("[status]"),status);
	RFX_Text(pFX, _T("[waiter8]"),waiter8);
	RFX_Text(pFX, _T("[status8]"),status8);
	RFX_Text(pFX, _T("[status5]"),status5);
	RFX_Text(pFX, _T("[pinyin1]"),pinyin1);	
	RFX_Text(pFX, _T("[status4]"),status4);
	RFX_Text(pFX, _T("[pinyin2]"),pinyin2);	
	RFX_Text(pFX, _T("[waiter9]"),waiter9);
	// Jeff add
	RFX_Text(pFX, _T("[xplrr]"),xplrr);
	RFX_Text(pFX, _T("[xplrtime]"),xplrtime);
	//}}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(CRsthqview, CRecordset)
CRsthqview::CRsthqview(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRsthqview)
	m_nFields = 17;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
}


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

CString CRsthqview::GetDefaultSQL()
{
	return _T("[hqview]");
}

void CRsthqview::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRsthqview)
	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("[time3]"), time3);
	RFX_Text(pFX, _T("[check3]"), check3);
	RFX_Text(pFX, _T("[ren]"), ren);
	RFX_Text(pFX, _T("[taoxiname]"), taoxiname);
	RFX_Text(pFX, _T("[taoxijiage]"), taoxijiage);
 	RFX_Text(pFX, _T("[name]"), name);
 	RFX_Text(pFX, _T("[hqdate]"), hqdate);
 	RFX_Text(pFX, _T("[hqtime]"), hqtime);
	RFX_Text(pFX, _T("[ren1]"), ren1);
	RFX_Text(pFX, _T("[ren2]"), ren2);
	RFX_Text(pFX, _T("[hqstatus]"), hqstatus);
	RFX_Text(pFX, _T("[bz]"), bz, 200);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRsthqview diagnostics

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

void CRsthqview::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("");
	rights2 = _T("");
	discount = _T("");
	discount2 = _T("");
	m_nFields = 9;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
	m_strSort="bm desc,name desc";
}


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

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

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);
	RFX_Text(pFX, _T("[discount]"), discount);
	RFX_Text(pFX, _T("[rights2]"), rights2, 4096);
	RFX_Text(pFX, _T("[discount2]"), discount2);	RFX_Text(pFX, _T("[level]"), level);	RFX_Text(pFX, _T("[bm]"), bm);
	//}}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("");
	rate3 = _T("");
	rate4 = _T("");
	rate5 = _T("");
	bz = _T("");
	bm = _T("");
	m_nFields = 9;
	//}}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("[rate3]"), rate3);
	RFX_Text(pFX, _T("[rate4]"), rate4);
	RFX_Text(pFX, _T("[rate5]"), rate5);
	RFX_Text(pFX, _T("[bz2]"), bz, 4096);
	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("");
 	time6 = _T("");
	status = _T("");
	status2 = _T("");
	status3 = _T("");
	status4 = _T("");
	status5 = _T("");
	status8 = _T("");
	waiter1 = _T("");
	waiter12 = _T("");
	waiter13 = _T("");
	waiter14 = _T("");
	waiter2 = _T("");
	waiter22 = _T("");
	waiter23 = _T("");
	waiter24 = _T("");
 	waiter8 = _T("");
	waiter4 = _T("");
	phone1 = _T("");
	phone2 = _T("");
	taketime = _T("");
	pinyin1 = _T("");
	pinyin2 = _T("");
	status6 = _T("");
	waiter3 = _T("");
	waiter5 = _T("");
	waiter7 = _T("");
	waiter6 = _T("");
	tichenren1 = _T("");
	tichenren2 = _T("");
 	tichenren3 = _T("");
	tichenren4 = _T("");
	tichenren5 = _T("");
	send1 = _T("");
	send2 = _T("");
	send3 = _T("");
	txtype = _T("");
	outside = _T("");
	discount = _T("");
	discount2 = _T("");
	authorize = _T("");
	authorize2 = _T("");
	contractno1 = _T("");
	contractno2 = _T("");
	m_nFields = 57;
	//}}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("[time6]"), time6);
	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("[status8]"),status8);
	RFX_Text(pFX, _T("[waiter1]"),waiter1);
	RFX_Text(pFX, _T("[waiter12]"),waiter12);
	RFX_Text(pFX, _T("[waiter13]"),waiter13);
	RFX_Text(pFX, _T("[waiter14]"),waiter14);
	RFX_Text(pFX, _T("[waiter2]"),waiter2);
	RFX_Text(pFX, _T("[waiter22]"),waiter22);
	RFX_Text(pFX, _T("[waiter23]"),waiter23);
	RFX_Text(pFX, _T("[waiter24]"),waiter24);
	RFX_Text(pFX, _T("[waiter4]"),waiter4);
	RFX_Text(pFX, _T("[waiter8]"),waiter8);
	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);
	RFX_Text(pFX, _T("[tichenren1]"),tichenren1);
	RFX_Text(pFX, _T("[tichenren2]"),tichenren2);
	RFX_Text(pFX, _T("[tichenren3]"),tichenren3);
	RFX_Text(pFX, _T("[tichenren4]"),tichenren4);
	RFX_Text(pFX, _T("[tichenren5]"),tichenren5);
	RFX_Text(pFX, _T("[send1]"),send1);
	RFX_Text(pFX, _T("[send2]"),send2);
	RFX_Text(pFX, _T("[send3]"),send3);
	RFX_Text(pFX, _T("[txtype]"),txtype);
	RFX_Text(pFX, _T("[outside]"),outside);
	RFX_Text(pFX, _T("[discount]"),discount);
	RFX_Text(pFX, _T("[authorize]"),authorize);
	RFX_Text(pFX, _T("[discount2]"),discount2);
	RFX_Text(pFX, _T("[authorize2]"),authorize2);
	RFX_Text(pFX, _T("[contractno1]"),contractno1);
	RFX_Text(pFX, _T("[contractno2]"),contractno2);
	RFX_Text(pFX, _T("[send4]"),send4);
	RFX_Text(pFX, _T("[send5]"),send5);
	RFX_Text(pFX, _T("[dindantype]"),dindantype);
	RFX_Text(pFX, _T("[from]"),from);
	//}}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(CRstDindanView, CRecordset)
CRstDindanView::CRstDindanView(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstDindanView)
	id = _T("");
	name1 = _T("");
	name2 = _T("");
	taoxiname = _T("");
 	taoxijiage = _T("");
	time1 = _T("");
	time2 = _T("");
	ren = _T("");
 	time4 = _T("");
	time5 = _T("");
 	time6 = _T("");
	status = _T("");
	status2 = _T("");
	status3 = _T("");
	status4 = _T("");
	status5 = _T("");
	status8 = _T("");
	waiter1 = _T("");
	waiter12 = _T("");
	waiter13 = _T("");
	waiter14 = _T("");
	waiter2 = _T("");
	waiter22 = _T("");
	waiter23 = _T("");
	waiter24 = _T("");
 	waiter8 = _T("");
	waiter4 = _T("");
	phone1 = _T("");
	phone2 = _T("");
	taketime = _T("");
	pinyin1 = _T("");
	pinyin2 = _T("");
	status6 = _T("");
	waiter3 = _T("");
	waiter5 = _T("");
	waiter7 = _T("");
	waiter6 = _T("");
	tichenren1 = _T("");
	tichenren2 = _T("");
 	tichenren3 = _T("");
	tichenren4 = _T("");
	tichenren5 = _T("");
	send1 = _T("");
	send2 = _T("");
	send3 = _T("");
	txtype = _T("");
	outside = _T("");
	discount = _T("");
	discount2 = _T("");
	authorize = _T("");
	authorize2 = _T("");
	contractno1 = _T("");
	contractno2 = _T("");
	m_nFields = 57;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
	m_strSort="id desc";
}


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

CString CRstDindanView::GetDefaultSQL()
{
	return _T("[dindanview]");
}

void CRstDindanView::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstDindanView)
	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("[time6]"), time6);
	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("[status8]"),status8);
	RFX_Text(pFX, _T("[waiter1]"),waiter1);
	RFX_Text(pFX, _T("[waiter12]"),waiter12);
	RFX_Text(pFX, _T("[waiter13]"),waiter13);
	RFX_Text(pFX, _T("[waiter14]"),waiter14);
	RFX_Text(pFX, _T("[waiter2]"),waiter2);
	RFX_Text(pFX, _T("[waiter22]"),waiter22);
	RFX_Text(pFX, _T("[waiter23]"),waiter23);
	RFX_Text(pFX, _T("[waiter24]"),waiter24);
	RFX_Text(pFX, _T("[waiter4]"),waiter4);
	RFX_Text(pFX, _T("[waiter8]"),waiter8);
	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);
	RFX_Text(pFX, _T("[tichenren1]"),tichenren1);
	RFX_Text(pFX, _T("[tichenren2]"),tichenren2);
	RFX_Text(pFX, _T("[tichenren3]"),tichenren3);
	RFX_Text(pFX, _T("[tichenren4]"),tichenren4);
	RFX_Text(pFX, _T("[tichenren5]"),tichenren5);
	RFX_Text(pFX, _T("[send1]"),send1);
	RFX_Text(pFX, _T("[send2]"),send2);
	RFX_Text(pFX, _T("[send3]"),send3);
	RFX_Text(pFX, _T("[txtype]"),txtype);
	RFX_Text(pFX, _T("[outside]"),outside);
	RFX_Text(pFX, _T("[discount]"),discount);
	RFX_Text(pFX, _T("[authorize]"),authorize);
	RFX_Text(pFX, _T("[discount2]"),discount2);
	RFX_Text(pFX, _T("[authorize2]"),authorize2);
	RFX_Text(pFX, _T("[contractno1]"),contractno1);
	RFX_Text(pFX, _T("[contractno2]"),contractno2);
	RFX_Text(pFX, _T("[send4]"),send4);
	RFX_Text(pFX, _T("[send5]"),send5);
	RFX_Text(pFX, _T("[dindantype]"),dindantype);	RFX_Text(pFX, _T("[STA]"),STA);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstDindanView diagnostics

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

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

IMPLEMENT_DYNAMIC(CRsttakeview, CRecordset)
CRsttakeview::CRsttakeview(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRsttakeview)
	m_nFields = 33;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
	m_strSort="bookingdate,time";
}

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

CString CRsttakeview::GetDefaultSQL()
{
	return _T("[takeview]");
}

void CRsttakeview::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRsttakeview)
	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("[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("[name]"),name);
	RFX_Text(pFX, _T("[status]"),status);
	RFX_Text(pFX, _T("[date]"),date);
	RFX_Text(pFX, _T("[waiter1]"),waiter1);
	RFX_Text(pFX, _T("[waiter12]"),waiter12);
	RFX_Text(pFX, _T("[waiter2]"),waiter2);
	RFX_Text(pFX, _T("[waiter22]"),waiter22);
	RFX_Text(pFX, _T("[time5]"),time5);
	RFX_Text(pFX, _T("[time3]"),time3);
	RFX_Text(pFX, _T("[bookingdate]"),bookingdate);
	RFX_Text(pFX, _T("[time]"),time);
	RFX_Text(pFX, _T("[dress]"),dress);
	RFX_Text(pFX, _T("[bz]"),bz);
	RFX_Text(pFX, _T("[birthday1]"),birthday1);
	RFX_Text(pFX, _T("[check1]"),check1);
	RFX_Text(pFX, _T("[clerk]"),clerk);
	RFX_Text(pFX, _T("[payed4]"),m_payed4);
	RFX_Text(pFX, _T("[payed5]"),m_payed5);
	RFX_Text(pFX, _T("[money1]"),m_money1);
	RFX_Text(pFX, _T("[sex]"),sex);	
	RFX_Text(pFX, _T("[inputtime]"),inputtime);	
	RFX_Text(pFX, _T("[branch]"),branch);	RFX_Text(pFX, _T("[curno]"),curno);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRsttakeview diagnostics

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

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

IMPLEMENT_DYNAMIC(CRstannualfeeview, CRecordset)
CRstannualfeeview::CRstannualfeeview(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstannualfeeview)
	m_nFields = 14;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
	m_strSort="id,year,date";
}

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

CString CRstannualfeeview::GetDefaultSQL()
{
	return _T("[annualfeeview]");
}

void CRstannualfeeview::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstannualfeeview)
	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("[time2]"), time2);
	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("[year]"),year);
	RFX_Text(pFX, _T("[clerk]"),clerk);
	RFX_Text(pFX, _T("[date]"),date);	RFX_Text(pFX, _T("[status5]"),status5);
	RFX_Text(pFX, _T("[bz]"),bz,4096);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstannualfeeview diagnostics

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

void CRstannualfeeview::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG
IMPLEMENT_DYNAMIC(CRstDindanFormLKAY, CRecordset)
CRstDindanFormLKAY::CRstDindanFormLKAY(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstDindanFormLKAY)
	id = _T("");
	name1 = _T("");
	name2 = _T("");
	taoxiname = _T("");
 	taoxijiage = _T("");
	time1 = _T("");
	time2 = _T("");
	ren = _T("");
 	time4 = _T("");
	time5 = _T("");
 	time6 = _T("");
	status = _T("");
	status2 = _T("");
	status3 = _T("");
	status4 = _T("");
	status5 = _T("");
	status8 = _T("");
	waiter1 = _T("");
	waiter12 = _T("");
	waiter13 = _T("");
	waiter14 = _T("");
	waiter2 = _T("");
	waiter22 = _T("");
	waiter23 = _T("");
	waiter24 = _T("");
 	waiter8 = _T("");
	waiter4 = _T("");
	phone1 = _T("");
	phone2 = _T("");
	taketime = _T("");
	pinyin1 = _T("");
	pinyin2 = _T("");
	status6 = _T("");
	waiter3 = _T("");
	waiter5 = _T("");
	waiter7 = _T("");
	waiter6 = _T("");
	tichenren1 = _T("");
	tichenren2 = _T("");
 	tichenren3 = _T("");
	tichenren4 = _T("");
	tichenren5 = _T("");
	send1 = _T("");
	send2 = _T("");
	send3 = _T("");
	txtype = _T("");
	outside = _T("");
	discount = _T("");
	discount2 = _T("");
	authorize = _T("");
	authorize2 = _T("");
	contractno1 = _T("");
	contractno2 = _T("");
	sex = _T("");
	birthday1 = _T("");
	check1 = _T("");
	m_nFields = 56;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
	m_strSort="id desc";
}


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

CString CRstDindanFormLKAY::GetDefaultSQL()
{
	return _T("[dindanlkay]");
}

void CRstDindanFormLKAY::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstDindanFormLKAY)
	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("[time6]"), time6);
	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("[status8]"),status8);
	RFX_Text(pFX, _T("[waiter1]"),waiter1);
	RFX_Text(pFX, _T("[waiter12]"),waiter12);
	RFX_Text(pFX, _T("[waiter13]"),waiter13);
	RFX_Text(pFX, _T("[waiter14]"),waiter14);
	RFX_Text(pFX, _T("[waiter2]"),waiter2);
	RFX_Text(pFX, _T("[waiter22]"),waiter22);
	RFX_Text(pFX, _T("[waiter23]"),waiter23);
	RFX_Text(pFX, _T("[waiter24]"),waiter24);
	RFX_Text(pFX, _T("[waiter4]"),waiter4);
	RFX_Text(pFX, _T("[waiter8]"),waiter8);
	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);
	RFX_Text(pFX, _T("[tichenren1]"),tichenren1);
	RFX_Text(pFX, _T("[tichenren2]"),tichenren2);
	RFX_Text(pFX, _T("[tichenren3]"),tichenren3);
	RFX_Text(pFX, _T("[tichenren4]"),tichenren4);
	RFX_Text(pFX, _T("[tichenren5]"),tichenren5);
	RFX_Text(pFX, _T("[send1]"),send1);
	RFX_Text(pFX, _T("[send2]"),send2);
	RFX_Text(pFX, _T("[send3]"),send3);
	RFX_Text(pFX, _T("[txtype]"),txtype);
	RFX_Text(pFX, _T("[outside]"),outside);
	RFX_Text(pFX, _T("[discount]"),discount);
	RFX_Text(pFX, _T("[authorize]"),authorize);
	RFX_Text(pFX, _T("[discount2]"),discount2);
	RFX_Text(pFX, _T("[authorize2]"),authorize2);
	RFX_Text(pFX, _T("[contractno1]"),contractno1);
	RFX_Text(pFX, _T("[contractno2]"),contractno2);
	RFX_Text(pFX, _T("[sex]"),sex);
	RFX_Text(pFX, _T("[birthday1]"),birthday1);
	RFX_Text(pFX, _T("[check1]"),check1);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstDindanFormLKAY diagnostics

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

void CRstDindanFormLKAY::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG
IMPLEMENT_DYNAMIC(CRstDindanForm9, CRecordset)
CRstDindanForm9::CRstDindanForm9(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstDindanForm9)
	id = _T("");
	name1 = _T("");
	name2 = _T("");
	taoxiname = _T("");
 	taoxijiage = _T("");
	waiter1 = _T("");
	waiter12 = _T("");
	waiter13 = _T("");
	waiter14 = _T("");
	waiter1rate = _T("");
	waiter12rate = _T("");
	waiter13rate = _T("");
	waiter14rate = _T("");
	waiter2 = _T("");
	waiter22 = _T("");
	waiter23 = _T("");
	waiter24 = _T("");
	waiter2rate = _T("");
	waiter22rate = _T("");
	waiter23rate = _T("");
	waiter24rate = _T("");
	phone1 = _T("");
	phone2 = _T("");
	pinyin1 = _T("");
	pinyin2 = _T("");
	status3 = _T("");
	choosezs = _T("");
	ren = _T("");
	ren2 = _T("");
	renrate = _T("");
	ren2rate = _T("");
	status = _T("");
	time2 = _T("");
	m_nFields = 33;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
	m_strSort="id desc";
}


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

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

void CRstDindanForm9::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstDindanForm9)
	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("[waiter1]"),waiter1);
	RFX_Text(pFX, _T("[waiter12]"),waiter12);
	RFX_Text(pFX, _T("[waiter13]"),waiter13);
	RFX_Text(pFX, _T("[waiter14]"),waiter14);
	RFX_Text(pFX, _T("[waiter1rate]"),waiter1rate);
	RFX_Text(pFX, _T("[waiter12rate]"),waiter12rate);
	RFX_Text(pFX, _T("[waiter13rate]"),waiter13rate);
	RFX_Text(pFX, _T("[waiter14rate]"),waiter14rate);
	RFX_Text(pFX, _T("[waiter2]"),waiter2);
	RFX_Text(pFX, _T("[waiter22]"),waiter22);
	RFX_Text(pFX, _T("[waiter23]"),waiter23);
	RFX_Text(pFX, _T("[waiter24]"),waiter24);
	RFX_Text(pFX, _T("[waiter2rate]"),waiter2rate);
	RFX_Text(pFX, _T("[waiter22rate]"),waiter22rate);
	RFX_Text(pFX, _T("[waiter23rate]"),waiter23rate);
	RFX_Text(pFX, _T("[waiter24rate]"),waiter24rate);
	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("[status3]"),status3);
	RFX_Text(pFX, _T("[choosezs]"),choosezs);
	RFX_Text(pFX, _T("[ren]"),ren);
	RFX_Text(pFX, _T("[ren2]"),ren2);
	RFX_Text(pFX, _T("[renrate]"),renrate);
	RFX_Text(pFX, _T("[ren2rate]"),ren2rate);
	RFX_Text(pFX, _T("[time2]"),time2);	
	RFX_Text(pFX, _T("[status]"),status);
	//}}AFX_FIELD_MAP
}
/////////////////////////////////////////////////////////////////////////////
// CRstDindanForm9 diagnostics

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

void CRstDindanForm9::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("");
 	money3 = _T("");
 	choosezs = _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("[money3]"), money3);
	RFX_Text(pFX, _T("[choosezs]"), choosezs);
	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_money1 = _T("");
	status5 = _T("");
	urgent = _T("");
	time5 = _T("");
	ren = _T("");
	time1 = _T("");
	txtype = _T("");
	discount = _T("");
	taoxizs= _T("");
	takezs= _T("");
	choosezs= _T("");
	status2= _T("");
	waiter1= _T("");
	waiter2= _T("");
	clothescount= _T("");
	dindantype= _T("");
	reason= _T("");
	from= _T("");
	m_nFields = 30;
	//}}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);
	RFX_Text(pFX, _T("[money1]"),m_money1);
	RFX_Text(pFX, _T("[status5]"),status5);
	RFX_Text(pFX, _T("[urgent]"),urgent);
	RFX_Text(pFX, _T("[time5]"),time5);
	RFX_Text(pFX, _T("[ren]"),ren);
	RFX_Text(pFX, _T("[time1]"),time1);
	RFX_Text(pFX, _T("[txtype]"),txtype);
	RFX_Text(pFX, _T("[discount]"),discount);
	RFX_Text(pFX, _T("[taoxizs]"),taoxizs);
	RFX_Text(pFX, _T("[takezs]"),takezs);
	RFX_Text(pFX, _T("[choosezs]"),choosezs);
	RFX_Text(pFX, _T("[status2]"),status2);
	RFX_Text(pFX, _T("[waiter1]"),waiter1);
	RFX_Text(pFX, _T("[waiter2]"),waiter2);
	RFX_Text(pFX, _T("[clothescount]"),clothescount);
	RFX_Text(pFX, _T("[dindantype]"),dindantype);
	RFX_Text(pFX, _T("[from]"),from);
	RFX_Text(pFX, _T("[reason]"),reason);
	//}}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(CRstdindanspview, CRecordset)
CRstdindanspview::CRstdindanspview(CDatabase* pdb)
	: CRecordset(pdb)
{
	//m_nFields = 24;
	m_nFields = 25;

	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
	m_strSort="id desc";
}

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

CString CRstdindanspview::GetDefaultSQL()
{
	return _T("[dindanspview]");
}

void CRstdindanspview::DoFieldExchange(CFieldExchange* pFX)
{
	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("[status5]"),status5);
	RFX_Text(pFX, _T("[waiter4]"),m_strDesigner); //Jeff.add.for.ddf
	RFX_Text(pFX, _T("[urgent]"),urgent);
	RFX_Text(pFX, _T("[time5]"),time5);
	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("[taoxijiage]"),taoxijiage);
	RFX_Text(pFX, _T("[payed4]"),m_payed4);
	RFX_Text(pFX, _T("[payed5]"),m_payed5);
	RFX_Text(pFX, _T("[money1]"),m_money1);
	RFX_Text(pFX, _T("[status52]"),status52);
	RFX_Text(pFX, _T("[status6]"),status6);
 	RFX_Text(pFX, _T("[name]"),name);
	RFX_Text(pFX, _T("[status32]"),status3);
	RFX_Text(pFX, _T("[status4]"),status4);
	RFX_Text(pFX, _T("[status1]"),status1);
	RFX_Text(pFX, _T("[status2]"),status2);
	RFX_Text(pFX, _T("[urgent2]"),urgent2);
	//RFX_Text(pFX, _T("[taketime]"),taketime);//delete by Jeff.
	RFX_Text(pFX, _T("[date4]"),taketime);	// 将taketime用date4来代替：取件日期;
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstdindanspview diagnostics

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

void CRstdindanspview::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("");
 	status8 = _T("");
 	urgent = _T("");
 	time5 = _T("");
 	time6 = _T("");
 	time10 = _T("");
 	bz2 = _T("");
	ren = _T("");
	waiter8 = _T("");
	waiter4 = _T("");
	taoxiname = _T("");
 	taoxijiage = _T("");
	phone1 = _T("");
	phone2 = _T("");
	pinyin1 = _T("");
	pinyin2 = _T("");
	m_nFields = 20;
	//}}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("[status8]"), status8);
	RFX_Text(pFX, _T("[urgent]"), urgent);
	RFX_Text(pFX, _T("[time5]"), time5);
	RFX_Text(pFX, _T("[time6]"), time6);
	RFX_Text(pFX, _T("[time10]"), time10);
	RFX_Text(pFX, _T("[bz2]"), bz2, 4096);
	RFX_Text(pFX, _T("[ren]"), ren);
	RFX_Text(pFX, _T("[waiter8]"),waiter8);
	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("");
	status2 = _T("");
	status7 = _T("");
	bruncount = _T("");
 	urgent = _T("");
 	time5 = _T("");
	ren = _T("");
	taoxiname = _T("");
 	taoxijiage = _T("");
	phone1 = _T("");
	phone2 = _T("");
	pinyin1 = _T("");
	pinyin2 = _T("");
	m_nFields = 15;
	//}}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("[status2]"),status2);
	RFX_Text(pFX, _T("[status7]"),status7);
	RFX_Text(pFX, _T("[bruncount]"),bruncount);
	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("");
	time4 = _T("");
	time8 = _T("");
	taoxiname = _T("");
 	taoxijiage = _T("");
	waiter1 = _T("");
	waiter5 = _T("");
	ren = _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 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("[time4]"),time4);
	RFX_Text(pFX, _T("[time8]"),time8);
	//}}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(CRstDindanSatisfaction, CRecordset)
CRstDindanSatisfaction::CRstDindanSatisfaction(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstDindanSatisfaction)
	id = _T("");
	name1 = _T("");
	name2 = _T("");
	satisfaction1 = _T("");
	satisfaction2 = _T("");
	satisfaction3 = _T("");
	satisfaction4 = _T("");
	satisfaction5 = _T("");
	satisfaction6 = _T("");
	satisfaction7 = _T("");
	bz5 = _T("");
	ren = _T("");
	taoxiname = _T("");
	taoxijiage = _T("");
	phone1 = _T("");
	phone2 = _T("");
	pinyin1 = _T("");
	pinyin2 = _T("");
	time1 = _T("");
	m_nFields = 25;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
	m_strSort="id desc";
}

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

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

void CRstDindanSatisfaction::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstDindanSatisfaction)
	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("[satisfaction1]"), satisfaction1);
	RFX_Text(pFX, _T("[satisfaction2]"), satisfaction2);
	RFX_Text(pFX, _T("[satisfaction3]"), satisfaction3);
	RFX_Text(pFX, _T("[satisfaction4]"), satisfaction4);
	RFX_Text(pFX, _T("[satisfaction5]"), satisfaction5);
	RFX_Text(pFX, _T("[satisfaction6]"), satisfaction6);
	RFX_Text(pFX, _T("[satisfaction7]"), satisfaction7);
	RFX_Text(pFX, _T("[bz5]"), bz5, 4096);
	RFX_Text(pFX, _T("[taoxiname]"), taoxiname);
	RFX_Text(pFX, _T("[taoxijiage]"), taoxijiage);
	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("[time1]"),time1);
	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("[waiter5]"),waiter5);
	RFX_Text(pFX, _T("[waiter7]"),waiter7);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstDindanSatisfaction diagnostics

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

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

IMPLEMENT_DYNAMIC(CRstworkerreport, CRecordset)
CRstworkerreport::CRstworkerreport(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstworkerreport)
	m_nFields = 9;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 	
	m_strSort="date1 desc";
}

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

CString CRstworkerreport::GetDefaultSQL()
{
	return _T("[workerreport]");
}

void CRstworkerreport::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstworkerreport)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[id]"), id);
	RFX_Text(pFX, _T("[worker]"), worker);
	RFX_Text(pFX, _T("[addr]"), addr);
	RFX_Text(pFX, _T("[date1]"), date1);
	RFX_Text(pFX, _T("[date2]"), date2);	
	RFX_Text(pFX, _T("[read]"), read);
	RFX_Text(pFX, _T("[remark]"), remark, 10240);
 	RFX_Text(pFX, _T("[remark2]"), remark2, 10240);	 
 	RFX_Text(pFX, _T("[remark3]"), remark3, 10240);	 
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstworkerreport diagnostics

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

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

IMPLEMENT_DYNAMIC(CRstmsgcode, CRecordset)
CRstmsgcode::CRstmsgcode(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstmsgcode)
	m_nFields = 5;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
	m_strSort="type";
	
}

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

CString CRstmsgcode::GetDefaultSQL()
{
	return _T("[msgcode]");
}

void CRstmsgcode::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstmsgcode)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[type]"), type);
	RFX_Text(pFX, _T("[code]"), code);
	RFX_Text(pFX, _T("[good]"), good);
	RFX_Text(pFX, _T("[medium]"), medium);
	RFX_Text(pFX, _T("[bad]"), bad);	
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstmsgcode diagnostics

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

void CRstmsgcode::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_time4 = _T("");
	m_time5 = _T("");
	m_time6 = _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_waiter3 = _T("");
	m_waiter8 = _T("");
	m_clothescount = _T("");
	m_outside = _T("");
	m_ren = _T("");
	m_bz2 = _T("");
	pinyin1 = _T("");
	pinyin2 = _T("");
 	datetime4 = _T("");
	datetime5 = _T("");
	datetime6 = _T("");
	m_nFields = 25;
	//}}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("[time4]"), m_time4);
	RFX_Text(pFX, _T("[time5]"), m_time5);
	RFX_Text(pFX, _T("[time6]"), m_time6);
	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("[waiter3]"), m_waiter3);
	RFX_Text(pFX, _T("[waiter8]"), m_waiter8);
	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, 4096);
	RFX_Text(pFX, _T("[pinyin1]"), pinyin1);
	RFX_Text(pFX, _T("[pinyin2]"), pinyin2);
	RFX_Text(pFX, _T("[datetime4]"), datetime4);
	RFX_Text(pFX, _T("[datetime5]"), datetime5);
	RFX_Text(pFX, _T("[datetime6]"), datetime6);	RFX_Text(pFX, _T("[waiter9]"), m_waiter9);
	//}}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 = _T("");
	m_id = _T("");
	m_money = _T("");
	m_ren = _T("");
	m_ren2 = _T("");
	m_date = _T("");
	m_bz = _T("");
	m_kind = _T("");
	m_item = _T("");
	paytype = _T("");
	jdd = _T("");
	m_financecheck = _T("");
	m_nFields = 13;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
	m_strSort="id desc";
}


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_Text(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, 4096);
	RFX_Text(pFX, _T("[kind]"), m_kind);
	RFX_Text(pFX, _T("[item]"), m_item);
	RFX_Text(pFX, _T("[paytype]"), paytype);
	RFX_Text(pFX, _T("[jdd]"), jdd);
	RFX_Text(pFX, _T("[financecheck]"), m_financecheck);
	RFX_Text(pFX, _T("[discount]"), m_discount);
	//}}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(CRstBuKuanView2, CRecordset)
CRstBuKuanView2::CRstBuKuanView2(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstBuKuanView2)
	m_autoid = _T("");
	m_id = _T("");
	m_money = _T("");
	m_ren = _T("");
	m_ren2 = _T("");
	m_date = _T("");
	m_bz = _T("");
	m_kind = _T("");
	m_item = _T("");
	paytype = _T("");
	jdd = _T("");
	m_financecheck = _T("");
	m_nFields = 16;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
	m_strSort="id desc";
}


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

CString CRstBuKuanView2::GetDefaultSQL()
{
	return _T("[dindanbukuanview2]");
}

void CRstBuKuanView2::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstBuKuanView2)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(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, 4096);
	RFX_Text(pFX, _T("[kind]"), m_kind);
	RFX_Text(pFX, _T("[item]"), m_item);
	RFX_Text(pFX, _T("[paytype]"), paytype);
	RFX_Text(pFX, _T("[jdd]"), jdd);
	RFX_Text(pFX, _T("[financecheck]"), m_financecheck);
	RFX_Text(pFX, _T("[name1]"), m_name1);
	RFX_Text(pFX, _T("[name2]"), m_name2);
	RFX_Text(pFX, _T("[time]"), m_time);

	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstBuKuanView2 diagnostics

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

void CRstBuKuanView2::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG
IMPLEMENT_DYNAMIC(CRstdindanbukuanview, CRecordset)
CRstdindanbukuanview::CRstdindanbukuanview(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstdindanbukuanview)
	m_nFields = 11;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
	m_strSort="id desc";
}


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

CString CRstdindanbukuanview::GetDefaultSQL()
{
	return _T("[dindanbukuanview]");
}

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

/////////////////////////////////////////////////////////////////////////////
// CRstdindanbukuanview diagnostics

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

void CRstdindanbukuanview::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 = _T("");
	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; 
	m_strSort="id desc";
}


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_Text(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, 4096);
	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("");
	path5 = _T("");
	m_nFields = 5;
	//}}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);
	RFX_Text(pFX, _T("[path5]"), path5);
	//}}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_time9 = _T("");
	m_nFields = 19;
	//}}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);
	RFX_Text(pFX, _T("[time9]"), m_time9);
	RFX_Text(pFX, _T("[time4]"), m_time4);
	//}}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(CRstDindanForm8, CRecordset)
CRstDindanForm8::CRstDindanForm8(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstDindanForm8)
	id = _T("");
	name1 = _T("");
	name2 = _T("");
	status = _T("");
	status4 = _T("");	
	status2 = _T("");
	status6 = _T("");
	status5 = _T("");
	waiter5 = _T("");	
	waiter7 = _T("");
	waiter4 = _T("");
	urgent = _T("");
 	time5 = _T("");
	time2 = _T("");
	time4 = _T("");
	time6 = _T("");
	ren = _T("");
	taoxiname = _T("");
 	taoxijiage = _T("");
	phone1 = _T("");
	phone2 = _T("");
	pinyin1 = _T("");
	pinyin2 = _T("");
	m_nFields = 23;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
	m_strSort="id desc";
}

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

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

void CRstDindanForm8::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstDindanForm8)
	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("[status2]"), status2);
	RFX_Text(pFX, _T("[status6]"), status6);
	RFX_Text(pFX, _T("[status5]"), status5);
	RFX_Text(pFX, _T("[waiter5]"), waiter5);
	RFX_Text(pFX, _T("[waiter7]"), waiter7);
	RFX_Text(pFX, _T("[waiter4]"), waiter4);
	RFX_Text(pFX, _T("[urgent]"), urgent);
	RFX_Text(pFX, _T("[time5]"), time5);
	RFX_Text(pFX, _T("[time2]"), time2);
	RFX_Text(pFX, _T("[time4]"), time4);
	RFX_Text(pFX, _T("[time6]"), time6);	
	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
}

/////////////////////////////////////////////////////////////////////////////
// CRstDindanForm8 diagnostics

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

void CRstDindanForm8::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_time1 = _T("");
	m_time2 = _T("");
	m_area = _T("");
	m_nFields = 8;
	//}}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);
	RFX_Text(pFX, _T("[time1]"), m_time1);
	RFX_Text(pFX, _T("[time2]"), m_time2);
	RFX_Text(pFX, _T("[area]"), m_area);
	//}}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_name = _T("");
	m_count = _T("");
	m_area = _T("");
	m_status1 = _T("");
	m_status2 = _T("");
	m_time1 = _T("");
	m_time2 = _T("");
#if 0 // Jeff delete
	m_nFields = 17;
#else
	m_strBllingPerson = _T("");
	m_strDesigner = _T("");
	m_nFields = 19;
#endif
	//}}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("[photoprintview]");
}

void CRstPhotoPrintForm::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstPhotoPrintForm)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[name]"), m_name);
	RFX_Text(pFX, _T("[count]"), m_count);
	RFX_Text(pFX, _T("[area]"), m_area);
	RFX_Text(pFX, _T("[status1]"), m_status1);
	RFX_Text(pFX, _T("[status2]"), m_status2);
	RFX_Text(pFX, _T("[time1]"), m_time1);
	RFX_Text(pFX, _T("[time2]"), m_time2);
	RFX_Text(pFX, _T("[id]"), id);
	RFX_Text(pFX, _T("[name1]"), name1);
	RFX_Text(pFX, _T("[name2]"), name2);
	RFX_Text(pFX, _T("[status5]"), status5);
	RFX_Text(pFX, _T("[urgent]"), urgent);
	RFX_Text(pFX, _T("[time5]"), time5);
	RFX_Text(pFX, _T("[phone1]"), phone1);
	RFX_Text(pFX, _T("[phone2]"), phone2);
	RFX_Text(pFX, _T("[pinyin1]"), pinyin1);
	RFX_Text(pFX, _T("[pinyin2]"), pinyin2);
#if 1 // Jeff
	RFX_Text(pFX, _T("[ren]"), m_strBllingPerson);
	RFX_Text(pFX, _T("[waiter4]"), m_strDesigner);
#endif
	//}}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_bz = _T("");
	m_bz2 = _T("");
	m_bz3 = _T("");
	m_money3 = _T("");
	m_money1 = _T("");
	m_taoxijiage = _T("");
	m_payed4 = _T("");
	m_payed5 = _T("");
	m_taoxiname = _T("");
	m_time6 = _T("");
	m_waiter8 = _T("");
	designreplaceno = _T("");
	m_nFields = 30;
	//}}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("[bz]"), m_bz, 4096);
	RFX_Text(pFX, _T("[bz2]"), m_bz2, 4096);
	RFX_Text(pFX, _T("[bz3]"), m_bz3, 4096);
	RFX_Text(pFX, _T("[bz4]"), m_bz4, 4096);
	RFX_Text(pFX, _T("[designreplaceno]"), designreplaceno, 4096);
	RFX_Text(pFX, _T("[money3]"), m_money3);
	RFX_Text(pFX, _T("[money1]"), m_money1);
	RFX_Text(pFX, _T("[taoxijiage]"), m_taoxijiage);
	RFX_Text(pFX, _T("[payed4]"), m_payed4);
	RFX_Text(pFX, _T("[payed5]"), m_payed5);
	RFX_Text(pFX, _T("[taoxiname]"), m_taoxiname);
	RFX_Text(pFX, _T("[time6]"), m_time6);
	RFX_Text(pFX, _T("[waiter8]"), m_waiter8);
	//}}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(RstSendReg, CRecordset)

RstSendReg::RstSendReg(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(RstSendReg)
	m_phones = _T("");
	m_content = _T("");
	m_timestamp = _T("");
	m_msgcount = _T("");
	m_log = _T("");
	m_status = _T("");
	m_id = _T("");
	m_issended = _T("");
	m_ren = _T("");
	m_nFields = 9;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
	m_strSort="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("[phones]"), m_phones, 202400);
	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("[log]"), m_log);
	RFX_Text(pFX, _T("[status]"), m_status);
	RFX_Text(pFX, _T("[autoid]"), m_id);
	RFX_Text(pFX, _T("[issended]"), m_issended);
	RFX_Text(pFX, _T("[ren]"), m_ren);
	//}}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(RstSendReg2, CRecordset)

RstSendReg2::RstSendReg2(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(RstSendReg2)
	m_price = _T("");
	m_yytime = _T("");
	m_client = _T("");
	m_type = _T("");
	m_phones = _T("");
	m_content = _T("");
	m_timestamp = _T("");
	m_ren = _T("");
	m_nFields = 8;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
	m_strSort="date desc,phones desc";
}

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

CString RstSendReg2::GetDefaultSQL()
{
	return _T("[sendreg2]");
}

void RstSendReg2::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(RstSendReg2)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[price]"), m_price);
	RFX_Text(pFX, _T("[yytime]"), m_yytime);
	RFX_Text(pFX, _T("[client]"), m_client);
	RFX_Text(pFX, _T("[type]"), m_type);
	RFX_Text(pFX, _T("[phones]"), m_phones, 202400 );
	RFX_Text(pFX, _T("[content]"), m_content, 102400);
	RFX_Text(pFX, _T("[date]"), m_timestamp);
	RFX_Text(pFX, _T("[ren]"), m_ren);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// RstSendReg2 diagnostics

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

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


IMPLEMENT_DYNAMIC(RstMemberReg, CRecordset)
RstMemberReg::RstMemberReg(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(RstMemberReg)
	m_memberno = _T("");
	m_balance = _T("");
	m_name = _T("");
	m_date = _T("");
	m_id = _T("");
	m_sex = _T("");
	m_phone = _T("");
	m_qq = _T("");
	m_addr = _T("");
	m_occupation = _T("");
	m_birthday = _T("");
	m_money = _T("");
	m_pinyin = _T("");
	m_sendmark1 = _T("");
	m_sendmark2 = _T("");
	m_psw = _T("");
	m_discount = _T("");
	m_nFields = 19;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
}

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

CString RstMemberReg::GetDefaultSQL()
{
	return _T("[membermanage]");
}

void RstMemberReg::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(RstMemberReg)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[memberno]"), m_memberno);
	RFX_Text(pFX, _T("[name]"), m_name);
	RFX_Text(pFX, _T("[date]"), m_date);
	RFX_Text(pFX, _T("[autoid]"), m_id);
	RFX_Text(pFX, _T("[sex]"), m_sex);
	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("[occupation]"), m_occupation);
	RFX_Text(pFX, _T("[birthday]"), m_birthday);
	RFX_Text(pFX, _T("[money]"), m_money);
	RFX_Text(pFX, _T("[pinyin]"), m_pinyin);
	RFX_Text(pFX, _T("[balance]"), m_balance);
	RFX_Text(pFX, _T("[psw]"), m_psw);
	RFX_Text(pFX, _T("[sendmark1]"), m_sendmark1, 4096);
	RFX_Text(pFX, _T("[sendmark2]"), m_sendmark2, 4096);
	RFX_Text(pFX, _T("[cardtype]"), m_cardtype);
	RFX_Text(pFX, _T("[check1]"), m_check1);
	RFX_Text(pFX, _T("[discount]"), m_discount);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// RstMemberReg diagnostics

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

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

IMPLEMENT_DYNAMIC(memberview2Reg, CRecordset)
memberview2Reg::memberview2Reg(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(memberview2Reg)
	m_memberno = _T("");
	m_balance = _T("");
	m_name = _T("");
	m_date = _T("");
	m_id = _T("");
	m_sex = _T("");
	m_phone = _T("");
	m_qq = _T("");
	m_addr = _T("");
	m_occupation = _T("");
	m_birthday = _T("");
	m_money = _T("");
	m_pinyin = _T("");
	m_sendmark1 = _T("");
	m_sendmark2 = _T("");
	m_psw = _T("");
	m_discount = _T("");
	m_nFields = 21;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
}

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

CString memberview2Reg::GetDefaultSQL()
{
	return _T("[memberview2]");
}

void memberview2Reg::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(memberview2Reg)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[memberno]"), m_memberno);
	RFX_Text(pFX, _T("[name]"), m_name);
	RFX_Text(pFX, _T("[date]"), m_date);
	RFX_Text(pFX, _T("[autoid]"), m_id);
	RFX_Text(pFX, _T("[sex]"), m_sex);
	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("[occupation]"), m_occupation);
	RFX_Text(pFX, _T("[birthday]"), m_birthday);
	RFX_Text(pFX, _T("[money]"), m_money);
	RFX_Text(pFX, _T("[pinyin]"), m_pinyin);
	RFX_Text(pFX, _T("[balance]"), m_balance);
	RFX_Text(pFX, _T("[psw]"), m_psw);
	RFX_Text(pFX, _T("[sendmark1]"), m_sendmark1, 4096);
	RFX_Text(pFX, _T("[sendmark2]"), m_sendmark2, 4096);
	RFX_Text(pFX, _T("[cardtype]"), m_cardtype);
	RFX_Text(pFX, _T("[check1]"), m_check1);
	RFX_Text(pFX, _T("[discount]"), m_discount);
	RFX_Text(pFX, _T("[card2no]"), card2no);
	RFX_Text(pFX, _T("[card2date]"), card2date);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// memberview2Reg diagnostics

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

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

IMPLEMENT_DYNAMIC(memberview3Reg, CRecordset)
memberview3Reg::memberview3Reg(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(memberview3Reg)
	m_memberno = _T("");
	m_balance = _T("");
	m_name = _T("");
	m_date = _T("");
	m_id = _T("");
	m_sex = _T("");
	m_phone = _T("");
	m_qq = _T("");
	m_addr = _T("");
	m_occupation = _T("");
	m_birthday = _T("");
	m_money = _T("");
	m_pinyin = _T("");
	m_sendmark1 = _T("");
	m_sendmark2 = _T("");
	m_psw = _T("");
	m_discount = _T("");
	m_nFields = 25;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
}

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

CString memberview3Reg::GetDefaultSQL()
{
	return _T("[memberview3]");
}

void memberview3Reg::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(memberview3Reg)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[memberno]"), m_memberno);
	RFX_Text(pFX, _T("[name]"), m_name);
	RFX_Text(pFX, _T("[date]"), m_date);
	RFX_Text(pFX, _T("[autoid]"), m_id);
	RFX_Text(pFX, _T("[sex]"), m_sex);
	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("[occupation]"), m_occupation);
	RFX_Text(pFX, _T("[birthday]"), m_birthday);
	RFX_Text(pFX, _T("[money]"), m_money);
	RFX_Text(pFX, _T("[pinyin]"), m_pinyin);
	RFX_Text(pFX, _T("[balance]"), m_balance);
	RFX_Text(pFX, _T("[psw]"), m_psw);
	RFX_Text(pFX, _T("[sendmark1]"), m_sendmark1, 4096);
	RFX_Text(pFX, _T("[sendmark2]"), m_sendmark2, 4096);
	RFX_Text(pFX, _T("[cardtype]"), m_cardtype);
	RFX_Text(pFX, _T("[check1]"), m_check1);
	RFX_Text(pFX, _T("[discount]"), m_discount);
	RFX_Text(pFX, _T("[card2no]"), card2no);
	RFX_Text(pFX, _T("[date2]"), date2);
	RFX_Text(pFX, _T("[dindanid]"), dindanid);
	RFX_Text(pFX, _T("[taoxi]"), taoxi);
	RFX_Text(pFX, _T("[card2money]"), card2money);
	RFX_Text(pFX, _T("[card2date]"), card2date);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// memberview3Reg diagnostics

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

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

RstMemberRegBlue::RstMemberRegBlue(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(RstMemberRegBlue)
	m_memberno = _T("");
	m_name = _T("");
	m_date = _T("");
	m_id = _T("");
	m_sex = _T("");
	m_phone = _T("");
	m_qq = _T("");
	m_addr = _T("");
	m_occupation = _T("");
	m_birthday = _T("");
	m_money = _T("");
	m_money2 = _T("");
	m_money3 = _T("");
	m_occupation = _T("");
	m_pinyin = _T("");
	m_jiage = _T("");
	m_nFields = 16;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
}

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

CString RstMemberRegBlue::GetDefaultSQL()
{
	return _T("[membermanageblue]");
}

void RstMemberRegBlue::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(RstMemberRegBlue)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[memberno]"), m_memberno);
	RFX_Text(pFX, _T("[name]"), m_name);
	RFX_Text(pFX, _T("[date]"), m_date);
	RFX_Text(pFX, _T("[autoid]"), m_id);
	RFX_Text(pFX, _T("[sex]"), m_sex);
	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("[occupation]"), m_occupation);
	RFX_Text(pFX, _T("[birthday]"), m_birthday);
	RFX_Text(pFX, _T("[money]"), m_money);
	RFX_Text(pFX, _T("[money2]"), m_money2);
	RFX_Text(pFX, _T("[money3]"), m_money3);
	RFX_Text(pFX, _T("[occupation]"), m_occupation);
	RFX_Text(pFX, _T("[pinyin]"), m_pinyin);
	RFX_Text(pFX, _T("[jiage]"), m_jiage);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// RstMemberRegBlue diagnostics

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

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


IMPLEMENT_DYNAMIC(RstMemberReg2, CRecordset)

RstMemberReg2::RstMemberReg2(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(RstMemberReg2)
	m_memberno = _T("");
	m_dindanid = _T("");
	m_money = _T("");
	m_date = _T("");
	m_date2 = _T("");
	m_card2no = _T("");
	m_taoxi = _T("");
	m_nFields = 7;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
}

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

CString RstMemberReg2::GetDefaultSQL()
{
	return _T("[memberreg]");
}

void RstMemberReg2::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(RstMemberReg2)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[memberno]"), m_memberno);
	RFX_Text(pFX, _T("[dindanid]"), m_dindanid);
	RFX_Text(pFX, _T("[money]"), m_money);
	RFX_Text(pFX, _T("[date]"), m_date);
	RFX_Text(pFX, _T("[date2]"), m_date2);
	RFX_Text(pFX, _T("[card2no]"), m_card2no);
	RFX_Text(pFX, _T("[taoxi]"), m_taoxi);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// RstMemberReg2 diagnostics

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

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

IMPLEMENT_DYNAMIC(RstMemberReg32, CRecordset)
RstMemberReg32::RstMemberReg32(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(RstMemberReg32)
	m_memberno = _T("");
	m_id = _T("");
	m_money = _T("");
	m_date = _T("");
	m_clerk = _T("");
	m_nFields = 6;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
}

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

CString RstMemberReg32::GetDefaultSQL()
{
	return _T("[memberreg3]");
}

void RstMemberReg32::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(RstMemberReg32)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[memberno]"), m_memberno);
	RFX_Text(pFX, _T("[id]"), m_id);
	RFX_Text(pFX, _T("[money]"), m_money);
	RFX_Text(pFX, _T("[date]"), m_date);
	RFX_Text(pFX, _T("[clerk]"), m_clerk);
	RFX_Text(pFX, _T("[money2]"), m_money2);
	//}}AFX_FIELD_MAP clerk
}

/////////////////////////////////////////////////////////////////////////////
// RstMemberReg32 diagnostics

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

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

IMPLEMENT_DYNAMIC(memberviewReg, CRecordset)
memberviewReg::memberviewReg(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(memberviewReg)
	m_memberno = _T("");
	m_id = _T("");
	m_money = _T("");
	m_date = _T("");
	m_clerk = _T("");
	m_nFields = 9;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
}

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

CString memberviewReg::GetDefaultSQL()
{
	return _T("[memberview]");
}

void memberviewReg::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(memberviewReg)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[memberno]"), m_memberno);
	RFX_Text(pFX, _T("[id]"), m_id);
	RFX_Text(pFX, _T("[money]"), m_money);
	RFX_Text(pFX, _T("[date]"), m_date);
	RFX_Text(pFX, _T("[clerk]"), m_clerk);
	RFX_Text(pFX, _T("[name]"), m_name);
	RFX_Text(pFX, _T("[financecheck]"), m_financecheck);
	RFX_Text(pFX, _T("[moneytype]"), m_moneytype);
	RFX_Text(pFX, _T("[time]"), m_time);
	//}}AFX_FIELD_MAP clerk
}

/////////////////////////////////////////////////////////////////////////////
// memberviewReg diagnostics

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

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

IMPLEMENT_DYNAMIC(RstMemberReg4, CRecordset)
RstMemberReg4::RstMemberReg4(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(RstMemberReg4)
	m_memberno = _T("");
	m_id = _T("");
	m_money = _T("");
	m_date = _T("");
	m_clerk = _T("");
	m_card2no = _T("");
	m_nFields = 6;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
}

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

CString RstMemberReg4::GetDefaultSQL()
{
	return _T("[memberreg4]");
}

void RstMemberReg4::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(RstMemberReg4)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[memberno]"), m_memberno);
	RFX_Text(pFX, _T("[id]"), m_id);
	RFX_Text(pFX, _T("[money]"), m_money);
	RFX_Text(pFX, _T("[date]"), m_date);
	RFX_Text(pFX, _T("[clerk]"), m_clerk);
	RFX_Text(pFX, _T("[card2no]"), m_card2no);
	//}}AFX_FIELD_MAP clerk
}

/////////////////////////////////////////////////////////////////////////////
// RstMemberReg4 diagnostics

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

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

RstMemberReg2blue::RstMemberReg2blue(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(RstMemberReg2blue)
	m_memberno = _T("");
	m_dindanid = _T("");
	m_money = _T("");
	m_date = _T("");
	m_date2 = _T("");
	m_card2no = _T("");
	m_taoxi = _T("");
	m_nFields = 7;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
}

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

CString RstMemberReg2blue::GetDefaultSQL()
{
	return _T("[memberregblue]");
}

void RstMemberReg2blue::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(RstMemberReg2blue)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[memberno]"), m_memberno);
	RFX_Text(pFX, _T("[dindanid]"), m_dindanid);
	RFX_Text(pFX, _T("[money]"), m_money);
	RFX_Text(pFX, _T("[date]"), m_date);
	RFX_Text(pFX, _T("[date2]"), m_date2);
	RFX_Text(pFX, _T("[card2no]"), m_card2no);
	RFX_Text(pFX, _T("[taoxi]"), m_taoxi);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// RstMemberReg2blue diagnostics

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

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

RstMemberReg3::RstMemberReg3(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(RstMemberReg3)
	m_id = _T("");
	m_memberno = _T("");
	m_dindanid = _T("");
	m_money = _T("");
	m_point = _T("");
	m_date = _T("");
	m_nFields = 6;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
}

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

CString RstMemberReg3::GetDefaultSQL()
{
	return _T("[memberreg2]");
}

void RstMemberReg3::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(RstMemberReg3)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[id]"), m_id);
	RFX_Text(pFX, _T("[memberno]"), m_memberno);
	RFX_Text(pFX, _T("[dindanid]"), m_dindanid);
	RFX_Text(pFX, _T("[money]"), m_money);
	RFX_Text(pFX, _T("[point]"), m_point);
	RFX_Text(pFX, _T("[date]"), m_date);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// RstMemberReg3 diagnostics

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

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


IMPLEMENT_DYNAMIC(RstDressTypeReg, CRecordset)

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

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

CString RstDressTypeReg::GetDefaultSQL()
{
	return _T("[dresstype]");
}

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

/////////////////////////////////////////////////////////////////////////////
// RstDressTypeReg diagnostics

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

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


IMPLEMENT_DYNAMIC(RstDressInfoReg, CRecordset)

RstDressInfoReg::RstDressInfoReg(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(RstDressInfoReg)
	m_name = _T("");
	m_type = _T("");
	m_no = _T("");
	m_count = _T("");
	m_hirecount = _T("");
	m_salecount = _T("");
	m_washcount = _T("");
	m_balance = _T("");
	m_price1 = _T("");
	m_price2 = _T("");
	m_date = _T("");
	m_remark = _T("");
	m_dressarea = _T("");
	m_nFields = 14;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
	m_strSort="type desc,name desc";
}

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

CString RstDressInfoReg::GetDefaultSQL()
{
	return _T("[dressinfo]");
}

void RstDressInfoReg::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(RstDressInfoReg)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[name]"), m_name);
	RFX_Text(pFX, _T("[type]"), m_type);
	RFX_Text(pFX, _T("[type2]"), m_type2);
	RFX_Text(pFX, _T("[no]"), m_no);
	RFX_Text(pFX, _T("[count]"), m_count);
	RFX_Text(pFX, _T("[hirecount]"), m_hirecount);
	RFX_Text(pFX, _T("[salecount]"), m_salecount);
	RFX_Text(pFX, _T("[washcount]"), m_washcount);
	RFX_Text(pFX, _T("[balance]"), m_balance);
	RFX_Text(pFX, _T("[price1]"), m_price1);
	RFX_Text(pFX, _T("[price2]"), m_price2);
	RFX_Text(pFX, _T("[date]"), m_date);
	RFX_Text(pFX, _T("[remark]"), m_remark);
	RFX_Text(pFX, _T("[dressarea]"), m_dressarea);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// RstDressInfoReg diagnostics

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

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


IMPLEMENT_DYNAMIC(RstDressHireReg, CRecordset)
RstDressHireReg::RstDressHireReg(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(RstDressHireReg)
	m_id = _T("");
	m_money = _T("");
	m_money2 = _T("");
	m_name = _T("");
	m_phone = _T("");
	m_date = _T("");
	m_date1 = _T("");
	m_date2 = _T("");
	m_clerk = _T("");
	m_hireorsale = _T("");
	m_remark = _T("");
	m_nFields = 11;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
	m_strSort="id desc";
}


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

CString RstDressHireReg::GetDefaultSQL()
{
	return _T("[dresshire]");
}

void RstDressHireReg::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(RstDressHireReg)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[id]"), m_id);
	RFX_Text(pFX, _T("[money]"), m_money);
	RFX_Text(pFX, _T("[money2]"), m_money2);
	RFX_Text(pFX, _T("[name]"), m_name);
	RFX_Text(pFX, _T("[phone]"), m_phone);
	RFX_Text(pFX, _T("[date]"), m_date);
	RFX_Text(pFX, _T("[date1]"), m_date1);
	RFX_Text(pFX, _T("[date2]"), m_date2);
	RFX_Text(pFX, _T("[clerk]"), m_clerk);
	RFX_Text(pFX, _T("[hireorsale]"), m_hireorsale);
	RFX_Text(pFX, _T("[remark]"), m_remark, 4096);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// RstDressHireReg diagnostics

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

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

IMPLEMENT_DYNAMIC(RstDressView, CRecordset)
RstDressView::RstDressView(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(RstDressView)
	m_nFields = 11;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
	m_strSort="no,date1,date2";
}

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

CString RstDressView::GetDefaultSQL()
{
	return _T("[dressview]");
}

void RstDressView::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(RstDressView)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[no]"), no);
	RFX_Text(pFX, _T("[name]"), name);
	RFX_Text(pFX, _T("[count]"), count);
	RFX_Text(pFX, _T("[salecount]"), salecount);
	RFX_Text(pFX, _T("[clientname]"), clientname);
	RFX_Text(pFX, _T("[phone]"), phone);
	RFX_Text(pFX, _T("[count2]"), count2);
	RFX_Text(pFX, _T("[date1]"), date1);
	RFX_Text(pFX, _T("[date2]"), date2);
	RFX_Text(pFX, _T("[clerk]"), clerk);
	RFX_Text(pFX, _T("[date]"), date);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// RstDressView diagnostics

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

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

RstDressHireData::RstDressHireData(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(RstDressHireData)
	m_id = _T("");
	m_name = _T("");
	m_count = _T("");
	m_isreturn = _T("");
	m_returndate = _T("");
	m_clerk = _T("");
	m_no = _T("");
	m_hireorsale = _T("");
	m_nFields =8;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
	m_strSort="id desc";
}


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

CString RstDressHireData::GetDefaultSQL()
{
	return _T("[dresshiredata]");
}

void RstDressHireData::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(RstDressHireData)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[id]"), m_id);
	RFX_Text(pFX, _T("[name]"), m_name);
	RFX_Text(pFX, _T("[count]"), m_count);
	RFX_Text(pFX, _T("[isreturn]"), m_isreturn);
	RFX_Text(pFX, _T("[returndate]"), m_returndate);
	RFX_Text(pFX, _T("[clerk]"), m_clerk);
	RFX_Text(pFX, _T("[no]"), m_no);
	RFX_Text(pFX, _T("[hireorsale]"), m_hireorsale);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// RstDressHireData diagnostics

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

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


IMPLEMENT_DYNAMIC(CGoodsinfoSet, CRecordset)

CGoodsinfoSet::CGoodsinfoSet(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CGoodsinfoSet)
	m_id = _T("");
	m_type = _T("");
	m_name = _T("");
	m_count = _T("");
	m_date = _T("");
	m_clerk = _T("");
	m_remark = _T("");
	m_nFields = 7;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
	m_strSort="type desc,name desc";
}


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

CString CGoodsinfoSet::GetDefaultSQL()
{
	return _T("[storeinfo]");
}

void CGoodsinfoSet::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CGoodsinfoSet)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[id]"), m_id);
	RFX_Text(pFX, _T("[type]"), m_type);
	RFX_Text(pFX, _T("[name]"), m_name);
	RFX_Text(pFX, _T("[count]"), m_count);
	RFX_Text(pFX, _T("[date]"), m_date);
	RFX_Text(pFX, _T("[clerk]"), m_clerk);
	RFX_Text(pFX, _T("[remark]"), m_remark, 4096);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CGoodsinfoSet diagnostics

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

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

IMPLEMENT_DYNAMIC(CGoodsinfoSet2, CRecordset)

CGoodsinfoSet2::CGoodsinfoSet2(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CGoodsinfoSet2)
	m_id = _T("");
	m_type = _T("");
	m_name = _T("");
	m_count = _T("");
	m_date = _T("");
	m_clerk = _T("");
	m_remark = _T("");
	m_nFields = 7;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
	m_strSort="name desc";
}


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

CString CGoodsinfoSet2::GetDefaultSQL()
{
	return _T("[storeinfo2]");
}

void CGoodsinfoSet2::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CGoodsinfoSet2)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[id]"), m_id);
	RFX_Text(pFX, _T("[type]"), m_type);
	RFX_Text(pFX, _T("[name]"), m_name);
	RFX_Text(pFX, _T("[count]"), m_count);
	RFX_Text(pFX, _T("[date]"), m_date);
	RFX_Text(pFX, _T("[clerk]"), m_clerk);
	RFX_Text(pFX, _T("[remark]"), m_remark, 4096);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CGoodsinfoSet2 diagnostics

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

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

IMPLEMENT_DYNAMIC(RstTaoXifg, CRecordset)

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


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

CString RstTaoXifg::GetDefaultSQL()
{
	return _T("[taoxifg]");
}

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

/////////////////////////////////////////////////////////////////////////////
// RstTaoXifg diagnostics

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

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

IMPLEMENT_DYNAMIC(CRstburncdreg, CRecordset)
CRstburncdreg::CRstburncdreg(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstburncdreg)
	m_name = _T("");
	m_date = _T("");
	id = _T("");
	remark = _T("");
	m_nFields = 4;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
 	m_strSort="[date] desc";
}


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

CString CRstburncdreg::GetDefaultSQL()
{
	return _T("[burncdreg]");
}

void CRstburncdreg::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstburncdreg)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[ren]"), m_name);
	RFX_Text(pFX, _T("[date]"), m_date);
	RFX_Text(pFX, _T("[id]"), id);
	RFX_Text(pFX, _T("[remark]"), remark);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstburncdreg diagnostics

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

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

IMPLEMENT_DYNAMIC(CSalaryreg, CRecordset)
CSalaryreg::CSalaryreg(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CSalaryreg)
	name = _T("");
	year = _T("");
	month = _T("");
	money = _T("");
	m_nFields = 4;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
}


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

CString CSalaryreg::GetDefaultSQL()
{
	return _T("[salary]");
}

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

/////////////////////////////////////////////////////////////////////////////
// CSalaryreg diagnostics

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

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


IMPLEMENT_DYNAMIC(CRstrewards, CRecordset)

CRstrewards::CRstrewards(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstrewards)
	m_name = _T("");
	m_type = _T("");
	m_money = _T("");
	m_execute = _T("");
	m_date = _T("");
	m_renyuan = _T("");
	m_bz = _T("");
	m_id = _T("");
	m_nFields = 8;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
}


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


CString CRstrewards::GetDefaultSQL()
{
	return _T("[rewards]");
}

void CRstrewards::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstrewards)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[name]"), m_name);
	RFX_Text(pFX, _T("[type]"), m_type);
	RFX_Text(pFX, _T("[money]"), m_money);
	RFX_Text(pFX, _T("[execute]"), m_execute);
	RFX_Text(pFX, _T("[date]"), m_date);
	RFX_Text(pFX, _T("[renyuan]"), m_renyuan);
	RFX_Text(pFX, _T("[id]"), m_id);
	RFX_Text(pFX, _T("[bz]"), m_bz, 4096);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstrewards diagnostics

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

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

RstClient2::RstClient2(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(RstClient2)
	m_name = _T("");
	m_phone = _T("");
	m_qq = _T("");
	m_addr = _T("");
	m_from = _T("");
	m_reason = _T("");
	m_bz = _T("");
	m_pinyin = _T("");
	m_date = _T("");
	m_id = _T("");
	m_sex = _T("");
	m_ren = _T("");
	m_birthday = _T("");
	m_check1 = _T("");
	m_nFields = 14;
#ifdef LYFZ_VERSION
	m_nFields = 18;
#endif
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
}


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

CString RstClient2::GetDefaultSQL()
{
	return _T("[client2]");
}

void RstClient2::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(RstClient2)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	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("[from]"), m_from);
	RFX_Text(pFX, _T("[reason]"), m_reason);
	RFX_Text(pFX, _T("[bz]"), m_bz, 4096);
	RFX_Text(pFX, _T("[pinyin]"), m_pinyin);
	RFX_Text(pFX, _T("[date]"), m_date);
	RFX_Text(pFX, _T("[id]"), m_id);
	RFX_Text(pFX, _T("[sex]"), m_sex);
	RFX_Text(pFX, _T("[ren]"), m_ren);
	RFX_Text(pFX, _T("[birthday]"), m_birthday);
	RFX_Text(pFX, _T("[check1]"), m_check1);
#ifdef LYFZ_VERSION
	RFX_Text(pFX, _T("[area]"), m_area);
	RFX_Text(pFX, _T("[name2]"), m_name2);
	RFX_Text(pFX, _T("[status]"), m_status);
	RFX_Text(pFX, _T("[pinyin2]"), m_pinyin2);
#endif
	//}}AFX_FIELD_MAP
}
 
/////////////////////////////////////////////////////////////////////////////
// RstClient2 diagnostics

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

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

IMPLEMENT_DYNAMIC(Rstclient3, CRecordset)

Rstclient3::Rstclient3(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(Rstclient3)
	m_name = _T("");
	m_name2 = _T("");
	m_sex = _T("");
	m_phone = _T("");
	m_phone2 = _T("");
	m_qq = _T("");
	m_qq2 = _T("");
	m_birthday = _T("");
	m_birthday2 = _T("");
	m_time3 = _T("");
	m_taoxiname = _T("");
	m_taoxijiage = _T("");
	m_dandate = _T("");
	m_date = _T("");
	m_ren = _T("");
	m_pinyin = _T("");
	m_pinyin2 = _T("");
	m_id = _T("");
	m_check1 = _T("");
	m_check2 = _T("");
	m_check3 = _T("");
	m_nFields = 21;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
}

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

CString Rstclient3::GetDefaultSQL()
{
	return _T("[client3]");
}

void Rstclient3::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(Rstclient3)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[name]"), m_name);
	RFX_Text(pFX, _T("[name2]"), m_name2);
	RFX_Text(pFX, _T("[sex]"), m_sex);
	RFX_Text(pFX, _T("[phone]"), m_phone);
	RFX_Text(pFX, _T("[phone2]"), m_phone2);
	RFX_Text(pFX, _T("[qq]"), m_qq);
	RFX_Text(pFX, _T("[qq2]"), m_qq2);
	RFX_Text(pFX, _T("[birthday]"), m_birthday);
	RFX_Text(pFX, _T("[birthday2]"), m_birthday2);
	RFX_Text(pFX, _T("[time3]"), m_time3);
	RFX_Text(pFX, _T("[taoxiname]"), m_taoxiname);
	RFX_Text(pFX, _T("[taoxijiage]"), m_taoxijiage);
	RFX_Text(pFX, _T("[dandate]"), m_dandate);
 	RFX_Text(pFX, _T("[date]"), m_date);
 	RFX_Text(pFX, _T("[ren]"), m_ren);
	RFX_Text(pFX, _T("[pinyin]"), m_pinyin);
	RFX_Text(pFX, _T("[pinyin2]"), m_pinyin2);
	RFX_Text(pFX, _T("[id]"), m_id);
	RFX_Text(pFX, _T("[check1]"), m_check1);
	RFX_Text(pFX, _T("[check2]"), m_check2);
	RFX_Text(pFX, _T("[check3]"), m_check3);
	//}}AFX_FIELD_MAP
}
 
    
/////////////////////////////////////////////////////////////////////////////
// Rstclient3 diagnostics

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

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

IMPLEMENT_DYNAMIC(CRstLoninData, CRecordset)

CRstLoninData::CRstLoninData(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstLoninData)
	no = _T("");
	datetime = _T("");
	m_nFields = 2;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
	m_strSort="datetime";
}


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

CString CRstLoninData::GetDefaultSQL()
{
	return _T("[lonindata]");
}

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

/////////////////////////////////////////////////////////////////////////////
// CRstLoninData diagnostics

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

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

IMPLEMENT_DYNAMIC(CRstLoninTimeSet, CRecordset)

CRstLoninTimeSet::CRstLoninTimeSet(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstLoninTimeSet)
	name = _T("");
	time1 = _T("");
	time2 = _T("");
	time3 = _T("");
	time4 = _T("");
	m_nFields = 5;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
}


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

CString CRstLoninTimeSet::GetDefaultSQL()
{
	return _T("[lonintimeset]");
}

void CRstLoninTimeSet::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstLoninTimeSet)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[name]"), name);
	RFX_Text(pFX, _T("[time1]"), time1);
	RFX_Text(pFX, _T("[time2]"), time2);
	RFX_Text(pFX, _T("[time3]"), time3);
	RFX_Text(pFX, _T("[time4]"), time4);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstLoninTimeSet diagnostics

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

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

IMPLEMENT_DYNAMIC(CRstLoninBanSet, CRecordset)

CRstLoninBanSet::CRstLoninBanSet(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstLoninBanSet)
	weekname = _T("");
	name = _T("");
	banname1 = _T("");
	banname2 = _T("");
	banname3 = _T("");
	banname4 = _T("");
	banname5 = _T("");
	banname6 = _T("");
	banname7 = _T("");
	m_nFields = 9;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
	m_strSort="weekname";
}


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

CString CRstLoninBanSet::GetDefaultSQL()
{
	return _T("[loninbanset]");
}

void CRstLoninBanSet::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstLoninBanSet)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[weekname]"), weekname);
	RFX_Text(pFX, _T("[name]"), name);
	RFX_Text(pFX, _T("[banname1]"), banname1);
	RFX_Text(pFX, _T("[banname2]"), banname2);
	RFX_Text(pFX, _T("[banname3]"), banname3);
	RFX_Text(pFX, _T("[banname4]"), banname4);
	RFX_Text(pFX, _T("[banname5]"), banname5);
	RFX_Text(pFX, _T("[banname6]"), banname6);
	RFX_Text(pFX, _T("[banname7]"), banname7);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstLoninBanSet diagnostics

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

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

IMPLEMENT_DYNAMIC(CRstphonerecord, CRecordset)

CRstphonerecord::CRstphonerecord(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstphonerecord)
	id = _T("");
	phoneno = _T("");
	datetime = _T("");
	m_nFields = 3;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
	m_strSort="id desc";
}


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

CString CRstphonerecord::GetDefaultSQL()
{
	return _T("[phonerecord]");
}

void CRstphonerecord::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstphonerecord)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[id]"), id);
	RFX_Text(pFX, _T("[phoneno]"), phoneno);
	RFX_Text(pFX, _T("[datetime]"), datetime);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstphonerecord diagnostics

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

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

IMPLEMENT_DYNAMIC(CRstclient2phonerecord, CRecordset)
CRstclient2phonerecord::CRstclient2phonerecord(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstclient2phonerecord)
	phone = _T("");
	datetime = _T("");
	m_nFields = 2;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
	m_strSort="phone desc";
}


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

CString CRstclient2phonerecord::GetDefaultSQL()
{
	return _T("[client2phonerecord]");
}

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

/////////////////////////////////////////////////////////////////////////////
// CRstclient2phonerecord diagnostics

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

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

IMPLEMENT_DYNAMIC(CRstclient3phonerecord, CRecordset)
CRstclient3phonerecord::CRstclient3phonerecord(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstclient3phonerecord)
	phone = _T("");
	datetime = _T("");
	m_nFields = 2;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
	m_strSort="phone desc";
}


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

CString CRstclient3phonerecord::GetDefaultSQL()
{
	return _T("[client3phonerecord]");
}

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

/////////////////////////////////////////////////////////////////////////////
// CRstclient3phonerecord diagnostics

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

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

IMPLEMENT_DYNAMIC(CRstemployeephonerecord, CRecordset)

CRstemployeephonerecord::CRstemployeephonerecord(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstemployeephonerecord)
	name = _T("");
	datetime = _T("");
	m_nFields = 2;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
	m_strSort="name desc";
}


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

CString CRstemployeephonerecord::GetDefaultSQL()
{
	return _T("[employeephonerecord]");
}

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

/////////////////////////////////////////////////////////////////////////////
// CRstemployeephonerecord diagnostics

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

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

IMPLEMENT_DYNAMIC(CRstunknownphonerecord, CRecordset)

CRstunknownphonerecord::CRstunknownphonerecord(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstunknownphonerecord)
	phone = _T("");
	datetime = _T("");
	m_nFields = 2;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
	m_strSort="datetime desc";
}


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

CString CRstunknownphonerecord::GetDefaultSQL()
{
	return _T("[unknownphonerecord]");
}

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

/////////////////////////////////////////////////////////////////////////////
// CRstunknownphonerecord diagnostics

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

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

IMPLEMENT_DYNAMIC(CRstphonerecordout, CRecordset)

CRstphonerecordout::CRstphonerecordout(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstphonerecordout)
	name = _T("");
	phoneno = _T("");
	datetime = _T("");
	m_nFields = 3;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
	m_strSort="datetime desc";
}


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

CString CRstphonerecordout::GetDefaultSQL()
{
	return _T("[phonerecordout]");
}

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

/////////////////////////////////////////////////////////////////////////////
// CRstphonerecordout diagnostics

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

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

IMPLEMENT_DYNAMIC(CRstclient2phonerecordout, CRecordset)

CRstclient2phonerecordout::CRstclient2phonerecordout(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstclient2phonerecordout)
	name = _T("");
	phoneno = _T("");
	datetime = _T("");
	m_nFields = 3;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
	m_strSort="datetime desc";
}


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

CString CRstclient2phonerecordout::GetDefaultSQL()
{
	return _T("[client2phonerecordout]");
}

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

/////////////////////////////////////////////////////////////////////////////
// CRstclient2phonerecordout diagnostics

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

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

IMPLEMENT_DYNAMIC(CRstclient3phonerecordout, CRecordset)

CRstclient3phonerecordout::CRstclient3phonerecordout(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstclient3phonerecordout)
	name = _T("");
	phoneno = _T("");
	datetime = _T("");
	m_nFields = 3;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
	m_strSort="datetime desc";
}


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

CString CRstclient3phonerecordout::GetDefaultSQL()
{
	return _T("[client3phonerecordout]");
}

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

/////////////////////////////////////////////////////////////////////////////
// CRstclient3phonerecordout diagnostics

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

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

CRstemployeephonerecordout::CRstemployeephonerecordout(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstemployeephonerecordout)
	name = _T("");
	phoneno = _T("");
	datetime = _T("");
	m_nFields = 3;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
	m_strSort="datetime desc";
}


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

CString CRstemployeephonerecordout::GetDefaultSQL()
{
	return _T("[employeephonerecordout]");
}

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

/////////////////////////////////////////////////////////////////////////////
// CRstemployeephonerecordout diagnostics

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

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

CRstunknownphonerecordout::CRstunknownphonerecordout(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstunknownphonerecordout)
	phoneno = _T("");
	datetime = _T("");
	m_nFields = 2;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
	m_strSort="datetime desc";
}


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

CString CRstunknownphonerecordout::GetDefaultSQL()
{
	return _T("[unknownphonerecordout]");
}

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

/////////////////////////////////////////////////////////////////////////////
// CRstunknownphonerecordout diagnostics

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

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

CRstmisscallrecord::CRstmisscallrecord(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstmisscallrecord)
	phone = _T("");
	datetime = _T("");
	name = _T("");
	type = _T("");
	m_nFields = 4;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
	m_strSort="datetime desc";
}


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

CString CRstmisscallrecord::GetDefaultSQL()
{
	return _T("[misscallrecord]");
}

void CRstmisscallrecord::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstmisscallrecord)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[phone]"), phone);
	RFX_Text(pFX, _T("[datetime]"), datetime);
	RFX_Text(pFX, _T("[name]"), name);
	RFX_Text(pFX, _T("[type]"), type);

	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstmisscallrecord diagnostics

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

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

CRstsendregcard::CRstsendregcard(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstsendregcard)
	timestamp = _T("");
	phones = _T("");
	m_nFields =2;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
	m_strSort="timestamp desc";
}


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

CString CRstsendregcard::GetDefaultSQL()
{
	return _T("[sendregcard]");
}
void CRstsendregcard::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstsendregcard)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[timestamp]"), timestamp);
	RFX_Text(pFX, _T("[phones]"), phones);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstsendregcard diagnostics

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

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

CRstmsgview::CRstmsgview(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstmsgview)
	timestamp = _T("");
	phones = _T("");
	content = _T("");
	m_nFields =13;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
	m_strSort="timestamp desc";
}


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

CString CRstmsgview::GetDefaultSQL()
{
	return _T("[msgview]");
}
void CRstmsgview::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstmsgview)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[timestamp]"), timestamp);
	RFX_Text(pFX, _T("[phones]"), phones);
	RFX_Text(pFX, _T("[content]"), content);
	RFX_Text(pFX, _T("[name1]"), name1);
	RFX_Text(pFX, _T("[name2]"), name2);
	RFX_Text(pFX, _T("[time1]"), time1);
	RFX_Text(pFX, _T("[ren]"), ren);
	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("[waiter5]"), waiter5);
	RFX_Text(pFX, _T("[waiter7]"), waiter7);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstmsgview diagnostics

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

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

IMPLEMENT_DYNAMIC(CRstinsidemsg, CRecordset)

CRstinsidemsg::CRstinsidemsg(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstinsidemsg)
	timestamp = _T("");
	content = _T("");
	sender = _T("");
	receiver = _T("");
	receiver2 = _T("");
	m_nFields =6;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
	m_strSort="timestamp desc";
}

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

CString CRstinsidemsg::GetDefaultSQL()
{
	return _T("[insidemsg]");
}
void CRstinsidemsg::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstinsidemsg)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[timestamp]"), timestamp);
	RFX_Text(pFX, _T("[sender]"), sender);
	RFX_Text(pFX, _T("[file]"), file, 40960);
	RFX_Text(pFX, _T("[content]"), content, 40960);
	RFX_Text(pFX, _T("[receiver]"), receiver, 40960);
	RFX_Text(pFX, _T("[receiver2]"), receiver2, 40960);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstinsidemsg diagnostics

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

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

IMPLEMENT_DYNAMIC(CRstmembercard2, CRecordset)
CRstmembercard2::CRstmembercard2(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstmembercard2)
	memberno = _T("");
	card2no = _T("");
	date = _T("");
	m_nFields =3;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
}

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

CString CRstmembercard2::GetDefaultSQL()
{
	return _T("[membercard2]");
}
void CRstmembercard2::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstmembercard2)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[memberno]"), memberno);
	RFX_Text(pFX, _T("[card2no]"), card2no);
	RFX_Text(pFX, _T("[date]"), date);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstmembercard2 diagnostics

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

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

IMPLEMENT_DYNAMIC(CRstmembercard3, CRecordset)
CRstmembercard3::CRstmembercard3(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstmembercard3)
	memberno = _T("");
	card2no = _T("");
	date = _T("");
	balance = _T("");
	psw = _T("");
	m_nFields =5;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
}

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

CString CRstmembercard3::GetDefaultSQL()
{
	return _T("[membercard3]");
}
void CRstmembercard3::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstmembercard3)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[memberno]"), memberno);
	RFX_Text(pFX, _T("[card2no]"), card2no);
	RFX_Text(pFX, _T("[date]"), date);
	RFX_Text(pFX, _T("[balance]"), balance);
	RFX_Text(pFX, _T("[psw]"), psw);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstmembercard3 diagnostics

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

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

IMPLEMENT_DYNAMIC(CRstmembercard3usereg, CRecordset)
CRstmembercard3usereg::CRstmembercard3usereg(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstmembercard3usereg)
	memberno = _T("");
	id = _T("");
	date = _T("");
	dindanid = _T("");
	money = _T("");

#if 0	// Jeff.add;
	m_strCashier = _T("");	
	m_strFinancialAudit = _T("");
	m_strModeOfPayment = _T("");
	m_nFields =8;
#else
	m_nFields =5;
#endif
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
}

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

CString CRstmembercard3usereg::GetDefaultSQL()
{
	return _T("[membercard3usereg]");
}
void CRstmembercard3usereg::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstmembercard3usereg)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[memberno]"), memberno);
	RFX_Text(pFX, _T("[id]"), id);
	RFX_Text(pFX, _T("[date]"), date);
	RFX_Text(pFX, _T("[dindanid]"), dindanid);
	RFX_Text(pFX, _T("[money]"), money);
	
#if 0	// Jeff.add
	RFX_Text(pFX,_T("[ModeOfPayment]"),m_strModeOfPayment);
	RFX_Text(pFX,_T("[Cashier]"),m_strCashier);
	RFX_Text(pFX,_T("[FinancialAudit]"),m_strFinancialAudit);
#endif
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstmembercard3usereg diagnostics

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

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

IMPLEMENT_DYNAMIC(CRstmembercard3childusereg, CRecordset)
CRstmembercard3childusereg::CRstmembercard3childusereg(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstmembercard3childusereg)
	memberno = _T("");
	id = _T("");
	date = _T("");
	dindanid = _T("");
	money = _T("");
	m_nFields =5;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
}

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

CString CRstmembercard3childusereg::GetDefaultSQL()
{
	return _T("[membercard3childusereg]");
}
void CRstmembercard3childusereg::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstmembercard3childusereg)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[memberno]"), memberno);
	RFX_Text(pFX, _T("[id]"), id);
	RFX_Text(pFX, _T("[date]"), date);
	RFX_Text(pFX, _T("[dindanid]"), dindanid);
	RFX_Text(pFX, _T("[money]"), money);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstmembercard3childusereg diagnostics

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

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

CRstmembercard2blue::CRstmembercard2blue(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstmembercard2blue)
	memberno = _T("");
	card2no = _T("");
	date = _T("");
	m_nFields =3;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
}

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

CString CRstmembercard2blue::GetDefaultSQL()
{
	return _T("[membercard2blue]");
}
void CRstmembercard2blue::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstmembercard2blue)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[memberno]"), memberno);
	RFX_Text(pFX, _T("[card2no]"), card2no);
	RFX_Text(pFX, _T("[date]"), date);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstmembercard2blue diagnostics

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

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

IMPLEMENT_DYNAMIC(CRstmsgtemp, CRecordset)

CRstmsgtemp::CRstmsgtemp(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstmsgtemp)
	title = _T("");
	content = _T("");
	m_nFields =2;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
}

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

CString CRstmsgtemp::GetDefaultSQL()
{
	return _T("[msgtemp]");
}
void CRstmsgtemp::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstmsgtemp)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[title]"), title);
	RFX_Text(pFX, _T("[content]"), content, 4096);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstmsgtemp diagnostics

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

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

IMPLEMENT_DYNAMIC(CRstmsgtemp2, CRecordset)

CRstmsgtemp2::CRstmsgtemp2(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstmsgtemp2)
	name = _T("");
	content1 = _T("");
	content2 = _T("");
	check1 = _T("");
	check2 = _T("");
	point = _T("");
	m_nFields =6;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
	m_strSort="point desc";
}

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

CString CRstmsgtemp2::GetDefaultSQL()
{
	return _T("[msgtemp2]");
}
void CRstmsgtemp2::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstmsgtemp2)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[name]"), name);
	RFX_Text(pFX, _T("[content1]"), content1, 4096);
	RFX_Text(pFX, _T("[content2]"), content2, 4096);
	RFX_Text(pFX, _T("[check1]"), check1);
	RFX_Text(pFX, _T("[check2]"), check2);
	RFX_Text(pFX, _T("[point]"), point);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstmsgtemp2 diagnostics

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

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

IMPLEMENT_DYNAMIC(CRstdigitalwork, CRecordset)

CRstdigitalwork::CRstdigitalwork(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstdigitalwork)
	id = _T("");
	waiter1 = _T("");
	waiter2 = _T("");
	waiter3 = _T("");
	date1 = _T("");
	date2 = _T("");
	date3 = _T("");
	m_nFields =7;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
}

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

CString CRstdigitalwork::GetDefaultSQL()
{
	return _T("[digitalwork]");
}
void CRstdigitalwork::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstdigitalwork)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[id]"), id);
	RFX_Text(pFX, _T("[waiter1]"), waiter1);
	RFX_Text(pFX, _T("[waiter2]"), waiter2);
	RFX_Text(pFX, _T("[waiter3]"), waiter3);
	RFX_Text(pFX, _T("[date1]"), date1);
	RFX_Text(pFX, _T("[date2]"), date2);
	RFX_Text(pFX, _T("[date3]"), date3);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstdigitalwork diagnostics

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

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

IMPLEMENT_DYNAMIC(CRstMyWork, CRecordset)

CRstMyWork::CRstMyWork(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstMyWork)
	id = _T("");
	name = _T("");
	datetime = _T("");
	count1 = _T("");
	count2 = _T("");
	count3 = _T("");
	type = _T("");
	inputdate = _T("");
	inputren = _T("");
	m_nFields =9;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
}

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

CString CRstMyWork::GetDefaultSQL()
{
	return _T("[mywork]");
}
void CRstMyWork::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstMyWork)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[id]"), id);
	RFX_Text(pFX, _T("[name]"), name);
	RFX_Text(pFX, _T("[datetime]"), datetime);
	RFX_Text(pFX, _T("[count1]"), count1);
	RFX_Text(pFX, _T("[count2]"), count2);
	RFX_Text(pFX, _T("[count3]"), count3);
	RFX_Text(pFX, _T("[type]"), type);
	RFX_Text(pFX, _T("[inputdate]"), inputdate);
	RFX_Text(pFX, _T("[inputren]"), inputren);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstMyWork diagnostics

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

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

IMPLEMENT_DYNAMIC(CRstWorkRate, CRecordset)

CRstWorkRate::CRstWorkRate(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstWorkRate)
	type = _T("");
	data1 = _T("");
	data2 = _T("");
	data3 = _T("");
	data4 = _T("");
	data5 = _T("");
	m_nFields =6;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
}

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

CString CRstWorkRate::GetDefaultSQL()
{
	return _T("[workrate]");
}
void CRstWorkRate::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstWorkRate)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[type]"), type);
	RFX_Text(pFX, _T("[data1]"), data1);
	RFX_Text(pFX, _T("[data2]"), data2);
	RFX_Text(pFX, _T("[data3]"), data3);
	RFX_Text(pFX, _T("[data4]"), data4);	
	RFX_Text(pFX, _T("[data5]"), data5);	
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstWorkRate diagnostics

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

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

IMPLEMENT_DYNAMIC(CRstdindanjd, CRecordset)
CRstdindanjd::CRstdindanjd(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstdindanjd)
	id = _T("");
	name = _T("");
	date = _T("");
	time = _T("");
	waiter1 = _T("");
	waiter2 = _T("");
	status = _T("");
	waiter12 = _T("");
	waiter22 = _T("");
	bookingdate = _T("");
	dress = _T("");
	bz = _T("");
	m_nFields =13;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
	m_strSort="id desc,name desc";
}

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

CString CRstdindanjd::GetDefaultSQL()
{
	return _T("[dindanjd]");
}
void CRstdindanjd::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstdindanjd)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[id]"), id);
	RFX_Text(pFX, _T("[name]"), name);
	RFX_Text(pFX, _T("[date]"), date);
	RFX_Text(pFX, _T("[time]"), time);
	RFX_Text(pFX, _T("[waiter1]"), waiter1);	
	RFX_Text(pFX, _T("[waiter2]"), waiter2);	
	RFX_Text(pFX, _T("[status]"), status);
	RFX_Text(pFX, _T("[waiter12]"), waiter12);	
	RFX_Text(pFX, _T("[waiter22]"), waiter22);	
	RFX_Text(pFX, _T("[bookingdate]"), bookingdate);	
	RFX_Text(pFX, _T("[dress]"), dress);
	RFX_Text(pFX, _T("[bz]"), bz, 150);	
	RFX_Text(pFX, _T("[branch]"), branch);	
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstdindanjd diagnostics

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

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

IMPLEMENT_DYNAMIC(CRstloginsign, CRecordset)
CRstloginsign::CRstloginsign(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstloginsign)
	id = _T("");
	name = _T("");
	date = _T("");
	type = _T("");
	cleck = _T("");
	m_nFields =5;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
}

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

CString CRstloginsign::GetDefaultSQL()
{
	return _T("[loginsign]");
}
void CRstloginsign::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstloginsign)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[id]"), id);
	RFX_Text(pFX, _T("[name]"), name);
	RFX_Text(pFX, _T("[date]"), date);
	RFX_Text(pFX, _T("[type]"), type);
	RFX_Text(pFX, _T("[cleck]"), cleck);		
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstloginsign diagnostics

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

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

IMPLEMENT_DYNAMIC(CRstbakstate, CRecordset)
CRstbakstate::CRstbakstate(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstbakstate)
	date = _T("");
	photo = _T("");
	info = _T("");
	m_nFields =3;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
	m_strSort="date";
}

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

CString CRstbakstate::GetDefaultSQL()
{
	return _T("[bakstate]");
}
void CRstbakstate::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstbakstate)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[date]"), date);
	RFX_Text(pFX, _T("[photo]"), photo);
	RFX_Text(pFX, _T("[info]"), info);		
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstbakstate diagnostics

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

void CRstbakstate::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("");
	name = _T("");
	count = _T("");
	date = _T("");
	clerk = _T("");
	m_nFields =5;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
	m_strSort="date desc,name";
}

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

CString CRstdindansp2::GetDefaultSQL()
{
	return _T("[dindansp2]");
}
void CRstdindansp2::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstdindansp2)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[id]"), id);
	RFX_Text(pFX, _T("[name]"), name);
	RFX_Text(pFX, _T("[count]"), count);	
	RFX_Text(pFX, _T("[date]"), date);
	RFX_Text(pFX, _T("[clerk]"), clerk);	
	//}}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(CRstframesize, CRecordset)
CRstframesize::CRstframesize(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstframesize)
	name = _T("");
	width = _T("");
	height = _T("");
	m_nFields =3;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
}

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

CString CRstframesize::GetDefaultSQL()
{
	return _T("[framesize]");
}
void CRstframesize::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstframesize)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[name]"), name);
	RFX_Text(pFX, _T("[width]"), width);	
	RFX_Text(pFX, _T("[height]"), height);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstframesize diagnostics

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

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

IMPLEMENT_DYNAMIC(CRstchildmsg, CRecordset)
CRstchildmsg::CRstchildmsg(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstchildmsg)
	check = _T("");
	days = _T("");
	content = _T("");
	mode = _T("");
	m_nFields =4;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
}
 
CString CRstchildmsg::GetDefaultConnect()
{
	return _T("ODBC;DSN=");
}

CString CRstchildmsg::GetDefaultSQL()
{
	return _T("[childmsg]");
}
void CRstchildmsg::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstchildmsg)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[check]"), check);
	RFX_Text(pFX, _T("[days]"), days);	
	RFX_Text(pFX, _T("[mode]"), mode);	
	RFX_Text(pFX, _T("[content]"), content, 4096);
	//}}AFX_FIELD_MAP
}
 
/////////////////////////////////////////////////////////////////////////////
// CRstchildmsg diagnostics

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

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

IMPLEMENT_DYNAMIC(CRsttodaytake, CRecordset)
CRsttodaytake::CRsttodaytake(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRsttodaytake)
	name = _T("");
	phone = _T("");
	date = _T("");
	time = _T("");
	type = _T("");
	price = _T("");
	waiter1 = _T("");
	waiter2 = _T("");
	receptionist = _T("");
	arrearage = _T("");
	clerk = _T("");
	remark = _T("");
	timestamp = _T("");
	mode = _T("");
	content = _T("");
	arrive = _T("");
	id = _T("");
	m_nFields =17;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
	m_strSort="date";
}

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

CString CRsttodaytake::GetDefaultSQL()
{
	return _T("[todaytake]");
}
void CRsttodaytake::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRsttodaytake)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[name]"), name);
	RFX_Text(pFX, _T("[phone]"), phone);
	RFX_Text(pFX, _T("[date]"), date);
	RFX_Text(pFX, _T("[time]"), time);
	RFX_Text(pFX, _T("[type]"), type);
	RFX_Text(pFX, _T("[price]"), price);
	RFX_Text(pFX, _T("[waiter1]"), waiter1);
	RFX_Text(pFX, _T("[waiter2]"), waiter2);
	RFX_Text(pFX, _T("[receptionist]"), receptionist);
	RFX_Text(pFX, _T("[arrearage]"), arrearage);
	RFX_Text(pFX, _T("[clerk]"), clerk);
	RFX_Text(pFX, _T("[timestamp]"), timestamp);	
	RFX_Text(pFX, _T("[mode]"), mode);	
	RFX_Text(pFX, _T("[content]"), content);	
	RFX_Text(pFX, _T("[arrive]"), arrive);	
	RFX_Text(pFX, _T("[id]"), id);	
	RFX_Text(pFX, _T("[remark]"), remark, 4096);
	//}}AFX_FIELD_MAP
}
 
/////////////////////////////////////////////////////////////////////////////
// CRsttodaytake diagnostics

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

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

IMPLEMENT_DYNAMIC(CRstdindansp3, CRecordset)
CRstdindansp3::CRstdindansp3(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstdindansp3)
	spid = _T("");
	name = _T("");
	count = _T("");
	id = _T("");
	m_nFields =4;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
	m_strSort="id desc,name";
}

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

CString CRstdindansp3::GetDefaultSQL()
{
	return _T("[dindansp3]");
}
void CRstdindansp3::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstdindansp3)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[id]"), id);
	RFX_Text(pFX, _T("[spid]"), spid);
	RFX_Text(pFX, _T("[name]"), name);
	RFX_Text(pFX, _T("[count]"), count);
	//}}AFX_FIELD_MAP
}
 
/////////////////////////////////////////////////////////////////////////////
// CRstdindansp3 diagnostics

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

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

IMPLEMENT_DYNAMIC(CRstLog, CRecordset)
CRstLog::CRstLog(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstLog)
	datetime = _T("");
	content = _T("");
	m_nFields =2;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;	
	m_strSort="datetime desc";
}

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

CString CRstLog::GetDefaultSQL()
{
	return _T("[log]");
}
void CRstLog::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstLog)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[datetime]"), datetime);
	RFX_Text(pFX, _T("[content]"), content, 1024);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstLog diagnostics

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

void CRstLog::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG 4096
IMPLEMENT_DYNAMIC(CRstDindanForm10, CRecordset)
CRstDindanForm10::CRstDindanForm10(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstDindanForm10)
	m_id = _T("");
	m_name1 = _T("");
	m_name2 = _T("");
	m_taoxiname = _T("");
	m_taoxijiage = _T("");
	m_waiter4 = _T("");
	m_waiter5 = _T("");
	m_waiter7 = _T("");
	m_time8 = _T("");
	m_time9 = _T("");
	m_time10 = _T("");
	m_status4 = _T("");
	m_status6 = _T("");
	m_status5 = _T("");
	m_money2 = _T("");
	m_nFields = 18;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
}


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

CString CRstDindanForm10::GetDefaultSQL()
{
	return _T("[digitalview]");
}

void CRstDindanForm10::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstDindanForm10)
	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("[taoxiname]"), m_taoxiname);
	RFX_Text(pFX, _T("[taoxijiage]"), m_taoxijiage);
	RFX_Text(pFX, _T("[waiter4]"), m_waiter4);
	RFX_Text(pFX, _T("[waiter5]"), m_waiter5);
	RFX_Text(pFX, _T("[waiter7]"), m_waiter7);
	RFX_Text(pFX, _T("[time8]"), m_time8);
	RFX_Text(pFX, _T("[time9]"), m_time9);
	RFX_Text(pFX, _T("[time10]"), m_time10);
	RFX_Text(pFX, _T("[status4]"), m_status4);
	RFX_Text(pFX, _T("[status6]"), m_status6);
	RFX_Text(pFX, _T("[status5]"), m_status5);
	RFX_Text(pFX, _T("[money2]"), m_money2);
	RFX_Text(pFX, _T("[txtype]"), txtype);
	RFX_Text(pFX, _T("[ps]"), ps);
	RFX_Text(pFX, _T("[zs]"), zs);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstDindanForm10 diagnostics

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

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

IMPLEMENT_DYNAMIC(CRstsingleincomemoney, CRecordset)
CRstsingleincomemoney::CRstsingleincomemoney(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstsingleincomemoney)
	autoid = _T("");
	id = _T("");
	money = _T("");
	date = _T("");
	clerk = _T("");
	paytype = _T("");
	jdd = _T("");
	m_nFields = 7;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
}


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

CString CRstsingleincomemoney::GetDefaultSQL()
{
	return _T("[singleincomemoney]");
}

void CRstsingleincomemoney::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstsingleincomemoney)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[autoid]"), autoid);
	RFX_Text(pFX, _T("[id]"), id);
	RFX_Text(pFX, _T("[money]"), money);
	RFX_Text(pFX, _T("[date]"), date);
	RFX_Text(pFX, _T("[clerk]"), clerk);
	RFX_Text(pFX, _T("[paytype]"), paytype);
	RFX_Text(pFX, _T("[jdd]"), jdd);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstsingleincomemoney diagnostics

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

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

IMPLEMENT_DYNAMIC(CRstsingleincomemoneyview, CRecordset)
CRstsingleincomemoneyview::CRstsingleincomemoneyview(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstsingleincomemoneyview)
	autoid = _T("");
	id = _T("");
	money = _T("");
	date = _T("");
	clerk = _T("");
	paytype = _T("");
	name = _T("");
	renyuan1 = _T("");
	renyuan3 = _T("");
	sale2type = _T("");
	financecheck = _T("");	
	jdd = _T("");
	m_nFields = 13;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
}


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

CString CRstsingleincomemoneyview::GetDefaultSQL()
{
	return _T("[singleincomemoneyview]");
}

void CRstsingleincomemoneyview::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstsingleincomemoneyview)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[autoid]"), autoid);
	RFX_Text(pFX, _T("[id]"), id);
	RFX_Text(pFX, _T("[money]"), money);
	RFX_Text(pFX, _T("[date]"), date);
	RFX_Text(pFX, _T("[clerk]"), clerk);
	RFX_Text(pFX, _T("[paytype]"), paytype);
	RFX_Text(pFX, _T("[name]"), name);
	RFX_Text(pFX, _T("[renyuan1]"), renyuan1);
	RFX_Text(pFX, _T("[renyuan3]"), renyuan3);
	RFX_Text(pFX, _T("[sale2type]"), sale2type);
	RFX_Text(pFX, _T("[financecheck]"), financecheck);
	RFX_Text(pFX, _T("[time]"), time);
	RFX_Text(pFX, _T("[jdd]"), jdd);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstsingleincomemoneyview diagnostics

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

void CRstsingleincomemoneyview::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG
IMPLEMENT_DYNAMIC(CRstversion, CRecordset)
CRstversion::CRstversion(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstversion)
	m_nFields = 155;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
}


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

CString CRstversion::GetDefaultSQL()
{
	return _T("[version]");
}

void CRstversion::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstversion)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[version]"), version);
	RFX_Text(pFX, _T("[check1]"), m_check1);
	RFX_Text(pFX, _T("[check2]"), m_check2);
	RFX_Text(pFX, _T("[check3]"), m_check3);
	RFX_Text(pFX, _T("[check4]"), m_check4);
	RFX_Text(pFX, _T("[edit1]"), m_edit1);
	RFX_Text(pFX, _T("[edit2]"), m_edit2);
	RFX_Text(pFX, _T("[edit3]"), m_edit3);
	RFX_Text(pFX, _T("[edit4]"), m_edit4);
	RFX_Text(pFX, _T("[info1]"), m_info1);
	RFX_Text(pFX, _T("[info2]"), m_info2);
	RFX_Text(pFX, _T("[info3]"), m_info3);
	RFX_Text(pFX, _T("[info4]"), m_info4);
 	RFX_Text(pFX, _T("[info5]"), m_info5);
	RFX_Text(pFX, _T("[info6]"), m_info6);
 	RFX_Text(pFX, _T("[bak1]"), m_bak1);
	RFX_Text(pFX, _T("[bak2]"), m_bak2);
	RFX_Text(pFX, _T("[bak3]"), m_bak3);
	RFX_Text(pFX, _T("[bak4]"), m_bak4);
 	RFX_Text(pFX, _T("[bak5]"), m_bak5);
 	RFX_Text(pFX, _T("[bak6]"), m_bak6); 
 	RFX_Text(pFX, _T("[bakserver1]"), m_bakserver1);
	RFX_Text(pFX, _T("[bakserver2]"), m_bakserver2);
	RFX_Text(pFX, _T("[bakserver3]"), m_bakserver3);
	RFX_Text(pFX, _T("[bakserver4]"), m_bakserver4);
 	RFX_Text(pFX, _T("[bakserver5]"), m_bakserver5);
 	RFX_Text(pFX, _T("[baktime]"), m_baktime);
  	RFX_Text(pFX, _T("[msgaccount]"), msgaccount);
  	RFX_Text(pFX, _T("[msgpsw]"), msgpsw);
	RFX_Text(pFX, _T("[msgused]"), msgused);
  	RFX_Text(pFX, _T("[msgbalance]"), msgbalance);
	RFX_Text(pFX, _T("[msgcheck1]"), msgcheck1);
  	RFX_Text(pFX, _T("[msgcheck2]"), msgcheck2);
	RFX_Text(pFX, _T("[msgdays1]"), msgdays1);
	RFX_Text(pFX, _T("[msgdays2]"), msgdays2);
  	RFX_Text(pFX, _T("[msgcontent1]"), msgcontent1, 4096);
	RFX_Text(pFX, _T("[msgcontent2]"), msgcontent2, 4096);
  	RFX_Text(pFX, _T("[remarks]"), remarks, 4096);
	RFX_Text(pFX, _T("[rate]"), rate);
  	RFX_Text(pFX, _T("[msgcheck3]"), msgcheck3);
	RFX_Text(pFX, _T("[msgcontent3]"), msgcontent3, 4096);
  	RFX_Text(pFX, _T("[msgcontent5]"), msgcontent5, 4096);
	RFX_Text(pFX, _T("[msgcontent6]"), msgcontent6, 4096);
  	RFX_Text(pFX, _T("[salarycheck1]"), salarycheck1);
	RFX_Text(pFX, _T("[salarycheck2]"), salarycheck2);
  	RFX_Text(pFX, _T("[salarycheck3]"), salarycheck3);
	RFX_Text(pFX, _T("[salarycheck4]"), salarycheck4);
  	RFX_Text(pFX, _T("[msgcheck4]"), msgcheck4);
	RFX_Text(pFX, _T("[msgcheck5]"), msgcheck5);
  	RFX_Text(pFX, _T("[msgcheck6]"), msgcheck6);
	RFX_Text(pFX, _T("[msgtime]"), msgtime);
  	RFX_Text(pFX, _T("[msgphones]"), msgphones, 4096);
	RFX_Text(pFX, _T("[msgphones2]"), msgphones2, 4096);
  	RFX_Text(pFX, _T("[msgcompanyname]"), msgcompanyname);
	RFX_Text(pFX, _T("[msgsendtype]"), msgsendtype);
  	RFX_Text(pFX, _T("[rate2]"), rate2);
	RFX_Text(pFX, _T("[setcheck1]"), setcheck1);
  	RFX_Text(pFX, _T("[setcheck2]"), setcheck2);
	RFX_Text(pFX, _T("[setcheck3]"), setcheck3);
   	RFX_Text(pFX, _T("[setcheck4]"), setcheck4);
	RFX_Text(pFX, _T("[setcheck5]"), setcheck5);
   	RFX_Text(pFX, _T("[setcheck10]"), setcheck10);
	RFX_Text(pFX, _T("[printer1]"), printer1);
   	RFX_Text(pFX, _T("[printer2]"), printer2);
	RFX_Text(pFX, _T("[printer3]"), printer3);
   	RFX_Text(pFX, _T("[setprintstyle]"), setprintstyle);
	RFX_Text(pFX, _T("[setprintstyle2]"), setprintstyle2);
   	RFX_Text(pFX, _T("[uploadcheck1]"), uploadcheck1);
	RFX_Text(pFX, _T("[uploadcheck2]"), uploadcheck2);
   	RFX_Text(pFX, _T("[uploadcheck3]"), uploadcheck3);
	RFX_Text(pFX, _T("[uploadcheck4]"), uploadcheck4);
   	RFX_Text(pFX, _T("[bak11]"), bak11);
	RFX_Text(pFX, _T("[bak22]"), bak22);
   	RFX_Text(pFX, _T("[bak33]"), bak33);
	RFX_Text(pFX, _T("[bak44]"), bak44);
   	RFX_Text(pFX, _T("[salaryset]"), salaryset, 4096);
	RFX_Text(pFX, _T("[ziptype1]"), ziptype1);
    RFX_Text(pFX, _T("[ziptype2]"), ziptype2);
	RFX_Text(pFX, _T("[ziptype3]"), ziptype3);
   	RFX_Text(pFX, _T("[ziptype4]"), ziptype4);
	RFX_Text(pFX, _T("[limitcount1]"), limitcount1);
   	RFX_Text(pFX, _T("[limitcount2]"), limitcount2);
	RFX_Text(pFX, _T("[limitcount3]"), limitcount3);
   	RFX_Text(pFX, _T("[setcheck11]"), setcheck11);
	RFX_Text(pFX, _T("[setcheck12]"), setcheck12);
   	RFX_Text(pFX, _T("[setprintstyle3]"), setprintstyle3);
	RFX_Text(pFX, _T("[msgcheck7]"), msgcheck7);
   	RFX_Text(pFX, _T("[msgcheck8]"), msgcheck8);
	RFX_Text(pFX, _T("[msgcheck9]"), msgcheck9);
   	RFX_Text(pFX, _T("[msgcheck10]"), msgcheck10);
	RFX_Text(pFX, _T("[msgcontent8]"), msgcontent8, 4096);
    RFX_Text(pFX, _T("[msgcontent9]"), msgcontent9, 4096);
	RFX_Text(pFX, _T("[msgcontent10]"), msgcontent10, 4096);
    RFX_Text(pFX, _T("[setcheck13]"), setcheck13);
	RFX_Text(pFX, _T("[time1]"), time1);
    RFX_Text(pFX, _T("[time2]"), time2);
	RFX_Text(pFX, _T("[time3]"), time3);
    RFX_Text(pFX, _T("[setcheck14]"), setcheck14);
	RFX_Text(pFX, _T("[setcheck15]"), setcheck15);
    RFX_Text(pFX, _T("[setcheck17]"), setcheck17);
	RFX_Text(pFX, _T("[setcheck18]"), setcheck18);
    RFX_Text(pFX, _T("[setcheck19]"), setcheck19);
	RFX_Text(pFX, _T("[msgcheck11]"), msgcheck11);
    RFX_Text(pFX, _T("[msgcheck12]"), msgcheck12);
	RFX_Text(pFX, _T("[msgcheck13]"), msgcheck13);
    RFX_Text(pFX, _T("[msgcheck14]"), msgcheck14);
	RFX_Text(pFX, _T("[msgcontent11]"), msgcontent11, 4096);
    RFX_Text(pFX, _T("[msgcontent12]"), msgcontent12, 4096);
	RFX_Text(pFX, _T("[msgcontent13]"), msgcontent13, 4096);
    RFX_Text(pFX, _T("[msgcontent14]"), msgcontent14, 4096);
	RFX_Text(pFX, _T("[setcheck6]"), setcheck6);
    RFX_Text(pFX, _T("[msgcheck15]"), msgcheck15);
    RFX_Text(pFX, _T("[msgcheck16]"), msgcheck16);
	RFX_Text(pFX, _T("[msgcontent15]"), msgcontent15, 4096);
    RFX_Text(pFX, _T("[logdays]"), logdays);
	RFX_Text(pFX, _T("[uploadrule]"), uploadrule, 4096);
    RFX_Text(pFX, _T("[setcheck20]"), setcheck20);
    RFX_Text(pFX, _T("[cardnum]"), cardnum);
    RFX_Text(pFX, _T("[info1]"), info1);
    RFX_Text(pFX, _T("[info2]"), info2);
    RFX_Text(pFX, _T("[info3]"), info3);
    RFX_Text(pFX, _T("[cardscale]"), cardscale, 500);
    RFX_Text(pFX, _T("[info7]"), m_info7, 120);
    RFX_Text(pFX, _T("[setcheck21]"), setcheck21);  
	RFX_Text(pFX, _T("[setcheck22]"), setcheck22);
	RFX_Text(pFX, _T("[setcheck23]"), setcheck23);
    RFX_Text(pFX, _T("[hospitalmsgcheck1]"), hospitalmsgcheck1);
    RFX_Text(pFX, _T("[hospitalmsgcheck2]"), hospitalmsgcheck2);
    RFX_Text(pFX, _T("[serialno]"), serialno);
    RFX_Text(pFX, _T("[serialno2]"), serialno2);
    RFX_Text(pFX, _T("[msgcheck17]"), msgcheck17); 
	RFX_Text(pFX, _T("[info8]"), info8);
	RFX_Text(pFX, _T("[info9]"), info9);
	RFX_Text(pFX, _T("[setcheck24]"), setcheck24);
	RFX_Text(pFX, _T("[outtime]"), outtime);
	RFX_Text(pFX, _T("[msgcontent17]"), msgcontent17, 4096);
	RFX_Text(pFX, _T("[reverse1]"), reverse1);
	RFX_Text(pFX, _T("[reverse2]"), reverse2);
	RFX_Text(pFX, _T("[reverse3]"), reverse3);
	RFX_Text(pFX, _T("[reverse4]"), reverse4);
	RFX_Text(pFX, _T("[reverse5]"), reverse5);

	RFX_Text(pFX, _T("[delcheck1]"), m_delcheck1);
	RFX_Text(pFX, _T("[delcheck2]"), m_delcheck2);
	RFX_Text(pFX, _T("[delcheck3]"), m_delcheck3);
	RFX_Text(pFX, _T("[delcheck4]"), m_delcheck4);
	RFX_Text(pFX, _T("[deledit1]"), m_deledit1);
	RFX_Text(pFX, _T("[deledit2]"), m_deledit2);
	RFX_Text(pFX, _T("[deledit3]"), m_deledit3);
	RFX_Text(pFX, _T("[deledit4]"), m_deledit4);
	RFX_Text(pFX, _T("[alarmdays1]"), alarmdays1);
	RFX_Text(pFX, _T("[alarmdays2]"), alarmdays2);
	RFX_Text(pFX, _T("[alarmdays3]"), alarmdays3);
	RFX_Text(pFX, _T("[alarmdays4]"), alarmdays4);
	RFX_Text(pFX, _T("[alarmdays5]"), alarmdays5);
	RFX_Text(pFX, _T("[alarmdays6]"), alarmdays6);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstversion diagnostics

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

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


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


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

CString CRstbusinesstype::GetDefaultSQL()
{
	return _T("[businesstype]");
}

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

/////////////////////////////////////////////////////////////////////////////
// CRstbusinesstype diagnostics

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

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


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


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

CString CRstbusinessintention::GetDefaultSQL()
{
	return _T("[businessintention]");
}

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

/////////////////////////////////////////////////////////////////////////////
// CRstbusinessintention diagnostics

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

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


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


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

CString CRstclienttype::GetDefaultSQL()
{
	return _T("[clienttype]");
}

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

/////////////////////////////////////////////////////////////////////////////
// CRstclienttype diagnostics

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

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


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


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

CString CRsthospital::GetDefaultSQL()
{
	return _T("[hospital]");
}

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

/////////////////////////////////////////////////////////////////////////////
// CRsthospital diagnostics

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

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

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


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

CString CRstclientqequirement::GetDefaultSQL()
{
	return _T("[clientqequirement]");
}

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

/////////////////////////////////////////////////////////////////////////////
// CRstclientqequirement diagnostics

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

void CRstclientqequirement::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG
IMPLEMENT_DYNAMIC(CRsthospitalclientcontactreg, CRecordset)
CRsthospitalclientcontactreg::CRsthospitalclientcontactreg(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRsthospitalclientcontactreg)
	m_nFields = 8;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
}


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

CString CRsthospitalclientcontactreg::GetDefaultSQL()
{
	return _T("[hospitalclientcontactreg]");
}

void CRsthospitalclientcontactreg::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRsthospitalclientcontactreg)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[autoid]"), autoid);
	RFX_Text(pFX, _T("[businesstype]"), businesstype);
	RFX_Text(pFX, _T("[businessintention]"), businessintention);
	RFX_Text(pFX, _T("[bookingdate]"), bookingdate);
	RFX_Text(pFX, _T("[desaddr]"), desaddr);
	RFX_Text(pFX, _T("[businessremark]"), businessremark);
	RFX_Text(pFX, _T("[alarmcheck]"), alarmcheck);
	RFX_Text(pFX, _T("[alarmdate]"), alarmdate);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRsthospitalclientcontactreg diagnostics

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

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

IMPLEMENT_DYNAMIC(CRsthospitalview, CRecordset)
CRsthospitalview::CRsthospitalview(CDatabase* pdb)
	: CRecordset(pdb)
{
	//m_nFields = 24;	// Jeff,添加了变量，这里要修改个数；
	m_nFields = 26;

	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
	m_strSort="id desc";
}


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

CString CRsthospitalview::GetDefaultSQL()
{
	return _T("[hospitalview]");
}

void CRsthospitalview::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRsthospitalview)
	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("[sex]"), sex);
	/************************************************************************/
	RFX_Text(pFX, _T("[birthdaytype]"), birthdaytype);
	RFX_Text(pFX, _T("[birthday]"), birthday);
	/************************************************************************/
	RFX_Text(pFX, _T("[from]"), from);
	RFX_Text(pFX, _T("[type]"), type);
	RFX_Text(pFX, _T("[hospital]"), hospital);
	RFX_Text(pFX, _T("[phone1]"), phone1);
	RFX_Text(pFX, _T("[phone2]"), phone2);
	RFX_Text(pFX, _T("[qq]"), qq);
	RFX_Text(pFX, _T("[addr1]"), addr1);
	RFX_Text(pFX, _T("[addr2]"), addr2);
	RFX_Text(pFX, _T("[addr3]"), addr3);
	RFX_Text(pFX, _T("[inputdate]"), inputdate);
	RFX_Text(pFX, _T("[clerk]"), clerk);
	RFX_Text(pFX, _T("[inputer]"), inputer);
	RFX_Text(pFX, _T("[businesstype]"), businesstype);
	RFX_Text(pFX, _T("[businessintention]"), businessintention);
	RFX_Text(pFX, _T("[bookingdate]"), bookingdate);
	RFX_Text(pFX, _T("[alarmdate]"), alarmdate);
	RFX_Text(pFX, _T("[desaddr]"), desaddr);
	RFX_Text(pFX, _T("[businessremark]"), businessremark);
	RFX_Text(pFX, _T("[pinyin1]"), pinyin1);
	RFX_Text(pFX, _T("[pinyin2]"), pinyin2);	
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRsthospitalview diagnostics

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

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

IMPLEMENT_DYNAMIC(CRstclientserviceview, CRecordset)
CRstclientserviceview::CRstclientserviceview(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstclientserviceview)
	m_nFields = 22;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
	m_strSort="id desc,autoid";
}


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

CString CRstclientserviceview::GetDefaultSQL()
{
	return _T("[clientserviceview]");
}

void CRstclientserviceview::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstclientserviceview)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[dindanid]"), dindanid);
	RFX_Text(pFX, _T("[name1]"), name1);
	RFX_Text(pFX, _T("[name2]"), name2);
	RFX_Text(pFX, _T("[phone1]"), phone1);
 	RFX_Text(pFX, _T("[addr1]"), addr1);
	RFX_Text(pFX, _T("[qq1]"), qq1);
 	RFX_Text(pFX, _T("[txtype]"), txtype);
	RFX_Text(pFX, _T("[ren]"), ren);
	RFX_Text(pFX, _T("[from]"), from);
 	RFX_Text(pFX, _T("[checkcontent]"), checkcontent);
	RFX_Text(pFX, _T("[clientqq]"), clientqq);
	RFX_Text(pFX, _T("[contact]"), contact);
	RFX_Text(pFX, _T("[time]"), time);
 	RFX_Text(pFX, _T("[clerk]"), clerk);
	RFX_Text(pFX, _T("[useqq]"), useqq);
	RFX_Text(pFX, _T("[date]"), date);
 	RFX_Text(pFX, _T("[question]"), question);
	RFX_Text(pFX, _T("[solution]"), solution, 4096);
	RFX_Text(pFX, _T("[result]"), result);
	RFX_Text(pFX, _T("[autoid]"), autoid);
	RFX_Text(pFX, _T("[pinyin1]"), pinyin1);
	RFX_Text(pFX, _T("[pinyin2]"), pinyin2); 
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstclientserviceview diagnostics

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

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

IMPLEMENT_DYNAMIC(CRsthospitalclient, CRecordset)
CRsthospitalclient::CRsthospitalclient(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRsthospitalclient)
	m_nFields = 28;
	//}}AFX_FIELD_INIT
	m_nDefaultType = forwardOnly;
	this->m_pDatabase = g_curdb; 
}


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

CString CRsthospitalclient::GetDefaultSQL()
{
	return _T("[hospitalclient]");
}

void CRsthospitalclient::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRsthospitalclient)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[checkmsg]"), checkmsg);
	RFX_Text(pFX, _T("[name1]"), name1);
	RFX_Text(pFX, _T("[name2]"), name2);
 	RFX_Text(pFX, _T("[food]"), food);
	RFX_Text(pFX, _T("[sex]"), sex);
	RFX_Text(pFX, _T("[check1]"), check1);
	RFX_Text(pFX, _T("[birthdaytype]"), birthdaytype);
	RFX_Text(pFX, _T("[birthday]"), birthday);
	RFX_Text(pFX, _T("[pregnancydays]"), pregnancydays);
	RFX_Text(pFX, _T("[qq]"), qq);
	RFX_Text(pFX, _T("[date1]"), date1);
	RFX_Text(pFX, _T("[id]"), no);
	RFX_Text(pFX, _T("[from]"), from);
	RFX_Text(pFX, _T("[clerk]"), clerk);
	RFX_Text(pFX, _T("[type]"), type);
	RFX_Text(pFX, _T("[hospital]"), hospital);
  	RFX_Text(pFX, _T("[remark]"), remark);
	RFX_Text(pFX, _T("[phone1]"), phone1);
  	RFX_Text(pFX, _T("[phone2]"), phone2);
	RFX_Text(pFX, _T("[phone3]"), phone3);
  	RFX_Text(pFX, _T("[phone4]"), phone4);
	RFX_Text(pFX, _T("[phone5]"), phone5);
    RFX_Text(pFX, _T("[addr1]"), addr1);
	RFX_Text(pFX, _T("[addr2]"), addr2);
  	RFX_Text(pFX, _T("[addr3]"), addr3);
	RFX_Text(pFX, _T("[post1]"), post1);
  	RFX_Text(pFX, _T("[post2]"), post2);
	RFX_Text(pFX, _T("[post3]"), post3);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRsthospitalclient diagnostics

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

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

IMPLEMENT_DYNAMIC(CRstfixedassets, CRecordset)
CRstfixedassets::CRstfixedassets(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstfixedassets)
	m_nFields = 8;
	//}}AFX_FIELD_INIT
	m_nDefaultType = dynamic;
	this->m_pDatabase = g_curdb; 
}


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

CString CRstfixedassets::GetDefaultSQL()
{
	return _T("[fixedassets]");
}

void CRstfixedassets::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstfixedassets)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[id]"), id);
	RFX_Text(pFX, _T("[name]"), name);
	RFX_Text(pFX, _T("[count]"), count);
  	RFX_Text(pFX, _T("[type]"), type);
	RFX_Text(pFX, _T("[clerk]"), clerk);
  	RFX_Text(pFX, _T("[date]"), date);
  	RFX_Text(pFX, _T("[remark]"), remark, 4096);
	RFX_LongBinary(pFX, _T("[photo]"), photo);
	//}}AFX_FIELD_MAP
}

/////////////////////////////////////////////////////////////////////////////
// CRstfixedassets diagnostics

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

void CRstfixedassets::Dump(CDumpContext& dc) const
{
	CRecordset::Dump(dc);
}
#endif //_DEBUG [no]


IMPLEMENT_DYNAMIC(qjviewReg, CRecordset)
qjviewReg::qjviewReg(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(qjviewReg)
	m_nFields = 10;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
}

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

CString qjviewReg::GetDefaultSQL()
{
	return _T("[qjview]");
}

void qjviewReg::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(qjviewReg)
	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("[name]"), name);
	RFX_Text(pFX, _T("[shuliang]"), shuliang);
	RFX_Text(pFX, _T("[status3]"), status3);
	RFX_Text(pFX, _T("[status4]"), status4);
	RFX_Text(pFX, _T("[date2]"), date2);
	RFX_Text(pFX, _T("[status1]"), status1);
	RFX_Text(pFX, _T("[date3]"), date3);
	//}}AFX_FIELD_MAP clerk
}

/////////////////////////////////////////////////////////////////////////////
// qjviewReg diagnostics

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

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

IMPLEMENT_DYNAMIC(CRstfilemanage, CRecordset)
CRstfilemanage::CRstfilemanage(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstfilemanage)
	m_nFields = 3;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	m_nDefaultType = forwardOnly;
}

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

CString CRstfilemanage::GetDefaultSQL()
{
	return _T("[filemanage]");
}

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

/////////////////////////////////////////////////////////////////////////////
// CRstfilemanage diagnostics

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

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

IMPLEMENT_DYNAMIC(CRstfilemanage2, CRecordset)
CRstfilemanage2::CRstfilemanage2(CDatabase* pdb)
	: CRecordset(pdb)
{
	//{{AFX_FIELD_INIT(CRstfilemanage2)
	m_nFields = 8;
	//m_nFields = 7;
	//}}AFX_FIELD_INIT
	this->m_pDatabase = g_curdb; 
	//m_nDefaultType = forwardOnly;
	m_nDefaultType = dynaset;
	m_strSort="date desc";
}

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

CString CRstfilemanage2::GetDefaultSQL()
{
	return _T("[filemanage2]");
}

void CRstfilemanage2::DoFieldExchange(CFieldExchange* pFX)
{
	//{{AFX_FIELD_MAP(CRstfilemanage2)
	pFX->SetFieldType(CFieldExchange::outputColumn);
	RFX_Text(pFX, _T("[parent]"), parent);
	RFX_Text(pFX, _T("[filename]"), filename);
	RFX_Text(pFX, _T("[clerk]"), clerk);
	RFX_Text(pFX, _T("[date]"), date);
	RFX_Text(pFX, _T("[level]"), level);
	RFX_Text(pFX, _T("[bz]"), bz);	
	RFX_Text(pFX, _T("[position]"), position);
	RFX_LongBinary(pFX, _T("[files]"), files);
	//}}AFX_FIELD_MAP clerk
}

/////////////////////////////////////////////////////////////////////////////
// CRstfilemanage2 diagnostics

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

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