├── LICENSE
├── README.md
├── SECURITY.md
├── UPGRADE.md
├── composer.json
├── doctrine-mapping.xsd
├── phpstan-dbal3.neon
└── src
    ├── AbstractQuery.php
    ├── Cache.php
    ├── Cache
        ├── AssociationCacheEntry.php
        ├── CacheConfiguration.php
        ├── CacheEntry.php
        ├── CacheException.php
        ├── CacheFactory.php
        ├── CacheKey.php
        ├── CollectionCacheEntry.php
        ├── CollectionCacheKey.php
        ├── CollectionHydrator.php
        ├── ConcurrentRegion.php
        ├── DefaultCache.php
        ├── DefaultCacheFactory.php
        ├── DefaultCollectionHydrator.php
        ├── DefaultEntityHydrator.php
        ├── DefaultQueryCache.php
        ├── EntityCacheEntry.php
        ├── EntityCacheKey.php
        ├── EntityHydrator.php
        ├── Exception
        │   ├── CacheException.php
        │   ├── CannotUpdateReadOnlyCollection.php
        │   ├── CannotUpdateReadOnlyEntity.php
        │   ├── FeatureNotImplemented.php
        │   ├── NonCacheableEntity.php
        │   └── NonCacheableEntityAssociation.php
        ├── Lock.php
        ├── LockException.php
        ├── Logging
        │   ├── CacheLogger.php
        │   ├── CacheLoggerChain.php
        │   └── StatisticsCacheLogger.php
        ├── Persister
        │   ├── CachedPersister.php
        │   ├── Collection
        │   │   ├── AbstractCollectionPersister.php
        │   │   ├── CachedCollectionPersister.php
        │   │   ├── NonStrictReadWriteCachedCollectionPersister.php
        │   │   ├── ReadOnlyCachedCollectionPersister.php
        │   │   └── ReadWriteCachedCollectionPersister.php
        │   └── Entity
        │   │   ├── AbstractEntityPersister.php
        │   │   ├── CachedEntityPersister.php
        │   │   ├── NonStrictReadWriteCachedEntityPersister.php
        │   │   ├── ReadOnlyCachedEntityPersister.php
        │   │   └── ReadWriteCachedEntityPersister.php
        ├── QueryCache.php
        ├── QueryCacheEntry.php
        ├── QueryCacheKey.php
        ├── QueryCacheValidator.php
        ├── Region.php
        ├── Region
        │   ├── DefaultRegion.php
        │   ├── FileLockRegion.php
        │   └── UpdateTimestampCache.php
        ├── RegionsConfiguration.php
        ├── TimestampCacheEntry.php
        ├── TimestampCacheKey.php
        ├── TimestampQueryCacheValidator.php
        └── TimestampRegion.php
    ├── Configuration.php
    ├── Decorator
        └── EntityManagerDecorator.php
    ├── EntityManager.php
    ├── EntityManagerInterface.php
    ├── EntityNotFoundException.php
    ├── EntityRepository.php
    ├── Event
        ├── ListenersInvoker.php
        ├── LoadClassMetadataEventArgs.php
        ├── OnClassMetadataNotFoundEventArgs.php
        ├── OnClearEventArgs.php
        ├── OnFlushEventArgs.php
        ├── PostFlushEventArgs.php
        ├── PostLoadEventArgs.php
        ├── PostPersistEventArgs.php
        ├── PostRemoveEventArgs.php
        ├── PostUpdateEventArgs.php
        ├── PreFlushEventArgs.php
        ├── PrePersistEventArgs.php
        ├── PreRemoveEventArgs.php
        └── PreUpdateEventArgs.php
    ├── Events.php
    ├── Exception
        ├── ConfigurationException.php
        ├── DuplicateFieldException.php
        ├── EntityIdentityCollisionException.php
        ├── EntityManagerClosed.php
        ├── EntityMissingAssignedId.php
        ├── InvalidEntityRepository.php
        ├── InvalidHydrationMode.php
        ├── ManagerException.php
        ├── MissingIdentifierField.php
        ├── MissingMappingDriverImplementation.php
        ├── MultipleSelectorsFoundException.php
        ├── NoMatchingPropertyException.php
        ├── NotSupported.php
        ├── ORMException.php
        ├── PersisterException.php
        ├── RepositoryException.php
        ├── SchemaToolException.php
        ├── UnexpectedAssociationValue.php
        └── UnrecognizedIdentifierFields.php
    ├── Id
        ├── AbstractIdGenerator.php
        ├── AssignedGenerator.php
        ├── BigIntegerIdentityGenerator.php
        ├── IdentityGenerator.php
        └── SequenceGenerator.php
    ├── Internal
        ├── Hydration
        │   ├── AbstractHydrator.php
        │   ├── ArrayHydrator.php
        │   ├── HydrationException.php
        │   ├── ObjectHydrator.php
        │   ├── ScalarColumnHydrator.php
        │   ├── ScalarHydrator.php
        │   ├── SimpleObjectHydrator.php
        │   └── SingleScalarHydrator.php
        ├── HydrationCompleteHandler.php
        ├── NoUnknownNamedArguments.php
        ├── QueryType.php
        ├── SQLResultCasing.php
        ├── StronglyConnectedComponents.php
        ├── TopologicalSort.php
        └── TopologicalSort
        │   └── CycleDetectedException.php
    ├── LazyCriteriaCollection.php
    ├── Mapping
        ├── AnsiQuoteStrategy.php
        ├── ArrayAccessImplementation.php
        ├── AssociationMapping.php
        ├── AssociationOverride.php
        ├── AssociationOverrides.php
        ├── AttributeOverride.php
        ├── AttributeOverrides.php
        ├── Builder
        │   ├── AssociationBuilder.php
        │   ├── ClassMetadataBuilder.php
        │   ├── EmbeddedBuilder.php
        │   ├── EntityListenerBuilder.php
        │   ├── FieldBuilder.php
        │   ├── ManyToManyAssociationBuilder.php
        │   └── OneToManyAssociationBuilder.php
        ├── Cache.php
        ├── ChainTypedFieldMapper.php
        ├── ChangeTrackingPolicy.php
        ├── ClassMetadata.php
        ├── ClassMetadataFactory.php
        ├── Column.php
        ├── CustomIdGenerator.php
        ├── DefaultEntityListenerResolver.php
        ├── DefaultNamingStrategy.php
        ├── DefaultQuoteStrategy.php
        ├── DefaultTypedFieldMapper.php
        ├── DiscriminatorColumn.php
        ├── DiscriminatorColumnMapping.php
        ├── DiscriminatorMap.php
        ├── Driver
        │   ├── AttributeDriver.php
        │   ├── AttributeReader.php
        │   ├── DatabaseDriver.php
        │   ├── LoadMappingFileImplementation.php
        │   ├── ReflectionBasedDriver.php
        │   ├── RepeatableAttributeCollection.php
        │   ├── SimplifiedXmlDriver.php
        │   └── XmlDriver.php
        ├── Embeddable.php
        ├── Embedded.php
        ├── EmbeddedClassMapping.php
        ├── Entity.php
        ├── EntityListenerResolver.php
        ├── EntityListeners.php
        ├── Exception
        │   ├── InvalidCustomGenerator.php
        │   └── UnknownGeneratorType.php
        ├── FieldMapping.php
        ├── GeneratedValue.php
        ├── GetReflectionClassImplementation.php
        ├── HasLifecycleCallbacks.php
        ├── Id.php
        ├── Index.php
        ├── InheritanceType.php
        ├── InverseJoinColumn.php
        ├── InverseSideMapping.php
        ├── JoinColumn.php
        ├── JoinColumnMapping.php
        ├── JoinColumnProperties.php
        ├── JoinColumns.php
        ├── JoinTable.php
        ├── JoinTableMapping.php
        ├── ManyToMany.php
        ├── ManyToManyAssociationMapping.php
        ├── ManyToManyInverseSideMapping.php
        ├── ManyToManyOwningSideMapping.php
        ├── ManyToOne.php
        ├── ManyToOneAssociationMapping.php
        ├── MappedSuperclass.php
        ├── MappingAttribute.php
        ├── MappingException.php
        ├── NamingStrategy.php
        ├── OneToMany.php
        ├── OneToManyAssociationMapping.php
        ├── OneToOne.php
        ├── OneToOneAssociationMapping.php
        ├── OneToOneInverseSideMapping.php
        ├── OneToOneOwningSideMapping.php
        ├── OrderBy.php
        ├── OwningSideMapping.php
        ├── PostLoad.php
        ├── PostPersist.php
        ├── PostRemove.php
        ├── PostUpdate.php
        ├── PreFlush.php
        ├── PrePersist.php
        ├── PreRemove.php
        ├── PreUpdate.php
        ├── QuoteStrategy.php
        ├── ReflectionEmbeddedProperty.php
        ├── ReflectionEnumProperty.php
        ├── ReflectionReadonlyProperty.php
        ├── SequenceGenerator.php
        ├── Table.php
        ├── ToManyAssociationMapping.php
        ├── ToManyAssociationMappingImplementation.php
        ├── ToManyInverseSideMapping.php
        ├── ToManyOwningSideMapping.php
        ├── ToOneAssociationMapping.php
        ├── ToOneInverseSideMapping.php
        ├── ToOneOwningSideMapping.php
        ├── TypedFieldMapper.php
        ├── UnderscoreNamingStrategy.php
        ├── UniqueConstraint.php
        └── Version.php
    ├── NativeQuery.php
    ├── NoResultException.php
    ├── NonUniqueResultException.php
    ├── ORMInvalidArgumentException.php
    ├── ORMSetup.php
    ├── OptimisticLockException.php
    ├── PersistentCollection.php
    ├── Persisters
        ├── Collection
        │   ├── AbstractCollectionPersister.php
        │   ├── CollectionPersister.php
        │   ├── ManyToManyPersister.php
        │   └── OneToManyPersister.php
        ├── Entity
        │   ├── AbstractEntityInheritancePersister.php
        │   ├── BasicEntityPersister.php
        │   ├── CachedPersisterContext.php
        │   ├── EntityPersister.php
        │   ├── JoinedSubclassPersister.php
        │   └── SingleTablePersister.php
        ├── Exception
        │   ├── CantUseInOperatorOnCompositeKeys.php
        │   ├── InvalidOrientation.php
        │   └── UnrecognizedField.php
        ├── MatchingAssociationFieldRequiresObject.php
        ├── PersisterException.php
        ├── SqlExpressionVisitor.php
        └── SqlValueVisitor.php
    ├── PessimisticLockException.php
    ├── Proxy
        ├── Autoloader.php
        ├── DefaultProxyClassNameResolver.php
        ├── InternalProxy.php
        ├── NotAProxyClass.php
        └── ProxyFactory.php
    ├── Query.php
    ├── Query
        ├── AST
        │   ├── ASTException.php
        │   ├── AggregateExpression.php
        │   ├── ArithmeticExpression.php
        │   ├── ArithmeticFactor.php
        │   ├── ArithmeticTerm.php
        │   ├── BetweenExpression.php
        │   ├── CoalesceExpression.php
        │   ├── CollectionMemberExpression.php
        │   ├── ComparisonExpression.php
        │   ├── ConditionalExpression.php
        │   ├── ConditionalFactor.php
        │   ├── ConditionalPrimary.php
        │   ├── ConditionalTerm.php
        │   ├── DeleteClause.php
        │   ├── DeleteStatement.php
        │   ├── EmptyCollectionComparisonExpression.php
        │   ├── ExistsExpression.php
        │   ├── FromClause.php
        │   ├── Functions
        │   │   ├── AbsFunction.php
        │   │   ├── AvgFunction.php
        │   │   ├── BitAndFunction.php
        │   │   ├── BitOrFunction.php
        │   │   ├── ConcatFunction.php
        │   │   ├── CountFunction.php
        │   │   ├── CurrentDateFunction.php
        │   │   ├── CurrentTimeFunction.php
        │   │   ├── CurrentTimestampFunction.php
        │   │   ├── DateAddFunction.php
        │   │   ├── DateDiffFunction.php
        │   │   ├── DateSubFunction.php
        │   │   ├── FunctionNode.php
        │   │   ├── IdentityFunction.php
        │   │   ├── LengthFunction.php
        │   │   ├── LocateFunction.php
        │   │   ├── LowerFunction.php
        │   │   ├── MaxFunction.php
        │   │   ├── MinFunction.php
        │   │   ├── ModFunction.php
        │   │   ├── SizeFunction.php
        │   │   ├── SqrtFunction.php
        │   │   ├── SubstringFunction.php
        │   │   ├── SumFunction.php
        │   │   ├── TrimFunction.php
        │   │   └── UpperFunction.php
        │   ├── GeneralCaseExpression.php
        │   ├── GroupByClause.php
        │   ├── HavingClause.php
        │   ├── IdentificationVariableDeclaration.php
        │   ├── InListExpression.php
        │   ├── InSubselectExpression.php
        │   ├── IndexBy.php
        │   ├── InputParameter.php
        │   ├── InstanceOfExpression.php
        │   ├── Join.php
        │   ├── JoinAssociationDeclaration.php
        │   ├── JoinAssociationPathExpression.php
        │   ├── JoinClassPathExpression.php
        │   ├── JoinVariableDeclaration.php
        │   ├── LikeExpression.php
        │   ├── Literal.php
        │   ├── NewObjectExpression.php
        │   ├── Node.php
        │   ├── NullComparisonExpression.php
        │   ├── NullIfExpression.php
        │   ├── OrderByClause.php
        │   ├── OrderByItem.php
        │   ├── ParenthesisExpression.php
        │   ├── PartialObjectExpression.php
        │   ├── PathExpression.php
        │   ├── Phase2OptimizableConditional.php
        │   ├── QuantifiedExpression.php
        │   ├── RangeVariableDeclaration.php
        │   ├── SelectClause.php
        │   ├── SelectExpression.php
        │   ├── SelectStatement.php
        │   ├── SimpleArithmeticExpression.php
        │   ├── SimpleCaseExpression.php
        │   ├── SimpleSelectClause.php
        │   ├── SimpleSelectExpression.php
        │   ├── SimpleWhenClause.php
        │   ├── Subselect.php
        │   ├── SubselectFromClause.php
        │   ├── SubselectIdentificationVariableDeclaration.php
        │   ├── TypedExpression.php
        │   ├── UpdateClause.php
        │   ├── UpdateItem.php
        │   ├── UpdateStatement.php
        │   ├── WhenClause.php
        │   └── WhereClause.php
        ├── Exec
        │   ├── AbstractSqlExecutor.php
        │   ├── FinalizedSelectExecutor.php
        │   ├── MultiTableDeleteExecutor.php
        │   ├── MultiTableUpdateExecutor.php
        │   ├── PreparedExecutorFinalizer.php
        │   ├── SingleSelectExecutor.php
        │   ├── SingleSelectSqlFinalizer.php
        │   ├── SingleTableDeleteUpdateExecutor.php
        │   └── SqlFinalizer.php
        ├── Expr.php
        ├── Expr
        │   ├── Andx.php
        │   ├── Base.php
        │   ├── Comparison.php
        │   ├── Composite.php
        │   ├── From.php
        │   ├── Func.php
        │   ├── GroupBy.php
        │   ├── Join.php
        │   ├── Literal.php
        │   ├── Math.php
        │   ├── OrderBy.php
        │   ├── Orx.php
        │   └── Select.php
        ├── Filter
        │   ├── FilterException.php
        │   └── SQLFilter.php
        ├── FilterCollection.php
        ├── Lexer.php
        ├── OutputWalker.php
        ├── Parameter.php
        ├── ParameterTypeInferer.php
        ├── Parser.php
        ├── ParserResult.php
        ├── Printer.php
        ├── QueryException.php
        ├── QueryExpressionVisitor.php
        ├── ResultSetMapping.php
        ├── ResultSetMappingBuilder.php
        ├── SqlOutputWalker.php
        ├── SqlWalker.php
        ├── TokenType.php
        ├── TreeWalker.php
        ├── TreeWalkerAdapter.php
        └── TreeWalkerChain.php
    ├── QueryBuilder.php
    ├── Repository
        ├── DefaultRepositoryFactory.php
        ├── Exception
        │   ├── InvalidFindByCall.php
        │   └── InvalidMagicMethodCall.php
        └── RepositoryFactory.php
    ├── Tools
        ├── AttachEntityListenersListener.php
        ├── Console
        │   ├── Command
        │   │   ├── AbstractEntityManagerCommand.php
        │   │   ├── ClearCache
        │   │   │   ├── CollectionRegionCommand.php
        │   │   │   ├── EntityRegionCommand.php
        │   │   │   ├── MetadataCommand.php
        │   │   │   ├── QueryCommand.php
        │   │   │   ├── QueryRegionCommand.php
        │   │   │   └── ResultCommand.php
        │   │   ├── GenerateProxiesCommand.php
        │   │   ├── InfoCommand.php
        │   │   ├── MappingDescribeCommand.php
        │   │   ├── RunDqlCommand.php
        │   │   ├── SchemaTool
        │   │   │   ├── AbstractCommand.php
        │   │   │   ├── CreateCommand.php
        │   │   │   ├── DropCommand.php
        │   │   │   └── UpdateCommand.php
        │   │   └── ValidateSchemaCommand.php
        │   ├── ConsoleRunner.php
        │   ├── EntityManagerProvider.php
        │   ├── EntityManagerProvider
        │   │   ├── ConnectionFromManagerProvider.php
        │   │   ├── SingleManagerProvider.php
        │   │   └── UnknownManagerException.php
        │   └── MetadataFilter.php
        ├── Debug.php
        ├── DebugUnitOfWorkListener.php
        ├── Event
        │   ├── GenerateSchemaEventArgs.php
        │   └── GenerateSchemaTableEventArgs.php
        ├── Exception
        │   ├── MissingColumnException.php
        │   └── NotSupported.php
        ├── Pagination
        │   ├── CountOutputWalker.php
        │   ├── CountWalker.php
        │   ├── Exception
        │   │   └── RowNumberOverFunctionNotEnabled.php
        │   ├── LimitSubqueryOutputWalker.php
        │   ├── LimitSubqueryWalker.php
        │   ├── Paginator.php
        │   ├── RootTypeWalker.php
        │   ├── RowNumberOverFunction.php
        │   └── WhereInWalker.php
        ├── ResolveTargetEntityListener.php
        ├── SchemaTool.php
        ├── SchemaValidator.php
        ├── ToolEvents.php
        └── ToolsException.php
    ├── TransactionRequiredException.php
    ├── UnexpectedResultException.php
    ├── UnitOfWork.php
    └── Utility
        ├── HierarchyDiscriminatorResolver.php
        ├── IdentifierFlattener.php
        ├── LockSqlHelper.php
        └── PersisterHelper.php


/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) Doctrine Project
 2 | 
 3 | Permission is hereby granted, free of charge, to any person obtaining a copy of
 4 | this software and associated documentation files (the "Software"), to deal in
 5 | the Software without restriction, including without limitation the rights to
 6 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
 7 | of the Software, and to permit persons to whom the Software is furnished to do
 8 | so, subject to the following conditions:
 9 | 
10 | The above copyright notice and this permission notice shall be included in all
11 | copies or substantial portions of the Software.
12 | 
13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
19 | SOFTWARE.
20 | 


--------------------------------------------------------------------------------
/SECURITY.md:
--------------------------------------------------------------------------------
 1 | Security
 2 | ========
 3 | 
 4 | The Doctrine library is operating very close to your database and as such needs
 5 | to handle and make assumptions about SQL injection vulnerabilities.
 6 | 
 7 | It is vital that you understand how Doctrine approaches security, because
 8 | we cannot protect you from SQL injection.
 9 | 
10 | Please read the documentation chapter on Security in Doctrine DBAL and ORM to
11 | understand the assumptions we make.
12 | 
13 | - [DBAL Security Page](https://www.doctrine-project.org/projects/doctrine-dbal/en/stable/reference/security.html)
14 | - [ORM Security Page](https://www.doctrine-project.org/projects/doctrine-orm/en/stable/reference/security.html)
15 | 
16 | If you find a Security bug in Doctrine, please follow our
17 | [Security reporting guidelines](https://www.doctrine-project.org/policies/security.html#reporting).
18 | 


--------------------------------------------------------------------------------
/src/Cache/AssociationCacheEntry.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Cache;
 6 | 
 7 | class AssociationCacheEntry implements CacheEntry
 8 | {
 9 |     /**
10 |      * @param array<string, mixed> $identifier The entity identifier.
11 |      * @param class-string         $class      The entity class name
12 |      */
13 |     public function __construct(
14 |         public readonly string $class,
15 |         public readonly array $identifier,
16 |     ) {
17 |     }
18 | 
19 |     /**
20 |      * Creates a new AssociationCacheEntry
21 |      *
22 |      * This method allow Doctrine\Common\Cache\PhpFileCache compatibility
23 |      *
24 |      * @param array<string, mixed> $values array containing property values
25 |      */
26 |     public static function __set_state(array $values): self
27 |     {
28 |         return new self($values['class'], $values['identifier']);
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Cache/CacheEntry.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Cache;
 6 | 
 7 | /**
 8 |  * Cache entry interface
 9 |  *
10 |  * <b>IMPORTANT NOTE:</b>
11 |  *
12 |  * Fields of classes that implement CacheEntry are public for performance reason.
13 |  */
14 | interface CacheEntry
15 | {
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Cache/CacheException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Cache;
 6 | 
 7 | use Doctrine\ORM\Exception\ORMException;
 8 | use LogicException;
 9 | 
10 | use function sprintf;
11 | 
12 | /**
13 |  * Exception for cache.
14 |  */
15 | class CacheException extends LogicException implements ORMException
16 | {
17 |     public static function updateReadOnlyCollection(string $sourceEntity, string $fieldName): self
18 |     {
19 |         return new self(sprintf('Cannot update a readonly collection "%s#%s"', $sourceEntity, $fieldName));
20 |     }
21 | 
22 |     public static function nonCacheableEntity(string $entityName): self
23 |     {
24 |         return new self(sprintf('Entity "%s" not configured as part of the second-level cache.', $entityName));
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Cache/CacheKey.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Cache;
 6 | 
 7 | /**
 8 |  * Defines entity / collection / query key to be stored in the cache region.
 9 |  * Allows multiple roles to be stored in the same cache region.
10 |  */
11 | abstract class CacheKey
12 | {
13 |     public function __construct(public readonly string $hash)
14 |     {
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Cache/CollectionCacheEntry.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Cache;
 6 | 
 7 | class CollectionCacheEntry implements CacheEntry
 8 | {
 9 |     /** @param CacheKey[] $identifiers List of entity identifiers hold by the collection */
10 |     public function __construct(public readonly array $identifiers)
11 |     {
12 |     }
13 | 
14 |     /**
15 |      * Creates a new CollectionCacheEntry
16 |      *
17 |      * This method allows for Doctrine\Common\Cache\PhpFileCache compatibility
18 |      *
19 |      * @param array<string, mixed> $values array containing property values
20 |      */
21 |     public static function __set_state(array $values): CollectionCacheEntry
22 |     {
23 |         return new self($values['identifiers']);
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Cache/CollectionCacheKey.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Cache;
 6 | 
 7 | use function implode;
 8 | use function ksort;
 9 | use function str_replace;
10 | use function strtolower;
11 | 
12 | /**
13 |  * Defines entity collection roles to be stored in the cache region.
14 |  */
15 | class CollectionCacheKey extends CacheKey
16 | {
17 |     /**
18 |      * The owner entity identifier
19 |      *
20 |      * @var array<string, mixed>
21 |      */
22 |     public readonly array $ownerIdentifier;
23 | 
24 |     /**
25 |      * @param class-string         $entityClass     The owner entity class.
26 |      * @param array<string, mixed> $ownerIdentifier The identifier of the owning entity.
27 |      */
28 |     public function __construct(
29 |         public readonly string $entityClass,
30 |         public readonly string $association,
31 |         array $ownerIdentifier,
32 |         string $filterHash = '',
33 |     ) {
34 |         ksort($ownerIdentifier);
35 | 
36 |         $this->ownerIdentifier = $ownerIdentifier;
37 | 
38 |         $filterHash = $filterHash === '' ? '' : '_' . $filterHash;
39 | 
40 |         parent::__construct(str_replace('\\', '.', strtolower($entityClass)) . '_' . implode(' ', $ownerIdentifier) . '__' . $association . $filterHash);
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/src/Cache/CollectionHydrator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Cache;
 6 | 
 7 | use Doctrine\Common\Collections\Collection;
 8 | use Doctrine\ORM\Mapping\ClassMetadata;
 9 | use Doctrine\ORM\PersistentCollection;
10 | 
11 | /**
12 |  * Hydrator cache entry for collections
13 |  */
14 | interface CollectionHydrator
15 | {
16 |     /** @param mixed[]|Collection $collection The collection. */
17 |     public function buildCacheEntry(ClassMetadata $metadata, CollectionCacheKey $key, array|Collection $collection): CollectionCacheEntry;
18 | 
19 |     /** @return mixed[]|null */
20 |     public function loadCacheEntry(ClassMetadata $metadata, CollectionCacheKey $key, CollectionCacheEntry $entry, PersistentCollection $collection): array|null;
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Cache/ConcurrentRegion.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Cache;
 6 | 
 7 | /**
 8 |  * Defines contract for concurrently managed data region.
 9 |  * It should be able to lock an specific cache entry in an atomic operation.
10 |  *
11 |  * When a entry is locked another process should not be able to read or write the entry.
12 |  * All evict operation should not consider locks, even though an entry is locked evict should be able to delete the entry and its lock.
13 |  */
14 | interface ConcurrentRegion extends Region
15 | {
16 |     /**
17 |      * Attempts to read lock the mapping for the given key.
18 |      *
19 |      * @param CacheKey $key The key of the item to lock.
20 |      *
21 |      * @return Lock|null A lock instance or NULL if the lock already exists.
22 |      *
23 |      * @throws LockException Indicates a problem accessing the region.
24 |      */
25 |     public function lock(CacheKey $key): Lock|null;
26 | 
27 |     /**
28 |      * Attempts to read unlock the mapping for the given key.
29 |      *
30 |      * @param CacheKey $key  The key of the item to unlock.
31 |      * @param Lock     $lock The lock previously obtained from {@link readLock}
32 |      *
33 |      * @throws LockException Indicates a problem accessing the region.
34 |      */
35 |     public function unlock(CacheKey $key, Lock $lock): bool;
36 | }
37 | 


--------------------------------------------------------------------------------
/src/Cache/EntityCacheEntry.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Cache;
 6 | 
 7 | use Doctrine\ORM\EntityManagerInterface;
 8 | 
 9 | use function array_map;
10 | 
11 | class EntityCacheEntry implements CacheEntry
12 | {
13 |     /**
14 |      * @param class-string        $class The entity class name
15 |      * @param array<string,mixed> $data  The entity map data
16 |      */
17 |     public function __construct(
18 |         public readonly string $class,
19 |         public readonly array $data,
20 |     ) {
21 |     }
22 | 
23 |     /**
24 |      * Creates a new EntityCacheEntry
25 |      *
26 |      * This method allows Doctrine\Common\Cache\PhpFileCache compatibility
27 |      *
28 |      * @param array<string,mixed> $values array containing property values
29 |      */
30 |     public static function __set_state(array $values): self
31 |     {
32 |         return new self($values['class'], $values['data']);
33 |     }
34 | 
35 |     /**
36 |      * Retrieves the entity data resolving cache entries
37 |      *
38 |      * @return array<string, mixed>
39 |      */
40 |     public function resolveAssociationEntries(EntityManagerInterface $em): array
41 |     {
42 |         return array_map(static function ($value) use ($em) {
43 |             if (! ($value instanceof AssociationCacheEntry)) {
44 |                 return $value;
45 |             }
46 | 
47 |             return $em->getReference($value->class, $value->identifier);
48 |         }, $this->data);
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/src/Cache/EntityCacheKey.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Cache;
 6 | 
 7 | use function implode;
 8 | use function ksort;
 9 | use function str_replace;
10 | use function strtolower;
11 | 
12 | /**
13 |  * Defines entity classes roles to be stored in the cache region.
14 |  */
15 | class EntityCacheKey extends CacheKey
16 | {
17 |     /**
18 |      * The entity identifier
19 |      *
20 |      * @var array<string, mixed>
21 |      */
22 |     public readonly array $identifier;
23 | 
24 |     /**
25 |      * @param class-string         $entityClass The entity class name. In a inheritance hierarchy it should always be the root entity class.
26 |      * @param array<string, mixed> $identifier  The entity identifier
27 |      */
28 |     public function __construct(
29 |         public readonly string $entityClass,
30 |         array $identifier,
31 |     ) {
32 |         ksort($identifier);
33 | 
34 |         $this->identifier = $identifier;
35 | 
36 |         parent::__construct(str_replace('\\', '.', strtolower($entityClass) . '_' . implode(' ', $identifier)));
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Cache/EntityHydrator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Cache;
 6 | 
 7 | use Doctrine\ORM\Mapping\ClassMetadata;
 8 | 
 9 | /**
10 |  * Hydrator cache entry for entities
11 |  */
12 | interface EntityHydrator
13 | {
14 |     /**
15 |      * @param ClassMetadata  $metadata The entity metadata.
16 |      * @param EntityCacheKey $key      The entity cache key.
17 |      * @param object         $entity   The entity.
18 |      */
19 |     public function buildCacheEntry(ClassMetadata $metadata, EntityCacheKey $key, object $entity): EntityCacheEntry;
20 | 
21 |     /**
22 |      * @param ClassMetadata    $metadata The entity metadata.
23 |      * @param EntityCacheKey   $key      The entity cache key.
24 |      * @param EntityCacheEntry $entry    The entity cache entry.
25 |      * @param object|null      $entity   The entity to load the cache into. If not specified, a new entity is created.
26 |      */
27 |     public function loadCacheEntry(ClassMetadata $metadata, EntityCacheKey $key, EntityCacheEntry $entry, object|null $entity = null): object|null;
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Cache/Exception/CacheException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Cache\Exception;
 6 | 
 7 | use Doctrine\ORM\Cache\CacheException as BaseCacheException;
 8 | 
 9 | /**
10 |  * Exception for cache.
11 |  */
12 | class CacheException extends BaseCacheException
13 | {
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Cache/Exception/CannotUpdateReadOnlyCollection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Cache\Exception;
 6 | 
 7 | use function sprintf;
 8 | 
 9 | class CannotUpdateReadOnlyCollection extends CacheException
10 | {
11 |     public static function fromEntityAndField(string $sourceEntity, string $fieldName): self
12 |     {
13 |         return new self(sprintf(
14 |             'Cannot update a readonly collection "%s#%s"',
15 |             $sourceEntity,
16 |             $fieldName,
17 |         ));
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Cache/Exception/CannotUpdateReadOnlyEntity.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Cache\Exception;
 6 | 
 7 | use function sprintf;
 8 | 
 9 | class CannotUpdateReadOnlyEntity extends CacheException
10 | {
11 |     public static function fromEntity(string $entityName): self
12 |     {
13 |         return new self(sprintf('Cannot update a readonly entity "%s"', $entityName));
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Cache/Exception/FeatureNotImplemented.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Cache\Exception;
 6 | 
 7 | class FeatureNotImplemented extends CacheException
 8 | {
 9 |     public static function scalarResults(): self
10 |     {
11 |         return new self('Second level cache does not support scalar results.');
12 |     }
13 | 
14 |     public static function multipleRootEntities(): self
15 |     {
16 |         return new self('Second level cache does not support multiple root entities.');
17 |     }
18 | 
19 |     public static function nonSelectStatements(): self
20 |     {
21 |         return new self('Second-level cache query supports only select statements.');
22 |     }
23 | 
24 |     public static function partialEntities(): self
25 |     {
26 |         return new self('Second level cache does not support partial entities.');
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Cache/Exception/NonCacheableEntity.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Cache\Exception;
 6 | 
 7 | use function sprintf;
 8 | 
 9 | class NonCacheableEntity extends CacheException
10 | {
11 |     public static function fromEntity(string $entityName): self
12 |     {
13 |         return new self(sprintf(
14 |             'Entity "%s" not configured as part of the second-level cache.',
15 |             $entityName,
16 |         ));
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Cache/Exception/NonCacheableEntityAssociation.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Cache\Exception;
 6 | 
 7 | use function sprintf;
 8 | 
 9 | class NonCacheableEntityAssociation extends CacheException
10 | {
11 |     public static function fromEntityAndField(string $entityName, string $field): self
12 |     {
13 |         return new self(sprintf(
14 |             'Entity association field "%s#%s" not configured as part of the second-level cache.',
15 |             $entityName,
16 |             $field,
17 |         ));
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Cache/Lock.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Cache;
 6 | 
 7 | use function time;
 8 | use function uniqid;
 9 | 
10 | class Lock
11 | {
12 |     public int $time;
13 | 
14 |     public function __construct(
15 |         public string $value,
16 |         int|null $time = null,
17 |     ) {
18 |         $this->time = $time ?? time();
19 |     }
20 | 
21 |     public static function createLockRead(): Lock
22 |     {
23 |         return new self(uniqid((string) time(), true));
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Cache/LockException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Cache;
 6 | 
 7 | use Doctrine\ORM\Cache\Exception\CacheException;
 8 | 
 9 | /**
10 |  * Lock exception for cache.
11 |  */
12 | class LockException extends CacheException
13 | {
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Cache/Persister/CachedPersister.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Cache\Persister;
 6 | 
 7 | use Doctrine\ORM\Cache\Region;
 8 | 
 9 | /**
10 |  * Interface for persister that support second level cache.
11 |  */
12 | interface CachedPersister
13 | {
14 |     /**
15 |      * Perform whatever processing is encapsulated here after completion of the transaction.
16 |      */
17 |     public function afterTransactionComplete(): void;
18 | 
19 |     /**
20 |      * Perform whatever processing is encapsulated here after completion of the rolled-back.
21 |      */
22 |     public function afterTransactionRolledBack(): void;
23 | 
24 |     public function getCacheRegion(): Region;
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Cache/Persister/Collection/CachedCollectionPersister.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Cache\Persister\Collection;
 6 | 
 7 | use Doctrine\Common\Collections\Collection;
 8 | use Doctrine\ORM\Cache\CollectionCacheKey;
 9 | use Doctrine\ORM\Cache\Persister\CachedPersister;
10 | use Doctrine\ORM\Mapping\ClassMetadata;
11 | use Doctrine\ORM\PersistentCollection;
12 | use Doctrine\ORM\Persisters\Collection\CollectionPersister;
13 | 
14 | /**
15 |  * Interface for second level cache collection persisters.
16 |  */
17 | interface CachedCollectionPersister extends CachedPersister, CollectionPersister
18 | {
19 |     public function getSourceEntityMetadata(): ClassMetadata;
20 | 
21 |     public function getTargetEntityMetadata(): ClassMetadata;
22 | 
23 |     /**
24 |      * Loads a collection from cache
25 |      *
26 |      * @return mixed[]|null
27 |      */
28 |     public function loadCollectionCache(PersistentCollection $collection, CollectionCacheKey $key): array|null;
29 | 
30 |     /**
31 |      * Stores a collection into cache
32 |      *
33 |      * @param mixed[]|Collection $elements
34 |      */
35 |     public function storeCollectionCache(CollectionCacheKey $key, Collection|array $elements): void;
36 | }
37 | 


--------------------------------------------------------------------------------
/src/Cache/Persister/Collection/ReadOnlyCachedCollectionPersister.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Cache\Persister\Collection;
 6 | 
 7 | use Doctrine\ORM\Cache\Exception\CannotUpdateReadOnlyCollection;
 8 | use Doctrine\ORM\PersistentCollection;
 9 | use Doctrine\ORM\Proxy\DefaultProxyClassNameResolver;
10 | 
11 | class ReadOnlyCachedCollectionPersister extends NonStrictReadWriteCachedCollectionPersister
12 | {
13 |     public function update(PersistentCollection $collection): void
14 |     {
15 |         if ($collection->isDirty() && $collection->getSnapshot()) {
16 |             throw CannotUpdateReadOnlyCollection::fromEntityAndField(
17 |                 DefaultProxyClassNameResolver::getClass($collection->getOwner()),
18 |                 $this->association->fieldName,
19 |             );
20 |         }
21 | 
22 |         parent::update($collection);
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Cache/Persister/Entity/CachedEntityPersister.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Cache\Persister\Entity;
 6 | 
 7 | use Doctrine\ORM\Cache\EntityCacheKey;
 8 | use Doctrine\ORM\Cache\EntityHydrator;
 9 | use Doctrine\ORM\Cache\Persister\CachedPersister;
10 | use Doctrine\ORM\Persisters\Entity\EntityPersister;
11 | 
12 | /**
13 |  * Interface for second level cache entity persisters.
14 |  */
15 | interface CachedEntityPersister extends CachedPersister, EntityPersister
16 | {
17 |     public function getEntityHydrator(): EntityHydrator;
18 | 
19 |     public function storeEntityCache(object $entity, EntityCacheKey $key): bool;
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Cache/Persister/Entity/ReadOnlyCachedEntityPersister.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Cache\Persister\Entity;
 6 | 
 7 | use Doctrine\ORM\Cache\Exception\CannotUpdateReadOnlyEntity;
 8 | use Doctrine\ORM\Proxy\DefaultProxyClassNameResolver;
 9 | 
10 | /**
11 |  * Specific read-only region entity persister
12 |  */
13 | class ReadOnlyCachedEntityPersister extends NonStrictReadWriteCachedEntityPersister
14 | {
15 |     public function update(object $entity): void
16 |     {
17 |         throw CannotUpdateReadOnlyEntity::fromEntity(DefaultProxyClassNameResolver::getClass($entity));
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Cache/QueryCache.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Cache;
 6 | 
 7 | use Doctrine\ORM\Query\ResultSetMapping;
 8 | 
 9 | /**
10 |  * Defines the contract for caches capable of storing query results.
11 |  * These caches should only concern themselves with storing the matching result ids.
12 |  */
13 | interface QueryCache
14 | {
15 |     public function clear(): bool;
16 | 
17 |     /** @param mixed[] $hints */
18 |     public function put(QueryCacheKey $key, ResultSetMapping $rsm, mixed $result, array $hints = []): bool;
19 | 
20 |     /**
21 |      * @param mixed[] $hints
22 |      *
23 |      * @return mixed[]|null
24 |      */
25 |     public function get(QueryCacheKey $key, ResultSetMapping $rsm, array $hints = []): array|null;
26 | 
27 |     public function getRegion(): Region;
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Cache/QueryCacheEntry.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Cache;
 6 | 
 7 | use function microtime;
 8 | 
 9 | class QueryCacheEntry implements CacheEntry
10 | {
11 |     /**
12 |      * Time creation of this cache entry
13 |      */
14 |     public readonly float $time;
15 | 
16 |     /** @param array<string, mixed> $result List of entity identifiers */
17 |     public function __construct(
18 |         public readonly array $result,
19 |         float|null $time = null,
20 |     ) {
21 |         $this->time = $time ?: microtime(true);
22 |     }
23 | 
24 |     /** @param array<string, mixed> $values */
25 |     public static function __set_state(array $values): self
26 |     {
27 |         return new self($values['result'], $values['time']);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Cache/QueryCacheKey.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Cache;
 6 | 
 7 | use Doctrine\ORM\Cache;
 8 | 
 9 | /**
10 |  * A cache key that identifies a particular query.
11 |  */
12 | class QueryCacheKey extends CacheKey
13 | {
14 |     /** @param Cache::MODE_* $cacheMode */
15 |     public function __construct(
16 |         string $cacheId,
17 |         public readonly int $lifetime = 0,
18 |         public readonly int $cacheMode = Cache::MODE_NORMAL,
19 |         public readonly TimestampCacheKey|null $timestampKey = null,
20 |     ) {
21 |         parent::__construct($cacheId);
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Cache/QueryCacheValidator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Cache;
 6 | 
 7 | /**
 8 |  * Cache query validator interface.
 9 |  */
10 | interface QueryCacheValidator
11 | {
12 |     /**
13 |      * Checks if the query entry is valid
14 |      */
15 |     public function isValid(QueryCacheKey $key, QueryCacheEntry $entry): bool;
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Cache/Region/UpdateTimestampCache.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Cache\Region;
 6 | 
 7 | use Doctrine\ORM\Cache\CacheKey;
 8 | use Doctrine\ORM\Cache\TimestampCacheEntry;
 9 | use Doctrine\ORM\Cache\TimestampRegion;
10 | 
11 | /**
12 |  * Tracks the timestamps of the most recent updates to particular keys.
13 |  */
14 | class UpdateTimestampCache extends DefaultRegion implements TimestampRegion
15 | {
16 |     public function update(CacheKey $key): void
17 |     {
18 |         $this->put($key, new TimestampCacheEntry());
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Cache/TimestampCacheEntry.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Cache;
 6 | 
 7 | use function microtime;
 8 | 
 9 | class TimestampCacheEntry implements CacheEntry
10 | {
11 |     public readonly float $time;
12 | 
13 |     public function __construct(float|null $time = null)
14 |     {
15 |         $this->time = $time ?? microtime(true);
16 |     }
17 | 
18 |     /**
19 |      * Creates a new TimestampCacheEntry
20 |      *
21 |      * This method allow Doctrine\Common\Cache\PhpFileCache compatibility
22 |      *
23 |      * @param array<string,float> $values array containing property values
24 |      */
25 |     public static function __set_state(array $values): TimestampCacheEntry
26 |     {
27 |         return new self($values['time']);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Cache/TimestampCacheKey.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Cache;
 6 | 
 7 | /**
 8 |  * A key that identifies a timestamped space.
 9 |  */
10 | class TimestampCacheKey extends CacheKey
11 | {
12 |     /** @param string $space Result cache id */
13 |     public function __construct(string $space)
14 |     {
15 |         parent::__construct($space);
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Cache/TimestampQueryCacheValidator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Cache;
 6 | 
 7 | use function microtime;
 8 | 
 9 | class TimestampQueryCacheValidator implements QueryCacheValidator
10 | {
11 |     public function __construct(private readonly TimestampRegion $timestampRegion)
12 |     {
13 |     }
14 | 
15 |     public function isValid(QueryCacheKey $key, QueryCacheEntry $entry): bool
16 |     {
17 |         if ($this->regionUpdated($key, $entry)) {
18 |             return false;
19 |         }
20 | 
21 |         if ($key->lifetime === 0) {
22 |             return true;
23 |         }
24 | 
25 |         return $entry->time + $key->lifetime > microtime(true);
26 |     }
27 | 
28 |     private function regionUpdated(QueryCacheKey $key, QueryCacheEntry $entry): bool
29 |     {
30 |         if ($key->timestampKey === null) {
31 |             return false;
32 |         }
33 | 
34 |         $timestamp = $this->timestampRegion->get($key->timestampKey);
35 | 
36 |         return $timestamp && $timestamp->time > $entry->time;
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Cache/TimestampRegion.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Cache;
 6 | 
 7 | /**
 8 |  * Defines the contract for a cache region which will specifically be used to store entity "update timestamps".
 9 |  */
10 | interface TimestampRegion extends Region
11 | {
12 |     /**
13 |      * Update a specific key into the cache region.
14 |      *
15 |      * @throws LockException Indicates a problem accessing the region.
16 |      */
17 |     public function update(CacheKey $key): void;
18 | }
19 | 


--------------------------------------------------------------------------------
/src/EntityNotFoundException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM;
 6 | 
 7 | use Doctrine\ORM\Exception\ORMException;
 8 | use RuntimeException;
 9 | 
10 | use function implode;
11 | use function sprintf;
12 | 
13 | /**
14 |  * Exception thrown when a Proxy fails to retrieve an Entity result.
15 |  */
16 | class EntityNotFoundException extends RuntimeException implements ORMException
17 | {
18 |     /**
19 |      * Static constructor.
20 |      *
21 |      * @param string[] $id
22 |      */
23 |     public static function fromClassNameAndIdentifier(string $className, array $id): self
24 |     {
25 |         $ids = [];
26 | 
27 |         foreach ($id as $key => $value) {
28 |             $ids[] = $key . '(' . $value . ')';
29 |         }
30 | 
31 |         return new self(
32 |             'Entity of type \'' . $className . '\'' . ($ids ? ' for IDs ' . implode(', ', $ids) : '') . ' was not found',
33 |         );
34 |     }
35 | 
36 |     /**
37 |      * Instance for which no identifier can be found
38 |      */
39 |     public static function noIdentifierFound(string $className): self
40 |     {
41 |         return new self(sprintf(
42 |             'Unable to find "%s" entity identifier associated with the UnitOfWork',
43 |             $className,
44 |         ));
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/src/Event/LoadClassMetadataEventArgs.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Event;
 6 | 
 7 | use Doctrine\ORM\EntityManagerInterface;
 8 | use Doctrine\ORM\Mapping\ClassMetadata;
 9 | use Doctrine\Persistence\Event\LoadClassMetadataEventArgs as BaseLoadClassMetadataEventArgs;
10 | 
11 | /**
12 |  * Class that holds event arguments for a loadMetadata event.
13 |  *
14 |  * @extends BaseLoadClassMetadataEventArgs<ClassMetadata<object>, EntityManagerInterface>
15 |  */
16 | class LoadClassMetadataEventArgs extends BaseLoadClassMetadataEventArgs
17 | {
18 |     /**
19 |      * Retrieve associated EntityManager.
20 |      */
21 |     public function getEntityManager(): EntityManagerInterface
22 |     {
23 |         return $this->getObjectManager();
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Event/OnClearEventArgs.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Event;
 6 | 
 7 | use Doctrine\ORM\EntityManagerInterface;
 8 | use Doctrine\Persistence\Event\OnClearEventArgs as BaseOnClearEventArgs;
 9 | 
10 | /**
11 |  * Provides event arguments for the onClear event.
12 |  *
13 |  * @link        www.doctrine-project.org
14 |  *
15 |  * @extends BaseOnClearEventArgs<EntityManagerInterface>
16 |  */
17 | class OnClearEventArgs extends BaseOnClearEventArgs
18 | {
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Event/OnFlushEventArgs.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Event;
 6 | 
 7 | use Doctrine\ORM\EntityManagerInterface;
 8 | use Doctrine\Persistence\Event\ManagerEventArgs;
 9 | 
10 | /**
11 |  * Provides event arguments for the preFlush event.
12 |  *
13 |  * @link        www.doctrine-project.org
14 |  *
15 |  * @extends ManagerEventArgs<EntityManagerInterface>
16 |  */
17 | class OnFlushEventArgs extends ManagerEventArgs
18 | {
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Event/PostFlushEventArgs.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Event;
 6 | 
 7 | use Doctrine\ORM\EntityManagerInterface;
 8 | use Doctrine\Persistence\Event\ManagerEventArgs;
 9 | 
10 | /**
11 |  * Provides event arguments for the postFlush event.
12 |  *
13 |  * @link        www.doctrine-project.org
14 |  *
15 |  * @extends ManagerEventArgs<EntityManagerInterface>
16 |  */
17 | class PostFlushEventArgs extends ManagerEventArgs
18 | {
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Event/PostLoadEventArgs.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Event;
 6 | 
 7 | use Doctrine\ORM\EntityManagerInterface;
 8 | use Doctrine\Persistence\Event\LifecycleEventArgs;
 9 | 
10 | /** @extends LifecycleEventArgs<EntityManagerInterface> */
11 | final class PostLoadEventArgs extends LifecycleEventArgs
12 | {
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Event/PostPersistEventArgs.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Event;
 6 | 
 7 | use Doctrine\ORM\EntityManagerInterface;
 8 | use Doctrine\Persistence\Event\LifecycleEventArgs;
 9 | 
10 | /** @extends LifecycleEventArgs<EntityManagerInterface> */
11 | final class PostPersistEventArgs extends LifecycleEventArgs
12 | {
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Event/PostRemoveEventArgs.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Event;
 6 | 
 7 | use Doctrine\ORM\EntityManagerInterface;
 8 | use Doctrine\Persistence\Event\LifecycleEventArgs;
 9 | 
10 | /** @extends LifecycleEventArgs<EntityManagerInterface> */
11 | final class PostRemoveEventArgs extends LifecycleEventArgs
12 | {
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Event/PostUpdateEventArgs.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Event;
 6 | 
 7 | use Doctrine\ORM\EntityManagerInterface;
 8 | use Doctrine\Persistence\Event\LifecycleEventArgs;
 9 | 
10 | /** @extends LifecycleEventArgs<EntityManagerInterface> */
11 | final class PostUpdateEventArgs extends LifecycleEventArgs
12 | {
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Event/PreFlushEventArgs.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Event;
 6 | 
 7 | use Doctrine\ORM\EntityManagerInterface;
 8 | use Doctrine\Persistence\Event\ManagerEventArgs;
 9 | 
10 | /**
11 |  * Provides event arguments for the preFlush event.
12 |  *
13 |  * @link        www.doctrine-project.com
14 |  *
15 |  * @extends ManagerEventArgs<EntityManagerInterface>
16 |  */
17 | class PreFlushEventArgs extends ManagerEventArgs
18 | {
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Event/PrePersistEventArgs.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Event;
 6 | 
 7 | use Doctrine\ORM\EntityManagerInterface;
 8 | use Doctrine\Persistence\Event\LifecycleEventArgs;
 9 | 
10 | /** @extends LifecycleEventArgs<EntityManagerInterface> */
11 | final class PrePersistEventArgs extends LifecycleEventArgs
12 | {
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Event/PreRemoveEventArgs.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Event;
 6 | 
 7 | use Doctrine\ORM\EntityManagerInterface;
 8 | use Doctrine\Persistence\Event\LifecycleEventArgs;
 9 | 
10 | /** @extends LifecycleEventArgs<EntityManagerInterface> */
11 | final class PreRemoveEventArgs extends LifecycleEventArgs
12 | {
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Exception/ConfigurationException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Exception;
 6 | 
 7 | interface ConfigurationException extends ORMException
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/Exception/DuplicateFieldException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Exception;
 6 | 
 7 | use LogicException;
 8 | 
 9 | use function sprintf;
10 | 
11 | class DuplicateFieldException extends LogicException implements ORMException
12 | {
13 |     public static function create(string $argName, string $columnName): self
14 |     {
15 |         return new self(sprintf('Name "%s" for "%s" already in use.', $argName, $columnName));
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Exception/EntityIdentityCollisionException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Exception;
 6 | 
 7 | use Exception;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class EntityIdentityCollisionException extends Exception implements ORMException
12 | {
13 |     public static function create(object $existingEntity, object $newEntity, string $idHash): self
14 |     {
15 |         return new self(
16 |             sprintf(
17 |                 <<<'EXCEPTION'
18 | While adding an entity of class %s with an ID hash of "%s" to the identity map,
19 | another object of class %s was already present for the same ID. This exception
20 | is a safeguard against an internal inconsistency - IDs should uniquely map to
21 | entity object instances. This problem may occur if:
22 | 
23 | - you use application-provided IDs and reuse ID values;
24 | - database-provided IDs are reassigned after truncating the database without
25 | clearing the EntityManager;
26 | - you might have been using EntityManager#getReference() to create a reference
27 | for a nonexistent ID that was subsequently (by the RDBMS) assigned to another
28 | entity.
29 | 
30 | Otherwise, it might be an ORM-internal inconsistency, please report it.
31 | EXCEPTION
32 |                 ,
33 |                 $newEntity::class,
34 |                 $idHash,
35 |                 $existingEntity::class,
36 |             ),
37 |         );
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/Exception/EntityManagerClosed.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Exception;
 6 | 
 7 | use RuntimeException;
 8 | 
 9 | final class EntityManagerClosed extends RuntimeException implements ManagerException
10 | {
11 |     public static function create(): self
12 |     {
13 |         return new self('The EntityManager is closed.');
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Exception/EntityMissingAssignedId.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Exception;
 6 | 
 7 | use LogicException;
 8 | 
 9 | use function get_debug_type;
10 | 
11 | final class EntityMissingAssignedId extends LogicException implements ORMException
12 | {
13 |     public static function forField(object $entity, string $field): self
14 |     {
15 |         return new self('Entity of type ' . get_debug_type($entity) . " is missing an assigned ID for field  '" . $field . "'. " .
16 |             'The identifier generation strategy for this entity requires the ID field to be populated before ' .
17 |             'EntityManager#persist() is called. If you want automatically generated identifiers instead ' .
18 |             'you need to adjust the metadata mapping accordingly.');
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Exception/InvalidEntityRepository.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Exception;
 6 | 
 7 | use Doctrine\ORM\EntityRepository;
 8 | use LogicException;
 9 | 
10 | final class InvalidEntityRepository extends LogicException implements ConfigurationException
11 | {
12 |     public static function fromClassName(string $className): self
13 |     {
14 |         return new self(
15 |             "Invalid repository class '" . $className . "'. It must be a " . EntityRepository::class . '.',
16 |         );
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Exception/InvalidHydrationMode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Exception;
 6 | 
 7 | use LogicException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class InvalidHydrationMode extends LogicException implements ManagerException
12 | {
13 |     public static function fromMode(string $mode): self
14 |     {
15 |         return new self(sprintf('"%s" is an invalid hydration mode.', $mode));
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Exception/ManagerException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Exception;
 6 | 
 7 | use Throwable;
 8 | 
 9 | interface ManagerException extends Throwable
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Exception/MissingIdentifierField.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Exception;
 6 | 
 7 | use LogicException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class MissingIdentifierField extends LogicException implements ManagerException
12 | {
13 |     public static function fromFieldAndClass(string $fieldName, string $className): self
14 |     {
15 |         return new self(sprintf(
16 |             'The identifier %s is missing for a query of %s',
17 |             $fieldName,
18 |             $className,
19 |         ));
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Exception/MissingMappingDriverImplementation.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Exception;
 6 | 
 7 | use LogicException;
 8 | 
 9 | final class MissingMappingDriverImplementation extends LogicException implements ManagerException
10 | {
11 |     public static function create(): self
12 |     {
13 |         return new self(
14 |             "It's a requirement to specify a Metadata Driver and pass it " .
15 |             'to Doctrine\\ORM\\Configuration::setMetadataDriverImpl().',
16 |         );
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Exception/MultipleSelectorsFoundException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Exception;
 6 | 
 7 | use LogicException;
 8 | 
 9 | use function implode;
10 | use function sprintf;
11 | 
12 | final class MultipleSelectorsFoundException extends LogicException implements ORMException
13 | {
14 |     public const MULTIPLE_SELECTORS_FOUND_EXCEPTION = 'Multiple selectors found: %s. Please select only one.';
15 | 
16 |     /** @param string[] $selectors */
17 |     public static function create(array $selectors): self
18 |     {
19 |         return new self(
20 |             sprintf(
21 |                 self::MULTIPLE_SELECTORS_FOUND_EXCEPTION,
22 |                 implode(', ', $selectors),
23 |             ),
24 |         );
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Exception/NoMatchingPropertyException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Exception;
 6 | 
 7 | use LogicException;
 8 | 
 9 | use function sprintf;
10 | 
11 | class NoMatchingPropertyException extends LogicException implements ORMException
12 | {
13 |     public static function create(string $property): self
14 |     {
15 |         return new self(sprintf('Column name "%s" does not match any property name. Consider aliasing it to the name of an existing property.', $property));
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Exception/NotSupported.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Exception;
 6 | 
 7 | use LogicException;
 8 | 
 9 | use function sprintf;
10 | 
11 | /** @deprecated */
12 | final class NotSupported extends LogicException implements ORMException
13 | {
14 |     public static function create(): self
15 |     {
16 |         return new self('This behaviour is (currently) not supported by Doctrine 2');
17 |     }
18 | 
19 |     public static function createForDbal3(string $context): self
20 |     {
21 |         return new self(sprintf(
22 |             <<<'EXCEPTION'
23 | Context: %s
24 | Problem: Feature was deprecated in doctrine/dbal 2.x and is not supported by installed doctrine/dbal:3.x
25 | Solution: See the doctrine/deprecations logs for new alternative approaches.
26 | EXCEPTION
27 |             ,
28 |             $context,
29 |         ));
30 |     }
31 | 
32 |     public static function createForPersistence3(string $context): self
33 |     {
34 |         return new self(sprintf(
35 |             <<<'EXCEPTION'
36 | Context: %s
37 | Problem: Feature was deprecated in doctrine/persistence 2.x and is not supported by installed doctrine/persistence:3.x
38 | Solution: See the doctrine/deprecations logs for new alternative approaches.
39 | EXCEPTION
40 |             ,
41 |             $context,
42 |         ));
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/src/Exception/ORMException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Exception;
 6 | 
 7 | use Throwable;
 8 | 
 9 | interface ORMException extends Throwable
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Exception/PersisterException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Exception;
 6 | 
 7 | use Doctrine\ORM\Persisters\PersisterException as BasePersisterException;
 8 | 
 9 | class PersisterException extends BasePersisterException
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Exception/RepositoryException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Exception;
 6 | 
 7 | /**
 8 |  * This interface should be implemented by all exceptions in the Repository
 9 |  * namespace.
10 |  */
11 | interface RepositoryException extends ORMException
12 | {
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Exception/SchemaToolException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Exception;
 6 | 
 7 | use Throwable;
 8 | 
 9 | interface SchemaToolException extends Throwable
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Exception/UnexpectedAssociationValue.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Exception;
 6 | 
 7 | use Doctrine\ORM\Cache\Exception\CacheException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class UnexpectedAssociationValue extends CacheException
12 | {
13 |     public static function create(
14 |         string $class,
15 |         string $association,
16 |         string $given,
17 |         string $expected,
18 |     ): self {
19 |         return new self(sprintf(
20 |             'Found entity of type %s on association %s#%s, but expecting %s',
21 |             $given,
22 |             $class,
23 |             $association,
24 |             $expected,
25 |         ));
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Exception/UnrecognizedIdentifierFields.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Exception;
 6 | 
 7 | use LogicException;
 8 | 
 9 | use function implode;
10 | use function sprintf;
11 | 
12 | final class UnrecognizedIdentifierFields extends LogicException implements ManagerException
13 | {
14 |     /** @param string[] $fieldNames */
15 |     public static function fromClassAndFieldNames(string $className, array $fieldNames): self
16 |     {
17 |         return new self(sprintf(
18 |             'Unrecognized identifier fields: "%s" are not present on class "%s".',
19 |             implode("', '", $fieldNames),
20 |             $className,
21 |         ));
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Id/AbstractIdGenerator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Id;
 6 | 
 7 | use Doctrine\ORM\EntityManagerInterface;
 8 | 
 9 | abstract class AbstractIdGenerator
10 | {
11 |     /**
12 |      * Generates an identifier for an entity.
13 |      */
14 |     abstract public function generateId(EntityManagerInterface $em, object|null $entity): mixed;
15 | 
16 |     /**
17 |      * Gets whether this generator is a post-insert generator which means that
18 |      * {@link generateId()} must be called after the entity has been inserted
19 |      * into the database.
20 |      *
21 |      * By default, this method returns FALSE. Generators that have this requirement
22 |      * must override this method and return TRUE.
23 |      */
24 |     public function isPostInsertGenerator(): bool
25 |     {
26 |         return false;
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Id/AssignedGenerator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Id;
 6 | 
 7 | use Doctrine\ORM\EntityManagerInterface;
 8 | use Doctrine\ORM\Exception\EntityMissingAssignedId;
 9 | 
10 | /**
11 |  * Special generator for application-assigned identifiers (doesn't really generate anything).
12 |  */
13 | class AssignedGenerator extends AbstractIdGenerator
14 | {
15 |     /**
16 |      * Returns the identifier assigned to the given entity.
17 |      *
18 |      * {@inheritDoc}
19 |      *
20 |      * @throws EntityMissingAssignedId
21 |      */
22 |     public function generateId(EntityManagerInterface $em, object|null $entity): array
23 |     {
24 |         $class      = $em->getClassMetadata($entity::class);
25 |         $idFields   = $class->getIdentifierFieldNames();
26 |         $identifier = [];
27 | 
28 |         foreach ($idFields as $idField) {
29 |             $value = $class->getFieldValue($entity, $idField);
30 | 
31 |             if (! isset($value)) {
32 |                 throw EntityMissingAssignedId::forField($entity, $idField);
33 |             }
34 | 
35 |             if (isset($class->associationMappings[$idField])) {
36 |                 // NOTE: Single Columns as associated identifiers only allowed - this constraint it is enforced.
37 |                 $value = $em->getUnitOfWork()->getSingleIdentifierValue($value);
38 |             }
39 | 
40 |             $identifier[$idField] = $value;
41 |         }
42 | 
43 |         return $identifier;
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/Id/BigIntegerIdentityGenerator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Id;
 6 | 
 7 | use Doctrine\ORM\EntityManagerInterface;
 8 | 
 9 | /**
10 |  * Id generator that obtains IDs from special "identity" columns. These are columns
11 |  * that automatically get a database-generated, auto-incremented identifier on INSERT.
12 |  * This generator obtains the last insert id after such an insert.
13 |  */
14 | class BigIntegerIdentityGenerator extends AbstractIdGenerator
15 | {
16 |     public function generateId(EntityManagerInterface $em, object|null $entity): string
17 |     {
18 |         return (string) $em->getConnection()->lastInsertId();
19 |     }
20 | 
21 |     public function isPostInsertGenerator(): bool
22 |     {
23 |         return true;
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Id/IdentityGenerator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Id;
 6 | 
 7 | use Doctrine\ORM\EntityManagerInterface;
 8 | 
 9 | /**
10 |  * Id generator that obtains IDs from special "identity" columns. These are columns
11 |  * that automatically get a database-generated, auto-incremented identifier on INSERT.
12 |  * This generator obtains the last insert id after such an insert.
13 |  */
14 | class IdentityGenerator extends AbstractIdGenerator
15 | {
16 |     public function generateId(EntityManagerInterface $em, object|null $entity): int
17 |     {
18 |         return (int) $em->getConnection()->lastInsertId();
19 |     }
20 | 
21 |     public function isPostInsertGenerator(): bool
22 |     {
23 |         return true;
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Internal/Hydration/ScalarColumnHydrator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Internal\Hydration;
 6 | 
 7 | use Doctrine\DBAL\Driver\Exception;
 8 | use Doctrine\ORM\Exception\MultipleSelectorsFoundException;
 9 | 
10 | use function array_column;
11 | use function count;
12 | 
13 | /**
14 |  * Hydrator that produces one-dimensional array.
15 |  */
16 | final class ScalarColumnHydrator extends AbstractHydrator
17 | {
18 |     /**
19 |      * {@inheritDoc}
20 |      *
21 |      * @throws MultipleSelectorsFoundException
22 |      * @throws Exception
23 |      */
24 |     protected function hydrateAllData(): array
25 |     {
26 |         if (count($this->resultSetMapping()->fieldMappings) > 1) {
27 |             throw MultipleSelectorsFoundException::create($this->resultSetMapping()->fieldMappings);
28 |         }
29 | 
30 |         $result = $this->statement()->fetchAllNumeric();
31 | 
32 |         return array_column($result, 0);
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Internal/Hydration/ScalarHydrator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Internal\Hydration;
 6 | 
 7 | /**
 8 |  * Hydrator that produces flat, rectangular results of scalar data.
 9 |  * The created result is almost the same as a regular SQL result set, except
10 |  * that column names are mapped to field names and data type conversions take place.
11 |  */
12 | class ScalarHydrator extends AbstractHydrator
13 | {
14 |     /**
15 |      * {@inheritDoc}
16 |      */
17 |     protected function hydrateAllData(): array
18 |     {
19 |         $result = [];
20 | 
21 |         while ($data = $this->statement()->fetchAssociative()) {
22 |             $this->hydrateRowData($data, $result);
23 |         }
24 | 
25 |         return $result;
26 |     }
27 | 
28 |     /**
29 |      * {@inheritDoc}
30 |      */
31 |     protected function hydrateRowData(array $row, array &$result): void
32 |     {
33 |         $result[] = $this->gatherScalarRowData($row);
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/Internal/Hydration/SingleScalarHydrator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Internal\Hydration;
 6 | 
 7 | use Doctrine\ORM\NonUniqueResultException;
 8 | use Doctrine\ORM\NoResultException;
 9 | 
10 | use function array_shift;
11 | use function count;
12 | use function key;
13 | 
14 | /**
15 |  * Hydrator that hydrates a single scalar value from the result set.
16 |  */
17 | class SingleScalarHydrator extends AbstractHydrator
18 | {
19 |     protected function hydrateAllData(): mixed
20 |     {
21 |         $data    = $this->statement()->fetchAllAssociative();
22 |         $numRows = count($data);
23 | 
24 |         if ($numRows === 0) {
25 |             throw new NoResultException();
26 |         }
27 | 
28 |         if ($numRows > 1) {
29 |             throw new NonUniqueResultException('The query returned multiple rows. Change the query or use a different result function like getScalarResult().');
30 |         }
31 | 
32 |         $result = $this->gatherScalarRowData($data[key($data)]);
33 | 
34 |         if (count($result) > 1) {
35 |             throw new NonUniqueResultException('The query returned a row containing multiple columns. Change the query or use a different result function like getScalarResult().');
36 |         }
37 | 
38 |         return array_shift($result);
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Internal/QueryType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Internal;
 6 | 
 7 | /** @internal To be used inside the QueryBuilder only. */
 8 | enum QueryType
 9 | {
10 |     case Select;
11 |     case Delete;
12 |     case Update;
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Internal/SQLResultCasing.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Internal;
 6 | 
 7 | use Doctrine\DBAL\Platforms\AbstractPlatform;
 8 | use Doctrine\DBAL\Platforms\DB2Platform;
 9 | use Doctrine\DBAL\Platforms\OraclePlatform;
10 | use Doctrine\DBAL\Platforms\PostgreSQLPlatform;
11 | 
12 | use function strtolower;
13 | use function strtoupper;
14 | 
15 | /** @internal */
16 | trait SQLResultCasing
17 | {
18 |     private function getSQLResultCasing(AbstractPlatform $platform, string $column): string
19 |     {
20 |         if ($platform instanceof DB2Platform || $platform instanceof OraclePlatform) {
21 |             return strtoupper($column);
22 |         }
23 | 
24 |         if ($platform instanceof PostgreSQLPlatform) {
25 |             return strtolower($column);
26 |         }
27 | 
28 |         return $column;
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Internal/TopologicalSort/CycleDetectedException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Internal\TopologicalSort;
 6 | 
 7 | use RuntimeException;
 8 | 
 9 | use function array_unshift;
10 | 
11 | class CycleDetectedException extends RuntimeException
12 | {
13 |     /** @var list<object> */
14 |     private array $cycle;
15 | 
16 |     /**
17 |      * Do we have the complete cycle collected?
18 |      */
19 |     private bool $cycleCollected = false;
20 | 
21 |     public function __construct(private readonly object $startNode)
22 |     {
23 |         parent::__construct('A cycle has been detected, so a topological sort is not possible. The getCycle() method provides the list of nodes that form the cycle.');
24 | 
25 |         $this->cycle = [$startNode];
26 |     }
27 | 
28 |     /** @return list<object> */
29 |     public function getCycle(): array
30 |     {
31 |         return $this->cycle;
32 |     }
33 | 
34 |     public function addToCycle(object $node): void
35 |     {
36 |         array_unshift($this->cycle, $node);
37 | 
38 |         if ($node === $this->startNode) {
39 |             $this->cycleCollected = true;
40 |         }
41 |     }
42 | 
43 |     public function isCycleCollected(): bool
44 |     {
45 |         return $this->cycleCollected;
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/src/Mapping/AssociationOverrides.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | use Attribute;
 8 | 
 9 | use function array_values;
10 | use function is_array;
11 | 
12 | /** This attribute is used to override association mappings of relationship properties. */
13 | #[Attribute(Attribute::TARGET_CLASS)]
14 | final class AssociationOverrides implements MappingAttribute
15 | {
16 |     /**
17 |      * Mapping overrides of relationship properties.
18 |      *
19 |      * @var list<AssociationOverride>
20 |      */
21 |     public readonly array $overrides;
22 | 
23 |     /** @param array<AssociationOverride>|AssociationOverride $overrides */
24 |     public function __construct(array|AssociationOverride $overrides)
25 |     {
26 |         if (! is_array($overrides)) {
27 |             $overrides = [$overrides];
28 |         }
29 | 
30 |         foreach ($overrides as $override) {
31 |             if (! ($override instanceof AssociationOverride)) {
32 |                 throw MappingException::invalidOverrideType('AssociationOverride', $override);
33 |             }
34 |         }
35 | 
36 |         $this->overrides = array_values($overrides);
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Mapping/AttributeOverride.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | /** This attribute is used to override the mapping of a entity property. */
 8 | final class AttributeOverride implements MappingAttribute
 9 | {
10 |     public function __construct(
11 |         public string $name,
12 |         public Column $column,
13 |     ) {
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Mapping/AttributeOverrides.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | use Attribute;
 8 | 
 9 | use function array_values;
10 | use function is_array;
11 | 
12 | /** This attribute is used to override the mapping of a entity property. */
13 | #[Attribute(Attribute::TARGET_CLASS)]
14 | final class AttributeOverrides implements MappingAttribute
15 | {
16 |     /**
17 |      * One or more field or property mapping overrides.
18 |      *
19 |      * @var list<AttributeOverride>
20 |      */
21 |     public readonly array $overrides;
22 | 
23 |     /** @param array<AttributeOverride>|AttributeOverride $overrides */
24 |     public function __construct(array|AttributeOverride $overrides)
25 |     {
26 |         if (! is_array($overrides)) {
27 |             $overrides = [$overrides];
28 |         }
29 | 
30 |         foreach ($overrides as $override) {
31 |             if (! ($override instanceof AttributeOverride)) {
32 |                 throw MappingException::invalidOverrideType('AttributeOverride', $override);
33 |             }
34 |         }
35 | 
36 |         $this->overrides = array_values($overrides);
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Mapping/Builder/EmbeddedBuilder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping\Builder;
 6 | 
 7 | /**
 8 |  * Embedded Builder
 9 |  *
10 |  * @link        www.doctrine-project.com
11 |  */
12 | class EmbeddedBuilder
13 | {
14 |     /** @param mixed[] $mapping */
15 |     public function __construct(
16 |         private readonly ClassMetadataBuilder $builder,
17 |         private array $mapping,
18 |     ) {
19 |     }
20 | 
21 |     /**
22 |      * Sets the column prefix for all of the embedded columns.
23 |      *
24 |      * @return $this
25 |      */
26 |     public function setColumnPrefix(string $columnPrefix): static
27 |     {
28 |         $this->mapping['columnPrefix'] = $columnPrefix;
29 | 
30 |         return $this;
31 |     }
32 | 
33 |     /**
34 |      * Finalizes this embeddable and attach it to the ClassMetadata.
35 |      *
36 |      * Without this call an EmbeddedBuilder has no effect on the ClassMetadata.
37 |      */
38 |     public function build(): ClassMetadataBuilder
39 |     {
40 |         $cm = $this->builder->getClassMetadata();
41 | 
42 |         $cm->mapEmbedded($this->mapping);
43 | 
44 |         return $this->builder;
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/src/Mapping/Builder/OneToManyAssociationBuilder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping\Builder;
 6 | 
 7 | /**
 8 |  * OneToMany Association Builder
 9 |  *
10 |  * @link        www.doctrine-project.com
11 |  */
12 | class OneToManyAssociationBuilder extends AssociationBuilder
13 | {
14 |     /**
15 |      * @phpstan-param array<string, string> $fieldNames
16 |      *
17 |      * @return $this
18 |      */
19 |     public function setOrderBy(array $fieldNames): static
20 |     {
21 |         $this->mapping['orderBy'] = $fieldNames;
22 | 
23 |         return $this;
24 |     }
25 | 
26 |     /** @return $this */
27 |     public function setIndexBy(string $fieldName): static
28 |     {
29 |         $this->mapping['indexBy'] = $fieldName;
30 | 
31 |         return $this;
32 |     }
33 | 
34 |     public function build(): ClassMetadataBuilder
35 |     {
36 |         $mapping = $this->mapping;
37 |         if ($this->joinColumns) {
38 |             $mapping['joinColumns'] = $this->joinColumns;
39 |         }
40 | 
41 |         $cm = $this->builder->getClassMetadata();
42 |         $cm->mapOneToMany($mapping);
43 | 
44 |         return $this->builder;
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/src/Mapping/Cache.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | use Attribute;
 8 | 
 9 | /** Caching to an entity or a collection. */
10 | #[Attribute(Attribute::TARGET_CLASS | Attribute::TARGET_PROPERTY)]
11 | final class Cache implements MappingAttribute
12 | {
13 |     /** @phpstan-param 'READ_ONLY'|'NONSTRICT_READ_WRITE'|'READ_WRITE' $usage */
14 |     public function __construct(
15 |         public readonly string $usage = 'READ_ONLY',
16 |         public readonly string|null $region = null,
17 |     ) {
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Mapping/ChainTypedFieldMapper.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | use Doctrine\ORM\Internal\NoUnknownNamedArguments;
 8 | use ReflectionProperty;
 9 | 
10 | final class ChainTypedFieldMapper implements TypedFieldMapper
11 | {
12 |     use NoUnknownNamedArguments;
13 | 
14 |     /** @var list<TypedFieldMapper> $typedFieldMappers */
15 |     private readonly array $typedFieldMappers;
16 | 
17 |     public function __construct(TypedFieldMapper ...$typedFieldMappers)
18 |     {
19 |         self::validateVariadicParameter($typedFieldMappers);
20 | 
21 |         $this->typedFieldMappers = $typedFieldMappers;
22 |     }
23 | 
24 |     /**
25 |      * {@inheritDoc}
26 |      */
27 |     public function validateAndComplete(array $mapping, ReflectionProperty $field): array
28 |     {
29 |         foreach ($this->typedFieldMappers as $typedFieldMapper) {
30 |             $mapping = $typedFieldMapper->validateAndComplete($mapping, $field);
31 |         }
32 | 
33 |         return $mapping;
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/Mapping/ChangeTrackingPolicy.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_CLASS)]
10 | final class ChangeTrackingPolicy implements MappingAttribute
11 | {
12 |     /** @phpstan-param 'DEFERRED_IMPLICIT'|'DEFERRED_EXPLICIT' $value */
13 |     public function __construct(
14 |         public readonly string $value,
15 |     ) {
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Mapping/Column.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | use Attribute;
 8 | use BackedEnum;
 9 | 
10 | #[Attribute(Attribute::TARGET_PROPERTY)]
11 | final class Column implements MappingAttribute
12 | {
13 |     /**
14 |      * @param int|null                      $precision The precision for a decimal (exact numeric) column (Applies only for decimal column).
15 |      * @param int|null                      $scale     The scale for a decimal (exact numeric) column (Applies only for decimal column).
16 |      * @param class-string<BackedEnum>|null $enumType
17 |      * @param array<string,mixed>           $options
18 |      * @phpstan-param 'NEVER'|'INSERT'|'ALWAYS'|null $generated
19 |      */
20 |     public function __construct(
21 |         public readonly string|null $name = null,
22 |         public readonly string|null $type = null,
23 |         public readonly int|null $length = null,
24 |         public readonly int|null $precision = null,
25 |         public readonly int|null $scale = null,
26 |         public readonly bool $unique = false,
27 |         public readonly bool $nullable = false,
28 |         public readonly bool $insertable = true,
29 |         public readonly bool $updatable = true,
30 |         public readonly string|null $enumType = null,
31 |         public readonly array $options = [],
32 |         public readonly string|null $columnDefinition = null,
33 |         public readonly string|null $generated = null,
34 |     ) {
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/Mapping/CustomIdGenerator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_PROPERTY)]
10 | final class CustomIdGenerator implements MappingAttribute
11 | {
12 |     public function __construct(
13 |         public readonly string|null $class = null,
14 |     ) {
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Mapping/DefaultEntityListenerResolver.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | use function trim;
 8 | 
 9 | /**
10 |  * The default DefaultEntityListener
11 |  */
12 | class DefaultEntityListenerResolver implements EntityListenerResolver
13 | {
14 |     /** @var array<class-string, object> Map to store entity listener instances. */
15 |     private array $instances = [];
16 | 
17 |     public function clear(string|null $className = null): void
18 |     {
19 |         if ($className === null) {
20 |             $this->instances = [];
21 | 
22 |             return;
23 |         }
24 | 
25 |         $className = trim($className, '\\');
26 |         unset($this->instances[$className]);
27 |     }
28 | 
29 |     public function register(object $object): void
30 |     {
31 |         $this->instances[$object::class] = $object;
32 |     }
33 | 
34 |     public function resolve(string $className): object
35 |     {
36 |         $className = trim($className, '\\');
37 | 
38 |         return $this->instances[$className] ??= new $className();
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Mapping/DiscriminatorColumn.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | use Attribute;
 8 | use BackedEnum;
 9 | 
10 | #[Attribute(Attribute::TARGET_CLASS)]
11 | final class DiscriminatorColumn implements MappingAttribute
12 | {
13 |     public function __construct(
14 |         public readonly string|null $name = null,
15 |         public readonly string|null $type = null,
16 |         public readonly int|null $length = null,
17 |         public readonly string|null $columnDefinition = null,
18 |         /** @var class-string<BackedEnum>|null */
19 |         public readonly string|null $enumType = null,
20 |         /** @var array<string, mixed> */
21 |         public readonly array $options = [],
22 |     ) {
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Mapping/DiscriminatorMap.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_CLASS)]
10 | final class DiscriminatorMap implements MappingAttribute
11 | {
12 |     /** @param array<int|string, string> $value */
13 |     public function __construct(
14 |         public readonly array $value,
15 |     ) {
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Mapping/Driver/LoadMappingFileImplementation.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping\Driver;
 6 | 
 7 | use Doctrine\Persistence\Mapping\StaticReflectionService;
 8 | 
 9 | use function class_exists;
10 | 
11 | if (! class_exists(StaticReflectionService::class)) {
12 |     /** @internal */
13 |     trait LoadMappingFileImplementation
14 |     {
15 |         /**
16 |          * {@inheritDoc}
17 |          */
18 |         protected function loadMappingFile($file): array
19 |         {
20 |             return $this->doLoadMappingFile($file);
21 |         }
22 |     }
23 | } else {
24 |     /** @internal */
25 |     trait LoadMappingFileImplementation
26 |     {
27 |         /**
28 |          * {@inheritDoc}
29 |          */
30 |         protected function loadMappingFile($file)
31 |         {
32 |             return $this->doLoadMappingFile($file);
33 |         }
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/Mapping/Driver/RepeatableAttributeCollection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping\Driver;
 6 | 
 7 | use ArrayObject;
 8 | use Doctrine\ORM\Mapping\MappingAttribute;
 9 | 
10 | /**
11 |  * @template-extends ArrayObject<int, T>
12 |  * @template T of MappingAttribute
13 |  */
14 | final class RepeatableAttributeCollection extends ArrayObject
15 | {
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Mapping/Driver/SimplifiedXmlDriver.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping\Driver;
 6 | 
 7 | use Doctrine\Persistence\Mapping\Driver\SymfonyFileLocator;
 8 | 
 9 | /**
10 |  * XmlDriver that additionally looks for mapping information in a global file.
11 |  */
12 | class SimplifiedXmlDriver extends XmlDriver
13 | {
14 |     public const DEFAULT_FILE_EXTENSION = '.orm.xml';
15 | 
16 |     /**
17 |      * {@inheritDoc}
18 |      */
19 |     public function __construct($prefixes, $fileExtension = self::DEFAULT_FILE_EXTENSION, bool $isXsdValidationEnabled = true)
20 |     {
21 |         $locator = new SymfonyFileLocator((array) $prefixes, $fileExtension);
22 | 
23 |         parent::__construct($locator, $fileExtension, $isXsdValidationEnabled);
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Mapping/Embeddable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_CLASS)]
10 | final class Embeddable implements MappingAttribute
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Mapping/Embedded.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_PROPERTY)]
10 | final class Embedded implements MappingAttribute
11 | {
12 |     public function __construct(
13 |         public readonly string|null $class = null,
14 |         public readonly string|bool|null $columnPrefix = null,
15 |     ) {
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Mapping/Entity.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\ORM\EntityRepository;
 9 | 
10 | /** @template T of object */
11 | #[Attribute(Attribute::TARGET_CLASS)]
12 | final class Entity implements MappingAttribute
13 | {
14 |     /** @phpstan-param class-string<EntityRepository<T>>|null $repositoryClass */
15 |     public function __construct(
16 |         public readonly string|null $repositoryClass = null,
17 |         public readonly bool $readOnly = false,
18 |     ) {
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Mapping/EntityListenerResolver.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | /**
 8 |  * A resolver is used to instantiate an entity listener.
 9 |  */
10 | interface EntityListenerResolver
11 | {
12 |     /**
13 |      * Clear all instances from the set, or a specific instance when given its identifier.
14 |      *
15 |      * @param string|null $className May be any arbitrary string. Name kept for BC only.
16 |      */
17 |     public function clear(string|null $className = null): void;
18 | 
19 |     /**
20 |      * Returns a entity listener instance for the given identifier.
21 |      *
22 |      * @param string $className May be any arbitrary string. Name kept for BC only.
23 |      */
24 |     public function resolve(string $className): object;
25 | 
26 |     /**
27 |      * Register a entity listener instance.
28 |      */
29 |     public function register(object $object): void;
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Mapping/EntityListeners.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | use Attribute;
 8 | 
 9 | /**
10 |  * The EntityListeners attribute specifies the callback listener classes to be used for an entity or mapped superclass.
11 |  * The EntityListeners attribute may be applied to an entity class or mapped superclass.
12 |  */
13 | #[Attribute(Attribute::TARGET_CLASS)]
14 | final class EntityListeners implements MappingAttribute
15 | {
16 |     /** @param array<string> $value */
17 |     public function __construct(
18 |         public readonly array $value = [],
19 |     ) {
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Mapping/Exception/InvalidCustomGenerator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping\Exception;
 6 | 
 7 | use Doctrine\ORM\Exception\ORMException;
 8 | use LogicException;
 9 | 
10 | use function sprintf;
11 | use function var_export;
12 | 
13 | final class InvalidCustomGenerator extends LogicException implements ORMException
14 | {
15 |     public static function onClassNotConfigured(): self
16 |     {
17 |         return new self('Cannot instantiate custom generator, no class has been defined');
18 |     }
19 | 
20 |     /** @param mixed[] $definition */
21 |     public static function onMissingClass(array $definition): self
22 |     {
23 |         return new self(sprintf(
24 |             'Cannot instantiate custom generator : %s',
25 |             var_export($definition, true),
26 |         ));
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Mapping/Exception/UnknownGeneratorType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping\Exception;
 6 | 
 7 | use Doctrine\ORM\Exception\ORMException;
 8 | use LogicException;
 9 | 
10 | final class UnknownGeneratorType extends LogicException implements ORMException
11 | {
12 |     public static function create(int $generatorType): self
13 |     {
14 |         return new self('Unknown generator type: ' . $generatorType);
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Mapping/GeneratedValue.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_PROPERTY)]
10 | final class GeneratedValue implements MappingAttribute
11 | {
12 |     /** @phpstan-param 'AUTO'|'SEQUENCE'|'IDENTITY'|'NONE'|'CUSTOM' $strategy */
13 |     public function __construct(
14 |         public readonly string $strategy = 'AUTO',
15 |     ) {
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Mapping/GetReflectionClassImplementation.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | use Doctrine\Persistence\Mapping\StaticReflectionService;
 8 | use ReflectionClass;
 9 | 
10 | use function class_exists;
11 | 
12 | if (! class_exists(StaticReflectionService::class)) {
13 |     trait GetReflectionClassImplementation
14 |     {
15 |         public function getReflectionClass(): ReflectionClass
16 |         {
17 |             return $this->reflClass;
18 |         }
19 |     }
20 | } else {
21 |     trait GetReflectionClassImplementation
22 |     {
23 |         /**
24 |          * {@inheritDoc}
25 |          *
26 |          * Can return null when using static reflection, in violation of the LSP
27 |          */
28 |         public function getReflectionClass(): ReflectionClass|null
29 |         {
30 |             return $this->reflClass;
31 |         }
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/Mapping/HasLifecycleCallbacks.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_CLASS)]
10 | final class HasLifecycleCallbacks implements MappingAttribute
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Mapping/Id.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_PROPERTY)]
10 | final class Id implements MappingAttribute
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Mapping/Index.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_CLASS | Attribute::IS_REPEATABLE)]
10 | final class Index implements MappingAttribute
11 | {
12 |     /**
13 |      * @param array<string>|null       $columns
14 |      * @param array<string>|null       $fields
15 |      * @param array<string>|null       $flags
16 |      * @param array<string,mixed>|null $options
17 |      */
18 |     public function __construct(
19 |         public readonly string|null $name = null,
20 |         public readonly array|null $columns = null,
21 |         public readonly array|null $fields = null,
22 |         public readonly array|null $flags = null,
23 |         public readonly array|null $options = null,
24 |     ) {
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Mapping/InheritanceType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_CLASS)]
10 | final class InheritanceType implements MappingAttribute
11 | {
12 |     /** @phpstan-param 'NONE'|'JOINED'|'SINGLE_TABLE' $value */
13 |     public function __construct(
14 |         public readonly string $value,
15 |     ) {
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Mapping/InverseJoinColumn.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_PROPERTY | Attribute::IS_REPEATABLE)]
10 | final class InverseJoinColumn implements MappingAttribute
11 | {
12 |     use JoinColumnProperties;
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Mapping/InverseSideMapping.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | abstract class InverseSideMapping extends AssociationMapping
 8 | {
 9 |     /**
10 |      * required for bidirectional associations
11 |      * The name of the field that completes the bidirectional association on
12 |      * the owning side. This key must be specified on the inverse side of a
13 |      * bidirectional association.
14 |      */
15 |     public string $mappedBy;
16 | 
17 |     final public function backRefFieldName(): string
18 |     {
19 |         return $this->mappedBy;
20 |     }
21 | 
22 |     /** @return list<string> */
23 |     public function __sleep(): array
24 |     {
25 |         return [
26 |             ...parent::__sleep(),
27 |             'mappedBy',
28 |         ];
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Mapping/JoinColumn.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_PROPERTY | Attribute::IS_REPEATABLE)]
10 | final class JoinColumn implements MappingAttribute
11 | {
12 |     use JoinColumnProperties;
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Mapping/JoinColumnProperties.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | trait JoinColumnProperties
 8 | {
 9 |     /** @param array<string, mixed> $options */
10 |     public function __construct(
11 |         public readonly string|null $name = null,
12 |         public readonly string $referencedColumnName = 'id',
13 |         public readonly bool $unique = false,
14 |         public readonly bool $nullable = true,
15 |         public readonly mixed $onDelete = null,
16 |         public readonly string|null $columnDefinition = null,
17 |         public readonly string|null $fieldName = null,
18 |         public readonly array $options = [],
19 |     ) {
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Mapping/JoinColumns.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | final class JoinColumns implements MappingAttribute
 8 | {
 9 |     /** @param array<JoinColumn> $value */
10 |     public function __construct(
11 |         public readonly array $value,
12 |     ) {
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Mapping/JoinTable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_PROPERTY)]
10 | final class JoinTable implements MappingAttribute
11 | {
12 |     /** @var array<JoinColumn> */
13 |     public readonly array $joinColumns;
14 | 
15 |     /** @var array<JoinColumn> */
16 |     public readonly array $inverseJoinColumns;
17 | 
18 |     /**
19 |      * @param array<JoinColumn>|JoinColumn $joinColumns
20 |      * @param array<JoinColumn>|JoinColumn $inverseJoinColumns
21 |      * @param array<string, mixed>         $options
22 |      */
23 |     public function __construct(
24 |         public readonly string|null $name = null,
25 |         public readonly string|null $schema = null,
26 |         array|JoinColumn $joinColumns = [],
27 |         array|JoinColumn $inverseJoinColumns = [],
28 |         public readonly array $options = [],
29 |     ) {
30 |         $this->joinColumns        = $joinColumns instanceof JoinColumn ? [$joinColumns] : $joinColumns;
31 |         $this->inverseJoinColumns = $inverseJoinColumns instanceof JoinColumn
32 |             ? [$inverseJoinColumns]
33 |             : $inverseJoinColumns;
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/Mapping/ManyToMany.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_PROPERTY)]
10 | final class ManyToMany implements MappingAttribute
11 | {
12 |     /**
13 |      * @param class-string  $targetEntity
14 |      * @param string[]|null $cascade
15 |      * @phpstan-param 'LAZY'|'EAGER'|'EXTRA_LAZY' $fetch
16 |      */
17 |     public function __construct(
18 |         public readonly string $targetEntity,
19 |         public readonly string|null $mappedBy = null,
20 |         public readonly string|null $inversedBy = null,
21 |         public readonly array|null $cascade = null,
22 |         public readonly string $fetch = 'LAZY',
23 |         public readonly bool $orphanRemoval = false,
24 |         public readonly string|null $indexBy = null,
25 |     ) {
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Mapping/ManyToManyAssociationMapping.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | interface ManyToManyAssociationMapping extends ToManyAssociationMapping
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/Mapping/ManyToManyInverseSideMapping.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | final class ManyToManyInverseSideMapping extends ToManyInverseSideMapping implements ManyToManyAssociationMapping
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/Mapping/ManyToOne.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_PROPERTY)]
10 | final class ManyToOne implements MappingAttribute
11 | {
12 |     /**
13 |      * @param class-string|null $targetEntity
14 |      * @param string[]|null     $cascade
15 |      * @phpstan-param 'LAZY'|'EAGER'|'EXTRA_LAZY' $fetch
16 |      */
17 |     public function __construct(
18 |         public readonly string|null $targetEntity = null,
19 |         public readonly array|null $cascade = null,
20 |         public readonly string $fetch = 'LAZY',
21 |         public readonly string|null $inversedBy = null,
22 |     ) {
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Mapping/ManyToOneAssociationMapping.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | /**
 8 |  * The "many" side of a many-to-one association mapping is always the owning side.
 9 |  */
10 | final class ManyToOneAssociationMapping extends ToOneOwningSideMapping
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Mapping/MappedSuperclass.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | use Attribute;
 8 | use Doctrine\ORM\EntityRepository;
 9 | 
10 | #[Attribute(Attribute::TARGET_CLASS)]
11 | final class MappedSuperclass implements MappingAttribute
12 | {
13 |     /** @param class-string<EntityRepository>|null $repositoryClass */
14 |     public function __construct(
15 |         public readonly string|null $repositoryClass = null,
16 |     ) {
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Mapping/MappingAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | /** A marker interface for mapping attributes. */
 8 | interface MappingAttribute
 9 | {
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Mapping/OneToMany.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_PROPERTY)]
10 | final class OneToMany implements MappingAttribute
11 | {
12 |     /**
13 |      * @param class-string|null $targetEntity
14 |      * @param string[]|null     $cascade
15 |      * @phpstan-param 'LAZY'|'EAGER'|'EXTRA_LAZY' $fetch
16 |      */
17 |     public function __construct(
18 |         public readonly string|null $targetEntity = null,
19 |         public readonly string|null $mappedBy = null,
20 |         public readonly array|null $cascade = null,
21 |         public readonly string $fetch = 'LAZY',
22 |         public readonly bool $orphanRemoval = false,
23 |         public readonly string|null $indexBy = null,
24 |     ) {
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Mapping/OneToOne.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_PROPERTY)]
10 | final class OneToOne implements MappingAttribute
11 | {
12 |     /**
13 |      * @param class-string|null  $targetEntity
14 |      * @param array<string>|null $cascade
15 |      * @phpstan-param 'LAZY'|'EAGER'|'EXTRA_LAZY' $fetch
16 |      */
17 |     public function __construct(
18 |         public readonly string|null $targetEntity = null,
19 |         public readonly string|null $mappedBy = null,
20 |         public readonly string|null $inversedBy = null,
21 |         public readonly array|null $cascade = null,
22 |         public readonly string $fetch = 'LAZY',
23 |         public readonly bool $orphanRemoval = false,
24 |     ) {
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Mapping/OneToOneAssociationMapping.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | interface OneToOneAssociationMapping extends ToOneAssociationMapping
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/Mapping/OneToOneInverseSideMapping.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | final class OneToOneInverseSideMapping extends ToOneInverseSideMapping implements OneToOneAssociationMapping
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/Mapping/OneToOneOwningSideMapping.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | final class OneToOneOwningSideMapping extends ToOneOwningSideMapping implements OneToOneAssociationMapping
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/Mapping/OrderBy.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_PROPERTY)]
10 | final class OrderBy implements MappingAttribute
11 | {
12 |     /** @param array<string> $value */
13 |     public function __construct(
14 |         public readonly array $value,
15 |     ) {
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Mapping/OwningSideMapping.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | abstract class OwningSideMapping extends AssociationMapping
 8 | {
 9 |     /**
10 |      * required for bidirectional associations
11 |      * The name of the field that completes the bidirectional association on
12 |      * the inverse side. This key must be specified on the owning side of a
13 |      * bidirectional association.
14 |      */
15 |     public string|null $inversedBy = null;
16 | 
17 |     /** @return list<string> */
18 |     public function __sleep(): array
19 |     {
20 |         $serialized = parent::__sleep();
21 | 
22 |         if ($this->inversedBy !== null) {
23 |             $serialized[] = 'inversedBy';
24 |         }
25 | 
26 |         return $serialized;
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Mapping/PostLoad.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_METHOD)]
10 | final class PostLoad implements MappingAttribute
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Mapping/PostPersist.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_METHOD)]
10 | final class PostPersist implements MappingAttribute
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Mapping/PostRemove.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_METHOD)]
10 | final class PostRemove implements MappingAttribute
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Mapping/PostUpdate.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_METHOD)]
10 | final class PostUpdate implements MappingAttribute
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Mapping/PreFlush.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_METHOD)]
10 | final class PreFlush implements MappingAttribute
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Mapping/PrePersist.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_METHOD)]
10 | final class PrePersist implements MappingAttribute
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Mapping/PreRemove.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_METHOD)]
10 | final class PreRemove implements MappingAttribute
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Mapping/PreUpdate.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_METHOD)]
10 | final class PreUpdate implements MappingAttribute
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Mapping/SequenceGenerator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_PROPERTY)]
10 | final class SequenceGenerator implements MappingAttribute
11 | {
12 |     public function __construct(
13 |         public readonly string|null $sequenceName = null,
14 |         public readonly int $allocationSize = 1,
15 |         public readonly int $initialValue = 1,
16 |     ) {
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Mapping/ToManyAssociationMapping.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | interface ToManyAssociationMapping
 8 | {
 9 |     /** @phpstan-assert-if-true string $this->indexBy() */
10 |     public function isIndexed(): bool;
11 | 
12 |     public function indexBy(): string;
13 | 
14 |     /** @return array<string, 'asc'|'desc'> */
15 |     public function orderBy(): array;
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Mapping/ToManyInverseSideMapping.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | abstract class ToManyInverseSideMapping extends InverseSideMapping implements ToManyAssociationMapping
 8 | {
 9 |     use ToManyAssociationMappingImplementation;
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Mapping/ToManyOwningSideMapping.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | abstract class ToManyOwningSideMapping extends OwningSideMapping
 8 | {
 9 |     use ToManyAssociationMappingImplementation;
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Mapping/ToOneAssociationMapping.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | interface ToOneAssociationMapping
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/Mapping/TypedFieldMapper.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | use BackedEnum;
 8 | use ReflectionProperty;
 9 | 
10 | interface TypedFieldMapper
11 | {
12 |     /**
13 |      * Validates & completes the given field mapping based on typed property.
14 |      *
15 |      * @param array{fieldName: string, enumType?: class-string<BackedEnum>, type?: string} $mapping The field mapping to validate & complete.
16 |      *
17 |      * @return array{fieldName: string, enumType?: class-string<BackedEnum>, type?: string} The updated mapping.
18 |      */
19 |     public function validateAndComplete(array $mapping, ReflectionProperty $field): array;
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Mapping/UniqueConstraint.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_CLASS | Attribute::IS_REPEATABLE)]
10 | final class UniqueConstraint implements MappingAttribute
11 | {
12 |     /**
13 |      * @param array<string>|null       $columns
14 |      * @param array<string>|null       $fields
15 |      * @param array<string,mixed>|null $options
16 |      */
17 |     public function __construct(
18 |         public readonly string|null $name = null,
19 |         public readonly array|null $columns = null,
20 |         public readonly array|null $fields = null,
21 |         public readonly array|null $options = null,
22 |     ) {
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Mapping/Version.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Mapping;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_PROPERTY)]
10 | final class Version implements MappingAttribute
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/src/NoResultException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM;
 6 | 
 7 | /**
 8 |  * Exception thrown when an ORM query unexpectedly does not return any results.
 9 |  */
10 | class NoResultException extends UnexpectedResultException
11 | {
12 |     public function __construct()
13 |     {
14 |         parent::__construct('No result was found for query although at least one row was expected.');
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/NonUniqueResultException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM;
 6 | 
 7 | /**
 8 |  * Exception thrown when an ORM query unexpectedly returns more than one result.
 9 |  */
10 | class NonUniqueResultException extends UnexpectedResultException
11 | {
12 |     public const DEFAULT_MESSAGE = 'More than one result was found for query although one row or none was expected.';
13 | 
14 |     public function __construct(string|null $message = null)
15 |     {
16 |         parent::__construct($message ?? self::DEFAULT_MESSAGE);
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Persisters/Exception/CantUseInOperatorOnCompositeKeys.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Persisters\Exception;
 6 | 
 7 | use Doctrine\ORM\Exception\PersisterException;
 8 | 
 9 | class CantUseInOperatorOnCompositeKeys extends PersisterException
10 | {
11 |     public static function create(): self
12 |     {
13 |         return new self("Can't use IN operator on entities that have composite keys.");
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Persisters/Exception/InvalidOrientation.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Persisters\Exception;
 6 | 
 7 | use Doctrine\ORM\Exception\PersisterException;
 8 | 
 9 | class InvalidOrientation extends PersisterException
10 | {
11 |     public static function fromClassNameAndField(string $className, string $field): self
12 |     {
13 |         return new self('Invalid order by orientation specified for ' . $className . '#' . $field);
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Persisters/Exception/UnrecognizedField.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Persisters\Exception;
 6 | 
 7 | use Doctrine\ORM\Exception\PersisterException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class UnrecognizedField extends PersisterException
12 | {
13 |     /** @deprecated Use {@see byFullyQualifiedName()} instead. */
14 |     public static function byName(string $field): self
15 |     {
16 |         return new self(sprintf('Unrecognized field: %s', $field));
17 |     }
18 | 
19 |     /** @param class-string $className */
20 |     public static function byFullyQualifiedName(string $className, string $field): self
21 |     {
22 |         return new self(sprintf('Unrecognized field: %s::$%s', $className, $field));
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Persisters/MatchingAssociationFieldRequiresObject.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Persisters;
 6 | 
 7 | use Doctrine\ORM\Exception\PersisterException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class MatchingAssociationFieldRequiresObject extends PersisterException
12 | {
13 |     public static function fromClassAndAssociation(string $class, string $associationName): self
14 |     {
15 |         return new self(sprintf(
16 |             'Cannot match on %s::%s with a non-object value. Matching objects by id is ' .
17 |             'not compatible with matching on an in-memory collection, which compares objects by reference.',
18 |             $class,
19 |             $associationName,
20 |         ));
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Persisters/PersisterException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Persisters;
 6 | 
 7 | use Doctrine\ORM\Exception\ORMException;
 8 | use Exception;
 9 | 
10 | use function sprintf;
11 | 
12 | class PersisterException extends Exception implements ORMException
13 | {
14 |     public static function matchingAssocationFieldRequiresObject(string $class, string $associationName): PersisterException
15 |     {
16 |         return new self(sprintf(
17 |             'Cannot match on %s::%s with a non-object value. Matching objects by id is ' .
18 |             'not compatible with matching on an in-memory collection, which compares objects by reference.',
19 |             $class,
20 |             $associationName,
21 |         ));
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/PessimisticLockException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM;
 6 | 
 7 | use Doctrine\ORM\Exception\ORMException;
 8 | use RuntimeException;
 9 | 
10 | class PessimisticLockException extends RuntimeException implements ORMException
11 | {
12 |     public static function lockFailed(): self
13 |     {
14 |         return new self('The pessimistic lock failed.');
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Proxy/DefaultProxyClassNameResolver.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Proxy;
 6 | 
 7 | use Doctrine\Persistence\Mapping\ProxyClassNameResolver;
 8 | use Doctrine\Persistence\Proxy;
 9 | 
10 | use function strrpos;
11 | use function substr;
12 | 
13 | /**
14 |  * Class-related functionality for objects that might or not be proxy objects
15 |  * at the moment.
16 |  */
17 | final class DefaultProxyClassNameResolver implements ProxyClassNameResolver
18 | {
19 |     public function resolveClassName(string $className): string
20 |     {
21 |         $pos = strrpos($className, '\\' . Proxy::MARKER . '\\');
22 | 
23 |         if ($pos === false) {
24 |             return $className;
25 |         }
26 | 
27 |         return substr($className, $pos + Proxy::MARKER_LENGTH + 2);
28 |     }
29 | 
30 |     /** @return class-string */
31 |     public static function getClass(object $object): string
32 |     {
33 |         return (new self())->resolveClassName($object::class);
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/Proxy/InternalProxy.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Proxy;
 6 | 
 7 | use Doctrine\Persistence\Proxy;
 8 | 
 9 | /**
10 |  * @internal
11 |  *
12 |  * @template T of object
13 |  * @template-extends Proxy<T>
14 |  */
15 | interface InternalProxy extends Proxy
16 | {
17 |     public function __setInitialized(bool $initialized): void;
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Proxy/NotAProxyClass.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Proxy;
 6 | 
 7 | use Doctrine\ORM\Exception\ORMException;
 8 | use InvalidArgumentException;
 9 | 
10 | use function sprintf;
11 | 
12 | final class NotAProxyClass extends InvalidArgumentException implements ORMException
13 | {
14 |     public function __construct(string $className, string $proxyNamespace)
15 |     {
16 |         parent::__construct(sprintf(
17 |             'The class "%s" is not part of the proxy namespace "%s"',
18 |             $className,
19 |             $proxyNamespace,
20 |         ));
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Query/AST/ASTException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\QueryException;
 8 | 
 9 | use function get_debug_type;
10 | 
11 | /**
12 |  * Base exception class for AST exceptions.
13 |  */
14 | class ASTException extends QueryException
15 | {
16 |     public static function noDispatchForNode(Node $node): self
17 |     {
18 |         return new self('Double-dispatch for node ' . get_debug_type($node) . ' is not supported.');
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Query/AST/AggregateExpression.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | class AggregateExpression extends Node
10 | {
11 |     /** @param bool $isDistinct Some aggregate expressions support distinct, eg COUNT. */
12 |     public function __construct(
13 |         public string $functionName,
14 |         public Node|string $pathExpression,
15 |         public bool $isDistinct,
16 |     ) {
17 |     }
18 | 
19 |     public function dispatch(SqlWalker $walker): string
20 |     {
21 |         return $walker->walkAggregateExpression($this);
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Query/AST/ArithmeticExpression.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | /**
10 |  * ArithmeticExpression ::= SimpleArithmeticExpression | "(" Subselect ")"
11 |  *
12 |  * @link    www.doctrine-project.org
13 |  */
14 | class ArithmeticExpression extends Node
15 | {
16 |     public Node|string|null $simpleArithmeticExpression = null;
17 | 
18 |     public Subselect|null $subselect = null;
19 | 
20 |     public function isSimpleArithmeticExpression(): bool
21 |     {
22 |         return (bool) $this->simpleArithmeticExpression;
23 |     }
24 | 
25 |     public function isSubselect(): bool
26 |     {
27 |         return (bool) $this->subselect;
28 |     }
29 | 
30 |     public function dispatch(SqlWalker $walker): string
31 |     {
32 |         return $walker->walkArithmeticExpression($this);
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Query/AST/ArithmeticFactor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | /**
10 |  * ArithmeticFactor ::= [("+" | "-")] ArithmeticPrimary
11 |  *
12 |  * @link    www.doctrine-project.org
13 |  */
14 | class ArithmeticFactor extends Node
15 | {
16 |     public function __construct(
17 |         public mixed $arithmeticPrimary,
18 |         public bool|null $sign = null,
19 |     ) {
20 |     }
21 | 
22 |     public function isPositiveSigned(): bool
23 |     {
24 |         return $this->sign === true;
25 |     }
26 | 
27 |     public function isNegativeSigned(): bool
28 |     {
29 |         return $this->sign === false;
30 |     }
31 | 
32 |     public function dispatch(SqlWalker $walker): string
33 |     {
34 |         return $walker->walkArithmeticFactor($this);
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/Query/AST/ArithmeticTerm.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | /**
10 |  * ArithmeticTerm ::= ArithmeticFactor {("*" | "/") ArithmeticFactor}*
11 |  *
12 |  * @link    www.doctrine-project.org
13 |  */
14 | class ArithmeticTerm extends Node
15 | {
16 |     /** @param mixed[] $arithmeticFactors */
17 |     public function __construct(public array $arithmeticFactors)
18 |     {
19 |     }
20 | 
21 |     public function dispatch(SqlWalker $walker): string
22 |     {
23 |         return $walker->walkArithmeticTerm($this);
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Query/AST/BetweenExpression.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | class BetweenExpression extends Node
10 | {
11 |     public function __construct(
12 |         public ArithmeticExpression $expression,
13 |         public ArithmeticExpression $leftBetweenExpression,
14 |         public ArithmeticExpression $rightBetweenExpression,
15 |         public bool $not = false,
16 |     ) {
17 |     }
18 | 
19 |     public function dispatch(SqlWalker $walker): string
20 |     {
21 |         return $walker->walkBetweenExpression($this);
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Query/AST/CoalesceExpression.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | /**
10 |  * CoalesceExpression ::= "COALESCE" "(" ScalarExpression {"," ScalarExpression}* ")"
11 |  *
12 |  * @link    www.doctrine-project.org
13 |  */
14 | class CoalesceExpression extends Node
15 | {
16 |     /** @param mixed[] $scalarExpressions */
17 |     public function __construct(public array $scalarExpressions)
18 |     {
19 |     }
20 | 
21 |     public function dispatch(SqlWalker $walker): string
22 |     {
23 |         return $walker->walkCoalesceExpression($this);
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Query/AST/CollectionMemberExpression.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | /**
10 |  * CollectionMemberExpression ::= EntityExpression ["NOT"] "MEMBER" ["OF"] CollectionValuedPathExpression
11 |  *
12 |  * @link    www.doctrine-project.org
13 |  */
14 | class CollectionMemberExpression extends Node
15 | {
16 |     public function __construct(
17 |         public mixed $entityExpression,
18 |         public PathExpression $collectionValuedPathExpression,
19 |         public bool $not = false,
20 |     ) {
21 |     }
22 | 
23 |     public function dispatch(SqlWalker $walker): string
24 |     {
25 |         return $walker->walkCollectionMemberExpression($this);
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Query/AST/ComparisonExpression.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | /**
10 |  * ComparisonExpression ::= ArithmeticExpression ComparisonOperator ( QuantifiedExpression | ArithmeticExpression ) |
11 |  *                          StringExpression ComparisonOperator (StringExpression | QuantifiedExpression) |
12 |  *                          BooleanExpression ("=" | "<>" | "!=") (BooleanExpression | QuantifiedExpression) |
13 |  *                          EnumExpression ("=" | "<>" | "!=") (EnumExpression | QuantifiedExpression) |
14 |  *                          DatetimeExpression ComparisonOperator (DatetimeExpression | QuantifiedExpression) |
15 |  *                          EntityExpression ("=" | "<>") (EntityExpression | QuantifiedExpression)
16 |  *
17 |  * @link    www.doctrine-project.org
18 |  */
19 | class ComparisonExpression extends Node
20 | {
21 |     public function __construct(
22 |         public Node|string $leftExpression,
23 |         public string $operator,
24 |         public Node|string $rightExpression,
25 |     ) {
26 |     }
27 | 
28 |     public function dispatch(SqlWalker $walker): string
29 |     {
30 |         return $walker->walkComparisonExpression($this);
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Query/AST/ConditionalExpression.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | /**
10 |  * ConditionalExpression ::= ConditionalTerm {"OR" ConditionalTerm}*
11 |  *
12 |  * @link    www.doctrine-project.org
13 |  */
14 | class ConditionalExpression extends Node
15 | {
16 |     /** @param mixed[] $conditionalTerms */
17 |     public function __construct(public array $conditionalTerms)
18 |     {
19 |     }
20 | 
21 |     public function dispatch(SqlWalker $walker): string
22 |     {
23 |         return $walker->walkConditionalExpression($this);
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Query/AST/ConditionalFactor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | /**
10 |  * ConditionalFactor ::= ["NOT"] ConditionalPrimary
11 |  *
12 |  * @link    www.doctrine-project.org
13 |  */
14 | class ConditionalFactor extends Node implements Phase2OptimizableConditional
15 | {
16 |     public function __construct(
17 |         public ConditionalPrimary $conditionalPrimary,
18 |         public bool $not = false,
19 |     ) {
20 |     }
21 | 
22 |     public function dispatch(SqlWalker $walker): string
23 |     {
24 |         return $walker->walkConditionalFactor($this);
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Query/AST/ConditionalPrimary.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | /**
10 |  * ConditionalPrimary ::= SimpleConditionalExpression | "(" ConditionalExpression ")"
11 |  *
12 |  * @link    www.doctrine-project.org
13 |  */
14 | class ConditionalPrimary extends Node implements Phase2OptimizableConditional
15 | {
16 |     public Node|null $simpleConditionalExpression = null;
17 | 
18 |     public ConditionalExpression|Phase2OptimizableConditional|null $conditionalExpression = null;
19 | 
20 |     public function isSimpleConditionalExpression(): bool
21 |     {
22 |         return (bool) $this->simpleConditionalExpression;
23 |     }
24 | 
25 |     public function isConditionalExpression(): bool
26 |     {
27 |         return (bool) $this->conditionalExpression;
28 |     }
29 | 
30 |     public function dispatch(SqlWalker $walker): string
31 |     {
32 |         return $walker->walkConditionalPrimary($this);
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Query/AST/ConditionalTerm.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | /**
10 |  * ConditionalTerm ::= ConditionalFactor {"AND" ConditionalFactor}*
11 |  *
12 |  * @link    www.doctrine-project.org
13 |  */
14 | class ConditionalTerm extends Node implements Phase2OptimizableConditional
15 | {
16 |     /** @param mixed[] $conditionalFactors */
17 |     public function __construct(public array $conditionalFactors)
18 |     {
19 |     }
20 | 
21 |     public function dispatch(SqlWalker $walker): string
22 |     {
23 |         return $walker->walkConditionalTerm($this);
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Query/AST/DeleteClause.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | /**
10 |  * DeleteClause ::= "DELETE" ["FROM"] AbstractSchemaName [["AS"] AliasIdentificationVariable]
11 |  *
12 |  * @link    www.doctrine-project.org
13 |  */
14 | class DeleteClause extends Node
15 | {
16 |     public string $aliasIdentificationVariable;
17 | 
18 |     public function __construct(public string $abstractSchemaName)
19 |     {
20 |     }
21 | 
22 |     public function dispatch(SqlWalker $walker): string
23 |     {
24 |         return $walker->walkDeleteClause($this);
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Query/AST/DeleteStatement.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | /**
10 |  * DeleteStatement = DeleteClause [WhereClause]
11 |  *
12 |  * @link    www.doctrine-project.org
13 |  */
14 | class DeleteStatement extends Node
15 | {
16 |     public WhereClause|null $whereClause = null;
17 | 
18 |     public function __construct(public DeleteClause $deleteClause)
19 |     {
20 |     }
21 | 
22 |     public function dispatch(SqlWalker $walker): string
23 |     {
24 |         return $walker->walkDeleteStatement($this);
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Query/AST/EmptyCollectionComparisonExpression.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | /**
10 |  * EmptyCollectionComparisonExpression ::= CollectionValuedPathExpression "IS" ["NOT"] "EMPTY"
11 |  *
12 |  * @link    www.doctrine-project.org
13 |  */
14 | class EmptyCollectionComparisonExpression extends Node
15 | {
16 |     public function __construct(
17 |         public PathExpression $expression,
18 |         public bool $not = false,
19 |     ) {
20 |     }
21 | 
22 |     public function dispatch(SqlWalker $walker): string
23 |     {
24 |         return $walker->walkEmptyCollectionComparisonExpression($this);
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Query/AST/ExistsExpression.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | /**
10 |  * ExistsExpression ::= ["NOT"] "EXISTS" "(" Subselect ")"
11 |  *
12 |  * @link    www.doctrine-project.org
13 |  */
14 | class ExistsExpression extends Node
15 | {
16 |     public function __construct(
17 |         public Subselect $subselect,
18 |         public bool $not = false,
19 |     ) {
20 |     }
21 | 
22 |     public function dispatch(SqlWalker $walker): string
23 |     {
24 |         return $walker->walkExistsExpression($this);
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Query/AST/FromClause.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | /**
10 |  * FromClause ::= "FROM" IdentificationVariableDeclaration {"," IdentificationVariableDeclaration}
11 |  *
12 |  * @link    www.doctrine-project.org
13 |  */
14 | class FromClause extends Node
15 | {
16 |     /** @param mixed[] $identificationVariableDeclarations */
17 |     public function __construct(public array $identificationVariableDeclarations)
18 |     {
19 |     }
20 | 
21 |     public function dispatch(SqlWalker $walker): string
22 |     {
23 |         return $walker->walkFromClause($this);
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Query/AST/Functions/AbsFunction.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST\Functions;
 6 | 
 7 | use Doctrine\ORM\Query\AST\Node;
 8 | use Doctrine\ORM\Query\Parser;
 9 | use Doctrine\ORM\Query\SqlWalker;
10 | use Doctrine\ORM\Query\TokenType;
11 | 
12 | /**
13 |  * "ABS" "(" SimpleArithmeticExpression ")"
14 |  *
15 |  * @link    www.doctrine-project.org
16 |  */
17 | class AbsFunction extends FunctionNode
18 | {
19 |     public Node|string $simpleArithmeticExpression;
20 | 
21 |     public function getSql(SqlWalker $sqlWalker): string
22 |     {
23 |         return 'ABS(' . $sqlWalker->walkSimpleArithmeticExpression(
24 |             $this->simpleArithmeticExpression,
25 |         ) . ')';
26 |     }
27 | 
28 |     public function parse(Parser $parser): void
29 |     {
30 |         $parser->match(TokenType::T_IDENTIFIER);
31 |         $parser->match(TokenType::T_OPEN_PARENTHESIS);
32 | 
33 |         $this->simpleArithmeticExpression = $parser->SimpleArithmeticExpression();
34 | 
35 |         $parser->match(TokenType::T_CLOSE_PARENTHESIS);
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/Query/AST/Functions/AvgFunction.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST\Functions;
 6 | 
 7 | use Doctrine\ORM\Query\AST\AggregateExpression;
 8 | use Doctrine\ORM\Query\Parser;
 9 | use Doctrine\ORM\Query\SqlWalker;
10 | 
11 | /**
12 |  * "AVG" "(" ["DISTINCT"] StringPrimary ")"
13 |  */
14 | final class AvgFunction extends FunctionNode
15 | {
16 |     private AggregateExpression $aggregateExpression;
17 | 
18 |     public function getSql(SqlWalker $sqlWalker): string
19 |     {
20 |         return $this->aggregateExpression->dispatch($sqlWalker);
21 |     }
22 | 
23 |     public function parse(Parser $parser): void
24 |     {
25 |         $this->aggregateExpression = $parser->AggregateExpression();
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Query/AST/Functions/BitAndFunction.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST\Functions;
 6 | 
 7 | use Doctrine\ORM\Query\AST\Node;
 8 | use Doctrine\ORM\Query\Parser;
 9 | use Doctrine\ORM\Query\SqlWalker;
10 | use Doctrine\ORM\Query\TokenType;
11 | 
12 | /**
13 |  * "BIT_AND" "(" ArithmeticPrimary "," ArithmeticPrimary ")"
14 |  *
15 |  * @link    www.doctrine-project.org
16 |  */
17 | class BitAndFunction extends FunctionNode
18 | {
19 |     public Node $firstArithmetic;
20 |     public Node $secondArithmetic;
21 | 
22 |     public function getSql(SqlWalker $sqlWalker): string
23 |     {
24 |         $platform = $sqlWalker->getConnection()->getDatabasePlatform();
25 | 
26 |         return $platform->getBitAndComparisonExpression(
27 |             $this->firstArithmetic->dispatch($sqlWalker),
28 |             $this->secondArithmetic->dispatch($sqlWalker),
29 |         );
30 |     }
31 | 
32 |     public function parse(Parser $parser): void
33 |     {
34 |         $parser->match(TokenType::T_IDENTIFIER);
35 |         $parser->match(TokenType::T_OPEN_PARENTHESIS);
36 | 
37 |         $this->firstArithmetic = $parser->ArithmeticPrimary();
38 |         $parser->match(TokenType::T_COMMA);
39 |         $this->secondArithmetic = $parser->ArithmeticPrimary();
40 | 
41 |         $parser->match(TokenType::T_CLOSE_PARENTHESIS);
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/src/Query/AST/Functions/BitOrFunction.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST\Functions;
 6 | 
 7 | use Doctrine\ORM\Query\AST\Node;
 8 | use Doctrine\ORM\Query\Parser;
 9 | use Doctrine\ORM\Query\SqlWalker;
10 | use Doctrine\ORM\Query\TokenType;
11 | 
12 | /**
13 |  * "BIT_OR" "(" ArithmeticPrimary "," ArithmeticPrimary ")"
14 |  *
15 |  * @link    www.doctrine-project.org
16 |  */
17 | class BitOrFunction extends FunctionNode
18 | {
19 |     public Node $firstArithmetic;
20 |     public Node $secondArithmetic;
21 | 
22 |     public function getSql(SqlWalker $sqlWalker): string
23 |     {
24 |         $platform = $sqlWalker->getConnection()->getDatabasePlatform();
25 | 
26 |         return $platform->getBitOrComparisonExpression(
27 |             $this->firstArithmetic->dispatch($sqlWalker),
28 |             $this->secondArithmetic->dispatch($sqlWalker),
29 |         );
30 |     }
31 | 
32 |     public function parse(Parser $parser): void
33 |     {
34 |         $parser->match(TokenType::T_IDENTIFIER);
35 |         $parser->match(TokenType::T_OPEN_PARENTHESIS);
36 | 
37 |         $this->firstArithmetic = $parser->ArithmeticPrimary();
38 |         $parser->match(TokenType::T_COMMA);
39 |         $this->secondArithmetic = $parser->ArithmeticPrimary();
40 | 
41 |         $parser->match(TokenType::T_CLOSE_PARENTHESIS);
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/src/Query/AST/Functions/CountFunction.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST\Functions;
 6 | 
 7 | use Doctrine\DBAL\Types\Type;
 8 | use Doctrine\DBAL\Types\Types;
 9 | use Doctrine\ORM\Query\AST\AggregateExpression;
10 | use Doctrine\ORM\Query\AST\TypedExpression;
11 | use Doctrine\ORM\Query\Parser;
12 | use Doctrine\ORM\Query\SqlWalker;
13 | 
14 | /**
15 |  * "COUNT" "(" ["DISTINCT"] StringPrimary ")"
16 |  */
17 | final class CountFunction extends FunctionNode implements TypedExpression
18 | {
19 |     private AggregateExpression $aggregateExpression;
20 | 
21 |     public function getSql(SqlWalker $sqlWalker): string
22 |     {
23 |         return $this->aggregateExpression->dispatch($sqlWalker);
24 |     }
25 | 
26 |     public function parse(Parser $parser): void
27 |     {
28 |         $this->aggregateExpression = $parser->AggregateExpression();
29 |     }
30 | 
31 |     public function getReturnType(): Type
32 |     {
33 |         return Type::getType(Types::INTEGER);
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/Query/AST/Functions/CurrentDateFunction.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST\Functions;
 6 | 
 7 | use Doctrine\ORM\Query\Parser;
 8 | use Doctrine\ORM\Query\SqlWalker;
 9 | use Doctrine\ORM\Query\TokenType;
10 | 
11 | /**
12 |  * "CURRENT_DATE"
13 |  *
14 |  * @link    www.doctrine-project.org
15 |  */
16 | class CurrentDateFunction extends FunctionNode
17 | {
18 |     public function getSql(SqlWalker $sqlWalker): string
19 |     {
20 |         return $sqlWalker->getConnection()->getDatabasePlatform()->getCurrentDateSQL();
21 |     }
22 | 
23 |     public function parse(Parser $parser): void
24 |     {
25 |         $parser->match(TokenType::T_IDENTIFIER);
26 |         $parser->match(TokenType::T_OPEN_PARENTHESIS);
27 |         $parser->match(TokenType::T_CLOSE_PARENTHESIS);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Query/AST/Functions/CurrentTimeFunction.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST\Functions;
 6 | 
 7 | use Doctrine\ORM\Query\Parser;
 8 | use Doctrine\ORM\Query\SqlWalker;
 9 | use Doctrine\ORM\Query\TokenType;
10 | 
11 | /**
12 |  * "CURRENT_TIME"
13 |  *
14 |  * @link    www.doctrine-project.org
15 |  */
16 | class CurrentTimeFunction extends FunctionNode
17 | {
18 |     public function getSql(SqlWalker $sqlWalker): string
19 |     {
20 |         return $sqlWalker->getConnection()->getDatabasePlatform()->getCurrentTimeSQL();
21 |     }
22 | 
23 |     public function parse(Parser $parser): void
24 |     {
25 |         $parser->match(TokenType::T_IDENTIFIER);
26 |         $parser->match(TokenType::T_OPEN_PARENTHESIS);
27 |         $parser->match(TokenType::T_CLOSE_PARENTHESIS);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Query/AST/Functions/CurrentTimestampFunction.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST\Functions;
 6 | 
 7 | use Doctrine\ORM\Query\Parser;
 8 | use Doctrine\ORM\Query\SqlWalker;
 9 | use Doctrine\ORM\Query\TokenType;
10 | 
11 | /**
12 |  * "CURRENT_TIMESTAMP"
13 |  *
14 |  * @link    www.doctrine-project.org
15 |  */
16 | class CurrentTimestampFunction extends FunctionNode
17 | {
18 |     public function getSql(SqlWalker $sqlWalker): string
19 |     {
20 |         return $sqlWalker->getConnection()->getDatabasePlatform()->getCurrentTimestampSQL();
21 |     }
22 | 
23 |     public function parse(Parser $parser): void
24 |     {
25 |         $parser->match(TokenType::T_IDENTIFIER);
26 |         $parser->match(TokenType::T_OPEN_PARENTHESIS);
27 |         $parser->match(TokenType::T_CLOSE_PARENTHESIS);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Query/AST/Functions/DateDiffFunction.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST\Functions;
 6 | 
 7 | use Doctrine\ORM\Query\AST\Node;
 8 | use Doctrine\ORM\Query\Parser;
 9 | use Doctrine\ORM\Query\SqlWalker;
10 | use Doctrine\ORM\Query\TokenType;
11 | 
12 | /**
13 |  * "DATE_DIFF" "(" ArithmeticPrimary "," ArithmeticPrimary ")"
14 |  *
15 |  * @link    www.doctrine-project.org
16 |  */
17 | class DateDiffFunction extends FunctionNode
18 | {
19 |     public Node $date1;
20 |     public Node $date2;
21 | 
22 |     public function getSql(SqlWalker $sqlWalker): string
23 |     {
24 |         return $sqlWalker->getConnection()->getDatabasePlatform()->getDateDiffExpression(
25 |             $this->date1->dispatch($sqlWalker),
26 |             $this->date2->dispatch($sqlWalker),
27 |         );
28 |     }
29 | 
30 |     public function parse(Parser $parser): void
31 |     {
32 |         $parser->match(TokenType::T_IDENTIFIER);
33 |         $parser->match(TokenType::T_OPEN_PARENTHESIS);
34 | 
35 |         $this->date1 = $parser->ArithmeticPrimary();
36 |         $parser->match(TokenType::T_COMMA);
37 |         $this->date2 = $parser->ArithmeticPrimary();
38 | 
39 |         $parser->match(TokenType::T_CLOSE_PARENTHESIS);
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/src/Query/AST/Functions/FunctionNode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST\Functions;
 6 | 
 7 | use Doctrine\ORM\Query\AST\Node;
 8 | use Doctrine\ORM\Query\Parser;
 9 | use Doctrine\ORM\Query\SqlWalker;
10 | 
11 | /**
12 |  * Abstract Function Node.
13 |  *
14 |  * @link    www.doctrine-project.org
15 |  *
16 |  * @phpstan-consistent-constructor
17 |  */
18 | abstract class FunctionNode extends Node
19 | {
20 |     public function __construct(public string $name)
21 |     {
22 |     }
23 | 
24 |     abstract public function getSql(SqlWalker $sqlWalker): string;
25 | 
26 |     public function dispatch(SqlWalker $sqlWalker): string
27 |     {
28 |         return $sqlWalker->walkFunction($this);
29 |     }
30 | 
31 |     abstract public function parse(Parser $parser): void;
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Query/AST/Functions/LengthFunction.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST\Functions;
 6 | 
 7 | use Doctrine\DBAL\Types\Type;
 8 | use Doctrine\DBAL\Types\Types;
 9 | use Doctrine\ORM\Query\AST\Node;
10 | use Doctrine\ORM\Query\AST\TypedExpression;
11 | use Doctrine\ORM\Query\Parser;
12 | use Doctrine\ORM\Query\SqlWalker;
13 | use Doctrine\ORM\Query\TokenType;
14 | 
15 | /**
16 |  * "LENGTH" "(" StringPrimary ")"
17 |  *
18 |  * @link    www.doctrine-project.org
19 |  */
20 | class LengthFunction extends FunctionNode implements TypedExpression
21 | {
22 |     public Node $stringPrimary;
23 | 
24 |     public function getSql(SqlWalker $sqlWalker): string
25 |     {
26 |         return $sqlWalker->getConnection()->getDatabasePlatform()->getLengthExpression(
27 |             $sqlWalker->walkSimpleArithmeticExpression($this->stringPrimary),
28 |         );
29 |     }
30 | 
31 |     public function parse(Parser $parser): void
32 |     {
33 |         $parser->match(TokenType::T_IDENTIFIER);
34 |         $parser->match(TokenType::T_OPEN_PARENTHESIS);
35 | 
36 |         $this->stringPrimary = $parser->StringPrimary();
37 | 
38 |         $parser->match(TokenType::T_CLOSE_PARENTHESIS);
39 |     }
40 | 
41 |     public function getReturnType(): Type
42 |     {
43 |         return Type::getType(Types::INTEGER);
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/Query/AST/Functions/LowerFunction.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST\Functions;
 6 | 
 7 | use Doctrine\ORM\Query\AST\Node;
 8 | use Doctrine\ORM\Query\Parser;
 9 | use Doctrine\ORM\Query\SqlWalker;
10 | use Doctrine\ORM\Query\TokenType;
11 | 
12 | use function sprintf;
13 | 
14 | /**
15 |  * "LOWER" "(" StringPrimary ")"
16 |  *
17 |  * @link    www.doctrine-project.org
18 |  */
19 | class LowerFunction extends FunctionNode
20 | {
21 |     public Node $stringPrimary;
22 | 
23 |     public function getSql(SqlWalker $sqlWalker): string
24 |     {
25 |         return sprintf(
26 |             'LOWER(%s)',
27 |             $sqlWalker->walkSimpleArithmeticExpression($this->stringPrimary),
28 |         );
29 |     }
30 | 
31 |     public function parse(Parser $parser): void
32 |     {
33 |         $parser->match(TokenType::T_IDENTIFIER);
34 |         $parser->match(TokenType::T_OPEN_PARENTHESIS);
35 | 
36 |         $this->stringPrimary = $parser->StringPrimary();
37 | 
38 |         $parser->match(TokenType::T_CLOSE_PARENTHESIS);
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Query/AST/Functions/MaxFunction.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST\Functions;
 6 | 
 7 | use Doctrine\ORM\Query\AST\AggregateExpression;
 8 | use Doctrine\ORM\Query\Parser;
 9 | use Doctrine\ORM\Query\SqlWalker;
10 | 
11 | /**
12 |  * "MAX" "(" ["DISTINCT"] StringPrimary ")"
13 |  */
14 | final class MaxFunction extends FunctionNode
15 | {
16 |     private AggregateExpression $aggregateExpression;
17 | 
18 |     public function getSql(SqlWalker $sqlWalker): string
19 |     {
20 |         return $this->aggregateExpression->dispatch($sqlWalker);
21 |     }
22 | 
23 |     public function parse(Parser $parser): void
24 |     {
25 |         $this->aggregateExpression = $parser->AggregateExpression();
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Query/AST/Functions/MinFunction.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST\Functions;
 6 | 
 7 | use Doctrine\ORM\Query\AST\AggregateExpression;
 8 | use Doctrine\ORM\Query\Parser;
 9 | use Doctrine\ORM\Query\SqlWalker;
10 | 
11 | /**
12 |  * "MIN" "(" ["DISTINCT"] StringPrimary ")"
13 |  */
14 | final class MinFunction extends FunctionNode
15 | {
16 |     private AggregateExpression $aggregateExpression;
17 | 
18 |     public function getSql(SqlWalker $sqlWalker): string
19 |     {
20 |         return $this->aggregateExpression->dispatch($sqlWalker);
21 |     }
22 | 
23 |     public function parse(Parser $parser): void
24 |     {
25 |         $this->aggregateExpression = $parser->AggregateExpression();
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Query/AST/Functions/ModFunction.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST\Functions;
 6 | 
 7 | use Doctrine\ORM\Query\AST\Node;
 8 | use Doctrine\ORM\Query\Parser;
 9 | use Doctrine\ORM\Query\SqlWalker;
10 | use Doctrine\ORM\Query\TokenType;
11 | 
12 | /**
13 |  * "MOD" "(" SimpleArithmeticExpression "," SimpleArithmeticExpression ")"
14 |  *
15 |  * @link    www.doctrine-project.org
16 |  */
17 | class ModFunction extends FunctionNode
18 | {
19 |     public Node|string $firstSimpleArithmeticExpression;
20 |     public Node|string $secondSimpleArithmeticExpression;
21 | 
22 |     public function getSql(SqlWalker $sqlWalker): string
23 |     {
24 |         return $sqlWalker->getConnection()->getDatabasePlatform()->getModExpression(
25 |             $sqlWalker->walkSimpleArithmeticExpression($this->firstSimpleArithmeticExpression),
26 |             $sqlWalker->walkSimpleArithmeticExpression($this->secondSimpleArithmeticExpression),
27 |         );
28 |     }
29 | 
30 |     public function parse(Parser $parser): void
31 |     {
32 |         $parser->match(TokenType::T_IDENTIFIER);
33 |         $parser->match(TokenType::T_OPEN_PARENTHESIS);
34 | 
35 |         $this->firstSimpleArithmeticExpression = $parser->SimpleArithmeticExpression();
36 | 
37 |         $parser->match(TokenType::T_COMMA);
38 | 
39 |         $this->secondSimpleArithmeticExpression = $parser->SimpleArithmeticExpression();
40 | 
41 |         $parser->match(TokenType::T_CLOSE_PARENTHESIS);
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/src/Query/AST/Functions/SqrtFunction.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST\Functions;
 6 | 
 7 | use Doctrine\ORM\Query\AST\Node;
 8 | use Doctrine\ORM\Query\Parser;
 9 | use Doctrine\ORM\Query\SqlWalker;
10 | use Doctrine\ORM\Query\TokenType;
11 | 
12 | use function sprintf;
13 | 
14 | /**
15 |  * "SQRT" "(" SimpleArithmeticExpression ")"
16 |  *
17 |  * @link    www.doctrine-project.org
18 |  */
19 | class SqrtFunction extends FunctionNode
20 | {
21 |     public Node|string $simpleArithmeticExpression;
22 | 
23 |     public function getSql(SqlWalker $sqlWalker): string
24 |     {
25 |         return sprintf(
26 |             'SQRT(%s)',
27 |             $sqlWalker->walkSimpleArithmeticExpression($this->simpleArithmeticExpression),
28 |         );
29 |     }
30 | 
31 |     public function parse(Parser $parser): void
32 |     {
33 |         $parser->match(TokenType::T_IDENTIFIER);
34 |         $parser->match(TokenType::T_OPEN_PARENTHESIS);
35 | 
36 |         $this->simpleArithmeticExpression = $parser->SimpleArithmeticExpression();
37 | 
38 |         $parser->match(TokenType::T_CLOSE_PARENTHESIS);
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Query/AST/Functions/SumFunction.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST\Functions;
 6 | 
 7 | use Doctrine\ORM\Query\AST\AggregateExpression;
 8 | use Doctrine\ORM\Query\Parser;
 9 | use Doctrine\ORM\Query\SqlWalker;
10 | 
11 | /**
12 |  * "SUM" "(" ["DISTINCT"] StringPrimary ")"
13 |  */
14 | final class SumFunction extends FunctionNode
15 | {
16 |     private AggregateExpression $aggregateExpression;
17 | 
18 |     public function getSql(SqlWalker $sqlWalker): string
19 |     {
20 |         return $this->aggregateExpression->dispatch($sqlWalker);
21 |     }
22 | 
23 |     public function parse(Parser $parser): void
24 |     {
25 |         $this->aggregateExpression = $parser->AggregateExpression();
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Query/AST/Functions/UpperFunction.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST\Functions;
 6 | 
 7 | use Doctrine\ORM\Query\AST\Node;
 8 | use Doctrine\ORM\Query\Parser;
 9 | use Doctrine\ORM\Query\SqlWalker;
10 | use Doctrine\ORM\Query\TokenType;
11 | 
12 | use function sprintf;
13 | 
14 | /**
15 |  * "UPPER" "(" StringPrimary ")"
16 |  *
17 |  * @link    www.doctrine-project.org
18 |  */
19 | class UpperFunction extends FunctionNode
20 | {
21 |     public Node $stringPrimary;
22 | 
23 |     public function getSql(SqlWalker $sqlWalker): string
24 |     {
25 |         return sprintf(
26 |             'UPPER(%s)',
27 |             $sqlWalker->walkSimpleArithmeticExpression($this->stringPrimary),
28 |         );
29 |     }
30 | 
31 |     public function parse(Parser $parser): void
32 |     {
33 |         $parser->match(TokenType::T_IDENTIFIER);
34 |         $parser->match(TokenType::T_OPEN_PARENTHESIS);
35 | 
36 |         $this->stringPrimary = $parser->StringPrimary();
37 | 
38 |         $parser->match(TokenType::T_CLOSE_PARENTHESIS);
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Query/AST/GeneralCaseExpression.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | /**
10 |  * GeneralCaseExpression ::= "CASE" WhenClause {WhenClause}* "ELSE" ScalarExpression "END"
11 |  *
12 |  * @link    www.doctrine-project.org
13 |  */
14 | class GeneralCaseExpression extends Node
15 | {
16 |     /** @param mixed[] $whenClauses */
17 |     public function __construct(
18 |         public array $whenClauses,
19 |         public mixed $elseScalarExpression = null,
20 |     ) {
21 |     }
22 | 
23 |     public function dispatch(SqlWalker $walker): string
24 |     {
25 |         return $walker->walkGeneralCaseExpression($this);
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Query/AST/GroupByClause.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | class GroupByClause extends Node
10 | {
11 |     /** @param mixed[] $groupByItems */
12 |     public function __construct(public array $groupByItems)
13 |     {
14 |     }
15 | 
16 |     public function dispatch(SqlWalker $walker): string
17 |     {
18 |         return $walker->walkGroupByClause($this);
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Query/AST/HavingClause.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | class HavingClause extends Node
10 | {
11 |     public function __construct(public ConditionalExpression|Phase2OptimizableConditional $conditionalExpression)
12 |     {
13 |     }
14 | 
15 |     public function dispatch(SqlWalker $walker): string
16 |     {
17 |         return $walker->walkHavingClause($this);
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Query/AST/IdentificationVariableDeclaration.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | /**
10 |  * IdentificationVariableDeclaration ::= RangeVariableDeclaration [IndexBy] {JoinVariableDeclaration}*
11 |  *
12 |  * @link    www.doctrine-project.org
13 |  */
14 | class IdentificationVariableDeclaration extends Node
15 | {
16 |     /** @param mixed[] $joins */
17 |     public function __construct(
18 |         public RangeVariableDeclaration|null $rangeVariableDeclaration = null,
19 |         public IndexBy|null $indexBy = null,
20 |         public array $joins = [],
21 |     ) {
22 |     }
23 | 
24 |     public function dispatch(SqlWalker $walker): string
25 |     {
26 |         return $walker->walkIdentificationVariableDeclaration($this);
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Query/AST/InListExpression.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | class InListExpression extends Node
10 | {
11 |     /** @param non-empty-list<mixed> $literals */
12 |     public function __construct(
13 |         public ArithmeticExpression $expression,
14 |         public array $literals,
15 |         public bool $not = false,
16 |     ) {
17 |     }
18 | 
19 |     public function dispatch(SqlWalker $walker): string
20 |     {
21 |         return $walker->walkInListExpression($this);
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Query/AST/InSubselectExpression.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | class InSubselectExpression extends Node
10 | {
11 |     public function __construct(
12 |         public ArithmeticExpression $expression,
13 |         public Subselect $subselect,
14 |         public bool $not = false,
15 |     ) {
16 |     }
17 | 
18 |     public function dispatch(SqlWalker $walker): string
19 |     {
20 |         return $walker->walkInSubselectExpression($this);
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Query/AST/IndexBy.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | /**
10 |  * IndexBy ::= "INDEX" "BY" SingleValuedPathExpression
11 |  *
12 |  * @link    www.doctrine-project.org
13 |  */
14 | class IndexBy extends Node
15 | {
16 |     public function __construct(public PathExpression $singleValuedPathExpression)
17 |     {
18 |     }
19 | 
20 |     public function dispatch(SqlWalker $walker): string
21 |     {
22 |         $walker->walkIndexBy($this);
23 | 
24 |         return '';
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Query/AST/InputParameter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\QueryException;
 8 | use Doctrine\ORM\Query\SqlWalker;
 9 | 
10 | use function is_numeric;
11 | use function strlen;
12 | use function substr;
13 | 
14 | class InputParameter extends Node
15 | {
16 |     public bool $isNamed;
17 |     public string $name;
18 | 
19 |     /** @throws QueryException */
20 |     public function __construct(string $value)
21 |     {
22 |         if (strlen($value) === 1) {
23 |             throw QueryException::invalidParameterFormat($value);
24 |         }
25 | 
26 |         $param         = substr($value, 1);
27 |         $this->isNamed = ! is_numeric($param);
28 |         $this->name    = $param;
29 |     }
30 | 
31 |     public function dispatch(SqlWalker $walker): string
32 |     {
33 |         return $walker->walkInputParameter($this);
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/Query/AST/InstanceOfExpression.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | /**
10 |  * InstanceOfExpression ::= IdentificationVariable ["NOT"] "INSTANCE" ["OF"] (InstanceOfParameter | "(" InstanceOfParameter {"," InstanceOfParameter}* ")")
11 |  * InstanceOfParameter  ::= AbstractSchemaName | InputParameter
12 |  *
13 |  * @link    www.doctrine-project.org
14 |  */
15 | class InstanceOfExpression extends Node
16 | {
17 |     /** @param non-empty-list<InputParameter|string> $value */
18 |     public function __construct(
19 |         public string $identificationVariable,
20 |         public array $value,
21 |         public bool $not = false,
22 |     ) {
23 |     }
24 | 
25 |     public function dispatch(SqlWalker $walker): string
26 |     {
27 |         return $walker->walkInstanceOfExpression($this);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Query/AST/Join.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | /**
10 |  * Join ::= ["LEFT" ["OUTER"] | "INNER"] "JOIN" JoinAssociationPathExpression
11 |  *          ["AS"] AliasIdentificationVariable [("ON" | "WITH") ConditionalExpression]
12 |  *
13 |  * @link    www.doctrine-project.org
14 |  */
15 | class Join extends Node
16 | {
17 |     final public const JOIN_TYPE_LEFT      = 1;
18 |     final public const JOIN_TYPE_LEFTOUTER = 2;
19 |     final public const JOIN_TYPE_INNER     = 3;
20 | 
21 |     public ConditionalExpression|Phase2OptimizableConditional|null $conditionalExpression = null;
22 | 
23 |     /** @phpstan-param self::JOIN_TYPE_* $joinType */
24 |     public function __construct(
25 |         public int $joinType,
26 |         public Node|null $joinAssociationDeclaration = null,
27 |     ) {
28 |     }
29 | 
30 |     public function dispatch(SqlWalker $walker): string
31 |     {
32 |         return $walker->walkJoin($this);
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Query/AST/JoinAssociationDeclaration.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | /**
10 |  * JoinAssociationDeclaration ::= JoinAssociationPathExpression ["AS"] AliasIdentificationVariable
11 |  *
12 |  * @link    www.doctrine-project.org
13 |  */
14 | class JoinAssociationDeclaration extends Node
15 | {
16 |     public function __construct(
17 |         public JoinAssociationPathExpression $joinAssociationPathExpression,
18 |         public string $aliasIdentificationVariable,
19 |         public IndexBy|null $indexBy,
20 |     ) {
21 |     }
22 | 
23 |     public function dispatch(SqlWalker $walker): string
24 |     {
25 |         return $walker->walkJoinAssociationDeclaration($this);
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Query/AST/JoinAssociationPathExpression.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | /**
 8 |  * JoinAssociationPathExpression ::= IdentificationVariable "." (SingleValuedAssociationField | CollectionValuedAssociationField)
 9 |  *
10 |  * @link    www.doctrine-project.org
11 |  */
12 | class JoinAssociationPathExpression extends Node
13 | {
14 |     public function __construct(
15 |         public string $identificationVariable,
16 |         public string $associationField,
17 |     ) {
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Query/AST/JoinClassPathExpression.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | /**
10 |  * JoinClassPathExpression ::= AbstractSchemaName ["AS"] AliasIdentificationVariable
11 |  *
12 |  * @link    www.doctrine-project.org
13 |  */
14 | class JoinClassPathExpression extends Node
15 | {
16 |     public function __construct(
17 |         public mixed $abstractSchemaName,
18 |         public mixed $aliasIdentificationVariable,
19 |     ) {
20 |     }
21 | 
22 |     public function dispatch(SqlWalker $walker): string
23 |     {
24 |         return $walker->walkJoinPathExpression($this);
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Query/AST/JoinVariableDeclaration.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | /**
10 |  * JoinVariableDeclaration ::= Join [IndexBy]
11 |  *
12 |  * @link    www.doctrine-project.org
13 |  */
14 | class JoinVariableDeclaration extends Node
15 | {
16 |     public function __construct(public Join $join, public IndexBy|null $indexBy)
17 |     {
18 |     }
19 | 
20 |     public function dispatch(SqlWalker $walker): string
21 |     {
22 |         return $walker->walkJoinVariableDeclaration($this);
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Query/AST/LikeExpression.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\AST\Functions\FunctionNode;
 8 | use Doctrine\ORM\Query\SqlWalker;
 9 | 
10 | /**
11 |  * LikeExpression ::= StringExpression ["NOT"] "LIKE" string ["ESCAPE" char]
12 |  *
13 |  * @link    www.doctrine-project.org
14 |  */
15 | class LikeExpression extends Node
16 | {
17 |     public function __construct(
18 |         public Node|string $stringExpression,
19 |         public InputParameter|FunctionNode|PathExpression|Literal $stringPattern,
20 |         public Literal|null $escapeChar = null,
21 |         public bool $not = false,
22 |     ) {
23 |     }
24 | 
25 |     public function dispatch(SqlWalker $walker): string
26 |     {
27 |         return $walker->walkLikeExpression($this);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Query/AST/Literal.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | class Literal extends Node
10 | {
11 |     final public const STRING  = 1;
12 |     final public const BOOLEAN = 2;
13 |     final public const NUMERIC = 3;
14 | 
15 |     /** @phpstan-param self::* $type */
16 |     public function __construct(
17 |         public int $type,
18 |         public mixed $value,
19 |     ) {
20 |     }
21 | 
22 |     public function dispatch(SqlWalker $walker): string
23 |     {
24 |         return $walker->walkLiteral($this);
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Query/AST/NewObjectExpression.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | use function func_get_arg;
10 | use function func_num_args;
11 | 
12 | /**
13 |  * NewObjectExpression ::= "NEW" IdentificationVariable "(" NewObjectArg {"," NewObjectArg}* ")"
14 |  *
15 |  * @link    www.doctrine-project.org
16 |  */
17 | class NewObjectExpression extends Node
18 | {
19 |     /**
20 |      * @param class-string $className
21 |      * @param mixed[]      $args
22 |      */
23 |     public function __construct(public string $className, public array $args)
24 |     {
25 |     }
26 | 
27 |     public function dispatch(SqlWalker $walker /*, string|null $parentAlias = null */): string
28 |     {
29 |         $parentAlias = func_num_args() > 1 ? func_get_arg(1) : null;
30 | 
31 |         return $walker->walkNewObject($this, $parentAlias);
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/Query/AST/NullComparisonExpression.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | /**
10 |  * NullComparisonExpression ::= (SingleValuedPathExpression | InputParameter) "IS" ["NOT"] "NULL"
11 |  *
12 |  * @link    www.doctrine-project.org
13 |  */
14 | class NullComparisonExpression extends Node
15 | {
16 |     public function __construct(
17 |         public Node|string $expression,
18 |         public bool $not = false,
19 |     ) {
20 |     }
21 | 
22 |     public function dispatch(SqlWalker $walker): string
23 |     {
24 |         return $walker->walkNullComparisonExpression($this);
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Query/AST/NullIfExpression.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | /**
10 |  * NullIfExpression ::= "NULLIF" "(" ScalarExpression "," ScalarExpression ")"
11 |  *
12 |  * @link    www.doctrine-project.org
13 |  */
14 | class NullIfExpression extends Node
15 | {
16 |     public function __construct(public mixed $firstExpression, public mixed $secondExpression)
17 |     {
18 |     }
19 | 
20 |     public function dispatch(SqlWalker $walker): string
21 |     {
22 |         return $walker->walkNullIfExpression($this);
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Query/AST/OrderByClause.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | /**
10 |  * OrderByClause ::= "ORDER" "BY" OrderByItem {"," OrderByItem}*
11 |  *
12 |  * @link    www.doctrine-project.org
13 |  */
14 | class OrderByClause extends Node
15 | {
16 |     /** @param OrderByItem[] $orderByItems */
17 |     public function __construct(public array $orderByItems)
18 |     {
19 |     }
20 | 
21 |     public function dispatch(SqlWalker $walker): string
22 |     {
23 |         return $walker->walkOrderByClause($this);
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Query/AST/OrderByItem.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | use function strtoupper;
10 | 
11 | /**
12 |  * OrderByItem ::= (ResultVariable | StateFieldPathExpression) ["ASC" | "DESC"]
13 |  *
14 |  * @link    www.doctrine-project.org
15 |  */
16 | class OrderByItem extends Node
17 | {
18 |     public string $type;
19 | 
20 |     public function __construct(public mixed $expression)
21 |     {
22 |     }
23 | 
24 |     public function isAsc(): bool
25 |     {
26 |         return strtoupper($this->type) === 'ASC';
27 |     }
28 | 
29 |     public function isDesc(): bool
30 |     {
31 |         return strtoupper($this->type) === 'DESC';
32 |     }
33 | 
34 |     public function dispatch(SqlWalker $walker): string
35 |     {
36 |         return $walker->walkOrderByItem($this);
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Query/AST/ParenthesisExpression.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | /**
10 |  * ParenthesisExpression ::= "(" ArithmeticPrimary ")"
11 |  */
12 | class ParenthesisExpression extends Node
13 | {
14 |     public function __construct(public Node $expression)
15 |     {
16 |     }
17 | 
18 |     public function dispatch(SqlWalker $walker): string
19 |     {
20 |         return $walker->walkParenthesisExpression($this);
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Query/AST/PartialObjectExpression.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | class PartialObjectExpression extends Node
 8 | {
 9 |     /** @param mixed[] $partialFieldSet */
10 |     public function __construct(
11 |         public string $identificationVariable,
12 |         public array $partialFieldSet,
13 |     ) {
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Query/AST/Phase2OptimizableConditional.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | /**
 8 |  * Marks types that can be used in place of a ConditionalExpression as a phase
 9 |  * 2 optimization.
10 |  *
11 |  * @internal
12 |  */
13 | interface Phase2OptimizableConditional
14 | {
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Query/AST/QuantifiedExpression.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | use function strtoupper;
10 | 
11 | /**
12 |  * QuantifiedExpression ::= ("ALL" | "ANY" | "SOME") "(" Subselect ")"
13 |  *
14 |  * @link    www.doctrine-project.org
15 |  */
16 | class QuantifiedExpression extends Node
17 | {
18 |     public string $type;
19 | 
20 |     public function __construct(public Subselect $subselect)
21 |     {
22 |     }
23 | 
24 |     public function isAll(): bool
25 |     {
26 |         return strtoupper($this->type) === 'ALL';
27 |     }
28 | 
29 |     public function isAny(): bool
30 |     {
31 |         return strtoupper($this->type) === 'ANY';
32 |     }
33 | 
34 |     public function isSome(): bool
35 |     {
36 |         return strtoupper($this->type) === 'SOME';
37 |     }
38 | 
39 |     public function dispatch(SqlWalker $walker): string
40 |     {
41 |         return $walker->walkQuantifiedExpression($this);
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/src/Query/AST/RangeVariableDeclaration.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | /**
10 |  * RangeVariableDeclaration ::= AbstractSchemaName ["AS"] AliasIdentificationVariable
11 |  *
12 |  * @link    www.doctrine-project.org
13 |  */
14 | class RangeVariableDeclaration extends Node
15 | {
16 |     public function __construct(
17 |         public string $abstractSchemaName,
18 |         public string $aliasIdentificationVariable,
19 |         public bool $isRoot = true,
20 |     ) {
21 |     }
22 | 
23 |     public function dispatch(SqlWalker $walker): string
24 |     {
25 |         return $walker->walkRangeVariableDeclaration($this);
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Query/AST/SelectClause.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | /**
10 |  * SelectClause = "SELECT" ["DISTINCT"] SelectExpression {"," SelectExpression}
11 |  *
12 |  * @link    www.doctrine-project.org
13 |  */
14 | class SelectClause extends Node
15 | {
16 |     /** @param mixed[] $selectExpressions */
17 |     public function __construct(
18 |         public array $selectExpressions,
19 |         public bool $isDistinct,
20 |     ) {
21 |     }
22 | 
23 |     public function dispatch(SqlWalker $walker): string
24 |     {
25 |         return $walker->walkSelectClause($this);
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Query/AST/SelectExpression.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | /**
10 |  * SelectExpression ::= IdentificationVariable ["." "*"] | StateFieldPathExpression |
11 |  *                      (AggregateExpression | "(" Subselect ")") [["AS"] ["HIDDEN"] FieldAliasIdentificationVariable]
12 |  *
13 |  * @link    www.doctrine-project.org
14 |  */
15 | class SelectExpression extends Node
16 | {
17 |     public function __construct(
18 |         public mixed $expression,
19 |         public string|null $fieldIdentificationVariable,
20 |         public bool $hiddenAliasResultVariable = false,
21 |     ) {
22 |     }
23 | 
24 |     public function dispatch(SqlWalker $walker): string
25 |     {
26 |         return $walker->walkSelectExpression($this);
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Query/AST/SelectStatement.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | /**
10 |  * SelectStatement = SelectClause FromClause [WhereClause] [GroupByClause] [HavingClause] [OrderByClause]
11 |  *
12 |  * @link    www.doctrine-project.org
13 |  */
14 | class SelectStatement extends Node
15 | {
16 |     public WhereClause|null $whereClause = null;
17 | 
18 |     public GroupByClause|null $groupByClause = null;
19 | 
20 |     public HavingClause|null $havingClause = null;
21 | 
22 |     public OrderByClause|null $orderByClause = null;
23 | 
24 |     public function __construct(public SelectClause $selectClause, public FromClause $fromClause)
25 |     {
26 |     }
27 | 
28 |     public function dispatch(SqlWalker $walker): string
29 |     {
30 |         return $walker->walkSelectStatement($this);
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Query/AST/SimpleArithmeticExpression.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | /**
10 |  * SimpleArithmeticExpression ::= ArithmeticTerm {("+" | "-") ArithmeticTerm}*
11 |  *
12 |  * @link    www.doctrine-project.org
13 |  */
14 | class SimpleArithmeticExpression extends Node
15 | {
16 |     /** @param mixed[] $arithmeticTerms */
17 |     public function __construct(public array $arithmeticTerms)
18 |     {
19 |     }
20 | 
21 |     public function dispatch(SqlWalker $walker): string
22 |     {
23 |         return $walker->walkSimpleArithmeticExpression($this);
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Query/AST/SimpleCaseExpression.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | /**
10 |  * SimpleCaseExpression ::= "CASE" CaseOperand SimpleWhenClause {SimpleWhenClause}* "ELSE" ScalarExpression "END"
11 |  *
12 |  * @link    www.doctrine-project.org
13 |  */
14 | class SimpleCaseExpression extends Node
15 | {
16 |     /** @param mixed[] $simpleWhenClauses */
17 |     public function __construct(
18 |         public PathExpression|null $caseOperand = null,
19 |         public array $simpleWhenClauses = [],
20 |         public mixed $elseScalarExpression = null,
21 |     ) {
22 |     }
23 | 
24 |     public function dispatch(SqlWalker $walker): string
25 |     {
26 |         return $walker->walkSimpleCaseExpression($this);
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Query/AST/SimpleSelectClause.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | /**
10 |  * SimpleSelectClause  ::= "SELECT" ["DISTINCT"] SimpleSelectExpression
11 |  *
12 |  * @link    www.doctrine-project.org
13 |  */
14 | class SimpleSelectClause extends Node
15 | {
16 |     public function __construct(
17 |         public SimpleSelectExpression $simpleSelectExpression,
18 |         public bool $isDistinct = false,
19 |     ) {
20 |     }
21 | 
22 |     public function dispatch(SqlWalker $walker): string
23 |     {
24 |         return $walker->walkSimpleSelectClause($this);
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Query/AST/SimpleSelectExpression.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | /**
10 |  * SimpleSelectExpression ::= StateFieldPathExpression | IdentificationVariable
11 |  *                          | (AggregateExpression [["AS"] FieldAliasIdentificationVariable])
12 |  *
13 |  * @link    www.doctrine-project.org
14 |  */
15 | class SimpleSelectExpression extends Node
16 | {
17 |     public string|null $fieldIdentificationVariable = null;
18 | 
19 |     public function __construct(public Node|string $expression)
20 |     {
21 |     }
22 | 
23 |     public function dispatch(SqlWalker $walker): string
24 |     {
25 |         return $walker->walkSimpleSelectExpression($this);
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Query/AST/SimpleWhenClause.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | /**
10 |  * SimpleWhenClause ::= "WHEN" ScalarExpression "THEN" ScalarExpression
11 |  *
12 |  * @link    www.doctrine-project.org
13 |  */
14 | class SimpleWhenClause extends Node
15 | {
16 |     public function __construct(
17 |         public mixed $caseScalarExpression = null,
18 |         public mixed $thenScalarExpression = null,
19 |     ) {
20 |     }
21 | 
22 |     public function dispatch(SqlWalker $walker): string
23 |     {
24 |         return $walker->walkWhenClauseExpression($this);
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Query/AST/Subselect.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | /**
10 |  * Subselect ::= SimpleSelectClause SubselectFromClause [WhereClause] [GroupByClause] [HavingClause] [OrderByClause]
11 |  *
12 |  * @link    www.doctrine-project.org
13 |  */
14 | class Subselect extends Node
15 | {
16 |     public WhereClause|null $whereClause = null;
17 | 
18 |     public GroupByClause|null $groupByClause = null;
19 | 
20 |     public HavingClause|null $havingClause = null;
21 | 
22 |     public OrderByClause|null $orderByClause = null;
23 | 
24 |     public function __construct(public SimpleSelectClause $simpleSelectClause, public SubselectFromClause $subselectFromClause)
25 |     {
26 |     }
27 | 
28 |     public function dispatch(SqlWalker $walker): string
29 |     {
30 |         return $walker->walkSubselect($this);
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Query/AST/SubselectFromClause.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | /**
10 |  * SubselectFromClause ::= "FROM" SubselectIdentificationVariableDeclaration {"," SubselectIdentificationVariableDeclaration}*
11 |  *
12 |  * @link    www.doctrine-project.org
13 |  */
14 | class SubselectFromClause extends Node
15 | {
16 |     /** @param mixed[] $identificationVariableDeclarations */
17 |     public function __construct(public array $identificationVariableDeclarations)
18 |     {
19 |     }
20 | 
21 |     public function dispatch(SqlWalker $walker): string
22 |     {
23 |         return $walker->walkSubselectFromClause($this);
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Query/AST/SubselectIdentificationVariableDeclaration.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | /**
 8 |  * SubselectIdentificationVariableDeclaration ::= AssociationPathExpression ["AS"] AliasIdentificationVariable
 9 |  *
10 |  * @link    www.doctrine-project.org
11 |  */
12 | class SubselectIdentificationVariableDeclaration
13 | {
14 |     public function __construct(
15 |         public PathExpression $associationPathExpression,
16 |         public string $aliasIdentificationVariable,
17 |     ) {
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Query/AST/TypedExpression.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\DBAL\Types\Type;
 8 | 
 9 | /**
10 |  * Provides an API for resolving the type of a Node
11 |  */
12 | interface TypedExpression
13 | {
14 |     public function getReturnType(): Type;
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Query/AST/UpdateClause.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | /**
10 |  * UpdateClause ::= "UPDATE" AbstractSchemaName [["AS"] AliasIdentificationVariable] "SET" UpdateItem {"," UpdateItem}*
11 |  *
12 |  * @link    www.doctrine-project.org
13 |  */
14 | class UpdateClause extends Node
15 | {
16 |     public string $aliasIdentificationVariable;
17 | 
18 |     /** @param mixed[] $updateItems */
19 |     public function __construct(
20 |         public string $abstractSchemaName,
21 |         public array $updateItems,
22 |     ) {
23 |     }
24 | 
25 |     public function dispatch(SqlWalker $walker): string
26 |     {
27 |         return $walker->walkUpdateClause($this);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Query/AST/UpdateItem.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | /**
10 |  * UpdateItem ::= [IdentificationVariable "."] {StateField | SingleValuedAssociationField} "=" NewValue
11 |  * NewValue ::= SimpleArithmeticExpression | StringPrimary | DatetimePrimary | BooleanPrimary |
12 |  *              EnumPrimary | SimpleEntityExpression | "NULL"
13 |  *
14 |  * @link    www.doctrine-project.org
15 |  */
16 | class UpdateItem extends Node
17 | {
18 |     public function __construct(public PathExpression $pathExpression, public InputParameter|ArithmeticExpression|null $newValue)
19 |     {
20 |     }
21 | 
22 |     public function dispatch(SqlWalker $walker): string
23 |     {
24 |         return $walker->walkUpdateItem($this);
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Query/AST/UpdateStatement.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | /**
10 |  * UpdateStatement = UpdateClause [WhereClause]
11 |  *
12 |  * @link    www.doctrine-project.org
13 |  */
14 | class UpdateStatement extends Node
15 | {
16 |     public WhereClause|null $whereClause = null;
17 | 
18 |     public function __construct(public UpdateClause $updateClause)
19 |     {
20 |     }
21 | 
22 |     public function dispatch(SqlWalker $walker): string
23 |     {
24 |         return $walker->walkUpdateStatement($this);
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Query/AST/WhenClause.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | /**
10 |  * WhenClause ::= "WHEN" ConditionalExpression "THEN" ScalarExpression
11 |  *
12 |  * @link    www.doctrine-project.org
13 |  */
14 | class WhenClause extends Node
15 | {
16 |     public function __construct(
17 |         public ConditionalExpression|Phase2OptimizableConditional $caseConditionExpression,
18 |         public mixed $thenScalarExpression = null,
19 |     ) {
20 |     }
21 | 
22 |     public function dispatch(SqlWalker $walker): string
23 |     {
24 |         return $walker->walkWhenClauseExpression($this);
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Query/AST/WhereClause.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\AST;
 6 | 
 7 | use Doctrine\ORM\Query\SqlWalker;
 8 | 
 9 | /**
10 |  * WhereClause ::= "WHERE" ConditionalExpression
11 |  *
12 |  * @link    www.doctrine-project.org
13 |  */
14 | class WhereClause extends Node
15 | {
16 |     public function __construct(public ConditionalExpression|Phase2OptimizableConditional $conditionalExpression)
17 |     {
18 |     }
19 | 
20 |     public function dispatch(SqlWalker $walker): string
21 |     {
22 |         return $walker->walkWhereClause($this);
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Query/Exec/FinalizedSelectExecutor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\Exec;
 6 | 
 7 | use Doctrine\DBAL\Connection;
 8 | use Doctrine\DBAL\Result;
 9 | 
10 | /**
11 |  * SQL executor for a given, final, single SELECT SQL query
12 |  *
13 |  * @method string getSqlStatements()
14 |  */
15 | class FinalizedSelectExecutor extends AbstractSqlExecutor
16 | {
17 |     public function __construct(string $sql)
18 |     {
19 |         $this->sqlStatements = $sql;
20 |     }
21 | 
22 |     /**
23 |      * {@inheritDoc}
24 |      */
25 |     public function execute(Connection $conn, array $params, array $types): Result
26 |     {
27 |         return $conn->executeQuery($this->getSqlStatements(), $params, $types, $this->queryCacheProfile);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Query/Exec/PreparedExecutorFinalizer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\Exec;
 6 | 
 7 | use Doctrine\ORM\Query;
 8 | 
 9 | /**
10 |  * PreparedExecutorFinalizer is a wrapper for the SQL finalization
11 |  * phase that does nothing - it is constructed with the sql executor
12 |  * already.
13 |  */
14 | final class PreparedExecutorFinalizer implements SqlFinalizer
15 | {
16 |     private AbstractSqlExecutor $executor;
17 | 
18 |     public function __construct(AbstractSqlExecutor $exeutor)
19 |     {
20 |         $this->executor = $exeutor;
21 |     }
22 | 
23 |     public function createExecutor(Query $query): AbstractSqlExecutor
24 |     {
25 |         return $this->executor;
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Query/Exec/SingleSelectExecutor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\Exec;
 6 | 
 7 | use Doctrine\DBAL\Connection;
 8 | use Doctrine\DBAL\Result;
 9 | use Doctrine\ORM\Query\AST\SelectStatement;
10 | use Doctrine\ORM\Query\SqlWalker;
11 | 
12 | /**
13 |  * Executor that executes the SQL statement for simple DQL SELECT statements.
14 |  *
15 |  * @link        www.doctrine-project.org
16 |  */
17 | class SingleSelectExecutor extends AbstractSqlExecutor
18 | {
19 |     public function __construct(SelectStatement $AST, SqlWalker $sqlWalker)
20 |     {
21 |         $this->sqlStatements = $sqlWalker->walkSelectStatement($AST);
22 |     }
23 | 
24 |     /**
25 |      * {@inheritDoc}
26 |      */
27 |     public function execute(Connection $conn, array $params, array $types): Result
28 |     {
29 |         return $conn->executeQuery($this->sqlStatements, $params, $types, $this->queryCacheProfile);
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/Query/Exec/SingleTableDeleteUpdateExecutor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\Exec;
 6 | 
 7 | use Doctrine\DBAL\Connection;
 8 | use Doctrine\DBAL\Connections\PrimaryReadReplicaConnection;
 9 | use Doctrine\ORM\Query\AST;
10 | use Doctrine\ORM\Query\SqlWalker;
11 | 
12 | /**
13 |  * Executor that executes the SQL statements for DQL DELETE/UPDATE statements on classes
14 |  * that are mapped to a single table.
15 |  *
16 |  * @link        www.doctrine-project.org
17 |  */
18 | class SingleTableDeleteUpdateExecutor extends AbstractSqlExecutor
19 | {
20 |     public function __construct(AST\Node $AST, SqlWalker $sqlWalker)
21 |     {
22 |         if ($AST instanceof AST\UpdateStatement) {
23 |             $this->sqlStatements = $sqlWalker->walkUpdateStatement($AST);
24 |         } elseif ($AST instanceof AST\DeleteStatement) {
25 |             $this->sqlStatements = $sqlWalker->walkDeleteStatement($AST);
26 |         }
27 |     }
28 | 
29 |     /**
30 |      * {@inheritDoc}
31 |      */
32 |     public function execute(Connection $conn, array $params, array $types): int
33 |     {
34 |         if ($conn instanceof PrimaryReadReplicaConnection) {
35 |             $conn->ensureConnectedToPrimary();
36 |         }
37 | 
38 |         return $conn->executeStatement($this->sqlStatements, $params, $types);
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Query/Exec/SqlFinalizer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\Exec;
 6 | 
 7 | use Doctrine\ORM\Query;
 8 | 
 9 | /**
10 |  * SqlFinalizers are created by OutputWalkers that traversed the DQL AST.
11 |  * The SqlFinalizer instance can be kept in the query cache and re-used
12 |  * at a later time.
13 |  *
14 |  * Once the SqlFinalizer has been created or retrieved from the query cache,
15 |  * it receives the Query object again in order to yield the AbstractSqlExecutor
16 |  * that will then be used to execute the query.
17 |  *
18 |  * The SqlFinalizer may assume that the DQL that was used to build the AST
19 |  * and run the OutputWalker (which created the SqlFinalizer) is equivalent to
20 |  * the query that will be passed to the createExecutor() method. Potential differences
21 |  * are the parameter values or firstResult/maxResult settings.
22 |  */
23 | interface SqlFinalizer
24 | {
25 |     public function createExecutor(Query $query): AbstractSqlExecutor;
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Query/Expr/Andx.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\Expr;
 6 | 
 7 | /**
 8 |  * Expression class for building DQL and parts.
 9 |  *
10 |  * @link    www.doctrine-project.org
11 |  */
12 | class Andx extends Composite
13 | {
14 |     protected string $separator = ' AND ';
15 | 
16 |     /** @var string[] */
17 |     protected array $allowedClasses = [
18 |         Comparison::class,
19 |         Func::class,
20 |         Orx::class,
21 |         self::class,
22 |     ];
23 | 
24 |     /** @phpstan-var list<string|Comparison|Func|Orx|self> */
25 |     protected array $parts = [];
26 | 
27 |     /** @phpstan-return list<string|Comparison|Func|Orx|self> */
28 |     public function getParts(): array
29 |     {
30 |         return $this->parts;
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Query/Expr/Comparison.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\Expr;
 6 | 
 7 | use Stringable;
 8 | 
 9 | /**
10 |  * Expression class for DQL comparison expressions.
11 |  *
12 |  * @link    www.doctrine-project.org
13 |  */
14 | class Comparison implements Stringable
15 | {
16 |     final public const EQ  = '=';
17 |     final public const NEQ = '<>';
18 |     final public const LT  = '<';
19 |     final public const LTE = '<=';
20 |     final public const GT  = '>';
21 |     final public const GTE = '>=';
22 | 
23 |     /** Creates a comparison expression with the given arguments. */
24 |     public function __construct(protected mixed $leftExpr, protected string $operator, protected mixed $rightExpr)
25 |     {
26 |     }
27 | 
28 |     public function getLeftExpr(): mixed
29 |     {
30 |         return $this->leftExpr;
31 |     }
32 | 
33 |     public function getOperator(): string
34 |     {
35 |         return $this->operator;
36 |     }
37 | 
38 |     public function getRightExpr(): mixed
39 |     {
40 |         return $this->rightExpr;
41 |     }
42 | 
43 |     public function __toString(): string
44 |     {
45 |         return $this->leftExpr . ' ' . $this->operator . ' ' . $this->rightExpr;
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/src/Query/Expr/Composite.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\Expr;
 6 | 
 7 | use Stringable;
 8 | 
 9 | use function implode;
10 | use function is_object;
11 | use function preg_match;
12 | 
13 | /**
14 |  * Expression class for building DQL and parts.
15 |  *
16 |  * @link    www.doctrine-project.org
17 |  */
18 | class Composite extends Base
19 | {
20 |     public function __toString(): string
21 |     {
22 |         if ($this->count() === 1) {
23 |             return (string) $this->parts[0];
24 |         }
25 | 
26 |         $components = [];
27 | 
28 |         foreach ($this->parts as $part) {
29 |             $components[] = $this->processQueryPart($part);
30 |         }
31 | 
32 |         return implode($this->separator, $components);
33 |     }
34 | 
35 |     private function processQueryPart(string|Stringable $part): string
36 |     {
37 |         $queryPart = (string) $part;
38 | 
39 |         if (is_object($part) && $part instanceof self && $part->count() > 1) {
40 |             return $this->preSeparator . $queryPart . $this->postSeparator;
41 |         }
42 | 
43 |         // Fixes DDC-1237: User may have added a where item containing nested expression (with "OR" or "AND")
44 |         if (preg_match('/\s(OR|AND)\s/i', $queryPart)) {
45 |             return $this->preSeparator . $queryPart . $this->postSeparator;
46 |         }
47 | 
48 |         return $queryPart;
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/src/Query/Expr/From.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\Expr;
 6 | 
 7 | use Stringable;
 8 | 
 9 | /**
10 |  * Expression class for DQL from.
11 |  *
12 |  * @link    www.doctrine-project.org
13 |  */
14 | class From implements Stringable
15 | {
16 |     /**
17 |      * @param class-string $from  The class name.
18 |      * @param string       $alias The alias of the class.
19 |      */
20 |     public function __construct(
21 |         protected string $from,
22 |         protected string $alias,
23 |         protected string|null $indexBy = null,
24 |     ) {
25 |     }
26 | 
27 |     /** @return class-string */
28 |     public function getFrom(): string
29 |     {
30 |         return $this->from;
31 |     }
32 | 
33 |     public function getAlias(): string
34 |     {
35 |         return $this->alias;
36 |     }
37 | 
38 |     public function getIndexBy(): string|null
39 |     {
40 |         return $this->indexBy;
41 |     }
42 | 
43 |     public function __toString(): string
44 |     {
45 |         return $this->from . ' ' . $this->alias .
46 |                 ($this->indexBy ? ' INDEX BY ' . $this->indexBy : '');
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/src/Query/Expr/Func.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\Expr;
 6 | 
 7 | use Stringable;
 8 | 
 9 | use function implode;
10 | 
11 | /**
12 |  * Expression class for generating DQL functions.
13 |  *
14 |  * @link    www.doctrine-project.org
15 |  */
16 | class Func implements Stringable
17 | {
18 |     /** @var mixed[] */
19 |     protected array $arguments;
20 | 
21 |     /**
22 |      * Creates a function, with the given argument.
23 |      *
24 |      * @phpstan-param list<mixed>|mixed $arguments
25 |      */
26 |     public function __construct(
27 |         protected string $name,
28 |         mixed $arguments,
29 |     ) {
30 |         $this->arguments = (array) $arguments;
31 |     }
32 | 
33 |     public function getName(): string
34 |     {
35 |         return $this->name;
36 |     }
37 | 
38 |     /** @phpstan-return list<mixed> */
39 |     public function getArguments(): array
40 |     {
41 |         return $this->arguments;
42 |     }
43 | 
44 |     public function __toString(): string
45 |     {
46 |         return $this->name . '(' . implode(', ', $this->arguments) . ')';
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/src/Query/Expr/GroupBy.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\Expr;
 6 | 
 7 | /**
 8 |  * Expression class for building DQL Group By parts.
 9 |  *
10 |  * @link    www.doctrine-project.org
11 |  */
12 | class GroupBy extends Base
13 | {
14 |     protected string $preSeparator  = '';
15 |     protected string $postSeparator = '';
16 | 
17 |     /** @phpstan-var list<string> */
18 |     protected array $parts = [];
19 | 
20 |     /** @phpstan-return list<string> */
21 |     public function getParts(): array
22 |     {
23 |         return $this->parts;
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Query/Expr/Literal.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\Expr;
 6 | 
 7 | /**
 8 |  * Expression class for generating DQL functions.
 9 |  *
10 |  * @link    www.doctrine-project.org
11 |  */
12 | class Literal extends Base
13 | {
14 |     protected string $preSeparator  = '';
15 |     protected string $postSeparator = '';
16 | 
17 |     /** @phpstan-var list<string> */
18 |     protected array $parts = [];
19 | 
20 |     /** @phpstan-return list<string> */
21 |     public function getParts(): array
22 |     {
23 |         return $this->parts;
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Query/Expr/Math.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\Expr;
 6 | 
 7 | use Stringable;
 8 | 
 9 | /**
10 |  * Expression class for DQL math statements.
11 |  *
12 |  * @link    www.doctrine-project.org
13 |  */
14 | class Math implements Stringable
15 | {
16 |     /**
17 |      * Creates a mathematical expression with the given arguments.
18 |      */
19 |     public function __construct(
20 |         protected mixed $leftExpr,
21 |         protected string $operator,
22 |         protected mixed $rightExpr,
23 |     ) {
24 |     }
25 | 
26 |     public function getLeftExpr(): mixed
27 |     {
28 |         return $this->leftExpr;
29 |     }
30 | 
31 |     public function getOperator(): string
32 |     {
33 |         return $this->operator;
34 |     }
35 | 
36 |     public function getRightExpr(): mixed
37 |     {
38 |         return $this->rightExpr;
39 |     }
40 | 
41 |     public function __toString(): string
42 |     {
43 |         // Adjusting Left Expression
44 |         $leftExpr = (string) $this->leftExpr;
45 | 
46 |         if ($this->leftExpr instanceof Math) {
47 |             $leftExpr = '(' . $leftExpr . ')';
48 |         }
49 | 
50 |         // Adjusting Right Expression
51 |         $rightExpr = (string) $this->rightExpr;
52 | 
53 |         if ($this->rightExpr instanceof Math) {
54 |             $rightExpr = '(' . $rightExpr . ')';
55 |         }
56 | 
57 |         return $leftExpr . ' ' . $this->operator . ' ' . $rightExpr;
58 |     }
59 | }
60 | 


--------------------------------------------------------------------------------
/src/Query/Expr/Orx.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\Expr;
 6 | 
 7 | /**
 8 |  * Expression class for building DQL OR clauses.
 9 |  *
10 |  * @link    www.doctrine-project.org
11 |  */
12 | class Orx extends Composite
13 | {
14 |     protected string $separator = ' OR ';
15 | 
16 |     /** @var string[] */
17 |     protected array $allowedClasses = [
18 |         Comparison::class,
19 |         Func::class,
20 |         Andx::class,
21 |         self::class,
22 |     ];
23 | 
24 |     /** @phpstan-var list<string|Comparison|Func|Andx|self> */
25 |     protected array $parts = [];
26 | 
27 |     /** @phpstan-return list<string|Comparison|Func|Andx|self> */
28 |     public function getParts(): array
29 |     {
30 |         return $this->parts;
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Query/Expr/Select.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\Expr;
 6 | 
 7 | /**
 8 |  * Expression class for building DQL select statements.
 9 |  *
10 |  * @link    www.doctrine-project.org
11 |  */
12 | class Select extends Base
13 | {
14 |     protected string $preSeparator  = '';
15 |     protected string $postSeparator = '';
16 | 
17 |     /** @var string[] */
18 |     protected array $allowedClasses = [Func::class];
19 | 
20 |     /** @phpstan-var list<string|Func> */
21 |     protected array $parts = [];
22 | 
23 |     /** @phpstan-return list<string|Func> */
24 |     public function getParts(): array
25 |     {
26 |         return $this->parts;
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Query/Filter/FilterException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query\Filter;
 6 | 
 7 | use Doctrine\ORM\Exception\ORMException;
 8 | use LogicException;
 9 | 
10 | use function sprintf;
11 | 
12 | class FilterException extends LogicException implements ORMException
13 | {
14 |     public static function cannotConvertListParameterIntoSingleValue(string $name): self
15 |     {
16 |         return new self(sprintf('Cannot convert list-based SQL filter parameter "%s" into a single value.', $name));
17 |     }
18 | 
19 |     public static function cannotConvertSingleParameterIntoListValue(string $name): self
20 |     {
21 |         return new self(sprintf('Cannot convert single SQL filter parameter "%s" into a list value.', $name));
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Query/OutputWalker.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query;
 6 | 
 7 | use Doctrine\ORM\Query\Exec\SqlFinalizer;
 8 | 
 9 | /**
10 |  * Interface for output walkers
11 |  *
12 |  * Output walkers, like tree walkers, can traverse the DQL AST to perform
13 |  * their purpose.
14 |  *
15 |  * The goal of an OutputWalker is to ultimately provide the SqlFinalizer
16 |  * which produces the final, executable SQL statement in a "finalization" phase.
17 |  *
18 |  * It must be possible to use the same SqlFinalizer for Queries with different
19 |  * firstResult/maxResult values. In other words, SQL produced by the
20 |  * output walker should not depend on those values, and any SQL generation/modification
21 |  * specific to them should happen in the finalizer's `\Doctrine\ORM\Query\Exec\SqlFinalizer::createExecutor()`
22 |  * method instead.
23 |  */
24 | interface OutputWalker
25 | {
26 |     public function getFinalizer(AST\DeleteStatement|AST\UpdateStatement|AST\SelectStatement $AST): SqlFinalizer;
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Query/SqlOutputWalker.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query;
 6 | 
 7 | use Doctrine\ORM\Query\Exec\PreparedExecutorFinalizer;
 8 | use Doctrine\ORM\Query\Exec\SingleSelectSqlFinalizer;
 9 | use Doctrine\ORM\Query\Exec\SqlFinalizer;
10 | use LogicException;
11 | 
12 | class SqlOutputWalker extends SqlWalker implements OutputWalker
13 | {
14 |     public function getFinalizer(AST\DeleteStatement|AST\UpdateStatement|AST\SelectStatement $AST): SqlFinalizer
15 |     {
16 |         switch (true) {
17 |             case $AST instanceof AST\SelectStatement:
18 |                 return new SingleSelectSqlFinalizer($this->createSqlForFinalizer($AST));
19 | 
20 |             case $AST instanceof AST\UpdateStatement:
21 |                 return new PreparedExecutorFinalizer($this->createUpdateStatementExecutor($AST));
22 | 
23 |             case $AST instanceof AST\DeleteStatement:
24 |                 return new PreparedExecutorFinalizer($this->createDeleteStatementExecutor($AST));
25 |         }
26 | 
27 |         throw new LogicException('Unexpected AST node type');
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Query/TreeWalker.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Query;
 6 | 
 7 | use Doctrine\ORM\AbstractQuery;
 8 | 
 9 | /**
10 |  * Interface for walkers of DQL ASTs (abstract syntax trees).
11 |  *
12 |  * @phpstan-import-type QueryComponent from Parser
13 |  */
14 | interface TreeWalker
15 | {
16 |     /**
17 |      * Initializes TreeWalker with important information about the ASTs to be walked.
18 |      *
19 |      * @phpstan-param array<string, QueryComponent> $queryComponents The query components (symbol table).
20 |      */
21 |     public function __construct(AbstractQuery $query, ParserResult $parserResult, array $queryComponents);
22 | 
23 |     /**
24 |      * Returns internal queryComponents array.
25 |      *
26 |      * @phpstan-return array<string, QueryComponent>
27 |      */
28 |     public function getQueryComponents(): array;
29 | 
30 |     /**
31 |      * Walks down a SelectStatement AST node.
32 |      */
33 |     public function walkSelectStatement(AST\SelectStatement $selectStatement): void;
34 | 
35 |     /**
36 |      * Walks down an UpdateStatement AST node.
37 |      */
38 |     public function walkUpdateStatement(AST\UpdateStatement $updateStatement): void;
39 | 
40 |     /**
41 |      * Walks down a DeleteStatement AST node.
42 |      */
43 |     public function walkDeleteStatement(AST\DeleteStatement $deleteStatement): void;
44 | }
45 | 


--------------------------------------------------------------------------------
/src/Repository/Exception/InvalidFindByCall.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Repository\Exception;
 6 | 
 7 | use Doctrine\ORM\Exception\RepositoryException;
 8 | use LogicException;
 9 | 
10 | final class InvalidFindByCall extends LogicException implements RepositoryException
11 | {
12 |     public static function fromInverseSideUsage(
13 |         string $entityName,
14 |         string $associationFieldName,
15 |     ): self {
16 |         return new self(
17 |             "You cannot search for the association field '" . $entityName . '#' . $associationFieldName . "', " .
18 |             'because it is the inverse side of an association. Find methods only work on owning side associations.',
19 |         );
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Repository/Exception/InvalidMagicMethodCall.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Repository\Exception;
 6 | 
 7 | use Doctrine\ORM\Exception\RepositoryException;
 8 | use LogicException;
 9 | 
10 | final class InvalidMagicMethodCall extends LogicException implements RepositoryException
11 | {
12 |     public static function becauseFieldNotFoundIn(
13 |         string $entityName,
14 |         string $fieldName,
15 |         string $method,
16 |     ): self {
17 |         return new self(
18 |             "Entity '" . $entityName . "' has no field '" . $fieldName . "'. " .
19 |             "You can therefore not call '" . $method . "' on the entities' repository.",
20 |         );
21 |     }
22 | 
23 |     public static function onMissingParameter(string $methodName): self
24 |     {
25 |         return new self("You need to pass a parameter to '" . $methodName . "'");
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Repository/RepositoryFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Repository;
 6 | 
 7 | use Doctrine\ORM\EntityManagerInterface;
 8 | use Doctrine\ORM\EntityRepository;
 9 | 
10 | /**
11 |  * Interface for entity repository factory.
12 |  */
13 | interface RepositoryFactory
14 | {
15 |     /**
16 |      * Gets the repository for an entity class.
17 |      *
18 |      * @param EntityManagerInterface $entityManager The EntityManager instance.
19 |      * @param class-string<T>        $entityName    The name of the entity.
20 |      *
21 |      * @return EntityRepository<T>
22 |      *
23 |      * @template T of object
24 |      */
25 |     public function getRepository(EntityManagerInterface $entityManager, string $entityName): EntityRepository;
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Tools/Console/Command/AbstractEntityManagerCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Tools\Console\Command;
 6 | 
 7 | use Doctrine\ORM\EntityManagerInterface;
 8 | use Doctrine\ORM\Tools\Console\EntityManagerProvider;
 9 | use Symfony\Component\Console\Command\Command;
10 | use Symfony\Component\Console\Input\InputInterface;
11 | 
12 | abstract class AbstractEntityManagerCommand extends Command
13 | {
14 |     public function __construct(private readonly EntityManagerProvider $entityManagerProvider)
15 |     {
16 |         parent::__construct();
17 |     }
18 | 
19 |     final protected function getEntityManager(InputInterface $input): EntityManagerInterface
20 |     {
21 |         return $input->getOption('em') === null
22 |             ? $this->entityManagerProvider->getDefaultManager()
23 |             : $this->entityManagerProvider->getManager($input->getOption('em'));
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Tools/Console/Command/SchemaTool/AbstractCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Tools\Console\Command\SchemaTool;
 6 | 
 7 | use Doctrine\ORM\Tools\Console\Command\AbstractEntityManagerCommand;
 8 | use Doctrine\ORM\Tools\SchemaTool;
 9 | use Symfony\Component\Console\Input\InputInterface;
10 | use Symfony\Component\Console\Output\OutputInterface;
11 | use Symfony\Component\Console\Style\SymfonyStyle;
12 | 
13 | /**
14 |  * Base class for CreateCommand, DropCommand and UpdateCommand.
15 |  *
16 |  * @link    www.doctrine-project.org
17 |  */
18 | abstract class AbstractCommand extends AbstractEntityManagerCommand
19 | {
20 |     /** @param mixed[] $metadatas */
21 |     abstract protected function executeSchemaCommand(InputInterface $input, OutputInterface $output, SchemaTool $schemaTool, array $metadatas, SymfonyStyle $ui): int;
22 | 
23 |     protected function execute(InputInterface $input, OutputInterface $output): int
24 |     {
25 |         $ui = new SymfonyStyle($input, $output);
26 | 
27 |         $em = $this->getEntityManager($input);
28 | 
29 |         $metadatas = $em->getMetadataFactory()->getAllMetadata();
30 | 
31 |         if (empty($metadatas)) {
32 |             $ui->getErrorStyle()->success('No Metadata Classes to process.');
33 | 
34 |             return 0;
35 |         }
36 | 
37 |         return $this->executeSchemaCommand($input, $output, new SchemaTool($em), $metadatas, $ui);
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/Tools/Console/EntityManagerProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Tools\Console;
 6 | 
 7 | use Doctrine\ORM\EntityManagerInterface;
 8 | 
 9 | interface EntityManagerProvider
10 | {
11 |     public function getDefaultManager(): EntityManagerInterface;
12 | 
13 |     public function getManager(string $name): EntityManagerInterface;
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Tools/Console/EntityManagerProvider/ConnectionFromManagerProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Tools\Console\EntityManagerProvider;
 6 | 
 7 | use Doctrine\DBAL\Connection;
 8 | use Doctrine\DBAL\Tools\Console\ConnectionProvider;
 9 | use Doctrine\ORM\Tools\Console\EntityManagerProvider;
10 | 
11 | final class ConnectionFromManagerProvider implements ConnectionProvider
12 | {
13 |     public function __construct(private readonly EntityManagerProvider $entityManagerProvider)
14 |     {
15 |     }
16 | 
17 |     public function getDefaultConnection(): Connection
18 |     {
19 |         return $this->entityManagerProvider->getDefaultManager()->getConnection();
20 |     }
21 | 
22 |     public function getConnection(string $name): Connection
23 |     {
24 |         return $this->entityManagerProvider->getManager($name)->getConnection();
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Tools/Console/EntityManagerProvider/SingleManagerProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Tools\Console\EntityManagerProvider;
 6 | 
 7 | use Doctrine\ORM\EntityManagerInterface;
 8 | use Doctrine\ORM\Tools\Console\EntityManagerProvider;
 9 | 
10 | final class SingleManagerProvider implements EntityManagerProvider
11 | {
12 |     public function __construct(
13 |         private readonly EntityManagerInterface $entityManager,
14 |         private readonly string $defaultManagerName = 'default',
15 |     ) {
16 |     }
17 | 
18 |     public function getDefaultManager(): EntityManagerInterface
19 |     {
20 |         return $this->entityManager;
21 |     }
22 | 
23 |     public function getManager(string $name): EntityManagerInterface
24 |     {
25 |         if ($name !== $this->defaultManagerName) {
26 |             throw UnknownManagerException::unknownManager($name, [$this->defaultManagerName]);
27 |         }
28 | 
29 |         return $this->entityManager;
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/Tools/Console/EntityManagerProvider/UnknownManagerException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Tools\Console\EntityManagerProvider;
 6 | 
 7 | use OutOfBoundsException;
 8 | 
 9 | use function implode;
10 | use function sprintf;
11 | 
12 | final class UnknownManagerException extends OutOfBoundsException
13 | {
14 |     /** @phpstan-param list<string> $knownManagers */
15 |     public static function unknownManager(string $unknownManager, array $knownManagers = []): self
16 |     {
17 |         return new self(sprintf(
18 |             'Requested unknown entity manager: %s, known managers: %s',
19 |             $unknownManager,
20 |             implode(', ', $knownManagers),
21 |         ));
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Tools/Event/GenerateSchemaEventArgs.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Tools\Event;
 6 | 
 7 | use Doctrine\Common\EventArgs;
 8 | use Doctrine\DBAL\Schema\Schema;
 9 | use Doctrine\ORM\EntityManagerInterface;
10 | 
11 | /**
12 |  * Event Args used for the Events::postGenerateSchema event.
13 |  *
14 |  * @link        www.doctrine-project.com
15 |  */
16 | class GenerateSchemaEventArgs extends EventArgs
17 | {
18 |     public function __construct(
19 |         private readonly EntityManagerInterface $em,
20 |         private readonly Schema $schema,
21 |     ) {
22 |     }
23 | 
24 |     public function getEntityManager(): EntityManagerInterface
25 |     {
26 |         return $this->em;
27 |     }
28 | 
29 |     public function getSchema(): Schema
30 |     {
31 |         return $this->schema;
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/Tools/Event/GenerateSchemaTableEventArgs.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Tools\Event;
 6 | 
 7 | use Doctrine\Common\EventArgs;
 8 | use Doctrine\DBAL\Schema\Schema;
 9 | use Doctrine\DBAL\Schema\Table;
10 | use Doctrine\ORM\Mapping\ClassMetadata;
11 | 
12 | /**
13 |  * Event Args used for the Events::postGenerateSchemaTable event.
14 |  *
15 |  * @link        www.doctrine-project.com
16 |  */
17 | class GenerateSchemaTableEventArgs extends EventArgs
18 | {
19 |     public function __construct(
20 |         private readonly ClassMetadata $classMetadata,
21 |         private readonly Schema $schema,
22 |         private readonly Table $classTable,
23 |     ) {
24 |     }
25 | 
26 |     public function getClassMetadata(): ClassMetadata
27 |     {
28 |         return $this->classMetadata;
29 |     }
30 | 
31 |     public function getSchema(): Schema
32 |     {
33 |         return $this->schema;
34 |     }
35 | 
36 |     public function getClassTable(): Table
37 |     {
38 |         return $this->classTable;
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Tools/Exception/MissingColumnException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Tools\Exception;
 6 | 
 7 | use Doctrine\ORM\Exception\ORMException;
 8 | use LogicException;
 9 | 
10 | use function sprintf;
11 | 
12 | final class MissingColumnException extends LogicException implements ORMException
13 | {
14 |     public static function fromColumnSourceAndTarget(string $column, string $source, string $target): self
15 |     {
16 |         return new self(sprintf(
17 |             'Column name "%s" referenced for relation from %s towards %s does not exist.',
18 |             $column,
19 |             $source,
20 |             $target,
21 |         ));
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Tools/Exception/NotSupported.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Tools\Exception;
 6 | 
 7 | use Doctrine\ORM\Exception\SchemaToolException;
 8 | use LogicException;
 9 | 
10 | final class NotSupported extends LogicException implements SchemaToolException
11 | {
12 |     public static function create(): self
13 |     {
14 |         return new self('This behaviour is (currently) not supported by Doctrine 2');
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Tools/Pagination/Exception/RowNumberOverFunctionNotEnabled.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Tools\Pagination\Exception;
 6 | 
 7 | use Doctrine\ORM\Exception\ORMException;
 8 | use LogicException;
 9 | 
10 | final class RowNumberOverFunctionNotEnabled extends LogicException implements ORMException
11 | {
12 |     public static function create(): self
13 |     {
14 |         return new self('The RowNumberOverFunction is not intended for, nor is it enabled for use in DQL.');
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Tools/Pagination/RowNumberOverFunction.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Tools\Pagination;
 6 | 
 7 | use Doctrine\ORM\Query\AST\Functions\FunctionNode;
 8 | use Doctrine\ORM\Query\AST\OrderByClause;
 9 | use Doctrine\ORM\Query\Parser;
10 | use Doctrine\ORM\Query\SqlWalker;
11 | use Doctrine\ORM\Tools\Pagination\Exception\RowNumberOverFunctionNotEnabled;
12 | 
13 | use function trim;
14 | 
15 | /**
16 |  * RowNumberOverFunction
17 |  *
18 |  * Provides ROW_NUMBER() OVER(ORDER BY...) construct for use in LimitSubqueryOutputWalker
19 |  */
20 | class RowNumberOverFunction extends FunctionNode
21 | {
22 |     public OrderByClause $orderByClause;
23 | 
24 |     public function getSql(SqlWalker $sqlWalker): string
25 |     {
26 |         return 'ROW_NUMBER() OVER(' . trim($sqlWalker->walkOrderByClause(
27 |             $this->orderByClause,
28 |         )) . ')';
29 |     }
30 | 
31 |     /**
32 |      * @throws RowNumberOverFunctionNotEnabled
33 |      *
34 |      * @inheritdoc
35 |      */
36 |     public function parse(Parser $parser): void
37 |     {
38 |         throw RowNumberOverFunctionNotEnabled::create();
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Tools/ToolEvents.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Tools;
 6 | 
 7 | class ToolEvents
 8 | {
 9 |     /**
10 |      * The postGenerateSchemaTable event occurs in SchemaTool#getSchemaFromMetadata()
11 |      * whenever an entity class is transformed into its table representation. It receives
12 |      * the current non-complete Schema instance, the Entity Metadata Class instance and
13 |      * the Schema Table instance of this entity.
14 |      */
15 |     public const postGenerateSchemaTable = 'postGenerateSchemaTable';
16 | 
17 |     /**
18 |      * The postGenerateSchema event is triggered in SchemaTool#getSchemaFromMetadata()
19 |      * after all entity classes have been transformed into the related Schema structure.
20 |      * The EventArgs contain the EntityManager and the created Schema instance.
21 |      */
22 |     public const postGenerateSchema = 'postGenerateSchema';
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Tools/ToolsException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Tools;
 6 | 
 7 | use Doctrine\ORM\Exception\ORMException;
 8 | use RuntimeException;
 9 | use Throwable;
10 | 
11 | /**
12 |  * Tools related Exceptions.
13 |  */
14 | class ToolsException extends RuntimeException implements ORMException
15 | {
16 |     public static function schemaToolFailure(string $sql, Throwable $e): self
17 |     {
18 |         return new self(
19 |             "Schema-Tool failed with Error '" . $e->getMessage() . "' while executing DDL: " . $sql,
20 |             0,
21 |             $e,
22 |         );
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/TransactionRequiredException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM;
 6 | 
 7 | use Doctrine\ORM\Exception\ORMException;
 8 | use LogicException;
 9 | 
10 | /**
11 |  * Is thrown when a transaction is required for the current operation, but there is none open.
12 |  *
13 |  * @link        www.doctrine-project.com
14 |  */
15 | class TransactionRequiredException extends LogicException implements ORMException
16 | {
17 |     public static function transactionRequired(): self
18 |     {
19 |         return new self('An open transaction is required for this operation.');
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/UnexpectedResultException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM;
 6 | 
 7 | use Doctrine\ORM\Exception\ORMException;
 8 | use RuntimeException;
 9 | 
10 | /**
11 |  * Exception for a unexpected query result.
12 |  */
13 | class UnexpectedResultException extends RuntimeException implements ORMException
14 | {
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Utility/LockSqlHelper.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\ORM\Utility;
 6 | 
 7 | use Doctrine\DBAL\Platforms\AbstractMySQLPlatform;
 8 | use Doctrine\DBAL\Platforms\AbstractPlatform;
 9 | use Doctrine\DBAL\Platforms\DB2Platform;
10 | use Doctrine\DBAL\Platforms\PostgreSQLPlatform;
11 | use Doctrine\DBAL\Platforms\SQLitePlatform;
12 | use Doctrine\DBAL\Platforms\SQLServerPlatform;
13 | 
14 | /** @internal */
15 | trait LockSqlHelper
16 | {
17 |     private function getReadLockSQL(AbstractPlatform $platform): string
18 |     {
19 |         return match (true) {
20 |             $platform instanceof AbstractMySQLPlatform => 'LOCK IN SHARE MODE',
21 |             $platform instanceof PostgreSQLPlatform => 'FOR SHARE',
22 |             default => $this->getWriteLockSQL($platform),
23 |         };
24 |     }
25 | 
26 |     private function getWriteLockSQL(AbstractPlatform $platform): string
27 |     {
28 |         return match (true) {
29 |             $platform instanceof DB2Platform => 'WITH RR USE AND KEEP UPDATE LOCKS',
30 |             $platform instanceof SQLitePlatform,
31 |             $platform instanceof SQLServerPlatform => '',
32 |             default => 'FOR UPDATE',
33 |         };
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------