Return to get_tid.c CVS log

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

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

1.1       root        1: #include       <btree.h>
                      2: #include       <sccs.h>
                      3: 
                      4: SCCSID(@(#)get_tid.c   8.3     1/31/86)
                      5: 
                      6: /*     GET_TID -- BTree retrieval routine
                      7: **
                      8: **     Retrieve the tid corresponding to the given lid
                      9: **
                     10: **     Parameters :
                     11: **             tree - BTree filename (I)
                     12: **             lid - given lid (I)
                     13: **             tid_id - storage information of location of the tid (O)
                     14: **
                     15: **     Returns :
                     16: **             > 0     tid
                     17: **             -1      lid corresponds to very last lid in tree
                     18: **             -2      lid does not exist
                     19: */
                     20: 
                     21: long
                     22: get_tid(rootpage, lid, tid_id)
                     23: 
                     24: long rootpage;
                     25: long lid;
                     26: register struct locator *tid_id;
                     27: {
                     28:        struct BTreeNode        p;
                     29:        long                    pgno, sum, k, t;
                     30:        register int            i;
                     31: 
                     32: #      ifdef xATR1
                     33:        if (tTf(24, 0))
                     34:                printf("getting btree tid for lid %ld in rootpage %d\n", lid, rootpage);
                     35: #      endif
                     36: 
                     37:        
                     38:        if (lid <= 0)
                     39:                return(-2);     /* negative lids nonexistent */
                     40: 
                     41:        get_node(rootpage, &p);
                     42:        pgno = rootpage;
                     43:        sum = 0;
                     44:        t = 0;
                     45: 
                     46:        /* find the leaf node containing desired tid */
                     47:        while (p.nodetype != 'L')
                     48:        {
                     49:                if (t == -1)
                     50:                        /* continue along path to very last lid */
                     51:                        i = p.nelmts - 1;
                     52:                else
                     53:                {
                     54:                        /* find pointer in node which will lead down to proper leaf */
                     55:                        for (i = 0, k = p.node.intnode.key[0]; sum + k < lid && i < p.nelmts; )
                     56:                        {
                     57:                                sum += k;
                     58:                                ++i;
                     59:                                if (i < p.nelmts)
                     60:                                        k = p.node.intnode.key[i];
                     61:                        }
                     62:        
                     63:                        if (i >= p.nelmts)
                     64:                        {
                     65:                                if (sum < lid - 1)
                     66:                                        return(-2);     /* lid doesn't exist */
                     67:                                else
                     68:                                {
                     69:                                        --i;
                     70:                                        t = -1;
                     71:                                }
                     72:                        }
                     73:                }
                     74: 
                     75:                pgno = p.node.intnode.ptr[i];
                     76:                get_node(pgno, &p);
                     77:        }
                     78: 
                     79:        if (t == -1)
                     80:                /* new lid is to be inserted at very last leaf position */
                     81:                tid_id->offset = p.nelmts;
                     82:        else
                     83:        {
                     84:                /* search through the leaf for the proper tid */
                     85:                for (i = 0, ++sum, t = p.node.leafnode.tid_pos[p.node.leafnode.tid_loc[0]]; sum < lid && i < p.nelmts; )
                     86:                {
                     87:                        ++sum;
                     88:                        ++i;
                     89:                        if (i < p.nelmts)
                     90:                                t = p.node.leafnode.tid_pos[p.node.leafnode.tid_loc[i]];
                     91:                }
                     92:                if (i >= p.nelmts)
                     93:                {
                     94:                        if (sum < lid)
                     95:                                return(-2);     /* lid doesn't exist */
                     96:                        else
                     97:                                t = -1;
                     98:                }
                     99:                tid_id->offset = i;
                    100:        }
                    101: 
                    102:        bmove(&p, &tid_id->page, sizeof p);
                    103:        tid_id->pageno = pgno;
                    104: 
                    105: #      ifdef xATR1
                    106:        if (tTf(24, 0))
                    107:        {
                    108:                printf("Main relation tid found in tree:");
                    109:                dumptid(&t);
                    110:                printf("Btree tid location:");
                    111:                dumptid(tid_id);
                    112:        }
                    113: #      endif
                    114: 
                    115:        return(t);
                    116: }

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