Configuration.php — MailPoet – Newsletters, Email Marketing, and Automation 5.36.0

mailpoet / vendor-prefixed / doctrine / orm / src / Configuration.php

mailpoet / vendor-prefixed / doctrine / orm / src Last commit date

Configuration.php

492 lines

1	<?php
2	declare (strict_types=1);
3	namespace MailPoetVendor\Doctrine\ORM;
4	if (!defined('ABSPATH')) exit;
5	use BadMethodCallException;
6	use MailPoetVendor\Doctrine\Common\Annotations\AnnotationReader;
7	use MailPoetVendor\Doctrine\Common\Annotations\CachedReader;
8	use MailPoetVendor\Doctrine\Common\Annotations\SimpleAnnotationReader;
9	use MailPoetVendor\Doctrine\Common\Cache\ArrayCache;
10	use MailPoetVendor\Doctrine\Common\Cache\Cache as CacheDriver;
11	use MailPoetVendor\Doctrine\Common\Cache\Psr6\CacheAdapter;
12	use MailPoetVendor\Doctrine\Common\Cache\Psr6\DoctrineProvider;
13	use MailPoetVendor\Doctrine\Common\Persistence\PersistentObject;
14	use MailPoetVendor\Doctrine\DBAL\Platforms\AbstractPlatform;
15	use MailPoetVendor\Doctrine\Deprecations\Deprecation;
16	use MailPoetVendor\Doctrine\ORM\Cache\CacheConfiguration;
17	use MailPoetVendor\Doctrine\ORM\Cache\Exception\CacheException;
18	use MailPoetVendor\Doctrine\ORM\Cache\Exception\MetadataCacheNotConfigured;
19	use MailPoetVendor\Doctrine\ORM\Cache\Exception\MetadataCacheUsesNonPersistentCache;
20	use MailPoetVendor\Doctrine\ORM\Cache\Exception\QueryCacheNotConfigured;
21	use MailPoetVendor\Doctrine\ORM\Cache\Exception\QueryCacheUsesNonPersistentCache;
22	use MailPoetVendor\Doctrine\ORM\Exception\InvalidEntityRepository;
23	use MailPoetVendor\Doctrine\ORM\Exception\NamedNativeQueryNotFound;
24	use MailPoetVendor\Doctrine\ORM\Exception\NamedQueryNotFound;
25	use MailPoetVendor\Doctrine\ORM\Exception\NotSupported;
26	use MailPoetVendor\Doctrine\ORM\Exception\ProxyClassesAlwaysRegenerating;
27	use MailPoetVendor\Doctrine\ORM\Exception\UnknownEntityNamespace;
28	use MailPoetVendor\Doctrine\ORM\Internal\Hydration\AbstractHydrator;
29	use MailPoetVendor\Doctrine\ORM\Mapping\ClassMetadata;
30	use MailPoetVendor\Doctrine\ORM\Mapping\ClassMetadataFactory;
31	use MailPoetVendor\Doctrine\ORM\Mapping\DefaultEntityListenerResolver;
32	use MailPoetVendor\Doctrine\ORM\Mapping\DefaultNamingStrategy;
33	use MailPoetVendor\Doctrine\ORM\Mapping\DefaultQuoteStrategy;
34	use MailPoetVendor\Doctrine\ORM\Mapping\Driver\AnnotationDriver;
35	use MailPoetVendor\Doctrine\ORM\Mapping\EntityListenerResolver;
36	use MailPoetVendor\Doctrine\ORM\Mapping\NamingStrategy;
37	use MailPoetVendor\Doctrine\ORM\Mapping\QuoteStrategy;
38	use MailPoetVendor\Doctrine\ORM\Mapping\TypedFieldMapper;
39	use MailPoetVendor\Doctrine\ORM\Proxy\ProxyFactory;
40	use MailPoetVendor\Doctrine\ORM\Query\AST\Functions\FunctionNode;
41	use MailPoetVendor\Doctrine\ORM\Query\Filter\SQLFilter;
42	use MailPoetVendor\Doctrine\ORM\Query\ResultSetMapping;
43	use MailPoetVendor\Doctrine\ORM\Repository\DefaultRepositoryFactory;
44	use MailPoetVendor\Doctrine\ORM\Repository\RepositoryFactory;
45	use MailPoetVendor\Doctrine\Persistence\Mapping\Driver\MappingDriver;
46	use MailPoetVendor\Doctrine\Persistence\ObjectRepository;
47	use MailPoetVendor\Doctrine\Persistence\Reflection\RuntimeReflectionProperty;
48	use LogicException;
49	use MailPoetVendor\Psr\Cache\CacheItemPoolInterface;
50	use MailPoetVendor\Symfony\Component\VarExporter\LazyGhostTrait;
51	use function class_exists;
52	use function is_a;
53	use function method_exists;
54	use function sprintf;
55	use function strtolower;
56	use function trait_exists;
57	use function trim;
58	class Configuration extends \MailPoetVendor\Doctrine\DBAL\Configuration
59	{
60	protected $_attributes = [];
61	private $identityGenerationPreferences = [];
62	public function setIdentityGenerationPreferences(array $value) : void
63	{
64	$this->identityGenerationPreferences = $value;
65	}
66	public function getIdentityGenerationPreferences() : array
67	{
68	return $this->identityGenerationPreferences;
69	}
70	public function setProxyDir($dir)
71	{
72	$this->_attributes['proxyDir'] = $dir;
73	}
74	public function getProxyDir()
75	{
76	return $this->_attributes['proxyDir'] ?? null;
77	}
78	public function getAutoGenerateProxyClasses()
79	{
80	return $this->_attributes['autoGenerateProxyClasses'] ?? ProxyFactory::AUTOGENERATE_ALWAYS;
81	}
82	public function setAutoGenerateProxyClasses($autoGenerate)
83	{
84	$this->_attributes['autoGenerateProxyClasses'] = (int) $autoGenerate;
85	}
86	public function getProxyNamespace()
87	{
88	return $this->_attributes['proxyNamespace'] ?? null;
89	}
90	public function setProxyNamespace($ns)
91	{
92	$this->_attributes['proxyNamespace'] = $ns;
93	}
94	public function setMetadataDriverImpl(MappingDriver $driverImpl)
95	{
96	$this->_attributes['metadataDriverImpl'] = $driverImpl;
97	}
98	public function newDefaultAnnotationDriver($paths = [], $useSimpleAnnotationReader = \true, bool $reportFieldsWhereDeclared = \false)
99	{
100	Deprecation::trigger('doctrine/orm', 'https://github.com/doctrine/orm/pull/9443', '%s is deprecated, call %s::createDefaultAnnotationDriver() instead.', __METHOD__, ORMSetup::class);
101	if (!class_exists(AnnotationReader::class)) {
102	throw new LogicException('The annotation metadata driver cannot be enabled because the "doctrine/annotations" library' . ' is not installed. Please run "composer require doctrine/annotations" or choose a different' . ' metadata driver.');
103	}
104	if ($useSimpleAnnotationReader) {
105	if (!class_exists(SimpleAnnotationReader::class)) {
106	throw new BadMethodCallException('SimpleAnnotationReader has been removed in doctrine/annotations 2.' . ' Downgrade to version 1 or set $useSimpleAnnotationReader to false.');
107	}
108	// Register the ORM Annotations in the AnnotationRegistry
109	$reader = new SimpleAnnotationReader();
110	$reader->addNamespace('MailPoetVendor\\Doctrine\\ORM\\Mapping');
111	} else {
112	$reader = new AnnotationReader();
113	}
114	if (class_exists(ArrayCache::class) && class_exists(CachedReader::class)) {
115	$reader = new CachedReader($reader, new ArrayCache());
116	}
117	return new AnnotationDriver($reader, (array) $paths, $reportFieldsWhereDeclared);
118	}
119	public function addEntityNamespace($alias, $namespace)
120	{
121	if (class_exists(PersistentObject::class)) {
122	Deprecation::trigger('doctrine/orm', 'https://github.com/doctrine/orm/issues/8818', 'Short namespace aliases such as "%s" are deprecated and will be removed in Doctrine ORM 3.0.', $alias);
123	} else {
124	throw NotSupported::createForPersistence3(sprintf('Using short namespace alias "%s" by calling %s', $alias, __METHOD__));
125	}
126	$this->_attributes['entityNamespaces'][$alias] = $namespace;
127	}
128	public function getEntityNamespace($entityNamespaceAlias)
129	{
130	Deprecation::trigger('doctrine/orm', 'https://github.com/doctrine/orm/issues/8818', 'Entity short namespace aliases such as "%s" are deprecated, use ::class constant instead.', $entityNamespaceAlias);
131	if (!isset($this->_attributes['entityNamespaces'][$entityNamespaceAlias])) {
132	// @phpstan-ignore staticMethod.deprecatedClass
133	throw UnknownEntityNamespace::fromNamespaceAlias($entityNamespaceAlias);
134	}
135	return trim($this->_attributes['entityNamespaces'][$entityNamespaceAlias], '\\');
136	}
137	public function setEntityNamespaces(array $entityNamespaces)
138	{
139	$this->_attributes['entityNamespaces'] = $entityNamespaces;
140	}
141	public function getEntityNamespaces()
142	{
143	return $this->_attributes['entityNamespaces'];
144	}
145	public function getMetadataDriverImpl()
146	{
147	return $this->_attributes['metadataDriverImpl'] ?? null;
148	}
149	public function getResultCache() : ?CacheItemPoolInterface
150	{
151	// Compatibility with DBAL 2
152	if (!method_exists(parent::class, 'getResultCache')) {
153	// @phpstan-ignore method.deprecated
154	$cacheImpl = $this->getResultCacheImpl();
155	return $cacheImpl ? CacheAdapter::wrap($cacheImpl) : null;
156	}
157	return parent::getResultCache();
158	}
159	public function setResultCache(CacheItemPoolInterface $cache) : void
160	{
161	// Compatibility with DBAL 2
162	if (!method_exists(parent::class, 'setResultCache')) {
163	// @phpstan-ignore method.deprecated
164	$this->setResultCacheImpl(DoctrineProvider::wrap($cache));
165	return;
166	}
167	parent::setResultCache($cache);
168	}
169	public function getQueryCacheImpl()
170	{
171	Deprecation::trigger('doctrine/orm', 'https://github.com/doctrine/orm/pull/9002', 'Method %s() is deprecated and will be removed in Doctrine ORM 3.0. Use getQueryCache() instead.', __METHOD__);
172	return $this->_attributes['queryCacheImpl'] ?? null;
173	}
174	public function setQueryCacheImpl(CacheDriver $cacheImpl)
175	{
176	Deprecation::trigger('doctrine/orm', 'https://github.com/doctrine/orm/pull/9002', 'Method %s() is deprecated and will be removed in Doctrine ORM 3.0. Use setQueryCache() instead.', __METHOD__);
177	$this->_attributes['queryCache'] = CacheAdapter::wrap($cacheImpl);
178	$this->_attributes['queryCacheImpl'] = $cacheImpl;
179	}
180	public function getQueryCache() : ?CacheItemPoolInterface
181	{
182	return $this->_attributes['queryCache'] ?? null;
183	}
184	public function setQueryCache(CacheItemPoolInterface $cache) : void
185	{
186	$this->_attributes['queryCache'] = $cache;
187	$this->_attributes['queryCacheImpl'] = DoctrineProvider::wrap($cache);
188	}
189	public function getHydrationCacheImpl()
190	{
191	Deprecation::trigger('doctrine/orm', 'https://github.com/doctrine/orm/pull/9002', 'Method %s() is deprecated and will be removed in Doctrine ORM 3.0. Use getHydrationCache() instead.', __METHOD__);
192	return $this->_attributes['hydrationCacheImpl'] ?? null;
193	}
194	public function setHydrationCacheImpl(CacheDriver $cacheImpl)
195	{
196	Deprecation::trigger('doctrine/orm', 'https://github.com/doctrine/orm/pull/9002', 'Method %s() is deprecated and will be removed in Doctrine ORM 3.0. Use setHydrationCache() instead.', __METHOD__);
197	$this->_attributes['hydrationCache'] = CacheAdapter::wrap($cacheImpl);
198	$this->_attributes['hydrationCacheImpl'] = $cacheImpl;
199	}
200	public function getHydrationCache() : ?CacheItemPoolInterface
201	{
202	return $this->_attributes['hydrationCache'] ?? null;
203	}
204	public function setHydrationCache(CacheItemPoolInterface $cache) : void
205	{
206	$this->_attributes['hydrationCache'] = $cache;
207	$this->_attributes['hydrationCacheImpl'] = DoctrineProvider::wrap($cache);
208	}
209	public function getMetadataCacheImpl()
210	{
211	Deprecation::trigger('doctrine/orm', 'https://github.com/doctrine/orm/issues/8650', 'Method %s() is deprecated and will be removed in Doctrine ORM 3.0. Use getMetadataCache() instead.', __METHOD__);
212	if (isset($this->_attributes['metadataCacheImpl'])) {
213	return $this->_attributes['metadataCacheImpl'];
214	}
215	return isset($this->_attributes['metadataCache']) ? DoctrineProvider::wrap($this->_attributes['metadataCache']) : null;
216	}
217	public function setMetadataCacheImpl(CacheDriver $cacheImpl)
218	{
219	Deprecation::trigger('doctrine/orm', 'https://github.com/doctrine/orm/issues/8650', 'Method %s() is deprecated and will be removed in Doctrine ORM 3.0. Use setMetadataCache() instead.', __METHOD__);
220	$this->_attributes['metadataCacheImpl'] = $cacheImpl;
221	$this->_attributes['metadataCache'] = CacheAdapter::wrap($cacheImpl);
222	}
223	public function getMetadataCache() : ?CacheItemPoolInterface
224	{
225	return $this->_attributes['metadataCache'] ?? null;
226	}
227	public function setMetadataCache(CacheItemPoolInterface $cache) : void
228	{
229	$this->_attributes['metadataCache'] = $cache;
230	$this->_attributes['metadataCacheImpl'] = DoctrineProvider::wrap($cache);
231	}
232	public function addNamedQuery($name, $dql)
233	{
234	$this->_attributes['namedQueries'][$name] = $dql;
235	}
236	public function getNamedQuery($name)
237	{
238	if (!isset($this->_attributes['namedQueries'][$name])) {
239	throw NamedQueryNotFound::fromName($name);
240	}
241	return $this->_attributes['namedQueries'][$name];
242	}
243	public function addNamedNativeQuery($name, $sql, Query\ResultSetMapping $rsm)
244	{
245	$this->_attributes['namedNativeQueries'][$name] = [$sql, $rsm];
246	}
247	public function getNamedNativeQuery($name)
248	{
249	if (!isset($this->_attributes['namedNativeQueries'][$name])) {
250	throw NamedNativeQueryNotFound::fromName($name);
251	}
252	return $this->_attributes['namedNativeQueries'][$name];
253	}
254	public function ensureProductionSettings()
255	{
256	Deprecation::triggerIfCalledFromOutside('doctrine/orm', 'https://github.com/doctrine/orm/pull/9074', '%s is deprecated', __METHOD__);
257	$queryCacheImpl = $this->getQueryCacheImpl();
258	if (!$queryCacheImpl) {
259	throw QueryCacheNotConfigured::create();
260	}
261	if ($queryCacheImpl instanceof ArrayCache) {
262	throw QueryCacheUsesNonPersistentCache::fromDriver($queryCacheImpl);
263	}
264	if ($this->getAutoGenerateProxyClasses() !== ProxyFactory::AUTOGENERATE_NEVER) {
265	throw ProxyClassesAlwaysRegenerating::create();
266	}
267	if (!$this->getMetadataCache()) {
268	throw MetadataCacheNotConfigured::create();
269	}
270	$metadataCacheImpl = $this->getMetadataCacheImpl();
271	if ($metadataCacheImpl instanceof ArrayCache) {
272	throw MetadataCacheUsesNonPersistentCache::fromDriver($metadataCacheImpl);
273	}
274	}
275	public function addCustomStringFunction($name, $className)
276	{
277	$this->_attributes['customStringFunctions'][strtolower($name)] = $className;
278	}
279	public function getCustomStringFunction($name)
280	{
281	$name = strtolower($name);
282	return $this->_attributes['customStringFunctions'][$name] ?? null;
283	}
284	public function setCustomStringFunctions(array $functions)
285	{
286	foreach ($functions as $name => $className) {
287	$this->addCustomStringFunction($name, $className);
288	}
289	}
290	public function addCustomNumericFunction($name, $className)
291	{
292	$this->_attributes['customNumericFunctions'][strtolower($name)] = $className;
293	}
294	public function getCustomNumericFunction($name)
295	{
296	$name = strtolower($name);
297	return $this->_attributes['customNumericFunctions'][$name] ?? null;
298	}
299	public function setCustomNumericFunctions(array $functions)
300	{
301	foreach ($functions as $name => $className) {
302	$this->addCustomNumericFunction($name, $className);
303	}
304	}
305	public function addCustomDatetimeFunction($name, $className)
306	{
307	$this->_attributes['customDatetimeFunctions'][strtolower($name)] = $className;
308	}
309	public function getCustomDatetimeFunction($name)
310	{
311	$name = strtolower($name);
312	return $this->_attributes['customDatetimeFunctions'][$name] ?? null;
313	}
314	public function setCustomDatetimeFunctions(array $functions)
315	{
316	foreach ($functions as $name => $className) {
317	$this->addCustomDatetimeFunction($name, $className);
318	}
319	}
320	public function setTypedFieldMapper(?TypedFieldMapper $typedFieldMapper) : void
321	{
322	$this->_attributes['typedFieldMapper'] = $typedFieldMapper;
323	}
324	public function getTypedFieldMapper() : ?TypedFieldMapper
325	{
326	return $this->_attributes['typedFieldMapper'] ?? null;
327	}
328	public function setCustomHydrationModes($modes)
329	{
330	$this->_attributes['customHydrationModes'] = [];
331	foreach ($modes as $modeName => $hydrator) {
332	$this->addCustomHydrationMode($modeName, $hydrator);
333	}
334	}
335	public function getCustomHydrationMode($modeName)
336	{
337	return $this->_attributes['customHydrationModes'][$modeName] ?? null;
338	}
339	public function addCustomHydrationMode($modeName, $hydrator)
340	{
341	$this->_attributes['customHydrationModes'][$modeName] = $hydrator;
342	}
343	public function setClassMetadataFactoryName($cmfName)
344	{
345	$this->_attributes['classMetadataFactoryName'] = $cmfName;
346	}
347	public function getClassMetadataFactoryName()
348	{
349	if (!isset($this->_attributes['classMetadataFactoryName'])) {
350	$this->_attributes['classMetadataFactoryName'] = ClassMetadataFactory::class;
351	}
352	return $this->_attributes['classMetadataFactoryName'];
353	}
354	public function addFilter($name, $className)
355	{
356	$this->_attributes['filters'][$name] = $className;
357	}
358	public function getFilterClassName($name)
359	{
360	return $this->_attributes['filters'][$name] ?? null;
361	}
362	public function setDefaultRepositoryClassName($className)
363	{
364	if (!class_exists($className) \|\| !is_a($className, ObjectRepository::class, \true)) {
365	throw InvalidEntityRepository::fromClassName($className);
366	}
367	if (!is_a($className, EntityRepository::class, \true)) {
368	Deprecation::trigger('doctrine/orm', 'https://github.com/doctrine/orm/pull/9533', 'Configuring %s as default repository class is deprecated because it does not extend %s.', $className, EntityRepository::class);
369	}
370	$this->_attributes['defaultRepositoryClassName'] = $className;
371	}
372	public function getDefaultRepositoryClassName()
373	{
374	return $this->_attributes['defaultRepositoryClassName'] ?? EntityRepository::class;
375	}
376	public function setNamingStrategy(NamingStrategy $namingStrategy)
377	{
378	$this->_attributes['namingStrategy'] = $namingStrategy;
379	}
380	public function getNamingStrategy()
381	{
382	if (!isset($this->_attributes['namingStrategy'])) {
383	$this->_attributes['namingStrategy'] = new DefaultNamingStrategy();
384	}
385	return $this->_attributes['namingStrategy'];
386	}
387	public function setQuoteStrategy(QuoteStrategy $quoteStrategy)
388	{
389	$this->_attributes['quoteStrategy'] = $quoteStrategy;
390	}
391	public function getQuoteStrategy()
392	{
393	if (!isset($this->_attributes['quoteStrategy'])) {
394	$this->_attributes['quoteStrategy'] = new DefaultQuoteStrategy();
395	}
396	return $this->_attributes['quoteStrategy'];
397	}
398	public function setEntityListenerResolver(EntityListenerResolver $resolver)
399	{
400	$this->_attributes['entityListenerResolver'] = $resolver;
401	}
402	public function getEntityListenerResolver()
403	{
404	if (!isset($this->_attributes['entityListenerResolver'])) {
405	$this->_attributes['entityListenerResolver'] = new DefaultEntityListenerResolver();
406	}
407	return $this->_attributes['entityListenerResolver'];
408	}
409	public function setRepositoryFactory(RepositoryFactory $repositoryFactory)
410	{
411	$this->_attributes['repositoryFactory'] = $repositoryFactory;
412	}
413	public function getRepositoryFactory()
414	{
415	return $this->_attributes['repositoryFactory'] ?? new DefaultRepositoryFactory();
416	}
417	public function isSecondLevelCacheEnabled()
418	{
419	return $this->_attributes['isSecondLevelCacheEnabled'] ?? \false;
420	}
421	public function setSecondLevelCacheEnabled($flag = \true)
422	{
423	$this->_attributes['isSecondLevelCacheEnabled'] = (bool) $flag;
424	}
425	public function setSecondLevelCacheConfiguration(CacheConfiguration $cacheConfig)
426	{
427	$this->_attributes['secondLevelCacheConfiguration'] = $cacheConfig;
428	}
429	public function getSecondLevelCacheConfiguration()
430	{
431	if (!isset($this->_attributes['secondLevelCacheConfiguration']) && $this->isSecondLevelCacheEnabled()) {
432	$this->_attributes['secondLevelCacheConfiguration'] = new CacheConfiguration();
433	}
434	return $this->_attributes['secondLevelCacheConfiguration'] ?? null;
435	}
436	public function getDefaultQueryHints()
437	{
438	return $this->_attributes['defaultQueryHints'] ?? [];
439	}
440	public function setDefaultQueryHints(array $defaultQueryHints)
441	{
442	$this->_attributes['defaultQueryHints'] = $defaultQueryHints;
443	}
444	public function getDefaultQueryHint($name)
445	{
446	return $this->_attributes['defaultQueryHints'][$name] ?? \false;
447	}
448	public function setDefaultQueryHint($name, $value)
449	{
450	$this->_attributes['defaultQueryHints'][$name] = $value;
451	}
452	public function getSchemaIgnoreClasses() : array
453	{
454	return $this->_attributes['schemaIgnoreClasses'] ?? [];
455	}
456	public function setSchemaIgnoreClasses(array $schemaIgnoreClasses) : void
457	{
458	$this->_attributes['schemaIgnoreClasses'] = $schemaIgnoreClasses;
459	}
460	public function isLazyGhostObjectEnabled() : bool
461	{
462	return $this->_attributes['isLazyGhostObjectEnabled'] ?? \false;
463	}
464	public function setLazyGhostObjectEnabled(bool $flag) : void
465	{
466	// @phpstan-ignore classConstant.deprecatedTrait (Because we support Symfony < 7.3)
467	if ($flag && !trait_exists(LazyGhostTrait::class)) {
468	throw new LogicException('Lazy ghost objects cannot be enabled because the "symfony/var-exporter" library' . ' version 6.2 or higher is not installed. Please run "composer require symfony/var-exporter:^6.2".');
469	}
470	if ($flag && !class_exists(RuntimeReflectionProperty::class)) {
471	throw new LogicException('Lazy ghost objects cannot be enabled because the "doctrine/persistence" library' . ' version 3.1 or higher is not installed. Please run "composer update doctrine/persistence".');
472	}
473	$this->_attributes['isLazyGhostObjectEnabled'] = $flag;
474	}
475	public function setRejectIdCollisionInIdentityMap(bool $flag) : void
476	{
477	$this->_attributes['rejectIdCollisionInIdentityMap'] = $flag;
478	}
479	public function isRejectIdCollisionInIdentityMapEnabled() : bool
480	{
481	return $this->_attributes['rejectIdCollisionInIdentityMap'] ?? \false;
482	}
483	public function setEagerFetchBatchSize(int $batchSize = 100) : void
484	{
485	$this->_attributes['fetchModeSubselectBatchSize'] = $batchSize;
486	}
487	public function getEagerFetchBatchSize() : int
488	{
489	return $this->_attributes['fetchModeSubselectBatchSize'] ?? 100;
490	}
491	}
492