Convert IEEE decimal parameter values in FbParameter instead of DbValue

Every parameter value reaches DbValue through FbParameter.InternalValue
(FbCommand and FbBatchCommand, sync and async), so Decimal32/64/128 values
are converted to FbDecFloat there. DbValue no longer checks the type of every
value it stores: both clients store decoded row values in DbValue (the managed
client through the constructors, the native client through SetValue), and
those values are never IEEE decimals. DbValue's constructors and SetValue are
back to their previous code.

Adds a batch command test (Decimal64/Decimal128 parameters, bit-exact round
trip), as FbBatchCommand takes the same path.

Author: fdcastel

src/FirebirdSql.Data.FirebirdClient.Tests/FbBatchCommandTests.cs

@@ -66,6 +66,59 @@ public override async Task TearDown()
 		await base.TearDown();
 	}
 
+#if NET11_0_OR_GREATER
+	[Test]
+	public async Task Decimal128AndDecimal64ProperlyInDatabase()
+	{
+		await using (var cmd = Connection.CreateCommand())
+		{
+			cmd.CommandText = "recreate table batch_decfloat (id int, d16 decfloat(16), d34 decfloat(34))";
+			await cmd.ExecuteNonQueryAsync();
+		}
+		try
+		{
+			var d34 = new[] { Decimal128.Parse("1234567890123456789012345678.901234", System.Globalization.CultureInfo.InvariantCulture), Decimal128.Parse("-1.10", System.Globalization.CultureInfo.InvariantCulture) };
+			var d16 = new[] { Decimal64.Parse("1.10", System.Globalization.CultureInfo.InvariantCulture), Decimal64.Parse("-9.999999999999999E+384", System.Globalization.CultureInfo.InvariantCulture) };
+			await using (var cmd = Connection.CreateBatchCommand())
+			{
+				cmd.CommandText = "insert into batch_decfloat values (@id, @d16, @d34)";
+				for (var i = 0; i < d34.Length; i++)
+				{
+					var batch = cmd.AddBatchParameters();
+					batch.Add("id", i);
+					batch.Add("d16", d16[i]);
+					batch.Add("d34", d34[i]);
+				}
+				var result = await cmd.ExecuteNonQueryAsync();
+				Assert.IsTrue(result.AllSuccess);
+			}
+			await using (var cmd = Connection.CreateCommand())
+			{
+				cmd.CommandText = "select d16, d34 from batch_decfloat order by id";
+				await using (var reader = await cmd.ExecuteReaderAsync())
+				{
+					for (var i = 0; i < d34.Length; i++)
+					{
+						Assert.IsTrue(await reader.ReadAsync());
+						// same bits: same value and same exponent
+						Assert.AreEqual(Decimal64.EncodeDecimal(d16[i]), Decimal64.EncodeDecimal(reader.GetFieldValue<Decimal64>(0)));
+						Assert.AreEqual(Decimal128.EncodeDecimal(d34[i]), Decimal128.EncodeDecimal(reader.GetFieldValue<Decimal128>(1)));
+					}
+					Assert.IsFalse(await reader.ReadAsync());
+				}
+			}
+		}
+		finally
+		{
+			await using (var cmd = Connection.CreateCommand())
+			{
+				cmd.CommandText = "drop table batch_decfloat";
+				await cmd.ExecuteNonQueryAsync();
+			}
+		}
+	}
+#endif
+
 	[Test]
 	public async Task DataProperlyInDatabase()
 	{

src/FirebirdSql.Data.FirebirdClient/Common/DbValue.cs

@@ -40,30 +40,14 @@ public DbField Field
 	public DbValue(DbField field, object value)
 	{
 		_field = field;
-		_value = Normalize(value) ?? DBNull.Value;
+		_value = value ?? DBNull.Value;
 	}
 
 	public DbValue(StatementBase statement, DbField field, object value)
 	{
 		_statement = statement;
 		_field = field;
-		_value = Normalize(value) ?? DBNull.Value;
-	}
-
-	// IEEE 754 decimal values are kept as FbDecFloat (exact), so every conversion that handles FbDecFloat handles them too.
-	static object Normalize(object value)
-	{
-#if NET11_0_OR_GREATER
-		return value switch
-		{
-			Decimal128 d => (FbDecFloat)d,
-			Decimal64 d => (FbDecFloat)d,
-			Decimal32 d => (FbDecFloat)d,
-			_ => value,
-		};
-#else
-		return value;
-#endif
+		_value = value ?? DBNull.Value;
 	}
 
 	public bool IsDBNull()
@@ -160,7 +144,7 @@ public async ValueTask<object> GetValueAsync(CancellationToken cancellationToken
 
 	public void SetValue(object value)
 	{
-		_value = Normalize(value);
+		_value = value;
 	}
 
 	public string GetString()

src/FirebirdSql.Data.FirebirdClient/FirebirdClient/FbParameter.cs

@@ -242,6 +242,15 @@ internal object InternalValue
 					var result = new byte[Math.Min(Size, bvalue.Length)];
 					Array.Copy(bvalue, result, result.Length);
 					return result;
+#if NET11_0_OR_GREATER
+				// IEEE 754 decimal values are passed on as FbDecFloat (exact), so every conversion that handles FbDecFloat handles them too.
+				case System.Numerics.Decimal128 d128:
+					return (Types.FbDecFloat)d128;
+				case System.Numerics.Decimal64 d64:
+					return (Types.FbDecFloat)d64;
+				case System.Numerics.Decimal32 d32:
+					return (Types.FbDecFloat)d32;
+#endif
 				default:
 					return _value;
 			}