![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to creatdb.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / ingres / source / support|
Return to creatdb.c CVS log | Up to [CSRG BSD Unix] / 43BSD / ingres / source / support |
1.1 root 1:
2: # include <stdio.h>
3: # include <ingres.h>
4: # include <aux.h>
5: # include <version.h>
6: # include <access.h>
7: # include <symbol.h>
8: # include <opsys.h>
9: # include <pv.h>
10: # include <sccs.h>
11: # include <sys/dir.h>
12:
13: SCCSID(@(#)creatdb.c 8.6 1/31/86)
14:
15: /*
16: ** CREATDB -- create database (or modify database status)
17: **
18: ** This program creates a new database. It takes the name of
19: ** the new database (syntax defined below) and a series of
20: ** flags (also defined below).
21: **
22: ** In order to perform this command, you must be enabled by
23: ** having the U_CREATDB bit set in the user status word
24: ** of the users file.
25: **
26: ** The -m flag specifies that the directory for the database
27: ** already exists. It stands for "mounted-file-system",
28: ** because this is presumably when you might use this feature.
29: ** The directory must be empty.
30: **
31: ** The -e flag specifies that the database already exists.
32: ** It must be in all ways a valid database. This mode allows
33: ** you to turn flags on and off, as controlled by the other
34: ** flags.
35: **
36: ** Usage:
37: ** creatdb [flags] databasename
38: **
39: ** Positional Parameters:
40: ** databasename -- the name of the database to create.
41: ** It must conform to all the usual rules
42: ** about names. Notice that this is more
43: ** restrictive than UNIX usually is: names
44: ** must begin with an alpha, and must be
45: ** composed of alphanumerics. It may be
46: ** at most 14 characters long. Underscore
47: ** counts as an alphabetic.
48: **
49: ** Flags:
50: ** -m
51: ** This is a mounted filesystem. Actually,
52: ** this just means that the directory in which
53: ** the database is to reside already exists.
54: ** It must be empty.
55: ** -e
56: ** This database exists. When the -e flag is
57: ** specified, the database is brought up to date,
58: ** rather than created. Things which may be
59: ** changed with the -e flag is anything that
60: ** affects the database status or the relation
61: ** status bits.
62: ** -uXX
63: ** Run as user XX (usercode or login name). This
64: ** flag may only be used by the INGRES superuser.
65: ** Normally, the database administrator for the
66: ** new database is the user who performs the
67: ** command, but the -u flag allows INGRES to
68: ** give the database to someone else. Thus, it
69: ** is possible for someone to be a DBA without
70: ** having the U_CREATDB bit set.
71: ** -Fpathname
72: ** Use the named file as the database template.
73: ** This is, of course, for debugging use only.
74: ** +-c
75: ** Turn concurrency control on/off. The default
76: ** for a new database depends on the dbtmplt file,
77: ** but as of this writing it defaults on.
78: ** +-q
79: ** Turn query modification on/off.
80: ** +-l
81: ** Turn protection violation logging on/off.
82: **
83: ** Files:
84: ** .../files/dbtmplt<VERSION>
85: ** This file drives the entire program. The
86: ** syntax of this file is defined below in
87: ** readdbtemp(). Briefly, it tells the database
88: ** status, the relations in an 'empty' database,
89: ** and the status and format of those relations.
90: ** .../data/base
91: ** This directory is the directory in which all
92: ** databases eventually reside. Each database is
93: ** a subdirectory of this directory.
94: **
95: ** Return Codes:
96: ** zero -- success
97: ** else -- failure.
98: **
99: ** Defined Constants:
100: ** MAXRELNS
101: ** This defines the maximum number of relations
102: ** which may be declared in the dbtmplt file.
103: ** MAXDBTEMP
104: ** The maximum size of the dbtmplt file. This
105: ** determines the maximum number of characters
106: ** which may be in the file.
107: **
108: ** Compilation Flags:
109: ** xB_UNIX -- if defined, says that we have a "Berkeley
110: ** UNIX" system, with no group id's. If
111: ** undefined, specifies either a version seven
112: ** UNIX (with 16-bit group id's) or version six
113: ** UNIX (with 8-bit group id's); either way,
114: ** "setgid(getgid())" will work.
115: **
116: ** Trace Flags:
117: ** -Tn, as below:
118: **
119: ** 1 -- makereln()
120: ** 2 -- create()
121: ** 10 -- makeadmin()
122: ** 12 -- makefile()
123: ** 20 -- makedb()
124: **
125: ** Compilation Instructions:
126: ** % setup creatdb
127: **
128: ** - which translates to -
129: **
130: ** % cc -n -O creatdb.c error.c ../../lib/dbulib \
131: ** ../../lib/access ../../lib/utility
132: ** % chmod 4711 a.out
133: */
134:
135:
136:
137:
138: # define MAXRELNS 20
139: # define MAXDBTEMP 2000
140:
141: /* relation & attribute reln descriptors used in access methods */
142: extern DESC Reldes;
143: extern DESC Attdes;
144:
145: extern int Status; /* user status, set by initucode */
146: DESC Btreesec; /* desc for btree sec. structure */
147: char *Fileset;
148: int Btree_fd; /* btree file */
149: int Dbstat; /* database status */
150: int Dbson, Dbsoff; /* same: bits turned on, bits turned off */
151: typedef struct reldes
152: {
153: int bitson;
154: int bitsoff;
155: PARM parmv[PV_MAXPC];
156: } RELDES;
157: RELDES Rellist[MAXRELNS];
158: char Delim;
159: extern char *Dbpath;
160: short tTdbu[100];
161:
162:
163:
164: main(argc, argv)
165: int argc;
166: char *argv[];
167: {
168: register int i;
169: int admin;
170: char adminbuf[100];
171: extern struct admin Admin;
172: extern int errno;
173: auto int code;
174: struct relation relk;
175: char *database;
176: char **av;
177: register char *p;
178: char *user_ovrd;
179: int faterr;
180: register int *flagv;
181: char *dbtmpfile;
182: extern char *Parmvect[];
183: extern char *Flagvect[];
184: int exists;
185: int *flaglkup();
186: char *ztack();
187: extern char *rindex();
188: # ifdef rewinddir
189: DIR *dir_ptr; /* pointer to '.' */
190: struct direct *dir; /* directory entry */
191: # else rewinddir
192: struct dir direct;
193: # endif rewinddir
194:
195: argv[argc] = NULL;
196:
197: # ifdef xSTR1
198: tTrace(argv, 'T', tTdbu, 100);
199: # endif
200:
201: /*
202: ** Do a lot of magic initialization.
203: **
204: ** 'exists' get set to -1 if the database does not exist
205: ** at all, 1 if it exists, and 0 if it does not
206: ** exist but there is an indirect pointer to it.
207: */
208:
209: exists = 0;
210: i = initucode(argc, argv, TRUE, NULL, -1);
211: switch (i)
212: {
213: case 0:
214: case 5:
215: exists = 1;
216: break;
217:
218: case 6:
219: exists = 0;
220:
221: case 1:
222: break;
223:
224: case 2:
225: printf("You are not authorized to create this database\n");
226: exit(-1);
227:
228: case 3:
229: printf("You are not a valid INGRES user\n");
230: exit(-1);
231:
232: case 4:
233: printf("No database name specified\n");
234: usage:
235: printf("Usage: creatdb [-uname] [-e] [-m] [+-c] [+-q] dbname\n");
236: exit(-1);
237:
238: default:
239: syserr("initucode %d", i);
240: }
241:
242: faterr = 0;
243: dbtmpfile = 0;
244: for (av = Flagvect; (p = *av) != NULL; av++)
245: {
246: if (p[0] != '-' && p[0] != '+')
247: syserr("flag %s", p);
248: switch (p[1])
249: {
250: case 'F': /* dbtmplt file */
251: if (p[2] == 0)
252: goto badflag;
253: dbtmpfile = &p[2];
254: break;
255:
256: case 'T': /* trace flag */
257: break;
258:
259: default:
260: if (flagv = flaglkup(p[1], p[0]))
261: {
262: if (p[0] == '+')
263: *flagv = 1;
264: else
265: *flagv = -1;
266: continue;
267: }
268: badflag:
269: printf("bad flag %s\n", p);
270: faterr++;
271: continue;
272:
273: }
274: if (p[0] == '+')
275: goto badflag;
276: }
277:
278: /* check for legality of database name */
279: database = Parmvect[0];
280: if (Parmvect[1] != NULL)
281: {
282: printf("Too many parameters to creatdb");
283: goto usage;
284: }
285: if (!check(database))
286: {
287: printf("Illegal database name %s\n", database);
288: exit(-1);
289: }
290:
291: if ((Status & U_CREATDB) == 0)
292: {
293: printf("You are not allowed this command\n");
294: exit(-1);
295: }
296:
297: /* end of input checking */
298: if (faterr != 0)
299: exit(2);
300:
301: /* now see if it should have been there */
302: if (flagval('m') || flagval('e'))
303: {
304: if (exists <= 0)
305: {
306: printf("Database %s does not exist\n", database);
307: exit(-1);
308: }
309:
310: # ifdef xSTR3
311: if (tTf(1, 14))
312: printf("Dbpath = '%s'\n", Dbpath);
313: # endif
314: if (chdir(Dbpath) < 0)
315: syserr("chdir %s", Dbpath);
316:
317: if (!flagval('e'))
318: {
319: # ifdef rewinddir
320:
321: /* make certain that it is empty */
322: if ( (dir_ptr = opendir(".")) == NULL )
323: syserr(0,"Can't open '.'");
324: for ( dir = readdir(dir_ptr) ; dir != NULL ; dir = readdir(dir_ptr) )
325: {
326: if ( strcmp(".",dir->d_name) && strcmp("..",dir->d_name) )
327: syserr(0, "%s is not empty", database);
328: }
329: closedir(dir_ptr);
330:
331: # else rewinddir
332: /* make certain that it is empty */
333: freopen(".", "r", stdin);
334: /* Skip "." and ".." entries */
335: fread(&direct, sizeof (struct dir), 1, stdin);
336: fread(&direct, sizeof (struct dir), 1, stdin);
337: while ( fread(&direct, sizeof (struct dir), 1, stdin) != EOF)
338: {
339: if ( direct.d_ino != 0)
340: syserr(0, "%s is not empty", database);
341: }
342: # endif rewinddir
343: }
344: else
345: {
346: /* check for correct owner */
347: acc_init();
348: if (!bequal(Usercode, Admin.adhdr.adowner, UCODE_SZ))
349: syserr(0, "You are not the DBA for this database");
350: }
351: }
352: else
353: {
354: if (exists > 0)
355: {
356: printf("Database %s already exists\n", database);
357: exit(-1);
358: }
359:
360: /* create it */
361: i = fork();
362: if (i < 0)
363: syserr("fork err");
364: if (i == 0)
365: {
366: /* split off directory */
367: *(p = rindex(Dbpath, '/')) = '\0';
368: chdir(Dbpath);
369: if (setuid(getuid()))
370: syserr("setuid");
371: # ifndef xB_UNIX
372: if (setgid(getgid()))
373: syserr("setgid");
374: # endif
375: # ifdef xV7_UNIX
376: umask(00);
377: # endif
378: *p++ = '/';
379: execl("/bin/mkdir", "/bin/mkdir", p, 0);
380: execl("/usr/bin/mkdir", "/usr/bin/mkdir", p, 0);
381: syserr("exec /bin/mkdir");
382: }
383: while (wait(&code) != -1)
384: continue;
385:
386: /* move into data/base directory */
387: if (chdir(Dbpath) < 0)
388: syserr("chdir %s: probably bad default mode in mkdir",
389: Dbpath);
390:
391: /* change the mode of the database */
392: i = fork();
393: if (i < 0)
394: syserr("fork 2");
395: if (i == 0)
396: {
397: setuid(getuid());
398: if (chmod(".", 0777))
399: syserr("chmod");
400: exit(0);
401: }
402:
403: while (wait(&code) != -1)
404: continue;
405: if ((code & I1MASK) != 0)
406: exit(code);
407: }
408:
409: /* reset 'errno', set from possibly bad chdir */
410: errno = 0;
411:
412: /* determine name of dbtmplt file and open */
413: if (dbtmpfile == NULL)
414: {
415: /* create dbtmplt file name */
416: dbtmpfile = ztack(ztack(Pathname, "/files/dbtmplt"), VERSION);
417: }
418: if (freopen(dbtmpfile, "r", stdin) == NULL)
419: syserr("dbtmplt open %s", dbtmpfile);
420:
421: readdbtemp();
422:
423: /* check for type -- update database status versus create */
424: if (flagval('e'))
425: changedb();
426: else
427: makedb();
428:
429: /* close the cache descriptors */
430: # ifdef xSTR3
431: if (tTf(50, 0))
432: {
433: printf("Attdes.reltid = ");
434: dumptid(&Attdes.reltid);
435: printf("Reldes.reltid = ");
436: dumptid(&Reldes.reltid);
437: }
438: # endif
439: if (i = closer(&Attdes))
440: syserr("creatdb: closer(att) %d", i);
441: if (i = closer(&Reldes))
442: syserr("creatdb: closer(rel) %d", i);
443:
444: /* bring tupcount in 'admin' file to date */
445: Admin.adreld.reldum.reltups = Reldes.reldum.reltups;
446: Admin.adattd.reldum.reltups = Attdes.reldum.reltups;
447:
448: /* set other fields as appropriate */
449: Admin.adreld.relfp = Admin.adattd.relfp = -1;
450: Admin.adreld.relopn = Admin.adattd.relopn = 0;
451: Admin.adhdr.adlength = sizeof Admin.adhdr;
452: Admin.adhdr.adreldsz = Admin.adhdr.adattdsz = sizeof Admin.adreld;
453: Admin.adhdr.adversion = DBVERCODE;
454:
455: if ((admin = creat("admin", FILEMODE)) < 0)
456: syserr("main: creat admin");
457: if (write(admin, &Admin, sizeof Admin) != sizeof Admin)
458: syserr("main: write Admin");
459: close(admin);
460:
461: execl((ztack(Pathname, "/bin/sysmod")), "sysmod", database, 0);
462: /* exit successfully */
463: exit(0);
464: }
465: /*
466: ** Rubout processing.
467: */
468:
469: rubproc()
470: {
471: exit(-2);
472: }
473: /*
474: ** READDBTEMP -- read the dbtmplt file and build internal form
475: **
476: ** This routine reads the dbtmplt file (presumably openned as
477: ** the standard input) and initializes the Dbstat (global database
478: ** status word) and Rellist variables.
479: **
480: ** Rellist is an array of argument vectors, exactly as passed to
481: ** 'create'.
482: **
483: ** The syntax of the dbtmplt file is as follows:
484: **
485: ** The first line is a single status word (syntax defined below)
486: ** which is the database status.
487: **
488: ** The rest of the file is sets of lines separated by blank lines.
489: ** Each set of lines define one relation. Two blank lines in a
490: ** row or an end-of-file define the end of the file. Each set
491: ** of lines is broken down:
492: **
493: ** The first line is in the following format:
494: ** relname:status
495: ** which defines the relation name and the relation status for
496: ** this relation (syntax defined in 'getstat' below). Status
497: ** may be omitted, in which case a default status is assumed.
498: **
499: ** Second through n'th lines of each set define the attributes.
500: ** They are of the form:
501: ** attname format
502: ** separated by a single tab. 'Format' is the same as on a
503: ** 'create' statement in QUEL.
504: **
505: ** Notice that we force the S_CATALOG bit to be on in any
506: ** case. This is because the changedb() routine will fail
507: ** if the -e flag is ever used on this database if any
508: ** relation appears to be a user relation.
509: **
510: ** Parameters:
511: ** none
512: **
513: ** Returns:
514: ** none
515: **
516: ** Side Effects:
517: ** Dbstat gets the database status.
518: ** Rellist is created with a list of the relations,
519: ** (as parameter vectors -01:2st as passed to
520: ** create). The entry after the last entry
521: ** has its pv[0] == NULL.
522: **
523: ** Called By:
524: ** main
525: **
526: ** Trace Flags:
527: ** none
528: */
529:
530: readdbtemp()
531: {
532: static char buf[MAXDBTEMP];
533: register RELDES *r;
534: register PARM *q;
535: register int i;
536: int j;
537: char *p;
538: int defrstat;
539: auto int bitson, bitsoff;
540:
541: /* read database status */
542: defrstat = S_CATALOG | S_NOUPDT | S_CONCUR | S_PROTALL;
543: bitson = bitsoff = 0;
544: Dbstat = getstat(A_DBCONCUR, &Dbson, &Dbsoff);
545: if (Delim == ':')
546: defrstat = getstat(defrstat, &bitson, &bitsoff);
547: if (Delim != '\n')
548: syserr("readdbtemp: bad Dbstat %c", Delim);
549:
550: /* compute default relation status */
551:
552: /* start reading relation info */
553: p = buf;
554: for (r = Rellist; ; r++)
555: {
556: r->bitson = bitson;
557: r->bitsoff = bitsoff;
558:
559: q = r->parmv;
560:
561: /* get relation name */
562: q[1].pv_type = PV_STR;
563: q[1].pv_val.pv_str = p;
564: p += getname(p) + 1;
565:
566: /* test for end of dbtmplt file */
567: if (q[1].pv_val.pv_str[0] == 0)
568: break;
569:
570: /* get relation status */
571: i = getstat(defrstat, &r->bitson, &r->bitsoff);
572: i |= S_CATALOG; /* guarantee system catalog */
573: q->pv_type = PV_STR;
574: q++->pv_val.pv_str = p;
575: *p++ = ((i >> 15) & 1) + '0';
576: for (j = 12; j >= 0; j -= 3)
577: *p++ = ((i >> j) & 07) + '0';
578: *p++ = 0;
579: q++;
580: if (Delim != '\n')
581: syserr("readdbtemp: bad rel %c", Delim);
582:
583: /* read attribute names and formats */
584: for (;;)
585: {
586: /* get attribute name */
587: q->pv_type = PV_STR;
588: q++->pv_val.pv_str = p;
589: p += getname(p) + 1;
590: if (q[-1].pv_val.pv_str[0] == 0)
591: break;
592: if (Delim != '\t')
593: syserr("readdbtemp: bad att %s, d='%c'",
594: q[-1].pv_val.pv_str, Delim);
595:
596: /* get attribute type */
597: q->pv_type = PV_STR;
598: q++->pv_val.pv_str = p;
599: p += getname(p) + 1;
600: if (Delim != '\n')
601: syserr("readdbtemp: bad type %c", Delim);
602: }
603:
604: /* insert end of argv signal */
605: (--q)->pv_type = PV_EOF;
606:
607: /* ad-hoc overflow test */
608: if (p >= &buf[MAXDBTEMP])
609: syserr("readdbtemp: overflow");
610: }
611: /* mark the end of list */
612: q[1].pv_type = PV_EOF;
613: }
614: /*
615: ** GETSTAT -- Get status word
616: **
617: ** A status word is read from the standard input (presumably
618: ** 'dbtmplt'). The string read is interpreted as an octal
619: ** number. The syntax is:
620: ** N{+c+N[~N]}
621: ** where N is a number, + is a plus or a minus sign, and c is
622: ** a flag. '+c+N1[~N2]' groups are interpreted as follows:
623: ** If flag 'c' is set (assuming the preceeding character is a +,
624: ** clear if it is a -), then set (clear) bits N1. If tilde N2
625: ** is present, then if flag 'c' is unset (called as '-c' ('+c'))
626: ** clear (set) bits N2; if ~N2 is not present, clear (set)
627: ** bits N1.
628: **
629: ** For example, an entry might be (but probably isn't):
630: ** 1-c-1+q+6~2
631: ** having the following meaning:
632: **
633: ** 1. Default to the 1 bit set.
634: **
635: ** 2. If the -c flag is specified, clear the '1' bit. If the
636: ** +c flag is specified, set the '1' bit. If it is unspecified,
637: ** leave the '1' bit alone.
638: **
639: ** 3. If the +q flag is specified, set the '2' bit and the '4'
640: ** bit. If the -q flag is specified, clear the '2' bit (but leave
641: ** the '4' bit alone). If the +-q flag is unspecified, leave
642: ** those bits alone.
643: **
644: ** Thus, a database with this entry is initially created with
645: ** the 1 bit on. The '4' bit is a history, which says if the
646: ** 'q' flag has ever been set, while the '2' bit tells if it is
647: ** currently set.
648: **
649: ** Parameters:
650: ** def -- the default to return if there is no number
651: ** there at all.
652: ** bitson -- a pointer to a word to contain all the
653: ** bits to be turned on -- used for the -e flag.
654: ** bitsoff -- same, for bits turned off.
655: **
656: ** Returns:
657: ** The value of the status word.
658: ** There are no error returns.
659: **
660: ** Side Effects:
661: ** File activity.
662: **
663: ** Called By:
664: ** readdbtemp
665: **
666: ** Trace Flags:
667: ** none
668: */
669:
670: getstat(def, bitson, bitsoff)
671: int def;
672: int *bitson;
673: int *bitsoff;
674: {
675: register int c;
676: register int stat;
677: register int i;
678: int setbits;
679: int clrbits;
680: char ctlch;
681:
682: /* reset bits being turned on and off */
683: *bitson = *bitsoff = 0;
684:
685: /* check to see if a base status wolushs defined */
686: if (Delim == '\n' || (Delim = c = getchar()) < '0' || c > '7')
687: {
688: /* no, use default */
689: stat = def;
690: }
691: else
692: {
693: /* read base status field */
694: ungetc(c, stdin);
695: stat = roctal();
696: }
697:
698: /* scan '+c+N' entries */
699: for (;;)
700: {
701: /* check for a flag present */
702: c = Delim;
703: if (c == '\n' || c == ':')
704: return (stat);
705: if (c != '+' && c != '-')
706: {
707: badfmt:
708: syserr("getstat: bad fmt %c", c);
709: }
710:
711: /* we have some flag -- get it's value */
712: i = flagval(getchar());
713:
714: /* save sign char on flag */
715: ctlch = c;
716:
717: /* get sign on associated number and the number */
718: c = getchar();
719: if (c != '+' && c != '-')
720: goto badfmt;
721: setbits = roctal();
722:
723: /* test whether action on -X same as on +X */
724: if (Delim == '~')
725: {
726: /* they have different bits (see above) */
727: clrbits = roctal();
728: }
729: else
730: {
731: /* on 'creatdb -e -X', use opposite bits of +X */
732: clrbits = setbits;
733: }
734:
735: /* test for any effect at all */
736: if (i == 0)
737: continue;
738:
739: /* test whether we should process the '+N' */
740: if ((ctlch == '-') ? (i < 0) : (i > 0))
741: i = setbits;
742: else
743: {
744: i = clrbits;
745:
746: /* switch sense of bit action */
747: if (c == '+')
748: c = '-';
749: else
750: c = '+';
751: }
752:
753: if (c == '+')
754: {
755: stat |= i;
756: *bitson |= i;
757: }
758: else
759: {
760: stat &= ~i;
761: *bitsoff |= i;
762: }
763: }
764: }
765: /*
766: ** ROCTAL -- Read an octal number from standard input.
767: **
768: ** This routine just reads a single octal number from the standard
769: ** input and returns its value. It will only read up to a non-
770: ** octal digit. It will also skip initial and trailing blanks.
771: ** 'Delim' is set to the next character in the input stream.
772: **
773: ** Parameters:
774: ** none
775: **
776: ** Returns:
777: ** value of octal number in the input stream.
778: **
779: ** Side Effects:
780: ** 'Delim' is set to the delimiter which terminated the
781: ** number.
782: ** File activity on stdin.
783: **
784: ** Called By:
785: ** getstat()
786: **
787: ** Trace Flags:
788: ** none
789: */
790:
791: roctal()
792: {
793: register int c;
794: register int val;
795:
796: val = 0;
797:
798: /* skip initial blanks */
799: while ((c = getchar()) == ' ')
800: continue;
801:
802: /* get numeric value */
803: while (c >= '0' && c <= '7')
804: {
805: val = (val << 3) | (c - '0');
806: c = getchar();
807: }
808:
809: /* skip trailing blanks */
810: while (c == ' ')
811: c = getchar();
812:
813: /* set Delim and return numeric value */
814: Delim = c;
815: return (val);
816: }
817: /*
818: ** GETNAME -- get name from standard input
819: **
820: ** This function reads a name from the standard input. A
821: ** name is defined as a string of letters and digits.
822: **
823: ** The character which caused the scan to terminate is stored
824: ** into 'Delim'.
825: **
826: ** Parameters:
827: ** ptr -- a pointer to the buffer in which to dump the
828: ** name.
829: **
830: ** Returns:
831: ** The length of the string.
832: **
833: ** Side Effects:
834: ** File activity on standard input.
835: **
836: ** Called By:
837: ** readdbtemp
838: **
839: ** Trace Flags:
840: ** none
841: */
842:
843: getname(ptr)
844: char *ptr;
845: {
846: register int len;
847: register int c;
848: register char *p;
849:
850: len = 0;
851:
852: for (p = ptr; (c = getchar()) != EOF; len++)
853: {
854: /* check for end of name */
855: if ((c < 'a' || c > 'z') &&
856: (c < '0' || c > '9'))
857: break;
858:
859: /* store character into buffer */
860: *p++ = c;
861: }
862:
863: /* null-terminate the string */
864: *p = '\0';
865:
866: /* store the delimiting character and return length of string */
867: Delim = c;
868: return (len);
869: }
870: /*
871: ** MAKEDB -- make a database from scratch
872: **
873: ** This is the code to make a database if the -e flag is off.
874: **
875: ** The first step is to make a copy of the admin file
876: ** in the internal 'Admin' struct. This is the code which
877: ** subsequently gets used by openr and opencatalog. Notice
878: ** that the admin file is not written out; this happens after
879: ** makedb returns.
880: **
881: ** Next, the physical files are created with one initial (empty)
882: ** page. This has to happen before the 'create' call so
883: ** that it will be possible to flush 'relation' and 'attribute'
884: ** relation pages during the creates of the 'relation' and
885: ** 'attribute' relations. Other relations don't need this,
886: ** but it is more convenient to be symmetric.
887: **
888: ** The next step is to create the relations. Of course, all
889: ** this really is is inserting stuff into the system catalogs.
890: **
891: ** When we are all done we open the relation relation for the
892: ** admin cache (which of course should exist now). Thus,
893: ** the closer's in main (which must be around to update the
894: ** tuple count) will work right.
895: **
896: ** Parameters:
897: ** none
898: **
899: ** Returns:
900: ** none
901: **
902: ** Side Effects:
903: ** A database is created!!
904: ** Several files will be created in the current directory,
905: ** one for each relation mentioned in the
906: ** 'dbtmplt' file.
907: ** The 'Admin' struct will be filled in.
908: **
909: ** Called By:
910: ** main
911: **
912: ** Trace Flags:
913: ** 20
914: */
915:
916: makedb()
917: {
918: DESC d;
919: register RELDES *r;
920:
921: # ifdef xSTR3
922: if (tTf(51, 0))
923: printf(">>makedb, Usercode = %s (%u)\n", Usercode, Usercode);
924: # endif
925:
926: /* create the physical files */
927: for (r = Rellist; r->parmv[1].pv_type != PV_EOF; r++)
928: {
929: makefile(r);
930: }
931:
932: /* initialize the admin file internal cache */
933: bmove(Usercode, Admin.adhdr.adowner, UCODE_SZ);
934: Admin.adhdr.adflags = Dbstat;
935: makeadmin(&Admin.adreld, Rellist[0].parmv);
936: makeadmin(&Admin.adattd, Rellist[1].parmv);
937:
938: /* done with admin initialization */
939:
940: /* initialize relations */
941: for (r = Rellist; r->parmv[1].pv_type != PV_EOF; r++)
942: {
943: makereln(r);
944: }
945: }
946: /*
947: ** MAKEADMIN -- manually initialize descriptor for admin file
948: **
949: ** The relation descriptor pointed to by 'pv' is turned into
950: ** a descriptor, returned in 'd'. Presumably, this descriptor
951: ** is later written out to the admin file.
952: **
953: ** Notice that the 'reltid' field is filled in sequentially.
954: ** This means that the relations put into the admin file
955: ** must be created in the same order that they are 'made'
956: ** (by this routine), that the format of tid's must not
957: ** change, and that there can not be over one page worth of
958: ** relations in the admin file. Our current system currently
959: ** handles this easily.
960: **
961: ** Parameters:
962: ** d -- the descriptor to get the result.
963: ** pv -- a parm vector in 'create' format, which drives
964: ** this routine.
965: **
966: ** Returns:
967: ** none
968: **
969: ** Side Effects:
970: ** none
971: **
972: ** Called By:
973: ** main
974: **
975: ** Trace Flags:
976: ** 10
977: */
978:
979:
980:
981: makeadmin(d, pv)
982: DESC *d;
983: PARM pv[];
984: {
985: register DESC *des;
986: register PARM *p;
987: register int i;
988: auto int len;
989: static int lineno;
990: char fname[MAXNAME + 3];
991:
992: des = d;
993: p = pv;
994:
995: # ifdef xSTR2
996: if (tTf(10, -1))
997: {
998: printf("creating %s in admin\n", p[1].pv_val.pv_str);
999: }
1000: # endif
1001: i = oatoi(p++->pv_val.pv_str);
1002: ingresname(p++->pv_val.pv_str, Usercode, fname);
1003: bmove(fname, des->reldum.relid, MAXNAME + 2);
1004: des->reldum.relstat = i;
1005: des->reldum.relatts = 0;
1006: des->reldum.relwid = 0;
1007: des->reldum.relspec = M_HEAP;
1008: des->reltid.ltid = 0;
1009: des->reltid.s_tupid.line_id = lineno++;
1010: des->relfp = open(fname, O_RDWR);
1011: if (des->relfp < 0)
1012: syserr("makeadmin: open %s", fname);
1013: des->relopn = (des->relfp + 1) * -5;
1014:
1015: /* initialize domain info */
1016: for (; p++->pv_type != PV_EOF; p++)
1017: {
1018: register char c;
1019:
1020: c = p[0].pv_val.pv_str[0];
1021: if (c != 'i' && c != 'c' && c != 'f')
1022: syserr("dbtmplt: type err on %s", p[0].pv_val.pv_str);
1023: des->relfrmt[++(des->reldum.relatts)] = c;
1024: len = atoi(&p[0].pv_val.pv_str[1]);
1025: des->relfrml[des->reldum.relatts] = len;
1026: des->reloff[des->reldum.relatts] = des->reldum.relwid;
1027: des->reldum.relwid += len;
1028: }
1029: }
1030: /*
1031: ** MAKEFILE -- make an 'empty' file for a relation
1032: **
1033: ** This routine creates a file with a single (empty) page
1034: ** on it -- it is part of the 'create' code, essentially.
1035: **
1036: ** Parameters:
1037: ** rr -- a pointer to the 'reldes' structure for this
1038: ** relation (file).
1039: **
1040: ** Returns:
1041: ** none
1042: **
1043: ** Side Effects:
1044: ** A file with one page is created.
1045: **
1046: ** Called By:
1047: ** makedb
1048: ** changedb
1049: **
1050: ** Trace Flags:
1051: ** 12
1052: */
1053:
1054: makefile(r)
1055: register RELDES *r;
1056: {
1057: DESC d;
1058: register int i;
1059:
1060: ingresname(r->parmv[1].pv_val.pv_str, Usercode, d.reldum.relid);
1061: # ifdef xSTR1
1062: if (tTf(12, 0))
1063: printf("creat %s\n", d.reldum.relid);
1064: # endif
1065: if ((d.relfp = creat(d.reldum.relid, FILEMODE)) < 0)
1066: syserr("creat %s", d.reldum.relid);
1067: if ((i = formatpg(&d, (long) 1)) != 0)
1068: syserr("makefile: formatpg %d", i);
1069: close(d.relfp);
1070: }
1071: /*
1072: ** MAKERELN -- make a relation
1073: **
1074: ** This is the second half of the create, started by 'makefile'.
1075: **
1076: ** This routine just sets up argument vectors and calls create,
1077: ** which does the real work.
1078: **
1079: ** Parameters:
1080: ** rr -- a pointer to the Rellist entry for the relation
1081: ** to be created.
1082: **
1083: ** Returns:
1084: ** none
1085: **
1086: ** Side Effects:
1087: ** Information will be inserted into the 'relation' and
1088: ** 'attribute' relations.
1089: **
1090: ** Called By:
1091: ** makedb
1092: ** changedb
1093: **
1094: ** Trace Flags:
1095: ** 1
1096: */
1097:
1098: makereln(r)
1099: register RELDES *r;
1100: {
1101: register int pc;
1102: register PARM *pv;
1103: int i;
1104:
1105: pc = 0;
1106: for (pv = r->parmv; pv->pv_type != PV_EOF; pv++)
1107: pc++;
1108: pv = r->parmv;
1109: i = create(pc, pv);
1110: if (i != 0)
1111: syserr("create %d", i);
1112: }
1113: /*
1114: ** CHECK -- check database name syntax
1115: **
1116: ** The name of a database is checked for validity. A valid
1117: ** database name is not more than 14 characters long, begins
1118: ** with an alphabetic character, and contains only alpha-
1119: ** numerics. Underscore is considered numeric.
1120: **
1121: ** Parameters:
1122: ** p -- the string to check.
1123: **
1124: ** Returns:
1125: ** TRUE -- ok.
1126: ** FALSE -- failure.
1127: **
1128: ** Side Effects:
1129: ** none
1130: **
1131: ** Called By:
1132: ** main
1133: **
1134: ** Trace Flags:
1135: ** none
1136: */
1137:
1138: check(p)
1139: char *p;
1140: {
1141: register char c;
1142:
1143: /* check string length */
1144: if (length(p) > 14)
1145: return (FALSE);
1146:
1147: /* check the first character of the string for alphabetic */
1148: c = *p++;
1149: if (c < 'a' || c > 'z')
1150: return (FALSE);
1151:
1152: /* check the rest for alphanumeric */
1153: while ((c = *p++) != 0)
1154: {
1155: if (c == '_')
1156: continue;
1157: if (c >= '0' && c <= '9')
1158: continue;
1159: if (c >= 'a' && c <= 'z')
1160: continue;
1161: return (FALSE);
1162: }
1163: return (TRUE);
1164: }
1165: /*
1166: ** FLAGLKUP -- look up user flag
1167: **
1168: ** This routine helps support a variety of user flags. The
1169: ** routine takes a given user flag and looks it up (via a
1170: ** very crude linear search) in the 'Flags' vector, and
1171: ** returns a pointer to the value.
1172: **
1173: ** The 'flag' struct defines the flags. The 'flagname' field
1174: ** is the character which is the flag id, for example, 'c'
1175: ** in the flag '-c'. The 'flagtype' field defines how the
1176: ** flag may appear; if negative, only '-c' may appear, if
1177: ** positive, only '+c' may appear; if zero, either form may
1178: ** appear. Finally, the 'flagval' field is the value of the
1179: ** flag -- it may default any way the user wishes.
1180: **
1181: ** Parameters:
1182: ** flagname -- the name (as defined above) of the
1183: ** flag to be looked up.
1184: ** plusminus -- a character, '+' means the '+x' form
1185: ** was issued, '-' means the '-x' form was
1186: ** issued, something else means *don't care*.
1187: ** If an illegal form was issued (that is,
1188: ** that does not match the 'flagtype' field
1189: ** in the structure), the "not found" return
1190: ** is taken.
1191: **
1192: ** Returns:
1193: ** NULL -- flag not found, or was incorrect type,
1194: ** as when the '+x' form is specified in the
1195: ** parameters, but the 'Flags' struct says
1196: ** that only a '-x' form may appear.
1197: ** else -- pointer to the 'flagval' field of the correct
1198: ** field in the 'Flags' vector.
1199: **
1200: ** Side Effects:
1201: ** none
1202: **
1203: ** Called By:
1204: ** main
1205: ** flagval
1206: **
1207: ** Trace Flags:
1208: ** none
1209: */
1210:
1211: struct flag
1212: {
1213: char flagname; /* the name of the flag */
1214: char flagtype; /* -1: -x form; +1: +x form; 0: both */
1215: int flagval; /* user-defined value of the flag */
1216: };
1217:
1218: struct flag Flags[] =
1219: {
1220: 'q', 0, 0,
1221: 'l', 0, 0,
1222: 'c', 0, 0,
1223: 'e', -1, 0,
1224: 'm', -1, 0,
1225: 0
1226: };
1227:
1228: int *
1229: flaglkup(flagname, plusminus)
1230: char flagname;
1231: char plusminus;
1232: {
1233: register char f;
1234: register struct flag *p;
1235: register char pm;
1236:
1237: f = flagname;
1238: pm = plusminus;
1239:
1240: /* look up flag in vector */
1241: for (p = Flags; p->flagname != f; p++)
1242: {
1243: if (p->flagname == 0)
1244: return (NULL);
1245: }
1246:
1247: /* found in list -- check type */
1248: if ((pm == '+' && p->flagtype < 0) ||
1249: (pm == '-' && p->flagtype > 0))
1250: return (NULL);
1251:
1252: /* type is OK -- return pointer to value */
1253: return (&p->flagval);
1254: }
1255: /*
1256: ** FLAGVAL -- return value of a flag
1257: **
1258: ** Similar to 'flaglkup', except that the value is returned
1259: ** instead of the address, and no error return can occur.
1260: **
1261: ** Parameters:
1262: ** f -- the flag to look up (see flaglkup).
1263: **
1264: ** Returns:
1265: ** The value of flag 'f'.
1266: **
1267: ** Side Effects:
1268: ** none
1269: **
1270: ** Called By:
1271: ** readdbtemp()
1272: ** main()
1273: **
1274: ** Trace Flags:
1275: ** none
1276: */
1277:
1278: flagval(f)
1279: register char f;
1280: {
1281: register char *p;
1282: int *flaglkup();
1283:
1284: /* get value of flag */
1285: p = (char *)flaglkup(f, 0);
1286:
1287: /* test for error return, syserr if so */
1288: if (p == NULL)
1289: syserr("flagval: flag %c", f);
1290:
1291: /* return value */
1292: return (*p);
1293: }
1294: /*
1295: ** CHANGEDB -- change status bits for database/relations
1296: **
1297: ** In this function we change the status bits for use with the
1298: ** -e flag.
1299: **
1300: ** This module always uses the differential status
1301: ** change information, so that existing bits are not touched.
1302: **
1303: ** We check to see that invalid updates, such as turning off
1304: ** query modification when it is already on, can not occur.
1305: ** This is because of potential syserr's when the system is
1306: ** later run, e.g., because of views without instantiations.
1307: **
1308: ** In the second step, the database status is updated. This is
1309: ** done strictly in-core, and will be updated in the database
1310: ** after we return.
1311: **
1312: ** The list of valid relations are then scanned. For each
1313: ** relation listed, a series of steps occurs:
1314: **
1315: ** (1) The relation is checked for existance. If it does not
1316: ** exist, it is created, and we return to the beginning of the
1317: ** loop. Notice that we don't have to change modes in this
1318: ** case, since it already has been done.
1319: **
1320: ** (2) If the relation does exist, we check to see that it
1321: ** is a system catalog. If it is not, we have an error, since
1322: ** this is a user relation which just happenned to have the
1323: ** same name. We inform the user and give up.
1324: **
1325: ** (3) If the relation exists, is a system catalog, and all
1326: ** that, then we check the changes we need to make in the
1327: ** bits. If no change need be made, we continue the loop;
1328: ** otherwise, we change the bits and replace the tuple in
1329: ** the relation relation.
1330: **
1331: ** (4) If the relation being updated was the "relation" or
1332: ** "attribute" relation, we change the Admin struct accordingly.
1333: **
1334: ** Notice that the result of all this is that all relations
1335: ** which might ever be used exist and have the correct status.
1336: **
1337: ** Notice that it is fatal for either the attribute or relation
1338: ** relations to not exist, since the file is created at the
1339: ** same time that relation descriptors are filled in. This
1340: ** should not be a problem, since this is only called on an
1341: ** existing database.
1342: **
1343: ** As a final note, we open the attribute relation cache not
1344: ** because we use it, but because we want to do a closer
1345: ** in main() to insure that the tupcount is updated in all
1346: ** cases.
1347: **
1348: ** Parameters:
1349: ** none
1350: **
1351: ** Returns:
1352: ** none
1353: **
1354: ** Side Effects:
1355: ** The database is brought up to date, as described
1356: ** above.
1357: ** Tuples may be added or changed in system catalogs.
1358: ** Files may be created.
1359: **
1360: ** Called By:
1361: ** main
1362: **
1363: ** Trace Flags:
1364: ** 40
1365: */
1366:
1367: changedb()
1368: {
1369: register RELDES *r;
1370: struct relation relk, relt;
1371: TID tid;
1372: register int i;
1373:
1374: # ifdef xSTR1
1375: if (tTf(40, 0))
1376: printf(">>> changedb: Dbson=%o, Dbsoff=%o\n", Dbson, Dbsoff);
1377: # endif
1378:
1379: /* check to see we aren't doing anything illegal */
1380: if (flagval('q') < 0)
1381: {
1382: syserr(0, "I'm sorry, it is not possible to turn query modification off");
1383: }
1384:
1385: /* update the database status field */
1386: Admin.adhdr.adflags = (Admin.adhdr.adflags | Dbson) & ~Dbsoff;
1387:
1388: /* open the system catalog caches */
1389: opencatalog("relation", OR_WRITE);
1390: opencatalog("attribute", OR_READ);
1391:
1392: /* scan the relation list:- Rellist */
1393: for (r = Rellist; r->parmv[1].pv_type != PV_EOF; r++)
1394: {
1395: /* see if this relation exists */
1396: clearkeys(&Reldes);
1397: setkey(&Reldes, &relk, r->parmv[1].pv_val.pv_str, RELID);
1398: i = getequal(&Reldes, &relk, &relt, &tid);
1399:
1400: if (i < 0)
1401: syserr("changedb: getequal");
1402:
1403: if (i > 0)
1404: {
1405: /* doesn't exist, create it */
1406: printf("Creating relation %s\n", r->parmv[1].pv_val.pv_str);
1407: makefile(r);
1408: makereln(r);
1409: }
1410: else
1411: {
1412: /* exists -- check to make sure it is the right one */
1413: if ((relt.relstat & S_CATALOG) == 0)
1414: {
1415: /* exists as a user reln -- tough luck buster */
1416: printf("Relation %s already exists -- I cannot bring this database\n", r->parmv[1].pv_val.pv_str);
1417: printf(" up to date. Sorry.\n");
1418: exit(3);
1419: }
1420:
1421: /* it exists and is the right one -- update status */
1422: if (r->bitson == 0 && r->bitsoff == 0)
1423: continue;
1424:
1425: /* actual work need be done */
1426: relt.relstat = (relt.relstat | r->bitson) & ~r->bitsoff;
1427:
1428: /* replace tuple in relation relation */
1429: i = replace(&Reldes, &tid, &relt, FALSE);
1430: if (i != 0)
1431: syserr("changedb: replace %d", i);
1432:
1433: /* update Admin struct if "relation" or "attribute" */
1434: if (sequal(r->parmv[1].pv_val.pv_str, "relation"))
1435: Admin.adreld.reldum.relstat = relt.relstat;
1436: else if (sequal(r->parmv[1].pv_val.pv_str, "attribute"))
1437: Admin.adattd.reldum.relstat = relt.relstat;
1438: }
1439: }
1440: }
1441: /*
1442: ** READADMIN -- read the admin file into the 'Admin' cache
1443: **
1444: ** This routine opens and reads the 'Admin' cache from the
1445: ** 'admin' file in the current directory.
1446: **
1447: ** This version of the routine is modified for creatdb --
1448: ** the '-e' flag is checked, and nothing is performed
1449: ** unless it is set.
1450: **
1451: ** If not set, the 'relation' and 'attribute' relations
1452: ** are opened, and the descriptors for them in the Admin
1453: ** struct are filled in with their file descriptors.
1454: **
1455: ** Parameters:
1456: ** none
1457: **
1458: ** Returns:
1459: ** none
1460: **
1461: ** Side Effects:
1462: ** The 'Admin' struct is filled in.
1463: ** The 'relation...xx' and 'attribute...xx' files are
1464: ** opened.
1465: **
1466: ** Called By:
1467: ** acc_init (accbuf.c)
1468: ** changedb
1469: **
1470: ** Trace Flags:
1471: ** none
1472: */
1473:
1474: readadmin()
1475: {
1476: register int i;
1477: char relname[MAXNAME + 4];
1478:
1479: /* read the stuff from the admin file */
1480: if (flagval('e'))
1481: {
1482: i = open("admin", O_RDONLY);
1483: if (i < 0)
1484: syserr("readadmin: open admin %d", i);
1485: checkadmin(i);
1486: close(i);
1487:
1488: /* open the physical files for 'relation' and 'attribute' */
1489: ingresname("relation", Admin.adhdr.adowner, relname);
1490: if ((Admin.adreld.relfp = open(relname, O_RDWR)) < 0)
1491: syserr("readadmin: open `%.14s'", relname);
1492: ingresname("attribute", Admin.adhdr.adowner, relname);
1493: if ((Admin.adattd.relfp = open(relname, O_RDWR)) < 0)
1494: syserr("readadmin: open `%.14s'", relname);
1495: Admin.adreld.relopn = (Admin.adreld.relfp + 1) * -5;
1496: Admin.adattd.relopn = (Admin.adattd.relfp + 1) * 5;
1497: }
1498:
1499: return (0);
1500: }
1501:
1502:
1503:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.