ConnectionPool.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */
 
namespace ‪TYPO3\CMS\Core\Database;
 
use Doctrine\DBAL\Configuration;
use Doctrine\DBAL\Driver\Middleware as DriverMiddleware;
use Doctrine\DBAL\DriverManager;
use Doctrine\DBAL\Events;
use Doctrine\DBAL\Types\Type;
use Doctrine\DBAL\Types\Types;
use ‪TYPO3\CMS\Core\Database\Driver\PDOMySql\Driver as PDOMySqlDriver;
use ‪TYPO3\CMS\Core\Database\Driver\PDOPgSql\Driver as PDOPgSqlDriver;
use ‪TYPO3\CMS\Core\Database\Driver\PDOSqlite\Driver as PDOSqliteDriver;
use TYPO3\CMS\Core\Database\Query\QueryBuilder;
use ‪TYPO3\CMS\Core\Database\Schema\EventListener\SchemaAlterTableListener;
use ‪TYPO3\CMS\Core\Database\Schema\EventListener\SchemaColumnDefinitionListener;
use ‪TYPO3\CMS\Core\Database\Schema\EventListener\SchemaIndexDefinitionListener;
use ‪TYPO3\CMS\Core\Database\Schema\Types\DateTimeType;
use ‪TYPO3\CMS\Core\Database\Schema\Types\DateType;
use ‪TYPO3\CMS\Core\Database\Schema\Types\EnumType;
use ‪TYPO3\CMS\Core\Database\Schema\Types\SetType;
use ‪TYPO3\CMS\Core\Database\Schema\Types\TimeType;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
 
class ‪ConnectionPool
{
    public const ‪DEFAULT_CONNECTION_NAME = 'Default';
 
    protected static ‪$connections = [];
 
    protected array ‪$customDoctrineTypes = [
        ‪EnumType::TYPE => EnumType::class,
        ‪SetType::TYPE => SetType::class,
    ];
 
    protected array ‪$overrideDoctrineTypes = [
        Types::DATE_MUTABLE => DateType::class,
        Types::DATETIME_MUTABLE => DateTimeType::class,
        Types::TIME_MUTABLE => TimeType::class,
    ];
 
    protected static ‪$driverMap = [
        'pdo_mysql' => PDOMySqlDriver::class,
        'pdo_sqlite' => PDOSqliteDriver::class,
        'pdo_pgsql' => PDOPgSqlDriver::class,
        // TODO: not supported yet, need to be checked later
//        'pdo_oci' => PDOOCIDriver::class,
//        'drizzle_pdo_mysql' => DrizzlePDOMySQLDriver::class,
    ];
 
    public function ‪getConnectionForTable(string $tableName): ‪Connection
    {
        if (empty($tableName)) {
            throw new \UnexpectedValueException(
                'ConnectionPool->getConnectionForTable() requires a table name to be provided.',
                1459421719
            );
        }
 
        $connectionName = ‪self::DEFAULT_CONNECTION_NAME;
        if (!empty(‪$GLOBALS['TYPO3_CONF_VARS']['DB']['TableMapping'][$tableName])) {
            $connectionName = (string)‪$GLOBALS['TYPO3_CONF_VARS']['DB']['TableMapping'][$tableName];
        }
 
        return $this->‪getConnectionByName($connectionName);
    }
 
    public function ‪getConnectionByName(string $connectionName): ‪Connection
    {
        if (empty($connectionName)) {
            throw new \UnexpectedValueException(
                'ConnectionPool->getConnectionByName() requires a connection name to be provided.',
                1459422125
            );
        }
 
        if (isset(static::$connections[$connectionName])) {
            return static::$connections[$connectionName];
        }
 
        $connectionParams = ‪$GLOBALS['TYPO3_CONF_VARS']['DB']['Connections'][$connectionName] ?? [];
        if (empty($connectionParams)) {
            throw new \RuntimeException(
                'The requested database connection named "' . $connectionName . '" has not been configured.',
                1459422492
            );
        }
 
        if (empty($connectionParams['wrapperClass'])) {
            $connectionParams['wrapperClass'] = Connection::class;
        }
 
        if (!is_a($connectionParams['wrapperClass'], Connection::class, true)) {
            throw new \UnexpectedValueException(
                'The "wrapperClass" for the connection name "' . $connectionName .
                '" needs to be a subclass of "' . Connection::class . '".',
                1459422968
            );
        }
 
        // Transform TYPO3 `tableoptions` to valid `doctrine/dbal` connection param option `defaultTableOptions`
        // @todo TYPO3 database configuration should be changed to directly write defaultTableOptions instead,
        //       with proper upgrade migration. Along with that, default table options for MySQL in
        //       testing-framework and core should be adjusted.
        if (isset($connectionParams['tableoptions'])) {
            $connectionParams['defaultTableOptions'] = array_replace(
                $connectionParams['defaultTableOptions'] ?? [],
                $connectionParams['tableoptions']
            );
            unset($connectionParams['tableoptions']);
        }
 
        static::$connections[$connectionName] = $this->‪getDatabaseConnection($connectionParams);
 
        return static::$connections[$connectionName];
    }
 
    protected function ‪mapCustomDriver(array $connectionParams): array
    {
        // if no custom driver is provided, map TYPO3 specific drivers
        if (!isset($connectionParams['driverClass']) && isset(static::$driverMap[$connectionParams['driver']])) {
            $connectionParams['driverClass'] = static::$driverMap[$connectionParams['driver']];
        }
 
        return $connectionParams;
    }
 
    protected function ‪getDriverMiddlewares(array $connectionParams): array
    {
        $middlewares = [];
 
        foreach ($connectionParams['driverMiddlewares'] ?? [] as $className) {
            if (!in_array(DriverMiddleware::class, class_implements($className) ?: [], true)) {
                throw new \UnexpectedValueException('Doctrine Driver Middleware must implement \Doctrine\DBAL\Driver\Middleware', 1677958727);
            }
            $middlewares[] = GeneralUtility::makeInstance($className);
        }
 
        return $middlewares;
    }
 
    protected function ‪getDatabaseConnection(array $connectionParams): Connection
    {
        $this->‪registerDoctrineTypes();
 
        // Default to UTF-8 connection charset
        if (empty($connectionParams['charset'])) {
            $connectionParams['charset'] = 'utf8';
        }
 
        $connectionParams = $this->‪mapCustomDriver($connectionParams);
        $middlewares = $this->‪getDriverMiddlewares($connectionParams);
        $configuration = $middlewares ? (new Configuration())->setMiddlewares($middlewares) : null;
 
        $conn = DriverManager::getConnection($connectionParams, $configuration);
        $conn->prepareConnection($connectionParams['initCommands'] ?? '');
 
        // Register all custom data types in the type mapping
        foreach ($this->customDoctrineTypes as $type => $className) {
            $conn->getDatabasePlatform()->registerDoctrineTypeMapping($type, $type);
        }
 
        // Register all override data types in the type mapping
        foreach ($this->overrideDoctrineTypes as $type => $className) {
            $conn->getDatabasePlatform()->registerDoctrineTypeMapping($type, $type);
        }
 
        // Handler for building custom data type column definitions
        // in the SchemaManager
        $conn->getDatabasePlatform()->getEventManager()->addEventListener(
            Events::onSchemaColumnDefinition,
            GeneralUtility::makeInstance(SchemaColumnDefinitionListener::class)
        );
 
        // Handler for enhanced index definitions in the SchemaManager
        $conn->getDatabasePlatform()->getEventManager()->addEventListener(
            Events::onSchemaIndexDefinition,
            GeneralUtility::makeInstance(SchemaIndexDefinitionListener::class)
        );
 
        // Handler for adding custom database platform options to ALTER TABLE
        // requests in the SchemaManager
        $conn->getDatabasePlatform()->getEventManager()->addEventListener(
            Events::onSchemaAlterTable,
            GeneralUtility::makeInstance(SchemaAlterTableListener::class)
        );
 
        return $conn;
    }
 
    public function ‪getQueryBuilderForTable(string $tableName): QueryBuilder
    {
        if (empty($tableName)) {
            throw new \UnexpectedValueException(
                'ConnectionPool->getQueryBuilderForTable() requires a connection name to be provided.',
                1459423448
            );
        }
 
        return $this->‪getConnectionForTable($tableName)->createQueryBuilder();
    }
 
    public function ‪getConnectionNames(): array
    {
        return array_keys(‪$GLOBALS['TYPO3_CONF_VARS']['DB']['Connections']);
    }
 
    public function ‪registerDoctrineTypes(): void
    {
        // Register custom data types
        foreach ($this->customDoctrineTypes as $type => $className) {
            if (!Type::hasType($type)) {
                Type::addType($type, $className);
            }
        }
        // Override data types
        foreach ($this->overrideDoctrineTypes as $type => $className) {
            if (!Type::hasType($type)) {
                Type::addType($type, $className);
                continue;
            }
            Type::overrideType($type, $className);
        }
    }
 
    public function ‪resetConnections(): void
    {
        static::$connections = [];
    }
}