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

  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\DriverManager;
  9. use Doctrine\DBAL\Exception as DBALException;
  10. use Doctrine\DBAL\Exception\DriverException;
  11. use Doctrine\DBAL\Platforms\AbstractMySQLPlatform;
  12. use Doctrine\DBAL\Platforms\AbstractPlatform;
  13. use Doctrine\DBAL\Types\Type;
  14. use Doctrine\Deprecations\Deprecation;
  16. use function array_merge;
  17. use function is_subclass_of;
  18. use function trigger_deprecation;
  20. use const PHP_EOL;
  22. /** @psalm-import-type Params from DriverManager */
  23. class ConnectionFactory
  24. {
  25.     /** @var mixed[][] */
  26.     private array $typesConfig = [];
  28.     private bool $initialized = false;
  30.     /** @param mixed[][] $typesConfig */
  31.     public function __construct(array $typesConfig)
  32.     {
  33.         $this->typesConfig = $typesConfig;
  34.     }
  36.     /**
  37.      * Create a connection by name.
  38.      *
  39.      * @param mixed[]               $params
  40.      * @param array<string, string> $mappingTypes
  41.      * @psalm-param Params $params
  42.      *
  43.      * @return Connection
  44.      */
  45.     public function createConnection(array $params, ?Configuration $config = null, ?EventManager $eventManager = null, array $mappingTypes = [])
  46.     {
  47.         if (! $this->initialized) {
  48.             $this->initializeTypes();
  49.         }
  51.         $overriddenOptions = [];
  52.         if (isset($params['connection_override_options'])) {
  53.             trigger_deprecation('doctrine/doctrine-bundle', '2.4', 'The "connection_override_options" connection parameter is deprecated');
  54.             $overriddenOptions = $params['connection_override_options'];
  55.             unset($params['connection_override_options']);
  56.         }
  58.         if (! isset($params['pdo']) && (! isset($params['charset']) || $overriddenOptions || isset($params['dbname_suffix']))) {
  59.             $wrapperClass = null;
  61.             if (isset($params['wrapperClass'])) {
  62.                 if (! is_subclass_of($params['wrapperClass'], Connection::class)) {
  63.                     throw DBALException::invalidWrapperClass($params['wrapperClass']);
  64.                 }
  66.                 $wrapperClass           = $params['wrapperClass'];
  67.                 $params['wrapperClass'] = null;
  68.             }
  70.             $connection = DriverManager::getConnection($params, $config, $eventManager);
  71.             $params     = $this->addDatabaseSuffix(array_merge($connection->getParams(), $overriddenOptions));
  72.             $driver     = $connection->getDriver();
  73.             $platform   = $driver->getDatabasePlatform();
  75.             if (! isset($params['charset'])) {
  76.                 if ($platform instanceof AbstractMySQLPlatform) {
  77.                     $params['charset'] = 'utf8mb4';
  79.                     if (isset($params['defaultTableOptions']['collate'])) {
  80.                         Deprecation::trigger(
  81.                             'doctrine/doctrine-bundle',
  82.                             'https://github.com/doctrine/dbal/issues/5214',
  83.                             'The "collate" default table option is deprecated in favor of "collation" and will be removed in doctrine/doctrine-bundle 3.0. '
  84.                         );
  85.                         $params['defaultTableOptions']['collation'] = $params['defaultTableOptions']['collate'];
  86.                         unset($params['defaultTableOptions']['collate']);
  87.                     }
  89.                     if (! isset($params['defaultTableOptions']['collation'])) {
  90.                         $params['defaultTableOptions']['collation'] = 'utf8mb4_unicode_ci';
  91.                     }
  92.                 } else {
  93.                     $params['charset'] = 'utf8';
  94.                 }
  95.             }
  97.             if ($wrapperClass !== null) {
  98.                 $params['wrapperClass'] = $wrapperClass;
  99.             } else {
  100.                 $wrapperClass = Connection::class;
  101.             }
  103.             $connection = new $wrapperClass($params, $driver, $config, $eventManager);
  104.         } else {
  105.             $connection = DriverManager::getConnection($params, $config, $eventManager);
  106.         }
  108.         if (! empty($mappingTypes)) {
  109.             $platform = $this->getDatabasePlatform($connection);
  110.             foreach ($mappingTypes as $dbType => $doctrineType) {
  111.                 $platform->registerDoctrineTypeMapping($dbType, $doctrineType);
  112.             }
  113.         }
  115.         return $connection;
  116.     }
  118.     /**
  119.      * Try to get the database platform.
  120.      *
  121.      * This could fail if types should be registered to an predefined/unused connection
  122.      * and the platform version is unknown.
  123.      *
  124.      * @link https://github.com/doctrine/DoctrineBundle/issues/673
  125.      *
  126.      * @throws DBALException
  127.      */
  128.     private function getDatabasePlatform(Connection $connection): AbstractPlatform
  129.     {
  130.         try {
  131.             return $connection->getDatabasePlatform();
  132.         } catch (DriverException $driverException) {
  133.             throw new DBALException(
  134.                 'An exception occurred while establishing a connection to figure out your platform version.' . PHP_EOL .
  135.                 "You can circumvent this by setting a 'server_version' configuration value" . PHP_EOL . PHP_EOL .
  136.                 'For further information have a look at:' . PHP_EOL .
  137.                 'https://github.com/doctrine/DoctrineBundle/issues/673',
  138.                 0,
  139.                 $driverException
  140.             );
  141.         }
  142.     }
  144.     /**
  145.      * initialize the types
  146.      */
  147.     private function initializeTypes(): void
  148.     {
  149.         foreach ($this->typesConfig as $typeName => $typeConfig) {
  150.             if (Type::hasType($typeName)) {
  151.                 Type::overrideType($typeName, $typeConfig['class']);
  152.             } else {
  153.                 Type::addType($typeName, $typeConfig['class']);
  154.             }
  155.         }
  157.         $this->initialized = true;
  158.     }
  160.     /**
  161.      * @param array<string, mixed> $params
  162.      *
  163.      * @return array<string, mixed>
  164.      */
  165.     private function addDatabaseSuffix(array $params): array
  166.     {
  167.         if (isset($params['dbname']) && isset($params['dbname_suffix'])) {
  168.             $params['dbname'] .= $params['dbname_suffix'];
  169.         }
  171.         foreach ($params['replica'] ?? [] as $key => $replicaParams) {
  172.             if (! isset($replicaParams['dbname'], $replicaParams['dbname_suffix'])) {
  173.                 continue;
  174.             }
  176.             $params['replica'][$key]['dbname'] .= $replicaParams['dbname_suffix'];
  177.         }
  179.         if (isset($params['primary']['dbname'], $params['primary']['dbname_suffix'])) {
  180.             $params['primary']['dbname'] .= $params['primary']['dbname_suffix'];
  181.         }
  183.         return $params;
  184.     }
  185. }