![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to nmodify.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / ingres / source / dbu|
Return to nmodify.c CVS log | Up to [CSRG BSD Unix] / 42BSD / ingres / source / dbu |
1.1 root 1: # include <pv.h>
2: # include <ingres.h>
3: # include <aux.h>
4: # include <access.h>
5: # include <batch.h>
6: # include <lock.h>
7: # include <fileio.h>
8: # include <opsys.h>
9: # include <func.h>
10: # include <sccs.h>
11:
12: SCCSID(@(#)nmodify.c 7.2 6/4/83)
13:
14: extern short tTdbu[];
15: extern int modify();
16: extern int null_fn();
17:
18: struct fn_def ModifyFn =
19: {
20: "MODIFY",
21: modify,
22: null_fn,
23: null_fn,
24: NULL,
25: 0,
26: tTdbu,
27: 100,
28: 'Z',
29: 0
30: };
31:
32: /*
33: ** MODIFY -- converts any relation to the specified
34: ** storage structure
35: **
36: ** arguments:
37: ** 0 - relation name
38: ** 1 - storage structure ("heap", "cheap", "hash", "chash",
39: ** "isam", "cisam", "btree")
40: ** 2 - "name" for attribute names, or "num" for numbers
41: ** 3 - key1
42: ** 4 - key2
43: ** .
44: ** .
45: ** i - null
46: ** i+1 - option name (e.g., "fillfactor")
47: ** i+2 - option value
48: ** .
49: ** .
50: **
51: ** If all the options default, parameter i -> pc are omitted.
52: ** If no keys are provided, parameter 2 is omitted.
53: **
54: ** History:
55: ** 12/28/78 (rse) -- added descending sort option
56: ** 9/12/78 -- (marc) modified to give error message
57: ** 5519 when someone tries to modify a view.
58: ** For this I split the openr mode 0 into 2,
59: ** mode -1 then -2.
60: ** 9/25/78 -- (marc) 2 openr's replaced by one
61: ** as view error code put in openr
62: **
63: */
64:
65: int F_fac, Mn_pages, Mx_pages;
66:
67: struct modtab
68: {
69: char *type;
70: char newrelspec;
71: char yeskeys;
72: char sortit;
73: char yes_seq;
74: int f_fac;
75: int mn_pages;
76: int mx_pages;
77: };
78:
79:
80: struct modtab Modtab[] =
81: {
82: /* type spec keys sort seq ffac min max */
83:
84: "heap", M_HEAP, FALSE, FALSE, FALSE, 0, 0, 0,
85: "cheap", -M_HEAP,FALSE, FALSE, FALSE, 0, 0, 0,
86: "hash", M_HASH, TRUE, TRUE, FALSE, 50, 10, -1,
87: "chash", -M_HASH,TRUE, TRUE, FALSE, 75, 1, -1,
88: "isam", M_ISAM, TRUE, TRUE, FALSE, 80, 0, 0,
89: "cisam", -M_ISAM,TRUE, TRUE, FALSE, 100, 0, 0,
90: "btree", M_BTREE, TRUE, TRUE, FALSE, 66, 0, 0,
91: "heapsort", M_HEAP, TRUE, TRUE, TRUE, 0, 0, 0,
92: "cheapsort", -M_HEAP,TRUE, TRUE, TRUE, 0, 0, 0,
93: "truncated", M_TRUNC,FALSE, FALSE, FALSE, 0, 0, 0,
94: 0
95: };
96:
97: struct mod_info
98: {
99: char outfile[MAXNAME + 4]; /* result file filled by ksort */
100: char formfile[MAXNAME + 4]; /* file with descriptor for ksort */
101: char infile[MAXNAME + 4]; /* input file for ksort (relation itself */
102: char reltemp[MAXNAME + 4]; /* file holding new relation */
103: char spfile[MAXNAME + 4], spflag; /* isam spool file for overflow */
104: };
105:
106: struct mod_info Mod_info;
107:
108: modify(pc, pv)
109: int pc;
110: PARM *pv;
111: {
112: register int i;
113: register char *rname;
114: register struct modtab *mp;
115: int sorted;
116: DESC dold, dnew;
117: long temptid;
118: extern int Noupdt;
119:
120:
121: # ifdef xZTR1
122: if (tTf(34, -1))
123: {
124: printf("enter modify\n");
125: prvect(pc, pv);
126: }
127: # endif
128:
129: pv[pc].pv_val.pv_str = NULL;
130:
131: /* check for nice parameters */
132: if (pc < 2)
133: syserr("MODIFY: pc %d", pc);
134:
135: /* save relation name for error messages */
136: rname = (pv++)->pv_val.pv_str; /* *pv now pointes to storage spec */
137:
138: /* check for good relation */
139: i = openr(&dold, 0, rname);
140: if (i == AMOPNVIEW_ERR)
141: return (error(5519, rname, 0));
142: if (i > 0)
143: /* reln does not exist */
144: return (error(5500, rname, 0));
145: else if (i < 0)
146: syserr("MODIFY: openr (%.14s) %d", rname, i);
147: /* can only modify a relation you own and isn't a sys rel */
148:
149: if (!bequal(Usercode, dold.reldum.relowner, 2))
150: {
151: i = 5501;
152: }
153: if ((dold.reldum.relstat & S_CATALOG) && Noupdt)
154: {
155: i = 5504;
156: }
157: if (i)
158: {
159: closer(&dold);
160: return (error(i, rname, 0));
161: }
162:
163: /*
164: ** Form descriptor for new relation. Here we need to
165: ** separate the pages from the old and new relations.
166: ** Since pages are identified by the TID of the relation
167: ** relation tuple, both old and new have the same identifiers.
168: ** To avoid this problem, a special TID is hand crafted for
169: ** the new relation.
170: */
171: bmove(&dold, &dnew, sizeof dnew);
172: dnew.reltid.line_id = (char) -2; /* choose impossible reltid */
173:
174: /* In case of an interrupt from a previous modify,
175: ** there might be pages around. Get rid of them.
176: */
177: cleanrel(&dnew);
178:
179: ingresname(dold.reldum.relid, dold.reldum.relowner, Mod_info.infile);
180:
181: /* scan for entry in relspec table */
182: for (mp = Modtab; mp->type; mp++)
183: if (sequal(mp->type, pv->pv_val.pv_str))
184: break;
185:
186: /* if not found, error */
187: if (!mp->type)
188: {
189: closer(&dold);
190: return (error(5510, rname, pv->pv_val.pv_str, 0)); /* bad relspec */
191: }
192: dnew.reldum.relspec = mp->newrelspec;
193:
194: if (dnew.reldum.relspec == M_TRUNC)
195: dnew.reldum.relspec = M_HEAP;
196:
197: pv++; /* now points to first parameter */
198:
199: F_fac = mp->f_fac;
200: Mn_pages = mp->mn_pages;
201: Mx_pages = mp->mx_pages;
202:
203: /* get the key domains information */
204: if (i = getkeys(&pv, rname, &dnew, mp))
205: {
206: closer(&dold);
207: return (i); /* user error */
208: }
209:
210: /* get fillfactor and other options if any */
211: if (i = getfill(pv, rname, mp))
212: {
213: closer(&dold);
214: return (i); /* user error */
215: }
216:
217:
218: /* lock the relation relation */
219: if (Lockrel)
220: {
221: get_p_tid(&dold, &temptid);
222: setrll(A_SLP, temptid, M_EXCL);
223: }
224:
225: /* compute new relation parameters & build descriptor */
226: make_newrel(&dnew);
227:
228: if (sorted = (mp->sortit && (dold.reldum.reltups != 0)))
229: sortrel(&dold, &dnew);
230:
231: /* physically create the new relation */
232: if (formatpg(&dnew, (dnew.reldum.relspec == M_BTREE) ? dnew.reldum.relprim + 1 : dnew.reldum.relprim) != 0)
233: syserr("modify: formatpg");
234:
235: /* clear relgiven field; if heap remove any keys */
236: clearkeys(&dnew);
237: if (abs(dnew.reldum.relspec) == M_HEAP)
238: for (i = 1; i <= dnew.reldum.relatts; i++)
239: dnew.relxtra[i] = 0;
240:
241: if (mp->newrelspec != M_TRUNC)
242: fill_rel(&dold, &dnew, sorted);
243:
244: closer(&dold); /* error return is impossible */
245: if (abs(dnew.reldum.relspec) == M_ISAM)
246: {
247: if (i = bldindex(&dnew))
248: syserr("bldindex: %.14s %d", dnew.reldum.relid, i);
249: unspool(&dnew);
250: }
251: else if (dnew.reldum.relspec == M_BTREE)
252: {
253: if (i = bldbindex(&dnew))
254: syserr("bldbindex: %.14s %d", dnew.reldum.relid, i);
255: }
256:
257: /*
258: ** New relation is now complete. The system relations need to
259: ** be updated. First destroy all buffers with pages from the
260: ** new relation.
261: */
262: if (i = cleanrel(&dnew))
263: syserr("modify:clean new %d,%.14s", i, dnew.reldum.relid);
264:
265: fill_batch(&dold, &dnew);
266:
267: /*
268: ** Close the file for the new relation. This must be
269: ** done after the fill_batch in case we are modifing
270: ** the attribute relation.
271: */
272: close(dnew.relfp);
273: dnew.relopn = 0;
274: ruboff("modify");
275: modupdate();
276: rubon();
277:
278: if (Lockrel)
279: unlrl(temptid);
280:
281: # ifdef xZTM
282: if (tTf(35, 1))
283: timtrace(16, 0);
284: # endif
285: return (0);
286: }
287:
288:
289: getkeys(ppv, relname, desc, mp)
290: PARM **ppv;
291: char *relname;
292: DESC *desc;
293: struct modtab *mp;
294: {
295: register PARM *pv;
296: register char *cp;
297: register DESC *d;
298: int namemode, sort_only, as_ds;
299: int i, keyno, keywid;
300: struct attribute attkey, atttup;
301: TID tid;
302: extern DESC Attdes;
303:
304: pv = *ppv; /* copy list of params */
305:
306: d = desc;
307:
308: /* zero key info */
309: for (i = 0; i <= d->reldum.relatts; i++)
310: d->relxtra[i] = d->relgiven[i] = 0;
311:
312: /* determine whether there are any keys at all */
313: keyno = 0;
314: keywid = 0;
315: sort_only = FALSE;
316: cp = pv->pv_val.pv_str;
317:
318: if (cp == NULL || *cp == NULL)
319: {
320: /* no key information. default as needed */
321: if (mp->yeskeys)
322: {
323: cp = "\1"; /* default to first key */
324: namemode = FALSE;
325: }
326: else
327: pv++; /* point one to far */
328: }
329: else
330: {
331: /* check for name mode */
332: if (namemode = sequal(cp, "name"))
333: {
334:
335: /* check attribute names, and convert them to numbers */
336: opencatalog("attribute", 0);
337: setkey(&Attdes, &attkey, Mod_info.infile, ATTRELID);
338: setkey(&Attdes, &attkey, Usercode, ATTOWNER);
339: }
340: pv++; /* inc to next key */
341: cp = (pv++)->pv_val.pv_str;
342: }
343:
344:
345: /* scan for attribute names */
346: for (; cp != NULL; cp = (pv++)->pv_val.pv_str)
347: {
348: /* check for separator between keys & options */
349: if (*cp == NULL)
350: {
351: pv++; /* point two past NULL */
352: break;
353: }
354:
355: if (namemode)
356: {
357: /* check for "sort only" attribute */
358: if (*cp == '#')
359: {
360: cp++; /* inc to start of name */
361: sort_only = TRUE;
362: }
363:
364: /* check for ascending/descending modifier */
365: if ((as_ds = modseqkey(cp, relname, mp->yes_seq)) > 0)
366: return (as_ds); /* error */
367:
368: setkey(&Attdes, &attkey, cp, ATTNAME);
369: i = getequal(&Attdes, &attkey, &atttup, &tid);
370: if (i < 0)
371: syserr("MODIFY: geteq(att) %d", i);
372: if (i > 0)
373: {
374: return (error(5511, relname, cp, 0)); /* bad att name */
375: }
376: i = atttup.attid;
377: }
378: else
379: {
380: i = *cp;
381: as_ds = 0;
382: }
383:
384: /* add new key to descriptor */
385: keyno++;
386: if (!sort_only)
387: {
388: d->relxtra[i] = keyno;
389: keywid += (d->relfrml[i] & I1MASK);
390: }
391: if (d->relgiven[i])
392: return (error(5507, relname, cp, 0)); /* duplicate attribute */
393: d->relgiven[i] = as_ds == 0 ? keyno : -keyno;
394: }
395: pv--; /* back up one to point to "-1" terminator */
396:
397:
398: if (abs(d->reldum.relspec) == M_ISAM && keywid > (MAXTUP / 2 - 4))
399: {
400: return (error(5508, relname, iocv(keywid), 0));
401: }
402:
403: /* if a heap, there can be no keys */
404: if (!mp->yeskeys && keyno != 0)
405: {
406: return (error(5502, relname, mp->type, 0)); /* no keys allowed on heap */
407: }
408:
409: /* fill out default sort on remainder of keys */
410: if (mp->yeskeys)
411: for (i = 1; i <= d->reldum.relatts; i++)
412: if (d->relgiven[i] == 0)
413: d->relgiven[i] = ++keyno;
414: *ppv = pv;
415: return (0);
416: }
417:
418:
419: modseqkey(domain, relname, seq_ok)
420: char *domain;
421: char *relname;
422: int seq_ok;
423: {
424: register char *cp, c;
425: register int ret;
426:
427: ret = 0;
428:
429: for (cp = domain; c = *cp++; )
430: if (c == ':')
431: break;
432:
433: if (c != '\0')
434: {
435: /* replace ":" with null */
436: *(cp - 1) = '\0';
437:
438: /* verify sequence is valid */
439: if (!seq_ok)
440: ret = error(5520, relname, cp, domain, 0);
441: else if (sequal("descending", cp) || sequal("d", cp))
442: ret = -1;
443: else if (!(sequal("ascending", cp) || sequal("a", cp)))
444: ret = error(5518, relname, cp, domain, 0);
445: }
446:
447: return (ret);
448: }
449: /*
450: ** GETFILL -- Get fill factor and minimum pages parameters
451: ** from argument list, convert them from ascii to integer
452: ** and store them in global variables. If the global
453: ** variable for the corresponding parameter is zero,
454: ** it means that that parameter is not allowed and an
455: ** error is generated.
456: */
457:
458: getfill(pvx, rel, mp)
459: PARM *pvx;
460: char *rel;
461: struct modinfo *mp;
462: {
463: register PARM *pv;
464: register char *p1;
465: register int err;
466: char *p2;
467: int fill_flag, min_flag, max_flag;
468:
469: pv = pvx;
470: err = 0;
471: fill_flag = min_flag = max_flag = FALSE;
472:
473: while ((p1 = (pv++)->pv_val.pv_str) != NULL)
474: {
475: p2 = (pv++)->pv_val.pv_str;
476: if (sequal(p1, "fillfactor"))
477: {
478: if (F_fac == 0 || fill_flag)
479: {
480: err = 5512;
481: break;
482: }
483: p1 = p2;
484: F_fac = atoi(p1);
485: if (F_fac > 100 || F_fac < 1)
486: {
487: err = 5513;
488: break;
489: }
490: fill_flag = TRUE;
491: continue;
492: }
493: if (sequal(p1, "minpages"))
494: {
495: if (Mn_pages == 0 || min_flag)
496: {
497: err = 5512;
498: break;
499: }
500: p1 = p2;
501: Mn_pages = atoi(p1);
502: if (Mn_pages < 1)
503: {
504: err = 5514;
505: break;
506: }
507: if (max_flag && (Mn_pages > Mx_pages))
508: {
509: err = 5517;
510: break;
511: }
512: min_flag = TRUE;
513: continue;
514: }
515: if (sequal(p1, "maxpages"))
516: {
517: if (Mx_pages == 0 || max_flag)
518: {
519: err = 5512;
520: break;
521: }
522: p1 = p2;
523: Mx_pages = atoi(p1);
524: if (Mx_pages < 1)
525: {
526: err = 5516;
527: break;
528: }
529: if (min_flag && (Mn_pages > Mx_pages))
530: {
531: err = 5517;
532: break;
533: }
534: max_flag = TRUE;
535: continue;
536: }
537: err = 5515;
538: break;
539: }
540: if (err)
541: return (error(err, rel, p1, 0));
542: return (0);
543: }
544: /*
545: ** MAKE_NEWREL -- Create a file for the modified relation
546: ** and build one or more primary pages for the
547: ** relation based on its storage structure and the
548: ** number of tuples it must hold.
549: */
550:
551: make_newrel(descx)
552: DESC *descx;
553: {
554: register DESC *desc;
555: register int i, tups_p_page;
556:
557: desc = descx;
558: concat(MODTEMP, Fileset, Mod_info.reltemp);
559: close(creat(Mod_info.reltemp, FILEMODE));
560: if ((desc->relfp = open(Mod_info.reltemp, 2)) < 0)
561: syserr("MAKE_NEWREL: open %.14s %d", Mod_info.reltemp, desc->relfp);
562: desc->relopn = (desc->relfp + 1) * -5;
563: desc->reldum.relprim = 1;
564: if (abs(desc->reldum.relspec) == M_HASH && F_fac > 0 && Mn_pages > 0)
565: {
566: /*
567: ** Determine the number of primary pages. The following
568: ** first determines the number of tuples/page which the
569: ** relation should have in order to get the requested
570: ** fillfactor. Then that number is divided into the
571: ** number of tuples to get the number of primary pages.
572: ** To avoid round off, it must guaranteed that the
573: ** number of tuples per page must be at least 1.
574: **
575: ** primary_pages = #tuples / (#tuples/page * fillfactor)
576: */
577: tups_p_page = (((MAXTUP+2) / (desc->reldum.relwid+2)) * F_fac) / 100;
578: if (tups_p_page == 0)
579: tups_p_page = 1;
580: /* we add one to simulate a ceiling function */
581: desc->reldum.relprim = desc->reldum.reltups / tups_p_page + 1;
582: if (desc->reldum.relprim < Mn_pages)
583: desc->reldum.relprim = Mn_pages;
584: if (Mx_pages > 0 && desc->reldum.relprim > Mx_pages)
585: desc->reldum.relprim = Mx_pages;
586: # ifdef xZTR1
587: if (tTf(36, 0))
588: printf("using %ld prim pages\n", desc->reldum.relprim);
589: # endif
590: }
591: desc->reldum.reltups = 0;
592: return (0);
593: }
594: /*
595: ** SORTREL - Call KSORT to sort the given relation. SORTREL
596: ** sets up the descriptor struct specifying the sort
597: ** keys and tells KSORT whether or not the hash key should
598: ** be included as a sort key.
599: */
600:
601: sortrel(odesc, descx)
602: DESC *odesc, *descx;
603: {
604: extern char *Pathname;
605: register DESC *desc;
606: register int fp, i;
607: char savespec;
608: char buf[50];
609:
610: desc = descx;
611: concat(ISAM_SORTED, Fileset, Mod_info.outfile);
612: if (close(creat(Mod_info.outfile, FILEMODE)))
613: syserr("SORTREL: creat %.14s", Mod_info.outfile);
614: concat(ISAM_DESC, Fileset, Mod_info.formfile);
615: if ((fp = creat(Mod_info.formfile, FILEMODE)) < 0)
616: syserr("SORTREL: creat %.14s %d", Mod_info.formfile, fp);
617: if (abs(desc->reldum.relspec) == M_HASH)
618: {
619: /* sort on hash bucket first */
620: desc->relgiven[0] = 1;
621: for (i = 1; i <= desc->reldum.relatts; i++)
622: desc->relgiven[i]++;
623: }
624: savespec = desc->reldum.relspec;
625: desc->reldum.relspec = odesc->reldum.relspec;
626:
627: if (write(fp, desc, sizeof *desc) != sizeof *desc)
628: syserr("SORTREL: desc write err");
629: close(fp);
630: desc->reldum.relspec = savespec;
631:
632: i = fork();
633: if (i == -1)
634: syserr("SORTREL: fork");
635: if (i == 0)
636: {
637: for (i = 3; i < NOFILE; i++)
638: close(i);
639: concat(Pathname, "/bin/ksort", buf);
640: execl(buf, buf, Fileset, iocv(tTf(37, -1)),
641: Mod_info.formfile, Mod_info.infile,
642: Mod_info.outfile, 0);
643: syserr("SORTREL: exec %s", buf);
644: }
645:
646: # ifdef xZTR1
647: tTfp(37, 1, "SORTREL: after execl; pid = %d\n", i);
648: # endif
649:
650: if (fp = fullwait(i, "modify")) /* wait for ksort to complete */
651: syserr("modify:ksort failed %d", fp);
652:
653: # ifdef xZTR1
654: tTfp(37, 2, "SORTREL: after fullwait\n");
655: # endif
656:
657: unlink(Mod_info.formfile);
658: return (0);
659: }
660: /*
661: ** FILL_REL -- Fill the new relation with tuples from either
662: ** the old relation or the output file of KSORT.
663: */
664:
665: fill_rel(sdescx, descx, sortit)
666: DESC *sdescx, *descx;
667: char sortit;
668: {
669: register DESC *sdesc, *desc;
670: register int i;
671: char tup_buf[MAXTUP], last_tup[MAXTUP];
672: char junk[4], newreltype, anytups, chkdups;
673: char sortbuf[IOBUFSIZ], spoolbuf[IOBUFSIZ];
674: int need, j;
675: long lnum;
676: TID tid, stid, stidlim;
677: FILE *fp, *spfp;
678:
679: sdesc = sdescx;
680: desc = descx;
681: newreltype = abs(desc->reldum.relspec);
682: if (sortit)
683: {
684: if ((fp = fopen(Mod_info.outfile, "read", sortbuf)) == NULL)
685: syserr("FILL_REL: fopen %.14s", Mod_info.outfile);
686: }
687: else
688: {
689: cleanrel(sdesc); /* make sure each page is read fresh */
690: find(sdesc, NOKEY, &stid, &stidlim);
691: }
692: if (newreltype == M_ISAM)
693: {
694: lnum = 0;
695: stuff_page(&tid, &lnum);
696: tid.line_id = 0;
697: get_page(desc, &tid);
698: concat(ISAM_SPOOL, Fileset, Mod_info.spfile);
699: /* assume that spool file is not needed */
700: spfp = NULL;
701: Mod_info.spflag = FALSE;
702: if (F_fac == 0)
703: F_fac = 100;
704: /* setup relgiven field for kcompare later on */
705: for (i = 1; i <= desc->reldum.relatts; i++)
706: desc->relgiven[i] = desc->relxtra[i];
707: }
708: else if (newreltype == M_BTREE)
709: {
710: lnum = 1;
711: stuff_page(&tid, &lnum);
712: tid.line_id = 0;
713: get_page(desc, &tid);
714: concat(ISAM_SPOOL, Fileset, Mod_info.spfile);
715: /* assume that spool file is not needed */
716: spfp = NULL;
717: Mod_info.spflag = FALSE;
718: if (F_fac == 0)
719: F_fac = 100;
720: /* setup relgiven field for kcompare later on */
721: for (i = 1; i <= desc->reldum.relatts; i++)
722: desc->relgiven[i] = desc->relxtra[i];
723: }
724: desc->reladds = 0;
725: anytups = FALSE;
726: chkdups = !sortit;
727: for (;;)
728: {
729: if (sortit)
730: {
731: i = fread(fp, tup_buf, desc->reldum.relwid);
732: if (i == 0)
733: break;
734: if (i != desc->reldum.relwid)
735: syserr("FILL_REL: fread A %d", i);
736: if (newreltype == M_HASH)
737: if (fread(fp, junk, 4) != 4)
738: syserr("FILL_REL: fread B");
739: }
740: else
741: {
742: # ifdef xZTR2
743: if (tTf(36, 1))
744: {
745: printf("FILL_REL: stid ");
746: dumptid(&stid);
747: printf("FILL_REL: stidlim ");
748: dumptid(&stidlim);
749: }
750: # endif
751: i = get(sdesc, &stid, &stidlim, tup_buf, TRUE);
752: # ifdef xZTR2
753: if (tTf(36, 1))
754: {
755: printf("FILLREL: get %d ", i);
756: printup(sdesc, tup_buf);
757: }
758: # endif
759: if (i < 0)
760: syserr("FILL_REL: get %d", i);
761: if (i == 1)
762: break;
763: }
764: if (newreltype != M_ISAM && newreltype != M_BTREE)
765: {
766: if ((i = insert(desc, &tid, tup_buf, chkdups)) < 0)
767: syserr("FILL_REL: insert %d", i);
768: # ifdef xZTR2
769: if (tTf(36, 2))
770: {
771: printf("FILL_REL: insert ");
772: printup(desc, tup_buf);
773: printf("FILL_REL: insert ret %d at", i);
774: dumptid(&tid);
775: }
776: # endif
777: continue;
778: }
779: if (anytups)
780: i = kcompare(desc, tup_buf, last_tup);
781: else
782: {
783: anytups = TRUE;
784: i = 1;
785: }
786: bmove(tup_buf, last_tup, desc->reldum.relwid);
787: need = canonical(desc, tup_buf);
788: if (i == 0 && need > space_left(Acc_head))
789: {
790: /* spool out this tuple. will go on overflow page later */
791: if (spfp == NULL)
792: {
793: if ((spfp = fopen(Mod_info.spfile, "write", spoolbuf)) == NULL)
794: syserr("FILL_REL: fopen %.14s", Mod_info.spfile);
795: Mod_info.spflag = TRUE;
796: }
797: if (fwrite(spfp, tup_buf, desc->reldum.relwid) != desc->reldum.relwid)
798: syserr("FILL_REL: putb spool");
799: continue;
800: }
801: j = (100 - F_fac) * MAXTUP / 100;
802: if (j < need)
803: j = need;
804: if (i != 0 && j > space_left(Acc_head))
805: {
806: if (i = add_prim(desc, &tid))
807: syserr("FILL_REL: force ovflo %d", i);
808: }
809: tid.line_id = newlino(need);
810: put_tuple(&tid, Acctuple, need);
811: desc->reladds++;
812: }
813: if (sortit)
814: {
815: fclose(fp);
816: unlink(Mod_info.outfile);
817: }
818: if (newreltype == M_ISAM || newreltype == M_BTREE)
819: {
820: if (i = pageflush(Acc_head))
821: syserr("fill_rel:pg clean %d", i);
822: if (spfp != NULL)
823: fclose(spfp);
824: }
825: desc->reldum.reltups = desc->reladds;
826: desc->reladds = 0;
827: return (0);
828: }
829:
830:
831: bldindex(dx)
832: DESC *dx;
833: {
834: register DESC *d;
835: register TID *tid;
836: register int tmp;
837: TID tidx;
838: struct accbuf dirbuf;
839: int keywid, level, savespec, keyx[MAXDOM];
840: int offset, len;
841: char tuple[MAXTUP], temptup[MAXTUP], *key;
842: long pageid, start, stop, newstart, newstop;
843:
844: d = dx;
845: tid = &tidx;
846: for (tmp = 0; tmp < MAXDOM; tmp++)
847: keyx[tmp] = 0;
848: for (tmp = 1; tmp <= d->reldum.relatts; tmp++)
849: if (d->relxtra[tmp] > 0)
850: {
851: keyx[d->relxtra[tmp] - 1] = tmp;
852: keywid += d->relfrml[tmp] & I1MASK;
853: }
854:
855: /* Determine the last page of the relation. This will
856: ** only work if all pages have been written out. Fill_rel
857: ** must guarantee that all pages have been written
858: */
859: level = 0;
860: last_page(d, tid, 0);
861: pluck_page(tid, &stop);
862: start = 0;
863: dirbuf.filedesc = d->relfp;
864: dirbuf.rel_tupid = d->reltid.ltid;
865: savespec = d->reldum.relspec;
866: for (;;)
867: {
868: # ifdef xZTR2
869: if (tTf(38, 7))
870: printf("isam: level %d\n", level);
871: # endif
872: dirbuf.ovflopg = start;
873: dirbuf.mainpg = level;
874: dirbuf.thispage = stop + 1;
875: dirbuf.linetab[0] = (short) (dirbuf.firstup - (char *) &dirbuf);
876: offset = dirbuf.linetab[0];
877: dirbuf.bufstatus = BUF_DIRTY | BUF_DIRECT;
878:
879: dirbuf.nxtlino = 0;
880: newstart = stop + 1;
881: newstop = newstart;
882: for (pageid = start; pageid <= stop; pageid++)
883: {
884: # ifdef xZTR2
885: if (tTf(38, 8))
886: printf("isam:get key from %ld\n", pageid);
887: # endif
888: stuff_page(tid, &pageid);
889: tid->line_id = 0;
890: if (tmp = get(d, tid, tid, tuple, FALSE))
891: {
892: /*
893: ** If the relation is empty, then page 0 will
894: ** return AMINVL_ERR on a get(). Form a blank tuple
895: ** and use it to create a one tuple directory
896: */
897: if (pageid == 0 && tmp == AMINVL_ERR)
898: {
899: clr_tuple(d, tuple);
900: }
901: else
902: {
903: return (-2);
904: }
905: }
906:
907: /*
908: ** If this is the first level then form the tuple
909: ** from the mainpage of the relation. Otherwise
910: ** the tuple is the first tuple of a directory page
911: ** and it is already correctly formed.
912: */
913: if (level == 0)
914: {
915: key = temptup;
916: for (tmp = 0; keyx[tmp] != 0; tmp++)
917: {
918: len = d->relfrml[keyx[tmp]] & I1MASK;
919: bmove(&tuple[d->reloff[keyx[tmp]]], key, len);
920: key += len;
921: }
922: key = temptup;
923: }
924: else
925: key = tuple;
926:
927: if (keywid > space_left(&dirbuf))
928: {
929: if (pageflush(&dirbuf))
930: return (-3);
931: dirbuf.thispage++;
932: newstop = dirbuf.thispage;
933: dirbuf.ovflopg = pageid;
934: dirbuf.linetab[0] = (short) (dirbuf.firstup - (char *) &dirbuf);
935: offset = dirbuf.linetab[0];
936: dirbuf.bufstatus = BUF_DIRTY;
937: dirbuf.nxtlino = 0;
938: }
939: /* copy key to directory page */
940: bmove(key, (char *) &dirbuf + offset, keywid);
941:
942: /* update next line number */
943: offset += keywid;
944: dirbuf.nxtlino++;
945: dirbuf.linetab[-dirbuf.nxtlino] = offset;
946: }
947: if (pageflush(&dirbuf))
948: return (-4);
949: if (newstart == newstop)
950: break;
951: d->reldum.relspec = abs(d->reldum.relspec);
952: level++;
953: start = newstart;
954: stop = newstop;
955: }
956: d->reldum.relspec = savespec;
957: d->reldum.relprim = newstart;
958: return (0);
959: }
960:
961: bldbindex(dx)
962: register DESC *dx;
963: {
964: register TID *tid;
965: register int tmp;
966: TID tidx;
967: struct accbuf dirbuf;
968: int keywid, level, savespec, keyx[MAXDOM];
969: int offset, len;
970: struct pgtuple tuple, temptup;
971: char *key;
972: long pageid, start, stop, newstart, newstop;
973: int fill_leave;
974:
975: tid = &tidx;
976: keywid = 0;
977: for (tmp = 0; tmp < MAXDOM; tmp++)
978: keyx[tmp] = 0;
979: for (tmp = 1; tmp <= d->reldum.relatts; tmp++)
980: if (d->relxtra[tmp] > 0)
981: {
982: keyx[d->relxtra[tmp - 1]] = tmp;
983: keywid += d->relfrml[tmp] & I1MASK;
984: }
985:
986: keywid += PGPTRSIZ;
987:
988: /* determine fill factor for directory pages */
989:
990: fill_leave = (100 - F_fac) * MAXTUP / 100;
991: if (keywid > fill_leave)
992: fill_leave = keywid;
993:
994: /* Determine the last page of the relation. This will
995: ** only work if all pages have been written out. Fill_rel
996: ** must guarantee that all pages have been written
997: */
998:
999: level = 0;
1000: last_page(d, tid, 0);
1001: pluck_page(tid, &stop);
1002: start = 1; /* page 0 is the root */
1003: dirbuf.filedesc = d->relfp;
1004: dirbuf.rel_tupid = d->reltid.ltid;
1005: savespec = d->reldum.relspec;
1006: for (;;)
1007: {
1008: # ifdef xZTR2
1009: if (tTf(38, 7))
1010: printf("btree: level %d\n", level);
1011: # endif
1012: dirbuf.mainpg = level;
1013: dirbuf.thispage = stop + 1;
1014: dirbuf.ovflopg = dirbuf.thispage + 1;
1015: dirbuf.linetab[0] = (short) (&dirbuf.firstup[PGPTRSIZ] - (char *) &dirbuf);
1016:
1017: stuff_page(dirbuf.firstup, &start); /* put first pgnum in */
1018: start++;
1019:
1020: offset = dirbuf.linetab[0];
1021: dirbuf.bufstatus = BUF_DIRTY | BUF_DIRECT;
1022:
1023: dirbuf.nxtlino = 0;
1024: newstart = stop + 1;
1025: newstop = newstart;
1026: for (pageid = start; pageid <= stop; pageid++)
1027: {
1028: # ifdef xZTR2
1029: if (tTf(38, 8))
1030: printf("btree:get key from %ld\n", pageid);
1031: # endif
1032: stuff_page(tid, &pageid);
1033: tid->line_id = 0;
1034: if (tmp = get(d, tid, tid, &tuple, FALSE))
1035: {
1036: syserr("modify: bldbindex: get %d\n", tmp);
1037: }
1038:
1039: /*
1040: ** If this is the first level then form the tuple
1041: ** from the mainpage of the relation. Otherwise
1042: ** the tuple is the first tuple of a directory page
1043: ** and it is already correctly formed.
1044: */
1045: if (level == 0)
1046: {
1047: bndxkey(d, tuple.childtup, &temptup, &pageid, keyx);
1048: /*
1049: stuff_page(&temptup.childtid, &pageid);
1050: key = temptup.childtup;
1051: for (tmp = 0; keyx[tmp] != 0; tmp++)
1052: {
1053: len = d->relfrml[keyx[tmp]] & I1MASK;
1054: bmove(&((char *) &tuple)[d->reloff[keyx[tmp]]], key, len);
1055: key += len;
1056: }
1057: */
1058:
1059:
1060: printf("primary ");
1061: key = &temptup;
1062: }
1063: else
1064: {
1065: stuff_page(&tuple.childtid, &pageid);
1066: key = &tuple;
1067: printf("secondary %d: ", level);
1068: }
1069:
1070: printf("adding: ");
1071: prbndxkey(d, key, keyx);
1072: printf("\n");
1073:
1074: if (fill_leave > space_left(&dirbuf))
1075: {
1076: if (pageflush(&dirbuf))
1077: return (-3);
1078: dirbuf.thispage++;
1079: newstop = dirbuf.thispage;
1080: dirbuf.ovflopg = dirbuf.thispage + 1;
1081: dirbuf.linetab[0] = (short) (&dirbuf.firstup[PGPTRSIZ] - (char *) &dirbuf);
1082:
1083: stuff_page(dirbuf.firstup, &pageid);
1084:
1085: offset = dirbuf.linetab[0];
1086: dirbuf.bufstatus = BUF_DIRTY;
1087: dirbuf.nxtlino = 0;
1088: continue;
1089: }
1090: /* copy key to directory page */
1091: bmove(key, (char *) &dirbuf + offset, keywid);
1092:
1093: /* update next line number */
1094: offset += keywid;
1095: dirbuf.nxtlino++;
1096: dirbuf.linetab[-dirbuf.nxtlino] = offset;
1097: }
1098: if (newstart == newstop) /* must be root */
1099: dirbuf.thispage = 0; /* root is page 0 */
1100:
1101: dirbuf.ovflopg = 0; /* no more pages */
1102:
1103: if (pageflush(&dirbuf))
1104: return (-4);
1105:
1106: if (newstart == newstop)
1107: break;
1108: d->reldum.relspec = abs(d->reldum.relspec);
1109: level++;
1110: start = newstart;
1111: stop = newstop;
1112: }
1113: d->reldum.relspec = savespec;
1114: d->reldum.relprim = newstart;
1115: return (0);
1116: }
1117: /*
1118: ** UNSPOOL -- Take tuples saved in spool file and insert them
1119: ** in new relation. This is only for ISAM relations.
1120: */
1121:
1122: unspool(descx)
1123: DESC *descx;
1124: {
1125: register DESC *desc;
1126: register int i;
1127: TID tid;
1128: char tup_buf[MAXTUP], spoolbuf[IOBUFSIZ];
1129: FILE *spfp;
1130:
1131: desc = descx;
1132: if (Mod_info.spflag)
1133: {
1134: if ((spfp = fopen(Mod_info.spfile, "read", spoolbuf)) == NULL)
1135: syserr("UNSPOOL: fopen spool");
1136: while ((i = fread(spfp, tup_buf, desc->reldum.relwid)) == desc->reldum.relwid)
1137: if ((i = insert(desc, &tid, tup_buf, FALSE)) < 0)
1138: syserr("UNSPOOL: insert %.14s %d", desc->reldum.relid, i);
1139: if (i != 0)
1140: syserr("UNSPOOL: read %d", i);
1141: fclose(spfp);
1142: unlink(Mod_info.spfile);
1143: }
1144: desc->reldum.reltups += desc->reladds;
1145: desc->reladds = 0;
1146: return (0);
1147: }
1148: /*
1149: ** FILL_BATCH -- Create and fill a batch file containing the
1150: ** updates for the system catalog so that MODIFY will
1151: ** be recoverable if the system crashes.
1152: */
1153:
1154: fill_batch(odesc, descx)
1155: DESC *odesc, *descx;
1156: {
1157: register DESC *desc, *dessys;
1158: register int i;
1159: struct relation reltup, rkey;
1160: TID tid, lotid, hitid;
1161: struct attribute atttup, akey;
1162: int j;
1163: char prebatch[MAXNAME + 4], modbatch[MAXNAME + 4];
1164:
1165: desc = descx;
1166: if (bequal(desc->reldum.relid, "relation ", 12))
1167: {
1168: clearkeys(desc);
1169: setkey(desc, &rkey, desc->reldum.relid, RELID);
1170: setkey(desc, &rkey, desc->reldum.relowner, RELOWNER);
1171: if (i = getequal(desc, &rkey, &reltup, &tid))
1172: syserr("FILL_BATCH: geteq rel rel %d", i);
1173: bmove(&tid, &desc->reltid, sizeof desc->reltid);
1174: }
1175: else
1176: bmove(&odesc->reltid, &desc->reltid, sizeof desc->reltid);
1177: resetacc(Acc_head);
1178: concat(MOD_PREBATCH, Fileset, prebatch);
1179: close(creat(prebatch, FILEMODE));
1180: if ((Batch_fp = open(prebatch, 2)) < 0)
1181: syserr("FILL_BATCH: open %.14s %d", prebatch, Batch_fp);
1182: smove(Fileset, Batchbuf.file_id);
1183: Batch_cnt = 0;
1184: wrbatch(desc, sizeof *desc);
1185: if (bequal(desc->reldum.relid, "attribute ", 12))
1186: dessys = desc;
1187: else
1188: dessys = &Admin.adattd;
1189: clearkeys(dessys);
1190: setkey(dessys, &akey, desc->reldum.relid, ATTRELID);
1191: setkey(dessys, &akey, desc->reldum.relowner, ATTOWNER);
1192: if (i = find(dessys, EXACTKEY, &lotid, &hitid, &akey))
1193: syserr("FILL_BATCH: find %d", i);
1194: j = desc->reldum.relatts;
1195: while(!(i = get(dessys, &lotid, &hitid, &atttup, TRUE)) && j > 0)
1196: if (!kcompare(dessys, &akey, &atttup))
1197: {
1198: j--;
1199: atttup.attxtra = desc->relxtra[atttup.attid];
1200: wrbatch(&lotid, sizeof lotid);
1201: wrbatch(&atttup, sizeof atttup);
1202: }
1203: if (i < 0 || j > 0)
1204: syserr("FILL_BATCH: get att %d count %d", i, j);
1205: /* get rid of attribute pages */
1206: cleanrel(dessys);
1207: flushbatch();
1208: close(Batch_fp);
1209: concat(MODBATCH, Fileset, modbatch);
1210: if (link(prebatch, modbatch) == -1)
1211: syserr("FILL_BATCH: can't link %.14s %.14s",
1212: prebatch, modbatch);
1213: unlink(prebatch);
1214: return (0);
1215:
1216: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.