db_main.c

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

        return(df);
}

/*
 *      db_fhdr_open - Check file header data on open
 */

void db_fhdr_open(fh)
 FILE_HDR fh;
{
        db_error = 0;

	if (fh->fh_db_version == 12)
		fh->fh_db_version = 13;
		/* Upgrade shouldn't change data (we hope) */

        if (fh->fh_db_version != DB_VERSION)
        {       db_error = DB_VERSION_ERROR;
                return;
        }

        if (fh->fh_file_type != DB_SEQ    &&
            fh->fh_file_type != DB_RANDOM &&
            fh->fh_file_type != DB_INDEX  &&
            fh->fh_file_type != DB_VAR)
        {       db_error = DB_INVALID_FHDR;
                return;
        }

#ifndef SEQ
        if (fh->fh_file_type == DB_SEQ)
        {       db_error = DB_UNSUPP_FEATURE;
                return;
        }
#endif

#ifndef RAN
        if (fh->fh_file_type == DB_RANDOM)
        {       db_error = DB_UNSUPP_FEATURE;
                return;
        }
#endif

#ifndef IDX
        if (fh->fh_file_type == DB_INDEX)
        {       db_error = DB_UNSUPP_FEATURE;
                return;
        }
#endif

#ifndef VAR
        if (fh->fh_file_type == DB_VAR)
        {       db_error = DB_UNSUPP_FEATURE;
                return;
        }
#endif

        if (fh->fh_block_size   == 0 ||
            fh->fh_rec_size     == 0 ||
            fh->fh_recs_per_blk == 0)
        {       db_error = DB_INVALID_FHDR;
                return;
        }

        if (fh->fh_rec_size != fh->fh_ctl_size + fh->fh_data_size)
        {       db_error = DB_INVALID_FHDR;
                return;
        }

        if (fh->fh_key_size > fh->fh_data_size)
        {       db_error = DB_INVALID_FHDR;
                return;
        }

        if (fh->fh_file_type == DB_RANDOM &&
            fh->fh_base_size == 0)
        {       db_error = DB_INVALID_FHDR;
                return;
        }
}

/*
 *      db_close  -  close a data set
 */

DATA_FILE db_close(df)
 DATA_FILE df;
{
        db_error = 0;

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

        db_put_blk(df, df->df_fhdr);
	if (db_error) return(NULL);

        close(df->df_fd);

        db_free_df(df);

        return(NULL);
}

/*
 *      db_add  -  Add a new record to a data set
 */

ulong db_add(df, user_data, data_size)
 DATA_FILE df;
 char *user_data;
 int data_size;
{
        FILE_HDR fh;
        BUFFER  buf;
        ulong   rec_no;

        db_error = 0;

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

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

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

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

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

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

                default:
                        db_error = DB_INVALID_REQUEST;
                        break;
        }

        if (db_error) return(0);

	if (fh->fh_file_type == DB_VAR)
		rec_no = db_add_blk;
	else
	        rec_no = (db_add_blk - 1) * fh->fh_recs_per_blk + db_add_rec;

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

        return(rec_no);
}

/*
 *      db_read_first  -  Read First Record in a data set
 */

void db_read_first(df, user_data, data_size)
 DATA_FILE df;
 char *user_data;
 int  *data_size;
{
        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 (!fh->fh_rec_cnt)
        {       db_error = DB_END_OF_FILE;
                return;
        }

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

#ifdef IDX
                case DB_INDEX:
                        db_read_first_idx(df, fh->fh_root_ptr, user_data);
                        break;
#endif

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

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

                default:
                        db_error = DB_INVALID_REQUEST;
                        break;
        }

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

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

	return;
}

/*
 *      db_read_next  -  Read next record from a data set
 */

void db_read_next(df, user_data, data_size)
 DATA_FILE df;
 char *user_data;
 int  *data_size;
{
        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 (!fh->fh_rec_cnt)
        {       db_error = DB_END_OF_FILE;
                return;
        }

        if (!df->df_prev_blk)
        {       db_error = DB_NO_CURRENT_REC;
                return;
        }

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

#ifdef IDX
                case DB_INDEX:
                        db_read_next_idx(df, user_data);
                        break;
#endif
                              
#ifdef RAN
                case DB_RANDOM:
                        db_read_next_ran(df, user_data);
                        break;
#endif

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

                default:
                        db_error = DB_INVALID_REQUEST;
                        break;
        }

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

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

	return;
}
 
/*
 *	db_read_last  -  Read Last Record in a data set
 */

void db_read_last(df, user_data, data_size)
 DATA_FILE df;
 char *user_data;
 int  *data_size;
{
        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 (!fh->fh_rec_cnt)
        {       db_error = DB_END_OF_FILE;
                return;
        }

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

#ifdef IDX
                case DB_INDEX:
			db_read_last_idx(df, fh->fh_root_ptr, user_data);
                        break;
#endif

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

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

                default:
                        db_error = DB_INVALID_REQUEST;
                        break;
        }

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

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

	return;
}

/*
 *	db_read_prev  -  Read prev record from a data set
 */

void db_read_prev(df, user_data, data_size)
 DATA_FILE df;
 char *user_data;
 int  *data_size;
{
        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 (!fh->fh_rec_cnt)
        {       db_error = DB_END_OF_FILE;
                return;
        }

        if (!df->df_prev_blk)
        {       db_error = DB_NO_CURRENT_REC;
                return;
        }

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

#ifdef IDX
                case DB_INDEX:
			db_read_prev_idx(df, user_data);
                        break;
#endif
                              
#ifdef RAN
                case DB_RANDOM:
			db_read_prev_ran(df, user_data);
                        break;
#endif

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

                default:
                        db_error = DB_INVALID_REQUEST;
                        break;
        }

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

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

	return;
}

/*
 *      db_find  -  Find a Record
 */

void db_find(df, user_data, key, key_size)
 DATA_FILE df;
 char *user_data;
 char *key;
 int   key_size;
{
        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 (!fh->fh_rec_cnt)
        {       db_error = DB_REC_NOT_FOUND;
                return;
        }

        if (!key_size) key_size = fh->fh_key_size;

        switch (fh->fh_file_type)
        {