Changeset: 68e5327f51d1 for MonetDB URL: https://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=68e5327f51d1 Modified Files: gdk/gdk_join.c sql/backends/monet5/sql_fround_impl.h sql/backends/monet5/sql_round_impl.h Branch: default Log Message:
Merged with Oct2020 diffs (truncated from 705 to 300 lines): diff --git a/gdk/gdk_calc.c b/gdk/gdk_calc.c --- a/gdk/gdk_calc.c +++ b/gdk/gdk_calc.c @@ -66,6 +66,23 @@ checkbats(BAT *b1, BAT *b2, const char * return GDK_SUCCEED; } +#define ON_OVERFLOW1(TYPE, OP) \ + do { \ + GDKerror("22003!overflow in calculation " \ + OP "(" FMT##TYPE ").\n", \ + CST##TYPE src[x]); \ + BBPreclaim(bn); \ + return NULL; \ + } while (0) + +#define ON_OVERFLOW(TYPE1, TYPE2, OP) \ + do { \ + GDKerror("22003!overflow in calculation " \ + FMT##TYPE1 OP FMT##TYPE2 ".\n", \ + CST##TYPE1 ((TYPE1 *)lft)[i], CST##TYPE2 ((TYPE2 *)rgt)[j]); \ + return BUN_NONE; \ + } while (0) + #define UNARY_2TYPE_FUNC(TYPE1, TYPE2, FUNC) \ do { \ const TYPE1 *restrict src = (const TYPE1 *) Tloc(b, 0); \ @@ -81,6 +98,24 @@ checkbats(BAT *b1, BAT *b2, const char * } \ } while (0) +#define UNARY_2TYPE_FUNC_nilcheck(TYPE1, TYPE2, FUNC, on_overflow) \ + do { \ + const TYPE1 *restrict src = (const TYPE1 *) Tloc(b, 0); \ + TYPE2 *restrict dst = (TYPE2 *) Tloc(bn, 0); \ + for (i = 0; i < ci.ncand; i++) { \ + x = canditer_next(&ci) - b->hseqbase; \ + if (is_##TYPE1##_nil(src[x])) { \ + nils++; \ + dst[i] = TYPE2##_nil; \ + } else { \ + dst[i] = FUNC(src[x]); \ + if (is_##TYPE2##_nil(dst[i])) { \ + on_overflow; \ + } \ + } \ + } \ + } while (0) + #define BINARY_3TYPE_FUNC(TYPE1, TYPE2, TYPE3, FUNC) \ do { \ i = j = 0; \ @@ -117,6 +152,46 @@ checkbats(BAT *b1, BAT *b2, const char * } \ } while (0) +#define BINARY_3TYPE_FUNC_nilcheck(TYPE1, TYPE2, TYPE3, FUNC, on_overflow) \ + do { \ + i = j = 0; \ + if (ci1->tpe == cand_dense && ci2->tpe == cand_dense) { \ + for (k = 0; k < ci1->ncand; k++) { \ + if (incr1) \ + i = canditer_next_dense(ci1) - candoff1; \ + if (incr2) \ + j = canditer_next_dense(ci2) - candoff2; \ + TYPE1 v1 = ((const TYPE1 *) lft)[i]; \ + TYPE2 v2 = ((const TYPE2 *) rgt)[j]; \ + if (is_##TYPE1##_nil(v1) || is_##TYPE2##_nil(v2)) { \ + nils++; \ + ((TYPE3 *) dst)[k] = TYPE3##_nil; \ + } else { \ + ((TYPE3 *) dst)[k] = FUNC(v1, v2); \ + if (is_##TYPE3##_nil(((TYPE3 *) dst)[k])) \ + on_overflow; \ + } \ + } \ + } else { \ + for (k = 0; k < ci1->ncand; k++) { \ + if (incr1) \ + i = canditer_next(ci1) - candoff1; \ + if (incr2) \ + j = canditer_next(ci2) - candoff2; \ + TYPE1 v1 = ((const TYPE1 *) lft)[i]; \ + TYPE2 v2 = ((const TYPE2 *) rgt)[j]; \ + if (is_##TYPE1##_nil(v1) || is_##TYPE2##_nil(v2)) { \ + nils++; \ + ((TYPE3 *) dst)[k] = TYPE3##_nil; \ + } else { \ + ((TYPE3 *) dst)[k] = FUNC(v1, v2); \ + if (is_##TYPE3##_nil(((TYPE3 *) dst)[k])) \ + on_overflow; \ + } \ + } \ + } \ + } while (0) + /* special case for EQ and NE where we have a nil_matches flag for * when it is set */ #define BINARY_3TYPE_FUNC_nilmatch(TYPE1, TYPE2, TYPE3, FUNC) \ @@ -179,6 +254,36 @@ checkbats(BAT *b1, BAT *b2, const char * } \ } while (0) +#define BINARY_3TYPE_FUNC_nonil_nilcheck(TYPE1, TYPE2, TYPE3, FUNC, on_overflow) \ + do { \ + i = j = 0; \ + if (ci1->tpe == cand_dense && ci2->tpe == cand_dense) { \ + for (k = 0; k < ci1->ncand; k++) { \ + if (incr1) \ + i = canditer_next_dense(ci1) - candoff1; \ + if (incr2) \ + j = canditer_next_dense(ci2) - candoff2; \ + TYPE1 v1 = ((const TYPE1 *) lft)[i]; \ + TYPE2 v2 = ((const TYPE2 *) rgt)[j]; \ + ((TYPE3 *) dst)[k] = FUNC(v1, v2); \ + if (is_##TYPE3##_nil(((TYPE3 *) dst)[k])) \ + on_overflow; \ + } \ + } else { \ + for (k = 0; k < ci1->ncand; k++) { \ + if (incr1) \ + i = canditer_next(ci1) - candoff1; \ + if (incr2) \ + j = canditer_next(ci2) - candoff2; \ + TYPE1 v1 = ((const TYPE1 *) lft)[i]; \ + TYPE2 v2 = ((const TYPE2 *) rgt)[j]; \ + ((TYPE3 *) dst)[k] = FUNC(v1, v2); \ + if (is_##TYPE3##_nil(((TYPE3 *) dst)[k])) \ + on_overflow; \ + } \ + } \ + } while (0) + #define BINARY_3TYPE_FUNC_CHECK(TYPE1, TYPE2, TYPE3, FUNC, CHECK) \ do { \ i = j = 0; \ @@ -270,21 +375,21 @@ BATcalcnot(BAT *b, BAT *s) if (b->ttype == TYPE_bit) { UNARY_2TYPE_FUNC(bit, bit, NOTBIT); } else { - UNARY_2TYPE_FUNC(bte, bte, NOT); + UNARY_2TYPE_FUNC_nilcheck(bte, bte, NOT, ON_OVERFLOW1(bte, "NOT")); } break; case TYPE_sht: - UNARY_2TYPE_FUNC(sht, sht, NOT); + UNARY_2TYPE_FUNC_nilcheck(sht, sht, NOT, ON_OVERFLOW1(sht, "NOT")); break; case TYPE_int: - UNARY_2TYPE_FUNC(int, int, NOT); + UNARY_2TYPE_FUNC_nilcheck(int, int, NOT, ON_OVERFLOW1(int, "NOT")); break; case TYPE_lng: - UNARY_2TYPE_FUNC(lng, lng, NOT); + UNARY_2TYPE_FUNC_nilcheck(lng, lng, NOT, ON_OVERFLOW1(lng, "NOT")); break; #ifdef HAVE_HGE case TYPE_hge: - UNARY_2TYPE_FUNC(hge, hge, NOT); + UNARY_2TYPE_FUNC_nilcheck(hge, hge, NOT, ON_OVERFLOW1(hge, "NOT")); break; #endif default: @@ -320,33 +425,64 @@ VARcalcnot(ValPtr ret, const ValRecord * ret->val.btval = bit_nil; else if (v->vtype == TYPE_bit) ret->val.btval = !v->val.btval; - else + else { ret->val.btval = ~v->val.btval; + if (is_bte_nil(ret->val.btval)) { + GDKerror("22003!overflow in calculation " + "NOT(" FMTbte ").\n", v->val.btval); + return GDK_FAIL; + } + } break; case TYPE_sht: if (is_sht_nil(v->val.shval)) ret->val.shval = sht_nil; - else + else { ret->val.shval = ~v->val.shval; + if (is_sht_nil(ret->val.shval)) { + GDKerror("22003!overflow in calculation " + "NOT(" FMTsht ").\n", v->val.shval); + return GDK_FAIL; + } + } break; case TYPE_int: if (is_int_nil(v->val.ival)) ret->val.ival = int_nil; - else + else { ret->val.ival = ~v->val.ival; + if (is_int_nil(ret->val.ival)) { + GDKerror("22003!overflow in calculation " + "NOT(" FMTint ").\n", v->val.ival); + return GDK_FAIL; + } + } break; case TYPE_lng: if (is_lng_nil(v->val.lval)) ret->val.lval = lng_nil; - else + else { ret->val.lval = ~v->val.lval; + if (is_lng_nil(ret->val.lval)) { + GDKerror("22003!overflow in calculation " + "NOT(" FMTlng ").\n", v->val.lval); + return GDK_FAIL; + } + } break; #ifdef HAVE_HGE case TYPE_hge: if (is_hge_nil(v->val.hval)) ret->val.hval = hge_nil; - else + else { ret->val.hval = ~v->val.hval; + if (is_hge_nil(ret->val.hval)) { + GDKerror("22003!overflow in calculation " + "NOT(" FMThge ").\n", + CSThge v->val.hval); + return GDK_FAIL; + } + } break; #endif default: @@ -1694,14 +1830,6 @@ BATcalccstmax_no_nil(const ValRecord *v, /* ---------------------------------------------------------------------- */ /* addition (any numeric type) */ -#define ON_OVERFLOW(TYPE1, TYPE2, OP) \ - do { \ - GDKerror("22003!overflow in calculation " \ - FMT##TYPE1 OP FMT##TYPE2 ".\n", \ - CST##TYPE1 lft[i], CST##TYPE2 rgt[j]); \ - return BUN_NONE; \ - } while (0) - #define ADD_3TYPE(TYPE1, TYPE2, TYPE3, IF) \ static BUN \ add_##TYPE1##_##TYPE2##_##TYPE3(const TYPE1 *lft, bool incr1, \ @@ -11483,35 +11611,35 @@ xor_typeswitchloop(const void *lft, bool BINARY_3TYPE_FUNC(bit, bit, bit, XORBIT); } else { if (nonil) - BINARY_3TYPE_FUNC_nonil(bte, bte, bte, XOR); + BINARY_3TYPE_FUNC_nonil_nilcheck(bte, bte, bte, XOR, ON_OVERFLOW(bte, bte, "XOR")); else - BINARY_3TYPE_FUNC(bte, bte, bte, XOR); + BINARY_3TYPE_FUNC_nilcheck(bte, bte, bte, XOR, ON_OVERFLOW(bte, bte, "XOR")); } break; case TYPE_sht: if (nonil) - BINARY_3TYPE_FUNC_nonil(sht, sht, sht, XOR); + BINARY_3TYPE_FUNC_nonil_nilcheck(sht, sht, sht, XOR, ON_OVERFLOW(sht, sht, "XOR")); else - BINARY_3TYPE_FUNC(sht, sht, sht, XOR); + BINARY_3TYPE_FUNC_nilcheck(sht, sht, sht, XOR, ON_OVERFLOW(sht, sht, "XOR")); break; case TYPE_int: if (nonil) - BINARY_3TYPE_FUNC_nonil(int, int, int, XOR); + BINARY_3TYPE_FUNC_nonil_nilcheck(int, int, int, XOR, ON_OVERFLOW(int, int, "XOR")); else - BINARY_3TYPE_FUNC(int, int, int, XOR); + BINARY_3TYPE_FUNC_nilcheck(int, int, int, XOR, ON_OVERFLOW(int, int, "XOR")); break; case TYPE_lng: if (nonil) - BINARY_3TYPE_FUNC_nonil(lng, lng, lng, XOR); + BINARY_3TYPE_FUNC_nonil_nilcheck(lng, lng, lng, XOR, ON_OVERFLOW(lng, lng, "XOR")); else - BINARY_3TYPE_FUNC(lng, lng, lng, XOR); + BINARY_3TYPE_FUNC_nilcheck(lng, lng, lng, XOR, ON_OVERFLOW(lng, lng, "XOR")); break; #ifdef HAVE_HGE case TYPE_hge: if (nonil) - BINARY_3TYPE_FUNC_nonil(hge, hge, hge, XOR); + BINARY_3TYPE_FUNC_nonil_nilcheck(hge, hge, hge, XOR, ON_OVERFLOW(hge, hge, "XOR")); else - BINARY_3TYPE_FUNC(hge, hge, hge, XOR); + BINARY_3TYPE_FUNC_nilcheck(hge, hge, hge, XOR, ON_OVERFLOW(hge, hge, "XOR")); break; #endif default: @@ -11685,6 +11813,11 @@ or_typeswitchloop(const void *lft, bool BUN i = 0, j = 0, k; BUN nils = 0; + /* note, we don't have to check whether the result is equal to + * NIL when using bitwise OR: there is only a single bit set in _______________________________________________ checkin-list mailing list checkin-list@monetdb.org https://www.monetdb.org/mailman/listinfo/checkin-list