vendor/doctrine/dbal/lib/Doctrine/DBAL/Configuration.php line 18

Open in your IDE?
  1. <?php
  3. namespace Doctrine\DBAL;
  5. use Doctrine\Common\Cache\Cache;
  6. use Doctrine\DBAL\Logging\SQLLogger;
  7. use Doctrine\DBAL\Schema\AbstractAsset;
  8. use Doctrine\Deprecations\Deprecation;
  10. use function preg_match;
  12. /**
  13.  * Configuration container for the Doctrine DBAL.
  14.  *
  15.  * Internal note: When adding a new configuration option just write a getter/setter
  16.  *                pair and add the option to the _attributes array with a proper default value.
  17.  */
  18. class Configuration
  19. {
  20.     /**
  21.      * The attributes that are contained in the configuration.
  22.      * Values are default values.
  23.      *
  24.      * @var mixed[]
  25.      */
  26.     protected $_attributes = [];
  28.     /**
  29.      * Sets the SQL logger to use. Defaults to NULL which means SQL logging is disabled.
  30.      *
  31.      * @return void
  32.      */
  33.     public function setSQLLogger(?SQLLogger $logger = null)
  34.     {
  35.         $this->_attributes['sqlLogger'] = $logger;
  36.     }
  38.     /**
  39.      * Gets the SQL logger that is used.
  40.      *
  41.      * @return SQLLogger|null
  42.      */
  43.     public function getSQLLogger()
  44.     {
  45.         return $this->_attributes['sqlLogger'] ?? null;
  46.     }
  48.     /**
  49.      * Gets the cache driver implementation that is used for query result caching.
  50.      *
  51.      * @return Cache|null
  52.      */
  53.     public function getResultCacheImpl()
  54.     {
  55.         return $this->_attributes['resultCacheImpl'] ?? null;
  56.     }
  58.     /**
  59.      * Sets the cache driver implementation that is used for query result caching.
  60.      *
  61.      * @return void
  62.      */
  63.     public function setResultCacheImpl(Cache $cacheImpl)
  64.     {
  65.         $this->_attributes['resultCacheImpl'] = $cacheImpl;
  66.     }
  68.     /**
  69.      * Sets the filter schema assets expression.
  70.      *
  71.      * Only include tables/sequences matching the filter expression regexp in
  72.      * schema instances generated for the active connection when calling
  73.      * {AbstractSchemaManager#createSchema()}.
  74.      *
  75.      * @deprecated Use Configuration::setSchemaAssetsFilter() instead
  76.      *
  77.      * @param string|null $filterExpression
  78.      *
  79.      * @return void
  80.      */
  81.     public function setFilterSchemaAssetsExpression($filterExpression)
  82.     {
  83.         Deprecation::trigger(
  84.             'doctrine/dbal',
  85.             'https://github.com/doctrine/dbal/pull/3316',
  86.             'Configuration::setFilterSchemaAssetsExpression() is deprecated, use setSchemaAssetsFilter() instead.'
  87.         );
  89.         $this->_attributes['filterSchemaAssetsExpression'] = $filterExpression;
  90.         if ($filterExpression) {
  91.             $this->_attributes['filterSchemaAssetsExpressionCallable']
  92.                 = $this->buildSchemaAssetsFilterFromExpression($filterExpression);
  93.         } else {
  94.             $this->_attributes['filterSchemaAssetsExpressionCallable'] = null;
  95.         }
  96.     }
  98.     /**
  99.      * Returns filter schema assets expression.
  100.      *
  101.      * @deprecated Use Configuration::getSchemaAssetsFilter() instead
  102.      *
  103.      * @return string|null
  104.      */
  105.     public function getFilterSchemaAssetsExpression()
  106.     {
  107.         Deprecation::trigger(
  108.             'doctrine/dbal',
  109.             'https://github.com/doctrine/dbal/pull/3316',
  110.             'Configuration::getFilterSchemaAssetsExpression() is deprecated, use getSchemaAssetsFilter() instead.'
  111.         );
  113.         return $this->_attributes['filterSchemaAssetsExpression'] ?? null;
  114.     }
  116.     /**
  117.      * @param string $filterExpression
  118.      *
  119.      * @return callable(string|AbstractAsset)
  120.      */
  121.     private function buildSchemaAssetsFilterFromExpression($filterExpression): callable
  122.     {
  123.         return static function ($assetName) use ($filterExpression) {
  124.             if ($assetName instanceof AbstractAsset) {
  125.                 $assetName = $assetName->getName();
  126.             }
  128.             return preg_match($filterExpression, $assetName);
  129.         };
  130.     }
  132.     /**
  133.      * Sets the callable to use to filter schema assets.
  134.      */
  135.     public function setSchemaAssetsFilter(?callable $callable = null): ?callable
  136.     {
  137.         $this->_attributes['filterSchemaAssetsExpression'] = null;
  139.         return $this->_attributes['filterSchemaAssetsExpressionCallable'] = $callable;
  140.     }
  142.     /**
  143.      * Returns the callable to use to filter schema assets.
  144.      */
  145.     public function getSchemaAssetsFilter(): ?callable
  146.     {
  147.         return $this->_attributes['filterSchemaAssetsExpressionCallable'] ?? null;
  148.     }
  150.     /**
  151.      * Sets the default auto-commit mode for connections.
  152.      *
  153.      * If a connection is in auto-commit mode, then all its SQL statements will be executed and committed as individual
  154.      * transactions. Otherwise, its SQL statements are grouped into transactions that are terminated by a call to either
  155.      * the method commit or the method rollback. By default, new connections are in auto-commit mode.
  156.      *
  157.      * @see   getAutoCommit
  158.      *
  159.      * @param bool $autoCommit True to enable auto-commit mode; false to disable it.
  160.      *
  161.      * @return void
  162.      */
  163.     public function setAutoCommit($autoCommit)
  164.     {
  165.         $this->_attributes['autoCommit'] = (bool) $autoCommit;
  166.     }
  168.     /**
  169.      * Returns the default auto-commit mode for connections.
  170.      *
  171.      * @see    setAutoCommit
  172.      *
  173.      * @return bool True if auto-commit mode is enabled by default for connections, false otherwise.
  174.      */
  175.     public function getAutoCommit()
  176.     {
  177.         return $this->_attributes['autoCommit'] ?? true;
  178.     }
  179. }