Return to creatdb.c CVS log

Up to [CSRG BSD Unix] / 43BSD / ingres / source / support

Annotation of 43BSD/ingres/source/support/creatdb.c, revision 1.1

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.