![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to modify.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 / dbu|
Return to modify.c CVS log | Up to [CSRG BSD Unix] / 42BSD / ingres / source / dbu |
1.1 ! root 1: # include <stdio.h> ! 2: # include <ingres.h> ! 3: # include <pv.h> ! 4: # include <aux.h> ! 5: # include <access.h> ! 6: # include <batch.h> ! 7: # include <lock.h> ! 8: # include <opsys.h> ! 9: # include <func.h> ! 10: # include <version.h> ! 11: # include <sccs.h> ! 12: ! 13: SCCSID(@(#)modify.c 7.2 5/31/83) ! 14: ! 15: extern short tTdbu[]; ! 16: extern int modify(); ! 17: extern int null_fn(); ! 18: ! 19: struct fn_def ModifyFn = ! 20: { ! 21: "MODIFY", ! 22: modify, ! 23: null_fn, ! 24: null_fn, ! 25: NULL, ! 26: 0, ! 27: tTdbu, ! 28: 100, ! 29: 'Z', ! 30: 0 ! 31: }; ! 32: ! 33: /* ! 34: ** MODIFY -- converts any relation to the specified ! 35: ** storage structure ! 36: ** ! 37: ** arguments: ! 38: ** 0 - relation name ! 39: ** 1 - storage structure ("heap", "cheap", "hash", "chash", ! 40: ** "isam", "cisam") ! 41: ** 2 - "name" for attribute names, or "num" for numbers ! 42: ** 3 - key1 ! 43: ** 4 - key2 ! 44: ** . ! 45: ** . ! 46: ** i - null ! 47: ** i+1 - option name (e.g., "fillfactor") ! 48: ** i+2 - option value ! 49: ** . ! 50: ** . ! 51: ** ! 52: ** If all the options default, parameter i -> pc are omitted. ! 53: ** If no keys are provided, parameter 2 is omitted. ! 54: */ ! 55: ! 56: int F_fac, Mn_pages, Mx_pages; ! 57: ! 58: struct modtab ! 59: { ! 60: char *type; ! 61: char newrelspec; ! 62: char yeskeys; ! 63: char sortit; ! 64: char yes_seq; ! 65: int f_fac; ! 66: int mn_pages; ! 67: int mx_pages; ! 68: }; ! 69: ! 70: ! 71: struct modtab Modtab[] = ! 72: { ! 73: /* type spec keys sort seq ffac min max */ ! 74: ! 75: "heap", M_HEAP, FALSE, FALSE, FALSE, 0, 0, 0, ! 76: "cheap", -M_HEAP,FALSE, FALSE, FALSE, 0, 0, 0, ! 77: "hash", M_HASH, TRUE, TRUE, FALSE, 50, 10, -1, ! 78: "chash", -M_HASH,TRUE, TRUE, FALSE, 75, 1, -1, ! 79: "isam", M_ISAM, TRUE, TRUE, FALSE, 80, 0, 0, ! 80: "cisam", -M_ISAM,TRUE, TRUE, FALSE, 100, 0, 0, ! 81: "heapsort", M_HEAP, TRUE, TRUE, TRUE, 0, 0, 0, ! 82: "cheapsort", -M_HEAP,TRUE, TRUE, TRUE, 0, 0, 0, ! 83: "truncated", M_TRUNC,FALSE, FALSE, FALSE, 0, 0, 0, ! 84: 0 ! 85: }; ! 86: ! 87: struct mod_info ! 88: { ! 89: char outfile[MAXNAME + 4]; /* result file filled by ksort */ ! 90: char formfile[MAXNAME + 4]; /* file with descriptor for ksort */ ! 91: char infile[MAXNAME + 4]; /* input file for ksort (relation itself */ ! 92: char reltemp[MAXNAME + 4]; /* file holding new relation */ ! 93: char spfile[MAXNAME + 4], spflag; /* isam spool file for overflow */ ! 94: }; ! 95: ! 96: struct mod_info Mod_info; ! 97: ! 98: ! 99: ! 100: ! 101: ! 102: modify(pc, pv) ! 103: int pc; ! 104: PARM *pv; ! 105: { ! 106: register int i; ! 107: register char *rname; ! 108: register struct modtab *mp; ! 109: int sorted; ! 110: DESC dold, dnew; ! 111: long temptid; ! 112: extern int Noupdt; ! 113: ! 114: ! 115: # ifdef xZTR1 ! 116: if (tTf(34, -1)) ! 117: { ! 118: printf("enter modify\n"); ! 119: prvect(pc, pv); ! 120: } ! 121: # endif ! 122: ! 123: pv[pc].pv_val.pv_str = NULL; ! 124: ! 125: /* check for nice parameters */ ! 126: if (pc < 2) ! 127: syserr("MODIFY: pc %d", pc); ! 128: ! 129: /* save relation name for error messages */ ! 130: rname = (pv++)->pv_val.pv_str; /* *pv now pointes to storage spec */ ! 131: ! 132: /* check for good relation */ ! 133: i = openr(&dold, 0, rname); ! 134: if (i == AMOPNVIEW_ERR) ! 135: return (error(5519, rname, 0)); ! 136: if (i > 0) ! 137: /* reln does not exist */ ! 138: return (error(5500, rname, 0)); ! 139: else if (i < 0) ! 140: syserr("MODIFY: openr (%.14s) %d", rname, i); ! 141: /* can only modify a relation you own and isn't a sys rel */ ! 142: ! 143: if (!bequal(Usercode, dold.reldum.relowner, 2)) ! 144: { ! 145: i = 5501; ! 146: } ! 147: if ((dold.reldum.relstat & S_CATALOG) && Noupdt) ! 148: { ! 149: i = 5504; ! 150: } ! 151: if (i) ! 152: { ! 153: closer(&dold); ! 154: return (error(i, rname, 0)); ! 155: } ! 156: ! 157: /* ! 158: ** Form descriptor for new relation. Here we need to ! 159: ** separate the pages from the old and new relations. ! 160: ** Since pages are identified by the TID of the relation ! 161: ** relation tuple, both old and new have the same identifiers. ! 162: ** To avoid this problem, a special TID is hand crafted for ! 163: ** the new relation. ! 164: */ ! 165: bmove(&dold, &dnew, sizeof dnew); ! 166: dnew.reltid.s_tupid.line_id = (char) -2; /* choose impossible reltid */ ! 167: ! 168: /* In case of an interrupt from a previous modify, ! 169: ** there might be pages around. Get rid of them. ! 170: */ ! 171: cleanrel(&dnew); ! 172: ! 173: ingresname(dold.reldum.relid, dold.reldum.relowner, Mod_info.infile); ! 174: ! 175: /* scan for entry in relspec table */ ! 176: for (mp = Modtab; mp->type; mp++) ! 177: if (sequal(mp->type, pv->pv_val.pv_str)) ! 178: break; ! 179: ! 180: /* if not found, error */ ! 181: if (!mp->type) ! 182: { ! 183: closer(&dold); ! 184: return (error(5510, rname, pv->pv_val.pv_str, 0)); /* bad relspec */ ! 185: } ! 186: dnew.reldum.relspec = mp->newrelspec; ! 187: if (dnew.reldum.relspec == M_TRUNC) ! 188: dnew.reldum.relspec = M_HEAP; ! 189: ! 190: pv++; /* now points to first parameter */ ! 191: ! 192: F_fac = mp->f_fac; ! 193: Mn_pages = mp->mn_pages; ! 194: Mx_pages = mp->mx_pages; ! 195: ! 196: /* get the key domains information */ ! 197: if (i = getkeys(&pv, rname, &dnew, mp)) ! 198: { ! 199: closer(&dold); ! 200: return (i); /* user error */ ! 201: } ! 202: ! 203: /* get fillfactor and other options if any */ ! 204: if (i = getfill(pv, rname, mp)) ! 205: { ! 206: closer(&dold); ! 207: return (i); /* user error */ ! 208: } ! 209: ! 210: ! 211: /* lock the relation relation */ ! 212: if (Lockrel) ! 213: { ! 214: get_p_tid(&dold, &temptid); ! 215: setrll(A_SLP, temptid, M_EXCL); ! 216: } ! 217: ! 218: /* compute new relation parameters & build descriptor */ ! 219: make_newrel(&dnew); ! 220: ! 221: if (sorted = (mp->sortit && (dold.reldum.reltups != 0))) ! 222: sortrel(&dold, &dnew); ! 223: ! 224: /* physically create the new relation */ ! 225: if (formatpg(&dnew, dnew.reldum.relprim) != 0) ! 226: syserr("modify: formatpg"); ! 227: ! 228: /* clear relgiven field; if heap remove any keys */ ! 229: clearkeys(&dnew); ! 230: if (abs(dnew.reldum.relspec) == M_HEAP) ! 231: for (i = 1; i <= dnew.reldum.relatts; i++) ! 232: dnew.relxtra[i] = 0; ! 233: ! 234: if (mp->newrelspec != M_TRUNC) ! 235: fill_rel(&dold, &dnew, sorted); ! 236: ! 237: closer(&dold); /* error return is impossible */ ! 238: if (abs(dnew.reldum.relspec) == M_ISAM) ! 239: { ! 240: if (i = bldindex(&dnew)) ! 241: syserr("bldindex: %.14s %d", dnew.reldum.relid, i); ! 242: unspool(&dnew); ! 243: } ! 244: ! 245: /* ! 246: ** New relation is now complete. The system relations need to ! 247: ** be updated. First destroy all buffers with pages from the ! 248: ** new relation. ! 249: */ ! 250: if (i = cleanrel(&dnew)) ! 251: syserr("modify:clean new %d,%.14s", i, dnew.reldum.relid); ! 252: ! 253: fill_batch(&dold, &dnew); ! 254: ! 255: /* ! 256: ** Close the file for the new relation. This must be ! 257: ** done after the fill_batch in case we are modifing ! 258: ** the attribute relation. ! 259: */ ! 260: close(dnew.relfp); ! 261: dnew.relopn = 0; ! 262: ruboff("modify"); ! 263: modupdate(); ! 264: rubon(); ! 265: ! 266: if (Lockrel) ! 267: unlrl(temptid); ! 268: ! 269: # ifdef xZTM ! 270: if (tTf(35, 1)) ! 271: timtrace(16, 0); ! 272: # endif ! 273: return (0); ! 274: } ! 275: ! 276: ! 277: getkeys(ppv, relname, d, mp) ! 278: PARM **ppv; ! 279: char *relname; ! 280: register DESC *d; ! 281: struct modtab *mp; ! 282: { ! 283: register PARM *pv; ! 284: register char *cp; ! 285: int namemode, sort_only, as_ds; ! 286: int i, keyno, keywid; ! 287: struct attribute attkey, atttup; ! 288: TID tid; ! 289: extern DESC Attdes; ! 290: ! 291: pv = *ppv; /* copy list of params */ ! 292: ! 293: /* zero key info */ ! 294: for (i = 0; i <= d->reldum.relatts; i++) ! 295: d->relxtra[i] = d->relgiven[i] = 0; ! 296: ! 297: /* determine whether there are any keys at all */ ! 298: keyno = 0; ! 299: keywid = 0; ! 300: sort_only = FALSE; ! 301: cp = pv->pv_val.pv_str; ! 302: ! 303: if (cp == NULL || *cp == NULL) ! 304: { ! 305: /* no key information. default as needed */ ! 306: if (mp->yeskeys) ! 307: { ! 308: cp = "\1"; /* default to first key */ ! 309: namemode = FALSE; ! 310: } ! 311: else ! 312: pv++; /* point one to far */ ! 313: } ! 314: else ! 315: { ! 316: /* check for name mode */ ! 317: if (namemode = sequal(cp, "name")) ! 318: { ! 319: ! 320: /* check attribute names, and convert them to numbers */ ! 321: opencatalog("attribute", 0); ! 322: setkey(&Attdes, &attkey, Mod_info.infile, ATTRELID); ! 323: setkey(&Attdes, &attkey, Usercode, ATTOWNER); ! 324: } ! 325: pv++; /* inc to next key */ ! 326: cp = (pv++)->pv_val.pv_str; ! 327: } ! 328: ! 329: ! 330: /* scan for attribute names */ ! 331: for (; cp != NULL; cp = (pv++)->pv_val.pv_str) ! 332: { ! 333: /* check for separator between keys & options */ ! 334: if (*cp == NULL) ! 335: { ! 336: pv++; /* point two past NULL */ ! 337: break; ! 338: } ! 339: ! 340: if (namemode) ! 341: { ! 342: /* check for "sort only" attribute */ ! 343: if (*cp == '#') ! 344: { ! 345: cp++; /* inc to start of name */ ! 346: sort_only = TRUE; ! 347: } ! 348: ! 349: /* check for ascending/descending modifier */ ! 350: if ((as_ds = modseqkey(cp, relname, mp->yes_seq)) > 0) ! 351: return (as_ds); /* error */ ! 352: ! 353: setkey(&Attdes, &attkey, cp, ATTNAME); ! 354: i = getequal(&Attdes, &attkey, &atttup, &tid); ! 355: if (i < 0) ! 356: syserr("MODIFY: geteq(att) %d", i); ! 357: if (i > 0) ! 358: { ! 359: return (error(5511, relname, cp, 0)); /* bad att name */ ! 360: } ! 361: i = atttup.attid; ! 362: } ! 363: else ! 364: { ! 365: i = *cp; ! 366: as_ds = 0; ! 367: } ! 368: ! 369: /* add new key to descriptor */ ! 370: keyno++; ! 371: if (!sort_only) ! 372: { ! 373: d->relxtra[i] = keyno; ! 374: keywid += (d->relfrml[i] & I1MASK); ! 375: } ! 376: if (d->relgiven[i]) ! 377: return (error(5507, relname, cp, 0)); /* duplicate attribute */ ! 378: d->relgiven[i] = as_ds == 0 ? keyno : -keyno; ! 379: } ! 380: pv--; /* back up one to point to "-1" terminator */ ! 381: ! 382: ! 383: if (abs(d->reldum.relspec) == M_ISAM && keywid > (MAXTUP / 2 - 4)) ! 384: { ! 385: return (error(5508, relname, iocv(keywid), 0)); ! 386: } ! 387: ! 388: /* if a heap, there can be no keys */ ! 389: if (!mp->yeskeys && keyno != 0) ! 390: { ! 391: return (error(5502, relname, mp->type, 0)); /* no keys allowed on heap */ ! 392: } ! 393: ! 394: /* fill out default sort on remainder of keys */ ! 395: if (mp->yeskeys) ! 396: for (i = 1; i <= d->reldum.relatts; i++) ! 397: if (d->relgiven[i] == 0) ! 398: d->relgiven[i] = ++keyno; ! 399: *ppv = pv; ! 400: return (0); ! 401: } ! 402: ! 403: ! 404: modseqkey(domain, relname, seq_ok) ! 405: char *domain; ! 406: char *relname; ! 407: int seq_ok; ! 408: { ! 409: register char *cp, c; ! 410: register int ret; ! 411: ! 412: ret = 0; ! 413: ! 414: for (cp = domain; c = *cp++; ) ! 415: if (c == ':') ! 416: break; ! 417: ! 418: if (c != '\0') ! 419: { ! 420: /* replace ":" with null */ ! 421: *(cp - 1) = '\0'; ! 422: ! 423: /* verify sequence is valid */ ! 424: if (!seq_ok) ! 425: ret = error(5520, relname, cp, domain, 0); ! 426: else if (sequal("descending", cp) || sequal("d", cp)) ! 427: ret = -1; ! 428: else if (!(sequal("ascending", cp) || sequal("a", cp))) ! 429: ret = error(5518, relname, cp, domain, 0); ! 430: } ! 431: ! 432: return (ret); ! 433: } ! 434: /* ! 435: ** GETFILL -- Get fill factor and minimum pages parameters ! 436: ** from argument list, convert them from ascii to integer ! 437: ** and store them in global variables. If the global ! 438: ** variable for the corresponding parameter is zero, ! 439: ** it means that that parameter is not allowed and an ! 440: ** error is generated. ! 441: */ ! 442: ! 443: /*ARGSUSED*/ ! 444: getfill(pv, rel, mp) ! 445: register PARM *pv; ! 446: char *rel; ! 447: struct modtab *mp; ! 448: { ! 449: register char *p1; ! 450: register int err; ! 451: char *p2; ! 452: int fill_flag, min_flag, max_flag; ! 453: ! 454: err = 0; ! 455: fill_flag = min_flag = max_flag = FALSE; ! 456: ! 457: while ((p1 = (pv++)->pv_val.pv_str) != NULL) ! 458: { ! 459: p2 = (pv++)->pv_val.pv_str; ! 460: if (sequal(p1, "fillfactor")) ! 461: { ! 462: if (F_fac == 0 || fill_flag) ! 463: { ! 464: err = 5512; ! 465: break; ! 466: } ! 467: p1 = p2; ! 468: F_fac = atoi(p1); ! 469: if (F_fac > 100 || F_fac < 1) ! 470: { ! 471: err = 5513; ! 472: break; ! 473: } ! 474: fill_flag = TRUE; ! 475: continue; ! 476: } ! 477: if (sequal(p1, "minpages")) ! 478: { ! 479: if (Mn_pages == 0 || min_flag) ! 480: { ! 481: err = 5512; ! 482: break; ! 483: } ! 484: p1 = p2; ! 485: Mn_pages = atoi(p1); ! 486: if (Mn_pages < 1) ! 487: { ! 488: err = 5514; ! 489: break; ! 490: } ! 491: if (max_flag && (Mn_pages > Mx_pages)) ! 492: { ! 493: err = 5517; ! 494: break; ! 495: } ! 496: min_flag = TRUE; ! 497: continue; ! 498: } ! 499: if (sequal(p1, "maxpages")) ! 500: { ! 501: if (Mx_pages == 0 || max_flag) ! 502: { ! 503: err = 5512; ! 504: break; ! 505: } ! 506: p1 = p2; ! 507: Mx_pages = atoi(p1); ! 508: if (Mx_pages < 1) ! 509: { ! 510: err = 5516; ! 511: break; ! 512: } ! 513: if (min_flag && (Mn_pages > Mx_pages)) ! 514: { ! 515: err = 5517; ! 516: break; ! 517: } ! 518: max_flag = TRUE; ! 519: continue; ! 520: } ! 521: err = 5515; ! 522: break; ! 523: } ! 524: if (err) ! 525: return (error(err, rel, p1, 0)); ! 526: return (0); ! 527: } ! 528: /* ! 529: ** MAKE_NEWREL -- Create a file for the modified relation ! 530: ** and build one or more primary pages for the ! 531: ** relation based on its storage structure and the ! 532: ** number of tuples it must hold. ! 533: */ ! 534: ! 535: make_newrel(desc) ! 536: register DESC *desc; ! 537: { ! 538: register int tups_p_page; ! 539: ! 540: concat(MODTEMP, Fileset, Mod_info.reltemp); ! 541: close(creat(Mod_info.reltemp, FILEMODE)); ! 542: if ((desc->relfp = open(Mod_info.reltemp, 2)) < 0) ! 543: syserr("MAKE_NEWREL: open %.14s %d", Mod_info.reltemp, desc->relfp); ! 544: desc->relopn = (desc->relfp + 1) * -5; ! 545: desc->reldum.relprim = 1; ! 546: if (abs(desc->reldum.relspec) == M_HASH && F_fac > 0 && Mn_pages > 0) ! 547: { ! 548: /* ! 549: ** Determine the number of primary pages. The following ! 550: ** first determines the number of tuples/page which the ! 551: ** relation should have in order to get the requested ! 552: ** fillfactor. Then that number is divided into the ! 553: ** number of tuples to get the number of primary pages. ! 554: ** To avoid round off, it must guaranteed that the ! 555: ** number of tuples per page must be at least 1. ! 556: ** ! 557: ** primary_pages = #tuples / (#tuples/page * fillfactor) ! 558: */ ! 559: tups_p_page = (((MAXTUP+2) / (desc->reldum.relwid+2)) * F_fac) / 100; ! 560: if (tups_p_page == 0) ! 561: tups_p_page = 1; ! 562: /* we add one to simulate a ceiling function */ ! 563: desc->reldum.relprim = desc->reldum.reltups / tups_p_page + 1; ! 564: if (desc->reldum.relprim < Mn_pages) ! 565: desc->reldum.relprim = Mn_pages; ! 566: if (Mx_pages > 0 && desc->reldum.relprim > Mx_pages) ! 567: desc->reldum.relprim = Mx_pages; ! 568: # ifdef xZTR1 ! 569: if (tTf(36, 0)) ! 570: printf("using %ld prim pages\n", desc->reldum.relprim); ! 571: # endif ! 572: } ! 573: desc->reldum.reltups = 0; ! 574: return (0); ! 575: } ! 576: /* ! 577: ** SORTREL - Call KSORT to sort the given relation. SORTREL ! 578: ** sets up the descriptor struct specifying the sort ! 579: ** keys and tells KSORT whether or not the hash key should ! 580: ** be included as a sort key. ! 581: */ ! 582: ! 583: sortrel(odesc, desc) ! 584: DESC *odesc; ! 585: register DESC *desc; ! 586: { ! 587: extern char *Pathname; ! 588: register int fp, i; ! 589: char savespec; ! 590: char buf[50]; ! 591: ! 592: concat(ISAM_SORTED, Fileset, Mod_info.outfile); ! 593: if (close(creat(Mod_info.outfile, FILEMODE))) ! 594: syserr("SORTREL: creat %.14s", Mod_info.outfile); ! 595: concat(ISAM_DESC, Fileset, Mod_info.formfile); ! 596: if ((fp = creat(Mod_info.formfile, FILEMODE)) < 0) ! 597: syserr("SORTREL: creat %.14s %d", Mod_info.formfile, fp); ! 598: if (abs(desc->reldum.relspec) == M_HASH) ! 599: { ! 600: /* sort on hash bucket first */ ! 601: desc->relgiven[0] = 1; ! 602: for (i = 1; i <= desc->reldum.relatts; i++) ! 603: desc->relgiven[i]++; ! 604: } ! 605: savespec = desc->reldum.relspec; ! 606: desc->reldum.relspec = odesc->reldum.relspec; ! 607: ! 608: # ifdef xZTR2 ! 609: if (tTf(36, 4)) ! 610: { ! 611: printf("sortrel: "); ! 612: printdesc(desc); ! 613: } ! 614: # endif ! 615: ! 616: if (write(fp, desc, sizeof *desc) != sizeof *desc) ! 617: syserr("SORTREL: desc write err"); ! 618: close(fp); ! 619: desc->reldum.relspec = savespec; ! 620: ! 621: i = fork(); ! 622: if (i == -1) ! 623: syserr("SORTREL: fork"); ! 624: if (i == 0) ! 625: { ! 626: for (i = 3; i < NOFILE; i++) ! 627: close(i); ! 628: # ifdef KSORTPATH ! 629: smove(KSORTPATH, buf); ! 630: # else ! 631: concat(Pathname, ztack("/bin/ksort", VERSION), buf); ! 632: # endif KSORTPATH ! 633: # ifdef xZTR2 ! 634: if (tTf(36, 0)) ! 635: { ! 636: printf("Calling ksort, args:\n"); ! 637: printf("\tbuf = `%s'\n", buf); ! 638: printf("\tFileset = `%s'\n", Fileset); ! 639: printf("\ttTf = `%s'\n", iocv(tTf(37, -1))); ! 640: printf("\tformfile = `%s'\n", Mod_info.formfile); ! 641: printf("\tinfile = `%s'\n", Mod_info.infile); ! 642: printf("\toutfile = `%s'\n", Mod_info.outfile); ! 643: } ! 644: # endif xZTR2 ! 645: execl(buf, buf, Fileset, iocv(tTf(37, -1)), ! 646: Mod_info.formfile, Mod_info.infile, ! 647: Mod_info.outfile, 0); ! 648: syserr("SORTREL: exec %s", buf); ! 649: } ! 650: ! 651: # ifdef xZTR1 ! 652: tTfp(36, 9, "SORTREL: after execl; pid = %d\n", i); ! 653: # endif ! 654: ! 655: if (fp = fullwait(i, "modify")) /* wait for ksort to complete */ ! 656: syserr("modify:ksort failed %d", fp); ! 657: ! 658: # ifdef xZTR1 ! 659: tTfp(36, 10, "SORTREL: after fullwait\n"); ! 660: # endif ! 661: ! 662: unlink(Mod_info.formfile); ! 663: return (0); ! 664: } ! 665: /* ! 666: ** FILL_REL -- Fill the new relation with tuples from either ! 667: ** the old relation or the output file of KSORT. ! 668: */ ! 669: ! 670: fill_rel(sdesc, desc, sortit) ! 671: register DESC *sdesc, *desc; ! 672: char sortit; ! 673: { ! 674: register int i; ! 675: char tup_buf[MAXTUP], last_tup[MAXTUP]; ! 676: char junk[4], newreltype, anytups, chkdups; ! 677: int need, j; ! 678: long lnum; ! 679: TID tid, stid, stidlim; ! 680: FILE *fp, *spfp; ! 681: ! 682: newreltype = abs(desc->reldum.relspec); ! 683: if (sortit) ! 684: { ! 685: if ((fp = fopen(Mod_info.outfile, "r")) == NULL) ! 686: syserr("FILL_REL: fopen %.14s", Mod_info.outfile); ! 687: } ! 688: else ! 689: { ! 690: cleanrel(sdesc); /* make sure each page is read fresh */ ! 691: find(sdesc, NOKEY, &stid, &stidlim); ! 692: } ! 693: if (newreltype == M_ISAM) ! 694: { ! 695: lnum = 0; ! 696: stuff_page(&tid, &lnum); ! 697: tid.line_id = 0; ! 698: get_page(desc, &tid); ! 699: concat(ISAM_SPOOL, Fileset, Mod_info.spfile); ! 700: /* assume that spool file is not needed */ ! 701: spfp = NULL; ! 702: Mod_info.spflag = FALSE; ! 703: if (F_fac == 0) ! 704: F_fac = 100; ! 705: /* setup relgiven field for kcompare later on */ ! 706: for (i = 1; i <= desc->reldum.relatts; i++) ! 707: desc->relgiven[i] = desc->relxtra[i]; ! 708: } ! 709: desc->reladds = 0; ! 710: anytups = FALSE; ! 711: chkdups = !sortit; ! 712: # ifdef xZTR2 ! 713: if (tTf(36, 3)) ! 714: { ! 715: printf(" FILLREL: "); ! 716: printdesc(desc); ! 717: } ! 718: # endif ! 719: for (;;) ! 720: { ! 721: if (sortit) ! 722: { ! 723: i = fread(tup_buf, 1, desc->reldum.relwid, fp); ! 724: if (i == 0) ! 725: break; ! 726: if (i != desc->reldum.relwid) ! 727: syserr("FILL_REL: fread A %d", i); ! 728: if (newreltype == M_HASH) ! 729: if (fread(junk, 1, 4, fp) != 4) ! 730: syserr("FILL_REL: fread B"); ! 731: } ! 732: else ! 733: { ! 734: # ifdef xZTR2 ! 735: if (tTf(36, 1)) ! 736: { ! 737: printf("FILL_REL: stid "); ! 738: dumptid(&stid); ! 739: printf("FILL_REL: stidlim "); ! 740: dumptid(&stidlim); ! 741: } ! 742: # endif ! 743: i = get(sdesc, &stid, &stidlim, tup_buf, TRUE); ! 744: # ifdef xZTR2 ! 745: if (tTf(36, 1)) ! 746: { ! 747: printf("FILLREL: get %d ", i); ! 748: printup(sdesc, tup_buf); ! 749: } ! 750: # endif ! 751: if (i < 0) ! 752: syserr("FILL_REL: get %d", i); ! 753: if (i == 1) ! 754: break; ! 755: } ! 756: if (newreltype != M_ISAM) ! 757: { ! 758: if ((i = insert(desc, &tid, tup_buf, chkdups)) < 0) ! 759: syserr("FILL_REL: insert %d", i); ! 760: # ifdef xZTR2 ! 761: if (tTf(36, 2)) ! 762: { ! 763: printf("FILL_REL: insert "); ! 764: printup(desc, tup_buf); ! 765: printf("FILL_REL: insert ret %d at", i); ! 766: dumptid(&tid); ! 767: } ! 768: # endif ! 769: continue; ! 770: } ! 771: if (anytups) ! 772: i = kcompare(desc, tup_buf, last_tup); ! 773: else ! 774: { ! 775: anytups = TRUE; ! 776: i = 1; ! 777: } ! 778: bmove(tup_buf, last_tup, desc->reldum.relwid); ! 779: need = canonical(desc, tup_buf); ! 780: if (i == 0 && need > space_left(Acc_head)) ! 781: { ! 782: /* spool out this tuple. will go on overflow page later */ ! 783: if (spfp == NULL) ! 784: { ! 785: if ((spfp = fopen(Mod_info.spfile, "w")) == NULL) ! 786: syserr("FILL_REL: fopen %.14s", Mod_info.spfile); ! 787: Mod_info.spflag = TRUE; ! 788: } ! 789: if (fwrite(tup_buf, 1, desc->reldum.relwid, spfp) != desc->reldum.relwid) ! 790: syserr("FILL_REL: putb spool"); ! 791: continue; ! 792: } ! 793: j = (100 - F_fac) * MAXTUP / 100; ! 794: if (j < need) ! 795: j = need; ! 796: if (i != 0 && j > space_left(Acc_head)) ! 797: { ! 798: if (i = add_prim(desc, &tid)) ! 799: syserr("FILL_REL: force ovflo %d", i); ! 800: } ! 801: tid.line_id = newlino(need); ! 802: put_tuple(&tid, Acctuple, need); ! 803: desc->reladds++; ! 804: } ! 805: if (sortit) ! 806: { ! 807: fclose(fp); ! 808: unlink(Mod_info.outfile); ! 809: } ! 810: if (newreltype == M_ISAM) ! 811: { ! 812: if (i = pageflush(Acc_head)) ! 813: syserr("fill_rel:pg clean %d", i); ! 814: if (spfp != NULL) ! 815: fclose(spfp); ! 816: } ! 817: desc->reldum.reltups = desc->reladds; ! 818: desc->reladds = 0; ! 819: return (0); ! 820: } ! 821: ! 822: ! 823: bldindex(d) ! 824: register DESC *d; ! 825: { ! 826: register TID *tid; ! 827: register int tmp; ! 828: TID tidx; ! 829: struct accbuf dirbuf; ! 830: int keywid, level, savespec, keyx[MAXDOM]; ! 831: int offset, len; ! 832: char tuple[MAXTUP], temptup[MAXTUP], *key; ! 833: long pageid, start, stop, newstart, newstop; ! 834: ! 835: tid = &tidx; ! 836: keywid = 0; ! 837: for (tmp = 0; tmp < MAXDOM; tmp++) ! 838: keyx[tmp] = 0; ! 839: for (tmp = 1; tmp <= d->reldum.relatts; tmp++) ! 840: if (d->relxtra[tmp] > 0) ! 841: { ! 842: keyx[d->relxtra[tmp] - 1] = tmp; ! 843: keywid += d->relfrml[tmp] & I1MASK; ! 844: } ! 845: ! 846: /* Determine the last page of the relation. This will ! 847: ** only work if all pages have been written out. Fill_rel ! 848: ** must guarantee that all pages have been written ! 849: */ ! 850: level = 0; ! 851: last_page(d, tid, 0); ! 852: pluck_page(tid, &stop); ! 853: start = 0; ! 854: dirbuf.filedesc = d->relfp; ! 855: dirbuf.rel_tupid = d->reltid.ltid; ! 856: savespec = d->reldum.relspec; ! 857: for (;;) ! 858: { ! 859: # ifdef xZTR2 ! 860: if (tTf(38, 7)) ! 861: printf("isam: level %d\n", level); ! 862: # endif ! 863: dirbuf.ovflopg = start; ! 864: dirbuf.mainpg = level; ! 865: dirbuf.thispage = stop + 1; ! 866: dirbuf.linetab[0] = (short) (dirbuf.firstup - (char *) &dirbuf); ! 867: offset = dirbuf.linetab[0]; ! 868: dirbuf.bufstatus = BUF_DIRTY | BUF_DIRECT; ! 869: ! 870: dirbuf.nxtlino = 0; ! 871: newstart = stop + 1; ! 872: newstop = newstart; ! 873: for (pageid = start; pageid <= stop; pageid++) ! 874: { ! 875: # ifdef xZTR2 ! 876: if (tTf(38, 8)) ! 877: printf("isam:get key from %ld\n", pageid); ! 878: # endif ! 879: stuff_page(tid, &pageid); ! 880: tid->line_id = 0; ! 881: if (tmp = get(d, tid, tid, tuple, FALSE)) ! 882: { ! 883: /* ! 884: ** If the relation is empty, then page 0 will ! 885: ** return AMINVL_ERR on a get(). Form a blank tuple ! 886: ** and use it to create a one tuple directory ! 887: */ ! 888: if (pageid == 0 && tmp == AMINVL_ERR) ! 889: { ! 890: clr_tuple(d, tuple); ! 891: } ! 892: else ! 893: { ! 894: return (-2); ! 895: } ! 896: } ! 897: ! 898: /* ! 899: ** If this is the first level then form the tuple ! 900: ** from the mainpage of the relation. Otherwise ! 901: ** the tuple is the first tuple of a directory page ! 902: ** and it is already correctly formed. ! 903: */ ! 904: if (level == 0) ! 905: { ! 906: key = temptup; ! 907: for (tmp = 0; keyx[tmp] != 0; tmp++) ! 908: { ! 909: len = d->relfrml[keyx[tmp]] & I1MASK; ! 910: bmove(&tuple[d->reloff[keyx[tmp]]], key, len); ! 911: key += len; ! 912: } ! 913: key = temptup; ! 914: } ! 915: else ! 916: key = tuple; ! 917: ! 918: if (keywid > space_left(&dirbuf)) ! 919: { ! 920: if (pageflush(&dirbuf)) ! 921: return (-3); ! 922: dirbuf.thispage++; ! 923: newstop = dirbuf.thispage; ! 924: dirbuf.ovflopg = pageid; ! 925: dirbuf.linetab[0] = (short) (dirbuf.firstup - (char *) &dirbuf); ! 926: offset = dirbuf.linetab[0]; ! 927: dirbuf.bufstatus = BUF_DIRTY; ! 928: dirbuf.nxtlino = 0; ! 929: } ! 930: /* copy key to directory page */ ! 931: bmove(key, (char *) &dirbuf + offset, keywid); ! 932: ! 933: /* update next line number */ ! 934: offset += keywid; ! 935: dirbuf.nxtlino++; ! 936: dirbuf.linetab[-dirbuf.nxtlino] = offset; ! 937: } ! 938: if (pageflush(&dirbuf)) ! 939: return (-4); ! 940: if (newstart == newstop) ! 941: break; ! 942: d->reldum.relspec = abs(d->reldum.relspec); ! 943: level++; ! 944: start = newstart; ! 945: stop = newstop; ! 946: } ! 947: d->reldum.relspec = savespec; ! 948: d->reldum.relprim = newstart; ! 949: return (0); ! 950: } ! 951: /* ! 952: ** UNSPOOL -- Take tuples saved in spool file and insert them ! 953: ** in new relation. This is only for ISAM relations. ! 954: */ ! 955: ! 956: unspool(desc) ! 957: register DESC *desc; ! 958: { ! 959: register int i; ! 960: TID tid; ! 961: char tup_buf[MAXTUP]; ! 962: FILE *spfp; ! 963: ! 964: if (Mod_info.spflag) ! 965: { ! 966: if ((spfp = fopen(Mod_info.spfile, "r")) == NULL) ! 967: syserr("UNSPOOL: fopen spool"); ! 968: while ((i = fread(tup_buf, 1, desc->reldum.relwid, spfp)) == desc->reldum.relwid) ! 969: if ((i = insert(desc, &tid, tup_buf, FALSE)) < 0) ! 970: syserr("UNSPOOL: insert %.14s %d", desc->reldum.relid, i); ! 971: if (i != 0) ! 972: syserr("UNSPOOL: read %d", i); ! 973: fclose(spfp); ! 974: unlink(Mod_info.spfile); ! 975: } ! 976: desc->reldum.reltups += desc->reladds; ! 977: desc->reladds = 0; ! 978: return (0); ! 979: } ! 980: /* ! 981: ** FILL_BATCH -- Create and fill a batch file containing the ! 982: ** updates for the system catalog so that MODIFY will ! 983: ** be recoverable if the system crashes. ! 984: */ ! 985: ! 986: fill_batch(odesc, desc) ! 987: DESC *odesc; ! 988: register DESC *desc; ! 989: { ! 990: register DESC *dessys; ! 991: register int i; ! 992: struct relation reltup, rkey; ! 993: TID tid, lotid, hitid; ! 994: struct attribute atttup, akey; ! 995: int j; ! 996: char prebatch[MAXNAME + 4], modbatch[MAXNAME + 4]; ! 997: ! 998: if (bequal(desc->reldum.relid, "relation ", 12)) ! 999: { ! 1000: clearkeys(desc); ! 1001: setkey(desc, &rkey, desc->reldum.relid, RELID); ! 1002: setkey(desc, &rkey, desc->reldum.relowner, RELOWNER); ! 1003: if (i = getequal(desc, &rkey, &reltup, &tid)) ! 1004: syserr("FILL_BATCH: geteq rel rel %d", i); ! 1005: bmove(&tid, &desc->reltid, sizeof desc->reltid); ! 1006: } ! 1007: else ! 1008: bmove(&odesc->reltid, &desc->reltid, sizeof desc->reltid); ! 1009: resetacc(Acc_head); ! 1010: concat(MOD_PREBATCH, Fileset, prebatch); ! 1011: close(creat(prebatch, FILEMODE)); ! 1012: if ((Batch_fp = open(prebatch, 2)) < 0) ! 1013: syserr("FILL_BATCH: open %.14s %d", prebatch, Batch_fp); ! 1014: smove(Fileset, Batchbuf.file_id); ! 1015: Batch_cnt = 0; ! 1016: wrbatch(desc, sizeof *desc); ! 1017: if (bequal(desc->reldum.relid, "attribute ", 12)) ! 1018: dessys = desc; ! 1019: else ! 1020: dessys = &Admin.adattd; ! 1021: clearkeys(dessys); ! 1022: setkey(dessys, &akey, desc->reldum.relid, ATTRELID); ! 1023: setkey(dessys, &akey, desc->reldum.relowner, ATTOWNER); ! 1024: if (i = find(dessys, EXACTKEY, &lotid, &hitid, &akey)) ! 1025: syserr("FILL_BATCH: find %d", i); ! 1026: j = desc->reldum.relatts; ! 1027: while(!(i = get(dessys, &lotid, &hitid, &atttup, TRUE)) && j > 0) ! 1028: if (!kcompare(dessys, &akey, &atttup)) ! 1029: { ! 1030: j--; ! 1031: atttup.attxtra = desc->relxtra[atttup.attid]; ! 1032: wrbatch(&lotid, sizeof lotid); ! 1033: wrbatch(&atttup, sizeof atttup); ! 1034: } ! 1035: if (i < 0 || j > 0) ! 1036: syserr("FILL_BATCH: get att %d count %d", i, j); ! 1037: /* get rid of attribute pages */ ! 1038: cleanrel(dessys); ! 1039: flushbatch(); ! 1040: close(Batch_fp); ! 1041: concat(MODBATCH, Fileset, modbatch); ! 1042: if (link(prebatch, modbatch) == -1) ! 1043: syserr("FILL_BATCH: can't link %.14s %.14s", ! 1044: prebatch, modbatch); ! 1045: unlink(prebatch); ! 1046: return (0); ! 1047: ! 1048: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.