Merge branch '2.19.x' into 3.1.x

* 2.19.x:
  Fix BIGINT validation (#11414)
  Fix templated phpdoc return type (#11407)
  [Documentation] Merging "Query Result Formats" with "Hydration Modes"
  Fix psalm errors: remove override of template type
  Update dql-doctrine-query-language.rst
  Adding `NonUniqueResultException`
  [Documentation] Query Result Formats

.doctrine-project.json

@@ -6,22 +6,52 @@
     "docsSlug": "doctrine-orm",
     "versions": [
         {
-            "name": "3.0",
-            "branchName": "3.0.x",
+            "name": "4.0",
+            "branchName": "4.0.x",
             "slug": "latest",
             "upcoming": true
         },
+        {
+            "name": "3.2",
+            "branchName": "3.2.x",
+            "slug": "3.2",
+            "upcoming": true
+        },
+        {
+            "name": "3.1",
+            "branchName": "3.1.x",
+            "slug": "3.1",
+            "current": true
+        },
+        {
+            "name": "3.0",
+            "branchName": "3.0.x",
+            "slug": "3.0",
+            "maintained": false
+        },
+        {
+            "name": "2.20",
+            "branchName": "2.20.x",
+            "slug": "2.20",
+            "upcoming": true
+        },
+        {
+            "name": "2.19",
+            "branchName": "2.19.x",
+            "slug": "2.19",
+            "maintained": true
+        },
         {
             "name": "2.18",
             "branchName": "2.18.x",
             "slug": "2.18",
-            "upcoming": true
+            "maintained": false
         },
         {
             "name": "2.17",
             "branchName": "2.17.x",
             "slug": "2.17",
-            "current": true
+            "maintained": false
         },
         {
             "name": "2.16",
@@ -64,42 +94,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/workflows/coding-standards.yml

@@ -8,7 +8,7 @@ on:
       - .github/workflows/coding-standards.yml
       - bin/**
       - composer.*
-      - lib/**
+      - src/**
       - phpcs.xml.dist
       - tests/**
   push:
@@ -18,7 +18,7 @@ on:
       - .github/workflows/coding-standards.yml
       - bin/**
       - composer.*
-      - lib/**
+      - src/**
       - phpcs.xml.dist
       - tests/**
 

.github/workflows/continuous-integration.yml

@@ -8,7 +8,7 @@ on:
       - .github/workflows/continuous-integration.yml
       - ci/**
       - composer.*
-      - lib/**
+      - src/**
       - phpunit.xml.dist
       - tests/**
   push:
@@ -18,7 +18,7 @@ on:
       - .github/workflows/continuous-integration.yml
       - ci/**
       - composer.*
-      - lib/**
+      - src/**
       - phpunit.xml.dist
       - tests/**
 
@@ -33,32 +33,27 @@ jobs:
     strategy:
       matrix:
         php-version:
-          - "7.2"
-          - "7.3"
-          - "7.4"
-          - "8.0"
           - "8.1"
           - "8.2"
           - "8.3"
         dbal-version:
           - "default"
+          - "3.7"
         extension:
+          - "sqlite3"
           - "pdo_sqlite"
-        proxy:
-          - "common"
+        deps:
+          - "highest"
         include:
-          - php-version: "8.0"
-            dbal-version: "2.13"
+          - php-version: "8.2"
+            dbal-version: "4@dev"
             extension: "pdo_sqlite"
           - php-version: "8.2"
-            dbal-version: "3@dev"
-            extension: "pdo_sqlite"
-          - php-version: "8.2"
-            dbal-version: "default"
+            dbal-version: "4@dev"
             extension: "sqlite3"
           - php-version: "8.1"
             dbal-version: "default"
-            proxy: "lazy-ghost"
+            deps: "lowest"
             extension: "pdo_sqlite"
 
     steps:
@@ -83,23 +78,22 @@ jobs:
         uses: "ramsey/composer-install@v2"
         with:
           composer-options: "--ignore-platform-req=php+"
+          dependency-versions: "${{ matrix.deps }}"
 
       - name: "Run PHPUnit"
         run: "vendor/bin/phpunit -c ci/github/phpunit/${{ matrix.extension }}.xml --coverage-clover=coverage-no-cache.xml"
         env:
             ENABLE_SECOND_LEVEL_CACHE: 0
-            ORM_PROXY_IMPLEMENTATION: "${{ matrix.proxy }}"
 
       - name: "Run PHPUnit with Second Level Cache"
         run: "vendor/bin/phpunit -c ci/github/phpunit/${{ matrix.extension }}.xml --exclude-group performance,non-cacheable,locking_functional --coverage-clover=coverage-cache.xml"
         env:
             ENABLE_SECOND_LEVEL_CACHE: 1
-            ORM_PROXY_IMPLEMENTATION: "${{ matrix.proxy }}"
 
       - name: "Upload coverage file"
-        uses: "actions/upload-artifact@v3"
+        uses: "actions/upload-artifact@v4"
         with:
-          name: "phpunit-${{ matrix.extension }}-${{ matrix.php-version }}-${{ matrix.dbal-version }}-coverage"
+          name: "phpunit-${{ matrix.extension }}-${{ matrix.php-version }}-${{ matrix.dbal-version }}-${{ matrix.deps }}-coverage"
           path: "coverage*.xml"
 
 
@@ -115,19 +109,19 @@ jobs:
           - "8.3"
         dbal-version:
           - "default"
-          - "3@dev"
+          - "3.7"
         postgres-version:
           - "15"
         extension:
           - pdo_pgsql
           - pgsql
         include:
-          - php-version: "8.0"
-            dbal-version: "2.13"
+          - php-version: "8.2"
+            dbal-version: "4@dev"
             postgres-version: "14"
             extension: pdo_pgsql
           - php-version: "8.2"
-            dbal-version: "default"
+            dbal-version: "3.7"
             postgres-version: "9.6"
             extension: pdo_pgsql
 
@@ -170,9 +164,9 @@ jobs:
         run: "vendor/bin/phpunit -c ci/github/phpunit/pdo_pgsql.xml --coverage-clover=coverage.xml"
 
       - name: "Upload coverage file"
-        uses: "actions/upload-artifact@v3"
+        uses: "actions/upload-artifact@v4"
         with:
-          name: "${{ github.job }}-${{ matrix.postgres-version }}-${{ matrix.php-version }}-${{ matrix.dbal-version }}-coverage"
+          name: "${{ github.job }}-${{ matrix.postgres-version }}-${{ matrix.php-version }}-${{ matrix.dbal-version }}-${{ matrix.extension }}-coverage"
           path: "coverage.xml"
 
 
@@ -188,17 +182,13 @@ jobs:
           - "8.3"
         dbal-version:
           - "default"
-          - "3@dev"
+          - "3.7"
+          - "4@dev"
         mariadb-version:
           - "10.9"
         extension:
           - "mysqli"
           - "pdo_mysql"
-        include:
-          - php-version: "8.0"
-            dbal-version: "2.13"
-            mariadb-version: "10.6"
-            extension: "pdo_mysql"
 
     services:
       mariadb:
@@ -240,7 +230,7 @@ jobs:
         run: "vendor/bin/phpunit -c ci/github/phpunit/${{ matrix.extension }}.xml --coverage-clover=coverage.xml"
 
       - name: "Upload coverage file"
-        uses: "actions/upload-artifact@v3"
+        uses: "actions/upload-artifact@v4"
         with:
           name: "${{ github.job }}-${{ matrix.mariadb-version }}-${{ matrix.extension }}-${{ matrix.php-version }}-${{ matrix.dbal-version }}-coverage"
           path: "coverage.xml"
@@ -258,7 +248,7 @@ jobs:
           - "8.3"
         dbal-version:
           - "default"
-          - "3@dev"
+          - "3.7"
         mysql-version:
           - "5.7"
           - "8.0"
@@ -266,8 +256,12 @@ jobs:
           - "mysqli"
           - "pdo_mysql"
         include:
-          - php-version: "8.0"
-            dbal-version: "2.13"
+          - php-version: "8.2"
+            dbal-version: "4@dev"
+            mysql-version: "8.0"
+            extension: "mysqli"
+          - php-version: "8.2"
+            dbal-version: "4@dev"
             mysql-version: "8.0"
             extension: "pdo_mysql"
 
@@ -317,45 +311,11 @@ jobs:
             ENABLE_SECOND_LEVEL_CACHE: 1
 
       - name: "Upload coverage files"
-        uses: "actions/upload-artifact@v3"
+        uses: "actions/upload-artifact@v4"
         with:
           name: "${{ github.job }}-${{ matrix.mysql-version }}-${{ matrix.extension }}-${{ matrix.php-version }}-${{ matrix.dbal-version }}-coverage"
           path: "coverage*.xml"
 
-
-  phpunit-lower-php-versions:
-    name: "PHPUnit with SQLite"
-    runs-on: "ubuntu-22.04"
-
-    strategy:
-      matrix:
-        php-version:
-          - "7.1"
-        deps:
-          - "highest"
-          - "lowest"
-
-    steps:
-      - name: "Checkout"
-        uses: "actions/checkout@v4"
-        with:
-          fetch-depth: 2
-
-      - name: "Install PHP"
-        uses: "shivammathur/setup-php@v2"
-        with:
-          php-version: "${{ matrix.php-version }}"
-          ini-values: "zend.assertions=1, apc.enable_cli=1"
-
-      - name: "Install dependencies with Composer"
-        uses: "ramsey/composer-install@v2"
-        with:
-          dependency-versions: "${{ matrix.deps }}"
-
-      - name: "Run PHPUnit"
-        run: "vendor/bin/phpunit -c ci/github/phpunit/pdo_sqlite.xml"
-
-
   upload_coverage:
     name: "Upload coverage to Codecov"
     runs-on: "ubuntu-22.04"
@@ -372,7 +332,7 @@ jobs:
           fetch-depth: 2
 
       - name: "Download coverage files"
-        uses: "actions/download-artifact@v3"
+        uses: "actions/download-artifact@v4"
         with:
           path: "reports"
 

.github/workflows/documentation.yml

@@ -27,7 +27,7 @@ jobs:
         uses: "shivammathur/setup-php@v2"
         with:
           coverage: "none"
-          php-version: "8.2"
+          php-version: "8.3"
 
       - name: "Remove existing composer file"
         run: "rm composer.json"
@@ -40,9 +40,10 @@ jobs:
         with:
           dependency-versions: "highest"
 
-      - name: "Add dummy title to the sidebar"
+      - name: "Add orphan metadata where needed"
         run: |
-          printf '%s\n%s\n\n%s\n' "Dummy title" "===========" "$(cat docs/en/sidebar.rst)" > docs/en/sidebar.rst
+          printf '%s\n\n%s\n' ":orphan:" "$(cat docs/en/sidebar.rst)" > docs/en/sidebar.rst
+          printf '%s\n\n%s\n' ":orphan:" "$(cat docs/en/reference/installation.rst)" > docs/en/reference/installation.rst
 
       - name: "Run guides-cli"
-        run: "vendor/bin/guides -vvv --no-progress docs/en 2>&1 | grep -v 'Unknown directive' | ( ! grep WARNING )"
+        run: "vendor/bin/guides -vvv --no-progress docs/en 2>&1 | grep -v 'No template found for rendering directive' | ( ! grep WARNING )"

.github/workflows/phpbench.yml

@@ -8,7 +8,7 @@ on:
     paths:
       - .github/workflows/phpbench.yml
       - composer.*
-      - lib/**
+      - src/**
       - phpbench.json
       - tests/**
   push:
@@ -17,7 +17,7 @@ on:
     paths:
       - .github/workflows/phpbench.yml
       - composer.*
-      - lib/**
+      - src/**
       - phpbench.json
       - tests/**
 
@@ -32,7 +32,7 @@ jobs:
     strategy:
       matrix:
         php-version:
-          - "7.4"
+          - "8.1"
 
     steps:
       - name: "Checkout"

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

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

.github/workflows/static-analysis.yml

@@ -7,97 +7,83 @@ on:
     paths:
       - .github/workflows/static-analysis.yml
       - composer.*
-      - lib/**
+      - src/**
       - phpstan*
       - psalm*
-      - tests/Doctrine/StaticAnalysis/**
+      - tests/StaticAnalysis/**
   push:
     branches:
       - "*.x"
     paths:
       - .github/workflows/static-analysis.yml
       - composer.*
-      - lib/**
+      - src/**
       - phpstan*
       - psalm*
-      - tests/Doctrine/StaticAnalysis/**
+      - tests/StaticAnalysis/**
 
 jobs:
   static-analysis-phpstan:
-    name: "Static Analysis with PHPStan"
-    runs-on: "ubuntu-22.04"
+    name: Static Analysis with PHPStan
+    runs-on: ubuntu-22.04
 
     strategy:
-      fail-fast: false
       matrix:
-        dbal-version:
-          - "default"
-        persistence-version:
-          - "default"
         include:
-          - dbal-version: "2.13"
-            persistence-version: "default"
-          - dbal-version: "default"
-            persistence-version: "2.5"
+        - dbal-version: default
+          config: phpstan.neon
+        - dbal-version: 3.8.2
+          config: phpstan-dbal3.neon
 
     steps:
       - name: "Checkout code"
         uses: "actions/checkout@v4"
 
-      - name: "Install PHP"
-        uses: "shivammathur/setup-php@v2"
+      - name: Install PHP
+        uses: shivammathur/setup-php@v2
         with:
-          coverage: "none"
-          php-version: "8.2"
+          coverage: none
+          php-version: "8.3"
+          tools: cs2pr
 
-      - name: "Require specific DBAL version"
+      - name: Require specific DBAL version
         run: "composer require doctrine/dbal ^${{ matrix.dbal-version }} --no-update"
         if: "${{ matrix.dbal-version != 'default' }}"
 
-      - name: "Require specific persistence version"
-        run: "composer require doctrine/persistence ^$([ ${{ matrix.persistence-version }} = default ] && echo '3.1' || echo ${{ matrix.persistence-version }}) --no-update"
 
-      - name: "Install dependencies with Composer"
-        uses: "ramsey/composer-install@v2"
-        with:
-          dependency-versions: "highest"
+      - name: Install dependencies with Composer
+        uses: ramsey/composer-install@v2
 
-      - name: "Run a static analysis with phpstan/phpstan"
-        run: "vendor/bin/phpstan analyse"
-        if: "${{ matrix.dbal-version == 'default' && matrix.persistence-version == 'default'}}"
-
-      - name: "Run a static analysis with phpstan/phpstan"
-        run: "vendor/bin/phpstan analyse -c phpstan-dbal2.neon"
-        if: "${{ matrix.dbal-version == '2.13' }}"
-
-      - name: "Run a static analysis with phpstan/phpstan"
-        run: "vendor/bin/phpstan analyse -c phpstan-persistence2.neon"
-        if: "${{ matrix.dbal-version == 'default' && matrix.persistence-version != 'default'}}"
+      - name: Run static analysis with phpstan/phpstan
+        run: "vendor/bin/phpstan analyse -c ${{ matrix.config }} --error-format=checkstyle | cs2pr"
 
   static-analysis-psalm:
-    name: "Static Analysis with Psalm"
-    runs-on: "ubuntu-22.04"
+    name: Static Analysis with Psalm
+    runs-on: ubuntu-22.04
 
     strategy:
-      fail-fast: false
+      matrix:
+        dbal-version:
+        - default
+        - 3.8.2
 
     steps:
       - name: "Checkout code"
         uses: "actions/checkout@v4"
 
-      - name: "Install PHP"
-        uses: "shivammathur/setup-php@v2"
+      - name: Install PHP
+        uses: shivammathur/setup-php@v2
         with:
-          coverage: "none"
-          php-version: "8.2"
+          coverage: none
+          php-version: "8.3"
+          tools: cs2pr
 
-      - name: "Require specific persistence version"
-        run: "composer require doctrine/persistence ^3.1 --no-update"
+      - name: Require specific DBAL version
+        run: "composer require doctrine/dbal ^${{ matrix.dbal-version }} --no-update"
+        if: "${{ matrix.dbal-version != 'default' }}"
 
-      - name: "Install dependencies with Composer"
-        uses: "ramsey/composer-install@v2"
-        with:
-          dependency-versions: "highest"
+      - name: Install dependencies with Composer
+        uses: ramsey/composer-install@v2
 
-      - name: "Run a static analysis with vimeo/psalm"
-        run: "vendor/bin/psalm --show-info=false --stats --output-format=github --threads=$(nproc)"
+      - name: Run static analysis with Vimeo Psalm
+        run: vendor/bin/psalm --shepherd

.gitignore

@@ -3,9 +3,6 @@ logs/
 reports/
 dist/
 download/
-lib/api/
-lib/Doctrine/Common
-lib/Doctrine/DBAL
 /.settings/
 .buildpath
 .project

.gitmodules

@@ -1,6 +0,0 @@
-[submodule "docs/en/_theme"]
-    path = docs/en/_theme
-    url = git://github.com/doctrine/doctrine-sphinx-theme.git
-[submodule "lib/vendor/doctrine-build-common"]
-    path = lib/vendor/doctrine-build-common
-    url = git://github.com/doctrine/doctrine-build-common.git

CONTRIBUTING.md

@@ -23,7 +23,7 @@ You may fix many some of the issues with `vendor/bin/phpcbf`.
 Please try to add a test for your pull-request.
 
 * If you want to fix a bug or provide a reproduce case, create a test file in
-  ``tests/Doctrine/Tests/ORM/Functional/Ticket`` with the name of the ticket,
+  ``tests/Tests/ORM/Functional/Ticket`` with the name of the ticket,
   ``DDC1234Test.php`` for example.
 * If you want to contribute new functionality add unit- or functional tests
   depending on the scope of the feature.
@@ -57,7 +57,7 @@ sqlite database.
 Tips for creating unit tests:
 
 1. If you put a test into the `Ticket` namespace as described above, put the testcase and all entities into the same class.
-   See `https://github.com/doctrine/orm/tree/2.8.x/tests/Doctrine/Tests/ORM/Functional/Ticket/DDC2306Test.php` for an
+   See `https://github.com/doctrine/orm/tree/3.0.x/tests/Tests/ORM/Functional/Ticket/DDC2306Test.php` for an
    example.
 
 ## Getting merged

README.md

@@ -1,11 +1,11 @@
-| [3.0.x][3.0] | [2.16.x][2.16] | [2.15.x][2.15] |
-|:----------------:|:----------------:|:----------:|
-| [![Build status][3.0 image]][3.0] | [![Build status][2.16 image]][2.16] | [![Build status][2.15 image]][2.15] |
-| [![Coverage Status][3.0 coverage image]][3.0 coverage]| [![Coverage Status][2.16 coverage image]][2.16 coverage] | [![Coverage Status][2.15 coverage image]][2.15 coverage]  |
+|                      [4.0.x][4.0]                      |                      [3.2.x][3.2]                      |                      [3.1.x][3.1]                      |                      [2.20.x][2.20]                      |                      [2.19.x][2.19]                      |
+|:------------------------------------------------------:|:------------------------------------------------------:|:------------------------------------------------------:|:--------------------------------------------------------:|:--------------------------------------------------------:|
+|           [![Build status][4.0 image]][4.0]            |           [![Build status][3.2 image]][3.2]            |           [![Build status][3.1 image]][3.1]            |           [![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.2 coverage image]][3.2 coverage] | [![Coverage Status][3.1 coverage image]][3.1 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)
 
-Doctrine ORM is an object-relational mapper for PHP 7.1+ that provides transparent persistence
+Doctrine ORM is an object-relational mapper for PHP 8.1+ that provides transparent persistence
 for PHP objects. It sits on top of a powerful database abstraction layer (DBAL). One of its key features
 is the option to write database queries in a proprietary object oriented SQL dialect called Doctrine Query Language (DQL),
 inspired by Hibernate's HQL. This provides developers with a powerful alternative to SQL that maintains flexibility
@@ -18,15 +18,23 @@ without requiring unnecessary code duplication.
 * [Documentation](https://www.doctrine-project.org/projects/doctrine-orm/en/stable/index.html)
 
 
-  [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
-  [2.16 image]: https://github.com/doctrine/orm/actions/workflows/continuous-integration.yml/badge.svg?branch=2.16.x
-  [2.16]: https://github.com/doctrine/orm/tree/2.16.x
-  [2.16 coverage image]: https://codecov.io/gh/doctrine/orm/branch/2.16.x/graph/badge.svg
-  [2.16 coverage]: https://codecov.io/gh/doctrine/orm/branch/2.16.x
-  [2.15 image]: https://github.com/doctrine/orm/actions/workflows/continuous-integration.yml/badge.svg?branch=2.15.x
-  [2.15]: https://github.com/doctrine/orm/tree/2.15.x
-  [2.15 coverage image]: https://codecov.io/gh/doctrine/orm/branch/2.15.x/graph/badge.svg
-  [2.15 coverage]: https://codecov.io/gh/doctrine/orm/branch/2.15.x
+  [4.0 image]: https://github.com/doctrine/orm/actions/workflows/continuous-integration.yml/badge.svg?branch=4.0.x
+  [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.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
+  [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
+  [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

SECURITY.md

@@ -13,6 +13,5 @@ understand the assumptions we make.
 - [DBAL Security Page](https://www.doctrine-project.org/projects/doctrine-dbal/en/stable/reference/security.html)
 - [ORM Security Page](https://www.doctrine-project.org/projects/doctrine-orm/en/stable/reference/security.html)
 
-If you find a Security bug in Doctrine, please report it on Jira and change the
-Security Level to "Security Issues". It will be visible to Doctrine Core
-developers and you only.
+If you find a Security bug in Doctrine, please follow our
+[Security reporting guidelines](https://www.doctrine-project.org/policies/security.html#reporting).

UPGRADE.md

@@ -1,3 +1,719 @@
+# 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
+
+Previously, calling
+`Doctrine\ORM\Mapping\ClassMetadata::getAssociationMappedByTargetField()` with
+the owning side of an association returned `null`, which was 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.
+
+## BC BREAK: `Doctrine\ORM\Proxy\Autoloader` no longer extends `Doctrine\Common\Proxy\Autoloader`
+
+Make sure to use the former when writing a type declaration or an `instanceof` check.
+
+## Minor BC BREAK: Changed order of arguments passed to `OneToOne`, `ManyToOne` and `Index` mapping PHP attributes
+
+To keep PHP mapping attributes consistent, order of arguments passed to above attributes has been changed
+so `$targetEntity` is a first argument now. This change affects only non-named arguments usage.
+
+## BC BREAK: AUTO keyword for identity generation defaults to IDENTITY for PostgreSQL when using `doctrine/dbal` 4
+
+When using the `AUTO` strategy to let Doctrine determine the identity generation mechanism for
+an entity, and when using `doctrine/dbal` 4, PostgreSQL now uses `IDENTITY`
+instead of `SEQUENCE` or `SERIAL`.
+* If you want to upgrade your existing tables to identity columns, you will need to follow [migration to identity columns on PostgreSQL](https://www.doctrine-project.org/projects/doctrine-dbal/en/4.0/how-to/postgresql-identity-migration.html)
+* If you want to keep using SQL sequences, you need to configure the ORM this way:
+```php
+use Doctrine\DBAL\Platforms\PostgreSQLPlatform;
+use Doctrine\ORM\Configuration;
+use Doctrine\ORM\Mapping\ClassMetadata;
+
+assert($configuration instanceof Configuration);
+$configuration->setIdentityGenerationPreferences([
+    PostgreSQLPlatform::CLASS => ClassMetadata::GENERATOR_TYPE_SEQUENCE,
+]);
+```
+
+## BC BREAK: Throw exceptions when using illegal attributes on Embeddable
+
+There are only a few attributes allowed on an embeddable such as `#[Column]` or
+`#[Embedded]`. Previously all others that target entity classes where ignored,
+now they throw an exception.
+
+## BC BREAK: Partial objects are removed
+
+- The `PARTIAL` keyword in DQL no longer exists.
+- `Doctrine\ORM\Query\AST\PartialObjectExpression`is removed.
+- `Doctrine\ORM\Query\SqlWalker::HINT_PARTIAL` and
+  `Doctrine\ORM\Query::HINT_FORCE_PARTIAL_LOAD` are removed.
+- `Doctrine\ORM\EntityManager*::getPartialReference()` is removed.
+
+## BC BREAK: `Doctrine\ORM\Persister\Entity\EntityPersister::executeInserts()` return type changed to `void`
+
+Implementors should adapt to the new signature, and should call
+`UnitOfWork::assignPostInsertId()` for each entry in the previously returned
+array.
+
+## BC BREAK: `Doctrine\ORM\Proxy\ProxyFactory` no longer extends abstract factory from `doctrine/common`
+
+It is no longer possible to call methods, constants or properties inherited
+from that class on a `ProxyFactory` instance.
+
+`Doctrine\ORM\Proxy\ProxyFactory::createProxyDefinition()` and
+`Doctrine\ORM\Proxy\ProxyFactory::resetUninitializedProxy()` are removed as well.
+
+## BC BREAK: lazy ghosts are enabled unconditionally
+
+`Doctrine\ORM\Configuration::setLazyGhostObjectEnabled()` and
+`Doctrine\ORM\Configuration::isLazyGhostObjectEnabled()` are now no-ops and
+will be deprecated in 3.1.0
+
+## BC BREAK: collisions in identity map are unconditionally rejected
+
+`Doctrine\ORM\Configuration::setRejectIdCollisionInIdentityMap()` and
+`Doctrine\ORM\Configuration::isRejectIdCollisionInIdentityMapEnabled()` are now
+no-ops and will be deprecated in 3.1.0.
+
+## BC BREAK: Lifecycle callback mapping on embedded classes is now explicitly forbidden
+
+Lifecycle callback mapping on embedded classes produced no effect, and is now
+explicitly forbidden to point out mistakes.
+
+## BC BREAK: The `NOTIFY` change tracking policy is removed
+
+You should use `DEFERRED_EXPLICIT` instead.
+
+## BC BREAK: `Mapping\Driver\XmlDriver::__construct()` third argument is now enabled by default
+
+The third argument to
+`Doctrine\ORM\Mapping\Driver\XmlDriver::__construct()` was introduced to
+let users opt-in to XML validation, that is now always enabled by default.
+
+As a consequence, the same goes for
+`Doctrine\ORM\Mapping\Driver\SimplifiedXmlDriver`, and for
+`Doctrine\ORM\ORMSetup::createXMLMetadataConfiguration()`.
+
+## BC BREAK: `Mapping\Driver\AttributeDriver::__construct()` second argument is now a no-op
+
+The second argument to
+`Doctrine\ORM\Mapping\Driver\AttributeDriver::__construct()` was introduced to
+let users opt-in to a new behavior, that is now always enforced, regardless of
+the value of that argument.
+
+## BC BREAK: `Query::setDQL()` and `Query::setFirstResult()` no longer accept `null`
+
+The `$dqlQuery` argument of `Doctrine\ORM\Query::setDQL()` must always be a
+string.
+
+The `$firstResult` argument of `Doctrine\ORM\Query::setFirstResult()` must
+always be an integer.
+
+## BC BREAK: `orm:schema-tool:update` option `--complete` is now a no-op
+
+`orm:schema-tool:update` now behaves as if `--complete` was provided,
+regardless of whether it is provided or not.
+
+## BC BREAK: Removed `Doctrine\ORM\Proxy\Proxy` interface.
+
+Use `Doctrine\Persistence\Proxy` instead to check whether proxies are initialized.
+
+## BC BREAK: Overriding fields or associations declared in other than mapped superclasses
+
+As stated in the documentation, fields and associations may only be overridden when being inherited
+from mapped superclasses. Overriding them for parent entity classes now throws a `MappingException`.
+
+## BC BREAK: Undeclared entity inheritance now throws a `MappingException`
+
+As soon as an entity class inherits from another entity class, inheritance has to
+be declared by adding the appropriate configuration for the root entity.
+
+## Removed `getEntityManager()` in `Doctrine\ORM\Event\OnClearEventArgs` and `Doctrine\ORM\Event\*FlushEventArgs`
+
+Use `getObjectManager()` instead.
+
+## BC BREAK: Removed `Doctrine\ORM\Mapping\ClassMetadataInfo` class
+
+Use `Doctrine\ORM\Mapping\ClassMetadata` instead.
+
+## BC BREAK: Removed `Doctrine\ORM\Event\LifecycleEventArgs` class.
+
+Use one of the dedicated event classes instead:
+
+* `Doctrine\ORM\Event\PrePersistEventArgs`
+* `Doctrine\ORM\Event\PreUpdateEventArgs`
+* `Doctrine\ORM\Event\PreRemoveEventArgs`
+* `Doctrine\ORM\Event\PostPersistEventArgs`
+* `Doctrine\ORM\Event\PostUpdateEventArgs`
+* `Doctrine\ORM\Event\PostRemoveEventArgs`
+* `Doctrine\ORM\Event\PostLoadEventArgs`
+
+## BC BREAK: Removed `AttributeDriver::$entityAnnotationClasses` and `AttributeDriver::getReader()`
+
+* If you need to change the behavior of `AttributeDriver::isTransient()`,
+  override that method instead.
+* The attribute reader is internal to the driver and should not be accessed from outside.
+
+## BC BREAK: Removed `Doctrine\ORM\Query\AST\InExpression`
+
+The AST parser will create a `InListExpression` or a `InSubselectExpression` when
+encountering an `IN ()` DQL expression instead of a generic `InExpression`.
+
+As a consequence, `SqlWalker::walkInExpression()` has been replaced by
+`SqlWalker::walkInListExpression()` and `SqlWalker::walkInSubselectExpression()`.
+
+## BC BREAK: Changed `EntityManagerInterface#refresh($entity)`, `EntityManagerDecorator#refresh($entity)` and `UnitOfWork#refresh($entity)` signatures
+
+The new signatures of these methods add an optional `LockMode|int|null $lockMode`
+param with default `null` value (no lock).
+
+## BC Break: Removed AnnotationDriver
+
+The annotation driver and anything related to annotation has been removed.
+Please migrate to another mapping driver.
+
+The `Doctrine\ORM\Mapping\Annotation` maker interface has been removed in favor of the new
+`Doctrine\ORM\Mapping\MappingAttribute` interface.
+
+## BC BREAK: Removed `EntityManager::create()`
+
+The constructor of `EntityManager` is now public and must be used instead of the `create()` method.
+However, the constructor expects a `Connection` while `create()` accepted an array with connection parameters.
+You can pass that array to DBAL's `Doctrine\DBAL\DriverManager::getConnection()` method to bootstrap the
+connection.
+
+## BC BREAK: Removed `QueryBuilder` methods and constants.
+
+The following `QueryBuilder` constants and methods have been removed:
+
+1. `SELECT`,
+2. `DELETE`,
+3. `UPDATE`,
+4. `STATE_DIRTY`,
+5. `STATE_CLEAN`,
+6. `getState()`,
+7. `getType()`.
+
+## BC BREAK: Omitting only the alias argument for `QueryBuilder::update` and `QueryBuilder::delete` is not supported anymore
+
+When building an UPDATE or DELETE query and when passing a class/type to the function, the alias argument must not be omitted.
+
+### Before
+
+```php
+$qb = $em->createQueryBuilder()
+    ->delete('User u')
+    ->where('u.id = :user_id')
+    ->setParameter('user_id', 1);
+```
+
+### After
+
+```php
+$qb = $em->createQueryBuilder()
+    ->delete('User', 'u')
+    ->where('u.id = :user_id')
+    ->setParameter('user_id', 1);
+```
+
+## BC BREAK: Split output walkers and tree walkers
+
+`SqlWalker` and its child classes don't implement the `TreeWalker` interface
+anymore.
+
+The following methods have been removed from the `TreeWalker` interface and
+from the `TreeWalkerAdapter` and `TreeWalkerChain` classes:
+
+* `setQueryComponent()`
+* `walkSelectClause()`
+* `walkFromClause()`
+* `walkFunction()`
+* `walkOrderByClause()`
+* `walkOrderByItem()`
+* `walkHavingClause()`
+* `walkJoin()`
+* `walkSelectExpression()`
+* `walkQuantifiedExpression()`
+* `walkSubselect()`
+* `walkSubselectFromClause()`
+* `walkSimpleSelectClause()`
+* `walkSimpleSelectExpression()`
+* `walkAggregateExpression()`
+* `walkGroupByClause()`
+* `walkGroupByItem()`
+* `walkDeleteClause()`
+* `walkUpdateClause()`
+* `walkUpdateItem()`
+* `walkWhereClause()`
+* `walkConditionalExpression()`
+* `walkConditionalTerm()`
+* `walkConditionalFactor()`
+* `walkConditionalPrimary()`
+* `walkExistsExpression()`
+* `walkCollectionMemberExpression()`
+* `walkEmptyCollectionComparisonExpression()`
+* `walkNullComparisonExpression()`
+* `walkInExpression()`
+* `walkInstanceOfExpression()`
+* `walkLiteral()`
+* `walkBetweenExpression()`
+* `walkLikeExpression()`
+* `walkStateFieldPathExpression()`
+* `walkComparisonExpression()`
+* `walkInputParameter()`
+* `walkArithmeticExpression()`
+* `walkArithmeticTerm()`
+* `walkStringPrimary()`
+* `walkArithmeticFactor()`
+* `walkSimpleArithmeticExpression()`
+* `walkPathExpression()`
+* `walkResultVariable()`
+* `getExecutor()`
+
+The following changes have been made to the abstract `TreeWalkerAdapter` class:
+
+* The method `setQueryComponent()` is now protected.
+* The method `_getQueryComponents()` has been removed in favor of
+  `getQueryComponents()`.
+
+## BC BREAK: Removed identity columns emulation through sequences
+
+If the platform you are using does not support identity columns, you should
+switch to the `SEQUENCE` strategy.
+
+## BC BREAK: Made setters parameters mandatory
+
+The following methods require an argument when being called. Pass `null`
+instead of omitting the argument.
+
+* `Doctrine\ORM\Event\OnClassMetadataNotFoundEventArgs::setFoundMetadata()`
+* `Doctrine\ORM\AbstractQuery::setHydrationCacheProfile()`
+* `Doctrine\ORM\AbstractQuery::setResultCache()`
+* `Doctrine\ORM\AbstractQuery::setResultCacheProfile()`
+
+## BC BREAK: New argument to `NamingStrategy::joinColumnName()`
+
+### Before
+
+```php
+<?php
+class MyStrategy implements NamingStrategy
+{
+    /**
+     * @param string $propertyName A property name.
+     */
+    public function joinColumnName($propertyName): string
+    {
+        // …
+    }
+}
+```
+
+### After
+
+The `class-string` type for `$className` can be inherited from the signature of
+the interface.
+
+```php
+<?php
+class MyStrategy implements NamingStrategy
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function joinColumnName(string $propertyName, string $className): string
+    {
+        // …
+    }
+}
+```
+
+## BC BREAK: Remove `StaticPHPDriver` and `DriverChain`
+
+Use `Doctrine\Persistence\Mapping\Driver\StaticPHPDriver` and
+`Doctrine\Persistence\Mapping\Driver\MappingDriverChain` from
+`doctrine/persistence` instead.
+
+## BC BREAK: `UnderscoreNamingStrategy` is number aware only
+
+The second argument to `UnderscoreNamingStrategy::__construct()` was dropped,
+the strategy can no longer be unaware of numbers.
+
+## BC BREAK: Remove `Doctrine\ORM\Tools\DisconnectedClassMetadataFactory`
+
+No replacement is provided.
+
+## BC BREAK: Remove support for `Type::canRequireSQLConversion()`
+
+This feature was deprecated in DBAL 3.3.0 and will be removed in DBAL 4.0.
+The value conversion methods are now called regardless of the type.
+
+The `MappingException::sqlConversionNotAllowedForIdentifiers()` method has been removed
+as no longer relevant.
+
+## BC Break: Removed the `doctrine` binary.
+
+The documentation explains how the console tools can be bootstrapped for
+standalone usage:
+
+https://www.doctrine-project.org/projects/doctrine-orm/en/stable/reference/tools.html
+
+The method `ConsoleRunner::printCliConfigTemplate()` has been removed as well
+because it was only useful in the context of the `doctrine` binary.
+
+## BC Break: Removed `EntityManagerHelper` and related logic
+
+All console commands require a `$entityManagerProvider` to be passed via the
+constructor. Commands won't try to get the entity manager from a previously
+registered `em` console helper.
+
+The following classes have been removed:
+
+* `Doctrine\ORM\Tools\Console\EntityManagerProvider\HelperSetManagerProvider`
+* `Doctrine\ORM\Tools\Console\Helper\EntityManagerHelper`
+
+The following breaking changes have been applied to `Doctrine\ORM\Tools\Console\ConsoleRunner`:
+
+* The method `createHelperSet()` has been removed.
+* The methods `run()` and `createApplication()` don't accept an instance of
+  `HelperSet` as first argument anymore.
+* The method `addCommands()` requires an instance of `EntityManagerProvider`
+  as second argument now.
+
+## BC Break: `Exception\ORMException` is no longer a class, but an interface
+
+All methods in `Doctrine\ORM\ORMException` have been extracted to dedicated exceptions.
+
+ * `missingMappingDriverImpl()` => `Exception\MissingMappingDriverImplementation::create()`
+ * `unrecognizedField()` => `Persisters\Exception\UnrecognizedField::byName()`
+ * `unexpectedAssociationValue()` => `Exception\UnexpectedAssociationValue::create()`
+ * `invalidOrientation()` => `Persisters\Exception\InvalidOrientation::fromClassNameAndField()`
+ * `entityManagerClosed()` => `Exception\EntityManagerClosed::create()`
+ * `invalidHydrationMode()` => `Exception\InvalidHydrationMode::fromMode()`
+ * `mismatchedEventManager()` => `Exception\MismatchedEventManager::create()`
+ * `findByRequiresParameter()` => `Repository\Exception\InvalidMagicMethodCall::onMissingParameter()`
+ * `invalidMagicCall()` => `Repository\Exception\InvalidMagicMethodCall::becauseFieldNotFoundIn()`
+ * `invalidFindByInverseAssociation()` => `Repository\Exception\InvalidFindByCall::fromInverseSideUsage()`
+ * `invalidResultCacheDriver()` => `Cache\Exception\InvalidResultCacheDriver::create()`
+ * `notSupported()` => `Exception\NotSupported::create()`
+ * `queryCacheNotConfigured()` => `QueryCacheNotConfigured::create()`
+ * `metadataCacheNotConfigured()` => `Cache\Exception\MetadataCacheNotConfigured::create()`
+ * `queryCacheUsesNonPersistentCache()` => `Cache\Exception\QueryCacheUsesNonPersistentCache::fromDriver()`
+ * `metadataCacheUsesNonPersistentCache()` => `Cache\Exception\MetadataCacheUsesNonPersistentCache::fromDriver()`
+ * `proxyClassesAlwaysRegenerating()` => `Exception\ProxyClassesAlwaysRegenerating::create()`
+ * `invalidEntityRepository()` => `Exception\InvalidEntityRepository::fromClassName()`
+ * `missingIdentifierField()` => `Exception\MissingIdentifierField::fromFieldAndClass()`
+ * `unrecognizedIdentifierFields()` => `Exception\UnrecognizedIdentifierFields::fromClassAndFieldNames()`
+ * `cantUseInOperatorOnCompositeKeys()` => `Persisters\Exception\CantUseInOperatorOnCompositeKeys::create()`
+
+## BC Break: `CacheException` is no longer a class, but an interface
+
+All methods in `Doctrine\ORM\Cache\CacheException` have been extracted to dedicated exceptions.
+
+ * `updateReadOnlyCollection()` => `Cache\Exception\CannotUpdateReadOnlyCollection::fromEntityAndField()`
+ * `updateReadOnlyEntity()` => `Cache\Exception\CannotUpdateReadOnlyEntity::fromEntity()`
+ * `nonCacheableEntity()` => `Cache\Exception\NonCacheableEntity::fromEntity()`
+ * `nonCacheableEntityAssociation()` => `Cache\Exception\NonCacheableEntityAssociation::fromEntityAndField()`
+
+
+## BC Break: Missing type declaration added for identifier generators
+
+Although undocumented, it was possible to configure a custom repository
+class that implements `ObjectRepository` but does not extend the
+`EntityRepository` base class. Repository classes have to extend
+`EntityRepository` now.
+
+## BC BREAK: Removed support for entity namespace alias
+
+- `EntityManager::getRepository()` no longer accepts the entity namespace alias
+  notation.
+- `Configuration::addEntityNamespace()` and
+  `Configuration::getEntityNamespace()` have been removed.
+
+## BC BREAK: Remove helper methods from `AbstractCollectionPersister`
+
+The following protected methods of
+`Doctrine\ORM\Cache\Persister\Collection\AbstractCollectionPersister`
+have been removed.
+
+* `evictCollectionCache()`
+* `evictElementCache()`
+
+## BC BREAK: `Doctrine\ORM\Query\TreeWalkerChainIterator`
+
+This class has been removed without replacement.
+
+## BC BREAK: Remove quoting methods from `ClassMetadata`
+
+The following methods have been removed from the class metadata because
+quoting is handled by implementations of `Doctrine\ORM\Mapping\QuoteStrategy`:
+
+* `getQuotedIdentifierColumnNames()`
+* `getQuotedColumnName()`
+* `getQuotedTableName()`
+* `getQuotedJoinTableName()`
+
+## BC BREAK: Remove ability to merge detached entities
+
+Merge semantics was a poor fit for the PHP "share-nothing" architecture.
+In addition to that, merging caused multiple issues with data integrity
+in the managed entity graph, which was constantly spawning more edge-case
+bugs/scenarios.
+
+The method `UnitOfWork::merge()` has been removed. The method
+`EntityManager::merge()` will throw an exception on each call.
+
+## BC BREAK: Removed ability to partially flush/commit entity manager and unit of work
+
+The following methods don't accept a single entity or an array of entities anymore:
+
+* `Doctrine\ORM\EntityManager::flush()`
+* `Doctrine\ORM\Decorator\EntityManagerDecorator::flush()`
+* `Doctrine\ORM\UnitOfWork::commit()`
+
+The semantics of `flush()` and `commit()` will remain the same, but the change
+tracking will be performed on all entities managed by the unit of work, and not
+just on the provided entities, as the parameter is now completely ignored.
+
+## BC BREAK: Removed ability to partially clear entity manager and unit of work
+
+* Passing an argument other than `null` to `EntityManager::clear()` will raise
+  an exception.
+* The unit of work cannot be cleared partially anymore. Passing an argument to
+  `UnitOfWork::clear()` does not have any effect anymore; the unit of work is
+  cleared completely.
+* The method `EntityRepository::clear()` has been removed.
+* The methods `getEntityClass()` and `clearsAllEntities()` have been removed
+  from `OnClearEventArgs`.
+
+## BC BREAK: Remove support for Doctrine Cache
+
+The Doctrine Cache library is not supported anymore. The following methods
+have been removed from `Doctrine\ORM\Configuration`:
+
+* `getQueryCacheImpl()`
+* `setQueryCacheImpl()`
+* `getHydrationCacheImpl()`
+* `setHydrationCacheImpl()`
+* `getMetadataCacheImpl()`
+* `setMetadataCacheImpl()`
+
+The methods have been replaced by PSR-6 compatible counterparts
+(just strip the `Impl` suffix from the old name to get the new one).
+
+## BC BREAK: Remove `Doctrine\ORM\Configuration::newDefaultAnnotationDriver`
+
+This functionality has been moved to the new `ORMSetup` class. Call
+`Doctrine\ORM\ORMSetup::createDefaultAnnotationDriver()` to create
+a new annotation driver.
+
+## BC BREAK: Remove `Doctrine\ORM\Tools\Setup`
+
+In our effort to migrate from Doctrine Cache to PSR-6, the `Setup` class which
+accepted a Doctrine Cache instance in each method has been removed.
+
+The replacement is `Doctrine\ORM\ORMSetup` which accepts a PSR-6
+cache instead.
+
+## BC BREAK: Removed named queries
+
+All APIs related to named queries have been removed.
+
+## BC BREAK: Remove old cache accessors and mutators from query classes
+
+The following methods have been removed from `AbstractQuery`:
+
+* `setResultCacheDriver()`
+* `getResultCacheDriver()`
+* `useResultCache()`
+* `getResultCacheLifetime()`
+* `getResultCacheId()`
+
+The following methods have been removed from `Query`:
+
+* `setQueryCacheDriver()`
+* `getQueryCacheDriver()`
+
+## BC BREAK: Remove `Doctrine\ORM\Cache\MultiGetRegion`
+
+The interface has been merged into `Doctrine\ORM\Cache\Region`.
+
+## BC BREAK: Rename `AbstractIdGenerator::generate()` to `generateId()`
+
+* Implementations of `AbstractIdGenerator` have to implement the method
+  `generateId()`.
+* The method `generate()` has been removed from `AbstractIdGenerator`.
+
+## BC BREAK: Remove cache settings inspection
+
+Doctrine does not provide its own cache implementation anymore and relies on
+the PSR-6 standard instead. As a consequence, we cannot determine anymore
+whether a given cache adapter is suitable for a production environment.
+Because of that, functionality that aims to do so has been removed:
+
+* `Configuration::ensureProductionSettings()`
+* the `orm:ensure-production-settings` console command
+
+## BC BREAK: PSR-6-based second level cache
+
+The second level cache has been reworked to consume a PSR-6 cache. Using a
+Doctrine Cache instance is not supported anymore.
+
+* `DefaultCacheFactory`: The constructor expects a PSR-6 cache item pool as
+  second argument now.
+* `DefaultMultiGetRegion`: This class has been removed.
+* `DefaultRegion`:
+    * The constructor expects a PSR-6 cache item pool as second argument now.
+    * The protected `$cache` property is removed.
+    * The properties `$name` and `$lifetime` as well as the constant
+      `REGION_KEY_SEPARATOR` and the method `getCacheEntryKey()` are
+      `private` now.
+    * The method `getCache()` has been removed.
+
+
+## BC Break: Remove `Doctrine\ORM\Mapping\Driver\PHPDriver`
+
+Use `StaticPHPDriver` instead when you want to programmatically configure
+entity metadata.
+
+## BC BREAK: Remove `Doctrine\ORM\EntityManagerInterface#transactional()`
+
+This method has been replaced by `Doctrine\ORM\EntityManagerInterface#wrapInTransaction()`.
+
+## BC BREAK: Removed support for schema emulation.
+
+The ORM no longer attempts to emulate schemas on SQLite.
+
+## BC BREAK: Remove `Setup::registerAutoloadDirectory()`
+
+Use Composer's autoloader instead.
+
+## BC BREAK: Remove YAML mapping drivers.
+
+If your code relies on `YamlDriver` or `SimpleYamlDriver`, you **MUST** migrate to
+attribute, annotation or XML drivers instead.
+
+You can use the `orm:convert-mapping` command to convert your metadata mapping to XML
+_before_ upgrading to 3.0:
+
+```sh
+php doctrine orm:convert-mapping xml /path/to/mapping-path-converted-to-xml
+```
+
+## BC BREAK: Remove code generators and related console commands
+
+These console commands have been removed:
+
+* `orm:convert-d1-schema`
+* `orm:convert-mapping`
+* `orm:generate:entities`
+* `orm:generate-repositories`
+
+These classes have been deprecated:
+
+* `Doctrine\ORM\Tools\ConvertDoctrine1Schema`
+* `Doctrine\ORM\Tools\EntityGenerator`
+* `Doctrine\ORM\Tools\EntityRepositoryGenerator`
+
+The entire `Doctrine\ORM\Tools\Export` namespace has been removed as well.
+
+## BC BREAK: Removed `Doctrine\ORM\Version`
+
+Use Composer's runtime API if you _really_ need to check the version of the ORM package at runtime.
+
+## BC BREAK: EntityRepository::count() signature change
+
+The argument `$criteria` of `Doctrine\ORM\EntityRepository::count()` is now
+optional. Overrides in child classes should be made compatible.
+
+## BC BREAK: changes in exception hierarchy
+
+- `Doctrine\ORM\ORMException` has been removed
+- `Doctrine\ORM\Exception\ORMException` is now an interface
+
+## Variadic methods now use native variadics
+The following methods were using `func_get_args()` to simulate a variadic argument:
+- `Doctrine\ORM\Query\Expr#andX()`
+- `Doctrine\ORM\Query\Expr#orX()`
+- `Doctrine\ORM\QueryBuilder#select()`
+- `Doctrine\ORM\QueryBuilder#addSelect()`
+- `Doctrine\ORM\QueryBuilder#where()`
+- `Doctrine\ORM\QueryBuilder#andWhere()`
+- `Doctrine\ORM\QueryBuilder#orWhere()`
+- `Doctrine\ORM\QueryBuilder#groupBy()`
+- `Doctrine\ORM\QueryBuilder#andGroupBy()`
+- `Doctrine\ORM\QueryBuilder#having()`
+- `Doctrine\ORM\QueryBuilder#andHaving()`
+- `Doctrine\ORM\QueryBuilder#orHaving()`
+A variadic argument is now actually used in their signatures signature (`...$x`).
+Signatures of overridden methods should be changed accordingly
+
+## Minor BC BREAK: removed `Doctrine\ORM\EntityManagerInterface#copy()`
+
+Method `Doctrine\ORM\EntityManagerInterface#copy()` never got its implementation and is removed in 3.0.
+
+## BC BREAK: Removed classes related to UUID and TABLE generator strategies
+
+The following classes have been removed:
+- `Doctrine\ORM\Id\TableGenerator`
+- `Doctrine\ORM\Id\UuidGenerator`
+
+Using the `UUID` strategy for generating identifiers is not supported anymore.
+
+## BC BREAK: Removed `Query::iterate()`
+
+The deprecated method `Query::iterate()` has been removed along with the
+following classes and methods:
+
+- `AbstractHydrator::iterate()`
+- `AbstractHydrator::hydrateRow()`
+- `IterableResult`
+
+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
@@ -1235,7 +1951,7 @@ The EntityRepository now has an interface Doctrine\Persistence\ObjectRepository.
 The annotation reader was heavily refactored between 2.0 and 2.1-RC1. In theory the operation of the new reader should be backwards compatible, but it has to be setup differently to work that way:
 
     // new call to the AnnotationRegistry
-    \Doctrine\Common\Annotations\AnnotationRegistry::registerFile('/doctrine-src/lib/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php');
+    \Doctrine\Common\Annotations\AnnotationRegistry::registerFile('/doctrine-src/src/Mapping/Driver/DoctrineAnnotations.php');
 
     $reader = new \Doctrine\Common\Annotations\AnnotationReader();
     $reader->setDefaultAnnotationNamespace('Doctrine\ORM\Mapping\\');

bin/doctrine

@@ -1,4 +0,0 @@
-#!/usr/bin/env php
-<?php
-
-include(__DIR__ . '/doctrine.php');

bin/doctrine-pear.php

@@ -1,43 +0,0 @@
-<?php
-
-fwrite(
-    STDERR,
-    '[Warning] The use of this script is discouraged. See'
-    . ' https://www.doctrine-project.org/projects/doctrine-orm/en/current/reference/tools.html#doctrine-console'
-    . ' for instructions on bootstrapping the console runner.'
-    . PHP_EOL
-);
-
-echo PHP_EOL . PHP_EOL;
-
-require_once 'Doctrine/Common/ClassLoader.php';
-
-$classLoader = new \Doctrine\Common\ClassLoader('Doctrine');
-$classLoader->register();
-
-$classLoader = new \Doctrine\Common\ClassLoader('Symfony');
-$classLoader->register();
-
-$configFile = getcwd() . DIRECTORY_SEPARATOR . 'cli-config.php';
-
-$helperSet = null;
-if (file_exists($configFile)) {
-    if ( ! is_readable($configFile)) {
-        trigger_error(
-            'Configuration file [' . $configFile . '] does not have read permission.', E_USER_ERROR
-        );
-    }
-
-    require $configFile;
-
-    foreach ($GLOBALS as $helperSetCandidate) {
-        if ($helperSetCandidate instanceof \Symfony\Component\Console\Helper\HelperSet) {
-            $helperSet = $helperSetCandidate;
-            break;
-        }
-    }
-}
-
-$helperSet = ($helperSet) ?: new \Symfony\Component\Console\Helper\HelperSet();
-
-\Doctrine\ORM\Tools\Console\ConsoleRunner::run($helperSet);

bin/doctrine.bat

@@ -1,9 +0,0 @@
-@echo off
-
-if "%PHPBIN%" == "" set PHPBIN=@php_bin@
-if not exist "%PHPBIN%" if "%PHP_PEAR_PHP_BIN%" neq "" goto USE_PEAR_PATH
-GOTO RUN
-:USE_PEAR_PATH
-set PHPBIN=%PHP_PEAR_PHP_BIN%
-:RUN
-"%PHPBIN%" "@bin_dir@\doctrine" %*

bin/doctrine.php

@@ -1,62 +0,0 @@
-<?php
-
-use Symfony\Component\Console\Helper\HelperSet;
-use Doctrine\ORM\Tools\Console\ConsoleRunner;
-
-fwrite(
-    STDERR,
-    '[Warning] The use of this script is discouraged. See'
-    . ' https://www.doctrine-project.org/projects/doctrine-orm/en/current/reference/tools.html#doctrine-console'
-    . ' for instructions on bootstrapping the console runner.'
-    . PHP_EOL
-);
-
-echo PHP_EOL . PHP_EOL;
-
-$autoloadFiles = [
-    __DIR__ . '/../vendor/autoload.php',
-    __DIR__ . '/../../../autoload.php'
-];
-
-foreach ($autoloadFiles as $autoloadFile) {
-    if (file_exists($autoloadFile)) {
-        require_once $autoloadFile;
-        break;
-    }
-}
-
-$directories = [getcwd(), getcwd() . DIRECTORY_SEPARATOR . 'config'];
-
-$configFile = null;
-foreach ($directories as $directory) {
-    $configFile = $directory . DIRECTORY_SEPARATOR . 'cli-config.php';
-
-    if (file_exists($configFile)) {
-        break;
-    }
-}
-
-if ( ! file_exists($configFile)) {
-    ConsoleRunner::printCliConfigTemplate();
-    exit(1);
-}
-
-if ( ! is_readable($configFile)) {
-    echo 'Configuration file [' . $configFile . '] does not have read permission.' . "\n";
-    exit(1);
-}
-
-$commands = [];
-
-$helperSet = require $configFile;
-
-if ( ! ($helperSet instanceof HelperSet)) {
-    foreach ($GLOBALS as $helperSetCandidate) {
-        if ($helperSetCandidate instanceof HelperSet) {
-            $helperSet = $helperSetCandidate;
-            break;
-        }
-    }
-}
-
-ConsoleRunner::run($helperSet, $commands);

ci/github/phpunit/mysqli.xml

@@ -3,9 +3,8 @@
          xsi:noNamespaceSchemaLocation="../../../vendor/phpunit/phpunit/phpunit.xsd"
          colors="true"
          beStrictAboutOutputDuringTests="true"
-         beStrictAboutTodoAnnotatedTests="true"
          failOnRisky="true"
-         convertDeprecationsToExceptions="true"
+         cacheDirectory=".phpunit.cache"
 >
     <php>
         <ini name="error_reporting" value="-1" />
@@ -14,6 +13,9 @@
         <var name="db_port" value="3306"/>
         <var name="db_user" value="root" />
         <var name="db_dbname" value="doctrine_tests" />
+        <var name="db_default_table_option_charset" value="utf8mb4" />
+        <var name="db_default_table_option_collation" value="utf8mb4_unicode_ci" />
+        <var name="db_default_table_option_engine" value="InnoDB" />
 
         <!-- necessary change for some CLI/console output test assertions -->
         <env name="COLUMNS" value="120"/>
@@ -25,11 +27,11 @@
         </testsuite>
     </testsuites>
 
-    <filter>
-        <whitelist>
-            <directory suffix=".php">../../../lib/Doctrine</directory>
-        </whitelist>
-    </filter>
+    <source>
+        <include>
+            <directory suffix=".php">../../../src</directory>
+        </include>
+    </source>
 
     <groups>
         <exclude>

ci/github/phpunit/pdo_mysql.xml

@@ -3,9 +3,8 @@
          xsi:noNamespaceSchemaLocation="../../../vendor/phpunit/phpunit/phpunit.xsd"
          colors="true"
          beStrictAboutOutputDuringTests="true"
-         beStrictAboutTodoAnnotatedTests="true"
          failOnRisky="true"
-         convertDeprecationsToExceptions="true"
+         cacheDirectory=".phpunit.cache"
 >
     <php>
         <ini name="error_reporting" value="-1" />
@@ -14,6 +13,9 @@
         <var name="db_port" value="3306"/>
         <var name="db_user" value="root" />
         <var name="db_dbname" value="doctrine_tests" />
+        <var name="db_default_table_option_charset" value="utf8mb4" />
+        <var name="db_default_table_option_collation" value="utf8mb4_unicode_ci" />
+        <var name="db_default_table_option_engine" value="InnoDB" />
 
         <!-- necessary change for some CLI/console output test assertions -->
         <env name="COLUMNS" value="120"/>
@@ -25,12 +27,11 @@
         </testsuite>
     </testsuites>
 
-    <filter>
-        <whitelist>
-            <directory suffix=".php">../../../lib/Doctrine</directory>
-        </whitelist>
-    </filter>
-
+    <source>
+        <include>
+            <directory suffix=".php">../../../src</directory>
+        </include>
+    </source>
 
     <groups>
         <exclude>

ci/github/phpunit/pdo_pgsql.xml

@@ -3,9 +3,8 @@
          xsi:noNamespaceSchemaLocation="../../../vendor/phpunit/phpunit/phpunit.xsd"
          colors="true"
          beStrictAboutOutputDuringTests="true"
-         beStrictAboutTodoAnnotatedTests="true"
          failOnRisky="true"
-         convertDeprecationsToExceptions="true"
+         cacheDirectory=".phpunit.cache"
 >
     <php>
         <ini name="error_reporting" value="-1" />
@@ -25,11 +24,11 @@
         </testsuite>
     </testsuites>
 
-    <filter>
-        <whitelist>
-            <directory suffix=".php">../../../lib/Doctrine</directory>
-        </whitelist>
-    </filter>
+    <source>
+        <include>
+            <directory suffix=".php">../../../src</directory>
+        </include>
+    </source>
 
     <groups>
         <exclude>

ci/github/phpunit/pdo_sqlite.xml

@@ -3,9 +3,8 @@
          xsi:noNamespaceSchemaLocation="../../../vendor/phpunit/phpunit/phpunit.xsd"
          colors="true"
          beStrictAboutOutputDuringTests="true"
-         beStrictAboutTodoAnnotatedTests="true"
          failOnRisky="true"
-         convertDeprecationsToExceptions="true"
+         cacheDirectory=".phpunit.cache"
 >
     <php>
         <ini name="error_reporting" value="-1" />
@@ -23,11 +22,11 @@
         </testsuite>
     </testsuites>
 
-    <filter>
-        <whitelist>
-            <directory suffix=".php">../../../lib/Doctrine</directory>
-        </whitelist>
-    </filter>
+    <source>
+        <include>
+            <directory suffix=".php">../../../src</directory>
+        </include>
+    </source>
 
     <groups>
         <exclude>

ci/github/phpunit/pgsql.xml

@@ -3,9 +3,8 @@
          xsi:noNamespaceSchemaLocation="../../../vendor/phpunit/phpunit/phpunit.xsd"
          colors="true"
          beStrictAboutOutputDuringTests="true"
-         beStrictAboutTodoAnnotatedTests="true"
          failOnRisky="true"
-         convertDeprecationsToExceptions="true"
+         cacheDirectory=".phpunit.cache"
 >
     <php>
         <ini name="error_reporting" value="-1" />
@@ -25,11 +24,11 @@
         </testsuite>
     </testsuites>
 
-    <filter>
-        <whitelist>
-            <directory suffix=".php">../../../lib/Doctrine</directory>
-        </whitelist>
-    </filter>
+    <source>
+        <include>
+            <directory suffix=".php">../../../src</directory>
+        </include>
+    </source>
 
     <groups>
         <exclude>

ci/github/phpunit/sqlite3.xml

@@ -3,9 +3,8 @@
          xsi:noNamespaceSchemaLocation="../../../vendor/phpunit/phpunit/phpunit.xsd"
          colors="true"
          beStrictAboutOutputDuringTests="true"
-         beStrictAboutTodoAnnotatedTests="true"
          failOnRisky="true"
-         convertDeprecationsToExceptions="true"
+         cacheDirectory=".phpunit.cache"
 >
     <php>
         <ini name="error_reporting" value="-1" />
@@ -23,11 +22,11 @@
         </testsuite>
     </testsuites>
 
-    <filter>
-        <whitelist>
-            <directory suffix=".php">../../../lib/Doctrine</directory>
-        </whitelist>
-    </filter>
+    <source>
+        <include>
+            <directory suffix=".php">../../../src</directory>
+        </include>
+    </source>
 
     <groups>
         <exclude>

composer.json

@@ -20,56 +20,45 @@
         "sort-packages": true
     },
     "require": {
-        "php": "^7.1 || ^8.0",
+        "php": "^8.1",
         "composer-runtime-api": "^2",
         "ext-ctype": "*",
-        "doctrine/cache": "^1.12.1 || ^2.1.1",
-        "doctrine/collections": "^1.5 || ^2.1",
-        "doctrine/common": "^3.0.3",
-        "doctrine/dbal": "^2.13.1 || ^3.2",
+        "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": "^2",
-        "doctrine/persistence": "^2.4 || ^3",
+        "doctrine/lexer": "^3",
+        "doctrine/persistence": "^3.3.1",
         "psr/cache": "^1 || ^2 || ^3",
-        "symfony/console": "^4.2 || ^5.0 || ^6.0 || ^7.0",
-        "symfony/polyfill-php72": "^1.23",
-        "symfony/polyfill-php80": "^1.16"
+        "symfony/console": "^5.4 || ^6.0 || ^7.0",
+        "symfony/var-exporter": "^6.3.9 || ^7.0"
     },
     "require-dev": {
-        "doctrine/annotations": "^1.13 || ^2",
-        "doctrine/coding-standard": "^9.0.2 || ^12.0",
-        "phpbench/phpbench": "^0.16.10 || ^1.0",
-        "phpstan/phpstan": "~1.4.10 || 1.10.35",
-        "phpunit/phpunit": "^7.5 || ^8.5 || ^9.6",
+        "doctrine/coding-standard": "^12.0",
+        "phpbench/phpbench": "^1.0",
+        "phpstan/phpstan": "1.10.59",
+        "phpunit/phpunit": "^10.4.0",
         "psr/log": "^1 || ^2 || ^3",
         "squizlabs/php_codesniffer": "3.7.2",
-        "symfony/cache": "^4.4 || ^5.4 || ^6.4 || ^7.0",
-        "symfony/var-exporter": "^4.4 || ^5.4 || ^6.2 || ^7.0",
-        "symfony/yaml": "^3.4 || ^4.0 || ^5.0 || ^6.0 || ^7.0",
-        "vimeo/psalm": "4.30.0 || 5.16.0"
-    },
-    "conflict": {
-        "doctrine/annotations": "<1.13 || >= 3.0"
+        "symfony/cache": "^5.4 || ^6.2 || ^7.0",
+        "vimeo/psalm": "5.22.2"
     },
     "suggest": {
         "ext-dom": "Provides support for XSD validation for XML mapping files",
-        "symfony/cache": "Provides cache support for Setup Tool with doctrine/cache 2.0",
-        "symfony/yaml": "If you want to use YAML Metadata Mapping Driver"
+        "symfony/cache": "Provides cache support for Setup Tool with doctrine/cache 2.0"
     },
     "autoload": {
-        "psr-4": { "Doctrine\\ORM\\": "lib/Doctrine/ORM" }
+        "psr-4": { "Doctrine\\ORM\\": "src" }
     },
     "autoload-dev": {
         "psr-4": {
-            "Doctrine\\Tests\\": "tests/Doctrine/Tests",
-            "Doctrine\\StaticAnalysis\\": "tests/Doctrine/StaticAnalysis",
-            "Doctrine\\Performance\\": "tests/Doctrine/Performance"
+            "Doctrine\\Tests\\": "tests/Tests",
+            "Doctrine\\StaticAnalysis\\": "tests/StaticAnalysis",
+            "Doctrine\\Performance\\": "tests/Performance"
         }
     },
-    "bin": ["bin/doctrine"],
     "archive": {
         "exclude": ["!vendor", "tests", "*phpunit.xml", "build.xml", "build.properties", "composer.phar", "vendor/satooshi", "lib/vendor", "*.swp"]
     }

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/_exts/configurationblock.py

@@ -35,14 +35,12 @@ class ConfigurationBlock(Directive):
         'html':            'HTML',
         'xml':             'XML',
         'php':             'PHP',
-        'yaml':            'YAML',
         'jinja':           'Twig',
         'html+jinja':      'Twig',
         'jinja+html':      'Twig',
         'php+html':        'PHP',
         'html+php':        'PHP',
         'ini':             'INI',
-        'php-annotations': 'Annotations',
     }
 
     def run(self):

docs/en/cookbook/advanced-field-value-conversion-using-custom-mapping-types.rst

@@ -140,11 +140,6 @@ Now we're going to create the ``point`` type and implement all required methods.
             return $value;
         }
 
-        public function canRequireSQLConversion()
-        {
-            return true;
-        }
-
         public function convertToPHPValueSQL($sqlExpr, AbstractPlatform $platform)
         {
             return sprintf('AsText(%s)', $sqlExpr);

docs/en/cookbook/aggregate-fields.rst

@@ -36,71 +36,50 @@ Our entities look like:
     namespace Bank\Entities;
 
     use Doctrine\ORM\Mapping as ORM;
-    
-    /**
-     * @ORM\Entity
-     */
+    use Doctrine\Common\Collections\ArrayCollection;
+    use Doctrine\Common\Collections\Collection;
+
+    #[ORM\Entity]
     class Account
     {
-        /**
-         * @ORM\Id
-         * @ORM\GeneratedValue
-         * @ORM\Column(type="integer")
-         */
+        #[ORM\Id]
+        #[ORM\GeneratedValue]
+        #[ORM\Column(type: 'integer')]
         private ?int $id;
-    
-        /**
-         * @ORM\Column(type="string", unique=true)
-         */
-        private string $no;
-    
-        /**
-         * @ORM\OneToMany(targetEntity="Entry", mappedBy="account", cascade={"persist"})
-         */
-        private array $entries;
-    
-        /**
-         * @ORM\Column(type="integer")
-         */
-        private int $maxCredit = 0;
-    
-        public function __construct(string $no, int $maxCredit = 0)
-        {
-            $this->no = $no;
-            $this->maxCredit = $maxCredit;
-            $this->entries = new \Doctrine\Common\Collections\ArrayCollection();
+
+        #[ORM\OneToMany(targetEntity: Entry::class, mappedBy: 'account', cascade: ['persist'])]
+        private Collection $entries;
+
+
+        public function __construct(
+            #[ORM\Column(type: 'string', unique: true)]
+            private string $no,
+
+            #[ORM\Column(type: 'integer')]
+            private int $maxCredit = 0,
+        ) {
+            $this->entries = new ArrayCollection();
         }
     }
-    
-    /**
-     * @ORM\Entity
-     */
+
+    #[ORM\Entity]
     class Entry
     {
-        /**
-         * @ORM\Id
-         * @ORM\GeneratedValue
-         * @ORM\Column(type="integer")
-         */
+        #[ORM\Id]
+        #[ORM\GeneratedValue]
+        #[ORM\Column(type: 'integer')]
         private ?int $id;
-    
-        /**
-         * @ORM\ManyToOne(targetEntity="Account", inversedBy="entries")
-         */
-        private Account $account;
-    
-        /**
-         * @ORM\Column(type="integer")
-         */
-        private int $amount;
-    
-        public function __construct(Account $account, int $amount)
-        {
-            $this->account = $account;
-            $this->amount = $amount;
+
+        public function __construct(
+            #[ORM\ManyToOne(targetEntity: Account::class, inversedBy: 'entries')]
+            private Account $account,
+
+            #[ORM\Column(type: 'integer')]
+            private int $amount,
+        ) {
             // more stuff here, from/to whom, stated reason, execution date and such
         }
-    
+
         public function getAmount(): Amount
         {
             return $this->amount;
@@ -193,9 +172,8 @@ relation with this method:
         public function addEntry(int $amount): void
         {
             $this->assertAcceptEntryAllowed($amount);
-    
-            $e = new Entry($this, $amount);
-            $this->entries[] = $e;
+
+            $this->entries[] = new Entry($this, $amount);
         }
     }
 
@@ -213,18 +191,18 @@ Now look at the following test-code for our entities:
         {
             $account = new Account("123456", maxCredit: 200);
             $this->assertEquals(0, $account->getBalance());
-    
+
             $account->addEntry(500);
             $this->assertEquals(500, $account->getBalance());
-    
+
             $account->addEntry(-700);
             $this->assertEquals(-200, $account->getBalance());
         }
-    
+
         public function testExceedMaxLimit()
         {
             $account = new Account("123456", maxCredit: 200);
-    
+
             $this->expectException(Exception::class);
             $account->addEntry(-1000);
         }
@@ -285,22 +263,19 @@ entries collection) we want to add an aggregate field called
     <?php
     class Account
     {
-        /**
-         * @ORM\Column(type="integer")
-         */
+        #[ORM\Column(type: 'integer')]
         private int $balance = 0;
-    
+
         public function getBalance(): int
         {
             return $this->balance;
         }
-    
+
         public function addEntry(int $amount): void
         {
             $this->assertAcceptEntryAllowed($amount);
-    
-            $e = new Entry($this, $amount);
-            $this->entries[] = $e;
+
+            $this->entries[] = new Entry($this, $amount);
             $this->balance += $amount;
         }
     }
@@ -331,13 +306,13 @@ potentially lead to inconsistent state. See this example:
     // The Account $accId has a balance of 0 and a max credit limit of 200:
     // request 1 account
     $account1 = $em->find(Account::class, $accId);
-    
+
     // request 2 account
     $account2 = $em->find(Account::class, $accId);
-    
+
     $account1->addEntry(-200);
     $account2->addEntry(-200);
-    
+
     // now request 1 and 2 both flush the changes.
 
 The aggregate field ``Account::$balance`` is now -200, however the
@@ -357,10 +332,8 @@ Optimistic locking is as easy as adding a version column:
 
     class Account
     {
-        /**
-         * @ORM\Column(type="integer")
-         * @ORM\Version
-         */
+        #[ORM\Column(type: 'integer')]
+        #[ORM\Version]
         private int $version;
     }
 

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

@@ -99,12 +99,12 @@ discuss it step by step:
 
         public function parse(\Doctrine\ORM\Query\Parser $parser)
         {
-            $parser->match(Lexer::T_IDENTIFIER); // (2)
-            $parser->match(Lexer::T_OPEN_PARENTHESIS); // (3)
+            $parser->match(TokenType::T_IDENTIFIER); // (2)
+            $parser->match(TokenType::T_OPEN_PARENTHESIS); // (3)
             $this->firstDateExpression = $parser->ArithmeticPrimary(); // (4)
-            $parser->match(Lexer::T_COMMA); // (5)
+            $parser->match(TokenType::T_COMMA); // (5)
             $this->secondDateExpression = $parser->ArithmeticPrimary(); // (6)
-            $parser->match(Lexer::T_CLOSE_PARENTHESIS); // (3)
+            $parser->match(TokenType::T_CLOSE_PARENTHESIS); // (3)
         }
 
         public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
@@ -183,23 +183,23 @@ I'll skip the blah and show the code for this function:
 
         public function parse(\Doctrine\ORM\Query\Parser $parser)
         {
-            $parser->match(Lexer::T_IDENTIFIER);
-            $parser->match(Lexer::T_OPEN_PARENTHESIS);
+            $parser->match(TokenType::T_IDENTIFIER);
+            $parser->match(TokenType::T_OPEN_PARENTHESIS);
 
             $this->firstDateExpression = $parser->ArithmeticPrimary();
 
-            $parser->match(Lexer::T_COMMA);
-            $parser->match(Lexer::T_IDENTIFIER);
+            $parser->match(TokenType::T_COMMA);
+            $parser->match(TokenType::T_IDENTIFIER);
 
             $this->intervalExpression = $parser->ArithmeticPrimary();
 
-            $parser->match(Lexer::T_IDENTIFIER);
+            $parser->match(TokenType::T_IDENTIFIER);
 
             /** @var Lexer $lexer */
             $lexer = $parser->getLexer();
             $this->unit = $lexer->token['value'];
 
-            $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+            $parser->match(TokenType::T_CLOSE_PARENTHESIS);
         }
 
         public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)

docs/en/cookbook/implementing-arrayaccess-for-domain-objects.rst

@@ -1,7 +1,7 @@
 Implementing ArrayAccess for Domain Objects
 ===========================================
 
-.. sectionauthor:: Roman Borschel (roman@code-factory.org)
+.. sectionauthor:: Roman Borschel <roman@code-factory.org>
 
 This recipe will show you how to implement ArrayAccess for your
 domain objects in order to allow more uniform access, for example

docs/en/cookbook/implementing-the-notify-changetracking-policy.rst

@@ -1,75 +0,0 @@
-Implementing the Notify ChangeTracking Policy
-=============================================
-
-.. sectionauthor:: Roman Borschel (roman@code-factory.org)
-
-The NOTIFY change-tracking policy is the most effective
-change-tracking policy provided by Doctrine but it requires some
-boilerplate code. This recipe will show you how this boilerplate
-code should look like. We will implement it on a
-`Layer Supertype <https://martinfowler.com/eaaCatalog/layerSupertype.html>`_
-for all our domain objects.
-
-.. note::
-
-    The notify change tracking policy is deprecated and will be removed in ORM 3.0.
-    (\ `Details <https://github.com/doctrine/orm/issues/8383>`_)
-
-Implementing NotifyPropertyChanged
-----------------------------------
-
-The NOTIFY policy is based on the assumption that the entities
-notify interested listeners of changes to their properties. For
-that purpose, a class that wants to use this policy needs to
-implement the ``NotifyPropertyChanged`` interface from the
-``Doctrine\Common`` namespace.
-
-.. code-block:: php
-
-    <?php
-    use Doctrine\Persistence\NotifyPropertyChanged;
-    use Doctrine\Persistence\PropertyChangedListener;
-
-    abstract class DomainObject implements NotifyPropertyChanged
-    {
-        private $listeners = array();
-
-        public function addPropertyChangedListener(PropertyChangedListener $listener) {
-            $this->listeners[] = $listener;
-        }
-
-        /** Notifies listeners of a change. */
-        protected function onPropertyChanged($propName, $oldValue, $newValue) {
-            if ($this->listeners) {
-                foreach ($this->listeners as $listener) {
-                    $listener->propertyChanged($this, $propName, $oldValue, $newValue);
-                }
-            }
-        }
-    }
-
-Then, in each property setter of concrete, derived domain classes,
-you need to invoke onPropertyChanged as follows to notify
-listeners:
-
-.. code-block:: php
-
-    <?php
-    // Mapping not shown, either in attributes, annotations, xml or yaml as usual
-    class MyEntity extends DomainObject
-    {
-        private $data;
-        // ... other fields as usual
-
-        public function setData($data) {
-            if ($data != $this->data) { // check: is it actually modified?
-                $this->onPropertyChanged('data', $this->data, $data);
-                $this->data = $data;
-            }
-        }
-    }
-
-The check whether the new value is different from the old one is
-not mandatory but recommended. That way you can avoid unnecessary
-updates and also have full control over when you consider a
-property changed.

docs/en/cookbook/mysql-enums.rst

@@ -43,13 +43,13 @@ entities:
 .. code-block:: php
 
     <?php
-    /** @Entity */
+    #[Entity]
     class Article
     {
         const STATUS_VISIBLE = 'visible';
         const STATUS_INVISIBLE = 'invisible';
 
-        /** @Column(type="string") */
+        #[Column(type: "string")]
         private $status;
 
         public function setStatus($status)
@@ -67,10 +67,10 @@ the **columnDefinition** attribute.
 .. code-block:: php
 
     <?php
-    /** @Entity */
+    #[Entity]
     class Article
     {
-        /** @Column(type="string", columnDefinition="ENUM('visible', 'invisible')") */
+        #[Column(type: "string", columnDefinition: "ENUM('visible', 'invisible')")]
         private $status;
     }
 
@@ -131,10 +131,10 @@ Then in your entity you can just use this type:
 .. code-block:: php
 
     <?php
-    /** @Entity */
+    #[Entity]
     class Article
     {
-        /** @Column(type="enumvisibility") */
+        #[Column(type: "enumvisibility")]
         private $status;
     }
 
@@ -196,4 +196,3 @@ With this base class you can define an enum as easily as:
         protected $name = 'enumvisibility';
         protected $values = array('visible', 'invisible');
     }
-

docs/en/cookbook/resolve-target-entity-listener.rst

@@ -47,10 +47,8 @@ A Customer entity
     use Acme\CustomerModule\Entity\Customer as BaseCustomer;
     use Acme\InvoiceModule\Model\InvoiceSubjectInterface;
 
-    /**
-     * @ORM\Entity
-     * @ORM\Table(name="customer")
-     */
+    #[ORM\Entity]
+    #[ORM\Table(name: 'customer')]
     class Customer extends BaseCustomer implements InvoiceSubjectInterface
     {
         // In our example, any methods defined in the InvoiceSubjectInterface
@@ -69,19 +67,12 @@ An Invoice entity
     use Doctrine\ORM\Mapping AS ORM;
     use Acme\InvoiceModule\Model\InvoiceSubjectInterface;
 
-    /**
-     * Represents an Invoice.
-     *
-     * @ORM\Entity
-     * @ORM\Table(name="invoice")
-     */
+    #[ORM\Entity]
+    #[ORM\Table(name: 'invoice')]
     class Invoice
     {
-        /**
-         * @ORM\ManyToOne(targetEntity="Acme\InvoiceModule\Model\InvoiceSubjectInterface")
-         * @var InvoiceSubjectInterface
-         */
-        protected $subject;
+        #[ORM\ManyToOne(targetEntity: InvoiceSubjectInterface::class)]
+        protected InvoiceSubjectInterface $subject;
     }
 
 An InvoiceSubjectInterface

docs/en/cookbook/strategy-cookbook-introduction.rst

@@ -155,7 +155,7 @@ As you can see, we have a method "setBlockEntity" which ties a potential strateg
          * that is used for this blockitem. (This string (!) value will be persisted by Doctrine ORM)
          *
          * This is a doctrine field, so make sure that you use a
-           #[Column] attribute or setup your yaml or xml files correctly
+           #[Column] attribute or setup your xml files correctly
          * @var string
          */
         protected $strategyClassName;

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

@@ -71,23 +71,6 @@ First Attributes:
         public function assertCustomerAllowedBuying() {}
     }
 
-As Annotations:
-
-.. code-block:: php
-
-    <?php
-    /**
-     * @Entity
-     * @HasLifecycleCallbacks
-     */
-    class Order
-    {
-        /**
-         * @PrePersist @PreUpdate
-         */
-        public function assertCustomerAllowedBuying() {}
-    }
-
 In XML Mappings:
 
 .. code-block:: xml

docs/en/cookbook/working-with-datetime.rst

@@ -162,15 +162,13 @@ requiring timezoned datetimes:
     <?php
     namespace Shipping;
 
-    /**
-     * @Entity
-     */
+     #[Entity]
     class Event
     {
-        /** @Column(type="datetime") */
+        #[Column(type: 'datetime')]
         private $created;
 
-        /** @Column(type="string") */
+        #[Column(type: 'string')]
         private $timezone;
 
         /**

docs/en/index.rst

@@ -1,4 +1,4 @@
-Welcome to Doctrine 2 ORM's documentation!
+Welcome to Doctrine ORM's documentation!
 ==========================================
 
 The Doctrine documentation is comprised of tutorials, a reference section and
@@ -39,10 +39,8 @@ Mapping Objects onto a Database
   :doc:`Inheritance <reference/inheritance-mapping>`
 
 * **Drivers**:
-  :doc:`Docblock Annotations <reference/annotations-reference>` \|
   :doc:`Attributes <reference/attributes-reference>` \|
   :doc:`XML <reference/xml-mapping>` \|
-  :doc:`YAML <reference/yaml-mapping>` \|
   :doc:`PHP <reference/php-mapping>`
 
 Working with Objects
@@ -75,7 +73,6 @@ Advanced Topics
 * :doc:`TypedFieldMapper <reference/typedfieldmapper>`
 * :doc:`Improving Performance <reference/improving-performance>`
 * :doc:`Caching <reference/caching>`
-* :doc:`Partial Objects <reference/partial-objects>`
 * :doc:`Change Tracking Policies <reference/change-tracking-policies>`
 * :doc:`Best Practices <reference/best-practices>`
 * :doc:`Metadata Drivers <reference/metadata-drivers>`
@@ -96,7 +93,7 @@ Tutorials
 Changelogs
 ----------
 
-* `Upgrade <https://github.com/doctrine/doctrine2/blob/master/UPGRADE.md>`_
+* `Upgrade <https://github.com/doctrine/orm/blob/HEAD/UPGRADE.md>`_
 
 Cookbook
 --------
@@ -112,7 +109,6 @@ Cookbook
 
 * **Implementation**:
   :doc:`Array Access <cookbook/implementing-arrayaccess-for-domain-objects>` \|
-  :doc:`Notify ChangeTracking Example <cookbook/implementing-the-notify-changetracking-policy>` \|
   :doc:`Working with DateTime <cookbook/working-with-datetime>` \|
   :doc:`Validation <cookbook/validation-of-entities>` \|
   :doc:`Entities in the Session <cookbook/entities-in-session>` \|

docs/en/reference/advanced-configuration.rst

@@ -111,21 +111,16 @@ Gets or sets the metadata driver implementation that is used by
 Doctrine to acquire the object-relational metadata for your
 classes.
 
-There are currently 5 available implementations:
+There are currently 3 available implementations:
 
 
 -  ``Doctrine\ORM\Mapping\Driver\AttributeDriver``
 -  ``Doctrine\ORM\Mapping\Driver\XmlDriver``
 -  ``Doctrine\ORM\Mapping\Driver\DriverChain``
--  ``Doctrine\ORM\Mapping\Driver\AnnotationDriver`` (deprecated and will
-  be removed in ``doctrine/orm`` 3.0)
--  ``Doctrine\ORM\Mapping\Driver\YamlDriver`` (deprecated and will be
-   removed in ``doctrine/orm`` 3.0)
 
 Throughout the most part of this manual the AttributeDriver is
 used in the examples. For information on the usage of the
-AnnotationDriver, XmlDriver or YamlDriver please refer to the dedicated
-chapters ``Annotation Reference``, ``XML Mapping`` and ``YAML Mapping``.
+XmlDriver please refer to the dedicated chapter ``XML Mapping``.
 
 The attribute driver can be injected in the ``Doctrine\ORM\Configuration``:
 
@@ -155,9 +150,9 @@ Metadata Cache (***RECOMMENDED***)
 
 Gets or sets the cache adapter to use for caching metadata
 information, that is, all the information you supply via attributes,
-annotations, xml or yaml, so that they do not need to be parsed and
-loaded from scratch on every single request which is a waste of
-resources. The cache implementation must implement the PSR-6
+xml, so that they do not need to be parsed and loaded from scratch on
+every single request which is a waste of resources. The cache
+implementation must implement the PSR-6
 ``Psr\Cache\CacheItemPoolInterface`` interface.
 
 Usage of a metadata cache is highly recommended.
@@ -425,7 +420,7 @@ Multiple Metadata Sources
 
 When using different components using Doctrine ORM you may end up
 with them using two different metadata drivers, for example XML and
-YAML. You can use the MappingDriverChain Metadata implementations to
+PHP. You can use the MappingDriverChain Metadata implementations to
 aggregate these drivers based on namespaces:
 
 .. code-block:: php
@@ -435,7 +430,7 @@ aggregate these drivers based on namespaces:
 
     $chain = new MappingDriverChain();
     $chain->addDriver($xmlDriver, 'Doctrine\Tests\Models\Company');
-    $chain->addDriver($yamlDriver, 'Doctrine\Tests\ORM\Mapping');
+    $chain->addDriver($phpDriver, 'Doctrine\Tests\ORM\Mapping');
 
 Based on the namespace of the entity the loading of entities is
 delegated to the appropriate driver. The chain semantics come from

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

@@ -56,27 +56,6 @@ A many-to-one association is the most common association between objects. Exampl
             // ...
         }
 
-    .. code-block:: annotation
-
-        <?php
-        /** @Entity */
-        class User
-        {
-            // ...
-
-            /**
-             * @ManyToOne(targetEntity="Address")
-             * @JoinColumn(name="address_id", referencedColumnName="id")
-             */
-            private Address|null $address = null;
-        }
-
-        /** @Entity */
-        class Address
-        {
-            // ...
-        }
-
     .. code-block:: xml
 
         <doctrine-mapping>
@@ -87,18 +66,6 @@ A many-to-one association is the most common association between objects. Exampl
             </entity>
         </doctrine-mapping>
 
-    .. code-block:: yaml
-
-        User:
-          type: entity
-          manyToOne:
-            address:
-              targetEntity: Address
-              joinColumn:
-                name: address_id
-                referencedColumnName: id
-
-
 .. note::
 
     The above ``#[JoinColumn]`` is optional as it would default
@@ -154,30 +121,6 @@ references one ``Shipment`` entity.
             // ...
         }
 
-    .. code-block:: annotation
-
-        <?php
-        /** @Entity */
-        class Product
-        {
-            // ...
-
-            /**
-             * One Product has One Shipment.
-             * @OneToOne(targetEntity="Shipment")
-             * @JoinColumn(name="shipment_id", referencedColumnName="id")
-             */
-            private Shipment|null $shipment = null;
-
-            // ...
-        }
-
-        /** @Entity */
-        class Shipment
-        {
-            // ...
-        }
-
     .. code-block:: xml
 
         <doctrine-mapping>
@@ -188,17 +131,6 @@ references one ``Shipment`` entity.
             </entity>
         </doctrine-mapping>
 
-    .. code-block:: yaml
-
-        Product:
-          type: entity
-          oneToOne:
-            shipment:
-              targetEntity: Shipment
-              joinColumn:
-                name: shipment_id
-                referencedColumnName: id
-
 Note that the ``#[JoinColumn]`` is not really necessary in this example,
 as the defaults would be the same.
 
@@ -259,38 +191,6 @@ object.
             // ...
         }
 
-    .. code-block:: annotation
-
-        <?php
-        /** @Entity */
-        class Customer
-        {
-            // ...
-
-            /**
-             * One Customer has One Cart.
-             * @OneToOne(targetEntity="Cart", mappedBy="customer")
-             */
-            private Cart|null $cart = null;
-
-            // ...
-        }
-
-        /** @Entity */
-        class Cart
-        {
-            // ...
-
-            /**
-             * One Cart has One Customer.
-             * @OneToOne(targetEntity="Customer", inversedBy="cart")
-             * @JoinColumn(name="customer_id", referencedColumnName="id")
-             */
-            private Customer|null $customer = null;
-
-            // ...
-        }
-
     .. code-block:: xml
 
         <doctrine-mapping>
@@ -304,22 +204,6 @@ object.
             </entity>
         </doctrine-mapping>
 
-    .. code-block:: yaml
-
-        Customer:
-          oneToOne:
-            cart:
-              targetEntity: Cart
-              mappedBy: customer
-        Cart:
-          oneToOne:
-            customer:
-              targetEntity: Customer
-              inversedBy: cart
-              joinColumn:
-                name: customer_id
-                referencedColumnName: id
-
 Note that the @JoinColumn is not really necessary in this example,
 as the defaults would be the same.
 
@@ -428,41 +312,6 @@ bidirectional many-to-one.
             // ...
         }
 
-    .. code-block:: annotation
-
-        <?php
-        use Doctrine\Common\Collections\ArrayCollection;
-
-        /** @Entity */
-        class Product
-        {
-            // ...
-            /**
-             * One product has many features. This is the inverse side.
-             * @var Collection<int, Feature>
-             * @OneToMany(targetEntity="Feature", mappedBy="product")
-             */
-            private Collection $features;
-            // ...
-
-            public function __construct() {
-                $this->features = new ArrayCollection();
-            }
-        }
-
-        /** @Entity */
-        class Feature
-        {
-            // ...
-            /**
-             * Many features have one product. This is the owning side.
-             * @ManyToOne(targetEntity="Product", inversedBy="features")
-             * @JoinColumn(name="product_id", referencedColumnName="id")
-             */
-            private Product|null $product = null;
-            // ...
-        }
-
     .. code-block:: xml
 
         <doctrine-mapping>
@@ -476,24 +325,6 @@ bidirectional many-to-one.
             </entity>
         </doctrine-mapping>
 
-    .. code-block:: yaml
-
-        Product:
-          type: entity
-          oneToMany:
-            features:
-              targetEntity: Feature
-              mappedBy: product
-        Feature:
-          type: entity
-          manyToOne:
-            product:
-              targetEntity: Product
-              inversedBy: features
-              joinColumn:
-                name: product_id
-                referencedColumnName: id
-
 Note that the @JoinColumn is not really necessary in this example,
 as the defaults would be the same.
 
@@ -556,39 +387,6 @@ The following example sets up such a unidirectional one-to-many association:
             // ...
         }
 
-    .. code-block:: annotation
-
-        <?php
-        /** @Entity */
-        class User
-        {
-            // ...
-
-            /**
-             * Many Users have Many Phonenumbers.
-             * @ManyToMany(targetEntity="Phonenumber")
-             * @JoinTable(name="users_phonenumbers",
-             *      joinColumns={@JoinColumn(name="user_id", referencedColumnName="id")},
-             *      inverseJoinColumns={@JoinColumn(name="phonenumber_id", referencedColumnName="id", unique=true)}
-             *      )
-             * @var Collection<int, Phonenumber>
-             */
-            private Collection $phonenumbers;
-
-            public function __construct()
-            {
-                $this->phonenumbers = new \Doctrine\Common\Collections\ArrayCollection();
-            }
-
-            // ...
-        }
-
-        /** @Entity */
-        class Phonenumber
-        {
-            // ...
-        }
-
     .. code-block:: xml
 
         <doctrine-mapping>
@@ -606,24 +404,6 @@ The following example sets up such a unidirectional one-to-many association:
             </entity>
         </doctrine-mapping>
 
-    .. code-block:: yaml
-
-        User:
-          type: entity
-          manyToMany:
-            phonenumbers:
-              targetEntity: Phonenumber
-              joinTable:
-                name: users_phonenumbers
-                joinColumns:
-                  user_id:
-                    referencedColumnName: id
-                inverseJoinColumns:
-                  phonenumber_id:
-                    referencedColumnName: id
-                    unique: true
-
-
 Generates the following MySQL Schema:
 
 .. code-block:: sql
@@ -684,33 +464,6 @@ database perspective is known as an adjacency list approach.
             }
         }
 
-    .. code-block:: annotation
-
-        <?php
-        /** @Entity */
-        class Category
-        {
-            // ...
-            /**
-             * One Category has Many Categories.
-             * @OneToMany(targetEntity="Category", mappedBy="parent")
-             * @var Collection<int, Category>
-             */
-            private Collection $children;
-
-            /**
-             * Many Categories have One Category.
-             * @ManyToOne(targetEntity="Category", inversedBy="children")
-             * @JoinColumn(name="parent_id", referencedColumnName="id")
-             */
-            private Category|null $parent = null;
-            // ...
-
-            public function __construct() {
-                $this->children = new \Doctrine\Common\Collections\ArrayCollection();
-            }
-        }
-
     .. code-block:: xml
 
         <doctrine-mapping>
@@ -720,19 +473,6 @@ database perspective is known as an adjacency list approach.
             </entity>
         </doctrine-mapping>
 
-    .. code-block:: yaml
-
-        Category:
-          type: entity
-          oneToMany:
-            children:
-              targetEntity: Category
-              mappedBy: parent
-          manyToOne:
-            parent:
-              targetEntity: Category
-              inversedBy: children
-
 Note that the @JoinColumn is not really necessary in this example,
 as the defaults would be the same.
 
@@ -787,38 +527,6 @@ entities:
             // ...
         }
 
-    .. code-block:: annotation
-
-        <?php
-        /** @Entity */
-        class User
-        {
-            // ...
-
-            /**
-             * Many Users have Many Groups.
-             * @ManyToMany(targetEntity="Group")
-             * @JoinTable(name="users_groups",
-             *      joinColumns={@JoinColumn(name="user_id", referencedColumnName="id")},
-             *      inverseJoinColumns={@JoinColumn(name="group_id", referencedColumnName="id")}
-             *      )
-             * @var Collection<int, Group>
-             */
-            private Collection $groups;
-
-            // ...
-
-            public function __construct() {
-                $this->groups = new \Doctrine\Common\Collections\ArrayCollection();
-            }
-        }
-
-        /** @Entity */
-        class Group
-        {
-            // ...
-        }
-
     .. code-block:: xml
 
         <doctrine-mapping>
@@ -836,22 +544,6 @@ entities:
             </entity>
         </doctrine-mapping>
 
-    .. code-block:: yaml
-
-        User:
-          type: entity
-          manyToMany:
-            groups:
-              targetEntity: Group
-              joinTable:
-                name: users_groups
-                joinColumns:
-                  user_id:
-                    referencedColumnName: id
-                inverseJoinColumns:
-                  group_id:
-                    referencedColumnName: id
-
 Generated MySQL Schema:
 
 .. code-block:: sql
@@ -939,47 +631,6 @@ one is bidirectional.
             // ...
         }
 
-    .. code-block:: annotation
-
-        <?php
-        /** @Entity */
-        class User
-        {
-            // ...
-
-            /**
-             * Many Users have Many Groups.
-             * @ManyToMany(targetEntity="Group", inversedBy="users")
-             * @JoinTable(name="users_groups")
-             * @var Collection<int, Group>
-             */
-            private Collection $groups;
-
-            public function __construct() {
-                $this->groups = new \Doctrine\Common\Collections\ArrayCollection();
-            }
-
-            // ...
-        }
-
-        /** @Entity */
-        class Group
-        {
-            // ...
-            /**
-             * Many Groups have Many Users.
-             * @ManyToMany(targetEntity="User", mappedBy="groups")
-             * @var Collection<int, User>
-             */
-            private Collection $users;
-
-            public function __construct() {
-                $this->users = new \Doctrine\Common\Collections\ArrayCollection();
-            }
-
-            // ...
-        }
-
     .. code-block:: xml
 
         <doctrine-mapping>
@@ -1001,30 +652,6 @@ one is bidirectional.
             </entity>
         </doctrine-mapping>
 
-    .. code-block:: yaml
-
-        User:
-          type: entity
-          manyToMany:
-            groups:
-              targetEntity: Group
-              inversedBy: users
-              joinTable:
-                name: users_groups
-                joinColumns:
-                  user_id:
-                    referencedColumnName: id
-                inverseJoinColumns:
-                  group_id:
-                    referencedColumnName: id
-
-        Group:
-          type: entity
-          manyToMany:
-            users:
-              targetEntity: User
-              mappedBy: groups
-
 The MySQL schema is exactly the same as for the Many-To-Many
 uni-directional case above.
 
@@ -1172,12 +799,6 @@ As an example, consider this mapping:
         #[OneToOne(targetEntity: Shipment::class)]
         private Shipment|null $shipment = null;
 
-    .. code-block:: annotation
-
-        <?php
-        /** @OneToOne(targetEntity="Shipment") */
-        private Shipment|null $shipment = null;
-
     .. code-block:: xml
 
         <doctrine-mapping>
@@ -1186,14 +807,6 @@ As an example, consider this mapping:
             </entity>
         </doctrine-mapping>
 
-    .. code-block:: yaml
-
-        Product:
-          type: entity
-          oneToOne:
-            shipment:
-              targetEntity: Shipment
-
 This is essentially the same as the following, more verbose,
 mapping:
 
@@ -1207,16 +820,6 @@ mapping:
         #[JoinColumn(name: 'shipment_id', referencedColumnName: 'id')]
         private Shipment|null $shipment = null;
 
-    .. code-block:: annotation
-
-        <?php
-        /**
-         * One Product has One Shipment.
-         * @OneToOne(targetEntity="Shipment")
-         * @JoinColumn(name="shipment_id", referencedColumnName="id")
-         */
-        private Shipment|null $shipment = null;
-
     .. code-block:: xml
 
         <doctrine-mapping>
@@ -1227,17 +830,6 @@ mapping:
             </entity>
         </doctrine-mapping>
 
-    .. code-block:: yaml
-
-        Product:
-          type: entity
-          oneToOne:
-            shipment:
-              targetEntity: Shipment
-              joinColumn:
-                name: shipment_id
-                referencedColumnName: id
-
 The @JoinTable definition used for many-to-many mappings has
 similar defaults. As an example, consider this mapping:
 
@@ -1255,20 +847,6 @@ similar defaults. As an example, consider this mapping:
             // ...
         }
 
-    .. code-block:: annotation
-
-        <?php
-        class User
-        {
-            // ...
-            /**
-             * @ManyToMany(targetEntity="Group")
-             * @var Collection<int, Group>
-             */
-            private Collection $groups;
-            // ...
-        }
-
     .. code-block:: xml
 
         <doctrine-mapping>
@@ -1277,14 +855,6 @@ similar defaults. As an example, consider this mapping:
             </entity>
         </doctrine-mapping>
 
-    .. code-block:: yaml
-
-        User:
-          type: entity
-          manyToMany:
-            groups:
-              targetEntity: Group
-
 This is essentially the same as the following, more verbose, mapping:
 
 .. configuration-block::
@@ -1307,25 +877,6 @@ This is essentially the same as the following, more verbose, mapping:
             // ...
         }
 
-    .. code-block:: annotation
-
-        <?php
-        class User
-        {
-            // ...
-            /**
-             * Many Users have Many Groups.
-             * @ManyToMany(targetEntity="Group")
-             * @JoinTable(name="User_Group",
-             *      joinColumns={@JoinColumn(name="User_id", referencedColumnName="id")},
-             *      inverseJoinColumns={@JoinColumn(name="Group_id", referencedColumnName="id")}
-             *      )
-             * @var Collection<int, Group>
-             */
-            private Collection $groups;
-            // ...
-        }
-
     .. code-block:: xml
 
         <doctrine-mapping>
@@ -1343,22 +894,6 @@ This is essentially the same as the following, more verbose, mapping:
             </entity>
         </doctrine-mapping>
 
-    .. code-block:: yaml
-
-        User:
-          type: entity
-          manyToMany:
-            groups:
-              targetEntity: Group
-              joinTable:
-                name: User_Group
-                joinColumns:
-                  User_id:
-                    referencedColumnName: id
-                inverseJoinColumns:
-                  Group_id:
-                    referencedColumnName: id
-
 In that case, the name of the join table defaults to a combination
 of the simple, unqualified class names of the participating
 classes, separated by an underscore character. The names of the
@@ -1379,12 +914,6 @@ attribute on ``JoinColumn`` will be inherited from PHP type. So that:
         #[OneToOne]
         private Shipment $shipment;
 
-    .. code-block:: annotation
-
-        <?php
-        /** @OneToOne */
-        private Shipment $shipment;
-
     .. code-block:: xml
 
         <doctrine-mapping>
@@ -1393,13 +922,6 @@ attribute on ``JoinColumn`` will be inherited from PHP type. So that:
             </entity>
         </doctrine-mapping>
 
-    .. code-block:: yaml
-
-        Product:
-          type: entity
-          oneToOne:
-            shipment: ~
-
 Is essentially the same as following:
 
 .. configuration-block::
@@ -1432,18 +954,6 @@ Is essentially the same as following:
             </entity>
         </doctrine-mapping>
 
-    .. code-block:: yaml
-
-        Product:
-          type: entity
-          oneToOne:
-            shipment:
-              targetEntity: Shipment
-              joinColumn:
-                name: shipment_id
-                referencedColumnName: id
-                nullable: false
-
 If you accept these defaults, you can reduce the mapping code to a
 minimum.
 

docs/en/reference/attributes-reference.rst

@@ -4,8 +4,9 @@ Attributes Reference
 PHP 8 adds native support for metadata with its "Attributes" feature.
 Doctrine ORM provides support for mapping metadata using PHP attributes as of version 2.9.
 
-The attributes metadata support is closely modelled after the already existing
-annotation metadata supported since the first version 2.0.
+The attributes metadata support is closely modelled after the already
+existing and now removed annotation metadata supported since the first
+version 2.0.
 
 Index
 -----
@@ -310,7 +311,6 @@ Example:
         Entity,
         ChangeTrackingPolicy("DEFERRED_IMPLICIT"),
         ChangeTrackingPolicy("DEFERRED_EXPLICIT"),
-        ChangeTrackingPolicy("NOTIFY")
     ]
     class User {}
 
@@ -485,9 +485,8 @@ used as default.
 Optional parameters:
 
 -  **strategy**: Set the name of the identifier generation strategy.
-   Valid values are ``AUTO``, ``SEQUENCE``, ``IDENTITY``, ``UUID``
-   (deprecated), ``CUSTOM`` and ``NONE``.
-   If not specified, the default value is ``AUTO``.
+   Valid values are ``AUTO``, ``SEQUENCE``, ``IDENTITY``, ``CUSTOM`` and
+   ``NONE``. If not specified, the default value is ``AUTO``.
 
 Example:
 
@@ -712,10 +711,6 @@ details of the database join table. If you do not specify
 ``#[JoinTable]`` on these relations reasonable mapping defaults apply
 using the affected table and the column names.
 
-A notable difference to the annotation metadata support, ``#[JoinColumn]``
-and ``#[InverseJoinColumn]`` can be specified at the property level and are not
-nested within the ``#[JoinTable]`` attribute.
-
 Required attribute:
 
 -  **name**: Database name of the join-table
@@ -931,7 +926,7 @@ Example:
     #[OneToMany(
         targetEntity: "Phonenumber",
         mappedBy: "user",
-        cascade: ["persist", "remove", "merge"],
+        cascade: ["persist", "remove"],
         orphanRemoval: true)
     ]
     public $phonenumbers;

docs/en/reference/basic-mapping.rst

@@ -47,17 +47,14 @@ mapping metadata:
 -  :doc:`Attributes <attributes-reference>`
 -  :doc:`XML <xml-mapping>`
 -  :doc:`PHP code <php-mapping>`
--  :doc:`Docblock Annotations <annotations-reference>` (deprecated and will be removed in ``doctrine/orm`` 3.0)
--  :doc:`YAML <yaml-mapping>` (deprecated and will be removed in ``doctrine/orm`` 3.0.)
 
 This manual will usually show mapping metadata via attributes, though
-many examples also show the equivalent configuration in annotations,
-YAML and XML.
+many examples also show the equivalent configuration in XML.
 
 .. note::
 
     All metadata drivers perform equally. Once the metadata of a class has been
-    read from the source (attributes, annotations, XML, etc.) it is stored in an instance
+    read from the source (attributes, XML, etc.) it is stored in an instance
     of the ``Doctrine\ORM\Mapping\ClassMetadata`` class which are
     stored in the metadata cache.  If you're not using a metadata cache (not
     recommended!) then the XML driver is the fastest.
@@ -77,17 +74,6 @@ Marking our ``Message`` class as an entity for Doctrine is straightforward:
             // ...
         }
 
-    .. code-block:: annotation
-
-        <?php
-        use Doctrine\ORM\Mapping\Entity;
-
-        /** @Entity */
-        class Message
-        {
-            // ...
-        }
-
     .. code-block:: xml
 
         <doctrine-mapping>
@@ -96,12 +82,6 @@ Marking our ``Message`` class as an entity for Doctrine is straightforward:
           </entity>
         </doctrine-mapping>
 
-    .. code-block:: yaml
-
-        Message:
-          type: entity
-          # ...
-
 With no additional information, Doctrine expects the entity to be saved
 into a table with the same name as the class in our case ``Message``.
 You can change this by configuring information about the table:
@@ -121,21 +101,6 @@ You can change this by configuring information about the table:
             // ...
         }
 
-    .. code-block:: annotation
-
-        <?php
-        use Doctrine\ORM\Mapping\Entity;
-        use Doctrine\ORM\Mapping\Table;
-
-        /**
-         * @Entity
-         * @Table(name="message")
-         */
-        class Message
-        {
-            // ...
-        }
-
     .. code-block:: xml
 
         <doctrine-mapping>
@@ -144,13 +109,6 @@ You can change this by configuring information about the table:
           </entity>
         </doctrine-mapping>
 
-    .. code-block:: yaml
-
-        Message:
-          type: entity
-          table: message
-          # ...
-
 Now the class ``Message`` will be saved and fetched from the table ``message``.
 
 Property Mapping
@@ -182,23 +140,6 @@ specified, ``string`` is used as the default.
             private $postedAt;
         }
 
-    .. code-block:: annotation
-
-        <?php
-        use Doctrine\ORM\Mapping\Entity;
-        use Doctrine\ORM\Mapping\Column;
-
-        /** @Entity */
-        class Message
-        {
-            /** @Column(type="integer") */
-            private $id;
-            /** @Column(length=140) */
-            private $text;
-            /** @Column(type="datetime", name="posted_at") */
-            private $postedAt;
-        }
-
     .. code-block:: xml
 
         <doctrine-mapping>
@@ -209,19 +150,6 @@ specified, ``string`` is used as the default.
           </entity>
         </doctrine-mapping>
 
-    .. code-block:: yaml
-
-        Message:
-          type: entity
-          fields:
-            id:
-              type: integer
-            text:
-              length: 140
-            postedAt:
-              type: datetime
-              column: posted_at
-
 When we don't explicitly specify a column name via the ``name`` option, Doctrine
 assumes the field name is also the column name. So in this example:
 
@@ -300,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::
 
@@ -384,20 +274,6 @@ the field that serves as the identifier with the ``#[Id]`` attribute.
             // ...
         }
 
-    .. code-block:: annotation
-
-        <?php
-        class Message
-        {
-            /**
-             * @Id
-             * @Column(type="integer")
-             * @GeneratedValue
-             */
-            private int|null $id = null;
-            // ...
-        }
-
     .. code-block:: xml
 
         <doctrine-mapping>
@@ -409,24 +285,27 @@ the field that serves as the identifier with the ``#[Id]`` attribute.
           </entity>
         </doctrine-mapping>
 
-    .. code-block:: yaml
-
-        Message:
-          type: entity
-          id:
-            id:
-              type: integer
-              generator:
-                strategy: AUTO
-          fields:
-            # fields here
-
 In most cases using the automatic generator strategy (``#[GeneratedValue]``) is
 what you want, but for backwards-compatibility reasons it might not. It
 defaults to the identifier generation mechanism your current database
 vendor preferred at the time that strategy was introduced:
 ``AUTO_INCREMENT`` with MySQL, sequences with PostgreSQL and Oracle and
 so on.
+If you are using `doctrine/dbal` 4, we now recommend using ``IDENTITY``
+for PostgreSQL, and ``AUTO`` resolves to it because of that.
+You can stick with ``SEQUENCE`` while still using the ``AUTO``
+strategy, by configuring what it defaults to.
+
+.. code-block:: php
+
+    <?php
+    use Doctrine\DBAL\Platforms\PostgreSQLPlatform;
+    use Doctrine\ORM\Configuration;
+
+    $config = new Configuration();
+    $config->setIdentityGenerationPreferences([
+        PostgreSQLPlatform::class => ClassMetadata::GENERATOR_TYPE_SEQUENCE,
+    ]);
 
 .. _identifier-generation-strategies:
 
@@ -455,14 +334,12 @@ Here is the list of possible generation strategies:
    generation. This strategy does currently not provide full
    portability. Sequences are supported by Oracle, PostgreSql and
    SQL Anywhere.
--  ``UUID`` (deprecated): Tells Doctrine to use the built-in Universally
-   Unique Identifier generator. This strategy provides full portability.
 -  ``NONE``: Tells Doctrine that the identifiers are assigned (and
    thus generated) by your code. The assignment must take place before
    a new entity is passed to ``EntityManager#persist``. NONE is the
    same as leaving off the ``#[GeneratedValue]`` entirely.
 -  ``CUSTOM``: With this option, you can use the ``#[CustomIdGenerator]`` attribute.
-   It will allow you to pass a :ref:`class of your own to generate the identifiers.<annref_customidgenerator>`
+   It will allow you to pass a :ref:`class of your own to generate the identifiers. <attrref_customidgenerator>`
 
 Sequence Generator
 ^^^^^^^^^^^^^^^^^^
@@ -485,20 +362,6 @@ besides specifying the sequence's name:
             // ...
         }
 
-    .. code-block:: annotation
-
-        <?php
-        class Message
-        {
-            /**
-             * @Id
-             * @GeneratedValue(strategy="SEQUENCE")
-             * @SequenceGenerator(sequenceName="message_seq", initialValue=1, allocationSize=100)
-             */
-            protected int|null $id = null;
-            // ...
-        }
-
     .. code-block:: xml
 
         <doctrine-mapping>
@@ -510,20 +373,6 @@ besides specifying the sequence's name:
           </entity>
         </doctrine-mapping>
 
-    .. code-block:: yaml
-
-        Message:
-          type: entity
-          id:
-            id:
-              type: integer
-              generator:
-                strategy: SEQUENCE
-              sequenceGenerator:
-                sequenceName: message_seq
-                allocationSize: 100
-                initialValue: 1
-
 The initial value specifies at which value the sequence should
 start.
 

docs/en/reference/batch-processing.rst

@@ -18,14 +18,20 @@ especially what the strategies presented here provide help with.
 
 .. note::
 
-    Having an SQL logger enabled when processing batches can have a serious impact on performance and resource usage.
-    To avoid that you should remove the corresponding middleware.
-    To remove all middlewares, you can use this line:
+    Having an SQL logger enabled when processing batches can have a
+    serious impact on performance and resource usage.
+    To avoid that, you should use a PSR logger implementation that can be
+    disabled at runtime.
+    For example, with Monolog, you can use ``Logger::pushHandler()``
+    to push a ``NullHandler`` to the logger instance, and then pop it
+    when you need to enable logging again.
+
+    With DBAL 2, you can disable the SQL logger like below:
+
 .. code-block:: php
 
     <?php
-    $em->getConnection()->getConfiguration()->setMiddlewares([]); // DBAL 3
-    $em->getConnection()->getConfiguration()->setSQLLogger(null); // DBAL 2
+    $em->getConnection()->getConfiguration()->setSQLLogger(null);
 
 Bulk Inserts
 ------------
@@ -188,6 +194,3 @@ problems using the following approach:
     Iterating results is not possible with queries that
     fetch-join a collection-valued association. The nature of such SQL
     result sets is not suitable for incremental hydration.
-
-
-

docs/en/reference/best-practices.rst

@@ -43,7 +43,7 @@ should use events judiciously.
 Use cascades judiciously
 ------------------------
 
-Automatic cascades of the persist/remove/merge/etc. operations are
+Automatic cascades of the persist/remove/etc. operations are
 very handy but should be used wisely. Do NOT simply add all
 cascades to all associations. Think about which cascades actually
 do make sense for you for a particular association, given the

docs/en/reference/caching.rst

@@ -109,7 +109,7 @@ Metadata Cache
 ~~~~~~~~~~~~~~
 
 Your class metadata can be parsed from a few different sources like
-YAML, XML, Attributes, Annotations etc. Instead of parsing this
+XML, Attributes, etc. Instead of parsing this
 information on each request we should cache it using one of the cache
 drivers.
 

docs/en/reference/change-tracking-policies.rst

@@ -5,7 +5,7 @@ Change tracking is the process of determining what has changed in
 managed entities since the last time they were synchronized with
 the database.
 
-Doctrine provides 3 different change tracking policies, each having
+Doctrine provides 2 different change tracking policies, each having
 its particular advantages and disadvantages. The change tracking
 policy can be defined on a per-class basis (or more precisely,
 per-hierarchy).
@@ -56,122 +56,3 @@ This policy can be configured as follows:
     {
         // ...
     }
-
-Notify
-~~~~~~
-
-.. note::
-
-    The notify change tracking policy is deprecated and will be removed in ORM 3.0.
-    (\ `Details <https://github.com/doctrine/orm/issues/8383>`_)
-
-This policy is based on the assumption that the entities notify
-interested listeners of changes to their properties. For that
-purpose, a class that wants to use this policy needs to implement
-the ``NotifyPropertyChanged`` interface from the Doctrine
-namespace. As a guideline, such an implementation can look as
-follows:
-
-.. code-block:: php
-
-    <?php
-    use Doctrine\Persistence\NotifyPropertyChanged,
-        Doctrine\Persistence\PropertyChangedListener;
-
-    #[Entity]
-    #[ChangeTrackingPolicy('NOTIFY')]
-    class MyEntity implements NotifyPropertyChanged
-    {
-        // ...
-
-        private array $_listeners = array();
-
-        public function addPropertyChangedListener(PropertyChangedListener $listener): void
-        {
-            $this->_listeners[] = $listener;
-        }
-    }
-
-Then, in each property setter of this class or derived classes, you
-need to notify all the ``PropertyChangedListener`` instances. As an
-example we add a convenience method on ``MyEntity`` that shows this
-behaviour:
-
-.. code-block:: php
-
-    <?php
-    // ...
-
-    class MyEntity implements NotifyPropertyChanged
-    {
-        // ...
-
-        protected function _onPropertyChanged($propName, $oldValue, $newValue): void
-        {
-            if ($this->_listeners) {
-                foreach ($this->_listeners as $listener) {
-                    $listener->propertyChanged($this, $propName, $oldValue, $newValue);
-                }
-            }
-        }
-
-        public function setData($data): void
-        {
-            if ($data != $this->data) {
-                $this->_onPropertyChanged('data', $this->data, $data);
-                $this->data = $data;
-            }
-        }
-    }
-
-You have to invoke ``_onPropertyChanged`` inside every method that
-changes the persistent state of ``MyEntity``.
-
-The check whether the new value is different from the old one is
-not mandatory but recommended. That way you also have full control
-over when you consider a property changed.
-
-If your entity contains an embeddable, you will need to notify
-separately for each property in the embeddable when it changes
-for example:
-
-.. code-block:: php
-
-    <?php
-    // ...
-
-    class MyEntity implements NotifyPropertyChanged
-    {
-        public function setEmbeddable(MyValueObject $embeddable): void
-        {
-            if (!$embeddable->equals($this->embeddable)) {
-                // notice the entityField.embeddableField notation for referencing the property
-                $this->_onPropertyChanged('embeddable.prop1', $this->embeddable->getProp1(), $embeddable->getProp1());
-                $this->_onPropertyChanged('embeddable.prop2', $this->embeddable->getProp2(), $embeddable->getProp2());
-                $this->embeddable = $embeddable;
-            }
-        }
-    }
-
-This would update all the fields of the embeddable, you may wish to
-implement a diff method on your embedded object which returns only
-the changed fields.
-
-The negative point of this policy is obvious: You need implement an
-interface and write some plumbing code. But also note that we tried
-hard to keep this notification functionality abstract. Strictly
-speaking, it has nothing to do with the persistence layer and the
-Doctrine ORM or DBAL. You may find that property notification
-events come in handy in many other scenarios as well. As mentioned
-earlier, the ``Doctrine\Common`` namespace is not that evil and
-consists solely of very small classes and interfaces that have
-almost no external dependencies (none to the DBAL and none to the
-ORM) and that you can easily take with you should you want to swap
-out the persistence layer. This change tracking policy does not
-introduce a dependency on the Doctrine DBAL/ORM or the persistence
-layer.
-
-The positive point and main advantage of this policy is its
-effectiveness. It has the best performance characteristics of the 3
-policies with larger units of work and a flush() operation is very
-cheap when nothing has changed.

docs/en/reference/configuration.rst

@@ -60,11 +60,6 @@ access point to ORM functionality provided by Doctrine.
     $connection = DriverManager::getConnection($dbParams, $config);
     $entityManager = new EntityManager($connection, $config);
 
-.. note::
-
-    The ``ORMSetup`` class has been introduced with ORM 2.12. It's predecessor ``Setup`` is deprecated and will
-    be removed in version 3.0.
-
 Or if you prefer XML:
 
 .. code-block:: php
@@ -75,23 +70,6 @@ Or if you prefer XML:
     $connection = DriverManager::getConnection($dbParams, $config);
     $entityManager = new EntityManager($connection, $config);
 
-Or if you prefer YAML:
-
-.. code-block:: php
-
-    <?php
-    $paths = ['/path/to/yml-mappings'];
-    $config = ORMSetup::createYAMLMetadataConfiguration($paths, $isDevMode);
-    $connection = DriverManager::getConnection($dbParams, $config);
-    $entityManager = new EntityManager($connection, $config);
-
-.. note::
-    If you want to use yml mapping you should add yaml dependency to your `composer.json`:
-
-    ::
-
-        "symfony/yaml": "*"
-
 Inside the ``ORMSetup`` methods several assumptions are made:
 
 -  If ``$isDevMode`` is true caching is done in memory with the ``ArrayAdapter``. Proxy objects are recreated on every request.

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

@@ -523,33 +523,6 @@ when the DQL is switched to an arbitrary join.
     - HAVING is applied to the results of a query after
       aggregation (GROUP BY)
 
-
-Partial Object Syntax
-^^^^^^^^^^^^^^^^^^^^^
-
-By default when you run a DQL query in Doctrine and select only a
-subset of the fields for a given entity, you do not receive objects
-back. Instead, you receive only arrays as a flat rectangular result
-set, similar to how you would if you were just using SQL directly
-and joining some data.
-
-If you want to select partial objects you can use the ``partial``
-DQL keyword:
-
-.. code-block:: php
-
-    <?php
-    $query = $em->createQuery('SELECT partial u.{id, username} FROM CmsUser u');
-    $users = $query->getResult(); // array of partially loaded CmsUser objects
-
-You use the partial syntax when joining as well:
-
-.. code-block:: php
-
-    <?php
-    $query = $em->createQuery('SELECT partial u.{id, username}, partial a.{id, name} FROM CmsUser u JOIN u.articles a');
-    $users = $query->getResult(); // array of partially loaded CmsUser objects
-
 "NEW" Operator Syntax
 ^^^^^^^^^^^^^^^^^^^^^
 
@@ -812,7 +785,7 @@ classes have to implement the base class :
     namespace MyProject\Query\AST;
 
     use Doctrine\ORM\Query\AST\Functions\FunctionNode;
-    use Doctrine\ORM\Query\Lexer;
+    use Doctrine\ORM\Query\TokenType;
 
     class MysqlFloor extends FunctionNode
     {
@@ -827,12 +800,12 @@ classes have to implement the base class :
 
         public function parse(\Doctrine\ORM\Query\Parser $parser)
         {
-            $parser->match(Lexer::T_IDENTIFIER);
-            $parser->match(Lexer::T_OPEN_PARENTHESIS);
+            $parser->match(TokenType::T_IDENTIFIER);
+            $parser->match(TokenType::T_OPEN_PARENTHESIS);
 
             $this->simpleArithmeticExpression = $parser->SimpleArithmeticExpression();
 
-            $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+            $parser->match(TokenType::T_CLOSE_PARENTHESIS);
         }
     }
 
@@ -1003,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:
@@ -1020,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
 ~~~~~~~~~~~~~~~~~~~~~~
@@ -1175,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
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -1422,15 +1324,6 @@ exist mostly internal query hints that are not be consumed in
 userland. However the following few hints are to be used in
 userland:
 
-
--  ``Query::HINT_FORCE_PARTIAL_LOAD`` - Allows to hydrate objects
-   although not all their columns are fetched. This query hint can be
-   used to handle memory consumption problems with large result-sets
-   that contain char or binary data. Doctrine has no way of implicitly
-   reloading this data. Partially loaded objects have to be passed to
-   ``EntityManager::refresh()`` if they are to be reloaded fully from
-   the database. This query hint is deprecated and will be removed
-   in the future (\ `Details <https://github.com/doctrine/orm/issues/8471>`_)
 -  ``Query::HINT_REFRESH`` - This query is used internally by
    ``EntityManager::refresh()`` and can be used in userland as well.
    If you specify this hint and a query returns the data for an entity
@@ -1587,8 +1480,8 @@ Identifiers
     /* Alias Identification declaration (the "u" of "FROM User u") */
     AliasIdentificationVariable :: = identifier
 
-    /* identifier that must be a class name (the "User" of "FROM User u"), possibly as a fully qualified class name or namespace-aliased */
-    AbstractSchemaName ::= fully_qualified_name | aliased_name | identifier
+    /* identifier that must be a class name (the "User" of "FROM User u"), possibly as a fully qualified class name */
+    AbstractSchemaName ::= fully_qualified_name | identifier
 
     /* Alias ResultVariable declaration (the "total" of "COUNT(*) AS total") */
     AliasResultVariable = identifier
@@ -1683,10 +1576,8 @@ Select Expressions
 
 .. code-block:: php
 
-    SelectExpression        ::= (IdentificationVariable | ScalarExpression | AggregateExpression | FunctionDeclaration | PartialObjectExpression | "(" Subselect ")" | CaseExpression | NewObjectExpression) [["AS"] ["HIDDEN"] AliasResultVariable]
+    SelectExpression        ::= (IdentificationVariable | ScalarExpression | AggregateExpression | FunctionDeclaration | "(" Subselect ")" | CaseExpression | NewObjectExpression) [["AS"] ["HIDDEN"] AliasResultVariable]
     SimpleSelectExpression  ::= (StateFieldPathExpression | IdentificationVariable | FunctionDeclaration | AggregateExpression | "(" Subselect ")" | ScalarExpression) [["AS"] AliasResultVariable]
-    PartialObjectExpression ::= "PARTIAL" IdentificationVariable "." PartialFieldSet
-    PartialFieldSet         ::= "{" SimpleStateField {"," SimpleStateField}* "}"
     NewObjectExpression     ::= "NEW" AbstractSchemaName "(" NewObjectArg {"," NewObjectArg}* ")"
     NewObjectArg            ::= ScalarExpression | "(" Subselect ")"
 

docs/en/reference/events.rst

@@ -131,47 +131,47 @@ There are two ways to set up an event handler:
 * For *all events* you can create a Lifecycle Event Listener or Subscriber class and register
 it by calling ``$eventManager->addEventListener()`` or ``eventManager->addEventSubscriber()``,
 see
-:ref:`Listening and subscribing to Lifecycle Events<listening-and-subscribing-to-lifecycle-events>`
+:ref:`Listening and subscribing to Lifecycle Events <listening-and-subscribing-to-lifecycle-events>`
 * For *some events* (see table below), you can create a *Lifecycle Callback* method in the
-entity, see :ref:`Lifecycle Callbacks<lifecycle-callbacks>`.
+entity, see :ref:`Lifecycle Callbacks <lifecycle-callbacks>`.
 
 .. _reference-events-lifecycle-events:
 
 Events Overview
 ---------------
 
-+-----------------------------------------------------------------+-----------------------+-----------+-------------------------------------+
-| Event                                                           | Dispatched by         | Lifecycle | Passed                              |
-|                                                                 |                       | Callback  | Argument                            |
-+=================================================================+=======================+===========+=====================================+
-| :ref:`preRemove<reference-events-pre-remove>`                   | ``$em->remove()``     | Yes       | `PreRemoveEventArgs`_               |
-+-----------------------------------------------------------------+-----------------------+-----------+-------------------------------------+
-| :ref:`postRemove<reference-events-post-update-remove-persist>`  | ``$em->flush()``      | Yes       | `PostRemoveEventArgs`_              |
-+-----------------------------------------------------------------+-----------------------+-----------+-------------------------------------+
-| :ref:`prePersist<reference-events-pre-persist>`                 | ``$em->persist()``    | Yes       | `PrePersistEventArgs`_              |
-|                                                                 | on *initial* persist  |           |                                     |
-+-----------------------------------------------------------------+-----------------------+-----------+-------------------------------------+
-| :ref:`postPersist<reference-events-post-update-remove-persist>` | ``$em->flush()``      | Yes       | `PostPersistEventArgs`_             |
-+-----------------------------------------------------------------+-----------------------+-----------+-------------------------------------+
-| :ref:`preUpdate<reference-events-pre-update>`                   | ``$em->flush()``      | Yes       | `PreUpdateEventArgs`_               |
-+-----------------------------------------------------------------+-----------------------+-----------+-------------------------------------+
-| :ref:`postUpdate<reference-events-post-update-remove-persist>`  | ``$em->flush()``      | Yes       | `PostUpdateEventArgs`_              |
-+-----------------------------------------------------------------+-----------------------+-----------+-------------------------------------+
-| :ref:`postLoad<reference-events-post-load>`                     | Loading from database | Yes       | `PostLoadEventArgs`_                |
-+-----------------------------------------------------------------+-----------------------+-----------+-------------------------------------+
-| :ref:`loadClassMetadata<reference-events-load-class-metadata>`  | Loading of mapping    | No        | `LoadClassMetadataEventArgs`_       |
-|                                                                 | metadata              |           |                                     |
-+-----------------------------------------------------------------+-----------------------+-----------+-------------------------------------+
-| ``onClassMetadataNotFound``                                     | ``MappingException``  | No        | `OnClassMetadataNotFoundEventArgs`_ |
-+-----------------------------------------------------------------+-----------------------+-----------+-------------------------------------+
-| :ref:`preFlush<reference-events-pre-flush>`                     | ``$em->flush()``      | Yes       | `PreFlushEventArgs`_                |
-+-----------------------------------------------------------------+-----------------------+-----------+-------------------------------------+
-| :ref:`onFlush<reference-events-on-flush>`                       | ``$em->flush()``      | No        | `OnFlushEventArgs`_                 |
-+-----------------------------------------------------------------+-----------------------+-----------+-------------------------------------+
-| :ref:`postFlush<reference-events-post-flush>`                   | ``$em->flush()``      | No        | `PostFlushEventArgs`_               |
-+-----------------------------------------------------------------+-----------------------+-----------+-------------------------------------+
-| :ref:`onClear<reference-events-on-clear>`                       | ``$em->clear()``      | No        | `OnClearEventArgs`_                 |
-+-----------------------------------------------------------------+-----------------------+-----------+-------------------------------------+
++------------------------------------------------------------------+-----------------------+-----------+-------------------------------------+
+| Event                                                            | Dispatched by         | Lifecycle | Passed                              |
+|                                                                  |                       | Callback  | Argument                            |
++==================================================================+=======================+===========+=====================================+
+| :ref:`preRemove <reference-events-pre-remove>`                   | ``$em->remove()``     | Yes       | `PreRemoveEventArgs`_               |
++------------------------------------------------------------------+-----------------------+-----------+-------------------------------------+
+| :ref:`postRemove <reference-events-post-update-remove-persist>`  | ``$em->flush()``      | Yes       | `PostRemoveEventArgs`_              |
++------------------------------------------------------------------+-----------------------+-----------+-------------------------------------+
+| :ref:`prePersist <reference-events-pre-persist>`                 | ``$em->persist()``    | Yes       | `PrePersistEventArgs`_              |
+|                                                                  | on *initial* persist  |           |                                     |
++------------------------------------------------------------------+-----------------------+-----------+-------------------------------------+
+| :ref:`postPersist <reference-events-post-update-remove-persist>` | ``$em->flush()``      | Yes       | `PostPersistEventArgs`_             |
++------------------------------------------------------------------+-----------------------+-----------+-------------------------------------+
+| :ref:`preUpdate <reference-events-pre-update>`                   | ``$em->flush()``      | Yes       | `PreUpdateEventArgs`_               |
++------------------------------------------------------------------+-----------------------+-----------+-------------------------------------+
+| :ref:`postUpdate <reference-events-post-update-remove-persist>`  | ``$em->flush()``      | Yes       | `PostUpdateEventArgs`_              |
++------------------------------------------------------------------+-----------------------+-----------+-------------------------------------+
+| :ref:`postLoad <reference-events-post-load>`                     | Loading from database | Yes       | `PostLoadEventArgs`_                |
++------------------------------------------------------------------+-----------------------+-----------+-------------------------------------+
+| :ref:`loadClassMetadata <reference-events-load-class-metadata>`  | Loading of mapping    | No        | `LoadClassMetadataEventArgs`_       |
+|                                                                  | metadata              |           |                                     |
++------------------------------------------------------------------+-----------------------+-----------+-------------------------------------+
+| ``onClassMetadataNotFound``                                      | ``MappingException``  | No        | `OnClassMetadataNotFoundEventArgs`_ |
++------------------------------------------------------------------+-----------------------+-----------+-------------------------------------+
+| :ref:`preFlush <reference-events-pre-flush>`                     | ``$em->flush()``      | Yes       | `PreFlushEventArgs`_                |
++------------------------------------------------------------------+-----------------------+-----------+-------------------------------------+
+| :ref:`onFlush <reference-events-on-flush>`                       | ``$em->flush()``      | No        | `OnFlushEventArgs`_                 |
++------------------------------------------------------------------+-----------------------+-----------+-------------------------------------+
+| :ref:`postFlush <reference-events-post-flush>`                   | ``$em->flush()``      | No        | `PostFlushEventArgs`_               |
++------------------------------------------------------------------+-----------------------+-----------+-------------------------------------+
+| :ref:`onClear <reference-events-on-clear>`                       | ``$em->clear()``      | No        | `OnClearEventArgs`_                 |
++------------------------------------------------------------------+-----------------------+-----------+-------------------------------------+
 
 .. warning::
 
@@ -260,40 +260,6 @@ specific to a particular entity class's lifecycle.
                 $this->value = 'changed from preUpdate callback!';
             }
         }
-    .. code-block:: annotation
-
-        <?php
-        use Doctrine\ORM\Event\PrePersistEventArgs;
-
-        /**
-         * @Entity
-         * @HasLifecycleCallbacks
-         */
-        class User
-        {
-            // ...
-
-            /** @Column(type="string", length=255) */
-            public $value;
-
-            /** @PrePersist */
-            public function doStuffOnPrePersist(PrePersistEventArgs $eventArgs)
-            {
-                $this->createdAt = date('Y-m-d H:i:s');
-            }
-
-            /** @PrePersist */
-            public function doOtherStuffOnPrePersist()
-            {
-                $this->value = 'changed from prePersist callback!';
-            }
-
-            /** @PreUpdate */
-            public function doStuffOnPreUpdate(PreUpdateEventArgs $eventArgs)
-            {
-                $this->value = 'changed from preUpdate callback!';
-            }
-        }
     .. code-block:: xml
 
         <?xml version="1.0" encoding="UTF-8"?>
@@ -311,17 +277,6 @@ specific to a particular entity class's lifecycle.
                 </lifecycle-callbacks>
             </entity>
         </doctrine-mapping>
-    .. code-block:: yaml
-
-        User:
-          type: entity
-          fields:
-            # ...
-            value:
-              type: string(255)
-          lifecycleCallbacks:
-            prePersist: [ doStuffOnPrePersist, doOtherStuffOnPrePersist ]
-            preUpdate: [ doStuffOnPreUpdate ]
 
 Lifecycle Callbacks Event Argument
 ----------------------------------
@@ -358,7 +313,7 @@ behaviors across different entity classes.
 
 Note that they require much more detailed knowledge about the inner
 workings of the ``EntityManager`` and ``UnitOfWork`` classes. Please
-read the :ref:`Implementing Event Listeners<reference-events-implementing-listeners>` section
+read the :ref:`Implementing Event Listeners <reference-events-implementing-listeners>` section
 carefully if you are trying to write your own listener.
 
 For event subscribers, there are no surprises. They declare the
@@ -471,11 +426,11 @@ prePersist
 There are two ways for the ``prePersist`` event to be triggered:
 
 - One is when you call ``EntityManager::persist()``. The
-  event is also called for all :ref:`cascaded associations<transitive-persistence>`.
+  event is also called for all :ref:`cascaded associations <transitive-persistence>`.
 - The other is inside the ``flush()`` method when changes to associations are computed and
-  this association is marked as :ref:`cascade: persist<transitive-persistence>`. Any new entity found
+  this association is marked as :ref:`cascade: persist <transitive-persistence>`. Any new entity found
   during this operation is also persisted and ``prePersist`` called
-  on it. This is called :ref:`persistence by reachability<persistence-by-reachability>`.
+  on it. This is called :ref:`persistence by reachability <persistence-by-reachability>`.
 
 In both cases you get passed a ``PrePersistEventArgs`` instance
 which has access to the entity and the entity manager.
@@ -499,7 +454,7 @@ preRemove
 
 The ``preRemove`` event is called on every entity immediately when it is passed
 to the ``EntityManager::remove()`` method. It is cascaded for all
-associations that are marked as :ref:`cascade: remove<transitive-persistence>`
+associations that are marked as :ref:`cascade: remove <transitive-persistence>`
 
 It is not called for a DQL ``DELETE`` statement.
 
@@ -547,7 +502,7 @@ entities and their associations have been computed. This means, the
 -  Collections scheduled for removal
 
 To make use of the ``onFlush`` event you have to be familiar with the
-internal :ref:`UnitOfWork<unit-of-work>` API, which grants you access to the previously
+internal :ref:`UnitOfWork <unit-of-work>` API, which grants you access to the previously
 mentioned sets. See this example:
 
 .. code-block:: php
@@ -794,16 +749,6 @@ An entity listener is a lifecycle listener class used for an entity.
         {
             // ....
         }
-    .. code-block:: annotation
-
-        <?php
-        namespace MyProject\Entity;
-
-        /** @Entity @EntityListeners({"UserListener"}) */
-        class User
-        {
-            // ....
-        }
     .. code-block:: xml
 
         <doctrine-mapping>
@@ -814,13 +759,6 @@ An entity listener is a lifecycle listener class used for an entity.
                 <!-- .... -->
             </entity>
         </doctrine-mapping>
-    .. code-block:: yaml
-
-        MyProject\Entity\User:
-          type: entity
-          entityListeners:
-            UserListener:
-          # ....
 
 .. _reference-entity-listeners:
 
@@ -893,45 +831,6 @@ you need to map the listener method using the event type mapping:
             public function postLoadHandler(User $user, PostLoadEventArgs $event): void { // ... }
         }
 
-    .. code-block:: annotation
-
-        <?php
-        use Doctrine\ORM\Event\PostLoadEventArgs;
-        use Doctrine\ORM\Event\PostPersistEventArgs;
-        use Doctrine\ORM\Event\PostRemoveEventArgs;
-        use Doctrine\ORM\Event\PostUpdateEventArgs;
-        use Doctrine\ORM\Event\PreFlushEventArgs;
-        use Doctrine\ORM\Event\PrePersistEventArgs;
-        use Doctrine\ORM\Event\PreRemoveEventArgs;
-        use Doctrine\ORM\Event\PreUpdateEventArgs;
-
-        class UserListener
-        {
-            /** @PrePersist */
-            public function prePersistHandler(User $user, PrePersistEventArgs $event): void { // ... }
-
-            /** @PostPersist */
-            public function postPersistHandler(User $user, PostPersistEventArgs $event): void { // ... }
-
-            /** @PreUpdate */
-            public function preUpdateHandler(User $user, PreUpdateEventArgs $event): void { // ... }
-
-            /** @PostUpdate */
-            public function postUpdateHandler(User $user, PostUpdateEventArgs $event): void { // ... }
-
-            /** @PostRemove */
-            public function postRemoveHandler(User $user, PostRemoveEventArgs $event): void { // ... }
-
-            /** @PreRemove */
-            public function preRemoveHandler(User $user, PreRemoveEventArgs $event): void { // ... }
-
-            /** @PreFlush */
-            public function preFlushHandler(User $user, PreFlushEventArgs $event): void { // ... }
-
-            /** @PostLoad */
-            public function postLoadHandler(User $user, PostLoadEventArgs $event): void { // ... }
-        }
-
     .. code-block:: xml
 
         <doctrine-mapping>
@@ -954,24 +853,6 @@ you need to map the listener method using the event type mapping:
                 <!-- .... -->
             </entity>
         </doctrine-mapping>
-    .. code-block:: yaml
-
-        MyProject\Entity\User:
-          type: entity
-          entityListeners:
-            UserListener:
-              preFlush: [preFlushHandler]
-              postLoad: [postLoadHandler]
-
-              postPersist: [postPersistHandler]
-              prePersist: [prePersistHandler]
-
-              postUpdate: [postUpdateHandler]
-              preUpdate: [preUpdateHandler]
-
-              postRemove: [postRemoveHandler]
-              preRemove: [preRemoveHandler]
-          # ....
 
 .. note::
 
@@ -994,7 +875,8 @@ Specifying an entity listener instance :
 
     // User.php
 
-    /** @Entity @EntityListeners({"UserListener"}) */
+    #[Entity]
+    #[EntityListeners(["UserListener"])
     class User
     {
         // ....
@@ -1052,7 +934,7 @@ Load ClassMetadata Event
 
 ``loadClassMetadata`` - The ``loadClassMetadata`` event occurs after the
 mapping metadata for a class has been loaded from a mapping source
-(attributes/annotations/xml/yaml) in to a ``Doctrine\ORM\Mapping\ClassMetadata`` instance.
+(attributes/xml) in to a ``Doctrine\ORM\Mapping\ClassMetadata`` instance.
 You can hook in to this process and manipulate the instance.
 This event is not a lifecycle callback.
 
@@ -1143,16 +1025,16 @@ and the EntityManager.
         }
     }
 
-.. _PrePersistEventArgs: https://github.com/doctrine/orm/blob/HEAD/lib/Doctrine/ORM/Event/PrePersistEventArgs.php
-.. _PreRemoveEventArgs: https://github.com/doctrine/orm/blob/HEAD/lib/Doctrine/ORM/Event/PreRemoveEventArgs.php
-.. _PreUpdateEventArgs: https://github.com/doctrine/orm/blob/HEAD/lib/Doctrine/ORM/Event/PreUpdateEventArgs.php
-.. _PostPersistEventArgs: https://github.com/doctrine/orm/blob/HEAD/lib/Doctrine/ORM/Event/PostPersistEventArgs.php
-.. _PostRemoveEventArgs: https://github.com/doctrine/orm/blob/HEAD/lib/Doctrine/ORM/Event/PostRemoveEventArgs.php
-.. _PostUpdateEventArgs: https://github.com/doctrine/orm/blob/HEAD/lib/Doctrine/ORM/Event/PostUpdateEventArgs.php
-.. _PostLoadEventArgs: https://github.com/doctrine/orm/blob/HEAD/lib/Doctrine/ORM/Event/PostLoadEventArgs.php
-.. _PreFlushEventArgs: https://github.com/doctrine/orm/blob/HEAD/lib/Doctrine/ORM/Event/PreFlushEventArgs.php
-.. _PostFlushEventArgs: https://github.com/doctrine/orm/blob/HEAD/lib/Doctrine/ORM/Event/PostFlushEventArgs.php
-.. _OnFlushEventArgs: https://github.com/doctrine/orm/blob/HEAD/lib/Doctrine/ORM/Event/OnFlushEventArgs.php
-.. _OnClearEventArgs: https://github.com/doctrine/orm/blob/HEAD/lib/Doctrine/ORM/Event/OnClearEventArgs.php
-.. _LoadClassMetadataEventArgs: https://github.com/doctrine/orm/blob/HEAD/lib/Doctrine/ORM/Event/LoadClassMetadataEventArgs.php
-.. _OnClassMetadataNotFoundEventArgs: https://github.com/doctrine/orm/blob/HEAD/lib/Doctrine/ORM/Event/OnClassMetadataNotFoundEventArgs.php
+.. _PrePersistEventArgs: https://github.com/doctrine/orm/blob/HEAD/src/Event/PrePersistEventArgs.php
+.. _PreRemoveEventArgs: https://github.com/doctrine/orm/blob/HEAD/src/Event/PreRemoveEventArgs.php
+.. _PreUpdateEventArgs: https://github.com/doctrine/orm/blob/HEAD/src/Event/PreUpdateEventArgs.php
+.. _PostPersistEventArgs: https://github.com/doctrine/orm/blob/HEAD/src/Event/PostPersistEventArgs.php
+.. _PostRemoveEventArgs: https://github.com/doctrine/orm/blob/HEAD/src/Event/PostRemoveEventArgs.php
+.. _PostUpdateEventArgs: https://github.com/doctrine/orm/blob/HEAD/src/Event/PostUpdateEventArgs.php
+.. _PostLoadEventArgs: https://github.com/doctrine/orm/blob/HEAD/src/Event/PostLoadEventArgs.php
+.. _PreFlushEventArgs: https://github.com/doctrine/orm/blob/HEAD/src/Event/PreFlushEventArgs.php
+.. _PostFlushEventArgs: https://github.com/doctrine/orm/blob/HEAD/src/Event/PostFlushEventArgs.php
+.. _OnFlushEventArgs: https://github.com/doctrine/orm/blob/HEAD/src/Event/OnFlushEventArgs.php
+.. _OnClearEventArgs: https://github.com/doctrine/orm/blob/HEAD/src/Event/OnClearEventArgs.php
+.. _LoadClassMetadataEventArgs: https://github.com/doctrine/orm/blob/HEAD/src/Event/LoadClassMetadataEventArgs.php
+.. _OnClassMetadataNotFoundEventArgs: https://github.com/doctrine/orm/blob/HEAD/src/Event/OnClassMetadataNotFoundEventArgs.php

docs/en/reference/faq.rst

@@ -101,7 +101,7 @@ The many-to-many association is only supporting foreign keys in the table defini
 To work with many-to-many tables containing extra columns you have to use the
 foreign keys as primary keys feature of Doctrine ORM.
 
-See :doc:`the tutorial on composite primary keys for more information<../tutorials/composite-primary-keys>`.
+See :doc:`the tutorial on composite primary keys for more information <../tutorials/composite-primary-keys>`.
 
 
 How can i paginate fetch-joined collections?

docs/en/reference/inheritance-mapping.rst

@@ -208,44 +208,6 @@ Example:
             // ...
         }
 
-    .. code-block:: annotation
-
-        <?php
-        namespace MyProject\Model;
-
-        /**
-         * @Entity
-         * @InheritanceType("SINGLE_TABLE")
-         * @DiscriminatorColumn(name="discr", type="string")
-         * @DiscriminatorMap({"person" = "Person", "employee" = "Employee"})
-         */
-        class Person
-        {
-            // ...
-        }
-
-        /**
-         * @Entity
-         */
-        class Employee extends Person
-        {
-            // ...
-        }
-
-    .. code-block:: yaml
-
-        MyProject\Model\Person:
-          type: entity
-          inheritanceType: SINGLE_TABLE
-          discriminatorColumn:
-            name: discr
-            type: string
-          discriminatorMap:
-            person: Person
-            employee: Employee
-
-        MyProject\Model\Employee:
-          type: entity
 
 In this example, the ``#[DiscriminatorMap]`` specifies that in the
 discriminator column, a value of "person" identifies a row as being of type
@@ -380,7 +342,7 @@ It is not supported to use overrides in entity inheritance scenarios.
 .. note::
 
     When using traits, make sure not to miss the warnings given in the
-    :doc:`Limitations and Known Issues</reference/limitations-and-known-issues>` chapter.
+    :doc:`Limitations and Known Issues </reference/limitations-and-known-issues>` chapter.
 
 
 Association Override
@@ -439,58 +401,6 @@ Example:
         {
         }
 
-    .. code-block:: annotation
-
-        <?php
-        // user mapping
-        namespace MyProject\Model;
-        /**
-         * @MappedSuperclass
-         */
-        class User
-        {
-            // other fields mapping
-
-            /**
-             * @ManyToMany(targetEntity="Group", inversedBy="users")
-             * @JoinTable(name="users_groups",
-             *  joinColumns={@JoinColumn(name="user_id", referencedColumnName="id")},
-             *  inverseJoinColumns={@JoinColumn(name="group_id", referencedColumnName="id")}
-             * )
-             * @var Collection<int, Group>
-             */
-            protected Collection $groups;
-
-            /**
-             * @ManyToOne(targetEntity="Address")
-             * @JoinColumn(name="address_id", referencedColumnName="id")
-             */
-            protected Address|null $address = null;
-        }
-
-        // admin mapping
-        namespace MyProject\Model;
-        /**
-         * @Entity
-         * @AssociationOverrides({
-         *      @AssociationOverride(name="groups",
-         *          joinTable=@JoinTable(
-         *              name="users_admingroups",
-         *              joinColumns=@JoinColumn(name="adminuser_id"),
-         *              inverseJoinColumns=@JoinColumn(name="admingroup_id")
-         *          )
-         *      ),
-         *      @AssociationOverride(name="address",
-         *          joinColumns=@JoinColumn(
-         *              name="adminaddress_id", referencedColumnName="id"
-         *          )
-         *      )
-         * })
-         */
-        class Admin extends User
-        {
-        }
-
     .. code-block:: xml
 
         <!-- user mapping -->
@@ -500,7 +410,6 @@ Example:
                 <many-to-many field="groups" target-entity="Group" inversed-by="users">
                     <cascade>
                         <cascade-persist/>
-                        <cascade-merge/>
                         <cascade-detach/>
                     </cascade>
                     <join-table name="users_groups">
@@ -537,51 +446,6 @@ Example:
                 </association-overrides>
             </entity>
         </doctrine-mapping>
-    .. code-block:: yaml
-
-        # user mapping
-        MyProject\Model\User:
-          type: mappedSuperclass
-          # other fields mapping
-          manyToOne:
-            address:
-              targetEntity: Address
-              joinColumn:
-                name: address_id
-                referencedColumnName: id
-              cascade: [ persist, merge ]
-          manyToMany:
-            groups:
-              targetEntity: Group
-              joinTable:
-                name: users_groups
-                joinColumns:
-                  user_id:
-                    referencedColumnName: id
-                inverseJoinColumns:
-                  group_id:
-                    referencedColumnName: id
-              cascade: [ persist, merge, detach ]
-
-        # admin mapping
-        MyProject\Model\Admin:
-          type: entity
-          associationOverride:
-            address:
-              joinColumn:
-                adminaddress_id:
-                  name: adminaddress_id
-                  referencedColumnName: id
-            groups:
-              joinTable:
-                name: users_admingroups
-                joinColumns:
-                  adminuser_id:
-                    referencedColumnName: id
-                inverseJoinColumns:
-                  admingroup_id:
-                    referencedColumnName: id
-
 
 Things to note:
 
@@ -645,51 +509,6 @@ Could be used by an entity that extends a mapped superclass to override a field
         {
         }
 
-    .. code-block:: annotation
-
-        <?php
-        // user mapping
-        namespace MyProject\Model;
-        /**
-         * @MappedSuperclass
-         */
-        class User
-        {
-            /** @Id @GeneratedValue @Column(type="integer", name="user_id", length=150) */
-            protected int|null $id = null;
-
-            /** @Column(name="user_name", nullable=true, unique=false, length=250) */
-            protected string $name;
-
-            // other fields mapping
-        }
-
-        // guest mapping
-        namespace MyProject\Model;
-        /**
-         * @Entity
-         * @AttributeOverrides({
-         *      @AttributeOverride(name="id",
-         *          column=@Column(
-         *              name     = "guest_id",
-         *              type     = "integer",
-         *              length   = 140
-         *          )
-         *      ),
-         *      @AttributeOverride(name="name",
-         *          column=@Column(
-         *              name     = "guest_name",
-         *              nullable = false,
-         *              unique   = true,
-         *              length   = 240
-         *          )
-         *      )
-         * })
-         */
-        class Guest extends User
-        {
-        }
-
     .. code-block:: xml
 
         <!-- user mapping -->
@@ -702,7 +521,6 @@ Could be used by an entity that extends a mapped superclass to override a field
                 <many-to-one field="address" target-entity="Address">
                     <cascade>
                         <cascade-persist/>
-                        <cascade-merge/>
                     </cascade>
                     <join-column name="address_id" referenced-column-name="id"/>
                 </many-to-one>
@@ -723,42 +541,6 @@ Could be used by an entity that extends a mapped superclass to override a field
                 </attribute-overrides>
             </entity>
         </doctrine-mapping>
-    .. code-block:: yaml
-
-        # user mapping
-        MyProject\Model\User:
-          type: mappedSuperclass
-          id:
-            id:
-              type: integer
-              column: user_id
-              length: 150
-              generator:
-                strategy: AUTO
-          fields:
-            name:
-              type: string
-              column: user_name
-              length: 250
-              nullable: true
-              unique: false
-          #other fields mapping
-
-
-        # guest mapping
-        MyProject\Model\Guest:
-          type: entity
-          attributeOverride:
-            id:
-              column: guest_id
-              type: integer
-              length: 140
-            name:
-              column: guest_name
-              type: string
-              length: 240
-              nullable: false
-              unique: true
 
 Things to note:
 

docs/en/reference/limitations-and-known-issues.rst

@@ -65,15 +65,6 @@ Where the ``attribute_name`` column contains the key and
 The feature request for persistence of primitive value arrays
 `is described in the DDC-298 ticket <https://github.com/doctrine/orm/issues/3743>`_.
 
-Cascade Merge with Bi-directional Associations
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-There are two bugs now that concern the use of cascade merge in combination with bi-directional associations.
-Make sure to study the behavior of cascade merge if you are using it:
-
--  `DDC-875 <https://github.com/doctrine/orm/issues/5398>`_ Merge can sometimes add the same entity twice into a collection
--  `DDC-763 <https://github.com/doctrine/orm/issues/5277>`_ Cascade merge on associated entities can insert too many rows through "Persistence by Reachability"
-
 Custom Persisters
 ~~~~~~~~~~~~~~~~~
 

docs/en/reference/metadata-drivers.rst

@@ -16,13 +16,6 @@ metadata:
 -  **Attributes** (AttributeDriver)
 -  **PHP Code in files or static functions** (PhpDriver)
 
-There are also two deprecated ways to do this:
-
--  **Class DocBlock Annotations** (AnnotationDriver)
--  **YAML files** (YamlDriver)
-
-They will be removed in 3.0, make sure to avoid them.
-
 Something important to note about the above drivers is they are all
 an intermediate step to the same end result. The mapping
 information is populated to ``Doctrine\ORM\Mapping\ClassMetadata``
@@ -44,11 +37,7 @@ an entity.
         $em->getConfiguration()->setMetadataCacheImpl(new ApcuCache());
 
 
-If you want to use one of the included core metadata drivers you need to
-configure it. If you pick the annotation driver despite it being
-deprecated, you will additionally need to install
-``doctrine/annotations``. All the drivers are in the
-``Doctrine\ORM\Mapping\Driver`` namespace:
+All the drivers are in the ``Doctrine\ORM\Mapping\Driver`` namespace:
 
 .. code-block:: php
 

docs/en/reference/namingstrategy.rst

@@ -110,28 +110,28 @@ You need to create a class which implements ``Doctrine\ORM\Mapping\NamingStrateg
     <?php
     class MyAppNamingStrategy implements NamingStrategy
     {
-        public function classToTableName($className)
+        public function classToTableName(string $className): string
         {
             return 'MyApp_' . substr($className, strrpos($className, '\\') + 1);
         }
-        public function propertyToColumnName($propertyName)
+        public function propertyToColumnName(string $propertyName): string
         {
             return $propertyName;
         }
-        public function referenceColumnName()
+        public function referenceColumnName(): string
         {
             return 'id';
         }
-        public function joinColumnName($propertyName, $className = null)
+        public function joinColumnName(string $propertyName, ?string $className = null): string
         {
             return $propertyName . '_' . $this->referenceColumnName();
         }
-        public function joinTableName($sourceEntity, $targetEntity, $propertyName = null)
+        public function joinTableName(string $sourceEntity, string $targetEntity, string $propertyName): string
         {
             return strtolower($this->classToTableName($sourceEntity) . '_' .
                     $this->classToTableName($targetEntity));
         }
-        public function joinKeyColumnName($entityName, $referencedColumnName = null)
+        public function joinKeyColumnName(string $entityName, ?string $referencedColumnName): string
         {
             return strtolower($this->classToTableName($entityName) . '_' .
                     ($referencedColumnName ?: $this->referenceColumnName()));

docs/en/reference/native-sql.rst

@@ -465,477 +465,3 @@ above would result in partial objects if any objects in the result
 are actually a subtype of User. When using DQL, Doctrine
 automatically includes the necessary joins for this mapping
 strategy but with native SQL it is your responsibility.
-
-Named Native Query
-------------------
-
-.. note::
-
-    Named Native Queries are deprecated as of version 2.9 and will be removed in ORM 3.0
-
-You can also map a native query using a named native query mapping.
-
-To achieve that, you must describe the SQL resultset structure
-using named native query (and sql resultset mappings if is a several resultset mappings).
-
-Like named query, a named native query can be defined at class level or in a XML or YAML file.
-
-
-A resultSetMapping parameter is defined in @NamedNativeQuery,
-it represents the name of a defined @SqlResultSetMapping.
-
-.. configuration-block::
-
-    .. code-block:: php
-
-        <?php
-        namespace MyProject\Model;
-        /**
-         * @NamedNativeQueries({
-         *      @NamedNativeQuery(
-         *          name            = "fetchMultipleJoinsEntityResults",
-         *          resultSetMapping= "mappingMultipleJoinsEntityResults",
-         *          query           = "SELECT u.id AS u_id, u.name AS u_name, u.status AS u_status, a.id AS a_id, a.zip AS a_zip, a.country AS a_country, COUNT(p.phonenumber) AS numphones FROM users u INNER JOIN addresses a ON u.id = a.user_id INNER JOIN phonenumbers p ON u.id = p.user_id GROUP BY u.id, u.name, u.status, u.username, a.id, a.zip, a.country ORDER BY u.username"
-         *      ),
-         * })
-         * @SqlResultSetMappings({
-         *      @SqlResultSetMapping(
-         *          name    = "mappingMultipleJoinsEntityResults",
-         *          entities= {
-         *              @EntityResult(
-         *                  entityClass = "__CLASS__",
-         *                  fields      = {
-         *                      @FieldResult(name = "id",       column="u_id"),
-         *                      @FieldResult(name = "name",     column="u_name"),
-         *                      @FieldResult(name = "status",   column="u_status"),
-         *                  }
-         *              ),
-         *              @EntityResult(
-         *                  entityClass = "Address",
-         *                  fields      = {
-         *                      @FieldResult(name = "id",       column="a_id"),
-         *                      @FieldResult(name = "zip",      column="a_zip"),
-         *                      @FieldResult(name = "country",  column="a_country"),
-         *                  }
-         *              )
-         *          },
-         *          columns = {
-         *              @ColumnResult("numphones")
-         *          }
-         *      )
-         *})
-         */
-         class User
-        {
-            /** @Id @Column(type="integer") @GeneratedValue */
-            public $id;
-
-            /** @Column(type="string", length=50, nullable=true) */
-            public $status;
-
-            /** @Column(type="string", length=255, unique=true) */
-            public $username;
-
-            /** @Column(type="string", length=255) */
-            public $name;
-
-            /** @OneToMany(targetEntity="Phonenumber") */
-            public $phonenumbers;
-
-            /** @OneToOne(targetEntity="Address") */
-            public $address;
-
-            // ....
-        }
-
-    .. code-block:: xml
-
-        <doctrine-mapping>
-            <entity name="MyProject\Model\User">
-                <named-native-queries>
-                    <named-native-query name="fetchMultipleJoinsEntityResults" result-set-mapping="mappingMultipleJoinsEntityResults">
-                        <query>SELECT u.id AS u_id, u.name AS u_name, u.status AS u_status, a.id AS a_id, a.zip AS a_zip, a.country AS a_country, COUNT(p.phonenumber) AS numphones FROM users u INNER JOIN addresses a ON u.id = a.user_id INNER JOIN phonenumbers p ON u.id = p.user_id GROUP BY u.id, u.name, u.status, u.username, a.id, a.zip, a.country ORDER BY u.username</query>
-                    </named-native-query>
-                </named-native-queries>
-                <sql-result-set-mappings>
-                    <sql-result-set-mapping name="mappingMultipleJoinsEntityResults">
-                        <entity-result entity-class="__CLASS__">
-                            <field-result name="id" column="u_id"/>
-                            <field-result name="name" column="u_name"/>
-                            <field-result name="status" column="u_status"/>
-                        </entity-result>
-                        <entity-result entity-class="Address">
-                            <field-result name="id" column="a_id"/>
-                            <field-result name="zip" column="a_zip"/>
-                            <field-result name="country" column="a_country"/>
-                        </entity-result>
-                        <column-result name="numphones"/>
-                    </sql-result-set-mapping>
-                </sql-result-set-mappings>
-            </entity>
-        </doctrine-mapping>
-    .. code-block:: yaml
-
-        MyProject\Model\User:
-          type: entity
-          namedNativeQueries:
-            fetchMultipleJoinsEntityResults:
-              name: fetchMultipleJoinsEntityResults
-              resultSetMapping: mappingMultipleJoinsEntityResults
-              query: SELECT u.id AS u_id, u.name AS u_name, u.status AS u_status, a.id AS a_id, a.zip AS a_zip, a.country AS a_country, COUNT(p.phonenumber) AS numphones FROM users u INNER JOIN addresses a ON u.id = a.user_id INNER JOIN phonenumbers p ON u.id = p.user_id GROUP BY u.id, u.name, u.status, u.username, a.id, a.zip, a.country ORDER BY u.username
-          sqlResultSetMappings:
-            mappingMultipleJoinsEntityResults:
-              name: mappingMultipleJoinsEntityResults
-              columnResult:
-                0:
-                  name: numphones
-              entityResult:
-                0:
-                  entityClass: __CLASS__
-                  fieldResult:
-                    0:
-                      name: id
-                      column: u_id
-                    1:
-                      name: name
-                      column: u_name
-                    2:
-                      name: status
-                      column: u_status
-                1:
-                  entityClass: Address
-                  fieldResult:
-                    0:
-                      name: id
-                      column: a_id
-                    1:
-                      name: zip
-                      column: a_zip
-                    2:
-                      name: country
-                      column: a_country
-
-
-Things to note:
-    - The resultset mapping declares the entities retrieved by this native query.
-    - Each field of the entity is bound to a SQL alias (or column name).
-    - All fields of the entity including the ones of subclasses
-      and the foreign key columns of related entities have to be present in the SQL query.
-    - Field definitions are optional provided that they map to the same
-      column name as the one declared on the class property.
-    - ``__CLASS__`` is an alias for the mapped class
-
-
-In the above example,
-the ``fetchJoinedAddress`` named query use the joinMapping result set mapping.
-This mapping returns 2 entities, User and Address, each property is declared and associated to a column name,
-actually the column name retrieved by the query.
-
-Let's now see an implicit declaration of the property / column.
-
-.. configuration-block::
-
-    .. code-block:: php
-
-        <?php
-        namespace MyProject\Model;
-            /**
-             * @NamedNativeQueries({
-             *      @NamedNativeQuery(
-             *          name                = "findAll",
-             *          resultSetMapping    = "mappingFindAll",
-             *          query               = "SELECT * FROM addresses"
-             *      ),
-             * })
-             * @SqlResultSetMappings({
-             *      @SqlResultSetMapping(
-             *          name    = "mappingFindAll",
-             *          entities= {
-             *              @EntityResult(
-             *                  entityClass = "Address"
-             *              )
-             *          }
-             *      )
-             * })
-             */
-           class Address
-           {
-                /**  @Id @Column(type="integer") @GeneratedValue */
-                public $id;
-
-                /** @Column() */
-                public $country;
-
-                /** @Column() */
-                public $zip;
-
-                /** @Column()*/
-                public $city;
-
-                // ....
-            }
-
-    .. code-block:: xml
-
-        <doctrine-mapping>
-            <entity name="MyProject\Model\Address">
-                <named-native-queries>
-                    <named-native-query name="findAll" result-set-mapping="mappingFindAll">
-                        <query>SELECT * FROM addresses</query>
-                    </named-native-query>
-                </named-native-queries>
-                <sql-result-set-mappings>
-                    <sql-result-set-mapping name="mappingFindAll">
-                        <entity-result entity-class="Address"/>
-                    </sql-result-set-mapping>
-                </sql-result-set-mappings>
-            </entity>
-        </doctrine-mapping>
-    .. code-block:: yaml
-
-        MyProject\Model\Address:
-          type: entity
-          namedNativeQueries:
-            findAll:
-              resultSetMapping: mappingFindAll
-              query: SELECT * FROM addresses
-          sqlResultSetMappings:
-            mappingFindAll:
-              name: mappingFindAll
-              entityResult:
-                address:
-                  entityClass: Address
-
-
-In this example, we only describe the entity member of the result set mapping.
-The property / column mappings is done using the entity mapping values.
-In this case the model property is bound to the model_txt column.
-If the association to a related entity involve a composite primary key,
-a @FieldResult element should be used for each foreign key column.
-The @FieldResult name is composed of the property name for the relationship,
-followed by a dot ("."), followed by the name or the field or property of the primary key.
-
-
-.. configuration-block::
-
-    .. code-block:: php
-
-        <?php
-        namespace MyProject\Model;
-            /**
-             * @NamedNativeQueries({
-             *      @NamedNativeQuery(
-             *          name            = "fetchJoinedAddress",
-             *          resultSetMapping= "mappingJoinedAddress",
-             *          query           = "SELECT u.id, u.name, u.status, a.id AS a_id, a.country AS a_country, a.zip AS a_zip, a.city AS a_city FROM users u INNER JOIN addresses a ON u.id = a.user_id WHERE u.username = ?"
-             *      ),
-             * })
-             * @SqlResultSetMappings({
-             *      @SqlResultSetMapping(
-             *          name    = "mappingJoinedAddress",
-             *          entities= {
-             *              @EntityResult(
-             *                  entityClass = "__CLASS__",
-             *                  fields      = {
-             *                      @FieldResult(name = "id"),
-             *                      @FieldResult(name = "name"),
-             *                      @FieldResult(name = "status"),
-             *                      @FieldResult(name = "address.id", column = "a_id"),
-             *                      @FieldResult(name = "address.zip", column = "a_zip"),
-             *                      @FieldResult(name = "address.city", column = "a_city"),
-             *                      @FieldResult(name = "address.country", column = "a_country"),
-             *                  }
-             *              )
-             *          }
-             *      )
-             * })
-             */
-            class User
-            {
-                /** @Id @Column(type="integer") @GeneratedValue */
-                public $id;
-
-                /** @Column(type="string", length=50, nullable=true) */
-                public $status;
-
-                /** @Column(type="string", length=255, unique=true) */
-                public $username;
-
-                /** @Column(type="string", length=255) */
-                public $name;
-
-                /** @OneToOne(targetEntity="Address") */
-                public $address;
-
-                // ....
-            }
-
-    .. code-block:: xml
-
-        <doctrine-mapping>
-            <entity name="MyProject\Model\User">
-                <named-native-queries>
-                    <named-native-query name="fetchJoinedAddress" result-set-mapping="mappingJoinedAddress">
-                        <query>SELECT u.id, u.name, u.status, a.id AS a_id, a.country AS a_country, a.zip AS a_zip, a.city AS a_city FROM users u INNER JOIN addresses a ON u.id = a.user_id WHERE u.username = ?</query>
-                    </named-native-query>
-                </named-native-queries>
-                <sql-result-set-mappings>
-                    <sql-result-set-mapping name="mappingJoinedAddress">
-                        <entity-result entity-class="__CLASS__">
-                            <field-result name="id"/>
-                            <field-result name="name"/>
-                            <field-result name="status"/>
-                            <field-result name="address.id" column="a_id"/>
-                            <field-result name="address.zip"  column="a_zip"/>
-                            <field-result name="address.city"  column="a_city"/>
-                            <field-result name="address.country" column="a_country"/>
-                        </entity-result>
-                    </sql-result-set-mapping>
-                </sql-result-set-mappings>
-            </entity>
-        </doctrine-mapping>
-    .. code-block:: yaml
-
-        MyProject\Model\User:
-          type: entity
-          namedNativeQueries:
-            fetchJoinedAddress:
-              name: fetchJoinedAddress
-              resultSetMapping: mappingJoinedAddress
-              query: SELECT u.id, u.name, u.status, a.id AS a_id, a.country AS a_country, a.zip AS a_zip, a.city AS a_city FROM users u INNER JOIN addresses a ON u.id = a.user_id WHERE u.username = ?
-          sqlResultSetMappings:
-            mappingJoinedAddress:
-              entityResult:
-                0:
-                  entityClass: __CLASS__
-                  fieldResult:
-                    0:
-                      name: id
-                    1:
-                      name: name
-                    2:
-                      name: status
-                    3:
-                      name: address.id
-                      column: a_id
-                    4:
-                      name: address.zip
-                      column: a_zip
-                    5:
-                      name: address.city
-                      column: a_city
-                    6:
-                      name: address.country
-                      column: a_country
-
-
-
-If you retrieve a single entity and if you use the default mapping,
-you can use the resultClass attribute instead of resultSetMapping:
-
-.. configuration-block::
-
-    .. code-block:: php
-
-        <?php
-        namespace MyProject\Model;
-            /**
-             * @NamedNativeQueries({
-             *      @NamedNativeQuery(
-             *          name           = "find-by-id",
-             *          resultClass    = "Address",
-             *          query          = "SELECT * FROM addresses"
-             *      ),
-             * })
-             */
-           class Address
-           {
-                // ....
-           }
-
-    .. code-block:: xml
-
-        <doctrine-mapping>
-            <entity name="MyProject\Model\Address">
-                <named-native-queries>
-                    <named-native-query name="find-by-id" result-class="Address">
-                        <query>SELECT * FROM addresses WHERE id = ?</query>
-                    </named-native-query>
-                </named-native-queries>
-            </entity>
-        </doctrine-mapping>
-    .. code-block:: yaml
-
-        MyProject\Model\Address:
-          type: entity
-          namedNativeQueries:
-            findAll:
-              name: findAll
-              resultClass: Address
-              query: SELECT * FROM addresses
-
-
-In some of your native queries, you'll have to return scalar values,
-for example when building report queries.
-You can map them in the @SqlResultsetMapping through @ColumnResult.
-You actually can even mix, entities and scalar returns in the same native query (this is probably not that common though).
-
-.. configuration-block::
-
-    .. code-block:: php
-
-        <?php
-        namespace MyProject\Model;
-            /**
-             * @NamedNativeQueries({
-             *      @NamedNativeQuery(
-             *          name            = "count",
-             *          resultSetMapping= "mappingCount",
-             *          query           = "SELECT COUNT(*) AS count FROM addresses"
-             *      )
-             * })
-             * @SqlResultSetMappings({
-             *      @SqlResultSetMapping(
-             *          name    = "mappingCount",
-             *          columns = {
-             *              @ColumnResult(
-             *                  name = "count"
-             *              )
-             *          }
-             *      )
-             * })
-             */
-           class Address
-           {
-                // ....
-           }
-
-    .. code-block:: xml
-
-        <doctrine-mapping>
-            <entity name="MyProject\Model\Address">
-                <named-native-query name="count" result-set-mapping="mappingCount">
-                    <query>SELECT COUNT(*) AS count FROM addresses</query>
-                </named-native-query>
-                <sql-result-set-mappings>
-                    <sql-result-set-mapping name="mappingCount">
-                        <column-result name="count"/>
-                    </sql-result-set-mapping>
-                </sql-result-set-mappings>
-            </entity>
-        </doctrine-mapping>
-    .. code-block:: yaml
-
-        MyProject\Model\Address:
-          type: entity
-          namedNativeQueries:
-            count:
-              name: count
-              resultSetMapping: mappingCount
-              query: SELECT COUNT(*) AS count FROM addresses
-          sqlResultSetMappings:
-            mappingCount:
-              name: mappingCount
-              columnResult:
-                count:
-                  name: count

docs/en/reference/partial-objects.rst

@@ -1,98 +0,0 @@
-Partial Objects
-===============
-
-
-.. note::
-
-    Creating Partial Objects through DQL is deprecated and
-    will be removed in the future, use data transfer object
-    support in DQL instead. (\ `Details
-    <https://github.com/doctrine/orm/issues/8471>`_)
-
-A partial object is an object whose state is not fully initialized
-after being reconstituted from the database and that is
-disconnected from the rest of its data. The following section will
-describe why partial objects are problematic and what the approach
-of Doctrine2 to this problem is.
-
-.. note::
-
-    The partial object problem in general does not apply to
-    methods or queries where you do not retrieve the query result as
-    objects. Examples are: ``Query#getArrayResult()``,
-    ``Query#getScalarResult()``, ``Query#getSingleScalarResult()``,
-    etc.
-
-.. warning::
-
-    Use of partial objects is tricky. Fields that are not retrieved
-    from the database will not be updated by the UnitOfWork even if they
-    get changed in your objects. You can only promote a partial object
-    to a fully-loaded object by calling ``EntityManager#refresh()``
-    or a DQL query with the refresh flag.
-
-
-What is the problem?
---------------------
-
-In short, partial objects are problematic because they are usually
-objects with broken invariants. As such, code that uses these
-partial objects tends to be very fragile and either needs to "know"
-which fields or methods can be safely accessed or add checks around
-every field access or method invocation. The same holds true for
-the internals, i.e. the method implementations, of such objects.
-You usually simply assume the state you need in the method is
-available, after all you properly constructed this object before
-you pushed it into the database, right? These blind assumptions can
-quickly lead to null reference errors when working with such
-partial objects.
-
-It gets worse with the scenario of an optional association (0..1 to
-1). When the associated field is NULL, you don't know whether this
-object does not have an associated object or whether it was simply
-not loaded when the owning object was loaded from the database.
-
-These are reasons why many ORMs do not allow partial objects at all
-and instead you always have to load an object with all its fields
-(associations being proxied). One secure way to allow partial
-objects is if the programming language/platform allows the ORM tool
-to hook deeply into the object and instrument it in such a way that
-individual fields (not only associations) can be loaded lazily on
-first access. This is possible in Java, for example, through
-bytecode instrumentation. In PHP though this is not possible, so
-there is no way to have "secure" partial objects in an ORM with
-transparent persistence.
-
-Doctrine, by default, does not allow partial objects. That means,
-any query that only selects partial object data and wants to
-retrieve the result as objects (i.e. ``Query#getResult()``) will
-raise an exception telling you that partial objects are dangerous.
-If you want to force a query to return you partial objects,
-possibly as a performance tweak, you can use the ``partial``
-keyword as follows:
-
-.. code-block:: php
-
-    <?php
-    $q = $em->createQuery("select partial u.{id,name} from MyApp\Domain\User u");
-
-You can also get a partial reference instead of a proxy reference by
-calling:
-
-.. code-block:: php
-
-    <?php
-    $reference = $em->getPartialReference('MyApp\Domain\User', 1);
-
-Partial references are objects with only the identifiers set as they
-are passed to the second argument of the ``getPartialReference()`` method.
-All other fields are null.
-
-When should I force partial objects?
-------------------------------------
-
-Mainly for optimization purposes, but be careful of premature
-optimization as partial objects lead to potentially more fragile
-code.
-
-

docs/en/reference/php-mapping.rst

@@ -1,97 +1,20 @@
 PHP Mapping
 ===========
 
-Doctrine ORM also allows you to provide the ORM metadata in the form
-of plain PHP code using the ``ClassMetadata`` API. You can write
-the code in PHP files or inside of a static function named
-``loadMetadata($class)`` on the entity class itself.
-
-PHP Files
----------
-
-.. note::
-
-   PHPDriver is deprecated and will be removed in 3.0, use StaticPHPDriver
-   instead.
-
-If you wish to write your mapping information inside PHP files that
-are named after the entity and included to populate the metadata
-for an entity you can do so by using the ``PHPDriver``:
-
-.. code-block:: php
-
-    <?php
-    $driver = new PHPDriver('/path/to/php/mapping/files');
-    $em->getConfiguration()->setMetadataDriverImpl($driver);
-
-Now imagine we had an entity named ``Entities\User`` and we wanted
-to write a mapping file for it using the above configured
-``PHPDriver`` instance:
-
-.. code-block:: php
-
-    <?php
-    namespace Entities;
-
-    class User
-    {
-        private $id;
-        private $username;
-    }
-
-To write the mapping information you just need to create a file
-named ``Entities.User.php`` inside of the
-``/path/to/php/mapping/files`` folder:
-
-.. code-block:: php
-
-    <?php
-    // /path/to/php/mapping/files/Entities.User.php
-
-    $metadata->mapField(array(
-       'id' => true,
-       'fieldName' => 'id',
-       'type' => 'integer'
-    ));
-
-    $metadata->mapField(array(
-       'fieldName' => 'username',
-       'type' => 'string',
-       'options' => array(
-           'fixed' => true,
-           'comment' => "User's login name"
-       )
-    ));
-
-    $metadata->mapField(array(
-       'fieldName' => 'login_count',
-       'type' => 'integer',
-       'nullable' => false,
-       'options' => array(
-           'unsigned' => true,
-           'default' => 0
-       )
-    ));
-
-Now we can easily retrieve the populated ``ClassMetadata`` instance
-where the ``PHPDriver`` includes the file and the
-``ClassMetadataFactory`` caches it for later retrieval:
-
-.. code-block:: php
-
-    <?php
-    $class = $em->getClassMetadata('Entities\User');
-    // or
-    $class = $em->getMetadataFactory()->getMetadataFor('Entities\User');
+Doctrine ORM also allows you to provide the ORM metadata in the form of plain
+PHP code using the ``ClassMetadata`` API. You can write the code in inside of a
+static function named ``loadMetadata($class)`` on the entity class itself.
 
 Static Function
 ---------------
 
-In addition to the PHP files you can also specify your mapping
-information inside of a static function defined on the entity class
-itself. This is useful for cases where you want to keep your entity
-and mapping information together but don't want to use attributes or
-annotations. For this you just need to use the ``StaticPHPDriver``:
+In addition to other drivers using configuration languages you can also
+programatically specify your mapping information inside of a static function
+defined on the entity class itself.
+
+This is useful for cases where you want to keep your entity and mapping
+information together but don't want to use attributes. For this you just
+need to use the ``StaticPHPDriver``:
 
 .. code-block:: php
 
@@ -164,13 +87,11 @@ The API of the ClassMetadataBuilder has the following methods with a fluent inte
 -   ``setTable($name)``
 -   ``addIndex(array $columns, $indexName)``
 -   ``addUniqueConstraint(array $columns, $constraintName)``
--   ``addNamedQuery($name, $dqlQuery)``
 -   ``setJoinedTableInheritance()``
 -   ``setSingleTableInheritance()``
 -   ``setDiscriminatorColumn($name, $type = 'string', $length = 255, $columnDefinition = null, $enumType = null, $options = [])``
 -   ``addDiscriminatorMapClass($name, $class)``
 -   ``setChangeTrackingPolicyDeferredExplicit()``
--   ``setChangeTrackingPolicyNotify()``
 -   ``addLifecycleEvent($methodName, $event)``
 -   ``addManyToOne($name, $targetEntity, $inversedBy = null)``
 -   ``addInverseOneToOne($name, $targetEntity, $mappedBy)``
@@ -272,7 +193,6 @@ Inheritance Getters
 -  ``isInheritanceTypeNone()``
 -  ``isInheritanceTypeJoined()``
 -  ``isInheritanceTypeSingleTable()``
--  ``isInheritanceTypeTablePerClass()``
 -  ``isInheritedField($fieldName)``
 -  ``isInheritedAssociation($fieldName)``
 
@@ -282,7 +202,6 @@ Change Tracking Getters
 
 -  ``isChangeTrackingDeferredExplicit()``
 -  ``isChangeTrackingDeferredImplicit()``
--  ``isChangeTrackingNotify()``
 
 Field & Association Getters
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~

docs/en/reference/second-level-cache.rst

@@ -295,30 +295,6 @@ level cache region.
             // other properties and methods
         }
 
-    .. code-block:: annotation
-
-        <?php
-        /**
-         * @Entity
-         * @Cache("NONSTRICT_READ_WRITE")
-         */
-        class State
-        {
-            /**
-             * @Id
-             * @GeneratedValue
-             * @Column(type="integer")
-             */
-            protected int|null $id = null;
-
-            /**
-             * @Column(unique=true)
-             */
-            protected string $name;
-
-            // other properties and methods
-        }
-
     .. code-block:: xml
 
         <?xml version="1.0" encoding="utf-8"?>
@@ -335,24 +311,6 @@ level cache region.
           </entity>
         </doctrine-mapping>
 
-    .. code-block:: yaml
-
-        Country:
-          type: entity
-          cache:
-            usage: READ_ONLY
-            region: my_entity_region
-          id:
-            id:
-              type: integer
-              id: true
-              generator:
-                strategy: IDENTITY
-          fields:
-            name:
-              type: string
-
-
 Association cache definition
 ----------------------------
 The most common use case is to cache entities. But we can also cache relationships.
@@ -389,44 +347,6 @@ It caches the primary keys of association and cache each element will be cached
             // other properties and methods
         }
 
-    .. code-block:: annotation
-
-        <?php
-        /**
-         * @Entity
-         * @Cache("NONSTRICT_READ_WRITE")
-         */
-        class State
-        {
-            /**
-             * @Id
-             * @GeneratedValue
-             * @Column(type="integer")
-             */
-            protected int|null $id = null;
-
-            /**
-             * @Column(unique=true)
-             */
-            protected string $name;
-
-            /**
-             * @Cache("NONSTRICT_READ_WRITE")
-             * @ManyToOne(targetEntity="Country")
-             * @JoinColumn(name="country_id", referencedColumnName="id")
-             */
-            protected Country|null $country;
-
-            /**
-             * @Cache("NONSTRICT_READ_WRITE")
-             * @OneToMany(targetEntity="City", mappedBy="state")
-             * @var Collection<int, City>
-             */
-            protected Collection $cities;
-
-            // other properties and methods
-        }
-
     .. code-block:: xml
 
         <?xml version="1.0" encoding="utf-8"?>
@@ -458,38 +378,6 @@ It caches the primary keys of association and cache each element will be cached
           </entity>
         </doctrine-mapping>
 
-    .. code-block:: yaml
-
-        State:
-          type: entity
-          cache:
-            usage: NONSTRICT_READ_WRITE
-          id:
-            id:
-              type: integer
-              id: true
-              generator:
-                strategy: IDENTITY
-          fields:
-            name:
-              type: string
-
-          manyToOne:
-            state:
-              targetEntity: Country
-              joinColumns:
-                country_id:
-                  referencedColumnName: id
-              cache:
-                usage: NONSTRICT_READ_WRITE
-
-          oneToMany:
-            cities:
-              targetEntity:City
-              mappedBy: state
-              cache:
-                usage: NONSTRICT_READ_WRITE
-
 .. note::
 
     for this to work, the target entity must also be marked as cacheable.

docs/en/reference/security.rst

@@ -12,9 +12,8 @@ page only handles Security issues in the ORM.
 
 - `DBAL Security Page <https://www.doctrine-project.org/projects/doctrine-dbal/en/current/reference/security.html>`
 
-If you find a Security bug in Doctrine, please report it on Jira and change the
-Security Level to "Security Issues". It will be visible to Doctrine Core
-developers and you only.
+If you find a Security bug in Doctrine, please follow our
+`Security reporting guidelines <https://www.doctrine-project.org/policies/security.html#reporting>`_.
 
 User input and Doctrine ORM
 ---------------------------

docs/en/reference/tools.rst

@@ -83,18 +83,8 @@ The following Commands are currently available:
    cache drivers.
 -  ``orm:clear-cache:result`` Clear result cache of the various
    cache drivers.
--  ``orm:convert-d1-schema`` Converts Doctrine 1.X schema into a
-   Doctrine 2.X schema.
--  ``orm:convert-mapping`` Convert mapping information between
-   supported formats.
--  ``orm:ensure-production-settings`` Verify that Doctrine is
-   properly configured for a production environment.
--  ``orm:generate-entities`` Generate entity classes and method
-   stubs from your mapping information.
 -  ``orm:generate-proxies`` Generates proxy classes for entity
    classes.
--  ``orm:generate-repositories`` Generate repository classes from
-   your mapping information.
 -  ``orm:run-dql`` Executes arbitrary DQL directly from the command
    line.
 -  ``orm:schema-tool:create`` Processes the schema and either
@@ -107,14 +97,10 @@ The following Commands are currently available:
    update the database schema of EntityManager Storage Connection or
    generate the SQL output.
 
-For these commands are also available aliases:
+The following alias is defined:
 
 
--  ``orm:convert:d1-schema`` is alias for ``orm:convert-d1-schema``.
--  ``orm:convert:mapping`` is alias for ``orm:convert-mapping``.
--  ``orm:generate:entities`` is alias for ``orm:generate-entities``.
 -  ``orm:generate:proxies`` is alias for ``orm:generate-proxies``.
--  ``orm:generate:repositories`` is alias for ``orm:generate-repositories``.
 
 .. note::
 
@@ -225,163 +211,6 @@ will output the SQL for the ran operation.
 
     $ php bin/doctrine orm:schema-tool:create --dump-sql
 
-Entity Generation
------------------
-
-Generate entity classes and method stubs from your mapping information.
-
-.. code-block:: php
-
-    $ php bin/doctrine orm:generate-entities
-    $ php bin/doctrine orm:generate-entities --update-entities
-    $ php bin/doctrine orm:generate-entities --regenerate-entities
-
-This command is not suited for constant usage. It is a little helper and does
-not support all the mapping edge cases very well. You still have to put work
-in your entities after using this command.
-
-It is possible to use the EntityGenerator on code that you have already written. It will
-not be lost. The EntityGenerator will only append new code to your
-file and will not delete the old code. However this approach may still be prone
-to error and we suggest you use code repositories such as GIT or SVN to make
-backups of your code.
-
-It makes sense to generate the entity code if you are using entities as Data
-Access Objects only and don't put much additional logic on them. If you are
-however putting much more logic on the entities you should refrain from using
-the entity-generator and code your entities manually.
-
-.. note::
-
-    Even if you specified Inheritance options in your
-    XML or YAML Mapping files the generator cannot generate the base and
-    child classes for you correctly, because it doesn't know which
-    class is supposed to extend which. You have to adjust the entity
-    code manually for inheritance to work!
-
-
-Convert Mapping Information
----------------------------
-
-Convert mapping information between supported formats.
-
-This is an **execute one-time** command. It should not be necessary for
-you to call this method multiple times, especially when using the ``--from-database``
-flag.
-
-Converting an existing database schema into mapping files only solves about 70-80%
-of the necessary mapping information. Additionally the detection from an existing
-database cannot detect inverse associations, inheritance types,
-entities with foreign keys as primary keys and many of the
-semantical operations on associations such as cascade.
-
-.. note::
-
-    There is no need to convert YAML or XML mapping files to annotations
-    every time you make changes. All mapping drivers are first class citizens
-    in Doctrine 2 and can be used as runtime mapping for the ORM. See the
-    docs on XML and YAML Mapping for an example how to register this metadata
-    drivers as primary mapping source.
-
-To convert some mapping information between the various supported
-formats you can use the ``ClassMetadataExporter`` to get exporter
-instances for the different formats:
-
-.. code-block:: php
-
-    <?php
-    $cme = new \Doctrine\ORM\Tools\Export\ClassMetadataExporter();
-
-Once you have a instance you can use it to get an exporter. For
-example, the yml exporter:
-
-.. code-block:: php
-
-    <?php
-    $exporter = $cme->getExporter('yml', '/path/to/export/yml');
-
-Now you can export some ``ClassMetadata`` instances:
-
-.. code-block:: php
-
-    <?php
-    $classes = array(
-      $em->getClassMetadata('Entities\User'),
-      $em->getClassMetadata('Entities\Profile')
-    );
-    $exporter->setMetadata($classes);
-    $exporter->export();
-
-This functionality is also available from the command line to
-convert your loaded mapping information to another format. The
-``orm:convert-mapping`` command accepts two arguments, the type to
-convert to and the path to generate it:
-
-.. code-block:: php
-
-    $ php bin/doctrine orm:convert-mapping xml /path/to/mapping-path-converted-to-xml
-
-Reverse Engineering
--------------------
-
-You can use the ``DatabaseDriver`` to reverse engineer a database to an
-array of ``ClassMetadata`` instances and generate YAML, XML, etc. from
-them.
-
-.. note::
-
-    Reverse Engineering is a **one-time** process that can get you started with a project.
-    Converting an existing database schema into mapping files only detects about 70-80%
-    of the necessary mapping information. Additionally the detection from an existing
-    database cannot detect inverse associations, inheritance types,
-    entities with foreign keys as primary keys and many of the
-    semantical operations on associations such as cascade.
-
-First you need to retrieve the metadata instances with the
-``DatabaseDriver``:
-
-.. code-block:: php
-
-    <?php
-    $em->getConfiguration()->setMetadataDriverImpl(
-        new \Doctrine\ORM\Mapping\Driver\DatabaseDriver(
-            $em->getConnection()->getSchemaManager()
-        )
-    );
-
-    $cmf = new \Doctrine\ORM\Tools\DisconnectedClassMetadataFactory();
-    $cmf->setEntityManager($em);
-    $metadata = $cmf->getAllMetadata();
-
-Now you can get an exporter instance and export the loaded metadata
-to yml:
-
-.. code-block:: php
-
-    <?php
-    $cme = new \Doctrine\ORM\Tools\Export\ClassMetadataExporter();
-    $exporter = $cme->getExporter('yml', '/path/to/export/yml');
-    $exporter->setMetadata($metadata);
-    $exporter->export();
-
-You can also reverse engineer a database using the
-``orm:convert-mapping`` command:
-
-.. code-block:: php
-
-    $ php bin/doctrine orm:convert-mapping --from-database yml /path/to/mapping-path-converted-to-yml
-
-.. note::
-
-    Reverse Engineering is not always working perfectly
-    depending on special cases. It will only detect Many-To-One
-    relations (even if they are One-To-One) and will try to create
-    entities from Many-To-Many tables. It also has problems with naming
-    of foreign keys that have multiple column names. Any Reverse
-    Engineered Database-Schema needs considerable manual work to become
-    a useful domain model.
-
-
 Runtime vs Development Mapping Validation
 -----------------------------------------
 

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

@@ -200,17 +200,6 @@ example we'll use an integer.
             // ...
         }
 
-    .. code-block:: annotation
-
-        <?php
-        class User
-        {
-            // ...
-            /** @Version @Column(type="integer") */
-            private int $version;
-            // ...
-        }
-
     .. code-block:: xml
 
         <doctrine-mapping>
@@ -219,15 +208,6 @@ example we'll use an integer.
           </entity>
         </doctrine-mapping>
 
-    .. code-block:: yaml
-
-        User:
-          type: entity
-          fields:
-            version:
-              type: integer
-              version: true
-
 Alternatively a datetime type can be used (which maps to a SQL
 timestamp or datetime):
 
@@ -244,17 +224,6 @@ timestamp or datetime):
             // ...
         }
 
-    .. code-block:: annotation
-
-        <?php
-        class User
-        {
-            // ...
-            /** @Version @Column(type="datetime") */
-            private DateTime $version;
-            // ...
-        }
-
     .. code-block:: xml
 
         <doctrine-mapping>
@@ -263,15 +232,6 @@ timestamp or datetime):
           </entity>
         </doctrine-mapping>
 
-    .. code-block:: yaml
-
-        User:
-          type: entity
-          fields:
-            version:
-              type: datetime
-              version: true
-
 Version numbers (not timestamps) should however be preferred as
 they can not potentially conflict in a highly concurrent
 environment, unlike timestamps where this is a possibility,

docs/en/reference/typedfieldmapper.rst

@@ -47,21 +47,6 @@ Then, an entity using the ``CustomIdObject`` typed field will be correctly assig
             // ...
         }
 
-    .. code-block:: annotation
-
-        <?php
-        /**
-         * @Entity
-         * @Table(name="cms_users_typed_with_custom_typed_field")
-         */
-        class UserTypedWithCustomTypedField
-        {
-            /** @Column */
-            public CustomIdObject $customId;
-
-            // ...
-        }
-
     .. code-block:: xml
 
         <doctrine-mapping>
@@ -176,4 +161,4 @@ You need to create a class which implements ``Doctrine\ORM\Mapping\TypedFieldMap
 
     Note that this case checks whether the mapping is already assigned, and if yes, it skips it. This is up to your
     implementation. You can make a "greedy" mapper which will always override the mapping with its own type, or one
-    that behaves like the ``DefaultTypedFieldMapper`` and does not modify the type once its set prior in the chain.
+    that behaves like the ``DefaultTypedFieldMapper`` and does not modify the type once its set prior in the chain.

docs/en/reference/unitofwork.rst

@@ -129,16 +129,10 @@ optimize the performance of the Flush Operation:
 - Temporarily mark entities as read only. If you have a very large UnitOfWork
   but know that a large set of entities has not changed, just mark them as read
   only with ``$entityManager->getUnitOfWork()->markReadOnly($entity)``.
-- Flush only a single entity with ``$entityManager->flush($entity)``.
 - Use :doc:`Change Tracking Policies <change-tracking-policies>` to use more
   explicit strategies of notifying the UnitOfWork what objects/properties
   changed.
 
-.. note::
-
-    Flush only a single entity with ``$entityManager->flush($entity)`` is deprecated and will be removed in ORM 3.0.
-    (\ `Details <https://github.com/doctrine/orm/issues/8459>`_)
-
 Query Internals
 ---------------
 

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

@@ -415,7 +415,7 @@ Transitive persistence / Cascade Operations
 Doctrine ORM provides a mechanism for transitive persistence through cascading of certain operations.
 Each association to another entity or a collection of
 entities can be configured to automatically cascade the following operations to the associated entities:
-``persist``, ``remove``, ``merge``, ``detach``, ``refresh`` or ``all``.
+``persist``, ``remove``, ``detach``, ``refresh`` or ``all``.
 
 The main use case for ``cascade: persist`` is to avoid "exposing" associated entities to your PHP application.
 Continuing with the User-Comment example of this chapter, this is how the creation of a new user and a new

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

@@ -413,77 +413,6 @@ automatically without invoking the ``detach`` method:
 The ``detach`` operation is usually not as frequently needed and
 used as ``persist`` and ``remove``.
 
-Merging entities
-----------------
-
-Merging entities refers to the merging of (usually detached)
-entities into the context of an EntityManager so that they become
-managed again. To merge the state of an entity into an
-EntityManager use the ``EntityManager#merge($entity)`` method. The
-state of the passed entity will be merged into a managed copy of
-this entity and this copy will subsequently be returned.
-
-Example:
-
-.. code-block:: php
-
-    <?php
-    $detachedEntity = unserialize($serializedEntity); // some detached entity
-    $entity = $em->merge($detachedEntity);
-    // $entity now refers to the fully managed copy returned by the merge operation.
-    // The EntityManager $em now manages the persistence of $entity as usual.
-
-
-The semantics of the merge operation, applied to an entity X, are
-as follows:
-
-
--  If X is a detached entity, the state of X is copied onto a
-   pre-existing managed entity instance X' of the same identity.
--  If X is a new entity instance, a new managed copy X' will be
-   created and the state of X is copied onto this managed instance.
--  If X is a removed entity instance, an InvalidArgumentException
-   will be thrown.
--  If X is a managed entity, it is ignored by the merge operation,
-   however, the merge operation is cascaded to entities referenced by
-   relationships from X if these relationships have been mapped with
-   the cascade element value MERGE or ALL (see ":ref:`transitive-persistence`").
--  For all entities Y referenced by relationships from X having the
-   cascade element value MERGE or ALL, Y is merged recursively as Y'.
-   For all such Y referenced by X, X' is set to reference Y'. (Note
-   that if X is managed then X is the same object as X'.)
--  If X is an entity merged to X', with a reference to another
-   entity Y, where cascade=MERGE or cascade=ALL is not specified, then
-   navigation of the same association from X' yields a reference to a
-   managed object Y' with the same persistent identity as Y.
-
-The ``merge`` operation will throw an ``OptimisticLockException``
-if the entity being merged uses optimistic locking through a
-version field and the versions of the entity being merged and the
-managed copy don't match. This usually means that the entity has
-been modified while being detached.
-
-The ``merge`` operation is usually not as frequently needed and
-used as ``persist`` and ``remove``. The most common scenario for
-the ``merge`` operation is to reattach entities to an EntityManager
-that come from some cache (and are therefore detached) and you want
-to modify and persist such an entity.
-
-.. warning::
-
-    If you need to perform multiple merges of entities that share certain subparts
-    of their object-graphs and cascade merge, then you have to call ``EntityManager#clear()`` between the
-    successive calls to ``EntityManager#merge()``. Otherwise you might end up with
-    multiple copies of the "same" object in the database, however with different ids.
-
-.. note::
-
-    If you load some detached entities from a cache and you do
-    not need to persist or delete them or otherwise make use of them
-    without the need for persistence services there is no need to use
-    ``merge``. I.e. you can simply pass detached objects from a cache
-    directly to the view.
-
 
 Synchronization with the Database
 ---------------------------------
@@ -594,7 +523,7 @@ during development.
 .. note::
 
     Do not invoke ``flush`` after every change to an entity
-    or every single invocation of persist/remove/merge/... This is an
+    or every single invocation of persist/remove/... This is an
     anti-pattern and unnecessarily reduces the performance of your
     application. Instead, form units of work that operate on your
     objects and call ``flush`` when you are done. While serving a
@@ -862,7 +791,7 @@ By default the EntityManager returns a default implementation of
 ``Doctrine\ORM\EntityRepository`` when you call
 ``EntityManager#getRepository($entityClass)``. You can overwrite
 this behaviour by specifying the class name of your own Entity
-Repository in the Attribute, Annotation, XML or YAML metadata. In large
+Repository in the Attribute or XML metadata. In large
 applications that require lots of specialized DQL queries using a
 custom repository is one recommended way of grouping these queries
 in a central location.

docs/en/reference/xml-mapping.rst

@@ -2,7 +2,8 @@ XML Mapping
 ===========
 
 The XML mapping driver enables you to provide the ORM metadata in
-form of XML documents.
+form of XML documents. It requires the ``dom`` extension in order to be
+able to validate your mapping documents against its XML Schema.
 
 The XML driver is backed by an XML Schema document that describes
 the structure of a mapping document. The most recent version of the
@@ -691,7 +692,6 @@ specified by their respective tags:
 
 
 -  ``<cascade-persist />``
--  ``<cascade-merge />``
 -  ``<cascade-remove />``
 -  ``<cascade-refresh />``
 -  ``<cascade-detach />``

docs/en/reference/yaml-mapping.rst

@@ -1,158 +0,0 @@
-YAML Mapping
-============
-
-.. warning::
-    The YAML driver is deprecated and will be removed in version 3.0.
-    It is strongly recommended to switch to one of the other mappings.
-
-The YAML mapping driver enables you to provide the ORM metadata in
-form of YAML documents.
-
-The YAML mapping document of a class is loaded on-demand the first
-time it is requested and subsequently stored in the metadata cache.
-In order to work, this requires certain conventions:
-
-
--  Each entity/mapped superclass must get its own dedicated YAML
-   mapping document.
--  The name of the mapping document must consist of the fully
-   qualified name of the class, where namespace separators are
-   replaced by dots (.).
--  All mapping documents should get the extension ".dcm.yml" to
-   identify it as a Doctrine mapping file. This is more of a
-   convention and you are not forced to do this. You can change the
-   file extension easily enough.
-
-.. code-block:: php
-
-    <?php
-    $driver->setFileExtension('.yml');
-
-It is recommended to put all YAML mapping documents in a single
-folder but you can spread the documents over several folders if you
-want to. In order to tell the YamlDriver where to look for your
-mapping documents, supply an array of paths as the first argument
-of the constructor, like this:
-
-.. code-block:: php
-
-    <?php
-    use Doctrine\ORM\Mapping\Driver\YamlDriver;
-
-    // $config instanceof Doctrine\ORM\Configuration
-    $driver = new YamlDriver(array('/path/to/files'));
-    $config->setMetadataDriverImpl($driver);
-
-Simplified YAML Driver
-~~~~~~~~~~~~~~~~~~~~~~
-
-The Symfony project sponsored a driver that simplifies usage of the YAML Driver.
-The changes between the original driver are:
-
-- File Extension is .orm.yml
-- Filenames are shortened, "MyProject\\Entities\\User" will become User.orm.yml
-- You can add a global file and add multiple entities in this file.
-
-Configuration of this client works a little bit different:
-
-.. code-block:: php
-
-    <?php
-    $namespaces = array(
-        '/path/to/files1' => 'MyProject\Entities',
-        '/path/to/files2' => 'OtherProject\Entities'
-    );
-    $driver = new \Doctrine\ORM\Mapping\Driver\SimplifiedYamlDriver($namespaces);
-    $driver->setGlobalBasename('global'); // global.orm.yml
-
-Example
--------
-
-As a quick start, here is a small example document that makes use
-of several common elements:
-
-.. code-block:: yaml
-
-    # Doctrine.Tests.ORM.Mapping.User.dcm.yml
-    Doctrine\Tests\ORM\Mapping\User:
-      type: entity
-      repositoryClass: Doctrine\Tests\ORM\Mapping\UserRepository
-      table: cms_users
-      schema: schema_name # The schema the table lies in, for platforms that support schemas (Optional, >= 2.5)
-      readOnly: true
-      indexes:
-        name_index:
-          columns: [ name ]
-      id:
-        id:
-          type: integer
-          generator:
-            strategy: AUTO
-      fields:
-        name:
-          type: string
-          length: 50
-        email:
-          type: string
-          length: 32
-          column: user_email
-          unique: true
-          options:
-            fixed: true
-            comment: User's email address
-        loginCount:
-          type: integer
-          column: login_count
-          nullable: false
-          options:
-            unsigned: true
-            default: 0
-      oneToOne:
-        address:
-          targetEntity: Address
-          joinColumn:
-            name: address_id
-            referencedColumnName: id
-            onDelete: CASCADE
-      oneToMany:
-        phonenumbers:
-          targetEntity: Phonenumber
-          mappedBy: user
-          cascade: ["persist", "merge"]
-      manyToMany:
-        groups:
-          targetEntity: Group
-          joinTable:
-            name: cms_users_groups
-            joinColumns:
-              user_id:
-                referencedColumnName: id
-            inverseJoinColumns:
-              group_id:
-                referencedColumnName: id
-      lifecycleCallbacks:
-        prePersist: [ doStuffOnPrePersist, doOtherStuffOnPrePersistToo ]
-        postPersist: [ doStuffOnPostPersist ]
-
-Be aware that class-names specified in the YAML files should be
-fully qualified.
-
-Reference
-~~~~~~~~~~~~~~~~~~~~~~
-
-Unique Constraints
-------------------
-
-It is possible to define unique constraints by the following declaration:
-
-.. code-block:: yaml
-
-    # ECommerceProduct.orm.yml
-    ECommerceProduct:
-      type: entity
-      fields:
-        # definition of some fields
-      uniqueConstraints:
-        search_idx:
-          columns: [ name, email ]
-

docs/en/sidebar.rst

@@ -31,6 +31,7 @@
       reference/inheritance-mapping
       reference/working-with-objects
       reference/working-with-associations
+      reference/typedfieldmapper
       reference/events
       reference/unitofwork
       reference/unitofwork-associations
@@ -40,11 +41,8 @@
       reference/query-builder
       reference/native-sql
       reference/change-tracking-policies
-      reference/partial-objects
-      reference/annotations-reference
       reference/attributes-reference
       reference/xml-mapping
-      reference/yaml-mapping
       reference/php-mapping
       reference/caching
       reference/improving-performance
@@ -72,7 +70,6 @@
       cookbook/dql-custom-walkers
       cookbook/dql-user-defined-functions
       cookbook/implementing-arrayaccess-for-domain-objects
-      cookbook/implementing-the-notify-changetracking-policy
       cookbook/resolve-target-entity-listener
       cookbook/sql-table-prefixes
       cookbook/strategy-cookbook-introduction

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

@@ -50,38 +50,6 @@ and year of production as primary keys:
             }
         }
 
-    .. code-block:: annotation
-
-        <?php
-        namespace VehicleCatalogue\Model;
-
-        /**
-         * @Entity
-         */
-        class Car
-        {
-            /** @Id @Column(type="string") */
-            private string $name;
-            /** @Id @Column(type="integer") */
-            private int $year;
-
-            public function __construct($name, $year)
-            {
-                $this->name = $name;
-                $this->year = $year;
-            }
-
-            public function getModelName(): string
-            {
-                return $this->name;
-            }
-
-            public function getYearOfProduction(): int
-            {
-                return $this->year;
-            }
-        }
-
     .. code-block:: xml
 
         <?xml version="1.0" encoding="UTF-8"?>
@@ -96,16 +64,6 @@ and year of production as primary keys:
             </entity>
         </doctrine-mapping>
 
-    .. code-block:: yaml
-
-        VehicleCatalogue\Model\Car:
-          type: entity
-          id:
-            name:
-              type: string
-            year:
-              type: integer
-
 Now you can use this entity:
 
 .. code-block:: php
@@ -160,7 +118,6 @@ The semantics of mapping identity through foreign entities are easy:
 -   Only allowed on Many-To-One or One-To-One associations.
 -   Plug an ``#[Id]`` attribute onto every association.
 -   Set an attribute ``association-key`` with the field name of the association in XML.
--   Set a key ``associationKey:`` with the field name of the association in YAML.
 
 Use-Case 1: Dynamic Attributes
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -214,57 +171,6 @@ We keep up the example of an Article with arbitrary attributes, the mapping look
             }
         }
 
-    .. code-block:: annotation
-
-        <?php
-        namespace Application\Model;
-
-        use Doctrine\Common\Collections\ArrayCollection;
-
-        /**
-         * @Entity
-         */
-        class Article
-        {
-            /** @Id @Column(type="integer") @GeneratedValue */
-            private int|null $id = null;
-            /** @Column(type="string") */
-            private string $title;
-
-            /**
-             * @OneToMany(targetEntity="ArticleAttribute", mappedBy="article", cascade={"ALL"}, indexBy="attribute")
-             * @var Collection<int, ArticleAttribute>
-             */
-            private Collection $attributes;
-
-            public function addAttribute($name, $value): void
-            {
-                $this->attributes[$name] = new ArticleAttribute($name, $value, $this);
-            }
-        }
-
-        /**
-         * @Entity
-         */
-        class ArticleAttribute
-        {
-            /** @Id @ManyToOne(targetEntity="Article", inversedBy="attributes") */
-            private Article|null $article;
-
-            /** @Id @Column(type="string") */
-            private string $attribute;
-
-            /** @Column(type="string") */
-            private string $value;
-
-            public function __construct($name, $value, $article)
-            {
-                $this->attribute = $name;
-                $this->value = $value;
-                $this->article = $article;
-            }
-        }
-
     .. code-block:: xml
 
         <doctrine-mapping xmlns="http://doctrine-project.org/schemas/orm/doctrine-mapping"
@@ -283,24 +189,6 @@ We keep up the example of an Article with arbitrary attributes, the mapping look
 
         </doctrine-mapping>
 
-    .. code-block:: yaml
-
-        Application\Model\ArticleAttribute:
-          type: entity
-          id:
-            article:
-              associationKey: true
-            attribute:
-              type: string
-          fields:
-            value:
-              type: string
-          manyToOne:
-            article:
-              targetEntity: Article
-              inversedBy: attributes
-
-
 Use-Case 2: Simple Derived Identity
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -328,26 +216,6 @@ One good example for this is a user-address relationship:
             private User|null $user = null;
         }
 
-    .. code-block:: yaml
-
-        User:
-          type: entity
-          id:
-            id:
-              type: integer
-              generator:
-                strategy: AUTO
-
-        Address:
-          type: entity
-          id:
-            user:
-              associationKey: true
-          oneToOne:
-            user:
-              targetEntity: User
-
-
 Use-Case 3: Join-Table with Metadata
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

docs/en/tutorials/embeddables.rst

@@ -44,33 +44,6 @@ instead of simply adding the respective columns to the ``User`` class.
             private string $country;
         }
 
-    .. code-block:: annotation
-
-        <?php
-
-        /** @Entity */
-        class User
-        {
-            /** @Embedded(class = "Address") */
-            private Address $address;
-        }
-
-        /** @Embeddable */
-        class Address
-        {
-            /** @Column(type = "string") */
-            private string $street;
-
-            /** @Column(type = "string") */
-            private string $postalCode;
-
-            /** @Column(type = "string") */
-            private string $city;
-
-            /** @Column(type = "string") */
-            private string $country;
-        }
-
     .. code-block:: xml
 
         <doctrine-mapping>
@@ -86,22 +59,6 @@ instead of simply adding the respective columns to the ``User`` class.
             </embeddable>
         </doctrine-mapping>
 
-    .. code-block:: yaml
-
-        User:
-          type: entity
-          embedded:
-            address:
-              class: Address
-
-        Address:
-          type: embeddable
-          fields:
-            street: { type: string }
-            postalCode: { type: string }
-            city: { type: string }
-            country: { type: string }
-
 In terms of your database schema, Doctrine will automatically inline all
 columns from the ``Address`` class into the table of the ``User`` class,
 just as if you had declared them directly there.
@@ -147,32 +104,12 @@ The following example shows you how to set your prefix to ``myPrefix_``:
             private Address $address;
         }
 
-    .. code-block:: annotation
-
-        <?php
-
-        /** @Entity */
-        class User
-        {
-            /** @Embedded(class = "Address", columnPrefix = "myPrefix_") */
-            private $address;
-        }
-
     .. code-block:: xml
 
         <entity name="User">
             <embedded name="address" class="Address" column-prefix="myPrefix_" />
         </entity>
 
-    .. code-block:: yaml
-
-        User:
-          type: entity
-          embedded:
-            address:
-              class: Address
-              columnPrefix: myPrefix_
-
 To have Doctrine drop the prefix and use the value object's property name
 directly, set ``columnPrefix=false`` (``use-column-prefix="false"`` for XML):
 
@@ -189,32 +126,12 @@ directly, set ``columnPrefix=false`` (``use-column-prefix="false"`` for XML):
             private Address $address;
         }
 
-    .. code-block:: annotation
-
-        <?php
-
-        /** @Entity */
-        class User
-        {
-            /** @Embedded(class = "Address", columnPrefix = false) */
-            private Address $address;
-        }
-
     .. code-block:: xml
 
         <entity name="User">
             <embedded name="address" class="Address" use-column-prefix="false" />
         </entity>
 
-    .. code-block:: yaml
-
-        User:
-          type: entity
-          embedded:
-            address:
-              class: Address
-              columnPrefix: false
-
 
 DQL
 ---

docs/en/tutorials/extra-lazy-associations.rst

@@ -65,23 +65,6 @@ switch to extra lazy as shown in these examples:
             public Collection $users;
         }
 
-    .. code-block:: annotation
-
-        <?php
-        namespace Doctrine\Tests\Models\CMS;
-
-        /**
-         * @Entity
-         */
-        class CmsGroup
-        {
-            /**
-             * @ManyToMany(targetEntity="CmsUser", mappedBy="groups", fetch="EXTRA_LAZY")
-             * @var Collection<int, CmsUser>
-             */
-            public Collection $users;
-        }
-
     .. code-block:: xml
 
         <?xml version="1.0" encoding="UTF-8"?>
@@ -95,14 +78,3 @@ switch to extra lazy as shown in these examples:
                 <many-to-many field="users" target-entity="CmsUser" mapped-by="groups" fetch="EXTRA_LAZY" />
             </entity>
         </doctrine-mapping>
-
-    .. code-block:: yaml
-
-        Doctrine\Tests\Models\CMS\CmsGroup:
-          type: entity
-          # ...
-          manyToMany:
-            users:
-              targetEntity: CmsUser
-              mappedBy: groups
-              fetch: EXTRA_LAZY

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.
 
@@ -82,10 +82,9 @@ that directory with the following contents:
 
     {
         "require": {
-            "doctrine/orm": "^2.11.0",
-            "doctrine/dbal": "^3.2",
-            "symfony/yaml": "^5.4",
-            "symfony/cache": "^5.4"
+            "doctrine/orm": "^3",
+            "doctrine/dbal": "^4",
+            "symfony/cache": "^7"
         },
         "autoload": {
             "psr-0": {"": "src/"}
@@ -107,12 +106,8 @@ Add the following directories::
     doctrine2-tutorial
     |-- config
     |   `-- xml
-    |   `-- yaml
     `-- src
 
-.. note::
-    The YAML driver is deprecated and will be removed in version 3.0.
-    It is strongly recommended to switch to one of the other mappings.
 .. note::
     It is strongly recommended that you require ``doctrine/dbal`` in your
     ``composer.json`` as well, because using the ORM means mapping objects
@@ -147,19 +142,11 @@ step:
         paths: array(__DIR__."/src"),
         isDevMode: true,
     );
-    // or if you prefer annotation, YAML or XML
-    // $config = ORMSetup::createAnnotationMetadataConfiguration(
-    //    paths: array(__DIR__."/src"),
-    //    isDevMode: true,
-    // );
+    // or if you prefer XML
     // $config = ORMSetup::createXMLMetadataConfiguration(
     //    paths: array(__DIR__."/config/xml"),
     //    isDevMode: true,
     //);
-    // $config = ORMSetup::createYAMLMetadataConfiguration(
-    //    paths: array(__DIR__."/config/yaml"),
-    //    isDevMode: true,
-    // );
 
     // configuring the database connection
     $connection = DriverManager::getConnection([
@@ -170,10 +157,6 @@ step:
     // obtaining the entity manager
     $entityManager = new EntityManager($connection, $config);
 
-.. note::
-    The YAML driver is deprecated and will be removed in version 3.0.
-    It is strongly recommended to switch to one of the other mappings.
-
 The ``require_once`` statement sets up the class autoloading for Doctrine and
 its dependencies using Composer's autoloader.
 
@@ -500,8 +483,8 @@ language describes how entities, their properties and references should be
 persisted and what constraints should be applied to them.
 
 Metadata for an Entity can be configured using attributes directly in
-the Entity class itself, or in an external XML or YAML file. This
-Getting Started guide will demonstrate metadata mappings using all three
+the Entity class itself, or in an external XML file. This
+Getting Started guide will demonstrate metadata mappings using both
 methods, but you only need to choose one.
 
 .. configuration-block::
@@ -527,33 +510,6 @@ methods, but you only need to choose one.
             // .. (other code)
         }
 
-    .. code-block:: annotation
-
-        <?php
-        // src/Product.php
-
-        use Doctrine\ORM\Mapping as ORM;
-
-        /**
-         * @ORM\Entity
-         * @ORM\Table(name="products")
-         */
-        class Product
-        {
-            /**
-             * @ORM\Id
-             * @ORM\Column(type="integer")
-             * @ORM\GeneratedValue
-             */
-            private int|null $id = null;
-            /**
-             * @ORM\Column(type="string")
-             */
-            private string $name;
-
-            // .. (other code)
-        }
-
     .. code-block:: xml
 
         <!-- config/xml/Product.dcm.xml -->
@@ -571,25 +527,6 @@ methods, but you only need to choose one.
               </entity>
         </doctrine-mapping>
 
-.. note::
-    The YAML driver is deprecated and will be removed in version 3.0.
-    It is strongly recommended to switch to one of the other mappings.
-
-    .. code-block:: yaml
-
-        # config/yaml/Product.dcm.yml
-        Product:
-          type: entity
-          table: products
-          id:
-            id:
-              type: integer
-              generator:
-                strategy: AUTO
-          fields:
-            name:
-              type: string
-
 The top-level ``entity`` definition specifies information about
 the class and table name. The primitive type ``Product#name`` is
 defined as a ``field`` attribute. The ``id`` property is defined with
@@ -1082,59 +1019,6 @@ the ``Product`` before:
             // ... (other code)
         }
 
-    .. code-block:: annotation
-
-        <?php
-        // src/Bug.php
-
-        use Doctrine\ORM\Mapping as ORM;
-
-        /**
-         * @ORM\Entity
-         * @ORM\Table(name="bugs")
-         */
-        class Bug
-        {
-            /**
-             * @ORM\Id
-             * @ORM\Column(type="integer")
-             * @ORM\GeneratedValue
-             */
-            private int|null $id = null;
-
-            /**
-             * @ORM\Column(type="string")
-             */
-            private string $description;
-
-            /**
-             * @ORM\Column(type="datetime")
-             */
-            private DateTime $created;
-
-            /**
-             * @ORM\Column(type="string")
-             */
-            private string $status;
-
-            /**
-             * @ORM\ManyToOne(targetEntity="User", inversedBy="assignedBugs")
-             */
-            private User|null $engineer;
-
-            /**
-             * @ORM\ManyToOne(targetEntity="User", inversedBy="reportedBugs")
-             */
-            private User|null $reporter;
-
-            /**
-             * @ORM\ManyToMany(targetEntity="Product")
-             */
-            private Collection $products;
-
-            // ... (other code)
-        }
-
     .. code-block:: xml
 
         <!-- config/xml/Bug.dcm.xml -->
@@ -1159,40 +1043,6 @@ the ``Product`` before:
             </entity>
         </doctrine-mapping>
 
-.. note::
-    The YAML driver is deprecated and will be removed in version 3.0.
-    It is strongly recommended to switch to one of the other mappings.
-
-    .. code-block:: yaml
-
-        # config/yaml/Bug.dcm.yml
-        Bug:
-          type: entity
-          table: bugs
-          id:
-            id:
-              type: integer
-              generator:
-                strategy: AUTO
-          fields:
-            description:
-              type: text
-            created:
-              type: datetime
-            status:
-              type: string
-          manyToOne:
-            reporter:
-              targetEntity: User
-              inversedBy: reportedBugs
-            engineer:
-              targetEntity: User
-              inversedBy: assignedBugs
-          manyToMany:
-            products:
-              targetEntity: Product
-
-
 Here we have the entity, id and primitive type definitions.
 For the "created" field we have used the ``datetime`` type,
 which translates the YYYY-mm-dd HH:mm:ss database format
@@ -1249,47 +1099,6 @@ Finally, we'll add metadata mappings for the ``User`` entity.
             // .. (other code)
         }
 
-    .. code-block:: annotation
-
-        <?php
-        // src/User.php
-
-        use Doctrine\ORM\Mapping as ORM;
-
-        /**
-         * @ORM\Entity
-         * @ORM\Table(name="users")
-         */
-        class User
-        {
-            /**
-             * @ORM\Id
-             * @ORM\GeneratedValue
-             * @ORM\Column(type="integer")
-             * @var int
-             */
-            private int|null $id = null;
-
-            /**
-             * @ORM\Column(type="string")
-             * @var string
-             */
-            private string $name;
-
-            /**
-             * @ORM\OneToMany(targetEntity="Bug", mappedBy="reporter")
-             * @var Collection<int, Bug> An ArrayCollection of Bug objects.
-             */
-            private Collection $reportedBugs;
-
-            /**
-             * @ORM\OneToMany(targetEntity="Bug", mappedBy="engineer")
-             * @var Collection<int, Bug> An ArrayCollection of Bug objects.
-             */
-            private Collection $assignedBugs;
-
-            // .. (other code)
-        }
     .. code-block:: xml
 
         <!-- config/xml/User.dcm.xml -->
@@ -1310,33 +1119,7 @@ Finally, we'll add metadata mappings for the ``User`` entity.
              </entity>
         </doctrine-mapping>
 
-.. note::
-    The YAML driver is deprecated and will be removed in version 3.0.
-    It is strongly recommended to switch to one of the other mappings.
-
-    .. code-block:: yaml
-
-        # config/yaml/User.dcm.yml
-        User:
-          type: entity
-          table: users
-          id:
-            id:
-              type: integer
-              generator:
-                strategy: AUTO
-          fields:
-            name:
-              type: string
-          oneToMany:
-            reportedBugs:
-              targetEntity: Bug
-              mappedBy: reporter
-            assignedBugs:
-              targetEntity: Bug
-              mappedBy: engineer
-
-Here are some new things to mention about the ``OneToMany`` attribute.
+Here are some new things to mention about the ``one-to-many`` tags.
 Remember that we discussed about the inverse and owning side. Now
 both reportedBugs and assignedBugs are inverse relations, which
 means the join details have already been defined on the owning
@@ -1800,21 +1583,6 @@ we have to adjust the metadata slightly.
             // ...
         }
 
-    .. code-block:: annotation
-
-        <?php
-
-        use Doctrine\ORM\Mapping as ORM;
-
-        /**
-         * @ORM\Entity(repositoryClass="BugRepository")
-         * @ORM\Table(name="bugs")
-         */
-        class Bug
-        {
-            // ...
-        }
-
     .. code-block:: xml
 
         <doctrine-mapping xmlns="http://doctrine-project.org/schemas/orm/doctrine-mapping"
@@ -1827,16 +1595,6 @@ we have to adjust the metadata slightly.
               </entity>
         </doctrine-mapping>
 
-.. note::
-    The YAML driver is deprecated and will be removed in version 3.0.
-    It is strongly recommended to switch to one of the other mappings.
-
-    .. code-block:: yaml
-
-        Bug:
-          type: entity
-          repositoryClass: BugRepository
-
 Now we can remove our query logic in all the places and instead use them through the EntityRepository.
 As an example here is the code of the first use case "List of Bugs":
 

docs/en/tutorials/ordered-associations.rst

@@ -27,22 +27,6 @@ can specify the ``#[OrderBy]`` in the following way:
             private Collection $groups;
         }
 
-    .. code-block:: annotation
-
-        <?php
-        /** @Entity **/
-        class User
-        {
-            // ...
-
-            /**
-             * @ManyToMany(targetEntity="Group")
-             * @OrderBy({"name" = "ASC"})
-             * @var Collection<int, Group>
-             */
-            private Collection $groups;
-        }
-
     .. code-block:: xml
 
         <doctrine-mapping>
@@ -55,23 +39,6 @@ can specify the ``#[OrderBy]`` in the following way:
             </entity>
         </doctrine-mapping>
 
-    .. code-block:: yaml
-
-        User:
-          type: entity
-          manyToMany:
-            groups:
-              orderBy: { 'name': 'ASC' }
-              targetEntity: Group
-              joinTable:
-                name: users_groups
-                joinColumns:
-                  user_id:
-                    referencedColumnName: id
-                inverseJoinColumns:
-                  group_id:
-                    referencedColumnName: id
-
 The DQL Snippet in OrderBy is only allowed to consist of
 unqualified, unquoted field names and of an optional ASC/DESC
 positional statement. Multiple Fields are separated by a comma (,).

docs/en/tutorials/override-field-association-mappings-in-subclasses.rst

@@ -66,7 +66,7 @@ which has mapping metadata that is overridden by the attribute above:
         #[Column(name: 'trait_foo', type: 'integer', length: 100, nullable: true, unique: true)]
         protected int $foo;
 
-        #[OneToOne(targetEntity: Bar::class, cascade: ['persist', 'merge'])]
+        #[OneToOne(targetEntity: Bar::class, cascade: ['persist'])]
         #[JoinColumn(name: 'example_trait_bar_id', referencedColumnName: 'id')]
         protected Bar|null $bar = null;
     }
@@ -81,4 +81,4 @@ The case for just extending a class would be just the same but:
         // ...
     }
 
-Overriding is also supported via XML and YAML (:ref:`examples <inheritence_mapping_overrides>`).
+Overriding is also supported via XML (:ref:`examples <inheritence_mapping_overrides>`).

docs/en/tutorials/working-with-indexed-associations.rst

@@ -24,9 +24,7 @@ Mapping Indexed Associations
 You can map indexed associations by adding:
 
     * ``indexBy`` argument to any ``#[OneToMany]`` or ``#[ManyToMany]`` attribute.
-    * ``indexBy`` attribute to any ``@OneToMany`` or ``@ManyToMany`` annotation.
     * ``index-by`` attribute to any ``<one-to-many />`` or ``<many-to-many />`` xml element.
-    * ``indexBy:`` key-value pair to any association defined in ``manyToMany:`` or ``oneToMany:`` YAML mapping files.
 
 The code and mappings for the Market entity looks like this:
 
@@ -90,74 +88,6 @@ The code and mappings for the Market entity looks like this:
             }
         }
 
-    .. code-block:: annotation
-
-        <?php
-        namespace Doctrine\Tests\Models\StockExchange;
-
-        use Doctrine\Common\Collections\ArrayCollection;
-
-        /**
-         * @Entity
-         * @Table(name="exchange_markets")
-         */
-        class Market
-        {
-            /**
-             * @Id @Column(type="integer") @GeneratedValue
-             * @var int
-             */
-            private int|null $id = null;
-
-            /**
-             * @Column(type="string")
-             * @var string
-             */
-            private string $name;
-
-            /**
-             * @OneToMany(targetEntity="Stock", mappedBy="market", indexBy="symbol")
-             * @var Collection<int, Stock>
-             */
-            private Collection $stocks;
-
-            public function __construct($name)
-            {
-                $this->name = $name;
-                $this->stocks = new ArrayCollection();
-            }
-
-            public function getId(): int|null
-            {
-                return $this->id;
-            }
-
-            public function getName(): string
-            {
-                return $this->name;
-            }
-
-            public function addStock(Stock $stock): void
-            {
-                $this->stocks[$stock->getSymbol()] = $stock;
-            }
-
-            public function getStock($symbol): Stock
-            {
-                if (!isset($this->stocks[$symbol])) {
-                    throw new \InvalidArgumentException("Symbol is not traded on this market.");
-                }
-
-                return $this->stocks[$symbol];
-            }
-
-            /** @return array<string, Stock> */
-            public function getStocks(): array
-            {
-                return $this->stocks->toArray();
-            }
-        }
-
     .. code-block:: xml
 
         <?xml version="1.0" encoding="UTF-8"?>
@@ -177,24 +107,6 @@ The code and mappings for the Market entity looks like this:
             </entity>
         </doctrine-mapping>
 
-    .. code-block:: yaml
-
-        Doctrine\Tests\Models\StockExchange\Market:
-          type: entity
-          id:
-            id:
-              type: integer
-              generator:
-                strategy: AUTO
-          fields:
-            name:
-              type:string
-          oneToMany:
-            stocks:
-              targetEntity: Stock
-              mappedBy: market
-              indexBy: symbol
-
 Inside the ``addStock()`` method you can see how we directly set the key of the association to the symbol,
 so that we can work with the indexed association directly after invoking ``addStock()``. Inside ``getStock($symbol)``
 we pick a stock traded on the particular market by symbol. If this stock doesn't exist an exception is thrown.
@@ -234,47 +146,6 @@ here are the code and mappings for it:
             }
         }
 
-    .. code-block:: annotation
-
-        <?php
-        namespace Doctrine\Tests\Models\StockExchange;
-
-        /**
-         * @Entity
-         * @Table(name="exchange_stocks")
-         */
-        class Stock
-        {
-            /**
-             * @Id @GeneratedValue @Column(type="integer")
-             * @var int
-             */
-            private int|null $id = null;
-
-            /**
-             * @Column(type="string", unique=true)
-             */
-            private string $symbol;
-
-            /**
-             * @ManyToOne(targetEntity="Market", inversedBy="stocks")
-             * @var Market
-             */
-            private Market|null $market = null;
-
-            public function __construct($symbol, Market $market)
-            {
-                $this->symbol = $symbol;
-                $this->market = $market;
-                $market->addStock($this);
-            }
-
-            public function getSymbol(): string
-            {
-                return $this->symbol;
-            }
-        }
-
     .. code-block:: xml
 
         <?xml version="1.0" encoding="UTF-8"?>
@@ -293,23 +164,6 @@ here are the code and mappings for it:
             </entity>
         </doctrine-mapping>
 
-    .. code-block:: yaml
-
-        Doctrine\Tests\Models\StockExchange\Stock:
-          type: entity
-          id:
-            id:
-              type: integer
-              generator:
-                strategy: AUTO
-          fields:
-            symbol:
-              type: string
-          manyToOne:
-            market:
-              targetEntity: Market
-              inversedBy: stocks
-
 Querying indexed associations
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

doctrine-mapping.xsd

@@ -35,7 +35,6 @@
     <xs:choice minOccurs="0" maxOccurs="unbounded">
       <xs:element name="cascade-all" type="orm:emptyType" minOccurs="0"/>
       <xs:element name="cascade-persist" type="orm:emptyType" minOccurs="0"/>
-      <xs:element name="cascade-merge" type="orm:emptyType" minOccurs="0"/>
       <xs:element name="cascade-remove" type="orm:emptyType" minOccurs="0"/>
       <xs:element name="cascade-refresh" type="orm:emptyType" minOccurs="0"/>
       <xs:element name="cascade-detach" type="orm:emptyType" minOccurs="0"/>
@@ -82,36 +81,6 @@
     <xs:anyAttribute namespace="##other"/>
   </xs:complexType>
 
-  <xs:complexType name="named-query">
-    <xs:attribute name="name" type="xs:string" use="required" />
-    <xs:attribute name="query" type="xs:string" use="required" />
-    <xs:anyAttribute namespace="##other"/>
-  </xs:complexType>
-
-  <xs:complexType name="named-queries">
-    <xs:sequence>
-      <xs:element name="named-query" type="orm:named-query" minOccurs="1" maxOccurs="unbounded" />
-      <xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
-    </xs:sequence>
-  </xs:complexType>
-
-  <xs:complexType name="named-native-query">
-    <xs:choice minOccurs="0" maxOccurs="unbounded">
-      <xs:element name="query" type="xs:string" minOccurs="1" maxOccurs="1"/>
-      <xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
-    </xs:choice>
-    <xs:attribute name="name" type="xs:string" use="required" />
-    <xs:attribute name="result-class" type="orm:fqcn" />
-    <xs:attribute name="result-set-mapping" type="xs:string" />
-  </xs:complexType>
-
-  <xs:complexType name="named-native-queries">
-    <xs:choice minOccurs="0" maxOccurs="unbounded">
-      <xs:element name="named-native-query" type="orm:named-native-query" minOccurs="1" maxOccurs="unbounded" />
-      <xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
-    </xs:choice>
-  </xs:complexType>
-
   <xs:complexType name="entity-listener">
     <xs:choice minOccurs="0" maxOccurs="unbounded">
       <xs:element name="lifecycle-callback" type="orm:lifecycle-callback" minOccurs="0" maxOccurs="unbounded"/>
@@ -143,23 +112,6 @@
     <xs:attribute name="discriminator-column" type="xs:string" use="optional" />
   </xs:complexType>
 
-  <xs:complexType name="sql-result-set-mapping">
-    <xs:choice minOccurs="0" maxOccurs="unbounded">
-        <xs:choice minOccurs="0" maxOccurs="unbounded">
-            <xs:element name="entity-result" type="orm:entity-result"/>
-            <xs:element name="column-result" type="orm:column-result"/>
-        </xs:choice>
-        <xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
-    </xs:choice>
-    <xs:attribute name="name" type="xs:string" use="required" />
-  </xs:complexType>
-
-  <xs:complexType name="sql-result-set-mappings">
-    <xs:choice minOccurs="0" maxOccurs="unbounded">
-      <xs:element name="sql-result-set-mapping" type="orm:sql-result-set-mapping" minOccurs="1" maxOccurs="unbounded" />
-    </xs:choice>
-  </xs:complexType>
-
   <xs:complexType name="cache">
     <xs:attribute name="usage" type="orm:cache-usage-type" />
     <xs:attribute name="region" type="xs:string" />
@@ -175,9 +127,6 @@
       <xs:element name="discriminator-map" type="orm:discriminator-map" minOccurs="0"/>
       <xs:element name="lifecycle-callbacks" type="orm:lifecycle-callbacks" minOccurs="0" maxOccurs="1" />
       <xs:element name="entity-listeners" type="orm:entity-listeners" minOccurs="0" maxOccurs="1" />
-      <xs:element name="named-queries" type="orm:named-queries" minOccurs="0" maxOccurs="1" />
-      <xs:element name="named-native-queries" type="orm:named-native-queries" minOccurs="0" maxOccurs="1" />
-      <xs:element name="sql-result-set-mappings" type="orm:sql-result-set-mappings" minOccurs="0" maxOccurs="unbounded" />
       <xs:element name="id" type="orm:id" minOccurs="0" maxOccurs="unbounded" />
       <xs:element name="field" type="orm:field" minOccurs="0" maxOccurs="unbounded"/>
       <xs:element name="embedded" type="orm:embedded" minOccurs="0" maxOccurs="unbounded"/>
@@ -239,7 +188,6 @@
     <xs:restriction base="xs:token">
       <xs:enumeration value="DEFERRED_IMPLICIT"/>
       <xs:enumeration value="DEFERRED_EXPLICIT"/>
-      <xs:enumeration value="NOTIFY"/>
     </xs:restriction>
   </xs:simpleType>
 
@@ -247,7 +195,6 @@
     <xs:restriction base="xs:token">
       <xs:enumeration value="SINGLE_TABLE"/>
       <xs:enumeration value="JOINED"/>
-      <xs:enumeration value="TABLE_PER_CLASS"/>
     </xs:restriction>
   </xs:simpleType>
 
@@ -257,7 +204,6 @@
       <xs:enumeration value="SEQUENCE"/>
       <xs:enumeration value="IDENTITY"/>
       <xs:enumeration value="AUTO"/>
-      <xs:enumeration value="UUID"/>
       <xs:enumeration value="CUSTOM" />
     </xs:restriction>
   </xs:simpleType>

lib/Doctrine/ORM/Cache.php

@@ -1,164 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Doctrine\ORM;
-
-use Doctrine\ORM\Cache\QueryCache;
-use Doctrine\ORM\Cache\Region;
-
-/**
- * Provides an API for querying/managing the second level cache regions.
- */
-interface Cache
-{
-    public const DEFAULT_QUERY_REGION_NAME = 'query_cache_region';
-
-    public const DEFAULT_TIMESTAMP_REGION_NAME = 'timestamp_cache_region';
-
-    /**
-     * May read items from the cache, but will not add items.
-     */
-    public const MODE_GET = 1;
-
-    /**
-     * Will never read items from the cache,
-     * but will add items to the cache as it reads them from the database.
-     */
-    public const MODE_PUT = 2;
-
-    /**
-     * May read items from the cache, and add items to the cache.
-     */
-    public const MODE_NORMAL = 3;
-
-    /**
-     * The query will never read items from the cache,
-     * but will refresh items to the cache as it reads them from the database.
-     */
-    public const MODE_REFRESH = 4;
-
-    /**
-     * @param string $className The entity class.
-     *
-     * @return Region|null
-     */
-    public function getEntityCacheRegion($className);
-
-    /**
-     * @param string $className   The entity class.
-     * @param string $association The field name that represents the association.
-     *
-     * @return Region|null
-     */
-    public function getCollectionCacheRegion($className, $association);
-
-    /**
-     * Determine whether the cache contains data for the given entity "instance".
-     *
-     * @param string $className  The entity class.
-     * @param mixed  $identifier The entity identifier
-     *
-     * @return bool true if the underlying cache contains corresponding data; false otherwise.
-     */
-    public function containsEntity($className, $identifier);
-
-    /**
-     * Evicts the entity data for a particular entity "instance".
-     *
-     * @param string $className  The entity class.
-     * @param mixed  $identifier The entity identifier.
-     *
-     * @return void
-     */
-    public function evictEntity($className, $identifier);
-
-    /**
-     * Evicts all entity data from the given region.
-     *
-     * @param string $className The entity metadata.
-     *
-     * @return void
-     */
-    public function evictEntityRegion($className);
-
-    /**
-     * Evict data from all entity regions.
-     *
-     * @return void
-     */
-    public function evictEntityRegions();
-
-    /**
-     * Determine whether the cache contains data for the given collection.
-     *
-     * @param string $className       The entity class.
-     * @param string $association     The field name that represents the association.
-     * @param mixed  $ownerIdentifier The identifier of the owning entity.
-     *
-     * @return bool true if the underlying cache contains corresponding data; false otherwise.
-     */
-    public function containsCollection($className, $association, $ownerIdentifier);
-
-    /**
-     * Evicts the cache data for the given identified collection instance.
-     *
-     * @param string $className       The entity class.
-     * @param string $association     The field name that represents the association.
-     * @param mixed  $ownerIdentifier The identifier of the owning entity.
-     *
-     * @return void
-     */
-    public function evictCollection($className, $association, $ownerIdentifier);
-
-    /**
-     * Evicts all entity data from the given region.
-     *
-     * @param string $className   The entity class.
-     * @param string $association The field name that represents the association.
-     *
-     * @return void
-     */
-    public function evictCollectionRegion($className, $association);
-
-    /**
-     * Evict data from all collection regions.
-     *
-     * @return void
-     */
-    public function evictCollectionRegions();
-
-    /**
-     * Determine whether the cache contains data for the given query.
-     *
-     * @param string $regionName The cache name given to the query.
-     *
-     * @return bool true if the underlying cache contains corresponding data; false otherwise.
-     */
-    public function containsQuery($regionName);
-
-    /**
-     * Evicts all cached query results under the given name, or default query cache if the region name is NULL.
-     *
-     * @param string|null $regionName The cache name associated to the queries being cached.
-     *
-     * @return void
-     */
-    public function evictQueryRegion($regionName = null);
-
-    /**
-     * Evict data from all query regions.
-     *
-     * @return void
-     */
-    public function evictQueryRegions();
-
-    /**
-     * Get query cache by region name or create a new one if none exist.
-     *
-     * @param string|null $regionName Query cache region name, or default query cache if the region name is NULL.
-     *
-     * @return QueryCache The Query Cache associated with the region name.
-     */
-    public function getQueryCache($regionName = null);
-}

lib/Doctrine/ORM/Cache/AssociationCacheEntry.php

@@ -1,53 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Doctrine\ORM\Cache;
-
-/**
- * Association cache entry
- */
-class AssociationCacheEntry implements CacheEntry
-{
-    /**
-     * The entity identifier
-     *
-     * @readonly Public only for performance reasons, it should be considered immutable.
-     * @var array<string, mixed>
-     */
-    public $identifier;
-
-    /**
-     * The entity class name
-     *
-     * @readonly Public only for performance reasons, it should be considered immutable.
-     * @var string
-     * @psalm-var class-string
-     */
-    public $class;
-
-    /**
-     * @param string               $class      The entity class.
-     * @param array<string, mixed> $identifier The entity identifier.
-     * @psalm-param class-string $class
-     */
-    public function __construct($class, array $identifier)
-    {
-        $this->class      = $class;
-        $this->identifier = $identifier;
-    }
-
-    /**
-     * Creates a new AssociationCacheEntry
-     *
-     * This method allow Doctrine\Common\Cache\PhpFileCache compatibility
-     *
-     * @param array<string, mixed> $values array containing property values
-     *
-     * @return AssociationCacheEntry
-     */
-    public static function __set_state(array $values)
-    {
-        return new self($values['class'], $values['identifier']);
-    }
-}

lib/Doctrine/ORM/Cache/CacheConfiguration.php

@@ -1,83 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Doctrine\ORM\Cache;
-
-use Doctrine\ORM\Cache\Logging\CacheLogger;
-
-/**
- * Configuration container for second-level cache.
- */
-class CacheConfiguration
-{
-    /** @var CacheFactory|null */
-    private $cacheFactory;
-
-    /** @var RegionsConfiguration|null */
-    private $regionsConfig;
-
-    /** @var CacheLogger|null */
-    private $cacheLogger;
-
-    /** @var QueryCacheValidator|null */
-    private $queryValidator;
-
-    /** @return CacheFactory|null */
-    public function getCacheFactory()
-    {
-        return $this->cacheFactory;
-    }
-
-    /** @return void */
-    public function setCacheFactory(CacheFactory $factory)
-    {
-        $this->cacheFactory = $factory;
-    }
-
-    /** @return CacheLogger|null */
-    public function getCacheLogger()
-    {
-         return $this->cacheLogger;
-    }
-
-    /** @return void */
-    public function setCacheLogger(CacheLogger $logger)
-    {
-        $this->cacheLogger = $logger;
-    }
-
-    /** @return RegionsConfiguration */
-    public function getRegionsConfiguration()
-    {
-        if ($this->regionsConfig === null) {
-            $this->regionsConfig = new RegionsConfiguration();
-        }
-
-        return $this->regionsConfig;
-    }
-
-    /** @return void */
-    public function setRegionsConfiguration(RegionsConfiguration $regionsConfig)
-    {
-        $this->regionsConfig = $regionsConfig;
-    }
-
-    /** @return QueryCacheValidator */
-    public function getQueryValidator()
-    {
-        if ($this->queryValidator === null) {
-            $this->queryValidator = new TimestampQueryCacheValidator(
-                $this->cacheFactory->getTimestampRegion()
-            );
-        }
-
-         return $this->queryValidator;
-    }
-
-    /** @return void */
-    public function setQueryValidator(QueryCacheValidator $validator)
-    {
-        $this->queryValidator = $validator;
-    }
-}

lib/Doctrine/ORM/Cache/CacheException.php

@@ -1,61 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Doctrine\ORM\Cache;
-
-use Doctrine\ORM\Exception\ORMException;
-
-use function sprintf;
-
-/**
- * Exception for cache.
- */
-class CacheException extends ORMException
-{
-    /**
-     * @param string $sourceEntity
-     * @param string $fieldName
-     *
-     * @return CacheException
-     */
-    public static function updateReadOnlyCollection($sourceEntity, $fieldName)
-    {
-        return new self(sprintf('Cannot update a readonly collection "%s#%s"', $sourceEntity, $fieldName));
-    }
-
-    /**
-     * @deprecated This method is not used anymore.
-     *
-     * @param string $entityName
-     *
-     * @return CacheException
-     */
-    public static function updateReadOnlyEntity($entityName)
-    {
-        return new self(sprintf('Cannot update a readonly entity "%s"', $entityName));
-    }
-
-    /**
-     * @param string $entityName
-     *
-     * @return CacheException
-     */
-    public static function nonCacheableEntity($entityName)
-    {
-        return new self(sprintf('Entity "%s" not configured as part of the second-level cache.', $entityName));
-    }
-
-    /**
-     * @deprecated This method is not used anymore.
-     *
-     * @param string $entityName
-     * @param string $field
-     *
-     * @return CacheException
-     */
-    public static function nonCacheableEntityAssociation($entityName, $field)
-    {
-        return new self(sprintf('Entity association field "%s#%s" not configured as part of the second-level cache.', $entityName, $field));
-    }
-}

lib/Doctrine/ORM/Cache/CacheFactory.php

@@ -1,89 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Doctrine\ORM\Cache;
-
-use Doctrine\ORM\Cache;
-use Doctrine\ORM\Cache\Persister\Collection\CachedCollectionPersister;
-use Doctrine\ORM\Cache\Persister\Entity\CachedEntityPersister;
-use Doctrine\ORM\EntityManagerInterface;
-use Doctrine\ORM\Mapping\ClassMetadata;
-use Doctrine\ORM\Persisters\Collection\CollectionPersister;
-use Doctrine\ORM\Persisters\Entity\EntityPersister;
-
-/**
- * Contract for building second level cache regions components.
- *
- * @psalm-import-type AssociationMapping from ClassMetadata
- */
-interface CacheFactory
-{
-    /**
-     * Build an entity persister for the given entity metadata.
-     *
-     * @param EntityManagerInterface $em        The entity manager.
-     * @param EntityPersister        $persister The entity persister that will be cached.
-     * @param ClassMetadata          $metadata  The entity metadata.
-     *
-     * @return CachedEntityPersister
-     */
-    public function buildCachedEntityPersister(EntityManagerInterface $em, EntityPersister $persister, ClassMetadata $metadata);
-
-    /**
-     * Build a collection persister for the given relation mapping.
-     *
-     * @param AssociationMapping $mapping The association mapping.
-     *
-     * @return CachedCollectionPersister
-     */
-    public function buildCachedCollectionPersister(EntityManagerInterface $em, CollectionPersister $persister, array $mapping);
-
-    /**
-     * Build a query cache based on the given region name
-     *
-     * @param string|null $regionName The region name.
-     *
-     * @return QueryCache The built query cache.
-     */
-    public function buildQueryCache(EntityManagerInterface $em, $regionName = null);
-
-    /**
-     * Build an entity hydrator
-     *
-     * @return EntityHydrator The built entity hydrator.
-     */
-    public function buildEntityHydrator(EntityManagerInterface $em, ClassMetadata $metadata);
-
-    /**
-     * Build a collection hydrator
-     *
-     * @param mixed[] $mapping The association mapping.
-     *
-     * @return CollectionHydrator The built collection hydrator.
-     */
-    public function buildCollectionHydrator(EntityManagerInterface $em, array $mapping);
-
-    /**
-     * Build a cache region
-     *
-     * @param array<string,mixed> $cache The cache configuration.
-     *
-     * @return Region The cache region.
-     */
-    public function getRegion(array $cache);
-
-    /**
-     * Build timestamp cache region
-     *
-     * @return TimestampRegion The timestamp region.
-     */
-    public function getTimestampRegion();
-
-    /**
-     * Build \Doctrine\ORM\Cache
-     *
-     * @return Cache
-     */
-    public function createCache(EntityManagerInterface $entityManager);
-}

lib/Doctrine/ORM/Cache/CacheKey.php

@@ -1,36 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Doctrine\ORM\Cache;
-
-use Doctrine\Deprecations\Deprecation;
-
-/**
- * Defines entity / collection / query key to be stored in the cache region.
- * Allows multiple roles to be stored in the same cache region.
- */
-abstract class CacheKey
-{
-    /**
-     * Unique identifier
-     *
-     * @readonly Public only for performance reasons, it should be considered immutable.
-     * @var string
-     */
-    public $hash;
-
-    public function __construct(?string $hash = null)
-    {
-        if ($hash === null) {
-            Deprecation::trigger(
-                'doctrine/orm',
-                'https://github.com/doctrine/orm/pull/10212',
-                'Calling %s() without providing a value for the $hash parameter is deprecated.',
-                __METHOD__
-            );
-        } else {
-            $this->hash = $hash;
-        }
-    }
-}

lib/Doctrine/ORM/Cache/CollectionCacheKey.php

@@ -1,58 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Doctrine\ORM\Cache;
-
-use function implode;
-use function ksort;
-use function str_replace;
-use function strtolower;
-
-/**
- * Defines entity collection roles to be stored in the cache region.
- */
-class CollectionCacheKey extends CacheKey
-{
-    /**
-     * The owner entity identifier
-     *
-     * @readonly Public only for performance reasons, it should be considered immutable.
-     * @var array<string, mixed>
-     */
-    public $ownerIdentifier;
-
-    /**
-     * The owner entity class
-     *
-     * @readonly Public only for performance reasons, it should be considered immutable.
-     * @var string
-     * @psalm-var class-string
-     */
-    public $entityClass;
-
-    /**
-     * The association name
-     *
-     * @readonly Public only for performance reasons, it should be considered immutable.
-     * @var string
-     */
-    public $association;
-
-    /**
-     * @param string               $entityClass     The entity class.
-     * @param string               $association     The field name that represents the association.
-     * @param array<string, mixed> $ownerIdentifier The identifier of the owning entity.
-     * @psalm-param class-string $entityClass
-     */
-    public function __construct($entityClass, $association, array $ownerIdentifier)
-    {
-        ksort($ownerIdentifier);
-
-        $this->ownerIdentifier = $ownerIdentifier;
-        $this->entityClass     = (string) $entityClass;
-        $this->association     = (string) $association;
-
-        parent::__construct(str_replace('\\', '.', strtolower($entityClass)) . '_' . implode(' ', $ownerIdentifier) . '__' . $association);
-    }
-}

lib/Doctrine/ORM/Cache/EntityCacheEntry.php

@@ -1,73 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Doctrine\ORM\Cache;
-
-use Doctrine\ORM\EntityManagerInterface;
-
-use function array_map;
-
-/**
- * Entity cache entry
- */
-class EntityCacheEntry implements CacheEntry
-{
-    /**
-     * The entity map data
-     *
-     * @readonly Public only for performance reasons, it should be considered immutable.
-     * @var array<string,mixed>
-     */
-    public $data;
-
-    /**
-     * The entity class name
-     *
-     * @readonly Public only for performance reasons, it should be considered immutable.
-     * @var string
-     * @psalm-var class-string
-     */
-    public $class;
-
-    /**
-     * @param string              $class The entity class.
-     * @param array<string,mixed> $data  The entity data.
-     * @psalm-param class-string $class
-     */
-    public function __construct($class, array $data)
-    {
-        $this->class = $class;
-        $this->data  = $data;
-    }
-
-    /**
-     * Creates a new EntityCacheEntry
-     *
-     * This method allow Doctrine\Common\Cache\PhpFileCache compatibility
-     *
-     * @param array<string,mixed> $values array containing property values
-     *
-     * @return EntityCacheEntry
-     */
-    public static function __set_state(array $values)
-    {
-        return new self($values['class'], $values['data']);
-    }
-
-    /**
-     * Retrieves the entity data resolving cache entries
-     *
-     * @return array<string, mixed>
-     */
-    public function resolveAssociationEntries(EntityManagerInterface $em)
-    {
-        return array_map(static function ($value) use ($em) {
-            if (! ($value instanceof AssociationCacheEntry)) {
-                return $value;
-            }
-
-            return $em->getReference($value->class, $value->identifier);
-        }, $this->data);
-    }
-}

lib/Doctrine/ORM/Cache/Exception/InvalidResultCacheDriver.php

@@ -1,16 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Doctrine\ORM\Cache\Exception;
-
-/** @deprecated */
-final class InvalidResultCacheDriver extends CacheException
-{
-    public static function create(): self
-    {
-        return new self(
-            'Invalid result cache driver; it must implement Doctrine\\Common\\Cache\\Cache.'
-        );
-    }
-}

lib/Doctrine/ORM/Cache/Exception/MetadataCacheNotConfigured.php

@@ -1,13 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Doctrine\ORM\Cache\Exception;
-
-final class MetadataCacheNotConfigured extends CacheException
-{
-    public static function create(): self
-    {
-        return new self('Class Metadata Cache is not configured.');
-    }
-}

lib/Doctrine/ORM/Cache/Exception/MetadataCacheUsesNonPersistentCache.php

@@ -1,19 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Doctrine\ORM\Cache\Exception;
-
-use Doctrine\Common\Cache\Cache;
-
-use function get_debug_type;
-
-final class MetadataCacheUsesNonPersistentCache extends CacheException
-{
-    public static function fromDriver(Cache $cache): self
-    {
-        return new self(
-            'Metadata Cache uses a non-persistent cache driver, ' . get_debug_type($cache) . '.'
-        );
-    }
-}

lib/Doctrine/ORM/Cache/Exception/QueryCacheNotConfigured.php

@@ -1,13 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Doctrine\ORM\Cache\Exception;
-
-final class QueryCacheNotConfigured extends CacheException
-{
-    public static function create(): self
-    {
-        return new self('Query Cache is not configured.');
-    }
-}

lib/Doctrine/ORM/Cache/Exception/QueryCacheUsesNonPersistentCache.php

@@ -1,19 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Doctrine\ORM\Cache\Exception;
-
-use Doctrine\Common\Cache\Cache;
-
-use function get_debug_type;
-
-final class QueryCacheUsesNonPersistentCache extends CacheException
-{
-    public static function fromDriver(Cache $cache): self
-    {
-        return new self(
-            'Query Cache uses a non-persistent cache driver, ' . get_debug_type($cache) . '.'
-        );
-    }
-}

lib/Doctrine/ORM/Cache/Lock.php

@@ -1,29 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Doctrine\ORM\Cache;
-
-use function time;
-use function uniqid;
-
-class Lock
-{
-    /** @var string */
-    public $value;
-
-    /** @var int */
-    public $time;
-
-    public function __construct(string $value, ?int $time = null)
-    {
-        $this->value = $value;
-        $this->time  = $time ?: time();
-    }
-
-    /** @return Lock */
-    public static function createLockRead()
-    {
-        return new self(uniqid((string) time(), true));
-    }
-}

lib/Doctrine/ORM/Cache/Logging/CacheLogger.php

@@ -1,105 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Doctrine\ORM\Cache\Logging;
-
-use Doctrine\ORM\Cache\CollectionCacheKey;
-use Doctrine\ORM\Cache\EntityCacheKey;
-use Doctrine\ORM\Cache\QueryCacheKey;
-
-/**
- * Interface for logging.
- */
-interface CacheLogger
-{
-    /**
-     * Log an entity put into second level cache.
-     *
-     * @param string         $regionName The name of the cache region.
-     * @param EntityCacheKey $key        The cache key of the entity.
-     *
-     * @return void
-     */
-    public function entityCachePut($regionName, EntityCacheKey $key);
-
-    /**
-     * Log an entity get from second level cache resulted in a hit.
-     *
-     * @param string         $regionName The name of the cache region.
-     * @param EntityCacheKey $key        The cache key of the entity.
-     *
-     * @return void
-     */
-    public function entityCacheHit($regionName, EntityCacheKey $key);
-
-    /**
-     * Log an entity get from second level cache resulted in a miss.
-     *
-     * @param string         $regionName The name of the cache region.
-     * @param EntityCacheKey $key        The cache key of the entity.
-     *
-     * @return void
-     */
-    public function entityCacheMiss($regionName, EntityCacheKey $key);
-
-    /**
-     * Log an entity put into second level cache.
-     *
-     * @param string             $regionName The name of the cache region.
-     * @param CollectionCacheKey $key        The cache key of the collection.
-     *
-     * @return void
-     */
-    public function collectionCachePut($regionName, CollectionCacheKey $key);
-
-    /**
-     * Log an entity get from second level cache resulted in a hit.
-     *
-     * @param string             $regionName The name of the cache region.
-     * @param CollectionCacheKey $key        The cache key of the collection.
-     *
-     * @return void
-     */
-    public function collectionCacheHit($regionName, CollectionCacheKey $key);
-
-    /**
-     * Log an entity get from second level cache resulted in a miss.
-     *
-     * @param string             $regionName The name of the cache region.
-     * @param CollectionCacheKey $key        The cache key of the collection.
-     *
-     * @return void
-     */
-    public function collectionCacheMiss($regionName, CollectionCacheKey $key);
-
-    /**
-     * Log a query put into the query cache.
-     *
-     * @param string        $regionName The name of the cache region.
-     * @param QueryCacheKey $key        The cache key of the query.
-     *
-     * @return void
-     */
-    public function queryCachePut($regionName, QueryCacheKey $key);
-
-    /**
-     * Log a query get from the query cache resulted in a hit.
-     *
-     * @param string        $regionName The name of the cache region.
-     * @param QueryCacheKey $key        The cache key of the query.
-     *
-     * @return void
-     */
-    public function queryCacheHit($regionName, QueryCacheKey $key);
-
-    /**
-     * Log a query get from the query cache resulted in a miss.
-     *
-     * @param string        $regionName The name of the cache region.
-     * @param QueryCacheKey $key        The cache key of the query.
-     *
-     * @return void
-     */
-    public function queryCacheMiss($regionName, QueryCacheKey $key);
-}

lib/Doctrine/ORM/Cache/MultiGetRegion.php

@@ -1,25 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Doctrine\ORM\Cache;
-
-/**
- * Defines a region that supports multi-get reading.
- *
- * With one method call we can get multiple items.
- *
- * @deprecated Implement {@see Region} instead.
- */
-interface MultiGetRegion
-{
-    /**
-     * Get all items from the cache identified by $keys.
-     * It returns NULL if some elements can not be found.
-     *
-     * @param CollectionCacheEntry $collection The collection of the items to be retrieved.
-     *
-     * @return CacheEntry[]|null The cached entries or NULL if one or more entries can not be found
-     */
-    public function getMultiple(CollectionCacheEntry $collection);
-}

lib/Doctrine/ORM/Cache/QueryCacheEntry.php

@@ -1,49 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Doctrine\ORM\Cache;
-
-use function microtime;
-
-/**
- * Query cache entry
- */
-class QueryCacheEntry implements CacheEntry
-{
-    /**
-     * List of entity identifiers
-     *
-     * @readonly Public only for performance reasons, it should be considered immutable.
-     * @var array<string, mixed>
-     */
-    public $result;
-
-    /**
-     * Time creation of this cache entry
-     *
-     * @readonly Public only for performance reasons, it should be considered immutable.
-     * @var float
-     */
-    public $time;
-
-    /**
-     * @param array<string, mixed> $result
-     * @param float|null           $time
-     */
-    public function __construct($result, $time = null)
-    {
-        $this->result = $result;
-        $this->time   = $time ?: microtime(true);
-    }
-
-    /**
-     * @param array<string, mixed> $values
-     *
-     * @return QueryCacheEntry
-     */
-    public static function __set_state(array $values)
-    {
-        return new self($values['result'], $values['time']);
-    }
-}

lib/Doctrine/ORM/Cache/QueryCacheKey.php

@@ -1,50 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Doctrine\ORM\Cache;
-
-use Doctrine\ORM\Cache;
-
-/**
- * A cache key that identifies a particular query.
- */
-class QueryCacheKey extends CacheKey
-{
-    /**
-     * Cache key lifetime
-     *
-     * @readonly Public only for performance reasons, it should be considered immutable.
-     * @var int
-     */
-    public $lifetime;
-
-    /**
-     * Cache mode
-     *
-     * @readonly Public only for performance reasons, it should be considered immutable.
-     * @var int
-     * @psalm-var Cache::MODE_*
-     */
-    public $cacheMode;
-
-    /**
-     * @readonly Public only for performance reasons, it should be considered immutable.
-     * @var TimestampCacheKey|null
-     */
-    public $timestampKey;
-
-    /** @psalm-param Cache::MODE_* $cacheMode */
-    public function __construct(
-        string $cacheId,
-        int $lifetime = 0,
-        int $cacheMode = Cache::MODE_NORMAL,
-        ?TimestampCacheKey $timestampKey = null
-    ) {
-        $this->lifetime     = $lifetime;
-        $this->cacheMode    = $cacheMode;
-        $this->timestampKey = $timestampKey;
-
-        parent::__construct($cacheId);
-    }
-}

lib/Doctrine/ORM/Cache/Region/DefaultMultiGetRegion.php

@@ -1,14 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Doctrine\ORM\Cache\Region;
-
-/**
- * A cache region that enables the retrieval of multiple elements with one call
- *
- * @deprecated Use {@link DefaultRegion} instead.
- */
-class DefaultMultiGetRegion extends DefaultRegion
-{
-}

lib/Doctrine/ORM/Cache/Region/DefaultRegion.php

@@ -1,213 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Doctrine\ORM\Cache\Region;
-
-use Closure;
-use Doctrine\Common\Cache\Cache as LegacyCache;
-use Doctrine\Common\Cache\CacheProvider;
-use Doctrine\Common\Cache\Psr6\CacheAdapter;
-use Doctrine\Common\Cache\Psr6\DoctrineProvider;
-use Doctrine\Deprecations\Deprecation;
-use Doctrine\ORM\Cache\CacheEntry;
-use Doctrine\ORM\Cache\CacheKey;
-use Doctrine\ORM\Cache\CollectionCacheEntry;
-use Doctrine\ORM\Cache\Lock;
-use Doctrine\ORM\Cache\Region;
-use Psr\Cache\CacheItemInterface;
-use Psr\Cache\CacheItemPoolInterface;
-use Traversable;
-use TypeError;
-
-use function array_map;
-use function get_debug_type;
-use function iterator_to_array;
-use function sprintf;
-use function strtr;
-
-/**
- * The simplest cache region compatible with all doctrine-cache drivers.
- */
-class DefaultRegion implements Region
-{
-    /** @internal since 2.11, this constant will be private in 3.0. */
-    public const REGION_KEY_SEPARATOR = '_';
-    private const REGION_PREFIX       = 'DC2_REGION_';
-
-    /**
-     * @deprecated since 2.11, this property will be removed in 3.0.
-     *
-     * @var LegacyCache
-     */
-    protected $cache;
-
-    /**
-     * @internal since 2.11, this property will be private in 3.0.
-     *
-     * @var string
-     */
-    protected $name;
-
-    /**
-     * @internal since 2.11, this property will be private in 3.0.
-     *
-     * @var int
-     */
-    protected $lifetime = 0;
-
-    /** @var CacheItemPoolInterface */
-    private $cacheItemPool;
-
-    /** @param CacheItemPoolInterface $cacheItemPool */
-    public function __construct(string $name, $cacheItemPool, int $lifetime = 0)
-    {
-        if ($cacheItemPool instanceof LegacyCache) {
-            Deprecation::trigger(
-                'doctrine/orm',
-                'https://github.com/doctrine/orm/pull/9322',
-                'Passing an instance of %s to %s is deprecated, pass a %s instead.',
-                get_debug_type($cacheItemPool),
-                __METHOD__,
-                CacheItemPoolInterface::class
-            );
-
-            $this->cache         = $cacheItemPool;
-            $this->cacheItemPool = CacheAdapter::wrap($cacheItemPool);
-        } elseif (! $cacheItemPool instanceof CacheItemPoolInterface) {
-            throw new TypeError(sprintf(
-                '%s: Parameter #2 is expected to be an instance of %s, got %s.',
-                __METHOD__,
-                CacheItemPoolInterface::class,
-                get_debug_type($cacheItemPool)
-            ));
-        } else {
-            $this->cache         = DoctrineProvider::wrap($cacheItemPool);
-            $this->cacheItemPool = $cacheItemPool;
-        }
-
-        $this->name     = $name;
-        $this->lifetime = $lifetime;
-    }
-
-    /**
-     * {@inheritDoc}
-     */
-    public function getName()
-    {
-        return $this->name;
-    }
-
-    /**
-     * @deprecated
-     *
-     * @return CacheProvider
-     */
-    public function getCache()
-    {
-        return $this->cache;
-    }
-
-    /**
-     * {@inheritDoc}
-     */
-    public function contains(CacheKey $key)
-    {
-        return $this->cacheItemPool->hasItem($this->getCacheEntryKey($key));
-    }
-
-    /**
-     * {@inheritDoc}
-     */
-    public function get(CacheKey $key)
-    {
-        $item  = $this->cacheItemPool->getItem($this->getCacheEntryKey($key));
-        $entry = $item->isHit() ? $item->get() : null;
-
-        if (! $entry instanceof CacheEntry) {
-            return null;
-        }
-
-        return $entry;
-    }
-
-    /**
-     * {@inheritDoc}
-     */
-    public function getMultiple(CollectionCacheEntry $collection)
-    {
-        $keys = array_map(
-            Closure::fromCallable([$this, 'getCacheEntryKey']),
-            $collection->identifiers
-        );
-        /** @var iterable<string, CacheItemInterface> $items */
-        $items = $this->cacheItemPool->getItems($keys);
-        if ($items instanceof Traversable) {
-            $items = iterator_to_array($items);
-        }
-
-        $result = [];
-        foreach ($keys as $arrayKey => $cacheKey) {
-            if (! isset($items[$cacheKey]) || ! $items[$cacheKey]->isHit()) {
-                return null;
-            }
-
-            $entry = $items[$cacheKey]->get();
-            if (! $entry instanceof CacheEntry) {
-                return null;
-            }
-
-            $result[$arrayKey] = $entry;
-        }
-
-        return $result;
-    }
-
-    /**
-     * {@inheritDoc}
-     *
-     * @return bool
-     */
-    public function put(CacheKey $key, CacheEntry $entry, ?Lock $lock = null)
-    {
-        $item = $this->cacheItemPool
-            ->getItem($this->getCacheEntryKey($key))
-            ->set($entry);
-
-        if ($this->lifetime > 0) {
-            $item->expiresAfter($this->lifetime);
-        }
-
-        return $this->cacheItemPool->save($item);
-    }
-
-    /**
-     * {@inheritDoc}
-     *
-     * @return bool
-     */
-    public function evict(CacheKey $key)
-    {
-        return $this->cacheItemPool->deleteItem($this->getCacheEntryKey($key));
-    }
-
-    /**
-     * {@inheritDoc}
-     *
-     * @return bool
-     */
-    public function evictAll()
-    {
-        return $this->cacheItemPool->clear(self::REGION_PREFIX . $this->name);
-    }
-
-    /**
-     * @internal since 2.11, this method will be private in 3.0.
-     *
-     * @return string
-     */
-    protected function getCacheEntryKey(CacheKey $key)
-    {
-        return self::REGION_PREFIX . $this->name . self::REGION_KEY_SEPARATOR . strtr($key->hash, '{}()/\@:', '________');
-    }
-}

lib/Doctrine/ORM/Cache/RegionsConfiguration.php

@@ -1,107 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Doctrine\ORM\Cache;
-
-/**
- * Cache regions configuration
- */
-class RegionsConfiguration
-{
-    /** @var array<string,int> */
-    private $lifetimes = [];
-
-    /** @var array<string,int> */
-    private $lockLifetimes = [];
-
-    /** @var int */
-    private $defaultLifetime;
-
-    /** @var int */
-    private $defaultLockLifetime;
-
-    /**
-     * @param int $defaultLifetime
-     * @param int $defaultLockLifetime
-     */
-    public function __construct($defaultLifetime = 3600, $defaultLockLifetime = 60)
-    {
-        $this->defaultLifetime     = (int) $defaultLifetime;
-        $this->defaultLockLifetime = (int) $defaultLockLifetime;
-    }
-
-    /** @return int */
-    public function getDefaultLifetime()
-    {
-        return $this->defaultLifetime;
-    }
-
-    /**
-     * @param int $defaultLifetime
-     *
-     * @return void
-     */
-    public function setDefaultLifetime($defaultLifetime)
-    {
-        $this->defaultLifetime = (int) $defaultLifetime;
-    }
-
-    /** @return int */
-    public function getDefaultLockLifetime()
-    {
-        return $this->defaultLockLifetime;
-    }
-
-    /**
-     * @param int $defaultLockLifetime
-     *
-     * @return void
-     */
-    public function setDefaultLockLifetime($defaultLockLifetime)
-    {
-        $this->defaultLockLifetime = (int) $defaultLockLifetime;
-    }
-
-    /**
-     * @param string $regionName
-     *
-     * @return int
-     */
-    public function getLifetime($regionName)
-    {
-        return $this->lifetimes[$regionName] ?? $this->defaultLifetime;
-    }
-
-    /**
-     * @param string $name
-     * @param int    $lifetime
-     *
-     * @return void
-     */
-    public function setLifetime($name, $lifetime)
-    {
-        $this->lifetimes[$name] = (int) $lifetime;
-    }
-
-    /**
-     * @param string $regionName
-     *
-     * @return int
-     */
-    public function getLockLifetime($regionName)
-    {
-        return $this->lockLifetimes[$regionName] ?? $this->defaultLockLifetime;
-    }
-
-    /**
-     * @param string $name
-     * @param int    $lifetime
-     *
-     * @return void
-     */
-    public function setLockLifetime($name, $lifetime)
-    {
-        $this->lockLifetimes[$name] = (int) $lifetime;
-    }
-}