![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to modify.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / ingres / source / dbu|
Return to modify.c CVS log | Up to [CSRG BSD Unix] / 43BSD / ingres / source / dbu |
1.1 root 1: # include <stdio.h>
2: # include <ingres.h>
3: # include <pv.h>
4: # include <aux.h>
5: # include <access.h>
6: # include <batch.h>
7: # include <lock.h>
8: # include <opsys.h>
9: # include <func.h>
10: # include <version.h>
11: # include <symbol.h>
12: # include <catalog.h>
13: # include <btree.h>
14: # include <sccs.h>
15: # include <errors.h>
16:
17: SCCSID(@(#)modify.c 8.8 5/7/85)
18:
19: extern short tTdbu[];
20: extern int modify();
21: extern int null_fn();
22:
23: struct fn_def ModifyFn =
24: {
25: "MODIFY",
26: modify,
27: null_fn,
28: null_fn,
29: NULL,
30: 0,
31: tTdbu,
32: 100,
33: 'Z',
34: 0
35: };
36:
37: /*
38: ** MODIFY -- converts any relation to the specified
39: ** storage structure
40: **
41: ** arguments:
42: ** 0 - relation name
43: ** 1 - storage structure ("heap", "cheap", "hash", "chash",
44: ** "isam", "cisam")
45: ** 2 - "name" for attribute names, or "num" for numbers
46: ** 3 - key1
47: ** 4 - key2
48: ** .
49: ** .
50: ** i - null
51: ** i+1 - option name (e.g., "fillfactor")
52: ** i+2 - option value
53: ** .
54: ** .
55: **
56: ** If all the options default, parameter i -> pc are omitted.
57: ** If no keys are provided, parameter 2 is omitted.
58: */
59:
60: int F_fac, Mn_pages, Mx_pages;
61: char Lid[MAXLID][MAXNAME];
62: int NLidKeys;
63: int LidKey[MAXLID];
64:
65: struct modtab
66: {
67: char *type;
68: char newrelspec;
69: char yeskeys;
70: char sortit;
71: char yes_seq;
72: int f_fac;
73: int mn_pages;
74: int mx_pages;
75: };
76:
77:
78: struct modtab Modtab[] =
79: {
80: /* type spec keys sort seq ffac min max */
81:
82: "heap", M_HEAP, FALSE, FALSE, FALSE, 0, 0, 0,
83: "cheap", -M_HEAP,FALSE, FALSE, FALSE, 0, 0, 0,
84: "hash", M_HASH, TRUE, TRUE, FALSE, 50, 10, -1,
85: "chash", -M_HASH,TRUE, TRUE, FALSE, 75, 1, -1,
86: "isam", M_ISAM, TRUE, TRUE, FALSE, 80, 0, 0,
87: "cisam", -M_ISAM,TRUE, TRUE, FALSE, 100, 0, 0,
88: "heapsort", M_HEAP, TRUE, TRUE, TRUE, 0, 0, 0,
89: "cheapsort", -M_HEAP,TRUE, TRUE, TRUE, 0, 0, 0,
90: "truncated", M_TRUNC,FALSE, FALSE, FALSE, 0, 0, 0,
91: "ordered", M_ORDER,TRUE, FALSE, FALSE, 0, 0, 0,
92: 0
93: };
94:
95: struct mod_info
96: {
97: char outfile[MAXNAME + 4]; /* result file filled by ksort */
98: char formfile[MAXNAME + 4]; /* file with descriptor for ksort */
99: char infile[MAXNAME + 4]; /* input file for ksort (relation itself */
100: char reltemp[MAXNAME + 4]; /* file holding new relation */
101: char spfile[MAXNAME + 4], spflag; /* isam spool file for overflow */
102: char btree[MAXNAME + 4]; /* file holding temporary btree structure */
103: char temp_sort[MAXNAME + 4]; /* file holding result of special isam
104: ** required when ordering on a field
105: */
106: };
107:
108: struct mod_info Mod_info;
109:
110: extern DESC Btreesec;
111: extern int Btree_fd;
112:
113:
114:
115: modify(pc, pv)
116: int pc;
117: PARM *pv;
118: {
119: register int i, j;
120: register char *rname;
121: register struct modtab *mp;
122: struct modtab *p;
123: int sorted, dim;
124: DESC dold, dnew;
125: long temptid;
126: extern int Noupdt;
127: extern DESC Attdes;
128: struct attribute atttup, attkey;
129: TID tid;
130: int lidkey, numatts;
131: extern char *trim_relname();
132: extern char *iocv();
133:
134:
135: # ifdef xZTR1
136: if (tTf(34, -1))
137: {
138: printf("enter modify\n");
139: prvect(pc, pv);
140: }
141: # endif
142:
143: pv[pc].pv_val.pv_str = NULL;
144:
145: /* check for nice parameters */
146: if (pc < 2)
147: syserr("MODIFY: pc %d", pc);
148:
149: /* save relation name for error messages */
150: rname = (pv++)->pv_val.pv_str; /* *pv now pointes to storage spec */
151:
152: /* check for good relation */
153: i = openr(&dold, OR_READ, rname);
154: if (i == AMOPNVIEW_ERR)
155: return (error(NOMODVIEW, rname, 0));
156: if (i > 0)
157: /* reln does not exist */
158: return (error(NOREL, rname, 0));
159: else if (i < 0)
160: syserr("MODIFY: openr (%.14s) %d", rname, i);
161: /* can only modify a relation you own and isn't a sys rel */
162:
163: if (!bequal(Usercode, dold.reldum.relowner, UCODE_SZ))
164: {
165: i = NOOWN;
166: }
167: if ((dold.reldum.relstat & S_CATALOG) && Noupdt)
168: {
169: i = NOMODSYSREL;
170: }
171: if (i)
172: {
173: closer(&dold);
174: return (error(i, rname, 0));
175: }
176:
177: /*
178: ** Form descriptor for new relation. Here we need to
179: ** separate the pages from the old and new relations.
180: ** Since pages are identified by the TID of the relation
181: ** relation tuple, both old and new have the same identifiers.
182: ** To avoid this problem, a special TID is hand crafted for
183: ** the new relation.
184: */
185: bmove(&dold, &dnew, sizeof dnew);
186: dnew.reltid.s_tupid.line_id = (char) -2; /* choose impossible reltid */
187: /* assume new relation isn't ordered */
188: if (dold.reldum.reldim)
189: {
190: dnew.reldum.relatts -= dold.reldum.reldim;
191: dnew.reldum.relwid -= dold.reldum.reldim * LIDSIZE;
192: dnew.reldum.reldim = 0;
193: }
194:
195: /* In case of an interrupt from a previous modify,
196: ** there might be pages around. Get rid of them.
197: */
198: cleanrel(&dnew);
199:
200: ingresname(dold.reldum.relid, dold.reldum.relowner, Mod_info.infile);
201: dim = 0;
202: NLidKeys = 0;
203:
204: /* scan for entry in relspec table */
205: for (mp = Modtab; mp->type; mp++)
206: {
207: if (bequal(mp->type, pv->pv_val.pv_str, 7) && bequal("ordered", pv->pv_val.pv_str, 7))
208: {
209: if ((dim = atoi(pv->pv_val.pv_str + 7)) <= 0 || dim > MAXLID)
210: {
211: closer(&dold);
212: return(error(BADORDDIM, rname, iocv(dim), 0));
213: }
214: break;
215: }
216: if (sequal(mp->type, pv->pv_val.pv_str))
217: break;
218: }
219:
220: /* if not found, error */
221: if (!mp->type)
222: {
223: closer(&dold);
224: return (error(BADSTORAGE, rname, pv->pv_val.pv_str, 0)); /* bad relspec */
225: }
226:
227: if (mp->newrelspec == M_ORDER && dold.reldum.relindxd == SECINDEX)
228: /* can't order an index relation */
229: {
230: closer(&dold);
231: return(error(NOORDINDX, rname,0));
232: }
233:
234: if (mp->newrelspec == M_ORDER)
235: {
236: dnew.reldum.reldim = dim;
237: for (i = 0; i < dim; ++i)
238: {
239: ++dnew.reldum.relatts;
240: dnew.relxtra[dnew.reldum.relatts] = 0;
241: dnew.reloff[dnew.reldum.relatts] = dnew.reldum.relwid;
242: dnew.relfrmt[dnew.reldum.relatts] = INT;
243: dnew.relfrml[dnew.reldum.relatts] = LIDSIZE;
244: dnew.reldum.relwid += LIDSIZE;
245: }
246: concat(BTREE, Fileset, Mod_info.btree);
247: create_btree(Mod_info.btree);
248: dnew.btree_fd = Btree_fd;
249: /* ok to order ascending/descending */
250: mp->yes_seq = TRUE;
251: }
252: else
253: {
254: dnew.reldum.relspec = mp->newrelspec;
255: if (dold.reldum.reldim)
256: {
257: dold.reldum.relatts -= dold.reldum.reldim;
258: dold.reldum.relwid -= dold.reldum.reldim * LIDSIZE;
259: dold.reldum.reldim = 0;
260: closer(dold.relbtree);
261: close(dold.btree_fd);
262: }
263: }
264:
265: if (dnew.reldum.relspec == M_TRUNC)
266: dnew.reldum.relspec = M_HEAP;
267:
268: pv++; /* now points to first parameter */
269:
270: /* get the key domains information */
271: if ((i = getkeys(&pv, rname, &dnew, mp)) > 0)
272: {
273: closer(&dold);
274: return (i); /* user error */
275: }
276:
277: j = 0;
278: for (i = 0; i < NLidKeys; ++i)
279: if (LidKey[i] > dold.reldum.relatts - dold.reldum.reldim)
280: {
281: j = 1;
282: break;
283: }
284:
285: if (!j && dold.reldum.reldim)
286: /* treat old relation as if not ordered since lid field not needed */
287: {
288: dold.reldum.relatts -= dold.reldum.reldim;
289: dold.reldum.relwid -= dold.reldum.reldim * LIDSIZE;
290: dold.reldum.reldim = 0;
291: closer(dold.relbtree);
292: close(dold.btree_fd);
293: }
294:
295: if (!dnew.reldum.reldim || !NLidKeys)
296: {
297: F_fac = mp->f_fac;
298: Mn_pages = mp->mn_pages;
299: Mx_pages = mp->mx_pages;
300: }
301: else
302: /* set parameters to that of storage type of relation to be ordered */
303: {
304: for (p = Modtab; p->type; p++)
305: if (dnew.reldum.relspec == p->newrelspec)
306: break;
307: F_fac = p->f_fac;
308: Mn_pages = p->mn_pages;
309: Mx_pages = p->mx_pages;
310: }
311:
312: if (mp->newrelspec != M_ORDER)
313: for (i = 0; i < dnew.reldum.reldim; ++i)
314: Lid[i][0] = NULL;
315: else
316: for (i = 1; i <= dnew.reldum.reldim; ++i)
317: concat("lid", iocv(i), Lid[i-1]);
318:
319: /* get fillfactor and other options if any */
320: if (i = getfill(&dnew, pv, rname, mp))
321: {
322: closer(&dold);
323: return (i); /* user error */
324: }
325:
326: /* check for duplicate attribute name */
327: if (mp->newrelspec == M_ORDER)
328: {
329: opencatalog("attribute", OR_READ);
330: setkey(&Attdes, &attkey, dnew.reldum.relid, ATTRELID);
331: setkey(&Attdes, &attkey, dnew.reldum.relowner, ATTOWNER);
332: numatts = dold.reldum.relatts - dold.reldum.reldim;
333: for (i = 0; i < dnew.reldum.reldim; ++i)
334: {
335: setkey(&Attdes, &attkey, Lid[i], ATTNAME);
336: if (getequal(&Attdes, &attkey, &atttup, &tid) == 0)
337: {
338: if (atttup.attid <= numatts)
339: /* ok to duplicate attributes that will be removed */
340: {
341: closer(&dold);
342: return(error(INVALIDATTR, rname, Lid[i], 0));
343: }
344: }
345: }
346: }
347:
348: /* lock the relation relation */
349: if (Lockrel)
350: {
351: get_p_tid(&dold, &temptid);
352: setrll(A_SLP, temptid, M_EXCL);
353: }
354:
355: if (!dnew.reldum.reldim || NLidKeys > 0)
356: /* compute new relation parameters & build descriptor */
357: make_newrel(&dnew);
358:
359: if (sorted = ((mp->sortit || NLidKeys > 0) && (dold.reldum.reltups != 0)))
360: {
361: sortrel(&dold, &dnew);
362: dold.reldum.relindxd = 0;
363: }
364:
365: if (!dnew.reldum.reldim || NLidKeys > 0)
366: /* physically create the new relation */
367: if (formatpg(&dnew, dnew.reldum.relprim) != 0)
368: syserr("modify: formatpg");
369:
370: /* clear relgiven field; if heap remove any keys */
371: clearkeys(&dnew);
372:
373: if (abs(dnew.reldum.relspec) == M_HEAP)
374: for (i = 1; i <= dnew.reldum.relatts; i++)
375: dnew.relxtra[i] = 0;
376:
377: if (NLidKeys > 0 && dnew.reldum.relspec == M_ISAM)
378: sort_isam(&dold, &dnew);
379:
380: if (mp->newrelspec != M_TRUNC)
381: fill_rel(&dold, &dnew, sorted);
382:
383: closer(&dold); /* error return is impossible */
384: if (abs(dnew.reldum.relspec) == M_ISAM && (!dnew.reldum.reldim || NLidKeys > 0))
385: {
386: j = dnew.reldum.reldim;
387: dnew.reldum.reldim = 0;
388: if (i = bldindex(&dnew))
389: syserr("bldindex: %.14s %d", dnew.reldum.relid, i);
390: dnew.reldum.reldim = j;
391: unspool(&dold, &dnew);
392: }
393:
394: /*
395: ** New relation is now complete. The system relations need to
396: ** be updated. First destroy all buffers with pages from the
397: ** new relation.
398: */
399: if (i = cleanrel(&dnew))
400: syserr("modify:clean new %d,%.14s", i, dnew.reldum.relid);
401:
402: fill_batch(&dold, &dnew);
403:
404: /*
405: ** Close the file for the new relation. This must be
406: ** done after the fill_batch in case we are modifing
407: ** the attribute relation.
408: */
409: if (!dnew.reldum.reldim || NLidKeys > 0)
410: close(dnew.relfp);
411: dnew.relopn = 0;
412: ruboff("modify");
413: modupdate();
414: if (mp->newrelspec == M_ORDER)
415: {
416: close(dnew.btree_fd);
417: make_bsec(dnew.reldum.relid, dim);
418: }
419: rubon();
420:
421: if (Lockrel)
422: unlrl(temptid);
423:
424: return (0);
425: }
426:
427:
428: /*
429: ** GETKEYS - get key domains information
430: **
431: ** Parameters:
432: ** ppv - parameter vector with info about keys
433: ** relname - relation name
434: ** d - new descriptor for the relation
435: ** mp - mod table
436: **
437: ** Return Codes:
438: ** 0 - ok
439: ** >0 - error from modseqkey
440: */
441: getkeys(ppv, relname, d, mp)
442: PARM **ppv;
443: char *relname;
444: register DESC *d;
445: struct modtab *mp;
446: {
447: register PARM *pv;
448: register char *cp;
449: int namemode, sort_only, as_ds;
450: int i, j, keyno, keywid;
451: struct attribute attkey, atttup;
452: struct index ikey, itup;
453: TID tid;
454: extern DESC Attdes, Inddes;
455: extern char *iocv();
456:
457: pv = *ppv; /* copy list of params */
458:
459: if (mp->newrelspec != M_ORDER)
460: /* zero key info (ordering does not change keyed fields) */
461: for (i = 0; i <= d->reldum.relatts; i++)
462: d->relxtra[i] = 0;
463: for (i = 0; i <= d->reldum.relatts; ++i)
464: d->relgiven[i] = 0;
465:
466: /* determine whether there are any keys at all */
467: keywid = 0;
468: keyno = 0;
469: sort_only = FALSE;
470: cp = pv->pv_val.pv_str;
471:
472: if (cp == NULL || *cp == NULL)
473: {
474: /* no key information. default as needed */
475: if (mp->yeskeys && mp->newrelspec != M_ORDER)
476: {
477: cp = "\1"; /* default to first key */
478: namemode = FALSE;
479: }
480: else
481: pv++; /* point one to far */
482: }
483: else
484: {
485: /* check for name mode */
486: if (namemode = sequal(cp, "name"))
487: {
488:
489: /* check attribute names, and convert them to numbers */
490: opencatalog("attribute", OR_READ);
491: setkey(&Attdes, &attkey, Mod_info.infile, ATTRELID);
492: setkey(&Attdes, &attkey, Usercode, ATTOWNER);
493: }
494: pv++; /* inc to next key */
495: cp = (pv++)->pv_val.pv_str;
496: }
497:
498: /* scan for attribute names */
499: for (; cp != NULL; cp = (pv++)->pv_val.pv_str)
500: {
501: /* check for separator between keys & options */
502: if (*cp == NULL)
503: {
504: pv++; /* point two past NULL */
505: break;
506: }
507:
508: if (NLidKeys >= d->reldum.reldim && mp->newrelspec == M_ORDER)
509: {
510: /* more than one field specified as ordering key */
511: closeall(0l, 0l);
512: return(error(TOOMANYORDKEYS, relname, 0));
513: }
514:
515: if (namemode)
516: {
517: /* check for "sort only" attribute */
518: if (*cp == '#')
519: {
520: cp++; /* inc to start of name */
521: sort_only = TRUE;
522: }
523:
524: /* check for ascending/descending modifier */
525: if ((as_ds = modseqkey(cp, relname, mp->yes_seq)) > 0)
526: return (as_ds); /* error */
527:
528: setkey(&Attdes, &attkey, cp, ATTNAME);
529: i = getequal(&Attdes, &attkey, &atttup, &tid);
530: if (i < 0)
531: syserr("MODIFY: geteq(att) %d", i);
532: if (i > 0)
533: {
534: closeall(0l, 0l);
535: return (error(INVALIDATTR, relname, cp, 0)); /* bad att name */
536: }
537: i = atttup.attid;
538: if (i > d->reldum.relatts)
539: {
540: /* attempting to key on lid field which will be
541: ** removed
542: */
543: closeall(0l,0l);
544: return(error(ATTRREMV, relname, cp, 0));
545: }
546: }
547: else
548: {
549: i = *cp;
550: as_ds = 0;
551: }
552:
553: keyno++;
554: /* add new key to descriptor */
555: if (mp->newrelspec == M_ORDER)
556: LidKey[NLidKeys++] = i;
557: if (!sort_only && mp->newrelspec != M_ORDER)
558: {
559: d->relxtra[i] = keyno;
560: keywid += (d->relfrml[i] & I1MASK);
561: }
562: if (d->relgiven[i])
563: {
564: closeall(0l, 0l);
565: return (error(DUPKEY, relname, cp, 0)); /* duplicate attribute */
566: }
567: d->relgiven[i] = as_ds == 0 ? keyno : -keyno;
568: }
569: pv--; /* back up one to point to "-1" terminator */
570:
571:
572: if (abs(d->reldum.relspec) == M_ISAM && keywid > (MAXTUP / 2 - 4))
573: {
574: closeall(0l, 0l);
575: return (error(TOOWIDEISAM, relname, iocv(keywid), 0));
576: }
577:
578: /* if a heap, there can be no keys */
579: if (!mp->yeskeys && keyno != 0)
580: {
581: closeall(0l, 0l);
582: return (error(NOKEYSHEAP, relname, mp->type, 0)); /* no keys allowed on heap */
583: }
584: /* fill out default sort on remainder of keys */
585: if (mp->yeskeys)
586: for (i = 1; i <= d->reldum.relatts; i++)
587: if (d->relgiven[i] == 0)
588: d->relgiven[i] = ++keyno;
589: *ppv = pv;
590: return (0);
591: }
592:
593:
594: /*
595: ** MODSEQKEY - verify that sequence specified is valid
596: **
597: ** Parameters:
598: ** domain - list of domains
599: ** relname - relation name
600: ** seq_ok - whether it is ok to specify the sequence
601: ** ascending or descending
602: **
603: ** Return Codes:
604: ** 0 - ok
605: ** > 0 - error in sequence specified
606: **
607: ** Called by:
608: ** getkeys
609: */
610: modseqkey(domain, relname, seq_ok)
611: char *domain;
612: char *relname;
613: int seq_ok;
614: {
615: register char *cp, c;
616: register int ret;
617:
618: ret = 0;
619:
620: for (cp = domain; c = *cp++; )
621: if (c == ':')
622: break;
623:
624: if (c != '\0')
625: {
626: /* replace ":" with null */
627: *(cp - 1) = '\0';
628:
629: /* verify sequence is valid */
630: if (!seq_ok)
631: {
632: closeall(0l, 0l);
633: ret = error(BADSEQSPEC, relname, cp, domain, 0);
634: }
635: else if (sequal("descending", cp) || sequal("d", cp))
636: ret = -1;
637: else if (!(sequal("ascending", cp) || sequal("a", cp)))
638: {
639: closeall(0l, 0l);
640: ret = error(INVALIDSEQ, relname, cp, domain, 0);
641: }
642: }
643:
644: return (ret);
645: }
646: /*
647: ** GETFILL -- Get fill factor and minimum pages parameters
648: ** from argument list, convert them from ascii to integer
649: ** and store them in global variables. If the global
650: ** variable for the corresponding parameter is zero,
651: ** it means that that parameter is not allowed and an
652: ** error is generated.
653: */
654:
655: /*ARGSUSED*/
656: getfill(d, pv, rel, mp)
657: DESC *d;
658: register PARM *pv;
659: char *rel;
660: struct modtab *mp;
661: {
662: register char *p1;
663: register int err;
664: char *p2;
665: int i, j;
666: int fill_flag, min_flag, max_flag, lid_flag[MAXLID];
667:
668: err = 0;
669: fill_flag = min_flag = max_flag = FALSE;
670: for (i = 0; i < d->reldum.reldim; ++i)
671: lid_flag[i] = FALSE;
672:
673: while ((p1 = (pv++)->pv_val.pv_str) != NULL)
674: {
675: p2 = (pv++)->pv_val.pv_str;
676: if (sequal(p1, "fillfactor"))
677: {
678: if (F_fac == 0 || fill_flag)
679: {
680: err = NOTALLOWED;
681: break;
682: }
683: p1 = p2;
684: F_fac = atoi(p1);
685: if (F_fac > 100 || F_fac < 1)
686: {
687: err = FILLBOUND;
688: break;
689: }
690: fill_flag = TRUE;
691: continue;
692: }
693: if (sequal(p1, "minpages"))
694: {
695: if (Mn_pages == 0 || min_flag)
696: {
697: err = NOTALLOWED;
698: break;
699: }
700: p1 = p2;
701: Mn_pages = atoi(p1);
702: if (Mn_pages < 1)
703: {
704: err = MINPGBOUND;
705: break;
706: }
707: if (max_flag && (Mn_pages > Mx_pages))
708: {
709: err = MINGTMAX;
710: break;
711: }
712: min_flag = TRUE;
713: continue;
714: }
715: if (sequal(p1, "maxpages"))
716: {
717: if (Mx_pages == 0 || max_flag)
718: {
719: err = NOTALLOWED;
720: break;
721: }
722: p1 = p2;
723: Mx_pages = atoi(p1);
724: if (Mx_pages < 1)
725: {
726: err = MAXPGBOUND;
727: break;
728: }
729: if (min_flag && (Mn_pages > Mx_pages))
730: {
731: err = MINGTMAX;
732: break;
733: }
734: max_flag = TRUE;
735: continue;
736: }
737: for ( i = 1; i <= d->reldum.reldim && !err; ++i)
738: if (sequal(p1, ztack("lid", iocv(i))))
739: {
740: if (lid_flag[i-1] || *Lid[i-1] == NULL)
741: {
742: err = NOTALLOWED;
743: break;
744: }
745: for (j = 0; j < d->reldum.reldim; ++j)
746: if (i - 1 != j && sequal(p2, Lid[j]) && lid_flag[j])
747: {
748: err = NOTALLOWED;
749: break;
750: }
751: p1 = p2;
752: smove(p1, Lid[i - 1]);
753: lid_flag[i - 1] = TRUE;
754: break;
755: }
756: if (err)
757: break;
758: if (i <= d->reldum.reldim)
759: continue;
760: err = NEEDFILL;
761: break;
762: }
763: if (err)
764: {
765: closeall(0l, 0l);
766: return (error(err, rel, p1, 0));
767: }
768: return (0);
769: }
770: /*
771: ** MAKE_NEWREL -- Create a file for the modified relation
772: ** and build one or more primary pages for the
773: ** relation based on its storage structure and the
774: ** number of tuples it must hold.
775: */
776:
777: make_newrel(desc)
778: register DESC *desc;
779: {
780: register int tups_p_page;
781: int width;
782:
783: concat(MODTEMP, Fileset, Mod_info.reltemp);
784: close(creat(Mod_info.reltemp, FILEMODE));
785: if ((desc->relfp = open(Mod_info.reltemp, O_RDWR)) < 0)
786: syserr("MAKE_NEWREL: open %.14s %d", Mod_info.reltemp, desc->relfp);
787: desc->relopn = (desc->relfp + 1) * -5;
788: desc->reldum.relprim = 1;
789: if (abs(desc->reldum.relspec) == M_HASH && F_fac > 0 && Mn_pages > 0)
790: {
791: /*
792: ** Determine the number of primary pages. The following
793: ** first determines the number of tuples/page which the
794: ** relation should have in order to get the requested
795: ** fillfactor. Then that number is divided into the
796: ** number of tuples to get the number of primary pages.
797: ** To avoid round off, it must guaranteed that the
798: ** number of tuples per page must be at least 1.
799: **
800: ** primary_pages = #tuples / (#tuples/page * fillfactor)
801: */
802: width = desc->reldum.relwid + 2 - LIDSIZE * desc->reldum.reldim;
803: tups_p_page = (((MAXTUP+2) / width) * F_fac) / 100;
804: if (tups_p_page == 0)
805: tups_p_page = 1;
806: /* we add one to simulate a ceiling function */
807: desc->reldum.relprim = desc->reldum.reltups / tups_p_page + 1;
808: if (desc->reldum.relprim < Mn_pages)
809: desc->reldum.relprim = Mn_pages;
810: if (Mx_pages > 0 && desc->reldum.relprim > Mx_pages)
811: desc->reldum.relprim = Mx_pages;
812: # ifdef xZTR1
813: if (tTf(36, 0))
814: printf("using %ld prim pages\n", desc->reldum.relprim);
815: # endif
816: }
817: desc->reldum.reltups = 0;
818: return (0);
819: }
820: /*
821: ** SORTREL - Call KSORT to sort the given relation. SORTREL
822: ** sets up the descriptor struct specifying the sort
823: ** keys and tells KSORT whether or not the hash key should
824: ** be included as a sort key.
825: */
826:
827: sortrel(odesc, desc)
828: DESC *odesc;
829: register DESC *desc;
830: {
831: extern char *Pathname;
832: register int i;
833: char buf[50];
834: DESC tempdesc;
835: char *temp;
836: int len;
837: short smalli;
838:
839: concat(ISAM_SORTED, Fileset, Mod_info.outfile);
840: if (close(creat(Mod_info.outfile, FILEMODE)))
841: syserr("SORTREL: creat %.14s", Mod_info.outfile);
842: bmove(odesc, &tempdesc, sizeof *odesc);
843: for (i = 1; i <= desc->reldum.relatts; ++i)
844: /* set up temporary descriptor for ksort with new keyed fields */
845: {
846: tempdesc.relxtra[i] = desc->relxtra[i];
847: tempdesc.relgiven[i] = desc->relgiven[i];
848: }
849:
850: if (abs(desc->reldum.relspec) == M_HASH && !desc->reldum.reldim)
851: {
852: /* sort on hash bucket first, (if ordering sort on ordering key, not bucket) */
853: tempdesc.relgiven[0] = 1;
854: for (i = 1; i <= desc->reldum.relatts; i++)
855: tempdesc.relgiven[i]++;
856: }
857:
858: # ifdef xZTR2
859: if (tTf(36, 4))
860: {
861: printf("sortrel: ");
862: printdesc(&tempdesc);
863: }
864: # endif
865:
866: /* flush buffers used by modify so that ksort can't look at them */
867: flush_rel(desc, TRUE);
868: resetacc(NULL);
869:
870: /* copy Fileset so it can't get trashed */
871:
872: len = length(Fileset) + 1;
873: temp = (char *) need(Qbuf, len);
874: bmove(Fileset, temp, len);
875:
876: initp();
877: setp(PV_STR, temp);
878: setp(PV_STR, Mod_info.infile);
879: setp(PV_STR, Mod_info.outfile);
880:
881: /* Descriptor for new relation */
882: setp(PV_STR, tempdesc.reldum.relid);
883: setp(PV_STR, tempdesc.reldum.relowner);
884: setp(PV_INT, tempdesc.reldum.relspec);
885: setp(PV_INT, tempdesc.reldum.relindxd);
886: setp(PV_INT, tempdesc.reldum.relstat2);
887: setp(PV_INT, tempdesc.reldum.relstat);
888: setp(PV_INT, (short) tempdesc.reldum.relsave);
889: setp(PV_INT, (short) tempdesc.reldum.reltups);
890: setp(PV_INT, tempdesc.reldum.relatts);
891: setp(PV_INT, tempdesc.reldum.relwid);
892: setp(PV_INT, (short) tempdesc.reldum.relprim);
893: setp(PV_INT, (short) tempdesc.reldum.relfree);
894: setp(PV_INT, (short) tempdesc.reldum.relstamp);
895: setp(PV_INT, tempdesc.reldum.reldim);
896:
897: setp(PV_STR, tempdesc.relvname);
898: setp(PV_INT, tempdesc.relfp);
899: setp(PV_INT, tempdesc.relopn);
900: setp(PV_INT, (short) tempdesc.reladds);
901: setp(PV_INT, tempdesc.reltid.ltid);
902: for (i = 0; i <= tempdesc.reldum.relatts; ++i)
903: {
904: smalli = (short) tempdesc.reloff[i];
905: setp(PV_INT, smalli);
906: smalli = (short) tempdesc.relfrmt[i];
907: setp(PV_INT, smalli);
908: smalli = (short) tempdesc.relfrml[i];
909: setp(PV_INT, smalli);
910: smalli = (short) tempdesc.relxtra[i];
911: setp(PV_INT, smalli);
912: smalli = (short) tempdesc.relgiven[i];
913: setp(PV_INT, smalli);
914: }
915:
916: if (tempdesc.reldum.reldim > 0)
917: {
918: setp(PV_STR, odesc->relbtree->reldum.relid);
919: setp(PV_STR, odesc->relbtree->reldum.relowner);
920: setp(PV_INT, odesc->relbtree->reldum.relspec);
921: setp(PV_INT, odesc->relbtree->reldum.relindxd);
922: setp(PV_INT, odesc->relbtree->reldum.relstat2);
923: setp(PV_INT, odesc->relbtree->reldum.relstat);
924: setp(PV_INT, (short) odesc->relbtree->reldum.relsave);
925: setp(PV_INT, (short) odesc->relbtree->reldum.reltups);
926: setp(PV_INT, odesc->relbtree->reldum.relatts);
927: setp(PV_INT, odesc->relbtree->reldum.relwid);
928: setp(PV_INT, (short) odesc->relbtree->reldum.relprim);
929: setp(PV_INT, (short) odesc->relbtree->reldum.relfree);
930: setp(PV_INT, (short) odesc->relbtree->reldum.relstamp);
931: setp(PV_INT, odesc->relbtree->reldum.reldim);
932:
933: setp(PV_STR, odesc->relbtree->relvname);
934: setp(PV_INT, odesc->relbtree->relfp);
935: setp(PV_INT, odesc->relbtree->relopn);
936: setp(PV_INT, (short) odesc->relbtree->reladds);
937: setp(PV_INT, odesc->relbtree->reltid.ltid);
938:
939: for (i = 0; i <= odesc->relbtree->reldum.relatts; ++i)
940: {
941: smalli = (short) odesc->relbtree->reloff[i];
942: setp(PV_INT, smalli);
943: smalli = (short) odesc->relbtree->relfrmt[i];
944: setp(PV_INT, smalli);
945: smalli = (short) odesc->relbtree->relfrml[i];
946: setp(PV_INT, smalli);
947: smalli = (short) odesc->relbtree->relxtra[i];
948: setp(PV_INT, smalli);
949: smalli = (short) odesc->relbtree->relgiven[i];
950: setp(PV_INT, smalli);
951: }
952: }
953:
954: call(mdKSORT, NULL);
955:
956: /* flush buffers used by ksort so that modify can't look at them */
957: flush_rel(desc, TRUE);
958: resetacc(NULL);
959:
960: # ifdef xZTR1
961: if (tTf(36,9))
962: printf("SORTREL: done calling ksort\n");
963: #endif
964: return (0);
965: }
966: /*
967: ** SORT_ISAM -- Sorts an isam relation back to its original order
968: ** so that it will be inserted into the relation in the proper order.
969: ** It is presently not in order because it has been sorted according
970: ** to a specified field for ordering.
971: */
972: sort_isam(sdesc, desc)
973: DESC *sdesc;
974: DESC *desc;
975: {
976: long lid[MAXLID];
977: register int i, j, k;
978: char tup_buf[MAXTUP], last_tup[MAXTUP], *dp, *sp;
979: FILE *sfp, *fp;
980: TID tid, tidpos;
981: DESC tempdesc;
982: int w;
983:
984: if (desc->reldum.reldim > 0)
985: Btree_fd = desc->btree_fd;
986: concat(STEMP, Fileset, Mod_info.temp_sort);
987: if ((sfp = fopen(Mod_info.temp_sort, "w")) == NULL)
988: syserr("sort_isam: can't open %s", Mod_info.temp_sort);
989: if ((fp = fopen(Mod_info.outfile, "r")) == NULL)
990: syserr("sort_isam: can't open %s", Mod_info.outfile);
991: for (i = 0; i < desc->reldum.reldim; lid[i++] = 0);
992: /* create input file for sort with proper lid attached to each tuple */
993: w = sdesc->reldum.relwid - LIDSIZE * sdesc->reldum.reldim;
994: for ( ; ; )
995: {
996: i = fread(tup_buf, 1, sdesc->reldum.relwid, fp);
997: if (i == 0)
998: break;
999: if (i != sdesc->reldum.relwid)
1000: syserr("sort_isam: read error in %s", Mod_info.outfile);
1001: for (j = 0; j < desc->reldum.reldim; ++j)
1002: if (j < NLidKeys && j < desc->reldum.reldim - 1)
1003: {
1004: dp = tup_buf + (sdesc->reloff[LidKey[j]] & I1MASK);
1005: sp = last_tup + (sdesc->reloff[LidKey[j]] & I1MASK);
1006: if (!bequal(dp, sp, sdesc->relfrml[LidKey[j]]) || !lid[j])
1007: {
1008: ++lid[j];
1009: for (k = j + 1; k < desc->reldum.reldim; ++k)
1010: lid[k] = 0;
1011: break;
1012: }
1013: }
1014: else
1015: {
1016: if (!lid[0])
1017: {
1018: lid[0] = 1;
1019: if (!(desc->reldum.reldim - 1))
1020: break;
1021: }
1022: ++lid[desc->reldum.reldim - 1];
1023: break;
1024: }
1025: bmove(tup_buf, last_tup, sdesc->reldum.relwid);
1026: /* reserve a slot in btree for tuple */
1027: insert_mbtree(desc, Mod_info.btree, lid, &tid, &tidpos);
1028: bmove(lid, tup_buf + w, LIDSIZE * desc->reldum.reldim);
1029: if (fwrite(tup_buf, 1, sdesc->reldum.relwid + LIDSIZE * desc->reldum.reldim, sfp) != sdesc->reldum.relwid + LIDSIZE * desc->reldum.reldim)
1030: syserr("sort_isam: write error in %s", Mod_info.temp_sort);
1031: }
1032: fclose(fp);
1033: fclose(sfp);
1034: /* set up new descriptor accounting for lid field */
1035: bmove(sdesc, &tempdesc, sizeof *sdesc);
1036: tempdesc.reldum.relspec = M_ORDER;
1037: for (i = 0; i < desc->reldum.reldim; ++i)
1038: {
1039: tempdesc.reldum.relwid += LIDSIZE;
1040: ++tempdesc.reldum.relatts;
1041: tempdesc.reloff[tempdesc.reldum.relatts] = tempdesc.reldum.relwid - LIDSIZE;
1042: tempdesc.relfrmt[tempdesc.reldum.relatts] = INT;
1043: tempdesc.relfrml[tempdesc.reldum.relatts] = LIDSIZE;
1044: }
1045: j = 0;
1046: /* use old keying attributes for specifying sort order */
1047: clearkeys(&tempdesc);
1048: for (i = 1; i <= sdesc->reldum.relatts; ++i)
1049: if (sdesc->relxtra[i])
1050: {
1051: tempdesc.relgiven[i] = sdesc->relxtra[i];
1052: ++j;
1053: }
1054: for (i = 1; i <= tempdesc.reldum.relatts; ++i)
1055: if (!tempdesc.relgiven[i])
1056: tempdesc.relgiven[i] = ++j;
1057: sortfile(Mod_info.temp_sort, &tempdesc, FALSE);
1058: if (unlink(Mod_info.outfile) < 0)
1059: syserr("can't unlink %s", Mod_info.outfile);
1060: if (link(ztack(REPL_OUT, Fileset), Mod_info.outfile) == -1)
1061: syserr("can't link %s to %s", ztack(REPL_OUT, Fileset), Mod_info.outfile);
1062: if (unlink(Mod_info.temp_sort) < 0)
1063: syserr("sort_isam: can't unlink %s", Mod_info.temp_sort);
1064: if (unlink(ztack(REPL_OUT, Fileset)) < 0)
1065: syserr("sort_isam: can't unlink replout file");
1066: }
1067: /*
1068: ** FILL_REL -- Fill the new relation with tuples from either
1069: ** the old relation or the output file of KSORT.
1070: */
1071:
1072: fill_rel(sdesc, desc, sortit)
1073: register DESC *sdesc, *desc;
1074: char sortit;
1075: {
1076: register int i;
1077: char tup_buf[MAXTUP], last_tup[MAXTUP], tup[2 * LIDSIZE];
1078: char junk[4], newreltype, anytups, chkdups;
1079: int need, j, k;
1080: long lnum, lid[MAXLID], l, page, t;
1081: TID tid, stid, stidlim, ntid, tidpos, btid;
1082: FILE *fp, *spfp;
1083: char *dp, *sp;
1084: int w, temp;
1085: struct locator tidloc;
1086:
1087: newreltype = abs(desc->reldum.relspec);
1088: if (sortit)
1089: {
1090: if ((fp = fopen(Mod_info.outfile, "r")) == NULL)
1091: syserr("FILL_REL: fopen %.14s", Mod_info.outfile);
1092: }
1093: else
1094: {
1095: cleanrel(sdesc); /* make sure each page is read fresh */
1096: find(sdesc, NOKEY, &stid, &stidlim);
1097: }
1098: if (newreltype == M_ISAM && (NLidKeys > 0 || !desc->reldum.reldim))
1099: {
1100: lnum = 0;
1101: stuff_page(&tid, &lnum);
1102: tid.line_id = 0;
1103: get_page(desc, &tid);
1104: concat(ISAM_SPOOL, Fileset, Mod_info.spfile);
1105: /* assume that spool file is not needed */
1106: spfp = NULL;
1107: Mod_info.spflag = FALSE;
1108: if (F_fac == 0)
1109: F_fac = 100;
1110: /* setup relgiven field for kcompare later on */
1111: for (i = 1; i <= desc->reldum.relatts; i++)
1112: desc->relgiven[i] = desc->relxtra[i];
1113: if (desc->reldum.reldim)
1114: Btree_fd = desc->btree_fd;
1115: }
1116: desc->reladds = 0;
1117: for (i = 0; i < desc->reldum.reldim; lid[i++] = 0)
1118: continue;
1119: anytups = FALSE;
1120: chkdups = !sortit && (newreltype != M_ORDER);
1121: # ifdef xZTR2
1122: if (tTf(36, 3))
1123: {
1124: printf(" FILLREL: ");
1125: printdesc(sdesc);
1126: printdesc(desc);
1127: }
1128: # endif
1129: for (;;)
1130: {
1131: w = (newreltype == M_ISAM) ? sdesc->reldum.relwid + desc->reldum.reldim * LIDSIZE : sdesc->reldum.relwid;
1132: if (sortit)
1133: {
1134: i = fread(tup_buf, 1, w, fp);
1135: if (i == 0)
1136: break;
1137: if (i != w)
1138: syserr("FILL_REL: fread A %d", i);
1139: if (newreltype == M_HASH && !desc->reldum.reldim)
1140: if (fread(junk, 1, 4, fp) != 4)
1141: syserr("FILL_REL: fread B");
1142: }
1143: else
1144: {
1145: # ifdef xZTR2
1146: if (tTf(36, 1))
1147: {
1148: printf("FILL_REL: stid ");
1149: dumptid(&stid);
1150: printf("FILL_REL: stidlim ");
1151: dumptid(&stidlim);
1152: }
1153: # endif
1154: i = get(sdesc, &stid, &stidlim, tup_buf, TRUE);
1155: # ifdef xZTR2
1156: if (tTf(36, 1))
1157: {
1158: printf("FILLREL: get %d ", i);
1159: printup(sdesc, tup_buf);
1160: }
1161: # endif
1162: if (i < 0)
1163: syserr("FILL_REL: get %d", i);
1164: if (i == 1)
1165: break;
1166: }
1167: if (newreltype != M_ISAM || (newreltype == M_ISAM && NLidKeys == 0 && desc->reldum.reldim > 0))
1168: {
1169: for (j = 0; j < desc->reldum.reldim; ++j)
1170: if (j < NLidKeys && j < desc->reldum.reldim - 1)
1171: {
1172: dp = tup_buf + (sdesc->reloff[LidKey[j]] & I1MASK);
1173: sp = last_tup + (sdesc->reloff[LidKey[j]] & I1MASK);
1174: if (!bequal(dp, sp, sdesc->relfrml[LidKey[j]]) || !lid[j])
1175: {
1176: ++lid[j];
1177: for (k = j + 1; k < desc->reldum.reldim; ++k)
1178: lid[k] = 0;
1179: break;
1180: }
1181: }
1182: else
1183: {
1184: if (!lid[0])
1185: {
1186: lid[0] = 1;
1187: if (!(desc->reldum.reldim -1))
1188: break;
1189: }
1190: ++lid[desc->reldum.reldim - 1];
1191: break;
1192: }
1193: Btree_fd = desc->btree_fd;
1194: if (!desc->reldum.reldim || NLidKeys > 0)
1195: {
1196: /* assume unordered so btree inserts done
1197: ** separately */
1198: temp = 0;
1199: if (desc->reldum.reldim > 0)
1200: {
1201: temp = desc->reldum.reldim;
1202: desc->reldum.reldim = 0;
1203: desc->reldum.relwid -= temp * LIDSIZE;
1204: }
1205: if ((i = insert(desc, &tid, tup_buf, chkdups)) < 0)
1206: syserr("FILL_REL: insert %d", i);
1207: if (NLidKeys > 0)
1208: {
1209: bmove(&tid, &stid, LIDSIZE);
1210: desc->reldum.reldim = temp;
1211: desc->reldum.relwid += temp * LIDSIZE;
1212: insert_mbtree(desc, Mod_info.btree, lid, &tid, &tidpos);
1213: }
1214: }
1215: if (desc->reldum.reldim && !NLidKeys)
1216: {
1217: /* new relation not changed, only lids added */
1218: page = RT;
1219: for (j = 0; j < desc->reldum.reldim - 1; ++j)
1220: {
1221: if (!lid[j])
1222: lid[j] = 1;
1223: if ((t = get_tid(page, lid[j], &tidloc)) < 0)
1224: {
1225: insert_btree(Mod_info.btree, page, lid[j], &ntid, &tidpos, j + 2);
1226: bmove(&ntid, &page, LIDSIZE);
1227: }
1228: else
1229: bmove(&t, &page, LIDSIZE);
1230: }
1231: insert_btree(Mod_info.btree, page, lid[abs(desc->reldum.reldim) - 1], &stid, &tidpos, FALSE);
1232: }
1233: bmove(tup_buf, last_tup, sdesc->reldum.relwid);
1234: if (desc->reldum.reldim > 0)
1235: {
1236: dp = tup_buf + desc->reldum.relwid - desc->reldum.reldim * LIDSIZE;
1237: bmove(lid, dp, LIDSIZE * desc->reldum.reldim);
1238: }
1239: # ifdef xZTR2
1240: if (tTf(36, 2))
1241: {
1242: printf("FILL_REL: insert ");
1243: printup(desc, tup_buf);
1244: printf("FILL_REL: insert ret %d at", i);
1245: dumptid(&tid);
1246: }
1247: # endif
1248: continue;
1249: }
1250: if (anytups)
1251: i = kcompare(desc, tup_buf, last_tup);
1252: else
1253: {
1254: anytups = TRUE;
1255: i = 1;
1256: }
1257: bmove(tup_buf, last_tup, desc->reldum.relwid);
1258: need = canonical(desc, tup_buf);
1259: if (i == 0 && need > space_left(Acc_head))
1260: {
1261: /* spool out this tuple. will go on overflow page later */
1262: if (spfp == NULL)
1263: {
1264: if ((spfp = fopen(Mod_info.spfile, "w")) == NULL)
1265: syserr("FILL_REL: fopen %.14s", Mod_info.spfile);
1266: Mod_info.spflag = TRUE;
1267: }
1268: if (fwrite(tup_buf, 1, desc->reldum.relwid, spfp) != desc->reldum.relwid)
1269: syserr("FILL_REL: putb spool");
1270: continue;
1271: }
1272: j = (100 - F_fac) * MAXTUP / 100;
1273: if (j < need)
1274: j = need;
1275: if (i != 0 && j > space_left(Acc_head))
1276: {
1277: if (i = add_prim(desc, &tid))
1278: syserr("FILL_REL: force ovflo %d", i);
1279: }
1280: tid.line_id = newlino(need);
1281: put_tuple(&tid, Acctuple, need);
1282: if (NLidKeys > 0)
1283: {
1284: bmove(tup_buf + desc->reldum.relwid - LIDSIZE * desc->reldum.reldim, lid, LIDSIZE * desc->reldum.reldim);
1285: page = RT;
1286: for (j = 0; j < desc->reldum.reldim; ++j)
1287: {
1288: if ((t = get_tid(page, lid[j], &tidloc)) < 0)
1289: syserr("get_tid error in modify isam ordered");
1290: page = t;
1291: }
1292: stuff_page(&btid, &tidloc.pageno);
1293: btid.line_id = tidloc.page.node.leafnode.tid_loc[tidloc.offset];
1294: /* place proper tid in tree */
1295: replace_btree(tid, &btid);
1296: }
1297: desc->reladds++;
1298: }
1299: if (sortit)
1300: {
1301: fclose(fp);
1302: unlink(Mod_info.outfile);
1303: }
1304: if (newreltype == M_ISAM && desc->reldum.reldim <= 0)
1305: {
1306: if (i = pageflush(Acc_head))
1307: syserr("fill_rel:pg clean %d", i);
1308: if (spfp != NULL)
1309: fclose(spfp);
1310: }
1311: if (!desc->reldum.reldim || NLidKeys > 0)
1312: desc->reldum.reltups = desc->reladds;
1313: desc->reladds = 0;
1314: return (0);
1315: }
1316:
1317:
1318: /*
1319: ** BLDINDEX -
1320: **
1321: ** Parameters:
1322: ** d - descriptor for relation
1323: **
1324: ** Return Codes:
1325: ** 0 - ok
1326: ** <0 - error
1327: **
1328: ** Trace Flags:
1329: ** Z38.7, Z38.8
1330: **
1331: ** Called by:
1332: ** modify
1333: **
1334: */
1335: bldindex(d)
1336: register DESC *d;
1337: {
1338: register TID *tid;
1339: register int tmp;
1340: TID tidx;
1341: struct accbuf dirbuf;
1342: int keywid, level, savespec, keyx[MAXDOM];
1343: int offset, len;
1344: char tuple[MAXTUP], temptup[MAXTUP], *key;
1345: long pageid, start, stop, newstart, newstop;
1346:
1347: tid = &tidx;
1348: keywid = 0;
1349: for (tmp = 0; tmp < MAXDOM; tmp++)
1350: keyx[tmp] = 0;
1351: for (tmp = 1; tmp <= d->reldum.relatts; tmp++)
1352: if (d->relxtra[tmp] > 0)
1353: {
1354: keyx[d->relxtra[tmp] - 1] = tmp;
1355: keywid += d->relfrml[tmp] & I1MASK;
1356: }
1357:
1358: /* Determine the last page of the relation. This will
1359: ** only work if all pages have been written out. Fill_rel
1360: ** must guarantee that all pages have been written
1361: */
1362: level = 0;
1363: last_page(d, tid, 0);
1364: pluck_page(tid, &stop);
1365: start = 0;
1366: dirbuf.filedesc = d->relfp;
1367: dirbuf.rel_tupid = d->reltid.ltid;
1368: savespec = d->reldum.relspec;
1369: for (;;)
1370: {
1371: # ifdef xZTR2
1372: if (tTf(38, 7))
1373: printf("isam: level %d\n", level);
1374: # endif
1375: dirbuf.ovflopg = start;
1376: dirbuf.mainpg = level;
1377: dirbuf.thispage = stop + 1;
1378: dirbuf.linetab[0] = (short) (dirbuf.firstup - (char *) &dirbuf);
1379: offset = dirbuf.linetab[0];
1380: dirbuf.bufstatus = BUF_DIRTY | BUF_DIRECT;
1381:
1382: dirbuf.nxtlino = 0;
1383: newstart = stop + 1;
1384: newstop = newstart;
1385: for (pageid = start; pageid <= stop; pageid++)
1386: {
1387: # ifdef xZTR2
1388: if (tTf(38, 8))
1389: printf("isam:get key from %ld\n", pageid);
1390: # endif
1391: stuff_page(tid, &pageid);
1392: tid->line_id = 0;
1393: if (tmp = get(d, tid, tid, tuple, FALSE))
1394: {
1395: /*
1396: ** If the relation is empty, then page 0 will
1397: ** return AMINVL_ERR on a get(). Form a blank tuple
1398: ** and use it to create a one tuple directory
1399: */
1400: if (pageid == 0 && tmp == AMINVL_ERR)
1401: {
1402: clr_tuple(d, tuple);
1403: }
1404: else
1405: {
1406: return (-2);
1407: }
1408: }
1409:
1410: /*
1411: ** If this is the first level then form the tuple
1412: ** from the mainpage of the relation. Otherwise
1413: ** the tuple is the first tuple of a directory page
1414: ** and it is already correctly formed.
1415: */
1416: if (level == 0)
1417: {
1418: key = temptup;
1419: for (tmp = 0; keyx[tmp] != 0; tmp++)
1420: {
1421: len = d->relfrml[keyx[tmp]] & I1MASK;
1422: bmove(&tuple[d->reloff[keyx[tmp]]], key, len);
1423: key += len;
1424: }
1425: key = temptup;
1426: }
1427: else
1428: key = tuple;
1429:
1430: if (keywid > space_left(&dirbuf))
1431: {
1432: if (pageflush(&dirbuf))
1433: return (-3);
1434: dirbuf.thispage++;
1435: newstop = dirbuf.thispage;
1436: dirbuf.ovflopg = pageid;
1437: dirbuf.linetab[0] = (short) (dirbuf.firstup - (char *) &dirbuf);
1438: offset = dirbuf.linetab[0];
1439: dirbuf.bufstatus = BUF_DIRTY;
1440: dirbuf.nxtlino = 0;
1441: }
1442: /* copy key to directory page */
1443: bmove(key, (char *) &dirbuf + offset, keywid);
1444:
1445: /* update next line number */
1446: offset += keywid;
1447: dirbuf.nxtlino++;
1448: dirbuf.linetab[-dirbuf.nxtlino] = offset;
1449: }
1450: if (pageflush(&dirbuf))
1451: return (-4);
1452: if (newstart == newstop)
1453: break;
1454: d->reldum.relspec = abs(d->reldum.relspec);
1455: level++;
1456: start = newstart;
1457: stop = newstop;
1458: }
1459: d->reldum.relspec = savespec;
1460: d->reldum.relprim = newstart;
1461: return (0);
1462: }
1463: /*
1464: ** UNSPOOL -- Take tuples saved in spool file and insert them
1465: ** in new relation. This is only for ISAM relations.
1466: */
1467:
1468: unspool(sdesc, desc)
1469: register DESC *sdesc, *desc;
1470: {
1471: register int i, j;
1472: TID tid, btid;
1473: char tup_buf[MAXTUP], tup[2 * LIDSIZE];
1474: FILE *spfp;
1475: long lid[MAXLID], page, t;
1476: int w;
1477: struct locator tidpos;
1478:
1479: w = sdesc->reldum.relwid + desc->reldum.reldim * LIDSIZE;
1480: if (Mod_info.spflag)
1481: {
1482: if ((spfp = fopen(Mod_info.spfile, "r")) == NULL)
1483: syserr("UNSPOOL: fopen spool");
1484: while ((i = fread(tup_buf, 1, w, spfp)) == w)
1485: {
1486: if ((i = insert(desc, &tid, tup_buf, FALSE)) < 0)
1487: syserr("UNSPOOL: insert %.14s %d", desc->reldum.relid, i);
1488: if (NLidKeys > 0)
1489: {
1490: bmove(tup_buf + desc->reldum.relwid - LIDSIZE * desc->reldum.reldim, lid, LIDSIZE * desc->reldum.reldim);
1491: page = RT;
1492: for (j = 0; j < desc->reldum.reldim; ++j)
1493: {
1494: if ((t = get_tid(page, lid[j], &tidpos)) < 0)
1495: syserr("get_tid error in unspool");
1496: page = t;
1497: }
1498: stuff_page(&btid, &tidpos.pageno);
1499: btid.line_id = tidpos.page.node.leafnode.tid_loc[tidpos.offset];
1500: replace_btree(tid, &btid);
1501: }
1502: }
1503: if (i != 0)
1504: syserr("UNSPOOL: read %d", i);
1505: fclose(spfp);
1506: unlink(Mod_info.spfile);
1507: }
1508: desc->reldum.reltups += desc->reladds;
1509: desc->reladds = 0;
1510: return (0);
1511: }
1512: /*
1513: ** FILL_BATCH -- Create and fill a batch file containing the
1514: ** updates for the system catalog so that MODIFY will
1515: ** be recoverable if the system crashes.
1516: */
1517:
1518: fill_batch(odesc, desc)
1519: DESC *odesc;
1520: register DESC *desc;
1521: {
1522: register DESC *dessys;
1523: register int i, k;
1524: struct relation reltup, rkey;
1525: TID tid, lotid, hitid;
1526: struct attribute atttup, akey;
1527: int numatts, j;
1528: char prebatch[MAXNAME + 4], modbatch[MAXNAME + 4];
1529:
1530: if (bequal(desc->reldum.relid, "relation ", 12))
1531: {
1532: clearkeys(desc);
1533: setkey(desc, &rkey, desc->reldum.relid, RELID);
1534: setkey(desc, &rkey, desc->reldum.relowner, RELOWNER);
1535: if (i = getequal(desc, &rkey, &reltup, &tid))
1536: syserr("FILL_BATCH: geteq rel rel %d", i);
1537: bmove(&tid, &desc->reltid, sizeof desc->reltid);
1538: }
1539: else
1540: bmove(&odesc->reltid, &desc->reltid, sizeof desc->reltid);
1541: resetacc(Acc_head);
1542: concat(MOD_PREBATCH, Fileset, prebatch);
1543: close(creat(prebatch, FILEMODE));
1544: if ((Batch_fp = open(prebatch, O_RDWR)) < 0)
1545: syserr("FILL_BATCH: open %.14s %d", prebatch, Batch_fp);
1546: smove(Fileset, Batchbuf.file_id);
1547: Batch_cnt = 0;
1548: wrbatch(desc, sizeof *desc);
1549: if (bequal(desc->reldum.relid, "attribute ", 12))
1550: dessys = desc;
1551: else
1552: dessys = &Admin.adattd;
1553: clearkeys(dessys);
1554: setkey(dessys, &akey, desc->reldum.relid, ATTRELID);
1555: setkey(dessys, &akey, desc->reldum.relowner, ATTOWNER);
1556: if (i = find(dessys, EXACTKEY, &lotid, &hitid, &akey))
1557: syserr("FILL_BATCH: find %d", i);
1558:
1559: /* if ordered relation, one of attributes is LID field */
1560: numatts = j = desc->reldum.relatts - desc->reldum.reldim;
1561:
1562: while(!(i = get(dessys, &lotid, &hitid, &atttup, TRUE)) && j > 0)
1563: if (!kcompare(dessys, &akey, &atttup))
1564: if (atttup.attid <= numatts)
1565: {
1566: j--;
1567: atttup.attxtra = desc->relxtra[atttup.attid];
1568: wrbatch(&lotid, sizeof lotid);
1569: wrbatch(&atttup, sizeof atttup);
1570: }
1571: for (k = 1; k <= desc->reldum.reldim; ++k)
1572: /* create new tuple corresponding to LID field; LID field is the
1573: ** last field of relation, a 4-byte integer
1574: */
1575: {
1576: smove(desc->reldum.relid, atttup.attrelid);
1577: bmove(desc->reldum.relowner, atttup.attowner, 2);
1578: atttup.attid = numatts + k;
1579: smove(Lid[k - 1], atttup.attname);
1580: pad(atttup.attname, MAXNAME);
1581: atttup.attoff = desc->reldum.relwid - (desc->reldum.reldim - k + 1) * LIDSIZE;
1582: atttup.attfrmt = INT;
1583: atttup.attfrml = LIDSIZE;
1584: atttup.attxtra = 0;
1585: wrbatch(&atttup, sizeof atttup);
1586: }
1587: if (i < 0 || j > 0)
1588: syserr("FILL_BATCH: get att %d count %d", i, j);
1589: /* get rid of attribute pages */
1590: cleanrel(dessys);
1591: flushbatch();
1592: close(Batch_fp);
1593: concat(MODBATCH, Fileset, modbatch);
1594: if (link(prebatch, modbatch) == -1)
1595: syserr("FILL_BATCH: can't link %.14s %.14s",
1596: prebatch, modbatch);
1597: unlink(prebatch);
1598: return (0);
1599:
1600: }
1601:
1602: /*
1603: ** MAKE_BSEC -- Creates the seecondary btree relation by first creating
1604: ** a heaped relation. The main relation tids are found by
1605: ** scanning the leaves of the btree. The relation is then
1606: ** modified to an isam relation.
1607: */
1608:
1609: make_bsec(relname, dim)
1610: char *relname;
1611: int dim;
1612: {
1613: PARM pv[8];
1614: register int i;
1615: DESC bdesc;
1616: TID tid, btid;
1617: long mtid, page, t, next;
1618: char tuple[2 * LIDSIZE], btree[MAXNAME], btreefile[MAXNAME + 4];
1619: struct locator tidpos;
1620: extern char *iocv();
1621: extern DESC Reldes;
1622:
1623: pv[0].pv_val.pv_str = "0000002";
1624: capital(trim_relname(relname), btree);
1625: pv[1].pv_val.pv_str = btree;
1626: pv[2].pv_val.pv_str = "mtid";
1627: pv[3].pv_val.pv_str = "i4";
1628: pv[4].pv_val.pv_str = "btid";
1629: pv[5].pv_val.pv_str = "i4";
1630: pv[6].pv_type = PV_EOF;
1631: if (create(6, pv))
1632: syserr("can't create btreesec %s", pv[1].pv_val.pv_str);
1633:
1634: if (noclose(&Reldes))
1635: syserr("noclose in make_bsec");
1636:
1637: if (i = openr(&bdesc, OR_WRITE, btree))
1638: syserr("opening bsec relation %d", i);
1639: btreename(relname, btreefile);
1640: if ((Btree_fd = open(btreefile, O_RDWR)) < 0)
1641: syserr("make_bsec: can't open %s", btreefile);
1642: page = RT;
1643: for (i = 0; i < dim - 1; ++i)
1644: {
1645: t = get_tid(page, 1, &tidpos);
1646: if (t < 0)
1647: break; /* lid value doesn't exist */
1648: bmove(&t, &page, LIDSIZE);
1649: }
1650: if (t >= 0) /* only do inserts if there are lids! */
1651: {
1652: do
1653: {
1654: get_node(page, &tidpos.page);
1655: next = tidpos.page.nexttree;
1656: get_tid(page, 1, &tidpos);
1657: page = tidpos.pageno;
1658: for (;;)
1659: /* scan through leaves of btree */
1660: {
1661: stuff_page(&btid, &page);
1662: for (i = 0; i < tidpos.page.nelmts; ++i)
1663: {
1664: btid.line_id = tidpos.page.node.leafnode.tid_loc[i];
1665: mtid = tidpos.page.node.leafnode.tid_pos[btid.line_id];
1666: /* form tuple */
1667: bmove(&mtid, tuple, LIDSIZE);
1668: bmove(&btid, tuple + LIDSIZE, LIDSIZE);
1669: if (insert(&bdesc, &tid, tuple, TRUE) < 0)
1670: syserr("insert error in btreesec");
1671: }
1672: page = tidpos.page.node.leafnode.nextleaf;
1673: if (page == NULL)
1674: break;
1675: else
1676: get_node(page, &tidpos.page);
1677: }
1678: } while (page = next);
1679: }
1680: close(Btree_fd);
1681: closer(&bdesc);
1682:
1683: /* modify to isam on mtid */
1684: pv[0].pv_val.pv_str = btree;
1685: pv[1].pv_val.pv_str = "isam";
1686: pv[2].pv_val.pv_str = "name";
1687: pv[3].pv_val.pv_str = "mtid";
1688: pv[4].pv_val.pv_str = "\0";
1689: pv[5].pv_val.pv_str = "fillfactor";
1690: /* use fillfactor provided for main relation */
1691: if (F_fac == 0)
1692: pv[6].pv_val.pv_str = iocv(80);
1693: else
1694: pv[6].pv_val.pv_str = iocv(F_fac);
1695: pv[7].pv_type = PV_EOF;
1696: if (modify(7, pv))
1697: syserr("can't modify btreesec to isam");
1698: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.