db_main.c

数据库C语言开发工具包,可以方便地移植到嵌入式系统中

#ifdef IDX
                case DB_INDEX:
                        db_find_first_idx(df, user_data, key, key_size);
                        break;
#endif

#ifdef RAN
                case DB_RANDOM:
                        db_find_ran(df, user_data, key);
                        break;
#endif

                default:
                        db_error = DB_INVALID_REQUEST;
                        break;
        }

        if (db_error)
        {       buf->buf_cur_blk = 0;
                buf->buf_rec_inx = 0;
        }

        df->df_prev_blk = buf->buf_cur_blk;
        df->df_prev_rec = buf->buf_rec_inx;

	return;
}

/*
 *      db_update  -  Update a record from a data set
 */

void db_update(df, user_data)
 DATA_FILE df;
 char *user_data;
{
        FILE_HDR  fh;
        BUFFER   buf;

        db_error = 0;

        db_check_df(df);
        if (db_error) return;

        fh  = (FILE_HDR) df->df_fhdr->buf_data;
        buf = (BUFFER) df->df_buf;

        if (!buf->buf_cur_blk)
        {       db_error = DB_NO_CURRENT_REC;
                return;
        }

        switch (fh->fh_file_type)
        {       
#ifdef SEQ
		case DB_SEQ:
                        db_update_seq(df, user_data);
                        break;
#endif

#ifdef RAN
                case DB_RANDOM:
                        db_update_ran(df, user_data);
                        break;
#endif

#ifdef IDX
                case DB_INDEX:
                        db_update_idx(df, user_data);
                        break;
#endif

#ifdef VAR
                case DB_VAR:
                        db_update_var(df, user_data);
                        break;
#endif

                default:
                        db_error = DB_INVALID_REQUEST;
                        break;
        }

        buf->buf_cur_blk = 0;
        buf->buf_rec_inx = 0;

	return;
}

/*
 *      db_delete  -  Delete a record from a data set
 */

void db_delete(df)
 DATA_FILE df;
{
        FILE_HDR  fh;
        BUFFER   buf;

        db_error = 0;

        db_check_df(df);
        if (db_error) return;

        fh  = (FILE_HDR) df->df_fhdr->buf_data;
        buf = (BUFFER) df->df_buf;

        if (!buf->buf_cur_blk)
        {       db_error = DB_NO_CURRENT_REC;
                return;
        }

        switch (fh->fh_file_type)
        {       
#ifdef SEQ
		case DB_SEQ:
                        db_free_rec(df, buf);
                        if (db_error) return;

                        if (fh->fh_rec_cnt > 0) fh->fh_rec_cnt--;
                        db_put_blk(df, df->df_fhdr);
                        break;
#endif

#ifdef IDX
                case DB_INDEX:
                        db_delete_idx(df);
                        break;
#endif

#ifdef RAN
                case DB_RANDOM:
                        db_delete_ran(df);
                        break;
#endif

#ifdef VAR
		case DB_VAR:
			db_delete_var(df);
			break;
#endif

                default:
                        db_error = DB_INVALID_REQUEST;
                        break;
        }

        buf->buf_cur_blk = 0;
        buf->buf_rec_inx = 0;

	return;
}

/*
 *      db_get_rec_no  -  Get relative record number
 */

ulong db_get_rec_no(df)
 DATA_FILE df;
{
        FILE_HDR  fh;
        BUFFER   buf;

        db_error = 0;

        db_check_df(df);
        if (db_error) return(0);

        fh  = (FILE_HDR) df->df_fhdr->buf_data;
        buf = df->df_buf;

        if (!buf->buf_cur_blk)
        {       db_error = DB_NO_CURRENT_REC;
                return(0);
        }
 
	if (fh->fh_file_type == DB_VAR)
		return(buf->buf_cur_blk + buf->buf_rec_inx);
	else
	        return((long)(buf->buf_cur_blk - 1) * fh->fh_recs_per_blk
                                                    + buf->buf_rec_inx);
}

/*
 *      db_read_direct  -  Read a record by number
 */                                               

void db_read_direct(df, rec_no, user_data, data_size)
 DATA_FILE     df;
 ulong    rec_no;
 char  *user_data;
 int   *data_size;
{
        FILE_HDR    fh;
        BUFFER      buf;
        INDEX_HDR   ihdr;
        RANDOM_HDR  rhdr;
        RANDOM_REC  rrec;
        SEQ_REC     seq;
	VAR_REC     vrec;
        ulong       blk;
        ushort      rec;
        char       *rbuf;

        db_error = 0;
                                       
        db_check_df(df);
	if (db_error) return;

        fh  = (FILE_HDR) df->df_fhdr->buf_data;
        buf = df->df_buf;

        buf->buf_cur_blk = 0;
        buf->buf_rec_inx = 0;

	if (fh->fh_file_type == DB_VAR)
	{	rec = 0;
		blk = rec_no;
	}
	else
        {	blk = rec_no / fh->fh_recs_per_blk;
	        rec = rec_no % fh->fh_recs_per_blk;

       		if (rec == 0)
                	rec = fh->fh_recs_per_blk;
	        else
       		        blk++;
	}

        db_get_blk(df, blk, buf);
	if (db_error) return;

        switch (fh->fh_file_type)
        {       
#ifdef SEQ
		case DB_SEQ:
                        rbuf = buf->buf_data + (rec-1) * fh->fh_rec_size;
                        seq  = (SEQ_REC) rbuf;
                        
                        if (seq->seq_stat != DB_INUSE)
                        {       db_error = DB_DELETED_REC;
				return;
                        }
                        break;
#endif

#ifdef IDX
                case DB_INDEX:
                        ihdr = (INDEX_HDR) buf->buf_data;
                        
                        if (ihdr->idx_stat != DB_INUSE)
                        {       db_error = DB_DELETED_REC;
				return;
                        }

                        if (rec > ihdr->idx_rec_cnt)
                        {       db_error = DB_DELETED_REC;
				return;
                        }

                        rbuf = buf->buf_data + sizeof(struct db_index_hdr)
                                                + (rec - 1) * fh->fh_rec_size;
                        break;
#endif

#ifdef RAN
                case DB_RANDOM:
                        rhdr = (RANDOM_HDR) buf->buf_data;
                        
                        if (rhdr->ran_stat != DB_INUSE)
                        {       db_error = DB_DELETED_REC;
				return;
                        }

                        if (rec > rhdr->ran_rec_cnt)
                        {       db_error = DB_DELETED_REC;
				return;
                        }

                        rbuf = buf->buf_data + sizeof(struct db_random_uhdr)
                                                + (rec - 1) * fh->fh_rec_size;

                        rrec = (RANDOM_REC) rbuf;
                        if (rrec->ran_stat != DB_INUSE)
                        {       db_error = DB_DELETED_REC;
				return;
                        }
                        break;
#endif

#ifdef VAR
		case DB_VAR:
			db_var_chk_csum(buf);
			if (db_error) return;

			vrec = (VAR_REC)(buf->buf_data + buf->buf_rec_inx);

			if (vrec->var_stat != DB_INUSE)
                        {       db_error = DB_DELETED_REC;
				return;
                        }
			*data_size = vrec->var_dsize;
			buf->buf_cur_size = vrec->var_dsize
				          + sizeof(struct db_var_rec);
			break;
#endif

                default:
                        db_error = DB_INVALID_REQUEST;
			return;
        }
	if (fh->fh_file_type == DB_VAR)
		memcpy(user_data, vrec->var_data, vrec->var_dsize);
	else
	        memcpy(user_data, rbuf + fh->fh_ctl_size, fh->fh_data_size);

        df->df_prev_blk   = buf->buf_cur_blk = blk;
        df->df_prev_rec   = buf->buf_rec_inx = rec;
	df->df_prev_vsize = buf->buf_cur_size;

	return;
}

/*
 *      db_reorg  -  Reorganize a File
 */

void db_reorg(df)
 DATA_FILE df;
{
        FILE_HDR  fh;
        BUFFER   buf;

        db_error = 0;

        db_check_df(df);
        if (db_error) return;

        fh  = (FILE_HDR) df->df_fhdr->buf_data;
        buf = (BUFFER) df->df_buf;

        switch (fh->fh_file_type)
        {
#ifdef VAR
	 	case DB_VAR:
			db_reorg_var(df);
			break;
#endif

                default:
                        db_error = DB_INVALID_REQUEST;
                        break;
        }

        buf->buf_cur_blk = 0;
        buf->buf_rec_inx = 0;

	return;
}

/*
 *      db_read_atr  - Read Data File Attribute Block
 */

void db_read_atr(df, user_data)
 DATA_FILE df;
 char  *user_data;
{        
        FILE_HDR fh;
	char    *atr_data;


        db_error = 0;

        db_check_df(df);
        if (db_error) return;

        fh = (FILE_HDR) df->df_fhdr->buf_data;

	atr_data = ((char *)fh) + DB_ATR_OFFSET;
        memcpy(user_data, atr_data, fh->fh_atr_size);

	return;
}

/*
 *      db_update_atr  - Update Data File Attribute Block
 */

void db_update_atr(df, user_data)
 DATA_FILE df;
 char  *user_data;
{
        FILE_HDR fh;
	char    *atr_data;

        db_error = 0;

        db_check_df(df);
        if (db_error) return;

        fh = (FILE_HDR) df->df_fhdr->buf_data;

	atr_data = ((char *)fh) + DB_ATR_OFFSET;
        memcpy(atr_data, user_data, fh->fh_atr_size);

        db_put_blk(df, df->df_fhdr);

	return;
}

/*
 *      db_check_df  -  Common checks on Data File Validity
 */                                                       

void db_check_df(df)
 DATA_FILE df;
{
        FILE_HDR fh;

        db_error = 0;

        if (!df)
        {       db_error = DB_FILE_NOT_OPEN;
                return;
        }

        if (!df->df_stat & DB_OPEN)
        {       db_error = DB_FILE_NOT_OPEN;
                return;
        }

        if (!df->df_fhdr || !df->df_buf)
        {       db_error = DB_BUFFER_ERROR;
                return;
        }

        fh = (FILE_HDR) df->df_fhdr->buf_data;

        if (fh->fh_file_type == DB_INDEX)
                if (!df->df_tmp || !df->df_aux)
                {       db_error = DB_BUFFER_ERROR;
                        return;
                }
}

/*
 *      db_extend  -  Extend a data set by 1 Block
 */

void db_extend(df, buf)
 DATA_FILE df;
 BUFFER   buf;
{
        FILE_HDR  fhdr;
        long       rec;
        char        *c;
        FREE_REC   fre;
        RANDOM_HDR ran;
        SEQ_REC    seq;
        int        cnt;


        fhdr                = (FILE_HDR) df->df_fhdr->buf_data;
        buf                 = df->df_buf;
        fhdr->fh_last_block = fhdr->fh_last_block + 1;
        buf->buf_cur_blk    = fhdr->fh_last_block;
        buf->buf_cur_size   = fhdr->fh_block_size;

        memset(buf->buf_data, 0, buf->buf_cur_size);

        switch(fhdr->fh_file_type)
        {       
#ifdef SEQ
		case DB_SEQ:     
                        rec = buf->buf_cur_blk * fhdr->fh_recs_per_blk;
                        c   = buf->buf_data + (fhdr->fh_recs_per_blk - 1)
                                                        * fhdr->fh_rec_size;

                        for (cnt=0; cnt < fhdr->fh_recs_per_blk; cnt++)
                        {       fre                 = (FREE_REC) c;
                                fre->fre_stat       = DB_FREE;
                                fre->fre_next       = fhdr->fh_next_avail;
                                fhdr->fh_next_avail = rec--;