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(@(#)btreeupdate.c	8.3	1/18/85)
  11: 
  12: btreeupdate(r)
  13: register DESC   *r;
  14: {
  15:     register char   *p;
  16:     register int    i;
  17:     int     j, domcnt, mode, dom;
  18:     long        oldtid, newtid;
  19:     long        tupcnt;
  20:     long        uptid;
  21:     char        oldtup[MAXTUP], newtup[MAXTUP];
  22:     char        oldkey[2 * LIDSIZE], newkey[2 * LIDSIZE];
  23:     char        dumtup[2 * LIDSIZE];
  24:     struct relation rkey, rtup;
  25:     DESC        b_desc;
  26:     extern DESC Reldes;
  27:     TID     tid, btid;
  28:     char        file[MAXNAME + 4], btree[MAXNAME + 4];
  29:     long        oldlid[MAXLID], newlid[MAXLID];
  30:     struct locator  tidpos;
  31:     long        l;
  32:     extern int  Btree_fd;
  33:     char        *tp;
  34:     long        page, t;
  35:     int     lidwid;
  36:     int     dellevel;
  37:     int     compare;
  38: 
  39: #	ifdef xZTR1
  40:     if (tTf(47, 0))
  41:         printf("BTREEUPDATE\n");
  42: #	endif
  43: 
  44:     mode = Batchhd.mode_up;
  45:     Batch_dirty = FALSE;
  46:     opencatalog("relation", OR_READ);
  47:     capital(trim_relname(r->reldum.relid), file);
  48:     setkey(&Reldes, &rkey, file, RELID);
  49:     setkey(&Reldes, &rkey, r->reldum.relowner, RELOWNER);
  50: 
  51:     if (!getequal(&Reldes, &rkey, &rtup, &tid))
  52:     {
  53:         if (i = openr(&b_desc, OR_WRITE, file))
  54:             syserr("btreeupdate:can't openr %.12s %d", file, i);
  55:         /* reposition batch file to the beginning. */
  56:         if ((i = lseek(Batch_fp, 0L, 0)) < 0)
  57:             syserr("secupdate:seek %d %d", i, Batch_fp);
  58:         Batch_cnt = BATCHSIZE;
  59:         getbatch(&Batchhd, sizeof Batchhd); /* reread header */
  60: 
  61:         ingresname(r->reldum.relid, r->reldum.relowner, file);
  62:         btreename(file, btree);
  63:         if ((Btree_fd = open(btree, O_RDWR)) < 0)
  64:             syserr("btreeupdate: can't open %s", btree);
  65: 
  66:         /*
  67: 		** Start reading the batch file and updating
  68: 		** the secondary indexes.
  69: 		*/
  70:         l = r->reladds;
  71:         tupcnt = Batchhd.num_updts;
  72:         lidwid = LIDSIZE * r->reldum.reldim;
  73:         dellevel = r->reldum.reldim - 1;
  74:         for (j = 0; j < r->reldum.reldim; ++j)
  75:         {
  76:             if (Repl_cnt[j] > 0)
  77:             {
  78:                 dellevel = j;
  79:                 break;
  80:             }
  81:         }
  82:         while (tupcnt--)
  83:         {
  84:             getbatch(&oldtid, Batchhd.tido_size);
  85:             getbatch(oldtup, Batchhd.tupo_size);
  86:             getbatch(newtup, Batchhd.tupn_size);
  87:             getbatch(&newtid, Batchhd.tidn_size);
  88: 
  89:             clearkeys(&b_desc);
  90:             /* if this is a replace or append form the new key */
  91:             if (mode != mdDEL)
  92:             {
  93:                 if (newtid < 0)
  94:                     continue;
  95:                 tp = newtup + Batchhd.tupn_size - lidwid;
  96:                 bmove(tp, newlid, lidwid);
  97:                 if (mode == mdREPL)
  98:                 {
  99:                     if (newlid[r->reldum.reldim - 1] < 0)
 100:                         continue;
 101:                     tp = oldtup + Batchhd.tupo_size - lidwid;
 102:                     bmove(tp, oldlid, lidwid);
 103:                     compare = 0;
 104:                     for (j = 0; j < r->reldum.reldim; ++j)
 105:                     {
 106:                         if (newlid[j] > oldlid[j])
 107:                         {
 108:                             compare = 1;
 109:                         }
 110:                         if (newlid[j] != oldlid[j])
 111:                             break;
 112:                     }
 113:                     if (compare == 1)
 114:                     {
 115:                         for (j = dellevel - 1; j >= 0; --j)
 116:                         {
 117:                             if (newlid[j] != oldlid[j])
 118:                             {
 119:                                 compare = 0;
 120:                                 break;
 121:                             }
 122:                         }
 123:                     }
 124:                     if (compare == 1)
 125:                         /* adjust due to deleted lids */
 126:                         newlid[dellevel] -= Repl_cnt[dellevel];
 127:                 }
 128:                 page  =  RT;
 129:                 for (j = 0; j < r->reldum.reldim; ++j)
 130:                 {
 131:                     if (!newlid[j])
 132:                         newlid[j] = 1;
 133:                     t = get_tid(page, newlid[j], &tidpos);
 134:                     page = t;
 135:                 }
 136:                 if (page != newtid)
 137:                 {
 138:                     /* try linear search of btree */
 139:                     lin_search(r->reldum.reldim, newtid, &btid, newlid, Batchhd.num_updts);
 140:                     setkey(&b_desc, newkey, &newtid, 1);
 141:                 }
 142:                 else
 143:                 {
 144:                     setkey(&b_desc, newkey, &newtid, 1);
 145:                     stuff_page(&btid, &tidpos.pageno);
 146:                     btid.line_id = tidpos.page.node.leafnode.tid_loc[tidpos.offset];
 147:                 }
 148:                 setkey(&b_desc, newkey, &btid, 2);
 149: #				ifdef xZTR1
 150:                 if(tTf(47,0))
 151:                 {
 152:                     printf("new key\n");
 153:                     printup(&b_desc, newkey);
 154:                 }
 155: #				endif
 156:             }
 157: 
 158:             /* if this is delete or replace form the old key */
 159:             if (mode != mdAPP)
 160:             {
 161:                 setkey(&b_desc, oldkey, &oldtid, 1);
 162: #				ifdef xZTR1
 163:                 if(tTf(47,0))
 164:                 {
 165:                     printf("old key\n");
 166:                     printup(&b_desc, oldkey);
 167:                 }
 168: #				endif
 169:             }
 170: 
 171:             switch (mode)
 172:             {
 173: 
 174:               case mdDEL:
 175:                 if (i = getequal(&b_desc, oldkey, dumtup, &uptid))
 176:                 {
 177:                     if (i > 0)
 178:                         break;
 179:                     syserr("btreeupdate:getequal %d", i);
 180:                 }
 181:                 if ((i = delete(&b_desc, &uptid)) < 0)
 182:                     syserr("btreeupdate:delete %d", i);
 183:                 break;
 184: 
 185:               case mdREPL:
 186:                 /* btree tid not provided */
 187:                 b_desc.relgiven[2] = 0;
 188:                 if (i = getequal(&b_desc, oldkey, dumtup, &uptid))
 189:                 {
 190:                     if (Batch_recovery && i > 0)
 191:                         goto btreeinsert;
 192:                     printup(&b_desc, oldkey);
 193:                     syserr("btreeupdate:getequal-repl %d", i);
 194:                 }
 195:                 /* btree tid provided */
 196:                 b_desc.relgiven[2] = 1;
 197:                 if (i = replace(&b_desc, &uptid, newkey, TRUE))
 198:                 {
 199:                     /* if newtuple is dup of old, ok */
 200:                     if (i == 1)
 201:                         break;
 202:                     /* if this is recovery and old tid not there, try an insert */
 203:                     if (Batch_recovery && i == 2)
 204:                         goto btreeinsert;
 205:                     syserr("secupdate:replace %d", i);
 206:                 }
 207:                 break;
 208: 
 209:               case mdAPP:
 210:               btreeinsert:
 211:                 if ((i = insert(&b_desc, &uptid, newkey, TRUE)) < 0)
 212:                     syserr("secupdate:insert %d", i);
 213:             }
 214:         }
 215:         if (i = closer(&b_desc))
 216:             syserr("btreeupdate:closer %.12s %d", file, i);
 217:         close(Btree_fd);
 218:     }
 219:     if (i < 0)
 220:         syserr("btreeupdate:bad get from indexes %d", i);
 221: }

Defined functions

btreeupdate defined in line 10; used 1 times
Last modified: 1986-04-17
Generated: 2016-12-26
Generated by src2html V0.67
page hit count: 1184
Valid CSS Valid XHTML 1.0 Strict