check.c

一个c语言开发的小型的dbms系统

			break;
			}
		case	'<':
		case	'>':
		case	'=':
			{				/*说明已经到了叶节点，该显示了*/
			error_var=one_select_con_check(dic,ss->st,stack[p]);/*看这个子条件是否正确*/
			if (strcmp(error_var,"")!=0)
			{	
				return(error_var);
			}
			p--;
			if (p>=0)		st_int[p]++;
			break;
			}
		}
	}while(p!=-1);
	return("");
}

char *one_delete_con_check(_dic_type *dic,char *table,_conditions_type *cons)
{						/*检查一个条件比较式的正确性*/
	char 		left_type,right_type;
	_conditions_type 	*left,*right;
	char 		*error_var;
	_selectedtables_type	*st;	/*虚拟建立一个被选择的表的链，其实只有一个表，是为了函数传参数*/
	
	st=(_selectedtables_type *)malloc(sizeof(_selectedtables_type));
	st->table=table;
	st->next_st=NULL;

	left=cons->left;
	right=cons->right;
						/*先判断左半边是否是正确的字段*/
	error_var=is_a_right_col_used(left->value,left->table,st,dic);
	if (strcmp(error_var,"")!=0)
	{	return(error_var);
	}
	left_type=get_type_of_col(dic,left->table,left->value);	/*获得字段的类型*/

	if (right->type=='2')			/*表示右节点也是字段*/
	{					/*判断右半边是否是正确的字段*/
		error_var=is_a_right_col_used(right->value,right->table,st,dic);
		////////////////////////////////////free st?
		if (strcmp(error_var,"")!=0)
		{	return(error_var);
		}
		right_type=get_type_of_col(dic,right->table,right->value);	/*获得字段的类型*/
	}
	else
	{	right_type=right->type;		/*如果不是字段，也要获得字段的类型*/
	}

	if (left_type!=right_type) 		/*左右两边的类型不匹配*/
	{	return(ERROR0006);
	}
	
	if ((cons->comp_op=='>' || cons->comp_op=='<') && right_type=='1')	/*企图用<,>来判断字符串*/
	{	return(ERROR0007);
	}
    free(st);
	/////////////////////////////////free st??????????
	return("");
}

char *delete_cons_check(_dic_type *dic,_deletestruct_type *ds)
{						/*delete语句中where子句的检查*/
	_conditions_type *stack[20];		/*堆栈，存放中间节点*/
	int	st_int[20];		/*辅助堆栈，用来标识对应stack堆栈中节点的左右节点的入栈情况*/
	int	p=0;
	char	*error_var;
	stack[p]=ds->cons;
	st_int[p]=0;
	do
	{
		switch (stack[p]->comp_op)
		{case	'a':
		case	'o':
			{
			switch  (st_int[p])
			{case 0 : /*表示没有子节点入栈了*/
				{p++;
				stack[p]=stack[p-1]->left;
				st_int[p]=0;
				break;
				}
			case 1 :  /*表示左节点入栈了*/
				{p++;		
				stack[p]=stack[p-1]->right;
				st_int[p]=0;
				break;
				}
			case 2 :  /*表示右节点入栈了*/
				{		
				p--;
				if (p>=0) st_int[p]++;
				break;
				}
			}
			break;
			}
		case	'<':
		case	'>':
		case	'=':
			{				/*说明已经到了叶节点，该显示了*/
			error_var=one_delete_con_check(dic,ds->table,stack[p]);/*看这个子条件是否正确*/
			if (strcmp(error_var,"")!=0)
			{	
				return(error_var);
			}
			p--;
			if (p>=0)		st_int[p]++;
			break;
			}
		}
	}while(p!=-1);
	return("");
}



char *select_errorcheck(_dic_type *dic, _selectstruct_type *ss)
{					/*初步检查select语句的语义正确性，与数据字典有关的部分*/
	_selectedfields_type *sf1;
	_selectedtables_type *st1;
	char 	*error_var="";

	st1=ss->st;
	do			/*判断选择的表名是否是数据字典中已经有的*/
	{
		error_var=is_an_exist_table(dic->tab,dic->tab_num,st1->table);
		if (strcmp(error_var,"")!=0) 
		{	return(error_var); 
		}
		if(st1->next_st==NULL) 	break;
		st1=st1->next_st;
	}while(1);

	sf1=ss->sf;
	if (strcmp(sf1->field,"*")!=0)
	{do
	{		
		st1=ss->st;
		error_var=is_a_right_col_used(sf1->field,sf1->table,st1,dic);
		if (strcmp(error_var,"")!=0)	
		{	return(error_var);
		}
		if (sf1->next_sf==NULL) break;
		sf1=sf1->next_sf;
	}while(1);
	}/*endif*/
	
	if (ss->cons!=NULL)
	{	error_var=select_cons_check(dic,ss);
		if (strcmp(error_var,"")!=0)
		{	return(error_var);
		}
	}
	return("");
}

char *delete_errorcheck(_dic_type *dic,_deletestruct_type *ds)
{					/*初步检查delete语句的语义正确性，与数据字典有关的部分*/
	char *error_var;
	error_var=is_an_exist_table(dic->tab,dic->tab_num,ds->table);
	if (strcmp(error_var,"")!=0)
	{	return(error_var);
	}

	if (ds->cons!=NULL)
	{	error_var=delete_cons_check(dic,ds);
		if (strcmp(error_var,"")!=0)
		{	return(error_var);
		}
	}
	return("");
}

char *create_fields_check(_createfieldsdef_type *fdef)
{					/*检查一个字段后面是否有和它同名的字段被创建*/
	_createfieldsdef_type	*fdef1;
	fdef1=fdef->next_fdef;

	if (strlen(fdef->field)>30)	/*字段名称太长*/
	{	return(ERROR0011);
	}


	while(fdef1!=NULL)
	{
		if (strcmp(fdef->field,fdef1->field)==0)
		{	return(ERROR0010);
		}
		fdef1=fdef1->next_fdef;
	}

	return("");
}

char *create_errorcheck(_dic_type *dic,_createstruct_type *cs)
{						/*初步检查create语句的语义正确性，与数据字典有关的部分*/
	char *error_var;
	_createfieldsdef_type	*fdef1;
	fdef1=cs->fdef;

	error_var=is_an_exist_table(dic->tab,dic->tab_num,cs->table);
	if (strcmp(error_var,"")==0)	/*如果已经有了这个表名，出错*/
	{	return(ERROR0008);
	}
	if (strlen(cs->table)>100)		/*表名称太长*/
	{	return(ERROR0009);
	}
	
	do
	{
		error_var=create_fields_check(fdef1);	/*检查后面有没有同名字段*/
		if (strcmp(error_var,"")!=0)
		{	return(error_var);
		}
		fdef1=fdef1->next_fdef;
	}while(fdef1!=NULL);
	return("");
}	


char *drop_errorcheck(_dic_type *dic,_dropstruct_type *drs)
{				/*初步检查drop语句的语义正确性，与数据字典有关的部分*/
	char *error_var;
	error_var=is_an_exist_table(dic->tab,dic->tab_num,drs->table);
	if (strcmp(error_var,"")!=0)
	{	return(error_var);
	}
	return("");
}



/*-------------------------------------------------------------insert-----not completed---*/	

void	add_insert_fields(_dic_type *dic,_insertstruct_type *is)
{					/*如果没有列出字段名，就给加进去*/
	_insertfields_type		*ifs1,*ifs_var;
	int	tab_id;
	int	i;
	
	ifs1=is->ifs;	/*利用这个指针，将属于给出表的所有字段一个个连下去*/

	tab_id=get_tab_id(dic->tab,dic->tab_num,is->table);
	for (i=0;i<dic->col_num;i++)
	{
		if (tab_id==dic->col[i].tab_id) 	/*如果这字段属于给出表*/
		{		
			ifs_var=(_insertfields_type *)malloc(sizeof(_insertfields_type));
			ifs_var->field=(char *)malloc(sizeof(strlen(dic->col[i].col_name)+1));
			strcpy(ifs_var->field,dic->col[i].col_name);
			ifs_var->next_if=NULL;
			ifs1->next_if=ifs_var;
			ifs1=ifs1->next_if;
		}
	}
	is->ifs=is->ifs->next_if;
//	free(ifs_var->field);
//	free(ifs_var);
	////////////////////////////////////////// free ?

}


char *insert_errorcheck(_dic_type *dic,_insertstruct_type *is)
{									/*初步检查insert语句的语义正确性，与数据字典有关的部分*/
	char	*error_var;
	_insertfields_type		*ifs1;
	_insertvalues_type		*iv1;
	_col_dic_type 		*col_info;

	ifs1=is->ifs;

	error_var=is_an_exist_table(dic->tab,dic->tab_num,is->table);
	if (strcmp(error_var,"")!=0)	/*如果没有这个表，出错*/
	{	return(ERROR0001);
	}

	if (strcmp(ifs1->field,"")==0)			/*如果没有列出字段名，就先给加进去*/
	{	add_insert_fields(dic,is);
	    ///////////////////////////free is ?????????????
	}

	ifs1=is->ifs;
	iv1=is->iv;

	do 
	{	
		col_info=get_info_of_a_col(dic,is->table,ifs1->field);
		if (col_info==NULL)			/*无返回值表示表中没有这列*/
		{	return(ERROR0003);
		}
		
//		printf("%c,%d\n",iv1->type,col_info->col_type ); 
		if (col_info->col_type==3 )
		{
			if(is_date(iv1->value) && (iv1->type =='1'))
				iv1->type='3';
			else
				return(ERROR0016);			/*插入日期非法*/
		}
		if (iv1->type!=(col_info->col_type+'0'))
		{	return(ERROR0012);			/*字段和插入值类型不匹配*/
		}

		if (iv1->type=='1' && strlen(iv1->value)>(unsigned int)col_info->col_length)
		{	
	printf("iv1->value=%s,col_info->col_length=%d\n",iv1->value,col_info->col_length );
			return(ERROR0013);			/*插入字符串长度超界*/
		}

		if (iv1->type=='0' && atoi(iv1->value)>32767)
		{	return(ERROR0014);			/*插入数字过大*/
		}

//		if (iv1->type=='3' && is_date(iv1->value))
//		{	return(ERROR0016);			/*插入日期非法*/
//		}		
			
		ifs1=ifs1->next_if;
		iv1=iv1->next_iv;
		if (ifs1==NULL) break;
		if (iv1==NULL) break;
	}while(1);		/*无论是字段结束还是值结束都结束循环*/

	if ((ifs1==NULL && iv1!=NULL) ||(ifs1!=NULL && iv1==NULL))
	{	return(ERROR0015);			/*字段数和插入值数目不等*/
	}	
	return("");

}


void read_dic(struct tab_dic_type *tab,int *tab_num,struct col_dic_type *col,int *col_num)
{							/*读入数据字典*/
	FILE *fp_tab,*fp_col;
	int i=0;
	fp_tab=fopen("TABLE","rb");
	fp_col=fopen("COLUMN","rb");
	fread(&tab[i],sizeof(struct tab_dic_type),1,fp_tab);
	while (!feof(fp_tab))
	{	fread(&tab[i],sizeof(struct tab_dic_type),1,fp_tab);
//		if(tab[i].tab_name[0]='*')
//			continue;
		i=i+1;
	}
	*tab_num=i-1;
	i=0;
	while (!feof(fp_col))
	{	fread(&col[i],sizeof(struct col_dic_type),1,fp_col);
		i=i+1;
 	}
 	*col_num=i-1;
	fclose(fp_tab);
	fclose(fp_col);
}

	
void selectpro(_selectstruct_type *ss,_dic_type *dic)
{
	select(ss);
}

void createpro(_createstruct_type *cs,_dic_type *dic)	/*用来检测create语句的语法树是否正确*/
{
	create(cs);/*建表*/
}

void droppro(_dropstruct_type *drs,_dic_type *dic)	/*用来检测drop语句的语法树是否正确*/
{
	drop(drs);/*删表*/
}

void insertpro(_insertstruct_type *is,_dic_type *dic)	/*用来检测insert语句的语法树是否正确*/
{
 //	mean_par(is,dic->tab,dic->tab_num,dic->col,dic->col_num);
	struct tab_dic_type tab[30];
    struct col_dic_type col[300];
    int i,j;
	read_dic(tab,&i,col,&j);
	mean_par(is,tab,i,col,j);
}
void deletepro(_deletestruct_type *ds,_dic_type *dic)	/*用来检测delete语句的语法树是否正确*/
{	del(ds);
}

int is_date(char *date)
{
	int i,len,year,month,day;
    char buf[8];
	
	if (strlen(date)!=8)
		return(0);
	for(i=0;i<8;i++)
		if (*(date+i)<'0' || *(date+i)>'9')
			return(0);
	
	strncpy(buf,date,4);
	
	buf[4]='\0';
	year=atoi(buf);
	

	strncpy(buf,date+4,2);
	buf[2]='\0';
	month=atoi(buf);
	if(month<1||month>12)
		return(0);
	strncpy(buf,date+6,2);
	buf[2]='\0';
	day=atoi(buf);
//	printf("%d\n",year);
//	printf("%d\n",month);
//	printf("%d\n",day);
	switch (month)
	{
	case 1:
	case 3:
	case 5:
	case 7:
	case 8:
	case 10:
	case 12:
		if(day>31 ||day ==0 )
			return(0);
		break;
	case 4:
	case 6:
	case 9:
	case 11:
		if(day>30)
			return(0);
		break;
	case 2:
		if ((year%4!=0) ||(year%100==0 && year%400!=0))
		{
			if (day>28||day ==0)
				return(0);
		}
		else
		{
			if(day>29)
				return(0);
		}
		break;
	}
}