![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to byeval.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 / decomp|
Return to byeval.c CVS log | Up to [CSRG BSD Unix] / 42BSD / ingres / source / decomp |
1.1 root 1: # include <ingres.h>
2: # include <tree.h>
3: # include <symbol.h>
4: # include <pv.h>
5: # include "globs.h"
6: # include <sccs.h>
7:
8: SCCSID(@(#)byeval.c 7.1 2/5/81)
9:
10: /*
11: ** BYEVAL - process aggregate function
12: **
13: ** Byeval is passed the root of the original query
14: ** tree and the root of the aggregate function to
15: ** be processed.
16: **
17: ** It first creates a temporary relation which will
18: ** hold the aggregate result. The format of the relation
19: ** is:
20: ** _SYSxxxxxaa(count, by-dom1, ... , by-domn, ag1, ... , agm)
21: **
22: ** The relation is moved into the range table and will become
23: ** a part of the query.
24: **
25: ** If there are any occurences of the variables
26: ** from the by-domains, anywhere in the original query tree,
27: ** the aggregate relation is linked on all by-domains in the
28: ** original query tree.
29: **
30: ** If the aggregate is unique, multivariable, or has a
31: ** qualification, then special processing is done.
32: **
33: ** If the aggregate is qualified then the by-domains are
34: ** projected into the result relation. This guarantees that
35: ** every value of the by-domains will be represented in the
36: ** aggregate result.
37: **
38: ** If the aggregate is unique or multivariable, then another
39: ** temporary relation is created and the values which will be
40: ** aggregated; along with the by-domains, are retrieved into
41: ** the temporary relation.
42: **
43: ** If unique, then duplicates are removed from the temporary relation.
44: **
45: ** Next the result relation for the aggregate is modified
46: ** to hash in order to speed up the processing of the aggregate
47: ** and guarantee that there are no duplicates in the bylist.
48: **
49: ** The aggregate is then run, and if a temporary relation was
50: ** created (eg. unique or multivar aggregate) then it is destroyed.
51: **
52: ** Trace Flags:
53: ** 42
54: */
55:
56:
57: QTREE *
58: byeval(root, aghead, agvar)
59: QTREE *root; /* root of orig query */
60: QTREE *aghead; /* root of ag fcn sub-tree */
61: int agvar; /* variable number assigned to this aggregate */
62: {
63:
64: register QTREE *q, *ag, *resdom;
65: QTREE *r;
66: int temp_relnum, i, filled;
67: QTREE *lnodv[MAXDOM+2], *save_node[MAXDOM+2];
68: char agbuf[AGBUFSIZ];
69: char nums[2];
70: int relnum;
71: QTREE *byhead, **alnp;
72: int bydoms, bymap, primeag, srcmap;
73: extern int derror();
74: extern QTREE *makroot(), *makavar(), *makresdom(), *copytree();
75: extern char *rnum_convert();
76:
77: # ifdef xDTR1
78: if (tTf(42, -1))
79: printf("BYEVAL\n");
80: # endif
81:
82: ag = aghead;
83: byhead = ag->left;
84:
85: /* first create the aggregate result relation */
86: /* params for create */
87:
88: initp(); /* init globals for setp */
89: setp(PV_STR,"0"); /* initial relstat field */
90: relnum = rnum_alloc();
91: setp(PV_STR,rnum_convert(relnum));
92: setp(PV_STR,"count"); /* domain 1 - count field per BY value */
93: setp(PV_STR,"i4"); /* format of count field */
94:
95: i = bydoms = lnode(byhead->left, lnodv, 0);
96: lnodv[i] = 0;
97: alnp = &lnodv[++i];
98: i = lnode(byhead->right, lnodv, i);
99: lnodv[i] = 0;
100:
101: domnam(lnodv, "by"); /* BY list domains */
102: domnam(alnp, "ag"); /* aggregate value domains */
103:
104: call_dbu(mdCREATE, FALSE);
105:
106: De.de_rangev[agvar].relnum = relnum;
107: # ifdef xDTR1
108: if (tTf(42, 7))
109: printf("agvar=%d,rel=%s\n", agvar, rnum_convert(relnum));
110: # endif
111:
112: bymap = varfind(byhead->left, (QTREE *)NULL);
113:
114: /*
115: ** Find all variables in the tree in which you are nested.
116: ** Do not look at any other aggregates in the tree. Just in
117: ** case the root is an aggregate, explicitly look at its
118: ** two descendents.
119: */
120: srcmap = varfind(root->left, ag) | varfind(root->right, ag);
121: # ifdef xDTR1
122: if (tTf(42, 8))
123: printf("bymap=%o,srcmap=%o\n", bymap, srcmap);
124: # endif
125:
126: if (bymap & srcmap)
127: modqual(root, lnodv, srcmap, agvar);
128:
129: /* if aggregate is unique or there is a qualification
130: ** or aggregate is multi-var, then special processing is done */
131:
132: temp_relnum = NORESULT;
133: filled = FALSE;
134: primeag = prime(byhead->right);
135: if (ag->right->sym.type != QLEND || ag->sym.value.sym_root.tvarc > 1 || primeag)
136: {
137: /* init a buffer for new tree components */
138: initbuf(agbuf, AGBUFSIZ, AGBUFFULL, derror);
139:
140: /* make a root for a new tree */
141: q = makroot(agbuf);
142:
143: /*
144: ** Create a RESDOM for each by-domain in the original
145: ** aggregate. Rather than using the existing by-domain
146: ** function, a copy is used instead. This is necessary
147: ** since that subtree might be needed later (if modqual())
148: ** decided to use it. Decomp does not restore the trees
149: ** it uses and thus the by-domains might be altered.
150: */
151: for (i = 0; r = lnodv[i]; i++)
152: {
153: resdom = makresdom(agbuf, r);
154: resdom->sym.value.sym_resdom.resno = i + 2;
155: resdom->right = copytree(r->right, agbuf);
156: resdom->left = q->left;
157: q->left = resdom;
158: }
159: mapvar(q, 0); /* make maps on root */
160: # ifdef xDTR1
161: if (tTf(42, 2))
162: {
163: printf("byedomains\n");
164: treepr(q);
165: }
166: # endif
167:
168: /* if agg is qualified, project by-domains into result */
169: if (ag->right->sym.type != QLEND)
170: {
171: filled = TRUE;
172: i = De.de_sourcevar; /* save value */
173: decomp(q, mdRETR, relnum);
174: De.de_sourcevar = i; /* restore value */
175: }
176:
177: /* if agg is prime or multivar, compute into temp rel */
178: if (ag->sym.value.sym_root.tvarc > 1 || primeag)
179: {
180: q->right = ag->right; /* give q the qualification */
181: ag->right = De.de_qle; /* remove qualification from ag */
182:
183: /* put aop resdoms on tree */
184: for (i = bydoms + 1; r = lnodv[i]; i++)
185: {
186: resdom = makresdom(agbuf, r);
187: resdom->right = r->right;
188: resdom->left = q->left;
189: q->left = resdom;
190:
191: /* make aop refer to temp relation */
192: r->right = makavar(resdom, FREEVAR, i);
193: }
194:
195: /* assign result domain numbers */
196: for (resdom = q->left; resdom->sym.type != TREE; resdom = resdom->left)
197: resdom->sym.value.sym_resdom.resno = --i;
198:
199: /*
200: ** change by-list in agg to reference new source rel.
201: ** Save the old bylist to be restored at the end of
202: ** this aggregate.
203: */
204: for (i = 0; resdom = lnodv[i]; i++)
205: {
206: save_node[i] = resdom->right;
207: resdom->right = makavar(resdom, FREEVAR, i + 1);
208: }
209:
210: mapvar(q, 0);
211: # ifdef xDTR1
212: if (tTf(42, 3))
213: {
214: printf("new ag src\n");
215: treepr(q);
216: }
217: # endif
218:
219: /* create temp relation */
220: temp_relnum = mak_t_rel(q, "a", -1);
221: decomp(q, mdRETR, temp_relnum);
222: De.de_rangev[FREEVAR].relnum = temp_relnum;
223: De.de_sourcevar = FREEVAR;
224: if (primeag)
225: removedups(FREEVAR);
226: # ifdef xDTR1
227: if (tTf(42, 4))
228: {
229: printf("new agg\n");
230: treepr(ag);
231: }
232: # endif
233: }
234: }
235:
236: /* set up parameters for modify to hash */
237: initp();
238: setp(PV_STR, rnum_convert(relnum));
239: setp(PV_STR, "hash"); /* modify the empty rel to hash */
240: setp(PV_STR, "num"); /* code to indicate numeric domain names */
241: nums[1] = '\0';
242: for (i = 0; i < bydoms; i++)
243: {
244: nums[0] = i + 2;
245: setp(PV_STR, nums);
246: }
247: setp(PV_STR, "");
248:
249: /* set up fill factor information */
250: setp(PV_STR,"minpages");
251: if (filled)
252: {
253: setp(PV_STR,"1");
254: setp(PV_STR,"fillfactor");
255: setp(PV_STR,"100");
256: }
257: else
258: {
259: setp(PV_STR,"10");
260: }
261: specclose(relnum);
262: call_dbu(mdMODIFY, FALSE);
263:
264:
265: De.de_newq = 1;
266: De.de_newr = TRUE;
267: call_ovqp(ag, mdRETR, relnum);
268:
269: De.de_newq = 0;
270: /* if temp relation was used, destroy it */
271: if (temp_relnum != NORESULT)
272: {
273: for (i = 0; resdom = lnodv[i]; i++)
274: resdom->right = save_node[i];
275: dstr_rel(temp_relnum);
276: }
277: }
278:
279:
280:
281:
282: modqual(root, lnodv, srcmap, agvar)
283: QTREE *root;
284: QTREE *lnodv[];
285: int srcmap;
286: int agvar;
287: {
288: register QTREE *and_eq, *afcn;
289: register int i;
290: extern QTREE *copytree();
291: extern char *need();
292: register int len;
293:
294: # ifdef xDTR1
295: if (tTf(42, 12))
296: printf("modqual %o\n", srcmap);
297: # endif
298:
299: for (i = 0; afcn = lnodv[i]; i++)
300: {
301: /* `AND' node */
302: len = sizeof (struct rootnode) - sizeof (short);
303: and_eq = (QTREE *) need(De.de_qbuf, QT_HDR_SIZ + len);
304: and_eq->sym.type = AND;
305: and_eq->sym.len = len;
306: and_eq->sym.value.sym_root.tvarc = 0;
307: and_eq->sym.value.sym_root.lvarc = 0;
308: and_eq->sym.value.sym_root.lvarm = 0;
309: and_eq->sym.value.sym_root.rvarm = 0;
310: and_eq->right = root->right;
311: root->right = and_eq;
312:
313: /* `EQ' node */
314: len = sizeof (struct opnode);
315: and_eq->left = (QTREE *) need(De.de_qbuf, QT_HDR_SIZ + len);
316: and_eq = and_eq->left;
317: and_eq->sym.type = BOP;
318: and_eq->sym.len = len;
319: and_eq->sym.value.sym_op.opno = opEQ;
320:
321: /* bydomain opEQ var */
322: and_eq->right = copytree(afcn->right, De.de_qbuf); /* a-fcn (in Source) specifying BY domain */
323: and_eq->left = makavar(afcn, agvar, i+2); /* VAR ref BY domain */
324: }
325: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.