executor.cpp

our homework big project

////////////////////////////////////////////////////////////////////////////
//
//
//
//
////////////////////////////////////////////////////////////////////////////


#include "Executor.h"
//#include "stdafx.h"

 


//extern map<string,TokenValue> TokenMap;

//执行函数CteatTable的定义
string ExCreateTable::ExecuteSQL(int line)
{
	
	string path="data\\";
	string fullCataName = path+m_ACTresult.m_catahead.tname+".cata";
	string fullRecdName = path+m_ACTresult.m_catahead.tname+".recd";
	ifstream fin;
    
	//测试表是否已经存在
	fin.open(fullCataName.c_str(),ios::in|ios::binary);
	if(fin.is_open())
	{	
		fin.close();
		throw  ErrorPos(ID_ERROR_EXISTTABLE,line);
	}
	fin.close();
	
	//用于测试建表语句中是否有重复属性定义
	set<string> s_tmp;
	for(int j=0; j<m_ACTresult.m_catahead.number; j++)
		s_tmp.insert(m_ACTresult.m_cata[j].attrName);
	
	if(s_tmp.size() != m_ACTresult.m_cata.size())
	{
		throw ErrorPos(ID_ERROR_SAMEATTR,line);								//属性重复
	}
	
	ofstream fout(fullCataName.c_str(),ios::out|ios::binary);
	
	if(!fout.is_open())
	{
		//int error=GetLastError();
		throw ErrorPos(ID_ERROR_EXCREATETABLE,line);						//建表失败
	}
	
	fout.write((char *)&(m_ACTresult.m_catahead),sizeof CatalogHead);		//写入文件头
	
	for(int i=0; i<m_ACTresult.m_catahead.number; i++)
	{
		
		fout.write((char *)& (m_ACTresult.m_cata[i]),sizeof CatalogFile);	//写入各个属性
		//AfxMessageBox(m_ACTresult.m_cata[i].attrName.c_str());
	}
	fout.close();
	
	int numOfRecord=0;
	int firstBlank=-1;
	
	fout.open(fullRecdName.c_str(),ios::out|ios::binary);
	if(!fout.is_open())
	{
		throw ErrorPos(ID_ERROR_EXCREATETABLE,line);						//建表失败
	}
	
	fout.write((char *)&numOfRecord,sizeof(int));
	fout.write((char *)&firstBlank,sizeof(int));
	fout.close();

	
	for( int k=0; k<m_ACTresult.m_catahead.number; k++)
	{
		
		if(m_ACTresult.m_cata[k].primaryFlag == 1)
		{ 
			string tmp("");
			tmp = tmp+m_ACTresult.m_cata[k].attrName+" on "+m_ACTresult.m_catahead.tname+"("+m_ACTresult.m_cata[k].attrName+")"+";";
			vector<string> v_tmp;
			SplitString a(tmp);
			a.SplitWords(v_tmp);
			AnCreateIndex antmp(v_tmp);
			antmp.AnalyseSQL(0,line);
			ExCreateIndex extmp(antmp);
			extmp.ExecuteSQL(line);
			break;
		}
	}
	return string("*****表被成功创建!*****");
}



string ExCreateIndex::ExecuteSQL(int line)
{
	ifstream fin;
	string path="data\\";
	string fullCataName = path+m_ACIresult.m_tableName+".cata";
	CatalogHead head;
	CatalogFile attr;
	
	fin.open(fullCataName.c_str(),ios::in|ios::binary);
	if(!fin.is_open())
	{	
		throw  ErrorPos(ID_ERROR_NOEXISTTABLE,line);				//表不存在
	}
	
	fin.read((char *)&head,sizeof(head));
	for( int i=0; i<head.number; i++)
	{
		fin.read((char *)&attr,sizeof(attr));
		if(attr.attrName == m_ACIresult.m_attrName && attr.uniqueFlag == 1)
		{
			break;
		}
	}
	if(i==head.number)
	{
		throw ErrorPos(ID_ERROR_EXCREATEINDEX,line);			//不能创建索引（找不到索引项）
	}
	int attrID = i;
	
	string fullIndexName = m_ACIresult.m_indexName;
							
	ifstream ffin(fullIndexName.c_str(),ios::in|ios::binary);
	if(ffin.is_open())
	{
		ffin.close();
		throw ErrorPos(ID_ERROR_EXSITINDEX,line);				//索引已经建立
	}
	ffin.close();
	
	switch(attr.typeFlag)
	{
	case 0:
		{
			Node<char *> char_node;
			RecordManager recd(m_ACIresult.m_tableName);
			for(int i=0; i<recd.GetRecordAmount(); i++)
			{
				if(recd.GetRecordHead(i).m_valid==true)
				{
					char *tmp=new char[attr.size];
					recd.RecordAtrrIO(*tmp,i,attrID,'i',attr.size);
					char_node.Insert_node(tmp,i);
					//delete []tmp;
				}
			}
			char_node.Index(fullIndexName,'c');
			break;
		}
			
	
	case 1:
		{
			Node<int> int_node;
			RecordManager recd(m_ACIresult.m_tableName);
			for(int i=0; i<recd.GetRecordAmount(); i++)
			{
				if(recd.GetRecordHead(i).m_valid==true)
				{
					int tmp;
					recd.RecordAtrrIO(tmp,i,attrID,'i',4);
					int_node.Insert_node(tmp,i);
				}
				
			}
			int_node.Index(fullIndexName,1);
			break;
		}
			

	case 2:
		{
			Node<float> float_node;
			RecordManager recd(m_ACIresult.m_tableName);
			for(int i=0; i<recd.GetRecordAmount(); i++)
			{
				if(recd.GetRecordHead(i).m_valid==true)
				{
					float tmp;
					recd.RecordAtrrIO(tmp,i,attrID,'i',4);
					float_node.Insert_node(tmp,i);
				}
			}
			float_node.Index(fullIndexName,1.0f);
			break;
		}
	}
	fin.close();
	return string("****索引被成功创建!****");
}




string ExDropTable::ExecuteSQL(int line)
{
	string path="data\\";
	string fullCataName = path+m_ADTresult.m_tableName+".cata";
	string fullRecdName = path+m_ADTresult.m_tableName+".recd";
	CatalogHead chead;
	CatalogFile cfile;
	ifstream fin(fullCataName.c_str(),ios::in|ios::binary);

	if(!fin.is_open())
	{
		throw ErrorPos(ID_ERROR_NOEXISTTABLE,line);
	}
	fin.seekg(0,ios::beg);
	fin.read((char *)&chead,sizeof(chead));
	for(int i=0; i<chead.number; i++)
	{
		fin.read((char *)&cfile,sizeof(cfile));
		if(cfile.primaryFlag==1)
		{
			CFile::Remove(string("data\\"+string(cfile.attrName)+".indx").c_str());
			break;
		}
			
	}
	fin.close();

	CFile::Remove(fullCataName.c_str());
	CFile::Remove(fullRecdName.c_str());
	//	AfxMessageBox("hello");
	return string("*****表被成功删除!*****");
}


string ExDropIndex::ExecuteSQL(int line)
{
	string path="data\\";
	string fullIndexName = path+m_ADIresult.m_indexName+".indx";
	ifstream fin(fullIndexName.c_str(),ios::in|ios::binary);
	if(!fin.is_open())
	{
		fin.close();
		throw ErrorPos(ID_ERROR_NOEXSITINDEX,line);
	}
	fin.close();
	
	CFile::Remove(fullIndexName.c_str());

	return string("*****索引被成功删除!******");
}


string ExInsertValues::ExecuteSQL(int line)
{
	string path="data\\";
	string fullCataName=path+m_AIVresult.m_tableName+".cata";

	CatalogHead headtmp;
	CatalogFile filetmp;

	ifstream ffin;
	ffin.open(fullCataName.c_str(),ios::in|ios::binary);
	if(!ffin.is_open())
	{
		ffin.close();
		throw ErrorPos(ID_ERROR_NOEXISTTABLE,line);				//待插入的表不存在
	}
	
	ffin.read((char *)&headtmp, sizeof CatalogHead);
	if(m_AIVresult.m_values.size() != headtmp.number)
	{
		ffin.close();
		throw ErrorPos(ID_ERROR_NOMATCH,line);					//属性数目不匹配
	}
	
	for(int j=0; j<headtmp.number; j++)
	{
		ffin.read((char *)&filetmp,sizeof CatalogFile);
		if(filetmp.typeFlag == 0 && m_AIVresult.m_values[j][0] != '\'')
		{
			//AfxMessageBox(m_AIVresult.m_values[j].c_str()); 
			
			throw ErrorPos(ID_ERROR_NOMATCH,line);				//属性不匹配
		}
		else if(filetmp.typeFlag == 0 && m_AIVresult.m_values[j][0]=='\'')
		{
			if(m_AIVresult.m_values[j].size() >= filetmp.size)
				throw ErrorPos(ID_ERROR_INSERTOVERSIZE,line);    //插入项超过最大字符数	
		}
		else if(filetmp.typeFlag == 1)
		{
			for(int i=0; i<m_AIVresult.m_values[j].size(); i++)
				if(!isdigit(m_AIVresult.m_values[j][i])&&m_AIVresult.m_values[j][i]!='-')
					throw ErrorPos(ID_ERROR_NOMATCH,line);		//插入项含有非法字符
		}
		else
		{
			for(int i=0; i<m_AIVresult.m_values[j].size(); i++)
				if(!isdigit(m_AIVresult.m_values[j][i]) && m_AIVresult.m_values[j][i]!='.'&&m_AIVresult.m_values[j][i]!='-')
					throw ErrorPos(ID_ERROR_NOMATCH,line);		//插入项含有非法字符
		}
	}
	ffin.close();
	
	RecordManager recd(m_AIVresult.m_tableName);
	int recordID=recd.GetFirstBlank();
	
	if(recordID == -1)
	{
		recordID = recd.GetRecordAmount();
		recd.WriteRecord(recordID,m_AIVresult.m_values,line);
	}
	else
	{ 
		recd.WriteRecord(recordID,m_AIVresult.m_values,line);
	}

	
	return string("*****成功插入 1 条记录!*****");
}





string ExDeleteValues::ExecuteSQL(int line)
{
	string myString("");
	fstream cataIn;
	CatalogFile cataFile;
	bool nameFlag=false;						//属性名是否相等的标志
	int attrAmount;						//属性个数	
	int i,j,k;							//循环计数变量
	int no;

	int itemp=0;
	float ftemp=0.0;
	

	vector <string> attrName;			//属性名容器
	vector <char> attrType;				//属性类型
	vector <char> attrPrim;				//属性的unique属性
	vector <int> attrSize;				//属性大小

	set <int> bpresult;
	set <int> result;			//结果集合
    set <int> :: const_iterator iter;

	string cataPath("data\\");
	cataPath+=m_ADTresult.m_tableName;
	cataPath+=".cata";
	cataIn.open((cataPath).c_str(), ios::in | ios::binary); //打开日志文件
	
	if(!cataIn.is_open())
	{
		throw ErrorPos(ID_ERROR_NOEXISTTABLE,line);
	}
	
	cataIn.seekg(16,ios::beg);
	cataIn.read((char *)&attrAmount,sizeof(int));	//获取记录属性个数
													//读指针定位到第一条记录（跳过头信息）



	for(i=0; i<attrAmount; i++)						//读出各属性值到响应容器
													
	{
         cataIn.read((char*)&cataFile, sizeof(cataFile));
			 attrName.push_back(cataFile.attrName);
		 attrPrim.push_back(cataFile.primaryFlag );
		 attrType.push_back(cataFile.typeFlag);
		 attrSize.push_back(cataFile.size);
	}

	

	RecordManager record(m_ADTresult.m_tableName); 

	
	RecordHead validHead;

	int max=record.GetRecordAmount()  ;
	bool max0=true;							  //是否0条记录
	int ident=0;

	vector<int> recordNum;
	
	for(j=0,i=0;i<max;i++)
	{		
		validHead=record.GetRecordHead(i);
		if(validHead.m_valid)
		{
			max0=false;
			recordNum.push_back(i);
            result.insert(i);
			
			for(;record.GetRecordHead(i).m_nextRecordID !=-1;)
			{
				result.insert(record.GetRecordHead(i).m_nextRecordID);
				recordNum.push_back (record.GetRecordHead(i).m_nextRecordID);

				i=record.GetRecordHead(i).m_nextRecordID;
				j++;
			}
			max=j+1;
			  break;
			
		}

	}


	if(max0)
		return "*****共有 0 条记录被成功删除!*****";


	
		for(i=0; i<m_ADTresult.m_attr.size(); i++)			//where中判断条件个数循环
		{
			
			for(j=0; j<attrName.size(); j++)			//属性个数循环
			{
				if(m_ADTresult.m_attr[i]==attrName[j])
				{
					nameFlag=true;
					if(attrPrim[j]==1)                  //属性主码，连b+树
					{
						string op =	m_ADTresult.m_opcode[i];
												
						switch(attrType[j])
						{ 
						case 0:
							{
							Node <char*> treeNode;
							treeNode.Buildtree(attrName[j],'d');
							char *str=const_cast<char *>(m_ADTresult.m_attrvalue[i].c_str());
								
									
								if(op=="=")
								{
									no=treeNode.Eqsearch(str)[0];
									if(no!=-1)
									{
									bpresult.insert(no);
									recordNum[ident++]=no;
									}