gdk_delta.c

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

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



#line 117 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_delta.mx"
BAT *
BATcommit(BAT *b)
{
	BATcheck(b, "BATcommit");
	DELTAprintf("#BATcommit1 %s free " SZFMT " ins " PTRFMT " del " PTRFMT " first " PTRFMT " base " PTRFMT "\n", BATgetId(b), b->batBuns->free, PTRFMTCAST b->batInserted, PTRFMTCAST b->batDeleted, PTRFMTCAST b->batFirst, PTRFMTCAST b->batBuns->base);
	ALIGNcommit(b);
	if (b->batDeleted < b->batFirst && BBP_cache(b->batCacheid)) {
		int (*hunfix) (ptr) = BATatoms[b->htype].atomUnfix;
		int (*tunfix) (ptr) = BATatoms[b->ttype].atomUnfix;
		void (*hatmdel) (Heap *, var_t *) = BATatoms[b->htype].atomDel;
		void (*tatmdel) (Heap *, var_t *) = BATatoms[b->ttype].atomDel;
		BUN p, q;
		int xx;

		if (hatmdel || hunfix || tatmdel || tunfix) {
			DELloop(b, p, q, xx) {
				ptr h = BUNhead(b, p);
				ptr t = BUNtail(b, p);

				if (hunfix) {
					(*hunfix) (h);
				}
				if (hatmdel) {
					(*hatmdel) (b->hheap, (var_t *) (p + b->hloc));
				}
				if (tunfix) {
					(*tunfix) (t);
				}
				if (tatmdel) {
					(*tatmdel) (b->theap, (var_t *) (p + b->tloc));
				}
			}
		}
	}
	if (!BATdirty(b)) {
		b->batDirtyflushed = 0;
	}
	if (DELTAdirty(b)) {
		b->batDirtydesc = 1;
	}
	b->batDeleted = b->batFirst;
	if (b->batBuns->base) {
		b->batInserted = BUNlast(b);
	} else {
		b->batInserted = (BUN) (b->batBuns->free / BUNsize(b));
	}
	DELTAprintf("#BATcommit2 %s free " SZFMT " ins " PTRFMT " del " PTRFMT " first " PTRFMT " base " PTRFMT "\n", BATgetId(b), b->batBuns->free, PTRFMTCAST b->batInserted, PTRFMTCAST b->batDeleted, PTRFMTCAST b->batFirst, PTRFMTCAST b->batBuns->base);
	return b;
}



#line 170 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_delta.mx"
BAT *
BATfakeCommit(BAT *b)
{
	if (b) {
		BATcommit(b);
		b->batDirty = 0;
		b->batDirtydesc = b->batDirtybuns = 0;
		b->hheapdirty = b->theapdirty = 0;
	}
	return b;
}



#line 192 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_delta.mx"
BAT *
BATundo(BAT *b)
{
	int bunsize = BUNsize(b);
	BUN p, bunlast, bunfirst;

	BATcheck(b, "BATundo");
	DELTAprintf("#BATundo %s \n", BATgetId(b));
	ALIGNundo(b);
	if (b->batDirtyflushed) {
		b->batDirtydesc = b->batDirtybuns = 1;
	} else {
		b->batDirty = 0;
		b->batDirtydesc = b->batDirtybuns = 0;
		b->hheapdirty = b->theapdirty = 0;
	}
	bunfirst = b->batInserted;
	bunlast = BUNlast(b) - BUNsize(b);
	if (bunlast >= b->batInserted) {
		size_t i = BUNindex(b, bunfirst);
		int (*hunfix) (ptr) = BATatoms[b->htype].atomUnfix;
		int (*tunfix) (ptr) = BATatoms[b->ttype].atomUnfix;
		void (*hatmdel) (Heap *, var_t *) = BATatoms[b->htype].atomDel;
		void (*tatmdel) (Heap *, var_t *) = BATatoms[b->ttype].atomDel;

		if (hunfix || tunfix || hatmdel || tatmdel || b->hhash || b->thash) {
			for (p = bunfirst; p <= bunlast; p += bunsize, i++) {
				ptr h = BUNhead(b, p);
				ptr t = BUNtail(b, p);

				if (b->hhash) {
					HASHdel(b->hhash, i, h, p < bunlast);
				}
				if (hunfix) {
					(*hunfix) (h);
				}
				if (hatmdel) {
					(*hatmdel) (b->hheap, (var_t *) (p + b->hloc));
				}
				if (b->thash) {
					HASHdel(b->thash, i, t, p < bunlast);
				}
				if (tunfix) {
					(*tunfix) (t);
				}
				if (tatmdel) {
					(*tatmdel) (b->theap, (var_t *) (p + b->tloc));
				}
			}
		}
	}
	b->batBuns->free = (char *) b->batInserted - (char *) Bunbase(b);

	bunfirst = b->batDeleted;
	bunlast = b->batFirst;
	if (bunlast > b->batDeleted) {
		size_t i = BUNindex(b, bunfirst);
                BAT *bm = BBP_cache(-b->batCacheid);

		/* elements are 'inserted' => zap properties */
		if (b->hsorted & 1 || b->hsorted == (bit)GDK_SORTED_REV)
			b->hsorted = FALSE;
		if (b->tsorted & 1 || b->tsorted == (bit)GDK_SORTED_REV)
			b->tsorted = FALSE;
		if (b->hkey)
			BATkey(b, FALSE);
		if (b->tkey)
			BATkey(BATmirror(b), FALSE);

		for (p = bunfirst; p < bunlast; p += bunsize, i++) {
			ptr h = BUNhead(b, p);
			ptr t = BUNtail(b, p);

			if (b->hhash) {
				HASHins(b, i, h);
			}
			if (b->thash) {
				HASHins(bm, i, t);
			}
		}
	}
	b->batFirst = b->batDeleted;
	BATsetcount(b, (BUNlast(b)-BUNfirst(b))/BUNsize(b) );
	return b;
}



#line 279 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_delta.mx"


#line 285 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_delta.mx"
BAT *
BATprev(BAT *b)
{
	BUN p;
	BAT *bn;

	BATcheck(b, "BATprev");
	if (b->batRestricted == BAT_READ) {
		bn = VIEWcreate(b);
		if (bn) {
			bn->batBuns->free = bn->batInserted - bn->batBuns->base;
			bn->batInserted = bn->batFirst = bn->batDeleted;
			BATsetcount(bn, (BUNlast(bn)-BUNfirst(bn))/BUNsize(bn) );
		}
		return bn;
	}
	bn = BATnew(BAThtype(b), BATttype(b), BATcapacity(b));
	if (bn == NULL) {
		return bn;
	}
	for (p = b->batDeleted; p < b->batInserted; p = BUNnext(b, p)) {
		if (BUNins(bn, BUNhead(b, p), BUNtail(b, p), FALSE) == NULL) {
			BBPreclaim(bn);
			return NULL;
		}
	}
	return bn;
}

BAT *
BATalpha(BAT *b)
{
	BUN p;
	BAT *bn;

	BATcheck(b, "BATalpha");
	if (b->batRestricted == BAT_READ) {
		bn = VIEWcreate(b);
		if (bn) {
			bn->batDeleted = bn->batFirst = bn->batInserted;
			BATsetcount(bn, (BUNlast(bn)-BUNfirst(bn))/BUNsize(bn) );
		}
		return bn;
	}
	bn = BATnew(BAThtype(b), BATttype(b), BATcapacity(b));
	if (bn == NULL) {
		return bn;
	}
	for (p = b->batInserted; p < BUNlast(b); p = BUNnext(b, p)) {
		if (BUNins(bn, BUNhead(b, p), BUNtail(b, p), FALSE) == NULL) {
			BBPreclaim(bn);
			return NULL;
		}
	}
	return bn;
}

BAT *
BATdelta(BAT *b)
{
	BUN p;
	BAT *bn;

	BATcheck(b, "BATdelta");
	if (b->batRestricted == BAT_READ) {
		bn = VIEWcreate(b);
		if (bn) {
			bn->batBuns->free = bn->batFirst - bn->batBuns->base;
			bn->batFirst = bn->batInserted = bn->batDeleted;
			BATsetcount(bn, (BUNlast(bn)-BUNfirst(bn))/BUNsize(bn) );
		}
		return bn;
	}
	bn = BATnew(BAThtype(b), BATttype(b), BATcapacity(b));
	if (bn == NULL) {
		return bn;
	}
	for (p = b->batDeleted; p < b->batFirst; p = BUNnext(b, p)) {
		if (BUNins(bn, BUNhead(b, p), BUNtail(b, p), FALSE) == NULL) {
			BBPreclaim(bn);
			return NULL;
		}
	}
	return bn;
}