db_idx.c

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

        if (!tdx->idx_idx_ptr) return(0);

        tmp        = df->df_buf;
        buf        = df->df_tmp;
        df->df_buf = buf;
        df->df_tmp = tmp;
                   
        ihdr = (INDEX_HDR) buf->buf_data;
        thdr = (INDEX_HDR) tmp->buf_data;

        blk = tdx->idx_idx_ptr;

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

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

                blk = idx->idx_idx_ptr;
        }

        idx = (INDEX_REC)((char *) idx - fh->fh_rec_size);

        idx->idx_idx_ptr = tdx->idx_idx_ptr;
        memcpy(tdx, idx, fh->fh_rec_size);
        idx->idx_idx_ptr = 0;

        db_put_blk(df, tmp);
        if (db_error) return(0);

        buf->buf_rec_inx = ihdr->idx_rec_cnt;

        return(1);
}

/*
 *      db_balance_idx  -  Rebalance tree after a delete
 */

void db_balance_idx(df)
 DATA_FILE df;
{
        FILE_HDR    fh;
        BUFFER     buf,  tmp,  aux;
        INDEX_HDR ihdr, thdr, ahdr;
        INDEX_REC  idx,  tdx,  adx;
        int    min_cnt, hold,  cnt,  op;
        char      *src, *dst;  

        db_error = 0;

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

        if (buf->buf_cur_blk == fh->fh_root_ptr)
        {       db_put_blk(df, buf);
                return;
        }

        min_cnt = (fh->fh_recs_per_blk + 1) / 2;
        if (ihdr->idx_rec_cnt >= min_cnt)
        {       db_put_blk(df, buf);
                return;
        }

        tmp        = df->df_buf;
        buf        = df->df_tmp;
        df->df_buf = buf;
        df->df_tmp = tmp;
        aux        = df->df_aux;

        thdr = (INDEX_HDR) tmp->buf_data;
        ahdr = (INDEX_HDR) aux->buf_data;
        ihdr = (INDEX_HDR) buf->buf_data;

        buf->buf_cur_blk = tmp->buf_cur_blk;
        buf->buf_rec_inx = tmp->buf_rec_inx;
        ihdr->idx_parent = thdr->idx_parent;

        db_get_parent_idx(df);
        if (db_error) return;

        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)
        {       adx = (INDEX_REC) ((char *) idx + fh->fh_rec_size);
                op  = 1;
        }
        else
        {       idx = adx = (INDEX_REC) ((char *) idx - fh->fh_rec_size);
                buf->buf_rec_inx--;
                op  = 2;          
        }                              

        db_get_blk(df, (long)adx->idx_idx_ptr, aux);
        if (db_error) return;

        if (ahdr->idx_rec_cnt <= min_cnt) op += 2;

        switch (op)
        {   case 1: /* Rotate Left */
                if (df->df_prev_blk == aux->buf_cur_blk &&
                    df->df_prev_rec == 0)
                {       df->df_prev_blk = buf->buf_cur_blk;
                        df->df_prev_rec = buf->buf_rec_inx;
                }

                if (df->df_prev_blk == buf->buf_cur_blk &&
                    df->df_prev_rec == buf->buf_rec_inx)
                {       df->df_prev_blk = tmp->buf_cur_blk;
                        df->df_prev_rec = thdr->idx_rec_cnt + 1;
                }                       
                else
                if (df->df_prev_blk == aux->buf_cur_blk &&
                    df->df_prev_rec == 1)
                {       df->df_prev_blk = buf->buf_cur_blk;
                        df->df_prev_rec = buf->buf_rec_inx;
                }
                else
                if (df->df_prev_blk == aux->buf_cur_blk)
                        df->df_prev_rec--;

                tdx = (INDEX_REC)(tmp->buf_data + sizeof(struct db_index_hdr)
                            + thdr->idx_rec_cnt * fh->fh_rec_size);
                adx = (INDEX_REC)(aux->buf_data + sizeof(struct db_index_hdr));

                hold = tdx->idx_idx_ptr;
                memcpy(tdx, idx, fh->fh_rec_size);
                tdx->idx_idx_ptr = hold;
                tdx = (INDEX_REC) ((char *) tdx + fh->fh_rec_size);
                tdx->idx_idx_ptr = adx->idx_idx_ptr;
                thdr->idx_rec_cnt++;
                db_put_blk(df,tmp);
                if (db_error) return;

                if (tdx->idx_idx_ptr)
                {       hold = tmp->buf_cur_blk;
                        db_get_blk(df, (long)tdx->idx_idx_ptr, tmp);
                        if (db_error) return;

                        thdr->idx_parent = hold;
                        db_put_blk(df, tmp);
                        if (db_error) return;
                }

                hold = idx->idx_idx_ptr;
                memcpy(idx, adx, fh->fh_rec_size);
                idx->idx_idx_ptr = hold;
                db_put_blk(df, buf);
                if (db_error) return;

                src = (char*) adx + fh->fh_rec_size;
                cnt = ahdr->idx_rec_cnt * fh->fh_rec_size;
                memcpy(adx, src, cnt);
                ahdr->idx_rec_cnt--;
                db_put_blk(df, aux);
                if (db_error) return;
                return;

            case 2: /* Rotate Right */ 
                if (df->df_prev_blk == buf->buf_cur_blk &&
                    df->df_prev_rec == buf->buf_rec_inx)
                {       df->df_prev_blk = tmp->buf_cur_blk;
                        df->df_prev_rec = 1;
                }                       
                else
                if (df->df_prev_blk == aux->buf_cur_blk &&
                    df->df_prev_rec == ahdr->idx_rec_cnt)
                {       df->df_prev_blk = buf->buf_cur_blk;
                        df->df_prev_rec = buf->buf_rec_inx;
                }
                else
                if (df->df_prev_blk == tmp->buf_cur_blk)
                        df->df_prev_rec++;

                tdx = (INDEX_REC)(tmp->buf_data + sizeof(struct db_index_hdr));
                adx = (INDEX_REC)(aux->buf_data + sizeof(struct db_index_hdr)
                                       + ahdr->idx_rec_cnt * fh->fh_rec_size);

                dst = (char *) tdx + fh->fh_rec_size;
                cnt = (thdr->idx_rec_cnt + 1) * fh->fh_rec_size;
                memcpy(dst, tdx, cnt);
                memcpy(tdx, idx, fh->fh_rec_size);
                tdx->idx_idx_ptr = adx->idx_idx_ptr;
                thdr->idx_rec_cnt++;
                db_put_blk(df, tmp);
                if (db_error) return;

                if (tdx->idx_idx_ptr)
                {       hold = tmp->buf_cur_blk;
                        db_get_blk(df, (long)tdx->idx_idx_ptr, tmp);
                        if (db_error) return;

                        thdr->idx_parent = hold;
                        db_put_blk(df, tmp);
                        if (db_error) return;
                }

                hold = idx->idx_idx_ptr;
                adx  = (INDEX_REC) ((char *) adx - fh->fh_rec_size);
                memcpy(idx, adx, fh->fh_rec_size);
                idx->idx_idx_ptr = hold;
                db_put_blk(df, buf);
                if (db_error) return;

                ahdr->idx_rec_cnt--;
                db_put_blk(df, aux);
                if (db_error) return;
                return;

            case 4: /* Merge Right */
                tmp        = df->df_aux;
                aux        = df->df_tmp;
                df->df_aux = aux;
                df->df_tmp = tmp;
                thdr       = (INDEX_HDR) tmp->buf_data;
                ahdr       = (INDEX_HDR) aux->buf_data;

            case 3: /* Merge Left */      
                if (df->df_prev_blk == buf->buf_cur_blk &&
                    df->df_prev_rec == buf->buf_rec_inx)
                {       df->df_prev_blk = tmp->buf_cur_blk;
                        df->df_prev_rec = thdr->idx_rec_cnt + 1;
                }                       
                else
                if (df->df_prev_blk == aux->buf_cur_blk)
                {       df->df_prev_blk  = tmp->buf_cur_blk;
                        df->df_prev_rec += thdr->idx_rec_cnt + 1;
                }                       

                tdx = (INDEX_REC)(tmp->buf_data + sizeof(struct db_index_hdr)
                            + thdr->idx_rec_cnt * fh->fh_rec_size);
                adx = (INDEX_REC)(aux->buf_data + sizeof(struct db_index_hdr));

                hold = tdx->idx_idx_ptr;
                memcpy(tdx, idx, fh->fh_rec_size);
                tdx->idx_idx_ptr = hold;
                tdx = (INDEX_REC) ((char *) tdx + fh->fh_rec_size);
                thdr->idx_rec_cnt++;

                cnt = ahdr->idx_rec_cnt * fh->fh_rec_size + fh->fh_ctl_size;
                memcpy(tdx, adx, cnt);
                thdr->idx_rec_cnt += ahdr->idx_rec_cnt;

                src = (char *) idx + fh->fh_rec_size;
                cnt = (ihdr->idx_rec_cnt - buf->buf_rec_inx)
                                       * fh->fh_rec_size + fh->fh_ctl_size;
                memcpy(idx, src, cnt);
                idx->idx_idx_ptr = tmp->buf_cur_blk;
                ihdr->idx_rec_cnt--;

                src = buf->buf_data + sizeof(struct db_index_hdr)
                    + ihdr->idx_rec_cnt * fh->fh_rec_size + fh->fh_ctl_size;
                cnt = fh->fh_rec_size;
                memset(src, 0, cnt);

		if (buf->buf_cur_blk == fh->fh_root_ptr)
                	if (!ihdr->idx_rec_cnt)
                 	       thdr->idx_parent = 0;

                db_put_blk(df, tmp);
                if (db_error) return;

                hold = ahdr->idx_rec_cnt + 1;
                db_free_rec(df, aux);
                if (db_error) return;

                for (cnt=1; cnt <= hold; cnt++)
                {       if (tdx->idx_idx_ptr)
                        {       db_get_blk(df, (long)tdx->idx_idx_ptr, aux);
                                if (db_error) return;

                                ahdr->idx_parent = tmp->buf_cur_blk;
                                db_put_blk(df, aux);
                                if (db_error) return;
                        }
                        tdx = (INDEX_REC)((char *) tdx + fh->fh_rec_size);
                }

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

                return;
        }
}

/*
 *      db_update_idx - Update an Index record
 */

void db_update_idx(df, user_data)
 DATA_FILE  df;
 char     *user_data;
{
        INDEX_HDR   ihdr;
        FILE_HDR    fh;
        BUFFER      buf;
        char       *rbuf;

        db_error = 0;

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

        if (ihdr->idx_rec_cnt < buf->buf_rec_inx)
        {       db_error = DB_DELETED_REC;
                return;
        }

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

        memcpy(rbuf+fh->fh_ctl_size, user_data, fh->fh_data_size);
        db_put_blk(df, buf);
        return;
}