Update branch metadata (#11663)

2.20.0 just got released

.doctrine-project.json

@@ -11,29 +11,53 @@
             "slug": "latest",
             "upcoming": true
         },
+        {
+            "name": "3.3",
+            "branchName": "3.3.x",
+            "slug": "3.3",
+            "upcoming": true
+        },
+        {
+            "name": "3.2",
+            "branchName": "3.2.x",
+            "slug": "3.2",
+            "current": true
+        },
         {
             "name": "3.1",
             "branchName": "3.1.x",
             "slug": "3.1",
-            "upcoming": true
+            "maintained": false
         },
         {
             "name": "3.0",
             "branchName": "3.0.x",
             "slug": "3.0",
-            "current": true
+            "maintained": false
+        },
+        {
+            "name": "2.21",
+            "branchName": "2.21.x",
+            "slug": "2.21",
+            "upcoming": true
+        },
+        {
+            "name": "2.20",
+            "branchName": "2.20.x",
+            "slug": "2.20",
+            "maintained": true
         },
         {
             "name": "2.19",
             "branchName": "2.19.x",
             "slug": "2.19",
-            "upcoming": true
+            "maintained": false
         },
         {
             "name": "2.18",
             "branchName": "2.18.x",
             "slug": "2.18",
-            "maintained": true
+            "maintained": false
         },
         {
             "name": "2.17",
@@ -82,42 +106,6 @@
             "branchName": "2.10.x",
             "slug": "2.10",
             "maintained": false
-        },
-        {
-            "name": "2.9",
-            "branchName": "2.9.x",
-            "slug": "2.9",
-            "maintained": false
-        },
-        {
-            "name": "2.8",
-            "branchName": "2.8.x",
-            "slug": "2.8",
-            "maintained": false
-        },
-        {
-            "name": "2.7",
-            "branchName": "2.7",
-            "slug": "2.7",
-            "maintained": false
-        },
-        {
-            "name": "2.6",
-            "branchName": "2.6",
-            "slug": "2.6",
-            "maintained": false
-        },
-        {
-            "name": "2.5",
-            "branchName": "2.5",
-            "slug": "2.5",
-            "maintained": false
-        },
-        {
-            "name": "2.4",
-            "branchName": "2.4",
-            "slug": "2.4",
-            "maintained": false
         }
     ]
 }

.github/dependabot.yml

@@ -0,0 +1,9 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    labels:
+      - "CI"
+    target-branch: "2.19.x"

.github/workflows/coding-standards.yml

@@ -24,4 +24,4 @@ on:
 
 jobs:
   coding-standards:
-    uses: "doctrine/.github/.github/workflows/coding-standards.yml@3.0.0"
+    uses: "doctrine/.github/.github/workflows/coding-standards.yml@5.1.0"

.github/workflows/continuous-integration.yml

@@ -75,7 +75,7 @@ jobs:
         if: "${{ matrix.dbal-version != 'default' }}"
 
       - name: "Install dependencies with Composer"
-        uses: "ramsey/composer-install@v2"
+        uses: "ramsey/composer-install@v3"
         with:
           composer-options: "--ignore-platform-req=php+"
           dependency-versions: "${{ matrix.deps }}"
@@ -156,7 +156,7 @@ jobs:
         if: "${{ matrix.dbal-version != 'default' }}"
 
       - name: "Install dependencies with Composer"
-        uses: "ramsey/composer-install@v2"
+        uses: "ramsey/composer-install@v3"
         with:
           composer-options: "--ignore-platform-req=php+"
 
@@ -185,7 +185,7 @@ jobs:
           - "3.7"
           - "4@dev"
         mariadb-version:
-          - "10.9"
+          - "11.4"
         extension:
           - "mysqli"
           - "pdo_mysql"
@@ -194,11 +194,11 @@ jobs:
       mariadb:
         image: "mariadb:${{ matrix.mariadb-version }}"
         env:
-          MYSQL_ALLOW_EMPTY_PASSWORD: yes
-          MYSQL_DATABASE: "doctrine_tests"
+          MARIADB_ALLOW_EMPTY_ROOT_PASSWORD: yes
+          MARIADB_DATABASE: "doctrine_tests"
 
         options: >-
-          --health-cmd "mysqladmin ping --silent"
+          --health-cmd "healthcheck.sh --connect --innodb_initialized"
 
         ports:
           - "3306:3306"
@@ -222,7 +222,7 @@ jobs:
           extensions: "${{ matrix.extension }}"
 
       - name: "Install dependencies with Composer"
-        uses: "ramsey/composer-install@v2"
+        uses: "ramsey/composer-install@v3"
         with:
           composer-options: "--ignore-platform-req=php+"
 
@@ -296,7 +296,7 @@ jobs:
         if: "${{ matrix.dbal-version != 'default' }}"
 
       - name: "Install dependencies with Composer"
-        uses: "ramsey/composer-install@v2"
+        uses: "ramsey/composer-install@v3"
         with:
           composer-options: "--ignore-platform-req=php+"
 
@@ -337,6 +337,8 @@ jobs:
           path: "reports"
 
       - name: "Upload to Codecov"
-        uses: "codecov/codecov-action@v3"
+        uses: "codecov/codecov-action@v4"
         with:
           directory: reports
+        env:
+          CODECOV_TOKEN: "${{ secrets.CODECOV_TOKEN }}"

.github/workflows/documentation.yml

@@ -5,40 +5,16 @@ on:
     branches:
       - "*.x"
     paths:
-      - .github/workflows/documentation.yml
-      - docs/**
+      - ".github/workflows/documentation.yml"
+      - "docs/**"
   push:
     branches:
       - "*.x"
     paths:
-      - .github/workflows/documentation.yml
-      - docs/**
+      - ".github/workflows/documentation.yml"
+      - "docs/**"
 
 jobs:
-  validate-with-guides:
-    name: "Validate documentation with phpDocumentor/guides"
-    runs-on: "ubuntu-22.04"
-
-    steps:
-      - name: "Checkout code"
-        uses: "actions/checkout@v4"
-
-      - name: "Install PHP"
-        uses: "shivammathur/setup-php@v2"
-        with:
-          coverage: "none"
-          php-version: "8.3"
-
-      - name: "Remove existing composer file"
-        run: "rm composer.json"
-
-      - name: "Require phpdocumentor/guides-cli"
-        run: "composer require --dev phpdocumentor/guides-cli --no-update"
-
-      - name: "Install dependencies with Composer"
-        uses: "ramsey/composer-install@v2"
-        with:
-          dependency-versions: "highest"
-
-      - name: "Run guides-cli"
-        run: "vendor/bin/guides -vvv --no-progress docs/en 2>&1 | grep -v 'No template found for rendering directive' | ( ! grep WARNING )"
+  documentation:
+    name: "Documentation"
+    uses: "doctrine/.github/.github/workflows/documentation.yml@5.1.0"

.github/workflows/phpbench.yml

@@ -47,15 +47,8 @@ jobs:
           coverage: "pcov"
           ini-values: "zend.assertions=1, apc.enable_cli=1"
 
-      - name: "Cache dependencies installed with composer"
-        uses: "actions/cache@v3"
-        with:
-          path: "~/.composer/cache"
-          key: "php-${{ matrix.php-version }}-composer-locked-${{ hashFiles('composer.lock') }}"
-          restore-keys: "php-${{ matrix.php-version }}-composer-locked-"
-
-      - name: "Install dependencies with composer"
-        run: "composer update --no-interaction --no-progress"
+      - name: "Install dependencies with Composer"
+        uses: "ramsey/composer-install@v3"
 
       - name: "Run PHPBench"
         run: "vendor/bin/phpbench run --report=default"

.github/workflows/release-on-milestone-closed.yml

@@ -7,7 +7,7 @@ on:
 
 jobs:
   release:
-    uses: "doctrine/.github/.github/workflows/release-on-milestone-closed.yml@4.0.0"
+    uses: "doctrine/.github/.github/workflows/release-on-milestone-closed.yml@5.1.0"
     secrets:
       GIT_AUTHOR_EMAIL: ${{ secrets.GIT_AUTHOR_EMAIL }}
       GIT_AUTHOR_NAME: ${{ secrets.GIT_AUTHOR_NAME }}

.github/workflows/static-analysis.yml

@@ -83,7 +83,7 @@ jobs:
         if: "${{ matrix.dbal-version != 'default' }}"
 
       - name: Install dependencies with Composer
-        uses: ramsey/composer-install@v2
+        uses: ramsey/composer-install@v3
 
       - name: Run static analysis with Vimeo Psalm
         run: vendor/bin/psalm --shepherd

README.md

@@ -1,7 +1,7 @@
-|                      [4.0.x][4.0]                      |                      [3.1.x][3.1]                      |                      [3.0.x][3.0]                       |                      [2.19.x][2.19]                      |                      [2.18.x][2.18]                       |
-|:------------------------------------------------------:|:------------------------------------------------------:|:-------------------------------------------------------:|:--------------------------------------------------------:|:---------------------------------------------------------:|
-|           [![Build status][4.0 image]][4.0]            |           [![Build status][3.1 image]][3.1]            |            [![Build status][3.0 image]][3.0]            |           [![Build status][2.19 image]][2.19]            |            [![Build status][2.18 image]][2.18]            |
-| [![Coverage Status][4.0 coverage image]][4.0 coverage] | [![Coverage Status][3.1 coverage image]][3.1 coverage] | [![Coverage Status][3.0 coverage image]][3.0 coverage]  | [![Coverage Status][2.19 coverage image]][2.19 coverage] | [![Coverage Status][2.18 coverage image]][2.18 coverage]  |
+|                      [4.0.x][4.0]                      |                      [3.3.x][3.3]                      |                      [3.2.x][3.2]                      |                      [2.20.x][2.20]                      |                      [2.19.x][2.19]                      |
+|:------------------------------------------------------:|:------------------------------------------------------:|:------------------------------------------------------:|:--------------------------------------------------------:|:--------------------------------------------------------:|
+|           [![Build status][4.0 image]][4.0]            |           [![Build status][3.3 image]][3.3]            |           [![Build status][3.2 image]][3.2]            |           [![Build status][2.20 image]][2.20]            |           [![Build status][2.19 image]][2.19]            |
+| [![Coverage Status][4.0 coverage image]][4.0 coverage] | [![Coverage Status][3.3 coverage image]][3.3 coverage] | [![Coverage Status][3.2 coverage image]][3.2 coverage] | [![Coverage Status][2.20 coverage image]][2.20 coverage] | [![Coverage Status][2.19 coverage image]][2.19 coverage] |
 
 [<h1 align="center">🇺🇦 UKRAINE NEEDS YOUR HELP NOW!</h1>](https://www.doctrine-project.org/stop-war.html)
 
@@ -22,19 +22,19 @@ without requiring unnecessary code duplication.
   [4.0]: https://github.com/doctrine/orm/tree/4.0.x
   [4.0 coverage image]: https://codecov.io/gh/doctrine/orm/branch/4.0.x/graph/badge.svg
   [4.0 coverage]: https://codecov.io/gh/doctrine/orm/branch/4.0.x
-  [3.1 image]: https://github.com/doctrine/orm/actions/workflows/continuous-integration.yml/badge.svg?branch=3.1.x
-  [3.1]: https://github.com/doctrine/orm/tree/3.1.x
-  [3.1 coverage image]: https://codecov.io/gh/doctrine/orm/branch/3.1.x/graph/badge.svg
-  [3.1 coverage]: https://codecov.io/gh/doctrine/orm/branch/3.1.x
-  [3.0 image]: https://github.com/doctrine/orm/actions/workflows/continuous-integration.yml/badge.svg?branch=3.0.x
-  [3.0]: https://github.com/doctrine/orm/tree/3.0.x
-  [3.0 coverage image]: https://codecov.io/gh/doctrine/orm/branch/3.0.x/graph/badge.svg
-  [3.0 coverage]: https://codecov.io/gh/doctrine/orm/branch/3.0.x
+  [3.3 image]: https://github.com/doctrine/orm/actions/workflows/continuous-integration.yml/badge.svg?branch=3.3.x
+  [3.3]: https://github.com/doctrine/orm/tree/3.3.x
+  [3.3 coverage image]: https://codecov.io/gh/doctrine/orm/branch/3.3.x/graph/badge.svg
+  [3.3 coverage]: https://codecov.io/gh/doctrine/orm/branch/3.3.x
+  [3.2 image]: https://github.com/doctrine/orm/actions/workflows/continuous-integration.yml/badge.svg?branch=3.2.x
+  [3.2]: https://github.com/doctrine/orm/tree/3.2.x
+  [3.2 coverage image]: https://codecov.io/gh/doctrine/orm/branch/3.2.x/graph/badge.svg
+  [3.2 coverage]: https://codecov.io/gh/doctrine/orm/branch/3.2.x
+  [2.20 image]: https://github.com/doctrine/orm/actions/workflows/continuous-integration.yml/badge.svg?branch=2.20.x
+  [2.20]: https://github.com/doctrine/orm/tree/2.20.x
+  [2.20 coverage image]: https://codecov.io/gh/doctrine/orm/branch/2.20.x/graph/badge.svg
+  [2.20 coverage]: https://codecov.io/gh/doctrine/orm/branch/2.20.x
   [2.19 image]: https://github.com/doctrine/orm/actions/workflows/continuous-integration.yml/badge.svg?branch=2.19.x
   [2.19]: https://github.com/doctrine/orm/tree/2.19.x
   [2.19 coverage image]: https://codecov.io/gh/doctrine/orm/branch/2.19.x/graph/badge.svg
   [2.19 coverage]: https://codecov.io/gh/doctrine/orm/branch/2.19.x
-  [2.18 image]: https://github.com/doctrine/orm/actions/workflows/continuous-integration.yml/badge.svg?branch=2.18.x
-  [2.18]: https://github.com/doctrine/orm/tree/2.18.x
-  [2.18 coverage image]: https://codecov.io/gh/doctrine/orm/branch/2.18.x/graph/badge.svg
-  [2.18 coverage]: https://codecov.io/gh/doctrine/orm/branch/2.18.x

UPGRADE.md

@@ -1,3 +1,52 @@
+# Upgrade to 3.2
+
+## Deprecate the `NotSupported` exception
+
+The class `Doctrine\ORM\Exception\NotSupported` is deprecated without replacement.
+
+## Deprecate remaining `Serializable` implementation
+
+Relying on `SequenceGenerator` implementing the `Serializable` is deprecated
+because that interface won't be implemented in ORM 4 anymore.
+
+The following methods are deprecated:
+
+* `SequenceGenerator::serialize()`
+* `SequenceGenerator::unserialize()`
+
+## `orm:schema-tool:update` option `--complete` is deprecated
+
+That option behaves as a no-op, and is deprecated. It will be removed in 4.0.
+
+## Deprecate properties `$indexes` and `$uniqueConstraints` of `Doctrine\ORM\Mapping\Table`
+
+The properties `$indexes` and `$uniqueConstraints` have been deprecated since they had no effect at all.
+The preferred way of defining indices and unique constraints is by
+using the `\Doctrine\ORM\Mapping\UniqueConstraint` and `\Doctrine\ORM\Mapping\Index` attributes.
+
+# Upgrade to 3.1
+
+## Deprecate `Doctrine\ORM\Mapping\ReflectionEnumProperty`
+
+This class is deprecated and will be removed in 4.0.
+Instead, use `Doctrine\Persistence\Reflection\EnumReflectionProperty` from
+`doctrine/persistence`.
+
+## Deprecate passing null to `ClassMetadata::fullyQualifiedClassName()`
+
+Passing `null` to `Doctrine\ORM\ClassMetadata::fullyQualifiedClassName()` is
+deprecated and will no longer be possible in 4.0.
+
+## Deprecate array access
+
+Using array access on instances of the following classes is deprecated:
+
+- `Doctrine\ORM\Mapping\DiscriminatorColumnMapping`
+- `Doctrine\ORM\Mapping\EmbedClassMapping`
+- `Doctrine\ORM\Mapping\FieldMapping`
+- `Doctrine\ORM\Mapping\JoinColumnMapping`
+- `Doctrine\ORM\Mapping\JoinTableMapping`
+
 # Upgrade to 3.0
 
 ## BC BREAK: Calling `ClassMetadata::getAssociationMappedByTargetField()` with the owning side of an association now throws an exception
@@ -674,6 +723,23 @@ following classes and methods:
 
 Use `toIterable()` instead.
 
+# Upgrade to 2.19
+
+## Deprecate calling `ClassMetadata::getAssociationMappedByTargetField()` with the owning side of an association
+
+Calling
+`Doctrine\ORM\Mapping\ClassMetadata::getAssociationMappedByTargetField()` with
+the owning side of an association returns `null`, which is undocumented, and
+wrong according to the phpdoc of the parent method.
+
+If you do not know whether you are on the owning or inverse side of an association,
+you can use  `Doctrine\ORM\Mapping\ClassMetadata::isAssociationInverseSide()`
+to find out.
+
+## Deprecate `Doctrine\ORM\Query\Lexer::T_*` constants
+
+Use `Doctrine\ORM\Query\TokenType::T_*` instead.
+
 # Upgrade to 2.17
 
 ## Deprecate annotations classes for named queries

composer.json

@@ -23,27 +23,28 @@
         "php": "^8.1",
         "composer-runtime-api": "^2",
         "ext-ctype": "*",
-        "doctrine/collections": "^2.1",
+        "doctrine/collections": "^2.2",
         "doctrine/dbal": "^3.8.2 || ^4",
         "doctrine/deprecations": "^0.5.3 || ^1",
         "doctrine/event-manager": "^1.2 || ^2",
         "doctrine/inflector": "^1.4 || ^2.0",
         "doctrine/instantiator": "^1.3 || ^2",
         "doctrine/lexer": "^3",
-        "doctrine/persistence": "^3.1.1",
+        "doctrine/persistence": "^3.3.1",
         "psr/cache": "^1 || ^2 || ^3",
         "symfony/console": "^5.4 || ^6.0 || ^7.0",
-        "symfony/var-exporter": "~6.2.13 || ^6.3.2 || ^7.0"
+        "symfony/var-exporter": "^6.3.9 || ^7.0"
     },
     "require-dev": {
         "doctrine/coding-standard": "^12.0",
         "phpbench/phpbench": "^1.0",
-        "phpstan/phpstan": "1.10.59",
+        "phpdocumentor/guides-cli": "^1.4",
+        "phpstan/phpstan": "1.12.6",
         "phpunit/phpunit": "^10.4.0",
         "psr/log": "^1 || ^2 || ^3",
         "squizlabs/php_codesniffer": "3.7.2",
         "symfony/cache": "^5.4 || ^6.2 || ^7.0",
-        "vimeo/psalm": "5.22.2"
+        "vimeo/psalm": "5.24.0"
     },
     "suggest": {
         "ext-dom": "Provides support for XSD validation for XML mapping files",

docs/.gitignore

@@ -1,4 +0,0 @@
-en/_exts/configurationblock.pyc
-build
-en/_build
-.idea

docs/.gitmodules

@@ -1,3 +0,0 @@
-[submodule "en/_theme"]
-	path = en/_theme
-	url = https://github.com/doctrine/doctrine-sphinx-theme.git

docs/en/cookbook/dql-user-defined-functions.rst

@@ -232,6 +232,33 @@ vendors SQL parser to show us further errors in the parsing
 process, for example if the Unit would not be one of the supported
 values by MySql.
 
+Typed functions
+---------------
+By default, result of custom functions is fetched as-is from the database driver.
+If you want to be sure that the type is always the same, then your custom function needs to 
+implement ``Doctrine\ORM\Query\AST\TypedExpression``. Then, the result is wired
+through ``Doctrine\DBAL\Types\Type::convertToPhpValue()`` of the ``Type`` returned in ``getReturnType()``.
+
+.. code-block:: php
+
+    <?php
+
+    use Doctrine\DBAL\Types\Type;
+    use Doctrine\DBAL\Types\Types;
+    use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+    use Doctrine\ORM\Query\AST\TypedExpression;
+
+    class DateDiff extends FunctionNode implements TypedExpression
+    {
+        // ...
+
+        public function getReturnType(): Type
+        {
+            return Type::getType(Types::INTEGER);
+        }
+    }
+
+
 Conclusion
 ----------
 

docs/en/cookbook/validation-of-entities.rst

@@ -11,7 +11,7 @@ What we offer are hooks to execute any kind of validation.
 .. note::
 
     You don't need to validate your entities in the lifecycle
-    events. Its only one of many options. Of course you can also
+    events. It is only one of many options. Of course you can also
     perform validations in value setters or any other method of your
     entities that are used in your code.
 

docs/en/reference/architecture.rst

@@ -18,7 +18,7 @@ well.
 Requirements
 ------------
 
-Doctrine ORM requires a minimum of PHP 7.1. For greatly improved
+Doctrine ORM requires a minimum of PHP 8.1. For greatly improved
 performance it is also recommended that you use APC with PHP.
 
 Doctrine ORM Packages

docs/en/reference/association-mapping.rst

@@ -870,8 +870,8 @@ This is essentially the same as the following, more verbose, mapping:
              * @var Collection<int, Group>
              */
             #[JoinTable(name: 'User_Group')]
-            #[JoinColumn(name: 'User_id', referencedColumnName: 'id')]
-            #[InverseJoinColumn(name: 'Group_id', referencedColumnName: 'id')]
+            #[JoinColumn(name: 'user_id', referencedColumnName: 'id')]
+            #[InverseJoinColumn(name: 'group_id', referencedColumnName: 'id')]
             #[ManyToMany(targetEntity: Group::class)]
             private Collection $groups;
             // ...
@@ -884,10 +884,10 @@ This is essentially the same as the following, more verbose, mapping:
                 <many-to-many field="groups" target-entity="Group">
                     <join-table name="User_Group">
                         <join-columns>
-                            <join-column id="User_id" referenced-column-name="id" />
+                            <join-column id="user_id" referenced-column-name="id" />
                         </join-columns>
                         <inverse-join-columns>
-                            <join-column id="Group_id" referenced-column-name="id" />
+                            <join-column id="group_id" referenced-column-name="id" />
                         </inverse-join-columns>
                     </join-table>
                 </many-to-many>

docs/en/reference/attributes-reference.rst

@@ -15,7 +15,7 @@ Index
 -  :ref:`#[AttributeOverride] <attrref_attributeoverride>`
 -  :ref:`#[Column] <attrref_column>`
 -  :ref:`#[Cache] <attrref_cache>`
--  :ref:`#[ChangeTrackingPolicy <attrref_changetrackingpolicy>`
+-  :ref:`#[ChangeTrackingPolicy] <attrref_changetrackingpolicy>`
 -  :ref:`#[CustomIdGenerator] <attrref_customidgenerator>`
 -  :ref:`#[DiscriminatorColumn] <attrref_discriminatorcolumn>`
 -  :ref:`#[DiscriminatorMap] <attrref_discriminatormap>`

docs/en/reference/basic-mapping.rst

@@ -228,50 +228,12 @@ and a custom ``Doctrine\ORM\Mapping\TypedFieldMapper`` implementation.
 Doctrine Mapping Types
 ----------------------
 
-The ``type`` option used in the ``@Column`` accepts any of the existing
-Doctrine types or even your own custom types. A Doctrine type defines
+The ``type`` option used in the ``@Column`` accepts any of the
+`existing Doctrine DBAL types <https://docs.doctrine-project.org/projects/doctrine-dbal/en/stable/reference/types.html#reference>`_
+or :doc:`your own custom mapping types
+<../cookbook/custom-mapping-types>`. A Doctrine type defines
 the conversion between PHP and SQL types, independent from the database vendor
-you are using. All Mapping Types that ship with Doctrine are fully portable
-between the supported database systems.
-
-As an example, the Doctrine Mapping Type ``string`` defines the
-mapping from a PHP string to a SQL VARCHAR (or VARCHAR2 etc.
-depending on the RDBMS brand). Here is a quick overview of the
-built-in mapping types:
-
--  ``string``: Type that maps a SQL VARCHAR to a PHP string.
--  ``integer``: Type that maps a SQL INT to a PHP integer.
--  ``smallint``: Type that maps a database SMALLINT to a PHP
-   integer.
--  ``bigint``: Type that maps a database BIGINT to a PHP string.
--  ``boolean``: Type that maps a SQL boolean or equivalent (TINYINT) to a PHP boolean.
--  ``decimal``: Type that maps a SQL DECIMAL to a PHP string.
--  ``date``: Type that maps a SQL DATETIME to a PHP DateTime
-   object.
--  ``time``: Type that maps a SQL TIME to a PHP DateTime object.
--  ``datetime``: Type that maps a SQL DATETIME/TIMESTAMP to a PHP
-   DateTime object.
--  ``datetimetz``: Type that maps a SQL DATETIME/TIMESTAMP to a PHP
-   DateTime object with timezone.
--  ``text``: Type that maps a SQL CLOB to a PHP string.
--  ``object``: Type that maps a SQL CLOB to a PHP object using
-   ``serialize()`` and ``unserialize()``
--  ``array``: Type that maps a SQL CLOB to a PHP array using
-   ``serialize()`` and ``unserialize()``
--  ``simple_array``: Type that maps a SQL CLOB to a PHP array using
-   ``implode()`` and ``explode()``, with a comma as delimiter. *IMPORTANT*
-   Only use this type if you are sure that your values cannot contain a ",".
--  ``json_array``: Type that maps a SQL CLOB to a PHP array using
-   ``json_encode()`` and ``json_decode()``
--  ``float``: Type that maps a SQL Float (Double Precision) to a
-   PHP double. *IMPORTANT*: Works only with locale settings that use
-   decimal points as separator.
--  ``guid``: Type that maps a database GUID/UUID to a PHP string. Defaults to
-   varchar but uses a specific type if the platform supports it.
--  ``blob``: Type that maps a SQL BLOB to a PHP resource stream
-
-A cookbook article shows how to define :doc:`your own custom mapping types
-<../cookbook/custom-mapping-types>`.
+you are using.
 
 .. note::
 

docs/en/reference/dql-doctrine-query-language.rst

@@ -976,7 +976,7 @@ The Query class
 ---------------
 
 An instance of the ``Doctrine\ORM\Query`` class represents a DQL
-query. You create a Query instance be calling
+query. You create a Query instance by calling
 ``EntityManager#createQuery($dql)``, passing the DQL query string.
 Alternatively you can create an empty ``Query`` instance and invoke
 ``Query#setDQL($dql)`` afterwards. Here are some examples:
@@ -993,58 +993,146 @@ Alternatively you can create an empty ``Query`` instance and invoke
     $q = $em->createQuery();
     $q->setDQL('select u from MyProject\Model\User u');
 
-Query Result Formats
-~~~~~~~~~~~~~~~~~~~~
+Query Result Formats (Hydration Modes)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-The format in which the result of a DQL SELECT query is returned
-can be influenced by a so-called ``hydration mode``. A hydration
-mode specifies a particular way in which a SQL result set is
-transformed. Each hydration mode has its own dedicated method on
-the Query class. Here they are:
+The way in which the SQL result set of a DQL SELECT query is transformed
+to PHP is determined by the so-called "hydration mode".
 
+``getResult()``
+^^^^^^^^^^^^^^^
 
--  ``Query#getResult()``: Retrieves a collection of objects. The
-   result is either a plain collection of objects (pure) or an array
-   where the objects are nested in the result rows (mixed).
--  ``Query#getSingleResult()``: Retrieves a single object. If the
-   result contains more than one object, an ``NonUniqueResultException``
-   is thrown. If the result contains no objects, an ``NoResultException``
-   is thrown. The pure/mixed distinction does not apply.
--  ``Query#getOneOrNullResult()``: Retrieve a single object. If the
-   result contains more than one object, a ``NonUniqueResultException``
-   is thrown. If no object is found null will be returned.
--  ``Query#getArrayResult()``: Retrieves an array graph (a nested
-   array) that is largely interchangeable with the object graph
-   generated by ``Query#getResult()`` for read-only purposes.
+Retrieves a collection of objects. The result is either a plain collection of objects (pure) or an array
+where the objects are nested in the result rows (mixed):
 
-    .. note::
+.. code-block:: php
 
-        An array graph can differ from the corresponding object
-        graph in certain scenarios due to the difference of the identity
-        semantics between arrays and objects.
+    <?php
+    use Doctrine\ORM\AbstractQuery;
 
+    $query = $em->createQuery('SELECT u FROM User u');
+    $users = $query->getResult();
+    // same as:
+    $users = $query->getResult(AbstractQuery::HYDRATE_OBJECT);
 
+- Objects fetched in a FROM clause are returned as a Set, that means every
+  object is only ever included in the resulting array once. This is the case
+  even when using JOIN or GROUP BY in ways that return the same row for an
+  object multiple times. If the hydrator sees the same object multiple times,
+  then it makes sure it is only returned once.
 
--  ``Query#getScalarResult()``: Retrieves a flat/rectangular result
-   set of scalar values that can contain duplicate data. The
-   pure/mixed distinction does not apply.
--  ``Query#getSingleScalarResult()``: Retrieves a single scalar
-   value from the result returned by the dbms. If the result contains
-   more than a single scalar value, an exception is thrown. The
-   pure/mixed distinction does not apply.
+- If an object is already in memory from a previous query of any kind, then
+  then the previous object is used, even if the database may contain more
+  recent data. This even happens if the previous object is still an unloaded proxy.
 
-Instead of using these methods, you can alternatively use the
-general-purpose method
-``Query#execute(array $params = [], $hydrationMode = Query::HYDRATE_OBJECT)``.
-Using this method you can directly supply the hydration mode as the
-second parameter via one of the Query constants. In fact, the
-methods mentioned earlier are just convenient shortcuts for the
-execute method. For example, the method ``Query#getResult()``
-internally invokes execute, passing in ``Query::HYDRATE_OBJECT`` as
-the hydration mode.
+``getArrayResult()``
+^^^^^^^^^^^^^^^^^^^^
 
-The use of the methods mentioned earlier is generally preferred as
-it leads to more concise code.
+Retrieves an array graph (a nested array) for read-only purposes.
+
+.. note::
+
+    An array graph can differ from the corresponding object
+    graph in certain scenarios due to the difference of the identity
+    semantics between arrays and objects.
+
+.. code-block:: php
+
+    <?php
+    $users = $query->getArrayResult();
+    // same as:
+    $users = $query->getResult(AbstractQuery::HYDRATE_ARRAY);
+
+``getScalarResult()``
+^^^^^^^^^^^^^^^^^^^^^
+
+Retrieves a flat/rectangular result set of scalar values that can contain duplicate data. The
+pure/mixed distinction does not apply.
+
+.. code-block:: php
+
+    <?php
+    $users = $query->getScalarResult();
+    // same as:
+    $users = $query->getResult(AbstractQuery::HYDRATE_SCALAR);
+
+Fields from classes are prefixed by the DQL alias in the result.
+A query of the kind `SELECT u.name ...` returns a key `u_name` in the result rows.
+
+``getSingleScalarResult()``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Retrieves a single scalar value from the result returned by the database. If the result contains
+more than a single scalar value, a ``NonUniqueResultException`` is thrown. The pure/mixed distinction does not apply.
+
+.. code-block:: php
+
+    <?php
+    $query = $em->createQuery('SELECT COUNT(u.id) FROM User u');
+    $numUsers = $query->getSingleScalarResult();
+    // same as:
+    $numUsers = $query->getResult(AbstractQuery::HYDRATE_SINGLE_SCALAR);
+
+``getSingleColumnResult()``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Retrieves an array from a one-dimensional array of scalar values:
+
+.. code-block:: php
+
+    <?php
+    $query = $em->createQuery('SELECT a.id FROM User u');
+    $ids = $query->getSingleColumnResult();
+    // same as:
+    $ids = $query->getResult(AbstractQuery::HYDRATE_SCALAR_COLUMN);
+
+``getSingleResult()``
+^^^^^^^^^^^^^^^^^^^^^
+
+Retrieves a single object. If the result contains more than one object, a ``NonUniqueResultException``
+is thrown. If the result contains no objects, a ``NoResultException`` is thrown. The pure/mixed distinction does not apply.
+
+``getOneOrNullResult()``
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+Retrieves a single object. If the result contains more than one object, a ``NonUniqueResultException``
+is thrown. If no object is found, ``null`` will be returned.
+
+Custom Hydration Modes
+^^^^^^^^^^^^^^^^^^^^^^
+
+You can easily add your own custom hydration modes by first
+creating a class which extends ``AbstractHydrator``:
+
+.. code-block:: php
+
+    <?php
+    namespace MyProject\Hydrators;
+
+    use Doctrine\ORM\Internal\Hydration\AbstractHydrator;
+
+    class CustomHydrator extends AbstractHydrator
+    {
+        protected function _hydrateAll()
+        {
+            return $this->_stmt->fetchAllAssociative();
+        }
+    }
+
+Next you just need to add the class to the ORM configuration:
+
+.. code-block:: php
+
+    <?php
+    $em->getConfiguration()->addCustomHydrationMode('CustomHydrator', 'MyProject\Hydrators\CustomHydrator');
+
+Now the hydrator is ready to be used in your queries:
+
+.. code-block:: php
+
+    <?php
+    $query = $em->createQuery('SELECT u FROM CmsUser u');
+    $results = $query->getResult('CustomHydrator');
 
 Pure and Mixed Results
 ~~~~~~~~~~~~~~~~~~~~~~
@@ -1148,165 +1236,6 @@ will return the rows iterating the different top-level entities.
         [2] => Object (User)
         [3] => Object (Group)
 
-
-Hydration Modes
-~~~~~~~~~~~~~~~
-
-Each of the Hydration Modes makes assumptions about how the result
-is returned to user land. You should know about all the details to
-make best use of the different result formats:
-
-The constants for the different hydration modes are:
-
-
--  ``Query::HYDRATE_OBJECT``
--  ``Query::HYDRATE_ARRAY``
--  ``Query::HYDRATE_SCALAR``
--  ``Query::HYDRATE_SINGLE_SCALAR``
--  ``Query::HYDRATE_SCALAR_COLUMN``
-
-Object Hydration
-^^^^^^^^^^^^^^^^
-
-Object hydration hydrates the result set into the object graph:
-
-.. code-block:: php
-
-    <?php
-    $query = $em->createQuery('SELECT u FROM CmsUser u');
-    $users = $query->getResult(Query::HYDRATE_OBJECT);
-
-Sometimes the behavior in the object hydrator can be confusing, which is
-why we are listing as many of the assumptions here for reference:
-
-- Objects fetched in a FROM clause are returned as a Set, that means every
-  object is only ever included in the resulting array once. This is the case
-  even when using JOIN or GROUP BY in ways that return the same row for an
-  object multiple times. If the hydrator sees the same object multiple times,
-  then it makes sure it is only returned once.
-
-- If an object is already in memory from a previous query of any kind, then
-  then the previous object is used, even if the database may contain more
-  recent data. Data from the database is discarded. This even happens if the
-  previous object is still an unloaded proxy.
-
-This list might be incomplete.
-
-Array Hydration
-^^^^^^^^^^^^^^^
-
-You can run the same query with array hydration and the result set
-is hydrated into an array that represents the object graph:
-
-.. code-block:: php
-
-    <?php
-    $query = $em->createQuery('SELECT u FROM CmsUser u');
-    $users = $query->getResult(Query::HYDRATE_ARRAY);
-
-You can use the ``getArrayResult()`` shortcut as well:
-
-.. code-block:: php
-
-    <?php
-    $users = $query->getArrayResult();
-
-Scalar Hydration
-^^^^^^^^^^^^^^^^
-
-If you want to return a flat rectangular result set instead of an
-object graph you can use scalar hydration:
-
-.. code-block:: php
-
-    <?php
-    $query = $em->createQuery('SELECT u FROM CmsUser u');
-    $users = $query->getResult(Query::HYDRATE_SCALAR);
-    echo $users[0]['u_id'];
-
-The following assumptions are made about selected fields using
-Scalar Hydration:
-
-
-1. Fields from classes are prefixed by the DQL alias in the result.
-   A query of the kind 'SELECT u.name ..' returns a key 'u_name' in
-   the result rows.
-
-Single Scalar Hydration
-^^^^^^^^^^^^^^^^^^^^^^^
-
-If you have a query which returns just a single scalar value you can use
-single scalar hydration:
-
-.. code-block:: php
-
-    <?php
-    $query = $em->createQuery('SELECT COUNT(a.id) FROM CmsUser u LEFT JOIN u.articles a WHERE u.username = ?1 GROUP BY u.id');
-    $query->setParameter(1, 'jwage');
-    $numArticles = $query->getResult(Query::HYDRATE_SINGLE_SCALAR);
-
-You can use the ``getSingleScalarResult()`` shortcut as well:
-
-.. code-block:: php
-
-    <?php
-    $numArticles = $query->getSingleScalarResult();
-
-Scalar Column Hydration
-^^^^^^^^^^^^^^^^^^^^^^^
-
-If you have a query which returns a one-dimensional array of scalar values
-you can use scalar column hydration:
-
-.. code-block:: php
-
-    <?php
-    $query = $em->createQuery('SELECT a.id FROM CmsUser u');
-    $ids = $query->getResult(Query::HYDRATE_SCALAR_COLUMN);
-
-You can use the ``getSingleColumnResult()`` shortcut as well:
-
-.. code-block:: php
-
-    <?php
-    $ids = $query->getSingleColumnResult();
-
-Custom Hydration Modes
-^^^^^^^^^^^^^^^^^^^^^^
-
-You can easily add your own custom hydration modes by first
-creating a class which extends ``AbstractHydrator``:
-
-.. code-block:: php
-
-    <?php
-    namespace MyProject\Hydrators;
-
-    use Doctrine\ORM\Internal\Hydration\AbstractHydrator;
-
-    class CustomHydrator extends AbstractHydrator
-    {
-        protected function _hydrateAll()
-        {
-            return $this->_stmt->fetchAllAssociative();
-        }
-    }
-
-Next you just need to add the class to the ORM configuration:
-
-.. code-block:: php
-
-    <?php
-    $em->getConfiguration()->addCustomHydrationMode('CustomHydrator', 'MyProject\Hydrators\CustomHydrator');
-
-Now the hydrator is ready to be used in your queries:
-
-.. code-block:: php
-
-    <?php
-    $query = $em->createQuery('SELECT u FROM CmsUser u');
-    $results = $query->getResult('CustomHydrator');
-
 Iterating Large Result Sets
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

docs/en/reference/transactions-and-concurrency.rst

@@ -88,7 +88,7 @@ requirement.
 
 A more convenient alternative for explicit transaction demarcation is the use
 of provided control abstractions in the form of
-``Connection#transactional($func)`` and ``EntityManager#transactional($func)``.
+``Connection#transactional($func)`` and ``EntityManager#wrapInTransaction($func)``.
 When used, these control abstractions ensure that you never forget to rollback
 the transaction, in addition to the obvious code reduction. An example that is
 functionally equivalent to the previously shown code looks as follows:
@@ -96,21 +96,23 @@ functionally equivalent to the previously shown code looks as follows:
 .. code-block:: php
 
     <?php
+    // transactional with Connection instance
+    // $conn instanceof Connection
+    $conn->transactional(function($conn) {
+        // ... do some work
+        $user = new User;
+        $user->setName('George');
+    });
+
+    // transactional with EntityManager instance
     // $em instanceof EntityManager
-    $em->transactional(function($em) {
+    $em->wrapInTransaction(function($em) {
         // ... do some work
         $user = new User;
         $user->setName('George');
         $em->persist($user);
     });
 
-.. warning::
-
-    For historical reasons, ``EntityManager#transactional($func)`` will return
-    ``true`` whenever the return value of ``$func`` is loosely false.
-    Some examples of this include ``array()``, ``"0"``, ``""``, ``0``, and
-    ``null``.
-
 The difference between ``Connection#transactional($func)`` and
 ``EntityManager#transactional($func)`` is that the latter
 abstraction flushes the ``EntityManager`` prior to transaction

docs/en/reference/working-with-objects.rst

@@ -338,10 +338,11 @@ Performance of different deletion strategies
 Deleting an object with all its associated objects can be achieved
 in multiple ways with very different performance impacts.
 
-1. If an association is marked as ``CASCADE=REMOVE`` Doctrine ORM
-   will fetch this association. If its a Single association it will
-   pass this entity to
-   ``EntityManager#remove()``. If the association is a collection, Doctrine will loop over all    its elements and pass them to``EntityManager#remove()``.
+1. If an association is marked as ``CASCADE=REMOVE`` Doctrine ORM will
+   fetch this association. If it's a Single association it will pass
+   this entity to ``EntityManager#remove()``. If the association is a
+   collection, Doctrine will loop over all its elements and pass them to
+   ``EntityManager#remove()``.
    In both cases the cascade remove semantics are applied recursively.
    For large object graphs this removal strategy can be very costly.
 2. Using a DQL ``DELETE`` statement allows you to delete multiple

docs/en/sidebar.rst

@@ -1,82 +1,73 @@
 :orphan:
 
-.. toc::
+.. toctree::
+   :caption: Tutorials
+   :depth: 3
 
-   .. tocheader:: Tutorials
+   tutorials/getting-started
+   tutorials/getting-started-database
+   tutorials/getting-started-models
+   tutorials/working-with-indexed-associations
+   tutorials/extra-lazy-associations
+   tutorials/composite-primary-keys
+   tutorials/ordered-associations
+   tutorials/override-field-association-mappings-in-subclasses
+   tutorials/pagination
+   tutorials/embeddables
 
-   .. toctree::
-      :depth: 3
+.. toctree::
+   :caption: Reference
+   :depth: 3
 
-      tutorials/getting-started
-      tutorials/getting-started-database
-      tutorials/getting-started-models
-      tutorials/working-with-indexed-associations
-      tutorials/extra-lazy-associations
-      tutorials/composite-primary-keys
-      tutorials/ordered-associations
-      tutorials/override-field-association-mappings-in-subclasses
-      tutorials/pagination
-      tutorials/embeddables
+   reference/architecture
+   reference/configuration
+   reference/faq
+   reference/basic-mapping
+   reference/association-mapping
+   reference/inheritance-mapping
+   reference/working-with-objects
+   reference/working-with-associations
+   reference/typedfieldmapper
+   reference/events
+   reference/unitofwork
+   reference/unitofwork-associations
+   reference/transactions-and-concurrency
+   reference/batch-processing
+   reference/dql-doctrine-query-language
+   reference/query-builder
+   reference/native-sql
+   reference/change-tracking-policies
+   reference/attributes-reference
+   reference/xml-mapping
+   reference/php-mapping
+   reference/caching
+   reference/improving-performance
+   reference/tools
+   reference/metadata-drivers
+   reference/best-practices
+   reference/limitations-and-known-issues
+   tutorials/pagination
+   reference/filters
+   reference/namingstrategy
+   reference/advanced-configuration
+   reference/second-level-cache
+   reference/security
 
-.. toc::
+.. toctree::
+   :caption: Cookbook
+   :depth: 3
 
-   .. tocheader:: Reference
-
-   .. toctree::
-      :depth: 3
-
-      reference/architecture
-      reference/configuration
-      reference/faq
-      reference/basic-mapping
-      reference/association-mapping
-      reference/inheritance-mapping
-      reference/working-with-objects
-      reference/working-with-associations
-      reference/typedfieldmapper
-      reference/events
-      reference/unitofwork
-      reference/unitofwork-associations
-      reference/transactions-and-concurrency
-      reference/batch-processing
-      reference/dql-doctrine-query-language
-      reference/query-builder
-      reference/native-sql
-      reference/change-tracking-policies
-      reference/attributes-reference
-      reference/xml-mapping
-      reference/php-mapping
-      reference/caching
-      reference/improving-performance
-      reference/tools
-      reference/metadata-drivers
-      reference/best-practices
-      reference/limitations-and-known-issues
-      tutorials/pagination
-      reference/filters
-      reference/namingstrategy
-      reference/advanced-configuration
-      reference/second-level-cache
-      reference/security
-
-.. toc::
-
-   .. tocheader:: Cookbook
-
-   .. toctree::
-      :depth: 3
-
-      cookbook/aggregate-fields
-      cookbook/custom-mapping-types
-      cookbook/decorator-pattern
-      cookbook/dql-custom-walkers
-      cookbook/dql-user-defined-functions
-      cookbook/implementing-arrayaccess-for-domain-objects
-      cookbook/resolve-target-entity-listener
-      cookbook/sql-table-prefixes
-      cookbook/strategy-cookbook-introduction
-      cookbook/validation-of-entities
-      cookbook/working-with-datetime
-      cookbook/mysql-enums
-      cookbook/advanced-field-value-conversion-using-custom-mapping-types
-      cookbook/entities-in-session
+   cookbook/aggregate-fields
+   cookbook/custom-mapping-types
+   cookbook/decorator-pattern
+   cookbook/dql-custom-walkers
+   cookbook/dql-user-defined-functions
+   cookbook/implementing-arrayaccess-for-domain-objects
+   cookbook/resolve-target-entity-listener
+   cookbook/sql-table-prefixes
+   cookbook/strategy-cookbook-introduction
+   cookbook/validation-of-entities
+   cookbook/working-with-datetime
+   cookbook/mysql-enums
+   cookbook/advanced-field-value-conversion-using-custom-mapping-types
+   cookbook/entities-in-session

docs/en/tutorials/composite-primary-keys.rst

@@ -145,7 +145,7 @@ We keep up the example of an Article with arbitrary attributes, the mapping look
             #[OneToMany(targetEntity: ArticleAttribute::class, mappedBy: 'article', cascade: ['ALL'], indexBy: 'attribute')]
             private Collection $attributes;
 
-            public function addAttribute(string $name, ArticleAttribute $value): void
+            public function addAttribute(string $name, string $value): void
             {
                 $this->attributes[$name] = new ArticleAttribute($name, $value, $this);
             }

docs/en/tutorials/getting-started.rst

@@ -27,7 +27,7 @@ What is Doctrine?
 -----------------
 
 Doctrine ORM is an `object-relational mapper (ORM) <https://en.wikipedia.org/wiki/Object-relational_mapping>`_
-for PHP 7.1+ that provides transparent persistence for PHP objects. It uses the Data Mapper
+for PHP that provides transparent persistence for PHP objects. It uses the Data Mapper
 pattern at the heart, aiming for a complete separation of your domain/business
 logic from the persistence in a relational database management system.
 
@@ -139,12 +139,12 @@ step:
 
     // Create a simple "default" Doctrine ORM configuration for Attributes
     $config = ORMSetup::createAttributeMetadataConfiguration(
-        paths: array(__DIR__."/src"),
+        paths: [__DIR__ . '/src'],
         isDevMode: true,
     );
     // or if you prefer XML
     // $config = ORMSetup::createXMLMetadataConfiguration(
-    //    paths: array(__DIR__."/config/xml"),
+    //    paths: [__DIR__ . '/config/xml'],
     //    isDevMode: true,
     //);
 

phpcs.xml.dist

@@ -14,7 +14,6 @@
     <file>src</file>
     <file>tests</file>
 
-    <exclude-pattern>*/src/Mapping/InverseJoinColumn.php</exclude-pattern>
     <exclude-pattern>*/tests/Tests/Proxies/__CG__*</exclude-pattern>
     <exclude-pattern>*/tests/Tests/ORM/Tools/Export/export/*</exclude-pattern>
 

phpstan-baseline.neon

@@ -115,11 +115,6 @@ parameters:
 			count: 1
 			path: src/EntityManagerInterface.php
 
-		-
-			message: "#^Template type T of method Doctrine\\\\ORM\\\\EntityManagerInterface\\:\\:getClassMetadata\\(\\) is not referenced in a parameter\\.$#"
-			count: 1
-			path: src/EntityManagerInterface.php
-
 		-
 			message: "#^Method Doctrine\\\\ORM\\\\EntityRepository\\:\\:matching\\(\\) should return Doctrine\\\\Common\\\\Collections\\\\AbstractLazyCollection\\<int, T of object\\>&Doctrine\\\\Common\\\\Collections\\\\Selectable\\<int, T of object\\> but returns Doctrine\\\\ORM\\\\LazyCriteriaCollection\\<\\(int\\|string\\), object\\>\\.$#"
 			count: 1

phpstan-dbal3.neon

@@ -20,10 +20,6 @@ parameters:
             message: '~^Method Doctrine\\ORM\\Persisters\\Entity\\BasicEntityPersister\:\:getArrayBindingType\(\) never returns .* so it can be removed from the return type\.$~'
             path: src/Persisters/Entity/BasicEntityPersister.php
 
-        -
-            message: '~^Unreachable statement \- code above always terminates\.$~'
-            path: src/Mapping/AssociationMapping.php
-
         - '~^Class Doctrine\\DBAL\\Platforms\\SQLitePlatform not found\.$~'
 
         # To be removed in 4.0

phpstan.neon

@@ -20,10 +20,6 @@ parameters:
             message: '~^Method Doctrine\\ORM\\Persisters\\Entity\\BasicEntityPersister\:\:getArrayBindingType\(\) never returns .* so it can be removed from the return type\.$~'
             path: src/Persisters/Entity/BasicEntityPersister.php
 
-        -
-            message: '~^Unreachable statement \- code above always terminates\.$~'
-            path: src/Mapping/AssociationMapping.php
-
         # Compatibility with DBAL 3
         # See https://github.com/doctrine/dbal/pull/3480
         -

psalm-baseline.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<files psalm-version="5.22.2@d768d914152dbbf3486c36398802f74e80cfde48">
+<files psalm-version="5.24.0@462c80e31c34e58cc4f750c656be3927e80e550e">
   <file src="src/AbstractQuery.php">
     <FalsableReturnStatement>
       <code><![CDATA[! $filteredParameters->isEmpty() ? $filteredParameters->first() : null]]></code>
@@ -154,14 +154,6 @@
       <code><![CDATA[$className]]></code>
     </ArgumentTypeCoercion>
   </file>
-  <file src="src/Decorator/EntityManagerDecorator.php">
-    <InvalidReturnStatement>
-      <code><![CDATA[$this->wrapped->getClassMetadata($className)]]></code>
-    </InvalidReturnStatement>
-    <InvalidReturnType>
-      <code><![CDATA[ClassMetadata]]></code>
-    </InvalidReturnType>
-  </file>
   <file src="src/EntityManager.php">
     <ArgumentTypeCoercion>
       <code><![CDATA[$className]]></code>
@@ -174,11 +166,9 @@
       <code><![CDATA[$persister->load($sortedId, null, null, [], $lockMode)]]></code>
       <code><![CDATA[$persister->loadById($sortedId)]]></code>
       <code><![CDATA[$this->metadataFactory]]></code>
-      <code><![CDATA[$this->metadataFactory->getMetadataFor($className)]]></code>
     </InvalidReturnStatement>
     <InvalidReturnType>
       <code><![CDATA[ClassMetadataFactory]]></code>
-      <code><![CDATA[Mapping\ClassMetadata]]></code>
     </InvalidReturnType>
     <PossiblyNullArgument>
       <code><![CDATA[$config->getProxyDir()]]></code>
@@ -216,6 +206,11 @@
       <code><![CDATA[$entity]]></code>
     </PossiblyNullArgument>
   </file>
+  <file src="src/Id/SequenceGenerator.php">
+    <ParamNameMismatch>
+      <code><![CDATA[$serialized]]></code>
+    </ParamNameMismatch>
+  </file>
   <file src="src/Internal/Hydration/AbstractHydrator.php">
     <ReferenceConstraintViolation>
       <code><![CDATA[return $rowData;]]></code>
@@ -251,9 +246,6 @@
     </UnsupportedReferenceUsage>
   </file>
   <file src="src/Internal/Hydration/ObjectHydrator.php">
-    <InvalidArgument>
-      <code><![CDATA[$element]]></code>
-    </InvalidArgument>
     <PossiblyFalseArgument>
       <code><![CDATA[$index]]></code>
     </PossiblyFalseArgument>
@@ -290,11 +282,6 @@
       <code><![CDATA[$repositoryClassName]]></code>
     </ArgumentTypeCoercion>
   </file>
-  <file src="src/Mapping/Builder/EntityListenerBuilder.php">
-    <PossiblyNullArgument>
-      <code><![CDATA[$class]]></code>
-    </PossiblyNullArgument>
-  </file>
   <file src="src/Mapping/ClassMetadata.php">
     <DeprecatedProperty>
       <code><![CDATA[$this->columnNames]]></code>
@@ -303,6 +290,10 @@
       <code><![CDATA[$this->columnNames]]></code>
     </DeprecatedProperty>
     <InvalidArgument>
+      <code><![CDATA[$mapping]]></code>
+      <code><![CDATA[$mapping]]></code>
+      <code><![CDATA[$mapping]]></code>
+      <code><![CDATA[$mapping]]></code>
       <code><![CDATA[$mapping]]></code>
       <code><![CDATA[$mapping]]></code>
       <code><![CDATA[$mapping]]></code>
@@ -322,8 +313,6 @@
       <code><![CDATA[$entity]]></code>
     </ParamNameMismatch>
     <PossiblyNullArgument>
-      <code><![CDATA[$class]]></code>
-      <code><![CDATA[$className]]></code>
       <code><![CDATA[$mapping['targetEntity']]]></code>
       <code><![CDATA[$mapping['targetEntity']]]></code>
       <code><![CDATA[$parentReflFields[$embeddedClass->declaredField]]]></code>
@@ -508,13 +497,8 @@
     <InvalidPropertyAssignmentValue>
       <code><![CDATA[$metadata->table]]></code>
     </InvalidPropertyAssignmentValue>
-    <InvalidPropertyFetch>
-      <code><![CDATA[$xmlRoot->{'discriminator-column'}]]></code>
-      <code><![CDATA[$xmlRoot->{'discriminator-map'}]]></code>
-    </InvalidPropertyFetch>
     <InvalidReturnStatement>
       <code><![CDATA[$mapping]]></code>
-      <code><![CDATA[$result]]></code>
       <code><![CDATA[[
             'usage'  => $usage,
             'region' => $region,
@@ -538,20 +522,10 @@
       *                   options?: array
       *               }]]></code>
       <code><![CDATA[array{usage: int|null, region?: string}]]></code>
-      <code><![CDATA[loadMappingFile]]></code>
     </InvalidReturnType>
     <MoreSpecificImplementedParamType>
       <code><![CDATA[$metadata]]></code>
     </MoreSpecificImplementedParamType>
-    <NoInterfaceProperties>
-      <code><![CDATA[$xmlRoot->{'discriminator-column'}]]></code>
-      <code><![CDATA[$xmlRoot->{'discriminator-map'}]]></code>
-    </NoInterfaceProperties>
-    <TypeDoesNotContainType>
-      <code><![CDATA[$xmlRoot->getName() === 'embeddable']]></code>
-      <code><![CDATA[$xmlRoot->getName() === 'entity']]></code>
-      <code><![CDATA[$xmlRoot->getName() === 'mapped-superclass']]></code>
-    </TypeDoesNotContainType>
   </file>
   <file src="src/Mapping/ManyToManyInverseSideMapping.php">
     <PropertyNotSetInConstructor>
@@ -767,13 +741,10 @@
       <code><![CDATA[$autoGenerate > 4]]></code>
     </TypeDoesNotContainType>
     <UndefinedMethod>
-      <code><![CDATA[self::createLazyGhost(static function (InternalProxy $object) use ($initializer, &$proxy): void {
-                $initializer($object, $proxy);
+      <code><![CDATA[self::createLazyGhost(static function (InternalProxy $object) use ($initializer, $identifier): void {
+                $initializer($object, $identifier);
             }, $skippedProperties)]]></code>
     </UndefinedMethod>
-    <UndefinedVariable>
-      <code><![CDATA[$proxy]]></code>
-    </UndefinedVariable>
     <UnresolvableInclude>
       <code><![CDATA[require $fileName]]></code>
     </UnresolvableInclude>
@@ -1034,10 +1005,6 @@
   </file>
   <file src="src/QueryBuilder.php">
     <ArgumentTypeCoercion>
-      <code><![CDATA[$having]]></code>
-      <code><![CDATA[$having]]></code>
-      <code><![CDATA[$where]]></code>
-      <code><![CDATA[$where]]></code>
       <code><![CDATA[[$rootAlias => $join]]]></code>
       <code><![CDATA[[$rootAlias => $join]]]></code>
     </ArgumentTypeCoercion>

src/Cache/Persister/Entity/AbstractEntityPersister.php

@@ -5,6 +5,7 @@ declare(strict_types=1);
 namespace Doctrine\ORM\Cache\Persister\Entity;
 
 use Doctrine\Common\Collections\Criteria;
+use Doctrine\Common\Collections\Order;
 use Doctrine\DBAL\LockMode;
 use Doctrine\ORM\Cache;
 use Doctrine\ORM\Cache\CollectionCacheKey;
@@ -17,7 +18,6 @@ use Doctrine\ORM\Cache\Region;
 use Doctrine\ORM\Cache\TimestampCacheKey;
 use Doctrine\ORM\Cache\TimestampRegion;
 use Doctrine\ORM\EntityManagerInterface;
-use Doctrine\ORM\Internal\CriteriaOrderings;
 use Doctrine\ORM\Mapping\AssociationMapping;
 use Doctrine\ORM\Mapping\ClassMetadata;
 use Doctrine\ORM\Mapping\ClassMetadataFactory;
@@ -34,8 +34,6 @@ use function sha1;
 
 abstract class AbstractEntityPersister implements CachedEntityPersister
 {
-    use CriteriaOrderings;
-
     protected UnitOfWork $uow;
     protected ClassMetadataFactory $metadataFactory;
 
@@ -204,8 +202,8 @@ abstract class AbstractEntityPersister implements CachedEntityPersister
     /**
      * Generates a string of currently query
      *
-     * @param string[]|Criteria $criteria
-     * @param string[]|null     $orderBy
+     * @param string[]|Criteria         $criteria
+     * @param array<string, Order>|null $orderBy
      */
     protected function getHash(
         string $query,
@@ -429,7 +427,7 @@ abstract class AbstractEntityPersister implements CachedEntityPersister
      */
     public function loadCriteria(Criteria $criteria): array
     {
-        $orderBy     = self::getCriteriaOrderings($criteria);
+        $orderBy     = $criteria->orderings();
         $limit       = $criteria->getMaxResults();
         $offset      = $criteria->getFirstResult();
         $query       = $this->persister->getSelectSQL($criteria);

src/Cache/Region/FileLockRegion.php

@@ -67,7 +67,7 @@ class FileLockRegion implements ConcurrentRegion
         $time    = $this->getLockTime($filename);
         $content = $this->getLockContent($filename);
 
-        if (! $content || ! $time) {
+        if ($content === false || $time === false) {
             @unlink($filename);
 
             return false;
@@ -156,12 +156,10 @@ class FileLockRegion implements ConcurrentRegion
     {
         // The check below is necessary because on some platforms glob returns false
         // when nothing matched (even though no errors occurred)
-        $filenames = glob(sprintf('%s/*.%s', $this->directory, self::LOCK_EXTENSION));
+        $filenames = glob(sprintf('%s/*.%s', $this->directory, self::LOCK_EXTENSION)) ?: [];
 
-        if ($filenames) {
-            foreach ($filenames as $filename) {
-                @unlink($filename);
-            }
+        foreach ($filenames as $filename) {
+            @unlink($filename);
         }
 
         return $this->region->evictAll();
@@ -176,7 +174,7 @@ class FileLockRegion implements ConcurrentRegion
         $lock     = Lock::createLockRead();
         $filename = $this->getLockFileName($key);
 
-        if (! @file_put_contents($filename, $lock->value, LOCK_EX)) {
+        if (@file_put_contents($filename, $lock->value, LOCK_EX) === false) {
             return null;
         }
 

src/EntityManager.php

@@ -63,27 +63,27 @@ class EntityManager implements EntityManagerInterface
     /**
      * The metadata factory, used to retrieve the ORM metadata of entity classes.
      */
-    private readonly ClassMetadataFactory $metadataFactory;
+    private ClassMetadataFactory $metadataFactory;
 
     /**
      * The UnitOfWork used to coordinate object-level transactions.
      */
-    private readonly UnitOfWork $unitOfWork;
+    private UnitOfWork $unitOfWork;
 
     /**
      * The event manager that is the central point of the event system.
      */
-    private readonly EventManager $eventManager;
+    private EventManager $eventManager;
 
     /**
      * The proxy factory used to create dynamic proxies.
      */
-    private readonly ProxyFactory $proxyFactory;
+    private ProxyFactory $proxyFactory;
 
     /**
      * The repository factory used to create dynamic repositories.
      */
-    private readonly RepositoryFactory $repositoryFactory;
+    private RepositoryFactory $repositoryFactory;
 
     /**
      * The expression builder instance used to generate query expressions.
@@ -112,8 +112,8 @@ class EntityManager implements EntityManagerInterface
      * @param Connection $conn The database connection used by the EntityManager.
      */
     public function __construct(
-        private readonly Connection $conn,
-        private readonly Configuration $config,
+        private Connection $conn,
+        private Configuration $config,
         EventManager|null $eventManager = null,
     ) {
         if (! $config->getMetadataDriverImpl()) {

src/EntityManagerInterface.php

@@ -234,7 +234,7 @@ interface EntityManagerInterface extends ObjectManager
      *
      * @psalm-param string|class-string<T> $className
      *
-     * @psalm-return Mapping\ClassMetadata<T>
+     * @psalm-return ($className is class-string<T> ? Mapping\ClassMetadata<T> : Mapping\ClassMetadata<object>)
      *
      * @psalm-template T of object
      */

src/Exception/NotSupported.php

@@ -8,6 +8,7 @@ use LogicException;
 
 use function sprintf;
 
+/** @deprecated */
 final class NotSupported extends LogicException implements ORMException
 {
     public static function create(): self

src/Id/SequenceGenerator.php

@@ -5,6 +5,7 @@ declare(strict_types=1);
 namespace Doctrine\ORM\Id;
 
 use Doctrine\DBAL\Connections\PrimaryReadReplicaConnection;
+use Doctrine\Deprecations\Deprecation;
 use Doctrine\ORM\EntityManagerInterface;
 use Serializable;
 
@@ -65,8 +66,17 @@ class SequenceGenerator extends AbstractIdGenerator implements Serializable
         return $this->nextValue;
     }
 
+    /** @deprecated without replacement. */
     final public function serialize(): string
     {
+        Deprecation::trigger(
+            'doctrine/orm',
+            'https://github.com/doctrine/orm/pull/11468',
+            '%s() is deprecated, use __serialize() instead. %s won\'t implement the Serializable interface anymore in ORM 4.',
+            __METHOD__,
+            self::class,
+        );
+
         return serialize($this->__serialize());
     }
 
@@ -79,8 +89,17 @@ class SequenceGenerator extends AbstractIdGenerator implements Serializable
         ];
     }
 
+    /** @deprecated without replacement. */
     final public function unserialize(string $serialized): void
     {
+        Deprecation::trigger(
+            'doctrine/orm',
+            'https://github.com/doctrine/orm/pull/11468',
+            '%s() is deprecated, use __unserialize() instead. %s won\'t implement the Serializable interface anymore in ORM 4.',
+            __METHOD__,
+            self::class,
+        );
+
         $this->__unserialize(unserialize($serialized));
     }
 

src/Internal/CriteriaOrderings.php

@@ -1,50 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Doctrine\ORM\Internal;
-
-use Doctrine\Common\Collections\Criteria;
-use Doctrine\Common\Collections\Order;
-
-use function array_map;
-use function enum_exists;
-use function method_exists;
-use function strtoupper;
-
-trait CriteriaOrderings
-{
-    /**
-     * @return array<string, string>
-     *
-     * @psalm-suppress DeprecatedMethod We need to call the deprecated API if the new one does not exist yet.
-     */
-    private static function getCriteriaOrderings(Criteria $criteria): array
-    {
-        if (! method_exists(Criteria::class, 'orderings')) {
-            return $criteria->getOrderings();
-        }
-
-        return array_map(
-            static fn (Order $order): string => $order->value,
-            $criteria->orderings(),
-        );
-    }
-
-    /**
-     * @param array<string, string> $orderings
-     *
-     * @return array<string, string>|array<string, Order>
-     */
-    private static function mapToOrderEnumIfAvailable(array $orderings): array
-    {
-        if (! enum_exists(Order::class)) {
-            return $orderings;
-        }
-
-        return array_map(
-            static fn (string $order): Order => Order::from(strtoupper($order)),
-            $orderings,
-        );
-    }
-}

src/Internal/Hydration/AbstractHydrator.php

@@ -104,29 +104,31 @@ abstract class AbstractHydrator
 
         $this->prepare();
 
-        while (true) {
-            $row = $this->statement()->fetchAssociative();
+        try {
+            while (true) {
+                $row = $this->statement()->fetchAssociative();
 
-            if ($row === false) {
-                $this->cleanup();
-
-                break;
-            }
-
-            $result = [];
-
-            $this->hydrateRowData($row, $result);
-
-            $this->cleanupAfterRowIteration();
-            if (count($result) === 1) {
-                if (count($resultSetMapping->indexByMap) === 0) {
-                    yield end($result);
-                } else {
-                    yield from $result;
+                if ($row === false) {
+                    break;
+                }
+
+                $result = [];
+
+                $this->hydrateRowData($row, $result);
+
+                $this->cleanupAfterRowIteration();
+                if (count($result) === 1) {
+                    if (count($resultSetMapping->indexByMap) === 0) {
+                        yield end($result);
+                    } else {
+                        yield from $result;
+                    }
+                } else {
+                    yield $result;
                 }
-            } else {
-                yield $result;
             }
+        } finally {
+            $this->cleanup();
         }
     }
 

src/Internal/Hydration/ObjectHydrator.php

@@ -91,7 +91,7 @@ class ObjectHydrator extends AbstractHydrator
             }
 
             // handle fetch-joined owning side bi-directional one-to-one associations
-            if ($assoc->inversedBy) {
+            if ($assoc->inversedBy !== null) {
                 $class        = $this->getClassMetadata($className);
                 $inverseAssoc = $class->associationMappings[$assoc->inversedBy];
 
@@ -356,11 +356,15 @@ class ObjectHydrator extends AbstractHydrator
                     $parentObject = $this->resultPointers[$parentAlias];
                 } else {
                     // Parent object of relation not found, mark as not-fetched again
-                    $element = $this->getEntity($data, $dqlAlias);
+                    if (isset($nonemptyComponents[$dqlAlias])) {
+                        $element = $this->getEntity($data, $dqlAlias);
 
-                    // Update result pointer and provide initial fetch data for parent
-                    $this->resultPointers[$dqlAlias]               = $element;
-                    $rowData['data'][$parentAlias][$relationField] = $element;
+                        // Update result pointer and provide initial fetch data for parent
+                        $this->resultPointers[$dqlAlias]               = $element;
+                        $rowData['data'][$parentAlias][$relationField] = $element;
+                    } else {
+                        $element = null;
+                    }
 
                     // Mark as not-fetched again
                     unset($this->hints['fetched'][$parentAlias][$relationField]);
@@ -439,7 +443,7 @@ class ObjectHydrator extends AbstractHydrator
                             if ($relation->isOwningSide()) {
                                 // TODO: Just check hints['fetched'] here?
                                 // If there is an inverse mapping on the target class its bidirectional
-                                if ($relation->inversedBy) {
+                                if ($relation->inversedBy !== null) {
                                     $inverseAssoc = $targetClass->associationMappings[$relation->inversedBy];
                                     if ($inverseAssoc->isToOne()) {
                                         $targetClass->reflFields[$inverseAssoc->fieldName]->setValue($element, $parentObject);

src/Internal/NoUnknownNamedArguments.php

@@ -0,0 +1,55 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\ORM\Internal;
+
+use BadMethodCallException;
+
+use function array_filter;
+use function array_is_list;
+use function array_keys;
+use function array_values;
+use function assert;
+use function debug_backtrace;
+use function implode;
+use function is_string;
+use function sprintf;
+
+use const DEBUG_BACKTRACE_IGNORE_ARGS;
+
+/**
+ * Checks if a variadic parameter contains unexpected named arguments.
+ *
+ * @internal
+ */
+trait NoUnknownNamedArguments
+{
+    /**
+     * @param TItem[] $parameter
+     *
+     * @template TItem
+     * @psalm-assert list<TItem> $parameter
+     */
+    private static function validateVariadicParameter(array $parameter): void
+    {
+        if (array_is_list($parameter)) {
+            return;
+        }
+
+        [, $trace] = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS);
+        assert(isset($trace['class']));
+
+        $additionalArguments = array_values(array_filter(
+            array_keys($parameter),
+            is_string(...),
+        ));
+
+        throw new BadMethodCallException(sprintf(
+            'Invalid call to %s::%s(), unknown named arguments: %s',
+            $trace['class'],
+            $trace['function'],
+            implode(', ', $additionalArguments),
+        ));
+    }
+}

src/LazyCriteriaCollection.php

@@ -64,11 +64,11 @@ class LazyCriteriaCollection extends AbstractLazyCollection implements Selectabl
     }
 
     /**
-     * {@inheritDoc}
-     *
      * Do an optimized search of an element
      *
-     * @template TMaybeContained
+     * @param mixed $element The element to search for.
+     *
+     * @return bool TRUE if the collection contains $element, FALSE otherwise.
      */
     public function contains(mixed $element): bool
     {

src/Mapping/ArrayAccessImplementation.php

@@ -4,6 +4,7 @@ declare(strict_types=1);
 
 namespace Doctrine\ORM\Mapping;
 
+use Doctrine\Deprecations\Deprecation;
 use InvalidArgumentException;
 
 use function property_exists;
@@ -14,12 +15,26 @@ trait ArrayAccessImplementation
     /** @param string $offset */
     public function offsetExists(mixed $offset): bool
     {
+        Deprecation::trigger(
+            'doctrine/orm',
+            'https://github.com/doctrine/orm/pull/11211',
+            'Using ArrayAccess on %s is deprecated and will not be possible in Doctrine ORM 4.0. Use the corresponding property instead.',
+            static::class,
+        );
+
         return isset($this->$offset);
     }
 
     /** @param string $offset */
     public function offsetGet(mixed $offset): mixed
     {
+        Deprecation::trigger(
+            'doctrine/orm',
+            'https://github.com/doctrine/orm/pull/11211',
+            'Using ArrayAccess on %s is deprecated and will not be possible in Doctrine ORM 4.0. Use the corresponding property instead.',
+            static::class,
+        );
+
         if (! property_exists($this, $offset)) {
             throw new InvalidArgumentException('Undefined property: ' . $offset);
         }
@@ -30,12 +45,26 @@ trait ArrayAccessImplementation
     /** @param string $offset */
     public function offsetSet(mixed $offset, mixed $value): void
     {
+        Deprecation::trigger(
+            'doctrine/orm',
+            'https://github.com/doctrine/orm/pull/11211',
+            'Using ArrayAccess on %s is deprecated and will not be possible in Doctrine ORM 4.0. Use the corresponding property instead.',
+            static::class,
+        );
+
         $this->$offset = $value;
     }
 
     /** @param string $offset */
     public function offsetUnset(mixed $offset): void
     {
+        Deprecation::trigger(
+            'doctrine/orm',
+            'https://github.com/doctrine/orm/pull/11211',
+            'Using ArrayAccess on %s is deprecated and will not be possible in Doctrine ORM 4.0. Use the corresponding property instead.',
+            static::class,
+        );
+
         $this->$offset = null;
     }
 }

src/Mapping/AssociationMapping.php

@@ -27,7 +27,7 @@ abstract class AssociationMapping implements ArrayAccess
     /**
      * The fetching strategy to use for the association, usually defaults to FETCH_LAZY.
      *
-     * @var ClassMetadata::FETCH_*
+     * @var ClassMetadata::FETCH_*|null
      */
     public int|null $fetch = null;
 
@@ -96,13 +96,26 @@ abstract class AssociationMapping implements ArrayAccess
     }
 
     /**
+     * @param mixed[] $mappingArray
      * @psalm-param array{
      *     fieldName: string,
      *     sourceEntity: class-string,
      *     targetEntity: class-string,
+     *     cascade?: list<'persist'|'remove'|'detach'|'refresh'|'all'>,
+     *     fetch?: ClassMetadata::FETCH_*|null,
+     *     inherited?: class-string|null,
+     *     declared?: class-string|null,
+     *     cache?: array<mixed>|null,
+     *     id?: bool|null,
+     *     isOnDeleteCascade?: bool|null,
+     *     originalClass?: class-string|null,
+     *     originalField?: string|null,
+     *     orphanRemoval?: bool,
+     *     unique?: bool|null,
      *     joinTable?: mixed[]|null,
      *     type?: int,
-     *     isOwningSide: bool, ...} $mappingArray
+     *     isOwningSide: bool,
+     * } $mappingArray
      */
     public static function fromMappingArray(array $mappingArray): static
     {

src/Mapping/Builder/ClassMetadataBuilder.php

@@ -288,7 +288,7 @@ class ClassMetadataBuilder
     ): ClassMetadataBuilder {
         $builder = $this->createManyToOne($name, $targetEntity);
 
-        if ($inversedBy) {
+        if ($inversedBy !== null) {
             $builder->inversedBy($inversedBy);
         }
 
@@ -348,7 +348,7 @@ class ClassMetadataBuilder
     ): ClassMetadataBuilder {
         $builder = $this->createOneToOne($name, $targetEntity);
 
-        if ($inversedBy) {
+        if ($inversedBy !== null) {
             $builder->inversedBy($inversedBy);
         }
 
@@ -380,7 +380,7 @@ class ClassMetadataBuilder
     ): ClassMetadataBuilder {
         $builder = $this->createManyToMany($name, $targetEntity);
 
-        if ($inversedBy) {
+        if ($inversedBy !== null) {
             $builder->inversedBy($inversedBy);
         }
 

src/Mapping/ChainTypedFieldMapper.php

@@ -4,18 +4,20 @@ declare(strict_types=1);
 
 namespace Doctrine\ORM\Mapping;
 
+use Doctrine\ORM\Internal\NoUnknownNamedArguments;
 use ReflectionProperty;
 
 final class ChainTypedFieldMapper implements TypedFieldMapper
 {
-    /**
-     * @readonly
-     * @var TypedFieldMapper[] $typedFieldMappers
-     */
+    use NoUnknownNamedArguments;
+
+    /** @var list<TypedFieldMapper> $typedFieldMappers */
     private readonly array $typedFieldMappers;
 
     public function __construct(TypedFieldMapper ...$typedFieldMappers)
     {
+        self::validateVariadicParameter($typedFieldMappers);
+
         $this->typedFieldMappers = $typedFieldMappers;
     }
 

src/Mapping/ClassMetadata.php

@@ -7,6 +7,7 @@ namespace Doctrine\ORM\Mapping;
 use BackedEnum;
 use BadMethodCallException;
 use Doctrine\DBAL\Platforms\AbstractPlatform;
+use Doctrine\Deprecations\Deprecation;
 use Doctrine\Instantiator\Instantiator;
 use Doctrine\Instantiator\InstantiatorInterface;
 use Doctrine\ORM\Cache\Exception\NonCacheableEntityAssociation;
@@ -14,6 +15,7 @@ use Doctrine\ORM\EntityRepository;
 use Doctrine\ORM\Id\AbstractIdGenerator;
 use Doctrine\Persistence\Mapping\ClassMetadata as PersistenceClassMetadata;
 use Doctrine\Persistence\Mapping\ReflectionService;
+use Doctrine\Persistence\Reflection\EnumReflectionProperty;
 use InvalidArgumentException;
 use LogicException;
 use ReflectionClass;
@@ -821,7 +823,7 @@ class ClassMetadata implements PersistenceClassMetadata, Stringable
                 assert($childProperty !== null);
 
                 if (isset($mapping->enumType)) {
-                    $childProperty = new ReflectionEnumProperty(
+                    $childProperty = new EnumReflectionProperty(
                         $childProperty,
                         $mapping->enumType,
                     );
@@ -840,7 +842,7 @@ class ClassMetadata implements PersistenceClassMetadata, Stringable
                 : $this->getAccessibleProperty($reflService, $this->name, $field);
 
             if (isset($mapping->enumType) && $this->reflFields[$field] !== null) {
-                $this->reflFields[$field] = new ReflectionEnumProperty(
+                $this->reflFields[$field] = new EnumReflectionProperty(
                     $this->reflFields[$field],
                     $mapping->enumType,
                 );
@@ -1150,7 +1152,7 @@ class ClassMetadata implements PersistenceClassMetadata, Stringable
      *     fieldName?: string,
      *     columnName?: string,
      *     id?: bool,
-     *     generated?: int,
+     *     generated?: self::GENERATED_*,
      *     enumType?: class-string,
      * } $mapping The field mapping to validate & complete.
      *
@@ -2004,6 +2006,12 @@ class ClassMetadata implements PersistenceClassMetadata, Stringable
      */
     public function setCustomRepositoryClass(string|null $repositoryClassName): void
     {
+        if ($repositoryClassName === null) {
+            $this->customRepositoryClassName = null;
+
+            return;
+        }
+
         $this->customRepositoryClassName = $this->fullyQualifiedClassName($repositoryClassName);
     }
 
@@ -2476,11 +2484,25 @@ class ClassMetadata implements PersistenceClassMetadata, Stringable
         return $assoc->mappedBy;
     }
 
-    /** @return string|null null if the input value is null */
+    /**
+     * @param C $className
+     *
+     * @return string|null null if and only if the input value is null
+     * @psalm-return (C is class-string ? class-string : (C is string ? string : null))
+     *
+     * @template C of string|null
+     */
     public function fullyQualifiedClassName(string|null $className): string|null
     {
-        if (empty($className)) {
-            return $className;
+        if ($className === null) {
+            Deprecation::trigger(
+                'doctrine/orm',
+                'https://github.com/doctrine/orm/pull/11294',
+                'Passing null to %s is deprecated and will not be supported in Doctrine ORM 4.0',
+                __METHOD__,
+            );
+
+            return null;
         }
 
         if (! str_contains($className, '\\') && $this->namespace) {
@@ -2523,12 +2545,8 @@ class ClassMetadata implements PersistenceClassMetadata, Stringable
             throw MappingException::missingEmbeddedClass($mapping['fieldName']);
         }
 
-        $fqcn = $this->fullyQualifiedClassName($mapping['class']);
-
-        assert($fqcn !== null);
-
         $this->embeddedClasses[$mapping['fieldName']] = EmbeddedClassMapping::fromMappingArray([
-            'class' => $fqcn,
+            'class' => $this->fullyQualifiedClassName($mapping['class']),
             'columnPrefix' => $mapping['columnPrefix'] ?? null,
             'declaredField' => $mapping['declaredField'] ?? null,
             'originalField' => $mapping['originalField'] ?? null,

src/Mapping/Driver/AttributeDriver.php

@@ -390,7 +390,7 @@ class AttributeDriver implements MappingDriver
                 $metadata->mapOneToMany($mapping);
             } elseif ($manyToOneAttribute !== null) {
                 if ($metadata->isEmbeddedClass) {
-                    throw MappingException::invalidAttributeOnEmbeddable($metadata->name, Mapping\OneToMany::class);
+                    throw MappingException::invalidAttributeOnEmbeddable($metadata->name, Mapping\ManyToOne::class);
                 }
 
                 $idAttribute = $this->reader->getPropertyAttribute($property, Mapping\Id::class);

src/Mapping/Driver/XmlDriver.php

@@ -38,6 +38,8 @@ use function strtoupper;
  * XmlDriver is a metadata driver that enables mapping through XML files.
  *
  * @link        www.doctrine-project.org
+ *
+ * @template-extends FileDriver<SimpleXMLElement>
  */
 class XmlDriver extends FileDriver
 {
@@ -78,7 +80,6 @@ class XmlDriver extends FileDriver
     public function loadMetadataForClass($className, PersistenceClassMetadata $metadata): void
     {
         $xmlRoot = $this->getElement($className);
-        assert($xmlRoot instanceof SimpleXMLElement);
 
         if ($xmlRoot->getName() === 'entity') {
             if (isset($xmlRoot['repository-class'])) {
@@ -134,6 +135,7 @@ class XmlDriver extends FileDriver
                     ];
 
                     if (isset($discrColumn['options'])) {
+                        assert($discrColumn['options'] instanceof SimpleXMLElement);
                         $columnDef['options'] = $this->parseOptions($discrColumn['options']->children());
                     }
 
@@ -145,6 +147,7 @@ class XmlDriver extends FileDriver
                 // Evaluate <discriminator-map...>
                 if (isset($xmlRoot->{'discriminator-map'})) {
                     $map = [];
+                    assert($xmlRoot->{'discriminator-map'}->{'discriminator-mapping'} instanceof SimpleXMLElement);
                     foreach ($xmlRoot->{'discriminator-map'}->{'discriminator-mapping'} as $discrMapElement) {
                         $map[(string) $discrMapElement['value']] = (string) $discrMapElement['class'];
                     }

src/Mapping/EmbeddedClassMapping.php

@@ -49,10 +49,12 @@ final class EmbeddedClassMapping implements ArrayAccess
 
     /**
      * @psalm-param array{
-     *    class: class-string,
-     *    columnPrefix?: false|string|null,
-     *    declaredField?: string|null,
-     *    originalField?: string|null
+     *     class: class-string,
+     *     columnPrefix?: false|string|null,
+     *     declaredField?: string|null,
+     *     originalField?: string|null,
+     *     inherited?: class-string|null,
+     *     declared?: class-string|null,
      * } $mappingArray
      */
     public static function fromMappingArray(array $mappingArray): self

src/Mapping/FieldMapping.php

@@ -26,7 +26,7 @@ final class FieldMapping implements ArrayAccess
     public bool|null $notInsertable      = null;
     public bool|null $notUpdatable       = null;
     public string|null $columnDefinition = null;
-    /** @psalm-var ClassMetadata::GENERATED_* */
+    /** @psalm-var ClassMetadata::GENERATED_*|null */
     public int|null $generated = null;
     /** @var class-string<BackedEnum>|null */
     public string|null $enumType = null;
@@ -83,7 +83,34 @@ final class FieldMapping implements ArrayAccess
     ) {
     }
 
-    /** @param array{type: string, fieldName: string, columnName: string} $mappingArray */
+    /**
+     * @param array<string, mixed> $mappingArray
+     * @psalm-param array{
+     *     type: string,
+     *     fieldName: string,
+     *     columnName: string,
+     *     length?: int|null,
+     *     id?: bool|null,
+     *     nullable?: bool|null,
+     *     notInsertable?: bool|null,
+     *     notUpdatable?: bool|null,
+     *     columnDefinition?: string|null,
+     *     generated?: ClassMetadata::GENERATED_*|null,
+     *     enumType?: string|null,
+     *     precision?: int|null,
+     *     scale?: int|null,
+     *     unique?: bool|null,
+     *     inherited?: string|null,
+     *     originalClass?: string|null,
+     *     originalField?: string|null,
+     *     quoted?: bool|null,
+     *     declared?: string|null,
+     *     declaredField?: string|null,
+     *     options?: array<string, mixed>|null,
+     *     version?: bool|null,
+     *     default?: string|int|null,
+     * } $mappingArray
+     */
     public static function fromMappingArray(array $mappingArray): self
     {
         $mapping = new self(

src/Mapping/InverseJoinColumn.php

@@ -2,7 +2,6 @@
 
 declare(strict_types=1);
 
-
 namespace Doctrine\ORM\Mapping;
 
 use Attribute;

src/Mapping/JoinColumnMapping.php

@@ -31,7 +31,17 @@ final class JoinColumnMapping implements ArrayAccess
 
     /**
      * @param array<string, mixed> $mappingArray
-     * @psalm-param array{name: string, referencedColumnName: string, ...} $mappingArray
+     * @psalm-param array{
+     *     name: string,
+     *     referencedColumnName: string,
+     *     unique?: bool|null,
+     *     quoted?: bool|null,
+     *     fieldName?: string|null,
+     *     onDelete?: string|null,
+     *     columnDefinition?: string|null,
+     *     nullable?: bool|null,
+     *     options?: array<string, mixed>|null,
+     * } $mappingArray
      */
     public static function fromMappingArray(array $mappingArray): self
     {

src/Mapping/JoinTableMapping.php

@@ -35,10 +35,10 @@ final class JoinTableMapping implements ArrayAccess
      * @param mixed[] $mappingArray
      * @psalm-param array{
      *    name: string,
-     *    quoted?: bool,
+     *    quoted?: bool|null,
      *    joinColumns?: mixed[],
      *    inverseJoinColumns?: mixed[],
-     *    schema?: string,
+     *    schema?: string|null,
      *    options?: array<string, mixed>
      * } $mappingArray
      */

src/Mapping/ManyToManyOwningSideMapping.php

@@ -41,9 +41,21 @@ final class ManyToManyOwningSideMapping extends ToManyOwningSideMapping implemen
      *     fieldName: string,
      *     sourceEntity: class-string,
      *     targetEntity: class-string,
+     *     cascade?: list<'persist'|'remove'|'detach'|'refresh'|'all'>,
+     *     fetch?: ClassMetadata::FETCH_*|null,
+     *     inherited?: class-string|null,
+     *     declared?: class-string|null,
+     *     cache?: array<mixed>|null,
+     *     id?: bool|null,
+     *     isOnDeleteCascade?: bool|null,
+     *     originalClass?: class-string|null,
+     *     originalField?: string|null,
+     *     orphanRemoval?: bool,
+     *     unique?: bool|null,
      *     joinTable?: mixed[]|null,
      *     type?: int,
-     *     isOwningSide: bool, ...} $mappingArray
+     *     isOwningSide: bool,
+     * } $mappingArray
      */
     public static function fromMappingArrayAndNamingStrategy(array $mappingArray, NamingStrategy $namingStrategy): self
     {

src/Mapping/OneToManyAssociationMapping.php

@@ -12,9 +12,21 @@ final class OneToManyAssociationMapping extends ToManyInverseSideMapping
      *     fieldName: string,
      *     sourceEntity: class-string,
      *     targetEntity: class-string,
+     *     cascade?: list<'persist'|'remove'|'detach'|'refresh'|'all'>,
+     *     fetch?: ClassMetadata::FETCH_*|null,
+     *     inherited?: class-string|null,
+     *     declared?: class-string|null,
+     *     cache?: array<mixed>|null,
+     *     id?: bool|null,
+     *     isOnDeleteCascade?: bool|null,
+     *     originalClass?: class-string|null,
+     *     originalField?: string|null,
+     *     orphanRemoval?: bool,
+     *     unique?: bool|null,
      *     joinTable?: mixed[]|null,
      *     type?: int,
-     *     isOwningSide: bool, ...} $mappingArray
+     *     isOwningSide: bool,
+     * } $mappingArray
      */
     public static function fromMappingArray(array $mappingArray): static
     {
@@ -33,9 +45,21 @@ final class OneToManyAssociationMapping extends ToManyInverseSideMapping
      *     fieldName: string,
      *     sourceEntity: class-string,
      *     targetEntity: class-string,
+     *     cascade?: list<'persist'|'remove'|'detach'|'refresh'|'all'>,
+     *     fetch?: ClassMetadata::FETCH_*|null,
+     *     inherited?: class-string|null,
+     *     declared?: class-string|null,
+     *     cache?: array<mixed>|null,
+     *     id?: bool|null,
+     *     isOnDeleteCascade?: bool|null,
+     *     originalClass?: class-string|null,
+     *     originalField?: string|null,
+     *     orphanRemoval?: bool,
+     *     unique?: bool|null,
      *     joinTable?: mixed[]|null,
      *     type?: int,
-     *     isOwningSide: bool, ...} $mappingArray
+     *     isOwningSide: bool,
+     * } $mappingArray
      */
     public static function fromMappingArrayAndName(array $mappingArray, string $name): static
     {

src/Mapping/ReflectionEmbeddedProperty.php

@@ -30,7 +30,7 @@ final class ReflectionEmbeddedProperty extends ReflectionProperty
         private readonly ReflectionProperty $childProperty,
         private readonly string $embeddedClass,
     ) {
-        parent::__construct($childProperty->class, $childProperty->name);
+        parent::__construct($childProperty->getDeclaringClass()->name, $childProperty->getName());
     }
 
     public function getValue(object|null $object = null): mixed

src/Mapping/ReflectionEnumProperty.php

@@ -11,6 +11,7 @@ use ValueError;
 use function array_map;
 use function is_array;
 
+/** @deprecated use Doctrine\Persistence\Reflection\EnumReflectionProperty instead */
 final class ReflectionEnumProperty extends ReflectionProperty
 {
     /** @param class-string<BackedEnum> $enumType */

src/Mapping/Table.php

@@ -5,6 +5,7 @@ declare(strict_types=1);
 namespace Doctrine\ORM\Mapping;
 
 use Attribute;
+use Doctrine\Deprecations\Deprecation;
 
 #[Attribute(Attribute::TARGET_CLASS)]
 final class Table implements MappingAttribute
@@ -21,5 +22,24 @@ final class Table implements MappingAttribute
         public readonly array|null $uniqueConstraints = null,
         public readonly array $options = [],
     ) {
+        if ($this->indexes !== null) {
+            Deprecation::trigger(
+                'doctrine/orm',
+                'https://github.com/doctrine/orm/pull/11357',
+                'Providing the property $indexes on %s does not have any effect and will be removed in Doctrine ORM 4.0. Please use the %s attribute instead.',
+                self::class,
+                Index::class,
+            );
+        }
+
+        if ($this->uniqueConstraints !== null) {
+            Deprecation::trigger(
+                'doctrine/orm',
+                'https://github.com/doctrine/orm/pull/11357',
+                'Providing the property $uniqueConstraints on %s does not have any effect and will be removed in Doctrine ORM 4.0. Please use the %s attribute instead.',
+                self::class,
+                UniqueConstraint::class,
+            );
+        }
     }
 }

src/Mapping/ToOneInverseSideMapping.php

@@ -13,8 +13,21 @@ abstract class ToOneInverseSideMapping extends InverseSideMapping
      *     fieldName: string,
      *     sourceEntity: class-string,
      *     targetEntity: class-string,
+     *     cascade?: list<'persist'|'remove'|'detach'|'refresh'|'all'>,
+     *     fetch?: ClassMetadata::FETCH_*|null,
+     *     inherited?: class-string|null,
+     *     declared?: class-string|null,
+     *     cache?: array<mixed>|null,
+     *     id?: bool|null,
+     *     isOnDeleteCascade?: bool|null,
+     *     originalClass?: class-string|null,
+     *     originalField?: string|null,
+     *     orphanRemoval?: bool,
+     *     unique?: bool|null,
+     *     joinTable?: mixed[]|null,
+     *     type?: int,
      *     isOwningSide: bool,
-     *     } $mappingArray
+     * } $mappingArray
      */
     public static function fromMappingArrayAndName(
         array $mappingArray,

src/Mapping/ToOneOwningSideMapping.php

@@ -31,8 +31,22 @@ abstract class ToOneOwningSideMapping extends OwningSideMapping implements ToOne
      *     fieldName: string,
      *     sourceEntity: class-string,
      *     targetEntity: class-string,
+     *     cascade?: list<'persist'|'remove'|'detach'|'refresh'|'all'>,
+     *     fetch?: ClassMetadata::FETCH_*|null,
+     *     inherited?: class-string|null,
+     *     declared?: class-string|null,
+     *     cache?: array<mixed>|null,
+     *     id?: bool|null,
+     *     isOnDeleteCascade?: bool|null,
+     *     originalClass?: class-string|null,
+     *     originalField?: string|null,
+     *     orphanRemoval?: bool,
+     *     unique?: bool|null,
+     *     joinTable?: mixed[]|null,
+     *     type?: int,
+     *     isOwningSide: bool,
      *     joinColumns?: mixed[]|null,
-     *     isOwningSide: bool, ...} $mappingArray
+     * } $mappingArray
      */
     public static function fromMappingArray(array $mappingArray): static
     {
@@ -64,8 +78,22 @@ abstract class ToOneOwningSideMapping extends OwningSideMapping implements ToOne
      *     fieldName: string,
      *     sourceEntity: class-string,
      *     targetEntity: class-string,
+     *     cascade?: list<'persist'|'remove'|'detach'|'refresh'|'all'>,
+     *     fetch?: ClassMetadata::FETCH_*|null,
+     *     inherited?: class-string|null,
+     *     declared?: class-string|null,
+     *     cache?: array<mixed>|null,
+     *     id?: bool|null,
+     *     isOnDeleteCascade?: bool|null,
+     *     originalClass?: class-string|null,
+     *     originalField?: string|null,
+     *     orphanRemoval?: bool,
+     *     unique?: bool|null,
+     *     joinTable?: mixed[]|null,
+     *     type?: int,
+     *     isOwningSide: bool,
      *     joinColumns?: mixed[]|null,
-     *     isOwningSide: bool, ...} $mappingArray
+     * } $mappingArray
      */
     public static function fromMappingArrayAndName(
         array $mappingArray,

src/NativeQuery.php

@@ -40,7 +40,15 @@ class NativeQuery extends AbstractQuery
         $types      = [];
 
         foreach ($this->getParameters() as $parameter) {
-            $name  = $parameter->getName();
+            $name = $parameter->getName();
+
+            if ($parameter->typeWasSpecified()) {
+                $parameters[$name] = $parameter->getValue();
+                $types[$name]      = $parameter->getType();
+
+                continue;
+            }
+
             $value = $this->processParameterValue($parameter->getValue());
             $type  = $parameter->getValue() === $value
                 ? $parameter->getType()

src/PersistentCollection.php

@@ -8,8 +8,8 @@ use Doctrine\Common\Collections\AbstractLazyCollection;
 use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\Common\Collections\Collection;
 use Doctrine\Common\Collections\Criteria;
+use Doctrine\Common\Collections\Order;
 use Doctrine\Common\Collections\Selectable;
-use Doctrine\ORM\Internal\CriteriaOrderings;
 use Doctrine\ORM\Mapping\AssociationMapping;
 use Doctrine\ORM\Mapping\ClassMetadata;
 use Doctrine\ORM\Mapping\ToManyAssociationMapping;
@@ -24,6 +24,7 @@ use function array_walk;
 use function assert;
 use function is_object;
 use function spl_object_id;
+use function strtoupper;
 
 /**
  * A PersistentCollection represents a collection of elements that have persistent state.
@@ -41,8 +42,6 @@ use function spl_object_id;
  */
 final class PersistentCollection extends AbstractLazyCollection implements Selectable
 {
-    use CriteriaOrderings;
-
     /**
      * A snapshot of the collection at the moment it was fetched from the database.
      * This is used to create a diff of the collection at commit time.
@@ -351,11 +350,6 @@ final class PersistentCollection extends AbstractLazyCollection implements Selec
         return parent::containsKey($key);
     }
 
-    /**
-     * {@inheritDoc}
-     *
-     * @template TMaybeContained
-     */
     public function contains(mixed $element): bool
     {
         if (! $this->initialized && $this->getMapping()->fetch === ClassMetadata::FETCH_EXTRA_LAZY) {
@@ -588,9 +582,12 @@ final class PersistentCollection extends AbstractLazyCollection implements Selec
 
         $criteria = clone $criteria;
         $criteria->where($expression);
-        $criteria->orderBy(self::mapToOrderEnumIfAvailable(
-            self::getCriteriaOrderings($criteria) ?: $association->orderBy(),
-        ));
+        $criteria->orderBy(
+            $criteria->orderings() ?: array_map(
+                static fn (string $order): Order => Order::from(strtoupper($order)),
+                $association->orderBy(),
+            ),
+        );
 
         $persister = $this->getUnitOfWork()->getEntityPersister($association->targetEntity);
 

src/Persisters/Collection/ManyToManyPersister.php

@@ -9,7 +9,6 @@ use Doctrine\Common\Collections\Criteria;
 use Doctrine\Common\Collections\Expr\Comparison;
 use Doctrine\DBAL\Exception as DBALException;
 use Doctrine\DBAL\LockMode;
-use Doctrine\ORM\Internal\CriteriaOrderings;
 use Doctrine\ORM\Mapping\AssociationMapping;
 use Doctrine\ORM\Mapping\ClassMetadata;
 use Doctrine\ORM\Mapping\InverseSideMapping;
@@ -33,8 +32,6 @@ use function sprintf;
  */
 class ManyToManyPersister extends AbstractCollectionPersister
 {
-    use CriteriaOrderings;
-
     public function delete(PersistentCollection $collection): void
     {
         $mapping = $this->getMapping($collection);
@@ -735,7 +732,7 @@ class ManyToManyPersister extends AbstractCollectionPersister
 
     private function getOrderingSql(Criteria $criteria, ClassMetadata $targetClass): string
     {
-        $orderings = self::getCriteriaOrderings($criteria);
+        $orderings = $criteria->orderings();
         if ($orderings) {
             $orderBy = [];
             foreach ($orderings as $name => $direction) {
@@ -744,7 +741,7 @@ class ManyToManyPersister extends AbstractCollectionPersister
                     $targetClass,
                     $this->platform,
                 );
-                $orderBy[] = $field . ' ' . $direction;
+                $orderBy[] = $field . ' ' . $direction->value;
             }
 
             return ' ORDER BY ' . implode(', ', $orderBy);

src/Persisters/Collection/OneToManyPersister.php

@@ -8,13 +8,18 @@ use BadMethodCallException;
 use Doctrine\Common\Collections\Criteria;
 use Doctrine\DBAL\Exception as DBALException;
 use Doctrine\DBAL\Types\Type;
+use Doctrine\ORM\EntityNotFoundException;
+use Doctrine\ORM\Mapping\MappingException;
 use Doctrine\ORM\Mapping\OneToManyAssociationMapping;
 use Doctrine\ORM\PersistentCollection;
 use Doctrine\ORM\Utility\PersisterHelper;
 
+use function array_fill;
+use function array_keys;
 use function array_reverse;
 use function array_values;
 use function assert;
+use function count;
 use function implode;
 use function is_int;
 use function is_string;
@@ -146,7 +151,11 @@ class OneToManyPersister extends AbstractCollectionPersister
         throw new BadMethodCallException('Filtering a collection by Criteria is not supported by this CollectionPersister.');
     }
 
-    /** @throws DBALException */
+    /**
+     * @throws DBALException
+     * @throws EntityNotFoundException
+     * @throws MappingException
+     */
     private function deleteEntityCollection(PersistentCollection $collection): int
     {
         $mapping     = $this->getMapping($collection);
@@ -166,6 +175,16 @@ class OneToManyPersister extends AbstractCollectionPersister
         $statement = 'DELETE FROM ' . $this->quoteStrategy->getTableName($targetClass, $this->platform)
             . ' WHERE ' . implode(' = ? AND ', $columns) . ' = ?';
 
+        if ($targetClass->isInheritanceTypeSingleTable()) {
+            $discriminatorColumn = $targetClass->getDiscriminatorColumn();
+            $discriminatorValues = $targetClass->discriminatorValue ? [$targetClass->discriminatorValue] : array_keys($targetClass->discriminatorMap);
+            $statement          .= ' AND ' . $discriminatorColumn->name . ' IN (' . implode(', ', array_fill(0, count($discriminatorValues), '?')) . ')';
+            foreach ($discriminatorValues as $discriminatorValue) {
+                $parameters[] = $discriminatorValue;
+                $types[]      = $discriminatorColumn->type;
+            }
+        }
+
         $numAffected = $this->conn->executeStatement($statement, $parameters, $types);
 
         assert(is_int($numAffected));

src/Persisters/Entity/BasicEntityPersister.php

@@ -7,6 +7,7 @@ namespace Doctrine\ORM\Persisters\Entity;
 use BackedEnum;
 use Doctrine\Common\Collections\Criteria;
 use Doctrine\Common\Collections\Expr\Comparison;
+use Doctrine\Common\Collections\Order;
 use Doctrine\DBAL\ArrayParameterType;
 use Doctrine\DBAL\Connection;
 use Doctrine\DBAL\LockMode;
@@ -16,7 +17,6 @@ use Doctrine\DBAL\Result;
 use Doctrine\DBAL\Types\Type;
 use Doctrine\DBAL\Types\Types;
 use Doctrine\ORM\EntityManagerInterface;
-use Doctrine\ORM\Internal\CriteriaOrderings;
 use Doctrine\ORM\Mapping\AssociationMapping;
 use Doctrine\ORM\Mapping\ClassMetadata;
 use Doctrine\ORM\Mapping\JoinColumnMapping;
@@ -98,7 +98,6 @@ use function trim;
  */
 class BasicEntityPersister implements EntityPersister
 {
-    use CriteriaOrderings;
     use LockSqlHelper;
 
     /** @var array<string,string> */
@@ -766,7 +765,7 @@ class BasicEntityPersister implements EntityPersister
         $targetClass = $this->em->getClassMetadata($assoc->targetEntity);
 
         if ($assoc->isOwningSide()) {
-            $isInverseSingleValued = $assoc->inversedBy && ! $targetClass->isCollectionValuedAssociation($assoc->inversedBy);
+            $isInverseSingleValued = $assoc->inversedBy !== null && ! $targetClass->isCollectionValuedAssociation($assoc->inversedBy);
 
             // Mark inverse side as fetched in the hints, otherwise the UoW would
             // try to load it in a separate query (remember: to-one inverse sides can not be lazy).
@@ -793,17 +792,42 @@ class BasicEntityPersister implements EntityPersister
 
         $computedIdentifier = [];
 
+        /** @var array<string,mixed>|null $sourceEntityData */
+        $sourceEntityData = null;
+
         // TRICKY: since the association is specular source and target are flipped
         foreach ($owningAssoc->targetToSourceKeyColumns as $sourceKeyColumn => $targetKeyColumn) {
             if (! isset($sourceClass->fieldNames[$sourceKeyColumn])) {
-                throw MappingException::joinColumnMustPointToMappedField(
-                    $sourceClass->name,
-                    $sourceKeyColumn,
-                );
-            }
+                // The likely case here is that the column is a join column
+                // in an association mapping. However, there is no guarantee
+                // at this point that a corresponding (generally identifying)
+                // association has been mapped in the source entity. To handle
+                // this case we directly reference the column-keyed data used
+                // to initialize the source entity before throwing an exception.
+                $resolvedSourceData = false;
+                if (! isset($sourceEntityData)) {
+                    $sourceEntityData = $this->em->getUnitOfWork()->getOriginalEntityData($sourceEntity);
+                }
 
-            $computedIdentifier[$targetClass->getFieldForColumn($targetKeyColumn)] =
-                $sourceClass->reflFields[$sourceClass->fieldNames[$sourceKeyColumn]]->getValue($sourceEntity);
+                if (isset($sourceEntityData[$sourceKeyColumn])) {
+                    $dataValue = $sourceEntityData[$sourceKeyColumn];
+                    if ($dataValue !== null) {
+                        $resolvedSourceData                                                    = true;
+                        $computedIdentifier[$targetClass->getFieldForColumn($targetKeyColumn)] =
+                            $dataValue;
+                    }
+                }
+
+                if (! $resolvedSourceData) {
+                    throw MappingException::joinColumnMustPointToMappedField(
+                        $sourceClass->name,
+                        $sourceKeyColumn,
+                    );
+                }
+            } else {
+                $computedIdentifier[$targetClass->getFieldForColumn($targetKeyColumn)] =
+                    $sourceClass->reflFields[$sourceClass->fieldNames[$sourceKeyColumn]]->getValue($sourceEntity);
+            }
         }
 
         $targetEntity = $this->load($computedIdentifier, null, $assoc);
@@ -844,7 +868,10 @@ class BasicEntityPersister implements EntityPersister
      */
     public function loadCriteria(Criteria $criteria): array
     {
-        $orderBy = self::getCriteriaOrderings($criteria);
+        $orderBy = array_map(
+            static fn (Order $order): string => $order->value,
+            $criteria->orderings(),
+        );
         $limit   = $criteria->getMaxResults();
         $offset  = $criteria->getFirstResult();
         $query   = $this->getSelectSQL($criteria, null, null, $limit, $offset, $orderBy);
@@ -1153,7 +1180,7 @@ class BasicEntityPersister implements EntityPersister
 
             if (isset($this->class->fieldMappings[$fieldName])) {
                 $tableAlias = isset($this->class->fieldMappings[$fieldName]->inherited)
-                    ? $this->getSQLTableAlias($this->class->fieldMappings[$fieldName]['inherited'])
+                    ? $this->getSQLTableAlias($this->class->fieldMappings[$fieldName]->inherited)
                     : $baseTableAlias;
 
                 $columnName    = $this->quoteStrategy->getColumnName($fieldName, $this->class, $this->platform);

src/Persisters/Entity/JoinedSubclassPersister.php

@@ -466,7 +466,7 @@ class JoinedSubclassPersister extends AbstractEntityInheritancePersister
                     || isset($this->class->associationMappings[$name]->inherited)
                     || ($this->class->isVersioned && $this->class->versionField === $name)
                     || isset($this->class->embeddedClasses[$name])
-                    || isset($this->class->fieldMappings[$name]['notInsertable'])
+                    || isset($this->class->fieldMappings[$name]->notInsertable)
             ) {
                 continue;
             }
@@ -519,9 +519,9 @@ class JoinedSubclassPersister extends AbstractEntityInheritancePersister
             $class = null;
             if ($this->class->isVersioned && $key === $versionedClass->versionField) {
                 $class = $versionedClass;
-            } elseif (isset($column['generated'])) {
-                $class = isset($column['inherited'])
-                    ? $this->em->getClassMetadata($column['inherited'])
+            } elseif (isset($column->generated)) {
+                $class = isset($column->inherited)
+                    ? $this->em->getClassMetadata($column->inherited)
                     : $this->class;
             } else {
                 continue;

src/Proxy/ProxyFactory.php

@@ -210,17 +210,16 @@ EOPHP;
     /**
      * Creates a closure capable of initializing a proxy
      *
-     * @return Closure(InternalProxy, InternalProxy):void
+     * @return Closure(InternalProxy, array):void
      *
      * @throws EntityNotFoundException
      */
     private function createLazyInitializer(ClassMetadata $classMetadata, EntityPersister $entityPersister, IdentifierFlattener $identifierFlattener): Closure
     {
-        return static function (InternalProxy $proxy, InternalProxy $original) use ($entityPersister, $classMetadata, $identifierFlattener): void {
-            $identifier = $classMetadata->getIdentifierValues($original);
-            $entity     = $entityPersister->loadById($identifier, $original);
+        return static function (InternalProxy $proxy, array $identifier) use ($entityPersister, $classMetadata, $identifierFlattener): void {
+            $original = $entityPersister->loadById($identifier);
 
-            if ($entity === null) {
+            if ($original === null) {
                 throw EntityNotFoundException::fromClassNameAndIdentifier(
                     $classMetadata->getName(),
                     $identifierFlattener->flattenIdentifier($classMetadata, $identifier),
@@ -234,11 +233,11 @@ EOPHP;
             $class = $entityPersister->getClassMetadata();
 
             foreach ($class->getReflectionProperties() as $property) {
-                if (! $property || ! $class->hasField($property->name) && ! $class->hasAssociation($property->name)) {
+                if (! $property || isset($identifier[$property->getName()]) || ! $class->hasField($property->getName()) && ! $class->hasAssociation($property->getName())) {
                     continue;
                 }
 
-                $property->setValue($proxy, $property->getValue($entity));
+                $property->setValue($proxy, $property->getValue($original));
             }
         };
     }
@@ -283,8 +282,8 @@ EOPHP;
         $identifierFields = array_intersect_key($class->getReflectionProperties(), $identifiers);
 
         $proxyFactory = Closure::bind(static function (array $identifier) use ($initializer, $skippedProperties, $identifierFields, $className): InternalProxy {
-            $proxy = self::createLazyGhost(static function (InternalProxy $object) use ($initializer, &$proxy): void {
-                $initializer($object, $proxy);
+            $proxy = self::createLazyGhost(static function (InternalProxy $object) use ($initializer, $identifier): void {
+                $initializer($object, $identifier);
             }, $skippedProperties);
 
             foreach ($identifierFields as $idField => $reflector) {
@@ -388,12 +387,18 @@ EOPHP;
         $code = substr($code, 7 + (int) strpos($code, "\n{"));
         $code = substr($code, 0, (int) strpos($code, "\n}"));
         $code = str_replace('LazyGhostTrait;', str_replace("\n    ", "\n", 'LazyGhostTrait {
-            initializeLazyObject as __load;
+            initializeLazyObject as private;
             setLazyObjectAsInitialized as public __setInitialized;
             isLazyObjectInitialized as private;
             createLazyGhost as private;
             resetLazyObject as private;
-        }'), $code);
+        }
+
+        public function __load(): void
+        {
+            $this->initializeLazyObject();
+        }
+        '), $code);
 
         return $code;
     }

src/Query.php

@@ -635,9 +635,10 @@ class Query extends AbstractQuery
     /**
      * Get the current lock mode for this query.
      *
-     * @return int|null The current lock mode of this query or NULL if no specific lock mode is set.
+     * @return LockMode|int|null The current lock mode of this query or NULL if no specific lock mode is set.
+     * @psalm-return LockMode::*|null
      */
-    public function getLockMode(): int|null
+    public function getLockMode(): LockMode|int|null
     {
         $lockMode = $this->getHint(self::HINT_LOCK_MODE);
 

src/Query/Expr.php

@@ -4,6 +4,7 @@ declare(strict_types=1);
 
 namespace Doctrine\ORM\Query;
 
+use Doctrine\ORM\Internal\NoUnknownNamedArguments;
 use Traversable;
 
 use function implode;
@@ -23,6 +24,8 @@ use function str_replace;
  */
 class Expr
 {
+    use NoUnknownNamedArguments;
+
     /**
      * Creates a conjunction of the given boolean expressions.
      *
@@ -38,6 +41,8 @@ class Expr
      */
     public function andX(Expr\Comparison|Expr\Func|Expr\Andx|Expr\Orx|string ...$x): Expr\Andx
     {
+        self::validateVariadicParameter($x);
+
         return new Expr\Andx($x);
     }
 
@@ -56,6 +61,8 @@ class Expr
      */
     public function orX(Expr\Comparison|Expr\Func|Expr\Andx|Expr\Orx|string ...$x): Expr\Orx
     {
+        self::validateVariadicParameter($x);
+
         return new Expr\Orx($x);
     }
 
@@ -225,6 +232,8 @@ class Expr
      */
     public function countDistinct(mixed ...$x): string
     {
+        self::validateVariadicParameter($x);
+
         return 'COUNT(DISTINCT ' . implode(', ', $x) . ')';
     }
 
@@ -470,6 +479,8 @@ class Expr
      */
     public function concat(mixed ...$x): Expr\Func
     {
+        self::validateVariadicParameter($x);
+
         return new Expr\Func('CONCAT', $x);
     }
 

src/Query/Parser.php

@@ -2563,7 +2563,10 @@ final class Parser
             return new AST\ParenthesisExpression($expr);
         }
 
-        assert($this->lexer->lookahead !== null);
+        if ($this->lexer->lookahead === null) {
+            $this->syntaxError('ArithmeticPrimary');
+        }
+
         switch ($this->lexer->lookahead->type) {
             case TokenType::T_COALESCE:
             case TokenType::T_NULLIF:

src/Query/ResultSetMappingBuilder.php

@@ -134,7 +134,7 @@ class ResultSetMappingBuilder extends ResultSetMapping implements Stringable
 
             $this->addFieldResult($alias, $columnAlias, $propertyName);
 
-            $enumType = $classMetadata->getFieldMapping($propertyName)['enumType'] ?? null;
+            $enumType = $classMetadata->getFieldMapping($propertyName)->enumType ?? null;
             if (! empty($enumType)) {
                 $this->addEnumResult($columnAlias, $enumType);
             }

src/Query/SqlWalker.php

@@ -30,6 +30,7 @@ use function count;
 use function implode;
 use function is_array;
 use function is_float;
+use function is_int;
 use function is_numeric;
 use function is_string;
 use function preg_match;
@@ -384,7 +385,9 @@ class SqlWalker
             $values = [];
 
             if ($class->discriminatorValue !== null) { // discriminators can be 0
-                $values[] = $conn->quote($class->discriminatorValue);
+                $values[] = $class->getDiscriminatorColumn()->type === 'integer' && is_int($class->discriminatorValue)
+                    ? $class->discriminatorValue
+                    : $conn->quote((string) $class->discriminatorValue);
             }
 
             foreach ($class->subClasses as $subclassName) {
@@ -396,7 +399,9 @@ class SqlWalker
                     continue;
                 }
 
-                $values[] = $conn->quote((string) $subclassMetadata->discriminatorValue);
+                $values[] = $subclassMetadata->getDiscriminatorColumn()->type === 'integer' && is_int($subclassMetadata->discriminatorValue)
+                    ? $subclassMetadata->discriminatorValue
+                    : $conn->quote((string) $subclassMetadata->discriminatorValue);
             }
 
             if ($values !== []) {
@@ -798,7 +803,7 @@ class SqlWalker
                 $class     = $this->getMetadataForDqlAlias($alias);
 
                 if (isset($class->associationMappings[$fieldName]->inherited)) {
-                    $class = $this->em->getClassMetadata($class->associationMappings[$fieldName]['inherited']);
+                    $class = $this->em->getClassMetadata($class->associationMappings[$fieldName]->inherited);
                 }
 
                 $association = $class->associationMappings[$fieldName];
@@ -906,7 +911,9 @@ class SqlWalker
             }
         }
 
-        if ($relation->fetch === ClassMetadata::FETCH_EAGER && $condExpr !== null) {
+        $fetchMode = $this->query->getHint('fetchMode')[$assoc->sourceEntity][$assoc->fieldName] ?? $relation->fetch;
+
+        if ($fetchMode === ClassMetadata::FETCH_EAGER && $condExpr !== null) {
             throw QueryException::eagerFetchJoinWithNotAllowed($assoc->sourceEntity, $assoc->fieldName);
         }
 
@@ -2246,8 +2253,10 @@ class SqlWalker
             $discriminators += HierarchyDiscriminatorResolver::resolveDiscriminatorsForClass($metadata, $this->em);
         }
 
-        foreach (array_keys($discriminators) as $dis) {
-            $sqlParameterList[] = $this->conn->quote($dis);
+        foreach (array_keys($discriminators) as $discriminatorValue) {
+            $sqlParameterList[] = $rootClass->getDiscriminatorColumn()->type === 'integer' && is_int($discriminatorValue)
+                ? $discriminatorValue
+                : $this->conn->quote((string) $discriminatorValue);
         }
 
         return '(' . implode(', ', $sqlParameterList) . ')';

src/QueryBuilder.php

@@ -8,7 +8,7 @@ use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\Common\Collections\Criteria;
 use Doctrine\DBAL\ArrayParameterType;
 use Doctrine\DBAL\ParameterType;
-use Doctrine\ORM\Internal\CriteriaOrderings;
+use Doctrine\ORM\Internal\NoUnknownNamedArguments;
 use Doctrine\ORM\Internal\QueryType;
 use Doctrine\ORM\Query\Expr;
 use Doctrine\ORM\Query\Parameter;
@@ -41,7 +41,7 @@ use function substr;
  */
 class QueryBuilder implements Stringable
 {
-    use CriteriaOrderings;
+    use NoUnknownNamedArguments;
 
     /**
      * The array of DQL parts collected.
@@ -616,6 +616,8 @@ class QueryBuilder implements Stringable
      */
     public function select(mixed ...$select): static
     {
+        self::validateVariadicParameter($select);
+
         $this->type = QueryType::Select;
 
         if ($select === []) {
@@ -662,6 +664,8 @@ class QueryBuilder implements Stringable
      */
     public function addSelect(mixed ...$select): static
     {
+        self::validateVariadicParameter($select);
+
         $this->type = QueryType::Select;
 
         if ($select === []) {
@@ -956,6 +960,8 @@ class QueryBuilder implements Stringable
      */
     public function where(mixed ...$predicates): static
     {
+        self::validateVariadicParameter($predicates);
+
         if (! (count($predicates) === 1 && $predicates[0] instanceof Expr\Composite)) {
             $predicates = new Expr\Andx($predicates);
         }
@@ -981,6 +987,8 @@ class QueryBuilder implements Stringable
      */
     public function andWhere(mixed ...$where): static
     {
+        self::validateVariadicParameter($where);
+
         $dql = $this->getDQLPart('where');
 
         if ($dql instanceof Expr\Andx) {
@@ -1011,6 +1019,8 @@ class QueryBuilder implements Stringable
      */
     public function orWhere(mixed ...$where): static
     {
+        self::validateVariadicParameter($where);
+
         $dql = $this->getDQLPart('where');
 
         if ($dql instanceof Expr\Orx) {
@@ -1038,6 +1048,8 @@ class QueryBuilder implements Stringable
      */
     public function groupBy(string ...$groupBy): static
     {
+        self::validateVariadicParameter($groupBy);
+
         return $this->add('groupBy', new Expr\GroupBy($groupBy));
     }
 
@@ -1056,6 +1068,8 @@ class QueryBuilder implements Stringable
      */
     public function addGroupBy(string ...$groupBy): static
     {
+        self::validateVariadicParameter($groupBy);
+
         return $this->add('groupBy', new Expr\GroupBy($groupBy), true);
     }
 
@@ -1067,6 +1081,8 @@ class QueryBuilder implements Stringable
      */
     public function having(mixed ...$having): static
     {
+        self::validateVariadicParameter($having);
+
         if (! (count($having) === 1 && ($having[0] instanceof Expr\Andx || $having[0] instanceof Expr\Orx))) {
             $having = new Expr\Andx($having);
         }
@@ -1082,6 +1098,8 @@ class QueryBuilder implements Stringable
      */
     public function andHaving(mixed ...$having): static
     {
+        self::validateVariadicParameter($having);
+
         $dql = $this->getDQLPart('having');
 
         if ($dql instanceof Expr\Andx) {
@@ -1102,6 +1120,8 @@ class QueryBuilder implements Stringable
      */
     public function orHaving(mixed ...$having): static
     {
+        self::validateVariadicParameter($having);
+
         $dql = $this->getDQLPart('having');
 
         if ($dql instanceof Expr\Orx) {
@@ -1167,7 +1187,7 @@ class QueryBuilder implements Stringable
             }
         }
 
-        foreach (self::getCriteriaOrderings($criteria) as $sort => $order) {
+        foreach ($criteria->orderings() as $sort => $order) {
             $hasValidAlias = false;
             foreach ($allAliases as $alias) {
                 if (str_starts_with($sort . '.', $alias . '.')) {
@@ -1180,7 +1200,7 @@ class QueryBuilder implements Stringable
                 $sort = $allAliases[0] . '.' . $sort;
             }
 
-            $this->addOrderBy($sort, $order);
+            $this->addOrderBy($sort, $order->value);
         }
 
         // Overwrite limits only if they was set in criteria

src/Tools/AttachEntityListenersListener.php

@@ -5,8 +5,10 @@ declare(strict_types=1);
 namespace Doctrine\ORM\Tools;
 
 use Doctrine\ORM\Event\LoadClassMetadataEventArgs;
+use Doctrine\ORM\Events;
 use Doctrine\ORM\Mapping\Builder\EntityListenerBuilder;
 
+use function assert;
 use function ltrim;
 
 /**
@@ -14,16 +16,22 @@ use function ltrim;
  */
 class AttachEntityListenersListener
 {
-    /** @var mixed[][] */
+    /**
+     * @var array<class-string, list<array{
+     *     event: Events::*|null,
+     *     class: class-string,
+     *     method: string|null,
+     * }>>
+     */
     private array $entityListeners = [];
 
     /**
      * Adds an entity listener for a specific entity.
      *
-     * @param string      $entityClass      The entity to attach the listener.
-     * @param string      $listenerClass    The listener class.
-     * @param string|null $eventName        The entity lifecycle event.
-     * @param string|null $listenerCallback The listener callback method or NULL to use $eventName.
+     * @param class-string          $entityClass      The entity to attach the listener.
+     * @param class-string          $listenerClass    The listener class.
+     * @param Events::*|null        $eventName        The entity lifecycle event.
+     * @param non-falsy-string|null $listenerCallback The listener callback method or NULL to use $eventName.
      */
     public function addEntityListener(
         string $entityClass,
@@ -34,7 +42,7 @@ class AttachEntityListenersListener
         $this->entityListeners[ltrim($entityClass, '\\')][] = [
             'event'  => $eventName,
             'class'  => $listenerClass,
-            'method' => $listenerCallback ?: $eventName,
+            'method' => $listenerCallback ?? $eventName,
         ];
     }
 
@@ -53,6 +61,7 @@ class AttachEntityListenersListener
             if ($listener['event'] === null) {
                 EntityListenerBuilder::bindEntityListener($metadata, $listener['class']);
             } else {
+                assert($listener['method'] !== null);
                 $metadata->addEntityListener($listener['event'], $listener['class'], $listener['method']);
             }
         }

src/Tools/Console/Command/SchemaTool/UpdateCommand.php

@@ -4,6 +4,7 @@ declare(strict_types=1);
 
 namespace Doctrine\ORM\Tools\Console\Command\SchemaTool;
 
+use Doctrine\Deprecations\Deprecation;
 use Doctrine\ORM\Tools\SchemaTool;
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Input\InputOption;
@@ -28,7 +29,7 @@ class UpdateCommand extends AbstractCommand
         $this->setName($this->name)
              ->setDescription('Executes (or dumps) the SQL needed to update the database schema to match the current mapping metadata')
              ->addOption('em', null, InputOption::VALUE_REQUIRED, 'Name of the entity manager to operate on')
-             ->addOption('complete', null, InputOption::VALUE_NONE, 'This option is a no-op and will be removed in 4.0')
+             ->addOption('complete', null, InputOption::VALUE_NONE, 'This option is a no-op, is deprecated and will be removed in 4.0')
              ->addOption('dump-sql', null, InputOption::VALUE_NONE, 'Dumps the generated SQL statements to the screen (does not execute them).')
              ->addOption('force', 'f', InputOption::VALUE_NONE, 'Causes the generated SQL statements to be physically executed against your database.')
              ->setHelp(<<<'EOT'
@@ -75,6 +76,15 @@ EOT);
     {
         $notificationUi = $ui->getErrorStyle();
 
+        if ($input->getOption('complete') === true) {
+            Deprecation::trigger(
+                'doctrine/orm',
+                'https://github.com/doctrine/orm/pull/11354',
+                'The --complete option is a no-op, is deprecated and will be removed in Doctrine ORM 4.0.',
+            );
+            $notificationUi->warning('The --complete option is a no-op, is deprecated and will be removed in Doctrine ORM 4.0.');
+        }
+
         $sqls = $schemaTool->getUpdateSchemaSql($metadatas);
 
         if (empty($sqls)) {

src/Tools/SchemaValidator.php

@@ -52,18 +52,18 @@ class SchemaValidator
      * It maps built-in Doctrine types to PHP types
      */
     private const BUILTIN_TYPES_MAP = [
-        AsciiStringType::class => 'string',
-        BigIntType::class => 'string',
-        BooleanType::class => 'bool',
-        DecimalType::class => 'string',
-        FloatType::class => 'float',
-        GuidType::class => 'string',
-        IntegerType::class => 'int',
-        JsonType::class => 'array',
-        SimpleArrayType::class => 'array',
-        SmallIntType::class => 'int',
-        StringType::class => 'string',
-        TextType::class => 'string',
+        AsciiStringType::class => ['string'],
+        BigIntType::class => ['int', 'string'],
+        BooleanType::class => ['bool'],
+        DecimalType::class => ['string'],
+        FloatType::class => ['float'],
+        GuidType::class => ['string'],
+        IntegerType::class => ['int'],
+        JsonType::class => ['array'],
+        SimpleArrayType::class => ['array'],
+        SmallIntType::class => ['int'],
+        StringType::class => ['string'],
+        TextType::class => ['string'],
     ];
 
     public function __construct(
@@ -162,7 +162,7 @@ class SchemaValidator
                 }
             }
 
-            if ($assoc->isOwningSide() && $assoc->inversedBy) {
+            if ($assoc->isOwningSide() && $assoc->inversedBy !== null) {
                 if ($targetMetadata->hasField($assoc->inversedBy)) {
                     $ce[] = 'The association ' . $class->name . '#' . $fieldName . ' refers to the inverse side ' .
                             'field ' . $assoc->targetEntity . '#' . $assoc->inversedBy . ' which is not defined as association.';
@@ -343,7 +343,7 @@ class SchemaValidator
                             return null;
                         }
 
-                        $metadataFieldType = $this->findBuiltInType(Type::getType($fieldMapping['type']));
+                        $metadataFieldType = $this->findBuiltInType(Type::getType($fieldMapping->type));
 
                         //If the metadata field type is not a mapped built-in type, we cannot check it
                         if ($metadataFieldType === null) {
@@ -353,25 +353,25 @@ class SchemaValidator
                         $propertyType = $propertyType->getName();
 
                         // If the property type is the same as the metadata field type, we are ok
-                        if ($propertyType === $metadataFieldType) {
+                        if (in_array($propertyType, $metadataFieldType, true)) {
                             return null;
                         }
 
                         if (is_a($propertyType, BackedEnum::class, true)) {
                             $backingType = (string) (new ReflectionEnum($propertyType))->getBackingType();
 
-                            if ($metadataFieldType !== $backingType) {
+                            if (! in_array($backingType, $metadataFieldType, true)) {
                                 return sprintf(
                                     "The field '%s#%s' has the property type '%s' with a backing type of '%s' that differs from the metadata field type '%s'.",
                                     $class->name,
                                     $fieldName,
                                     $propertyType,
                                     $backingType,
-                                    $metadataFieldType,
+                                    implode('|', $metadataFieldType),
                                 );
                             }
 
-                            if (! isset($fieldMapping['enumType']) || $propertyType === $fieldMapping['enumType']) {
+                            if (! isset($fieldMapping->enumType) || $propertyType === $fieldMapping->enumType) {
                                 return null;
                             }
 
@@ -380,19 +380,19 @@ class SchemaValidator
                                 $class->name,
                                 $fieldName,
                                 $propertyType,
-                                $fieldMapping['enumType'],
+                                $fieldMapping->enumType,
                             );
                         }
 
                         if (
-                            isset($fieldMapping['enumType'])
-                            && $propertyType !== $fieldMapping['enumType']
+                            isset($fieldMapping->enumType)
+                            && $propertyType !== $fieldMapping->enumType
                             && interface_exists($propertyType)
-                            && is_a($fieldMapping['enumType'], $propertyType, true)
+                            && is_a($fieldMapping->enumType, $propertyType, true)
                         ) {
-                            $backingType = (string) (new ReflectionEnum($fieldMapping['enumType']))->getBackingType();
+                            $backingType = (string) (new ReflectionEnum($fieldMapping->enumType))->getBackingType();
 
-                            if ($metadataFieldType === $backingType) {
+                            if (in_array($backingType, $metadataFieldType, true)) {
                                 return null;
                             }
 
@@ -400,14 +400,14 @@ class SchemaValidator
                                 "The field '%s#%s' has the metadata enumType '%s' with a backing type of '%s' that differs from the metadata field type '%s'.",
                                 $class->name,
                                 $fieldName,
-                                $fieldMapping['enumType'],
+                                $fieldMapping->enumType,
                                 $backingType,
-                                $metadataFieldType,
+                                implode('|', $metadataFieldType),
                             );
                         }
 
                         if (
-                            $fieldMapping['type'] === 'json'
+                            $fieldMapping->type === 'json'
                             && in_array($propertyType, ['string', 'int', 'float', 'bool', 'true', 'false', 'null'], true)
                         ) {
                             return null;
@@ -418,8 +418,8 @@ class SchemaValidator
                             $class->name,
                             $fieldName,
                             $propertyType,
-                            $metadataFieldType,
-                            $fieldMapping['type'],
+                            implode('|', $metadataFieldType),
+                            $fieldMapping->type,
                         );
                     },
                     $class->fieldMappings,
@@ -431,8 +431,10 @@ class SchemaValidator
     /**
      * The exact DBAL type must be used (no subclasses), since consumers of doctrine/orm may have their own
      * customization around field types.
+     *
+     * @return list<string>|null
      */
-    private function findBuiltInType(Type $type): string|null
+    private function findBuiltInType(Type $type): array|null
     {
         $typeName = $type::class;
 

src/UnitOfWork.php

@@ -997,7 +997,7 @@ class UnitOfWork implements PropertyChangedListener
         foreach ($actualData as $propName => $actualValue) {
             $orgValue = $originalData[$propName] ?? null;
 
-            if (isset($class->fieldMappings[$propName]['enumType'])) {
+            if (isset($class->fieldMappings[$propName]->enumType)) {
                 if (is_array($orgValue)) {
                     foreach ($orgValue as $id => $val) {
                         if ($val instanceof BackedEnum) {
@@ -1143,6 +1143,8 @@ class UnitOfWork implements PropertyChangedListener
         $eventsToDispatch = [];
 
         foreach ($entities as $entity) {
+            $this->removeFromIdentityMap($entity);
+
             $oid       = spl_object_id($entity);
             $class     = $this->em->getClassMetadata($entity::class);
             $persister = $this->getEntityPersister($class->name);
@@ -1267,16 +1269,16 @@ class UnitOfWork implements PropertyChangedListener
                 }
 
                 $joinColumns = reset($assoc->joinColumns);
-                if (! isset($joinColumns['onDelete'])) {
+                if (! isset($joinColumns->onDelete)) {
                     continue;
                 }
 
-                $onDeleteOption = strtolower($joinColumns['onDelete']);
+                $onDeleteOption = strtolower($joinColumns->onDelete);
                 if ($onDeleteOption !== 'cascade') {
                     continue;
                 }
 
-                $targetEntity = $class->getFieldValue($entity, $assoc['fieldName']);
+                $targetEntity = $class->getFieldValue($entity, $assoc->fieldName);
 
                 // If the association does not refer to another entity or that entity
                 // is not to be deleted, there is no ordering problem and we can
@@ -1484,8 +1486,6 @@ class UnitOfWork implements PropertyChangedListener
             return;
         }
 
-        $this->removeFromIdentityMap($entity);
-
         unset($this->entityUpdates[$oid]);
 
         if (! isset($this->entityDeletions[$oid])) {
@@ -1557,18 +1557,15 @@ class UnitOfWork implements PropertyChangedListener
      */
     final public static function getIdHashByIdentifier(array $identifier): string
     {
+        foreach ($identifier as $k => $value) {
+            if ($value instanceof BackedEnum) {
+                $identifier[$k] = $value->value;
+            }
+        }
+
         return implode(
             ' ',
-            array_map(
-                static function ($value) {
-                    if ($value instanceof BackedEnum) {
-                        return $value->value;
-                    }
-
-                    return $value;
-                },
-                $identifier,
-            ),
+            $identifier,
         );
     }
 
@@ -2470,10 +2467,7 @@ class UnitOfWork implements PropertyChangedListener
                             } else {
                                 $associatedId[$targetClass->fieldNames[$targetColumn]] = $joinColumnValue;
                             }
-                        } elseif (
-                            $targetClass->containsForeignIdentifier
-                            && in_array($targetClass->getFieldForColumn($targetColumn), $targetClass->identifier, true)
-                        ) {
+                        } elseif (in_array($targetClass->getFieldForColumn($targetColumn), $targetClass->identifier, true)) {
                             // the missing key is part of target's entity primary key
                             $associatedId = [];
                             break;
@@ -2550,7 +2544,7 @@ class UnitOfWork implements PropertyChangedListener
                     $this->originalEntityData[$oid][$field] = $newValue;
                     $class->reflFields[$field]->setValue($entity, $newValue);
 
-                    if ($assoc->inversedBy && $assoc->isOneToOne() && $newValue !== null) {
+                    if ($assoc->inversedBy !== null && $assoc->isOneToOne() && $newValue !== null) {
                         $inverseAssoc = $targetClass->associationMappings[$assoc->inversedBy];
                         $targetClass->reflFields[$inverseAssoc->fieldName]->setValue($newValue, $entity);
                     }
@@ -2584,9 +2578,9 @@ class UnitOfWork implements PropertyChangedListener
 
                     if ($hints['fetchMode'][$class->name][$field] === ClassMetadata::FETCH_EAGER) {
                         $isIteration = isset($hints[Query::HINT_INTERNAL_ITERATION]) && $hints[Query::HINT_INTERNAL_ITERATION];
-                        if (! $isIteration && $assoc->isOneToMany()) {
+                        if (! $isIteration && $assoc->isOneToMany() && ! $targetClass->isIdentifierComposite && ! $assoc->isIndexed()) {
                             $this->scheduleCollectionForBatchLoading($pColl, $class);
-                        } elseif (($isIteration && $assoc->isOneToMany()) || $assoc->isManyToMany()) {
+                        } else {
                             $this->loadCollection($pColl);
                             $pColl->takeSnapshot();
                         }
@@ -2656,7 +2650,7 @@ class UnitOfWork implements PropertyChangedListener
                 $entities[] = $collection->getOwner();
             }
 
-            $found = $this->getEntityPersister($targetEntity)->loadAll([$mappedBy => $entities]);
+            $found = $this->getEntityPersister($targetEntity)->loadAll([$mappedBy => $entities], $mapping->orderBy);
 
             $targetClass    = $this->em->getClassMetadata($targetEntity);
             $targetProperty = $targetClass->getReflectionProperty($mappedBy);
@@ -2665,7 +2659,19 @@ class UnitOfWork implements PropertyChangedListener
             foreach ($found as $targetValue) {
                 $sourceEntity = $targetProperty->getValue($targetValue);
 
-                $id     = $this->identifierFlattener->flattenIdentifier($class, $class->getIdentifierValues($sourceEntity));
+                if ($sourceEntity === null && isset($targetClass->associationMappings[$mappedBy]->joinColumns)) {
+                    // case where the hydration $targetValue itself has not yet fully completed, for example
+                    // in case a bi-directional association is being hydrated and deferring eager loading is
+                    // not possible due to subclassing.
+                    $data = $this->getOriginalEntityData($targetValue);
+                    $id   = [];
+                    foreach ($targetClass->associationMappings[$mappedBy]->joinColumns as $joinColumn) {
+                        $id[] = $data[$joinColumn->name];
+                    }
+                } else {
+                    $id = $this->identifierFlattener->flattenIdentifier($class, $class->getIdentifierValues($sourceEntity));
+                }
+
                 $idHash = implode(' ', $id);
 
                 if ($mapping->indexBy !== null) {
@@ -2713,7 +2719,7 @@ class UnitOfWork implements PropertyChangedListener
     private function scheduleCollectionForBatchLoading(PersistentCollection $collection, ClassMetadata $sourceClass): void
     {
         $mapping = $collection->getMapping();
-        $name    = $mapping['sourceEntity'] . '#' . $mapping['fieldName'];
+        $name    = $mapping->sourceEntity . '#' . $mapping->fieldName;
 
         if (! isset($this->eagerLoadingCollections[$name])) {
             $this->eagerLoadingCollections[$name] = [

tests/Performance/ArrayResultFactory.php

@@ -1,18 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Doctrine\Performance;
-
-use Doctrine\DBAL\Cache\ArrayResult;
-use Doctrine\DBAL\Connection;
-use Doctrine\DBAL\Driver\PDO\SQLite\Driver;
-use Doctrine\DBAL\Result;
-
-final class ArrayResultFactory
-{
-    public static function createFromArray(array $resultSet): Result
-    {
-        return new Result(new ArrayResult($resultSet), new Connection([], new Driver()));
-    }
-}

tests/Performance/EntityManagerFactory.php

@@ -5,7 +5,6 @@ declare(strict_types=1);
 namespace Doctrine\Performance;
 
 use Doctrine\Common\EventManager;
-use Doctrine\DBAL\Cache\ArrayResult;
 use Doctrine\DBAL\Cache\QueryCacheProfile;
 use Doctrine\DBAL\Connection;
 use Doctrine\DBAL\Driver\PDO\SQLite\Driver;
@@ -17,6 +16,7 @@ use Doctrine\ORM\EntityManagerInterface;
 use Doctrine\ORM\Mapping\Driver\AttributeDriver;
 use Doctrine\ORM\Proxy\ProxyFactory;
 use Doctrine\ORM\Tools\SchemaTool;
+use Doctrine\Tests\Mocks\ArrayResultFactory;
 use Doctrine\Tests\TestUtil;
 
 use function array_map;
@@ -67,7 +67,7 @@ final class EntityManagerFactory
             /** {@inheritDoc} */
             public function executeQuery(string $sql, array $params = [], $types = [], QueryCacheProfile|null $qcp = null): Result
             {
-                return new Result(new ArrayResult([]), $this);
+                return ArrayResultFactory::createWrapperResultFromArray([], $this);
             }
         };
 

tests/Performance/Hydration/MixedQueryFetchJoinArrayHydrationPerformanceBench.php

@@ -7,8 +7,8 @@ namespace Doctrine\Performance\Hydration;
 use Doctrine\DBAL\Result;
 use Doctrine\ORM\Internal\Hydration\ArrayHydrator;
 use Doctrine\ORM\Query\ResultSetMapping;
-use Doctrine\Performance\ArrayResultFactory;
 use Doctrine\Performance\EntityManagerFactory;
+use Doctrine\Tests\Mocks\ArrayResultFactory;
 use Doctrine\Tests\Models\CMS\CmsPhonenumber;
 use Doctrine\Tests\Models\CMS\CmsUser;
 use PhpBench\Benchmark\Metadata\Annotations\BeforeMethods;
@@ -62,7 +62,7 @@ final class MixedQueryFetchJoinArrayHydrationPerformanceBench
             ];
         }
 
-        $this->result   = ArrayResultFactory::createFromArray($resultSet);
+        $this->result   = ArrayResultFactory::createWrapperResultFromArray($resultSet);
         $this->hydrator = new ArrayHydrator(EntityManagerFactory::getEntityManager([]));
         $this->rsm      = new ResultSetMapping();
 

tests/Performance/Hydration/MixedQueryFetchJoinFullObjectHydrationPerformanceBench.php

@@ -7,8 +7,8 @@ namespace Doctrine\Performance\Hydration;
 use Doctrine\DBAL\Result;
 use Doctrine\ORM\Internal\Hydration\ObjectHydrator;
 use Doctrine\ORM\Query\ResultSetMapping;
-use Doctrine\Performance\ArrayResultFactory;
 use Doctrine\Performance\EntityManagerFactory;
+use Doctrine\Tests\Mocks\ArrayResultFactory;
 use Doctrine\Tests\Models\CMS\CmsAddress;
 use Doctrine\Tests\Models\CMS\CmsPhonenumber;
 use Doctrine\Tests\Models\CMS\CmsUser;
@@ -49,7 +49,7 @@ final class MixedQueryFetchJoinFullObjectHydrationPerformanceBench
             ];
         }
 
-        $this->result   = ArrayResultFactory::createFromArray($resultSet);
+        $this->result   = ArrayResultFactory::createWrapperResultFromArray($resultSet);
         $this->hydrator = new ObjectHydrator(EntityManagerFactory::getEntityManager([]));
         $this->rsm      = new ResultSetMapping();
 

tests/Performance/Hydration/SimpleQueryArrayHydrationPerformanceBench.php

@@ -7,8 +7,8 @@ namespace Doctrine\Performance\Hydration;
 use Doctrine\DBAL\Result;
 use Doctrine\ORM\Internal\Hydration\ArrayHydrator;
 use Doctrine\ORM\Query\ResultSetMapping;
-use Doctrine\Performance\ArrayResultFactory;
 use Doctrine\Performance\EntityManagerFactory;
+use Doctrine\Tests\Mocks\ArrayResultFactory;
 use Doctrine\Tests\Models\CMS\CmsUser;
 use PhpBench\Benchmark\Metadata\Annotations\BeforeMethods;
 
@@ -53,7 +53,7 @@ final class SimpleQueryArrayHydrationPerformanceBench
             ];
         }
 
-        $this->result   = ArrayResultFactory::createFromArray($resultSet);
+        $this->result   = ArrayResultFactory::createWrapperResultFromArray($resultSet);
         $this->hydrator = new ArrayHydrator(EntityManagerFactory::getEntityManager([]));
         $this->rsm      = new ResultSetMapping();
 

tests/Performance/Hydration/SimpleQueryFullObjectHydrationPerformanceBench.php

@@ -7,8 +7,8 @@ namespace Doctrine\Performance\Hydration;
 use Doctrine\DBAL\Result;
 use Doctrine\ORM\Internal\Hydration\ObjectHydrator;
 use Doctrine\ORM\Query\ResultSetMapping;
-use Doctrine\Performance\ArrayResultFactory;
 use Doctrine\Performance\EntityManagerFactory;
+use Doctrine\Tests\Mocks\ArrayResultFactory;
 use Doctrine\Tests\Models\CMS\CmsAddress;
 use Doctrine\Tests\Models\CMS\CmsUser;
 use PhpBench\Benchmark\Metadata\Annotations\BeforeMethods;
@@ -44,7 +44,7 @@ final class SimpleQueryFullObjectHydrationPerformanceBench
             ];
         }
 
-        $this->result   = ArrayResultFactory::createFromArray($resultSet);
+        $this->result   = ArrayResultFactory::createWrapperResultFromArray($resultSet);
         $this->hydrator = new ObjectHydrator(EntityManagerFactory::getEntityManager([]));
         $this->rsm      = new ResultSetMapping();
 

tests/Performance/Hydration/SimpleQueryScalarHydrationPerformanceBench.php

@@ -7,8 +7,8 @@ namespace Doctrine\Performance\Hydration;
 use Doctrine\DBAL\Result;
 use Doctrine\ORM\Internal\Hydration\ScalarHydrator;
 use Doctrine\ORM\Query\ResultSetMapping;
-use Doctrine\Performance\ArrayResultFactory;
 use Doctrine\Performance\EntityManagerFactory;
+use Doctrine\Tests\Mocks\ArrayResultFactory;
 use Doctrine\Tests\Models\CMS\CmsUser;
 use PhpBench\Benchmark\Metadata\Annotations\BeforeMethods;
 
@@ -53,7 +53,7 @@ final class SimpleQueryScalarHydrationPerformanceBench
             ];
         }
 
-        $this->result   = ArrayResultFactory::createFromArray($resultSet);
+        $this->result   = ArrayResultFactory::createWrapperResultFromArray($resultSet);
         $this->hydrator = new ScalarHydrator(EntityManagerFactory::getEntityManager([]));
         $this->rsm      = new ResultSetMapping();
 

tests/Performance/Mock/NonLoadingPersister.php

@@ -4,8 +4,7 @@ declare(strict_types=1);
 
 namespace Doctrine\Performance\Mock;
 
-use Doctrine\DBAL\LockMode;
-use Doctrine\ORM\Mapping\AssociationMapping;
+use Doctrine\ORM\Mapping\ClassMetadata;
 use Doctrine\ORM\Persisters\Entity\BasicEntityPersister;
 
 /**
@@ -13,22 +12,14 @@ use Doctrine\ORM\Persisters\Entity\BasicEntityPersister;
  */
 class NonLoadingPersister extends BasicEntityPersister
 {
-    public function __construct()
-    {
+    public function __construct(
+        ClassMetadata $class,
+    ) {
+        $this->class = $class;
     }
 
-    /**
-     * {@inheritDoc}
-     */
-    public function load(
-        array $criteria,
-        object|null $entity = null,
-        AssociationMapping|null $assoc = null,
-        array $hints = [],
-        LockMode|int|null $lockMode = null,
-        int|null $limit = null,
-        array|null $orderBy = null,
-    ): object|null {
-        return $entity;
+    public function loadById(array $identifier, object|null $entity = null): object|null
+    {
+        return $entity ?? new ($this->class->name)();
     }
 }

tests/Performance/Mock/NonProxyLoadingEntityManager.php

@@ -57,7 +57,7 @@ class NonProxyLoadingEntityManager implements EntityManagerInterface
 
     public function getUnitOfWork(): UnitOfWork
     {
-        return new NonProxyLoadingUnitOfWork();
+        return new NonProxyLoadingUnitOfWork($this);
     }
 
     public function getCache(): Cache|null

tests/Performance/Mock/NonProxyLoadingUnitOfWork.php

@@ -4,6 +4,7 @@ declare(strict_types=1);
 
 namespace Doctrine\Performance\Mock;
 
+use Doctrine\ORM\EntityManagerInterface;
 use Doctrine\ORM\UnitOfWork;
 
 /**
@@ -11,15 +12,17 @@ use Doctrine\ORM\UnitOfWork;
  */
 class NonProxyLoadingUnitOfWork extends UnitOfWork
 {
-    private NonLoadingPersister $entityPersister;
+    /** @var array<class-string, NonLoadingPersister> */
+    private array $entityPersisters = [];
 
-    public function __construct()
-    {
-        $this->entityPersister = new NonLoadingPersister();
+    public function __construct(
+        private EntityManagerInterface $entityManager,
+    ) {
     }
 
     public function getEntityPersister(string $entityName): NonLoadingPersister
     {
-        return $this->entityPersister;
+        return $this->entityPersisters[$entityName]
+            ??= new NonLoadingPersister($this->entityManager->getClassMetadata($entityName));
     }
 }

tests/Tests/Mocks/ArrayResultFactory.php

@@ -0,0 +1,42 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Tests\Mocks;
+
+use Doctrine\DBAL\Cache\ArrayResult;
+use Doctrine\DBAL\Connection;
+use Doctrine\DBAL\Driver\PDO\SQLite\Driver;
+use Doctrine\DBAL\Result;
+use ReflectionMethod;
+
+use function array_keys;
+use function array_map;
+use function array_values;
+
+final class ArrayResultFactory
+{
+    /** @param list<array<string, mixed>> $resultSet */
+    public static function createDriverResultFromArray(array $resultSet): ArrayResult
+    {
+        if ((new ReflectionMethod(ArrayResult::class, '__construct'))->getNumberOfRequiredParameters() < 2) {
+            // DBAL < 4.2
+            return new ArrayResult($resultSet);
+        }
+
+        // DBAL 4.2+
+        return new ArrayResult(
+            array_keys($resultSet[0] ?? []),
+            array_map(array_values(...), $resultSet),
+        );
+    }
+
+    /** @param list<array<string, mixed>> $resultSet */
+    public static function createWrapperResultFromArray(array $resultSet, Connection|null $connection = null): Result
+    {
+        return new Result(
+            self::createDriverResultFromArray($resultSet),
+            $connection ?? new Connection([], new Driver()),
+        );
+    }
+}

tests/Tests/Models/AbstractFetchEager/AbstractRemoteControl.php

@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Tests\Models\AbstractFetchEager;
+
+use Doctrine\Common\Collections\ArrayCollection;
+use Doctrine\Common\Collections\Collection;
+use Doctrine\ORM\Mapping as ORM;
+
+#[ORM\Entity]
+#[ORM\Table(name: 'abstract_fetch_eager_remote_control')]
+#[ORM\InheritanceType('SINGLE_TABLE')]
+#[ORM\DiscriminatorColumn(name: 'type', type: 'string')]
+#[ORM\DiscriminatorMap(['mobile' => 'MobileRemoteControl'])]
+abstract class AbstractRemoteControl
+{
+    #[ORM\Id]
+    #[ORM\GeneratedValue]
+    #[ORM\Column(type: 'integer')]
+    public int $id;
+
+    #[ORM\Column(type: 'string')]
+    public string $name;
+
+    /** @var Collection<User> */
+    #[ORM\OneToMany(targetEntity: User::class, mappedBy: 'remoteControl', fetch: 'EAGER')]
+    public Collection $users;
+
+    public function __construct(string $name)
+    {
+        $this->name  = $name;
+        $this->users = new ArrayCollection();
+    }
+}

tests/Tests/Models/AbstractFetchEager/MobileRemoteControl.php

@@ -0,0 +1,12 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Tests\Models\AbstractFetchEager;
+
+use Doctrine\ORM\Mapping as ORM;
+
+#[ORM\Entity]
+class MobileRemoteControl extends AbstractRemoteControl
+{
+}

tests/Tests/Models/AbstractFetchEager/User.php

@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Tests\Models\AbstractFetchEager;
+
+use Doctrine\ORM\Mapping as ORM;
+
+#[ORM\Entity]
+#[ORM\Table(name: 'abstract_fetch_eager_user')]
+class User
+{
+    #[ORM\Id]
+    #[ORM\GeneratedValue]
+    #[ORM\Column(type: 'integer')]
+    public int $id;
+
+    #[ORM\ManyToOne(targetEntity: AbstractRemoteControl::class, inversedBy: 'users')]
+    #[ORM\JoinColumn(nullable: false)]
+    public AbstractRemoteControl $remoteControl;
+
+    public function __construct(AbstractRemoteControl $control)
+    {
+        $this->remoteControl = $control;
+    }
+}

tests/Tests/Models/BigIntegers/BigIntegers.php

@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Tests\Models\BigIntegers;
+
+use Doctrine\DBAL\Types\Types;
+use Doctrine\ORM\Mapping as ORM;
+
+#[ORM\Entity]
+class BigIntegers
+{
+    #[ORM\Column]
+    #[ORM\Id]
+    #[ORM\GeneratedValue]
+    public int|null $id = null;
+
+    #[ORM\Column(type: Types::BIGINT)]
+    public int $one = 1;
+
+    #[ORM\Column(type: Types::BIGINT)]
+    public string $two = '2';
+
+    #[ORM\Column(type: Types::BIGINT)]
+    public float $three = 3.0;
+}

tests/Tests/Models/CompositeKeyRelations/CustomerClass.php

@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Tests\Models\CompositeKeyRelations;
+
+use Doctrine\ORM\Mapping\Column;
+use Doctrine\ORM\Mapping\Entity;
+use Doctrine\ORM\Mapping\Id;
+
+#[Entity]
+class CustomerClass
+{
+    #[Id]
+    #[Column(type: 'string')]
+    public string $companyCode;
+
+    #[Id]
+    #[Column(type: 'string')]
+    public string $code;
+
+    #[Column(type: 'string')]
+    public string $name;
+}

tests/Tests/Models/CompositeKeyRelations/InvoiceClass.php

@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Tests\Models\CompositeKeyRelations;
+
+use Doctrine\ORM\Mapping\Column;
+use Doctrine\ORM\Mapping\Entity;
+use Doctrine\ORM\Mapping\Id;
+use Doctrine\ORM\Mapping\JoinColumn;
+use Doctrine\ORM\Mapping\ManyToOne;
+
+#[Entity]
+class InvoiceClass
+{
+    #[Id]
+    #[Column(type: 'string')]
+    public string $companyCode;
+
+    #[Id]
+    #[Column(type: 'string')]
+    public string $invoiceNumber;
+
+    #[ManyToOne(targetEntity: CustomerClass::class)]
+    #[JoinColumn(name: 'companyCode', referencedColumnName: 'companyCode')]
+    #[JoinColumn(name: 'customerCode', referencedColumnName: 'code')]
+    public CustomerClass|null $customer;
+
+    #[Column(type: 'string', nullable: true)]
+    public string|null $customerCode = null;
+}

tests/Tests/Models/ECommerce/ECommerceProduct2.php

@@ -0,0 +1,46 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Tests\Models\ECommerce;
+
+use Doctrine\ORM\Mapping\Column;
+use Doctrine\ORM\Mapping\Entity;
+use Doctrine\ORM\Mapping\GeneratedValue;
+use Doctrine\ORM\Mapping\Id;
+use Doctrine\ORM\Mapping\Index;
+use Doctrine\ORM\Mapping\Table;
+
+/**
+ * ECommerceProduct2
+ * Resets the id when being cloned.
+ */
+#[Entity]
+#[Table(name: 'ecommerce_products')]
+#[Index(name: 'name_idx', columns: ['name'])]
+class ECommerceProduct2
+{
+    #[Column]
+    #[Id]
+    #[GeneratedValue]
+    private int|null $id = null;
+
+    #[Column(length: 50, nullable: true)]
+    private string|null $name = null;
+
+    public function getId(): int|null
+    {
+        return $this->id;
+    }
+
+    public function getName(): string|null
+    {
+        return $this->name;
+    }
+
+    public function __clone()
+    {
+        $this->id   = null;
+        $this->name = 'Clone of ' . $this->name;
+    }
+}

tests/Tests/Models/EagerFetchedCompositeOneToMany/RootEntity.php

@@ -0,0 +1,43 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Tests\Models\EagerFetchedCompositeOneToMany;
+
+use Doctrine\Common\Collections\ArrayCollection;
+use Doctrine\Common\Collections\Collection;
+use Doctrine\ORM\Mapping as ORM;
+
+#[ORM\Entity]
+#[ORM\Table(name: 'eager_composite_join_root')]
+class RootEntity
+{
+    #[ORM\Id]
+    #[ORM\Column(type: 'integer', nullable: false)]
+    private int|null $id = null;
+
+    #[ORM\Id]
+    #[ORM\Column(type: 'string', nullable: false, name: 'other_key', length: 42)]
+    private string $otherKey;
+
+    /** @var Collection<int, SecondLevel> */
+    #[ORM\OneToMany(mappedBy: 'root', targetEntity: SecondLevel::class, fetch: 'EAGER')]
+    private Collection $secondLevel;
+
+    public function __construct(int $id, string $other)
+    {
+        $this->otherKey    = $other;
+        $this->secondLevel = new ArrayCollection();
+        $this->id          = $id;
+    }
+
+    public function getId(): int|null
+    {
+        return $this->id;
+    }
+
+    public function getOtherKey(): string
+    {
+        return $this->otherKey;
+    }
+}

tests/Tests/Models/EagerFetchedCompositeOneToMany/SecondLevel.php

@@ -0,0 +1,38 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Tests\Models\EagerFetchedCompositeOneToMany;
+
+use Doctrine\ORM\Mapping as ORM;
+
+#[ORM\Entity]
+#[ORM\Table(name: 'eager_composite_join_second_level')]
+#[ORM\Index(name: 'root_other_key_idx', columns: ['root_other_key', 'root_id'])]
+class SecondLevel
+{
+    #[ORM\Id]
+    #[ORM\Column(type: 'integer', nullable: false)]
+    private int|null $upperId;
+
+    #[ORM\Id]
+    #[ORM\Column(type: 'string', nullable: false, name: 'other_key')]
+    private string $otherKey;
+
+    #[ORM\ManyToOne(targetEntity: RootEntity::class, inversedBy: 'secondLevel')]
+    #[ORM\JoinColumn(name: 'root_id', referencedColumnName: 'id')]
+    #[ORM\JoinColumn(name: 'root_other_key', referencedColumnName: 'other_key')]
+    private RootEntity $root;
+
+    public function __construct(RootEntity $upper)
+    {
+        $this->upperId  = $upper->getId();
+        $this->otherKey = $upper->getOtherKey();
+        $this->root     = $upper;
+    }
+
+    public function getId(): int|null
+    {
+        return $this->id;
+    }
+}

tests/Tests/Models/OneToOneInverseSideWithAssociativeIdLoad/InverseSide.php

@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Tests\Models\OneToOneInverseSideWithAssociativeIdLoad;
+
+use Doctrine\ORM\Mapping\Entity;
+use Doctrine\ORM\Mapping\Id;
+use Doctrine\ORM\Mapping\JoinColumn;
+use Doctrine\ORM\Mapping\OneToOne;
+use Doctrine\ORM\Mapping\Table;
+
+#[Entity]
+#[Table(name: 'one_to_one_inverse_side_assoc_id_load_inverse')]
+class InverseSide
+{
+    /** Associative id (owning identifier) */
+    #[Id]
+    #[OneToOne(targetEntity: InverseSideIdTarget::class, inversedBy: 'inverseSide')]
+    #[JoinColumn(nullable: false, name: 'associativeId')]
+    public InverseSideIdTarget $associativeId;
+
+    #[OneToOne(targetEntity: OwningSide::class, mappedBy: 'inverse')]
+    public OwningSide $owning;
+}

tests/Tests/Models/OneToOneInverseSideWithAssociativeIdLoad/InverseSideIdTarget.php

@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Tests\Models\OneToOneInverseSideWithAssociativeIdLoad;
+
+use Doctrine\ORM\Mapping\Column;
+use Doctrine\ORM\Mapping\Entity;
+use Doctrine\ORM\Mapping\GeneratedValue;
+use Doctrine\ORM\Mapping\Id;
+use Doctrine\ORM\Mapping\OneToOne;
+use Doctrine\ORM\Mapping\Table;
+
+#[Entity]
+#[Table(name: 'one_to_one_inverse_side_assoc_id_load_inverse_id_target')]
+class InverseSideIdTarget
+{
+    #[Id]
+    #[Column(type: 'string', length: 255)]
+    #[GeneratedValue(strategy: 'NONE')]
+    public string $id;
+
+    #[OneToOne(targetEntity: InverseSide::class, mappedBy: 'associativeId')]
+    public InverseSide $inverseSide;
+}

tests/Tests/Models/OneToOneInverseSideWithAssociativeIdLoad/OwningSide.php

@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Tests\Models\OneToOneInverseSideWithAssociativeIdLoad;
+
+use Doctrine\ORM\Mapping\Column;
+use Doctrine\ORM\Mapping\Entity;
+use Doctrine\ORM\Mapping\GeneratedValue;
+use Doctrine\ORM\Mapping\Id;
+use Doctrine\ORM\Mapping\JoinColumn;
+use Doctrine\ORM\Mapping\OneToOne;
+use Doctrine\ORM\Mapping\Table;
+
+#[Entity]
+#[Table(name: 'one_to_one_inverse_side_assoc_id_load_owning')]
+class OwningSide
+{
+    #[Id]
+    #[Column(type: 'string', length: 255)]
+    #[GeneratedValue(strategy: 'NONE')]
+    public string $id;
+
+    /** Owning side */
+    #[OneToOne(targetEntity: InverseSide::class, inversedBy: 'owning')]
+    #[JoinColumn(name: 'inverse', referencedColumnName: 'associativeId')]
+    public InverseSide $inverse;
+}