bpm.mx

一个内存数据库的源代码这是服务器端还有客户端

static BAT *bpmName;		/* bat[:bat,:str] */
static BAT *bpmPartition;	/* bat[:bat,:bat] */
static BAT *bpmHeadLow[TYPE_any]; /*bat[:bat,:type_i] */
static BAT *bpmHeadHigh[TYPE_any]; /*bat[:bat,:type_i] */
static BAT *bpmTailLow[TYPE_any]; /*bat[:bat,:type_i] */
static BAT *bpmTailHigh[TYPE_any]; /*bat[:bat,:type_i] */
static BAT *bpmHeadSlots; /*bat[:bat,:int] */
static BAT *bpmTailSlots; /*bat[:bat,:int] */

@- Box administration
The box currently does not carry any client protection.
This should later be added or being provided by the BAT access.

@= openCat
@c
str
BPMopen()
{
	int i;

	if( bpmName )
		return MAL_SUCCEED;

	/* open all BATs available in the catalog */
    mal_set_lock(mal_contextLock, "bpm");
	bpmName= BATdescriptor(BBPindex("bpmName"));
	if( bpmName == NULL)
		throw(MAL, "bpm.open", "failed to access bpmName");
	bpmPartition= BATdescriptor(BBPindex("bpmPartition"));
	if( bpmPartition == NULL)
		throw(MAL, "bpm.open", "failed to access bpmName");
	bpmHeadSlots= BATdescriptor(BBPindex("bpmHeadSlots"));
	if( bpmHeadSlots == NULL)
		throw(MAL, "bpm.open", "failed to access bpmHeadSlots");
	bpmTailSlots= BATdescriptor(BBPindex("bpmTailSlots"));
	if( bpmTailSlots == NULL)
		throw(MAL, "bpm.open", "failed to access bpmTailSlots");

	for(i=0; i< GDKatomcnt; i++){
		char buf[PATHLENGTH];
		snprintf(buf,PATHLENGTH,"pbmHeadLow_%i",i);
		bpmHeadLow[i]= BATdescriptor(BBPindex(buf));
		snprintf(buf,PATHLENGTH,"pbmHeadHigh%i",i);
		bpmHeadHigh[i]= BATdescriptor(BBPindex(buf));
		snprintf(buf,PATHLENGTH,"pbmTailLow_%i",i);
		bpmTailLow[i]= BATdescriptor(BBPindex(buf));
		snprintf(buf,PATHLENGTH,"pbmTailHigh%i",i);
		bpmTailHigh[i]= BATdescriptor(BBPindex(buf));
	}
    mal_unset_lock(mal_contextLock, "bpm");
	return MAL_SUCCEED;
}

str
BPMclose(int *ret)
{
	(void) ret;
	/* save the catalog using a subtransaction */
	throw(MAL, "bpm.close","NYI");
}

str
BPMdestroy(int *ret)
{
	(void) ret;
	/* re-initialize the partition table */
	throw(MAL, "bpm.destroy","NYI");
}

str
BPMdepositName(int *ret, str *nme, int *src)
{
	BAT *b;
	BPMopen();
	@:getBATdescriptor(src,b,"bpm.deposit");
	/* test for duplicate names */
	/* a nil-nil range partition*/
	(void) nme;
	(void) b;
	*ret= 0;
	throw(MAL, "bpm.deposit","NYI");
}
str
BPMdeposit(int *ret, int *bid, int *src)
{
	BAT *b, *bn;
	BPMopen();
	@:getBATdescriptor(bid,b,"bpm.deposit");
	@:getBATdescriptor(src,bn,"bpm.deposit");
	/* Distribued content of src to alias */
	(void) b;
	(void) bn;
	*ret= 0;
	throw(MAL, "bpm.deposit","NYI");
}

str
BPMrange(int *ret, int *bid, ptr *hl, ptr *hh, ptr *tl, ptr *th)
{
	BAT *b;
	BPMopen();
	@:getBATdescriptor(bid,b,"bpm.range")@
	/* determine the partitioning scheme */
	(void) b;
	(void) hl;
	(void) hh;
	(void) tl;
	(void) th;
	*ret= 0;
	throw(MAL, "bpm.range","NYI");
}
str
BPMhash(int *ret, int *bid, int *hslots, int *tslots)
{
	BAT *b;
	BPMopen();
	@:getBATdescriptor(bid,b,"bpm.hash")@
	/* get hash slot administration */
	(void) b;
	(void) hslots;
	(void) tslots;
	*ret= 0;
	throw(MAL, "bpm.hash","NYI");
}
str
BPMrangeHash(int *ret, int *bid, ptr *hl, ptr *hh, int *tslots)
{
	BAT *b;
	BPMopen();
	@:getBATdescriptor(bid,b,"bpm.rangeHash")@
	/* partition into two direction */
	(void) b;
	(void) hl;
	(void) hh;
	(void) tslots;
	*ret= 0;
	throw(MAL, "bpm.rangeHash","NYI");
}
str
BPMhashRange(int *ret, int *bid, int *hslots, ptr *tl, ptr *th)
{
	BAT *b;
	BPMopen();
	@:getBATdescriptor(bid,b,"bpm.hashRange")@
	/* partition into two direction */
	(void) b;
	(void) hslots;
	(void) tl;
	(void) th;
	*ret= 0;
	throw(MAL, "bpm.hashRange","NYI");
}
str
BPMderived(int *ret, int *bid, int *src)
{
	BAT *b;
	BPMopen();
	@:getBATdescriptor(bid,b,"bpm.derived")@
	/* partition into two direction */
	(void) b;
	(void) src;
	*ret= 0;
	throw(MAL, "bpm.derived","NYI");
}
@-
Takeing out partitions.
@c
str
BPMtake(int *ret, str *nme)
{
	BPMopen();
	(void) nme;
	*ret =0;
	throw(MAL, "bpm.take","NYI");
}
str
BPMtakeRange(int *ret, int *bid, ptr *hl, ptr *hh, ptr *tl, ptr *th)
{
	BAT *b;
	BPMopen();
	@:getBATdescriptor(bid,b,"bpm.take");
	(void) b;
	(void) hl;
	(void) hh;
	(void) tl;
	(void) th;
	*ret =0;
	throw(MAL, "bpm.take","NYI");
}

str
BPMtakeHash(int *ret, int *bid, int *hslots, int *tslots)
{
	BAT *b;
	BPMopen();
	@:getBATdescriptor(bid,b,"bpm.take");
	(void) b;
	(void) hslots;
	(void) tslots;
	*ret =0;
	throw(MAL, "bpm.take","NYI");
}

str
BPMtakeRangeHash(int *ret, int *bid, ptr *hl, ptr *hh, int *tslots)
{
	BAT *b;
	BPMopen();
	@:getBATdescriptor(bid,b,"bpm.take");
	(void) b;
	(void) hl;
	(void) hh;
	(void) tslots;
	*ret =0;
	throw(MAL, "bpm.take","NYI");
}

str
BPMtakeHashRange(int *ret, int *bid, int *hslots, ptr *tl, ptr *th)
{
	BAT *b;
	BPMopen();
	@:getBATdescriptor(bid,b,"bpm.take");
	(void) b;
	(void) tl;
	(void) th;
	(void) hslots;
	*ret =0;
	throw(MAL, "bpm.take","NYI");
}

str
BPMtakePartition(int *ret, int *bid, int *idx)
{
	BAT *b;
	BPMopen();
	@:getBATdescriptor(bid,b,"bpm.take")@
	(void) b;
	(void) idx;
	*ret =0;
	throw(MAL, "bpm.take","NYI");
}
@- Updates
@c
str
BPMinsert(int *ret, int *bid, int *ins)
{
	BAT *b;
	BPMopen();
	@:getBATdescriptor(bid,b,"bpm.insert")@
	/* distributed the content */
	(void) b;
	(void) ins;
	*ret= 0;
	throw(MAL, "bpm.insert","NYI");
}

str
BPMdelete(int *ret, int *bid, int *del)
{
	BAT *b;
	BPMopen();
	@:getBATdescriptor(bid,b,"bpm.delete")@
	/* delete some information from the partitions */
	(void) b;
	(void) del;
	*ret= 0;
	throw(MAL, "bpm.delete","NYI");
}

str
BPMreplace(int *ret, int *bid, int *ins, int *del)
{
	BAT *b;
	BPMopen();
	@:getBATdescriptor(bid,b,"bpm.insert")@
	/* replace values */
	(void) b;
	(void) ins;
	(void) del;
	*ret= 0;
	throw(MAL, "bpm.replace","NYI");
}

str
BPMgetNames(int *ret)
{
	BPMopen();
	*ret =0;
	throw(MAL, "bpm.getNames","NYI");
}

str
BPMdiscard(int *ret, int *bid)
{
	BPMopen();
	(void) bid;
	*ret =0;
	throw(MAL, "bpm.discard","NYI");
}
@- Iterations
We start with the large chunk iterator.
The definition of the control statements require the same
control variables, which means that the BATview is accessible
to determine how far to advance when the next chunk is retrieved.
The number of elements in the chunk is limited by the granule
size.
@c
str
BPMnewIteratorBase(int *ret, str *nme)
{
	(void) nme;
	*ret = 0;
	throw(MAL, "bpm.newIterator","NYI");
}

str
BPMhasMoreElementsBase(int *ret, str *nme)
{
	(void) nme;
	*ret = 0;
	throw(MAL, "bpm.hasMoreElements","NYI");
}

@-
Iterations over partitioned BATs can be valued constrainted.
@c
str
BPMnewIterator(int *ret, int *bid)
{
	(void) bid;
	*ret = 0;
	throw(MAL, "bpm.newIterator","NYI");
}

str
BPMnewIteratorRng(int *ret, int *bid, ptr *first, ptr *last)
{
	(void) first;
	(void) last;
	(void) bid;
	*ret = 0;
	throw(MAL, "bpm.newIterator","NYI");
}


str
BPMnewIteratorRng4(int *ret, int *bid, ptr *first, ptr *last,
	ptr *vlow, ptr *vhgh)
{
	(void) first;
	(void) last;
	(void) vlow;
	(void) vhgh;
	(void) bid;
	*ret = 0;
	throw(MAL, "bpm.newIterator","NYI");
}

str
BPMhasMoreElements(int *ret, int *bid)
{
	(void) bid;
	*ret = 0;
	throw(MAL, "bpm.hasMoreElements","NYI");
}

str
BPMhasMoreElementsRng(int *ret, int *bid, ptr *first, ptr *last)
{
	(void) first;
	(void) last;
	(void) bid;
	*ret = 0;
	throw(MAL, "bpm.hasMoreElements","NYI");
}


str
BPMhasMoreElementsRng4(int *ret, int *bid, ptr *first, ptr *last,
	ptr *vlow, ptr *vhgh)
{
	(void) first;
	(void) last;
	(void) vlow;
	(void) vhgh;
	(void) bid;
	*ret = 0;
	throw(MAL, "bpm.hasMoreElements","NYI");
}

str
BPMgetDimension(ptr *first, ptr *last, ptr *vlow, ptr *vhgh, int *bid)
{
	(void) first;
	(void) last;
	(void) vlow;
	(void) vhgh;
	(void) bid;
	throw(MAL, "bpm.getDimension","NYI");
}

str
BPMdump(int *ret)
{
	stream *fd = GDKout;
	ptr p,q;
	BATloop(bpmName,p,q){
		str nme= (str) BUNtail(bpmName,p);
		stream_printf(fd,"[ \"%s\"",nme);
		/* localize partition details */
		stream_printf(fd,"]\n");
	}
	(void) ret;
	throw(MAL, "bpm.dump","NYI");
}
str
BPMdumpAlias(int *ret, int *bid)
{
	(void) ret;
	(void) bid;
	throw(MAL, "bpm.dump","NYI");
}

@c
str
BPMprelude(int *ret)
{
    mal_set_lock(mal_contextLock, "bpm.prelude");
	bpmName= BATdescriptor(BBPindex("bpmName"));
	if( bpmName == NULL){
		/* initialize the bpm catalog */
	}
	*ret =0;
    mal_unset_lock(mal_contextLock, "bpm.prelude");
	return MAL_SUCCEED;
}
@-
In the epilogue phase we should discard any temporary MAT.
@c
str
BPMepilogue(int *ret)
{
	/* TODO: Make sure these are used. This is needed by icc only. And 
	   should be removed once the implementation matures.
	 */
	(void)bpmHeadLow[0];
	(void)bpmHeadHigh[0];
	(void)bpmTailLow[0];
	(void)bpmTailHigh[0];

	*ret =0;
	return MAL_SUCCEED;
}