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