void VALclear(ValPtr v) { if (v->vtype == TYPE_str || ATOMextern(v->vtype)) { if (v->val.pval && v->val.pval != str_nil) GDKfree(v->val.pval); } VALempty(v); }
/* Clear V to an empty value (type void, value nil), freeing any * memory allocated for external types. See VALempty for when V does * not yet contain a value. */ void VALclear(ValPtr v) { if (ATOMextern(v->vtype)) { if (v->val.pval && v->val.pval != ATOMnilptr(v->vtype)) GDKfree(v->val.pval); } VALempty(v); }
/* 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; }
atom * atom_general(sql_allocator *sa, sql_subtype *tpe, char *val) { atom *a; ptr p = NULL; if (atom_debug) fprintf(stderr, "atom_general(%s,%s)\n", tpe->type->sqlname, val); if (tpe->type->localtype == TYPE_str) return atom_string(sa, tpe, val); a = atom_create(sa); a->tpe = *tpe; a->data.val.pval = NULL; a->data.vtype = tpe->type->localtype; a->data.len = 0; assert(a->data.vtype >= 0); if (val) { int type = a->data.vtype; a->isnull = 0; if (ATOMstorage(type) == TYPE_str) { a->isnull = 0; a->data.val.sval = sql2str(sa_strdup(sa, val)); a->data.len = (int)strlen(a->data.val.sval); } else { int res = ATOMfromstr(type, &p, &a->data.len, val); /* no result or nil means error (SQL has NULL not nil) */ if (res < 0 || !p || ATOMcmp(type, p, ATOMnilptr(type)) == 0) { /*_DELETE(val);*/ if (p) GDKfree(p); return NULL; } VALset(&a->data, a->data.vtype, p); SA_VALcopy(sa, &a->data, &a->data); if (p && ATOMextern(a->data.vtype) == 0) GDKfree(p); /*_DELETE(val);*/ } } else { p = ATOMnilptr(a->data.vtype); VALset(&a->data, a->data.vtype, p); a->isnull = 1; } return a; }
void clearStack(MalStkPtr s) { ValPtr v; int i = s->stktop; for (v = s->stk; i >= 0; i--, v++) if (ATOMextern(v->vtype) && v->val.pval) { GDKfree(v->val.pval); v->vtype = 0; v->val.pval = NULL; } s->stkbot = 0; }
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; }
str MKEYhash(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr p) { wrd *res; ptr val; int tpe = getArgType(mb,p,1); (void) cntxt; res= getArgReference_wrd(stk,p,0); val= getArgReference(stk,p,1); switch (ATOMstorage(tpe)) { case TYPE_bte: *res = MKEYHASH_bte(val); break; case TYPE_sht: *res = MKEYHASH_sht(val); break; case TYPE_int: case TYPE_flt: *res = MKEYHASH_int(val); break; case TYPE_lng: case TYPE_dbl: *res = MKEYHASH_lng(val); break; #ifdef HAVE_HGE case TYPE_hge: *res = MKEYHASH_hge(val); break; #endif default: if (ATOMextern(tpe)) *res = ATOMhash(tpe, *(ptr*)val); else *res = ATOMhash(tpe, val); break; } return MAL_SUCCEED; }
void clearStack(MalStkPtr s) { ValPtr v; int i; if (!s) return; i = s->stktop; for (v = s->stk; i >= 0; i--, v++) if (ATOMextern(v->vtype) && v->val.pval) { GDKfree(v->val.pval); v->vtype = 0; v->val.pval = NULL; } else if (BATatoms[v->vtype].atomUnfix) { BATatoms[v->vtype].atomUnfix(VALget(v)); v->vtype = 0; v->val.pval = NULL; } s->stkbot = 0; }
str str_2_timestamp(timestamp *res, const str *val) { ptr p = NULL; int len = 0; int e; char buf[BUFSIZ]; e = ATOMfromstr(TYPE_timestamp, &p, &len, *val); if (e < 0 || !p || (ATOMcmp(TYPE_timestamp, p, ATOMnilptr(TYPE_timestamp)) == 0 && ATOMcmp(TYPE_str, *val, ATOMnilptr(TYPE_str)) != 0)) { if (p) GDKfree(p); snprintf(buf, BUFSIZ, "conversion of string '%s' failed", *val? *val:""); throw(SQL, "timestamp", "%s", buf); } *res = *(timestamp *) p; if (!ATOMextern(TYPE_timestamp)) { if (p) GDKfree(p); } return MAL_SUCCEED; }