vendor/doctrine/dbal/lib/Doctrine/DBAL/Connection.php line 1853

Open in your IDE?
  1. <?php
  3. namespace Doctrine\DBAL;
  5. use Closure;
  6. use Doctrine\Common\EventManager;
  7. use Doctrine\DBAL\Abstraction\Result;
  8. use Doctrine\DBAL\Cache\ArrayStatement;
  9. use Doctrine\DBAL\Cache\CacheException;
  10. use Doctrine\DBAL\Cache\QueryCacheProfile;
  11. use Doctrine\DBAL\Cache\ResultCacheStatement;
  12. use Doctrine\DBAL\Driver\Connection as DriverConnection;
  13. use Doctrine\DBAL\Driver\PingableConnection;
  14. use Doctrine\DBAL\Driver\ResultStatement;
  15. use Doctrine\DBAL\Driver\ServerInfoAwareConnection;
  16. use Doctrine\DBAL\Exception\ConnectionLost;
  17. use Doctrine\DBAL\Exception\InvalidArgumentException;
  18. use Doctrine\DBAL\Exception\NoKeyValue;
  19. use Doctrine\DBAL\Platforms\AbstractPlatform;
  20. use Doctrine\DBAL\Query\Expression\ExpressionBuilder;
  21. use Doctrine\DBAL\Query\QueryBuilder;
  22. use Doctrine\DBAL\Schema\AbstractSchemaManager;
  23. use Doctrine\DBAL\Types\Type;
  24. use Throwable;
  25. use Traversable;
  27. use function array_key_exists;
  28. use function array_shift;
  29. use function assert;
  30. use function func_get_args;
  31. use function implode;
  32. use function is_int;
  33. use function is_string;
  34. use function key;
  36. /**
  37.  * A wrapper around a Doctrine\DBAL\Driver\Connection that adds features like
  38.  * events, transaction isolation levels, configuration, emulated transaction nesting,
  39.  * lazy connecting and more.
  40.  */
  41. class Connection implements DriverConnection
  42. {
  43.     /**
  44.      * Constant for transaction isolation level READ UNCOMMITTED.
  45.      *
  46.      * @deprecated Use TransactionIsolationLevel::READ_UNCOMMITTED.
  47.      */
  48.     public const TRANSACTION_READ_UNCOMMITTED = TransactionIsolationLevel::READ_UNCOMMITTED;
  50.     /**
  51.      * Constant for transaction isolation level READ COMMITTED.
  52.      *
  53.      * @deprecated Use TransactionIsolationLevel::READ_COMMITTED.
  54.      */
  55.     public const TRANSACTION_READ_COMMITTED = TransactionIsolationLevel::READ_COMMITTED;
  57.     /**
  58.      * Constant for transaction isolation level REPEATABLE READ.
  59.      *
  60.      * @deprecated Use TransactionIsolationLevel::REPEATABLE_READ.
  61.      */
  62.     public const TRANSACTION_REPEATABLE_READ = TransactionIsolationLevel::REPEATABLE_READ;
  64.     /**
  65.      * Constant for transaction isolation level SERIALIZABLE.
  66.      *
  67.      * @deprecated Use TransactionIsolationLevel::SERIALIZABLE.
  68.      */
  69.     public const TRANSACTION_SERIALIZABLE = TransactionIsolationLevel::SERIALIZABLE;
  71.     /**
  72.      * Represents an array of ints to be expanded by Doctrine SQL parsing.
  73.      */
  74.     public const PARAM_INT_ARRAY = ParameterType::INTEGER + self::ARRAY_PARAM_OFFSET;
  76.     /**
  77.      * Represents an array of strings to be expanded by Doctrine SQL parsing.
  78.      */
  79.     public const PARAM_STR_ARRAY = ParameterType::STRING + self::ARRAY_PARAM_OFFSET;
  81.     /**
  82.      * Offset by which PARAM_* constants are detected as arrays of the param type.
  83.      */
  84.     public const ARRAY_PARAM_OFFSET = 100;
  86.     /**
  87.      * The wrapped driver connection.
  88.      *
  89.      * @var \Doctrine\DBAL\Driver\Connection|null
  90.      */
  91.     protected $_conn;
  93.     /** @var Configuration */
  94.     protected $_config;
  96.     /** @var EventManager */
  97.     protected $_eventManager;
  99.     /** @var ExpressionBuilder */
  100.     protected $_expr;
  102.     /**
  103.      * The current auto-commit mode of this connection.
  104.      *
  105.      * @var bool
  106.      */
  107.     private $autoCommit = true;
  109.     /**
  110.      * The transaction nesting level.
  111.      *
  112.      * @var int
  113.      */
  114.     private $transactionNestingLevel = 0;
  116.     /**
  117.      * The currently active transaction isolation level.
  118.      *
  119.      * @var int
  120.      */
  121.     private $transactionIsolationLevel;
  123.     /**
  124.      * If nested transactions should use savepoints.
  125.      *
  126.      * @var bool
  127.      */
  128.     private $nestTransactionsWithSavepoints = false;
  130.     /**
  131.      * The parameters used during creation of the Connection instance.
  132.      *
  133.      * @var mixed[]
  134.      */
  135.     private $params = [];
  137.     /**
  138.      * The DatabasePlatform object that provides information about the
  139.      * database platform used by the connection.
  140.      *
  141.      * @var AbstractPlatform
  142.      */
  143.     private $platform;
  145.     /**
  146.      * The schema manager.
  147.      *
  148.      * @var AbstractSchemaManager|null
  149.      */
  150.     protected $_schemaManager;
  152.     /**
  153.      * The used DBAL driver.
  154.      *
  155.      * @var Driver
  156.      */
  157.     protected $_driver;
  159.     /**
  160.      * Flag that indicates whether the current transaction is marked for rollback only.
  161.      *
  162.      * @var bool
  163.      */
  164.     private $isRollbackOnly = false;
  166.     /** @var int */
  167.     protected $defaultFetchMode = FetchMode::ASSOCIATIVE;
  169.     /**
  170.      * Initializes a new instance of the Connection class.
  171.      *
  172.      * @internal The connection can be only instantiated by the driver manager.
  173.      *
  174.      * @param mixed[]            $params       The connection parameters.
  175.      * @param Driver             $driver       The driver to use.
  176.      * @param Configuration|null $config       The configuration, optional.
  177.      * @param EventManager|null  $eventManager The event manager, optional.
  178.      *
  179.      * @throws Exception
  180.      */
  181.     public function __construct(
  182.         array $params,
  183.         Driver $driver,
  184.         ?Configuration $config = null,
  185.         ?EventManager $eventManager = null
  186.     ) {
  187.         $this->_driver = $driver;
  188.         $this->params  = $params;
  190.         if (isset($params['pdo'])) {
  191.             $this->_conn = $params['pdo'];
  192.             unset($this->params['pdo']);
  193.         }
  195.         if (isset($params['platform'])) {
  196.             if (! $params['platform'] instanceof Platforms\AbstractPlatform) {
  197.                 throw Exception::invalidPlatformType($params['platform']);
  198.             }
  200.             $this->platform = $params['platform'];
  201.         }
  203.         // Create default config and event manager if none given
  204.         if (! $config) {
  205.             $config = new Configuration();
  206.         }
  208.         if (! $eventManager) {
  209.             $eventManager = new EventManager();
  210.         }
  212.         $this->_config       = $config;
  213.         $this->_eventManager = $eventManager;
  215.         $this->_expr = new Query\Expression\ExpressionBuilder($this);
  217.         $this->autoCommit = $config->getAutoCommit();
  218.     }
  220.     /**
  221.      * Gets the parameters used during instantiation.
  222.      *
  223.      * @internal
  224.      *
  225.      * @return mixed[]
  226.      */
  227.     public function getParams()
  228.     {
  229.         return $this->params;
  230.     }
  232.     /**
  233.      * Gets the name of the database this Connection is connected to.
  234.      *
  235.      * @return string
  236.      */
  237.     public function getDatabase()
  238.     {
  239.         return $this->_driver->getDatabase($this);
  240.     }
  242.     /**
  243.      * Gets the hostname of the currently connected database.
  244.      *
  245.      * @deprecated
  246.      *
  247.      * @return string|null
  248.      */
  249.     public function getHost()
  250.     {
  251.         return $this->params['host'] ?? null;
  252.     }
  254.     /**
  255.      * Gets the port of the currently connected database.
  256.      *
  257.      * @deprecated
  258.      *
  259.      * @return mixed
  260.      */
  261.     public function getPort()
  262.     {
  263.         return $this->params['port'] ?? null;
  264.     }
  266.     /**
  267.      * Gets the username used by this connection.
  268.      *
  269.      * @deprecated
  270.      *
  271.      * @return string|null
  272.      */
  273.     public function getUsername()
  274.     {
  275.         return $this->params['user'] ?? null;
  276.     }
  278.     /**
  279.      * Gets the password used by this connection.
  280.      *
  281.      * @deprecated
  282.      *
  283.      * @return string|null
  284.      */
  285.     public function getPassword()
  286.     {
  287.         return $this->params['password'] ?? null;
  288.     }
  290.     /**
  291.      * Gets the DBAL driver instance.
  292.      *
  293.      * @return Driver
  294.      */
  295.     public function getDriver()
  296.     {
  297.         return $this->_driver;
  298.     }
  300.     /**
  301.      * Gets the Configuration used by the Connection.
  302.      *
  303.      * @return Configuration
  304.      */
  305.     public function getConfiguration()
  306.     {
  307.         return $this->_config;
  308.     }
  310.     /**
  311.      * Gets the EventManager used by the Connection.
  312.      *
  313.      * @return EventManager
  314.      */
  315.     public function getEventManager()
  316.     {
  317.         return $this->_eventManager;
  318.     }
  320.     /**
  321.      * Gets the DatabasePlatform for the connection.
  322.      *
  323.      * @return AbstractPlatform
  324.      *
  325.      * @throws Exception
  326.      */
  327.     public function getDatabasePlatform()
  328.     {
  329.         if ($this->platform === null) {
  330.             $this->detectDatabasePlatform();
  331.         }
  333.         return $this->platform;
  334.     }
  336.     /**
  337.      * Gets the ExpressionBuilder for the connection.
  338.      *
  339.      * @return ExpressionBuilder
  340.      */
  341.     public function getExpressionBuilder()
  342.     {
  343.         return $this->_expr;
  344.     }
  346.     /**
  347.      * Establishes the connection with the database.
  348.      *
  349.      * @return bool TRUE if the connection was successfully established, FALSE if
  350.      *              the connection is already open.
  351.      */
  352.     public function connect()
  353.     {
  354.         if ($this->_conn !== null) {
  355.             return false;
  356.         }
  358.         $driverOptions = $this->params['driverOptions'] ?? [];
  359.         $user          = $this->params['user'] ?? null;
  360.         $password      = $this->params['password'] ?? null;
  362.         $this->_conn = $this->_driver->connect($this->params, $user, $password, $driverOptions);
  364.         $this->transactionNestingLevel = 0;
  366.         if ($this->autoCommit === false) {
  367.             $this->beginTransaction();
  368.         }
  370.         if ($this->_eventManager->hasListeners(Events::postConnect)) {
  371.             $eventArgs = new Event\ConnectionEventArgs($this);
  372.             $this->_eventManager->dispatchEvent(Events::postConnect, $eventArgs);
  373.         }
  375.         return true;
  376.     }
  378.     /**
  379.      * Detects and sets the database platform.
  380.      *
  381.      * Evaluates custom platform class and version in order to set the correct platform.
  382.      *
  383.      * @throws Exception If an invalid platform was specified for this connection.
  384.      */
  385.     private function detectDatabasePlatform(): void
  386.     {
  387.         $version = $this->getDatabasePlatformVersion();
  389.         if ($version !== null) {
  390.             assert($this->_driver instanceof VersionAwarePlatformDriver);
  392.             $this->platform = $this->_driver->createDatabasePlatformForVersion($version);
  393.         } else {
  394.             $this->platform = $this->_driver->getDatabasePlatform();
  395.         }
  397.         $this->platform->setEventManager($this->_eventManager);
  398.     }
  400.     /**
  401.      * Returns the version of the related platform if applicable.
  402.      *
  403.      * Returns null if either the driver is not capable to create version
  404.      * specific platform instances, no explicit server version was specified
  405.      * or the underlying driver connection cannot determine the platform
  406.      * version without having to query it (performance reasons).
  407.      *
  408.      * @return string|null
  409.      *
  410.      * @throws Throwable
  411.      */
  412.     private function getDatabasePlatformVersion()
  413.     {
  414.         // Driver does not support version specific platforms.
  415.         if (! $this->_driver instanceof VersionAwarePlatformDriver) {
  416.             return null;
  417.         }
  419.         // Explicit platform version requested (supersedes auto-detection).
  420.         if (isset($this->params['serverVersion'])) {
  421.             return $this->params['serverVersion'];
  422.         }
  424.         // If not connected, we need to connect now to determine the platform version.
  425.         if ($this->_conn === null) {
  426.             try {
  427.                 $this->connect();
  428.             } catch (Throwable $originalException) {
  429.                 if (empty($this->params['dbname'])) {
  430.                     throw $originalException;
  431.                 }
  433.                 // The database to connect to might not yet exist.
  434.                 // Retry detection without database name connection parameter.
  435.                 $databaseName           = $this->params['dbname'];
  436.                 $this->params['dbname'] = null;
  438.                 try {
  439.                     $this->connect();
  440.                 } catch (Throwable $fallbackException) {
  441.                     // Either the platform does not support database-less connections
  442.                     // or something else went wrong.
  443.                     // Reset connection parameters and rethrow the original exception.
  444.                     $this->params['dbname'] = $databaseName;
  446.                     throw $originalException;
  447.                 }
  449.                 // Reset connection parameters.
  450.                 $this->params['dbname'] = $databaseName;
  451.                 $serverVersion          = $this->getServerVersion();
  453.                 // Close "temporary" connection to allow connecting to the real database again.
  454.                 $this->close();
  456.                 return $serverVersion;
  457.             }
  458.         }
  460.         return $this->getServerVersion();
  461.     }
  463.     /**
  464.      * Returns the database server version if the underlying driver supports it.
  465.      *
  466.      * @return string|null
  467.      */
  468.     private function getServerVersion()
  469.     {
  470.         $connection = $this->getWrappedConnection();
  472.         // Automatic platform version detection.
  473.         if ($connection instanceof ServerInfoAwareConnection && ! $connection->requiresQueryForServerVersion()) {
  474.             return $connection->getServerVersion();
  475.         }
  477.         // Unable to detect platform version.
  478.         return null;
  479.     }
  481.     /**
  482.      * Returns the current auto-commit mode for this connection.
  483.      *
  484.      * @see    setAutoCommit
  485.      *
  486.      * @return bool True if auto-commit mode is currently enabled for this connection, false otherwise.
  487.      */
  488.     public function isAutoCommit()
  489.     {
  490.         return $this->autoCommit === true;
  491.     }
  493.     /**
  494.      * Sets auto-commit mode for this connection.
  495.      *
  496.      * If a connection is in auto-commit mode, then all its SQL statements will be executed and committed as individual
  497.      * transactions. Otherwise, its SQL statements are grouped into transactions that are terminated by a call to either
  498.      * the method commit or the method rollback. By default, new connections are in auto-commit mode.
  499.      *
  500.      * NOTE: If this method is called during a transaction and the auto-commit mode is changed, the transaction is
  501.      * committed. If this method is called and the auto-commit mode is not changed, the call is a no-op.
  502.      *
  503.      * @see   isAutoCommit
  504.      *
  505.      * @param bool $autoCommit True to enable auto-commit mode; false to disable it.
  506.      *
  507.      * @return void
  508.      */
  509.     public function setAutoCommit($autoCommit)
  510.     {
  511.         $autoCommit = (bool) $autoCommit;
  513.         // Mode not changed, no-op.
  514.         if ($autoCommit === $this->autoCommit) {
  515.             return;
  516.         }
  518.         $this->autoCommit = $autoCommit;
  520.         // Commit all currently active transactions if any when switching auto-commit mode.
  521.         if ($this->_conn === null || $this->transactionNestingLevel === 0) {
  522.             return;
  523.         }
  525.         $this->commitAll();
  526.     }
  528.     /**
  529.      * Sets the fetch mode.
  530.      *
  531.      * @deprecated Use one of the fetch- or iterate-related methods.
  532.      *
  533.      * @param int $fetchMode
  534.      *
  535.      * @return void
  536.      */
  537.     public function setFetchMode($fetchMode)
  538.     {
  539.         $this->defaultFetchMode = $fetchMode;
  540.     }
  542.     /**
  543.      * Prepares and executes an SQL query and returns the first row of the result
  544.      * as an associative array.
  545.      *
  546.      * @deprecated Use fetchAssociative()
  547.      *
  548.      * @param string                                                               $sql    SQL query
  549.      * @param array<int, mixed>|array<string, mixed>                               $params Query parameters
  550.      * @param array<int, int|string|Type|null>|array<string, int|string|Type|null> $types  Parameter types
  551.      *
  552.      * @return array<string, mixed>|false False is returned if no rows are found.
  553.      *
  554.      * @throws Exception
  555.      */
  556.     public function fetchAssoc($sql, array $params = [], array $types = [])
  557.     {
  558.         return $this->executeQuery($sql, $params, $types)->fetch(FetchMode::ASSOCIATIVE);
  559.     }
  561.     /**
  562.      * Prepares and executes an SQL query and returns the first row of the result
  563.      * as a numerically indexed array.
  564.      *
  565.      * @deprecated Use fetchNumeric()
  566.      *
  567.      * @param string                                                               $sql    SQL query
  568.      * @param array<int, mixed>|array<string, mixed>                               $params Query parameters
  569.      * @param array<int, int|string|Type|null>|array<string, int|string|Type|null> $types  Parameter types
  570.      *
  571.      * @return array<int, mixed>|false False is returned if no rows are found.
  572.      */
  573.     public function fetchArray($sql, array $params = [], array $types = [])
  574.     {
  575.         return $this->executeQuery($sql, $params, $types)->fetch(FetchMode::NUMERIC);
  576.     }
  578.     /**
  579.      * Prepares and executes an SQL query and returns the value of a single column
  580.      * of the first row of the result.
  581.      *
  582.      * @deprecated Use fetchOne() instead.
  583.      *
  584.      * @param string                                                               $sql    SQL query
  585.      * @param array<int, mixed>|array<string, mixed>                               $params Query parameters
  586.      * @param int                                                                  $column 0-indexed column number
  587.      * @param array<int, int|string|Type|null>|array<string, int|string|Type|null> $types  Parameter types
  588.      *
  589.      * @return mixed|false False is returned if no rows are found.
  590.      *
  591.      * @throws Exception
  592.      */
  593.     public function fetchColumn($sql, array $params = [], $column = 0, array $types = [])
  594.     {
  595.         return $this->executeQuery($sql, $params, $types)->fetchColumn($column);
  596.     }
  598.     /**
  599.      * Prepares and executes an SQL query and returns the first row of the result
  600.      * as an associative array.
  601.      *
  602.      * @param string                                                               $query  SQL query
  603.      * @param array<int, mixed>|array<string, mixed>                               $params Query parameters
  604.      * @param array<int, int|string|Type|null>|array<string, int|string|Type|null> $types  Parameter types
  605.      *
  606.      * @return array<string, mixed>|false False is returned if no rows are found.
  607.      *
  608.      * @throws Exception
  609.      */
  610.     public function fetchAssociative(string $query, array $params = [], array $types = [])
  611.     {
  612.         try {
  613.             $stmt = $this->executeQuery($query, $params, $types);
  615.             if ($stmt instanceof Result) {
  616.                 return $stmt->fetchAssociative();
  617.             }
  619.             return $stmt->fetch(FetchMode::ASSOCIATIVE);
  620.         } catch (Throwable $e) {
  621.             $this->handleExceptionDuringQuery($e, $query, $params, $types);
  622.         }
  623.     }
  625.     /**
  626.      * Prepares and executes an SQL query and returns the first row of the result
  627.      * as a numerically indexed array.
  628.      *
  629.      * @param string                                                               $query  SQL query
  630.      * @param array<int, mixed>|array<string, mixed>                               $params Query parameters
  631.      * @param array<int, int|string|Type|null>|array<string, int|string|Type|null> $types  Parameter types
  632.      *
  633.      * @return array<int, mixed>|false False is returned if no rows are found.
  634.      *
  635.      * @throws Exception
  636.      */
  637.     public function fetchNumeric(string $query, array $params = [], array $types = [])
  638.     {
  639.         try {
  640.             $stmt = $this->executeQuery($query, $params, $types);
  642.             if ($stmt instanceof Result) {
  643.                 return $stmt->fetchNumeric();
  644.             }
  646.             return $stmt->fetch(FetchMode::NUMERIC);
  647.         } catch (Throwable $e) {
  648.             $this->handleExceptionDuringQuery($e, $query, $params, $types);
  649.         }
  650.     }
  652.     /**
  653.      * Prepares and executes an SQL query and returns the value of a single column
  654.      * of the first row of the result.
  655.      *
  656.      * @param string                                                               $query  SQL query
  657.      * @param array<int, mixed>|array<string, mixed>                               $params Query parameters
  658.      * @param array<int, int|string|Type|null>|array<string, int|string|Type|null> $types  Parameter types
  659.      *
  660.      * @return mixed|false False is returned if no rows are found.
  661.      *
  662.      * @throws Exception
  663.      */
  664.     public function fetchOne(string $query, array $params = [], array $types = [])
  665.     {
  666.         try {
  667.             $stmt = $this->executeQuery($query, $params, $types);
  669.             if ($stmt instanceof Result) {
  670.                 return $stmt->fetchOne();
  671.             }
  673.             return $stmt->fetch(FetchMode::COLUMN);
  674.         } catch (Throwable $e) {
  675.             $this->handleExceptionDuringQuery($e, $query, $params, $types);
  676.         }
  677.     }
  679.     /**
  680.      * Whether an actual connection to the database is established.
  681.      *
  682.      * @return bool
  683.      */
  684.     public function isConnected()
  685.     {
  686.         return $this->_conn !== null;
  687.     }
  689.     /**
  690.      * Checks whether a transaction is currently active.
  691.      *
  692.      * @return bool TRUE if a transaction is currently active, FALSE otherwise.
  693.      */
  694.     public function isTransactionActive()
  695.     {
  696.         return $this->transactionNestingLevel > 0;
  697.     }
  699.     /**
  700.      * Adds condition based on the criteria to the query components
  701.      *
  702.      * @param mixed[]  $criteria   Map of key columns to their values
  703.      * @param string[] $columns    Column names
  704.      * @param mixed[]  $values     Column values
  705.      * @param string[] $conditions Key conditions
  706.      *
  707.      * @throws Exception
  708.      */
  709.     private function addCriteriaCondition(
  710.         array $criteria,
  711.         array &$columns,
  712.         array &$values,
  713.         array &$conditions
  714.     ): void {
  715.         $platform = $this->getDatabasePlatform();
  717.         foreach ($criteria as $columnName => $value) {
  718.             if ($value === null) {
  719.                 $conditions[] = $platform->getIsNullExpression($columnName);
  720.                 continue;
  721.             }
  723.             $columns[]    = $columnName;
  724.             $values[]     = $value;
  725.             $conditions[] = $columnName . ' = ?';
  726.         }
  727.     }
  729.     /**
  730.      * Executes an SQL DELETE statement on a table.
  731.      *
  732.      * Table expression and columns are not escaped and are not safe for user-input.
  733.      *
  734.      * @param string                                                               $table    Table name
  735.      * @param array<string, mixed>                                                 $criteria Deletion criteria
  736.      * @param array<int, int|string|Type|null>|array<string, int|string|Type|null> $types    Parameter types
  737.      *
  738.      * @return int The number of affected rows.
  739.      *
  740.      * @throws Exception
  741.      */
  742.     public function delete($table, array $criteria, array $types = [])
  743.     {
  744.         if (empty($criteria)) {
  745.             throw InvalidArgumentException::fromEmptyCriteria();
  746.         }
  748.         $columns = $values = $conditions = [];
  750.         $this->addCriteriaCondition($criteria, $columns, $values, $conditions);
  752.         return $this->executeStatement(
  753.             'DELETE FROM ' . $table . ' WHERE ' . implode(' AND ', $conditions),
  754.             $values,
  755.             is_string(key($types)) ? $this->extractTypeValues($columns, $types) : $types
  756.         );
  757.     }
  759.     /**
  760.      * Closes the connection.
  761.      *
  762.      * @return void
  763.      */
  764.     public function close()
  765.     {
  766.         $this->_conn = null;
  767.     }
  769.     /**
  770.      * Sets the transaction isolation level.
  771.      *
  772.      * @param int $level The level to set.
  773.      *
  774.      * @return int
  775.      */
  776.     public function setTransactionIsolation($level)
  777.     {
  778.         $this->transactionIsolationLevel = $level;
  780.         return $this->executeStatement($this->getDatabasePlatform()->getSetTransactionIsolationSQL($level));
  781.     }
  783.     /**
  784.      * Gets the currently active transaction isolation level.
  785.      *
  786.      * @return int The current transaction isolation level.
  787.      */
  788.     public function getTransactionIsolation()
  789.     {
  790.         if ($this->transactionIsolationLevel === null) {
  791.             $this->transactionIsolationLevel = $this->getDatabasePlatform()->getDefaultTransactionIsolationLevel();
  792.         }
  794.         return $this->transactionIsolationLevel;
  795.     }
  797.     /**
  798.      * Executes an SQL UPDATE statement on a table.
  799.      *
  800.      * Table expression and columns are not escaped and are not safe for user-input.
  801.      *
  802.      * @param string                                                               $table    Table name
  803.      * @param array<string, mixed>                                                 $data     Column-value pairs
  804.      * @param array<string, mixed>                                                 $criteria Update criteria
  805.      * @param array<int, int|string|Type|null>|array<string, int|string|Type|null> $types    Parameter types
  806.      *
  807.      * @return int The number of affected rows.
  808.      *
  809.      * @throws Exception
  810.      */
  811.     public function update($table, array $data, array $criteria, array $types = [])
  812.     {
  813.         $columns = $values = $conditions = $set = [];
  815.         foreach ($data as $columnName => $value) {
  816.             $columns[] = $columnName;
  817.             $values[]  = $value;
  818.             $set[]     = $columnName . ' = ?';
  819.         }
  821.         $this->addCriteriaCondition($criteria, $columns, $values, $conditions);
  823.         if (is_string(key($types))) {
  824.             $types = $this->extractTypeValues($columns, $types);
  825.         }
  827.         $sql = 'UPDATE ' . $table . ' SET ' . implode(', ', $set)
  828.                 . ' WHERE ' . implode(' AND ', $conditions);
  830.         return $this->executeStatement($sql, $values, $types);
  831.     }
  833.     /**
  834.      * Inserts a table row with specified data.
  835.      *
  836.      * Table expression and columns are not escaped and are not safe for user-input.
  837.      *
  838.      * @param string                                                               $table Table name
  839.      * @param array<string, mixed>                                                 $data  Column-value pairs
  840.      * @param array<int, int|string|Type|null>|array<string, int|string|Type|null> $types Parameter types
  841.      *
  842.      * @return int The number of affected rows.
  843.      *
  844.      * @throws Exception
  845.      */
  846.     public function insert($table, array $data, array $types = [])
  847.     {
  848.         if (empty($data)) {
  849.             return $this->executeStatement('INSERT INTO ' . $table . ' () VALUES ()');
  850.         }
  852.         $columns = [];
  853.         $values  = [];
  854.         $set     = [];
  856.         foreach ($data as $columnName => $value) {
  857.             $columns[] = $columnName;
  858.             $values[]  = $value;
  859.             $set[]     = '?';
  860.         }
  862.         return $this->executeStatement(
  863.             'INSERT INTO ' . $table . ' (' . implode(', ', $columns) . ')' .
  864.             ' VALUES (' . implode(', ', $set) . ')',
  865.             $values,
  866.             is_string(key($types)) ? $this->extractTypeValues($columns, $types) : $types
  867.         );
  868.     }
  870.     /**
  871.      * Extract ordered type list from an ordered column list and type map.
  872.      *
  873.      * @param array<int, string>                                                   $columnList
  874.      * @param array<int, int|string|Type|null>|array<string, int|string|Type|null> $types
  875.      *
  876.      * @return array<int, int|string|Type|null>|array<string, int|string|Type|null>
  877.      */
  878.     private function extractTypeValues(array $columnList, array $types)
  879.     {
  880.         $typeValues = [];
  882.         foreach ($columnList as $columnIndex => $columnName) {
  883.             $typeValues[] = $types[$columnName] ?? ParameterType::STRING;
  884.         }
  886.         return $typeValues;
  887.     }
  889.     /**
  890.      * Quotes a string so it can be safely used as a table or column name, even if
  891.      * it is a reserved name.
  892.      *
  893.      * Delimiting style depends on the underlying database platform that is being used.
  894.      *
  895.      * NOTE: Just because you CAN use quoted identifiers does not mean
  896.      * you SHOULD use them. In general, they end up causing way more
  897.      * problems than they solve.
  898.      *
  899.      * @param string $str The name to be quoted.
  900.      *
  901.      * @return string The quoted name.
  902.      */
  903.     public function quoteIdentifier($str)
  904.     {
  905.         return $this->getDatabasePlatform()->quoteIdentifier($str);
  906.     }
  908.     /**
  909.      * {@inheritDoc}
  910.      *
  911.      * @param int|string|Type|null $type
  912.      */
  913.     public function quote($value, $type = ParameterType::STRING)
  914.     {
  915.         $connection = $this->getWrappedConnection();
  917.         [$value, $bindingType] = $this->getBindingInfo($value, $type);
  919.         return $connection->quote($value, $bindingType);
  920.     }
  922.     /**
  923.      * Prepares and executes an SQL query and returns the result as an associative array.
  924.      *
  925.      * @deprecated Use fetchAllAssociative()
  926.      *
  927.      * @param string         $sql    The SQL query.
  928.      * @param mixed[]        $params The query parameters.
  929.      * @param int[]|string[] $types  The query parameter types.
  930.      *
  931.      * @return mixed[]
  932.      */
  933.     public function fetchAll($sql, array $params = [], $types = [])
  934.     {
  935.         return $this->executeQuery($sql, $params, $types)->fetchAll();
  936.     }
  938.     /**
  939.      * Prepares and executes an SQL query and returns the result as an array of numeric arrays.
  940.      *
  941.      * @param string                                                               $query  SQL query
  942.      * @param array<int, mixed>|array<string, mixed>                               $params Query parameters
  943.      * @param array<int, int|string|Type|null>|array<string, int|string|Type|null> $types  Parameter types
  944.      *
  945.      * @return array<int,array<int,mixed>>
  946.      *
  947.      * @throws Exception
  948.      */
  949.     public function fetchAllNumeric(string $query, array $params = [], array $types = []): array
  950.     {
  951.         try {
  952.             $stmt = $this->executeQuery($query, $params, $types);
  954.             if ($stmt instanceof Result) {
  955.                 return $stmt->fetchAllNumeric();
  956.             }
  958.             return $stmt->fetchAll(FetchMode::NUMERIC);
  959.         } catch (Throwable $e) {
  960.             $this->handleExceptionDuringQuery($e, $query, $params, $types);
  961.         }
  962.     }
  964.     /**
  965.      * Prepares and executes an SQL query and returns the result as an array of associative arrays.
  966.      *
  967.      * @param string                                                               $query  SQL query
  968.      * @param array<int, mixed>|array<string, mixed>                               $params Query parameters
  969.      * @param array<int, int|string|Type|null>|array<string, int|string|Type|null> $types  Parameter types
  970.      *
  971.      * @return array<int,array<string,mixed>>
  972.      *
  973.      * @throws Exception
  974.      */
  975.     public function fetchAllAssociative(string $query, array $params = [], array $types = []): array
  976.     {
  977.         try {
  978.             $stmt = $this->executeQuery($query, $params, $types);
  980.             if ($stmt instanceof Result) {
  981.                 return $stmt->fetchAllAssociative();
  982.             }
  984.             return $stmt->fetchAll(FetchMode::ASSOCIATIVE);
  985.         } catch (Throwable $e) {
  986.             $this->handleExceptionDuringQuery($e, $query, $params, $types);
  987.         }
  988.     }
  990.     /**
  991.      * Prepares and executes an SQL query and returns the result as an associative array with the keys
  992.      * mapped to the first column and the values mapped to the second column.
  993.      *
  994.      * @param string                                           $query  SQL query
  995.      * @param array<int, mixed>|array<string, mixed>           $params Query parameters
  996.      * @param array<int, int|string>|array<string, int|string> $types  Parameter types
  997.      *
  998.      * @return array<mixed,mixed>
  999.      *
  1000.      * @throws Exception
  1001.      */
  1002.     public function fetchAllKeyValue(string $query, array $params = [], array $types = []): array
  1003.     {
  1004.         $stmt = $this->executeQuery($query, $params, $types);
  1006.         $this->ensureHasKeyValue($stmt);
  1008.         $data = [];
  1010.         foreach ($stmt->fetchAll(FetchMode::NUMERIC) as [$key, $value]) {
  1011.             $data[$key] = $value;
  1012.         }
  1014.         return $data;
  1015.     }
  1017.     /**
  1018.      * Prepares and executes an SQL query and returns the result as an associative array with the keys mapped
  1019.      * to the first column and the values being an associative array representing the rest of the columns
  1020.      * and their values.
  1021.      *
  1022.      * @param string                                           $query  SQL query
  1023.      * @param array<int, mixed>|array<string, mixed>           $params Query parameters
  1024.      * @param array<int, int|string>|array<string, int|string> $types  Parameter types
  1025.      *
  1026.      * @return array<mixed,array<string,mixed>>
  1027.      *
  1028.      * @throws Exception
  1029.      */
  1030.     public function fetchAllAssociativeIndexed(string $query, array $params = [], array $types = []): array
  1031.     {
  1032.         $stmt = $this->executeQuery($query, $params, $types);
  1034.         $data = [];
  1036.         foreach ($stmt->fetchAll(FetchMode::ASSOCIATIVE) as $row) {
  1037.             $data[array_shift($row)] = $row;
  1038.         }
  1040.         return $data;
  1041.     }
  1043.     /**
  1044.      * Prepares and executes an SQL query and returns the result as an array of the first column values.
  1045.      *
  1046.      * @param string                                                               $query  SQL query
  1047.      * @param array<int, mixed>|array<string, mixed>                               $params Query parameters
  1048.      * @param array<int, int|string|Type|null>|array<string, int|string|Type|null> $types  Parameter types
  1049.      *
  1050.      * @return array<int,mixed>
  1051.      *
  1052.      * @throws Exception
  1053.      */
  1054.     public function fetchFirstColumn(string $query, array $params = [], array $types = []): array
  1055.     {
  1056.         try {
  1057.             $stmt = $this->executeQuery($query, $params, $types);
  1059.             if ($stmt instanceof Result) {
  1060.                 return $stmt->fetchFirstColumn();
  1061.             }
  1063.             return $stmt->fetchAll(FetchMode::COLUMN);
  1064.         } catch (Throwable $e) {
  1065.             $this->handleExceptionDuringQuery($e, $query, $params, $types);
  1066.         }
  1067.     }
  1069.     /**
  1070.      * Prepares and executes an SQL query and returns the result as an iterator over rows represented as numeric arrays.
  1071.      *
  1072.      * @param string                                                               $query  SQL query
  1073.      * @param array<int, mixed>|array<string, mixed>                               $params Query parameters
  1074.      * @param array<int, int|string|Type|null>|array<string, int|string|Type|null> $types  Parameter types
  1075.      *
  1076.      * @return Traversable<int,array<int,mixed>>
  1077.      *
  1078.      * @throws Exception
  1079.      */
  1080.     public function iterateNumeric(string $query, array $params = [], array $types = []): Traversable
  1081.     {
  1082.         try {
  1083.             $stmt = $this->executeQuery($query, $params, $types);
  1085.             if ($stmt instanceof Result) {
  1086.                 yield from $stmt->iterateNumeric();
  1087.             } else {
  1088.                 while (($row = $stmt->fetch(FetchMode::NUMERIC)) !== false) {
  1089.                     yield $row;
  1090.                 }
  1091.             }
  1092.         } catch (Throwable $e) {
  1093.             $this->handleExceptionDuringQuery($e, $query, $params, $types);
  1094.         }
  1095.     }
  1097.     /**
  1098.      * Prepares and executes an SQL query and returns the result as an iterator over rows represented
  1099.      * as associative arrays.
  1100.      *
  1101.      * @param string                                                               $query  SQL query
  1102.      * @param array<int, mixed>|array<string, mixed>                               $params Query parameters
  1103.      * @param array<int, int|string|Type|null>|array<string, int|string|Type|null> $types  Parameter types
  1104.      *
  1105.      * @return Traversable<int,array<string,mixed>>
  1106.      *
  1107.      * @throws Exception
  1108.      */
  1109.     public function iterateAssociative(string $query, array $params = [], array $types = []): Traversable
  1110.     {
  1111.         try {
  1112.             $stmt = $this->executeQuery($query, $params, $types);
  1114.             if ($stmt instanceof Result) {
  1115.                 yield from $stmt->iterateAssociative();
  1116.             } else {
  1117.                 while (($row = $stmt->fetch(FetchMode::ASSOCIATIVE)) !== false) {
  1118.                     yield $row;
  1119.                 }
  1120.             }
  1121.         } catch (Throwable $e) {
  1122.             $this->handleExceptionDuringQuery($e, $query, $params, $types);
  1123.         }
  1124.     }
  1126.     /**
  1127.      * Prepares and executes an SQL query and returns the result as an iterator with the keys
  1128.      * mapped to the first column and the values mapped to the second column.
  1129.      *
  1130.      * @param string                                           $query  SQL query
  1131.      * @param array<int, mixed>|array<string, mixed>           $params Query parameters
  1132.      * @param array<int, int|string>|array<string, int|string> $types  Parameter types
  1133.      *
  1134.      * @return Traversable<mixed,mixed>
  1135.      *
  1136.      * @throws Exception
  1137.      */
  1138.     public function iterateKeyValue(string $query, array $params = [], array $types = []): Traversable
  1139.     {
  1140.         $stmt = $this->executeQuery($query, $params, $types);
  1142.         $this->ensureHasKeyValue($stmt);
  1144.         while (($row = $stmt->fetch(FetchMode::NUMERIC)) !== false) {
  1145.             yield $row[0] => $row[1];
  1146.         }
  1147.     }
  1149.     /**
  1150.      * Prepares and executes an SQL query and returns the result as an iterator with the keys mapped
  1151.      * to the first column and the values being an associative array representing the rest of the columns
  1152.      * and their values.
  1153.      *
  1154.      * @param string                                           $query  SQL query
  1155.      * @param array<int, mixed>|array<string, mixed>           $params Query parameters
  1156.      * @param array<int, int|string>|array<string, int|string> $types  Parameter types
  1157.      *
  1158.      * @return Traversable<mixed,array<string,mixed>>
  1159.      *
  1160.      * @throws Exception
  1161.      */
  1162.     public function iterateAssociativeIndexed(string $query, array $params = [], array $types = []): Traversable
  1163.     {
  1164.         $stmt = $this->executeQuery($query, $params, $types);
  1166.         while (($row = $stmt->fetch(FetchMode::ASSOCIATIVE)) !== false) {
  1167.             yield array_shift($row) => $row;
  1168.         }
  1169.     }
  1171.     /**
  1172.      * Prepares and executes an SQL query and returns the result as an iterator over the first column values.
  1173.      *
  1174.      * @param string                                                               $query  SQL query
  1175.      * @param array<int, mixed>|array<string, mixed>                               $params Query parameters
  1176.      * @param array<int, int|string|Type|null>|array<string, int|string|Type|null> $types  Parameter types
  1177.      *
  1178.      * @return Traversable<int,mixed>
  1179.      *
  1180.      * @throws Exception
  1181.      */
  1182.     public function iterateColumn(string $query, array $params = [], array $types = []): Traversable
  1183.     {
  1184.         try {
  1185.             $stmt = $this->executeQuery($query, $params, $types);
  1187.             if ($stmt instanceof Result) {
  1188.                 yield from $stmt->iterateColumn();
  1189.             } else {
  1190.                 while (($value = $stmt->fetch(FetchMode::COLUMN)) !== false) {
  1191.                     yield $value;
  1192.                 }
  1193.             }
  1194.         } catch (Throwable $e) {
  1195.             $this->handleExceptionDuringQuery($e, $query, $params, $types);
  1196.         }
  1197.     }
  1199.     /**
  1200.      * Prepares an SQL statement.
  1201.      *
  1202.      * @param string $sql The SQL statement to prepare.
  1203.      *
  1204.      * @return Statement The prepared statement.
  1205.      *
  1206.      * @throws Exception
  1207.      */
  1208.     public function prepare($sql)
  1209.     {
  1210.         try {
  1211.             $stmt = new Statement($sql, $this);
  1212.         } catch (Throwable $e) {
  1213.             $this->handleExceptionDuringQuery($e, $sql);
  1214.         }
  1216.         $stmt->setFetchMode($this->defaultFetchMode);
  1218.         return $stmt;
  1219.     }
  1221.     /**
  1222.      * Executes an, optionally parametrized, SQL query.
  1223.      *
  1224.      * If the query is parametrized, a prepared statement is used.
  1225.      * If an SQLLogger is configured, the execution is logged.
  1226.      *
  1227.      * @param string                                                               $sql    SQL query
  1228.      * @param array<int, mixed>|array<string, mixed>                               $params Query parameters
  1229.      * @param array<int, int|string|Type|null>|array<string, int|string|Type|null> $types  Parameter types
  1230.      *
  1231.      * @return ResultStatement The executed statement.
  1232.      *
  1233.      * @throws Exception
  1234.      */
  1235.     public function executeQuery($sql, array $params = [], $types = [], ?QueryCacheProfile $qcp = null)
  1236.     {
  1237.         if ($qcp !== null) {
  1238.             return $this->executeCacheQuery($sql, $params, $types, $qcp);
  1239.         }
  1241.         $connection = $this->getWrappedConnection();
  1243.         $logger = $this->_config->getSQLLogger();
  1244.         if ($logger) {
  1245.             $logger->startQuery($sql, $params, $types);
  1246.         }
  1248.         try {
  1249.             if ($params) {
  1250.                 [$sql, $params, $types] = SQLParserUtils::expandListParameters($sql, $params, $types);
  1252.                 $stmt = $connection->prepare($sql);
  1253.                 if ($types) {
  1254.                     $this->_bindTypedValues($stmt, $params, $types);
  1255.                     $stmt->execute();
  1256.                 } else {
  1257.                     $stmt->execute($params);
  1258.                 }
  1259.             } else {
  1260.                 $stmt = $connection->query($sql);
  1261.             }
  1262.         } catch (Throwable $e) {
  1263.             $this->handleExceptionDuringQuery(
  1264.                 $e,
  1265.                 $sql,
  1266.                 $params,
  1267.                 $types
  1268.             );
  1269.         }
  1271.         $stmt->setFetchMode($this->defaultFetchMode);
  1273.         if ($logger) {
  1274.             $logger->stopQuery();
  1275.         }
  1277.         return $stmt;
  1278.     }
  1280.     /**
  1281.      * Executes a caching query.
  1282.      *
  1283.      * @param string                                                               $sql    SQL query
  1284.      * @param array<int, mixed>|array<string, mixed>                               $params Query parameters
  1285.      * @param array<int, int|string|Type|null>|array<string, int|string|Type|null> $types  Parameter types
  1286.      *
  1287.      * @return ResultStatement
  1288.      *
  1289.      * @throws CacheException
  1290.      */
  1291.     public function executeCacheQuery($sql, $params, $types, QueryCacheProfile $qcp)
  1292.     {
  1293.         $resultCache = $qcp->getResultCacheDriver() ?? $this->_config->getResultCacheImpl();
  1295.         if ($resultCache === null) {
  1296.             throw CacheException::noResultDriverConfigured();
  1297.         }
  1299.         $connectionParams = $this->params;
  1300.         unset($connectionParams['platform']);
  1302.         [$cacheKey, $realKey] = $qcp->generateCacheKeys($sql, $params, $types, $connectionParams);
  1304.         // fetch the row pointers entry
  1305.         $data = $resultCache->fetch($cacheKey);
  1307.         if ($data !== false) {
  1308.             // is the real key part of this row pointers map or is the cache only pointing to other cache keys?
  1309.             if (isset($data[$realKey])) {
  1310.                 $stmt = new ArrayStatement($data[$realKey]);
  1311.             } elseif (array_key_exists($realKey, $data)) {
  1312.                 $stmt = new ArrayStatement([]);
  1313.             }
  1314.         }
  1316.         if (! isset($stmt)) {
  1317.             $stmt = new ResultCacheStatement(
  1318.                 $this->executeQuery($sql, $params, $types),
  1319.                 $resultCache,
  1320.                 $cacheKey,
  1321.                 $realKey,
  1322.                 $qcp->getLifetime()
  1323.             );
  1324.         }
  1326.         $stmt->setFetchMode($this->defaultFetchMode);
  1328.         return $stmt;
  1329.     }
  1331.     /**
  1332.      * Executes an, optionally parametrized, SQL query and returns the result,
  1333.      * applying a given projection/transformation function on each row of the result.
  1334.      *
  1335.      * @deprecated
  1336.      *
  1337.      * @param string  $sql      The SQL query to execute.
  1338.      * @param mixed[] $params   The parameters, if any.
  1339.      * @param Closure $function The transformation function that is applied on each row.
  1340.      *                           The function receives a single parameter, an array, that
  1341.      *                           represents a row of the result set.
  1342.      *
  1343.      * @return mixed[] The projected result of the query.
  1344.      */
  1345.     public function project($sql, array $params, Closure $function)
  1346.     {
  1347.         $result = [];
  1348.         $stmt   = $this->executeQuery($sql, $params);
  1350.         while ($row = $stmt->fetch()) {
  1351.             $result[] = $function($row);
  1352.         }
  1354.         $stmt->closeCursor();
  1356.         return $result;
  1357.     }
  1359.     /**
  1360.      * Executes an SQL statement, returning a result set as a Statement object.
  1361.      *
  1362.      * @deprecated Use {@link executeQuery()} instead.
  1363.      *
  1364.      * @return \Doctrine\DBAL\Driver\Statement
  1365.      *
  1366.      * @throws Exception
  1367.      */
  1368.     public function query()
  1369.     {
  1370.         $connection = $this->getWrappedConnection();
  1372.         $args = func_get_args();
  1374.         $logger = $this->_config->getSQLLogger();
  1375.         if ($logger) {
  1376.             $logger->startQuery($args[0]);
  1377.         }
  1379.         try {
  1380.             $statement = $connection->query(...$args);
  1381.         } catch (Throwable $e) {
  1382.             $this->handleExceptionDuringQuery($e, $args[0]);
  1383.         }
  1385.         $statement->setFetchMode($this->defaultFetchMode);
  1387.         if ($logger) {
  1388.             $logger->stopQuery();
  1389.         }
  1391.         return $statement;
  1392.     }
  1394.     /**
  1395.      * Executes an SQL INSERT/UPDATE/DELETE query with the given parameters
  1396.      * and returns the number of affected rows.
  1397.      *
  1398.      * This method supports PDO binding types as well as DBAL mapping types.
  1399.      *
  1400.      * @deprecated Use {@link executeStatement()} instead.
  1401.      *
  1402.      * @param string                                                               $sql    SQL statement
  1403.      * @param array<int, mixed>|array<string, mixed>                               $params Statement parameters
  1404.      * @param array<int, int|string|Type|null>|array<string, int|string|Type|null> $types  Parameter types
  1405.      *
  1406.      * @return int The number of affected rows.
  1407.      *
  1408.      * @throws Exception
  1409.      */
  1410.     public function executeUpdate($sql, array $params = [], array $types = [])
  1411.     {
  1412.         return $this->executeStatement($sql, $params, $types);
  1413.     }
  1415.     /**
  1416.      * Executes an SQL statement with the given parameters and returns the number of affected rows.
  1417.      *
  1418.      * Could be used for:
  1419.      *  - DML statements: INSERT, UPDATE, DELETE, etc.
  1420.      *  - DDL statements: CREATE, DROP, ALTER, etc.
  1421.      *  - DCL statements: GRANT, REVOKE, etc.
  1422.      *  - Session control statements: ALTER SESSION, SET, DECLARE, etc.
  1423.      *  - Other statements that don't yield a row set.
  1424.      *
  1425.      * This method supports PDO binding types as well as DBAL mapping types.
  1426.      *
  1427.      * @param string                                                               $sql    SQL statement
  1428.      * @param array<int, mixed>|array<string, mixed>                               $params Statement parameters
  1429.      * @param array<int, int|string|Type|null>|array<string, int|string|Type|null> $types  Parameter types
  1430.      *
  1431.      * @return int The number of affected rows.
  1432.      *
  1433.      * @throws Exception
  1434.      */
  1435.     public function executeStatement($sql, array $params = [], array $types = [])
  1436.     {
  1437.         $connection = $this->getWrappedConnection();
  1439.         $logger = $this->_config->getSQLLogger();
  1440.         if ($logger) {
  1441.             $logger->startQuery($sql, $params, $types);
  1442.         }
  1444.         try {
  1445.             if ($params) {
  1446.                 [$sql, $params, $types] = SQLParserUtils::expandListParameters($sql, $params, $types);
  1448.                 $stmt = $connection->prepare($sql);
  1450.                 if ($types) {
  1451.                     $this->_bindTypedValues($stmt, $params, $types);
  1452.                     $stmt->execute();
  1453.                 } else {
  1454.                     $stmt->execute($params);
  1455.                 }
  1457.                 $result = $stmt->rowCount();
  1458.             } else {
  1459.                 $result = $connection->exec($sql);
  1460.             }
  1461.         } catch (Throwable $e) {
  1462.             $this->handleExceptionDuringQuery(
  1463.                 $e,
  1464.                 $sql,
  1465.                 $params,
  1466.                 $types
  1467.             );
  1468.         }
  1470.         if ($logger) {
  1471.             $logger->stopQuery();
  1472.         }
  1474.         return $result;
  1475.     }
  1477.     /**
  1478.      * Executes an SQL statement and return the number of affected rows.
  1479.      *
  1480.      * @deprecated Use {@link executeStatement()} instead.
  1481.      *
  1482.      * @param string $sql
  1483.      *
  1484.      * @return int The number of affected rows.
  1485.      *
  1486.      * @throws Exception
  1487.      */
  1488.     public function exec($sql)
  1489.     {
  1490.         $connection = $this->getWrappedConnection();
  1492.         $logger = $this->_config->getSQLLogger();
  1493.         if ($logger) {
  1494.             $logger->startQuery($sql);
  1495.         }
  1497.         try {
  1498.             $result = $connection->exec($sql);
  1499.         } catch (Throwable $e) {
  1500.             $this->handleExceptionDuringQuery($e, $sql);
  1501.         }
  1503.         if ($logger) {
  1504.             $logger->stopQuery();
  1505.         }
  1507.         return $result;
  1508.     }
  1510.     /**
  1511.      * Returns the current transaction nesting level.
  1512.      *
  1513.      * @return int The nesting level. A value of 0 means there's no active transaction.
  1514.      */
  1515.     public function getTransactionNestingLevel()
  1516.     {
  1517.         return $this->transactionNestingLevel;
  1518.     }
  1520.     /**
  1521.      * Fetches the SQLSTATE associated with the last database operation.
  1522.      *
  1523.      * @deprecated The error information is available via exceptions.
  1524.      *
  1525.      * @return string|null The last error code.
  1526.      */
  1527.     public function errorCode()
  1528.     {
  1529.         return $this->getWrappedConnection()->errorCode();
  1530.     }
  1532.     /**
  1533.      * {@inheritDoc}
  1534.      *
  1535.      * @deprecated The error information is available via exceptions.
  1536.      */
  1537.     public function errorInfo()
  1538.     {
  1539.         return $this->getWrappedConnection()->errorInfo();
  1540.     }
  1542.     /**
  1543.      * Returns the ID of the last inserted row, or the last value from a sequence object,
  1544.      * depending on the underlying driver.
  1545.      *
  1546.      * Note: This method may not return a meaningful or consistent result across different drivers,
  1547.      * because the underlying database may not even support the notion of AUTO_INCREMENT/IDENTITY
  1548.      * columns or sequences.
  1549.      *
  1550.      * @param string|null $name Name of the sequence object from which the ID should be returned.
  1551.      *
  1552.      * @return string A string representation of the last inserted ID.
  1553.      */
  1554.     public function lastInsertId($name = null)
  1555.     {
  1556.         return $this->getWrappedConnection()->lastInsertId($name);
  1557.     }
  1559.     /**
  1560.      * Executes a function in a transaction.
  1561.      *
  1562.      * The function gets passed this Connection instance as an (optional) parameter.
  1563.      *
  1564.      * If an exception occurs during execution of the function or transaction commit,
  1565.      * the transaction is rolled back and the exception re-thrown.
  1566.      *
  1567.      * @param Closure $func The function to execute transactionally.
  1568.      *
  1569.      * @return mixed The value returned by $func
  1570.      *
  1571.      * @throws Throwable
  1572.      */
  1573.     public function transactional(Closure $func)
  1574.     {
  1575.         $this->beginTransaction();
  1576.         try {
  1577.             $res = $func($this);
  1578.             $this->commit();
  1580.             return $res;
  1581.         } catch (Throwable $e) {
  1582.             $this->rollBack();
  1584.             throw $e;
  1585.         }
  1586.     }
  1588.     /**
  1589.      * Sets if nested transactions should use savepoints.
  1590.      *
  1591.      * @param bool $nestTransactionsWithSavepoints
  1592.      *
  1593.      * @return void
  1594.      *
  1595.      * @throws ConnectionException
  1596.      */
  1597.     public function setNestTransactionsWithSavepoints($nestTransactionsWithSavepoints)
  1598.     {
  1599.         if ($this->transactionNestingLevel > 0) {
  1600.             throw ConnectionException::mayNotAlterNestedTransactionWithSavepointsInTransaction();
  1601.         }
  1603.         if (! $this->getDatabasePlatform()->supportsSavepoints()) {
  1604.             throw ConnectionException::savepointsNotSupported();
  1605.         }
  1607.         $this->nestTransactionsWithSavepoints = (bool) $nestTransactionsWithSavepoints;
  1608.     }
  1610.     /**
  1611.      * Gets if nested transactions should use savepoints.
  1612.      *
  1613.      * @return bool
  1614.      */
  1615.     public function getNestTransactionsWithSavepoints()
  1616.     {
  1617.         return $this->nestTransactionsWithSavepoints;
  1618.     }
  1620.     /**
  1621.      * Returns the savepoint name to use for nested transactions are false if they are not supported
  1622.      * "savepointFormat" parameter is not set
  1623.      *
  1624.      * @return mixed A string with the savepoint name or false.
  1625.      */
  1626.     protected function _getNestedTransactionSavePointName()
  1627.     {
  1628.         return 'DOCTRINE2_SAVEPOINT_' . $this->transactionNestingLevel;
  1629.     }
  1631.     /**
  1632.      * {@inheritDoc}
  1633.      */
  1634.     public function beginTransaction()
  1635.     {
  1636.         $connection = $this->getWrappedConnection();
  1638.         ++$this->transactionNestingLevel;
  1640.         $logger = $this->_config->getSQLLogger();
  1642.         if ($this->transactionNestingLevel === 1) {
  1643.             if ($logger) {
  1644.                 $logger->startQuery('"START TRANSACTION"');
  1645.             }
  1647.             $connection->beginTransaction();
  1649.             if ($logger) {
  1650.                 $logger->stopQuery();
  1651.             }
  1652.         } elseif ($this->nestTransactionsWithSavepoints) {
  1653.             if ($logger) {
  1654.                 $logger->startQuery('"SAVEPOINT"');
  1655.             }
  1657.             $this->createSavepoint($this->_getNestedTransactionSavePointName());
  1658.             if ($logger) {
  1659.                 $logger->stopQuery();
  1660.             }
  1661.         }
  1663.         return true;
  1664.     }
  1666.     /**
  1667.      * {@inheritDoc}
  1668.      *
  1669.      * @throws ConnectionException If the commit failed due to no active transaction or
  1670.      *                                            because the transaction was marked for rollback only.
  1671.      */
  1672.     public function commit()
  1673.     {
  1674.         if ($this->transactionNestingLevel === 0) {
  1675.             throw ConnectionException::noActiveTransaction();
  1676.         }
  1678.         if ($this->isRollbackOnly) {
  1679.             throw ConnectionException::commitFailedRollbackOnly();
  1680.         }
  1682.         $result = true;
  1684.         $connection = $this->getWrappedConnection();
  1686.         $logger = $this->_config->getSQLLogger();
  1688.         if ($this->transactionNestingLevel === 1) {
  1689.             if ($logger) {
  1690.                 $logger->startQuery('"COMMIT"');
  1691.             }
  1693.             $result = $connection->commit();
  1695.             if ($logger) {
  1696.                 $logger->stopQuery();
  1697.             }
  1698.         } elseif ($this->nestTransactionsWithSavepoints) {
  1699.             if ($logger) {
  1700.                 $logger->startQuery('"RELEASE SAVEPOINT"');
  1701.             }
  1703.             $this->releaseSavepoint($this->_getNestedTransactionSavePointName());
  1704.             if ($logger) {
  1705.                 $logger->stopQuery();
  1706.             }
  1707.         }
  1709.         --$this->transactionNestingLevel;
  1711.         if ($this->autoCommit !== false || $this->transactionNestingLevel !== 0) {
  1712.             return $result;
  1713.         }
  1715.         $this->beginTransaction();
  1717.         return $result;
  1718.     }
  1720.     /**
  1721.      * Commits all current nesting transactions.
  1722.      */
  1723.     private function commitAll(): void
  1724.     {
  1725.         while ($this->transactionNestingLevel !== 0) {
  1726.             if ($this->autoCommit === false && $this->transactionNestingLevel === 1) {
  1727.                 // When in no auto-commit mode, the last nesting commit immediately starts a new transaction.
  1728.                 // Therefore we need to do the final commit here and then leave to avoid an infinite loop.
  1729.                 $this->commit();
  1731.                 return;
  1732.             }
  1734.             $this->commit();
  1735.         }
  1736.     }
  1738.     /**
  1739.      * Cancels any database changes done during the current transaction.
  1740.      *
  1741.      * @return bool
  1742.      *
  1743.      * @throws ConnectionException If the rollback operation failed.
  1744.      */
  1745.     public function rollBack()
  1746.     {
  1747.         if ($this->transactionNestingLevel === 0) {
  1748.             throw ConnectionException::noActiveTransaction();
  1749.         }
  1751.         $connection = $this->getWrappedConnection();
  1753.         $logger = $this->_config->getSQLLogger();
  1755.         if ($this->transactionNestingLevel === 1) {
  1756.             if ($logger) {
  1757.                 $logger->startQuery('"ROLLBACK"');
  1758.             }
  1760.             $this->transactionNestingLevel = 0;
  1761.             $connection->rollBack();
  1762.             $this->isRollbackOnly = false;
  1763.             if ($logger) {
  1764.                 $logger->stopQuery();
  1765.             }
  1767.             if ($this->autoCommit === false) {
  1768.                 $this->beginTransaction();
  1769.             }
  1770.         } elseif ($this->nestTransactionsWithSavepoints) {
  1771.             if ($logger) {
  1772.                 $logger->startQuery('"ROLLBACK TO SAVEPOINT"');
  1773.             }
  1775.             $this->rollbackSavepoint($this->_getNestedTransactionSavePointName());
  1776.             --$this->transactionNestingLevel;
  1777.             if ($logger) {
  1778.                 $logger->stopQuery();
  1779.             }
  1780.         } else {
  1781.             $this->isRollbackOnly = true;
  1782.             --$this->transactionNestingLevel;
  1783.         }
  1785.         return true;
  1786.     }
  1788.     /**
  1789.      * Creates a new savepoint.
  1790.      *
  1791.      * @param string $savepoint The name of the savepoint to create.
  1792.      *
  1793.      * @return void
  1794.      *
  1795.      * @throws ConnectionException
  1796.      */
  1797.     public function createSavepoint($savepoint)
  1798.     {
  1799.         if (! $this->getDatabasePlatform()->supportsSavepoints()) {
  1800.             throw ConnectionException::savepointsNotSupported();
  1801.         }
  1803.         $this->getWrappedConnection()->exec($this->platform->createSavePoint($savepoint));
  1804.     }
  1806.     /**
  1807.      * Releases the given savepoint.
  1808.      *
  1809.      * @param string $savepoint The name of the savepoint to release.
  1810.      *
  1811.      * @return void
  1812.      *
  1813.      * @throws ConnectionException
  1814.      */
  1815.     public function releaseSavepoint($savepoint)
  1816.     {
  1817.         if (! $this->getDatabasePlatform()->supportsSavepoints()) {
  1818.             throw ConnectionException::savepointsNotSupported();
  1819.         }
  1821.         if (! $this->platform->supportsReleaseSavepoints()) {
  1822.             return;
  1823.         }
  1825.         $this->getWrappedConnection()->exec($this->platform->releaseSavePoint($savepoint));
  1826.     }
  1828.     /**
  1829.      * Rolls back to the given savepoint.
  1830.      *
  1831.      * @param string $savepoint The name of the savepoint to rollback to.
  1832.      *
  1833.      * @return void
  1834.      *
  1835.      * @throws ConnectionException
  1836.      */
  1837.     public function rollbackSavepoint($savepoint)
  1838.     {
  1839.         if (! $this->getDatabasePlatform()->supportsSavepoints()) {
  1840.             throw ConnectionException::savepointsNotSupported();
  1841.         }
  1843.         $this->getWrappedConnection()->exec($this->platform->rollbackSavePoint($savepoint));
  1844.     }
  1846.     /**
  1847.      * Gets the wrapped driver connection.
  1848.      *
  1849.      * @return DriverConnection
  1850.      */
  1851.     public function getWrappedConnection()
  1852.     {
  1853.         $this->connect();
  1855.         assert($this->_conn !== null);
  1857.         return $this->_conn;
  1858.     }
  1860.     /**
  1861.      * Gets the SchemaManager that can be used to inspect or change the
  1862.      * database schema through the connection.
  1863.      *
  1864.      * @return AbstractSchemaManager
  1865.      */
  1866.     public function getSchemaManager()
  1867.     {
  1868.         if ($this->_schemaManager === null) {
  1869.             $this->_schemaManager = $this->_driver->getSchemaManager($this);
  1870.         }
  1872.         return $this->_schemaManager;
  1873.     }
  1875.     /**
  1876.      * Marks the current transaction so that the only possible
  1877.      * outcome for the transaction to be rolled back.
  1878.      *
  1879.      * @return void
  1880.      *
  1881.      * @throws ConnectionException If no transaction is active.
  1882.      */
  1883.     public function setRollbackOnly()
  1884.     {
  1885.         if ($this->transactionNestingLevel === 0) {
  1886.             throw ConnectionException::noActiveTransaction();
  1887.         }
  1889.         $this->isRollbackOnly = true;
  1890.     }
  1892.     /**
  1893.      * Checks whether the current transaction is marked for rollback only.
  1894.      *
  1895.      * @return bool
  1896.      *
  1897.      * @throws ConnectionException If no transaction is active.
  1898.      */
  1899.     public function isRollbackOnly()
  1900.     {
  1901.         if ($this->transactionNestingLevel === 0) {
  1902.             throw ConnectionException::noActiveTransaction();
  1903.         }
  1905.         return $this->isRollbackOnly;
  1906.     }
  1908.     /**
  1909.      * Converts a given value to its database representation according to the conversion
  1910.      * rules of a specific DBAL mapping type.
  1911.      *
  1912.      * @param mixed  $value The value to convert.
  1913.      * @param string $type  The name of the DBAL mapping type.
  1914.      *
  1915.      * @return mixed The converted value.
  1916.      */
  1917.     public function convertToDatabaseValue($value, $type)
  1918.     {
  1919.         return Type::getType($type)->convertToDatabaseValue($value, $this->getDatabasePlatform());
  1920.     }
  1922.     /**
  1923.      * Converts a given value to its PHP representation according to the conversion
  1924.      * rules of a specific DBAL mapping type.
  1925.      *
  1926.      * @param mixed  $value The value to convert.
  1927.      * @param string $type  The name of the DBAL mapping type.
  1928.      *
  1929.      * @return mixed The converted type.
  1930.      */
  1931.     public function convertToPHPValue($value, $type)
  1932.     {
  1933.         return Type::getType($type)->convertToPHPValue($value, $this->getDatabasePlatform());
  1934.     }
  1936.     /**
  1937.      * Binds a set of parameters, some or all of which are typed with a PDO binding type
  1938.      * or DBAL mapping type, to a given statement.
  1939.      *
  1940.      * @internal Duck-typing used on the $stmt parameter to support driver statements as well as
  1941.      *           raw PDOStatement instances.
  1942.      *
  1943.      * @param \Doctrine\DBAL\Driver\Statement                                      $stmt   Prepared statement
  1944.      * @param array<int, mixed>|array<string, mixed>                               $params Statement parameters
  1945.      * @param array<int, int|string|Type|null>|array<string, int|string|Type|null> $types  Parameter types
  1946.      *
  1947.      * @return void
  1948.      */
  1949.     private function _bindTypedValues($stmt, array $params, array $types)
  1950.     {
  1951.         // Check whether parameters are positional or named. Mixing is not allowed, just like in PDO.
  1952.         if (is_int(key($params))) {
  1953.             // Positional parameters
  1954.             $typeOffset = array_key_exists(0, $types) ? -1 : 0;
  1955.             $bindIndex  = 1;
  1956.             foreach ($params as $value) {
  1957.                 $typeIndex = $bindIndex + $typeOffset;
  1958.                 if (isset($types[$typeIndex])) {
  1959.                     $type                  = $types[$typeIndex];
  1960.                     [$value, $bindingType] = $this->getBindingInfo($value, $type);
  1961.                     $stmt->bindValue($bindIndex, $value, $bindingType);
  1962.                 } else {
  1963.                     $stmt->bindValue($bindIndex, $value);
  1964.                 }
  1966.                 ++$bindIndex;
  1967.             }
  1968.         } else {
  1969.             // Named parameters
  1970.             foreach ($params as $name => $value) {
  1971.                 if (isset($types[$name])) {
  1972.                     $type                  = $types[$name];
  1973.                     [$value, $bindingType] = $this->getBindingInfo($value, $type);
  1974.                     $stmt->bindValue($name, $value, $bindingType);
  1975.                 } else {
  1976.                     $stmt->bindValue($name, $value);
  1977.                 }
  1978.             }
  1979.         }
  1980.     }
  1982.     /**
  1983.      * Gets the binding type of a given type. The given type can be a PDO or DBAL mapping type.
  1984.      *
  1985.      * @param mixed                $value The value to bind.
  1986.      * @param int|string|Type|null $type  The type to bind (PDO or DBAL).
  1987.      *
  1988.      * @return mixed[] [0] => the (escaped) value, [1] => the binding type.
  1989.      */
  1990.     private function getBindingInfo($value, $type)
  1991.     {
  1992.         if (is_string($type)) {
  1993.             $type = Type::getType($type);
  1994.         }
  1996.         if ($type instanceof Type) {
  1997.             $value       = $type->convertToDatabaseValue($value, $this->getDatabasePlatform());
  1998.             $bindingType = $type->getBindingType();
  1999.         } else {
  2000.             $bindingType = $type;
  2001.         }
  2003.         return [$value, $bindingType];
  2004.     }
  2006.     /**
  2007.      * Resolves the parameters to a format which can be displayed.
  2008.      *
  2009.      * @internal This is a purely internal method. If you rely on this method, you are advised to
  2010.      *           copy/paste the code as this method may change, or be removed without prior notice.
  2011.      *
  2012.      * @param array<int, mixed>|array<string, mixed>                               $params Query parameters
  2013.      * @param array<int, int|string|Type|null>|array<string, int|string|Type|null> $types  Parameter types
  2014.      *
  2015.      * @return array<int, int|string|Type|null>|array<string, int|string|Type|null>
  2016.      */
  2017.     public function resolveParams(array $params, array $types)
  2018.     {
  2019.         $resolvedParams = [];
  2021.         // Check whether parameters are positional or named. Mixing is not allowed, just like in PDO.
  2022.         if (is_int(key($params))) {
  2023.             // Positional parameters
  2024.             $typeOffset = array_key_exists(0, $types) ? -1 : 0;
  2025.             $bindIndex  = 1;
  2026.             foreach ($params as $value) {
  2027.                 $typeIndex = $bindIndex + $typeOffset;
  2028.                 if (isset($types[$typeIndex])) {
  2029.                     $type                       = $types[$typeIndex];
  2030.                     [$value]                    = $this->getBindingInfo($value, $type);
  2031.                     $resolvedParams[$bindIndex] = $value;
  2032.                 } else {
  2033.                     $resolvedParams[$bindIndex] = $value;
  2034.                 }
  2036.                 ++$bindIndex;
  2037.             }
  2038.         } else {
  2039.             // Named parameters
  2040.             foreach ($params as $name => $value) {
  2041.                 if (isset($types[$name])) {
  2042.                     $type                  = $types[$name];
  2043.                     [$value]               = $this->getBindingInfo($value, $type);
  2044.                     $resolvedParams[$name] = $value;
  2045.                 } else {
  2046.                     $resolvedParams[$name] = $value;
  2047.                 }
  2048.             }
  2049.         }
  2051.         return $resolvedParams;
  2052.     }
  2054.     /**
  2055.      * Creates a new instance of a SQL query builder.
  2056.      *
  2057.      * @return QueryBuilder
  2058.      */
  2059.     public function createQueryBuilder()
  2060.     {
  2061.         return new Query\QueryBuilder($this);
  2062.     }
  2064.     /**
  2065.      * Ping the server
  2066.      *
  2067.      * When the server is not available the method returns FALSE.
  2068.      * It is responsibility of the developer to handle this case
  2069.      * and abort the request or reconnect manually:
  2070.      *
  2071.      * @deprecated
  2072.      *
  2073.      * @return bool
  2074.      *
  2075.      * @example
  2076.      *
  2077.      *   if ($conn->ping() === false) {
  2078.      *      $conn->close();
  2079.      *      $conn->connect();
  2080.      *   }
  2081.      *
  2082.      * It is undefined if the underlying driver attempts to reconnect
  2083.      * or disconnect when the connection is not available anymore
  2084.      * as long it returns TRUE when a reconnect succeeded and
  2085.      * FALSE when the connection was dropped.
  2086.      */
  2087.     public function ping()
  2088.     {
  2089.         $connection = $this->getWrappedConnection();
  2091.         if ($connection instanceof PingableConnection) {
  2092.             return $connection->ping();
  2093.         }
  2095.         try {
  2096.             $this->query($this->getDatabasePlatform()->getDummySelectSQL());
  2098.             return true;
  2099.         } catch (DBALException $e) {
  2100.             return false;
  2101.         }
  2102.     }
  2104.     /**
  2105.      * @internal
  2106.      *
  2107.      * @param array<int, mixed>|array<string, mixed>                               $params
  2108.      * @param array<int, int|string|Type|null>|array<string, int|string|Type|null> $types
  2109.      *
  2110.      * @throws Exception
  2111.      *
  2112.      * @psalm-return never-return
  2113.      */
  2114.     public function handleExceptionDuringQuery(Throwable $e, string $sql, array $params = [], array $types = []): void
  2115.     {
  2116.         $this->throw(
  2117.             Exception::driverExceptionDuringQuery(
  2118.                 $this->_driver,
  2119.                 $e,
  2120.                 $sql,
  2121.                 $this->resolveParams($params, $types)
  2122.             )
  2123.         );
  2124.     }
  2126.     /**
  2127.      * @internal
  2128.      *
  2129.      * @throws Exception
  2130.      *
  2131.      * @psalm-return never-return
  2132.      */
  2133.     public function handleDriverException(Throwable $e): void
  2134.     {
  2135.         $this->throw(
  2136.             Exception::driverException(
  2137.                 $this->_driver,
  2138.                 $e
  2139.             )
  2140.         );
  2141.     }
  2143.     /**
  2144.      * @internal
  2145.      *
  2146.      * @throws Exception
  2147.      *
  2148.      * @psalm-return never-return
  2149.      */
  2150.     private function throw(Exception $e): void
  2151.     {
  2152.         if ($e instanceof ConnectionLost) {
  2153.             $this->close();
  2154.         }
  2156.         throw $e;
  2157.     }
  2159.     private function ensureHasKeyValue(ResultStatement $stmt): void
  2160.     {
  2161.         $columnCount = $stmt->columnCount();
  2163.         if ($columnCount < 2) {
  2164.             throw NoKeyValue::fromColumnCount($columnCount);
  2165.         }
  2166.     }
  2167. }