chrissy
/
P8000
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

ING_DB

This commit is contained in:
Oliver Lehmann 1989-04-03 19:44:14 +00:00
parent d86a2ba4c1
commit 9f95488636
17 changed files with 1976 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
WEGA/contrib/ingres/dbs/src/gutil/fgetline.c Normal file
View File

@ -0,0 +1,52 @@
# include <stdio.h>
/*
** FGETLINE -- get line from file
**
** This routine reads a single newline-terminated line from
** a file.
**
** Parameters:
** buf -- the buffer in which to place the result.
** maxch -- the maximum number of characters the
** buffer can hold.
** iop -- the file from which to read the characters.
**
** Returns:
** 0 -- end-of-file or error.
** else -- 'buf'.
*/
char *fgetline(buf, maxch, iop)
char *buf;
int maxch;
register FILE *iop;
{
register char *p;
register int n;
register int c;
p = buf;
for (n = maxch; n > 0; n--)
{
c = getc(iop);
/* test for end-of-file or error */
if (c == EOF)
{
*p = 0;
return ((char *) 0);
}
/* test for newline */
if (c == '\n')
break;
/* insert character into buffer */
*p++ = c;
}
/* null-terminate the string */
*p = 0;
return (buf);
}

140
WEGA/contrib/ingres/dbs/src/gutil/syserr.c Normal file
View File

@ -0,0 +1,140 @@
# include <stdio.h>
# include "gen.h"
/*
** AAsyserr -- SYStem ERRor message print and abort
**
** AAsyserr acts like a printf with up to five arguments.
**
** If the first argument to AAsyserr is not zero,
** the error messages are prepended.
**
** If the extern variable 'AAproc_name' is assigned to a
** string, that string is prepended to the message.
**
** All arguments must be null-terminated.
**
** The function pointed to by 'AAexitfn' is then called.
** It is initialized to be 'exit'.
*/
char *AAproc_name;
int AAccerror;
extern exit();
int (*AAexitfn)() = exit;
# ifdef P8000
AAsyserr(err, p0, p1, p2, p3, p4, p5)
# else
AAsyserr(err, p0)
# endif
register int err;
char *p0;
# ifdef P8000
char *p1;
char *p2;
char *p3;
char *p4;
char *p5;
# endif
{
register int exitvalue;
char buf[256];
extern int errno;
extern char *AAgetformat();
# ifndef P8000
register char **p;
p = &p0;
# endif
exitvalue = -1;
putchar('\n');
if (err)
{
if (AAproc_name)
printf("%s\n", AAproc_name);
printf("\007DB\terror\t%d\n", err);
if (errno)
printf("BS\terror\t%d\n", exitvalue = errno);
if (AAccerror)
printf("ACCESS\terror\t%d\n", AAccerror);
# ifdef P8000
printf(AAgetformat(err, buf), p0, p1, p2, p3, p4, p5);
# else
printf(AAgetformat(err, buf), p[0], p[1], p[2], p[3], p[4], p[5]);
# endif
}
else
# ifdef P8000
printf(p0, p1, p2, p3, p4, p5);
# else
printf(p[0], p[1], p[2], p[3], p[4], p[5]);
# endif
printf("\007\n");
AAunlall();
fflush(stdout);
sync();
(*AAexitfn)(exitvalue);
}
char *AAgetformat(err, buf)
int err;
char *buf;
{
register int c;
register char *p;
register FILE *iop;
short i;
# ifdef SETBUF
char iobufx[BUFSIZ];
# endif
extern char *AAerrfn();
/* open the appropriate error file */
if (!(iop = fopen(AAerrfn(err / 1000), "r")))
return ("");
# ifdef SETBUF
setbuf(iop, iobufx);
# endif
/* read in the code and check for correct */
for ( ; ; )
{
p = buf;
while ((c = getc(iop)) != '\t')
{
if (c <= 0)
/* no code exists */
goto fmt_err;
*p++ = c;
}
*p = 0;
if (AA_atoi(buf, &i))
goto fmt_err;
if (i != err)
{
while ((c = getc(iop)) != ERRDELIM)
if (c <= 0)
goto fmt_err;
getc(iop); /* throw out the newline */
continue;
}
/* got the correct line */
p = buf;
while ((c = getc(iop)) != ERRDELIM)
{
if (c <= 0)
{
fmt_err:
fclose(iop);
return ("");
}
*p++ = c;
}
*p = 0;
fclose(iop);
return (buf);
}
}

66
WEGA/contrib/ingres/dbs/src/iutil/getnuser.c Normal file
View File

@ -0,0 +1,66 @@
# include <stdio.h>
# include "gen.h"
# include "../h/dbs.h"
# include "../h/aux.h"
/*
** GETNUSER -- get line from user file based on name
**
** Given a user name as a string, this routine returns the
** corresponding line from AA_USERS into a buffer.
**
** Parameters:
** name -- the name of the user
** buf -- a buf to dump the line in (declare as
** char buf[MAXLINE + 1]
**
** Returns:
** zero -- success
** one -- failure (user not present)
*/
getnuser(name, buf)
char *name;
char buf[];
{
register int c;
register char *bp;
register FILE *userf;
# ifdef SETBUF
char userbuf[BUFSIZ];
# endif
if (!(userf = fopen(AAztack(AApath, AA_USERS), "r")))
AAsyserr(15001);
# ifdef SETBUF
setbuf(userf, userbuf);
# endif
for ( ; ; )
{
bp = buf;
while ((c = getc(userf)) != '\n')
{
if (c == EOF)
{
fclose(userf);
return (1);
}
*bp++ = c;
}
*bp++ = '\0';
bp = buf;
while ((c = *bp++) != ':')
if (!c)
{
fclose(userf);
return (1);
}
*--bp = 0;
if (AAsequal(buf, name))
{
fclose(userf);
*bp = ':';
return (0);
}
}
}

225
WEGA/contrib/ingres/dbs/src/monitor/buf.c Normal file
View File

@ -0,0 +1,225 @@
# include <stdio.h>
# include "buf.h"
# include "gen.h"
static char *Buf_flat;
/*
** BUFFER MANIPULATION ROUTINES
**
**
**
** BUFPUT -- put character onto buffer
**
** The character 'c' is put onto the buffer 'bp'. If the buffer
** need be extended it is.
*/
bufput(c, bp)
int c;
register struct buf **bp;
{
register struct buf *b;
register struct buf *a;
extern struct buf *bufalloc();
if (!(b = *bp) || b->ptr >= &b->buffer[BUFSIZE])
{
/* allocate new buffer segment */
a = bufalloc(sizeof (struct buf));
a->nextb = b;
a->ptr = a->buffer;
*bp = b = a;
}
*b->ptr++ = c;
}
/*
** BUFGET -- get character off of buffer
**
** The buffer is popped and the character is returned. If the
** segment is then empty, it is returned to the free list.
*/
bufget(bp)
register struct buf **bp;
{
register struct buf *b;
register int c;
if (!(b = *bp) || b->ptr == b->buffer)
return (0); /* buffer is empty -- return end of file */
c = *--(b->ptr);
/* check to see if we have emptied the (non-initial) segment */
if (b->ptr == b->buffer && b->nextb)
{
/* deallocate segment */
*bp = b->nextb;
buffree(b);
}
return (c);
}
/*
** BUFPURGE -- return an entire buffer to the free list
**
** The buffer is emptied and returned to the free list. This
** routine should be called when the buffer is to no longer
** be used.
*/
bufpurge(bp)
register struct buf **bp;
{
register struct buf *b;
register struct buf *a;
b = *bp;
*bp = (struct buf *) 0;
/* return the segments to the free list */
while (b)
{
a = b->nextb;
buffree(b);
b = a;
}
}
/*
** BUFFLUSH -- flush a buffer
**
** The named buffer is truncated to zero length. However, the
** segments of the buffer are not returned to the system.
*/
bufflush(bp)
register struct buf **bp;
{
register struct buf *b;
if (!(b = *bp))
return;
/* return second and subsequent segments to the system */
bufpurge(&b->nextb);
/* truncate this buffer to zero length */
b->ptr = b->buffer;
}
/*
** BUFCRUNCH -- flatten a series of buffers to a string
**
** The named buffer is flattenned to a conventional C string,
** null terminated. The buffer is deallocated. The string is
** allocated "somewhere" off in memory, and a pointer to it
** is returned.
*/
char *bufcrunch(buffer)
register struct buf **buffer;
{
register char *p;
extern char *bufflatten();
p = bufflatten(*buffer, 1);
*p = 0;
*buffer = (struct buf *) 0;
return (Buf_flat);
}
char *bufflatten(b, length)
register struct buf *b;
int length;
{
register char *p;
register char *q;
extern char *bufflatten();
extern struct buf *bufalloc();
/* see if we have advanced to beginning of buffer */
if (!b) /* yes, allocate the string */
return (Buf_flat = (char *) bufalloc(length));
/* no, keep moving back */
p = (char *) bufflatten(b->nextb, length + (b->ptr - b->buffer));
/* copy buffer into string */
for (q = b->buffer; q < b->ptr; )
*p++ = *q++;
/* deallocate the segment */
buffree(b);
/* process next segment */
return (p);
}
/*
** BUFALLOC -- allocate clear memory
**
** This is similar to the system alloc routine except that
** it has no error return, and memory is guaranteed to be clear
** when you return.
**
** It might be nice to rewrite this later to avoid the nasty
** memory fragmentation that alloc() tends toward.
**
** The error processing might have to be modified if used anywhere
** other than DBS.
*/
struct buf *bufalloc(size)
register int size;
{
register struct buf *p;
extern int (*AAexitfn)(); /* defined in AAsyserr.c */
extern char *malloc();
if (!(p = (struct buf *) malloc(size)))
{
printf("%sMACRO processor: Speicherueberlauf\n", ERROR);
fflush(stdout);
(*AAexitfn)(-1);
}
bufclear(p, size);
return (p);
}
/*
** BUFCLEAR -- clear a block of core memory
**
** Parameters:
** buf -- pointer to area
** size -- size in bytes
*/
bufclear(buf, size)
register char *buf;
register int size;
{
register char *b;
for (b = &buf[size]; buf < b; )
*buf++ = 0;
}
/*
** BUFFREE -- free memory
*/
buffree(ptr)
register char *ptr;
{
if (!ptr)
AAsyserr(16000);
free(ptr);
}

64
WEGA/contrib/ingres/dbs/src/monitor/edit.c Normal file
View File

@ -0,0 +1,64 @@
# include <stdio.h>
# include "gen.h"
# include "../h/dbs.h"
# include "../h/aux.h"
# include "../h/bs.h"
# include "monitor.h"
/*
** CALL TEXT EDITOR
**
** The BS text editor is called. The actual call is to
** the macro EDITOR. If that fails, /bin/ed is called.
** This routine suppressed the autoclear function.
*/
edit()
{
register int i;
register char *p;
register char *editfile;
extern int exit();
extern int (*AAexitfn)();
extern char *getfilename();
extern char *macro();
editfile = getfilename();
if (!*editfile)
editfile = Qbname;
Autoclear = 0;
fclose(Qryiop);
/* FORK PROCESS & INVOKE THE EDITOR */
fflush(stdout);
if ((Xwaitpid = fork()) < 0)
{
printf("CANNOT FORK\n");
return;
}
if (!Xwaitpid)
{
AAexitfn = exit;
setuid(getuid());
setgid(getgid());
for (i = 3; i < MAXFILES; i++)
close(i);
# ifdef MACRO
if (!(p = macro(EDITOR)))
# endif
p = BIN_ED;
if (Nodayfile >= 0)
printf(">>%s\n", p);
fflush(stdout);
execlp(p, p, editfile, (char *) 0);
if (Nodayfile >= 0)
{
printf("CANNOT EXEC\n");
fflush(stdout);
}
exit(-1);
}
/* WAIT FOR PROCESS TO DIE */
xwait();
}

162
WEGA/contrib/ingres/dbs/src/monitor/quit.c Normal file
View File

@ -0,0 +1,162 @@
# include <stdio.h>
# include "gen.h"
# include "../h/dbs.h"
# include "../h/aux.h"
# include "../h/pipes.h"
# include "monitor.h"
/* list of fatal signals */
static char *Siglist[] =
{
"Signal 0",
"hangup",
"interrupt",
"quit",
"illegal instruction",
"trace trap",
"IOT instruction",
"EMT instruction",
"floating point exception",
"kill",
"bus error",
"segmentation violation",
"bad argument to system call",
"write on broken pipe or link with no one to read it",
"alarm clock",
"software termination signal"
};
/*
** QUIT DBS
**
** This routine starts the death of the other processes. It
** then prints out the logout message, and then waits for the
** rest of the system to die. Note, however, that no relations
** are removed; this must be done using the PURGE command.
*/
quit()
{
register int ndx;
register int pidptr;
register int err;
int status;
int pidlist[50];
char buf[100];
char indexx[0400];
extern int (*AAexitfn)();
extern exit();
extern int sys_nerr;
extern char *sys_errlist[];
extern char *AAcustomer();
extern long time();
extern char *ctime();
# ifdef xMTR1
AAtTfp(1, -1, "entered QUIT\n");
# endif
/* INTERCEPT ALL FURTHER INTERRUPTS */
signal(1, (int (*)()) 1);
signal(2, (int (*)()) 1);
signal(3, (int (*)()) 1);
AAexitfn = exit;
close(W_down);
# ifdef xMTR3
AAtTfp(1, 2, "unlinking %s\n", Qbname);
# endif
/* REMOVE THE QUERY-BUFFER FILE */
fclose(Qryiop);
unlink(Qbname);
# ifdef MACRO
if (Trapfile)
fclose(Trapfile);
# endif
pidptr = 0;
err = 0;
/* clear out the system error index table */
for (ndx = 0; ndx < 0400; ndx++)
indexx[ndx] = 0;
/* wait for all process to terminate */
while ((ndx = wait(&status)) != -1)
{
# ifdef xMTR2
AAtTfp(1, 5, "QUIT: pid %u: 0%o/0%o\n", ndx, status >> 8, status & 0177);
# endif
pidlist[pidptr++] = ndx;
if (status & 0177)
{
printf("%u: ", ndx);
ndx = status & 0177;
if (ndx > sizeof Siglist / sizeof Siglist[0])
printf("Abnormal Termination %u", ndx);
else
printf("%s", Siglist[ndx]);
if (status & 0200)
printf(" -- Core Dumped");
putchar('\n');
err++;
indexx[0377 - ndx]++;
}
else
indexx[(status >> 8) & 0377]++;
}
if (err)
{
printf("pid list:");
for (ndx = 0; ndx < pidptr; ndx++)
printf(" %u", pidlist[ndx]);
putchar('\n');
}
/* print index of system errors */
err = 0;
for (ndx = 1; ndx <= 0377; ndx++)
{
if (!indexx[ndx])
continue;
if (ndx <= sys_nerr)
{
if (!err)
printf("\nBS error dictionary:\n");
printf("%3d: %s\n", ndx, sys_errlist[ndx]);
}
if (!err)
err = ndx;
}
if (err > 0 && err <= sys_nerr)
putchar('\n');
/* PRINT LOG CUE ? */
if (Nodayfile >= 0)
{
printf(LOG_1, AAversion);
time(buf);
# ifdef ESER_VMX
printf("%s\n%s", AAcustomer(), ctime(*((long *) buf)));
# else
printf("%s\n%s", AAcustomer(), ctime(buf));
# endif
if (!getuser(AAusercode, buf))
{
for (ndx = 0; buf[ndx]; ndx++)
if (buf[ndx] == ':')
break;
buf[ndx] = 0;
printf(LOG_21, buf);
}
else
printf(LOG_22);
printf(LOG_3);
}
# ifdef xMTR1
AAtTfp(1, 3, "QUIT: exit(%d)\n", err);
# endif
AAunlall();
fflush(stdout);
exit(err);
}

67
WEGA/contrib/ingres/dbs/src/monitor/shell.c Normal file
View File

@ -0,0 +1,67 @@
# include <stdio.h>
# include "gen.h"
# include "../h/dbs.h"
# include "../h/aux.h"
# include "../h/bs.h"
# include "monitor.h"
/*
** CALL BS SHELL
**
** The BS shell is called. Shell() first tries to call an
** alternate shell defined by the macro SHELL, and if it fails
** calls BIN_SH.
**
** If an argument is supplied, it is a shell file which is
** supplied to the shell.
*/
shell()
{
register int i;
register char *shellfile;
register char *sh_arg;
extern int exit();
extern int (*AAexitfn)();
extern char *macro();
extern char *getfilename();
sh_arg = "-c";
shellfile = getfilename();
if (!*shellfile)
{
# ifdef MACRO
if (!(shellfile = macro(SHELL)))
# endif
sh_arg = "-i";
}
fclose(Qryiop);
fflush(stdout);
if ((Xwaitpid = fork()) == -1)
{
printf("CANNOT FORK\n");
return;
}
if (!Xwaitpid)
{
AAexitfn = exit;
setuid(getuid());
setgid(getgid());
for (i = 3; i < MAXFILES; i++)
close(i);
if (Nodayfile >= 0)
printf(">>%s\n", shellfile? shellfile: BIN_SH);
fflush(stdout);
execlp(BIN_SH, BIN_SH, sh_arg, shellfile, (char *) 0);
if (Nodayfile >= 0)
{
printf("CANNOT EXEC\n");
fflush(stdout);
}
exit(-1);
}
/* wait for shell to complete */
xwait();
}

48
WEGA/contrib/ingres/dbs/src/monitor/writeout.c Normal file
View File

@ -0,0 +1,48 @@
# include <stdio.h>
# include "gen.h"
# include "../h/dbs.h"
# include "../h/aux.h"
# include "monitor.h"
/*
** WRITE OUT QUERY BUFFER TO BS FILE
**
** The logical buffer is written to a BS file, the name of which
** must follow the \w command.
*/
writeout()
{
register int i;
register char *file;
register int source;
register int dest;
char buf[BUFSIZ];
extern char *getfilename();
file = getfilename();
if (!*file || *file == '-')
{
printf("%sUnakzeptabler file name `%s'\n", ERROR, file);
return;
}
if ((dest = creat(file, 0644)) < 0)
{
printf("%screate WRITE file `%s'\n", ERROR, file);
return;
}
if (!Nautoclear)
Autoclear = 1;
if ((source = open(Qbname, 0)) < 0)
AAsyserr(16025, Qbname);
fflush(Qryiop);
while ((i = read(source, buf, sizeof buf)) > 0)
write(dest, buf, i);
close(source);
close(dest);
}

24
WEGA/contrib/ingres/dbs/src/qrymod/cat_desc.c Normal file
View File

@ -0,0 +1,24 @@
# include "gen.h"
# include "../h/dbs.h"
# include "../h/aux.h"
# include "../h/access.h"
/*
** SYSTEM RELATION DESCRIPTOR CACHE DEFINITION
**
** *** TOOLED FOR QUERY MODIFICATION PROCESS ***
*/
DESC Reldes;
DESC Prodes;
DESC Intdes;
DESC Treedes;
struct desxx Desxx[] =
{
AA_REL, &Reldes, &AAdmin.adreld,
AA_PROTECT, &Prodes, (DESC *) 0,
AA_INTEG, &Intdes, (DESC *) 0,
AA_TREE, &Treedes, (DESC *) 0,
(char *) 0
};

68
WEGA/contrib/ingres/dbs/src/qrymod/d_view.c Normal file
View File

@ -0,0 +1,68 @@
# include <stdio.h>
# include "gen.h"
# include "../h/dbs.h"
# include "../h/aux.h"
# include "../h/pipes.h"
# include "../h/tree.h"
# include "../h/symbol.h"
# include "../h/catalog.h"
# include "qrymod.h"
extern QTREE *Treeroot;
extern DESC Reldes;
extern struct pipfrmt Pipe;
/*
** D_VIEW -- define view
**
** This procedure connects the tree in with the AA_REL catalog
** and inserts the view tree into the AA_TREE catalog.
**
** The information in the pipe is expected to come as follows:
** create for view, with S_VIEW bit set so that a
** physical relation is not created.
** define tree, which will put the translation tree
** into the AA_TREE catalog.
** define view, which will connect the two together.
** The first two absolutely must be done before
** this step can be called.
*/
d_view()
{
char viewid[MAXNAME + 1];
/*
** Read parameters.
** Only parameter is view name (which must match the
** name of the Resultvar).
*/
if (rdpipe(P_NORM, &Pipe, R_up, viewid, 0) > MAXNAME + 1)
AAsyserr(19019);
AApad(viewid, MAXNAME);
/* done with pipe... */
rdpipe(P_SYNC, &Pipe, R_up);
# ifdef xQTR3
/* do some extra validation */
if (!Treeroot)
AAsyserr(19020);
if (Qmode != mdDEFINE)
AAsyserr(19021, Qmode);
if (Resultvar < 0)
AAsyserr(19022, Resultvar);
if (!Rangev[Resultvar].rused || !AAbequal(Rangev[Resultvar].relid, viewid, MAXNAME))
AAsyserr(19023, Rangev[Resultvar].rused, Rangev[Resultvar].relid);
# endif
Rangev[Resultvar].rused = FALSE;
Resultvar = -1;
Qmode = -1;
/* output tree to AA_TREE catalog */
puttree(Treeroot, viewid, AAusercode, mdVIEW);
/* clear Treeroot to detect some errors */
Treeroot = (QTREE *) 0;
}

140
WEGA/contrib/ingres/dbs/src/qrymod/fillprotup.c Normal file
View File

@ -0,0 +1,140 @@
# include <stdio.h>
# include "gen.h"
# include "../h/dbs.h"
# include "../h/aux.h"
# include "../h/bs.h"
# include "../h/catalog.h"
# include "../h/pipes.h"
# include "qrymod.h"
extern struct pipfrmt Pipe;
/*
** FILLPROTUP -- fill the protection tuple from pipe.
**
** This routine is broken off from d_prot.c so that we
** don't get symbol table overflows.
**
** Parameters:
** protup -- pointer to the protection tuple to fill.
**
** Returns:
** A bool telling whether we have PERMIT ALL TO ALL
** permission.
**
** Side Effects:
** The R_up pipe is flushed.
*/
fillprotup(protup)
struct protect *protup;
{
register struct protect *pt;
register int i;
register char *p;
char buf[30];
int all_pro;
short ix;
char ubuf[MAXLINE + 1];
/*
** Fill in the protection tuple with the information
** from the parser, validating as we go.
**
** Also, determine if we have a PERMIT xx to ALL
** with no further qualification case. The variable
** 'all_pro' is set to reflect this.
*/
all_pro = TRUE;
pt = protup;
/* read operation set */
if (rdpipe(P_NORM, &Pipe, R_up, buf, 0) <= 0)
AAsyserr(19030);
if (AA_atoi(buf, &ix))
AAsyserr(19031, buf);
pt->proopset = ix;
if ((ctoi(pt->proopset) & PRO_RETR) != 0)
pt->proopset |= PRO_TEST | PRO_AGGR;
/* read relation name */
if (rdpipe(P_NORM, &Pipe, R_up, buf, 0) > MAXNAME + 1)
AAsyserr(19032);
AApmove(buf, pt->prorelid, MAXNAME, ' ');
/* read relation owner */
if (rdpipe(P_NORM, &Pipe, R_up, buf, 0) != 3)
AAsyserr(19033);
AAbmove(buf, pt->prorelown, 2);
/* read user name */
rdpipe(P_NORM, &Pipe, R_up, buf, 0);
if (AAsequal(buf, "all"))
AAbmove(" ", pt->prouser, 2);
else
{
/* look up user in AA_USERS */
if (getnuser(buf, ubuf))
far_error(3591, -1, Resultvar, buf, (char *) 0);
for (p = ubuf; *p != ':' && *p != 0; p++)
continue;
AAbmove(++p, pt->prouser, 2);
if (p[0] == ':' || p[1] == ':' || p[2] != ':')
AAsyserr(19034, ubuf);
all_pro = FALSE;
}
/* read terminal id */
rdpipe(P_NORM, &Pipe, R_up, buf, 0);
if (AAsequal(buf, "all"))
{
AAbmove(" ", pt->proterm, PROTERM);
}
else
{
if (AAbequal(buf, "tty", 3))
AApmove(&buf[3], pt->proterm, PROTERM, ' ');
else
AApmove(buf, pt->proterm, PROTERM, ' ');
all_pro = FALSE;
}
/* read starting time of day */
rdpipe(P_NORM, &Pipe, R_up, buf, 0);
if (AA_atoi(buf, &ix))
AAsyserr(19035, buf);
pt->protodbgn = ix;
if (ix > 0)
all_pro = FALSE;
/* read ending time of day */
rdpipe(P_NORM, &Pipe, R_up, buf, 0);
if (AA_atoi(buf, &ix))
AAsyserr(19036, buf);
pt->protodend = ix;
if (ix < 24 * 60 - 1)
all_pro = FALSE;
/* read beginning day of week */
rdpipe(P_NORM, &Pipe, R_up, buf, 0);
i = cvt_dow(buf);
if (i < 0)
far_error(3594, -1, Resultvar, buf, (char *) 0); /* bad dow */
pt->prodowbgn = i;
if (i > 0)
all_pro = FALSE;
/* read ending day of week */
rdpipe(P_NORM, &Pipe, R_up, buf, 0);
i = cvt_dow(buf);
if (i < 0)
far_error(3594, -1, Resultvar, buf, (char *) 0); /* bad dow */
pt->prodowend = i;
if (i < 6)
all_pro = FALSE;
/* finished with pipe... */
rdpipe(P_SYNC, &Pipe, R_up);
return (all_pro);
}

45
WEGA/contrib/ingres/dbs/src/qrymod/qrymod.c Normal file
View File

@ -0,0 +1,45 @@
# include "gen.h"
# include "../h/dbs.h"
# include "../h/aux.h"
# include "../h/tree.h"
# include "qrymod.h"
/*
** QRYMOD -- main driver for query modification
**
** Reads in the query tree, performs the modifications, writes
** it out, and does process syncronization with below. The
** calling routine must sync with the process above.
**
** Parameters:
** root1 -- a pointer to the tree to modify.
**
** Returns:
** A pointer to the modified tree.
*/
QTREE *qrymod(root1)
QTREE *root1;
{
register QTREE *root;
extern QTREE *view();
extern QTREE *integrity();
extern QTREE *protect();
root = root1;
# ifdef xQTR1
if (AAtTf(1, 0))
treepr(root, "->QRYMOD");
# endif
/* view processing */
root = view(root);
/* integrity processing */
root = integrity(root);
/* protection processing */
root = protect(root);
return (root);
}

186
WEGA/contrib/ingres/dbs/src/qrymod/range.c Normal file
View File

@ -0,0 +1,186 @@
# include "gen.h"
# include "../h/dbs.h"
# include "../h/symbol.h"
# include "../h/tree.h"
# include "qrymod.h"
/*
** RANGE.C -- range table manipulation
**
** Defines:
** declare -- declare variable
** clrrange -- clear range table
** mapvars -- map varno's in a tree to unique numbers
** Remap[] -- a mapping from specified (preferred) varno's
** to actual varno's. -1 indicates no mapping.
** Presumably this cannot be set when reading an
** original query tree, but can happen easily when
** reading a tree from AA_TREE catalog.
** Rangev[] -- the range table.
*/
int Remap[MAXVAR + 1];
struct rngtab Rangev[MAXVAR + 1];
/*
** CLRRANGE -- clear range table(s)
**
** The range table (Rangev) and range table map (Remap) are
** initialized in one of two ways.
**
** Parameters:
** prim -- if TRUE, the primary range table (Rangev)
** is cleared and Remap is set to be FULL (for
** reading in an initial query). If FALSE,
** Rangev is untouched, but Remap is cleared.
**
** Side Effects:
** Rangev[i].rused set to FALSE for all entries.
** Remap[i] set to -1 or MAXVAR + 1 for all entries.
*/
clrrange(prim)
register int prim;
{
register int i;
for (i = 0; i < MAXVAR + 1; i++)
{
if (prim)
{
Rangev[i].rused = FALSE;
Remap[i] = MAXVAR + 1;
}
else
Remap[i] = -1;
}
}
/*
** DECLARE -- declare a range variable
**
** A range variable is declared. If possible, the preferred varno
** stated is used (this is the one already in the tree). This
** should always be possible when reading the original tree (and
** should probably stay this way to make debugging easier). When
** not possible, a new varno is chosen, and Remap[oldvarno] is
** set to newvarno, so that the tree can later be patched up by
** 'mapvars' (below).
**
** Parameters:
** varno -- the preferred varno.
** name -- the relation name.
** stat -- the 'relstat' of this relation.
**
** Side Effects:
** Rangev and possible Remap are updated. No Rangev
** entry is ever touched if the 'rused' field
** is set.
*/
declare(varno, name, owner, stat)
int varno;
char *name;
char owner[2];
int stat;
{
register int i;
register int vn;
register int s;
vn = varno;
s = stat;
/* check for preferred slot in range table available */
if (Rangev[vn].rused)
{
/* used: check if really redeclared */
if (Remap[vn] >= 0)
AAsyserr(19047, vn);
/* try to find another slot */
for (i = 0; i < MAXVAR + 1; i++)
if (!Rangev[i].rused)
break;
if (i >= MAXVAR + 1)
{
far_error(3100, Qmode, -1, name, (char *) 0); /* too many variables */
}
Remap[vn] = i;
vn = i;
}
/* declare variable in the guaranteed empty slot */
AAbmove(name, Rangev[vn].relid, MAXNAME);
AAbmove(owner, Rangev[vn].rowner, 2);
Rangev[vn].rstat = s;
Rangev[vn].rused = TRUE;
# ifdef xQTR2
AAtTfp(11, 0, "DECLARE: %d, %.12s, %.2s, 0%o into slot %d\n",
varno, name, owner, s, vn);
# endif
# ifdef xQTR3
AAtTfp(11, 1, "DECLARE: %.12s%.2s 0%o %d\n", Rangev[vn].relid,
Rangev[vn].rowner, Rangev[vn].rstat, Rangev[vn].rused);
# endif
}
/*
** MAPVARS -- remap varno's to be unique in AA_TREE tree
**
** A tree is scanned for VAR nodes; when found, the
** mapping defined in Remap[] is applied. This is done so that
** varno's as defined in trees in the AA_TREE catalog will be
** unique with respect to varno's in the user's query tree. For
** example, if the view definition uses variable 1 and the user's
** query also uses variable 1, the routine 'declare' will (when
** called to define the view definition varno 1) allocate a new
** varno (e.g. 3) in a free slot in the range table, and put
** the index of the new slot into the corresponding word of Remap;
** in this example, Remap[1] == 3. This routine does the actual
** mapping in the tree.
**
** Parameters:
** tree -- pointer to tree to be remapped.
**
** Side Effects:
** the tree pointed to by 'tree' is modified according
** to Remap[].
*/
mapvars(tree)
QTREE *tree;
{
register QTREE *t;
register int i;
t = tree;
# ifdef xQTR3
if (AAtTf(12, 0) && t != NULL && t->sym.type == ROOT)
{
treepr(t, "mapvars:");
for (i = 0; i < MAXVAR + 1; i++)
if (Rangev[i].rused && Remap[i] >= 0)
printf("\t%d => %d\n", i, Remap[i]);
}
# endif
while (t != NULL)
{
/* map right subtree */
mapvars(t->right);
/* check this node */
if (t->sym.type == VAR)
{
i = ((VAR_NODE *) t)->varno;
if ((i = Remap[i]) >= 0)
((VAR_NODE *) t)->varno = i;
}
/* map left subtree (iteratively) */
t = t->left;
}
}

329
WEGA/contrib/ingres/dbs/src/qrymod/readtree.c Normal file
View File

@ -0,0 +1,329 @@
# include <stdio.h>
# include "gen.h"
# include "../h/dbs.h"
# include "../h/catalog.h"
# include "../h/tree.h"
# include "../h/symbol.h"
# include "../h/pipes.h"
# include "qrymod.h"
/*
** READTREE.C -- query tree input procedures
**
** This file contains routines to read trees from pipes and
** catalogs.
**
** Defines:
** readqry
** readsymbol
** readtree
** pipetrrd
** relntrrd
** gettree
** Qmode
** Resultvar
*/
extern struct pipfrmt Pipe;
extern struct pipfrmt Outpipe;
int Qmode; /* Query mode */
int Resultvar; /* Result variable number */
/*
** READQRY
**
** Reads in query symbols from input pipe into core
** locations and sets up information needed for later
** processing.
**
** Returns ptr to root of querytree
**
** Locbuf is a 'struct srcid' since that is the largest node of
** a QMODE, SOURCEID, or RESULTVAR node.
*/
QTREE *readqry(rdfn, initialize)
int (*rdfn)(); /* tree read function */
int initialize; /* if set, initialize Qbuf */
{
register SYMBOL *s;
SRCID locbuf;
register QTREE *rtval;
register char *p;
extern xerror();
extern char *readtree();
extern QTREE *trbuild();
# ifdef xQTR1
AAtTfp(70, 0, "READQRY:\n");
# endif
if (initialize)
{
/* initialize for new query block */
initbuf(Qbuf, QBUFSIZ, QBUFFULL, xerror);
clrrange(TRUE);
Resultvar = -1;
Qmode = -1;
}
else
clrrange(FALSE);
s = (SYMBOL *) &locbuf;
/* read symbols from input */
for ( ; ; )
{
readsymbol(s, rdfn);
# ifdef xQTR1
if (AAtTfp(70, 1, "%d, %d, %d/",
s->type, s->len, ctou(s->value[0])))
{
if (s->type == SOURCEID)
printf("%.12s", ((SRCID *) s)->srcname);
putchar('\n');
}
# endif
switch (s->type)
{
case QMODE:
if (Qmode != -1)
AAsyserr(19048);
Qmode = s->value[0];
break;
case RESULTVAR:
if (Resultvar != -1)
AAsyserr(19049);
Resultvar = s->value[0];
break;
case SOURCEID:
declare(((SRCID *) s)->srcvar, ((SRCID *) s)->srcname, ((SRCID *) s)->srcown, ((SRCID *) s)->srcstat);
break;
case TREE: /* beginning of tree, no more other stuff */
p = readtree(s, rdfn);
rtval = trbuild(p);
if (!rtval)
far_error(STACKFULL, -1, -1, (char *) 0);
return (rtval);
default:
AAsyserr(19050, s->type);
}
}
}
/*
** READSYMBOL
** reads in one symbol from pipe into symbol struct.
*/
readsymbol(dest, rdfn)
char *dest; /* if non-zero, pts to allocated space */
int (*rdfn)(); /* tree read function */
{
register int len;
register SYMBOL *p;
extern char *need();
/* check if enough space for type and len of sym */
p = (SYMBOL *) (dest? dest: need(Qbuf, SYM_HDR_SIZ));
if ((*rdfn)(p, TYP_LEN_SIZ) < TYP_LEN_SIZ)
goto err3;
len = ctou(p->len);
if (len)
{
if (!dest)
{
/* this will be contiguous with above need call */
need(Qbuf, len);
}
if ((*rdfn)(p->value, len) < len)
goto err3;
}
return;
err3:
AAsyserr(19051);
}
/*
** READTREE
** reads in tree symbols into a buffer up to a root (end) symbol
*/
char *readtree(tresym, rdfn)
SYMBOL *tresym;
int (*rdfn)();
{
register QTREE *nod;
register char *rtval;
extern char *need();
rtval = need(Qbuf, QT_HDR_SIZ);
AAbmove(tresym, &(((QTREE *) rtval)->sym), TYP_LEN_SIZ); /* insert type and len of TREE node */
for ( ; ; )
{
/* space for left & right pointers */
nod = (QTREE *) need(Qbuf, QT_PTR_SIZ);
readsymbol((char *) 0, rdfn);
# ifdef xQTR1
if (AAtTf(70, 2))
nodepr(nod, TRUE);
# endif
if (nod->sym.type == ROOT)
return (rtval);
}
}
/*
** PIPETRRD -- read tree from R_up pipe
**
** This routine looks like a rdpipe with only the last two
** parameters.
**
** Parameters:
** ptr -- pointer to data area
** cnt -- byte count
**
** Returns:
** actual number of bytes read
*/
pipetrrd(ptr, cnt)
register char *ptr;
register int cnt;
{
return (rdpipe(P_NORM, &Pipe, R_up, ptr, cnt));
}
/*
** RELNTRRD -- read tree from AA_TREE relation
**
** This looks exactly like the 'pipetrrd' call, except that info
** comes from the AA_TREE catalog instead of from the pipe. It
** must be initialized by calling it with a NULL pointer and
** the segment name wanted as 'treeid'.
**
** Parameters:
** ptr -- NULL -- "initialize".
** else -- pointer to read area.
** cnt -- count of number of bytes to read.
** treeid -- if ptr == NULL, this is the tree id,
** otherwise this parameter is not supplied.
**
** Returns:
** count of actual number of bytes read.
**
** Side Effects:
** static variables are adjusted correctly. Note that
** this routine can be used on only one tree
** at one time.
*/
relntrrd(ptr, cnt, treerelid, treeowner, treetype, treeid)
char *ptr;
int cnt;
char *treerelid;
char *treeowner;
char treetype;
int treeid;
{
static struct tree trseg;
static char *trp;
static short seqno;
register char *p;
register int n;
register int i;
struct tree trkey;
struct tup_id tid;
p = ptr;
n = cnt;
if (!p)
{
/* initialize -- make buffer appear empty */
trp = &trseg.treetree[sizeof trseg.treetree];
AAbmove(treerelid, trseg.treerelid, MAXNAME);
AAbmove(treeowner, trseg.treeowner, 2);
trseg.treetype = treetype;
trseg.treeid = treeid;
seqno = 0;
opencatalog(AA_TREE, 0);
# ifdef xQTR2
AAtTfp(70, 6, "RELNTRRD: n=%.12s o=%.2s t=%d i=%d\n",
treerelid, treeowner, treetype, treeid);
# endif
return (0);
}
/* fetch characters */
while (n-- > 0)
{
/* check for segment empty */
if (trp >= &trseg.treetree[sizeof trseg.treetree])
{
/* then read new segment */
AAam_clearkeys(&Treedes);
AAam_setkey(&Treedes, &trkey, trseg.treerelid, TREERELID);
AAam_setkey(&Treedes, &trkey, trseg.treeowner, TREEOWNER);
AAam_setkey(&Treedes, &trkey, &trseg.treetype, TREETYPE);
AAam_setkey(&Treedes, &trkey, &trseg.treeid, TREEID);
AAam_setkey(&Treedes, &trkey, &seqno, TREESEQ);
seqno++;
if (i = AAgetequal(&Treedes, &trkey, &trseg, &tid))
AAsyserr(19052, i);
trp = &trseg.treetree[0];
}
/* do actual character fetch */
*p++ = *trp++;
}
return (cnt);
}
/*
** GETTREE -- get tree from AA_TREE catalog
**
** This function, given an internal treeid, fetches and builds
** that tree from the AA_TREE catalog. There is nothing exciting
** except the mapping of variables, done by mapvars().
**
** Parameters:
** treeid -- internal id of tree to fetch and build.
** init -- passed to 'readqry' to tell whether or not
** to initialize the query buffer.
**
** Returns:
** Pointer to root of tree.
*/
QTREE *gettree(treerelid, treeowner, treetype, treeid, init)
char *treerelid;
char *treeowner;
char treetype;
int treeid;
int init;
{
register QTREE *t;
extern int relntrrd();
/* initialize relntrrd() for this treeid */
relntrrd(NULL, 0, treerelid, treeowner, treetype, treeid);
/* read and build query tree */
t = readqry(relntrrd, init);
/* remap varno's to be unique */
if (!init)
mapvars(t);
return (t);
}

47
WEGA/contrib/ingres/dbs/src/qrymod/tree.c Normal file
View File

@ -0,0 +1,47 @@
# include "gen.h"
# include "../h/dbs.h"
# include "../h/tree.h"
# include "../h/symbol.h"
# include "qrymod.h"
/*
** TREE -- create new tree node.
**
** This is a stripped down version of the same thing in the
** parser.
**
** It only knows about lengths of zero and two.
**
** Parameters:
** lptr -- the left pointer.
** rptr -- the right pointer.
** typ -- the node type.
** len -- the node length.
** value -- the node value.
**
** Returns:
** A pointer to the created node.
*/
QTREE *tree(lptr, rptr, typ, len, value)
QTREE *lptr;
QTREE *rptr;
char typ;
int len;
int value;
{
register QTREE *tptr;
extern char *need();
register int l;
l = len;
tptr = (QTREE *) need(Qbuf, l + QT_HDR_SIZ);
tptr->left = lptr;
tptr->right = rptr;
tptr->sym.type = typ;
tptr->sym.len = l;
if (l > 0)
tptr->sym.value[0] = value;
return (tptr);
}

173
WEGA/contrib/ingres/dbs/src/qrymod/treepr.c Normal file
View File

@ -0,0 +1,173 @@
# include "gen.h"
# include "../h/dbs.h"
# include "../h/symbol.h"
# include "../h/tree.h"
# include "../h/aux.h"
# include "qrymod.h"
/*
** TREEPR -- print tree for debugging
**
** This module prints a tree for debugging purposes. There are
** two interfaces: treepr prints an entire treeree, and nodepr
** prints a single node.
**
** Defines:
** treepr -- tree print interface.
** rcsvtrpr -- the recursive part to traverse the tree.
** nodepr -- node print interface.
*/
extern char *Qmdname[]; /* defined in util.c */
/*
** TREEPR -- print tree for debugging
**
** This routine prints a tree for debugging.
**
** Parameters:
** t -- root of tree to be printed
** label -- label to print for identifying the tree. NULL
** is OK and produces a default label.
*/
treepr(tree, label)
register QTREE *tree;
register char *label;
{
register int i;
/* print label */
putchar('\n');
if (label != (char *) 0)
printf("%s ", label);
printf("Querytree @ 0%o:\n", tree);
/* print range table */
for (i = 0; i < MAXVAR + 1; i++)
{
if (!Rangev[i].rused)
continue;
printf("range of %d is %.12s [O=%.2s, S=0%o]\n",
i, Rangev[i].relid, Rangev[i].rowner, Rangev[i].rstat);
}
/* print query type */
if (Qmode >= 0)
printf("%s ", Qmdname[Qmode]);
/* print result relation if realistic */
if (Resultvar >= 0)
printf("Resultvar %d ", Resultvar);
putchar('\n');
/* print tree */
rcsvtrpr(tree);
/* print exciting final stuff */
putchar('\n');
}
/*
** RCSVTRPR -- traverse and print tree
**
** This function does the real stuff for treepr. It recursively
** traverses the tree in postfix order, printing each node.
**
** Parameters:
** tree -- the root of the tree to print.
*/
rcsvtrpr(tree)
register QTREE *tree;
{
while (tree != (QTREE *) 0)
{
rcsvtrpr(tree->left);
nodepr(tree, FALSE);
tree = tree->right;
}
}
/*
** NODEPR -- print node for debugging
**
** Parameters:
** tree -- the node to print.
*/
nodepr(tree)
register QTREE *tree;
{
register int ty;
register int l;
register char *cp;
ty = tree->sym.type;
l = ctou(tree->sym.len);
printf("0%o: 0%o, 0%o/ ", tree, tree->left, tree->right);
printf("%d, %d: ", ty, l);
switch (ty)
{
case VAR:
printf("%d.%d [%d/%d]",
((VAR_NODE *) tree)->varno, ((VAR_NODE *) tree)->attno,
((VAR_NODE *) tree)->frmt, ctou(((VAR_NODE *) tree)->frml));
break;
case RESDOM:
printf("%d [%d/%d]", ((RES_NODE *) tree)->resno,
((VAR_NODE *) tree)->frmt, ((VAR_NODE *) tree)->frml);
break;
case AOP:
printf("%d [%d/%d] [%d/%d]", ((RES_NODE *) tree)->resno,
((VAR_NODE *) tree)->frmt, ((VAR_NODE *) tree)->frml,
((AOP_NODE *) tree)->agfrmt, ((AOP_NODE *) tree)->agfrml);
break;
case UOP:
case BOP:
case COP:
case INT:
switch (tree->sym.len)
{
case sizeof (char):
case sizeof (short):
printf("%d", tree->sym.value[0]);
break;
case sizeof (long):
printf("%ld", ((I4TYPE *) tree->sym.value)->i4type);
break;
}
break;
case FLOAT:
printf("%.10f", ((I4TYPE *) tree->sym.value)->i4type);
break;
case CHAR:
cp = (char *) tree->sym.value;
while (l--)
{
putchar(*cp);
cp++;
}
break;
case TREE:
case AND:
case OR:
case QLEND:
case BYHEAD:
case ROOT:
case AGHEAD:
break;
default:
AAsyserr(19053, ty);
}
printf("/\n");
}

140
WEGA/contrib/ingres/dbs/src/qrymod/writetree.c Normal file
View File

@ -0,0 +1,140 @@
# include <stdio.h>
# include "gen.h"
# include "../h/dbs.h"
# include "../h/aux.h"
# include "../h/pipes.h"
# include "../h/tree.h"
# include "../h/symbol.h"
# include "qrymod.h"
/*
** WRITETREE.C -- query tree output routines
**
** These routines write out a query tree in internal format.
**
** Defines:
** writetree
** writeqry
** writesym
*/
extern struct pipfrmt Pipe;
extern struct pipfrmt Outpipe;
/*
** WRITETREE -- write a query tree
**
** A query tree is written to the down pipe. The parameter is
** the root of the tree to be written.
**
** Parameters:
** q1 -- the root of the tree to write.
** wrfn -- the function to call to do physical
** writes.
*/
writetree(q1, wrfn)
QTREE *q1;
int (*wrfn)();
{
register QTREE *q;
register int l;
register char t;
q = q1;
/* write the subtrees */
if (q->left != NULL)
writetree(q->left, wrfn);
if (q->right != NULL)
writetree(q->right, wrfn);
/* write this node */
t = q->sym.type;
if (t == AND || t == ROOT || t == AGHEAD)
q->sym.len = 0;
(*wrfn)(&(q->sym), TYP_LEN_SIZ);
if (l = ctou(q->sym.len))
(*wrfn)(q->sym.value, l);
# ifdef xQTR1
if (AAtTf(70, 5))
nodepr(q, TRUE);
# endif
}
/*
** WRITEQRY -- write a whole query
**
** An entire query is written, including range table, and so
** forth.
**
** Parameters:
** root -- the root of the tree to write.
** wrfn -- the function to do the physical write.
*/
writeqry(root, wrfn)
QTREE *root;
int (*wrfn)();
{
register int i;
short resvar;
SRCID sid;
/* write the query mode */
if (Qmode >= 0)
{
resvar = Qmode;
writesym(QMODE, sizeof (short), &resvar, wrfn);
}
/* write the range table */
for (i = 0; i < MAXVAR + 1; i++)
{
if (Rangev[i].rused)
{
((SYMBOL *) &sid)->type = SOURCEID;
((SYMBOL *) &sid)->len = SRC_SIZ;
AApmove(Rangev[i].relid, sid.srcname, MAXNAME, ' ');
sid.srcvar = i;
sid.srcstat = Rangev[i].rstat;
AAbmove(Rangev[i].rowner, sid.srcown, 2);
(*wrfn)(&sid, TYP_LEN_SIZ);
(*wrfn)(&sid.srcvar, SRC_SIZ);
}
}
/* write a possible result variable */
if (Resultvar >= 0)
{
resvar = Resultvar;
writesym(RESULTVAR, sizeof (short), &resvar, wrfn);
}
/* write the tree */
writetree(root, wrfn);
}
/*
** WRITESYM -- write a symbol block
**
** A single symbol entry of the is written.
** a 'value' of zero will not be written.
*/
writesym(typ, len, value, wrfn)
int typ;
int len;
char *value;
int (*wrfn)();
{
SYMBOL sym;
register char *v;
register int l;
sym.type = ctou(typ);
sym.len = l = ctou(len);
(*wrfn)(&sym, TYP_LEN_SIZ);
v = value;
if (v != 0)
(*wrfn)(v, l);
}