/* Create a copy of the type value combination in TPE/S, allocating
* space for external values (non-fixed sized values). See VALcopy
* for a version where the source is in a ValRecord, and see VALset
* for a version where ownership of the source is transferred.
*
* Returns NULL in case of (malloc) failure. */
ValPtr
VALinit(ValPtr d, int tpe, const void *s)
{
switch (ATOMstorage(d->vtype = tpe)) {
case TYPE_void:
d->val.oval = *(const oid *) s;
break;
case TYPE_bte:
d->val.btval = *(const bte *) s;
break;
case TYPE_sht:
d->val.shval = *(const sht *) s;
break;
case TYPE_int:
d->val.ival = *(const int *) s;
break;
case TYPE_flt:
d->val.fval = *(const flt *) s;
break;
case TYPE_dbl:
d->val.dval = *(const dbl *) s;
break;
case TYPE_lng:
d->val.lval = *(const lng *) s;
break;
#ifdef HAVE_HGE
case TYPE_hge:
d->val.hval = *(const hge *) s;
break;
#endif
case TYPE_str:
d->val.sval = GDKstrdup(s);
if (d->val.sval == NULL)
return NULL;
d->len = strLen(s);
break;
case TYPE_ptr:
d->val.pval = *(const ptr *) s;
d->len = ATOMlen(tpe, *(const ptr *) s);
break;
default:
assert(ATOMextern(ATOMstorage(tpe)));
d->len = ATOMlen(tpe, s);
d->val.pval = GDKmalloc(d->len);
if (d->val.pval == NULL)
return NULL;
memcpy(d->val.pval, s, d->len);
break;
}
return d;
}
static void *
column_find_value(sql_trans *tr, sql_column *c, oid rid)
{
BUN q = BUN_NONE;
BAT *b;
void *res = NULL;
b = full_column(tr, c);
if (b) {
if (rid < b->hseqbase || rid >= b->hseqbase + BATcount(b))
q = BUN_NONE;
else
q = rid - b->hseqbase;
}
if (q != BUN_NONE) {
BATiter bi = bat_iterator(b);
const void *r;
size_t sz;
r = BUNtail(bi, q);
sz = ATOMlen(b->ttype, r);
res = GDKmalloc(sz);
if (res)
memcpy(res, r, sz);
}
full_destroy(c, b);
return res;
}
ValPtr
VALcopy(ValPtr d, const ValRecord *s)
{
if (!ATOMextern(s->vtype)) {
*d = *s;
} else if (s->val.pval == 0) {
d->val.pval = ATOMnil(s->vtype);
d->vtype = s->vtype;
} else if (s->vtype == TYPE_str) {
d->vtype = TYPE_str;
d->val.sval = GDKstrdup(s->val.sval);
d->len = strLen(d->val.sval);
} else if (s->vtype == TYPE_bit) {
d->vtype = s->vtype;
d->len = 1;
d->val.btval = s->val.btval;
} else {
ptr p = s->val.pval;
d->vtype = s->vtype;
d->len = ATOMlen(d->vtype, p);
d->val.pval = GDKmalloc(d->len);
memcpy(d->val.pval, p, d->len);
}
return d;
}
static void *
column_find_value(sql_trans *tr, sql_column *c, oid rid)
{
BUN q;
BAT *b, *d = NULL;
void *res = NULL;
sql_dbat *bat = c->t->data;
if (bat->dbid)
d = store_funcs.bind_del(tr, c->t, RDONLY);
b = full_column(c, d, NULL);
if (d)
bat_destroy(d);
q = BUNfnd(b, (ptr) &rid);
if (q != BUN_NONE) {
BATiter bi = bat_iterator(b);
void *r;
int sz;
res = BUNtail(bi, q);
sz = ATOMlen(b->ttype, res);
r = GDKzalloc(sz);
memcpy(r,res,sz);
res = r;
}
bat_destroy(b);
return res;
}
static ValPtr
SA_VALcopy(sql_allocator *sa, ValPtr d, ValPtr s)
{
if (!ATOMextern(s->vtype)) {
*d = *s;
} else if (s->val.pval == 0) {
d->val.pval = ATOMnil(s->vtype);
d->vtype = s->vtype;
} else if (s->vtype == TYPE_str) {
d->vtype = TYPE_str;
d->val.sval = sa_strdup(sa, s->val.sval);
d->len = strLen(d->val.sval);
} else if (s->vtype == TYPE_bit) {
d->vtype = s->vtype;
d->len = 1;
d->val.btval = s->val.btval;
} else {
ptr p = s->val.pval;
d->vtype = s->vtype;
d->len = ATOMlen(d->vtype, p);
d->val.pval = sa_alloc(sa, d->len);
memcpy(d->val.pval, p, d->len);
}
return d;
}
/* Set V to the type/value combination in T/P. Also see VALinit. In
* this version, if P refers to an external type, no new memory is
* allocated, but instead the pointer P is given to V. */
ValPtr
VALset(ValPtr v, int t, ptr p)
{
switch (ATOMstorage(v->vtype = t)) {
case TYPE_void:
v->val.oval = *(oid *) p;
break;
case TYPE_bte:
v->val.btval = *(bte *) p;
break;
case TYPE_sht:
v->val.shval = *(sht *) p;
break;
case TYPE_int:
v->val.ival = *(int *) p;
break;
case TYPE_flt:
v->val.fval = *(flt *) p;
break;
case TYPE_dbl:
v->val.dval = *(dbl *) p;
break;
case TYPE_lng:
v->val.lval = *(lng *) p;
break;
#ifdef HAVE_HGE
case TYPE_hge:
v->val.hval = *(hge *) p;
break;
#endif
case TYPE_str:
v->val.sval = (str) p;
v->len = ATOMlen(t, p);
break;
case TYPE_ptr:
v->val.pval = *(ptr *) p;
v->len = ATOMlen(t, *(ptr *) p);
break;
default:
v->val.pval = p;
v->len = ATOMlen(t, p);
break;
}
return v;
}
ptr
ATOMdup(int t, const void *p)
{
size_t len = ATOMlen(t, p);
ptr n = GDKmalloc(len);
if (n)
memcpy(n, p, len);
return n;
}
ptr
ATOMnil(int t)
{
const void *src = ATOMnilptr(t);
size_t len = ATOMlen(ATOMtype(t), src);
ptr dst = GDKmalloc(len);
if (dst)
memcpy(dst, src, len);
return dst;
}
ValPtr
VALinit(ValPtr d, int tpe, const void *s)
{
if (ATOMextern(tpe) == 0) {
d->vtype = tpe;
memcpy(&d->val.ival, s, ATOMlen(tpe, s));
} else if (s == 0) {
GDKerror("VALinit:unsupported init\n");
d->vtype = TYPE_int;
} else if (tpe >= TYPE_str && ATOMstorage(tpe) == TYPE_str) {
d->vtype = TYPE_str;
d->val.sval = GDKstrdup(s);
d->len = strLen(s);
} else {
d->vtype = tpe;
d->len = ATOMlen(tpe, s);
d->val.pval = GDKmalloc(d->len);
memcpy(d->val.pval, s, d->len);
}
return d;
}
