vendor/doctrine/doctrine-bundle/ConnectionFactory.php line 82

Open in your IDE?
  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.         if (isset($params['connection_override_options'])) {
  82.             trigger_deprecation('doctrine/doctrine-bundle', '2.4', 'The "connection_override_options" connection parameter is deprecated');
  83.             $overriddenOptions = $params['connection_override_options'];
  84.             unset($params['connection_override_options']);
  85.         }
  87.         $params = $this->parseDatabaseUrl($params);
  89.         // URL support for PrimaryReplicaConnection
  90.         if (isset($params['primary'])) {
  91.             $params['primary'] = $this->parseDatabaseUrl($params['primary']);
  92.         }
  94.         if (isset($params['replica'])) {
  95.             foreach ($params['replica'] as $key => $replicaParams) {
  96.                 $params['replica'][$key] = $this->parseDatabaseUrl($replicaParams);
  97.             }
  98.         }
  100.         if (! isset($params['pdo']) && (! isset($params['charset']) || $overriddenOptions || isset($params['dbname_suffix']))) {
  101.             $wrapperClass = null;
  103.             if (isset($params['wrapperClass'])) {
  104.                 if (! is_subclass_of($params['wrapperClass'], Connection::class)) {
  105.                     if (class_exists(InvalidWrapperClass::class)) {
  106.                         throw InvalidWrapperClass::new($params['wrapperClass']);
  107.                     }
  109.                     throw DBALException::invalidWrapperClass($params['wrapperClass']);
  110.                 }
  112.                 $wrapperClass           = $params['wrapperClass'];
  113.                 $params['wrapperClass'] = null;
  114.             }
  116.             $connection = DriverManager::getConnection(...array_merge([$params, $config], $eventManager ? [$eventManager] : []));
  117.             $params     = $this->addDatabaseSuffix(array_merge($connection->getParams(), $overriddenOptions));
  118.             $driver     = $connection->getDriver();
  119.             $platform   = $driver->getDatabasePlatform(
  120.                 ...(class_exists(StaticServerVersionProvider::class) ? [new StaticServerVersionProvider($params['serverVersion'] ?? '')] : []),
  121.             );
  123.             if (! isset($params['charset'])) {
  124.                 if ($platform instanceof AbstractMySQLPlatform) {
  125.                     $params['charset'] = 'utf8mb4';
  127.                     if (isset($params['defaultTableOptions']['collate'])) {
  128.                         Deprecation::trigger(
  129.                             'doctrine/doctrine-bundle',
  130.                             'https://github.com/doctrine/dbal/issues/5214',
  131.                             'The "collate" default table option is deprecated in favor of "collation" and will be removed in doctrine/doctrine-bundle 3.0. ',
  132.                         );
  133.                         $params['defaultTableOptions']['collation'] = $params['defaultTableOptions']['collate'];
  134.                         unset($params['defaultTableOptions']['collate']);
  135.                     }
  137.                     if (! isset($params['defaultTableOptions']['collation'])) {
  138.                         $params['defaultTableOptions']['collation'] = 'utf8mb4_unicode_ci';
  139.                     }
  140.                 } else {
  141.                     $params['charset'] = 'utf8';
  142.                 }
  143.             }
  145.             if ($wrapperClass !== null) {
  146.                 $params['wrapperClass'] = $wrapperClass;
  147.             } else {
  148.                 $wrapperClass = Connection::class;
  149.             }
  151.             $connection = new $wrapperClass($params, $driver, $config, $eventManager);
  152.         } else {
  153.             $connection = DriverManager::getConnection(...array_merge([$params, $config], $eventManager ? [$eventManager] : []));
  154.         }
  156.         if (! empty($mappingTypes)) {
  157.             $platform = $this->getDatabasePlatform($connection);
  158.             foreach ($mappingTypes as $dbType => $doctrineType) {
  159.                 $platform->registerDoctrineTypeMapping($dbType, $doctrineType);
  160.             }
  161.         }
  163.         return $connection;
  164.     }
  166.     /**
  167.      * Try to get the database platform.
  168.      *
  169.      * This could fail if types should be registered to an predefined/unused connection
  170.      * and the platform version is unknown.
  171.      *
  172.      * @link https://github.com/doctrine/DoctrineBundle/issues/673
  173.      *
  174.      * @throws DBALException
  175.      */
  176.     private function getDatabasePlatform(Connection $connection): AbstractPlatform
  177.     {
  178.         try {
  179.             return $connection->getDatabasePlatform();
  180.         } catch (DriverException $driverException) {
  181.             $class = class_exists(DBALException::class) ? DBALException::class : ConnectionException::class;
  183.             throw new $class(
  184.                 'An exception occurred while establishing a connection to figure out your platform version.' . PHP_EOL .
  185.                 "You can circumvent this by setting a 'server_version' configuration value" . PHP_EOL . PHP_EOL .
  186.                 'For further information have a look at:' . PHP_EOL .
  187.                 'https://github.com/doctrine/DoctrineBundle/issues/673',
  188.                 0,
  189.                 $driverException,
  190.             );
  191.         }
  192.     }
  194.     /**
  195.      * initialize the types
  196.      */
  197.     private function initializeTypes(): void
  198.     {
  199.         foreach ($this->typesConfig as $typeName => $typeConfig) {
  200.             if (Type::hasType($typeName)) {
  201.                 Type::overrideType($typeName, $typeConfig['class']);
  202.             } else {
  203.                 Type::addType($typeName, $typeConfig['class']);
  204.             }
  205.         }
  207.         $this->initialized = true;
  208.     }
  210.     /**
  211.      * @param array<string, mixed> $params
  212.      *
  213.      * @return array<string, mixed>
  214.      */
  215.     private function addDatabaseSuffix(array $params): array
  216.     {
  217.         if (isset($params['dbname']) && isset($params['dbname_suffix'])) {
  218.             $params['dbname'] .= $params['dbname_suffix'];
  219.         }
  221.         foreach ($params['replica'] ?? [] as $key => $replicaParams) {
  222.             if (! isset($replicaParams['dbname'], $replicaParams['dbname_suffix'])) {
  223.                 continue;
  224.             }
  226.             $params['replica'][$key]['dbname'] .= $replicaParams['dbname_suffix'];
  227.         }
  229.         if (isset($params['primary']['dbname'], $params['primary']['dbname_suffix'])) {
  230.             $params['primary']['dbname'] .= $params['primary']['dbname_suffix'];
  231.         }
  233.         return $params;
  234.     }
  236.     /**
  237.      * Extracts parts from a database URL, if present, and returns an
  238.      * updated list of parameters.
  239.      *
  240.      * @param mixed[] $params The list of parameters.
  241.      * @psalm-param Params $params
  242.      *
  243.      * @return mixed[] A modified list of parameters with info from a database
  244.      *                 URL extracted into individual parameter parts.
  245.      * @psalm-return Params
  246.      *
  247.      * @throws DBALException
  248.      */
  249.     private function parseDatabaseUrl(array $params): array
  250.     {
  251.         if (! isset($params['url'])) {
  252.             return $params;
  253.         }
  255.         try {
  256.             $parsedParams = $this->dsnParser->parse($params['url']);
  257.         } catch (MalformedDsnException $e) {
  258.             throw new MalformedDsnException('Malformed parameter "url".', 0, $e);
  259.         }
  261.         if (isset($parsedParams['driver'])) {
  262.             // The requested driver from the URL scheme takes precedence
  263.             // over the default custom driver from the connection parameters (if any).
  264.             unset($params['driverClass']);
  265.         }
  267.         $params = array_merge($params, $parsedParams);
  269.         // If a schemeless connection URL is given, we require a default driver or default custom driver
  270.         // as connection parameter.
  271.         if (! isset($params['driverClass']) && ! isset($params['driver'])) {
  272.             if (class_exists(DriverRequired::class)) {
  273.                 throw DriverRequired::new($params['url']);
  274.             }
  276.             throw DBALException::driverRequired($params['url']);
  277.         }
  279.         unset($params['url']);
  281.         return $params;
  282.     }
  283. }