@@ -435,6 +435,7 @@ _Flags always override settings in `.dbdiff`._
 | `--allow-destructive` | Generate the migration even when it contains data-losing changes. See [Destructive Change Protection](#destructive-change-protection). |
 | `--renames=auto\|off` | PostgreSQL: `auto` (the default) renames a column, table or sequence whose only difference is its name, keeping its data, where exactly one such pair exists. `off` drops and adds instead. |
 | `--no-snapshot` | PostgreSQL: read each query on its own. By default each side is read as of one instant, in a `REPEATABLE READ` transaction held for the run, so a change made while the diff runs is seen by all of its reads or by none. As with `pg_dump`, what the reads lock stays locked until the run ends, so DDL on that side waits for it. |
+| `--source-snapshot=<id>` / `--target-snapshot=<id>` | PostgreSQL: read that side as of a snapshot another session exported with `pg_export_snapshot()` and holds open, so a tool running DBDiff as part of a larger read sees one instant throughout. |
 | `--debug` | Enable verbose error output. |
 | `server1.db1:server2.db2` | Databases to compare. Or a single table: `server1.db1.table1:server2.db2.table1`. |
 
 
@@ -71,7 +71,8 @@ public function connect($params): void {
             PostgresSessionOptions::apply($this->capsule->getConnection($key));
 
             if ($this->driver === 'pgsql' && ($params->snapshot ?? true)) {
-                $this->holdSnapshot($key, $config);
+                $given = $key === 'source' ? ($params->sourceSnapshot ?? null) : ($params->targetSnapshot ?? null);
+                $given ? $this->joinSnapshot($key, $given) : $this->holdSnapshot($key, $config);
             }
         }
         if ($this->driver === 'pgsql') {
@@ -82,6 +83,17 @@ public function connect($params): void {
         }
     }
 
+    /**
+     * Read `$side` as of a snapshot another session exported and holds — a
+     * tool running DBDiff as one part of a larger read, so all of it sees the
+     * same instant.
+     */
+    private function joinSnapshot(string $side, string $id): void {
+        if (PostgresSnapshot::join($this->getDB($side), $id, $side)) {
+            $this->snapshots[$side] = $id;
+        }
+    }
+
     /**
      * Read `$side` as of one instant: a second connection exports its
      * snapshot and keeps it open, and the one DBDiff reads with joins it —
 
@@ -99,6 +99,10 @@ protected function configure(): void
             ->addOption('renames', null, InputOption::VALUE_REQUIRED,
                 'PostgreSQL: "auto" (default) renames a column or table whose only difference is its name, '
                 . 'keeping its data, where exactly one such pair exists; "off" drops and adds instead.', 'auto')
+            ->addOption('source-snapshot', null, InputOption::VALUE_REQUIRED,
+                'PostgreSQL: read the source as of this snapshot, exported by a session that holds it open.')
+            ->addOption('target-snapshot', null, InputOption::VALUE_REQUIRED,
+                'PostgreSQL: read the target as of this snapshot, exported by a session that holds it open.')
             ->addOption('no-snapshot', null, InputOption::VALUE_NONE,
                 'PostgreSQL: read each query on its own, rather than each side as of one instant. '
                 . 'The snapshot keeps what the diff reads locked until it ends, as pg_dump does.');
@@ -173,6 +177,8 @@ private function buildParams(InputInterface $input): DefaultParams
         $params->allowDestructive = (bool) $input->getOption('allow-destructive');
         $params->renames          = $input->getOption('renames') === 'off' ? 'off' : 'auto';
         $params->snapshot         = !$input->getOption('no-snapshot');
+        $params->sourceSnapshot   = $input->getOption('source-snapshot') ?: null;
+        $params->targetSnapshot   = $input->getOption('target-snapshot') ?: null;
 
         if ($input->getOption('tables')) {
             $params->tables = array_map('trim', explode(',', $input->getOption('tables')));
 
@@ -156,6 +156,14 @@ class DefaultParams {
     */
     public bool $snapshot = true;
 
+    /*
+     PostgreSQL: a snapshot another session exported (pg_export_snapshot) and
+     holds open, to read the source or target as of instead of one of
+     DBDiff's own.
+    */
+    public ?string $sourceSnapshot = null;
+    public ?string $targetSnapshot = null;
+
     /*
      The penultimate parameter is what to compare: db1.table1:db2.table3 or db1:db2 
      This tool can compare just one table or all tables (entire db) from the database
 
@@ -15,12 +15,13 @@ class SnapshotPostgresTest extends PostgresRoundTripTestCase
 {
     protected string $prefix = 'dbdiff_snap';
 
-    private function manager(string $source, string $target, bool $snapshot = true): DBManager
+    private function manager(string $source, string $target, bool $snapshot = true, ?string $sourceSnapshot = null): DBManager
     {
         $server = ['user' => $this->user, 'password' => $this->pass, 'host' => $this->host, 'port' => $this->port];
         $params = new \stdClass;
         $params->driver   = 'pgsql';
         $params->snapshot = $snapshot;
+        $params->sourceSnapshot = $sourceSnapshot;
         $params->server1  = $server;
         $params->server2  = $server;
         $params->input    = [
@@ -89,4 +90,20 @@ public function testAFailedReadOrARenderingLeavesTheSnapshotReadable(): void
         $this->assertSame(['t'], $manager->getTables('source'));
         $this->assertSame(0, (int) $connection->selectOne("SELECT count(*) AS n FROM pg_class WHERE relname = 'dbdiff_render_probe'")['n']);
     }
+
+    public function testASnapshotAnotherSessionHoldsIsReadAsOf(): void
+    {
+        $source = $this->db('gs', 'CREATE TABLE exported_before (id int);');
+        $target = $this->db('gt', '');
+        $holder = $this->connect($source);
+        $holder->exec('BEGIN ISOLATION LEVEL REPEATABLE READ, READ ONLY');
+        $id = $holder->query('SELECT pg_export_snapshot()')->fetchColumn();
+        $this->connect($source)->exec('CREATE TABLE made_after (id int);');
+
+        $manager = $this->manager($source, $target, true, $id);
+
+        $this->assertTrue($manager->readsSnapshot('source'));
+        $this->assertSame(['exported_before'], $manager->getTables('source'));
+        $holder->exec('ROLLBACK');
+    }
 }