efureev/swoole-doctrine-dbal-pgsql-driver

English | Русский

swoole-doctrine-dbal-pgsql-driver

A PostgreSQL connection pool for Doctrine DBAL on Swoole: one physical connection per coroutine, a coroutine-safe Doctrine\DBAL\Connection wrapper, and a Symfony bundle that moves DoctrineBundle connections onto the pool with three lines of configuration.

Requirements

The official phpswoole/swoole:6.2.x-php8.5[-zts] images are built with pgsql support.

Installation

composer require efureev/swoole-doctrine-dbal-pgsql-driver

Symfony: quick start

// config/bundles.php
SwooleDoctrinePool\Bridge\Symfony\SwooleDoctrinePoolBundle::class => ['all' => true],

# config/packages/swoole_doctrine_pool.yaml
swoole_doctrine_pool:
  connections:
    default: ~          # every pool setting at its default

# config/packages/doctrine.yaml — no driver_class / wrapper_class needed, the bundle injects them
doctrine:
  dbal:
    url: '%env(resolve:DATABASE_URL)%'
    server_version: '17'          # otherwise DoctrineBundle connects to the DB while building the platform
    idle_connection_ttl: 0        # idle handling belongs to the pool

Verify: bin/console debug:config swoole_doctrine_pool prints the defaults, bin/console debug:container database_connection shows CoroutineSafeConnection.

If your Swoole runtime dispatches the swoole.* events, the rest is automatic: the connection goes back to the pool on kernel.terminate, pools are closed on swoole.worker_stop. Without them — see docs/symfony.md.

Without Symfony

$registry = new PoolRegistry(logger: $logger);           // one per worker

$config = new Configuration();
$config->setMiddlewares([new PoolDriverMiddleware($registry)]);

$connection = DriverManager::getConnection([
    'driverClass'  => SwooleDoctrinePool\Driver\Driver::class,
    'wrapperClass' => SwooleDoctrinePool\DBAL\CoroutineSafeConnection::class,
    'host' => '127.0.0.1', 'dbname' => 'app', 'user' => 'app', 'password' => 'secret',
    'serverVersion' => '17',
    'driverOptions' => ['pool' => ['size' => 20]],
], $config);

$server->on('workerStop', static fn() => $registry->closeAll());

Details: docs/standalone.md.

Things to remember

• A lease lives until the end of the request (kernel.terminate, an explicit $connection->close(), or the end of the coroutine), not until the end of an SQL statement — that is what keeps lastInsertId() and transactions on one session. Consequently size is also the cap on concurrent DB requests per worker.
• A child coroutine (go() inside a handler) gets its own connection and is outside the parent's transaction.
• Do not touch the database before the worker starts: a pool inherited across fork is discarded with a warning.
• size × number of workers must fit into Postgres max_connections.
• The package makes DBAL coroutine-safe. The ORM UnitOfWork is still the state of one EntityManager: concurrent coroutines need an EntityManager per coroutine.
• reset_on_release: rollback_only saves a round-trip, but SET, advisory locks and temp tables survive the request. The default is discard.

Documentation

Development

composer install --ignore-platform-req=ext-swoole   # locally without Swoole: phpcs, psalm, unit
composer ci                                          # phpcs + psalm + unit
composer up && composer integration                  # integration tests in docker (Postgres 17)
composer down

Integration image matrix: phpswoole/swoole:6.2.3-php8.5-zts (default), SWOOLE_IMAGES="phpswoole/swoole:6.2.3-php8.5" composer integration — NTS.

License

MIT