{

private string $db = 'dbdiff_overloads';

private ?PDO $adminDb = null;

private $capsule;

private $connection;

private PostgresAdapter $adapter;

protected function setUp(): void

{

if (!extension_loaded('pdo_pgsql')) {

$this->markTestSkipped('pdo_pgsql extension not loaded.');

}

$host = getenv('DB_HOST_POSTGRES') ?: null;

if (!$host) {

$this->markTestSkipped('DB_HOST_POSTGRES env var not set.');

}

$this->adminDb = new PDO(

"pgsql:host=$host;port=5432;dbname=diff1",

'dbdiff',

'rootpass',

[PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION]

);

$this->dropScratchDb();

$this->adminDb->exec("CREATE DATABASE {$this->db}");

$capsule = new Capsule;

$dispatcher = new Dispatcher();

$dispatcher->listen(StatementPrepared::class, function ($event) {

$event->statement->setFetchMode(PDO::FETCH_ASSOC);

});

$capsule->setEventDispatcher($dispatcher);

$capsule->addConnection([

'driver' => 'pgsql', 'host' => $host, 'port' => 5432,

'database' => $this->db, 'username' => 'dbdiff', 'password' => 'rootpass',

'charset' => 'utf8', 'schema' => 'public',

], 'ovl');

$this->capsule = $capsule;

$this->connection = $capsule->getConnection('ovl');

$this->adapter = new PostgresAdapter();

$this->connection->unprepared(<<<'SQL'

SQL);

}

protected function tearDown(): void

{

if ($this->adminDb === null) {

return;

}

if ($this->connection !== null) {

$this->connection->disconnect();

$this->connection = null;

}

$this->capsule = null;

$this->dropScratchDb();

$this->adminDb = null;

}

private function dropScratchDb(): void

{

try {

$this->adminDb->exec("DROP DATABASE IF EXISTS {$this->db} WITH (FORCE)");

} catch (PDOException $e) {

$this->adminDb->exec("DROP DATABASE IF EXISTS {$this->db}");

}

}

public function testEveryOverloadIsRetained(): void

{

// Keyed on proname, three overloads collapsed to one entry.

$routines = $this->adapter->getRoutines($this->connection);

$overloads = array_filter(

array_keys($routines),

fn($k) => str_starts_with($k, 'cosine_distance')

);

$this->assertCount(3, $overloads);

}

public function testKeysAreSignaturesNotBareNames(): void

{

$routines = $this->adapter->getRoutines($this->connection);

$this->assertArrayHasKey('cosine_distance(integer,integer)', $routines);

$this->assertArrayHasKey('cosine_distance(text,text)', $routines);

$this->assertArrayHasKey('cosine_distance(bigint,bigint)', $routines);

$this->assertArrayNotHasKey('cosine_distance', $routines);

}

public function testEachOverloadKeepsItsOwnDefinition(): void

{

$routines = $this->adapter->getRoutines($this->connection);

$this->assertStringContainsString('bigint', $routines['cosine_distance(bigint,bigint)']);

$this->assertStringContainsString('text', $routines['cosine_distance(text,text)']);

}

public function testNonOverloadedRoutineStillAppears(): void

{

$routines = $this->adapter->getRoutines($this->connection);

$this->assertArrayHasKey('solo()', $routines);

}

public function testRoutineOrderIsDeterministic(): void

{

// ORDER BY proname left overload ties unordered, which is what made the

// surviving definition differ between databases.

$first = array_keys($this->adapter->getRoutines($this->connection));

$second = array_keys($this->adapter->getRoutines($this->connection));

$this->assertSame($first, $second);

$sorted = $first;

sort($sorted);

$this->assertSame($sorted, $first);

}

public function testSameNamedTriggersOnDifferentTablesAreBothKept(): void

{

// tgname is unique per table, not per schema — keyed on the name alone,

// one of these was silently lost.

$triggers = $this->adapter->getTriggers($this->connection);

$this->assertArrayHasKey('t1.shared_trig', $triggers);

$this->assertArrayHasKey('t2.shared_trig', $triggers);

$this->assertSame('shared_trig', $triggers['t1.shared_trig']['name']);

$this->assertSame('t2', $triggers['t2.shared_trig']['table']);

}