Return to btreerange.c CVS log

Up to [CSRG BSD Unix] / 43BSD / ingres / source / iutil

Annotation of 43BSD/ingres/source/iutil/btreerange.c, revision 1.1.1.1

1.1       root        1: # include      <ingres.h>
                      2: # include      <btree.h>
                      3: # include      <sccs.h>
                      4: 
                      5: SCCSID(@(#)btreerange.c        8.1     12/31/84)
                      6: 
                      7: /*
                      8: **     Btreerange finds the smallest and largest tids corresponding to
                      9: **     the lids found between two given lids.
                     10: */
                     11: 
                     12: btreerange(d, low_lid, high_lid, lotid, hitid)
                     13: 
                     14: DESC *d;
                     15: long low_lid[], high_lid[];
                     16: register TID *lotid, *hitid;
                     17: {
                     18:        register int    i;
                     19:        long            l, h, tid, temp;
                     20:        struct locator  block;
                     21:        long            page, t, last, hbtid, last_lid();
                     22:        int             done, first;
                     23:        long            start, next;
                     24: 
                     25:        /* find tid corresponding to high lid */
                     26:        page = RT;
                     27:        for (i = 0; i < d->reldum.reldim; ++i)
                     28:        {
                     29:                if ((t = get_tid(page, high_lid[i], &block)) < 0)
                     30:                        syserr("get_tid error in btreerange, lid = %ld\n", high_lid[i]);
                     31:                page = t;
                     32:        }
                     33:        hbtid = page;
                     34:        /* find starting point of scan */
                     35:        page = RT;
                     36:        for (i = 0; i < d->reldum.reldim - 1; ++i)
                     37:        {
                     38:                last = last_lid(page) - 1;
                     39:                if (low_lid[i] > last)
                     40:                        low_lid[i] = last;
                     41:                if ((t = get_tid(page, low_lid[i], &block)) < 0)
                     42:                        syserr("get_tid error in btreerange, lid = %ld\n", low_lid[i]);
                     43:                page = t;
                     44:        }
                     45:        first = 1;
                     46:        last = last_lid(page) - 1;
                     47:        if (low_lid[d->reldum.reldim - 1] > last)
                     48:                low_lid[d->reldum.reldim - 1] = last;
                     49:        start = low_lid[d->reldum.reldim - 1];
                     50:        do
                     51:        {
                     52:                get_node(page, &block.page);
                     53:                next = block.page.nexttree;
                     54:                if ((tid = get_tid(page, start, &block)) < 0)
                     55:                        syserr("get_tid error in btreerange, lid = %ld\n", low_lid[d->reldum.reldim - 1]);
                     56:                /* set high and low to intial value */
                     57:                if (first)
                     58:                {
                     59:                        first = 0;
                     60:                        pluck_page(&tid, &l);
                     61:                        pluck_page(&tid, &h);
                     62:                }
                     63:                page = block.pageno;
                     64:                done = 0;
                     65:                while (done == 0)
                     66:                {
                     67:                        for (i = 0; i < block.page.nelmts && done == 0; ++i)
                     68:                        {
                     69:                                tid = block.page.node.leafnode.tid_pos[block.page.node.leafnode.tid_loc[i]];
                     70:                                pluck_page(&tid, &temp);
                     71:                                if (temp > h)
                     72:                                        h = temp;
                     73:                                else if (temp < l)
                     74:                                        l = temp;
                     75:                                if (tid == hbtid)
                     76:                                        done = 1;
                     77:                        }
                     78:                        page = block.page.node.leafnode.nextleaf;
                     79:                        if (page == NULL)
                     80:                                done = 1;
                     81:                        else
                     82:                                get_node(page, &block.page);
                     83:                }
                     84:                start = 1;
                     85:        } while (page = next && !done);
                     86:        stuff_page(lotid, &l);
                     87:        stuff_page(hitid, &h);
                     88:        lotid->line_id = hitid->line_id = -1;
                     89: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.