![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to call_ovqp.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 call_ovqp.c CVS log | Up to [CSRG BSD Unix] / 42BSD / ingres / source / decomp |
1.1 root 1: # include <ingres.h>
2: # include <aux.h>
3: # include <opsys.h>
4: # include <access.h>
5: # include <tree.h>
6: # include <symbol.h>
7: # include "globs.h"
8: # include <sccs.h>
9:
10: SCCSID(@(#)call_ovqp.c 7.1 2/5/81)
11:
12:
13: /*
14: ** CALL_OVQP -- Routines which interface to the One Variable Query Processor.
15: **
16: ** This file contains the routines associated with sending queries
17: ** and receiving results from OVQP. The interface to these routines is
18: ** still messy. Call_ovqp is given the query, mode, and result relation
19: ** as parameters and gets the source relation, and two flags
20: ** (De.de_newq, De.de_newr) as globals. The routines include:
21: **
22: ** Call_ovqp -- Sends a One-var query to ovqp and flushes the pipe.
23: **
24: ** Readresult -- Reads the result from a one-var query.
25: **
26: ** Endovqp -- Informs ovqp that the query is over. Helps to synchronize
27: ** the batch file (if any).
28: **
29: ** Trace Flags:
30: ** 61
31: */
32: /*
33: ** Call_ovqp -- send query down pipe to ovqp and flush pipe.
34: ** Inputs are:
35: ** mode retrieve, append, etc.
36: ** resultnum result relation id
37: ** tree the query
38: ** De.de_sourcevar (global) if >= 0 then source var
39: ** De.de_newq send NEWQ symbol
40: ** De.de_newr send NEWR symbol
41: */
42:
43: call_ovqp(tree, mode, resultnum)
44: register QTREE *tree;
45: int mode;
46: int resultnum;
47: {
48: register int i;
49: char *rangename();
50: extern int derror();
51: extern bool Batchupd;
52: extern DESC Inddes;
53: char ovqpbuf[LBUFSIZE];
54: DESC *readopen();
55: extern DESC *specopen();
56: extern char *rnum_convert();
57:
58: # ifdef xOTM
59: if (tTf(90, 1))
60: timtrace(7, 0);
61: # endif
62:
63: # ifdef xDTR1
64: if (tTf(61, -1))
65: {
66: if (tTf(61, 0))
67: printf("CALL_OVQP-\n");
68: if (tTf(61, 1))
69: {
70: if (De.de_newq)
71: {
72: printf("new query to ovqp\n");
73: treepr(tree);
74: }
75: else
76: printf("query same as previous\n");
77: }
78: if (tTf(61, 2))
79: {
80: printf("De.de_sourcevar=%d\t", De.de_sourcevar);
81: if (De.de_sourcevar >= 0)
82: printf("relid=%s\t", rangename(De.de_sourcevar));
83: if (resultnum >= 0)
84: printf("De.ov_resultname=%s", rnum_convert(resultnum));
85: if (tree->sym.value.sym_root.rootuser)
86: printf(", userqry");
87: printf("\n");
88: }
89: }
90: # endif
91:
92:
93:
94: /* assign mode of this query */
95: De.de_qmode = mode;
96:
97: if (De.de_newr)
98: {
99: De.de_newr = FALSE;
100: }
101:
102: if (resultnum >= 0)
103: {
104: De.ov_result = specopen(resultnum);
105: }
106: else
107: De.ov_result = NULL;
108:
109: if (De.de_sourcevar >= 0)
110: De.ov_source = readopen(De.de_sourcevar);
111: else
112: De.ov_source = NULL;
113:
114: /* assume this will be direct update */
115: De.ov_userqry = De.de_buflag = FALSE;
116:
117: if (tree->sym.value.sym_root.rootuser)
118: {
119: De.ov_userqry = TRUE;
120: /* handle batch file */
121: if (De.ov_result && De.de_qmode != mdRETR)
122: {
123: if (Batchupd || De.ov_result->reldum.relindxd > 0)
124: {
125: if (De.ov_bopen == 0)
126: {
127: if (De.ov_result->reldum.relindxd > 0)
128: opencatalog("indexes", 0);
129: if (i = openbatch(De.ov_result, &Inddes, De.de_qmode))
130: syserr("call_ovqp:opn batch %d", i);
131: De.ov_bopen = TRUE;
132: }
133: De.de_buflag = TRUE;
134: }
135: }
136: }
137:
138: /* now write the query list itself */
139: if (De.de_newq)
140: {
141: De.ov_ovqpbuf = ovqpbuf;
142: initbuf(De.ov_ovqpbuf, LBUFSIZE, LISTFULL, derror);
143: De.de_qvptr = 0;
144: De.ov_alist = De.ov_bylist = De.ov_qlist = De.ov_tlist = NULL;
145: De.ov_targvc = tree->sym.value.sym_root.lvarc;
146: De.ov_qualvc = bitcnt(tree->sym.value.sym_root.rvarm);
147: De.ov_agcount = 0;
148:
149: if (tree->sym.type == AGHEAD)
150: {
151: De.ov_alist = &De.de_qvect[0];
152: if (tree->left->sym.type == BYHEAD)
153: {
154: mklist(tree->left->right);
155: ovqpnod(tree->left); /* BYHEAD node */
156: De.ov_bylist = &De.de_qvect[De.de_qvptr];
157: mklist(tree->left->left);
158: }
159: else
160: mklist(tree->left);
161: }
162: else
163: {
164: if (tree->left->sym.type != TREE)
165: {
166: De.ov_tlist = &De.de_qvect[0];
167: mklist(tree->left);
168: }
169: }
170:
171: /* now for the qualification */
172: ovqpnod(tree); /* ROOT node */
173:
174: if (tree->right->sym.type != QLEND)
175: {
176: De.ov_qlist = &De.de_qvect[De.de_qvptr];
177: mklist(tree->right);
178: }
179: ovqpnod(De.de_qle); /* QLEND node */
180: }
181:
182: /* Now call ovqp */
183: if (strategy())
184: {
185:
186: # ifdef xOTM
187: if (tTf(90, 2))
188: timtrace(9, 0);
189: # endif
190:
191: i = scan(); /* scan the relation */
192:
193: # ifdef xOTM
194: if (tTf(90, 2))
195: timtrace(10, 0);
196: # endif
197:
198: }
199: else
200: i = EMPTY;
201:
202: # ifdef xOTM
203: if (tTf(90, 1))
204: timtrace(8, 0);
205: # endif
206:
207:
208: /* return result of query */
209: return (i == NONEMPTY); /* TRUE if tuple satisfied */
210: }
211: /*
212: ** Endovqp -- Inform ovqp that processing is complete. "Ack" indicates
213: ** whether to wait for an acknowledgement from ovqp. The overall
214: ** mode of the query is sent followed by an EXIT command.
215: **
216: ** Ovqp decides whether to use batch update or not. If ack == ACK
217: ** then endovqp will read a RETVAL symbol from ovqp and return
218: ** a token which specifies whether to call the update processor or not.
219: */
220:
221: endovqp(ack)
222: int ack;
223: {
224: register int i;
225:
226: if (ack != RUBACK)
227: {
228: if (Equel && De.de_qry_mode == mdRETTERM)
229: equeleol(EXIT); /* signal end of retrieve to equel process */
230: }
231:
232: i = NOUPDATE;
233:
234: if (ack == ACK)
235: {
236: if (De.ov_bopen)
237: {
238: closebatch();
239: De.ov_bopen = FALSE;
240: i = UPDATE;
241: }
242: }
243: else
244: {
245: if (De.ov_bopen)
246: {
247: rmbatch();
248: De.ov_bopen = FALSE;
249: }
250: }
251:
252: closecatalog(FALSE);
253:
254: return (i);
255: }
256: /*
257: ** Add node q to ovqp's list
258: */
259:
260: ovqpnod(q)
261: register QTREE *q;
262: {
263: register SYMBOL *s;
264: extern QTREE *ckvar();
265: extern char *need();
266: register int i;
267:
268: s = &q->sym;
269:
270: /* VAR nodes must be specially processed */
271: if (s->type == VAR)
272: {
273: /* locate currently active VAR */
274: q = ckvar(q);
275:
276: /* Allocate an ovqp var node for the VAR */
277: s = (SYMBOL *) need(De.ov_ovqpbuf, SYM_HDR_SIZ + sizeof s->value.sym_var);
278: s->len = sizeof s->value.sym_var;
279: s->value.sym_var.attno = q->sym.value.sym_var.attno;
280: s->value.sym_var.varfrmt = q->sym.value.sym_var.varfrmt;
281: s->value.sym_var.varfrml = q->sym.value.sym_var.varfrml;
282:
283: /* If VAR has been substituted for, get value */
284: if (q->sym.value.sym_var.valptr)
285: {
286: /* This is a substituted variable */
287: if (q->sym.value.sym_var.varno == De.de_sourcevar)
288: syserr("ovqpnod:bd sub %d,%d", q->sym.value.sym_var.varno, De.de_sourcevar);
289:
290: s->type = S_VAR;
291: s->value.sym_var.valptr = q->sym.value.sym_var.valptr;
292: }
293: else
294: {
295: /* Var for one variable query */
296: if (q->sym.value.sym_var.varno != De.de_sourcevar)
297: syserr("ovqpnod:src var %d,%d", q->sym.value.sym_var.varno, De.de_sourcevar);
298: s->type = VAR;
299: i = q->sym.value.sym_var.attno;
300: if (i != 0)
301: s->value.sym_var.valptr = (ANYTYPE *) (De.ov_intup + De.ov_source->reloff[i]);
302: else
303: s->value.sym_var.valptr = (ANYTYPE *) &De.ov_intid;
304: }
305: }
306: if (s->type == AOP)
307: De.ov_agcount++;
308:
309: /* add symbol to list */
310: if (De.de_qvptr > MAXNODES - 1)
311: ov_err(NODOVFLOW);
312: De.de_qvect[De.de_qvptr++] = s;
313: }
314: /*
315: ** READAGG_RESULT
316: */
317:
318: readagg_result(result)
319: QTREE *result[];
320: {
321: register QTREE **r, *aop;
322: register int i;
323:
324: De.ov_tend = De.ov_outtup;
325: r = result;
326:
327: while (aop = *r++)
328: {
329: i = aop->sym.len & I1MASK;
330:
331: if (aop->sym.type == CHAR)
332: pad(De.ov_tend, i);
333:
334: bmove(De.ov_tend, (char *)&aop->sym.value, i);
335:
336: De.ov_tend += i;
337: # ifdef xDTR1
338: if (tTf(61, 3))
339: nodepr(aop);
340: # endif
341: }
342: }
343:
344:
345: ov_err(code)
346: int code;
347: {
348: derror(code);
349: }
350:
351:
352: DESC *
353: openindex(name)
354: char *name;
355: {
356: register DESC *d;
357: register int varno;
358: DESC *readopen();
359:
360: varno = SECINDVAR;
361: De.de_rangev[varno].relnum = rnum_assign(name);
362: d = readopen(varno);
363: return (d);
364: }
365: /*
366: ** Use "closer()" for closing relations. See
367: ** desc_close in openrs.c for details.
368: */
369: extern int closer();
370: int (*Des_closefunc)() = closer;
371:
372: init_decomp()
373: {
374: static struct accbuf xtrabufs[12];
375:
376: set_so_buf();
377: acc_addbuf(xtrabufs, 12);
378: }
379:
380:
381: startdecomp()
382: {
383: /* called at the start of each user query */
384: initrange();
385: rnum_init();
386: startovqp();
387: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.