tablet.c

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

#line 453 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/mal/tablet.mx"
#include "mal_config.h"
#include "tablet.h"
#include "algebra.h"

#include <string.h>
#include <ctype.h>

#define CLEAR(X) if(X) {GDKfree(X);X = NULL;}
#define isScalar(C)  C->adt != TYPE_bat

tablet_export str TABsetFormat(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
tablet_export str TABheader(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
tablet_export str TABdisplayTable(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
tablet_export str TABdisplayRow(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
tablet_export str TABpage(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
tablet_export str TABsetProperties(int *ret, str *prop);
tablet_export str TABdump(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
tablet_export str TABfinishReport(int *ret);
tablet_export str TABsetStream(int *ret, stream **s);
tablet_export str TABsetPivot(int *ret, int *bid);
tablet_export str TABsetDelimiter(int *ret, str *sep);
tablet_export str TABsetColumn(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci);
tablet_export str TABsetColumnName(int *ret, int *idx, str *s);
tablet_export str TABsetTableBracket(int *ret, str *lbrk, str *rbrk);
tablet_export str TABsetRowBracket(int *ret, str *lbrk, str *rbrk);
tablet_export str TABsetColumnBracket(int *ret, int *idx, str *lbrk, str *rbrk);
tablet_export str TABsetColumnNull(int *ret, int *idx, str *nullstr);
tablet_export str TABsetColumnWidth(int *ret, int *idx, int *width);
tablet_export str TABsetColumnPosition(int *ret, int *idx, int *first, int *width);

tablet_export str TABsetColumnDecimal(int *ret, int *idx, int *scale, int *prec);
tablet_export str TABfirstPage(int *ret);
tablet_export str TABlastPage(int *ret);
tablet_export str TABnextPage(int *ret);
tablet_export str TABprevPage(int *ret);
tablet_export str TABgetPage(int *ret, int *pnr);
tablet_export str TABgetPageCnt(int *ret);
tablet_export str CMDtablet_load(int *ret, int *nameid, int *sepid, int *typeid, str *filename, int *nr);
tablet_export str CMDtablet_dump(int *ret, int *nameid, int *sepid, int *bids, str
*filename, int *nr);
tablet_export str CMDtablet_input(int *ret, int *nameid, int *sepid, int *typeid, stream *s, int *nr);
tablet_export str CMDtablet_output(int *ret, int *nameid, int *sepid, int *bids, void **s);
tablet_export void TABshowHeader(Tablet * t);
tablet_export void TABshowRow(Tablet * t);
tablet_export void TABshowRange(Tablet * t, lng first, lng last);

static void makeTableSpace(int rnr, unsigned int acnt);
static str bindVariable(Tablet * t, unsigned int anr, str nme, int tpe, ptr val, int *k);
static void clearTable(Tablet * t);
static int isScalarVector(Tablet * t);
static int isBATVector(Tablet * t);

static void TABshowPage(Tablet * t);
static int setTabwidth(Column * c);

#define LINE(s, X)     { int n=(int)(X)-1; stream_write(s, "#", 1, 1); while(--n>0) \
	                            stream_write(s, "-", 1, 1); \
	                            stream_printf(s, "#\n"); }
#define TABS(s, X)     { int n=(int)(X); while(n-->0) stream_printf(s, "\t");  }


#line 518 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/mal/tablet.mx"
static int tablet_debug = 0;
static Tablet *tableReports[MAL_MAXCLIENTS];


static void
TABformatPrepare(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
	Client c = MCgetClient();
	int rnr = c - mal_clients;
	Tablet *t;
	int anr = 0, i, tpe, k=0;
	ptr val;

	makeTableSpace(rnr, pci->argc - pci->retc);
	t = tableReports[rnr];
	if (t->rlbrk == 0)
		t->rlbrk = GDKstrdup("[ ");
	if (t->rrbrk == 0)
		t->rrbrk = GDKstrdup("]");
	if (t->sep == 0)
		t->sep = GDKstrdup("\t");
	t->rowwidth = strlen(t->rlbrk) + strlen(t->rrbrk) - 2;

	for (i = pci->retc; i < pci->argc; anr++, i++) {
		/* The type should be taken from the stack ! */
		tpe = stk->stk[pci->argv[i]].vtype;
		val = (ptr) getArgReference(stk, pci, i);
		bindVariable(t, anr, getArgName(mb, pci, i), tpe, val, &k);
	}
	t->nr_attrs = anr;
	t->fd = c->fdout;
	t->pivot = 0;
}

str
TABsetFormat(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
	TABformatPrepare(mb, stk, pci);
	return MAL_SUCCEED;
}

str
TABheader(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
	Client c = MCgetClient();
	int rnr = c - mal_clients;

	TABformatPrepare(mb, stk, pci);
	TABshowHeader(tableReports[rnr]);
	return MAL_SUCCEED;
}

str
TABdisplayTable(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
	Client c = MCgetClient();
	int rnr = c - mal_clients;
	Tablet *t;

	TABheader(mb, stk, pci);
	t = tableReports[rnr];
	if (!isBATVector(t))
		throw(MAL, "tablet.print", "Only aligned BATs expected");
	else {
		t->pageLimit = 20;
		t->firstrow = t->lastrow = 0;
		TABshowPage(t);
	}
	return MAL_SUCCEED;
}

str
TABdisplayRow(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
	Client c = MCgetClient();
	int rnr = c - mal_clients;
	Tablet *t;

	TABheader(mb, stk, pci);
	t = tableReports[rnr];
	if (!isScalarVector(t))
		throw(MAL, "tablet.print", "Only scalars expected");
	else
		TABshowRow(t);
	if (t->tbotbrk == 0) {
		LINE(t->fd, t->rowwidth);
	} else
		stream_write(t->fd, t->tbotbrk, 1, strlen(t->tbotbrk));
	return MAL_SUCCEED;
}

str
TABpage(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
	Client c = MCgetClient();
	int rnr = c - mal_clients;
	Tablet *t;

	TABformatPrepare(mb, stk, pci);
	t = tableReports[rnr];
	if (t->ttopbrk == 0) {
		LINE(t->fd, t->rowwidth);
	} else
		stream_write(t->fd, t->ttopbrk, 1, strlen(t->ttopbrk));
	if (!isBATVector(t))
		throw(MAL, "tablet.print", "Only aligned BATs expected");
	else {
		t->pageLimit = 20;
		t->firstrow = t->lastrow = 0;
		TABshowPage(t);
	}
	return MAL_SUCCEED;
}

str
TABsetProperties(int *ret, str *prop)
{
	Client c = MCgetClient();
	int rnr = c - mal_clients;

	(void) ret;		/* fool compiler */
	if (tableReports[rnr] == 0)
		throw(MAL, "tablet.properties", "Format definition missing");
	CLEAR(tableReports[rnr]->properties);
	tableReports[rnr]->properties = !strNil(*prop) ? GDKstrdup(*prop) : 0;
	return MAL_SUCCEED;
}

str
TABdump(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
	(void) mb;
	(void) stk;
	(void) pci;		/* fool compiler */
	throw(MAL, "tablet.report", "Not yet implemented");
}

str
TABfinishReport(int *ret)
{
	Client c = MCgetClient();
	int rnr = c - mal_clients;

	(void) ret;		/* fool compiler */
	if (tableReports[rnr] == 0)
		throw(MAL, "tablet.finish", "Header information missing");
	clearTable(tableReports[rnr]);
	GDKfree(tableReports[rnr]);
	tableReports[rnr] = 0;
	return MAL_SUCCEED;
}


str
TABsetStream(int *ret, stream **s)
{
	Client c = MCgetClient();
	int rnr = c - mal_clients;

	(void) ret;		/* fool compiler */
	if (tableReports[rnr] == 0)
		throw(MAL, "tablet.setStream", "Header information missing");
	tableReports[rnr]->fd = *s;
	return MAL_SUCCEED;
}

str
TABsetPivot(int *ret, int *bid)
{
	Client c = MCgetClient();
	int rnr = c - mal_clients;
	BAT *b;

	(void) ret;		/* fool compiler */
	if ((b = BATdescriptor(*bid)) == NULL) {
		throw(MAL, "tablet.setPivot", "Pivot BAT missing");
	}

	tableReports[rnr]->pivot = b;
	BBPunfix(b->batCacheid);
	return MAL_SUCCEED;
}

str
TABsetDelimiter(int *ret, str *sep)
{
	Client c = MCgetClient();
	int rnr = c - mal_clients;

	(void) ret;		/* fool compiler */
	if (tableReports[rnr] == 0)
		throw(MAL, "tablet.setDelimiters", "Header information missing");
	tableReports[rnr]->sep = !strNil(*sep) ? GDKstrdup(*sep) : 0;
	return MAL_SUCCEED;
}

str
TABsetColumn(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
	(void) mb;
	(void) stk;
	(void) pci;		/* fool compiler */
	throw(MAL, "tablet.setColumn", "Not yet implemented");
}

str
TABsetColumnName(int *ret, int *idx, str *s)
{
	Client c = MCgetClient();
	int rnr = c - mal_clients;

	(void) ret;		/* fool compiler */
	makeTableSpace(rnr, (*idx >= MAXARG ? *idx : MAXARG));
	tableReports[rnr]->columns[*idx].name = !strNil(*s) ? GDKstrdup(*s) : 0;
	return MAL_SUCCEED;
}

str
TABsetTableBracket(int *ret, str *lbrk, str *rbrk)
{
	Client c = MCgetClient();
	int rnr = c - mal_clients;

	(void) ret;		/* fool compiler */
	makeTableSpace(rnr, MAXARG);
	tableReports[rnr]->ttopbrk = !strNil(*lbrk) ? GDKstrdup(*lbrk) : 0;
	tableReports[rnr]->tbotbrk = !strNil(*rbrk) ? GDKstrdup(*rbrk) : 0;
	return MAL_SUCCEED;
}

str
TABsetRowBracket(int *ret, str *lbrk, str *rbrk)
{
	Client c = MCgetClient();
	int rnr = c - mal_clients;

	(void) ret;		/* fool compiler */
	makeTableSpace(rnr, MAXARG);
	tableReports[rnr]->rlbrk = !strNil(*lbrk) ? GDKstrdup(*lbrk) : 0;
	tableReports[rnr]->rrbrk = !strNil(*rbrk) ? GDKstrdup(*rbrk) : 0;
	return MAL_SUCCEED;
}

str
TABsetColumnBracket(int *ret, int *idx, str *lbrk, str *rbrk)
{
	Client c = MCgetClient();
	int rnr = c - mal_clients;

	(void) ret;		/* fool compiler */
	makeTableSpace(rnr, (*idx >= MAXARG ? *idx : MAXARG));
	tableReports[rnr]->columns[*idx].lbrk = !strNil(*lbrk) ? GDKstrdup(*lbrk) : 0;
	tableReports[rnr]->columns[*idx].rbrk = !strNil(*rbrk) ? GDKstrdup(*rbrk) : 0;
	return MAL_SUCCEED;
}

str
TABsetColumnNull(int *ret, int *idx, str *nullstr)
{
	Client c = MCgetClient();
	int rnr = c - mal_clients;

	(void) ret;		/* fool compiler */
	makeTableSpace(rnr, (*idx >= MAXARG ? *idx : MAXARG));
	tableReports[rnr]->columns[*idx].nullstr = !strNil(*nullstr) ? GDKstrdup(*nullstr) : 0;
	return MAL_SUCCEED;
}

str
TABsetColumnWidth(int *ret, int *idx, int *width)
{
	Client c = MCgetClient();
	int rnr = c - mal_clients;

	(void) ret;		/* fool compiler */
	makeTableSpace(rnr, (*idx >= MAXARG ? *idx : MAXARG));
	tableReports[rnr]->columns[*idx].maxwidth = *width;
	return MAL_SUCCEED;
}

str
TABsetColumnPosition(int *ret, int *idx, int *first, int *width)
{
	Client c = MCgetClient();
	int rnr = c - mal_clients;

	(void) ret;
	(void) first;		/* fool compiler */
	tableReports[rnr]->columns[*idx].fieldwidth = *width;
	tableReports[rnr]->columns[*idx].fieldstart = *width;
	makeTableSpace(rnr, (*idx >= MAXARG ? *idx : MAXARG));
	return MAL_SUCCEED;
}

str
TABsetColumnDecimal(int *ret, int *idx, int *scale, int *prec)
{
	Client c = MCgetClient();
	int rnr = c - mal_clients;

	(void) ret;		/* fool compiler */
	makeTableSpace(rnr, (*idx >= MAXARG ? *idx : MAXARG));
	if (*prec > *scale)
		throw(MAL, "tablet.setColumnDecimal", "Illegal range");
	tableReports[rnr]->columns[*idx].precision = *prec;
	tableReports[rnr]->columns[*idx].scale = *scale;
	return MAL_SUCCEED;
}

str
TABfirstPage(int *ret)
{
	(void) ret;		/* fool compiler */
	throw(MAL, "tablet.firstPage", "Not yet implemented");
}

str
TABlastPage(int *ret)
{
	(void) ret;		/* fool compiler */
	throw(MAL, "tablet.lastPage", "Not yet implemented");
}

str
TABnextPage(int *ret)
{
	(void) ret;		/* fool compiler */
	throw(MAL, "tablet.nextPage", "Not yet implemented");
}

str
TABprevPage(int *ret)
{
	(void) ret;		/* fool compiler */
	throw(MAL, "tablet.prevPage", "Not yet implemented");
}

str
TABgetPage(int *ret, int *pnr)
{
	(void) ret;
	(void) pnr;		/* fool compiler */
	throw(MAL, "tablet.getPage", "Not yet implemented");
}

str
TABgetPageCnt(int *ret)
{
	(void) ret;		/* fool compiler */
	throw(MAL, "tablet.getPageCnt", "Not yet implemented");
}

static ptr
bun_tail(BAT *b, size_t nr)
{
	REGISTER size_t _i = BUNindex((b), BUNfirst((b)));

	return (ptr) BUNtail(b, BUNptr(b, _i + nr));
}


static BAT *
void_bat_create(int adt, size_t nr)
{
	BAT *b = BATnew(TYPE_void, adt, BATTINY);

	/* check for correct structures */
	if (b == NULL)
		return b;
	if (BATmirror(b))
		BATseqbase(b, 0);
	if (nr > (size_t) REMAP_PAGE_MAXSIZE)
        	BATmmap(b, STORE_MMAP, STORE_MMAP, STORE_MMAP);
	if (nr > BATTINY)
		b = BATextend(b, nr);
	return b;
}

static char *
sep_dup(char *sep)
{
	size_t len = strlen(sep);
	char *res = GDKmalloc(len*2 + 1), *result = res;
	char *end = sep + len;

	while (sep < end) {
		if (*sep == '\\') {
			++sep;
			switch (*sep++) {
			case 'r':
				*res++ = '\r';
				break;
			case 'n':
				*res++ = '\n';
				break;
			case 't':
				*res++ = '\t';
				break;
			}
		} else {
			*res++ = *sep++;
		}
	}
	*res = '\0';
	return result;
}


ptr *
TABLETstrFrStr(Column *c, char *s, char *e)
{
	int len = (int) (e - s + 1); /* 64bit: should check for overflow */

	if (c->len < len){
		c->len = len;
		c->data = GDKrealloc(c->data,len); 
	}

	if (s == e) {
		*(char*)c->data = 0;
	} else if (GDKstrFromStr(c->data, (unsigned char *) s, e - s) < 0) {
		return NULL;
	}
	return c->data;
}

ptr *
TABLETadt_frStr(void *extra, int type, char *s, char *e, char quote)
{
	ptr *res = NULL;
	Column *c = extra;

	if (s == NULL || (!(type == TYPE_str && quote) && strcmp(s, "nil") == 0)) {
        	ptr src = ATOMnilptr(type);
        	int len = ATOMlen(ATOMtype(type), src);

		if (c->len < len) {
			c->len = len;
			c->data = GDKrealloc(c->data,len); 
		}
        	memcpy(c->data, src, len);
	} else if (type == TYPE_str) {
		return TABLETstrFrStr(c, s, e);
	} else {
		(void) (*BATatoms[type].atomFromStr) (s, &c->len, (ptr) &c->data);
		res = c->data;
	}
	return res;
}

int
TABLETadt_toStr(void *extra, char **buf, int *len, int type, ptr a)
{
	(void) extra;		/* fool compiler */
	if (type == TYPE_str) {
		char *dst, *src = a;
		int l;

		if (GDK_STRNIL(src)) {
			src = "nil";
		}
		l = strlen(src);
		if (l + 3 > *len) {
			GDKfree(buf);
			*len = 2 * l + 3;
			*buf = GDKmalloc(*len);
			memset(*buf,0,*len);
		}
		dst = *buf;
		dst[0] = '"';
		strncpy(dst + 1, src, l);
		dst[l + 1] = '"';
		dst[l + 2] = 0;
		return l + 2;
	} else {
		return (*BATatoms[type].atomToStr) (buf, len, a);
	}
}

static size_t
create_loadformat(Tablet * as, BAT *names, BAT *seps, BAT *types)
{
	size_t p;
	size_t nr_attrs = BATcount(names);
	Column *fmt = as->format = (Column *) GDKmalloc(sizeof(Column) * (nr_attrs + 1));

	as->offset = 0;
	as->nr_attrs = nr_attrs;
	/* assert(as->nr_attrs == nr_attrs); *//* i.e. it fits */
	for (p = 0; p < nr_attrs; p++) {
		fmt[p].name = (char *) bun_tail(names, p);
		fmt[p].sep = sep_dup((char *) bun_tail(seps, p));
		fmt[p].seplen = (int) strlen(fmt[p].sep);
		fmt[p].type = (char *) bun_tail(types, p);
		fmt[p].adt = ATOMindex(fmt[p].type);
		if (fmt[p].adt < 0) {
			GDKerror("create_loadformat: %s has unknown type %s (using str instead).\n", fmt[p].name, fmt[p].name);
			fmt[p].adt = TYPE_str;
		}
		fmt[p].tostr = &TABLETadt_toStr;
		fmt[p].frstr = &TABLETadt_frStr;
		fmt[p].extra = fmt+p;
		fmt[p].data = NULL;
		fmt[p].len = 0;
		if (tablet_debug)
			stream_printf(GDKerr, "%s\n", fmt[p].name);
	}
	return as->nr_attrs;
}

static
size_t
create_dumpformat(Tablet * as, BAT *names, BAT *seps, BAT *bats)
{
	size_t p;
	size_t nr_attrs = BATcount(bats);
	Column *fmt = as->format = (Column *) GDKmalloc(sizeof(Column) * (nr_attrs + 1));

	as->offset = 0;
	as->nr_attrs = nr_attrs;
	/* assert(as->nr_attrs == nr_attrs); *//* i.e. it fits */
	for (p = 0; p < nr_attrs; p++) {
		BAT *b = (BAT *) BATdescriptor(*(bat *) bun_tail(bats, p));

		if (!b)
			return ~(size_t) 0;	/* (size_t)(-1) */
		fmt[p].name = NULL;
		if (names)
			fmt[p].name = (char *) bun_tail(names, p);
		fmt[p].sep = sep_dup((char *) bun_tail(seps, p));
		fmt[p].seplen = (int) strlen(fmt[p].sep);
		fmt[p].type = ATOMname(b->ttype);
		fmt[p].adt = (b)->ttype;
		fmt[p].tostr = &TABLETadt_toStr;
		fmt[p].frstr = &TABLETadt_frStr;
		fmt[p].extra = fmt+p;
		fmt[p].data = NULL;
		fmt[p].len = 0;
		BBPunfix(b->batCacheid);
	}
	return as->nr_attrs;
}

void
TABLETdestroy_format(Tablet * as)
{
	size_t p;
	Column *fmt = as->format;

	for (p = 0; p < as->nr_attrs; p++) {
		if (fmt[p].c)
			BBPunfix(fmt[p].c->batCacheid);
		GDKfree(fmt[p].sep);
		if (fmt[p].data)
			GDKfree(fmt[p].data);
	}
	GDKfree(fmt);
}

size_t
TABLETassign_BATs(Tablet * as, BAT *bats)
{
	Column *fmt = as->format;
	size_t res = as->nr;
	size_t i;

	for (i = 0; i < as->nr_attrs; i++) {
		BAT *b = (BAT *) BATdescriptor(*(bat *) bun_tail(bats, i));

		fmt[i].c = (b);
		if (res == ~(size_t) 0 || BATcount(fmt[i].c) < res)
			res = BATcount(fmt[i].c);
	}
	as->nr = res;
	return res;
}

static oid
check_BATs(Tablet * as)
{
	Column *fmt = as->format;
	size_t i = 0;
	size_t cnt;
	oid base;

	if (fmt[i].c == NULL)
		i++;
	cnt = BATcount(fmt[i].c);
	base = fmt[i].c->hseqbase;

	if (!BAThdense(fmt[i].c) || as->nr != cnt )
		return oid_nil;

	for (i = 0; i < as->nr_attrs; i++) {
		BAT *b;
		size_t offset;

		b = fmt[i].c;
		if (b == NULL)