/* * 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; }