/*
* Enable incremental packing. The SQL front-end requires
* fixed oid sequences.
*/
str
MATpackIncrement(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr p)
{
bat *ret = getArgReference_bat(stk,p,0);
int pieces;
BAT *b, *bb, *bn;
size_t newsize;
(void) cntxt;
b = BATdescriptor( stk->stk[getArg(p,1)].val.ival);
if ( b == NULL)
throw(MAL, "mat.pack", RUNTIME_OBJECT_MISSING);
if ( getArgType(mb,p,2) == TYPE_int){
/* first step, estimate with some slack */
pieces = stk->stk[getArg(p,2)].val.ival;
bn = BATnew(TYPE_void, b->ttype?b->ttype:TYPE_oid, (BUN)(1.2 * BATcount(b) * pieces), TRANSIENT);
if (bn == NULL)
throw(MAL, "mat.pack", MAL_MALLOC_FAIL);
/* allocate enough space for the vheap, but not for strings,
* since BATappend does clever things for strings */
if ( b->T->vheap && bn->T->vheap && ATOMstorage(b->ttype) != TYPE_str){
newsize = b->T->vheap->size * pieces;
if (HEAPextend(bn->T->vheap, newsize, TRUE) != GDK_SUCCEED)
throw(MAL, "mat.pack", MAL_MALLOC_FAIL);
}
BATseqbase(bn, b->H->seq);
BATseqbase(BATmirror(bn), b->T->seq);
BATappend(bn,b,FALSE);
assert(!bn->H->nil || !bn->H->nonil);
assert(!bn->T->nil || !bn->T->nonil);
bn->H->align = (pieces-1);
BBPkeepref(*ret = bn->batCacheid);
BBPunfix(b->batCacheid);
} else {
/* remaining steps */
bb = BATdescriptor(stk->stk[getArg(p,2)].val.ival);
if ( bb ){
if (BATcount(b) == 0)
BATseqbase(b, bb->H->seq);
if (BATcount(b) == 0)
BATseqbase(BATmirror(b), bb->T->seq);
BATappend(b,bb,FALSE);
}
b->H->align--;
if(b->H->align == 0)
BATsetaccess(b, BAT_READ);
assert(!b->H->nil || !b->H->nonil);
assert(!b->T->nil || !b->T->nonil);
BBPkeepref(*ret = b->batCacheid);
if( bb)
BBPunfix(bb->batCacheid);
}
return MAL_SUCCEED;
}
char *
BKCappend_force_wrap(bat *r, const bat *bid, const bat *uid, const bit *force)
{
BAT *b, *u;
gdk_return ret;
if ((b = BATdescriptor(*bid)) == NULL)
throw(MAL, "bat.append", RUNTIME_OBJECT_MISSING);
if ((u = BATdescriptor(*uid)) == NULL) {
BBPunfix(b->batCacheid);
throw(MAL, "bat.append", RUNTIME_OBJECT_MISSING);
}
if (BATcount(u) == 0) {
ret = GDK_SUCCEED;
} else {
if ((b = setaccess(b, BAT_WRITE)) == NULL)
throw(MAL, "bat.append", OPERATION_FAILED);
ret = BATappend(b, u, *force);
}
BBPunfix(u->batCacheid);
if (ret != GDK_SUCCEED) {
BBPunfix(b->batCacheid);
throw(MAL, "bat.append", GDK_EXCEPTION);
}
if( b->batPersistence == PERSISTENT)
BATmsync(b);
BBPkeepref(*r = b->batCacheid);
return MAL_SUCCEED;
}
/*
* The pack is an ordinary multi BAT insert. Oid synchronistion
* between pieces should be ensured by the code generators.
* The pack operation could be quite expensive, because it
* may create a really large BAT.
* The slice over a mat helps to avoid constructing intermediates
* that are subsequently reduced.
* Contrary to most operations, NIL arguments are skipped and
* do not produce RUNTIME_OBJECT_MISSING.
*/
static str
MATpackInternal(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr p)
{
int i, *ret = (int*) getArgReference(stk,p,0);
BAT *b, *bn;
BUN cap = 0;
int tt = TYPE_any;
(void) cntxt;
(void) mb;
for (i = 1; i < p->argc; i++) {
int bid = stk->stk[getArg(p,i)].val.ival;
b = BBPquickdesc(abs(bid),FALSE);
if (b && bid < 0)
b = BATmirror(b);
if( b ){
assert(BAThdense(b));
if (tt == TYPE_any){
tt = b->ttype;
}
if (!tt && tt != b->ttype)
tt = b->ttype;
cap += BATcount(b);
}
}
if (tt == TYPE_any){
*ret = 0;
return MAL_SUCCEED;
}
bn = BATnew(TYPE_void, tt, cap, TRANSIENT);
if (bn == NULL)
throw(MAL, "mat.pack", MAL_MALLOC_FAIL);
for (i = 1; i < p->argc; i++) {
b = BATdescriptor(stk->stk[getArg(p,i)].val.ival);
if( b ){
if (BATcount(bn) == 0)
BATseqbase(bn, b->H->seq);
if (BATcount(bn) == 0)
BATseqbase(BATmirror(bn), b->T->seq);
BATappend(bn,b,FALSE);
BBPunfix(b->batCacheid);
}
}
assert(!bn->H->nil || !bn->H->nonil);
assert(!bn->T->nil || !bn->T->nonil);
BATsettrivprop(bn);
BATderiveProps(bn,FALSE);
BBPkeepref(*ret = bn->batCacheid);
return MAL_SUCCEED;
}
static str
MATpack2Internal(MalStkPtr stk, InstrPtr p)
{
int i,*ret;
BAT *b, *bn;
BUN cap=0;
b= BATdescriptor(stk->stk[getArg(p,1)].val.ival);
if( b == NULL)
throw(MAL, "mat.pack", RUNTIME_OBJECT_MISSING);
bn = BATcopy(b, b->htype, b->ttype, TRUE, TRANSIENT);
BBPunfix(b->batCacheid);
if( bn == NULL)
throw(MAL, "mat.pack", MAL_MALLOC_FAIL);
for(i = 2; i < p->argc; i++){
b= BATdescriptor(stk->stk[getArg(p,i)].val.ival);
if( b == NULL){
BBPreleaseref(bn->batCacheid);
throw(MAL, "mat.pack", RUNTIME_OBJECT_MISSING);
}
cap += BATcount(b);
BBPunfix(b->batCacheid);
}
bn = BATextend(bn, cap);
if( bn == NULL)
throw(MAL, "mat.pack", RUNTIME_OBJECT_MISSING);
for( i = 2; i < p->argc; i++){
b= BATdescriptor(stk->stk[getArg(p,i)].val.ival);
if( b == NULL){
BBPreleaseref(bn->batCacheid);
throw(MAL, "mat.pack", RUNTIME_OBJECT_MISSING);
}
BATappend(bn,b,FALSE);
BBPunfix(b->batCacheid);
}
ret= (int*) getArgReference(stk,p,0);
BBPkeepref(*ret = bn->batCacheid);
return MAL_SUCCEED;
}
static BAT *
delta_full_bat_( sql_column *c, sql_delta *bat, int temp)
{
/* return full normalized column bat
* b := b.copy()
b := b.append(i);
b := b.replace(u);
*/
BAT *r, *b, *ui, *uv, *i = temp_descriptor(bat->ibid);
int needcopy = 1;
if (!i)
return NULL;
r = i;
if (temp)
return r;
b = temp_descriptor(bat->bid);
if (!b) {
b = i;
} else {
if (BATcount(i)) {
r = COLcopy(b, b->ttype, true, TRANSIENT);
bat_destroy(b);
if (r == NULL) {
bat_destroy(i);
return NULL;
}
b = r;
if (BATappend(b, i, NULL, true) != GDK_SUCCEED) {
bat_destroy(b);
bat_destroy(i);
return NULL;
}
needcopy = 0;
}
bat_destroy(i);
}
if (bat->uibid && bat->ucnt) {
ui = temp_descriptor(bat->uibid);
uv = temp_descriptor(bat->uvbid);
if (ui && BATcount(ui)) {
if (needcopy) {
r = COLcopy(b, b->ttype, true, TRANSIENT);
bat_destroy(b);
b = r;
if(b == NULL) {
bat_destroy(ui);
bat_destroy(uv);
return NULL;
}
}
if (void_replace_bat(b, ui, uv, true) != GDK_SUCCEED) {
bat_destroy(ui);
bat_destroy(uv);
bat_destroy(b);
return NULL;
}
}
bat_destroy(ui);
bat_destroy(uv);
}
(void)c;
if (!store_initialized && !bat->cached)
bat->cached = b;
return b;
}
