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

##### Functions

    clrrange          X
    declare           X
    mapvars           X

##### Variables

    Rangev            X
    Remap             X

       1: # include   "../ingres.h"
       2: # include   "../symbol.h"
       3: # include   "../tree.h"
       4: # include   "qrymod.h"
       5:
       6:
       7: /*
       8: **  RANGE.C -- range table manipulation
       9: **
      10: **	Defines:
      11: **		declare -- declare variable
      12: **		clrrange -- clear range table
      13: **		mapvars -- map varno's in a tree to unique numbers
      14: **		Remap[] -- a mapping from specified (preferred) varno's
      15: **			to actual varno's.  -1 indicates no mapping.
      16: **			Presumably this cannot be set when reading an
      17: **			original query tree, but can happen easily when
      18: **			reading a tree from 'tree' catalog.
      19: **		Rangev[] -- the range table.
      20: **
      21: **	Required By:
      22: **		main
      23: **		treeio
      24: **
      25: **	Files:
      26: **		none
      27: **
      28: **	Trace Flags:
      29: **		11, 12
      30: **
      31: **	History:
      32: **		2/14/79 -- version 6.2 release.
      33: **		2/25/78 (eric) -- written
      34: */
      35:
      36:
      37: int     Remap[MAXVAR + 1];
      38: struct rngtab   Rangev[MAXVAR + 1];
      39: /*
      40: **  CLRRANGE -- clear range table(s)
      41: **
      42: **	The range table (Rangev) and range table map (Remap) are
      43: **	initialized in one of two ways.
      44: **
      45: **	Parameters:
      46: **		prim -- if TRUE, the primary range table (Rangev)
      47: **			is cleared and Remap is set to be FULL (for
      48: **			reading in an initial query).  If FALSE,
      49: **			Rangev is untouched, but Remap is cleared.
      50: **
      51: **	Returns:
      52: **		none
      53: **
      54: **	Side Effects:
      55: **		Rangev[i].rused set to FALSE for all entries.
      56: **		Remap[i] set to -1 or MAXVAR + 1 for all entries.
      57: **
      58: **	Requires:
      59: **		Rangev
      60: **		Remap
      61: **
      62: **	Called By:
      63: **		main
      64: **		gettree
      65: **
      66: **	Diagnostics:
      67: **		none
      68: **
      69: **	Syserrs:
      70: **		none
      71: */
      72:
      73: clrrange(prim)
      74: int prim;
      75: {
      76:     register int    i;
      77:     register int    p;
      78:
      79:     p = prim;
      80:
      81:     for (i = 0; i < MAXVAR + 1; i++)
      82:     {
      83:         if (p)
      84:         {
      85:             Rangev[i].rused = FALSE;
      86:             Remap[i] = MAXVAR + 1;
      87:         }
      88:         else
      89:             Remap[i] = -1;
      90:     }
      91: }
      92: /*
      93: **  DECLARE -- declare a range variable
      94: **
      95: **	A range variable is declared.  If possible, the preferred varno
      96: **	stated is used (this is the one already in the tree).  This
      97: **	should always be possible when reading the original tree (and
      98: **	should probably stay this way to make debugging easier).  When
      99: **	not possible, a new varno is chosen, and Remap[oldvarno] is
     100: **	set to newvarno, so that the tree can later be patched up by
     101: **	'mapvars' (below).
     102: **
     103: **	Parameters:
     104: **		varno -- the preferred varno.
     105: **		name -- the relation name.
     106: **		stat -- the 'relstat' of this relation.
     107: **
     108: **	Returns:
     109: **		none
     110: **		(non-local on error)
     111: **
     112: **	Side Effects:
     113: **		Rangev and possible Remap are updated.  No Rangev
     114: **			entry is ever touched if the 'rused' field
     115: **			is set.
     116: **
     117: **	Requires:
     118: **		Rangev
     119: **		Remap
     120: **
     121: **	Called By:
     122: **		readqry
     123: **
     124: **	Trace Flags:
     125: **		11
     126: **
     127: **	Diagnostics:
     128: **		3100 -- too many variables -- we have run out of
     129: **			space in the range table.  This "cannot happen"
     130: **			when reading the original tree, but can happen
     131: **			when reading another tree from the 'tree'
     132: **			catalog.
     133: **
     134: **	Syserrs:
     135: **		%d redec -- the variable stated has been declared
     136: **			twice in the range table.  Actually, if reading
     137: **			the original query, it means declared twice;
     138: **			if reading from the 'tree' catalog, it means
     139: **			declared THREE times (once in the original
     140: **			query and twice in the catalog).
     141: */
     142:
     143: declare(varno, name, owner, stat)
     144: int varno;
     145: char    *name;
     146: char    owner[2];
     147: int stat;
     148: {
     149:     register int    i;
     150:     register int    vn;
     151:     register int    s;
     152:
     153:     vn = varno;
     154:     s = stat;
     155:
     156:     /* check for preferred slot in range table available */
     157:     if (Rangev[vn].rused)
     158:     {
     159:         /* used: check if really redeclared */
     160:         if (Remap[vn] >= 0)
     161:             syserr("declare: %d redec", vn);
     162:
     163:         /* try to find another slot */
     164:         for (i = 0; i < MAXVAR + 1; i++)
     165:             if (!Rangev[i].rused)
     166:                 break;
     167:
     168:         if (i >= MAXVAR + 1)
     169:         {
     170:             ferror(3100, Qmode, -1, name, 0);   /* too many variables */
     171:         }
     172:
     173:         Remap[vn] = i;
     174:         vn = i;
     175:     }
     176:
     177:     /* declare variable in the guaranteed empty slot */
     178:     bmove(name, Rangev[vn].relid, MAXNAME);
     179:     bmove(owner, Rangev[vn].rowner, 2);
     180:     Rangev[vn].rstat = s;
     181:     Rangev[vn].rused = TRUE;
     182:
     183: #	ifdef xQTR2
     184:     if (tTf(11, 0))
     185:         printf("declare(%d, %.12s, %.2s, %o) into slot %d\n",
     186:             varno, name, owner, s, vn);
     187: #	endif
     188: #	ifdef xQTR3
     189:     if (tTf(11, 1))
     190:         printf("declare: %.12s%.2s 0%o %d\n", Rangev[vn].relid,
     191:             Rangev[vn].rowner, Rangev[vn].rstat, Rangev[vn].rused);
     192: #	endif
     193: }
     194: /*
     195: **  MAPVARS -- remap varno's to be unique in 'tree' tree
     196: **
     197: **	A tree is scanned for VAR nodes; when found, the
     198: **	mapping defined in Remap[] is applied.  This is done so that
     199: **	varno's as defined in trees in the 'tree' catalog will be
     200: **	unique with respect to varno's in the user's query tree.  For
     201: **	example, if the view definition uses variable 1 and the user's
     202: **	query also uses variable 1, the routine 'declare' will (when
     203: **	called to define the view definition varno 1) allocate a new
     204: **	varno (e.g. 3) in a free slot in the range table, and put
     205: **	the index of the new slot into the corresponding word of Remap;
     206: **	in this example, Remap[1] == 3.  This routine does the actual
     207: **	mapping in the tree.
     208: **
     209: **	Parameters:
     210: **		tree -- pointer to tree to be remapped.
     211: **
     212: **	Returns:
     213: **		none
     214: **
     215: **	Side Effects:
     216: **		the tree pointed to by 'tree' is modified according
     217: **		to Remap[].
     218: **
     219: **	Requires:
     220: **		Remap -- range table mapping.
     221: **
     222: **	Called By:
     223: **		gettree
     224: **
     225: **	Trace Flags:
     226: **		12
     227: **
     228: **	Diagnostics:
     229: **		none
     230: **
     231: **	Syserrs:
     232: **		none
     233: */
     234:
     235: mapvars(tree)
     236: QTREE   *tree;
     237: {
     238:     register QTREE  *t;
     239:     register int    i;
     240:
     241:     t = tree;
     242: #	ifdef xQTR3
     243:     if (tTf(12, 0) && t != NULL && t->sym.type == ROOT)
     244:     {
     245:         treepr(t, "mapvars:");
     246:         for (i = 0; i < MAXVAR + 1; i++)
     247:             if (Rangev[i].rused && Remap[i] >= 0)
     248:                 printf("\t%d => %d\n", i, Remap[i]);
     249:     }
     250: #	endif
     251:
     252:     while (t != NULL)
     253:     {
     254:         /* map right subtree */
     255:         mapvars(t->right);
     256:
     257:         /* check this node */
     258:         if (t->sym.type == VAR)
     259:         {
     260:             if ((i = Remap[((struct qt_var *)t)->varno]) >= 0)
     261:                 ((struct qt_var *)t)->varno = i;
     262:         }
     263:
     264:         /* map left subtree (iteratively) */
     265:         t = t->left;
     266:     }
     267: }

#### Defined functions

clrrange defined in line 73; used 3 times

- in /usr/ingres/source/qrymod/readtree.c line 79-84(2)
- in /usr/ingres/source/qrymod/util.c line 440

declare defined in line 143; used 1 times

- in /usr/ingres/source/qrymod/readtree.c line 116

mapvars defined in line 235; used 3 times

- in line 255
- in /usr/ingres/source/qrymod/readtree.c line 397
- in /usr/ingres/source/qrymod/util.c line 442

#### Defined variables

Rangev defined in line 38; used 48 times

- in line 85, 157, 165, 178-181(4), 190-191(4), 247
- in /usr/ingres/source/qrymod/range.c line 85, 157, 165, 178-181(4), 190-191(4), 247
- in /usr/ingres/source/qrymod/treepr.c line 88-91(4)
- in /usr/ingres/source/qrymod/util.c line 273, 427-432(8), 445
- in /usr/ingres/source/qrymod/view.c line 270-281(5), 306
- in /usr/ingres/source/qrymod/writetree.c line 120-127(4)

Remap defined in line 37; used 15 times

- in line 86-89(2), 160, 173, 247-248(2), 260
- in /usr/ingres/source/qrymod/range.c line 86-89(2), 160, 173, 247-248(2), 260
- in /usr/ingres/source/qrymod/util.c line 441

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