database.c

一个微型的数据库系统

	if( curRecord<=0 )					// 不存在当前记录
	{
		gDatabase[databaseID].error=_REC_NO_ERROR;
		return _REC_NO_ERROR;
	}

	dbEnterWCS();
	result=_db_recSet(databaseID,curRecord-1,_DB_SET);
	dbExitWCS();
	if( result!=_DB_CORRECT)
	{
		gDatabase[databaseID].curRecord=curRecord;	// 恢复当前记录信息
		gDatabase[databaseID].curPosition=curPosition;
		gDatabase[databaseID].error=result;
		return result;
	}

	gDatabase[databaseID].error=_DB_CORRECT;
	return _DB_CORRECT;
}

// 读取当前记录内容,OK
int db_recRead(int databaseID,void *buffer)
{
	int result;

	if( (unsigned int)databaseID>=_DB_DBD_MAX )
        return _DB_ID_ERROR;					// ID号错误

	if( gDatabase[databaseID].hFile<0 )
        return _DB_ID_ERROR;					// ID号错误
	
	if( gDatabase[databaseID].curRecord<0 )		// 不存在当前记录
	{
		gDatabase[databaseID].error=_REC_NO_ERROR;
		return _REC_NO_ERROR;
	}

	dbEnterWCS();
	result=_db_recRead(databaseID);
	dbExitWCS();
	if( result!=_DB_CORRECT)
	{
		gDatabase[databaseID].error=result;
		return result;
	}

	result=_db_decodeRecord(databaseID,buffer);		// 解码当前记录
	if( result!=_DB_CORRECT )
	{
		gDatabase[databaseID].error=result;
		return result;
	}

	gDatabase[databaseID].error=_DB_CORRECT;		// 操作成功
	return _DB_CORRECT;
}

// 写入当前记录内容,OK
int db_recWrite(int databaseID,void *buffer)
{
	int result;

	if( (unsigned int)databaseID>=_DB_DBD_MAX )
        return _DB_ID_ERROR;						// ID号错误

	if( gDatabase[databaseID].hFile<0 )
        return _DB_ID_ERROR;						// ID号错误
	
	if( gDatabase[databaseID].curRecord<0 )			// 不存在当前记录
	{
		gDatabase[databaseID].error=_REC_NO_ERROR;
		return _REC_NO_ERROR;
	}

	dbEnterWCS();
	result=_db_encodeRecord(databaseID,buffer);		// 编码当前记录
	dbExitWCS();
	if( result!=_DB_CORRECT )
	{
		gDatabase[databaseID].error=result;
		return result;
	}

	result=_db_recWrite(databaseID);				// 保存当前记录
	if( result!=_DB_CORRECT)
	{
		gDatabase[databaseID].error=result;
		return result;
	}

	gDatabase[databaseID].error=_DB_CORRECT;		// 操作成功
	return _DB_CORRECT;
}

// 删除当前记录,OK
int db_recDelete(int databaseID)
{
	int result;
	
	if( (unsigned int)databaseID>=_DB_DBD_MAX )
        return _DB_ID_ERROR;						// ID号错误

	if( gDatabase[databaseID].hFile<0 )
        return _DB_ID_ERROR;						// ID号错误
	
	// 写删除标记
	result=_db_recDelete(databaseID);
	if( result!=_DB_CORRECT )						// 写入删除标记
	{
		gDatabase[databaseID].error=_FS_ERROR;
		return _FS_ERROR;
	}

	gDatabase[databaseID].curRecord=-1;				// 失去当前记录
	gDatabase[databaseID].curPosition=-1;
	gDatabase[databaseID].recordNum--;

	gDatabase[databaseID].error=_DB_CORRECT;		// 操作成功
	return _DB_CORRECT;
}

// 将第n条记录设置为当前记录,OK
int db_recSet(int databaseID,int nth,int type)
{
	int curRecord,curPosition;
	int result;

	if( (unsigned int)databaseID>=_DB_DBD_MAX )
        return _DB_ID_ERROR;			// ID号错误

	if( gDatabase[databaseID].hFile<0 )
        return _DB_ID_ERROR;			// ID号错误
	
	curRecord=gDatabase[databaseID].curRecord;		// 保存当前记录信息
	curPosition=gDatabase[databaseID].curPosition;
	
	dbEnterWCS();
	result=_db_recSet(databaseID,nth,type);			// 将第n条记录设置为当前记录
	dbExitWCS();
	if( result!=_DB_CORRECT )
	{
		gDatabase[databaseID].curRecord=curRecord;	// 恢复当前记录信息
		gDatabase[databaseID].curPosition=curPosition;
		gDatabase[databaseID].error=result;
		return result;
	}

	gDatabase[databaseID].error=_DB_CORRECT;		// 操作成功
	return _DB_CORRECT;
}

// 获取当前记录的记录号,OK
int db_recGet(int databaseID,int *n)
{
	int result;

	if( (unsigned int)databaseID>=_DB_DBD_MAX )
        return _DB_ID_ERROR;			// ID号错误

	if( gDatabase[databaseID].hFile<0 )
        return _DB_ID_ERROR;			// ID号错误

	if( gDatabase[databaseID].curRecord<0 )
	{
		gDatabase[databaseID].error=_DB_NOT_FOUND;
		return _DB_NOT_FOUND;
	}

	gDatabase[databaseID].error=_DB_CORRECT;
	*n=gDatabase[databaseID].curRecord;
	return _DB_CORRECT;
}


// 根据关键字查找记录
int db_findNthRecordByKey(int databaseID,unsigned long keyID,int nth,void *keyValue, void *buffer)
{
	int j,i,k;
	int n,num,flag,count;
	int hFile;
	unsigned char *pData,*pBuffer,*pSrc,*pRecord;
	int pos,recordSize,recordTotal,len,recordNum;
	int cpPos,cpLen,delPos;
	DB_Field *pField;

	if( (unsigned int)databaseID>=_DB_DBD_MAX )
        return _DB_ID_ERROR;			// ID号错误

	hFile=gDatabase[databaseID].hFile;
	if( hFile<0 )
        return _DB_ID_ERROR;			// ID号错误
	
	if( keyID>=gDatabase[databaseID].fieldNum)
		return _KEY_ID_ERROR;			// 字段ID错误

	pField=gDatabase[databaseID].pField;
	switch(pField[keyID].type)			// 计算待比较的数据长度
	{
	case TY_CHAR:
	case TY_UCHAR:
		if(pField[keyID].size==1)
			cpLen=1;
		else
		{
			cpLen=strlen( (char *)keyValue);
			if(cpLen>=pField[keyID].size)
				cpLen=pField[keyID].size;
			else
				cpLen++;
		}
		break;
	default:
		cpLen=pField[keyID].size;
		break;
	}
	recordSize=gDatabase[databaseID].recordSize;		// 物理记录数
	cpPos=pField[keyID].offset;							// 比较的开始位置
	delPos=recordSize-cpPos-1;

	if( fs_lseek(hFile,gDatabase[databaseID].offset,SEEK_SET)<0 )	// 定位在数据区开始
		return _FS_ERROR;								// 文件错误

	recordTotal=gDatabase[databaseID].recordTotal;		// 物理记录数
	count=0;											// 记录记数
	num=DB_BUFFER_SIZE/recordSize;						// 缓冲区中可暂存的记录数
	pSrc=(unsigned char *)keyValue;
	recordNum=0;
	dbEnterWCS();
	for(i=0;i<recordTotal;)
	{
		n=recordTotal-i;
		if(n>num)										// 缓冲区中实际暂存的记录数
			n=num;

		len=n*recordSize;
		if( fs_read(hFile,gDbBuffer,len)!=len )			// 读出数据到缓冲区
		{
			dbExitWCS();
			return _FS_ERROR;							// 文件错误
		}

		pBuffer=&gDbBuffer[cpPos];
		for(j=0;j<n;j++,i++)
		{
			flag=0;
			for(k=0;k<cpLen;k++)						// 比较数据
			{
				if( pBuffer[k]!=pSrc[k] )
					break;
			}
			if(k==cpLen)
				flag=1;

			//if(flag && pBuffer[delPos]!=DB_REC_DELETE)	// 与关键字相同并且记录有效
			if(flag && pBuffer[delPos]!=DB_REC_DELETE && pBuffer[delPos]!=DB_REC_REMOVE)	// by zhangxp 2003/07/02
			{
				if(count==nth)
				{
					pBuffer-=cpPos;
					pRecord=gDatabase[databaseID].pRecord;
					memcpy( (void *)pRecord,(void *)pBuffer,recordSize);
					_db_decodeRecord(databaseID,buffer);
					gDatabase[databaseID].error=_DB_CORRECT;
					gDatabase[databaseID].curRecord=recordNum;
					gDatabase[databaseID].curPosition=i;
					dbExitWCS();
					return  _DB_CORRECT;
				}
				count++;
			}
			//if(pBuffer[delPos]!=DB_REC_DELETE)
			if(pBuffer[delPos]!=DB_REC_DELETE && pBuffer[delPos]!=DB_REC_REMOVE) // by zhangxp 2003/07/02
				recordNum++;
			pBuffer+=recordSize;
		}
	} 
	gDatabase[databaseID].error=_DB_NOT_FOUND;
	dbExitWCS();
	return  _DB_NOT_FOUND;
}


// by zhangxp  2003/05/26
int db_getHeadSize(char *dbdFileName)
{
    //int hFile,hDatabase,hmem,bexist=0;
	int hFile,hmem, bexist=0;
    //int offset,fileLen,recordTotal,recordNum,recordSize,flag,len;
	DB_Head  tHead;
	DB_Field *pField;                        
	unsigned char *pHead;              
	int size;
	char	strdb[20];

	if( dbdFileName==NULL || dbdFileName[0] == '\0')
        return _DB_NAME_ERROR;							// 文件名错误

	dbEnterWCS();                   

    memset(strdb,0,sizeof(strdb));
	strcpy(strdb,dbdFileName);
	strcat(strdb,".DBD");
	hFile = fs_open((char*)strdb,O_RDWR);				// 打开文件
	if( hFile<0 )
	{
		dbExitWCS();
        return _FS_ERROR;								// 打开文件错误
	}

    if( fs_read(hFile,(char *)&tHead,sizeof(struct tagHead))!=sizeof(struct tagHead) )	// 读出数据库头信息
    {
		fs_close(hFile);
		dbExitWCS();
		return _FS_ERROR;								// 读文件错误
    }

	pHead=(unsigned char*)&tHead;
	if(*pHead==0xBB)//myh
		bexist=1;
	if(bexist)
	{
		strcpy(strdb,dbdFileName);
		strcat(strdb,".MEM");
		hmem=fs_open((char*)strdb,O_RDWR);
		if( hmem<0 )
		{
			dbExitWCS();
			fs_close(hFile);
			return _FS_ERROR;							
		}        
		//fs_truncate(hmem, 0);
		fs_close(hmem);
	}
                                                 

	size = sizeof(struct tagHead)+sizeof(struct tagField)*(tHead.fieldNum);

	size++;   // tail tag 0x71
	//fs_lseek(hFile, 0, 0);
	//fs_truncate(hFile, size);
	fs_close(hFile); 


	dbExitWCS();
 	
	return size;

}

// by zhangxp  2003/05/27
int db_getHeader(char *dbdFileName, unsigned char *buffer)
{
    //int hFile,hDatabase,hmem,bexist=0;
	int hFile;//hmem, bexist=0;
    //int offset,fileLen,recordTotal,recordNum,recordSize,flag,len;
	//DB_Head  tHead;
	DB_Field *pField;                        
	DB_Head *pHead;
	char	strdb[20];
	int headLen, fieldLen, len;

	if( dbdFileName==NULL || dbdFileName[0] == '\0')
        return _DB_NAME_ERROR;							// 文件名错误

	dbEnterWCS();

    memset(strdb,0,sizeof(strdb));
	strcpy(strdb,dbdFileName);
	strcat(strdb,".DBD");
	hFile = fs_open((char*)strdb,O_RDWR);				// 打开文件
	if( hFile<0 )
	{
		dbExitWCS();
        return _FS_ERROR;								// 打开文件错误
	}

	headLen = sizeof(struct tagHead);
    //if( fs_read(hFile,(char *)&tHead, headLen)!=headLen )	// 读出数据库头信息
	if( fs_read(hFile, buffer, headLen)!=headLen )	// 读出数据库头信息
    {
		fs_close(hFile);
		dbExitWCS();
		return _FS_ERROR;								// 读文件错误
    }

	pHead=(DB_Head *)buffer;
	fieldLen = sizeof(struct tagField);

	len=fieldLen*(pHead->fieldNum);
    //if( fs_read(hFile,(unsigned char *)pField,len)!=len )	// 读出数据库字段信息
	if( fs_read(hFile, &buffer[headLen], len)!=len )	// 读出数据库字段信息
    {
		fs_close(hFile);
		dbExitWCS();
		return _FS_ERROR;								// 读文件错误
    }

	fs_close(hFile);
	dbExitWCS();

	//return _DB_CORRECT;	
	return (headLen+len);
}


// by zhangxp  2003/05/27
static char* tempDB_Name = "A:\\TempDBZ";
static char* tempDB_DBD = "A:\\TempDBZ.dbd";
static char* tempDB_MEM = "A:\\TempDBZ.mem";
// 整理数据库，清除置删除标记的记录
int db_pack(char *dbName)
{
	unsigned char *buffer;
	int i, hRet, size, count;
	int hFile, hSrcDB, hDestDB;
	char srcDBName[32], srcMemName[32];
	
	hRet = db_getHeadSize(dbName);
	if(hRet<0)
		return hRet;

	size = hRet;

	buffer = (unsigned char *)ap_malloc(size);

	hRet = db_getHeader(dbName, buffer);	
	if(hRet<0)
	{	
		ap_free(buffer);
		return hRet;
	}

	fs_delete(tempDB_DBD);
	fs_delete(tempDB_MEM);

	hFile = fs_open(tempDB_DBD, O_CREATE);
	if(hFile<0)
	{
		ap_free(buffer);
		return _FS_ERROR;
	}

	fs_write(hFile, buffer, size);
	fs_close(hFile);

	ap_free(buffer);

	hFile = fs_open(tempDB_MEM, O_CREATE);
	fs_close(hFile);


	hSrcDB = db_open(dbName, NULL, NULL);
	if(hSrcDB<0)
		return hSrcDB;

	hRet = db_getRecordNumber(hSrcDB,&count);
	if(hRet<0)
		return hRet;

	hDestDB = db_open(tempDB_Name, NULL, NULL);
	if(hDestDB<0)
	{
		db_close(hSrcDB);
		return hDestDB;
	}

	buffer = (unsigned char *)ap_malloc(6*1024);
	for(i=0; i<count; i++)
	{
		hRet = db_recRead(hSrcDB, buffer);	
		if(hRet != _DB_CORRECT)
		{
			db_close(hSrcDB);
			db_close(hDestDB);
			ap_free(buffer);
			return hRet;
		}

		hRet = db_addRecord(hDestDB, 0, buffer);
		if(hRet != _DB_CORRECT)
		{
			db_close(hSrcDB);
			db_close(hDestDB);
			ap_free(buffer);
			return hRet;
		}

		hRet = db_recNext(hSrcDB);
		if((hRet != _DB_CORRECT) && (i!=count-1))
		{
			db_close(hSrcDB);
			db_close(hDestDB);
			ap_free(buffer);
			return hRet;
		}
	}
	
	db_close(hSrcDB);
	db_close(hDestDB);	
	ap_free(buffer);

	strcpy(srcDBName, dbName);
	strcat(srcDBName, ".dbd");

	strcpy(srcMemName, dbName);
	strcat(srcMemName, ".mem");

	fs_delete(srcDBName);
	fs_delete(srcMemName);

	fs_rename(tempDB_DBD, srcDBName);
	fs_rename(tempDB_MEM, srcMemName);

	return _DB_CORRECT;
}