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