Handling CASE expression when one branch is of decimal/numeric and other branch is of smallmoney/money. (babelfish-for-postgresql#3719)

Currently, we treat typmod for smallmoney/money datatype as default which leads to output differences in many cases.

Following are the fixes introduced in this PR :

Introduce typmod handling for smallmoney/money datatype for objects like table/procedure/views/functions/casts and handling their upgrade scenarios.
We are also handling p&s for declared variables, nested case expressions and unions having smallmoney/money as one of it's node.
It also takes case of round vs truncation behaviour around edge cases for fixeddecimal multiplication
Money/smallmoney and Numeric Arithmetic operations - precision and sclae correction and fixing TDS protocol Errors.
T_Param node handling for fixeddecimal dataypes (money and smallmoney) when numeric is another operand.
T_Aggref handling for Sum/Avg for fixeddecimal and other fixed length datatypes when numeric is another operand.
Handing typmod for smallmoney/money in pg catalogs for views metadata and during dump-restore.
Handling money/smallmoney typmod and fixeddecimal typmodin during dump-restore and by-passing typmod while deparsing for ISC check constraint.
Avoiding crashes and wrong results by updating sanity checks and setting intermittent result size appropirately for bigint and fixeddecimal multiplication.
Signed-off-by: Tanya Gupta [email protected]

Engine PR : babelfish-for-postgresql/postgresql_modified_for_babelfish#575

Author: tanyagupta17

contrib/babelfishpg_money/fixeddecimal.c

@@ -35,6 +35,12 @@
  */
 #define FIXEDDECIMAL_MULTIPLIER 10000LL
 
+/*
+ * This ensures that we round up the result in case the 5th decimal place >= 5
+ * in case of fixeddecimal multiplication.
+ */
+#define FIXEDDECIMAL_ROUNDUP 5000
+
 /*
  * Number of decimal places to store.
  * This number should be the number of decimal digits that it takes to
@@ -53,11 +59,9 @@
 
 /*
  * This is bounded by the maximum and minimum values of int64.
- * 9223372036854775807 is 19 decimal digits long, but we we can only represent
- * this number / FIXEDDECIMAL_MULTIPLIER, so we must subtract
- * FIXEDDECIMAL_SCALE
+ * 9223372036854775807 is 19 decimal digits long.
  */
-#define FIXEDDECIMAL_MAX_PRECISION 19 - FIXEDDECIMAL_SCALE
+#define FIXEDDECIMAL_MAX_PRECISION 19
 
 /* Define this if your compiler has _builtin_add_overflow() */
 /* #define HAVE_BUILTIN_OVERFLOW */
@@ -791,14 +795,21 @@ fixeddecimaltypmodin(PG_FUNCTION_ARGS)
 	}
 	else if (n == 1)
 	{
-		if (tl[0] < FIXEDDECIMAL_SCALE || tl[0] > FIXEDDECIMAL_MAX_PRECISION)
+		int val_precision = ((tl[0] - VARHDRSZ) >> 16) & 0xffff;
+		int val_scale = (tl[0] - VARHDRSZ) & 0xffff;
+		if (val_precision < FIXEDDECIMAL_SCALE || val_precision > FIXEDDECIMAL_MAX_PRECISION)
 			ereport(ERROR,
 					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
 					 errmsg("FIXEDDECIMAL precision %d must be between %d and %d",
-							tl[0], FIXEDDECIMAL_SCALE, FIXEDDECIMAL_MAX_PRECISION)));
+							val_precision, FIXEDDECIMAL_SCALE, FIXEDDECIMAL_MAX_PRECISION)));
 
-		/* scale defaults to FIXEDDECIMAL_SCALE */
-		typmod = ((tl[0] << 16) | FIXEDDECIMAL_SCALE) + VARHDRSZ;
+		if (val_scale != FIXEDDECIMAL_SCALE)
+			ereport(ERROR,
+					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+					 errmsg("FIXEDDECIMAL scale must be %d",
+							FIXEDDECIMAL_SCALE)));
+
+		typmod = ((val_precision << 16) | val_scale) + VARHDRSZ;
 	}
 	else
 	{
@@ -1731,6 +1742,10 @@ fixeddecimalmul(PG_FUNCTION_ARGS)
 	 * we must divide the result by this to get the correct result.
 	 */
 	result = (int128) arg1 * arg2 / FIXEDDECIMAL_MULTIPLIER;
+	/* Round off the result to FIXEDDECIMAL_SCALE. */
+	if ((((int128) arg1 * arg2 % FIXEDDECIMAL_MULTIPLIER)) >= FIXEDDECIMAL_ROUNDUP)
+	result++;
+
 
 	if (result != ((int64) result))
 		ereport(ERROR,
@@ -1908,34 +1923,28 @@ fixeddecimalint8mul(PG_FUNCTION_ARGS)
 {
 	int64		arg1 = PG_GETARG_INT64(0);
 	int64		arg2 = PG_GETARG_INT64(1);
-	int64		result;
+	int128		result;
 
 #ifdef HAVE_BUILTIN_OVERFLOW
 	if (__builtin_mul_overflow(arg1, arg2, &result))
 		ereport(ERROR,
 				(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
 				 errmsg("fixeddecimal out of range")));
 #else
-	result = arg1 * arg2;
+	result = (int128) arg1 * arg2;
 
 	/*
-	 * Overflow check.  We basically check to see if result / arg1 gives arg2
-	 * again.  There is one case where this fails: arg1 = 0 (which cannot
-	 * overflow).
-	 *
-	 * Since the division is likely much more expensive than the actual
-	 * multiplication, we'd like to skip it where possible.  The best bang for
-	 * the buck seems to be to check whether both inputs are in the int32
-	 * range; if so, no overflow is possible.
+	 * Overflow check. We should not be testing based only on, if indiviudal arg (agr1)
+	 * is convertible to int32 as the result could still overflow. Hence we directly check
+	 * if result is in int64 range; if so, no overflow is possible.
 	 */
-	if (arg1 != (int64) ((int32) arg1) &&
-		result / arg1 != arg2)
+	if (result != (int128) ((int64) result))
 		ereport(ERROR,
 				(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
 				 errmsg("fixeddecimal out of range")));
 #endif							/* HAVE_BUILTIN_OVERFLOW */
 
-	PG_RETURN_INT64(result);
+	PG_RETURN_INT64((int64) result);
 }
 
 Datum
@@ -2051,34 +2060,28 @@ int8fixeddecimalmul(PG_FUNCTION_ARGS)
 {
 	int64		arg1 = PG_GETARG_INT64(0);
 	int64		arg2 = PG_GETARG_INT64(1);
-	int64		result;
+	int128		result;
 
 #ifdef HAVE_BUILTIN_OVERFLOW
 	if (__builtin_mul_overflow(arg1, arg2, &result))
 		ereport(ERROR,
 				(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
 				 errmsg("fixeddecimal out of range")));
 #else
-	result = arg1 * arg2;
+	result = (int128) arg1 * arg2;
 
 	/*
-	 * Overflow check.  We basically check to see if result / arg2 gives arg1
-	 * again.  There is one case where this fails: arg2 = 0 (which cannot
-	 * overflow).
-	 *
-	 * Since the division is likely much more expensive than the actual
-	 * multiplication, we'd like to skip it where possible.  The best bang for
-	 * the buck seems to be to check whether both inputs are in the int32
-	 * range; if so, no overflow is possible.
+	 * Overflow check. We should not be testing based only on, if indiviudal arg (agr2)
+	 * is convertible to int32 as the result could still overflow. Hence we directly check
+	 * if result is in int64 range; if so, no overflow is possible.
 	 */
-	if (arg2 != (int64) ((int32) arg2) &&
-		result / arg2 != arg1)
+	if (result != (int128) ((int64) result))
 		ereport(ERROR,
 				(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
 				 errmsg("fixeddecimal out of range")));
 #endif							/* HAVE_BUILTIN_OVERFLOW */
 
-	PG_RETURN_INT64(result);
+	PG_RETURN_INT64((int64) result);
 }
 
 Datum

contrib/babelfishpg_tsql/sql/sys_views.sql

@@ -169,6 +169,8 @@ BEGIN
 	CASE v_type 
 	WHEN 'decimal' THEN scale = (typemod - 4) & 65535;
 	WHEN 'numeric' THEN scale = (typemod - 4) & 65535;
+	WHEN 'money' THEN scale = 4;
+	WHEN 'smallmoney' THEN scale = 4;
 	WHEN 'smalldatetime' THEN scale = 0;
 	WHEN 'datetime2' THEN
 		CASE typemod 
@@ -256,6 +258,8 @@ BEGIN
 	CASE v_type
 	WHEN 'numeric' THEN precision = ((typemod - 4) >> 16) & 65535;
 	WHEN 'decimal' THEN precision = ((typemod - 4) >> 16) & 65535;
+	WHEN 'money' THEN precision = 19;
+	WHEN 'smallmoney' THEN precision = 10;
 	WHEN 'smalldatetime' THEN precision = 16;
 	WHEN 'datetime2' THEN 
 		CASE typemod