fix: correct PostgreSQL casts and partial index arity

Signed-off-by: Alexey Orlenko's AI Agent <robot@aqrln.net>

Author: tensordreams

psl/parser-database/src/attributes.rs

@@ -640,16 +640,16 @@ fn parse_where_clause(model_id: crate::ModelId, ctx: &mut Context<'_>) -> Option
 
 /// Parse raw("...") where clause.
 fn parse_raw_where_clause(args: &[ast::Argument], ctx: &mut Context<'_>) -> Option<WhereClause> {
-    let Some(first_arg) = args.first() else {
+    let [arg] = args else {
         ctx.push_attribute_validation_error(
-            "The `where` argument must be a raw() function with a string argument, e.g. `where: raw(\"status = 'active'\")`.",
+            "The `where` argument must be a raw() function with exactly one string argument, e.g. `where: raw(\"status = 'active'\")`.",
         );
         return None;
     };
 
-    let Some(predicate) = coerce::string(&first_arg.value, ctx.diagnostics) else {
+    let Some(predicate) = coerce::string(&arg.value, ctx.diagnostics) else {
         ctx.push_attribute_validation_error(
-            "The `where` argument must be a raw() function with a string argument, e.g. `where: raw(\"status = 'active'\")`.",
+            "The `where` argument must be a raw() function with exactly one string argument, e.g. `where: raw(\"status = 'active'\")`.",
         );
         return None;
     };

psl/psl/tests/attributes/partial_index.rs

@@ -166,7 +166,7 @@ fn partial_index_raw_requires_string_argument() {
 
     let err = parse_unwrap_err(&with_header(dml, Provider::Postgres, &["partialIndexes"]));
     let expected = expect![[r#"
-        [1;91merror[0m: [1mError parsing attribute "@unique": The `where` argument must be a raw() function with a string argument, e.g. `where: raw("status = 'active'")`.[0m
+        [1;91merror[0m: [1mError parsing attribute "@unique": The `where` argument must be a raw() function with exactly one string argument, e.g. `where: raw("status = 'active'")`.[0m
           -->  schema.prisma:15
            | 
         14 | 
@@ -176,6 +176,30 @@ fn partial_index_raw_requires_string_argument() {
     expected.assert_eq(&err);
 }
 
+#[test]
+fn partial_index_raw_rejects_multiple_arguments() {
+    let dml = indoc! {r#"
+        model User {
+            id        Int    @id
+            email     String
+            status    String
+
+            @@unique([email], where: raw("status = 'active'", "email IS NOT NULL"))
+        }
+    "#};
+
+    let err = parse_unwrap_err(&with_header(dml, Provider::Postgres, &["partialIndexes"]));
+    let expected = expect![[r#"
+        error: Error parsing attribute "@unique": The `where` argument must be a raw() function with exactly one string argument, e.g. `where: raw("status = 'active'")`.
+          -->  schema.prisma:15
+           | 
+        14 | 
+        15 |     @@unique([email], where: raw("status = 'active'", "email IS NOT NULL"))
+           | 
+    "#]];
+    expected.assert_eq(&err);
+}
+
 #[test]
 fn partial_index_cannot_have_empty_predicate() {
     let dml = indoc! {r#"

quaint/src/visitor/postgres.rs

@@ -27,16 +27,24 @@ impl<'a> Postgres<'a> {
         match expr.kind() {
             ExpressionKind::Column(col) => match (col.type_family.as_ref(), col.native_type.as_deref()) {
                 (Some(TypeFamily::Decimal(_)), Some("MONEY")) => {
+                    let is_list = col.is_list;
                     self.visit_expression(expr)?;
                     self.write("::numeric")?;
+                    if is_list {
+                        self.write("[]")?;
+                    }
 
                     Ok(())
                 }
                 // Cast BigInt to text to preserve precision when parsed by JavaScript.
                 // JavaScript's JSON.parse loses precision for integers > 2^53-1.
                 (Some(TypeFamily::Int), Some("BIGINT" | "INT8")) => {
+                    let is_list = col.is_list;
                     self.visit_expression(expr)?;
                     self.write("::text")?;
+                    if is_list {
+                        self.write("[]")?;
+                    }
 
                     Ok(())
                 }
@@ -1442,6 +1450,22 @@ mod tests {
             assert_eq!(sql, "SELECT JSONB_BUILD_OBJECT('money', \"money\"::numeric)");
         }
 
+        #[test]
+        fn money_array() {
+            let build_json = json_build_object(vec![(
+                "money".into(),
+                Column::from("money")
+                    .native_column_type(Some("money"))
+                    .type_family(TypeFamily::Decimal(None))
+                    .set_is_list(true)
+                    .into(),
+            )]);
+            let query = Select::default().value(build_json);
+            let (sql, _) = Postgres::build(query).unwrap();
+
+            assert_eq!(sql, "SELECT JSONB_BUILD_OBJECT('money', \"money\"::numeric[])");
+        }
+
         #[test]
         fn bigint() {
             let build_json = json_build_object(vec![(
@@ -1457,6 +1481,22 @@ mod tests {
             assert_eq!(sql, "SELECT JSONB_BUILD_OBJECT('id', \"id\"::text)");
         }
 
+        #[test]
+        fn bigint_array() {
+            let build_json = json_build_object(vec![(
+                "id".into(),
+                Column::from("id")
+                    .native_column_type(Some("BigInt"))
+                    .type_family(TypeFamily::Int)
+                    .set_is_list(true)
+                    .into(),
+            )]);
+            let query = Select::default().value(build_json);
+            let (sql, _) = Postgres::build(query).unwrap();
+
+            assert_eq!(sql, "SELECT JSONB_BUILD_OBJECT('id', \"id\"::text[])");
+        }
+
         #[test]
         fn int8() {
             let build_json = json_build_object(vec![(

query-compiler/query-builders/sql-query-builder/src/read.rs

@@ -242,7 +242,8 @@ fn apply_aggregate_selections(
                     .field
                     .as_scalar()
                     .unwrap()
-                    .as_column_with_style(ctx, col_style))
+                    .as_column_with_style(ctx, col_style)
+                    .set_is_selected(true))
                 .alias(next_field.db_alias().into_owned()),
             )
         }),
@@ -253,7 +254,8 @@ fn apply_aggregate_selections(
                     .field
                     .as_scalar()
                     .unwrap()
-                    .as_column_with_style(ctx, col_style))
+                    .as_column_with_style(ctx, col_style)
+                    .set_is_selected(true))
                 .alias(next_field.db_alias().into_owned()),
             )
         }),

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

@@ -163,6 +163,24 @@ mod postgres_money {
 
         Ok(())
     }
+
+    #[connector_test(schema(schema_decimal))]
+    async fn native_money_aggregates(runner: Runner) -> TestResult<()> {
+        runner
+            .raw_execute(
+                r#"INSERT INTO "Table" ("id", "money", "moneyList") VALUES
+                    (1, '$10.25', ARRAY[]::money[]),
+                    (2, '$20.75', ARRAY[]::money[]);"#,
+            )
+            .await?;
+
+        insta::assert_snapshot!(
+          run_query!(&runner, r#"{ aggregateTable { _sum { money } _avg { money } } }"#),
+          @r###"{"data":{"aggregateTable":{"_sum":{"money":"31"},"_avg":{"money":"15.5"}}}}"###
+        );
+
+        Ok(())
+    }
 }
 
 #[test_suite(only(Postgres))]

schema-engine/connectors/sql-schema-connector/src/flavour/postgres/renderer.rs

@@ -974,7 +974,7 @@ fn render_postgres_alter_enum(
             let sql = format!(
                 "ALTER TABLE {table_name} \
                             ALTER COLUMN {column_name} TYPE {tmp_name}{array} \
-                                USING ({column_name}::text::{tmp_name}{array})",
+                                USING ({column_name}::text{array}::{tmp_name}{array})",
                 table_name = QuotedWithPrefix::pg_from_table_walker(column.table()),
                 column_name = Quoted::postgres_ident(column.name()),
                 array = array,

schema-engine/sql-migration-tests/tests/migrations/enums.rs

@@ -542,6 +542,8 @@ fn enum_array_modification_should_work(api: TestApi) {
         .send_sync()
         .assert_applied_migrations(&["01init"]);
 
+    api.raw_cmd(r#"INSERT INTO "Test" ("positions") VALUES (ARRAY['First', 'Second']::"Position"[])"#);
+
     let dm = r#"
         datasource test {
             provider = "postgres"
@@ -623,8 +625,9 @@ fn alter_enum_and_change_default_must_work(api: TestApi) {
             provider = "postgres"
         }
         model Cat {
-            id      Int    @id
-            moods   Mood[] @default([])
+            id    Int    @id
+            mood  Mood
+            moods Mood[] @default([])
         }
         enum Mood {
             SLEEPY
@@ -639,8 +642,9 @@ fn alter_enum_and_change_default_must_work(api: TestApi) {
             provider = "postgres"
         }
         model Cat {
-            id      Int    @id
-            moods   Mood[] @default([SLEEPY])
+            id    Int    @id
+            mood  Mood
+            moods Mood[] @default([SLEEPY])
         }
         enum Mood {
             HUNGRY
@@ -682,7 +686,8 @@ fn alter_enum_and_change_default_must_work(api: TestApi) {
                 BEGIN;
                 CREATE TYPE "Mood_new" AS ENUM ('HUNGRY', 'SLEEPY');
                 ALTER TABLE "public"."Cat" ALTER COLUMN "moods" DROP DEFAULT;
-                ALTER TABLE "Cat" ALTER COLUMN "moods" TYPE "Mood_new"[] USING ("moods"::text::"Mood_new"[]);
+                ALTER TABLE "Cat" ALTER COLUMN "mood" TYPE "Mood_new" USING ("mood"::text::"Mood_new");
+                ALTER TABLE "Cat" ALTER COLUMN "moods" TYPE "Mood_new"[] USING ("moods"::text[]::"Mood_new"[]);
                 ALTER TYPE "Mood" RENAME TO "Mood_old";
                 ALTER TYPE "Mood_new" RENAME TO "Mood";
                 DROP TYPE "public"."Mood_old";