Return to replace.c CVS log

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

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

1.1     ! root        1: # include      <ingres.h>
        !             2: # include      <access.h>
        !             3: # include      <catalog.h>
        !             4: # include      <batch.h>
        !             5: # include      <btree.h>
        !             6: # include      <sccs.h>
        !             7: 
        !             8: SCCSID(@(#)replace.c   8.2     2/8/85)
        !             9: 
        !            10: # define       SAMETUP         0
        !            11: # define       SAMEKEYS        1
        !            12: # define       DIFFTUP         2
        !            13: 
        !            14: /*
        !            15: **  REPLACE - replace an already existing tuple
        !            16: **
        !            17: **     Replace will replace the tuple specified by TID
        !            18: **     with the new tuple. An attempt is made to not
        !            19: **     move the tuple if at all possible.
        !            20: **
        !            21: **     Three separate conditions are dealt with. If the
        !            22: **     new tuple is the same as the old tuple, a return 
        !            23: **     of zero occures and the page is not changed.
        !            24: **
        !            25: **     If the keys(if any) are the same and the canonical
        !            26: **     tuple lengths are the same, then the new tuple will
        !            27: **     be placed in the same location.
        !            28: **
        !            29: **     If the lengths or the keys are different, then the
        !            30: **     tuple is deleted and the new tuple inserted
        !            31: **
        !            32: **     Checkdups specifies whether to check for duplicates.
        !            33: **     If the new tuple is a duplicate of one already there,
        !            34: **     then the tuple at TID is deleted
        !            35: **
        !            36: **     Returns:
        !            37: **             <0  fatal error
        !            38: **              1(DUPTUP)  new tuple was duplicate of returned tid
        !            39: **              2(DELTUP) tuple identified by tid has been deleted
        !            40: **              3(BADLID) bad lid
        !            41: **
        !            42: **             If replace returns 1 then tid is set to the
        !            43: **             duplicate tuple. This is necessary for updating
        !            44: **             secondary indices.
        !            45: **
        !            46: **     Trace Flags:
        !            47: **             24.4-7
        !            48: */
        !            49: 
        !            50: 
        !            51: replace(d, tid, tuple, checkdups)      
        !            52: register DESC  *d;
        !            53: register TID   *tid;
        !            54: char           *tuple;
        !            55: int            checkdups;
        !            56: {
        !            57:        register int    i;
        !            58:        int             j;
        !            59:        char            oldtuple[MAXTUP];
        !            60:        TID             primtid, tidloc, tidpos;
        !            61:        long            primpage, old_lid[MAXLID], new_lid[MAXLID], page, t;
        !            62:        int             need, same, numatts;
        !            63:        int             len, oldlength;
        !            64:        char            *new, *old, *oldt;
        !            65:        char            *getint_tuple();
        !            66:        char            btree[MAXNAME + 4];
        !            67:        long            oldtid;
        !            68:        int             lidwid, compare;
        !            69:        struct locator  temp;
        !            70: 
        !            71: #      ifdef xATR1
        !            72:        if (tTf(24, 4))
        !            73:        {
        !            74:                printf("replace: %.14s,", d->reldum.relid);
        !            75:                dumptid(tid);
        !            76:                printf("replace: ");
        !            77:                printup(d, tuple);
        !            78:        }
        !            79: #      endif
        !            80: 
        !            81:        /* make tuple canonical */
        !            82:        need = canonical(d, tuple);
        !            83: 
        !            84:        /* if heap or ordered, no dup checking */
        !            85:        if (abs(d->reldum.relspec) == M_HEAP || d->reldum.reldim > 0)
        !            86:                checkdups = FALSE;
        !            87: 
        !            88:        if (i = get_page(d, tid))
        !            89:                return (i);     /* fatal error */
        !            90: 
        !            91:        /* check if tid exists */
        !            92:        if (i = invalid(tid))
        !            93:                return (i);     /* already deleted or invalid */
        !            94: 
        !            95:        oldt = getint_tuple(d, tid, oldtuple);
        !            96:        /* reset page back to main relation page */
        !            97:        if (i = get_page(d, tid))
        !            98:                return(i);
        !            99:        oldlength = tup_len(tid);
        !           100:        lidwid = LIDSIZE * d->reldum.reldim;
        !           101: 
        !           102:        if (d->reldum.reldim > 0)
        !           103:        {
        !           104:                /* extract lid values from tuples */
        !           105:                btreename(d->reldum.relid, btree);
        !           106:                old = oldt + d->reldum.relwid  - lidwid;
        !           107:                bmove(old, old_lid, lidwid);
        !           108:                new = tuple + d->reldum.relwid - lidwid;
        !           109:                bmove(new, new_lid, lidwid);
        !           110:                compare = 0;
        !           111:                for (i = 0; i < d->reldum.reldim; ++i)
        !           112:                {
        !           113:                        if (new_lid[i] > old_lid[i])
        !           114:                        {
        !           115:                                compare = 1;
        !           116:                                break;
        !           117:                        }
        !           118:                        else if (new_lid[i] == old_lid[i])
        !           119:                                compare = -1;
        !           120:                        else
        !           121:                        {
        !           122:                                compare = 0;
        !           123:                                break;
        !           124:                        }
        !           125:                }
        !           126:                if (compare >= 0)
        !           127:                {
        !           128:                /* do insertion and deletion of new lid and old values in
        !           129:                ** order that insures that they will be placed in the proper
        !           130:                ** place
        !           131:                */
        !           132:                        if (compare == 1)
        !           133:                        {
        !           134:                                if (insert_mbtree(d, btree, new_lid, tid, &tidpos) < 0)
        !           135:                                        return(BADLID);
        !           136:                                if (fwrite(old_lid, 1, lidwid, Del_infp) != lidwid)
        !           137:                                        syserr("write error in replace");
        !           138:                                ++Del_cnt;
        !           139:                        }
        !           140:                        else if (compare == 0)
        !           141:                        {
        !           142:                                page = RT;
        !           143:                                for (j = 0; j < d->reldum.reldim; ++j)
        !           144:                                {
        !           145:                                        if (new_lid[j] > 0 && (t = get_tid(page, new_lid[j], &temp)) > 0)
        !           146:                                                page = t;
        !           147:                                        else if (t == -1)
        !           148:                                        {
        !           149:                                                for (i = j + 1; i < d->reldum.reldim; ++i)
        !           150:                                                {
        !           151:                                                        if (new_lid[i] != 1 && new_lid[i] != 0)
        !           152:                                                                return(BADLID);
        !           153:                                                }
        !           154:                                                break;
        !           155:                                        }
        !           156:                                        else if (new_lid[j] == 0)
        !           157:                                        {
        !           158:                                                for (i = j + 1; i < d->reldum.reldim; ++i)
        !           159:                                                {
        !           160:                                                        if (new_lid[i] != 0)
        !           161:                                                                return(BADLID);
        !           162:                                                }
        !           163:                                                break;
        !           164:                                        }
        !           165:                                        else
        !           166:                                                return(BADLID);
        !           167:                                }
        !           168:                                for (i = 0; i < d->reldum.reldim; ++i)
        !           169:                                        if (new_lid[i] < 0)
        !           170:                                                return(BADLID);
        !           171:                                delete_btree(old_lid, d->reldum.reldim);
        !           172:                                if (insert_mbtree(d, btree, new_lid, tid, &tidpos) < 0)
        !           173:                                        return(BADLID);
        !           174:                        }
        !           175:                }
        !           176:        }
        !           177: 
        !           178:        /* check whether tuples are the same, different lengths, different keys */
        !           179:        same = DIFFTUP; /* assume diff lengths or keys */
        !           180:        if (oldlength == need)
        !           181:        {
        !           182:                /* same size. check for same domains */
        !           183:                same = SAMETUP; /* assume identical */
        !           184:                new = tuple;
        !           185:                old = oldt;
        !           186:                /* ignore lid field */
        !           187:                numatts = d->reldum.relatts - d->reldum.reldim;
        !           188:                for (i = 1; i <= numatts; i++)
        !           189:                {
        !           190:                        len = d->relfrml[i] & I1MASK;
        !           191:                        if (icompare(new, old, d->relfrmt[i], len))
        !           192:                        {
        !           193:                                if (d->relxtra[i])
        !           194:                                {
        !           195:                                        same = DIFFTUP;
        !           196:                                        break;
        !           197:                                }
        !           198:                                same = SAMEKEYS;
        !           199:                        }
        !           200:                        old += len;
        !           201:                        new += len;
        !           202:                }
        !           203:        }
        !           204: 
        !           205: #      ifdef xATR2
        !           206:        if (tTf(24, 5))
        !           207:                printf("replace:same=%d\n", same);
        !           208: #      endif
        !           209: 
        !           210:        switch (same)
        !           211:        {
        !           212: 
        !           213:          case SAMETUP:
        !           214:                /* new tuple same as old tuple */
        !           215:                i = DUPTUP;     /* flag as duplicate */
        !           216:                /* though character strings may compare equal,
        !           217:                **  they can look different, so if they do look different
        !           218:                **  go ahead and do the replace using put_tuple.  */
        !           219:                if (!bequal(tuple, oldt, d->reldum.relwid - lidwid))
        !           220:                        goto puttuple;
        !           221:                break;
        !           222: 
        !           223:          case SAMEKEYS:
        !           224:                /* keys the same, lengths the same, tuples different */
        !           225:                if (checkdups)
        !           226:                {
        !           227:                        /* This is either an ISAM or HASH file. If mainpg
        !           228:                        ** is non-zero, then the primary page=mainpg -1.
        !           229:                        ** Otherwise, "find" must be called to determine
        !           230:                        ** the primary page
        !           231:                        */
        !           232:                        if (Acc_head->mainpg)
        !           233:                        {
        !           234:                                primpage = Acc_head->mainpg -1;
        !           235:                                stuff_page(&primtid, &primpage);
        !           236:                        }
        !           237:                        else
        !           238:                        {
        !           239:                                if (i = find(d, FULLKEY, &primtid, &primtid, tuple))
        !           240:                                        return (i);     /* fatal error */
        !           241:                                if (i = get_page(d, tid))       /* restore page for tuple */
        !           242:                                        return (i);
        !           243:                        }
        !           244:        
        !           245:                        if (i = scan_dups(d, &primtid, tuple))
        !           246:                        {
        !           247:                                if (i == DUPTUP)
        !           248:                                {
        !           249:                                        del_tuple(tid, oldlength);      /* tuple a duplicate */
        !           250:                                        d->reladds--;
        !           251:                                        /* copy tid of duplicate tuple */
        !           252:                                        bmove(&primtid, tid, sizeof(primtid));
        !           253:                                }
        !           254:                                break;
        !           255:                        }
        !           256:                }
        !           257:                goto puttuple;
        !           258: 
        !           259:          case DIFFTUP:
        !           260:                /* keys different or lengths different */
        !           261:                get_page(d, tid);
        !           262:                del_tuple(tid, oldlength);
        !           263:                bmove(tid, &oldtid, LIDSIZE);
        !           264: 
        !           265:                /* find where to put tuple */
        !           266:                if (i = findbest(d, tid, tuple, need, checkdups))
        !           267:                {
        !           268:                        d->reladds--;
        !           269:                        break;
        !           270:                }
        !           271: 
        !           272:                /* place new tuple in page */
        !           273:        puttuple:
        !           274:                put_tuple(tid, Acctuple, need);
        !           275:                i = NEWTUP;
        !           276: 
        !           277:                if (same == DIFFTUP && d->reldum.reldim > 0)
        !           278:                {
        !           279:                        /* main tid value has changed, update btree */
        !           280:                        if (compare < 0)
        !           281:                                search_btree(oldtid, &tidpos);
        !           282:                        /* tid different, must be reflected in BTree */
        !           283:                                replace_btree(*tid, &tidpos);
        !           284:                }
        !           285:        }
        !           286: 
        !           287: #      ifdef xATR1
        !           288:        if (tTf(24, 6))
        !           289:        {
        !           290:                printf("replace rets %d,", i);
        !           291:                dumptid(tid);
        !           292:        }
        !           293: #      endif
        !           294:        return (i);
        !           295: }

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