vendor/doctrine/doctrine-bundle/src/ConnectionFactory.php line 118

  1. <?php
  3. namespace Doctrine\Bundle\DoctrineBundle;
  5. use Doctrine\Common\EventManager;
  6. use Doctrine\DBAL\Configuration;
  7. use Doctrine\DBAL\Connection;
  8. use Doctrine\DBAL\Connection\StaticServerVersionProvider;
  9. use Doctrine\DBAL\ConnectionException;
  10. use Doctrine\DBAL\DriverManager;
  11. use Doctrine\DBAL\Exception as DBALException;
  12. use Doctrine\DBAL\Exception\DriverException;
  13. use Doctrine\DBAL\Exception\DriverRequired;
  14. use Doctrine\DBAL\Exception\InvalidWrapperClass;
  15. use Doctrine\DBAL\Exception\MalformedDsnException;
  16. use Doctrine\DBAL\Platforms\AbstractMySQLPlatform;
  17. use Doctrine\DBAL\Platforms\AbstractPlatform;
  18. use Doctrine\DBAL\Tools\DsnParser;
  19. use Doctrine\DBAL\Types\Type;
  20. use Doctrine\Deprecations\Deprecation;
  21. use InvalidArgumentException;
  23. use function array_merge;
  24. use function class_exists;
  25. use function is_subclass_of;
  26. use function method_exists;
  27. use function trigger_deprecation;
  29. use const PHP_EOL;
  31. /** @psalm-import-type Params from DriverManager */
  32. class ConnectionFactory
  33. {
  34.     /** @internal */
  35.     public const DEFAULT_SCHEME_MAP = [
  36.         'db2'        => 'ibm_db2',
  37.         'mssql'      => 'pdo_sqlsrv',
  38.         'mysql'      => 'pdo_mysql',
  39.         'mysql2'     => 'pdo_mysql', // Amazon RDS, for some weird reason
  40.         'postgres'   => 'pdo_pgsql',
  41.         'postgresql' => 'pdo_pgsql',
  42.         'pgsql'      => 'pdo_pgsql',
  43.         'sqlite'     => 'pdo_sqlite',
  44.         'sqlite3'    => 'pdo_sqlite',
  45.     ];
  47.     /** @var mixed[][] */
  48.     private array $typesConfig = [];
  50.     private DsnParser $dsnParser;
  52.     private bool $initialized = false;
  54.     /** @param mixed[][] $typesConfig */
  55.     public function __construct(array $typesConfig, ?DsnParser $dsnParser = null)
  56.     {
  57.         $this->typesConfig = $typesConfig;
  58.         $this->dsnParser   = $dsnParser ?? new DsnParser(self::DEFAULT_SCHEME_MAP);
  59.     }
  61.     /**
  62.      * Create a connection by name.
  63.      *
  64.      * @param mixed[]               $params
  65.      * @param array<string, string> $mappingTypes
  66.      * @psalm-param Params $params
  67.      *
  68.      * @return Connection
  69.      */
  70.     public function createConnection(array $params, ?Configuration $config = null, ?EventManager $eventManager = null, array $mappingTypes = [])
  71.     {
  72.         if (! method_exists(Connection::class, 'getEventManager') && $eventManager !== null) {
  73.             throw new InvalidArgumentException('Passing an EventManager instance is not supported with DBAL > 3');
  74.         }
  76.         if (! $this->initialized) {
  77.             $this->initializeTypes();
  78.         }
  80.         $overriddenOptions = [];
  81.         /** @psalm-suppress InvalidArrayOffset We should adjust when https://github.com/vimeo/psalm/issues/8984 is fixed */
  82.         if (isset($params['connection_override_options'])) {
  83.             trigger_deprecation('doctrine/doctrine-bundle', '2.4', 'The "connection_override_options" connection parameter is deprecated');
  84.             $overriddenOptions = $params['connection_override_options'];
  85.             unset($params['connection_override_options']);
  86.         }
  88.         $params = $this->parseDatabaseUrl($params);
  90.         // URL support for PrimaryReplicaConnection
  91.         if (isset($params['primary'])) {
  92.             $params['primary'] = $this->parseDatabaseUrl($params['primary']);
  93.         }
  95.         if (isset($params['replica'])) {
  96.             foreach ($params['replica'] as $key => $replicaParams) {
  97.                 $params['replica'][$key] = $this->parseDatabaseUrl($replicaParams);
  98.             }
  99.         }
  101.         /** @psalm-suppress InvalidArrayOffset We should adjust when https://github.com/vimeo/psalm/issues/8984 is fixed */
  102.         if (! isset($params['pdo']) && (! isset($params['charset']) || $overriddenOptions || isset($params['dbname_suffix']))) {
  103.             $wrapperClass = null;
  105.             if (isset($params['wrapperClass'])) {
  106.                 if (! is_subclass_of($params['wrapperClass'], Connection::class)) {
  107.                     if (class_exists(InvalidWrapperClass::class)) {
  108.                         throw InvalidWrapperClass::new($params['wrapperClass']);
  109.                     }
  111.                     throw DBALException::invalidWrapperClass($params['wrapperClass']);
  112.                 }
  114.                 $wrapperClass           = $params['wrapperClass'];
  115.                 $params['wrapperClass'] = null;
  116.             }
  118.             $connection = DriverManager::getConnection(...array_merge([$params, $config], $eventManager ? [$eventManager] : []));
  119.             $params     = $this->addDatabaseSuffix(array_merge($connection->getParams(), $overriddenOptions));
  120.             $driver     = $connection->getDriver();
  121.             /** @psalm-suppress InvalidScalarArgument Bogus error, StaticServerVersionProvider implements Doctrine\DBAL\ServerVersionProvider  */
  122.             $platform = $driver->getDatabasePlatform(
  123.                 ...(class_exists(StaticServerVersionProvider::class) ? [new StaticServerVersionProvider($params['serverVersion'] ?? '')] : []),
  124.             );
  126.             if (! isset($params['charset'])) {
  127.                 if ($platform instanceof AbstractMySQLPlatform) {
  128.                     $params['charset'] = 'utf8mb4';
  130.                     if (isset($params['defaultTableOptions']['collate'])) {
  131.                         Deprecation::trigger(
  132.                             'doctrine/doctrine-bundle',
  133.                             'https://github.com/doctrine/dbal/issues/5214',
  134.                             'The "collate" default table option is deprecated in favor of "collation" and will be removed in doctrine/doctrine-bundle 3.0. ',
  135.                         );
  136.                         $params['defaultTableOptions']['collation'] = $params['defaultTableOptions']['collate'];
  137.                         unset($params['defaultTableOptions']['collate']);
  138.                     }
  140.                     if (! isset($params['defaultTableOptions']['collation'])) {
  141.                         $params['defaultTableOptions']['collation'] = 'utf8mb4_unicode_ci';
  142.                     }
  143.                 } else {
  144.                     $params['charset'] = 'utf8';
  145.                 }
  146.             }
  148.             if ($wrapperClass !== null) {
  149.                 $params['wrapperClass'] = $wrapperClass;
  150.             } else {
  151.                 $wrapperClass = Connection::class;
  152.             }
  154.             $connection = new $wrapperClass($params, $driver, $config, $eventManager);
  155.         } else {
  156.             $connection = DriverManager::getConnection(...array_merge([$params, $config], $eventManager ? [$eventManager] : []));
  157.         }
  159.         if (! empty($mappingTypes)) {
  160.             $platform = $this->getDatabasePlatform($connection);
  161.             foreach ($mappingTypes as $dbType => $doctrineType) {
  162.                 $platform->registerDoctrineTypeMapping($dbType, $doctrineType);
  163.             }
  164.         }
  166.         return $connection;
  167.     }
  169.     /**
  170.      * Try to get the database platform.
  171.      *
  172.      * This could fail if types should be registered to an predefined/unused connection
  173.      * and the platform version is unknown.
  174.      *
  175.      * @link https://github.com/doctrine/DoctrineBundle/issues/673
  176.      *
  177.      * @throws DBALException
  178.      */
  179.     private function getDatabasePlatform(Connection $connection): AbstractPlatform
  180.     {
  181.         try {
  182.             return $connection->getDatabasePlatform();
  183.         } catch (DriverException $driverException) {
  184.             $class = class_exists(DBALException::class) ? DBALException::class : ConnectionException::class;
  186.             throw new $class(
  187.                 'An exception occurred while establishing a connection to figure out your platform version.' . PHP_EOL .
  188.                 "You can circumvent this by setting a 'server_version' configuration value" . PHP_EOL . PHP_EOL .
  189.                 'For further information have a look at:' . PHP_EOL .
  190.                 'https://github.com/doctrine/DoctrineBundle/issues/673',
  191.                 0,
  192.                 $driverException,
  193.             );
  194.         }
  195.     }
  197.     /**
  198.      * initialize the types
  199.      */
  200.     private function initializeTypes(): void
  201.     {
  202.         foreach ($this->typesConfig as $typeName => $typeConfig) {
  203.             if (Type::hasType($typeName)) {
  204.                 Type::overrideType($typeName, $typeConfig['class']);
  205.             } else {
  206.                 Type::addType($typeName, $typeConfig['class']);
  207.             }
  208.         }
  210.         $this->initialized = true;
  211.     }
  213.     /**
  214.      * @param array<string, mixed> $params
  215.      *
  216.      * @return array<string, mixed>
  217.      */
  218.     private function addDatabaseSuffix(array $params): array
  219.     {
  220.         if (isset($params['dbname']) && isset($params['dbname_suffix'])) {
  221.             $params['dbname'] .= $params['dbname_suffix'];
  222.         }
  224.         foreach ($params['replica'] ?? [] as $key => $replicaParams) {
  225.             if (! isset($replicaParams['dbname'], $replicaParams['dbname_suffix'])) {
  226.                 continue;
  227.             }
  229.             $params['replica'][$key]['dbname'] .= $replicaParams['dbname_suffix'];
  230.         }
  232.         if (isset($params['primary']['dbname'], $params['primary']['dbname_suffix'])) {
  233.             $params['primary']['dbname'] .= $params['primary']['dbname_suffix'];
  234.         }
  236.         return $params;
  237.     }
  239.     /**
  240.      * Extracts parts from a database URL, if present, and returns an
  241.      * updated list of parameters.
  242.      *
  243.      * @param mixed[] $params The list of parameters.
  244.      * @psalm-param Params $params
  245.      *
  246.      * @return mixed[] A modified list of parameters with info from a database
  247.      *                 URL extracted into individual parameter parts.
  248.      * @psalm-return Params
  249.      *
  250.      * @throws DBALException
  251.      */
  252.     private function parseDatabaseUrl(array $params): array
  253.     {
  254.         /** @psalm-suppress InvalidArrayOffset Need to be compatible with DBAL < 4, which still has `$params['url']` */
  255.         if (! isset($params['url'])) {
  256.             return $params;
  257.         }
  259.         try {
  260.             $parsedParams = $this->dsnParser->parse($params['url']);
  261.         } catch (MalformedDsnException $e) {
  262.             throw new MalformedDsnException('Malformed parameter "url".', 0, $e);
  263.         }
  265.         if (isset($parsedParams['driver'])) {
  266.             // The requested driver from the URL scheme takes precedence
  267.             // over the default custom driver from the connection parameters (if any).
  268.             unset($params['driverClass']);
  269.         }
  271.         $params = array_merge($params, $parsedParams);
  273.         // If a schemeless connection URL is given, we require a default driver or default custom driver
  274.         // as connection parameter.
  275.         if (! isset($params['driverClass']) && ! isset($params['driver'])) {
  276.             if (class_exists(DriverRequired::class)) {
  277.                 throw DriverRequired::new($params['url']);
  278.             }
  280.             throw DBALException::driverRequired($params['url']);
  281.         }
  283.         unset($params['url']);
  285.         return $params;
  286.     }
  287. }