4.3BSD - /usr/ingres/source/dbu/display.c

   1: # include   <ingres.h>
   2: # include   <aux.h>
   3: # include   <catalog.h>
   4: # include   <tree.h>
   5: # include   <symbol.h>
   6: # include   <access.h>
   7: # include   <func.h>
   8: # include   <pv.h>
   9: # include   <sccs.h>
  10: # include   <errors.h>
  11: 
  12: SCCSID(@(#)display.c	8.3	2/8/85)
  13: 
  14: /*
  15: **  DISPLAY -- display query corresponding to view, permission,
  16: **		or intgerity declaration
  17: */
  18: 
  19: 
  20: 
  21: 
  22: extern short    tTdbu[];
  23: extern int  display();
  24: extern int  null_fn();
  25: 
  26: struct fn_def DsplayFn =
  27: {
  28:     "DISPLAY",
  29:     display,
  30:     null_fn,
  31:     null_fn,
  32:     NULL,
  33:     0,
  34:     tTdbu,
  35:     100,
  36:     'Z',
  37:     0
  38: };
  39: /*
  40: **  DISPLAY -- display query
  41: **
  42: **	Parameters:
  43: **		pc -- number of args in pv
  44: **		pv -- pv[i] == 4 for VIEW, 5 for PERMIT, 6 for INTEGRITY
  45: **				where i % 2 == 0
  46: **		pv[i] -- relation names for which pv[i-1] is mode
  47: **				where i%2==1
  48: **
  49: **	Returns:
  50: **		0 -- total success
  51: **		err -- error number of last error
  52: **
  53: **	Side Effects:
  54: **		prints out definition of appropriate characteristic of relation
  55: **
  56: **	Trace Flags:
  57: **		33, -1
  58: */
  59: 
  60: 
  61: display(pc, pv)
  62: int pc;
  63: PARM    pv[];
  64: {
  65:     register int    ac;
  66:     register PARM   *av;
  67:     extern DESC Treedes;
  68:     register int    i;
  69:     int     err;
  70:     char        err_array[PV_MAXPC];
  71:     auto int    mode;
  72: 
  73: #	ifdef xZTR1
  74:     if (tTf(50, -1))
  75:     {
  76:         printf("display: ");
  77:         prvect(pc, pv);
  78:     }
  79: #	endif
  80: 
  81:     err = 0;
  82:     if (pc % 2 != 0)
  83:         syserr("display: bad param count %d", pc);
  84:     opencatalog("tree", OR_READ);
  85: 
  86:     for (ac = 0, av = pv; ac < pc; av++, ac++)
  87:     {
  88:         mode = atoi(av->pv_val.pv_str);
  89:         av++;
  90:         err_array[ac++] = 0;
  91:         err_array[ac] = disp(av->pv_val.pv_str, mode);
  92:     }
  93:     for (ac = 0, av = pv; ac < pc; av++, ac++)
  94:     {
  95:         if (err_array[ac])
  96:             err = error(DISPERRBASE + err_array[ac], (av->pv_val).pv_str, 0);
  97:     }
  98:     return (err);
  99: }
 100: /*
 101: ** DISP -- display integrity, permit, or define query on a relation
 102: **
 103: **	Finds a relation owned by the user or the DBA and passes
 104: **	the name and owner to the appropritae routine depending on
 105: **	mode.
 106: **
 107: **	Parameters:
 108: **		relation -- relation on which query is to be printed
 109: **		mode -- the print mode:
 110: **			4 -- view
 111: **			5 -- permit
 112: **			6 -- integrity
 113: **
 114: **	Returns:
 115: **		0 -- success
 116: **		1 -- no such relation, or none seeable by the user.
 117: **		3 -- VIEW mode and relation not a view
 118: **		4 -- PERMIT and no permissions on relation
 119: **		5 -- INTEGRITY mode and no integrity constraints
 120: **
 121: **	Trace Flags:
 122: **		33, 8
 123: */
 124: 
 125: disp(relation, mode)
 126: char    *relation;
 127: int mode;
 128: {
 129:     DESC        d;
 130:     register int    i;
 131:     extern char *Resrel;
 132: 
 133: #	ifdef xZTR1
 134:     if (tTf(50, 8))
 135:         printf("disp: relation %s\n", relation);
 136: #	endif
 137: 
 138:     Resrel = relation;
 139:     i = openr(&d, OR_RELTID, relation);
 140:     if (i > 0)
 141:         return (1);
 142:     else if (i < 0)
 143:         syserr("disp: openr(%s) ret %d", relation, i);
 144:     switch (mode)
 145:     {
 146:       case 4:       /* View query */
 147:         if (d.reldum.relstat & S_VIEW)
 148:             pr_def(relation, d.reldum.relowner);
 149:         else
 150:             return (3);
 151:         break;
 152: 
 153:       case 5:
 154:         if (pr_prot(relation, &d))
 155:             return (4);
 156:         break;
 157: 
 158:       case 6:
 159:         if (d.reldum.relstat & S_INTEG)
 160:             pr_integrity(relation, d.reldum.relowner);
 161:         else
 162:             return (5);
 163:         break;
 164: 
 165:       default:
 166:         syserr("disp: mode == %d", mode);
 167:     }
 168:     return (0);
 169: }
 170: /*
 171: **  PR_DEF -- Print "define view" query of a view
 172: **
 173: **	Parameters:
 174: **		relation -- relation in question
 175: **		owner -- relowner
 176: **
 177: **	Returns:
 178: **		none
 179: **
 180: **	Side Effects:
 181: **		reads a tree, clears range table
 182: **
 183: **	Trace Flags:
 184: **		33, 9
 185: */
 186: 
 187: pr_def(relation, owner)
 188: char    *relation;
 189: char    *owner;
 190: {
 191:     register QTREE  *t;
 192:     QTREE       *gettree();
 193: 
 194: #	ifdef xZTR1
 195:     if (tTf(50, 9))
 196:         printf("pr_def(relation=\"%s\", owner=%s)\n", relation, owner);
 197: #	endif
 198: 
 199:     printf("View %s defined:\n\n", relation);
 200:     clrrange();
 201: 
 202:     /* Treeid == 0 because views have only one definition */
 203:     t = gettree(relation, owner, mdVIEW, 0,FALSE);
 204:     pr_range();
 205:     printf("define view ");
 206:     pr_tree(t);
 207: }
 208: /*
 209: **  PR_INTEGRITY -- print out integrity constraints on a relation
 210: **
 211: **	Finds all integrity tuples for this unique relation, and
 212: **	calls pr_int() to print a query from them.
 213: **
 214: **	Parameters:
 215: **		relid -- rel name
 216: **		relowner -- 2 byte owner id
 217: **
 218: **	Returns:
 219: **		none
 220: **
 221: **	Side Effects:
 222: **		file activity, query printing
 223: **
 224: **	Trace Flags:
 225: **		33, 9
 226: */
 227: 
 228: pr_integrity(relid, relowner)
 229: char    *relid;
 230: char    *relowner;
 231: {
 232:     extern DESC     Intdes;
 233:     TID         hitid, lotid;
 234:     struct integrity    key, tuple;
 235:     register int        i;
 236: 
 237: 
 238: #	ifdef xZTR1
 239:     if (tTf(50, 9))
 240:         printf("pr_integrity(relid =%s, relowner=%s)\n",
 241:         relid, relowner);
 242: #	endif
 243: 
 244:     printf("Integrity constraints on %s are:\n\n", relid);
 245:     opencatalog("integrities", OR_READ);
 246: 
 247:     /* get integrities tuples for relid, relowner */
 248:     clearkeys(&Intdes);
 249:     setkey(&Intdes, &key, relid, INTRELID);
 250:     setkey(&Intdes, &key, relowner, INTRELOWNER);
 251:     if (i = find(&Intdes, EXACTKEY, &lotid, &hitid, &key))
 252:         syserr("pr_integrity: find %d", i);
 253:     for ( ; ; )
 254:     {
 255:         if (i = get(&Intdes, &lotid, &hitid, &tuple, TRUE))
 256:             break;
 257:         if (kcompare(&Intdes, &tuple, &key) == 0)
 258:             pr_int(&tuple, relid);
 259:     }
 260:     if (i != 1)
 261:         syserr("pr_integrity: get %d", i);
 262: }
 263: /*
 264: **  PR_INT -- print an integrity definition given a integrities tuple
 265: **
 266: **	Parameters:
 267: **		i -- integrity tuple
 268: **
 269: **	Returns:
 270: **		none
 271: **
 272: **	Side Effects:
 273: **		prints a query
 274: **		reads a tree
 275: */
 276: 
 277: pr_int(i, relid)
 278: register struct integrity   *i;
 279: char                *relid;
 280: {
 281:     register QTREE  *t;
 282:     QTREE       *gettree();
 283: 
 284:     clrrange();
 285:     t = gettree(i->intrelid, i->intrelowner, mdINTEG, i->inttree);
 286:     printf("Integrity constraint %d -\n\n", i->inttree);
 287:     pr_range();
 288: 
 289:     printf("define integrity on ");
 290:     pr_rv(Qt.qt_resvar = i->intresvar);
 291:     printf(" is ");
 292:     pr_qual(t->right);
 293:     printf("\n\n\n");
 294: 
 295: }

Defined functions

Defined variables