ING_DB
This commit is contained in:
Oliver Lehmann
parent
86f59923cd
commit
801ae802cb
|
|
@ -0,0 +1,133 @@
|
|||
# include "gen.h"
|
||||
# include "../h/dbs.h"
|
||||
# include "../h/tree.h"
|
||||
# include "../h/symbol.h"
|
||||
|
||||
|
||||
struct proctemplate
|
||||
{
|
||||
char *proc_name;
|
||||
int proc_code;
|
||||
char proc_exec;
|
||||
char proc_func;
|
||||
};
|
||||
|
||||
static struct proctemplate Proc_template[] =
|
||||
{
|
||||
"copy", (int) mdCOPY, 0, 0,
|
||||
"create", (int) mdCREATE, 0, 0,
|
||||
"destroy", (int) mdDESTROY, 0, 0,
|
||||
"display", (int) mdDISPLAY, 0, 0,
|
||||
"help", (int) mdHELP, 0, 0,
|
||||
"index", (int) mdINDEX, 0, 0,
|
||||
"modify", (int) mdMODIFY, 0, 0,
|
||||
"print", (int) mdPRINT, 0, 0,
|
||||
"save", (int) mdSAVE, 0, 0,
|
||||
"update", (int) mdUPDATE, 0, 0,
|
||||
"resetrel", (int) mdRESETREL, 0, 0,
|
||||
"remqm", (int) mdREMQM, 0, 0,
|
||||
(char *) 0
|
||||
};
|
||||
|
||||
|
||||
init_proctab(proc, my_id)
|
||||
char *proc;
|
||||
char my_id;
|
||||
|
||||
/*
|
||||
** Initialize from the run time process table
|
||||
**
|
||||
** Each entry in the proctable is seached for in the
|
||||
** runtime process table. If an entry isn't found it
|
||||
** is considered a AAsyserr. If an entry is found the
|
||||
** first one which has an exec_id of "my_id" is taken.
|
||||
** Otherwise, the very first entry given will be used.
|
||||
*/
|
||||
|
||||
{
|
||||
register struct proctemplate *pt;
|
||||
register char *p;
|
||||
register char *name;
|
||||
char *found;
|
||||
int i;
|
||||
|
||||
# ifdef xZTR1
|
||||
AAtTfp(0, 0, "INIT_PTAB:\n");
|
||||
# endif
|
||||
|
||||
for (pt = Proc_template; name = pt->proc_name; pt++)
|
||||
{
|
||||
i = AAlength(name);
|
||||
p = proc;
|
||||
found = (char *) 0;
|
||||
|
||||
while (*p)
|
||||
{
|
||||
if (AAbequal(p, name, i))
|
||||
{
|
||||
/* found a match. skip past the colon */
|
||||
while (*p++ != ':')
|
||||
continue;
|
||||
|
||||
/* look for an alias in this dbu */
|
||||
found = p;
|
||||
do
|
||||
{
|
||||
if (*p == my_id)
|
||||
{
|
||||
found = p;
|
||||
break; /* found one */
|
||||
}
|
||||
p++;
|
||||
p++;
|
||||
} while (*p++ == ',');
|
||||
|
||||
# ifdef xZTR1
|
||||
AAtTfp(0, 1, "%s: %.2s\n", name, found);
|
||||
# endif
|
||||
|
||||
pt->proc_exec = *found++;
|
||||
pt->proc_func = *found;
|
||||
break;
|
||||
|
||||
}
|
||||
|
||||
/* skip to next */
|
||||
while (*p++ != '\n')
|
||||
continue;
|
||||
}
|
||||
|
||||
if (!found)
|
||||
AAsyserr(11017, name);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
get_proctab(code, exec, func)
|
||||
int code;
|
||||
char *exec;
|
||||
char *func;
|
||||
|
||||
/*
|
||||
** Find the correct exec & func for a given code
|
||||
*/
|
||||
|
||||
{
|
||||
register struct proctemplate *p;
|
||||
register int i;
|
||||
|
||||
i = code;
|
||||
for (p = Proc_template; p->proc_name; p++)
|
||||
{
|
||||
if (i == p->proc_code)
|
||||
{
|
||||
/* found entry */
|
||||
*exec = p->proc_exec;
|
||||
*func = p->proc_func;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
/* entry not there */
|
||||
AAsyserr(11018, i);
|
||||
}
|
||||
|
|
@ -0,0 +1,484 @@
|
|||
# include <stdio.h>
|
||||
# include "gen.h"
|
||||
# include "../h/dbs.h"
|
||||
# include "../h/aux.h"
|
||||
# include "../h/symbol.h"
|
||||
# include "../h/tree.h"
|
||||
# include "../h/pipes.h"
|
||||
# include "decomp.h"
|
||||
|
||||
/*
|
||||
** DECISION -- This file contains code related to deciding how to
|
||||
** process the remaining query. The main routine is decision()
|
||||
** and the other routines are called only by decision. The routine
|
||||
** in this file include:
|
||||
**
|
||||
** Decision -- Decides how to process a query.
|
||||
**
|
||||
** Fixtl -- Determines the target list for each component.
|
||||
**
|
||||
** Fixresult -- Determines the result relation for the next query
|
||||
**
|
||||
** Fixrange -- Adjust the range table after a query
|
||||
**
|
||||
** Fixovlap -- Fixes trees in cases where reduction is used
|
||||
**
|
||||
** Rmovlap -- Restores trees in cases where reduction was used.
|
||||
**
|
||||
** Listcomp -- Debugging routine.
|
||||
*/
|
||||
|
||||
|
||||
|
||||
|
||||
decision(root, qmode, result_num, buf)
|
||||
QTREE *root;
|
||||
int qmode;
|
||||
int result_num;
|
||||
char *buf;
|
||||
|
||||
/*
|
||||
** Decision is given a subquery and decides how to process it.
|
||||
** The choices are:
|
||||
** Disjoint pieces -- The original query had disjoint components.
|
||||
** Do each component separately.
|
||||
** Reduction -- The query is joined by a single variable.
|
||||
** Reduce the query on that joining variable
|
||||
** and do each component separately.
|
||||
** Substitution -- The query is neither disjoint nor reducible.
|
||||
** Process by tuple substitution.
|
||||
**
|
||||
** Notice that decision() is recursive and will call itself on each
|
||||
** subcomponent it decides to do. Decision calls various support
|
||||
** routines in the file "reduction.c".
|
||||
*/
|
||||
|
||||
{
|
||||
register QTREE **qp;
|
||||
register struct complist *clist;
|
||||
register int ovlapvar;
|
||||
register struct complist *cp;
|
||||
int i;
|
||||
int onepiece;
|
||||
int qtrue;
|
||||
int map;
|
||||
int mark;
|
||||
int mark1;
|
||||
int cand_map;
|
||||
register QTREE *tree;
|
||||
register QTREE *newtree;
|
||||
QTREE *qlist[MAXRANGE];
|
||||
int newqmode;
|
||||
int ovlaprelnum;
|
||||
int newr;
|
||||
int locrange[MAXRANGE];
|
||||
extern struct complist *buildlist();
|
||||
extern struct complist *order();
|
||||
extern QTREE *copy_ands();
|
||||
extern QTREE *construct();
|
||||
|
||||
# ifdef xDTR1
|
||||
AAtTfp(15, -1, "DECISION root=0%o,vc=%d,res=%d\n",
|
||||
root, ((ROOT_NODE *) root)->tvarc, result_num);
|
||||
# endif
|
||||
mark = markbuf(buf);
|
||||
if (((ROOT_NODE *) root)->tvarc < 3)
|
||||
{
|
||||
/* setup to do as one single piece */
|
||||
onepiece = TRUE;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* break the query apart if possible */
|
||||
|
||||
/* build component list */
|
||||
clist = buildlist(root, buf);
|
||||
# ifdef xDTR1
|
||||
if (AAtTf(15, 2))
|
||||
listcomp(clist, "Original Comp");
|
||||
# endif
|
||||
|
||||
/* is query completely connected or disjoint */
|
||||
map = ((ROOT_NODE *) root)->lvarm | ((ROOT_NODE *) root)->rvarm;
|
||||
onepiece = algorithm(clist, map);
|
||||
# ifdef xDTR1
|
||||
AAtTfp(15, 1, "Orig query %s\n", onepiece ? "connected" : "disjoint");
|
||||
# endif
|
||||
/* assume there is no joining variable */
|
||||
ovlapvar = -1;
|
||||
|
||||
if (onepiece)
|
||||
{
|
||||
/*
|
||||
** Try to reduce a single connected piece.
|
||||
** In turn each variable will be logically
|
||||
** removed from the query and a test will
|
||||
** be made to see if the query is still
|
||||
** connected.
|
||||
*/
|
||||
|
||||
cand_map = map;
|
||||
for (i = 1; cand_map; i <<= 1)
|
||||
{
|
||||
if ((cand_map & i) == 0)
|
||||
continue;
|
||||
cand_map &= ~i;
|
||||
freebuf(buf, mark);
|
||||
clist = buildlist(root, buf);
|
||||
if (algorithm(clist, map & ~i) == 0)
|
||||
{
|
||||
ovlapvar = bitpos(i);
|
||||
ovlaprelnum = Rangev[ovlapvar].relnum;
|
||||
onepiece = FALSE;
|
||||
break;
|
||||
}
|
||||
}
|
||||
# ifdef xDTR1
|
||||
if (AAtTf(15, 1))
|
||||
{
|
||||
if (ovlapvar < 0)
|
||||
printf("Query not reducible\n");
|
||||
else
|
||||
{
|
||||
printf("Query Reducible on %d\n", ovlapvar);
|
||||
if (AAtTf(15, 3))
|
||||
listcomp(clist, "After reduct");
|
||||
}
|
||||
}
|
||||
# endif
|
||||
}
|
||||
|
||||
/*
|
||||
** If query is more than one piece, build trees
|
||||
** for each piece.
|
||||
*/
|
||||
|
||||
if (!onepiece)
|
||||
{
|
||||
/* order pieces */
|
||||
clist = order(clist, ovlapvar);
|
||||
# ifdef xDTR1
|
||||
if (AAtTf(15, 4))
|
||||
listcomp(clist, "After ordering");
|
||||
# endif
|
||||
cp = clist;
|
||||
qp = qlist;
|
||||
do
|
||||
{
|
||||
*qp++ = construct(root, cp, buf);
|
||||
} while (cp = cp->nextcomp);
|
||||
*qp++ = 0;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
** The query is now either the one original piece or
|
||||
** is in multiple pieces. The information in clist
|
||||
** is no longer needed and now the ordered pieces
|
||||
** will be processed.
|
||||
*/
|
||||
|
||||
if (onepiece)
|
||||
{
|
||||
freebuf(buf, mark);
|
||||
qtrue = decompy(root, qmode, result_num, buf);
|
||||
}
|
||||
else
|
||||
{
|
||||
/* the query is in pieces. prepare to process */
|
||||
|
||||
newquery(locrange); /* save state of range table */
|
||||
|
||||
/* determine the target list for each piece of the query */
|
||||
for (qp = qlist; tree = *qp++; )
|
||||
fixtl(tree, qp, ovlapvar, buf);
|
||||
|
||||
/* adjust refs to ovlapvar since domain #'s could have changed */
|
||||
fixovlap(qlist, ovlapvar, buf);
|
||||
|
||||
|
||||
/* now process each component */
|
||||
mark1 = markbuf(buf);
|
||||
for (qp = qlist; tree = *qp++; )
|
||||
{
|
||||
|
||||
# ifdef xDTR1
|
||||
if (AAtTf(15, 6))
|
||||
printree(tree, "Next piece");
|
||||
# endif
|
||||
|
||||
/* determine result relation name */
|
||||
newr = fixresult(root, tree, &newqmode, qmode, result_num);
|
||||
|
||||
/*
|
||||
** Run the query. If reduction is being
|
||||
** performed, the actual tree given to
|
||||
** the decision routine must be a copy
|
||||
** to protect from the recursive call changing
|
||||
** the tree. Any work done at this level,
|
||||
** must be to the original tree
|
||||
*/
|
||||
newtree = tree;
|
||||
if (ovlapvar != -1)
|
||||
{
|
||||
freebuf(buf, mark1);
|
||||
newtree = copy_ands(tree, buf);
|
||||
}
|
||||
qtrue = decision(newtree, newqmode, newr, buf);
|
||||
|
||||
/* fix up the range table */
|
||||
fixrange(root, tree, ovlapvar, ovlaprelnum, newr);
|
||||
|
||||
/* if last piece was false then done */
|
||||
if (!qtrue)
|
||||
break;
|
||||
|
||||
}
|
||||
|
||||
/* restore the trees */
|
||||
rmovlap(qlist, ovlapvar);
|
||||
|
||||
/* restore range table back to original */
|
||||
endquery(locrange, TRUE); /* reopen previous range */
|
||||
|
||||
/* return any buffer space used */
|
||||
freebuf(buf, mark);
|
||||
}
|
||||
|
||||
/* all done with query */
|
||||
return (qtrue);
|
||||
}
|
||||
|
||||
|
||||
fixresult(root, tree1, newmode, origmode, resnum)
|
||||
QTREE *root;
|
||||
QTREE *tree1;
|
||||
int *newmode;
|
||||
int origmode;
|
||||
int resnum;
|
||||
|
||||
/*
|
||||
** Fixresult -- Determine result relation for 'tree' query.
|
||||
** If 'tree' is the original target list piece then use the
|
||||
** original relation and mode.
|
||||
** If 'tree' is a reduction piece then create a temporary relation
|
||||
** for it.
|
||||
** If 'tree' is a disjoint piece then there is no target list nor
|
||||
** result relation.
|
||||
**
|
||||
** Return:
|
||||
** result relation number
|
||||
** Side Effects:
|
||||
** *newmode is set to the query mode of the next piece
|
||||
*/
|
||||
|
||||
{
|
||||
register QTREE *tree;
|
||||
register int newresult;
|
||||
|
||||
tree = tree1;
|
||||
*newmode = (int) mdRETR;
|
||||
if (tree->left->sym.type != TREE)
|
||||
{
|
||||
if (tree != root)
|
||||
{
|
||||
/* make new result for reduction step */
|
||||
newresult = mak_t_rel(tree, "r", -1);
|
||||
}
|
||||
else
|
||||
{
|
||||
/* final piece with original result and mode */
|
||||
newresult = resnum;
|
||||
*newmode = origmode;
|
||||
}
|
||||
}
|
||||
else
|
||||
newresult = NORESULT;
|
||||
return (newresult);
|
||||
}
|
||||
|
||||
|
||||
fixrange(root, tree, ovlapvar, reductnum, newrelnum)
|
||||
QTREE *root;
|
||||
QTREE *tree;
|
||||
int ovlapvar;
|
||||
int reductnum;
|
||||
int newrelnum;
|
||||
|
||||
/*
|
||||
** Update range table after a reduction has been processed.
|
||||
** Only the intermiediate reductions will affect the range
|
||||
** table. The last piece does not.
|
||||
*/
|
||||
|
||||
{
|
||||
register int old;
|
||||
register int i;
|
||||
|
||||
if (root != tree)
|
||||
{
|
||||
/* this is an intermediate piece */
|
||||
i = ovlapvar;
|
||||
|
||||
if (newrelnum >= 0)
|
||||
{
|
||||
old = new_range(i, newrelnum);
|
||||
if (old != reductnum)
|
||||
dstr_rel(old);
|
||||
openr1(i);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
fixovlap(qlist, ovlapvar, buf)
|
||||
QTREE *qlist[];
|
||||
int ovlapvar;
|
||||
char *buf;
|
||||
|
||||
/*
|
||||
** Fixovlap -- Adjust subsequent trees which reference the reduction var
|
||||
**
|
||||
** If the first query in list redefines the reduction variable
|
||||
** (if any) then each subsequent query which references the
|
||||
** reduction variable is adjusted.
|
||||
** Since there may be multiple pieces,
|
||||
** subsequence redefinitions are done without
|
||||
** reallocating buffer space.
|
||||
**
|
||||
*/
|
||||
|
||||
{
|
||||
register QTREE **qp;
|
||||
register QTREE *piece;
|
||||
register QTREE **qp1;
|
||||
register QTREE *next;
|
||||
register int ovmap;
|
||||
|
||||
ovmap = 1 << ovlapvar;
|
||||
|
||||
/* for each piece, if it redefines ovlapvar, then fix up rest */
|
||||
for (qp = qlist; piece = *qp++; )
|
||||
{
|
||||
if (((ROOT_NODE *) piece)->lvarm & ovmap)
|
||||
{
|
||||
for (qp1 = qp; next = *qp1++; )
|
||||
{
|
||||
if ((((ROOT_NODE *) next)->lvarm | ((ROOT_NODE *) next)->rvarm) & ovmap)
|
||||
{
|
||||
tempvar(next, mksqlist(piece, ovlapvar), buf);
|
||||
buf = (char *) 0; /* do not allocate on subsequent refs */
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
rmovlap(qlist, ovlapvar)
|
||||
QTREE *qlist[];
|
||||
int ovlapvar;
|
||||
|
||||
/*
|
||||
** Rmovlap -- Restore query trees back to their original state.
|
||||
**
|
||||
** Rmovlap undoes the effect of fixovlap(). Any references
|
||||
** to the reduction variable which were adjusted are now
|
||||
** reverted back to the original reference. Note that the
|
||||
** first piece is not effected by fixovlap.
|
||||
*/
|
||||
|
||||
{
|
||||
register QTREE **qp;
|
||||
register QTREE *tree;
|
||||
|
||||
if (1 << ovlapvar)
|
||||
{
|
||||
/* for each piece, remove any tempvars */
|
||||
for (qp = &qlist[1]; tree = *qp++; )
|
||||
origvar(tree, mksqlist(tree, ovlapvar));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
fixtl(tree1, qp1, ovlapvar, buf)
|
||||
QTREE *tree1;
|
||||
QTREE *qp1[];
|
||||
int ovlapvar;
|
||||
char *buf;
|
||||
|
||||
/*
|
||||
** Fixtl -- Determine what the target list of each tree should be.
|
||||
**
|
||||
** Fixtl takes each query which references the reduction variable
|
||||
** and looks for references to that variable in subsequent queries.
|
||||
** Dfind will build a target list which includes every domain
|
||||
** which will later be referenced.
|
||||
*/
|
||||
|
||||
{
|
||||
register QTREE *tree;
|
||||
register QTREE **qp;
|
||||
register QTREE *next;
|
||||
register int var;
|
||||
register int map;
|
||||
|
||||
tree = tree1;
|
||||
var = ovlapvar;
|
||||
map = 1 << var;
|
||||
|
||||
/*
|
||||
** if the last tree referenced the overlap variable then
|
||||
** try to fix next tree
|
||||
*/
|
||||
if (((ROOT_NODE *) tree)->rvarm & map)
|
||||
{
|
||||
qp = qp1;
|
||||
while (next = *qp++)
|
||||
{
|
||||
if ((((ROOT_NODE *) next)->lvarm | ((ROOT_NODE *) next)->rvarm) & map)
|
||||
dfind(next, buf, mksqlist(tree, var));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
# ifdef xDTR1
|
||||
listcomp(list, mesg)
|
||||
struct complist *list;
|
||||
char *mesg;
|
||||
|
||||
/*
|
||||
** This is strictly a debuggin routine used for
|
||||
** printing component lists.
|
||||
*/
|
||||
|
||||
{
|
||||
register struct complist *c;
|
||||
register struct complist *cl;
|
||||
register int i;
|
||||
|
||||
if (AAtTfp(15, 14, "%s\n", mesg))
|
||||
{
|
||||
i = -1;
|
||||
for (cl = list; cl; cl = cl->nextcomp)
|
||||
{
|
||||
i++;
|
||||
printf("Component %d:map=0%o\n", i, cl->bitmap);
|
||||
for (c = cl; c; c = c->linkcomp)
|
||||
{
|
||||
printf("0%o, ", c->clause);
|
||||
if (AAtTf(15, 15))
|
||||
{
|
||||
printree(c->clause->left, "");
|
||||
writenod(c->clause);
|
||||
}
|
||||
}
|
||||
putchar('\n');
|
||||
}
|
||||
}
|
||||
}
|
||||
# endif
|
||||
Loading…
Reference in New Issue