xkexecengine.cpp

简单数据库管理系统

// xkExecEngine.cpp: implementation of the xkExecEngine class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "xkDBMS.h"
#include "xkExecEngine.h"
#include <assert.h>
#include "xkDBMSView.h"
#include "MainFrm.h"
#include "Shlwapi.h"

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

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
extern xkDict* pDict_;
//extern xkMemCoordinator* pMem_;
extern CxkDBMSApp theApp;

xkExecEngine::xkExecEngine(xkDict* pDict_, xkMemCoordinator* pMem_)
{	
	this->pDict_ = pDict_;
	this->pMem_ = pMem_;
}

xkExecEngine::~xkExecEngine()
{
	if(pMem_)
		delete pMem_;
	if(pDict_)
		delete pDict_;
}

int xkExecEngine::FindTable(const char* tablename_)
{
	return pDict_->FindTable(tablename_);
}

void xkExecEngine::LoadDict()
{
	pDict_->LoadxkDict();
}

void xkExecEngine::SaveDict()
{
	pDict_->SavexkDict();
}

bool xkExecEngine::CreateRelation(const char* tablename_, Vector<char*> &fields_,
								  Vector<int> &type_, Vector<bool> &iskey_, int count_)
{
	assert(count_ > 0);
	xkAttribute* pa_ = new xkAttribute[count_];
	for(size_t i = 0; i < count_; i++)
	{
		char* name_ = new char[strlen(fields_[i]) + 1];
		strcpy(name_, fields_[i]);
		pa_[i].SetName(name_);
		pa_[i].SetSize(strlen(name_));
		switch(type_[i])
		{
			case 0:
				pa_[i].SetType((xkAttributeType)t_int);
				break;
			case 1:
				pa_[i].SetType((xkAttributeType)t_float);
				break;
			case 2:
				pa_[i].SetType((xkAttributeType)t_string);
				break;
			case 3:
				pa_[i].SetType((xkAttributeType)t_char);
				break;
			default:
				break;
		}
		if(iskey_[i])
			pa_[i].SetKey();
	}
	char* tname_ = new char[strlen(tablename_) + 1];
	strcpy(tname_, tablename_);
	return pDict_->CreateRelation(pa_, count_, (char*)tname_);
}

bool xkExecEngine::DropRelation(const char* tablename_)
{
	int rid_ = FindTable(tablename_);
	if(rid_ == -1)
	{
		AfxMessageBox("表名不存在!");
		return false;
	}
	return pDict_->DropRelation(rid_);
}
/*
 *	先判断表名和关键字是否存在
	取剩余记录并在控件中显示
 */
bool xkExecEngine::DeleteTuple(const char* tablename_, const char* key_, char* keyval_)
{
	int rid_ = FindTable(tablename_);
	if(rid_ == -1)
	{
		AfxMessageBox("表名不存在!");
		return false;
	}
	if(key_)
	{
		xkAttriStruct pas_;
		GetTableAttribute(rid_, pas_);
		assert(pas_.pa_ != 0);
		size_t i = 0;
		for(i = 0; i < pas_.attrcount_; i++)
		{
			if(pas_.pa_[i].IsKey())
				break;
		}
		if(strlen(pas_.pa_[i].GetName()) != strlen(key_))
		{
			AfxMessageBox("关键字不对!");
			return false;
		}
		if(strcmp(pas_.pa_[i].GetName(), key_) != 0)
		{
			AfxMessageBox("关键字不对!");
			return false;
		}
		//delete the selected record
		xkRelation* pr_ = pDict_->GetRelation(rid_);
		if(pas_.pa_[i].GetType() == t_int)
		{
			int intval_ = StrToInt(keyval_);
			if(!pr_->DeleteTuple(pas_.pa_[i], &intval_))
			{
				AfxMessageBox("无法删除记录!");
				return false;
			}
		}
		else if(pas_.pa_[i].GetType() == t_float)
		{
			float floatval_ = (float)strtod(keyval_, NULL);
			if(!pr_->DeleteTuple(pas_.pa_[i], &floatval_))
			{
				AfxMessageBox("无法删除记录!");
				return false;
			}
		}
		else if(pas_.pa_[i].GetType() == t_string || pas_.pa_[i].GetType() == t_char)
		{
			if(!pr_->DeleteTuple(pas_.pa_[i], keyval_))
			{
				AfxMessageBox("无法删除记录!");
				return false;
			}
		}
		//show the latest table
		DisplayTable(tablename_);
		return true;
	}
	else//detele all records
	{
		DeleteAllRecords(rid_);
		return true;
	}
	return false;
}
/*
 *	先判断表名和关键字是否存在
	在取记录并在控件中显示
 */
bool xkExecEngine::GetSelectedTuple(const char* tablename_, const char* key_, char* keyval_, Vector<char*> *fieldlist_)
{
	int rid_ = FindTable(tablename_);
	if(rid_ == -1)
	{
		AfxMessageBox("表名不存在!");
		return false;
	}

	xkAttriStruct pas_;
	GetTableAttribute(rid_, pas_);
	assert(pas_.pa_ != 0);

	size_t i = 0;
	for(i = 0; i < pas_.attrcount_; i++)
	{
		if(pas_.pa_[i].IsKey())
			break;
	}
	if(strlen(pas_.pa_[i].GetName()) != strlen(key_))
	{
		AfxMessageBox("关键字不对!");
		return false;
	}
	if(strcmp(pas_.pa_[i].GetName(), key_) != 0)
	{
		AfxMessageBox("关键字不对!");
		return false;
	}
	size_t tuplesize_ = GetTabletuplesize(rid_);
	char* desired_ = new char[tuplesize_ + 1];

	xkRelation* pr_ = pDict_->GetRelation(rid_);
	//将关键字转换为字符串
	if(pas_.pa_[i].GetType() == t_int)
	{
		int intval_ = StrToInt(keyval_);
		if(pr_->GetSelectedTuple(pas_.pa_[i], &intval_, desired_) == false)
		return false;
	}
	else if(pas_.pa_[i].GetType() == t_float)
	{
		float floatval_ = (float)strtod(keyval_,NULL);
		if(pr_->GetSelectedTuple(pas_.pa_[i], &floatval_, desired_) == false)
		return false;
	}
	else if(pas_.pa_[i].GetType() == t_string || pas_.pa_[i].GetType() == t_char)
	{
		if(pr_->GetSelectedTuple(pas_.pa_[i], keyval_, desired_) == false)
			return false;
	}
	// display the selected record
	CxkDBMSView* pview_ = (CxkDBMSView*) ((CMainFrame*)theApp.m_pMainWnd)->GetActiveView();
	int row_count_ = pview_->m_recordset.GetItemCount();
	for(size_t r = 0; r < row_count_; r++)
		pview_->m_recordset.DeleteItem(0);

	int col_count_ = pview_->m_recordset.GetHeaderCtrl()->GetItemCount();
	for(size_t c = 0; c < col_count_; c++)
		pview_->m_recordset.DeleteColumn(0);
	//设选中字段
	for(i = 0; i < pas_.attrcount_; i++)
		pas_.pa_[i].SetSelected(false);//设初始值
	if(fieldlist_ != 0)
	{
		if(fieldlist_->size() != 0)
		{
			size_t fcount_ = fieldlist_->size();
			for(size_t fi = 0; fi < fcount_; fi++)
				for(size_t ai = 0; ai < pas_.attrcount_; ai++)
				{
					if(strlen((*fieldlist_)[fi]) == strlen(pas_.pa_[ai].GetName()) && strcmp((*fieldlist_)[fi], pas_.pa_[ai].GetName()) == 0)
					{
						pas_.pa_[ai].SetSelected(true);
						break;
					}
				}
		}
	}
	size_t selected_ = 0;
	for(i = 0; i < pas_.attrcount_; i++)
	{	
		if(fieldlist_ != 0)
		{
			if(pas_.pa_[i].GetSelected())
				pview_->m_recordset.InsertColumn(selected_++, (LPCTSTR)pas_.pa_[i].GetName(), LVCFMT_LEFT, 100);		
		}
		else
		{
			pview_->m_recordset.InsertColumn(selected_++, (LPCTSTR)pas_.pa_[i].GetName(), LVCFMT_LEFT, 100);
		}
	}
	
	LV_ITEM item_;
	item_.mask = LVIF_TEXT;
	size_t pos_ = 0;
	bool flag1_ = false;
	size_t colcount_ = 0;
	char* tmp_ = 0;
	for(i = 0; i < pas_.attrcount_; i++)
	{
		item_.iItem = 0;
		if(pas_.pa_[i].GetType() == t_int)
		{
			int intval_;
			memcpy(&intval_, desired_ + pos_, pas_.pa_[i].GetLength());
			tmp_ = new char[11];
			_itoa(intval_, tmp_, 10);
			tmp_[11] = '\0';
			item_.pszText = (LPSTR)tmp_;
		}
		else if(pas_.pa_[i].GetType() == t_float)
		{
			float floatval_;
			memcpy(&floatval_, desired_ + pos_, pas_.pa_[i].GetLength());
			char* buf_ = 0;
			int decimal_ = 0, sign_ = 0;
			buf_ = _ecvt(double(floatval_), 10, &decimal_, &sign_);
			tmp_ = new char[12];
			size_t t = 0;
			if(sign_)
				tmp_[t++] = '-';
			for(size_t j = 0; j < 10; j++)
			{
				if(j == decimal_)
					tmp_[t++] = '.';
				tmp_[t++] = buf_[j];
			}
			tmp_[12] = '\0';
			item_.pszText = (LPSTR)tmp_;
		}
		else if(pas_.pa_[i].GetType() == t_string || pas_.pa_[i].GetType() == t_char)
		{
			tmp_ = new char[pas_.pa_[i].GetLength() + 1];
			memcpy(tmp_, desired_ + pos_, pas_.pa_[i].GetLength());
			tmp_[pas_.pa_[i].GetLength()] = '\0';
			item_.pszText = (LPSTR)tmp_;
		}
		if(fieldlist_ != 0)
		{
			if(pas_.pa_[i].GetSelected())
			{
				if(!flag1_)
				{
					item_.iSubItem = colcount_++;
					pview_->m_recordset.InsertItem(&item_);
					flag1_ = true;
				}
				else
				{
					item_.iSubItem = colcount_++;
					pview_->m_recordset.SetItem(&item_);
				}
			}
		}
		else
		{
			if(!flag1_)
			{
				item_.iSubItem = colcount_++;
				pview_->m_recordset.InsertItem(&item_);
				flag1_ = true;
			}
			else
			{
				item_.iSubItem = colcount_++;
				pview_->m_recordset.SetItem(&item_);
			}
		}
		pos_ += pas_.pa_[i].GetLength();
	}
//	delete[] tmp_;
	delete[] desired_;
	desired_ = 0;
	return 1;
}

bool xkExecEngine::UpdateTuple(const char *tablename_, const xkAttribute &attr_, const void *originalval_, const void *value_)
{
	int i = FindTable(tablename_);
	assert(i != -1);
	xkRelation* pr_ = pDict_->GetRelation(i);
	if(attr_.GetType() == t_int)
	{
		int intval_ = StrToInt((char*)originalval_);
		return pr_->UpdateTuple(attr_, &intval_, value_);
	}
	else if(attr_.GetType() == t_float)
	{
		float floatval_ = (float)strtod((char*)originalval_, NULL);
		return pr_->UpdateTuple(attr_, &floatval_, value_);
	}
	else if(attr_.GetType() == t_string || attr_.GetType() == t_char)
	{
		return pr_->UpdateTuple(attr_, originalval_, value_);
	}
	return false;
}

bool xkExecEngine::InsertTuple(const char *tablename_, Vector<char*>& fieldlist_, Vector<char*>& valuelist_)
{
	int rid_ = FindTable(tablename_);
	assert(rid_ != -1);
	xkRelation* pr_ = pDict_->GetRelation(rid_);
	xkAttriStruct pas_;
	GetTableAttribute(rid_, pas_);
	assert(pas_.pa_ != 0);
	//判断字段列表是否合法
	if(fieldlist_.size() != pas_.attrcount_)
	{
		AfxMessageBox("请输入完整字段列表!");
		return false;
	}
	size_t i = 0, j = 0;
	for(i = 0; i < pas_.attrcount_; i++)
	{
		bool valid_ = false;
		for(j = 0; j < fieldlist_.size(); j++)