fix: handle PostgreSQL identifier quoting in partial index predicate comparison (#5788)

## Description

Closes #5787

## Problem

After #5780, partial indexes with object literal `where` clauses are
still recreated on every migration when predicates contain multiple
conditions. PostgreSQL's `pg_get_expr()` returns unquoted identifiers
for lowercase column names (`postcode`), while Prisma generates quoted
identifiers (`"postcode"`). The AST comparison treats these as
different, causing needless drop+recreate cycles.

```sql
-- Prisma generates:
("deletedAt" IS NULL AND "postcode" IS NOT NULL)

-- pg_get_expr() returns:
((("deletedAt" IS NULL) AND (postcode IS NOT NULL)))
```

## Solution

Extend `exprs_semantically_eq` to treat quoted and unquoted identifiers
as equivalent when the unquoted form is a valid PostgreSQL identifier.
Uses `sqlparser` with `PostgreSqlDialect` to verify that the identifier
value can be safely used without quotes (i.e., it's not a reserved
keyword and follows identifier rules).

## Changes

- **PG `schema_differ.rs`** — Added identifier quoting comparison in
`exprs_semantically_eq`; checks if `"foo"` and `foo` refer to the same
column by re-parsing with `sqlparser`
- **`partial.rs`** — Regression test for object literal predicates with
`null` and `not: null` conditions

<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit

* **Bug Fixes**
* Improved PostgreSQL schema comparison to more robustly treat
identifiers as equivalent across quote styles and within expressions.
* **Tests**
* Added an idempotency test for Postgres partial indexes using
object-literal filters with null and not-null conditions.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

Author: jay-l-e-e

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

@@ -17,7 +17,11 @@ use sql_schema_describer::{
     postgres::PostgresSchemaExt,
     walkers::{IndexWalker, TableColumnWalker},
 };
-use sqlparser::ast::Expr;
+use sqlparser::{
+    ast::{Expr, Ident},
+    dialect::PostgreSqlDialect,
+    parser::Parser,
+};
 
 /// These can be tables or views, depending on the PostGIS version. In both cases, they should be ignored.
 static POSTGIS_TABLES_OR_VIEWS: LazyLock<RegexSet> = LazyLock::new(|| {
@@ -749,11 +753,7 @@ fn push_alter_enum_previous_usages_as_default(db: &DifferDatabase<'_>, alter_enu
 
 // Accounts for PG expression normalization (operator aliases, parens, implicit literal casts).
 fn pg_predicates_semantically_equal(a: &str, b: &str) -> bool {
-    use sqlparser::{
-        ast::{Value, VisitMut, VisitorMut},
-        dialect::PostgreSqlDialect,
-        parser::Parser,
-    };
+    use sqlparser::ast::{Value, VisitMut, VisitorMut};
     use std::ops::ControlFlow;
 
     struct StripPgNormalization;
@@ -792,6 +792,20 @@ fn pg_predicates_semantically_equal(a: &str, b: &str) -> bool {
     exprs_semantically_eq(&ast_a, &ast_b)
 }
 
+// Compares two identifiers semantically.
+fn idents_semantically_eq(a: &Ident, b: &Ident) -> bool {
+    if a == b {
+        return true;
+    }
+
+    matches!((a.quote_style, b.quote_style), (Some('"'), None) | (None, Some('"')))
+        && a.value == b.value
+        && Parser::new(&PostgreSqlDialect {})
+            .try_with_sql(&a.value)
+            .and_then(|mut parser| parser.parse_expr())
+            .is_ok_and(|expr| matches!(expr, Expr::Identifier(_)))
+}
+
 // Compares two expressions that have already been normalized by `StripPgNormalization`.
 fn exprs_semantically_eq(a: &Expr, b: &Expr) -> bool {
     use sqlparser::ast::CastKind;
@@ -801,6 +815,12 @@ fn exprs_semantically_eq(a: &Expr, b: &Expr) -> bool {
     }
 
     match (a, b) {
+        (Expr::Identifier(ia), Expr::Identifier(ib)) => idents_semantically_eq(ia, ib),
+
+        (Expr::CompoundIdentifier(ia), Expr::CompoundIdentifier(ib)) if ia.len() == ib.len() => {
+            ia.iter().zip(ib.iter()).all(|(a, b)| idents_semantically_eq(a, b))
+        }
+
         // Value(x) matches Cast(::, Value(x), _): PG's single-level annotation on a bare literal.
         (
             Expr::Value(va),

schema-engine/sql-migration-tests/tests/migrations/indexes/partial.rs

@@ -1082,3 +1082,21 @@ fn partial_index_not_with_and_or_roundtrip_postgres(api: TestApi) {
     api.schema_push(&dm).send().assert_green();
     api.schema_push(&dm).send().assert_no_steps();
 }
+
+#[test_connector(tags(Postgres), exclude(CockroachDb), preview_features("partialIndexes"))]
+fn partial_index_object_literal_null_and_not_null_is_idempotent_postgres(api: TestApi) {
+    let dm = api.datamodel_with_provider_and_features(
+        r#"model Shop {
+            id        BigInt   @id
+            postcode  String?
+            deletedAt DateTime?
+
+            @@index([postcode], where: { deletedAt: null, postcode: { not: null } })
+        }"#,
+        &[],
+        PREVIEW_FEATURES,
+    );
+
+    api.schema_push(&dm).send().assert_green();
+    api.schema_push(&dm).send().assert_no_steps();
+}