Schema Diff: stop injecting whitespace into applied function/procedure bodies

[dpage]

What this is

Applying a Schema Diff script that creates a function or procedure that only exists on the source ("Source Only") left a whitespace-only difference behind, so re-comparing the two databases kept reporting the object as different unless "Ignore whitespace" was ticked.

The "Source Only" path routed through FunctionView.sql(), which always calls reformat_prosrc_code() to wrap the body with a leading and trailing newline around $BODY$...$BODY$ purely for readability in the SQL panel. That reformatted body was then executed verbatim against the target, so PostgreSQL stored the extra newlines in prosrc: the target's body no longer matched the source's byte for byte.

Schema Diff's update path (CREATE OR REPLACE against an existing target object) already suppressed this formatting via an allow_code_formatting flag, added for #7102, but that flag was never threaded through the create/"Source Only" path.

The fix

Extends the existing allow_code_formatting guard to sql() itself, and passes allow_code_formatting=False from the get_sql_from_diff() branch that builds the DDL actually applied to the target.

Testing

Added a dedicated regression test covering both the "Source Only" and "Different" cases for a function and a procedure: applying the generated script now leaves every object comparing as Identical without needing "Ignore whitespace".

tools.schema_diff passes against PostgreSQL 18; pycodestyle is clean.

Fixes #10302.

Summary by CodeRabbit

• Bug Fixes

  • Preserved function and procedure body whitespace in schema-diff-generated SQL.
  • Prevented unwanted leading or trailing newlines around stored code bodies.
  • Ensured source-only schema differences can be applied and subsequently compare as identical.
  • Added clear errors when unsupported new arguments are added to existing functions or procedures.

• Tests

  • Added regression coverage for whitespace preservation in function and procedure definitions.

[coderabbitai]

Caution

Review failed

The pull request is closed.

ℹ️ Recent review info

⚙️ Run configuration

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Team

Run ID: 3cbb7bf0-ed50-4862-ab78-cc20a82368eb

📥 Commits

Reviewing files that changed from the base of the PR and between bdfecb9 and f599501.

📒 Files selected for processing (1)

• web/pgadmin/browser/server_groups/servers/databases/schemas/functions/__init__.py

---

Walkthrough

Schema Diff SQL generation now preserves stored function and procedure body whitespace. Function edit-mode SQL also handles missing change data and rejects unsupported added arguments. Regression tests verify identical comparisons after applying generated SQL.

Changes

Schema Diff body formatting and function edit validation

Layer / File(s)	Summary
Conditional SQL generation and argument validation web/pgadmin/browser/server_groups/servers/databases/schemas/functions/__init__.py	SQL generation supports optional formatting, disables it for Schema Diff target SQL, handles missing changed data, and rejects added routine arguments.
End-to-end whitespace regression coverage web/pgadmin/tools/schema_diff/tests/test_schema_diff_function_body.py	The test covers source-only and differing functions and procedures, applies generated DDL, and verifies identical comparisons without whitespace ignoring.

Estimated code review effort: 3 (Moderate) | ~25 minutes

Merge Risk: ⚪ Minimal · up to bdfec

This localized change prevents formatting-only differences when applying function and procedure definitions, with dedicated regression coverage. No actionable merge-blocking risk remains beyond normal checks and review.

Sequence Diagram(s)

sequenceDiagram
  participant SchemaDiffTest
  participant SchemaDiff
  participant FunctionSQLGenerator
  participant TargetDatabase

  SchemaDiffTest->>SchemaDiff: generate routine diff SQL
  SchemaDiff->>FunctionSQLGenerator: disable code formatting
  FunctionSQLGenerator-->>SchemaDiff: return SQL with stored body whitespace
  SchemaDiff->>TargetDatabase: apply generated DDL
  SchemaDiffTest->>SchemaDiff: compare source and target routines
  SchemaDiff-->>SchemaDiffTest: report identical without ignored whitespace

Loading

Suggested reviewers: hiteshjambhale

🚥 Pre-merge checks | ✅ 5

✅ Passed checks (5 passed)

Check name	Status	Explanation
Description Check	✅ Passed	Check skipped - CodeRabbit’s high-level summary is enabled.
Title check	✅ Passed	The title clearly and concisely describes the main fix: preventing whitespace injection into applied function and procedure bodies.
Linked Issues check	✅ Passed	The implementation and regression test address issue #10302 by preserving function and procedure body whitespace during Schema Diff application.
Out of Scope Changes check	✅ Passed	The changes are limited to SQL formatting control and regression coverage directly related to issue #10302.
Docstring Coverage	✅ Passed	Docstring coverage is 88.89% which is sufficient. The required threshold is 80.00%.

✨ Finishing Touches

🧪 Generate unit tests (beta)

• Create PR with unit tests

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands.}

[hiteshjambhale]

Tested this hands-on. Created a source-only function with a spaced body, ran Schema Diff, and checked the generated script — the body now stays exactly as written ($BODY$ SELECT a + b; $BODY$), no extra newlines.

also applied it to the target and the stored body matched the source exactly, so a re-compare shows Identical without ticking "Ignore whitespace"

Looks good to me.