![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rmqm.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 rmqm.c CVS log | Up to [CSRG BSD Unix] / 43BSD / ingres / source / dbu |
1.1 root 1: # include <pv.h>
2: # include <ingres.h>
3: # include <access.h>
4: # include <aux.h>
5: # include <catalog.h>
6: # include <symbol.h>
7: # include <func.h>
8: # include <sccs.h>
9: # include <errors.h>
10:
11: SCCSID(@(#)rmqm.c 8.3 2/8/85)
12:
13: /*
14: ** RMQM -- DBU to delete protection and integrity constraints
15: **
16: ** Trace Flags:
17: ** 43
18: */
19:
20:
21: extern short tTdbu[];
22: extern int dest_const();
23: extern int null_fn();
24:
25: struct fn_def RmqmFn =
26: {
27: "RMQM",
28: dest_const,
29: null_fn,
30: null_fn,
31: NULL,
32: 0,
33: tTdbu,
34: 100,
35: 'Z',
36: 0
37: };
38: /*
39: ** DEST_CONST -- destroy constraints
40: **
41: ** Parameters:
42: ** pc -- number of parameters in pv
43: ** pv -- pv [0] == DESTPROT destroy permission
44: ** == DESTINTEG destroy integrity constraint
45: ** pv [1] relation from which to destroy constraint
46: ** pv [2] == if (pc != 2) relation from which to delete
47: ** constraints
48: ** pv[3] ... pv[pc - 1] == id of constraint
49: **
50: ** Returns:
51: ** 0
52: **
53: ** Side Effects:
54: ** destroys constraints. Involves activity on catalogs 'relation',
55: ** protect, integrities, and tree.
56: **
57: ** Trace Flags:
58: ** 43, 0
59: */
60:
61: dest_const(pc, pv)
62: int pc;
63: PARM pv[];
64: {
65: DESC d;
66: register int i;
67: int mode;
68: extern struct admin Admin;
69:
70: # ifdef xZTR1
71: if (tTf(43, 0))
72: {
73: printf("dest_const: ");
74: prvect(pc, pv);
75: }
76: # endif
77:
78: if (!(Admin.adhdr.adflags & A_QRYMOD))
79: return (0);
80: i = openr(&d, OR_RELTID, pv[1].pv_val.pv_str);
81: if (i < 0)
82: syserr("dest_const: openr(%s) %d", pv[1].pv_val.pv_str, i);
83:
84: if (i == 1 || !bequal(Usercode, d.reldum.relowner, UCODE_SZ))
85: {
86: error(RELNOEXIST, pv[1].pv_val.pv_str, 0);
87: return (0);
88: }
89:
90: mode = atoi(pv[0].pv_val.pv_str);
91: if (mode == DESTPROT)
92: dest_prot(&d, &pv[2]);
93: else if (mode == DESTINTEG)
94: dest_integ(&d, &pv[2]);
95: else
96: syserr("dest_const: bad mode %d", mode);
97: return (0);
98: }
99: /*
100: ** DEST_INTEG -- directs destruction of integrity constraints
101: **
102: ** Parameters:
103: ** desc -- descriptor for relation
104: ** intv -- PV_EOF terminated list of id strings, if first element
105: ** is PV_EOF means "all"
106: **
107: ** Returns:
108: ** none
109: **
110: ** Side Effects:
111: ** deletes integrity constraint. Activity on 'relation', integrities,
112: ** and tree.
113: */
114:
115: dest_integ(d, intv)
116: register DESC *d;
117: PARM intv[];
118: {
119: extern DESC Intdes;
120: struct integrity tuple, key;
121: struct tree tkey;
122: register i, j;
123: int tree_const();
124: int int_inttree();
125:
126: # ifdef xZTR1
127: if (tTf(43, 1))
128: printf("dest_integ((%s, %s)...)\n", d->reldum.relid, d->reldum.relowner);
129: # endif
130:
131: i_cat("integrities", &Intdes, &key, d->reldum.relid, INTRELID,
132: d->reldum.relowner, INTRELOWNER, mdINTEG, &tkey);
133:
134: if (intv[0].pv_type == PV_EOF)
135: {
136: /* destroy integrity 'relation' ALL */
137: if (!(d->reldum.relstat & S_INTEG))
138: return (0);
139: del_all(d, &Intdes, &key, &tuple, &tkey, S_INTEG,
140: tree_const, int_inttree);
141: return (0);
142: }
143: /* destroy integrity 'relation' int {, int} */
144: for (i = 0; intv[i].pv_type != PV_EOF; i++)
145: del_int(&Intdes, &key, &tuple, &tkey, intv[i].pv_val.pv_str, INTTREE,
146: tree_const, int_inttree);
147:
148: /* rescan to output error messages */
149: for (j = 0; j < i; j++)
150: if (*(intv[j].pv_val.pv_str))
151: error(BADINTEG, intv[j].pv_val.pv_str, 0);
152:
153: /* finally, check that there are still integrity constraints
154: ** on the relation, if not must reset the S_INTEG bit in the relation
155: ** relation tuple for that relation.
156: */
157: chk_const(d, &Intdes, &key, &tuple, d->reldum.relid, INTRELID, d->reldum.relowner,
158: INTRELOWNER, S_INTEG);
159: }
160: /*
161: ** DEST_PROT -- directs destruction of protection constraints
162: **
163: ** Parameters:
164: ** desc -- descriptor for relation
165: ** intv -- PV_EOF terminated list of id strings, if first element
166: ** is PV_EOF means "all"
167: **
168: ** Returns:
169: ** none
170: **
171: ** Side Effects:
172: ** deletes protection constraint. Activity on 'relation',
173: ** protect, and tree.
174: **
175: ** Trace Flags:
176: ** 43, 2
177: */
178:
179:
180: dest_prot(d, intv)
181: register DESC *d;
182: PARM intv[];
183: {
184: extern DESC Prodes;
185: struct protect tuple, key;
186: struct tree tkey;
187: register i, j;
188: int propermid;
189: int prot_protree();
190: int tree_prot();
191:
192: # ifdef xZTR1
193: if (tTf(43, 2))
194: printf("dest_prot((%s, %s)...)\n", d->reldum.relid, d->reldum.relowner);
195: # endif
196:
197: i_cat("protect", &Prodes, &key, d->reldum.relid, PRORELID, d->reldum.relowner,
198: PRORELOWN, mdPROT, &tkey);
199:
200: if (intv[0].pv_type == PV_EOF)
201: {
202: /* destroy permit 'relation' ALL */
203: if (!(d->reldum.relstat & S_PROTRET) || !(d->reldum.relstat & S_PROTALL))
204: r_relstat(d, S_PROTRET | S_PROTALL, 1);
205: if (!(d->reldum.relstat & S_PROTUPS))
206: return (0);
207: del_all(d, &Prodes, &key, &tuple, &tkey, S_PROTUPS,
208: tree_prot, prot_protree);
209: return (0);
210: }
211: /* destroy permit 'relation' int {, int} */
212: for (i = 0; intv[i].pv_type != PV_EOF; i++)
213: {
214: propermid = atoi(intv[i].pv_val.pv_str);
215: if (propermid == 0)
216: {
217: if (!(d->reldum.relstat & S_PROTALL))
218: {
219: r_relstat(d, S_PROTALL, 1);
220: intv[i].pv_val.pv_str = 0;
221: }
222: continue;
223: }
224: else if (propermid == 1)
225: {
226: if (!(d->reldum.relstat & S_PROTRET))
227: {
228: r_relstat(d, S_PROTRET, 1);
229: intv[i].pv_val.pv_str = 0;
230: }
231: continue;
232: }
233: del_int(&Prodes, &key, &tuple, &tkey, intv[i].pv_val.pv_str, PROPERMID,
234: tree_prot, prot_protree);
235: }
236: /* rescan to output error messages */
237: for (j = 0; j < i; j++)
238: if (intv[j].pv_val.pv_str && intv[j].pv_val.pv_str[0] )
239: error(BADPROT, intv[j].pv_val.pv_str, 0);
240:
241: /* finally, check that there are still permissions
242: ** on the relation, if not must reset the S_PROTUPS bit in the relation
243: ** relation tuple for that relation's relstat.
244: */
245: chk_const(d, &Prodes, &key, &tuple, d->reldum.relid, PRORELID,
246: d->reldum.relowner, PRORELOWN, S_PROTUPS);
247: }
248: /*
249: ** I_CAT -- prepare catalogs for deletin of constraint
250: **
251: ** Initializes treerelid, treeowner, and treetype fields
252: ** of tree key. Also relation id and owner fields of
253: ** appropriate catalog c_desc, with key 'key'.
254: **
255: ** Parameters:
256: ** c_name -- name of catalog for opencatalog
257: ** c_desc -- descriptor of catalog
258: ** key -- key for catalog
259: ** relid -- relation.relid for relation to be de-constrained
260: ** id_attno -- attno of relid in constraint catalog c_desc
261: ** relowner -- relation.relowner for rel to be de-constrained
262: ** own_attno -- attno of owner in constrain catalog
263: ** type -- treetype for tree tuple (depends on catalog)
264: ** tkey -- key for tree catalog
265: **
266: ** Returns:
267: ** none
268: **
269: ** Side Effects:
270: ** opencatalogs the constraint catalog c_desc, and the "tree" rel
271: ** for READ/WRITE. Sets keys.
272: **
273: ** Trace Flags:
274: ** 43, 3
275: */
276:
277: i_cat(c_name, c_desc, key, relid, id_attno, relowner, own_attno, type, tkey)
278: char *c_name;
279: DESC *c_desc;
280: char *key;
281: char *relid;
282: int id_attno;
283: char *relowner;
284: int own_attno;
285: int type;
286: struct tree *tkey;
287: {
288: extern DESC Treedes;
289: char realtype;
290:
291: # ifdef xZTR1
292: if (tTf(43, 3))
293: printf("i_cat(c_name \"%s\", relid %s id_attno %d relowner %s own_attno %d type %d)\n",
294: c_name, relid, id_attno, relowner, own_attno, type);
295: # endif
296:
297: realtype = type;
298: opencatalog("tree", OR_WRITE);
299: setkey(&Treedes, tkey, relid, TREERELID);
300: setkey(&Treedes, tkey, relowner, TREEOWNER);
301: setkey(&Treedes, tkey, &realtype, TREETYPE);
302: opencatalog(c_name, OR_WRITE);
303: clearkeys(c_desc);
304: setkey(c_desc, key, relid, id_attno);
305: setkey(c_desc, key, relowner, own_attno);
306: }
307: /*
308: ** DEL_ALL -- delete all constraints for a given relation
309: **
310: ** Deletes all constraints of a given type given by a constraint
311: ** catalog 'c_desc'. Note that Protection constraints 0 & 1, given
312: ** by relation.relstat field are not deleted here.
313: **
314: ** Parameters:
315: ** r_desc -- descriptor for relation to de-constrain (for
316: ** r_relstat)
317: ** c_desc -- constraint catalog descriptor
318: ** key -- c_desc's key
319: ** tuple -- c_desc's tuple (needed because sizeof tuple is not
320: ** known here, so must be allocated beforehand)
321: ** tkey -- tree key with TREERELID and TREERELOWNER setkeyed
322: ** bit -- bits in relstat to reset after deleting all constraints
323: ** tree_pred -- called with constraint tuple to determine
324: ** wether a tree tuple is present or not (as can happen
325: ** for protect catalog)
326: ** tree_field -- should return the treeid from tuple
327: **
328: ** Returns:
329: ** none
330: **
331: ** Side Effects:
332: ** tree and constraint catalog activity
333: **
334: ** Requires:
335: ** del_tree()
336: ** r_relstat()
337: **
338: ** Called By:
339: ** dest_????
340: **
341: ** Trace Flags:
342: ** 43, 4
343: **
344: ** Syserrs:
345: ** bad find, get, delete, flush_rel
346: **
347: ** History:
348: ** 1/10/79 -- (marc) written
349: */
350:
351: del_all(r_desc, c_desc, key, tuple, tkey, bit, tree_pred, tree_field)
352: DESC *r_desc;
353: DESC *c_desc;
354: char *key;
355: char *tuple;
356: struct tree *tkey;
357: int bit;
358: int (*tree_pred)();
359: int (*tree_field)();
360: {
361: TID lotid, hitid;
362: register int i;
363:
364: # ifdef xZTR1
365: if (tTf(43, 4))
366: printf("del_all(bit=0%o)\n", bit);
367: # endif
368:
369: if (i = find(c_desc, EXACTKEY, &lotid, &hitid, key))
370: syserr("del_all: find %d", i);
371: while (!(i = get(c_desc, &lotid, &hitid, tuple, TRUE)))
372: {
373: if (!kcompare(c_desc, tuple, key))
374: {
375: /* for each constraint of for a relation */
376: if (i = delete(c_desc, &lotid))
377: syserr("del_all: delete %d", i);
378: /* for crash recovery */
379: if (i = flush_rel(c_desc, FALSE))
380: syserr("del_all: flush_rel %d", i);
381: /* if there is a tree tuple, destroy it */
382: if ((*tree_pred)(tuple))
383: del_tree(tkey, (*tree_field)(tuple));
384: }
385: }
386: if (i != 1)
387: syserr("del_all: get %d", i);
388: /* turn off bit in relstat field */
389: r_relstat(r_desc, bit, 0);
390: }
391: /*
392: ** DEL_INT -- delete from a constraint catalog a constraint
393: **
394: ** Parameters:
395: ** c_desc -- catalog descriptor
396: ** key -- catalog key
397: ** tuple -- catalog tuple (needed because tuple size unknown here)
398: ** tkey -- tree key with TREERELID and TREERELOWNER setkeyed
399: ** constid -- integer constraint id in string form
400: ** constattno -- attno of comstraint number in c_desc
401: ** tree_pred -- predicate on existence of tree tuple
402: ** tree_field -- returns treeid from constrain tuple
403: **
404: ** Returns:
405: ** none
406: **
407: ** Side Effects:
408: ** constraint and tree catalog activity.
409: ** *constid set to 0 if constraint id exists.
410: **
411: ** Requires:
412: ** del_tree()
413: **
414: ** Called By:
415: ** dest_????
416: **
417: ** Trace Flags:
418: ** 43, 5
419: **
420: ** Syserrs:
421: ** bad atoi (parser error), getequal, delete, flush_rel
422: **
423: ** History:
424: ** 1/10/79 -- (marc) written
425: */
426:
427: del_int(c_desc, key, tuple, tkey, constid, constattno, tree_pred, tree_field)
428: DESC *c_desc;
429: char *key;
430: char *tuple;
431: struct tree *tkey;
432: char *constid;
433: int constattno;
434: int (*tree_pred)();
435: int (*tree_field)();
436: {
437: TID tid;
438: register int i;
439: short constnum;
440:
441: # ifdef xZTR1
442: if (tTf(43, 5))
443: printf("del_int(constid=%s, constattno=%d)\n",
444: constid, constattno);
445: # endif
446:
447: constnum = atoi(constid);
448: setkey(c_desc, key, &constnum, constattno);
449: if (!(i = getequal(c_desc, key, tuple, &tid)))
450: {
451: if (i = delete(c_desc, &tid))
452: syserr("del_int(%d) %d", constid, i);
453: if ((*tree_pred)(tuple))
454: del_tree(tkey, (*tree_field)(tuple));
455: *constid = '\0';
456: return;
457: }
458: else if (i != 1)
459: syserr("dest_int: getequal %d", i);
460: /* bad constnum */
461: }
462: /*
463: ** DEST_TREE -- destroy a tree tuple with for a given treeid
464: **
465: ** Deletes all tuples from tree with 'treeid' and previously set
466: ** keys.
467: **
468: ** Parameters:
469: ** key -- tre key
470: ** treeid -- integer treeid
471: **
472: ** Returns:
473: ** none
474: **
475: ** Side Effects:
476: ** tree activity
477: **
478: ** Trace Flags:
479: ** 43, 6
480: */
481:
482: del_tree(key, treeid)
483: struct tree *key;
484: int treeid;
485: {
486: struct tree tuple;
487: TID lotid, hitid;
488: register int i;
489: register int flag;
490: short realid;
491: extern DESC Treedes;
492:
493: # ifdef xZTR1
494: if (tTf(43, 6))
495: printf("del_tree(treeid=%d)\n", treeid);
496: # endif
497:
498: realid = treeid;
499: setkey(&Treedes, key, &realid, TREEID);
500: if (i = find(&Treedes, EXACTKEY, &lotid, &hitid, key))
501: syserr("del_tree: bad find %d treeid %d", i, treeid);
502: flag = 0;
503: while (!(i = get(&Treedes, &lotid, &hitid, &tuple, TRUE)))
504: {
505: if (!kcompare(&Treedes, &tuple, key))
506: {
507: if (i = delete(&Treedes, &lotid))
508: syserr("del_tree: delete treeid %d %d", treeid, i);
509: if (!flag)
510: flag++;
511: }
512: }
513: if (i != 1)
514: syserr("del_tree: bad get %d", i);
515: if (!flag)
516: syserr("del_tree: no tuples qualified treeid %d", treeid);
517: if (i = flush_rel(&Treedes, FALSE))
518: syserr("del_tree: flush_rel(&Treedes) %d", i);
519: }
520: /*
521: ** CHK_CONST -- check constraint catlg for tuples for a rel, and reset relatin.relstat
522: **
523: ** Parameters:
524: ** r_desc -- reon desc for de-constrained relation
525: ** c_desc -- catalog desc
526: ** key -- catalog key (here unknown size)
527: ** tuple -- " tuple space " " " " "
528: ** relid -- relation name
529: ** id_attno -- attno of relid
530: ** relowner -- relation owner
531: ** own_attno -- relowner attno
532: ** bit -- bits to reset in relstat if there are no constraints left
533: **
534: ** Returns:
535: ** none
536: **
537: ** Side Effects:
538: ** reads catalog, maybe changes relstat field of relation
539: ** relations's r_desc tuple
540: **
541: ** Trace Flags:
542: ** 43, 7
543: */
544:
545: chk_const(r_desc, c_desc, key, tuple, relid, id_attno, relowner, own_attno, bit)
546: DESC *r_desc;
547: DESC *c_desc;
548: char *key;
549: char *tuple;
550: char *relid;
551: int id_attno;
552: char *relowner;
553: int own_attno;
554: int bit;
555: {
556: TID tid;
557: register int i;
558:
559:
560: # ifdef xZTR1
561: if (tTf(43, 7))
562: printf("chk_const: relid %s id_attno %d relowner %s own_attno %d bit 0%o)\n",
563: relid, id_attno, relowner, own_attno, bit);
564: # endif
565:
566: clearkeys(c_desc);
567: setkey(c_desc, key, relid, id_attno);
568: setkey(c_desc, key, relowner, own_attno);
569: if ((i = getequal(c_desc, key, tuple, &tid)) == 1)
570: r_relstat(r_desc, bit, 0);
571: else if (i < 0)
572: syserr("chk_const: getequal %d", i);
573: }
574: /*
575: ** R_RELSTAT -- set or reset bits in the relation.relstat field
576: **
577: ** Does the above for relation described by desc.
578: **
579: ** Parameters:
580: ** d -- relation to have relation.relstat field changed
581: ** bit -- bits to set or reset
582: ** action -- 0 reset, 1 set
583: **
584: ** Returns:
585: ** none
586: **
587: ** Side Effects:
588: ** relation is opened for READ/WRITE, relstat changed
589: **
590: ** Trace Flags:
591: ** 43, 8
592: */
593:
594:
595: r_relstat(d, bit, action)
596: register DESC *d;
597: int bit;
598: int action;
599: {
600: struct relation tuple, key;
601: TID tid;
602: register int i;
603: extern DESC Reldes;
604:
605: # ifdef xZTR1
606: if (tTf(43, 8))
607: printf("r_relstat(bit=0%o, action %d)\n",
608: bit, action);
609: # endif
610:
611: opencatalog("relation", OR_WRITE);
612: clearkeys(&Reldes);
613: setkey(&Reldes, &key, d->reldum.relid, RELID);
614: setkey(&Reldes, &key, d->reldum.relowner, RELOWNER);
615: if (i = getequal(&Reldes, &key, &tuple, &tid))
616: syserr("r_relstat: getequal %s, %s, %d", d->reldum.relid,
617: d->reldum.relowner, i);
618: if (action)
619: {
620: if (tuple.relstat == (i = tuple.relstat | bit))
621: return;
622: tuple.relstat = i;
623: }
624: else
625: {
626: if (tuple.relstat == (i = tuple.relstat & ~bit))
627: return;
628: tuple.relstat = i;
629: }
630: if ((i = replace(&Reldes, &tid, &tuple, 0)) < 0 || i == 2)
631: syserr("r_relstat: replace %d", i);
632: if (i = flush_rel(&Reldes, FALSE))
633: syserr("r_relstat: flush_rel(&Reldes) %d", i);
634: }
635: /*
636: ** TREE_CONST -- True predicate
637: **
638: ** Called indirectly by routines wishing to know if
639: ** a integrity constraint has an associated tree tuple.
640: ** As this is always the case, returns TRUE always.
641: **
642: ** Parameters:
643: ** i -- integrity tuple
644: **
645: ** Returns:
646: ** TRUE
647: **
648: ** Side Effects:
649: ** none
650: **
651: ** Trace Flags:
652: ** 43, 9
653: */
654:
655: tree_const(i)
656: struct integrity *i;
657: {
658: # ifdef xZTR1
659: if (tTf(43, 9))
660: printf("tree_const()\n");
661: # endif
662:
663: return (TRUE);
664: }
665: /*
666: ** TREE_PROT -- Protection tuple tree predicate
667: **
668: ** Called indirectly by routines wishing to know if
669: ** a protection constraint has an associated tree tuple.
670: **
671: ** Parameters:
672: ** p -- protect tuple
673: **
674: ** Returns:
675: ** TRUE -- if p->protree != -1
676: ** FLASE -- otherwise
677: **
678: ** Side Effects:
679: ** none
680: **
681: ** Trace Flags:
682: ** 43, 9
683: */
684:
685: tree_prot(p)
686: struct protect *p;
687: {
688: # ifdef xZTR1
689: if (tTf(43, 9))
690: printf("tree_prot(p->protree=%d)\n", p->protree);
691: # endif
692:
693: if (p->protree == -1)
694: return (FALSE);
695: else
696: return (TRUE);
697: }
698: /*
699: ** PROT_PROTREE -- get protree field of a protection tuple
700: **
701: ** Parameters:
702: ** p -- protect tuple
703: **
704: ** Returns:
705: ** p->protree
706: **
707: ** Side Effects:
708: ** none
709: **
710: ** Trace Flags:
711: ** 43, 9
712: */
713:
714: prot_protree(p)
715: struct protect *p;
716: {
717: # ifdef xZTR1
718: if (tTf(43, 9))
719: printf("prot_protree(protree=%d)\n", p->protree);
720: # endif
721:
722: return (p->protree);
723: }
724: /*
725: ** INT_INTTREE -- get inttree field of a integrity tuple
726: **
727: ** Parameters:
728: ** i -- integrity tuple
729: **
730: ** Returns:
731: ** i->inttree
732: **
733: ** Side Effects:
734: ** none
735: **
736: ** Trace Flags:
737: ** 43, 9
738: */
739:
740: int_inttree(i)
741: struct integrity *i;
742: {
743: # ifdef xZTR1
744: if (tTf(43, 9))
745: printf("int_inttree(inttree=%d)\n", i->inttree);
746: # endif
747:
748: return (i->inttree);
749: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.