![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ksort.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / ingres / source / dbu|
Return to ksort.c CVS log | Up to [CSRG BSD Unix] / 43BSD / ingres / source / dbu |
1.1 root 1: # include <stdio.h>
2: # include <ingres.h>
3: # include <aux.h>
4: # include <symbol.h>
5: # include <access.h>
6: # include <func.h>
7: # include <batch.h>
8: # include <catalog.h>
9: # include <pv.h>
10: # include <sccs.h>
11:
12: SCCSID(@(#)ksort.c 8.4 12/8/85)
13:
14: # define N 7
15: # define MEM (32768 - 2)
16: # define BUCKETSIZE 4
17: # define ENDKEY MAXDOM + 1
18:
19:
20:
21: /*
22: ** Parameters:
23: **
24: ** pv[0]: Fileset
25: ** pv[1]: Infile from which reln is read
26: ** pv[2]: Outfile to which reln is written
27: ** pv[3...]: the desc of the new relation
28: **
29: ** Trace Flag: Z37
30: */
31:
32: extern short tTdbu[100];
33: extern int ksort();
34: extern int null_fn();
35:
36: struct fn_def KsortFn =
37: {
38: "KSORT",
39: ksort,
40: null_fn,
41: null_fn,
42: NULL,
43: 0,
44: tTdbu,
45: 100,
46: 'Z',
47: 0
48: };
49:
50: static char *Infile;
51: static char *Outfile;
52: static DESC Desc;
53: static char Descsort[MAXDOM+1];
54: static FILE *Oiop;
55: static int Tupsize;
56: static int Bucket;
57: static char File[15];
58: static char *Fileset;
59: static char *Filep;
60: static int Nlines;
61: static long Ccount;
62: static char **Lspace;
63: static char *Tspace;
64: extern int cmpa();
65: static long Tupsout;
66: static int firstime = 1;
67: static FILE *Btree_fp;
68: DESC Btreesec;
69: int Btree_fd;
70: int Nfiles;
71:
72: ksort(pc, pv)
73: int pc;
74: PARM *pv;
75: {
76: extern char *Proc_name;
77: register int i;
78: register int j;
79: unsigned int mem;
80: char *start;
81: int maxkey, rev;
82: extern char *malloc();
83:
84: # ifdef xZTR1
85: if (tTf(37,0))
86: {
87: lprintf("entering ksort\n");
88: prvect(pc,pv);
89: }
90: # endif
91:
92: Nfiles = 1;
93: Fileset = pv[0].pv_val.pv_str;
94:
95: /* first, the struct relation reldum */
96: strcpy(Desc.reldum.relid, pv[3].pv_val.pv_str);
97: strcpy(Desc.reldum.relowner, pv[4].pv_val.pv_str);
98: Desc.reldum.relspec = pv[5].pv_val.pv_int;
99: Desc.reldum.relindxd = pv[6].pv_val.pv_int;
100: Desc.reldum.relstat2 = pv[7].pv_val.pv_int;
101: Desc.reldum.relstat = pv[8].pv_val.pv_int;
102: Desc.reldum.relsave = (long) pv[9].pv_val.pv_int;
103: Desc.reldum.reltups = (long) pv[10].pv_val.pv_int;
104: Desc.reldum.relatts = pv[11].pv_val.pv_int;
105: Desc.reldum.relwid = pv[12].pv_val.pv_int;
106: Desc.reldum.relprim = (long) pv[13].pv_val.pv_int;
107: Desc.reldum.relfree = (long) pv[14].pv_val.pv_int;
108: Desc.reldum.relstamp = (long) pv[15].pv_val.pv_int;
109: Desc.reldum.reldim = pv[16].pv_val.pv_int;
110:
111: strcpy(Desc.relvname, pv[17].pv_val.pv_str);
112: Desc.relfp = pv[18].pv_val.pv_int;
113: Desc.relopn = pv[19].pv_val.pv_int;
114: Desc.reladds = (long) pv[20].pv_val.pv_int;
115: Desc.reltid.ltid = pv[21].pv_val.pv_int;
116: j = 22;
117: for (i = 0; i <= Desc.reldum.relatts; ++i)
118: {
119: Desc.reloff[i] = pv[j++].pv_val.pv_int;
120: Desc.relfrmt[i] = pv[j++].pv_val.pv_int;
121: Desc.relfrml[i] = pv[j++].pv_val.pv_int;
122: Desc.relxtra[i] = pv[j++].pv_val.pv_int;
123: Desc.relgiven[i] = pv[j++].pv_val.pv_int;
124: }
125:
126: if (Desc.reldum.reldim > 0)
127: {
128: if ((Desc.relbtree = (DESC *) calloc(1, sizeof(DESC))) == NULL)
129: syserr("bad calloc in ksort");
130: /* first, the struct relation reldum */
131: strcpy(Desc.relbtree->reldum.relid, pv[j++].pv_val.pv_str);
132: strcpy(Desc.relbtree->reldum.relowner, pv[j++].pv_val.pv_str);
133: Desc.relbtree->reldum.relspec = pv[j++].pv_val.pv_int;
134: Desc.relbtree->reldum.relindxd = pv[j++].pv_val.pv_int;
135: Desc.relbtree->reldum.relstat2 = pv[j++].pv_val.pv_int;
136: Desc.relbtree->reldum.relstat = pv[j++].pv_val.pv_int;
137: Desc.relbtree->reldum.relsave = pv[j++].pv_val.pv_int;
138: Desc.relbtree->reldum.reltups = pv[j++].pv_val.pv_int;
139: Desc.relbtree->reldum.relatts = pv[j++].pv_val.pv_int;
140: Desc.relbtree->reldum.relwid = pv[j++].pv_val.pv_int;
141: Desc.relbtree->reldum.relprim = pv[j++].pv_val.pv_int;
142: Desc.relbtree->reldum.relfree = pv[j++].pv_val.pv_int;
143: Desc.relbtree->reldum.relstamp = pv[j++].pv_val.pv_int;
144: Desc.relbtree->reldum.reldim = pv[j++].pv_val.pv_int;
145:
146: strcpy(Desc.relbtree->relvname, pv[j++].pv_val.pv_str);
147: Desc.relbtree->relfp = pv[j++].pv_val.pv_int;
148: Desc.relbtree->relopn = pv[j++].pv_val.pv_int;
149: Desc.relbtree->reladds = pv[j++].pv_val.pv_int;
150: Desc.relbtree->reltid.ltid = pv[j++].pv_val.pv_int;
151:
152: for (i = 0; i <= Desc.relbtree->reldum.relatts; ++i)
153: {
154: Desc.relbtree->reloff[i] = pv[j++].pv_val.pv_int;
155: Desc.relbtree->relfrmt[i] = pv[j++].pv_val.pv_int;
156: Desc.relbtree->relfrml[i] = pv[j++].pv_val.pv_int;
157: Desc.relbtree->relxtra[i] = pv[j++].pv_val.pv_int;
158: Desc.relbtree->relgiven[i] = pv[j++].pv_val.pv_int;
159: }
160: }
161:
162: # ifdef xZTR1
163: if (tTf(37,0))
164: {
165: lprintf(" Desc read in \n");
166: printdesc(&Desc);
167: }
168: #endif
169:
170: /* set up Descsort to indicate the sort order for tuple */
171: /* if domain zero is given prepare to generate "hash bucket"
172: ** value for tuple */
173:
174: maxkey = 0;
175: for (i = 0; i <= Desc.reldum.relatts; i++)
176: if (j = Desc.relgiven[i])
177: {
178: if ((rev = j) < 0)
179: j = -j;
180: if (maxkey < j)
181: maxkey = j;
182: Descsort[--j] = rev < 0 ? -i : i;
183: }
184:
185: Descsort[maxkey] = ENDKEY; /* mark end of list */
186:
187: Tupsize = Desc.reldum.relwid;
188:
189: if (Bucket = (Descsort[0] == 0))
190: {
191: /* we will be generating hash bucket */
192: Tupsize += BUCKETSIZE;
193: Desc.relfrml[0] = BUCKETSIZE;
194: Desc.relfrmt[0] = INT;
195: Desc.reloff[0] = Desc.reldum.relwid;
196: }
197:
198: # ifdef xZTR1
199: if (tTf(37,0))
200: {
201: lprintf("ksort: reldum.relatts is %d\n", Desc.reldum.relatts);
202: lprintf("Bucket is %d,Sort is:\n", Bucket);
203: for (i = 0; (j = Descsort[i]) != ENDKEY; i++)
204: lprintf("Descsort[%d]=%d\n", i, j);
205: }
206: # endif
207: if (i = (maxkey - Bucket - Desc.reldum.relatts))
208: {
209: lprintf("MAXKEY=%d\n", maxkey);
210: lprintf("ATTS=%d\n", Desc.reldum.relatts);
211: syserr("%d domains missing\n", -i);
212: }
213: Infile = pv[1].pv_val.pv_str;
214: Outfile = pv[2].pv_val.pv_str;
215:
216: /* get up to 2**15 - 1 bytes of memory for buffers */
217: /* note that mem must end up positive so that Nlines computation is right */
218: mem = MEM; /* take at most 2**15 - 1 bytes */
219: if (firstime)
220: {
221: while ((Lspace = (char **) malloc(mem)) == NULL)
222: mem -= 1024;
223: firstime = 0;
224: }
225:
226: /* compute pointers and sizes into buffer memory */
227: Nlines = mem / (Tupsize + sizeof(char *));
228: Tspace = (char *) (Lspace + Nlines);
229: # ifdef xZTR1
230: if (tTf(37,0))
231: lprintf("Tspace=%x,Lspace=%x,Nlines=%x,mem=%d\n",
232: Tspace, Lspace, Nlines, mem);
233: # endif
234:
235: /* set up temp files */
236: concat(ztack("_SYSS", Fileset), "Xaa", File);
237: Filep = File;
238: while (*Filep != 'X')
239: Filep++;
240: Filep++;
241:
242: if (abs(Desc.reldum.relspec) == M_ORDER)
243: if ((Btree_fp = fopen(Infile, "r")) == NULL)
244: syserr("can't open %s", Infile);
245:
246: /* sort stage -- create a bunch of temporaries */
247: Ccount = 0;
248: # ifdef xZTR1
249: if (tTf(37,0))
250: lprintf("sorting\n");
251: # endif
252: sort();
253: # ifdef xZTR1
254: if (tTf(37,0))
255: {
256: lprintf("done sorting\n%ld tuples written to %d files\n", Tupsout, Nfiles - 1);
257: lprintf("sort required %ld compares\n", Ccount);
258: }
259: # endif
260:
261: /* merge stage -- merge up to N temps into a new temp */
262: Ccount = 0;
263: for (i = 1; i + N < Nfiles; i += N)
264: {
265: newfile();
266: merge(i, i + N);
267: }
268:
269: /* merge last set of temps into target file */
270: if (i != Nfiles)
271: {
272: oldfile();
273: merge(i, Nfiles);
274: }
275: # ifdef xZTR1
276: if (tTf(37,0))
277: {
278: lprintf("%ld tuples in out file\n", Tupsout);
279: lprintf("merge required %ld compares\n", Ccount);
280: }
281: # endif
282: term(0);
283: }
284: /*
285: ** SORT
286: */
287:
288: sort()
289: {
290: register char *cp;
291: register char **lp;
292: register int i;
293: int done;
294: long ntups;
295: struct tup_id tid, ltid;
296: char *xp;
297: long pageid;
298: long rhash();
299: char btree[MAXNAME + 4], btreefile[MAXNAME + 4];
300: char relfile[MAXNAME + 4], btreestruct[MAXNAME + 4];
301:
302: done = 0;
303: ntups = 0;
304: Tupsout = 0;
305: if (abs(Desc.reldum.relspec) != M_ORDER)
306: {
307: if ((Desc.relfp = open(Infile, O_RDONLY)) < 0)
308: cant(Infile);
309: Desc.relopn = (Desc.relfp + 1) * 5;
310: }
311: if (Desc.reldum.reldim > 0 && abs(Desc.reldum.relspec != M_ORDER))
312: /* open all needed btree files */
313: {
314: capital(Desc.reldum.relid, btree);
315: ingresname(btree, Desc.reldum.relowner, btreefile);
316: if ((Desc.relbtree->relfp = open(btreefile, O_RDONLY)) < 0)
317: cant(btreefile);
318: Desc.relbtree->relopn = (Desc.relbtree->relfp + 1) * 5;
319: ingresname(Desc.reldum.relid, Desc.reldum.relowner, relfile);
320: btreename(relfile, btreestruct);
321: if ((Desc.btree_fd = open(btreestruct, O_RDWR)) < 0)
322: cant(btreestruct);
323: }
324:
325: /* initialize tids for full scan */
326: pageid = 0;
327: tid.line_id = -1;
328: stuff_page(&tid, &pageid);
329: pageid = -1;
330: ltid.line_id = -1;
331: stuff_page(<id, &pageid);
332:
333: do
334: {
335: cp = Tspace;
336: lp = Lspace;
337: while (lp < Lspace + Nlines)
338: {
339: if (abs(Desc.reldum.relspec) == M_ORDER)
340: {
341: /* not reading from a relation */
342: if ((i = fread(cp, 1, Desc.reldum.relwid, Btree_fp)) != Desc.reldum.relwid)
343: {
344: if (i != 0)
345: syserr("read error %d", i);
346: fclose(Btree_fp);
347: done++;
348: break;
349: }
350: }
351: else if ((i = kget(&Desc, &tid, <id, cp, TRUE)) != 0)
352: {
353: if (i < 0)
354: syserr("get %d", i);
355: close(Desc.relfp);
356: Desc.relopn = 0;
357: done++;
358: break;
359: }
360: # ifdef xZTR1
361: if (tTf(37,0))
362: printup(&Desc, cp);
363: # endif
364: if (Bucket)
365: {
366: /* compute hash bucket and insert at end */
367: pageid = rhash(&Desc, cp);
368: bmove(&pageid, cp + Desc.reldum.relwid, BUCKETSIZE);
369: }
370: *lp++ = cp;
371: cp += Tupsize;
372: ntups++;
373: }
374: qsort(Lspace, lp - Lspace, sizeof(char *), cmpa);
375: if (done == 0 || Nfiles != 1)
376: newfile();
377: else
378: oldfile();
379: while (lp > Lspace)
380: {
381: cp = *--lp;
382: xp = cp;
383: if ((lp == Lspace) || (i = abs(cmpa(&xp, &lp[-1]))) != 0 || (i == 0 && abs(Desc.reldum.relspec) == M_ORDER))
384: {
385: # ifdef xZTR1
386: if (tTf(37,0))
387: {
388: lprintf("writing ");
389: printup(&Desc, cp);
390: }
391: # endif
392: if ((i = fwrite(cp, 1, Tupsize, Oiop)) != Tupsize)
393: syserr("cant write outfile %d (%d)", i, Nfiles);
394: Tupsout++;
395: }
396: }
397: fclose(Oiop);
398: } while (done == 0);
399: if (Desc.reldum.reldim > 0 && Desc.reldum.relspec != M_ORDER)
400: {
401: close(Desc.relbtree->relfp);
402: Desc.relbtree->relopn = 0;
403: close(Desc.btree_fd);
404: }
405: # ifdef xZTR1
406: if (tTf(37,0))
407: lprintf("%ld tuples in\n", ntups);
408: # endif
409: }
410: /*
411: ** MERGE
412: */
413:
414: struct merg
415: {
416: char tup[MAXTUP+BUCKETSIZE];
417: int filedes;
418: FILE *fiop;
419: };
420:
421: merge(a, b)
422: int a;
423: int b;
424: {
425: register struct merg *merg;
426: register int i, j;
427: char *f, *yesno;
428: struct merg *mbuf[N + 1];
429: char *setfil();
430:
431: # ifdef xZTR1
432: if (tTf(37,0))
433: lprintf("merge %d to %d\n", a, b);
434: # endif
435: merg = (struct merg *) Lspace;
436: j = 0;
437: for (i = a; i < b; i++)
438: {
439: f = setfil(i);
440: mbuf[j] = merg;
441: merg->filedes = i;
442: if ((merg->fiop = fopen(f, "r")) == NULL)
443: cant(f);
444: if (!rline(merg))
445: j++;
446: merg++;
447: }
448:
449: i = j - 1;
450: # ifdef xZTR1
451: if (tTf(37,0))
452: lprintf("start merg with %d\n", i);
453: # endif
454: while (i >= 0)
455: {
456: # ifdef xZTR1
457: if (tTf(37,0))
458: lprintf("mintup %d\n", i);
459: # endif
460: if (mintup(mbuf, i, cmpa))
461: {
462: if (fwrite(mbuf[i]->tup, 1, Tupsize, Oiop) != Tupsize)
463: syserr("cant write merge output");
464: Tupsout++;
465: }
466: merg = mbuf[i];
467: if (rline(merg))
468: {
469: yesno = "not ";
470: # ifdef xZTR1
471: if (!tTf(37,0))
472: {
473: /* truncate temporary files to zero length */
474: yesno = "";
475: close(creat(setfil(merg->filedes), 0600));
476: }
477: # endif
478: # ifdef xZTR1
479: if (tTf(37,0))
480: lprintf("dropping and %struncating %s\n", yesno, setfil(merg->filedes));
481: # endif
482: i--;
483: }
484: }
485:
486: fclose(Oiop);
487: }
488: /*
489: ** Mintup puts the smallest tuple in mbuf[cnt-1].
490: ** If the tuple is a duplicate of another then
491: ** mintup returns 0, else 1.
492: **
493: ** Cnt is the number of compares to make; i.e.
494: ** mbuf[cnt] is the last element.
495: */
496:
497: mintup(mbuf, cnt, cmpfunc)
498: struct merg *mbuf[];
499: int cnt;
500: int (*cmpfunc)();
501: {
502: register struct merg **next, **last;
503: struct merg *temp;
504: register int nodup;
505: int j;
506:
507: nodup = TRUE;
508: next = mbuf;
509: last = &next[cnt];
510:
511: while (cnt--)
512: {
513: if (j = (*cmpfunc)(last, next))
514: {
515: /* tuples not equal. keep smallest */
516: if (j < 0)
517: {
518: /* exchange */
519: temp = *last;
520: *last = *next;
521: *next = temp;
522: nodup = TRUE;
523: }
524: }
525: else
526: nodup = FALSE;
527:
528: next++;
529: }
530: return (nodup);
531: }
532:
533:
534: rline(mp)
535: struct merg *mp;
536: {
537: register struct merg *merg;
538: register int i;
539:
540: merg = mp;
541: if ((i = fread(merg->tup, 1, Tupsize, merg->fiop)) != Tupsize)
542: {
543: if (i == 0)
544: {
545: fclose(merg->fiop);
546: return (1);
547: }
548: syserr("rd err %d on %s", i, setfil(merg->filedes));
549: }
550: return (0);
551: }
552:
553: newfile()
554: {
555: char *setfil();
556:
557: makfile(setfil(Nfiles));
558: Nfiles++;
559: }
560: /*
561: ** Convert the number i to a char
562: ** sequence aa, ab, ..., az, ba, etc.
563: */
564:
565: char *
566: setfil(i)
567: int i;
568: {
569: register int j;
570:
571: j = i;
572: j--;
573: Filep[0] = j/26 + 'a';
574: Filep[1] = j%26 + 'a';
575: return (File);
576: }
577:
578: oldfile()
579: {
580: makfile(Outfile);
581: Tupsout = 0;
582: }
583: /*
584: ** Create a file by the name "name"
585: ** and place its fio pointer in Oiop
586: */
587:
588: makfile(name)
589: char *name;
590: {
591: if ((Oiop = fopen(name, "w")) == NULL)
592: cant(name);
593: }
594:
595: cant(f)
596: char *f;
597: {
598: syserr("open %s", f);
599: }
600:
601: term(error)
602: int error;
603: {
604: register int i;
605:
606: if (Nfiles == 1)
607: Nfiles++;
608: # ifdef xZTR1
609: if (tTf(37,0))
610: lprintf("temp files not removed\n");
611: else
612: # endif
613: for (i = 1; i < Nfiles; i++)
614: {
615: unlink(setfil(i));
616: }
617: return(error);
618: }
619: /*
620: ** CMPA -- compare tuples
621: */
622:
623: cmpa(a, b)
624: char **a;
625: char **b;
626: {
627: int af[4];
628: int bf[4];
629: char *pa, *pb;
630: register union anytype *tupa, *tupb;
631: int dom;
632: register int frml;
633: int frmt;
634: int off;
635: int temp;
636: int rt;
637: char *dp;
638:
639: pa = *a;
640: pb = *b;
641: Ccount++;
642: dp = Descsort;
643: while ((temp = *dp++) != ENDKEY)
644: {
645: if ((dom = temp) < 0)
646: dom = -temp;
647: frml = Desc.relfrml[dom];
648: frmt = Desc.relfrmt[dom];
649: off = Desc.reloff[dom];
650: tupa = (union anytype *) &pa[off];
651: tupb = (union anytype *) &pb[off];
652: if (temp < 0)
653: {
654: tupb = tupa;
655: tupa = (union anytype *) &pb[off];
656: }
657: if (frmt == CHAR)
658: {
659: frml &= I1MASK;
660: if (rt = scompare(tupb, frml, tupa, frml))
661: return (rt);
662: continue;
663: }
664:
665: /* domain is a numeric type */
666: if (bequal(tupa, tupb, frml))
667: continue;
668: /* copy to even word boundary */
669: bmove(tupa, af, frml);
670: bmove(tupb, bf, frml);
671: tupa = (union anytype *) af;
672: tupb = (union anytype *) bf;
673:
674: switch (frmt)
675: {
676:
677: case INT:
678: switch (frml)
679: {
680:
681: case 1:
682: return (tupa->i1type > tupb->i1type ? -1 : 1);
683:
684: case 2:
685: return (tupa->i2type > tupb->i2type ? -1 : 1);
686:
687: case 4:
688: return (tupa->i4type > tupb->i4type ? -1 : 1);
689: }
690:
691: case FLOAT:
692: switch (frml)
693: {
694:
695: case 4:
696: return (tupa->f4type > tupb->f4type ? -1 : 1);
697:
698: case 8:
699: return (tupa->f8type > tupb->f8type ? -1 : 1);
700: }
701: }
702: }
703: return (0);
704: }
705: /*
706: ** KGET_PAGE
707: ** Replacement for access method routine get_page();
708: ** and associated globals and routines.
709: */
710:
711: long Accuread, Accuwrite;
712:
713: kget_page(d, tid)
714: register DESC *d;
715: struct tup_id *tid;
716: {
717: register int i;
718: long pageid;
719: register struct accbuf *b;
720: extern struct accbuf *choose_buf();
721:
722: # ifdef xZTR1
723: if (tTf(37,0))
724: {
725: lprintf("kget_page: %.14s,", d->reldum.relid);
726: dumptid(tid);
727: }
728: # endif
729: pluck_page(tid, &pageid);
730: if ((b = choose_buf(d, pageid)) == NULL)
731: {
732: # ifdef xZTR1
733: if (tTf(37,0))
734: lprintf(" choose_buf: buffer not avail \n");
735: # endif
736: return(-1);
737: }
738: top_acc(b);
739:
740: i = 0;
741: if (b->thispage != pageid)
742: {
743: # ifdef xZTR1
744: if (tTf(37,0))
745: lprintf("kget_page: rdg pg %ld\n", pageid);
746: # endif
747: b->thispage = pageid;
748: if ((lseek(d->relfp, pageid * PGSIZE, 0) < 0) ||
749: ((read(d->relfp, b, PGSIZE)) != PGSIZE))
750: {
751: i = AMREAD_ERR;
752: }
753: Accuread++;
754: }
755: return (i);
756: }
757:
758: /*
759: ** KGET - get a single tuple
760: **
761: ** Get either gets the next sequencial tuple after
762: ** "tid" or else gets the tuple specified by tid.
763: **
764: ** If getnxt == TRUE, then tid is incremented to the next
765: ** tuple after tid. If there are no more, then get returns
766: ** 1. Otherwise get returns 0 and "tid" is set to the tid of
767: ** the returned tuple.
768: **
769: ** Under getnxt mode, the previous page is reset before
770: ** the next page is read. This is done to prevent the previous
771: ** page from hanging around in the am's buffers when we "know"
772: ** that it will not be referenced again.
773: **
774: ** If getnxt == FALSE then the tuple specified by tid is
775: ** returned. If the tuple was deleted previously,
776: ** get retuns 2 else get returns 0.
777: **
778: ** If getnxt is true, limtid holds the the page number
779: ** of the first page past the end point. Limtid and the
780: ** initial value of tid are set by calls to FIND.
781: **
782: ** returns:
783: ** <0 fatal error
784: ** 0 success
785: ** 1 end of scan (getnxt=TRUE only)
786: ** 2 tuple deleted (getnxt=FALSE only)
787: */
788:
789:
790: kget(d, tid, limtid, tuple, getnxt)
791: register DESC *d;
792: register TID *tid;
793: TID *limtid;
794: int getnxt;
795: char *tuple;
796: {
797: register int i;
798: long pageid, lpageid;
799:
800: # ifdef xATR1
801: if (tTf(23, 0) || tTf(37,0))
802: {
803: lprintf("kget: %.14s,", d->reldum.relid);
804: dumptid(tid);
805: lprintf("kget: lim");
806: dumptid(limtid);
807: }
808: # endif
809: if (kget_page(d, tid))
810: {
811: return (-1);
812: }
813: if (getnxt)
814: {
815: pluck_page(limtid, &lpageid);
816: do
817: {
818: while (((++(tid->line_id)) & I1MASK) >= Acc_head->nxtlino)
819: {
820: tid->line_id = -1;
821: pageid = Acc_head->ovflopg;
822: stuff_page(tid, &pageid);
823: if (pageid == 0)
824: {
825: pageid = Acc_head->mainpg;
826: stuff_page(tid, &pageid);
827: if (pageid == 0 || pageid == lpageid + 1)
828: return (1);
829: }
830: if (i = resetacc(Acc_head))
831: return (i);
832: if (i = get_page(d, tid))
833: return (i);
834: }
835: } while (!Acc_head->linetab[-(tid->line_id & I1MASK)]);
836: }
837: else
838: {
839: if (i = invalid(tid))
840: return (i);
841: }
842: get_tuple(d, tid, tuple);
843: # ifdef xATR2
844: if (tTf(23, 1) || tTf(37,0))
845: {
846: printf("kget: ");
847: printup(d, tuple);
848: }
849: # endif
850: return (0);
851: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.