Late night float fun (prisma#249)

Fixes all kinds of small conversion errors on PostgreSQL numeric, real
and float types.

Author: Julius de Bruijn

src/connector/postgres/conversion.rs

@@ -499,12 +499,29 @@ impl<'a> ToSql for Value<'a> {
         let res = match (self, ty) {
             (Value::Integer(integer), &PostgresType::INT2) => integer.map(|integer| (integer as i16).to_sql(ty, out)),
             (Value::Integer(integer), &PostgresType::INT4) => integer.map(|integer| (integer as i32).to_sql(ty, out)),
+            #[cfg(feature = "bigdecimal")]
+            (Value::Integer(integer), &PostgresType::NUMERIC) => integer
+                .map(|integer| BigDecimal::from_i64(integer).unwrap())
+                .map(|bd| DecimalWrapper(bd))
+                .map(|dw| dw.to_sql(ty, out)),
             (Value::Integer(integer), &PostgresType::TEXT) => {
                 integer.map(|integer| format!("{}", integer).to_sql(ty, out))
             }
             (Value::Integer(integer), &PostgresType::OID) => integer.map(|integer| (integer as u32).to_sql(ty, out)),
             (Value::Integer(integer), _) => integer.map(|integer| (integer as i64).to_sql(ty, out)),
+            (Value::Float(float), &PostgresType::FLOAT8) => float.map(|float| (float as f64).to_sql(ty, out)),
+            #[cfg(feature = "bigdecimal")]
+            (Value::Float(float), &PostgresType::NUMERIC) => float
+                .map(|float| BigDecimal::from_f32(float).unwrap())
+                .map(DecimalWrapper)
+                .map(|dw| dw.to_sql(ty, out)),
             (Value::Float(float), _) => float.map(|float| float.to_sql(ty, out)),
+            (Value::Double(double), &PostgresType::FLOAT4) => double.map(|double| (double as f32).to_sql(ty, out)),
+            #[cfg(feature = "bigdecimal")]
+            (Value::Double(double), &PostgresType::NUMERIC) => double
+                .map(|double| BigDecimal::from_f64(double).unwrap())
+                .map(DecimalWrapper)
+                .map(|dw| dw.to_sql(ty, out)),
             (Value::Double(double), _) => double.map(|double| double.to_sql(ty, out)),
             #[cfg(feature = "bigdecimal")]
             (Value::Numeric(decimal), &PostgresType::FLOAT4) => decimal.as_ref().map(|decimal| {

src/tests/query.rs

@@ -502,7 +502,7 @@ async fn single_default_value_insert(api: &mut dyn TestApi) -> crate::Result<()>
 }
 
 #[cfg(any(feature = "mssql", feature = "postgresql"))]
-#[test_each_connector(tags("mssql", "postgres"))]
+#[test_each_connector(tags("mssql", "postgresql"))]
 async fn returning_insert(api: &mut dyn TestApi) -> crate::Result<()> {
     let table = api.create_table("id int, name varchar(255)").await?;
     let insert = Insert::single_into(&table).value("id", 2).value("name", "Naukio");
@@ -647,7 +647,7 @@ async fn single_insert_conflict_do_nothing_single_unique_with_autogen_default(
 }
 
 #[cfg(any(feature = "mssql", feature = "postgresql"))]
-#[test_each_connector(tags("postgres", "mssql"))]
+#[test_each_connector(tags("postgresql", "mssql"))]
 async fn single_insert_conflict_do_nothing_with_returning(api: &mut dyn TestApi) -> crate::Result<()> {
     let constraint = api.unique_constraint("id");
 
@@ -1073,7 +1073,7 @@ async fn unsigned_integers_are_handled(api: &mut dyn TestApi) -> crate::Result<(
 }
 
 #[cfg(feature = "json")]
-#[test_each_connector(tags("mysql", "postgres"))]
+#[test_each_connector(tags("mysql", "postgresql"))]
 async fn json_filtering_works(api: &mut dyn TestApi) -> crate::Result<()> {
     let json_type = match api.system() {
         "postgres" => "jsonb",
@@ -1117,7 +1117,7 @@ async fn json_filtering_works(api: &mut dyn TestApi) -> crate::Result<()> {
     Ok(())
 }
 
-#[test_each_connector(tags("mssql", "postgres"))]
+#[test_each_connector(tags("mssql", "postgresql"))]
 async fn xml_filtering_works(api: &mut dyn TestApi) -> crate::Result<()> {
     let table = api
         .create_table(&format!("{}, xmlfield {}", api.autogen_id("id"), "xml"))
@@ -1306,14 +1306,14 @@ async fn op_test_div_one_level(api: &mut dyn TestApi) -> crate::Result<()> {
     let row = api.conn().select(q).await?.into_single()?;
 
     match api.system() {
-        "mssql" => assert_eq!(Some(2.0), row[0].as_f32()),
+        "mssql" | "postgres" => assert_eq!(Some(2.0), row[0].as_f32()),
         _ => assert_eq!(Some(2.0), row[0].as_f64()),
     }
 
     Ok(())
 }
 
-#[test_each_connector(tags("postgres"))]
+#[test_each_connector(tags("postgresql"))]
 async fn enum_values(api: &mut dyn TestApi) -> crate::Result<()> {
     let type_name = api.get_name();
     let create_type = format!("CREATE TYPE {} AS ENUM ('A', 'B')", &type_name);
@@ -1615,3 +1615,32 @@ async fn insert_default_keyword(api: &mut dyn TestApi) -> crate::Result<()> {
 
     Ok(())
 }
+
+#[cfg(feature = "bigdecimal")]
+#[test_each_connector(tags("postgresql"))]
+async fn ints_read_write_to_numeric(api: &mut dyn TestApi) -> crate::Result<()> {
+    use bigdecimal::BigDecimal;
+    use std::str::FromStr;
+
+    let table = api.create_table("id int, value numeric(12,2)").await?;
+
+    let insert = Insert::multi_into(&table, &["id", "value"])
+        .values(vec![Value::integer(1), Value::double(1234.5)])
+        .values(vec![Value::integer(2), Value::integer(1234)])
+        .values(vec![Value::integer(3), Value::integer(12345)]);
+
+    api.conn().execute(insert.into()).await?;
+
+    let select = Select::from_table(&table);
+    let rows = api.conn().select(select).await?;
+
+    for (i, row) in rows.into_iter().enumerate() {
+        match i {
+            0 => assert_eq!(Value::numeric(BigDecimal::from_str("1234.5").unwrap()), row["value"]),
+            1 => assert_eq!(Value::numeric(BigDecimal::from_str("1234.0").unwrap()), row["value"]),
+            _ => assert_eq!(Value::numeric(BigDecimal::from_str("12345.0").unwrap()), row["value"]),
+        }
+    }
+
+    Ok(())
+}

src/tests/query/error.rs

@@ -173,7 +173,7 @@ async fn bigint_unsigned_positive_value_out_of_range(api: &mut dyn TestApi) -> c
     Ok(())
 }
 
-#[test_each_connector(tags("mysql", "mssql", "postgres"))]
+#[test_each_connector(tags("mysql", "mssql", "postgresql"))]
 async fn length_mismatch(api: &mut dyn TestApi) -> crate::Result<()> {
     let table = api.create_table("value varchar(3)").await?;
     let insert = Insert::single_into(&table).value("value", "fooo");
@@ -187,7 +187,7 @@ async fn length_mismatch(api: &mut dyn TestApi) -> crate::Result<()> {
     Ok(())
 }
 
-#[test_each_connector(tags("postgres", "sqlite"))]
+#[test_each_connector(tags("postgresql", "sqlite"))]
 async fn foreign_key_constraint_violation(api: &mut dyn TestApi) -> crate::Result<()> {
     let parent = api.create_table("id smallint not null primary key").await?;
     let foreign_key = api.foreign_key(&parent, "id", "parent_id");

src/tests/test_api/postgres.rs

@@ -6,7 +6,7 @@ use std::env;
 
 pub static CONN_STR: Lazy<String> = Lazy::new(|| env::var("TEST_PSQL").expect("TEST_PSQL env var"));
 
-pub(crate) async fn postgres_test_api<'a>() -> crate::Result<PostgreSql<'a>> {
+pub(crate) async fn postgresql_test_api<'a>() -> crate::Result<PostgreSql<'a>> {
     PostgreSql::new().await
 }