Return to get.c CVS log

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

Annotation of 42BSD/ingres/source/iutil/get.c, revision 1.1.1.1

1.1       root        1: # include      <ingres.h>
                      2: # include      <aux.h>
                      3: # include      <access.h>
                      4: # include      <sccs.h>
                      5: 
                      6: SCCSID(@(#)get.c       7.1     2/5/81)
                      7: 
                      8: /*
                      9: **  GET - get a single tuple
                     10: **
                     11: **     Get either gets the next sequencial tuple after
                     12: **     "tid" or else gets the tuple specified by tid.
                     13: **
                     14: **     If getnxt == TRUE, then tid is incremented to the next
                     15: **     tuple after tid. If there are no more, then get returns
                     16: **     1. Otherwise get returns 0 and "tid" is set to the tid of
                     17: **     the returned tuple.
                     18: **
                     19: **     Under getnxt mode, the previous page is reset before
                     20: **     the next page is read. This is done to prevent the previous
                     21: **     page from hanging around in the am's buffers when we "know"
                     22: **     that it will not be referenced again.
                     23: **
                     24: **     If getnxt == FALSE then the tuple specified by tid is
                     25: **     returned. If the tuple was deleted previously,
                     26: **     get retuns 2 else get returns 0.
                     27: **
                     28: **     If getnxt is true, limtid holds the the page number
                     29: **     of the first page past the end point. Limtid and the
                     30: **     initial value of tid are set by calls to FIND.
                     31: **
                     32: **     returns:
                     33: **             <0  fatal error
                     34: **             0   success
                     35: **             1   end of scan (getnxt=TRUE only)
                     36: **             2   tuple deleted (getnxt=FALSE only)
                     37: */
                     38: 
                     39: 
                     40: get(d, tid, limtid, tuple, getnxt)
                     41: register DESC  *d;
                     42: register TID   *tid;
                     43: TID            *limtid;
                     44: int            getnxt;
                     45: char           *tuple;
                     46: {
                     47:        register int    i;
                     48:        long            pageid, lpageid;
                     49: 
                     50: #      ifdef xATR1
                     51:        if (tTf(23, 0))
                     52:        {
                     53:                printf("get: %.14s,", d->reldum.relid);
                     54:                dumptid(tid);
                     55:                printf("get: lim");
                     56:                dumptid(limtid);
                     57:        }
                     58: #      endif
                     59:        if (get_page(d, tid))
                     60:        {
                     61:                return (-1);
                     62:        }
                     63:        if (getnxt)
                     64:        {
                     65:                pluck_page(limtid, &lpageid);
                     66:                do
                     67:                {
                     68:                        while (((++(tid->line_id)) & I1MASK) >= Acc_head->nxtlino)
                     69:                        {
                     70:                                tid->line_id = -1;
                     71:                                pageid = Acc_head->ovflopg;
                     72:                                stuff_page(tid, &pageid);
                     73:                                if (pageid == 0)
                     74:                                {
                     75:                                        pageid = Acc_head->mainpg;
                     76:                                        stuff_page(tid, &pageid);
                     77:                                        if (pageid == 0 || pageid == lpageid + 1)
                     78:                                                return (1);
                     79:                                }
                     80:                                if (i = resetacc(Acc_head))
                     81:                                        return (i);
                     82:                                if (i = get_page(d, tid))
                     83:                                        return (i);
                     84:                        }
                     85:                } while (!Acc_head->linetab[-(tid->line_id & I1MASK)]);
                     86:        }
                     87:        else
                     88:        {
                     89:                if (i = invalid(tid))
                     90:                        return (i);
                     91:        }
                     92:        get_tuple(d, tid, tuple);
                     93: #      ifdef xATR2
                     94:        if (tTf(23, 1))
                     95:        {
                     96:                printf("get: ");
                     97:                printup(d, tuple);
                     98:        }
                     99: #      endif
                    100:        return (0);
                    101: }

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