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: }

Defined functions

addbatch defined in line 173; never used
closebatch defined in line 219; never used
openbatch defined in line 10; never used
Last modified: 1986-04-17
Generated: 2016-12-26
Generated by src2html V0.67
page hit count: 618
Valid CSS Valid XHTML 1.0 Strict