feat(migrate): add MigrateRender trait and Migrator::render_pending_sql - #2

Summary

Adds a per-driver SQL-rendering helper so a library user can dump the SQL that apply() would execute for pending migrations — for DBA review, out-of-band application via psql/mysql/sqlite3, or pre-deploy inspection. Today this requires copying private execute_migration SQL from each driver crate (INSERT into _sqlx_migrations, bytea-literal syntax, checksum hex, transaction framing, MySQL's success=FALSE/UPDATE TRUE two-step). The CLI's existing --dry-run only prints status lines.

Targets upstream issue transact-rs#357 (the original "SQL that would have been executed, including the adjustments to the migrations table" ask was never delivered; transact-rs#357 was closed by transact-rs#649 which only added status-line output).

Stacking

Stacked on PR #1 (feat/migrator-pending). This PR's base is set to that branch so its diff shows phase-2-only changes (~317 lines). Once PR #1 lands in main, GitHub will auto-rebase this PR's base.

Migrator::render_pending_sql calls pending_direct (introduced in PR #1) rather than duplicating the diff loop.

API

pub trait MigrateRender {
    fn append_apply_sql(&self, table_name: &str, migration: &Migration, buf: &mut String);
}

impl Migrator {
    pub async fn render_pending_sql<'a, A>(&self, migrator: A) -> Result<String, MigrateError>
    where
        A: Acquire<'a>,
        <A::Connection as Deref>::Target: Migrate + MigrateRender;
}

Plus #[doc(hidden)] pub fn append_hex and append_sql_string in sqlx-core::migrate::render for driver-crate reuse.

Per-driver behavior (mirrors each apply() byte-for-byte)

Self-applying guarantee

Output includes the bookkeeping INSERT INTO _sqlx_migrations row with the migration's SHA-384 checksum and execution_time = -1. Executing the rendered SQL produces the same post-state as apply(), so a subsequent Migrator::run() sees those versions as applied (no checksum mismatch, no re-execution).

Test plan

End-to-end test in each of the three driver test suites: render the pending SQL, execute it via raw_sql(AssertSqlSafe(...)), assert pending is then empty, assert a follow-up run is a no-op (proves checksums match byte-for-byte what sqlx computes), assert re-rendering yields the empty string.

• cargo check -p sqlx-core clean
• cargo clippy -p sqlx-core clean (no new warnings)
• SQLite test runs locally and passes (full 7-test suite passes — 5 existing + pending from PR feat(migrate): add Migrator::pending to inspect unapplied migrations #1 + new render_pending_sql).
• Postgres test runs locally against PG 16 — both pending and render_pending_sql pass end-to-end.
• MySQL test compiles (cargo test --no-run); not exercised against a live MySQL locally. Implementation validated by symmetry with PG/SQLite and direct comparison against MySqlConnection::apply().

Two design decisions worth review

1. Separate trait MigrateRender rather than method on Migrate. Migrate's methods are all async + &mut self + BoxFuture; a sync &self-ignoring sibling method would clash with that shape. Easy to fold into Migrate if reviewers prefer.
2. append_apply_sql ignores &self. Pure formatting, no connection state needed. &self is required for trait dispatch via the connection type. Static method (no &self) was an option but verbose at call sites. Easy to flip.