fix: cast money columns to numeric (#5705)

[TML-1657](https://linear.app/prisma-company/issue/TML-1657/fix-dbmoney-parsing-issues)

Parsing money values returned from Postgres is incredibly complicated
due to it being dependent on locale and accepting a huge number of
formats. There's an easy trick to avoid all of that: do what we do for
enums and cast all money columns to `numeric`. This also allows us to
implement it once for both relationJoins and non-relationJoins code and
it conforms to our old behavior of always just returning the plain
number, while keeping the implementation simple.

Fixes prisma/prisma#27570

Author: jacek-prisma

quaint/src/visitor/postgres.rs

@@ -151,6 +151,8 @@ impl<'a> Visitor<'a> for Postgres<'a> {
 
     /// A database column identifier
     fn visit_column(&mut self, column: Column<'a>) -> visitor::Result {
+        let cast_target = get_column_cast_target(&column);
+
         match column.table {
             Some(table) => {
                 self.visit_table(table, false)?;
@@ -160,11 +162,11 @@ impl<'a> Visitor<'a> for Postgres<'a> {
             _ => self.delimited_identifiers(&[&*column.name])?,
         };
 
-        if column.is_enum && column.is_selected {
+        if let Some(cast) = cast_target {
+            self.write("::")?;
+            self.write(cast)?;
             if column.is_list {
-                self.write("::text[]")?;
-            } else {
-                self.write("::text")?;
+                self.write("[]")?;
             }
         }
 
@@ -739,27 +741,29 @@ impl<'a> Visitor<'a> for Postgres<'a> {
 
     fn visit_min(&mut self, min: Minimum<'a>) -> visitor::Result {
         // If the inner column is a selected enum, then we cast the result of MIN(enum)::text instead of casting the inner enum column, which changes the behavior of MIN.
-        let should_cast = min.column.is_enum && min.column.is_selected;
+        let cast_target = get_column_cast_target(&min.column);
 
         self.write("MIN")?;
         self.surround_with("(", ")", |ref mut s| s.visit_column(min.column.set_is_selected(false)))?;
 
-        if should_cast {
-            self.write("::text")?;
+        if let Some(cast_target) = cast_target {
+            self.write("::")?;
+            self.write(cast_target)?;
         }
 
         Ok(())
     }
 
     fn visit_max(&mut self, max: Maximum<'a>) -> visitor::Result {
         // If the inner column is a selected enum, then we cast the result of MAX(enum)::text instead of casting the inner enum column, which changes the behavior of MAX.
-        let should_cast = max.column.is_enum && max.column.is_selected;
+        let cast_target = get_column_cast_target(&max.column);
 
         self.write("MAX")?;
         self.surround_with("(", ")", |ref mut s| s.visit_column(max.column.set_is_selected(false)))?;
 
-        if should_cast {
-            self.write("::text")?;
+        if let Some(cast_target) = cast_target {
+            self.write("::")?;
+            self.write(cast_target)?;
         }
 
         Ok(())
@@ -785,6 +789,20 @@ impl<'a> Visitor<'a> for Postgres<'a> {
     }
 }
 
+fn get_column_cast_target(column: &Column<'_>) -> Option<&'static str> {
+    if !column.is_selected {
+        return None;
+    }
+
+    if column.is_enum {
+        Some("text")
+    } else if column.native_type.as_deref() == Some("MONEY") || column.native_type.as_deref() == Some("MONEY[]") {
+        Some("numeric")
+    } else {
+        None
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use crate::visitor::*;

query-engine/connector-test-kit-rs/query-engine-tests/tests/queries/data_types/native/postgres.rs

@@ -134,6 +134,37 @@ mod postgres_decimal {
     }
 }
 
+#[test_suite(only(Postgres))]
+mod postgres_money {
+    fn schema_decimal() -> String {
+        let schema = indoc! {
+            r#"
+            model Table {
+              #id(id, Int, @id)
+
+              money     Decimal   @test.Money
+              moneyList Decimal[] @test.Money
+            }"#
+        };
+
+        schema.to_owned()
+    }
+
+    #[connector_test(schema(schema_decimal))]
+    async fn native_money_type(runner: Runner) -> TestResult<()> {
+        runner.raw_execute(
+            r#"INSERT INTO "Table" ("id", "money", "moneyList") VALUES (1, '$300,000.52', array['$100,000.00', '$200.25']::money[]);"#,
+        ).await?;
+
+        insta::assert_snapshot!(
+          run_query!(&runner, r#"{ findManyTable { id money moneyList } }"#),
+          @r###"{"data":{"findManyTable":[{"id":1,"money":"300000.52","moneyList":["100000","200.25"]}]}}"###
+        );
+
+        Ok(())
+    }
+}
+
 #[test_suite(only(Postgres))]
 mod postgres_string {
     fn schema_string() -> String {