home *** CD-ROM | disk | FTP | other *** search
/ Complete Linux / Complete Linux.iso / docs / apps / database / ingres04.lzh / source / decomp / decomp.c < prev    next >
Encoding:
C/C++ Source or Header  |  1986-04-30  |  7.0 KB  |  310 lines
  1. # include    <ingres.h>
  2. # include    <aux.h>
  3. # include    <tree.h>
  4. # include    <symbol.h>
  5. # include    "globs.h"
  6. # include    <sccs.h>
  7. # include    <errors.h>
  8.  
  9. SCCSID(@(#)decomp.c    8.3    12/18/85)
  10.  
  11. /*
  12. ** DECOMP -- Process a query given a query tree and range table.
  13. **
  14. **    Decomp processes any arbitrary query by converting it into
  15. **    a sequence of "one variable queries"; eg. queries involving
  16. **    at most one source relation. This file and decision.c contain
  17. **    the principle decision making routines.
  18. **
  19. **    Decomp() is called with a pointer to a query tree, the mode
  20. **    of the query (retrieve, append, etc.), and the internal name
  21. **    of the result relation (if any). The routines included are:
  22. **
  23. **    Decomp  -- Opens the source relations and decides whether the
  24. **            query is multi-variable or single/zero variable.
  25. **
  26. **    Decompx -- Takes a multivariable query, removes and executes any
  27. **            one-var restrictions and passes the remaining query
  28. **            to decompz (if one/zero variable) or decision().
  29. **
  30. **    Decompy -- Performs "tuple substitution" on a multi-var query,
  31. **            does any new one-var restrictions and passes the
  32. **            remaining query to decompz (if one/zero variable)
  33. **            or decision().
  34. **
  35. **    Decompz -- Executes a one/zero variable query by calling call_ovqp().
  36. */
  37. /*
  38. **    Process query by calling either decompx for multivar
  39. **    or decompz for 0 or 1 var query. Decomp() must guarantee
  40. **    that the range table is the same upon exiting as it was
  41. **    when entered. Newquery() and endquery() perform that function.
  42. **
  43. **    Trace Flags:
  44. **        30
  45. */
  46.  
  47. decomp(q, qmode, result_num)
  48. QTREE    *q;
  49. int    qmode;
  50. int    result_num;
  51. {
  52.     register QTREE     *root;
  53.     register int     vc, i;
  54.     int        locrange[MAXRANGE];
  55.  
  56.     root = q;
  57.     vc = root->sym.value.sym_root.tvarc;
  58. #    ifdef xDTR1
  59.     if (tTf(30, 0))
  60.         printf("DECOMP: %d-var query, result_num=%d\n", vc, result_num);
  61.     if (tTf(30, 1))
  62.     {
  63.         printf("DECOMP\n");
  64.         treepr(root);
  65.     }
  66. #    endif
  67.  
  68.     openrs(root);
  69.  
  70.     if (vc > 1)
  71.     {
  72.         newquery(locrange);
  73.         i = decompx(root, qmode, result_num);
  74.         endquery(locrange, FALSE);    /* don't reopen previous range */
  75.     }
  76.     else
  77.     {
  78.         De.de_newq = 1;
  79.         De.de_sourcevar = -1;
  80.         i = decompz(root, qmode, result_num);
  81.     }
  82.     
  83.      /*
  84.     ** remove the range variables that the view subsystem
  85.     ** might have placed in.
  86.     */
  87.     clrrange();
  88.  
  89.     return (i);
  90. }
  91. /*
  92. ** Decompx -- Initialize for multi-variable query.
  93. **    All one-variable subqueries are run.
  94. **    If the remaining query is still multi-var
  95. **    then decision() is called; else decompz()
  96. **    is called. The range table is restored
  97. **    after the query is complete.
  98. **    The tempvars from the exec_sq() are left on the
  99. **    tree since it is presumed that the tree will be discarded
  100. **    anyway.
  101. **
  102. **    Trace Flags:
  103. **        31
  104. */
  105.  
  106. decompx(root, qmode, result_num)
  107. QTREE    *root;
  108. int    qmode;
  109. int    result_num;
  110. {
  111.     register int     i, vc;
  112.     int        disj;
  113.     int          sqbuf[1+SQSIZ/sizeof(int)];
  114.     QTREE         *sqlist[MAXRANGE];
  115.     int        locrang[MAXRANGE], sqrange[MAXRANGE];
  116.     extern int    derror();
  117.  
  118.     vc = root->sym.value.sym_root.tvarc;
  119.     initbuf((char *)sqbuf, SQSIZ, SQBUFFULL, derror);
  120.     pull_sq(root, sqlist, locrang, sqrange, (char *)sqbuf);
  121.     if ((i = exec_sq(sqlist, sqrange, &disj)) != -1) 
  122.     {
  123.         undo_sq(sqlist, locrang, sqrange, i, i, FALSE);
  124.         return (FALSE);
  125.     }
  126.     vc -= disj;
  127.     tempvar(root, sqlist, (char *)sqbuf);
  128.     if (pull_const(root, (char *)sqbuf) == 0)
  129.         return (FALSE);
  130.     if (vc <= 1)
  131.     {
  132.         De.de_sourcevar = -1;
  133.         De.de_newq = 1;
  134.         return (decompz(root, qmode, result_num));
  135.     }
  136.     i = decision(root, qmode, result_num, (char *)sqbuf);
  137.     undo_sq(sqlist, locrang, sqrange, MAXRANGE, MAXRANGE, FALSE);
  138.     return (i);
  139. }
  140. /*
  141. ** Decompy -- decompose a multi-variable query by tuple substitution.
  142. **    First a variable is selected
  143. **    for substitution. Then for each tuple in the
  144. **    selected variable, all one variable restrictions
  145. **    are done (exec_sq) and the remaining query is
  146. **    solved by calling either decompz() or recursively
  147. **    decision().
  148. **
  149. **    The original tree and range table are guaranteed to
  150. **    be the same on entry and exit (modulo the effects of
  151. **    reformat()).
  152. **
  153. **    Trace Flags:
  154. **        32
  155. */
  156.  
  157. decompy(q, qmode, result_num, sqbuf)
  158. QTREE     *q;
  159. int    qmode;
  160. int    result_num;
  161. char    *sqbuf;
  162. {
  163.     register QTREE    *root;
  164.     register int    j, vc;
  165.     DESC        *d;
  166.     QTREE        *newroot;
  167.     int        constl, sqcnt, var, srcvar, maxsqcnt;
  168.     int        disj, tc, qtrue;
  169.     TID        tid, hitid;
  170.     char        *tuple;
  171.     QTREE        *sqlist[MAXRANGE];
  172.     int        sqmark, sqmark1;
  173.     int        locrang[MAXRANGE], sqrange[MAXRANGE];
  174.     extern DESC    *readopen();
  175.     extern char    *need(), *rangename();
  176.     extern QTREE    *copy_ands();
  177.  
  178.     root = q;
  179.     vc = root->sym.value.sym_root.tvarc;
  180.  
  181. #    ifdef xDTR1
  182.     if (tTf(32, -1))
  183.         printf("DECOMPY:%x,vc=%d\n", root, vc);
  184. #    endif
  185.  
  186.     sqmark = markbuf(sqbuf);
  187.     constl = !root->sym.value.sym_root.lvarc;
  188.     qtrue = FALSE;
  189.  
  190.     if ((var = selectv(root)) < 0)
  191.         return (qtrue);
  192.     d = readopen(var);    /* gets full descriptor for setvar & get */
  193.     tuple = need(sqbuf, d->reldum.relwid);
  194.     setvar(root, var, &tid, tuple);
  195.     pull_sq(root, sqlist, locrang, sqrange, sqbuf);
  196.     tempvar(root, sqlist, sqbuf);
  197.     reformat(var, sqlist, locrang, sqbuf, root);
  198.     vc--;
  199. # ifdef xDTR2
  200.     if (tTf(32, 0))
  201.     {
  202.         printf("DECOMPY: &tup=%x, ", tuple);
  203.         printdesc(d);
  204.     }
  205. # endif xDTR2
  206.  
  207.     /* HERE FOR MULTI-VAR SUBSTITUTION */
  208.     sqmark1 = markbuf(sqbuf);
  209.     De.de_newq = 1;
  210.     tc = 0;
  211.     sqcnt = maxsqcnt = 0;
  212.     srcvar = -1;
  213.     De.de_sourcevar = -1;
  214.     find(readopen(var), NOKEY, &tid, &hitid);
  215.     while (!(j=get(readopen(var), &tid, &hitid, tuple, NXTTUP)))
  216.     {
  217. #        ifdef xDTR1
  218.         if (tTf(32, 2))
  219.         {
  220.             printf("Subst:");
  221.             printup(readopen(var), tuple);
  222.         }
  223. #        endif
  224.         tc++;
  225.         if (vc > 1)
  226.         {
  227.             reset_sq(sqlist, locrang, sqcnt);
  228.             if ((sqcnt = exec_sq(sqlist, sqrange, &disj)) != -1) 
  229.                 continue;
  230.  
  231.             maxsqcnt = sqcnt;
  232.             vc -= disj;
  233.             if (vc <= 1)
  234.             {
  235.                 De.de_sourcevar = srcvar;
  236.                 qtrue |= decompz(root, qmode, result_num);
  237.                 srcvar = De.de_sourcevar;
  238.             }
  239.             else
  240.             {
  241.                 freebuf(sqbuf, sqmark1);
  242.                 newroot = copy_ands(root, sqbuf);
  243.                 qtrue |= decision(newroot, qmode, result_num, sqbuf);
  244.             }
  245.             vc += disj;
  246.         }
  247.         else
  248.             qtrue |= decompz(root, qmode, result_num);
  249.  
  250.         /* check for early termination on constant Target list */
  251.         if (constl && qtrue) 
  252.             break;
  253.     }
  254.     if (j < 0) 
  255.         syserr("decompy: bad get %d on %.12s", j, readopen(var)->reldum.relid);
  256.  
  257.     /* undo the effect of pulling the sub queries */
  258.     origvar(root, sqlist);
  259.     undo_sq(sqlist, locrang, sqrange, sqcnt, maxsqcnt, TRUE);
  260.  
  261.     /* undo the setvar on the main tree and all subtrees */
  262.     clearvar(root, var);
  263.     for (j = 0; j < MAXRANGE; j++)
  264.         clearvar(sqlist[j], var);
  265.  
  266.     /* return any used buffer space */
  267.     freebuf(sqbuf, sqmark);
  268.  
  269. #    ifdef xDTR1
  270.     if (tTf(32, 2))
  271.         printf("tc[%.12s]=%d,qtrue=%d\n", rangename(var), tc, qtrue);
  272. #    endif
  273.  
  274.     return (qtrue);
  275. }
  276. /*
  277. **    Decompz processes a one variable query
  278. **    by calling call_ovqp().
  279. **
  280. **    Trace Flags:
  281. **        33
  282. */
  283.  
  284. decompz(q, qmode, result_num)
  285. QTREE     *q;
  286. int    qmode;
  287. int    result_num;
  288. {
  289.     register QTREE    *root;
  290.     register int    qualfound;
  291.  
  292.     root = q;
  293.     if (root->sym.value.sym_root.tvarc)
  294.     {
  295.         if (De.de_sourcevar < 0)
  296.         {
  297.             if ((De.de_sourcevar = selectv(root)) < 0) 
  298.                 return (FALSE);
  299.         }
  300.     }
  301.     else
  302.     {
  303.         De.de_sourcevar = -1;
  304.     }
  305.  
  306.     qualfound = call_ovqp(root, qmode, result_num);
  307.     De.de_newq = 0;
  308.     return (qualfound);
  309. }
  310.