Return to batch.c CVS log

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

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

1.1     ! root        1: # include      <ingres.h>
        !             2: # include      <aux.h>
        !             3: # include      <catalog.h>
        !             4: # include      <symbol.h>
        !             5: # include      <access.h>
        !             6: # include      <batch.h>
        !             7: # include      <btree.h>
        !             8: # include      <sccs.h>
        !             9: 
        !            10: SCCSID(@(#)batch.c     8.2     1/17/85)
        !            11: 
        !            12: /*
        !            13: **     Open batch prepares for batch processing.
        !            14: **     1. If the batch is already open, return an error
        !            15: **     2. Create the batch file.
        !            16: **     3. clear domain flags.
        !            17: **     4. If the relation is indexed, Identify all the domains
        !            18: **             which must be saved to speed the index update.
        !            19: **     5. Set up specifics for each type of update.
        !            20: **     6. Write out the batch structure.
        !            21: **
        !            22: **     The following itemizes what is saved (in bytes):
        !            23: **     f(si) means it's a function of the secondary index keys
        !            24: **     space for newtid is saved only if there is a sec. index.
        !            25: **
        !            26: **                     mdDEL   mdREPL  mdAPP
        !            27: **
        !            28: **     oldtid          4       4       0
        !            29: **     oldtuple        f(si)   f(si)   0
        !            30: **     newtuple        0       tupwid  tupwid
        !            31: **     newtid          0       4       4
        !            32: */
        !            33: 
        !            34: openbatch(rel_desc, index_desc, mode)
        !            35: DESC   *rel_desc, *index_desc;
        !            36: int    mode;
        !            37: {
        !            38:        register struct si_doms *sp;
        !            39:        register DESC           *rel, *indx;
        !            40:        int                     i, j, saveoff, dom;
        !            41:        char                    *p, *batchname();
        !            42:        TID                     lotid, hitid;
        !            43:        struct index            itup;
        !            44:        extern char             *Database;
        !            45: 
        !            46:        if (Batchhd.mode_up)
        !            47:                return (-1);    /* batch already open */
        !            48:        rel = rel_desc;
        !            49:        indx = index_desc;
        !            50:        p = batchname();        /* form batch name */
        !            51: #      ifdef xATR1
        !            52:        if (tTf(25, -1))
        !            53:                printf("Openbatch %s\n", p);
        !            54: #      endif
        !            55:        if ((Batch_fp = creat(p, FILEMODE)) < 0)
        !            56:                syserr("openbatch:can't creat %s,%d", p, Batch_fp);
        !            57:        Batch_cnt = 0;
        !            58: 
        !            59:        /* copy the important info */
        !            60:        smove(Fileset, Batchbuf.file_id);
        !            61:        smove(Database, Batchhd.db_name);
        !            62:        bmove(rel->reldum.relid, Batchhd.rel_name, MAXNAME);
        !            63:        bmove(rel->reldum.relowner, Batchhd.userid, 2);
        !            64:        Batchhd.mode_up = mode;
        !            65:        Batchhd.num_updts = 0;
        !            66: 
        !            67:        /* clear out the secondary index domain flags */
        !            68:        sp = Batchhd.si;        /* sp points to the structure */
        !            69:        for (i = 1; i <= MAXDOM; i++)
        !            70:        {
        !            71:                sp->dom_size = 0;
        !            72:                sp++;
        !            73:        }
        !            74:        Batchhd.si_dcount = 0;
        !            75: 
        !            76:        /* set up the tid and tuple sizes by type of update */
        !            77:        /* assume size of tido, tidn, and tupn */
        !            78:        Batchhd.tido_size = 4;  /* assume old tid is needed */
        !            79:        Batchhd.tupo_size = 0;  /* assume old tuple isn't needed */
        !            80:        Batchhd.tupn_size = rel->reldum.relwid; /* assume new tuple is needed */
        !            81:        Batchhd.tidn_size = 4;  /* assume space is needed for new tid */
        !            82:        switch(Batchhd.mode_up)
        !            83:        {
        !            84: 
        !            85:          case mdDEL:
        !            86:                Batchhd.tupn_size = 0;  /* new tuple isn't needed */
        !            87:                Batchhd.tidn_size = 0;  /* new tid isn't needed */
        !            88: 
        !            89:          case mdREPL:
        !            90:                break;
        !            91: 
        !            92:          case mdAPP:
        !            93:                Batchhd.tido_size = 0;  /* old tid isn't needed */
        !            94:                break;
        !            95: 
        !            96:          default:
        !            97:                syserr("openbatch:mode %d", Batchhd.mode_up);
        !            98:        }
        !            99:        /* if there are no secondary indexes then tipn isn't needed, unless 
        !           100:        ** relation is ordered
        !           101:        */
        !           102:        if (rel->reldum.relindxd <= 0 && rel->reldum.reldim <= 0)
        !           103:                Batchhd.tidn_size = 0;
        !           104: 
        !           105:        /* if this relation has a secondary index or an ordered relation,
        !           106:        ** figure out what to save 
        !           107:        */
        !           108:        if ((rel->reldum.relindxd > 0 || rel->reldum.reldim > 0) && mode != mdAPP)
        !           109:        {
        !           110:                if (rel->reldum.relindxd > 0)
        !           111:                {
        !           112:                        setkey(indx, (char *) &itup, rel->reldum.relid, IRELIDP);
        !           113:                        setkey(indx, (char *) &itup, rel->reldum.relowner, IOWNERP);
        !           114:        
        !           115:                        if (find(indx, EXACTKEY, &lotid, &hitid, (char *) &itup))
        !           116:                                syserr("openbatch:bad find %.12s", rel);
        !           117:        
        !           118:                        /* check each entry in "index" relation for useful index */
        !           119:                        while(!(i = get(indx, &lotid, &hitid, (char *) &itup, TRUE)))
        !           120:                        {
        !           121:                                if (!bequal(itup.irelidp, rel->reldum.relid, MAXNAME) ||
        !           122:                                    !bequal(itup.iownerp, rel->reldum.relowner, 2))
        !           123:                                        continue;
        !           124:                                /* found one. copy the used domains */
        !           125:                                p = itup.idom;          /* get address of first */
        !           126:                                i = 6;
        !           127:                                while (i--)
        !           128:                                {
        !           129:                                        if ((dom = *p++) == 0)
        !           130:                                                break;  /* no more domains */
        !           131:                                        sp = &Batchhd.si[dom];
        !           132:                                        if (sp->dom_size != 0)
        !           133:                                                continue;       /* domain has already been done once */
        !           134:                                        Batchhd.si_dcount++;
        !           135:                                        Batchhd.tupo_size += rel->relfrml[dom] & I1MASK;
        !           136:                                        sp->rel_off = rel->reloff[dom];
        !           137:                                        sp->dom_size = rel->relfrml[dom] & I1MASK;
        !           138:                                }
        !           139:                        }
        !           140:                }
        !           141:                for (j = rel->reldum.reldim - 1; j >= 0; --j)
        !           142:                {
        !           143:                        /* point to lid field */
        !           144:                        sp = &Batchhd.si[rel->reldum.relatts - j];
        !           145:                        Batchhd.si_dcount++;
        !           146:                        Batchhd.tupo_size += LIDSIZE;
        !           147:                        sp->rel_off = rel->reloff[rel->reldum.relatts - j];
        !           148:                        sp->dom_size = LIDSIZE;
        !           149:                }
        !           150:                if (i < 0)
        !           151:                        syserr("openbatch:bad get index %d", i);
        !           152:                /* compute offsets of domains in saved "oldtuple" */
        !           153:                saveoff = 0;
        !           154:                sp = Batchhd.si;
        !           155:                i = Batchhd.si_dcount;
        !           156:                while (i--)
        !           157:                {
        !           158:                        /* skip to next domain */
        !           159:                        while (sp->dom_size == 0)
        !           160:                                sp++;
        !           161:                        sp->tupo_off = saveoff;
        !           162:                        saveoff += sp->dom_size;
        !           163:                        sp++;
        !           164:                }
        !           165:        }
        !           166:        wrbatch((char *) &Batchhd, sizeof Batchhd);
        !           167:        return (0);
        !           168: }
        !           169: /*
        !           170: **  ADDBATCH -- add to batch file
        !           171: */
        !           172: 
        !           173: addbatch(oldtid, newtuple, oldtuple)
        !           174: TID    *oldtid;
        !           175: char   *newtuple, *oldtuple;
        !           176: {
        !           177:        TID                     newtid;
        !           178:        register int            i;
        !           179:        register struct si_doms *sp;
        !           180:        register char           *old;
        !           181: 
        !           182: #      ifdef xATR1
        !           183:        if (tTf(25,3))
        !           184:                printf("addbatch\n");
        !           185: #      endif
        !           186:        if (Batchhd.mode_up == 0)
        !           187:                return (-1);
        !           188:        Batchhd.num_updts++;    /* increment the number of add batches */
        !           189:        old = oldtuple;
        !           190:        /* write out the old tid */
        !           191:        wrbatch((char *) oldtid, Batchhd.tido_size);
        !           192: 
        !           193:        /* write out each of the old tuple domains */
        !           194:        i = Batchhd.si_dcount;  /* i get the number of domains */
        !           195:        sp = Batchhd.si;        /* sp points to the domain structures */
        !           196: 
        !           197:        while (i--)
        !           198:        {
        !           199:                /* skip to the next domain */
        !           200:                while (sp->dom_size == 0)
        !           201:                        sp++;
        !           202: 
        !           203:                wrbatch(&old[sp->rel_off], sp->dom_size);
        !           204:                sp++;
        !           205:        }
        !           206: 
        !           207:        /* write out the new tuple */
        !           208:        wrbatch(newtuple, Batchhd.tupn_size);
        !           209: 
        !           210:        /* reserve space for the new tid. Init to -1 */
        !           211:        *((long *) &newtid) = -1;
        !           212:        wrbatch((char *) &newtid, Batchhd.tidn_size);
        !           213:        return (0);
        !           214: }
        !           215: /*
        !           216: **  CLOSEBATCH -- close batch file
        !           217: */
        !           218: 
        !           219: closebatch()
        !           220: {
        !           221:        register int    i;
        !           222:        extern long     lseek();
        !           223: 
        !           224:        if (Batchhd.mode_up == 0)
        !           225:                return (-1);
        !           226:        flushbatch();   /* write out any remainder */
        !           227:        if ((i = lseek(Batch_fp, 0l, 0)) == -1)
        !           228:                syserr("closebatch:seek %d", i);
        !           229:        wrbatch((char *) &Batchhd, sizeof Batchhd);     /* update num_updts */
        !           230:        flushbatch();
        !           231:        if (i = close(Batch_fp))
        !           232:                syserr("closebatch:close %d", i);
        !           233:        Batchhd.mode_up = 0;
        !           234:        return (0);
        !           235: }

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