gdk_align.c

这个是内存数据库中的一个管理工具

#line 79 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_align.mx"
#include "monetdb_config.h"
#include "gdk.h"

int
ALIGNcommit(BAT *b)
{
	BATcheck(b, "ALIGNcommit: bat required");
	if (!b->halign) {
		b->halign = OIDnew(1);
	}
	if (!b->talign) {
		b->talign = OIDnew(1);
	}
	return 0;
}

int
ALIGNundo(BAT *b)
{
	BATcheck(b, "ALIGNundo: bat required");
	return 0;
}

int
ALIGNsetH(BAT *b1, BAT *b2)
{
	ssize_t diff = BUNindex(b1, BUNfirst(b1)) - BUNindex(b2, BUNfirst(b2));
	BATcheck(b1, "ALIGNsetH: bat 1 required");
	BATcheck(b2, "ALIGNsetH: bat 2 required");

	if (b2->halign == 0) {
		b2->halign = OIDnew(1);
		b2->batDirtydesc = TRUE;
	} else {
		/* propagate GDK_AGGR information */
		BATpropagate(b1, b2, GDK_AGGR_SIZE);
		BATpropagate(b1, b2, GDK_AGGR_CARD);
		BATpropagate(b1, b2, GDK_AGGR_HASNIL);
	}
	if (BAThvoid(b2)) {
		/* b2 is either dense or has a void(nil) head */
		if (b1->htype != TYPE_void)
			b1->hdense = TRUE;
		BATseqbase(b1, b2->hseqbase);
	} else if (b1->htype != TYPE_void) {
		/* b2 is not dense, so set b1 not dense */
		b1->hdense = FALSE;
		BATseqbase(b1, oid_nil);
	}
	BATkey(b1, b2->hkey != FALSE);
	b1->hsorted = BAThordered(b2);
	b1->halign = b2->halign;
	b1->batDirtydesc = TRUE;
	b1->H->nosorted_rev = b2->H->nosorted_rev + diff; 
	b1->H->nokey[0] = b2->H->nokey[0] + diff; 
	b1->H->nokey[1] = b2->H->nokey[1] + diff; 
	b1->H->nosorted = b2->H->nosorted + diff; 
	b1->H->nodense = b2->H->nodense + diff; 
 
	return 0;
}



#line 146 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_align.mx"
int
ALIGNsynced(BAT *b1, BAT *b2)
{
	BATcheck(b1, "ALIGNsynced: bat 1 required");
	BATcheck(b2, "ALIGNsynced: bat 2 required");

	/* first try to prove head columns are not in sync */
	if (BATcount(b1) != BATcount(b2))
		return 0;
	if (ATOMtype(BAThtype(b1)) != ATOMtype(BAThtype(b2)))
		return 0;
	if (BAThvoid(b1) && BAThvoid(b2))
		return (b1->hseqbase == b2->hseqbase);

	/* then try that they are */
	if (b1->batCacheid == b2->batCacheid)
		return 1;	/* same bat. trivial case */
	if (BATcount(b1) == 0)
		return 1;	/* empty bats of same type. trivial case */
	if (b1->halign && b1->halign == b2->halign)
		return 1;	/* columns marked as equal by algorithmics */
	if (VIEWparentcol(b1) && ALIGNsynced(BBPcache(VIEWparent(b1)), b2))
		return 1;	/* view on same bat --- left recursive def.. */
	if (VIEWparentcol(b2) && ALIGNsynced(b1, BBPcache(VIEWparent(b2))))
		return 1;	/* view on same bat --- right recursive def.. */

	return 0;		/* we simply don't know */
}



#line 179 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_align.mx"
int
ALIGNrelated(BAT *b1, BAT *b2)
{
	BATcheck(b1, "ALIGNrelated: bat 1 required");
	BATcheck(b2, "ALIGNrelated: bat 2 required");
	return (ALIGNsynced(b1, b2) || ALIGNsynced(BATmirror(b1), b2) || ALIGNsynced(b1, BATmirror(b2)) || ALIGNsynced(BATmirror(b1), BATmirror(b2)));
}




#line 203 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_align.mx"
BAT *
VIEWcreate_(BAT *b, int slice_view)
{
	BAT *bn, *recycled = NULL;
	bat parent;

	BATcheck(b, "VIEWcreate_: bat required");
	bn = BBPrecycle(TYPE_void, TYPE_void, 1);
	if (bn) {
		recycled = BATmirror(bn);
	} else {
		bn = BATcreatedesc(b->htype, b->ttype, FALSE);
	}

	parent = VIEWparent(b);
	if (parent == 0 || b->batBuns->copied) {
		parent = b->batCacheid;
	}
	bn->batParentid = parent;
	if (parent < 0)
		parent = -parent;

	BBPshare(parent);


#line 231 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_align.mx"
	bn->dims = b->dims;
	if (recycled) recycled->dims = BATmirror(b)->dims;
	*bn->H = *b->H;
	*bn->T = *b->T;
	assert(bn->U->buns.base == (char*)1 || bn->U->buns.base == NULL);
	*bn->U = *b->U;
	bn->H->props = bn->T->props = NULL;
	BATinit_idents(bn);


#line 242 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_align.mx"
	bn->batSet = b->batSet;
	bn->batDirty = BATdirty(b);
	bn->batRestricted = BAT_READ;


#line 252 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_align.mx"
	if (slice_view || VIEWparent(b)) {
		/* slices are unequal to their parents; cannot use accs */
		bn->hhash = bn->thash = NULL;
	} else {
		/* equal pointers to parent mean view uses acc of parent */
		bn->hhash = b->hhash;
		bn->thash = b->thash;
		if (recycled) {
			recycled->hhash = b->thash;
			recycled->thash = b->hhash;
		}
	}
	if (recycled == NULL) {
		BBPcacheit(bn); /* enter in BBP and create mirror */
	}
	return bn;
}

BAT *
VIEWcreate(BAT *b)
{
	return VIEWcreate_(b, FALSE);
}



#line 279 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_align.mx"
BAT *
VIEWhead(BAT *b)
{
	BAT *bn = VIEWcreate(b);
	BAT *bm = BATmirror(bn);
	BATstore *bs = (BATstore *) bn;

	if (bn == NULL || bm == NULL)
		return NULL;
	bn->T = &bs->T;

	if (bn->T != bm->H)
		*bn->T = *bm->H;
	bm->H = bn->T;
	bn->ttype = bm->htype = TYPE_void;
	bn->tvarsized = bm->hvarsized = 1;
	bn->thash = bm->hhash = NULL;
	BATseqbase(bm, oid_nil);

	return bn;
}

BAT *
VIEWhead_(BAT *b, int mode)
{
	BAT *bn = VIEWhead(b);

	if (bn)
		bn->batRestricted = mode;
	return bn;
}



#line 315 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_align.mx"
BAT *
VIEWcombine(BAT *b)
{
	BAT *bn = VIEWcreate(b);
	BAT *bm = BATmirror(bn);

	if (bn == NULL || bm == NULL)
		return NULL;
	bm->H = bn->T = bn->H;
	bn->ttype = bm->htype = bn->htype;
	bn->tloc = bm->hloc = bn->hloc;
	bn->ttype = bm->htype = bn->htype;
	bn->tkey = bm->hkey = bn->hkey;
	bn->tseqbase = bm->hseqbase = bn->hseqbase;
	bn->tvarsized = bm->hvarsized = bn->hvarsized;
	bn->thash = bm->hhash = bn->hhash;

	return bn;
}



#line 340 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_align.mx"
BAT *
BATmaterialize(BAT *b, size_t size)
{
	BAT *bm, *ret = NULL;

	BATcheck(b, "BATmaterialize: bat required");
	{
		int ht = b->htype, tt = b->ttype, vid = 0;
		int vv = (!ht && !tt);
		size_t oldsize = BATcount(b);
		size_t cnt = MAX(oldsize, size);
		Heap buns = *b->batBuns, *hh = b->hheap, *th = b->theap;
		int bunwidth = b->dims.bunwidth, hlc = b->hloc, tlc = b->tloc;
		int newbw = 0;
		BUN p = BUNfirst(b), q = BUNlast(b);
		char *nme = BBP_physical(b->batCacheid);
		int committed = BBP_status(b->batCacheid) & BBPEXISTING;

		ALGODEBUG THRprintf(GDKout, "#BATmaterialize(%d," SZFMT ");\n", (int) b->batCacheid, size);

		if (BAThdense(b) && ht == TYPE_void) {
			vid |= 1;
			ht = TYPE_oid;
		}
		if (BATtdense(b) && tt == TYPE_void) {
			vid |= 2;
			tt = TYPE_oid;
		}
		if (vid == 0) {	/* no voids */
			return b;
		}

		/* cleanup possible ACC's */
		HASHdestroy(b);

		/* guess new bunwidth before setting the new dimensions, +3 to allow chr-on-int alignment */
		b->batBuns->filename = NULL;
		if (HEAPalloc(b->batBuns, cnt + 3, 2 * MAX(sizeof(oid), b->dims.bunwidth)) < 0) {
			*b->batBuns = buns;
			return NULL;
		}
		if (hh) {
			b->hheap = (Heap*)GDKmalloc(sizeof(Heap));
			*b->hheap = *hh;
			b->hheap->filename = NULL;
			if (ATOMheap(ht, b->hheap, cnt) < 0) {
				HEAPfree(b->batBuns);
				*b->batBuns = buns;
				b->hheap = hh;
				return NULL;
			}
		}
		if (th) {
			b->theap = (Heap*)GDKmalloc(sizeof(Heap));
			*b->theap = *th;
			b->theap->filename = NULL;
			if (ATOMheap(tt, b->theap, cnt) < 0) {
				HEAPfree(b->batBuns);
				HEAPfree(b->hheap);
				GDKfree(b->hheap);
				*b->batBuns = buns;
				b->hheap = hh;
				b->theap = th;
				return NULL;
			}
		}

		/* point of no return */
		b->htype = ht;
		b->ttype = tt;
		BATsetdims(b);
		DELTAinit(b);
		newbw = BUNsize(b);
		b->batDirty = TRUE;
		b->batDirtydesc = TRUE;
		b->batDirtybuns = TRUE;

		bm = BATmirror(b);
		bm->dims.headtype = b->dims.tailtype;
		bm->dims.tailtype = b->dims.headtype;
		bm->dims.headloc = b->dims.tailloc;
		bm->dims.tailloc = b->dims.headloc;
		bm->dims.headkey = b->dims.tailkey;
		bm->dims.tailkey = b->dims.headkey;
		bm->dims.headvarsized = b->dims.tailvarsized;
		bm->dims.tailvarsized = b->dims.headvarsized;
		bm->dims.bunwidth = b->dims.bunwidth;
		bm->dims.bunshift = b->dims.bunshift;
		bm->dims.hseq = b->dims.tseq;
		bm->dims.tseq = b->dims.hseq;
		bm->hhash = b->thash;
		bm->thash = b->hhash;

		/* set the correct dense info */
		if (vid & 1) 	
			b->hdense = TRUE;
		if (vid & 2) 	
			b->tdense = TRUE;
		if (vid == 1) {
			oid h = b->hseqbase;
			BUN r = BUNlast(b);

			if (!b->tvarsized) {
				for (; p < q; p += bunwidth, h++, r += newbw)
					bunfastins_nocheck(b, r, (ptr) &h, p + tlc, newbw);
			} else if (tt == TYPE_void) {
				for (; p < q; p += bunwidth, h++, r += newbw)
					bunfastins_nocheck(b, r, (ptr) &h, NULL, newbw);
			} else {
				char *tbase = th->base;

				for (; p < q; p += bunwidth, h++, r += newbw)
					bunfastins_nocheck(b, r, (ptr) &h, tbase + (*(var_t *) (p + tlc)), newbw);
			}
		} else if (vid == 2) {
			oid t = b->tseqbase;
			BUN r = BUNlast(b);

			if (!b->hvarsized) {
				for (; p < q; p += bunwidth, t++, r += newbw)
					bunfastins_nocheck(b, r, p + hlc, (ptr) &t, newbw);
			} else if (ht == TYPE_void) {
				for (; p < q; p += bunwidth, t++, r += newbw)
					bunfastins_nocheck(b, r, NULL, (ptr) &t, newbw);
			} else {
				char *hbase = hh->base;

				for (; p < q; p += bunwidth, t++, r += newbw)
					bunfastins_nocheck(b, r, hbase + (*(var_t *) (p + hlc)), (ptr) &t, newbw);
			}