doctrine/orm

This system is the Doctrine Object-Relational Mapper, a PHP library that manages the persistence of domain objects to relational databases. It provides core capabilities for entity mapping, query execution via DQL, and data hydration, while supporting advanced features like second-level caching, schema validation, and cursor-based pagination. The codebase is currently undergoing a major architectural overhaul to modernize its internals, including a shift from legacy proxy generation to native PHP lazy objects and a restructuring of the mapping and query layers for improved performance and type safety.

63 changes.

This period focused on preparing Doctrine ORM for version 4.0 by refactoring the codebase to support PHP 8.4 native lazy objects and modernizing the mapping system with a new object-oriented model. Significant architectural changes included restructuring the query, hydration, and caching layers, while introducing new programmatic mapping builders and cursor-based pagination. The work also involved extensive test coverage expansion and deprecating legacy proxy and array-based mapping mechanisms to ensure a smooth transition to the next major release.

7 changes.

This period focused on refactoring the UnitOfWork by isolating INSERT batch generation into a dedicated class to improve performance and safety for different identifier strategies. Significant effort was also dedicated to expanding test coverage, particularly for complex scenarios involving ManyToMany relations, SQL filters, inheritance, and lazy loading proxies. Additionally, new console debug commands were introduced to help users inspect entity and event listeners.

The console tool now provides specific commands to clear individual second-level cache regions rather than only clearing all cache at once. Users can target entity regions (orm:clear-cache:region:entity), collection regions (orm:clear-cache:region:collection), and query regions (orm:clear-cache:region:query) by name or ID, or flush the underlying cache provider for a specific region. These new commands complement the existing ones for clearing metadata, query, and result caches, offering finer control over cache invalidation.

src/Tools/Console/Command/ClearCache · high confidence

The repository has been initialized with the standard project configuration files for the Doctrine ORM. This includes the \.doctrine-project.json\ metadata file which defines the active version branches (4.0.x, 3.8.x, 3.7.x, 2.21.x, 2.20.x), the \doctrine-mapping.xsd\ XML schema for entity mapping validation, and the \UPGRADE.md\ guide detailing breaking changes and deprecations for version 3.7 (such as the deprecation of the legacy \Paginator\ in favor of \OffsetPaginator\ and the no-op behavior of \LockMode::NONE\). Additionally, development tooling configurations like \phpcs.xml.dist\ for code style enforcement and \phpbench.json\ for performance benchmarking have been added to the project root.

(repo-wide) · high confidence

The mapping driver layer introduces a new AttributeDriver that reads metadata from PHP 8 attributes, supporting ClassLocator for path management and enforcing strict reporting of declared fields. The existing XmlDriver has been refactored to allow users to explicitly disable XSD validation via a constructor parameter while keeping it enabled by default, and now supports the SortDirection enum for sorting configurations. Supporting infrastructure includes a new AttributeReader for handling repeatable attributes, a RepeatableAttributeCollection class, and a deprecated DatabaseDriver for reverse engineering.

src/Mapping/Driver · high confidence

The src/Tools directory now contains a suite of new utilities for schema management and debugging. SchemaValidator has been added to perform strict validation of mapping consistency, including checks for bidirectional associations, target entity existence, and BIGINT type mapping. SchemaTool has been updated to support the DBAL editor API (opt-in via configuration) and includes new event args (GenerateSchemaEventArgs, GenerateSchemaTableEventArgs) that allow mutating the schema during postGenerateSchema events, requiring DBAL 4.5+. New debugging tools include Debug for exporting entity states with depth limits, DebugUnitOfWorkListener for dumping the identity map during flush, AttachEntityListenersListener for programmatically attaching listeners, and ResolveTargetEntityListener for remapping association targets.

src/Tools · high confidence

This change introduces new classes in the \src/Cache/Logging\ directory to support second-level cache monitoring: a \CacheLogger\ interface, a \CacheLoggerChain\ to aggregate multiple loggers, and a \StatisticsCacheLogger\ that tracks hit, miss, and put counts per region. Additionally, several new exception classes are added to \src/Mapping/Exception\ and \src/Persisters/Exception\ to provide specific error handling for custom generator configuration issues, unknown generator types, and invalid persister operations like using the IN operator on composite keys.

(repo-wide) · high confidence

Added three new cache region classes in src/Cache/Region: DefaultRegion, which provides a standard cache region implementation compatible with PSR-6 cache drivers; FileLockRegion, a concurrent region wrapper that uses file-based locking to prevent race conditions in multi-process environments; and UpdateTimestampCache, a specialized region for tracking update timestamps that extends DefaultRegion.

src/Cache/Region · high confidence

Added \orm:debug:entity-listeners\ and \orm:debug:event-manager\ commands to the debug toolset, allowing users to list and inspect configured listeners for specific entities or the entire event manager via the console. These commands support filtering by event name, selecting specific entity managers, and provide tab-completion for entity and event suggestions to simplify debugging listener configurations.

src/Tools/Console/Command/Debug · high confidence

The pagination tools in src/Tools/Pagination have been restructured to introduce a new cursor-based pagination strategy alongside the existing offset-based approach. A new CursorPaginator class allows users to paginate DQL queries using secure, URL-safe cursors, which is particularly useful for large datasets where offset-based pagination can be inefficient. The CursorPaginator works with new supporting classes like Cursor, CursorPage, and CursorWalker to handle cursor encoding, decoding, and SQL generation. The pagination API has been modernized with a new PaginatorInterface that both OffsetPaginator and CursorPaginator implement, providing a consistent stateless API where pagination position is passed to the paginate() method rather than being stored in the paginator. The legacy Paginator class is now deprecated in favor of OffsetPaginator. New exception classes (InvalidCursor, RowNumberOverFunctionNotEnabled) have been added for better error handling, and the pagination system now supports more complex scenarios including ManyToOne associations and toMany joins in cursor pagination.

src/Tools/Pagination · high confidence

This change introduces a new set of builder classes in the \src/Mapping/Builder\ namespace to allow defining entity metadata programmatically via a fluent API. The new components include \ClassMetadataBuilder\ for core class configuration (such as table names, inheritance types, and embedded classes), \FieldBuilder\ for defining column properties like length, nullable, and primary keys, and specialized association builders (\AssociationBuilder\, \OneToManyAssociationBuilder\, \ManyToManyAssociationBuilder\, \EmbeddedBuilder\) for mapping relationships. Additionally, \EntityListenerBuilder\ provides a utility to automatically bind entity lifecycle listeners based on method names. These builders enable developers to construct mapping configurations in code rather than relying solely on annotations or XML.

src/Mapping/Builder · high confidence

The src/Utility directory now includes several new helper classes: HierarchyDiscriminatorResolver extracts discriminators for inheritance hierarchies to support INSTANCEOF queries; IdentifierFlattener converts foreign identifiers into scalar values, adding support for BackedEnum values to prevent object-to-string conversion failures; LockSqlHelper provides platform-specific SQL for read and write locks (e.g., LOCK IN SHARE MODE, FOR SHARE); and PersisterHelper infers field and column types for parameter binding, including normalization of DateTime types. These utilities centralize logic previously scattered in UnitOfWork and persisters, improving reusability and correctness for complex entity relationships and locking scenarios.

src/Utility · high confidence

The cache persister layer now supports the new SortDirection enum introduced in Doctrine Collections 3.1 while maintaining backward compatibility with the deprecated Order enum. A new CompatOrderings trait handles the transition by detecting the collections version at runtime, allowing users to utilize the modern SortDirection API in attributes and PHP drivers without breaking support for older library versions.

src/Cache/Persister · high confidence

The console commands in src/Tools/Console/Command have been reorganized to share a common AbstractEntityManagerCommand base, introducing a consistent --em option across commands (such as orm:info, orm:validate-schema, and orm:run-dql) to allow users to select a specific entity manager. The orm:mapping:describe command now supports a --format=json option to output metadata in JSON format, and includes shell completion for the entity name argument. Additionally, the orm:generate-proxies command now emits a deprecation warning when running on PHP 8.4+ or when native lazy objects are enabled, signaling that proxy generation will be removed in Doctrine ORM 4.0.

src/Tools/Console/Command · high confidence

The legacy proxy autoloader and class name resolver are now deprecated on PHP 8.4+, signaling that the traditional proxy generation mechanism will be removed in Doctrine ORM 4.0. The ProxyFactory constructor now accepts nullable proxy directory and namespace arguments, allowing users to opt into native lazy objects (enabled via configuration) which bypass the need for file-based proxy generation entirely. Existing code relying on the old proxy directory and namespace settings will continue to work but will trigger deprecation warnings, encouraging migration to the native lazy object approach.

src/Proxy · high confidence

The repository and console entity manager provider classes have been reorganized into a flatter directory hierarchy. Repository-related code, including the \RepositoryFactory\ interface, the \DefaultRepositoryFactory\ implementation, and specific exception classes like \InvalidFindByCall\ and \InvalidMagicMethodCall\, is now located directly under \src/Repository\. Similarly, console tools for managing entity managers, such as \SingleManagerProvider\, \ConnectionFromManagerProvider\, and the associated \UnknownManagerException\, are now grouped under \src/Tools/Console/EntityManagerProvider\. This change simplifies the namespace structure for these core components without altering their functional behavior.

src/Repository, src/Tools/Console/EntityManagerProvider · high confidence

The internal hydration components in src/Internal/Hydration have been reorganized into a flattened directory structure and refactored to use modern PHP features. The AbstractHydrator base class now provides a unified toIterable() method for row-by-row processing and uses native lazy objects for partial object hydration. Specific hydrators have been updated: ObjectHydrator now handles int-backed enums stored as strings in MySQL ENUM columns, ArrayHydrator produces nested array graphs for read-only access, ScalarColumnHydrator optimizes hydrateAllData() performance, and SimpleObjectHydrator supports nested DTOs with named arguments. HydrationException has been consolidated to provide specific error messages for discriminator issues and partial object restrictions.

src/Internal/Hydration · medium confidence

The ORM now supports PHP 8.4 native lazy objects, enabled by default via the new \isNativeLazyObjectsEnabled()\ configuration flag. When enabled, the \EntityManager\ instantiates a \ProxyFactory\ without file-based proxy directories or auto-generation strategies, which are now deprecated for PHP 8.4+ and will be removed in ORM 4.0. This change shifts the lazy-loading mechanism from generated proxy classes to native PHP lazy ghost objects, improving performance and reducing filesystem dependencies for compatible environments.

src · high confidence

The logic for grouping entities into batched INSERT operations has been extracted from the UnitOfWork into a new, dedicated \InsertBatch\ class. This change ensures that batching is only performed for entities using an \AssignedGenerator\ (where identifiers are already known), while entities requiring ID generation or fetching are kept as single-item batches to maintain safety. This refactoring isolates performance-sensitive code and clarifies the conditions under which batch inserts are applied.

src/Internal/UnitOfWork · high confidence

This change introduces a comprehensive restructuring of the mapping and event systems, preparing the ORM for version 4.0. It replaces the legacy array-based mapping with a new object-oriented mapping model, introducing dedicated classes for associations (e.g., AssociationMapping, OneToOneOwningSideMapping) and fields (e.g., Column, JoinColumnMapping). The event system is refactored to use new, specific event argument classes (e.g., PreUpdateEventArgs, LoadClassMetadataEventArgs) and a new ListenersInvoker to manage lifecycle callbacks and entity listeners. Additionally, array access on mapping objects is deprecated in favor of direct property access, and the reflection-based field access is replaced by a new PropertyAccessor system to improve performance and compatibility with PHP 8.4 Lazy Objects.

src/Mapping · high confidence

Doctrine ORM now uses a new \PropertyAccessor\ interface and factory to handle property access, replacing previous reflection-based approaches. This change introduces specific accessor implementations: \EmbeddablePropertyAccessor\ for embedded objects, \EnumPropertyAccessor\ for backed enums, \TypedNoDefaultPropertyAccessor\ for non-nullable typed properties, and \ReadonlyAccessor\ for readonly properties. It also adds \ObjectCastPropertyAccessor\ for general use and \RawValuePropertyAccessor\ for PHP 8.4+ to support lazy objects and property hooks without triggering initialization or hooks unnecessarily. This refactoring centralizes edge-case handling for reflection and improves compatibility with PHP 8.4 features.

src/Mapping/PropertyAccessors · high confidence

The \src/Query\ directory has been restructured, introducing new internal classes such as \Expr\, \Lexer\, \Parser\, \Parameter\, \ParameterTypeInferer\, \FilterCollection\, and \SQLFilter\ to handle DQL parsing, expression building, and SQL filter management. The \Parser\ class now explicitly deprecates \setCustomOutputTreeWalker()\ in favor of the new \OutputWalker\ interface and \SqlFinalizer\ pattern, which separates SQL generation from \firstResult\/\maxResult\ handling to improve query caching. Additionally, the \ParserResult\ class deprecates direct \SqlExecutor\ usage, requiring users to provide a \SqlFinalizer\ instead, and the \SQLFilter\ implementation has been updated to use a dedicated \Parameter\ class for better type safety and state management.

src/Query · high confidence

The DQL AST function implementations in src/Query/AST/Functions have been rewritten to use the new TokenType class for lexer matching instead of raw string constants, and to implement the ExpressionWithReturnType interface (while deprecating the old TypedExpression interface) for functions like COUNT and LENGTH to provide explicit return type information. Additionally, the IdentityFunction now explicitly rejects usage on inverse-side associations, and the TrimFunction has been updated to correctly treat '0' as a valid trim character.

src/Query/AST/Functions · high confidence

The ID generation classes in src/Id have been restructured: a new AbstractIdGenerator base class now defines the common interface, and existing generators (AssignedGenerator, BigIntegerIdentityGenerator, IdentityGenerator, SequenceGenerator) have been moved into this flattened directory structure. Additionally, SequenceGenerator now triggers deprecation warnings when its serialize() or unserialize() methods are called, indicating that the class will no longer implement the Serializable interface in the next major version (ORM 4), encouraging users to rely on the new \_\serialize()/\\_unserialize() magic methods instead.

src/Id · high confidence

The console tooling has been restructured to support Symfony Console 8 by introducing a new \ApplicationCompatibility\ trait that abstracts command registration (switching from the deprecated \Application::add()\ to \Application::addCommand()\ where available) and a new \ConsoleRunner\ class that centralizes application creation and command wiring. Additionally, a new \EntityManagerProvider\ interface and \MetadataFilter\ utility have been added to improve how entity metadata is accessed and filtered within CLI commands.

src/Tools/Console · high confidence

The DQL expression classes (such as Andx, Base, Comparison, Composite, From, Func, GroupBy, Join, Literal, Math, OrderBy, Orx, and Select) have been moved from their previous location into the new src/Query/Expr directory. This structural change organizes the codebase by separating expression logic into a dedicated namespace, which may affect existing code that directly instantiates or references these classes by their old fully qualified names.

src/Query/Expr · high confidence

The entity persistence layer has been restructured to improve code organization and inheritance handling. A new \AbstractEntityInheritancePersister\ base class now centralizes logic for discriminator columns and SQL generation for inheritance strategies, utilized by the new \SingleTablePersister\ and \JoinedSubclassPersister\. The \BasicEntityPersister\ has been updated to use a new \CachedPersisterContext\ for managing query state, and its SQL generation now correctly reuses column aliases when SQL filters change, preventing issues with \indexBy\ and ensuring accurate filtering. Additionally, the \EntityPersister\ interface has been updated to support \SortDirection\ for ordering.

src/Persisters/Entity · high confidence

The query execution layer has been restructured to improve cache efficiency and code organization. A new \AbstractSqlExecutor\ base class and \SqlFinalizer\ interface define the execution contract, allowing finalizers to produce cached executor instances. \FinalizedSelectExecutor\ now handles pre-finalized SELECT queries, while \SingleSelectSqlFinalizer\ applies pagination and locking logic. Bulk operations for Class Table Inheritance are now handled by dedicated \MultiTableDeleteExecutor\ and \MultiTableUpdateExecutor\ classes using temporary tables, replacing previous implementations. The legacy \SingleSelectExecutor\ is deprecated and scheduled for removal in version 4.0.

src/Query/Exec · high confidence

The exception classes in the \src/Exception\ directory have been reorganized into a flat directory structure under the \Doctrine\\ORM\\Exception\ namespace. This change introduces a new base interface \ORMException\ and specific marker interfaces such as \ConfigurationException\, \ManagerException\, and \RepositoryException\ to better categorize error types. Several new specific exception classes have been added to provide clearer error reporting for scenarios like configuration issues, entity identity collisions, and invalid hydration modes, while the existing \NotSupported\ exception has been marked as deprecated.

src/Exception · high confidence

The entity cache persister classes have been moved from the root Cache/Persister directory into a new src/Cache/Persister/Entity subdirectory. This change introduces a CachedEntityPersister interface and refactors the concrete persisters (ReadOnly, NonStrictReadWrite, and ReadWrite) to implement it, ensuring that the second-level cache layer correctly implements the EntityPersister contract. Users relying on these classes should update their namespace references to Doctrine\\ORM\\Cache\\Persister\\Entity.

src/Cache/Persister/Entity · high confidence

The Query AST classes have been reorganized into a flat directory structure, with each node (such as SelectStatement, Join, and WhereClause) now residing as an individual file in src/Query/AST. This change introduces the ExpressionWithReturnType interface to replace the deprecated TypedExpression, allowing expressions to specify their DBAL type name as a string for better type safety. Additionally, a new ASTException class provides specific error handling for unsupported double-dispatch operations, and the OrderByClause now includes an includeCollectionOrderByItems flag to control the inclusion of collection-specific ordering.

src/Query/AST · high confidence

The collection persistence logic has been moved from the root \src/Persisters/\ directory into a new \src/Persisters/Collection/\ namespace, introducing a \CollectionPersister\ interface and an \AbstractCollectionPersister\ base class to standardize operations like delete, update, count, and slice. This refactor includes specific implementations for \OneToManyPersister\ and \ManyToManyPersister\, ensuring correct handling of inheritance discriminators during deletion and proper join-table management. Additionally, the codebase now supports Doctrine Collections 2.x (and prepares for 3.x) by adapting to changes in the \Criteria\ API, such as the deprecation of the boolean argument in \Criteria::create()\.

src/Persisters/Collection · high confidence

The schema tool console commands (create, drop, update) have been reorganized into a dedicated \SchemaTool\ subdirectory with a shared abstract base class, improving code structure. Additionally, the \--complete\ option for the \orm:schema-tool:update\ command is now deprecated and acts as a no-op, with a warning displayed to users; it will be removed in version 4.0.

src/Tools/Console/Command/SchemaTool · high confidence

The second-level cache subsystem has been reorganized into a flattened \src/Cache\ directory, introducing new core classes such as \CacheConfiguration\, \CacheFactory\, and \DefaultCache\ to manage regions, persisters, and hydration. This change updates the internal architecture for caching entities and collections, including new interfaces for hydrators and concurrent region locking, while maintaining backward compatibility for cache entry serialization.

src/Cache · high confidence

Added comprehensive test coverage for ORM pagination tools; Added comprehensive test suite for ORM hydration components; Added functional tests for ORM entity mapping and query behaviors; Added functional tests for ORM locking mechanisms; Added functional tests for ORM ticket scenarios; Added functional tests for SQL filter context switching and parameter changes; Added functional tests for SchemaTool across multiple database platforms; Added functional tests for value conversion in entity associations; Added mock classes for performance testing; Added performance benchmarks for hydration and insert operations; Added performance benchmarks for lazy-loading proxy initialization and instantiation; Added performance test infrastructure for EntityManager creation; Added test coverage for ORM Tools components; Added test fixtures for custom DBAL types; Added test for ManyToMany indexBy with inherited ID and filters; Added test for lazy loading proxies with readonly ID properties; Added test mocks for Doctrine DBAL 4.2 and Persistence 4.1 compatibility; Added tests for BasicEntityPersister composite types, SQL generation, and ManyToMany operations; Added tests for DefaultRepositoryFactory; Added tests for ManyToMany indexBy hydration with SQL filters; Added tests for ORM console commands; Added tests for ProxyFactory behavior and edge cases; Added tests for eager loading with indexBy on OneToMany associations; Added tests for hydration with index-by, filters, and inheritance; Added tests for proxy initialization with enum-typed OneToOne relations; Added tests for schema validation of property and enum type mismatches; Added tests for the deprecated proxy autoloader; Added tests for the internal InsertBatch class; Added unit tests for ORM event args and ID generators; Added unit tests for ORM second-level cache components; Added unit tests for cached entity and collection persisters; Expanded test coverage for Doctrine ORM core components; Expanded test coverage for ORM mapping components; Expanded test coverage for ORM performance, inheritance, and utilities; Expanded test model suite for ORM regression testing; Initial test infrastructure and documentation setup; Restructured test infrastructure and added static analysis fixtures.

The project now requires PHP 8.1 and updates its core dependencies to support Doctrine DBAL 3.8.2/4, Doctrine Collections 2.2/3.1, Doctrine Persistence 3.3.1/4, and Symfony components (Console, Cache, Var-Exporter) up to version 8. Development tooling has been upgraded to PHPStan 2.2.14, PHPUnit 10.5/11.5, and Doctrine Coding Standard 14.0, while dropping support for older PHP versions and legacy Doctrine packages like doctrine/cache and doctrine/annotations.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 48 → 73 (+24.7)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 84 → 80 (-4.3)
• Architecture 96 → 99 (+3.4)
• Maturity 64 → 67 (+3.2)
• Readiness 32 → 72 (+40.0)
• Security 50 → 77 (+27.0)
• Domain Modelling 75 → 100 (+25.2)

• Coverage not measured — test suite did not build
• Dimension evaluation failed
• Duplicated block (10 lines × 2) (src/Mapping/Driver/XmlDriver.php)
• Duplicated block (10 lines × 2) (src/Persisters/Entity/BasicEntityPersister.php)
• Duplicated block (11 lines × 2) (src/Mapping/Driver/AttributeDriver.php)
• Duplicated block (11 lines × 2) (src/Mapping/Driver/XmlDriver.php)
• Duplicated block (11 lines × 2) (src/Mapping/Driver/XmlDriver.php)
• Duplicated block (11 lines × 2) (src/Mapping/Driver/XmlDriver.php)
• Duplicated block (11 lines × 3) (src/Mapping/Driver/XmlDriver.php)
• Duplicated block (12 lines × 2) (src/Mapping/ManyToManyOwningSideMapping.php)
• Duplicated block (13 lines × 2) (src/Mapping/Driver/AttributeDriver.php)
• Duplicated block (15 lines × 2) (src/Query/SqlWalker.php)
• Duplicated block (15 lines × 2) (src/UnitOfWork.php)
• Duplicated block (5 lines × 2) (src/Mapping/MappingException.php)
• Duplicated block (5 lines × 2) (src/Persisters/Entity/BasicEntityPersister.php)
• Duplicated block (7 lines × 2) (src/Cache/Persister/Collection/ReadWriteCachedCollectionPersister.php)
• Duplicated block (7 lines × 2) (src/Cache/Persister/Entity/AbstractEntityPersister.php)
• Duplicated block (7 lines × 2) (src/Persisters/Entity/JoinedSubclassPersister.php)
• Duplicated block (7 lines × 2) (src/Query/SqlWalker.php)
• Duplicated block (7 lines × 2) (src/Query/SqlWalker.php)
• …and 40 more

• AbstractHydrator.gatherRowData (cognitive 44) (src/Internal/Hydration/AbstractHydrator.php)
• AbstractHydrator.gatherRowData (cyclomatic 26) (src/Internal/Hydration/AbstractHydrator.php)
• ArrayHydrator.hydrateRowData (cognitive 100) (src/Internal/Hydration/ArrayHydrator.php)
• ArrayHydrator.hydrateRowData (cyclomatic 38) (src/Internal/Hydration/ArrayHydrator.php)
• AttributeDriver.getMethodCallbacks (cognitive 17) (src/Mapping/Driver/AttributeDriver.php)
• AttributeDriver.loadMetadataForClass (cognitive 217) (src/Mapping/Driver/AttributeDriver.php)
• AttributeDriver.loadMetadataForClass (cyclomatic 95) (src/Mapping/Driver/AttributeDriver.php)
• BasicEntityPersister.deleteJoinTableRecords (cognitive 19) (src/Persisters/Entity/BasicEntityPersister.php)
• BasicEntityPersister.expandCriteriaParameters (cognitive 19) (src/Persisters/Entity/BasicEntityPersister.php)
• BasicEntityPersister.getInsertColumnList (cognitive 21) (src/Persisters/Entity/BasicEntityPersister.php)
• BasicEntityPersister.getOrderBySQL (cognitive 25) (src/Persisters/Entity/BasicEntityPersister.php)
• BasicEntityPersister.getSelectColumnsSQL (cognitive 42) (src/Persisters/Entity/BasicEntityPersister.php)
• BasicEntityPersister.getSelectColumnsSQL (cyclomatic 23) (src/Persisters/Entity/BasicEntityPersister.php)
• BasicEntityPersister.getSelectConditionStatementColumnSQL (cognitive 23) (src/Persisters/Entity/BasicEntityPersister.php)
• BasicEntityPersister.getSelectConditionStatementSQL (cognitive 31) (src/Persisters/Entity/BasicEntityPersister.php)
• BasicEntityPersister.getSelectConditionStatementSQL (cyclomatic 17) (src/Persisters/Entity/BasicEntityPersister.php)
• BasicEntityPersister.loadOneToOneEntity (cognitive 26) (src/Persisters/Entity/BasicEntityPersister.php)
• BasicEntityPersister.prepareUpdateData (cognitive 37) (src/Persisters/Entity/BasicEntityPersister.php)
• BasicEntityPersister.prepareUpdateData (cyclomatic 21) (src/Persisters/Entity/BasicEntityPersister.php)
• BasicEntityPersister.updateTable (cognitive 16) (src/Persisters/Entity/BasicEntityPersister.php)
• …and 458 more

• 70 commits — 56 feature/other, 14 fixes

• (repo) — 34 commits
• src/Tools — 9 commits
• (root) — 8 commits
• tests/Tests — 8 commits
• .github/workflows — 3 commits
• docs/en — 3 commits
• src/Configuration.php — 2 commits
• .github/PULL_REQUEST_TEMPLATE — 1 commit
• src/Mapping — 1 commit
• src/UnitOfWork.php — 1 commit

• fix: Fix EAGER collection duplicates with L2 cache
• fix: Fix deprecated is_a() calls (PHP 8.6) (#12594)
• fix: Fix no-op for initializeObject() and isUnitializedObject() when object is not a mapped entity
• fix: Fix type issue
• fix: Merge pull request #12544 from Athorcis/fix/eager-collection-second-level-cache-double-hydrate
• fix: Merge pull request #12548 from ruudk/fix-lock-mode-none-refresh
• fix: Merge pull request #12558 from greg0ire/revert-editor-api
• fix: Merge pull request #12607 from greg0ire/fix-12606
• fix: Merge pull request #12612 from alireza-aminzadeh/bugfix/GH-12609-sti-conflicting-join-column
• fix: Merge pull request #12617 from SherinBloemendaal/fix-initialize-object-for-native-lazy-objects-no-op
• fix: Merge pull request #12620 from mvanhorn/fix/5593-preserve-fulltext-index-with-unique-constraint
• fix: Revert usage of the editor API
• fix: [GH-12403] Fix stale original-data tracking for native lazy objects
• fix: fix: preserve fulltext indexes alongside unique constraints
• change: Add OffsetPaginator and align CursorPaginator on an immutable page API
• change: Allow configuring foreign key names
• change: Allow using the DBAL editor API internally
• change: Avoid creating duplicate index for conflicting STI associations
• change: Check useDbalEditorApi once in getSchemaFromMedata()
• change: Deprecate JoinColumns
• …and 50 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

doctrine/orm was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.