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