executor.cpp

our homework big project

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

	myString+=0x0D;
	myString+=0x0A;						//换行

	for(i=0; i<attrAmount; i++)	
		myString+="**\t";


	myString+=0x0D;
	myString+=0x0A;						//换行

	RecordManager record(m_ASTresult.m_tableName); 

	
	RecordHead validHead;                         //定义记录头实例

		int max=record.GetRecordAmount()  ;        //当前有效记录条数
		int ident=0;
		bool max0=true;							  //是否0条记录
		vector<int> recordNum;
		for(j=0,i=0;i<max;i++)
		{
		
			
			validHead=record.GetRecordHead(i);
			if(validHead.m_valid)
			{
				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++;
				}
				max0=false;
				max=j+1;
			    break;
				
			}

		}


		if(max0)
			return myString;



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

								else if(op==">=")
								{
									
									for(k=0;k<treeNode.Besearch(str).size();k++)
									{
									
									bpresult.insert(treeNode.Besearch(str)[k]);
									recordNum[ident++]=treeNode.Besearch(str)[k];
									}
								}

								else if(op=="<=")
								{
									for(k=0;k<treeNode.Sesearch(str).size();k++)
									{
									
									bpresult.insert(treeNode.Sesearch(str)[k]);
									recordNum[ident++]=treeNode.Sesearch(str)[k];
									}
								}

								else if(op=="!=")
								{
									
									for(k=0;k<treeNode.Neqsearch(str).size();k++)
									{
									
									bpresult.insert(treeNode.Neqsearch(str)[k]);
									recordNum[ident++]=treeNode.Neqsearch(str)[k];
									}
								}

								
							
							break;
							}


						case 1:
							{
								Node <int> treeNode;

								treeNode.Buildtree(attrName[j],1);
							
								const char *str=m_ASTresult.m_attrvalue[i].c_str();

								if(op=="=")
								{
									no=treeNode.Eqsearch(atoi(str))[0];
									if(no!=-1)
									{
								
										bpresult.insert(no);
										recordNum[ident++]=no;
									}
								}
								else if(op=="<")
								{
									for(k=0;k<treeNode.Ssearch(atoi(str)).size();k++)
									{
								
										bpresult.insert(treeNode.Ssearch(atoi(str))[k]);
										recordNum[ident++]=treeNode.Ssearch(atoi(str))[k];
									}
								}
								
								else if(op==">")
								{
									for(k=0;k<treeNode.Bsearch(atoi(str)).size();k++)
									{
									
									bpresult.insert(treeNode.Bsearch(atoi(str))[k]);
									recordNum[ident++]=treeNode.Bsearch(atoi(str))[k];
									}
								}

								else if(op==">=")
								{
									for(k=0;k<treeNode.Besearch(atoi(str)).size();k++)
									{
									
									bpresult.insert(treeNode.Besearch(atoi(str))[k]);
									recordNum[ident++]=treeNode.Besearch(atoi(str))[k];
									}
								}

								else if(op=="<=")
								{
									
										for(k=0;k<treeNode.Sesearch(atoi(str)).size();k++)
										{
										
									    bpresult.insert(treeNode.Sesearch(atoi(str))[k]);
										recordNum[ident++]=treeNode.Sesearch(atoi(str))[k];
										}
								}

								else if(op=="!=")
								{
									for(k=0;k<treeNode.Neqsearch(atoi(str)).size();k++)
									{
									
									bpresult.insert(treeNode.Neqsearch(atoi(str))[k]);
									recordNum[ident++]=treeNode.Neqsearch(atoi(str))[k];
									}
								}

							break;
							}

						case 2:
							{
								Node <float> treeNode;

								treeNode.Buildtree(attrName[j],1.0f);
							
								
								const char *str=m_ASTresult.m_attrvalue[i].c_str();

								
								if(op=="=")
								{
									no=treeNode.Eqsearch(atof(str))[0];
									if(no!=-1)
									{
								
										bpresult.insert(no);
										recordNum[ident++]=no;
									}
								}
								else if(op=="<")
								{
									for(k=0;k<treeNode.Ssearch(atof(str)).size();k++)
									{
								
										bpresult.insert(treeNode.Ssearch(atof(str))[k]);
										recordNum[ident++]=treeNode.Ssearch(atof(str))[k];
									}
								}
								
								else if(op==">")
								{
									for(k=0;k<treeNode.Bsearch(atof(str)).size();k++)
									{
									
									bpresult.insert(treeNode.Bsearch(atof(str))[k]);
									recordNum[ident++]=treeNode.Bsearch(atof(str))[k];
									}
								}

								else if(op==">=")
								{
									for(k=0;k<treeNode.Besearch(atof(str)).size();k++)
									{
									
									bpresult.insert(treeNode.Besearch(atof(str))[k]);
									recordNum[ident++]=treeNode.Besearch(atof(str))[k];
									}
								}

								else if(op=="<=")
								{
									
										for(k=0;k<treeNode.Sesearch(atof(str)).size();k++)
										{
										
									    bpresult.insert(treeNode.Sesearch(atof(str))[k]);
										recordNum[ident++]=treeNode.Sesearch(atof(str))[k];
										}
								}

								else if(op=="!=")
								{
									for(k=0;k<treeNode.Neqsearch(atof(str)).size();k++)
									{
									
									bpresult.insert(treeNode.Neqsearch(atof(str))[k]);
									recordNum[ident++]=treeNode.Neqsearch(atof(str))[k];
									}
								}
								
							break;
							}

						}	
						
						set<int> set_tmp;
						set_intersection(result.begin(),result.end(),
										bpresult.begin(),bpresult.end(),
										insert_iterator< set<int> >(set_tmp,set_tmp.begin()));
						result=set_tmp;
						bpresult.clear();
	

					}
					

					else								//属性非主码，文件遍历
					{
					for(k=0; k<max; k++)				//记录条数循环
						{
						switch(attrType[j])
						{
						case 0 :
							{									//字符属性
								char *atemp=new char[attrSize[j]];
								m_record.RecordAtrrIO(*atemp,recordNum[k],j,'i',attrSize[j]);

								if(Compare(string(atemp),
									m_ASTresult.m_attrvalue[i].
									substr(1,m_ASTresult.m_attrvalue[i].size()-2),
									 m_ASTresult.m_opcode[i]))
								{
									recordNum[ident++]=recordNum[k];
								}
								else
								{
									result.erase(recordNum[k]);
								}
								delete []atemp;
								break;
							}
						case 1:										//int属性
							
							m_record.RecordAtrrIO(itemp,recordNum[k],j,'i',4);
							if(Compare(itemp,atoi((m_ASTresult.m_attrvalue[i]).c_str()),
								m_ASTresult.m_opcode[i]))
								{
									recordNum[ident++]=recordNum[k];
								}
								else 
								{
									result.erase(recordNum[k]);
								}
							break;
						case 2:										//float属性
							m_record.RecordAtrrIO(ftemp,recordNum[k],j,'i',4);
							if(Compare(ftemp,atof((m_ASTresult.m_attrvalue[i]).c_str()),
								m_ASTresult.m_opcode[i]))
								{
									recordNum[ident++]=recordNum[k];
								}
								else 
								{
									result.erase(recordNum[k]);
								}
							break;					
							}
						}

					}
				}
			}
			if(!nameFlag)
				throw ErrorPos(ID_ERROR_NOATTREXIST,line);
			nameFlag=false;
			max=ident;
			ident=0;
		}


	iter=result.begin();
	for(;iter!=result.end();)	
	{
		myString+=record.GetRecord(*iter);
		myString+=0x0D;
		myString+=0x0A;						//换行
		iter++;
	}
	return myString;
}


bool Executor::Compare(int num1, int num2, string op)
{
	if(op=="=")
		return num1==num2;
	else if(op=="<")	
		return num1<num2;
    else if(op==">")
        return num1>num2;
    else if(op==">=")
         return num1>=num2;
    else if(op=="<=")
		return num1<=num2;
	else if(op=="!=")
		return num1!=num2;
	else
		return false;
    
}

bool Executor::Compare(float num1, float num2, string op)
{
	if(op=="=")
		return (num1-num2>-0.0001&&num1-num2<0.0001);
	else if(op=="<")
		return (num1-num2<0);
	else if(op==">")
		return (num2-num1<0);
	else if(op=="<=")
		return (num1-num2<=0.0001);
	else if(op==">=")
		return (num2-num1<=0.0001);
	else if(op=="!=")
		return (num1-num2>0.0001||num1-num2<-0.0001);
	else
		return false;
}


bool Executor::Compare(string num1, string num2, string op)
{
	if(op=="=")
		return num1==num2;
	else if(op=="<")	
		return num1<num2;
    else if(op==">")
        return num1>num2;
    else if(op==">=")
         return num1>=num2;
    else if(op=="<=")
		return num1<=num2;
	else if(op=="!=")
		return num1!=num2;
	else
		return false;
}