db_idx.c

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

        src = buf->buf_data + sizeof(struct db_index_hdr) + fh->fh_ctl_size;
        buf->buf_rec_inx = 1;
        memcpy(user_data, src, fh->fh_data_size);
}

/*
 *      db_read_next_idx  -  Read Next Record in an Index File
 */

void db_read_next_idx(df, user_data)
 DATA_FILE df;
 char *user_data;
{
        FILE_HDR    fh;
        BUFFER     buf;
        INDEX_HDR ihdr;
        INDEX_REC  idx;
        char      *src;

                    
        db_error = 0;

        fh   = (FILE_HDR) df->df_fhdr->buf_data;
        buf  = df->df_buf;
        ihdr = (INDEX_HDR)  buf->buf_data;
                                               
        db_get_blk(df, df->df_prev_blk, buf);
        if (db_error) return;

        buf->buf_rec_inx = df->df_prev_rec;

        if (buf->buf_rec_inx > ihdr->idx_rec_cnt)
        {       while (buf->buf_rec_inx > ihdr->idx_rec_cnt)
                {       db_get_parent_idx(df);
                        if (db_error) return;
                }

                src = buf->buf_data + sizeof(struct db_index_hdr)
                    + (buf->buf_rec_inx - 1) * fh->fh_rec_size
                    + fh->fh_ctl_size;

                memcpy(user_data, src, fh->fh_data_size);
                return;
        }

        buf->buf_rec_inx++;

        idx = (INDEX_REC) (buf->buf_data + sizeof(struct db_index_hdr)
            + (buf->buf_rec_inx - 1) * fh->fh_rec_size);

        if (idx->idx_idx_ptr)
        {       db_read_first_idx(df, idx->idx_idx_ptr, user_data);
                return;
        }

        if (buf->buf_rec_inx > ihdr->idx_rec_cnt)
        {       df->df_prev_rec = buf->buf_rec_inx;
                db_read_next_idx(df, user_data);
                return;
        }

        src = ((char *) idx) + fh->fh_ctl_size;
        memcpy(user_data, src, fh->fh_data_size);
}

/*
 *	db_read_last_idx  -  Read Last Record in an Index File
 */

void db_read_last_idx(df, blk, user_data)
 DATA_FILE df;
 int blk;
 char *user_data;
{
        FILE_HDR    fh;
        BUFFER     buf;
        INDEX_HDR ihdr;
        INDEX_REC  idx;
        char      *src;

                    
        db_error = 0;

        if (!blk)
        {       db_error = DB_END_OF_FILE;
                return;
        }

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

        while (blk)
        {       db_get_blk(df, (long) blk, buf);
                if (db_error) return;
         

                if (!ihdr->idx_rec_cnt)
                {       db_error = DB_INVALID_INDEX;
                        return;
                }

		idx  = (INDEX_REC) (buf->buf_data + sizeof(struct db_index_hdr)
				   + ihdr->idx_rec_cnt * fh->fh_rec_size);

                blk = idx->idx_idx_ptr;
        }                              

	src = buf->buf_data + sizeof(struct db_index_hdr)
	    + (ihdr->idx_rec_cnt - 1) * fh->fh_rec_size + fh->fh_ctl_size;

	buf->buf_rec_inx = ihdr->idx_rec_cnt;
        memcpy(user_data, src, fh->fh_data_size);
}

/*
 *	db_read_prev_idx  -  Read Prev Record in an Index File
 */

void db_read_prev_idx(df, user_data)
 DATA_FILE df;
 char *user_data;
{
        FILE_HDR    fh;
        BUFFER     buf;
        INDEX_HDR ihdr;
        INDEX_REC  idx;
        char      *src;

                    
        db_error = 0;

        fh   = (FILE_HDR) df->df_fhdr->buf_data;
        buf  = df->df_buf;
        ihdr = (INDEX_HDR)  buf->buf_data;
                                               
        db_get_blk(df, df->df_prev_blk, buf);
        if (db_error) return;

        buf->buf_rec_inx = df->df_prev_rec;

        idx = (INDEX_REC) (buf->buf_data + sizeof(struct db_index_hdr)
            + (buf->buf_rec_inx - 1) * fh->fh_rec_size);

	if (buf->buf_rec_inx == 1 && idx->idx_idx_ptr == 0)
	{	while (buf->buf_rec_inx == 1)
                {       db_get_parent_idx(df);
                        if (db_error) return;
                }
					    
		buf->buf_rec_inx--;

                src = buf->buf_data + sizeof(struct db_index_hdr)
                    + (buf->buf_rec_inx - 1) * fh->fh_rec_size
                    + fh->fh_ctl_size;

                memcpy(user_data, src, fh->fh_data_size);
                return;
        }

        if (idx->idx_idx_ptr)
	{	db_read_last_idx(df, idx->idx_idx_ptr, user_data);
                return;
        }

	buf->buf_rec_inx--;

        idx = (INDEX_REC) (buf->buf_data + sizeof(struct db_index_hdr)
            + (buf->buf_rec_inx - 1) * fh->fh_rec_size);

        src = ((char *) idx) + fh->fh_ctl_size;
        memcpy(user_data, src, fh->fh_data_size);
}


/*
 *      db_get_parent_idx  -  Get Parent Block
 */

void db_get_parent_idx(df)
 DATA_FILE df;        
{
        FILE_HDR     fh;
        BUFFER      buf;
        INDEX_HDR  ihdr;
        INDEX_REC   idx;
        char      *rbuf;
        ushort hold_blk;
        int         rec;

                    
        db_error = 0;

        fh   = (FILE_HDR) df->df_fhdr->buf_data;
        buf  = df->df_buf;
        rbuf = buf->buf_data + sizeof(struct db_index_hdr);
        ihdr = (INDEX_HDR)  buf->buf_data;                 

        hold_blk = buf->buf_cur_blk;
        if (!ihdr->idx_parent)
        {       db_error = DB_END_OF_FILE;
                return;
        }

        db_get_blk(df, (long)ihdr->idx_parent, buf);
        if (db_error) return;

        for (rec=1; rec <= ihdr->idx_rec_cnt + 1; rec++)
        {       idx = (INDEX_REC) rbuf;

                if (idx->idx_idx_ptr == hold_blk)
                        break;

                rbuf += fh->fh_rec_size;
        }

        if (idx->idx_idx_ptr != hold_blk)
        {       db_error = DB_INVALID_INDEX;
                return;
        }

        buf->buf_rec_inx = rec;
}

/*
 *      db_find_first_idx  -  Find First Record
 */

void db_find_first_idx(df, user_data, key, key_size)
 DATA_FILE df;
 char *user_data;
 char *key;
 int   key_size;
{
        FILE_HDR  fh;
        BUFFER   buf;
        char   *rbuf;

        db_error = 0;

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

        db_find_insert_idx(df, key, key_size);
        if (db_error) return;

        if (!db_match_blk)
        {       db_error = DB_REC_NOT_FOUND;
                return;
        }

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

        buf->buf_rec_inx = db_match_rec;

        rbuf = buf->buf_data + sizeof(struct db_index_hdr)
             + (buf->buf_rec_inx - 1) * fh->fh_rec_size + fh->fh_ctl_size;

        memcpy(user_data, rbuf, fh->fh_data_size);
}

/*
 *      db_delete_idx  -  Delete an Index Record
 */

void db_delete_idx(df)
 DATA_FILE df;
{
        FILE_HDR     fh;
        BUFFER      buf;
        INDEX_HDR  ihdr;
        char       *src, *dst;
        int         cnt, move_flag;

        db_error = 0;

        move_flag = db_move_to_leaf_idx(df);
        if (db_error) return;       

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

        dst = buf->buf_data + sizeof(struct db_index_hdr)
                            + (buf->buf_rec_inx - 1) * fh->fh_rec_size;
        src = dst + fh->fh_rec_size;
        cnt = (ihdr->idx_rec_cnt - buf->buf_rec_inx + 1) * fh->fh_rec_size;

        if (cnt) memcpy(dst, src, cnt);

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

        ihdr->idx_rec_cnt--;
        if (fh->fh_rec_cnt) fh->fh_rec_cnt--;

        if (buf->buf_cur_blk == fh->fh_root_ptr  &&  ihdr->idx_rec_cnt == 0)
        {       fh->fh_root_ptr = 0;
                db_free_rec(df, buf);
                if (db_error) return;
        }
        else
        {       db_balance_idx(df);
                if (db_error) return;
        }

        db_put_blk(df, df->df_fhdr);

        if (move_flag)
                db_read_next(df, df->df_tmp->buf_data);
}

/*
 *      db_move_to_leaf_idx  -  Move index record to a leaf node 
 *                              before deleting it
 */

short db_move_to_leaf_idx(df)
 DATA_FILE df;
{
        FILE_HDR     fh;
        BUFFER      buf, tmp;
        INDEX_HDR  ihdr, thdr;
        INDEX_REC   idx, tdx;
        ulong       blk;

        db_error = 0;

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

        tdx = (INDEX_REC)(buf->buf_data + sizeof(struct db_index_hdr)
                                + (buf->buf_rec_inx - 1) * fh->fh_rec_size);