vendor/doctrine/dbal/lib/Doctrine/DBAL/Driver/AbstractPostgreSQLDriver.php line 51

Open in your IDE?
  1. <?php
  3. namespace Doctrine\DBAL\Driver;
  5. use Doctrine\DBAL\Connection;
  6. use Doctrine\DBAL\DBALException;
  7. use Doctrine\DBAL\Driver;
  8. use Doctrine\DBAL\Exception;
  9. use Doctrine\DBAL\Platforms\PostgreSQL100Platform;
  10. use Doctrine\DBAL\Platforms\PostgreSQL91Platform;
  11. use Doctrine\DBAL\Platforms\PostgreSQL92Platform;
  12. use Doctrine\DBAL\Platforms\PostgreSQL94Platform;
  13. use Doctrine\DBAL\Platforms\PostgreSqlPlatform;
  14. use Doctrine\DBAL\Schema\PostgreSqlSchemaManager;
  15. use Doctrine\DBAL\VersionAwarePlatformDriver;
  16. use function preg_match;
  17. use function strpos;
  18. use function version_compare;
  20. /**
  21.  * Abstract base implementation of the {@link Doctrine\DBAL\Driver} interface for PostgreSQL based drivers.
  22.  */
  23. abstract class AbstractPostgreSQLDriver implements Driver, ExceptionConverterDriver, VersionAwarePlatformDriver
  24. {
  25.     /**
  26.      * {@inheritdoc}
  27.      *
  28.      * @link http://www.postgresql.org/docs/9.3/static/errcodes-appendix.html
  29.      */
  30.     public function convertException($message, DriverException $exception)
  31.     {
  32.         switch ($exception->getSQLState()) {
  33.             case '40001':
  34.             case '40P01':
  35.                 return new Exception\DeadlockException($message, $exception);
  36.             case '0A000':
  37.                 // Foreign key constraint violations during a TRUNCATE operation
  38.                 // are considered "feature not supported" in PostgreSQL.
  39.                 if (strpos($exception->getMessage(), 'truncate') !== false) {
  40.                     return new Exception\ForeignKeyConstraintViolationException($message, $exception);
  41.                 }
  43.                 break;
  44.             case '23502':
  45.                 return new Exception\NotNullConstraintViolationException($message, $exception);
  47.             case '23503':
  48.                 return new Exception\ForeignKeyConstraintViolationException($message, $exception);
  50.             case '23505':
  51.                 return new Exception\UniqueConstraintViolationException($message, $exception);
  53.             case '42601':
  54.                 return new Exception\SyntaxErrorException($message, $exception);
  56.             case '42702':
  57.                 return new Exception\NonUniqueFieldNameException($message, $exception);
  59.             case '42703':
  60.                 return new Exception\InvalidFieldNameException($message, $exception);
  62.             case '42P01':
  63.                 return new Exception\TableNotFoundException($message, $exception);
  65.             case '42P07':
  66.                 return new Exception\TableExistsException($message, $exception);
  68.             case '7':
  69.                 // In some case (mainly connection errors) the PDO exception does not provide a SQLSTATE via its code.
  70.                 // The exception code is always set to 7 here.
  71.                 // We have to match against the SQLSTATE in the error message in these cases.
  72.                 if (strpos($exception->getMessage(), 'SQLSTATE[08006]') !== false) {
  73.                     return new Exception\ConnectionException($message, $exception);
  74.                 }
  76.                 break;
  77.         }
  79.         return new Exception\DriverException($message, $exception);
  80.     }
  82.     /**
  83.      * {@inheritdoc}
  84.      */
  85.     public function createDatabasePlatformForVersion($version)
  86.     {
  87.         if (! preg_match('/^(?P<major>\d+)(?:\.(?P<minor>\d+)(?:\.(?P<patch>\d+))?)?/', $version, $versionParts)) {
  88.             throw DBALException::invalidPlatformVersionSpecified(
  89.                 $version,
  90.                 '<major_version>.<minor_version>.<patch_version>'
  91.             );
  92.         }
  94.         $majorVersion = $versionParts['major'];
  95.         $minorVersion = $versionParts['minor'] ?? 0;
  96.         $patchVersion = $versionParts['patch'] ?? 0;
  97.         $version      = $majorVersion . '.' . $minorVersion . '.' . $patchVersion;
  99.         switch (true) {
  100.             case version_compare($version, '10.0', '>='):
  101.                 return new PostgreSQL100Platform();
  102.             case version_compare($version, '9.4', '>='):
  103.                 return new PostgreSQL94Platform();
  104.             case version_compare($version, '9.2', '>='):
  105.                 return new PostgreSQL92Platform();
  106.             case version_compare($version, '9.1', '>='):
  107.                 return new PostgreSQL91Platform();
  108.             default:
  109.                 return new PostgreSqlPlatform();
  110.         }
  111.     }
  113.     /**
  114.      * {@inheritdoc}
  115.      */
  116.     public function getDatabase(Connection $conn)
  117.     {
  118.         $params = $conn->getParams();
  120.         return $params['dbname'] ?? $conn->query('SELECT CURRENT_DATABASE()')->fetchColumn();
  121.     }
  123.     /**
  124.      * {@inheritdoc}
  125.      */
  126.     public function getDatabasePlatform()
  127.     {
  128.         return new PostgreSqlPlatform();
  129.     }
  131.     /**
  132.      * {@inheritdoc}
  133.      */
  134.     public function getSchemaManager(Connection $conn)
  135.     {
  136.         return new PostgreSqlSchemaManager($conn);
  137.     }
  138. }