Return to get_tuple.c CVS log

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

Annotation of 43BSD/ingres/source/iutil/get_tuple.c, revision 1.1

1.1     ! root        1: # include      <ingres.h>
        !             2: # include      <access.h>
        !             3: # include      <symbol.h>
        !             4: # include      <catalog.h>
        !             5: # include      <btree.h>
        !             6: # include      <sccs.h>
        !             7: 
        !             8: SCCSID(@(#)get_tuple.c 8.2     2/8/85)
        !             9: 
        !            10: /*
        !            11: **     Routine associated with getting a tuple out of
        !            12: **     the current buffer.
        !            13: */
        !            14: 
        !            15: 
        !            16: /*
        !            17: **     Get_tuple - take the tuple specified
        !            18: **     by tid and move it to "tuple"
        !            19: */
        !            20: 
        !            21: get_tuple(d, tid, tuple)
        !            22: register DESC  *d;
        !            23: TID            *tid;
        !            24: char           *tuple;
        !            25: {
        !            26:        register char   *cp;
        !            27:        char            *get_addr();
        !            28:        TID             tidloc;
        !            29:        char            lid[MAXLID * LIDSIZE];
        !            30:        extern DESC     Btreesec;
        !            31:        extern int      Btree_fd;
        !            32: 
        !            33:        cp = get_addr(tid);
        !            34: 
        !            35:        if (d->reldum.relspec < 0)
        !            36:                uncomp_tup(d, cp, tuple);       /* compressed tuple */
        !            37:        else
        !            38:        {
        !            39:                if (d->reldum.reldim == 0)
        !            40:                        bmove(cp, tuple, d->reldum.relwid);     /* uncompressed tuple */
        !            41:                else
        !            42:                        /* ignore lid field for now */
        !            43:                        bmove(cp, tuple, d->reldum.relwid - d->reldum.reldim * LIDSIZE);
        !            44:        }
        !            45: 
        !            46:        if (d->reldum.reldim > 0)
        !            47:        /* find corresponding lid value given main relation tid */
        !            48:        {
        !            49:                bmove(d->relbtree, &Btreesec, sizeof(Btreesec));
        !            50:                Btree_fd = d->btree_fd;
        !            51:                search_btree(*tid, &tidloc);
        !            52:                get_lid(&tidloc, lid);
        !            53:                /* attach lid value to end of tuple */
        !            54:                cp = tuple + d->reldum.relwid - d->reldum.reldim * LIDSIZE;
        !            55:                bmove(lid, cp, d->reldum.reldim * LIDSIZE);
        !            56:        }
        !            57: }
        !            58: /*
        !            59: **     Getint_tuple - get the tuple specified by
        !            60: **     tid. If possible avoid moving the tuple.
        !            61: **     Return value is address of tuple.
        !            62: */
        !            63: 
        !            64: char *
        !            65: getint_tuple(d, tid, tuple)
        !            66: register DESC  *d;
        !            67: TID            *tid;
        !            68: char           *tuple;
        !            69: {
        !            70:        register char   *cp, *ret;
        !            71:        extern char     *get_addr();
        !            72:        TID             tidloc;
        !            73:        char            lid[MAXLID * LIDSIZE];
        !            74:        extern DESC     Btreesec;
        !            75:        extern int      Btree_fd;
        !            76: 
        !            77:        cp = get_addr(tid);
        !            78: 
        !            79:        if (d->reldum.relspec < 0)
        !            80:        {
        !            81:                ret = tuple;
        !            82:                uncomp_tup(d, cp, ret); /* compressed tuple */
        !            83:        }
        !            84:        else if (d->reldum.reldim == 0)
        !            85:                ret = cp;                       /* uncompressed tuple */
        !            86:        else
        !            87:        {
        !            88:                /* ignore lid field for now */
        !            89:                ret = tuple;
        !            90:                bmove(cp, tuple, d->reldum.relwid - d->reldum.reldim * LIDSIZE);
        !            91:        }
        !            92:        if (d->reldum.reldim > 0)
        !            93:        {
        !            94:                bmove(d->relbtree, &Btreesec, sizeof(Btreesec));
        !            95:                Btree_fd = d->btree_fd;
        !            96:                /* find corresponding lid value */
        !            97:                search_btree(*tid, &tidloc);
        !            98:                get_lid(&tidloc, lid);
        !            99:                /* attach lid value to end of tuple */
        !           100:                cp = ret + d->reldum.relwid - d->reldum.reldim * LIDSIZE;
        !           101:                bmove(lid, cp, d->reldum.reldim * LIDSIZE);
        !           102:        }
        !           103:        return (ret);
        !           104: }
        !           105: /*
        !           106: **     Routine to compute the address of a tuple
        !           107: **     within the current buffer.
        !           108: **     Syserr if specified tuple deleted.
        !           109: */
        !           110: 
        !           111: char *
        !           112: get_addr(tid)
        !           113: register TID   *tid;
        !           114: {
        !           115:        register int    offset;
        !           116: 
        !           117:        offset = Acc_head->linetab[-(tid->line_id & I1MASK)];
        !           118:        if (offset == 0)
        !           119:        {
        !           120:                syserr("get_addr rel=%ld tid=%ld", Acc_head->rel_tupid, *(long *)tid);
        !           121:        }
        !           122: #      ifdef xATR3
        !           123:        if (offset < 0 || offset > PGSIZE)
        !           124:                syserr("get_addr: offset=%d\n");
        !           125: #      endif
        !           126:        return (((char *) Acc_head) + offset);
        !           127: }
        !           128: /*
        !           129: **     Uncompress - decompress the tuple at address cp
        !           130: **     according to descriptor.
        !           131: */
        !           132: 
        !           133: uncomp_tup(d, cp, tuple)
        !           134: register DESC  *d;
        !           135: char           *cp;
        !           136: char           *tuple;
        !           137: {
        !           138:        register char   *src, *dst;
        !           139:        int             i, j, numatts;
        !           140: 
        !           141:        dst = tuple;
        !           142:        src = cp;
        !           143: 
        !           144:        /* for each domain, copy and blank pad if char */
        !           145:        /* ignore lid field */
        !           146:        numatts = d->reldum.relatts - d->reldum.reldim;
        !           147:        for (i = 1; i <= numatts; i++)
        !           148:        {
        !           149:                j = d->relfrml[i] & I1MASK;
        !           150:                if (d->relfrmt[i] == CHAR)
        !           151:                {
        !           152:                        while (j--)
        !           153:                        {
        !           154:                                if ((*dst++ = *src++) == NULL)
        !           155:                                {
        !           156:                                        /* back up one */
        !           157:                                        dst--;
        !           158:                                        j++;
        !           159:                                        break;
        !           160:                                }
        !           161:                        }
        !           162: 
        !           163:                        /* blank pad if necessary */
        !           164:                        while (j-- > 0)
        !           165:                                *dst++ = ' ';
        !           166:                }
        !           167:                else
        !           168:                {
        !           169:                        while (j--)
        !           170:                                *dst++ = *src++;
        !           171:                }
        !           172:        }
        !           173: }
        !           174: /*
        !           175: **     Check if a line number is valid.
        !           176: **     If linenumber is illegal return AMINVL_ERR
        !           177: **     if Line has been deleted return DELTUP
        !           178: **     else return 0
        !           179: */
        !           180: 
        !           181: invalid(tid)
        !           182: register TID   *tid;
        !           183: {
        !           184:        register int    i;
        !           185: 
        !           186:        i = tid->line_id & I1MASK;
        !           187: 
        !           188:        if (i >= Acc_head->nxtlino)
        !           189:                return (acc_err(AMINVL_ERR));
        !           190: 
        !           191:        if (Acc_head->linetab[-i] == 0)
        !           192:                return (DELTUP);
        !           193: 
        !           194:        return (0);
        !           195: }

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