4.3BSD/usr/ingres/source/support/creatdb.c
# include <stdio.h>
# include <ingres.h>
# include <aux.h>
# include <version.h>
# include <access.h>
# include <symbol.h>
# include <opsys.h>
# include <pv.h>
# include <sccs.h>
# include <sys/dir.h>
SCCSID(@(#)creatdb.c 8.6 1/31/86)
/*
** CREATDB -- create database (or modify database status)
**
** This program creates a new database. It takes the name of
** the new database (syntax defined below) and a series of
** flags (also defined below).
**
** In order to perform this command, you must be enabled by
** having the U_CREATDB bit set in the user status word
** of the users file.
**
** The -m flag specifies that the directory for the database
** already exists. It stands for "mounted-file-system",
** because this is presumably when you might use this feature.
** The directory must be empty.
**
** The -e flag specifies that the database already exists.
** It must be in all ways a valid database. This mode allows
** you to turn flags on and off, as controlled by the other
** flags.
**
** Usage:
** creatdb [flags] databasename
**
** Positional Parameters:
** databasename -- the name of the database to create.
** It must conform to all the usual rules
** about names. Notice that this is more
** restrictive than UNIX usually is: names
** must begin with an alpha, and must be
** composed of alphanumerics. It may be
** at most 14 characters long. Underscore
** counts as an alphabetic.
**
** Flags:
** -m
** This is a mounted filesystem. Actually,
** this just means that the directory in which
** the database is to reside already exists.
** It must be empty.
** -e
** This database exists. When the -e flag is
** specified, the database is brought up to date,
** rather than created. Things which may be
** changed with the -e flag is anything that
** affects the database status or the relation
** status bits.
** -uXX
** Run as user XX (usercode or login name). This
** flag may only be used by the INGRES superuser.
** Normally, the database administrator for the
** new database is the user who performs the
** command, but the -u flag allows INGRES to
** give the database to someone else. Thus, it
** is possible for someone to be a DBA without
** having the U_CREATDB bit set.
** -Fpathname
** Use the named file as the database template.
** This is, of course, for debugging use only.
** +-c
** Turn concurrency control on/off. The default
** for a new database depends on the dbtmplt file,
** but as of this writing it defaults on.
** +-q
** Turn query modification on/off.
** +-l
** Turn protection violation logging on/off.
**
** Files:
** .../files/dbtmplt<VERSION>
** This file drives the entire program. The
** syntax of this file is defined below in
** readdbtemp(). Briefly, it tells the database
** status, the relations in an 'empty' database,
** and the status and format of those relations.
** .../data/base
** This directory is the directory in which all
** databases eventually reside. Each database is
** a subdirectory of this directory.
**
** Return Codes:
** zero -- success
** else -- failure.
**
** Defined Constants:
** MAXRELNS
** This defines the maximum number of relations
** which may be declared in the dbtmplt file.
** MAXDBTEMP
** The maximum size of the dbtmplt file. This
** determines the maximum number of characters
** which may be in the file.
**
** Compilation Flags:
** xB_UNIX -- if defined, says that we have a "Berkeley
** UNIX" system, with no group id's. If
** undefined, specifies either a version seven
** UNIX (with 16-bit group id's) or version six
** UNIX (with 8-bit group id's); either way,
** "setgid(getgid())" will work.
**
** Trace Flags:
** -Tn, as below:
**
** 1 -- makereln()
** 2 -- create()
** 10 -- makeadmin()
** 12 -- makefile()
** 20 -- makedb()
**
** Compilation Instructions:
** % setup creatdb
**
** - which translates to -
**
** % cc -n -O creatdb.c error.c ../../lib/dbulib \
** ../../lib/access ../../lib/utility
** % chmod 4711 a.out
*/
# define MAXRELNS 20
# define MAXDBTEMP 2000
/* relation & attribute reln descriptors used in access methods */
extern DESC Reldes;
extern DESC Attdes;
extern int Status; /* user status, set by initucode */
DESC Btreesec; /* desc for btree sec. structure */
char *Fileset;
int Btree_fd; /* btree file */
int Dbstat; /* database status */
int Dbson, Dbsoff; /* same: bits turned on, bits turned off */
typedef struct reldes
{
int bitson;
int bitsoff;
PARM parmv[PV_MAXPC];
} RELDES;
RELDES Rellist[MAXRELNS];
char Delim;
extern char *Dbpath;
short tTdbu[100];
main(argc, argv)
int argc;
char *argv[];
{
register int i;
int admin;
char adminbuf[100];
extern struct admin Admin;
extern int errno;
auto int code;
struct relation relk;
char *database;
char **av;
register char *p;
char *user_ovrd;
int faterr;
register int *flagv;
char *dbtmpfile;
extern char *Parmvect[];
extern char *Flagvect[];
int exists;
int *flaglkup();
char *ztack();
extern char *rindex();
# ifdef rewinddir
DIR *dir_ptr; /* pointer to '.' */
struct direct *dir; /* directory entry */
# else rewinddir
struct dir direct;
# endif rewinddir
argv[argc] = NULL;
# ifdef xSTR1
tTrace(argv, 'T', tTdbu, 100);
# endif
/*
** Do a lot of magic initialization.
**
** 'exists' get set to -1 if the database does not exist
** at all, 1 if it exists, and 0 if it does not
** exist but there is an indirect pointer to it.
*/
exists = 0;
i = initucode(argc, argv, TRUE, NULL, -1);
switch (i)
{
case 0:
case 5:
exists = 1;
break;
case 6:
exists = 0;
case 1:
break;
case 2:
printf("You are not authorized to create this database\n");
exit(-1);
case 3:
printf("You are not a valid INGRES user\n");
exit(-1);
case 4:
printf("No database name specified\n");
usage:
printf("Usage: creatdb [-uname] [-e] [-m] [+-c] [+-q] dbname\n");
exit(-1);
default:
syserr("initucode %d", i);
}
faterr = 0;
dbtmpfile = 0;
for (av = Flagvect; (p = *av) != NULL; av++)
{
if (p[0] != '-' && p[0] != '+')
syserr("flag %s", p);
switch (p[1])
{
case 'F': /* dbtmplt file */
if (p[2] == 0)
goto badflag;
dbtmpfile = &p[2];
break;
case 'T': /* trace flag */
break;
default:
if (flagv = flaglkup(p[1], p[0]))
{
if (p[0] == '+')
*flagv = 1;
else
*flagv = -1;
continue;
}
badflag:
printf("bad flag %s\n", p);
faterr++;
continue;
}
if (p[0] == '+')
goto badflag;
}
/* check for legality of database name */
database = Parmvect[0];
if (Parmvect[1] != NULL)
{
printf("Too many parameters to creatdb");
goto usage;
}
if (!check(database))
{
printf("Illegal database name %s\n", database);
exit(-1);
}
if ((Status & U_CREATDB) == 0)
{
printf("You are not allowed this command\n");
exit(-1);
}
/* end of input checking */
if (faterr != 0)
exit(2);
/* now see if it should have been there */
if (flagval('m') || flagval('e'))
{
if (exists <= 0)
{
printf("Database %s does not exist\n", database);
exit(-1);
}
# ifdef xSTR3
if (tTf(1, 14))
printf("Dbpath = '%s'\n", Dbpath);
# endif
if (chdir(Dbpath) < 0)
syserr("chdir %s", Dbpath);
if (!flagval('e'))
{
# ifdef rewinddir
/* make certain that it is empty */
if ( (dir_ptr = opendir(".")) == NULL )
syserr(0,"Can't open '.'");
for ( dir = readdir(dir_ptr) ; dir != NULL ; dir = readdir(dir_ptr) )
{
if ( strcmp(".",dir->d_name) && strcmp("..",dir->d_name) )
syserr(0, "%s is not empty", database);
}
closedir(dir_ptr);
# else rewinddir
/* make certain that it is empty */
freopen(".", "r", stdin);
/* Skip "." and ".." entries */
fread(&direct, sizeof (struct dir), 1, stdin);
fread(&direct, sizeof (struct dir), 1, stdin);
while ( fread(&direct, sizeof (struct dir), 1, stdin) != EOF)
{
if ( direct.d_ino != 0)
syserr(0, "%s is not empty", database);
}
# endif rewinddir
}
else
{
/* check for correct owner */
acc_init();
if (!bequal(Usercode, Admin.adhdr.adowner, UCODE_SZ))
syserr(0, "You are not the DBA for this database");
}
}
else
{
if (exists > 0)
{
printf("Database %s already exists\n", database);
exit(-1);
}
/* create it */
i = fork();
if (i < 0)
syserr("fork err");
if (i == 0)
{
/* split off directory */
*(p = rindex(Dbpath, '/')) = '\0';
chdir(Dbpath);
if (setuid(getuid()))
syserr("setuid");
# ifndef xB_UNIX
if (setgid(getgid()))
syserr("setgid");
# endif
# ifdef xV7_UNIX
umask(00);
# endif
*p++ = '/';
execl("/bin/mkdir", "/bin/mkdir", p, 0);
execl("/usr/bin/mkdir", "/usr/bin/mkdir", p, 0);
syserr("exec /bin/mkdir");
}
while (wait(&code) != -1)
continue;
/* move into data/base directory */
if (chdir(Dbpath) < 0)
syserr("chdir %s: probably bad default mode in mkdir",
Dbpath);
/* change the mode of the database */
i = fork();
if (i < 0)
syserr("fork 2");
if (i == 0)
{
setuid(getuid());
if (chmod(".", 0777))
syserr("chmod");
exit(0);
}
while (wait(&code) != -1)
continue;
if ((code & I1MASK) != 0)
exit(code);
}
/* reset 'errno', set from possibly bad chdir */
errno = 0;
/* determine name of dbtmplt file and open */
if (dbtmpfile == NULL)
{
/* create dbtmplt file name */
dbtmpfile = ztack(ztack(Pathname, "/files/dbtmplt"), VERSION);
}
if (freopen(dbtmpfile, "r", stdin) == NULL)
syserr("dbtmplt open %s", dbtmpfile);
readdbtemp();
/* check for type -- update database status versus create */
if (flagval('e'))
changedb();
else
makedb();
/* close the cache descriptors */
# ifdef xSTR3
if (tTf(50, 0))
{
printf("Attdes.reltid = ");
dumptid(&Attdes.reltid);
printf("Reldes.reltid = ");
dumptid(&Reldes.reltid);
}
# endif
if (i = closer(&Attdes))
syserr("creatdb: closer(att) %d", i);
if (i = closer(&Reldes))
syserr("creatdb: closer(rel) %d", i);
/* bring tupcount in 'admin' file to date */
Admin.adreld.reldum.reltups = Reldes.reldum.reltups;
Admin.adattd.reldum.reltups = Attdes.reldum.reltups;
/* set other fields as appropriate */
Admin.adreld.relfp = Admin.adattd.relfp = -1;
Admin.adreld.relopn = Admin.adattd.relopn = 0;
Admin.adhdr.adlength = sizeof Admin.adhdr;
Admin.adhdr.adreldsz = Admin.adhdr.adattdsz = sizeof Admin.adreld;
Admin.adhdr.adversion = DBVERCODE;
if ((admin = creat("admin", FILEMODE)) < 0)
syserr("main: creat admin");
if (write(admin, &Admin, sizeof Admin) != sizeof Admin)
syserr("main: write Admin");
close(admin);
execl((ztack(Pathname, "/bin/sysmod")), "sysmod", database, 0);
/* exit successfully */
exit(0);
}
/*
** Rubout processing.
*/
rubproc()
{
exit(-2);
}
/*
** READDBTEMP -- read the dbtmplt file and build internal form
**
** This routine reads the dbtmplt file (presumably openned as
** the standard input) and initializes the Dbstat (global database
** status word) and Rellist variables.
**
** Rellist is an array of argument vectors, exactly as passed to
** 'create'.
**
** The syntax of the dbtmplt file is as follows:
**
** The first line is a single status word (syntax defined below)
** which is the database status.
**
** The rest of the file is sets of lines separated by blank lines.
** Each set of lines define one relation. Two blank lines in a
** row or an end-of-file define the end of the file. Each set
** of lines is broken down:
**
** The first line is in the following format:
** relname:status
** which defines the relation name and the relation status for
** this relation (syntax defined in 'getstat' below). Status
** may be omitted, in which case a default status is assumed.
**
** Second through n'th lines of each set define the attributes.
** They are of the form:
** attname format
** separated by a single tab. 'Format' is the same as on a
** 'create' statement in QUEL.
**
** Notice that we force the S_CATALOG bit to be on in any
** case. This is because the changedb() routine will fail
** if the -e flag is ever used on this database if any
** relation appears to be a user relation.
**
** Parameters:
** none
**
** Returns:
** none
**
** Side Effects:
** Dbstat gets the database status.
** Rellist is created with a list of the relations,
** (as parameter vectors -01:2st as passed to
** create). The entry after the last entry
** has its pv[0] == NULL.
**
** Called By:
** main
**
** Trace Flags:
** none
*/
readdbtemp()
{
static char buf[MAXDBTEMP];
register RELDES *r;
register PARM *q;
register int i;
int j;
char *p;
int defrstat;
auto int bitson, bitsoff;
/* read database status */
defrstat = S_CATALOG | S_NOUPDT | S_CONCUR | S_PROTALL;
bitson = bitsoff = 0;
Dbstat = getstat(A_DBCONCUR, &Dbson, &Dbsoff);
if (Delim == ':')
defrstat = getstat(defrstat, &bitson, &bitsoff);
if (Delim != '\n')
syserr("readdbtemp: bad Dbstat %c", Delim);
/* compute default relation status */
/* start reading relation info */
p = buf;
for (r = Rellist; ; r++)
{
r->bitson = bitson;
r->bitsoff = bitsoff;
q = r->parmv;
/* get relation name */
q[1].pv_type = PV_STR;
q[1].pv_val.pv_str = p;
p += getname(p) + 1;
/* test for end of dbtmplt file */
if (q[1].pv_val.pv_str[0] == 0)
break;
/* get relation status */
i = getstat(defrstat, &r->bitson, &r->bitsoff);
i |= S_CATALOG; /* guarantee system catalog */
q->pv_type = PV_STR;
q++->pv_val.pv_str = p;
*p++ = ((i >> 15) & 1) + '0';
for (j = 12; j >= 0; j -= 3)
*p++ = ((i >> j) & 07) + '0';
*p++ = 0;
q++;
if (Delim != '\n')
syserr("readdbtemp: bad rel %c", Delim);
/* read attribute names and formats */
for (;;)
{
/* get attribute name */
q->pv_type = PV_STR;
q++->pv_val.pv_str = p;
p += getname(p) + 1;
if (q[-1].pv_val.pv_str[0] == 0)
break;
if (Delim != '\t')
syserr("readdbtemp: bad att %s, d='%c'",
q[-1].pv_val.pv_str, Delim);
/* get attribute type */
q->pv_type = PV_STR;
q++->pv_val.pv_str = p;
p += getname(p) + 1;
if (Delim != '\n')
syserr("readdbtemp: bad type %c", Delim);
}
/* insert end of argv signal */
(--q)->pv_type = PV_EOF;
/* ad-hoc overflow test */
if (p >= &buf[MAXDBTEMP])
syserr("readdbtemp: overflow");
}
/* mark the end of list */
q[1].pv_type = PV_EOF;
}
/*
** GETSTAT -- Get status word
**
** A status word is read from the standard input (presumably
** 'dbtmplt'). The string read is interpreted as an octal
** number. The syntax is:
** N{+c+N[~N]}
** where N is a number, + is a plus or a minus sign, and c is
** a flag. '+c+N1[~N2]' groups are interpreted as follows:
** If flag 'c' is set (assuming the preceeding character is a +,
** clear if it is a -), then set (clear) bits N1. If tilde N2
** is present, then if flag 'c' is unset (called as '-c' ('+c'))
** clear (set) bits N2; if ~N2 is not present, clear (set)
** bits N1.
**
** For example, an entry might be (but probably isn't):
** 1-c-1+q+6~2
** having the following meaning:
**
** 1. Default to the 1 bit set.
**
** 2. If the -c flag is specified, clear the '1' bit. If the
** +c flag is specified, set the '1' bit. If it is unspecified,
** leave the '1' bit alone.
**
** 3. If the +q flag is specified, set the '2' bit and the '4'
** bit. If the -q flag is specified, clear the '2' bit (but leave
** the '4' bit alone). If the +-q flag is unspecified, leave
** those bits alone.
**
** Thus, a database with this entry is initially created with
** the 1 bit on. The '4' bit is a history, which says if the
** 'q' flag has ever been set, while the '2' bit tells if it is
** currently set.
**
** Parameters:
** def -- the default to return if there is no number
** there at all.
** bitson -- a pointer to a word to contain all the
** bits to be turned on -- used for the -e flag.
** bitsoff -- same, for bits turned off.
**
** Returns:
** The value of the status word.
** There are no error returns.
**
** Side Effects:
** File activity.
**
** Called By:
** readdbtemp
**
** Trace Flags:
** none
*/
getstat(def, bitson, bitsoff)
int def;
int *bitson;
int *bitsoff;
{
register int c;
register int stat;
register int i;
int setbits;
int clrbits;
char ctlch;
/* reset bits being turned on and off */
*bitson = *bitsoff = 0;
/* check to see if a base status wolushs defined */
if (Delim == '\n' || (Delim = c = getchar()) < '0' || c > '7')
{
/* no, use default */
stat = def;
}
else
{
/* read base status field */
ungetc(c, stdin);
stat = roctal();
}
/* scan '+c+N' entries */
for (;;)
{
/* check for a flag present */
c = Delim;
if (c == '\n' || c == ':')
return (stat);
if (c != '+' && c != '-')
{
badfmt:
syserr("getstat: bad fmt %c", c);
}
/* we have some flag -- get it's value */
i = flagval(getchar());
/* save sign char on flag */
ctlch = c;
/* get sign on associated number and the number */
c = getchar();
if (c != '+' && c != '-')
goto badfmt;
setbits = roctal();
/* test whether action on -X same as on +X */
if (Delim == '~')
{
/* they have different bits (see above) */
clrbits = roctal();
}
else
{
/* on 'creatdb -e -X', use opposite bits of +X */
clrbits = setbits;
}
/* test for any effect at all */
if (i == 0)
continue;
/* test whether we should process the '+N' */
if ((ctlch == '-') ? (i < 0) : (i > 0))
i = setbits;
else
{
i = clrbits;
/* switch sense of bit action */
if (c == '+')
c = '-';
else
c = '+';
}
if (c == '+')
{
stat |= i;
*bitson |= i;
}
else
{
stat &= ~i;
*bitsoff |= i;
}
}
}
/*
** ROCTAL -- Read an octal number from standard input.
**
** This routine just reads a single octal number from the standard
** input and returns its value. It will only read up to a non-
** octal digit. It will also skip initial and trailing blanks.
** 'Delim' is set to the next character in the input stream.
**
** Parameters:
** none
**
** Returns:
** value of octal number in the input stream.
**
** Side Effects:
** 'Delim' is set to the delimiter which terminated the
** number.
** File activity on stdin.
**
** Called By:
** getstat()
**
** Trace Flags:
** none
*/
roctal()
{
register int c;
register int val;
val = 0;
/* skip initial blanks */
while ((c = getchar()) == ' ')
continue;
/* get numeric value */
while (c >= '0' && c <= '7')
{
val = (val << 3) | (c - '0');
c = getchar();
}
/* skip trailing blanks */
while (c == ' ')
c = getchar();
/* set Delim and return numeric value */
Delim = c;
return (val);
}
/*
** GETNAME -- get name from standard input
**
** This function reads a name from the standard input. A
** name is defined as a string of letters and digits.
**
** The character which caused the scan to terminate is stored
** into 'Delim'.
**
** Parameters:
** ptr -- a pointer to the buffer in which to dump the
** name.
**
** Returns:
** The length of the string.
**
** Side Effects:
** File activity on standard input.
**
** Called By:
** readdbtemp
**
** Trace Flags:
** none
*/
getname(ptr)
char *ptr;
{
register int len;
register int c;
register char *p;
len = 0;
for (p = ptr; (c = getchar()) != EOF; len++)
{
/* check for end of name */
if ((c < 'a' || c > 'z') &&
(c < '0' || c > '9'))
break;
/* store character into buffer */
*p++ = c;
}
/* null-terminate the string */
*p = '\0';
/* store the delimiting character and return length of string */
Delim = c;
return (len);
}
/*
** MAKEDB -- make a database from scratch
**
** This is the code to make a database if the -e flag is off.
**
** The first step is to make a copy of the admin file
** in the internal 'Admin' struct. This is the code which
** subsequently gets used by openr and opencatalog. Notice
** that the admin file is not written out; this happens after
** makedb returns.
**
** Next, the physical files are created with one initial (empty)
** page. This has to happen before the 'create' call so
** that it will be possible to flush 'relation' and 'attribute'
** relation pages during the creates of the 'relation' and
** 'attribute' relations. Other relations don't need this,
** but it is more convenient to be symmetric.
**
** The next step is to create the relations. Of course, all
** this really is is inserting stuff into the system catalogs.
**
** When we are all done we open the relation relation for the
** admin cache (which of course should exist now). Thus,
** the closer's in main (which must be around to update the
** tuple count) will work right.
**
** Parameters:
** none
**
** Returns:
** none
**
** Side Effects:
** A database is created!!
** Several files will be created in the current directory,
** one for each relation mentioned in the
** 'dbtmplt' file.
** The 'Admin' struct will be filled in.
**
** Called By:
** main
**
** Trace Flags:
** 20
*/
makedb()
{
DESC d;
register RELDES *r;
# ifdef xSTR3
if (tTf(51, 0))
printf(">>makedb, Usercode = %s (%u)\n", Usercode, Usercode);
# endif
/* create the physical files */
for (r = Rellist; r->parmv[1].pv_type != PV_EOF; r++)
{
makefile(r);
}
/* initialize the admin file internal cache */
bmove(Usercode, Admin.adhdr.adowner, UCODE_SZ);
Admin.adhdr.adflags = Dbstat;
makeadmin(&Admin.adreld, Rellist[0].parmv);
makeadmin(&Admin.adattd, Rellist[1].parmv);
/* done with admin initialization */
/* initialize relations */
for (r = Rellist; r->parmv[1].pv_type != PV_EOF; r++)
{
makereln(r);
}
}
/*
** MAKEADMIN -- manually initialize descriptor for admin file
**
** The relation descriptor pointed to by 'pv' is turned into
** a descriptor, returned in 'd'. Presumably, this descriptor
** is later written out to the admin file.
**
** Notice that the 'reltid' field is filled in sequentially.
** This means that the relations put into the admin file
** must be created in the same order that they are 'made'
** (by this routine), that the format of tid's must not
** change, and that there can not be over one page worth of
** relations in the admin file. Our current system currently
** handles this easily.
**
** Parameters:
** d -- the descriptor to get the result.
** pv -- a parm vector in 'create' format, which drives
** this routine.
**
** Returns:
** none
**
** Side Effects:
** none
**
** Called By:
** main
**
** Trace Flags:
** 10
*/
makeadmin(d, pv)
DESC *d;
PARM pv[];
{
register DESC *des;
register PARM *p;
register int i;
auto int len;
static int lineno;
char fname[MAXNAME + 3];
des = d;
p = pv;
# ifdef xSTR2
if (tTf(10, -1))
{
printf("creating %s in admin\n", p[1].pv_val.pv_str);
}
# endif
i = oatoi(p++->pv_val.pv_str);
ingresname(p++->pv_val.pv_str, Usercode, fname);
bmove(fname, des->reldum.relid, MAXNAME + 2);
des->reldum.relstat = i;
des->reldum.relatts = 0;
des->reldum.relwid = 0;
des->reldum.relspec = M_HEAP;
des->reltid.ltid = 0;
des->reltid.s_tupid.line_id = lineno++;
des->relfp = open(fname, O_RDWR);
if (des->relfp < 0)
syserr("makeadmin: open %s", fname);
des->relopn = (des->relfp + 1) * -5;
/* initialize domain info */
for (; p++->pv_type != PV_EOF; p++)
{
register char c;
c = p[0].pv_val.pv_str[0];
if (c != 'i' && c != 'c' && c != 'f')
syserr("dbtmplt: type err on %s", p[0].pv_val.pv_str);
des->relfrmt[++(des->reldum.relatts)] = c;
len = atoi(&p[0].pv_val.pv_str[1]);
des->relfrml[des->reldum.relatts] = len;
des->reloff[des->reldum.relatts] = des->reldum.relwid;
des->reldum.relwid += len;
}
}
/*
** MAKEFILE -- make an 'empty' file for a relation
**
** This routine creates a file with a single (empty) page
** on it -- it is part of the 'create' code, essentially.
**
** Parameters:
** rr -- a pointer to the 'reldes' structure for this
** relation (file).
**
** Returns:
** none
**
** Side Effects:
** A file with one page is created.
**
** Called By:
** makedb
** changedb
**
** Trace Flags:
** 12
*/
makefile(r)
register RELDES *r;
{
DESC d;
register int i;
ingresname(r->parmv[1].pv_val.pv_str, Usercode, d.reldum.relid);
# ifdef xSTR1
if (tTf(12, 0))
printf("creat %s\n", d.reldum.relid);
# endif
if ((d.relfp = creat(d.reldum.relid, FILEMODE)) < 0)
syserr("creat %s", d.reldum.relid);
if ((i = formatpg(&d, (long) 1)) != 0)
syserr("makefile: formatpg %d", i);
close(d.relfp);
}
/*
** MAKERELN -- make a relation
**
** This is the second half of the create, started by 'makefile'.
**
** This routine just sets up argument vectors and calls create,
** which does the real work.
**
** Parameters:
** rr -- a pointer to the Rellist entry for the relation
** to be created.
**
** Returns:
** none
**
** Side Effects:
** Information will be inserted into the 'relation' and
** 'attribute' relations.
**
** Called By:
** makedb
** changedb
**
** Trace Flags:
** 1
*/
makereln(r)
register RELDES *r;
{
register int pc;
register PARM *pv;
int i;
pc = 0;
for (pv = r->parmv; pv->pv_type != PV_EOF; pv++)
pc++;
pv = r->parmv;
i = create(pc, pv);
if (i != 0)
syserr("create %d", i);
}
/*
** CHECK -- check database name syntax
**
** The name of a database is checked for validity. A valid
** database name is not more than 14 characters long, begins
** with an alphabetic character, and contains only alpha-
** numerics. Underscore is considered numeric.
**
** Parameters:
** p -- the string to check.
**
** Returns:
** TRUE -- ok.
** FALSE -- failure.
**
** Side Effects:
** none
**
** Called By:
** main
**
** Trace Flags:
** none
*/
check(p)
char *p;
{
register char c;
/* check string length */
if (length(p) > 14)
return (FALSE);
/* check the first character of the string for alphabetic */
c = *p++;
if (c < 'a' || c > 'z')
return (FALSE);
/* check the rest for alphanumeric */
while ((c = *p++) != 0)
{
if (c == '_')
continue;
if (c >= '0' && c <= '9')
continue;
if (c >= 'a' && c <= 'z')
continue;
return (FALSE);
}
return (TRUE);
}
/*
** FLAGLKUP -- look up user flag
**
** This routine helps support a variety of user flags. The
** routine takes a given user flag and looks it up (via a
** very crude linear search) in the 'Flags' vector, and
** returns a pointer to the value.
**
** The 'flag' struct defines the flags. The 'flagname' field
** is the character which is the flag id, for example, 'c'
** in the flag '-c'. The 'flagtype' field defines how the
** flag may appear; if negative, only '-c' may appear, if
** positive, only '+c' may appear; if zero, either form may
** appear. Finally, the 'flagval' field is the value of the
** flag -- it may default any way the user wishes.
**
** Parameters:
** flagname -- the name (as defined above) of the
** flag to be looked up.
** plusminus -- a character, '+' means the '+x' form
** was issued, '-' means the '-x' form was
** issued, something else means *don't care*.
** If an illegal form was issued (that is,
** that does not match the 'flagtype' field
** in the structure), the "not found" return
** is taken.
**
** Returns:
** NULL -- flag not found, or was incorrect type,
** as when the '+x' form is specified in the
** parameters, but the 'Flags' struct says
** that only a '-x' form may appear.
** else -- pointer to the 'flagval' field of the correct
** field in the 'Flags' vector.
**
** Side Effects:
** none
**
** Called By:
** main
** flagval
**
** Trace Flags:
** none
*/
struct flag
{
char flagname; /* the name of the flag */
char flagtype; /* -1: -x form; +1: +x form; 0: both */
int flagval; /* user-defined value of the flag */
};
struct flag Flags[] =
{
'q', 0, 0,
'l', 0, 0,
'c', 0, 0,
'e', -1, 0,
'm', -1, 0,
0
};
int *
flaglkup(flagname, plusminus)
char flagname;
char plusminus;
{
register char f;
register struct flag *p;
register char pm;
f = flagname;
pm = plusminus;
/* look up flag in vector */
for (p = Flags; p->flagname != f; p++)
{
if (p->flagname == 0)
return (NULL);
}
/* found in list -- check type */
if ((pm == '+' && p->flagtype < 0) ||
(pm == '-' && p->flagtype > 0))
return (NULL);
/* type is OK -- return pointer to value */
return (&p->flagval);
}
/*
** FLAGVAL -- return value of a flag
**
** Similar to 'flaglkup', except that the value is returned
** instead of the address, and no error return can occur.
**
** Parameters:
** f -- the flag to look up (see flaglkup).
**
** Returns:
** The value of flag 'f'.
**
** Side Effects:
** none
**
** Called By:
** readdbtemp()
** main()
**
** Trace Flags:
** none
*/
flagval(f)
register char f;
{
register char *p;
int *flaglkup();
/* get value of flag */
p = (char *)flaglkup(f, 0);
/* test for error return, syserr if so */
if (p == NULL)
syserr("flagval: flag %c", f);
/* return value */
return (*p);
}
/*
** CHANGEDB -- change status bits for database/relations
**
** In this function we change the status bits for use with the
** -e flag.
**
** This module always uses the differential status
** change information, so that existing bits are not touched.
**
** We check to see that invalid updates, such as turning off
** query modification when it is already on, can not occur.
** This is because of potential syserr's when the system is
** later run, e.g., because of views without instantiations.
**
** In the second step, the database status is updated. This is
** done strictly in-core, and will be updated in the database
** after we return.
**
** The list of valid relations are then scanned. For each
** relation listed, a series of steps occurs:
**
** (1) The relation is checked for existance. If it does not
** exist, it is created, and we return to the beginning of the
** loop. Notice that we don't have to change modes in this
** case, since it already has been done.
**
** (2) If the relation does exist, we check to see that it
** is a system catalog. If it is not, we have an error, since
** this is a user relation which just happenned to have the
** same name. We inform the user and give up.
**
** (3) If the relation exists, is a system catalog, and all
** that, then we check the changes we need to make in the
** bits. If no change need be made, we continue the loop;
** otherwise, we change the bits and replace the tuple in
** the relation relation.
**
** (4) If the relation being updated was the "relation" or
** "attribute" relation, we change the Admin struct accordingly.
**
** Notice that the result of all this is that all relations
** which might ever be used exist and have the correct status.
**
** Notice that it is fatal for either the attribute or relation
** relations to not exist, since the file is created at the
** same time that relation descriptors are filled in. This
** should not be a problem, since this is only called on an
** existing database.
**
** As a final note, we open the attribute relation cache not
** because we use it, but because we want to do a closer
** in main() to insure that the tupcount is updated in all
** cases.
**
** Parameters:
** none
**
** Returns:
** none
**
** Side Effects:
** The database is brought up to date, as described
** above.
** Tuples may be added or changed in system catalogs.
** Files may be created.
**
** Called By:
** main
**
** Trace Flags:
** 40
*/
changedb()
{
register RELDES *r;
struct relation relk, relt;
TID tid;
register int i;
# ifdef xSTR1
if (tTf(40, 0))
printf(">>> changedb: Dbson=%o, Dbsoff=%o\n", Dbson, Dbsoff);
# endif
/* check to see we aren't doing anything illegal */
if (flagval('q') < 0)
{
syserr(0, "I'm sorry, it is not possible to turn query modification off");
}
/* update the database status field */
Admin.adhdr.adflags = (Admin.adhdr.adflags | Dbson) & ~Dbsoff;
/* open the system catalog caches */
opencatalog("relation", OR_WRITE);
opencatalog("attribute", OR_READ);
/* scan the relation list:- Rellist */
for (r = Rellist; r->parmv[1].pv_type != PV_EOF; r++)
{
/* see if this relation exists */
clearkeys(&Reldes);
setkey(&Reldes, &relk, r->parmv[1].pv_val.pv_str, RELID);
i = getequal(&Reldes, &relk, &relt, &tid);
if (i < 0)
syserr("changedb: getequal");
if (i > 0)
{
/* doesn't exist, create it */
printf("Creating relation %s\n", r->parmv[1].pv_val.pv_str);
makefile(r);
makereln(r);
}
else
{
/* exists -- check to make sure it is the right one */
if ((relt.relstat & S_CATALOG) == 0)
{
/* exists as a user reln -- tough luck buster */
printf("Relation %s already exists -- I cannot bring this database\n", r->parmv[1].pv_val.pv_str);
printf(" up to date. Sorry.\n");
exit(3);
}
/* it exists and is the right one -- update status */
if (r->bitson == 0 && r->bitsoff == 0)
continue;
/* actual work need be done */
relt.relstat = (relt.relstat | r->bitson) & ~r->bitsoff;
/* replace tuple in relation relation */
i = replace(&Reldes, &tid, &relt, FALSE);
if (i != 0)
syserr("changedb: replace %d", i);
/* update Admin struct if "relation" or "attribute" */
if (sequal(r->parmv[1].pv_val.pv_str, "relation"))
Admin.adreld.reldum.relstat = relt.relstat;
else if (sequal(r->parmv[1].pv_val.pv_str, "attribute"))
Admin.adattd.reldum.relstat = relt.relstat;
}
}
}
/*
** READADMIN -- read the admin file into the 'Admin' cache
**
** This routine opens and reads the 'Admin' cache from the
** 'admin' file in the current directory.
**
** This version of the routine is modified for creatdb --
** the '-e' flag is checked, and nothing is performed
** unless it is set.
**
** If not set, the 'relation' and 'attribute' relations
** are opened, and the descriptors for them in the Admin
** struct are filled in with their file descriptors.
**
** Parameters:
** none
**
** Returns:
** none
**
** Side Effects:
** The 'Admin' struct is filled in.
** The 'relation...xx' and 'attribute...xx' files are
** opened.
**
** Called By:
** acc_init (accbuf.c)
** changedb
**
** Trace Flags:
** none
*/
readadmin()
{
register int i;
char relname[MAXNAME + 4];
/* read the stuff from the admin file */
if (flagval('e'))
{
i = open("admin", O_RDONLY);
if (i < 0)
syserr("readadmin: open admin %d", i);
checkadmin(i);
close(i);
/* open the physical files for 'relation' and 'attribute' */
ingresname("relation", Admin.adhdr.adowner, relname);
if ((Admin.adreld.relfp = open(relname, O_RDWR)) < 0)
syserr("readadmin: open `%.14s'", relname);
ingresname("attribute", Admin.adhdr.adowner, relname);
if ((Admin.adattd.relfp = open(relname, O_RDWR)) < 0)
syserr("readadmin: open `%.14s'", relname);
Admin.adreld.relopn = (Admin.adreld.relfp + 1) * -5;
Admin.adattd.relopn = (Admin.adattd.relfp + 1) * 5;
}
return (0);
}