Fix BIGINT validation (#11414)

* Improve getClassMetadata phpdoc

* Update baseline

.doctrine-project.json

@@ -5,23 +5,47 @@
     "slug": "orm",
     "docsSlug": "doctrine-orm",
     "versions": [
+        {
+            "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": "latest",
+            "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",
-            "upcoming": true
+            "maintained": true
         },
         {
             "name": "2.18",
             "branchName": "2.18.x",
             "slug": "2.18",
-            "current": true
+            "maintained": false
         },
         {
             "name": "2.17",

.github/workflows/continuous-integration.yml

@@ -97,9 +97,9 @@ jobs:
             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.proxy }}-coverage"
           path: "coverage*.xml"
 
 
@@ -170,9 +170,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"
 
 
@@ -240,7 +240,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"
@@ -317,7 +317,7 @@ 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"
@@ -372,7 +372,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,5 +40,10 @@ jobs:
         with:
           dependency-versions: "highest"
 
+      - name: "Add orphan metadata where needed"
+        run: |
+          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 'No template found for rendering directive' | ( ! grep WARNING )"

.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

@@ -48,7 +48,7 @@ jobs:
         uses: "shivammathur/setup-php@v2"
         with:
           coverage: "none"
-          php-version: "8.2"
+          php-version: "8.3"
 
       - name: "Require specific DBAL version"
         run: "composer require doctrine/dbal ^${{ matrix.dbal-version }} --no-update"
@@ -89,7 +89,7 @@ jobs:
         uses: "shivammathur/setup-php@v2"
         with:
           coverage: "none"
-          php-version: "8.2"
+          php-version: "8.3"
 
       - name: "Require specific persistence version"
         run: "composer require doctrine/persistence ^3.1 --no-update"

README.md

@@ -1,7 +1,7 @@
-|                      [4.0.x][4.0]                      |                      [3.1.x][3.1]                      |                      [3.0.x][3.0]                       |                      [2.19.x][2.19]                      |                      [2.18.x][2.18]                       |
-|:------------------------------------------------------:|:------------------------------------------------------:|:-------------------------------------------------------:|:--------------------------------------------------------:|:---------------------------------------------------------:|
-|           [![Build status][4.0 image]][4.0]            |           [![Build status][3.1 image]][3.1]            |            [![Build status][3.0 image]][3.0]            |           [![Build status][2.19 image]][2.19]            |            [![Build status][2.18 image]][2.18]            |
-| [![Coverage Status][4.0 coverage image]][4.0 coverage] | [![Coverage Status][3.1 coverage image]][3.1 coverage] | [![Coverage Status][3.0 coverage image]][3.0 coverage]  | [![Coverage Status][2.19 coverage image]][2.19 coverage] | [![Coverage Status][2.18 coverage image]][2.18 coverage]  |
+|                      [4.0.x][4.0]                      |                      [3.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)
 
@@ -22,19 +22,19 @@ without requiring unnecessary code duplication.
   [4.0]: https://github.com/doctrine/orm/tree/4.0.x
   [4.0 coverage image]: https://codecov.io/gh/doctrine/orm/branch/4.0.x/graph/badge.svg
   [4.0 coverage]: https://codecov.io/gh/doctrine/orm/branch/4.0.x
+  [3.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
-  [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.20 image]: https://github.com/doctrine/orm/actions/workflows/continuous-integration.yml/badge.svg?branch=2.20.x
+  [2.20]: https://github.com/doctrine/orm/tree/2.20.x
+  [2.20 coverage image]: https://codecov.io/gh/doctrine/orm/branch/2.20.x/graph/badge.svg
+  [2.20 coverage]: https://codecov.io/gh/doctrine/orm/branch/2.20.x
   [2.19 image]: https://github.com/doctrine/orm/actions/workflows/continuous-integration.yml/badge.svg?branch=2.19.x
   [2.19]: https://github.com/doctrine/orm/tree/2.19.x
   [2.19 coverage image]: https://codecov.io/gh/doctrine/orm/branch/2.19.x/graph/badge.svg
   [2.19 coverage]: https://codecov.io/gh/doctrine/orm/branch/2.19.x
-  [2.18 image]: https://github.com/doctrine/orm/actions/workflows/continuous-integration.yml/badge.svg?branch=2.18.x
-  [2.18]: https://github.com/doctrine/orm/tree/2.18.x
-  [2.18 coverage image]: https://codecov.io/gh/doctrine/orm/branch/2.18.x/graph/badge.svg
-  [2.18 coverage]: https://codecov.io/gh/doctrine/orm/branch/2.18.x

UPGRADE.md

@@ -1,3 +1,20 @@
+# 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

docs/.gitignore

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

docs/.gitmodules

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

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

@@ -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/reference/basic-mapping.rst

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

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

@@ -812,7 +812,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 +827,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 +1003,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 +1020,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 +1263,6 @@ will return the rows iterating the different top-level entities.
         [2] => Object (User)
         [3] => Object (Group)
 
-
-Hydration Modes
-~~~~~~~~~~~~~~~
-
-Each of the Hydration Modes makes assumptions about how the result
-is returned to user land. You should know about all the details to
-make best use of the different result formats:
-
-The constants for the different hydration modes are:
-
-
--  ``Query::HYDRATE_OBJECT``
--  ``Query::HYDRATE_ARRAY``
--  ``Query::HYDRATE_SCALAR``
--  ``Query::HYDRATE_SINGLE_SCALAR``
--  ``Query::HYDRATE_SCALAR_COLUMN``
-
-Object Hydration
-^^^^^^^^^^^^^^^^
-
-Object hydration hydrates the result set into the object graph:
-
-.. code-block:: php
-
-    <?php
-    $query = $em->createQuery('SELECT u FROM CmsUser u');
-    $users = $query->getResult(Query::HYDRATE_OBJECT);
-
-Sometimes the behavior in the object hydrator can be confusing, which is
-why we are listing as many of the assumptions here for reference:
-
-- Objects fetched in a FROM clause are returned as a Set, that means every
-  object is only ever included in the resulting array once. This is the case
-  even when using JOIN or GROUP BY in ways that return the same row for an
-  object multiple times. If the hydrator sees the same object multiple times,
-  then it makes sure it is only returned once.
-
-- If an object is already in memory from a previous query of any kind, then
-  then the previous object is used, even if the database may contain more
-  recent data. Data from the database is discarded. This even happens if the
-  previous object is still an unloaded proxy.
-
-This list might be incomplete.
-
-Array Hydration
-^^^^^^^^^^^^^^^
-
-You can run the same query with array hydration and the result set
-is hydrated into an array that represents the object graph:
-
-.. code-block:: php
-
-    <?php
-    $query = $em->createQuery('SELECT u FROM CmsUser u');
-    $users = $query->getResult(Query::HYDRATE_ARRAY);
-
-You can use the ``getArrayResult()`` shortcut as well:
-
-.. code-block:: php
-
-    <?php
-    $users = $query->getArrayResult();
-
-Scalar Hydration
-^^^^^^^^^^^^^^^^
-
-If you want to return a flat rectangular result set instead of an
-object graph you can use scalar hydration:
-
-.. code-block:: php
-
-    <?php
-    $query = $em->createQuery('SELECT u FROM CmsUser u');
-    $users = $query->getResult(Query::HYDRATE_SCALAR);
-    echo $users[0]['u_id'];
-
-The following assumptions are made about selected fields using
-Scalar Hydration:
-
-
-1. Fields from classes are prefixed by the DQL alias in the result.
-   A query of the kind 'SELECT u.name ..' returns a key 'u_name' in
-   the result rows.
-
-Single Scalar Hydration
-^^^^^^^^^^^^^^^^^^^^^^^
-
-If you have a query which returns just a single scalar value you can use
-single scalar hydration:
-
-.. code-block:: php
-
-    <?php
-    $query = $em->createQuery('SELECT COUNT(a.id) FROM CmsUser u LEFT JOIN u.articles a WHERE u.username = ?1 GROUP BY u.id');
-    $query->setParameter(1, 'jwage');
-    $numArticles = $query->getResult(Query::HYDRATE_SINGLE_SCALAR);
-
-You can use the ``getSingleScalarResult()`` shortcut as well:
-
-.. code-block:: php
-
-    <?php
-    $numArticles = $query->getSingleScalarResult();
-
-Scalar Column Hydration
-^^^^^^^^^^^^^^^^^^^^^^^
-
-If you have a query which returns a one-dimensional array of scalar values
-you can use scalar column hydration:
-
-.. code-block:: php
-
-    <?php
-    $query = $em->createQuery('SELECT a.id FROM CmsUser u');
-    $ids = $query->getResult(Query::HYDRATE_SCALAR_COLUMN);
-
-You can use the ``getSingleColumnResult()`` shortcut as well:
-
-.. code-block:: php
-
-    <?php
-    $ids = $query->getSingleColumnResult();
-
-Custom Hydration Modes
-^^^^^^^^^^^^^^^^^^^^^^
-
-You can easily add your own custom hydration modes by first
-creating a class which extends ``AbstractHydrator``:
-
-.. code-block:: php
-
-    <?php
-    namespace MyProject\Hydrators;
-
-    use Doctrine\ORM\Internal\Hydration\AbstractHydrator;
-
-    class CustomHydrator extends AbstractHydrator
-    {
-        protected function _hydrateAll()
-        {
-            return $this->_stmt->fetchAllAssociative();
-        }
-    }
-
-Next you just need to add the class to the ORM configuration:
-
-.. code-block:: php
-
-    <?php
-    $em->getConfiguration()->addCustomHydrationMode('CustomHydrator', 'MyProject\Hydrators\CustomHydrator');
-
-Now the hydrator is ready to be used in your queries:
-
-.. code-block:: php
-
-    <?php
-    $query = $em->createQuery('SELECT u FROM CmsUser u');
-    $results = $query->getResult('CustomHydrator');
-
 Iterating Large Result Sets
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

docs/en/reference/installation.rst

@@ -1,5 +1,3 @@
-:orphan:
-
 Installation
 ============
 

docs/en/sidebar.rst

@@ -1,5 +1,3 @@
-:orphan:
-
 .. toc::
 
    .. tocheader:: Tutorials

phpstan-baseline.neon

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

psalm-baseline.xml

@@ -257,12 +257,6 @@
       <code><![CDATA[transactional]]></code>
       <code><![CDATA[transactional]]></code>
     </DeprecatedMethod>
-    <InvalidReturnStatement>
-      <code><![CDATA[$this->wrapped->getClassMetadata($className)]]></code>
-    </InvalidReturnStatement>
-    <InvalidReturnType>
-      <code><![CDATA[getClassMetadata]]></code>
-    </InvalidReturnType>
     <MissingParamType>
       <code><![CDATA[$entity]]></code>
       <code><![CDATA[$lockMode]]></code>
@@ -309,11 +303,9 @@
       <code><![CDATA[$entity instanceof $class->name ? $entity : null]]></code>
       <code><![CDATA[$persister->load($sortedId, null, null, [], $lockMode)]]></code>
       <code><![CDATA[$persister->loadById($sortedId)]]></code>
-      <code><![CDATA[$this->metadataFactory->getMetadataFor($className)]]></code>
     </InvalidReturnStatement>
     <InvalidReturnType>
       <code><![CDATA[?T]]></code>
-      <code><![CDATA[getClassMetadata]]></code>
     </InvalidReturnType>
     <MissingReturnType>
       <code><![CDATA[wrapInTransaction]]></code>
@@ -462,9 +454,6 @@
     </RedundantConditionGivenDocblockType>
   </file>
   <file src="src/Internal/Hydration/ObjectHydrator.php">
-    <InvalidArgument>
-      <code><![CDATA[$element]]></code>
-    </InvalidArgument>
     <PossiblyFalseArgument>
       <code><![CDATA[$index]]></code>
     </PossiblyFalseArgument>
@@ -1492,6 +1481,7 @@
       <code><![CDATA[getValue]]></code>
       <code><![CDATA[setAccessible]]></code>
       <code><![CDATA[setValue]]></code>
+      <code><![CDATA[setValue]]></code>
     </PossiblyNullReference>
     <TypeDoesNotContainType>
       <code><![CDATA[$autoGenerate < 0]]></code>
@@ -1501,13 +1491,8 @@
       <code><![CDATA[__wakeup]]></code>
     </UndefinedInterfaceMethod>
     <UndefinedMethod>
-      <code><![CDATA[self::createLazyGhost(static function (InternalProxy $object) use ($initializer, &$proxy): void {
-                $initializer($object, $proxy);
-            }, $skippedProperties)]]></code>
+      <code><![CDATA[self::createLazyGhost($initializer, $skippedProperties)]]></code>
     </UndefinedMethod>
-    <UndefinedVariable>
-      <code><![CDATA[$proxy]]></code>
-    </UndefinedVariable>
     <UnresolvableInclude>
       <code><![CDATA[require $fileName]]></code>
     </UnresolvableInclude>
@@ -2108,7 +2093,7 @@
     </PossiblyUndefinedVariable>
     <RedundantConditionGivenDocblockType>
       <code><![CDATA[$AST instanceof AST\SelectStatement]]></code>
-      <code><![CDATA[$token === Lexer::T_IDENTIFIER]]></code>
+      <code><![CDATA[$token === TokenType::T_IDENTIFIER]]></code>
     </RedundantConditionGivenDocblockType>
   </file>
   <file src="src/Query/ParserResult.php">

src/EntityManagerInterface.php

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

src/LazyCriteriaCollection.php

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

src/Mapping/ClassMetadataInfo.php

@@ -3681,6 +3681,17 @@ class ClassMetadataInfo implements ClassMetadata
      */
     public function getAssociationMappedByTargetField($fieldName)
     {
+        if (! $this->isAssociationInverseSide($fieldName)) {
+            Deprecation::trigger(
+                'doctrine/orm',
+                'https://github.com/doctrine/orm/pull/11309',
+                'Calling %s with owning side field %s is deprecated and will no longer be supported in Doctrine ORM 3.0. Call %s::isAssociationInverseSide() to check first.',
+                __METHOD__,
+                $fieldName,
+                self::class
+            );
+        }
+
         return $this->associationMappings[$fieldName]['mappedBy'];
     }
 

src/PersistentCollection.php

@@ -412,11 +412,6 @@ final class PersistentCollection extends AbstractLazyCollection implements Selec
         return parent::containsKey($key);
     }
 
-    /**
-     * {@inheritDoc}
-     *
-     * @template TMaybeContained
-     */
     public function contains($element): bool
     {
         if (! $this->initialized && $this->getMapping()['fetch'] === ClassMetadata::FETCH_EXTRA_LAZY) {

src/Proxy/ProxyFactory.php

@@ -360,11 +360,11 @@ EOPHP;
      */
     private function createLazyInitializer(ClassMetadata $classMetadata, EntityPersister $entityPersister, IdentifierFlattener $identifierFlattener): Closure
     {
-        return static function (InternalProxy $proxy, InternalProxy $original) use ($entityPersister, $classMetadata, $identifierFlattener): void {
-            $identifier = $classMetadata->getIdentifierValues($original);
-            $entity     = $entityPersister->loadById($identifier, $original);
+        return static function (InternalProxy $proxy) use ($entityPersister, $classMetadata, $identifierFlattener): void {
+            $identifier = $classMetadata->getIdentifierValues($proxy);
+            $original   = $entityPersister->loadById($identifier);
 
-            if ($entity === null) {
+            if ($original === null) {
                 throw EntityNotFoundException::fromClassNameAndIdentifier(
                     $classMetadata->getName(),
                     $identifierFlattener->flattenIdentifier($classMetadata, $identifier)
@@ -382,7 +382,7 @@ EOPHP;
                     continue;
                 }
 
-                $property->setValue($proxy, $property->getValue($entity));
+                $property->setValue($proxy, $property->getValue($original));
             }
         };
     }
@@ -468,9 +468,7 @@ EOPHP;
         $identifierFields = array_intersect_key($class->getReflectionProperties(), $identifiers);
 
         $proxyFactory = Closure::bind(static function (array $identifier) use ($initializer, $skippedProperties, $identifierFields, $className): InternalProxy {
-            $proxy = self::createLazyGhost(static function (InternalProxy $object) use ($initializer, &$proxy): void {
-                $initializer($object, $proxy);
-            }, $skippedProperties);
+            $proxy = self::createLazyGhost($initializer, $skippedProperties);
 
             foreach ($identifierFields as $idField => $reflector) {
                 if (! isset($identifier[$idField])) {

src/Query/AST/Functions/AbsFunction.php

@@ -5,9 +5,9 @@ declare(strict_types=1);
 namespace Doctrine\ORM\Query\AST\Functions;
 
 use Doctrine\ORM\Query\AST\SimpleArithmeticExpression;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
+use Doctrine\ORM\Query\TokenType;
 
 /**
  * "ABS" "(" SimpleArithmeticExpression ")"
@@ -30,11 +30,11 @@ class AbsFunction extends FunctionNode
     /** @inheritDoc */
     public function parse(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);
     }
 }

src/Query/AST/Functions/BitAndFunction.php

@@ -5,9 +5,9 @@ declare(strict_types=1);
 namespace Doctrine\ORM\Query\AST\Functions;
 
 use Doctrine\ORM\Query\AST\Node;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
+use Doctrine\ORM\Query\TokenType;
 
 /**
  * "BIT_AND" "(" ArithmeticPrimary "," ArithmeticPrimary ")"
@@ -36,13 +36,13 @@ class BitAndFunction extends FunctionNode
     /** @inheritDoc */
     public function parse(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->firstArithmetic = $parser->ArithmeticPrimary();
-        $parser->match(Lexer::T_COMMA);
+        $parser->match(TokenType::T_COMMA);
         $this->secondArithmetic = $parser->ArithmeticPrimary();
 
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 }

src/Query/AST/Functions/BitOrFunction.php

@@ -5,9 +5,9 @@ declare(strict_types=1);
 namespace Doctrine\ORM\Query\AST\Functions;
 
 use Doctrine\ORM\Query\AST\Node;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
+use Doctrine\ORM\Query\TokenType;
 
 /**
  * "BIT_OR" "(" ArithmeticPrimary "," ArithmeticPrimary ")"
@@ -36,13 +36,13 @@ class BitOrFunction extends FunctionNode
     /** @inheritDoc */
     public function parse(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->firstArithmetic = $parser->ArithmeticPrimary();
-        $parser->match(Lexer::T_COMMA);
+        $parser->match(TokenType::T_COMMA);
         $this->secondArithmetic = $parser->ArithmeticPrimary();
 
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 }

src/Query/AST/Functions/ConcatFunction.php

@@ -5,9 +5,9 @@ declare(strict_types=1);
 namespace Doctrine\ORM\Query\AST\Functions;
 
 use Doctrine\ORM\Query\AST\Node;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
+use Doctrine\ORM\Query\TokenType;
 
 /**
  * "CONCAT" "(" StringPrimary "," StringPrimary {"," StringPrimary }* ")"
@@ -42,22 +42,22 @@ class ConcatFunction extends FunctionNode
     /** @inheritDoc */
     public function parse(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->firstStringPrimary  = $parser->StringPrimary();
         $this->concatExpressions[] = $this->firstStringPrimary;
 
-        $parser->match(Lexer::T_COMMA);
+        $parser->match(TokenType::T_COMMA);
 
         $this->secondStringPrimary = $parser->StringPrimary();
         $this->concatExpressions[] = $this->secondStringPrimary;
 
-        while ($parser->getLexer()->isNextToken(Lexer::T_COMMA)) {
-            $parser->match(Lexer::T_COMMA);
+        while ($parser->getLexer()->isNextToken(TokenType::T_COMMA)) {
+            $parser->match(TokenType::T_COMMA);
             $this->concatExpressions[] = $parser->StringPrimary();
         }
 
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 }

src/Query/AST/Functions/CurrentDateFunction.php

@@ -4,9 +4,9 @@ declare(strict_types=1);
 
 namespace Doctrine\ORM\Query\AST\Functions;
 
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
+use Doctrine\ORM\Query\TokenType;
 
 /**
  * "CURRENT_DATE"
@@ -24,8 +24,8 @@ class CurrentDateFunction extends FunctionNode
     /** @inheritDoc */
     public function parse(Parser $parser)
     {
-        $parser->match(Lexer::T_IDENTIFIER);
-        $parser->match(Lexer::T_OPEN_PARENTHESIS);
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_IDENTIFIER);
+        $parser->match(TokenType::T_OPEN_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 }

src/Query/AST/Functions/CurrentTimeFunction.php

@@ -4,9 +4,9 @@ declare(strict_types=1);
 
 namespace Doctrine\ORM\Query\AST\Functions;
 
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
+use Doctrine\ORM\Query\TokenType;
 
 /**
  * "CURRENT_TIME"
@@ -24,8 +24,8 @@ class CurrentTimeFunction extends FunctionNode
     /** @inheritDoc */
     public function parse(Parser $parser)
     {
-        $parser->match(Lexer::T_IDENTIFIER);
-        $parser->match(Lexer::T_OPEN_PARENTHESIS);
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_IDENTIFIER);
+        $parser->match(TokenType::T_OPEN_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 }

src/Query/AST/Functions/CurrentTimestampFunction.php

@@ -4,9 +4,9 @@ declare(strict_types=1);
 
 namespace Doctrine\ORM\Query\AST\Functions;
 
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
+use Doctrine\ORM\Query\TokenType;
 
 /**
  * "CURRENT_TIMESTAMP"
@@ -24,8 +24,8 @@ class CurrentTimestampFunction extends FunctionNode
     /** @inheritDoc */
     public function parse(Parser $parser)
     {
-        $parser->match(Lexer::T_IDENTIFIER);
-        $parser->match(Lexer::T_OPEN_PARENTHESIS);
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_IDENTIFIER);
+        $parser->match(TokenType::T_OPEN_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 }

src/Query/AST/Functions/DateAddFunction.php

@@ -5,10 +5,10 @@ declare(strict_types=1);
 namespace Doctrine\ORM\Query\AST\Functions;
 
 use Doctrine\ORM\Query\AST\Node;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\QueryException;
 use Doctrine\ORM\Query\SqlWalker;
+use Doctrine\ORM\Query\TokenType;
 
 use function strtolower;
 
@@ -84,15 +84,15 @@ class DateAddFunction extends FunctionNode
     /** @inheritDoc */
     public function parse(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(TokenType::T_COMMA);
         $this->intervalExpression = $parser->ArithmeticPrimary();
-        $parser->match(Lexer::T_COMMA);
+        $parser->match(TokenType::T_COMMA);
         $this->unit = $parser->StringPrimary();
 
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 }

src/Query/AST/Functions/DateDiffFunction.php

@@ -5,9 +5,9 @@ declare(strict_types=1);
 namespace Doctrine\ORM\Query\AST\Functions;
 
 use Doctrine\ORM\Query\AST\Node;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
+use Doctrine\ORM\Query\TokenType;
 
 /**
  * "DATE_DIFF" "(" ArithmeticPrimary "," ArithmeticPrimary ")"
@@ -34,13 +34,13 @@ class DateDiffFunction extends FunctionNode
     /** @inheritDoc */
     public function parse(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->date1 = $parser->ArithmeticPrimary();
-        $parser->match(Lexer::T_COMMA);
+        $parser->match(TokenType::T_COMMA);
         $this->date2 = $parser->ArithmeticPrimary();
 
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 }

src/Query/AST/Functions/IdentityFunction.php

@@ -5,10 +5,10 @@ declare(strict_types=1);
 namespace Doctrine\ORM\Query\AST\Functions;
 
 use Doctrine\ORM\Query\AST\PathExpression;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\QueryException;
 use Doctrine\ORM\Query\SqlWalker;
+use Doctrine\ORM\Query\TokenType;
 
 use function assert;
 use function reset;
@@ -77,20 +77,20 @@ class IdentityFunction extends FunctionNode
      */
     public function parse(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->pathExpression = $parser->SingleValuedAssociationPathExpression();
 
-        if ($parser->getLexer()->isNextToken(Lexer::T_COMMA)) {
-            $parser->match(Lexer::T_COMMA);
-            $parser->match(Lexer::T_STRING);
+        if ($parser->getLexer()->isNextToken(TokenType::T_COMMA)) {
+            $parser->match(TokenType::T_COMMA);
+            $parser->match(TokenType::T_STRING);
 
             $token = $parser->getLexer()->token;
             assert($token !== null);
             $this->fieldMapping = $token->value;
         }
 
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 }

src/Query/AST/Functions/LengthFunction.php

@@ -8,9 +8,9 @@ use Doctrine\DBAL\Types\Type;
 use Doctrine\DBAL\Types\Types;
 use Doctrine\ORM\Query\AST\Node;
 use Doctrine\ORM\Query\AST\TypedExpression;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
+use Doctrine\ORM\Query\TokenType;
 
 /**
  * "LENGTH" "(" StringPrimary ")"
@@ -33,12 +33,12 @@ class LengthFunction extends FunctionNode implements TypedExpression
     /** @inheritDoc */
     public function parse(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->stringPrimary = $parser->StringPrimary();
 
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 
     public function getReturnType(): Type

src/Query/AST/Functions/LocateFunction.php

@@ -6,9 +6,9 @@ namespace Doctrine\ORM\Query\AST\Functions;
 
 use Doctrine\ORM\Query\AST\Node;
 use Doctrine\ORM\Query\AST\SimpleArithmeticExpression;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
+use Doctrine\ORM\Query\TokenType;
 
 /**
  * "LOCATE" "(" StringPrimary "," StringPrimary ["," SimpleArithmeticExpression]")"
@@ -48,22 +48,22 @@ class LocateFunction extends FunctionNode
     /** @inheritDoc */
     public function parse(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->firstStringPrimary = $parser->StringPrimary();
 
-        $parser->match(Lexer::T_COMMA);
+        $parser->match(TokenType::T_COMMA);
 
         $this->secondStringPrimary = $parser->StringPrimary();
 
         $lexer = $parser->getLexer();
-        if ($lexer->isNextToken(Lexer::T_COMMA)) {
-            $parser->match(Lexer::T_COMMA);
+        if ($lexer->isNextToken(TokenType::T_COMMA)) {
+            $parser->match(TokenType::T_COMMA);
 
             $this->simpleArithmeticExpression = $parser->SimpleArithmeticExpression();
         }
 
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 }

src/Query/AST/Functions/LowerFunction.php

@@ -5,9 +5,9 @@ declare(strict_types=1);
 namespace Doctrine\ORM\Query\AST\Functions;
 
 use Doctrine\ORM\Query\AST\Node;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
+use Doctrine\ORM\Query\TokenType;
 
 use function sprintf;
 
@@ -33,11 +33,11 @@ class LowerFunction extends FunctionNode
     /** @inheritDoc */
     public function parse(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->stringPrimary = $parser->StringPrimary();
 
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 }

src/Query/AST/Functions/ModFunction.php

@@ -5,9 +5,9 @@ declare(strict_types=1);
 namespace Doctrine\ORM\Query\AST\Functions;
 
 use Doctrine\ORM\Query\AST\SimpleArithmeticExpression;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
+use Doctrine\ORM\Query\TokenType;
 
 /**
  * "MOD" "(" SimpleArithmeticExpression "," SimpleArithmeticExpression ")"
@@ -34,15 +34,15 @@ class ModFunction extends FunctionNode
     /** @inheritDoc */
     public function parse(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->firstSimpleArithmeticExpression = $parser->SimpleArithmeticExpression();
 
-        $parser->match(Lexer::T_COMMA);
+        $parser->match(TokenType::T_COMMA);
 
         $this->secondSimpleArithmeticExpression = $parser->SimpleArithmeticExpression();
 
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 }

src/Query/AST/Functions/SizeFunction.php

@@ -6,9 +6,9 @@ namespace Doctrine\ORM\Query\AST\Functions;
 
 use Doctrine\ORM\Mapping\ClassMetadata;
 use Doctrine\ORM\Query\AST\PathExpression;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
+use Doctrine\ORM\Query\TokenType;
 
 use function assert;
 
@@ -105,11 +105,11 @@ class SizeFunction extends FunctionNode
     /** @inheritDoc */
     public function parse(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->collectionPathExpression = $parser->CollectionValuedPathExpression();
 
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 }

src/Query/AST/Functions/SqrtFunction.php

@@ -5,9 +5,9 @@ declare(strict_types=1);
 namespace Doctrine\ORM\Query\AST\Functions;
 
 use Doctrine\ORM\Query\AST\SimpleArithmeticExpression;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
+use Doctrine\ORM\Query\TokenType;
 
 use function sprintf;
 
@@ -33,11 +33,11 @@ class SqrtFunction extends FunctionNode
     /** @inheritDoc */
     public function parse(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);
     }
 }

src/Query/AST/Functions/SubstringFunction.php

@@ -6,9 +6,9 @@ namespace Doctrine\ORM\Query\AST\Functions;
 
 use Doctrine\ORM\Query\AST\Node;
 use Doctrine\ORM\Query\AST\SimpleArithmeticExpression;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
+use Doctrine\ORM\Query\TokenType;
 
 /**
  * "SUBSTRING" "(" StringPrimary "," SimpleArithmeticExpression "," SimpleArithmeticExpression ")"
@@ -44,22 +44,22 @@ class SubstringFunction extends FunctionNode
     /** @inheritDoc */
     public function parse(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->stringPrimary = $parser->StringPrimary();
 
-        $parser->match(Lexer::T_COMMA);
+        $parser->match(TokenType::T_COMMA);
 
         $this->firstSimpleArithmeticExpression = $parser->SimpleArithmeticExpression();
 
         $lexer = $parser->getLexer();
-        if ($lexer->isNextToken(Lexer::T_COMMA)) {
-            $parser->match(Lexer::T_COMMA);
+        if ($lexer->isNextToken(TokenType::T_COMMA)) {
+            $parser->match(TokenType::T_COMMA);
 
             $this->secondSimpleArithmeticExpression = $parser->SimpleArithmeticExpression();
         }
 
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 }

src/Query/AST/Functions/TrimFunction.php

@@ -6,9 +6,9 @@ namespace Doctrine\ORM\Query\AST\Functions;
 
 use Doctrine\DBAL\Platforms\TrimMode;
 use Doctrine\ORM\Query\AST\Node;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
+use Doctrine\ORM\Query\TokenType;
 
 use function assert;
 use function strcasecmp;
@@ -62,25 +62,25 @@ class TrimFunction extends FunctionNode
     {
         $lexer = $parser->getLexer();
 
-        $parser->match(Lexer::T_IDENTIFIER);
-        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $parser->match(TokenType::T_IDENTIFIER);
+        $parser->match(TokenType::T_OPEN_PARENTHESIS);
 
         $this->parseTrimMode($parser);
 
-        if ($lexer->isNextToken(Lexer::T_STRING)) {
-            $parser->match(Lexer::T_STRING);
+        if ($lexer->isNextToken(TokenType::T_STRING)) {
+            $parser->match(TokenType::T_STRING);
 
             assert($lexer->token !== null);
             $this->trimChar = $lexer->token->value;
         }
 
         if ($this->leading || $this->trailing || $this->both || ($this->trimChar !== false)) {
-            $parser->match(Lexer::T_FROM);
+            $parser->match(TokenType::T_FROM);
         }
 
         $this->stringPrimary = $parser->StringPrimary();
 
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 
     /** @psalm-return TrimMode::* */
@@ -108,7 +108,7 @@ class TrimFunction extends FunctionNode
         $value = $lexer->lookahead->value;
 
         if (strcasecmp('leading', $value) === 0) {
-            $parser->match(Lexer::T_LEADING);
+            $parser->match(TokenType::T_LEADING);
 
             $this->leading = true;
 
@@ -116,7 +116,7 @@ class TrimFunction extends FunctionNode
         }
 
         if (strcasecmp('trailing', $value) === 0) {
-            $parser->match(Lexer::T_TRAILING);
+            $parser->match(TokenType::T_TRAILING);
 
             $this->trailing = true;
 
@@ -124,7 +124,7 @@ class TrimFunction extends FunctionNode
         }
 
         if (strcasecmp('both', $value) === 0) {
-            $parser->match(Lexer::T_BOTH);
+            $parser->match(TokenType::T_BOTH);
 
             $this->both = true;
 

src/Query/AST/Functions/UpperFunction.php

@@ -5,9 +5,9 @@ declare(strict_types=1);
 namespace Doctrine\ORM\Query\AST\Functions;
 
 use Doctrine\ORM\Query\AST\Node;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
+use Doctrine\ORM\Query\TokenType;
 
 use function sprintf;
 
@@ -33,11 +33,11 @@ class UpperFunction extends FunctionNode
     /** @inheritDoc */
     public function parse(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->stringPrimary = $parser->StringPrimary();
 
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 }

src/Query/Lexer.php

@@ -21,95 +21,249 @@ use function substr;
 /**
  * Scans a DQL query for tokens.
  *
- * @extends AbstractLexer<Lexer::T_*, string>
+ * @extends AbstractLexer<TokenType::T_*, string>
  */
 class Lexer extends AbstractLexer
 {
     // All tokens that are not valid identifiers must be < 100
-    public const T_NONE              = 1;
-    public const T_INTEGER           = 2;
-    public const T_STRING            = 3;
-    public const T_INPUT_PARAMETER   = 4;
-    public const T_FLOAT             = 5;
-    public const T_CLOSE_PARENTHESIS = 6;
-    public const T_OPEN_PARENTHESIS  = 7;
-    public const T_COMMA             = 8;
-    public const T_DIVIDE            = 9;
-    public const T_DOT               = 10;
-    public const T_EQUALS            = 11;
-    public const T_GREATER_THAN      = 12;
-    public const T_LOWER_THAN        = 13;
-    public const T_MINUS             = 14;
-    public const T_MULTIPLY          = 15;
-    public const T_NEGATE            = 16;
-    public const T_PLUS              = 17;
-    public const T_OPEN_CURLY_BRACE  = 18;
-    public const T_CLOSE_CURLY_BRACE = 19;
+    /** @deprecated use {@see TokenType::T_NONE} */
+    public const T_NONE = TokenType::T_NONE;
+
+    /** @deprecated use {@see TokenType::T_INTEGER} */
+    public const T_INTEGER = TokenType::T_INTEGER;
+
+    /** @deprecated use {@see TokenType::T_STRING} */
+    public const T_STRING = TokenType::T_STRING;
+
+    /** @deprecated use {@see TokenType::T_INPUT_PARAMETER} */
+    public const T_INPUT_PARAMETER = TokenType::T_INPUT_PARAMETER;
+
+    /** @deprecated use {@see TokenType::T_FLOAT} */
+    public const T_FLOAT = TokenType::T_FLOAT;
+
+    /** @deprecated use {@see TokenType::T_CLOSE_PARENTHESIS} */
+    public const T_CLOSE_PARENTHESIS = TokenType::T_CLOSE_PARENTHESIS;
+
+    /** @deprecated use {@see TokenType::T_OPEN_PARENTHESIS} */
+    public const T_OPEN_PARENTHESIS = TokenType::T_OPEN_PARENTHESIS;
+
+    /** @deprecated use {@see TokenType::T_COMMA} */
+    public const T_COMMA = TokenType::T_COMMA;
+
+    /** @deprecated use {@see TokenType::T_DIVIDE} */
+    public const T_DIVIDE = TokenType::T_DIVIDE;
+
+    /** @deprecated use {@see TokenType::T_DOT} */
+    public const T_DOT = TokenType::T_DOT;
+
+    /** @deprecated use {@see TokenType::T_EQUALS} */
+    public const T_EQUALS = TokenType::T_EQUALS;
+
+    /** @deprecated use {@see TokenType::T_GREATER_THAN} */
+    public const T_GREATER_THAN = TokenType::T_GREATER_THAN;
+
+    /** @deprecated use {@see TokenType::T_LOWER_THAN} */
+    public const T_LOWER_THAN = TokenType::T_LOWER_THAN;
+
+    /** @deprecated use {@see TokenType::T_MINUS} */
+    public const T_MINUS = TokenType::T_MINUS;
+
+    /** @deprecated use {@see TokenType::T_MULTIPLY} */
+    public const T_MULTIPLY = TokenType::T_MULTIPLY;
+
+    /** @deprecated use {@see TokenType::T_NEGATE} */
+    public const T_NEGATE = TokenType::T_NEGATE;
+
+    /** @deprecated use {@see TokenType::T_PLUS} */
+    public const T_PLUS = TokenType::T_PLUS;
+
+    /** @deprecated use {@see TokenType::T_OPEN_CURLY_BRACE} */
+    public const T_OPEN_CURLY_BRACE = TokenType::T_OPEN_CURLY_BRACE;
+
+    /** @deprecated use {@see TokenType::T_CLOSE_CURLY_BRACE} */
+    public const T_CLOSE_CURLY_BRACE = TokenType::T_CLOSE_CURLY_BRACE;
 
     // All tokens that are identifiers or keywords that could be considered as identifiers should be >= 100
     /** @deprecated No Replacement planned. */
-    public const T_ALIASED_NAME         = 100;
-    public const T_FULLY_QUALIFIED_NAME = 101;
-    public const T_IDENTIFIER           = 102;
+    public const T_ALIASED_NAME = TokenType::T_ALIASED_NAME;
+
+    /** @deprecated use {@see TokenType::T_FULLY_QUALIFIED_NAME} */
+    public const T_FULLY_QUALIFIED_NAME = TokenType::T_FULLY_QUALIFIED_NAME;
+
+    /** @deprecated use {@see TokenType::T_IDENTIFIER} */
+    public const T_IDENTIFIER = TokenType::T_IDENTIFIER;
 
     // All keyword tokens should be >= 200
-    public const T_ALL      = 200;
-    public const T_AND      = 201;
-    public const T_ANY      = 202;
-    public const T_AS       = 203;
-    public const T_ASC      = 204;
-    public const T_AVG      = 205;
-    public const T_BETWEEN  = 206;
-    public const T_BOTH     = 207;
-    public const T_BY       = 208;
-    public const T_CASE     = 209;
-    public const T_COALESCE = 210;
-    public const T_COUNT    = 211;
-    public const T_DELETE   = 212;
-    public const T_DESC     = 213;
-    public const T_DISTINCT = 214;
-    public const T_ELSE     = 215;
-    public const T_EMPTY    = 216;
-    public const T_END      = 217;
-    public const T_ESCAPE   = 218;
-    public const T_EXISTS   = 219;
-    public const T_FALSE    = 220;
-    public const T_FROM     = 221;
-    public const T_GROUP    = 222;
-    public const T_HAVING   = 223;
-    public const T_HIDDEN   = 224;
-    public const T_IN       = 225;
-    public const T_INDEX    = 226;
-    public const T_INNER    = 227;
-    public const T_INSTANCE = 228;
-    public const T_IS       = 229;
-    public const T_JOIN     = 230;
-    public const T_LEADING  = 231;
-    public const T_LEFT     = 232;
-    public const T_LIKE     = 233;
-    public const T_MAX      = 234;
-    public const T_MEMBER   = 235;
-    public const T_MIN      = 236;
-    public const T_NEW      = 237;
-    public const T_NOT      = 238;
-    public const T_NULL     = 239;
-    public const T_NULLIF   = 240;
-    public const T_OF       = 241;
-    public const T_OR       = 242;
-    public const T_ORDER    = 243;
-    public const T_OUTER    = 244;
-    public const T_PARTIAL  = 245;
-    public const T_SELECT   = 246;
-    public const T_SET      = 247;
-    public const T_SOME     = 248;
-    public const T_SUM      = 249;
-    public const T_THEN     = 250;
-    public const T_TRAILING = 251;
-    public const T_TRUE     = 252;
-    public const T_UPDATE   = 253;
-    public const T_WHEN     = 254;
-    public const T_WHERE    = 255;
-    public const T_WITH     = 256;
+    /** @deprecated use {@see TokenType::T_ALL} */
+    public const T_ALL = TokenType::T_ALL;
+
+    /** @deprecated use {@see TokenType::T_AND} */
+    public const T_AND = TokenType::T_AND;
+
+    /** @deprecated use {@see TokenType::T_ANY} */
+    public const T_ANY = TokenType::T_ANY;
+
+    /** @deprecated use {@see TokenType::T_AS} */
+    public const T_AS = TokenType::T_AS;
+
+    /** @deprecated use {@see TokenType::T_ASC} */
+    public const T_ASC = TokenType::T_ASC;
+
+    /** @deprecated use {@see TokenType::T_AVG} */
+    public const T_AVG = TokenType::T_AVG;
+
+    /** @deprecated use {@see TokenType::T_BETWEEN} */
+    public const T_BETWEEN = TokenType::T_BETWEEN;
+
+    /** @deprecated use {@see TokenType::T_BOTH} */
+    public const T_BOTH = TokenType::T_BOTH;
+
+    /** @deprecated use {@see TokenType::T_BY} */
+    public const T_BY = TokenType::T_BY;
+
+    /** @deprecated use {@see TokenType::T_CASE} */
+    public const T_CASE = TokenType::T_CASE;
+
+    /** @deprecated use {@see TokenType::T_COALESCE} */
+    public const T_COALESCE = TokenType::T_COALESCE;
+
+    /** @deprecated use {@see TokenType::T_COUNT} */
+    public const T_COUNT = TokenType::T_COUNT;
+
+    /** @deprecated use {@see TokenType::T_DELETE} */
+    public const T_DELETE = TokenType::T_DELETE;
+
+    /** @deprecated use {@see TokenType::T_DESC} */
+    public const T_DESC = TokenType::T_DESC;
+
+    /** @deprecated use {@see TokenType::T_DISTINCT} */
+    public const T_DISTINCT = TokenType::T_DISTINCT;
+
+    /** @deprecated use {@see TokenType::T_ELSE} */
+    public const T_ELSE = TokenType::T_ELSE;
+
+    /** @deprecated use {@see TokenType::T_EMPTY} */
+    public const T_EMPTY = TokenType::T_EMPTY;
+
+    /** @deprecated use {@see TokenType::T_END} */
+    public const T_END = TokenType::T_END;
+
+    /** @deprecated use {@see TokenType::T_ESCAPE} */
+    public const T_ESCAPE = TokenType::T_ESCAPE;
+
+    /** @deprecated use {@see TokenType::T_EXISTS} */
+    public const T_EXISTS = TokenType::T_EXISTS;
+
+    /** @deprecated use {@see TokenType::T_FALSE} */
+    public const T_FALSE = TokenType::T_FALSE;
+
+    /** @deprecated use {@see TokenType::T_FROM} */
+    public const T_FROM = TokenType::T_FROM;
+
+    /** @deprecated use {@see TokenType::T_GROUP} */
+    public const T_GROUP = TokenType::T_GROUP;
+
+    /** @deprecated use {@see TokenType::T_HAVING} */
+    public const T_HAVING = TokenType::T_HAVING;
+
+    /** @deprecated use {@see TokenType::T_HIDDEN} */
+    public const T_HIDDEN = TokenType::T_HIDDEN;
+
+    /** @deprecated use {@see TokenType::T_IN} */
+    public const T_IN = TokenType::T_IN;
+
+    /** @deprecated use {@see TokenType::T_INDEX} */
+    public const T_INDEX = TokenType::T_INDEX;
+
+    /** @deprecated use {@see TokenType::T_INNER} */
+    public const T_INNER = TokenType::T_INNER;
+
+    /** @deprecated use {@see TokenType::T_INSTANCE} */
+    public const T_INSTANCE = TokenType::T_INSTANCE;
+
+    /** @deprecated use {@see TokenType::T_IS} */
+    public const T_IS = TokenType::T_IS;
+
+    /** @deprecated use {@see TokenType::T_JOIN} */
+    public const T_JOIN = TokenType::T_JOIN;
+
+    /** @deprecated use {@see TokenType::T_LEADING} */
+    public const T_LEADING = TokenType::T_LEADING;
+
+    /** @deprecated use {@see TokenType::T_LEFT} */
+    public const T_LEFT = TokenType::T_LEFT;
+
+    /** @deprecated use {@see TokenType::T_LIKE} */
+    public const T_LIKE = TokenType::T_LIKE;
+
+    /** @deprecated use {@see TokenType::T_MAX} */
+    public const T_MAX = TokenType::T_MAX;
+
+    /** @deprecated use {@see TokenType::T_MEMBER} */
+    public const T_MEMBER = TokenType::T_MEMBER;
+
+    /** @deprecated use {@see TokenType::T_MIN} */
+    public const T_MIN = TokenType::T_MIN;
+
+    /** @deprecated use {@see TokenType::T_NEW} */
+    public const T_NEW = TokenType::T_NEW;
+
+    /** @deprecated use {@see TokenType::T_NOT} */
+    public const T_NOT = TokenType::T_NOT;
+
+    /** @deprecated use {@see TokenType::T_NULL} */
+    public const T_NULL = TokenType::T_NULL;
+
+    /** @deprecated use {@see TokenType::T_NULLIF} */
+    public const T_NULLIF = TokenType::T_NULLIF;
+
+    /** @deprecated use {@see TokenType::T_OF} */
+    public const T_OF = TokenType::T_OF;
+
+    /** @deprecated use {@see TokenType::T_OR} */
+    public const T_OR = TokenType::T_OR;
+
+    /** @deprecated use {@see TokenType::T_ORDER} */
+    public const T_ORDER = TokenType::T_ORDER;
+
+    /** @deprecated use {@see TokenType::T_OUTER} */
+    public const T_OUTER = TokenType::T_OUTER;
+
+    /** @deprecated use {@see TokenType::T_PARTIAL} */
+    public const T_PARTIAL = TokenType::T_PARTIAL;
+
+    /** @deprecated use {@see TokenType::T_SELECT} */
+    public const T_SELECT = TokenType::T_SELECT;
+
+    /** @deprecated use {@see TokenType::T_SET} */
+    public const T_SET = TokenType::T_SET;
+
+    /** @deprecated use {@see TokenType::T_SOME} */
+    public const T_SOME = TokenType::T_SOME;
+
+    /** @deprecated use {@see TokenType::T_SUM} */
+    public const T_SUM = TokenType::T_SUM;
+
+    /** @deprecated use {@see TokenType::T_THEN} */
+    public const T_THEN = TokenType::T_THEN;
+
+    /** @deprecated use {@see TokenType::T_TRAILING} */
+    public const T_TRAILING = TokenType::T_TRAILING;
+
+    /** @deprecated use {@see TokenType::T_TRUE} */
+    public const T_TRUE = TokenType::T_TRUE;
+
+    /** @deprecated use {@see TokenType::T_UPDATE} */
+    public const T_UPDATE = TokenType::T_UPDATE;
+
+    /** @deprecated use {@see TokenType::T_WHEN} */
+    public const T_WHEN = TokenType::T_WHEN;
+
+    /** @deprecated use {@see TokenType::T_WHERE} */
+    public const T_WHERE = TokenType::T_WHERE;
+
+    /** @deprecated use {@see TokenType::T_WITH} */
+    public const T_WITH = TokenType::T_WITH;
 
     /**
      * Creates a new query scanner object.
@@ -150,26 +304,26 @@ class Lexer extends AbstractLexer
      */
     protected function getType(&$value)
     {
-        $type = self::T_NONE;
+        $type = TokenType::T_NONE;
 
         switch (true) {
             // Recognize numeric values
             case is_numeric($value):
                 if (str_contains($value, '.') || stripos($value, 'e') !== false) {
-                    return self::T_FLOAT;
+                    return TokenType::T_FLOAT;
                 }
 
-                return self::T_INTEGER;
+                return TokenType::T_INTEGER;
 
             // Recognize quoted strings
             case $value[0] === "'":
                 $value = str_replace("''", "'", substr($value, 1, strlen($value) - 2));
 
-                return self::T_STRING;
+                return TokenType::T_STRING;
 
             // Recognize identifiers, aliased or qualified names
             case ctype_alpha($value[0]) || $value[0] === '_' || $value[0] === '\\':
-                $name = 'Doctrine\ORM\Query\Lexer::T_' . strtoupper($value);
+                $name = 'Doctrine\ORM\Query\TokenType::T_' . strtoupper($value);
 
                 if (defined($name)) {
                     $type = constant($name);
@@ -187,61 +341,61 @@ class Lexer extends AbstractLexer
                         $value
                     );
 
-                    return self::T_ALIASED_NAME;
+                    return TokenType::T_ALIASED_NAME;
                 }
 
                 if (str_contains($value, '\\')) {
-                    return self::T_FULLY_QUALIFIED_NAME;
+                    return TokenType::T_FULLY_QUALIFIED_NAME;
                 }
 
-                return self::T_IDENTIFIER;
+                return TokenType::T_IDENTIFIER;
 
             // Recognize input parameters
             case $value[0] === '?' || $value[0] === ':':
-                return self::T_INPUT_PARAMETER;
+                return TokenType::T_INPUT_PARAMETER;
 
             // Recognize symbols
             case $value === '.':
-                return self::T_DOT;
+                return TokenType::T_DOT;
 
             case $value === ',':
-                return self::T_COMMA;
+                return TokenType::T_COMMA;
 
             case $value === '(':
-                return self::T_OPEN_PARENTHESIS;
+                return TokenType::T_OPEN_PARENTHESIS;
 
             case $value === ')':
-                return self::T_CLOSE_PARENTHESIS;
+                return TokenType::T_CLOSE_PARENTHESIS;
 
             case $value === '=':
-                return self::T_EQUALS;
+                return TokenType::T_EQUALS;
 
             case $value === '>':
-                return self::T_GREATER_THAN;
+                return TokenType::T_GREATER_THAN;
 
             case $value === '<':
-                return self::T_LOWER_THAN;
+                return TokenType::T_LOWER_THAN;
 
             case $value === '+':
-                return self::T_PLUS;
+                return TokenType::T_PLUS;
 
             case $value === '-':
-                return self::T_MINUS;
+                return TokenType::T_MINUS;
 
             case $value === '*':
-                return self::T_MULTIPLY;
+                return TokenType::T_MULTIPLY;
 
             case $value === '/':
-                return self::T_DIVIDE;
+                return TokenType::T_DIVIDE;
 
             case $value === '!':
-                return self::T_NEGATE;
+                return TokenType::T_NEGATE;
 
             case $value === '{':
-                return self::T_OPEN_CURLY_BRACE;
+                return TokenType::T_OPEN_CURLY_BRACE;
 
             case $value === '}':
-                return self::T_CLOSE_CURLY_BRACE;
+                return TokenType::T_CLOSE_CURLY_BRACE;
 
             // Default
             default:

src/Query/TokenType.php

@@ -0,0 +1,99 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\ORM\Query;
+
+final class TokenType
+{
+    // All tokens that are not valid identifiers must be < 100
+    public const T_NONE              = 1;
+    public const T_INTEGER           = 2;
+    public const T_STRING            = 3;
+    public const T_INPUT_PARAMETER   = 4;
+    public const T_FLOAT             = 5;
+    public const T_CLOSE_PARENTHESIS = 6;
+    public const T_OPEN_PARENTHESIS  = 7;
+    public const T_COMMA             = 8;
+    public const T_DIVIDE            = 9;
+    public const T_DOT               = 10;
+    public const T_EQUALS            = 11;
+    public const T_GREATER_THAN      = 12;
+    public const T_LOWER_THAN        = 13;
+    public const T_MINUS             = 14;
+    public const T_MULTIPLY          = 15;
+    public const T_NEGATE            = 16;
+    public const T_PLUS              = 17;
+    public const T_OPEN_CURLY_BRACE  = 18;
+    public const T_CLOSE_CURLY_BRACE = 19;
+
+    // All tokens that are identifiers or keywords that could be considered as identifiers should be >= 100
+    /** @deprecated No Replacement planned. */
+    public const T_ALIASED_NAME         = 100;
+    public const T_FULLY_QUALIFIED_NAME = 101;
+    public const T_IDENTIFIER           = 102;
+
+    // All keyword tokens should be >= 200
+    public const T_ALL      = 200;
+    public const T_AND      = 201;
+    public const T_ANY      = 202;
+    public const T_AS       = 203;
+    public const T_ASC      = 204;
+    public const T_AVG      = 205;
+    public const T_BETWEEN  = 206;
+    public const T_BOTH     = 207;
+    public const T_BY       = 208;
+    public const T_CASE     = 209;
+    public const T_COALESCE = 210;
+    public const T_COUNT    = 211;
+    public const T_DELETE   = 212;
+    public const T_DESC     = 213;
+    public const T_DISTINCT = 214;
+    public const T_ELSE     = 215;
+    public const T_EMPTY    = 216;
+    public const T_END      = 217;
+    public const T_ESCAPE   = 218;
+    public const T_EXISTS   = 219;
+    public const T_FALSE    = 220;
+    public const T_FROM     = 221;
+    public const T_GROUP    = 222;
+    public const T_HAVING   = 223;
+    public const T_HIDDEN   = 224;
+    public const T_IN       = 225;
+    public const T_INDEX    = 226;
+    public const T_INNER    = 227;
+    public const T_INSTANCE = 228;
+    public const T_IS       = 229;
+    public const T_JOIN     = 230;
+    public const T_LEADING  = 231;
+    public const T_LEFT     = 232;
+    public const T_LIKE     = 233;
+    public const T_MAX      = 234;
+    public const T_MEMBER   = 235;
+    public const T_MIN      = 236;
+    public const T_NEW      = 237;
+    public const T_NOT      = 238;
+    public const T_NULL     = 239;
+    public const T_NULLIF   = 240;
+    public const T_OF       = 241;
+    public const T_OR       = 242;
+    public const T_ORDER    = 243;
+    public const T_OUTER    = 244;
+    public const T_PARTIAL  = 245;
+    public const T_SELECT   = 246;
+    public const T_SET      = 247;
+    public const T_SOME     = 248;
+    public const T_SUM      = 249;
+    public const T_THEN     = 250;
+    public const T_TRAILING = 251;
+    public const T_TRUE     = 252;
+    public const T_UPDATE   = 253;
+    public const T_WHEN     = 254;
+    public const T_WHERE    = 255;
+    public const T_WITH     = 256;
+
+    /** @internal */
+    private function __construct()
+    {
+    }
+}

src/Tools/SchemaTool.php

@@ -365,7 +365,7 @@ class SchemaTool
 
             if (isset($class->table['uniqueConstraints'])) {
                 foreach ($class->table['uniqueConstraints'] as $indexName => $indexData) {
-                    $uniqIndex = new Index($indexName, $this->getIndexColumns($class, $indexData), true, false, [], $indexData['options'] ?? []);
+                    $uniqIndex = new Index('tmp__' . $indexName, $this->getIndexColumns($class, $indexData), true, false, [], $indexData['options'] ?? []);
 
                     foreach ($table->getIndexes() as $tableIndexName => $tableIndex) {
                         $method = method_exists($tableIndex, 'isFulfilledBy') ? 'isFulfilledBy' : 'isFullfilledBy';

src/Tools/SchemaValidator.php

@@ -64,18 +64,18 @@ class SchemaValidator
      * It maps built-in Doctrine types to PHP types
      */
     private const BUILTIN_TYPES_MAP = [
-        AsciiStringType::class => 'string',
-        BigIntType::class => 'string',
-        BooleanType::class => 'bool',
-        DecimalType::class => 'string',
-        FloatType::class => 'float',
-        GuidType::class => 'string',
-        IntegerType::class => 'int',
-        JsonType::class => 'array',
-        SimpleArrayType::class => 'array',
-        SmallIntType::class => 'int',
-        StringType::class => 'string',
-        TextType::class => 'string',
+        AsciiStringType::class => ['string'],
+        BigIntType::class => ['int', 'string'],
+        BooleanType::class => ['bool'],
+        DecimalType::class => ['string'],
+        FloatType::class => ['float'],
+        GuidType::class => ['string'],
+        IntegerType::class => ['int'],
+        JsonType::class => ['array'],
+        SimpleArrayType::class => ['array'],
+        SmallIntType::class => ['int'],
+        StringType::class => ['string'],
+        TextType::class => ['string'],
     ];
 
     public function __construct(EntityManagerInterface $em, bool $validatePropertyTypes = true)
@@ -390,21 +390,21 @@ class SchemaValidator
                         $propertyType = $propertyType->getName();
 
                         // If the property type is the same as the metadata field type, we are ok
-                        if ($propertyType === $metadataFieldType) {
+                        if (in_array($propertyType, $metadataFieldType, true)) {
                             return null;
                         }
 
                         if (is_a($propertyType, BackedEnum::class, true)) {
                             $backingType = (string) (new ReflectionEnum($propertyType))->getBackingType();
 
-                            if ($metadataFieldType !== $backingType) {
+                            if (! in_array($backingType, $metadataFieldType, true)) {
                                 return sprintf(
                                     "The field '%s#%s' has the property type '%s' with a backing type of '%s' that differs from the metadata field type '%s'.",
                                     $class->name,
                                     $fieldName,
                                     $propertyType,
                                     $backingType,
-                                    $metadataFieldType
+                                    implode('|', $metadataFieldType)
                                 );
                             }
 
@@ -429,7 +429,7 @@ class SchemaValidator
                         ) {
                             $backingType = (string) (new ReflectionEnum($fieldMapping['enumType']))->getBackingType();
 
-                            if ($metadataFieldType === $backingType) {
+                            if (in_array($backingType, $metadataFieldType, true)) {
                                 return null;
                             }
 
@@ -439,7 +439,7 @@ class SchemaValidator
                                 $fieldName,
                                 $fieldMapping['enumType'],
                                 $backingType,
-                                $metadataFieldType
+                                implode('|', $metadataFieldType)
                             );
                         }
 
@@ -455,7 +455,7 @@ class SchemaValidator
                             $class->name,
                             $fieldName,
                             $propertyType,
-                            $metadataFieldType,
+                            implode('|', $metadataFieldType),
                             $fieldMapping['type']
                         );
                     },
@@ -468,8 +468,10 @@ class SchemaValidator
     /**
      * The exact DBAL type must be used (no subclasses), since consumers of doctrine/orm may have their own
      * customization around field types.
+     *
+     * @return list<string>|null
      */
-    private function findBuiltInType(Type $type): ?string
+    private function findBuiltInType(Type $type): ?array
     {
         $typeName = get_class($type);
 

src/UnitOfWork.php

@@ -1781,18 +1781,15 @@ EXCEPTION
      */
     final public static function getIdHashByIdentifier(array $identifier): string
     {
+        foreach ($identifier as $k => $value) {
+            if ($value instanceof BackedEnum) {
+                $identifier[$k] = $value->value;
+            }
+        }
+
         return implode(
             ' ',
-            array_map(
-                static function ($value) {
-                    if ($value instanceof BackedEnum) {
-                        return $value->value;
-                    }
-
-                    return $value;
-                },
-                $identifier
-            )
+            $identifier
         );
     }
 
@@ -3169,9 +3166,9 @@ EXCEPTION
 
                     if ($hints['fetchMode'][$class->name][$field] === ClassMetadata::FETCH_EAGER) {
                         $isIteration = isset($hints[Query::HINT_INTERNAL_ITERATION]) && $hints[Query::HINT_INTERNAL_ITERATION];
-                        if (! $isIteration && $assoc['type'] === ClassMetadata::ONE_TO_MANY) {
+                        if ($assoc['type'] === ClassMetadata::ONE_TO_MANY && ! $isIteration && ! $targetClass->isIdentifierComposite && ! isset($assoc['indexBy'])) {
                             $this->scheduleCollectionForBatchLoading($pColl, $class);
-                        } elseif (($isIteration && $assoc['type'] === ClassMetadata::ONE_TO_MANY) || $assoc['type'] === ClassMetadata::MANY_TO_MANY) {
+                        } else {
                             $this->loadCollection($pColl);
                             $pColl->takeSnapshot();
                         }
@@ -3252,7 +3249,19 @@ EXCEPTION
             foreach ($found as $targetValue) {
                 $sourceEntity = $targetProperty->getValue($targetValue);
 
-                $id     = $this->identifierFlattener->flattenIdentifier($class, $class->getIdentifierValues($sourceEntity));
+                if ($sourceEntity === null && isset($targetClass->associationMappings[$mappedBy]['joinColumns'])) {
+                    // case where the hydration $targetValue itself has not yet fully completed, for example
+                    // in case a bi-directional association is being hydrated and deferring eager loading is
+                    // not possible due to subclassing.
+                    $data = $this->getOriginalEntityData($targetValue);
+                    $id   = [];
+                    foreach ($targetClass->associationMappings[$mappedBy]['joinColumns'] as $joinColumn) {
+                        $id[] = $data[$joinColumn['name']];
+                    }
+                } else {
+                    $id = $this->identifierFlattener->flattenIdentifier($class, $class->getIdentifierValues($sourceEntity));
+                }
+
                 $idHash = implode(' ', $id);
 
                 if (isset($mapping['indexBy'])) {

tests/Tests/Models/AbstractFetchEager/AbstractRemoteControl.php

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

tests/Tests/Models/AbstractFetchEager/MobileRemoteControl.php

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

tests/Tests/Models/AbstractFetchEager/User.php

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

tests/Tests/Models/BigIntegers/BigIntegers.php

@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Tests\Models\BigIntegers;
+
+use Doctrine\ORM\Mapping as ORM;
+
+/** @ORM\Entity */
+class BigIntegers
+{
+    /**
+     * @ORM\Column(type="integer")
+     * @ORM\Id
+     * @ORM\GeneratedValue
+     */
+    public ?int $id = null;
+
+    /** @ORM\Column(type="bigint") */
+    public int $one = 1;
+
+    /** @ORM\Column(type="bigint") */
+    public string $two = '2';
+
+    /** @ORM\Column(type="bigint") */
+    public float $three = 3.0;
+}

tests/Tests/Models/EagerFetchedCompositeOneToMany/RootEntity.php

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

tests/Tests/Models/EagerFetchedCompositeOneToMany/SecondLevel.php

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

tests/Tests/ORM/Functional/AbstractFetchEagerTest.php

@@ -0,0 +1,37 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Tests\ORM\Functional;
+
+use Doctrine\Tests\Models\AbstractFetchEager\AbstractRemoteControl;
+use Doctrine\Tests\Models\AbstractFetchEager\MobileRemoteControl;
+use Doctrine\Tests\Models\AbstractFetchEager\User;
+use Doctrine\Tests\OrmFunctionalTestCase;
+
+final class AbstractFetchEagerTest extends OrmFunctionalTestCase
+{
+    public function testWithAbstractFetchEager(): void
+    {
+        $this->createSchemaForModels(
+            AbstractRemoteControl::class,
+            User::class
+        );
+
+        $control = new MobileRemoteControl('smart');
+        $user    = new User($control);
+
+        $entityManage = $this->getEntityManager();
+
+        $entityManage->persist($control);
+        $entityManage->persist($user);
+        $entityManage->flush();
+        $entityManage->clear();
+
+        $user = $entityManage->find(User::class, $user->id);
+
+        self::assertNotNull($user);
+        self::assertEquals('smart', $user->remoteControl->name);
+        self::assertTrue($user->remoteControl->users->contains($user));
+    }
+}

tests/Tests/ORM/Functional/CustomFunctionsTest.php

@@ -7,9 +7,9 @@ namespace Doctrine\Tests\ORM\Functional;
 use Doctrine\ORM\Query;
 use Doctrine\ORM\Query\AST\Functions\FunctionNode;
 use Doctrine\ORM\Query\AST\PathExpression;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
+use Doctrine\ORM\Query\TokenType;
 use Doctrine\Tests\Models\CMS\CmsUser;
 use Doctrine\Tests\OrmFunctionalTestCase;
 
@@ -75,10 +75,10 @@ class NoOp extends FunctionNode
 
     public function parse(Parser $parser): void
     {
-        $parser->match(Lexer::T_IDENTIFIER);
-        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $parser->match(TokenType::T_IDENTIFIER);
+        $parser->match(TokenType::T_OPEN_PARENTHESIS);
         $this->field = $parser->ArithmeticPrimary();
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 
     public function getSql(SqlWalker $sqlWalker): string

tests/Tests/ORM/Functional/EagerFetchOneToManyWithCompositeKeyTest.php

@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Tests\ORM\Functional;
+
+use Doctrine\Tests\Models\EagerFetchedCompositeOneToMany\RootEntity;
+use Doctrine\Tests\Models\EagerFetchedCompositeOneToMany\SecondLevel;
+use Doctrine\Tests\OrmFunctionalTestCase;
+
+final class EagerFetchOneToManyWithCompositeKeyTest extends OrmFunctionalTestCase
+{
+    /** @ticket 11154 */
+    public function testItDoesNotThrowAnExceptionWhenTriggeringALoad(): void
+    {
+        $this->setUpEntitySchema([RootEntity::class, SecondLevel::class]);
+
+        $a1 = new RootEntity(1, 'A');
+
+        $this->_em->persist($a1);
+        $this->_em->flush();
+
+        $this->_em->clear();
+
+        self::assertCount(1, $this->_em->getRepository(RootEntity::class)->findAll());
+    }
+}

tests/Tests/ORM/Functional/Ticket/GH11149/EagerProduct.php

@@ -0,0 +1,42 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Tests\ORM\Functional\Ticket\GH11149;
+
+use Doctrine\Common\Collections\ArrayCollection;
+use Doctrine\Common\Collections\Collection;
+use Doctrine\ORM\Mapping as ORM;
+
+/**
+ * @ORM\Entity
+ * @ORM\Table("gh11149_eager_product")
+ */
+class EagerProduct
+{
+    /**
+     * @ORM\Id
+     * @ORM\Column(type="integer")
+     *
+     * @var int
+     */
+    public $id;
+
+    /**
+     * @ORM\OneToMany(
+     *     targetEntity=EagerProductTranslation::class,
+     *     mappedBy="product",
+     *     fetch="EAGER",
+     *     indexBy="locale_code"
+     * )
+     *
+     * @var Collection<string, EagerProductTranslation>
+     */
+    public $translations;
+
+    public function __construct(int $id)
+    {
+        $this->id           = $id;
+        $this->translations = new ArrayCollection();
+    }
+}

tests/Tests/ORM/Functional/Ticket/GH11149/EagerProductTranslation.php

@@ -0,0 +1,45 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Tests\ORM\Functional\Ticket\GH11149;
+
+use Doctrine\ORM\Mapping as ORM;
+
+/**
+ * @ORM\Entity
+ * @ORM\Table("gh11149_eager_product_translation")
+ */
+class EagerProductTranslation
+{
+    /**
+     * @ORM\Id
+     * @ORM\Column(type="integer")
+     *
+     * @var int
+     */
+    private $id;
+
+    /**
+     * @ORM\ManyToOne(targetEntity=EagerProduct::class, inversedBy="translations")
+     * @ORM\JoinColumn(nullable=false)
+     *
+     * @var EagerProduct
+     */
+    public $product;
+
+    /**
+     * @ORM\ManyToOne(targetEntity=Locale::class)
+     * @ORM\JoinColumn(name="locale_code", referencedColumnName="code", nullable=false)
+     *
+     * @var Locale
+     */
+    public $locale;
+
+    public function __construct($id, EagerProduct $product, Locale $locale)
+    {
+        $this->id      = $id;
+        $this->product = $product;
+        $this->locale  = $locale;
+    }
+}

tests/Tests/ORM/Functional/Ticket/GH11149/GH11149Test.php

@@ -0,0 +1,47 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Tests\ORM\Functional\Ticket\GH11149;
+
+use Doctrine\ORM\PersistentCollection;
+use Doctrine\Persistence\Proxy;
+use Doctrine\Tests\OrmFunctionalTestCase;
+
+class GH11149Test extends OrmFunctionalTestCase
+{
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->setUpEntitySchema([
+            Locale::class,
+            EagerProduct::class,
+            EagerProductTranslation::class,
+        ]);
+    }
+
+    public function testFetchEagerModeWithIndexBy(): void
+    {
+        // Load entities into database
+        $this->_em->persist($product = new EagerProduct(11149));
+        $this->_em->persist($locale = new Locale('fr_FR'));
+        $this->_em->persist(new EagerProductTranslation(11149, $product, $locale));
+        $this->_em->flush();
+        $this->_em->clear();
+
+        // Fetch entity from database
+        $product = $this->_em->find(EagerProduct::class, 11149);
+
+        // Assert associated entity is loaded eagerly
+        static::assertInstanceOf(EagerProduct::class, $product);
+        static::assertInstanceOf(PersistentCollection::class, $product->translations);
+        static::assertTrue($product->translations->isInitialized());
+        static::assertCount(1, $product->translations);
+
+        // Assert associated entity is indexed by given property
+        $translation = $product->translations->get('fr_FR');
+        static::assertInstanceOf(EagerProductTranslation::class, $translation);
+        static::assertNotInstanceOf(Proxy::class, $translation);
+    }
+}

tests/Tests/ORM/Functional/Ticket/GH11149/Locale.php

@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Tests\ORM\Functional\Ticket\GH11149;
+
+use Doctrine\ORM\Mapping as ORM;
+
+/**
+ * @ORM\Entity
+ * @ORM\Table("gh11149_locale")
+ */
+class Locale
+{
+    /**
+     * @ORM\Id
+     * @ORM\Column(type="string", length=5)
+     *
+     * @var string
+     */
+    public $code;
+
+    public function __construct(string $code)
+    {
+        $this->code = $code;
+    }
+}

tests/Tests/ORM/Functional/Ticket/GH7286Test.php

@@ -10,9 +10,9 @@ use Doctrine\ORM\Mapping\GeneratedValue;
 use Doctrine\ORM\Mapping\Id;
 use Doctrine\ORM\Query\AST\Functions\FunctionNode;
 use Doctrine\ORM\Query\AST\Node;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
+use Doctrine\ORM\Query\TokenType;
 use Doctrine\Tests\OrmFunctionalTestCase;
 
 final class GH7286Test extends OrmFunctionalTestCase
@@ -114,14 +114,14 @@ class GH7286CustomConcat extends FunctionNode
 
     public function parse(Parser $parser): void
     {
-        $parser->match(Lexer::T_IDENTIFIER);
-        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $parser->match(TokenType::T_IDENTIFIER);
+        $parser->match(TokenType::T_OPEN_PARENTHESIS);
 
         $this->first = $parser->StringPrimary();
-        $parser->match(Lexer::T_COMMA);
+        $parser->match(TokenType::T_COMMA);
         $this->second = $parser->StringPrimary();
 
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 
     public function getSql(SqlWalker $walker): string

tests/Tests/ORM/Mapping/ClassMetadataTest.php

@@ -6,6 +6,7 @@ namespace Doctrine\Tests\ORM\Mapping;
 
 use ArrayObject;
 use Doctrine\DBAL\Types\Types;
+use Doctrine\Deprecations\PHPUnit\VerifyDeprecations;
 use Doctrine\ORM\Events;
 use Doctrine\ORM\Mapping\ChainTypedFieldMapper;
 use Doctrine\ORM\Mapping\ClassMetadata;
@@ -54,6 +55,8 @@ require_once __DIR__ . '/../../Models/Global/GlobalNamespaceModel.php';
 
 class ClassMetadataTest extends OrmTestCase
 {
+    use VerifyDeprecations;
+
     public function testClassMetadataInstanceSerialization(): void
     {
         $cm = new ClassMetadata(CMS\CmsUser::class);
@@ -1379,6 +1382,16 @@ class ClassMetadataTest extends OrmTestCase
             'columnPrefix' => false,
         ]);
     }
+
+    public function testInvalidCallToGetAssociationMappedByTargetFieldIsDeprecated(): void
+    {
+        $metadata = new ClassMetadata(self::class);
+        $metadata->mapOneToOne(['fieldName' => 'foo', 'targetEntity' => 'bar']);
+
+        $this->expectDeprecationWithIdentifier('https://github.com/doctrine/orm/pull/11309');
+
+        $metadata->getAssociationMappedByTargetField('foo');
+    }
 }
 
 /** @MappedSuperclass */

tests/Tests/ORM/Proxy/ProxyFactoryTest.php

@@ -64,8 +64,7 @@ class ProxyFactoryTest extends OrmTestCase
     public function testReferenceProxyDelegatesLoadingToThePersister(): void
     {
         $identifier = ['id' => 42];
-        $proxyClass = 'Proxies\__CG__\Doctrine\Tests\Models\ECommerce\ECommerceFeature';
-        $persister  = $this->getMockBuilderWithOnlyMethods(BasicEntityPersister::class, ['load'])
+        $persister  = $this->getMockBuilderWithOnlyMethods(BasicEntityPersister::class, ['loadById'])
             ->disableOriginalConstructor()
             ->getMock();
 
@@ -75,8 +74,8 @@ class ProxyFactoryTest extends OrmTestCase
 
         $persister
             ->expects(self::atLeastOnce())
-            ->method('load')
-            ->with(self::equalTo($identifier), self::isInstanceOf($proxyClass))
+            ->method('loadById')
+            ->with(self::equalTo($identifier))
             ->will(self::returnValue($proxy));
 
         $proxy->getDescription();

tests/Tests/ORM/Query/LexerTest.php

@@ -6,6 +6,7 @@ namespace Doctrine\Tests\ORM\Query;
 
 use Doctrine\Common\Lexer\Token;
 use Doctrine\ORM\Query\Lexer;
+use Doctrine\ORM\Query\TokenType;
 use Doctrine\Tests\OrmTestCase;
 
 class LexerTest extends OrmTestCase
@@ -35,7 +36,7 @@ class LexerTest extends OrmTestCase
         $lexer->moveNext();
         $token = $lexer->lookahead;
 
-        self::assertEquals(Lexer::T_ALL, $token->type);
+        self::assertEquals(TokenType::T_ALL, $token->type);
     }
 
     public function testScannerRecognizesDecimalInteger(): void
@@ -43,7 +44,7 @@ class LexerTest extends OrmTestCase
         $lexer = new Lexer('1234');
         $lexer->moveNext();
         $token = $lexer->lookahead;
-        self::assertEquals(Lexer::T_INTEGER, $token->type);
+        self::assertEquals(TokenType::T_INTEGER, $token->type);
         self::assertEquals(1234, $token->value);
     }
 
@@ -52,7 +53,7 @@ class LexerTest extends OrmTestCase
         $lexer = new Lexer('1.234');
         $lexer->moveNext();
         $token = $lexer->lookahead;
-        self::assertEquals(Lexer::T_FLOAT, $token->type);
+        self::assertEquals(TokenType::T_FLOAT, $token->type);
         self::assertEquals(1.234, $token->value);
     }
 
@@ -61,7 +62,7 @@ class LexerTest extends OrmTestCase
         $lexer = new Lexer('1.2e3');
         $lexer->moveNext();
         $token = $lexer->lookahead;
-        self::assertEquals(Lexer::T_FLOAT, $token->type);
+        self::assertEquals(TokenType::T_FLOAT, $token->type);
         self::assertEquals(1.2e3, $token->value);
     }
 
@@ -70,7 +71,7 @@ class LexerTest extends OrmTestCase
         $lexer = new Lexer('0.2e3');
         $lexer->moveNext();
         $token = $lexer->lookahead;
-        self::assertEquals(Lexer::T_FLOAT, $token->type);
+        self::assertEquals(TokenType::T_FLOAT, $token->type);
         self::assertEquals(.2e3, $token->value);
     }
 
@@ -79,7 +80,7 @@ class LexerTest extends OrmTestCase
         $lexer = new Lexer('7E-10');
         $lexer->moveNext();
         $token = $lexer->lookahead;
-        self::assertEquals(Lexer::T_FLOAT, $token->type);
+        self::assertEquals(TokenType::T_FLOAT, $token->type);
         self::assertEquals(7E-10, $token->value);
     }
 
@@ -88,7 +89,7 @@ class LexerTest extends OrmTestCase
         $lexer = new Lexer('123456789.01');
         $lexer->moveNext();
         $token = $lexer->lookahead;
-        self::assertEquals(Lexer::T_FLOAT, $token->type);
+        self::assertEquals(TokenType::T_FLOAT, $token->type);
         self::assertEquals(1.2345678901e8, $token->value);
     }
 
@@ -97,12 +98,12 @@ class LexerTest extends OrmTestCase
         $lexer = new Lexer('-   1.234e2');
         $lexer->moveNext();
         $token = $lexer->lookahead;
-        self::assertEquals(Lexer::T_MINUS, $token->type);
+        self::assertEquals(TokenType::T_MINUS, $token->type);
         self::assertEquals('-', $token->value);
 
         $lexer->moveNext();
         $token = $lexer->lookahead;
-        self::assertEquals(Lexer::T_FLOAT, $token->type);
+        self::assertEquals(TokenType::T_FLOAT, $token->type);
         self::assertNotEquals(-1.234e2, $token->value);
         self::assertEquals(1.234e2, $token->value);
     }
@@ -112,7 +113,7 @@ class LexerTest extends OrmTestCase
         $lexer = new Lexer("'This is a string.'");
         $lexer->moveNext();
         $token = $lexer->lookahead;
-        self::assertEquals(Lexer::T_STRING, $token->type);
+        self::assertEquals(TokenType::T_STRING, $token->type);
         self::assertEquals('This is a string.', $token->value);
     }
 
@@ -121,7 +122,7 @@ class LexerTest extends OrmTestCase
         $lexer = new Lexer("'abc''defg'''");
         $lexer->moveNext();
         $token = $lexer->lookahead;
-        self::assertEquals(Lexer::T_STRING, $token->type);
+        self::assertEquals(TokenType::T_STRING, $token->type);
         self::assertEquals("abc'defg'", $token->value);
     }
 
@@ -130,7 +131,7 @@ class LexerTest extends OrmTestCase
         $lexer = new Lexer('?1');
         $lexer->moveNext();
         $token = $lexer->lookahead;
-        self::assertEquals(Lexer::T_INPUT_PARAMETER, $token->type);
+        self::assertEquals(TokenType::T_INPUT_PARAMETER, $token->type);
         self::assertEquals('?1', $token->value);
     }
 
@@ -139,7 +140,7 @@ class LexerTest extends OrmTestCase
         $lexer = new Lexer(':name');
         $lexer->moveNext();
         $token = $lexer->lookahead;
-        self::assertEquals(Lexer::T_INPUT_PARAMETER, $token->type);
+        self::assertEquals(TokenType::T_INPUT_PARAMETER, $token->type);
         self::assertEquals(':name', $token->value);
     }
 
@@ -148,7 +149,7 @@ class LexerTest extends OrmTestCase
         $lexer = new Lexer(':_name');
         $lexer->moveNext();
         $token = $lexer->lookahead;
-        self::assertEquals(Lexer::T_INPUT_PARAMETER, $token->type);
+        self::assertEquals(TokenType::T_INPUT_PARAMETER, $token->type);
         self::assertEquals(':_name', $token->value);
     }
 
@@ -158,17 +159,17 @@ class LexerTest extends OrmTestCase
         $lexer = new Lexer($dql);
 
         $tokens = [
-            new Token('SELECT', Lexer::T_SELECT, 0),
-            new Token('u', Lexer::T_IDENTIFIER, 7),
-            new Token('FROM', Lexer::T_FROM, 9),
-            new Token('My\Namespace\User', Lexer::T_FULLY_QUALIFIED_NAME, 14),
-            new Token('u', Lexer::T_IDENTIFIER, 32),
-            new Token('WHERE', Lexer::T_WHERE, 34),
-            new Token('u', Lexer::T_IDENTIFIER, 40),
-            new Token('.', Lexer::T_DOT, 41),
-            new Token('name', Lexer::T_IDENTIFIER, 42),
-            new Token('=', Lexer::T_EQUALS, 47),
-            new Token("Jack O'Neil", Lexer::T_STRING, 49),
+            new Token('SELECT', TokenType::T_SELECT, 0),
+            new Token('u', TokenType::T_IDENTIFIER, 7),
+            new Token('FROM', TokenType::T_FROM, 9),
+            new Token('My\Namespace\User', TokenType::T_FULLY_QUALIFIED_NAME, 14),
+            new Token('u', TokenType::T_IDENTIFIER, 32),
+            new Token('WHERE', TokenType::T_WHERE, 34),
+            new Token('u', TokenType::T_IDENTIFIER, 40),
+            new Token('.', TokenType::T_DOT, 41),
+            new Token('name', TokenType::T_IDENTIFIER, 42),
+            new Token('=', TokenType::T_EQUALS, 47),
+            new Token("Jack O'Neil", TokenType::T_STRING, 49),
         ];
 
         foreach ($tokens as $expected) {
@@ -186,15 +187,15 @@ class LexerTest extends OrmTestCase
     public static function provideTokens(): array
     {
         return [
-            [Lexer::T_IDENTIFIER, 'u'], // one char
-            [Lexer::T_IDENTIFIER, 'someIdentifier'],
-            [Lexer::T_IDENTIFIER, 's0m31d3nt1f13r'], // including digits
-            [Lexer::T_IDENTIFIER, 'some_identifier'], // including underscore
-            [Lexer::T_IDENTIFIER, '_some_identifier'], // starts with underscore
-            [Lexer::T_IDENTIFIER, 'comma'], // name of a token class with value < 100 (whitebox test)
-            [Lexer::T_FULLY_QUALIFIED_NAME, 'Some\Class'], // DQL class reference
-            [Lexer::T_ALIASED_NAME, 'Some:Name'],
-            [Lexer::T_ALIASED_NAME, 'Some:Subclassed\Name'],
+            [TokenType::T_IDENTIFIER, 'u'], // one char
+            [TokenType::T_IDENTIFIER, 'someIdentifier'],
+            [TokenType::T_IDENTIFIER, 's0m31d3nt1f13r'], // including digits
+            [TokenType::T_IDENTIFIER, 'some_identifier'], // including underscore
+            [TokenType::T_IDENTIFIER, '_some_identifier'], // starts with underscore
+            [TokenType::T_IDENTIFIER, 'comma'], // name of a token class with value < 100 (whitebox test)
+            [TokenType::T_FULLY_QUALIFIED_NAME, 'Some\Class'], // DQL class reference
+            [TokenType::T_ALIASED_NAME, 'Some:Name'],
+            [TokenType::T_ALIASED_NAME, 'Some:Subclassed\Name'],
         ];
     }
 }

tests/Tests/ORM/Query/ParserTest.php

@@ -6,9 +6,9 @@ namespace Doctrine\Tests\ORM\Query;
 
 use Doctrine\Common\Persistence\PersistentObject;
 use Doctrine\ORM\Query;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\QueryException;
+use Doctrine\ORM\Query\TokenType;
 use Doctrine\Tests\Models\CMS\CmsUser;
 use Doctrine\Tests\OrmTestCase;
 use stdClass;
@@ -124,11 +124,11 @@ class ParserTest extends OrmTestCase
          * but in LexerTest.
          */
         return [
-            [Lexer::T_WHERE, 'where'], // keyword
-            [Lexer::T_DOT, '.'], // token that cannot be an identifier
-            [Lexer::T_IDENTIFIER, 'someIdentifier'],
-            [Lexer::T_IDENTIFIER, 'from'], // also a terminal string (the "FROM" keyword) as in DDC-505
-            [Lexer::T_IDENTIFIER, 'comma'],
+            [TokenType::T_WHERE, 'where'], // keyword
+            [TokenType::T_DOT, '.'], // token that cannot be an identifier
+            [TokenType::T_IDENTIFIER, 'someIdentifier'],
+            [TokenType::T_IDENTIFIER, 'from'], // also a terminal string (the "FROM" keyword) as in DDC-505
+            [TokenType::T_IDENTIFIER, 'comma'],
             // not even a terminal string, but the name of a constant in the Lexer (whitebox test)
         ];
     }
@@ -137,15 +137,15 @@ class ParserTest extends OrmTestCase
     public static function invalidMatches(): array
     {
         return [
-            [Lexer::T_DOT, 'ALL'], // ALL is a terminal string (reserved keyword) and also possibly an identifier
-            [Lexer::T_DOT, ','], // "," is a token on its own, but cannot be used as identifier
-            [Lexer::T_WHERE, 'WITH'], // as in DDC-3697
-            [Lexer::T_WHERE, '.'],
+            [TokenType::T_DOT, 'ALL'], // ALL is a terminal string (reserved keyword) and also possibly an identifier
+            [TokenType::T_DOT, ','], // "," is a token on its own, but cannot be used as identifier
+            [TokenType::T_WHERE, 'WITH'], // as in DDC-3697
+            [TokenType::T_WHERE, '.'],
 
             // The following are qualified or aliased names and must not be accepted where only an Identifier is expected
-            [Lexer::T_IDENTIFIER, '\\Some\\Class'],
-            [Lexer::T_IDENTIFIER, 'Some\\Class'],
-            [Lexer::T_IDENTIFIER, 'Some:Name'],
+            [TokenType::T_IDENTIFIER, '\\Some\\Class'],
+            [TokenType::T_IDENTIFIER, 'Some\\Class'],
+            [TokenType::T_IDENTIFIER, 'Some:Name'],
         ];
     }
 
@@ -164,7 +164,7 @@ class ParserTest extends OrmTestCase
         $parser = new Parser($query);
 
         $this->expectException(QueryException::class);
-        $parser->match(Lexer::T_SELECT);
+        $parser->match(TokenType::T_SELECT);
     }
 
     private function createParser(string $dql): Parser

tests/Tests/ORM/Query/SelectSqlGenerationTest.php

@@ -18,10 +18,10 @@ use Doctrine\ORM\Mapping\Id;
 use Doctrine\ORM\Query as ORMQuery;
 use Doctrine\ORM\Query\AST\Functions\FunctionNode;
 use Doctrine\ORM\Query\AST\SimpleArithmeticExpression;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\QueryException;
 use Doctrine\ORM\Query\SqlWalker;
+use Doctrine\ORM\Query\TokenType;
 use Doctrine\Tests\DbalTypes\NegativeToPositiveType;
 use Doctrine\Tests\Models\CMS\CmsGroup;
 use Doctrine\Tests\Models\CMS\CmsPhonenumber;
@@ -2186,12 +2186,12 @@ class MyAbsFunction extends FunctionNode
     {
         $lexer = $parser->getLexer();
 
-        $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);
     }
 }
 /** @Entity */

tests/Tests/ORM/Query/TreeWalkerAdapterTest.php

@@ -7,8 +7,8 @@ namespace Doctrine\Tests\ORM\Query;
 use Doctrine\Deprecations\PHPUnit\VerifyDeprecations;
 use Doctrine\ORM\AbstractQuery;
 use Doctrine\ORM\Mapping\ClassMetadata;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\ParserResult;
+use Doctrine\ORM\Query\TokenType;
 use Doctrine\ORM\Query\TreeWalkerAdapter;
 use PHPUnit\Framework\TestCase;
 use stdClass;
@@ -33,7 +33,7 @@ class TreeWalkerAdapterTest extends TestCase
             'relation' => null,
             'map' => null,
             'nestingLevel' => 0,
-            'token' => ['value' => '', 'type' => Lexer::T_NONE, 'position' => 0],
+            'token' => ['value' => '', 'type' => TokenType::T_NONE, 'position' => 0],
         ]);
     }
 
@@ -52,7 +52,7 @@ class TreeWalkerAdapterTest extends TestCase
                     'relation' => null,
                     'map' => null,
                     'nestingLevel' => 0,
-                    'token' => ['value' => '', 'type' => Lexer::T_NONE, 'position' => 0],
+                    'token' => ['value' => '', 'type' => TokenType::T_NONE, 'position' => 0],
                 ]);
             }
         };

tests/Tests/ORM/Tools/SchemaToolTest.php

@@ -374,6 +374,27 @@ class SchemaToolTest extends OrmTestCase
         self::assertTrue($schema->hasTable('first_entity'), 'Table first_entity should exist.');
         self::assertFalse($schema->hasTable('second_entity'), 'Table second_entity should not exist.');
     }
+
+    /** @group GH-11314 */
+    public function testLoadUniqueConstraintWithoutName(): void
+    {
+        $em     = $this->getTestEntityManager();
+        $entity = $em->getClassMetadata(GH11314Entity::class);
+
+        $schemaTool = new SchemaTool($em);
+        $schema     = $schemaTool->getSchemaFromMetadata([$entity]);
+
+        self::assertTrue($schema->hasTable('GH11314Entity'));
+
+        $tableEntity = $schema->getTable('GH11314Entity');
+
+        self::assertTrue($tableEntity->hasIndex('uniq_2d81a3ed5bf54558875f7fd5'));
+
+        $tableIndex = $tableEntity->getIndex('uniq_2d81a3ed5bf54558875f7fd5');
+
+        self::assertTrue($tableIndex->isUnique());
+        self::assertSame(['field', 'anotherField'], $tableIndex->getColumns());
+    }
 }
 
 /**
@@ -559,6 +580,32 @@ class IndexByFieldEntity
     public $fieldName;
 }
 
+/**
+ * @Entity
+ * @Table(uniqueConstraints={@UniqueConstraint(columns={"field", "anotherField"})})
+ */
+class GH11314Entity
+{
+    /**
+     * @Column(type="integer")
+     * @Id
+     * @var int
+     */
+    private $id;
+
+    /**
+     * @Column(name="field", type="string")
+     * @var string
+     */
+    private $field;
+
+    /**
+     * @Column(name="anotherField", type="string")
+     * @var string
+     */
+    private $anotherField;
+}
+
 class IncorrectIndexByFieldEntity
 {
     /** @var int */

tests/Tests/ORM/Tools/SchemaValidatorTest.php

@@ -24,6 +24,7 @@ use Doctrine\ORM\Mapping\OneToOne;
 use Doctrine\ORM\Mapping\OrderBy;
 use Doctrine\ORM\Mapping\Table;
 use Doctrine\ORM\Tools\SchemaValidator;
+use Doctrine\Tests\Models\BigIntegers\BigIntegers;
 use Doctrine\Tests\Models\ECommerce\ECommerceCart;
 use Doctrine\Tests\OrmTestCase;
 
@@ -240,6 +241,19 @@ class SchemaValidatorTest extends OrmTestCase
             $ce
         );
     }
+
+    /**
+     * @requires PHP 7.4
+     */
+    public function testBigIntProperty(): void
+    {
+        $class = $this->em->getClassMetadata(BigIntegers::class);
+
+        self::assertSame(
+            ['The field \'Doctrine\Tests\Models\BigIntegers\BigIntegers#three\' has the property type \'float\' that differs from the metadata field type \'int|string\' returned by the \'bigint\' DBAL type.'],
+            $this->validator->validateClass($class)
+        );
+    }
 }
 
 /** @MappedSuperclass */