# 2.11BSD#431 - /usr/ingres/source/qrymod/integrity.c

##### Functions

    integrity         X

       1: # include   "../ingres.h"
       2: # include   "../aux.h"
       3: # include   "../catalog.h"
       4: # include   "../access.h"
       5: # include   "../tree.h"
       6: # include   "../symbol.h"
       7: # include   "qrymod.h"
       8:
       9: /*
      10: **  INTEGRITY.C -- Integrity Constraint Processor
      11: **
      12: **	This module contains the integrity constraint processor.  This
      13: **	processor modifies the query to add integrity constraints.
      14: **
      15: **	Currently only single-variable aggregate-free constraints are
      16: **	handled.  Thus the algorithm is reduced to scanning the tree
      17: **	for each variable modified and appending the constraints for
      18: **	that variable to the tree.
      19: **
      20: **	Parameters:
      21: **		none
      22: **
      23: **	Returns:
      24: **		The root of the modified tree.
      25: **
      26: **	Side Effects:
      27: **		Much relation I/O.
      28: **		Modifies the tree in place, so the previous one is
      29: **			lost.
      30: **
      31: **	Defines:
      32: **		integrity()
      33: **
      34: **	Requires:
      35: **		lsetbit -- to create domain sets.
      36: **		opencatalog, setkey, find, get -- to read integrity
      37: **			catalog.
      38: **		appqual -- to create new qualifications.
      39: **		subsvars -- to change the simple VAR nodes in the
      40: **			integrity qualifications into the afcn they
      41: **			will become after the update.
      42: **
      43: **	Required By:
      44: **		qrymod.c
      45: **
      46: **	Files:
      47: **		integrity relation
      48: **
      49: **	Trace Flags:
      50: **		40 -> 49
      51: **
      52: **	Diagnostics:
      53: **		none
      54: **
      55: **	History:
      56: **		2/14/79 -- version 6.2 released.
      57: */
      58:
      59: extern struct descriptor    Intdes;
      60:
      61: QTREE *integrity(root)
      62: QTREE   *root;
      63: {
      64:     register QTREE      *r;
      65:     int         dset[8];
      66:     register QTREE      *p;
      67:     register int        i;
      68:     auto QTREE      *iqual;
      69:     struct integrity    inttup, intkey;
      70:     struct tup_id       hitid, lotid;
      71:     QTREE           *gettree(), *norml();
      72:
      73: #	ifdef xQTR1
      74:     tTfp(40, -1, "\n->INTEGRITY\n");
      75: #	endif
      76:
      77:     r = root;
      78:
      79:     /*
      80: 	**  Check to see if we should apply the integrity
      81: 	**  algorithm.
      82: 	**
      83: 	**  This means checking to insure that we have an update
      84: 	**  and seeing if any integrity constraints apply.
      85: 	*/
      86:
      87:     if (Qmode == mdRETR || (Rangev[Resultvar].rstat & S_INTEG) == 0)
      88:     {
      89: #		ifdef xQTR2
      90:         tTfp(40, 0, "->INTEGRITY: no integ\n");
      91: #		endif
      92:         return(r);
      93:     }
      94:
      95:     /*
      96: 	**  Create a set of the domains updated in this query.
      97: 	*/
      98:
      99:     for (i = 0; i < 8; i++)
     100:         dset[i] = 0;
     101:     for (p = r->left; p != NULL && p->sym.type != TREE; p = p->left)
     102:     {
     103: #		ifdef xQTR3
     104:         if (p->sym.type != RESDOM)
     105:             syserr("integrity: RESDOM %d", p->sym.type);
     106: #		endif
     107:         lsetbit(((struct qt_res *)p)->resno, dset);
     108:     }
     109:
     110: #	ifdef xQTR3
     111:     if (p == NULL)
     112:         syserr("integrity: NULL LHS");
     113: #	endif
     114: #	ifdef xQTR1
     115:     if (tTf(40, 1))
     116:         pr_set(dset, "dset");
     117: #	endif
     118:
     119:     /*
     120: 	**  Scan integrity catalog for possible tuples.  If found,
     121: 	**  include them in the integrity qualification.
     122: 	*/
     123:
     124:     iqual = NULL;
     125:     opencatalog("integrities", 0);
     126:     setkey(&Intdes, &intkey, Rangev[Resultvar].relid, INTRELID);
     127:     setkey(&Intdes, &intkey, Rangev[Resultvar].rowner, INTRELOWNER);
     128:     find(&Intdes, EXACTKEY, &lotid, &hitid, &intkey);
     129:
     130:     while ((i = get(&Intdes, &lotid, &hitid, &inttup, TRUE)) == 0)
     131:     {
     132:         if (kcompare(&Intdes, &intkey, &inttup) != 0)
     133:             continue;
     134:
     135: #		ifdef xQTR1
     136:         if (tTf(40, 2))
     137:             printup(&Intdes, &inttup);
     138: #		endif
     139:
     140:         /* check for some domain set overlap */
     141:         for (i = 0; i < 8; i++)
     142:             if ((dset[i] & inttup.intdomset[i]) != 0)
     143:                 break;
     144:         if (i >= 8)
     145:             continue;
     146:
     147:         /* some domain matches, include in integrity qual */
     148:         i = Resultvar;
     149:         p = gettree(Rangev[i].relid, Rangev[i].rowner, mdINTEG, inttup.inttree, FALSE);
     150: #		ifdef xQTR1
     151:         if (tTf(40, 3))
     152:             treepr(p, "int_qual");
     153: #		endif
     154:
     155:         /* trim off (null) target list */
     156:         p = p->right;
     157:
     158:         /* merge the 'integrity' var into the Resultvar */
     159:         i = inttup.intresvar;
     160:         if (Remap[i] >= 0)
     161:             i = Remap[i];
     162:         mergevar(i, Resultvar, p);
     163:
     164:         /* remove old integrity var */
     165:         Rangev[i].rused = FALSE;
     166:
     167:         /* add to integrity qual */
     168:         if (iqual == NULL)
     169:             iqual = p;
     170:         else
     171:             appqual(p, iqual);
     172:     }
     173:     if (i < 0)
     174:         syserr("integrity: get %d", i);
     175:
     176:     /*
     177: 	**  Clean up the integrity qualification so that it will merge
     178: 	**  nicely into the tree, and then append it to the user's
     179: 	**  qualification.
     180: 	*/
     181:
     182:     if (iqual != NULL)
     183:     {
     184:         /* replace VAR nodes by corresponding user afcn */
     185:         subsvars(&iqual, Resultvar, r->left, Qmode);
     186:
     187:         /* append to tree and normalize */
     188:         appqual(iqual, r);
     189: #		ifdef xQTR3
     190:         if (tTf(40, 8))
     191:             treepr(r, "Unnormalized tree");
     192: #		endif
     193:         r->right = norml(trimqlend(r->right));
     194:     }
     195:
     196: #	ifdef xQTR1
     197:     if (tTf(40, 15))
     198:         treepr(r, "INTEGRITY->");
     199: #	endif
     200:
     201:     return (r);
     202: }

#### Defined functions

integrity defined in line 61; used 2 times

- in /usr/ingres/source/qrymod/qrymod.c line 43, 56

Last modified: 1995-02-19 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 1129 |