[
{
"path": ".doctrine-project.json",
"content": "{\n \"active\": true,\n \"name\": \"Object Relational Mapper\",\n \"shortName\": \"ORM\",\n \"slug\": \"orm\",\n \"docsSlug\": \"doctrine-orm\",\n \"versions\": [\n {\n \"name\": \"4.0\",\n \"branchName\": \"4.0.x\",\n \"slug\": \"latest\",\n \"upcoming\": true\n },\n {\n \"name\": \"3.7\",\n \"branchName\": \"3.7.x\",\n \"slug\": \"3.7\",\n \"upcoming\": true\n },\n {\n \"name\": \"3.6\",\n \"branchName\": \"3.6.x\",\n \"slug\": \"3.6\",\n \"current\": true\n },\n {\n \"name\": \"2.21\",\n \"branchName\": \"2.21.x\",\n \"slug\": \"2.21\",\n \"upcoming\": true\n },\n {\n \"name\": \"2.20\",\n \"branchName\": \"2.20.x\",\n \"slug\": \"2.20\",\n \"maintained\": true\n },\n {\n \"name\": \"2.19\",\n \"slug\": \"2.19\",\n \"maintained\": false\n },\n {\n \"name\": \"2.18\",\n \"slug\": \"2.18\",\n \"maintained\": false\n },\n {\n \"name\": \"2.17\",\n \"slug\": \"2.17\",\n \"maintained\": false\n },\n {\n \"name\": \"2.16\",\n \"slug\": \"2.16\",\n \"maintained\": false\n },\n {\n \"name\": \"2.15\",\n \"slug\": \"2.15\",\n \"maintained\": false\n },\n {\n \"name\": \"2.14\",\n \"slug\": \"2.14\",\n \"maintained\": false\n }\n ]\n}\n"
},
{
"path": ".gitattributes",
"content": "/.github export-ignore\n/ci export-ignore\n/docs export-ignore\n/tests export-ignore\n/tools export-ignore\n.doctrine-project.json export-ignore\n.gitattributes export-ignore\n.gitignore export-ignore\nbuild.properties export-ignore\nbuild.properties.dev export-ignore\nbuild.xml export-ignore\nCONTRIBUTING.md export-ignore\nphpunit.xml.dist export-ignore\nphpcs.xml.dist export-ignore\nphpbench.json export-ignore\nphpstan.neon export-ignore\nphpstan-baseline.neon export-ignore\nphpstan-dbal3.neon export-ignore\nphpstan-params.neon export-ignore\nphpstan-persistence2.neon export-ignore\n"
},
{
"path": ".github/PULL_REQUEST_TEMPLATE/Failing_Test.md",
"content": "---\nname: 🐞 Failing Test\nabout: You found a bug and have a failing Unit or Functional test? 🔨\n---\n\n### Failing Test\n\n\n\n| Q | A\n|------------ | ------\n| BC Break | yes/no\n| Version | x.y.z\n\n\n#### Summary\n\n\n\n"
},
{
"path": ".github/PULL_REQUEST_TEMPLATE/Improvement.md",
"content": "---\nname: ⚙ Improvement\nabout: You have some improvement to make Doctrine better? 🎁\n---\n\n### Improvement\n\n\n\n| Q | A\n|------------ | ------\n| New Feature | yes\n| RFC | yes/no\n| BC Break | yes/no\n\n#### Summary\n\n\n"
},
{
"path": ".github/PULL_REQUEST_TEMPLATE/New_Feature.md",
"content": "---\nname: 🎉 New Feature\nabout: You have implemented some neat idea that you want to make part of Doctrine? 🎩\n---\n\n\n\n### New Feature\n\n\n\n| Q | A\n|------------ | ------\n| New Feature | yes\n| RFC | yes/no\n| BC Break | yes/no\n\n#### Summary\n\n\n"
},
{
"path": ".github/dependabot.yml",
"content": "version: 2\nupdates:\n - package-ecosystem: \"github-actions\"\n directory: \"/\"\n schedule:\n interval: \"weekly\"\n labels:\n - \"CI\"\n target-branch: \"2.20.x\"\n"
},
{
"path": ".github/workflows/coding-standards.yml",
"content": "name: \"Coding Standards\"\n\non:\n pull_request:\n branches:\n - \"*.x\"\n paths:\n - .github/workflows/coding-standards.yml\n - bin/**\n - composer.*\n - src/**\n - phpcs.xml.dist\n - tests/**\n push:\n branches:\n - \"*.x\"\n paths:\n - .github/workflows/coding-standards.yml\n - bin/**\n - composer.*\n - src/**\n - phpcs.xml.dist\n - tests/**\n\njobs:\n coding-standards:\n uses: \"doctrine/.github/.github/workflows/coding-standards.yml@13.1.0\"\n"
},
{
"path": ".github/workflows/composer-lint.yml",
"content": "name: \"Composer Lint\"\n\non:\n pull_request:\n branches:\n - \"*.x\"\n paths:\n - \".github/workflows/composer-lint.yml\"\n - \"composer.json\"\n push:\n branches:\n - \"*.x\"\n paths:\n - \".github/workflows/composer-lint.yml\"\n - \"composer.json\"\n\njobs:\n composer-lint:\n name: \"Composer Lint\"\n uses: \"doctrine/.github/.github/workflows/composer-lint.yml@13.1.0\"\n"
},
{
"path": ".github/workflows/continuous-integration.yml",
"content": "name: \"CI: PHPUnit\"\n\non:\n pull_request:\n branches:\n - \"*.x\"\n paths:\n - .github/workflows/continuous-integration.yml\n - ci/**\n - composer.*\n - src/**\n - tests/**\n push:\n branches:\n - \"*.x\"\n paths:\n - .github/workflows/continuous-integration.yml\n - ci/**\n - composer.*\n - src/**\n - tests/**\n\nenv:\n fail-fast: true\n\njobs:\n phpunit-smoke-check:\n name: >\n SQLite -\n ${{ format('PHP {0} - DBAL {1} - ext. {2} - proxy {3}',\n matrix.php-version || 'Ø',\n matrix.dbal-version || 'Ø',\n matrix.extension || 'Ø',\n matrix.proxy || 'Ø'\n ) }}\n runs-on: \"ubuntu-22.04\"\n\n strategy:\n matrix:\n php-version:\n - \"8.1\"\n - \"8.2\"\n - \"8.3\"\n - \"8.4\"\n - \"8.5\"\n dbal-version:\n - \"default\"\n - \"3.7\"\n extension:\n - \"sqlite3\"\n - \"pdo_sqlite\"\n deps:\n - \"highest\"\n stability:\n - \"stable\"\n native_lazy:\n - \"0\"\n include:\n - php-version: \"8.2\"\n dbal-version: \"4@dev\"\n extension: \"pdo_sqlite\"\n stability: \"stable\"\n native_lazy: \"0\"\n - php-version: \"8.2\"\n dbal-version: \"4@dev\"\n extension: \"sqlite3\"\n stability: \"stable\"\n native_lazy: \"0\"\n - php-version: \"8.1\"\n dbal-version: \"default\"\n deps: \"lowest\"\n extension: \"pdo_sqlite\"\n stability: \"stable\"\n native_lazy: \"0\"\n - php-version: \"8.4\"\n dbal-version: \"default\"\n deps: \"highest\"\n extension: \"pdo_sqlite\"\n stability: \"stable\"\n native_lazy: \"1\"\n - php-version: \"8.4\"\n dbal-version: \"default\"\n deps: \"highest\"\n extension: \"sqlite3\"\n stability: \"dev\"\n native_lazy: \"1\"\n\n steps:\n - name: \"Checkout\"\n uses: \"actions/checkout@v6\"\n with:\n fetch-depth: 2\n\n - name: \"Install PHP\"\n uses: \"shivammathur/setup-php@v2\"\n with:\n php-version: \"${{ matrix.php-version }}\"\n extensions: \"apcu, pdo, ${{ matrix.extension }}\"\n coverage: \"pcov\"\n ini-values: \"zend.assertions=1, apc.enable_cli=1\"\n\n - name: \"Allow dev dependencies\"\n run: |\n composer config minimum-stability dev\n composer remove --no-update --dev phpbench/phpbench phpdocumentor/guides-cli\n composer require --no-update symfony/console:^8 symfony/var-exporter:^8 doctrine/dbal:^4.4\n composer require --dev --no-update symfony/cache:^8\n if: \"${{ matrix.stability == 'dev' }}\"\n\n - name: \"Require specific DBAL version\"\n run: \"composer require doctrine/dbal ^${{ matrix.dbal-version }} --no-update\"\n if: \"${{ matrix.dbal-version != 'default' }}\"\n\n - name: \"Downgrade VarExporter\"\n run: 'composer require --no-update \"symfony/var-exporter:^6.4 || ^7.4\"'\n if: \"${{ matrix.native_lazy == '0' }}\"\n\n - name: \"Install dependencies with Composer\"\n uses: \"ramsey/composer-install@v3\"\n with:\n composer-options: \"--ignore-platform-req=php+\"\n dependency-versions: \"${{ matrix.deps }}\"\n\n - name: \"Run PHPUnit\"\n run: \"vendor/bin/phpunit -c ci/github/phpunit/${{ matrix.extension }}.xml --coverage-clover=coverage-no-cache.xml\"\n env:\n ENABLE_SECOND_LEVEL_CACHE: 0\n ENABLE_NATIVE_LAZY_OBJECTS: ${{ matrix.native_lazy }}\n\n - name: \"Run PHPUnit with Second Level Cache and PHPUnit 10\"\n run: |\n vendor/bin/phpunit -c ci/github/phpunit/${{ matrix.extension }}.xml \\\n --exclude-group=performance,non-cacheable,locking_functional \\\n --coverage-clover=coverage-cache.xml\n if: \"${{ matrix.php-version == '8.1' }}\"\n env:\n ENABLE_SECOND_LEVEL_CACHE: 1\n ENABLE_NATIVE_LAZY_OBJECTS: ${{ matrix.native_lazy }}\n\n - name: \"Run PHPUnit with Second Level Cache and PHPUnit 11+\"\n run: |\n vendor/bin/phpunit -c ci/github/phpunit/${{ matrix.extension }}.xml \\\n --exclude-group=performance \\\n --exclude-group=non-cacheable \\\n --exclude-group=locking_functional \\\n --coverage-clover=coverage-cache.xml\n if: \"${{ matrix.php-version != '8.1' }}\"\n env:\n ENABLE_SECOND_LEVEL_CACHE: 1\n ENABLE_NATIVE_LAZY_OBJECTS: ${{ matrix.native_lazy }}\n\n - name: \"Upload coverage file\"\n uses: \"actions/upload-artifact@v7\"\n with:\n name: \"phpunit-${{ matrix.extension }}-${{ matrix.php-version }}-${{ matrix.dbal-version }}-${{ matrix.deps }}-${{ matrix.stability }}-${{ matrix.native_lazy }}-coverage\"\n path: \"coverage*.xml\"\n\n\n phpunit-deprecations:\n name: \"PHPUnit (fail on deprecations)\"\n runs-on: \"ubuntu-24.04\"\n\n steps:\n - name: \"Checkout\"\n uses: \"actions/checkout@v5\"\n with:\n fetch-depth: 2\n\n - name: \"Install PHP\"\n uses: \"shivammathur/setup-php@v2\"\n with:\n php-version: \"8.5\"\n extensions: \"apcu, pdo, sqlite3\"\n coverage: \"pcov\"\n ini-values: \"zend.assertions=1, apc.enable_cli=1\"\n\n - name: \"Allow dev dependencies\"\n run: composer config minimum-stability dev\n\n - name: \"Install dependencies with Composer\"\n uses: \"ramsey/composer-install@v3\"\n with:\n composer-options: \"--ignore-platform-req=php+\"\n dependency-versions: \"highest\"\n\n - name: \"Run PHPUnit\"\n run: \"vendor/bin/phpunit -c ci/github/phpunit/sqlite3.xml --fail-on-deprecation\"\n env:\n ENABLE_SECOND_LEVEL_CACHE: 0\n ENABLE_NATIVE_LAZY_OBJECTS: 1\n\n\n phpunit-postgres:\n name: >\n ${{ format('PostgreSQL {0} - PHP {1} - DBAL {2} - ext. {3}',\n matrix.postgres-version || 'Ø',\n matrix.php-version || 'Ø',\n matrix.dbal-version || 'Ø',\n matrix.extension || 'Ø'\n ) }}\n runs-on: \"ubuntu-22.04\"\n needs: \"phpunit-smoke-check\"\n\n strategy:\n matrix:\n php-version:\n - \"8.2\"\n - \"8.3\"\n - \"8.4\"\n - \"8.5\"\n dbal-version:\n - \"default\"\n - \"3.7\"\n postgres-version:\n - \"17\"\n extension:\n - pdo_pgsql\n - pgsql\n include:\n - php-version: \"8.2\"\n dbal-version: \"4@dev\"\n postgres-version: \"14\"\n extension: pdo_pgsql\n - php-version: \"8.2\"\n dbal-version: \"3.7\"\n postgres-version: \"9.6\"\n extension: pdo_pgsql\n\n services:\n postgres:\n image: \"postgres:${{ matrix.postgres-version }}\"\n env:\n POSTGRES_PASSWORD: \"postgres\"\n\n options: >-\n --health-cmd \"pg_isready\"\n\n ports:\n - \"5432:5432\"\n\n steps:\n - name: \"Checkout\"\n uses: \"actions/checkout@v6\"\n with:\n fetch-depth: 2\n\n - name: \"Install PHP\"\n uses: \"shivammathur/setup-php@v2\"\n with:\n php-version: \"${{ matrix.php-version }}\"\n extensions: \"pgsql pdo_pgsql\"\n coverage: \"pcov\"\n ini-values: \"zend.assertions=1, apc.enable_cli=1\"\n\n - name: \"Require specific DBAL version\"\n run: \"composer require doctrine/dbal ^${{ matrix.dbal-version }} --no-update\"\n if: \"${{ matrix.dbal-version != 'default' }}\"\n\n - name: \"Install dependencies with Composer\"\n uses: \"ramsey/composer-install@v3\"\n with:\n composer-options: \"--ignore-platform-req=php+\"\n\n - name: \"Run PHPUnit\"\n run: \"vendor/bin/phpunit -c ci/github/phpunit/pdo_pgsql.xml --coverage-clover=coverage.xml\"\n\n - name: \"Upload coverage file\"\n uses: \"actions/upload-artifact@v7\"\n with:\n name: \"${{ github.job }}-${{ matrix.postgres-version }}-${{ matrix.php-version }}-${{ matrix.dbal-version }}-${{ matrix.extension }}-coverage\"\n path: \"coverage.xml\"\n\n\n phpunit-mariadb:\n name: >\n ${{ format('MariaDB {0} - PHP {1} - DBAL {2} - ext. {3}',\n matrix.mariadb-version || 'Ø',\n matrix.php-version || 'Ø',\n matrix.dbal-version || 'Ø',\n matrix.extension || 'Ø'\n ) }}\n runs-on: \"ubuntu-22.04\"\n needs: \"phpunit-smoke-check\"\n\n strategy:\n matrix:\n php-version:\n - \"8.2\"\n - \"8.3\"\n - \"8.4\"\n - \"8.5\"\n dbal-version:\n - \"default\"\n - \"3.7\"\n - \"4@dev\"\n mariadb-version:\n - \"11.4\"\n extension:\n - \"mysqli\"\n - \"pdo_mysql\"\n\n services:\n mariadb:\n image: \"mariadb:${{ matrix.mariadb-version }}\"\n env:\n MARIADB_ALLOW_EMPTY_ROOT_PASSWORD: yes\n MARIADB_DATABASE: \"doctrine_tests\"\n\n options: >-\n --health-cmd \"healthcheck.sh --connect --innodb_initialized\"\n\n ports:\n - \"3306:3306\"\n\n steps:\n - name: \"Checkout\"\n uses: \"actions/checkout@v6\"\n with:\n fetch-depth: 2\n\n - name: \"Require specific DBAL version\"\n run: \"composer require doctrine/dbal ^${{ matrix.dbal-version }} --no-update\"\n if: \"${{ matrix.dbal-version != 'default' }}\"\n\n - name: \"Install PHP\"\n uses: \"shivammathur/setup-php@v2\"\n with:\n php-version: \"${{ matrix.php-version }}\"\n coverage: \"pcov\"\n ini-values: \"zend.assertions=1, apc.enable_cli=1\"\n extensions: \"${{ matrix.extension }}\"\n\n - name: \"Install dependencies with Composer\"\n uses: \"ramsey/composer-install@v3\"\n with:\n composer-options: \"--ignore-platform-req=php+\"\n\n - name: \"Run PHPUnit\"\n run: \"vendor/bin/phpunit -c ci/github/phpunit/${{ matrix.extension }}.xml --coverage-clover=coverage.xml\"\n\n - name: \"Upload coverage file\"\n uses: \"actions/upload-artifact@v7\"\n with:\n name: \"${{ github.job }}-${{ matrix.mariadb-version }}-${{ matrix.extension }}-${{ matrix.php-version }}-${{ matrix.dbal-version }}-coverage\"\n path: \"coverage.xml\"\n\n\n phpunit-mysql:\n name: >\n ${{ format('MySQL {0} - PHP {1} - DBAL {2} - ext. {3}',\n matrix.mysql-version || 'Ø',\n matrix.php-version || 'Ø',\n matrix.dbal-version || 'Ø',\n matrix.extension || 'Ø'\n ) }}\n runs-on: \"ubuntu-22.04\"\n needs: \"phpunit-smoke-check\"\n\n strategy:\n matrix:\n php-version:\n - \"8.2\"\n - \"8.3\"\n - \"8.4\"\n - \"8.5\"\n dbal-version:\n - \"default\"\n - \"3.7\"\n mysql-version:\n - \"5.7\"\n - \"8.0\"\n extension:\n - \"mysqli\"\n - \"pdo_mysql\"\n include:\n - php-version: \"8.2\"\n dbal-version: \"4@dev\"\n mysql-version: \"8.0\"\n extension: \"mysqli\"\n - php-version: \"8.2\"\n dbal-version: \"4@dev\"\n mysql-version: \"8.0\"\n extension: \"pdo_mysql\"\n\n services:\n mysql:\n image: \"mysql:${{ matrix.mysql-version }}\"\n\n options: >-\n --health-cmd \"mysqladmin ping --silent\"\n -e MYSQL_ALLOW_EMPTY_PASSWORD=yes\n -e MYSQL_DATABASE=doctrine_tests\n\n ports:\n - \"3306:3306\"\n\n steps:\n - name: \"Checkout\"\n uses: \"actions/checkout@v6\"\n with:\n fetch-depth: 2\n\n - name: \"Install PHP\"\n uses: \"shivammathur/setup-php@v2\"\n with:\n php-version: \"${{ matrix.php-version }}\"\n coverage: \"pcov\"\n ini-values: \"zend.assertions=1, apc.enable_cli=1\"\n extensions: \"${{ matrix.extension }}\"\n\n - name: \"Require specific DBAL version\"\n run: \"composer require doctrine/dbal ^${{ matrix.dbal-version }} --no-update\"\n if: \"${{ matrix.dbal-version != 'default' }}\"\n\n - name: \"Install dependencies with Composer\"\n uses: \"ramsey/composer-install@v3\"\n with:\n composer-options: \"--ignore-platform-req=php+\"\n\n - name: \"Run PHPUnit\"\n run: \"vendor/bin/phpunit -c ci/github/phpunit/${{ matrix.extension }}.xml --coverage-clover=coverage-no-cache.xml\"\n env:\n ENABLE_SECOND_LEVEL_CACHE: 0\n\n - name: \"Run PHPUnit with Second Level Cache and PHPUnit 10\"\n run: |\n vendor/bin/phpunit -c ci/github/phpunit/${{ matrix.extension }}.xml \\\n --exclude-group=performance,non-cacheable,locking_functional \\\n --coverage-clover=coverage-no-cache.xml\"\n if: \"${{ matrix.php-version == '8.1' }}\"\n env:\n ENABLE_SECOND_LEVEL_CACHE: 1\n - name: \"Run PHPUnit with Second Level Cache and PHPUnit 11+\"\n run: |\n vendor/bin/phpunit -c ci/github/phpunit/${{ matrix.extension }}.xml \\\n --exclude-group=performance \\\n --exclude-group=non-cacheable \\\n --exclude-group=locking_functional \\\n --coverage-clover=coverage-no-cache.xml\n if: \"${{ matrix.php-version != '8.1' }}\"\n env:\n ENABLE_SECOND_LEVEL_CACHE: 1\n\n - name: \"Upload coverage files\"\n uses: \"actions/upload-artifact@v7\"\n with:\n name: \"${{ github.job }}-${{ matrix.mysql-version }}-${{ matrix.extension }}-${{ matrix.php-version }}-${{ matrix.dbal-version }}-coverage\"\n path: \"coverage*.xml\"\n\n upload_coverage:\n name: \"Upload coverage to Codecov\"\n runs-on: \"ubuntu-22.04\"\n # Only run on PRs from forks\n if: \"github.event.pull_request.head.repo.full_name != github.repository\"\n needs:\n - \"phpunit-smoke-check\"\n - \"phpunit-postgres\"\n - \"phpunit-mariadb\"\n - \"phpunit-mysql\"\n\n steps:\n - name: \"Checkout\"\n uses: \"actions/checkout@v6\"\n with:\n fetch-depth: 2\n\n - name: \"Download coverage files\"\n uses: \"actions/download-artifact@v8\"\n with:\n path: \"reports\"\n\n - name: \"Upload to Codecov\"\n uses: \"codecov/codecov-action@v5\"\n with:\n directory: reports\n env:\n CODECOV_TOKEN: \"${{ secrets.CODECOV_TOKEN }}\"\n"
},
{
"path": ".github/workflows/documentation.yml",
"content": "name: \"Documentation\"\n\non:\n pull_request:\n branches:\n - \"*.x\"\n paths:\n - \".github/workflows/documentation.yml\"\n - \"docs/**\"\n push:\n branches:\n - \"*.x\"\n paths:\n - \".github/workflows/documentation.yml\"\n - \"docs/**\"\n\njobs:\n documentation:\n name: \"Documentation\"\n uses: \"doctrine/.github/.github/workflows/documentation.yml@13.1.0\"\n"
},
{
"path": ".github/workflows/phpbench.yml",
"content": "\nname: \"Performance benchmark\"\n\non:\n pull_request:\n branches:\n - \"*.x\"\n paths:\n - .github/workflows/phpbench.yml\n - composer.*\n - src/**\n - phpbench.json\n - tests/**\n push:\n branches:\n - \"*.x\"\n paths:\n - .github/workflows/phpbench.yml\n - composer.*\n - src/**\n - phpbench.json\n - tests/**\n\nenv:\n fail-fast: true\n\njobs:\n phpbench:\n name: \"PHPBench\"\n runs-on: \"ubuntu-22.04\"\n\n strategy:\n matrix:\n php-version:\n - \"8.1\"\n\n steps:\n - name: \"Checkout\"\n uses: \"actions/checkout@v6\"\n with:\n fetch-depth: 2\n\n - name: \"Install PHP\"\n uses: \"shivammathur/setup-php@v2\"\n with:\n php-version: \"${{ matrix.php-version }}\"\n coverage: \"pcov\"\n ini-values: \"zend.assertions=1, apc.enable_cli=1\"\n\n - name: \"Install dependencies with Composer\"\n uses: \"ramsey/composer-install@v3\"\n\n - name: \"Run PHPBench\"\n run: \"vendor/bin/phpbench run --report=default\"\n"
},
{
"path": ".github/workflows/release-on-milestone-closed.yml",
"content": "name: \"Automatic Releases\"\n\non:\n milestone:\n types:\n - \"closed\"\n\njobs:\n release:\n uses: \"doctrine/.github/.github/workflows/release-on-milestone-closed.yml@13.1.0\"\n secrets:\n GIT_AUTHOR_EMAIL: ${{ secrets.GIT_AUTHOR_EMAIL }}\n GIT_AUTHOR_NAME: ${{ secrets.GIT_AUTHOR_NAME }}\n ORGANIZATION_ADMIN_TOKEN: ${{ secrets.ORGANIZATION_ADMIN_TOKEN }}\n SIGNING_SECRET_KEY: ${{ secrets.SIGNING_SECRET_KEY }}\n"
},
{
"path": ".github/workflows/stale.yml",
"content": "name: 'Close stale pull requests'\non:\n schedule:\n - cron: '0 3 * * *'\n\njobs:\n stale:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/stale@v9\n with:\n stale-pr-message: >\n There hasn't been any activity on this pull request in the past 90 days, so\n it has been marked as stale and it will be closed automatically if no\n further activity occurs in the next 7 days.\n\n If you want to continue working on it, please leave a comment.\n\n close-pr-message: >\n This pull request was closed due to inactivity.\n\n days-before-stale: -1\n days-before-pr-stale: 90\n days-before-pr-close: 7\n"
},
{
"path": ".github/workflows/static-analysis.yml",
"content": "name: \"Static Analysis\"\n\non:\n pull_request:\n branches:\n - \"*.x\"\n paths:\n - .github/workflows/static-analysis.yml\n - composer.*\n - src/**\n - phpstan*\n - tests/StaticAnalysis/**\n push:\n branches:\n - \"*.x\"\n paths:\n - .github/workflows/static-analysis.yml\n - composer.*\n - src/**\n - phpstan*\n - tests/StaticAnalysis/**\n\njobs:\n static-analysis-phpstan:\n name: Static Analysis with PHPStan\n runs-on: ubuntu-22.04\n\n strategy:\n matrix:\n include:\n - dbal-version: default\n config: phpstan.neon\n - dbal-version: 3.8.2\n config: phpstan-dbal3.neon\n\n steps:\n - name: \"Checkout code\"\n uses: \"actions/checkout@v6\"\n\n - name: Install PHP\n uses: shivammathur/setup-php@v2\n with:\n coverage: none\n php-version: \"8.4\"\n tools: cs2pr\n\n - name: Require specific DBAL version\n run: \"composer require doctrine/dbal ^${{ matrix.dbal-version }} --no-update\"\n if: \"${{ matrix.dbal-version != 'default' }}\"\n\n\n - name: Install dependencies with Composer\n uses: ramsey/composer-install@v2\n\n - name: Run static analysis with phpstan/phpstan\n run: \"vendor/bin/phpstan analyse -c ${{ matrix.config }} --error-format=checkstyle | cs2pr\"\n"
},
{
"path": ".github/workflows/website-schema.yml",
"content": "\nname: \"Website config validation\"\n\non:\n pull_request:\n branches:\n - \"*.x\"\n paths:\n - \".doctrine-project.json\"\n - \".github/workflows/website-schema.yml\"\n push:\n branches:\n - \"*.x\"\n paths:\n - \".doctrine-project.json\"\n - \".github/workflows/website-schema.yml\"\n\njobs:\n json-validate:\n name: \"Validate JSON schema\"\n uses: \"doctrine/.github/.github/workflows/website-schema.yml@7.1.0\"\n"
},
{
"path": ".gitignore",
"content": "build/\nlogs/\nreports/\ndist/\ndownload/\n/.settings/\n.buildpath\n.project\n.idea\n*.iml\nvendor/\n/tests/Doctrine/Performance/history.db\n/.phpcs-cache\ncomposer.lock\n.phpunit.cache\n.phpunit.result.cache\n/*.phpunit.xml\n"
},
{
"path": "CONTRIBUTING.md",
"content": "# Contribute to Doctrine\n\nThank you for contributing to Doctrine!\n\nBefore we can merge your Pull-Request here are some guidelines that you need to follow.\nThese guidelines exist not to annoy you, but to keep the code base clean,\nunified and future proof.\n\nDoctrine has [general contributing guidelines][contributor workflow], make\nsure you follow them.\n\n[contributor workflow]: https://www.doctrine-project.org/contribute/index.html\n\n## Coding Standard\n\nThis project follows [`doctrine/coding-standard`][coding standard homepage].\nYou may fix many some of the issues with `vendor/bin/phpcbf`.\n\n[coding standard homepage]: https://github.com/doctrine/coding-standard\n\n## Unit-Tests\n\nPlease try to add a test for your pull-request.\n\n* If you want to fix a bug or provide a reproduce case, create a test file in\n ``tests/Tests/ORM/Functional/Ticket`` with the name of the ticket,\n ``DDC1234Test.php`` for example.\n* If you want to contribute new functionality add unit- or functional tests\n depending on the scope of the feature.\n\nYou can run the unit-tests by calling ``vendor/bin/phpunit`` from the root of the project.\nIt will run all the tests with an in memory SQLite database.\n\nIn order to do that, you will need a fresh copy of the ORM, and you\nwill have to run a composer installation in the project:\n\n```sh\ngit clone git@github.com:doctrine/orm.git\ncd orm\ncomposer install\n```\n\nYou will also need to enable the PHP extension that provides the SQLite driver\nfor PDO: `pdo_sqlite`. How to do so depends on your system, but checking that it\nis enabled can universally be done with `php -m`: that command should list the\nextension.\n\nTo run the testsuite against another database, copy the ``phpunit.xml.dist``\nto for example ``mysql.phpunit.xml`` and edit the parameters. You can\ntake a look at the ``ci/github/phpunit`` directory for some examples. Then run:\n\n vendor/bin/phpunit -c mysql.phpunit.xml\n\nIf you do not provide these parameters, the test suite will use an in-memory\nsqlite database.\n\nTips for creating unit tests:\n\n1. If you put a test into the `Ticket` namespace as described above, put the testcase and all entities into the same class.\n See `https://github.com/doctrine/orm/tree/3.0.x/tests/Tests/ORM/Functional/Ticket/DDC2306Test.php` for an\n example.\n\n## Getting merged\n\nPlease allow us time to review your pull requests. We will give our best to review\neverything as fast as possible, but cannot always live up to our own expectations.\n\nThank you very much again for your contribution!\n\n"
},
{
"path": "LICENSE",
"content": "Copyright (c) Doctrine Project\n\nPermission is hereby granted, free of charge, to any person obtaining a copy of\nthis software and associated documentation files (the \"Software\"), to deal in\nthe Software without restriction, including without limitation the rights to\nuse, copy, modify, merge, publish, distribute, sublicense, and/or sell copies\nof the Software, and to permit persons to whom the Software is furnished to do\nso, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n"
},
{
"path": "README.md",
"content": "| [4.0.x][4.0] | [3.7.x][3.7] | [3.6.x][3.6] | [2.21.x][2.21] | [2.20.x][2.20] |\n|:------------------------------------------------------:|:------------------------------------------------------:|:------------------------------------------------------:|:--------------------------------------------------------:|:--------------------------------------------------------:|\n| [![Build status][4.0 image]][4.0 workflow] | [![Build status][3.7 image]][3.7 workflow] | [![Build status][3.6 image]][3.6 workflow] | [![Build status][2.21 image]][2.21 workflow] | [![Build status][2.20 image]][2.20 workflow] |\n| [![Coverage Status][4.0 coverage image]][4.0 coverage] | [![Coverage Status][3.7 coverage image]][3.7 coverage] | [![Coverage Status][3.6 coverage image]][3.6 coverage] | [![Coverage Status][2.21 coverage image]][2.21 coverage] | [![Coverage Status][2.20 coverage image]][2.20 coverage] |\n\nDoctrine ORM is an object-relational mapper for PHP 8.1+ that provides transparent persistence\nfor PHP objects. It sits on top of a powerful database abstraction layer (DBAL). One of its key features\nis the option to write database queries in a proprietary object oriented SQL dialect called Doctrine Query Language (DQL),\ninspired by Hibernate's HQL. This provides developers with a powerful alternative to SQL that maintains flexibility\nwithout requiring unnecessary code duplication.\n\n\n## More resources:\n\n* [Website](http://www.doctrine-project.org)\n* [Documentation](https://www.doctrine-project.org/projects/doctrine-orm/en/stable/index.html)\n\n\n [4.0 image]: https://github.com/doctrine/orm/actions/workflows/continuous-integration.yml/badge.svg?branch=4.0.x\n [4.0]: https://github.com/doctrine/orm/tree/4.0.x\n [4.0 workflow]: https://github.com/doctrine/orm/actions/workflows/continuous-integration.yml?query=branch%3A4.0.x\n [4.0 coverage image]: https://codecov.io/gh/doctrine/orm/branch/4.0.x/graph/badge.svg\n [4.0 coverage]: https://codecov.io/gh/doctrine/orm/branch/4.0.x\n [3.7 image]: https://github.com/doctrine/orm/actions/workflows/continuous-integration.yml/badge.svg?branch=3.7.x\n [3.7]: https://github.com/doctrine/orm/tree/3.7.x\n [3.7 workflow]: https://github.com/doctrine/orm/actions/workflows/continuous-integration.yml?query=branch%3A3.7.x\n [3.7 coverage image]: https://codecov.io/gh/doctrine/orm/branch/3.7.x/graph/badge.svg\n [3.7 coverage]: https://codecov.io/gh/doctrine/orm/branch/3.7.x\n [3.6 image]: https://github.com/doctrine/orm/actions/workflows/continuous-integration.yml/badge.svg?branch=3.6.x\n [3.6]: https://github.com/doctrine/orm/tree/3.6.x\n [3.6 workflow]: https://github.com/doctrine/orm/actions/workflows/continuous-integration.yml?query=branch%3A3.6.x\n [3.6 coverage image]: https://codecov.io/gh/doctrine/orm/branch/3.6.x/graph/badge.svg\n [3.6 coverage]: https://codecov.io/gh/doctrine/orm/branch/3.6.x\n [2.21 image]: https://github.com/doctrine/orm/actions/workflows/continuous-integration.yml/badge.svg?branch=2.21.x\n [2.21]: https://github.com/doctrine/orm/tree/2.21.x\n [2.21 workflow]: https://github.com/doctrine/orm/actions/workflows/continuous-integration.yml?query=branch%3A2.21.x\n [2.21 coverage image]: https://codecov.io/gh/doctrine/orm/branch/2.21.x/graph/badge.svg\n [2.21 coverage]: https://codecov.io/gh/doctrine/orm/branch/2.21.x\n [2.20 image]: https://github.com/doctrine/orm/actions/workflows/continuous-integration.yml/badge.svg?branch=2.20.x\n [2.20]: https://github.com/doctrine/orm/tree/2.20.x\n [2.20 workflow]: https://github.com/doctrine/orm/actions/workflows/continuous-integration.yml?query=branch%3A2.20.x\n [2.20 coverage image]: https://codecov.io/gh/doctrine/orm/branch/2.20.x/graph/badge.svg\n [2.20 coverage]: https://codecov.io/gh/doctrine/orm/branch/2.20.x\n"
},
{
"path": "SECURITY.md",
"content": "Security\n========\n\nThe Doctrine library is operating very close to your database and as such needs\nto handle and make assumptions about SQL injection vulnerabilities.\n\nIt is vital that you understand how Doctrine approaches security, because\nwe cannot protect you from SQL injection.\n\nPlease read the documentation chapter on Security in Doctrine DBAL and ORM to\nunderstand the assumptions we make.\n\n- [DBAL Security Page](https://www.doctrine-project.org/projects/doctrine-dbal/en/stable/reference/security.html)\n- [ORM Security Page](https://www.doctrine-project.org/projects/doctrine-orm/en/stable/reference/security.html)\n\nIf you find a Security bug in Doctrine, please follow our\n[Security reporting guidelines](https://www.doctrine-project.org/policies/security.html#reporting).\n"
},
{
"path": "UPGRADE.md",
"content": "Note about upgrading: Doctrine uses static and runtime mechanisms to raise\nawareness about deprecated code.\n\n- Use of `@deprecated` docblock that is detected by IDEs (like PHPStorm) or\n Static Analysis tools (like Psalm, phpstan)\n- Use of our low-overhead runtime deprecation API, details:\n https://github.com/doctrine/deprecations/\n\n# Upgrade to 3.x General Notes\n\nWe recommend you upgrade to DBAL 3 first before upgrading to ORM 3. See\nthe DBAL upgrade docs: https://github.com/doctrine/dbal/blob/3.10.x/UPGRADE.md\n\nRather than doing several major upgrades at once, we recommend you do the following:\n\n- upgrade to DBAL 3\n- deploy and monitor\n- upgrade to ORM 3\n- deploy and monitor\n- upgrade to DBAL 4\n- deploy and monitor\n\nIf you are using Symfony, the recommended minimal Doctrine Bundle version is 2.15\nto run with ORM 3.\n\nAt this point, we recommend upgrading to PHP 8.4 first and then directly from\nORM 2.19 to 3.5 and up so that you can skip the lazy ghost proxy generation\nand directly start using native lazy objects.\n\n# Upgrade to 3.6\n\n## Deprecate using string expression for default values in mappings\n\nUsing a string expression for default values in field mappings is deprecated.\nUse `Doctrine\\DBAL\\Schema\\DefaultExpression` instances instead.\n\nHere is how to address this deprecation when mapping entities using PHP attributes:\n\n```diff\n use DateTime;\n+use Doctrine\\DBAL\\Schema\\DefaultExpression\\CurrentDate;\n+use Doctrine\\DBAL\\Schema\\DefaultExpression\\CurrentTime;\n+use Doctrine\\DBAL\\Schema\\DefaultExpression\\CurrentTimestamp;\n use Doctrine\\ORM\\Mapping as ORM;\n\n #[ORM\\Entity]\n final class TimeEntity\n {\n #[ORM\\Id]\n #[ORM\\Column]\n public int $id;\n\n- #[ORM\\Column(options: ['default' => 'CURRENT_TIMESTAMP'], insertable: false, updatable: false)]\n+ #[ORM\\Column(options: ['default' => new CurrentTimestamp()], insertable: false, updatable: false)]\n public DateTime $createdAt;\n\n- #[ORM\\Column(options: ['default' => 'CURRENT_TIME'], insertable: false, updatable: false)]\n+ #[ORM\\Column(options: ['default' => new CurrentTime()], insertable: false, updatable: false)]\n public DateTime $createdTime;\n\n- #[ORM\\Column(options: ['default' => 'CURRENT_DATE'], insertable: false, updatable: false)]\n+ #[ORM\\Column(options: ['default' => new CurrentDate()], insertable: false, updatable: false)]\n public DateTime $createdDate;\n }\n```\n\nHere is how to do the same when mapping entities using XML:\n\n```diff\n \n\n \n\n \n \n \n \n\n \n \n- \n+ \n \n \n\n \n \n- \n+ \n \n \n\n \n \n- \n+ \n \n \n \n \n- \n+ \n \n \n \n \n```\n\n\n## Deprecate `FieldMapping::$default`\n\nThe `default` property of `Doctrine\\ORM\\Mapping\\FieldMapping` is deprecated and\nwill be removed in 4.0. Instead, use `FieldMapping::$options['default']`.\n\n## Deprecate specifying `nullable` on columns that end up being used in a primary key\n\nSpecifying `nullable` on join columns that are part of a primary key is\ndeprecated and will be an error in 4.0.\n\nThis can happen when using a join column mapping together with an id mapping,\nor when using a join column mapping or an inverse join column mapping on a\nmany-to-many relationship.\n\n```diff\n class User\n {\n #[ORM\\Id]\n #[ORM\\Column(type: 'integer')]\n private int $id;\n\n #[ORM\\Id]\n #[ORM\\ManyToOne(targetEntity: Family::class, inversedBy: 'users')]\n- #[ORM\\JoinColumn(name: 'family_id', referencedColumnName: 'id', nullable: true)]\n+ #[ORM\\JoinColumn(name: 'family_id', referencedColumnName: 'id')]\n private ?Family $family;\n\n #[ORM\\ManyToMany(targetEntity: Group::class)]\n #[ORM\\JoinTable(name: 'user_group')]\n- #[ORM\\JoinColumn(name: 'user_id', referencedColumnName: 'id', nullable: true)]\n- #[ORM\\InverseJoinColumn(name: 'group_id', referencedColumnName: 'id', nullable: true)]\n+ #[ORM\\JoinColumn(name: 'user_id', referencedColumnName: 'id')]\n+ #[ORM\\InverseJoinColumn(name: 'group_id', referencedColumnName: 'id')]\n private Collection $groups;\n }\n```\n\n## Deprecate `Doctrine\\ORM\\QueryBuilder::add('join', ...)` with a list of join parts\n\nUsing `Doctrine\\ORM\\QueryBuilder::add('join', ...)` with a list of join parts\nis deprecated in favor of using an associative array of join parts with the\nroot alias as key.\n\n## Deprecate using the `WITH` keyword for arbitrary DQL joins\n\nUsing the `WITH` keyword to specify the condition for an arbitrary DQL join is\ndeprecated in favor of using the `ON` keyword (similar to the SQL syntax for\njoins).\nThe `WITH` keyword is now meant to be used only for filtering conditions in\nassociation joins.\n\n# Upgrade to 3.5\n\nSee the General notes to upgrading to 3.x versions above.\n\n## Deprecate not using native lazy objects on PHP 8.4+\n\nHaving native lazy objects disabled on PHP 8.4+ is deprecated and will not be\npossible in 4.0.\n\nYou can enable them through configuration:\n\n```php\n$config->enableNativeLazyObjects(true);\n```\n\nAs a consequence, methods, parameters and commands related to userland lazy\nobjects have been deprecated on PHP 8.4+:\n\n- `Doctrine\\ORM\\Tools\\Console\\Command\\GenerateProxiesCommand`\n- `Doctrine\\ORM\\Configuration::getAutoGenerateProxyClasses()`\n- `Doctrine\\ORM\\Configuration::getProxyDir()`\n- `Doctrine\\ORM\\Configuration::getProxyNamespace()`\n- `Doctrine\\ORM\\Configuration::setAutoGenerateProxyClasses()`\n- `Doctrine\\ORM\\Configuration::setProxyDir()`\n- `Doctrine\\ORM\\Configuration::setProxyNamespace()`\n- Passing more than one argument to `Doctrine\\ORM\\Proxy\\ProxyFactory::__construct()`\n\nAdditionally, some methods of ORMSetup have been deprecated in favor of a new\ncounterpart.\n\n- `Doctrine\\ORM\\ORMSetup::createAttributeMetadataConfiguration()` is deprecated in favor of\n `Doctrine\\ORM\\ORMSetup::createAttributeMetadataConfig()`\n- `Doctrine\\ORM\\ORMSetup::createXMLMetadataConfiguration()` is deprecated in favor of\n `Doctrine\\ORM\\ORMSetup::createXMLMetadataConfig()`\n- `Doctrine\\ORM\\ORMSetup::createConfiguration()` is deprecated in favor of\n `Doctrine\\ORM\\ORMSetup::createConfig()`\n\n## Deprecate methods for configuring no longer configurable features\n\nSince 3.0, lazy ghosts are enabled unconditionally, and so is rejecting ID\ncollisions in the identity map.\n\nAs a consequence, the following methods are deprecated and will be removed in 4.0:\n* `Doctrine\\ORM\\Configuration::setLazyGhostObjectEnabled()`\n* `Doctrine\\ORM\\Configuration::isLazyGhostObjectEnabled()`\n* `Doctrine\\ORM\\Configuration::setRejectIdCollisionInIdentityMap()`\n* `Doctrine\\ORM\\Configuration::isRejectIdCollisionInIdentityMapEnabled()`\n\n# Upgrade to 3.4.1\n\n## BC BREAK: You can no longer use the `.*` notation to get all fields of an entity in a DTO\n\nThis feature was introduced in 3.4.0, and introduces several issues, so we\ndecide to remove it before it is used too widely.\n\n# Upgrade to 3.4\n\nSee the General notes to upgrading to 3.x versions above.\n\n## Discriminator Map class duplicates\n\nUsing the same class several times in a discriminator map is deprecated.\nIn 4.0, this will be an error.\n\n## `Doctrine\\ORM\\Mapping\\ClassMetadata::$reflFields` deprecated\n\nTo better support property hooks and lazy proxies in the future, `$reflFields` had to\nbe deprecated because we cannot use the PHP internal reflection API directly anymore.\n\nThe property was changed from an array to an object of type `LegacyReflectionFields`\nthat implements `ArrayAccess`.\n\nUse the new `Doctrine\\ORM\\Mapping\\PropertyAccessors\\PropertyAccessor` API and access\nthrough `Doctrine\\ORM\\Mapping\\ClassMetadata::$propertyAccessors` instead.\n\nCompanion accessor methods are deprecated as well.\n\n# Upgrade to 3.3\n\nSee the General notes to upgrading to 3.x versions above.\n\n## Deprecate `DatabaseDriver`\n\nThe class `Doctrine\\ORM\\Mapping\\Driver\\DatabaseDriver` is deprecated without replacement.\n\n## Add `Doctrine\\ORM\\Query\\OutputWalker` interface, deprecate `Doctrine\\ORM\\Query\\SqlWalker::getExecutor()`\n\nOutput walkers should implement the new `\\Doctrine\\ORM\\Query\\OutputWalker` interface and create\n`Doctrine\\ORM\\Query\\Exec\\SqlFinalizer` instances instead of `Doctrine\\ORM\\Query\\Exec\\AbstractSqlExecutor`s.\nThe output walker must not base its workings on the query `firstResult`/`maxResult` values, so that the\n`SqlFinalizer` can be kept in the query cache and used regardless of the actual `firstResult`/`maxResult` values.\nAny operation dependent on `firstResult`/`maxResult` should take place within the `SqlFinalizer::createExecutor()`\nmethod. Details can be found at https://github.com/doctrine/orm/pull/11188.\n\n\n# Upgrade to 3.2\n\nSee the General notes to upgrading to 3.x versions above.\n\n## Deprecate the `NotSupported` exception\n\nThe class `Doctrine\\ORM\\Exception\\NotSupported` is deprecated without replacement.\n\n## Deprecate remaining `Serializable` implementation\n\nRelying on `SequenceGenerator` implementing the `Serializable` is deprecated\nbecause that interface won't be implemented in ORM 4 anymore.\n\nThe following methods are deprecated:\n\n* `SequenceGenerator::serialize()`\n* `SequenceGenerator::unserialize()`\n\n## `orm:schema-tool:update` option `--complete` is deprecated\n\nThat option behaves as a no-op, and is deprecated. It will be removed in 4.0.\n\n## Deprecate properties `$indexes` and `$uniqueConstraints` of `Doctrine\\ORM\\Mapping\\Table`\n\nThe properties `$indexes` and `$uniqueConstraints` have been deprecated since they had no effect at all.\nThe preferred way of defining indices and unique constraints is by\nusing the `\\Doctrine\\ORM\\Mapping\\UniqueConstraint` and `\\Doctrine\\ORM\\Mapping\\Index` attributes.\n\n# Upgrade to 3.1\n\nSee the General notes to upgrading to 3.x versions above.\n\n## Deprecate `Doctrine\\ORM\\Mapping\\ReflectionEnumProperty`\n\nThis class is deprecated and will be removed in 4.0.\nInstead, use `Doctrine\\Persistence\\Reflection\\EnumReflectionProperty` from\n`doctrine/persistence`.\n\n## Deprecate passing null to `ClassMetadata::fullyQualifiedClassName()`\n\nPassing `null` to `Doctrine\\ORM\\ClassMetadata::fullyQualifiedClassName()` is\ndeprecated and will no longer be possible in 4.0.\n\n## Deprecate array access\n\nUsing array access on instances of the following classes is deprecated:\n\n- `Doctrine\\ORM\\Mapping\\DiscriminatorColumnMapping`\n- `Doctrine\\ORM\\Mapping\\EmbedClassMapping`\n- `Doctrine\\ORM\\Mapping\\FieldMapping`\n- `Doctrine\\ORM\\Mapping\\JoinColumnMapping`\n- `Doctrine\\ORM\\Mapping\\JoinTableMapping`\n\n# Upgrade to 3.0\n\nSee the General notes to upgrading to 3.x versions above.\n\n## BC BREAK: Calling `ClassMetadata::getAssociationMappedByTargetField()` with the owning side of an association now throws an exception\n\nPreviously, calling\n`Doctrine\\ORM\\Mapping\\ClassMetadata::getAssociationMappedByTargetField()` with\nthe owning side of an association returned `null`, which was undocumented, and\nwrong according to the phpdoc of the parent method.\n\nIf you do not know whether you are on the owning or inverse side of an association,\nyou can use `Doctrine\\ORM\\Mapping\\ClassMetadata::isAssociationInverseSide()`\nto find out.\n\n## BC BREAK: `Doctrine\\ORM\\Proxy\\Autoloader` no longer extends `Doctrine\\Common\\Proxy\\Autoloader`\n\nMake sure to use the former when writing a type declaration or an `instanceof` check.\n\n## Minor BC BREAK: Changed order of arguments passed to `OneToOne`, `ManyToOne` and `Index` mapping PHP attributes\n\nTo keep PHP mapping attributes consistent, order of arguments passed to above attributes has been changed\nso `$targetEntity` is a first argument now. This change affects only non-named arguments usage.\n\n## BC BREAK: AUTO keyword for identity generation defaults to IDENTITY for PostgreSQL when using `doctrine/dbal` 4\n\nWhen using the `AUTO` strategy to let Doctrine determine the identity generation mechanism for\nan entity, and when using `doctrine/dbal` 4, PostgreSQL now uses `IDENTITY`\ninstead of `SEQUENCE` or `SERIAL`.\n\nThere are three ways to handle this change.\n\n* If you want to upgrade your existing tables to identity columns, you will need to follow [migration to identity columns on PostgreSQL](https://www.doctrine-project.org/projects/doctrine-dbal/en/4.0/how-to/postgresql-identity-migration.html)\n* If you want to keep using SQL sequences, you need to configure the ORM this way:\n```php\nuse Doctrine\\DBAL\\Platforms\\PostgreSQLPlatform;\nuse Doctrine\\ORM\\Configuration;\nuse Doctrine\\ORM\\Mapping\\ClassMetadata;\n\nassert($configuration instanceof Configuration);\n$configuration->setIdentityGenerationPreferences([\n PostgreSQLPlatform::CLASS => ClassMetadata::GENERATOR_TYPE_SEQUENCE,\n]);\n```\n* You can change individual entities to use the `SEQUENCE` strategy instead of `AUTO`:\n```php\n\ndiff --git a/src/Entity/Example.php b/src/Entity/Example.php\nindex 28be8df378..3b7d61bda6 100644\n--- a/src/Entity/Example.php\n+++ b/src/Entity/Example.php\n@@ -38,7 +38,7 @@ class Example\n\n #[ORM\\Id]\n #[ORM\\Column(type: 'integer')]\n- #[ORM\\GeneratedValue(strategy: 'AUTO')]\n+ #[ORM\\GeneratedValue(strategy: 'SEQUENCE')]\n private int $id;\n\n #[Assert\\Length(max: 255)]\n```\nThe later two options require a small database migration that will remove the default\nexpression fetching the next value from the sequence. It's not strictly necessary to\ndo this migration because the code will work anyway. A benefit of this approach is\nthat you can just make and roll out the code changes first and then migrate the database later.\n\n## BC BREAK: Throw exceptions when using illegal attributes on Embeddable\n\nThere are only a few attributes allowed on an embeddable such as `#[Column]` or\n`#[Embedded]`. Previously all others that target entity classes where ignored,\nnow they throw an exception.\n\n## BC BREAK: Partial objects are removed\n\nWARNING: This was relaxed in ORM 3.2 when partial was re-allowed for array-hydration.\n\n- The `PARTIAL` keyword in DQL no longer exists (reintroduced in ORM 3.2)\n- `Doctrine\\ORM\\Query\\AST\\PartialObjectExpression` is removed. (reintroduced in ORM 3.2)\n- `Doctrine\\ORM\\Query\\SqlWalker::HINT_PARTIAL` (reintroduced in ORM 3.2) and\n `Doctrine\\ORM\\Query::HINT_FORCE_PARTIAL_LOAD` are removed.\n- `Doctrine\\ORM\\EntityManager*::getPartialReference()` is removed.\n\n## BC BREAK: Enforce ArrayCollection Type on `\\Doctrine\\ORM\\QueryBuilder::setParameters(ArrayCollection $parameters)`\n\nThe argument $parameters can no longer be a key=>value array. Only ArrayCollection types are allowed.\n\n### Before\n\n```php\n$qb = $em->createQueryBuilder()\n ->select('u')\n ->from('User', 'u')\n ->where('u.id = :user_id1 OR u.id = :user_id2')\n ->setParameters(array(\n 'user_id1' => 1,\n 'user_id2' => 2\n ));\n```\n\n### After\n\n```php\n$qb = $em->createQueryBuilder()\n ->select('u')\n ->from('User', 'u')\n ->where('u.id = :user_id1 OR u.id = :user_id2')\n ->setParameters(new ArrayCollection(array(\n new Parameter('user_id1', 1),\n new Parameter('user_id2', 2)\n )));\n```\n\n## BC BREAK: `Doctrine\\ORM\\Persister\\Entity\\EntityPersister::executeInserts()` return type changed to `void`\n\nImplementors should adapt to the new signature, and should call\n`UnitOfWork::assignPostInsertId()` for each entry in the previously returned\narray.\n\n## BC BREAK: `Doctrine\\ORM\\Proxy\\ProxyFactory` no longer extends abstract factory from `doctrine/common`\n\nIt is no longer possible to call methods, constants or properties inherited\nfrom that class on a `ProxyFactory` instance.\n\n`Doctrine\\ORM\\Proxy\\ProxyFactory::createProxyDefinition()` and\n`Doctrine\\ORM\\Proxy\\ProxyFactory::resetUninitializedProxy()` are removed as well.\n\n## BC BREAK: lazy ghosts are enabled unconditionally\n\n`Doctrine\\ORM\\Configuration::setLazyGhostObjectEnabled()` and\n`Doctrine\\ORM\\Configuration::isLazyGhostObjectEnabled()` are now no-ops and\nwill be deprecated in 3.1.0\n\n## BC BREAK: collisions in identity map are unconditionally rejected\n\n`Doctrine\\ORM\\Configuration::setRejectIdCollisionInIdentityMap()` and\n`Doctrine\\ORM\\Configuration::isRejectIdCollisionInIdentityMapEnabled()` are now\nno-ops and will be deprecated in 3.1.0.\n\n## BC BREAK: Lifecycle callback mapping on embedded classes is now explicitly forbidden\n\nLifecycle callback mapping on embedded classes produced no effect, and is now\nexplicitly forbidden to point out mistakes.\n\n## BC BREAK: The `NOTIFY` change tracking policy is removed\n\nYou should use `DEFERRED_EXPLICIT` instead.\n\n## BC BREAK: `Mapping\\Driver\\XmlDriver::__construct()` third argument is now enabled by default\n\nThe third argument to\n`Doctrine\\ORM\\Mapping\\Driver\\XmlDriver::__construct()` was introduced to\nlet users opt-in to XML validation, that is now always enabled by default.\n\nAs a consequence, the same goes for\n`Doctrine\\ORM\\Mapping\\Driver\\SimplifiedXmlDriver`, and for\n`Doctrine\\ORM\\ORMSetup::createXMLMetadataConfiguration()`.\n\n## BC BREAK: `Mapping\\Driver\\AttributeDriver::__construct()` second argument is now a no-op\n\nThe second argument to\n`Doctrine\\ORM\\Mapping\\Driver\\AttributeDriver::__construct()` was introduced to\nlet users opt-in to a new behavior, that is now always enforced, regardless of\nthe value of that argument.\n\n## BC BREAK: `Query::setDQL()` and `Query::setFirstResult()` no longer accept `null`\n\nThe `$dqlQuery` argument of `Doctrine\\ORM\\Query::setDQL()` must always be a\nstring.\n\nThe `$firstResult` argument of `Doctrine\\ORM\\Query::setFirstResult()` must\nalways be an integer.\n\n## BC BREAK: `orm:schema-tool:update` option `--complete` is now a no-op\n\n`orm:schema-tool:update` now behaves as if `--complete` was provided,\nregardless of whether it is provided or not.\n\n## BC BREAK: Removed `Doctrine\\ORM\\Proxy\\Proxy` interface.\n\nUse `Doctrine\\Persistence\\Proxy` instead to check whether proxies are initialized.\n\n## BC BREAK: Overriding fields or associations declared in other than mapped superclasses\n\nAs stated in the documentation, fields and associations may only be overridden when being inherited\nfrom mapped superclasses. Overriding them for parent entity classes now throws a `MappingException`.\n\n## BC BREAK: Undeclared entity inheritance now throws a `MappingException`\n\nAs soon as an entity class inherits from another entity class, inheritance has to\nbe declared by adding the appropriate configuration for the root entity.\n\n## Removed `getEntityManager()` in `Doctrine\\ORM\\Event\\OnClearEventArgs` and `Doctrine\\ORM\\Event\\*FlushEventArgs`\n\nUse `getObjectManager()` instead.\n\n## BC BREAK: Removed `Doctrine\\ORM\\Mapping\\ClassMetadataInfo` class\n\nUse `Doctrine\\ORM\\Mapping\\ClassMetadata` instead.\n\n## BC BREAK: Removed `Doctrine\\ORM\\Event\\LifecycleEventArgs` class.\n\nUse one of the dedicated event classes instead:\n\n* `Doctrine\\ORM\\Event\\PrePersistEventArgs`\n* `Doctrine\\ORM\\Event\\PreUpdateEventArgs`\n* `Doctrine\\ORM\\Event\\PreRemoveEventArgs`\n* `Doctrine\\ORM\\Event\\PostPersistEventArgs`\n* `Doctrine\\ORM\\Event\\PostUpdateEventArgs`\n* `Doctrine\\ORM\\Event\\PostRemoveEventArgs`\n* `Doctrine\\ORM\\Event\\PostLoadEventArgs`\n\n## BC BREAK: Removed `AttributeDriver::$entityAnnotationClasses` and `AttributeDriver::getReader()`\n\n* If you need to change the behavior of `AttributeDriver::isTransient()`,\n override that method instead.\n* The attribute reader is internal to the driver and should not be accessed from outside.\n\n## BC BREAK: Removed `Doctrine\\ORM\\Query\\AST\\InExpression`\n\nThe AST parser will create a `InListExpression` or a `InSubselectExpression` when\nencountering an `IN ()` DQL expression instead of a generic `InExpression`.\n\nAs a consequence, `SqlWalker::walkInExpression()` has been replaced by\n`SqlWalker::walkInListExpression()` and `SqlWalker::walkInSubselectExpression()`.\n\n## BC BREAK: Changed `EntityManagerInterface#refresh($entity)`, `EntityManagerDecorator#refresh($entity)` and `UnitOfWork#refresh($entity)` signatures\n\nThe new signatures of these methods add an optional `LockMode|int|null $lockMode`\nparam with default `null` value (no lock).\n\n## BC Break: Removed AnnotationDriver\n\nThe annotation driver and anything related to annotation has been removed.\nPlease migrate to another mapping driver.\n\nThe `Doctrine\\ORM\\Mapping\\Annotation` maker interface has been removed in favor of the new\n`Doctrine\\ORM\\Mapping\\MappingAttribute` interface.\n\n## BC BREAK: Removed `EntityManager::create()`\n\nThe constructor of `EntityManager` is now public and must be used instead of the `create()` method.\nHowever, the constructor expects a `Connection` while `create()` accepted an array with connection parameters.\nYou can pass that array to DBAL's `Doctrine\\DBAL\\DriverManager::getConnection()` method to bootstrap the\nconnection.\n\n## BC BREAK: Removed `QueryBuilder` methods and constants.\n\nThe following `QueryBuilder` constants and methods have been removed:\n\n1. `SELECT`,\n2. `DELETE`,\n3. `UPDATE`,\n4. `STATE_DIRTY`,\n5. `STATE_CLEAN`,\n6. `getState()`,\n7. `getType()`.\n\n## BC BREAK: Omitting only the alias argument for `QueryBuilder::update` and `QueryBuilder::delete` is not supported anymore\n\nWhen building an UPDATE or DELETE query and when passing a class/type to the function, the alias argument must not be omitted.\n\n### Before\n\n```php\n$qb = $em->createQueryBuilder()\n ->delete('User u')\n ->where('u.id = :user_id')\n ->setParameter('user_id', 1);\n```\n\n### After\n\n```php\n$qb = $em->createQueryBuilder()\n ->delete('User', 'u')\n ->where('u.id = :user_id')\n ->setParameter('user_id', 1);\n```\n\n## BC BREAK: Split output walkers and tree walkers\n\n`SqlWalker` and its child classes don't implement the `TreeWalker` interface\nanymore.\n\nThe following methods have been removed from the `TreeWalker` interface and\nfrom the `TreeWalkerAdapter` and `TreeWalkerChain` classes:\n\n* `setQueryComponent()`\n* `walkSelectClause()`\n* `walkFromClause()`\n* `walkFunction()`\n* `walkOrderByClause()`\n* `walkOrderByItem()`\n* `walkHavingClause()`\n* `walkJoin()`\n* `walkSelectExpression()`\n* `walkQuantifiedExpression()`\n* `walkSubselect()`\n* `walkSubselectFromClause()`\n* `walkSimpleSelectClause()`\n* `walkSimpleSelectExpression()`\n* `walkAggregateExpression()`\n* `walkGroupByClause()`\n* `walkGroupByItem()`\n* `walkDeleteClause()`\n* `walkUpdateClause()`\n* `walkUpdateItem()`\n* `walkWhereClause()`\n* `walkConditionalExpression()`\n* `walkConditionalTerm()`\n* `walkConditionalFactor()`\n* `walkConditionalPrimary()`\n* `walkExistsExpression()`\n* `walkCollectionMemberExpression()`\n* `walkEmptyCollectionComparisonExpression()`\n* `walkNullComparisonExpression()`\n* `walkInExpression()`\n* `walkInstanceOfExpression()`\n* `walkLiteral()`\n* `walkBetweenExpression()`\n* `walkLikeExpression()`\n* `walkStateFieldPathExpression()`\n* `walkComparisonExpression()`\n* `walkInputParameter()`\n* `walkArithmeticExpression()`\n* `walkArithmeticTerm()`\n* `walkStringPrimary()`\n* `walkArithmeticFactor()`\n* `walkSimpleArithmeticExpression()`\n* `walkPathExpression()`\n* `walkResultVariable()`\n* `getExecutor()`\n\nThe following changes have been made to the abstract `TreeWalkerAdapter` class:\n\n* The method `setQueryComponent()` is now protected.\n* The method `_getQueryComponents()` has been removed in favor of\n `getQueryComponents()`.\n\n## BC BREAK: Removed identity columns emulation through sequences\n\nIf the platform you are using does not support identity columns, you should\nswitch to the `SEQUENCE` strategy.\n\n## BC BREAK: Made setters parameters mandatory\n\nThe following methods require an argument when being called. Pass `null`\ninstead of omitting the argument.\n\n* `Doctrine\\ORM\\Event\\OnClassMetadataNotFoundEventArgs::setFoundMetadata()`\n* `Doctrine\\ORM\\AbstractQuery::setHydrationCacheProfile()`\n* `Doctrine\\ORM\\AbstractQuery::setResultCache()`\n* `Doctrine\\ORM\\AbstractQuery::setResultCacheProfile()`\n\n## BC BREAK: New argument to `NamingStrategy::joinColumnName()`\n\n### Before\n\n```php\n `Exception\\MissingMappingDriverImplementation::create()`\n * `unrecognizedField()` => `Persisters\\Exception\\UnrecognizedField::byName()`\n * `unexpectedAssociationValue()` => `Exception\\UnexpectedAssociationValue::create()`\n * `invalidOrientation()` => `Persisters\\Exception\\InvalidOrientation::fromClassNameAndField()`\n * `entityManagerClosed()` => `Exception\\EntityManagerClosed::create()`\n * `invalidHydrationMode()` => `Exception\\InvalidHydrationMode::fromMode()`\n * `mismatchedEventManager()` => `Exception\\MismatchedEventManager::create()`\n * `findByRequiresParameter()` => `Repository\\Exception\\InvalidMagicMethodCall::onMissingParameter()`\n * `invalidMagicCall()` => `Repository\\Exception\\InvalidMagicMethodCall::becauseFieldNotFoundIn()`\n * `invalidFindByInverseAssociation()` => `Repository\\Exception\\InvalidFindByCall::fromInverseSideUsage()`\n * `invalidResultCacheDriver()` => `Cache\\Exception\\InvalidResultCacheDriver::create()`\n * `notSupported()` => `Exception\\NotSupported::create()`\n * `queryCacheNotConfigured()` => `QueryCacheNotConfigured::create()`\n * `metadataCacheNotConfigured()` => `Cache\\Exception\\MetadataCacheNotConfigured::create()`\n * `queryCacheUsesNonPersistentCache()` => `Cache\\Exception\\QueryCacheUsesNonPersistentCache::fromDriver()`\n * `metadataCacheUsesNonPersistentCache()` => `Cache\\Exception\\MetadataCacheUsesNonPersistentCache::fromDriver()`\n * `proxyClassesAlwaysRegenerating()` => `Exception\\ProxyClassesAlwaysRegenerating::create()`\n * `invalidEntityRepository()` => `Exception\\InvalidEntityRepository::fromClassName()`\n * `missingIdentifierField()` => `Exception\\MissingIdentifierField::fromFieldAndClass()`\n * `unrecognizedIdentifierFields()` => `Exception\\UnrecognizedIdentifierFields::fromClassAndFieldNames()`\n * `cantUseInOperatorOnCompositeKeys()` => `Persisters\\Exception\\CantUseInOperatorOnCompositeKeys::create()`\n\n## BC Break: `CacheException` is no longer a class, but an interface\n\nAll methods in `Doctrine\\ORM\\Cache\\CacheException` have been extracted to dedicated exceptions.\n\n * `updateReadOnlyCollection()` => `Cache\\Exception\\CannotUpdateReadOnlyCollection::fromEntityAndField()`\n * `updateReadOnlyEntity()` => `Cache\\Exception\\CannotUpdateReadOnlyEntity::fromEntity()`\n * `nonCacheableEntity()` => `Cache\\Exception\\NonCacheableEntity::fromEntity()`\n * `nonCacheableEntityAssociation()` => `Cache\\Exception\\NonCacheableEntityAssociation::fromEntityAndField()`\n\n\n## BC Break: Missing type declaration added for identifier generators\n\nAlthough undocumented, it was possible to configure a custom repository\nclass that implements `ObjectRepository` but does not extend the\n`EntityRepository` base class. Repository classes have to extend\n`EntityRepository` now.\n\n## BC BREAK: Removed support for entity namespace alias\n\n- `EntityManager::getRepository()` no longer accepts the entity namespace alias\n notation.\n- `Configuration::addEntityNamespace()` and\n `Configuration::getEntityNamespace()` have been removed.\n\n## BC BREAK: Remove helper methods from `AbstractCollectionPersister`\n\nThe following protected methods of\n`Doctrine\\ORM\\Cache\\Persister\\Collection\\AbstractCollectionPersister`\nhave been removed.\n\n* `evictCollectionCache()`\n* `evictElementCache()`\n\n## BC BREAK: `Doctrine\\ORM\\Query\\TreeWalkerChainIterator`\n\nThis class has been removed without replacement.\n\n## BC BREAK: Remove quoting methods from `ClassMetadata`\n\nThe following methods have been removed from the class metadata because\nquoting is handled by implementations of `Doctrine\\ORM\\Mapping\\QuoteStrategy`:\n\n* `getQuotedIdentifierColumnNames()`\n* `getQuotedColumnName()`\n* `getQuotedTableName()`\n* `getQuotedJoinTableName()`\n\n## BC BREAK: Remove ability to merge detached entities\n\nMerge semantics was a poor fit for the PHP \"share-nothing\" architecture.\nIn addition to that, merging caused multiple issues with data integrity\nin the managed entity graph, which was constantly spawning more edge-case\nbugs/scenarios.\n\nThe method `UnitOfWork::merge()` has been removed. The method\n`EntityManager::merge()` will throw an exception on each call.\n\n## BC BREAK: Removed ability to partially flush/commit entity manager and unit of work\n\nThe following methods don't accept a single entity or an array of entities anymore:\n\n* `Doctrine\\ORM\\EntityManager::flush()`\n* `Doctrine\\ORM\\Decorator\\EntityManagerDecorator::flush()`\n* `Doctrine\\ORM\\UnitOfWork::commit()`\n\nThe semantics of `flush()` and `commit()` will remain the same, but the change\ntracking will be performed on all entities managed by the unit of work, and not\njust on the provided entities, as the parameter is now completely ignored.\n\n## BC BREAK: Removed ability to partially clear entity manager and unit of work\n\n* Passing an argument other than `null` to `EntityManager::clear()` will raise\n an exception.\n* The unit of work cannot be cleared partially anymore. Passing an argument to\n `UnitOfWork::clear()` does not have any effect anymore; the unit of work is\n cleared completely.\n* The method `EntityRepository::clear()` has been removed.\n* The methods `getEntityClass()` and `clearsAllEntities()` have been removed\n from `OnClearEventArgs`.\n\n## BC BREAK: Remove support for Doctrine Cache\n\nThe Doctrine Cache library is not supported anymore. The following methods\nhave been removed from `Doctrine\\ORM\\Configuration`:\n\n* `getQueryCacheImpl()`\n* `setQueryCacheImpl()`\n* `getHydrationCacheImpl()`\n* `setHydrationCacheImpl()`\n* `getMetadataCacheImpl()`\n* `setMetadataCacheImpl()`\n\nThe methods have been replaced by PSR-6 compatible counterparts\n(just strip the `Impl` suffix from the old name to get the new one).\n\n## BC BREAK: Remove `Doctrine\\ORM\\Configuration::newDefaultAnnotationDriver`\n\nThis functionality has been moved to the new `ORMSetup` class. Call\n`Doctrine\\ORM\\ORMSetup::createDefaultAnnotationDriver()` to create\na new annotation driver.\n\n## BC BREAK: Remove `Doctrine\\ORM\\Tools\\Setup`\n\nIn our effort to migrate from Doctrine Cache to PSR-6, the `Setup` class which\naccepted a Doctrine Cache instance in each method has been removed.\n\nThe replacement is `Doctrine\\ORM\\ORMSetup` which accepts a PSR-6\ncache instead.\n\n## BC BREAK: Removed named queries\n\nAll APIs related to named queries have been removed.\n\n## BC BREAK: Remove old cache accessors and mutators from query classes\n\nThe following methods have been removed from `AbstractQuery`:\n\n* `setResultCacheDriver()`\n* `getResultCacheDriver()`\n* `useResultCache()`\n* `getResultCacheLifetime()`\n* `getResultCacheId()`\n\nThe following methods have been removed from `Query`:\n\n* `setQueryCacheDriver()`\n* `getQueryCacheDriver()`\n\n## BC BREAK: Remove `Doctrine\\ORM\\Cache\\MultiGetRegion`\n\nThe interface has been merged into `Doctrine\\ORM\\Cache\\Region`.\n\n## BC BREAK: Rename `AbstractIdGenerator::generate()` to `generateId()`\n\n* Implementations of `AbstractIdGenerator` have to implement the method\n `generateId()`.\n* The method `generate()` has been removed from `AbstractIdGenerator`.\n\n## BC BREAK: Remove cache settings inspection\n\nDoctrine does not provide its own cache implementation anymore and relies on\nthe PSR-6 standard instead. As a consequence, we cannot determine anymore\nwhether a given cache adapter is suitable for a production environment.\nBecause of that, functionality that aims to do so has been removed:\n\n* `Configuration::ensureProductionSettings()`\n* the `orm:ensure-production-settings` console command\n\n## BC BREAK: PSR-6-based second level cache\n\nThe second level cache has been reworked to consume a PSR-6 cache. Using a\nDoctrine Cache instance is not supported anymore.\n\n* `DefaultCacheFactory`: The constructor expects a PSR-6 cache item pool as\n second argument now.\n* `DefaultMultiGetRegion`: This class has been removed.\n* `DefaultRegion`:\n * The constructor expects a PSR-6 cache item pool as second argument now.\n * The protected `$cache` property is removed.\n * The properties `$name` and `$lifetime` as well as the constant\n `REGION_KEY_SEPARATOR` and the method `getCacheEntryKey()` are\n `private` now.\n * The method `getCache()` has been removed.\n\n\n## BC Break: Remove `Doctrine\\ORM\\Mapping\\Driver\\PHPDriver`\n\nUse `StaticPHPDriver` instead when you want to programmatically configure\nentity metadata.\n\n## BC BREAK: Remove `Doctrine\\ORM\\EntityManagerInterface#transactional()`\n\nThis method has been replaced by `Doctrine\\ORM\\EntityManagerInterface#wrapInTransaction()`.\n\n## BC BREAK: Removed support for schema emulation.\n\nThe ORM no longer attempts to emulate schemas on SQLite.\n\n## BC BREAK: Remove `Setup::registerAutoloadDirectory()`\n\nUse Composer's autoloader instead.\n\n## BC BREAK: Remove YAML mapping drivers.\n\nIf your code relies on `YamlDriver` or `SimpleYamlDriver`, you **MUST** migrate to\nattribute, annotation or XML drivers instead.\n\nYou can use the `orm:convert-mapping` command to convert your metadata mapping to XML\n_before_ upgrading to 3.0:\n\n```sh\nphp doctrine orm:convert-mapping xml /path/to/mapping-path-converted-to-xml\n```\n\n## BC BREAK: Remove code generators and related console commands\n\nThese console commands have been removed:\n\n* `orm:convert-d1-schema`\n* `orm:convert-mapping`\n* `orm:generate:entities`\n* `orm:generate-repositories`\n\nThese classes have been deprecated:\n\n* `Doctrine\\ORM\\Tools\\ConvertDoctrine1Schema`\n* `Doctrine\\ORM\\Tools\\EntityGenerator`\n* `Doctrine\\ORM\\Tools\\EntityRepositoryGenerator`\n\nThe entire `Doctrine\\ORM\\Tools\\Export` namespace has been removed as well.\n\n## BC BREAK: Removed `Doctrine\\ORM\\Version`\n\nUse Composer's runtime API if you _really_ need to check the version of the ORM package at runtime.\n\n## BC BREAK: EntityRepository::count() signature change\n\nThe argument `$criteria` of `Doctrine\\ORM\\EntityRepository::count()` is now\noptional. Overrides in child classes should be made compatible.\n\n## BC BREAK: changes in exception hierarchy\n\n- `Doctrine\\ORM\\ORMException` has been removed\n- `Doctrine\\ORM\\Exception\\ORMException` is now an interface\n\n## Variadic methods now use native variadics\nThe following methods were using `func_get_args()` to simulate a variadic argument:\n- `Doctrine\\ORM\\Query\\Expr#andX()`\n- `Doctrine\\ORM\\Query\\Expr#orX()`\n- `Doctrine\\ORM\\QueryBuilder#select()`\n- `Doctrine\\ORM\\QueryBuilder#addSelect()`\n- `Doctrine\\ORM\\QueryBuilder#where()`\n- `Doctrine\\ORM\\QueryBuilder#andWhere()`\n- `Doctrine\\ORM\\QueryBuilder#orWhere()`\n- `Doctrine\\ORM\\QueryBuilder#groupBy()`\n- `Doctrine\\ORM\\QueryBuilder#andGroupBy()`\n- `Doctrine\\ORM\\QueryBuilder#having()`\n- `Doctrine\\ORM\\QueryBuilder#andHaving()`\n- `Doctrine\\ORM\\QueryBuilder#orHaving()`\nA variadic argument is now actually used in their signatures signature (`...$x`).\nSignatures of overridden methods should be changed accordingly\n\n## Minor BC BREAK: removed `Doctrine\\ORM\\EntityManagerInterface#copy()`\n\nMethod `Doctrine\\ORM\\EntityManagerInterface#copy()` never got its implementation and is removed in 3.0.\n\n## BC BREAK: Removed classes related to UUID and TABLE generator strategies\n\nThe following classes have been removed:\n- `Doctrine\\ORM\\Id\\TableGenerator`\n- `Doctrine\\ORM\\Id\\UuidGenerator`\n\nUsing the `UUID` strategy for generating identifiers is not supported anymore.\n\n## BC BREAK: Removed `Query::iterate()`\n\nThe deprecated method `Query::iterate()` has been removed along with the\nfollowing classes and methods:\n\n- `AbstractHydrator::iterate()`\n- `AbstractHydrator::hydrateRow()`\n- `IterableResult`\n\nUse `toIterable()` instead.\n\n# Upgrade to 2.20\n\n## Add `Doctrine\\ORM\\Query\\OutputWalker` interface, deprecate `Doctrine\\ORM\\Query\\SqlWalker::getExecutor()`\n\nOutput walkers should implement the new `\\Doctrine\\ORM\\Query\\OutputWalker` interface and create\n`Doctrine\\ORM\\Query\\Exec\\SqlFinalizer` instances instead of `Doctrine\\ORM\\Query\\Exec\\AbstractSqlExecutor`s.\nThe output walker must not base its workings on the query `firstResult`/`maxResult` values, so that the\n`SqlFinalizer` can be kept in the query cache and used regardless of the actual `firstResult`/`maxResult` values.\nAny operation dependent on `firstResult`/`maxResult` should take place within the `SqlFinalizer::createExecutor()`\nmethod. Details can be found at https://github.com/doctrine/orm/pull/11188.\n\n## Explictly forbid property hooks\n\nProperty hooks are not supported yet by Doctrine ORM. Until support is added,\nthey are explicitly forbidden because the support would result in a breaking\nchange in behavior.\n\nProgress on this is tracked at https://github.com/doctrine/orm/issues/11624 .\n\n## PARTIAL DQL syntax is undeprecated\n\nUse of the PARTIAL keyword is not deprecated anymore in DQL, because we will be\nable to support PARTIAL objects with PHP 8.4 Lazy Objects and\nSymfony/VarExporter in a better way. When we decided to remove this feature\nthese two abstractions did not exist yet.\n\nWARNING: If you want to upgrade to 3.x and still use PARTIAL keyword in DQL\nwith array or object hydrators, then you have to directly migrate to ORM 3.3.x or higher.\nPARTIAL keyword in DQL is not available in 3.0, 3.1 and 3.2 of ORM.\n\n## Deprecate `\\Doctrine\\ORM\\Query\\Parser::setCustomOutputTreeWalker()`\n\nUse the `\\Doctrine\\ORM\\Query::HINT_CUSTOM_OUTPUT_WALKER` query hint to set the output walker\nclass instead of setting it through the `\\Doctrine\\ORM\\Query\\Parser::setCustomOutputTreeWalker()` method\non the parser instance.\n\n# Upgrade to 2.19\n\n## Deprecate calling `ClassMetadata::getAssociationMappedByTargetField()` with the owning side of an association\n\nCalling\n`Doctrine\\ORM\\Mapping\\ClassMetadata::getAssociationMappedByTargetField()` with\nthe owning side of an association returns `null`, which is undocumented, and\nwrong according to the phpdoc of the parent method.\n\nIf you do not know whether you are on the owning or inverse side of an association,\nyou can use `Doctrine\\ORM\\Mapping\\ClassMetadata::isAssociationInverseSide()`\nto find out.\n\n## Deprecate `Doctrine\\ORM\\Query\\Lexer::T_*` constants\n\nUse `Doctrine\\ORM\\Query\\TokenType::T_*` instead.\n\n# Upgrade to 2.17\n\n## Deprecate annotations classes for named queries\n\nThe following classes have been deprecated:\n\n* `Doctrine\\ORM\\Mapping\\NamedNativeQueries`\n* `Doctrine\\ORM\\Mapping\\NamedNativeQuery`\n* `Doctrine\\ORM\\Mapping\\NamedQueries`\n* `Doctrine\\ORM\\Mapping\\NamedQuery`\n\n## Deprecate `Doctrine\\ORM\\Query\\Exec\\AbstractSqlExecutor::_sqlStatements`\n\nUse `Doctrine\\ORM\\Query\\Exec\\AbstractSqlExecutor::sqlStatements` instead.\n\n## Undeprecate `Doctrine\\ORM\\Proxy\\Autoloader`\n\nIt will be a full-fledged class, no longer extending\n`Doctrine\\Common\\Proxy\\Autoloader` in 3.0.x.\n\n## Deprecated: reliance on the non-optimal defaults that come with the `AUTO` identifier generation strategy\n\nWhen the `AUTO` identifier generation strategy was introduced, the best\nstrategy at the time was selected for each database platform.\nA lot of time has passed since then, and with ORM 3.0.0 and DBAL 4.0.0, support\nfor better strategies will be added.\n\nBecause of that, it is now deprecated to rely on the historical defaults when\nthey differ from what we will be recommended in the future.\n\nInstead, you should pick a strategy for each database platform you use, and it\nwill be used when using `AUTO`. As of now, only PostgreSQL is affected by this.\n\nIt is recommended that PostgreSQL users configure their existing and new\napplications to use `SEQUENCE` until `doctrine/dbal` 4.0.0 is released:\n\n```php\nuse Doctrine\\DBAL\\Platforms\\PostgreSQLPlatform;\nuse Doctrine\\ORM\\Configuration;\n\nassert($configuration instanceof Configuration);\n$configuration->setIdentityGenerationPreferences([\n PostgreSQLPlatform::CLASS => ClassMetadata::GENERATOR_TYPE_SEQUENCE,\n]);\n```\n\nWhen DBAL 4 is released, `AUTO` will result in `IDENTITY`, and the above\nconfiguration should be removed to migrate to it.\n\n## Deprecate `EntityManagerInterface::getPartialReference()`\n\nThis method does not have a replacement and will be removed in 3.0.\n\n## Deprecate not-enabling lazy-ghosts\n\nNot enabling lazy ghost objects is deprecated. In ORM 3.0, they will be always enabled.\nEnsure `Doctrine\\ORM\\Configuration::setLazyGhostObjectEnabled(true)` is called to enable them.\n\n# Upgrade to 2.16\n\n## Deprecated accepting duplicate IDs in the identity map\n\nFor any given entity class and ID value, there should be only one object instance\nrepresenting the entity.\n\nIn https://github.com/doctrine/orm/pull/10785, a check was added that will guard this\nin the identity map. The most probable cause for violations of this rule are collisions\nof application-provided IDs.\n\nIn ORM 2.16.0, the check was added by throwing an exception. In ORM 2.16.1, this will be\nchanged to a deprecation notice. ORM 3.0 will make it an exception again. Use\n`\\Doctrine\\ORM\\Configuration::setRejectIdCollisionInIdentityMap()` if you want to opt-in\nto the new mode.\n\n## Potential changes to the order in which `INSERT`s are executed\n\nIn https://github.com/doctrine/orm/pull/10547, the commit order computation was improved\nto fix a series of bugs where a correct (working) commit order was previously not found.\nAlso, the new computation may get away with fewer queries being executed: By inserting\nreferred-to entities first and using their ID values for foreign key fields in subsequent\n`INSERT` statements, additional `UPDATE` statements that were previously necessary can be\navoided.\n\nWhen using database-provided, auto-incrementing IDs, this may lead to IDs being assigned\nto entities in a different order than it was previously the case.\n\n## Deprecated returning post insert IDs from `EntityPersister::executeInserts()`\n\nPersisters implementing `\\Doctrine\\ORM\\Persisters\\Entity\\EntityPersister` should no longer\nreturn an array of post insert IDs from their `::executeInserts()` method. Make the\npersister call `Doctrine\\ORM\\UnitOfWork::assignPostInsertId()` instead.\n\n## Changing the way how reflection-based mapping drivers report fields, deprecated the \"old\" mode\n\nIn ORM 3.0, a change will be made regarding how the `AttributeDriver` reports field mappings.\nThis change is necessary to be able to detect (and reject) some invalid mapping configurations.\n\nTo avoid surprises during 2.x upgrades, the new mode is opt-in. It can be activated on the\n`AttributeDriver` and `AnnotationDriver` by setting the `$reportFieldsWhereDeclared`\nconstructor parameter to `true`. It will cause `MappingException`s to be thrown when invalid\nconfigurations are detected.\n\nNot enabling the new mode will cause a deprecation notice to be raised. In ORM 3.0,\nonly the new mode will be available.\n\n# Upgrade to 2.15\n\n## Deprecated configuring `JoinColumn` on the inverse side of one-to-one associations\n\nFor one-to-one associations, the side using the `mappedBy` attribute is the inverse side.\nThe owning side is the entity with the table containing the foreign key. Using `JoinColumn`\nconfiguration on the _inverse_ side now triggers a deprecation notice and will be an error\nin 3.0.\n\n## Deprecated overriding fields or associations not declared in mapped superclasses\n\nAs stated in the documentation, fields and associations may only be overridden when being inherited\nfrom mapped superclasses. Overriding them for parent entity classes now triggers a deprecation notice\nand will be an error in 3.0.\n\n## Deprecated undeclared entity inheritance\n\nAs soon as an entity class inherits from another entity class, inheritance has to\nbe declared by adding the appropriate configuration for the root entity.\n\n## Deprecated stubs for \"concrete table inheritance\"\n\nThis third way of mapping class inheritance was never implemented. Code stubs are\nnow deprecated and will be removed in 3.0.\n\n* `\\Doctrine\\ORM\\Mapping\\ClassMetadataInfo::INHERITANCE_TYPE_TABLE_PER_CLASS` constant\n* `\\Doctrine\\ORM\\Mapping\\ClassMetadataInfo::isInheritanceTypeTablePerClass()` method\n* Using `TABLE_PER_CLASS` as the value for the `InheritanceType` attribute or annotation\n or in XML configuration files.\n\n# Upgrade to 2.14\n\n## Deprecated `Doctrine\\ORM\\Persisters\\Exception\\UnrecognizedField::byName($field)` method.\n\nUse `Doctrine\\ORM\\Persisters\\Exception\\UnrecognizedField::byFullyQualifiedName($className, $field)` instead.\n\n## Deprecated constants of `Doctrine\\ORM\\Internal\\CommitOrderCalculator`\n\nThe following public constants have been deprecated:\n\n* `CommitOrderCalculator::NOT_VISITED`\n* `CommitOrderCalculator::IN_PROGRESS`\n* `CommitOrderCalculator::VISITED`\n\nThese constants were used for internal purposes. Relying on them is discouraged.\n\n## Deprecated `Doctrine\\ORM\\Query\\AST\\InExpression`\n\nThe AST parser will create a `InListExpression` or a `InSubselectExpression` when\nencountering an `IN ()` DQL expression instead of a generic `InExpression`.\n\nAs a consequence, `SqlWalker::walkInExpression()` has been deprecated in favor of\n`SqlWalker::walkInListExpression()` and `SqlWalker::walkInSubselectExpression()`.\n\n## Deprecated constructing a `CacheKey` without `$hash`\n\nThe `Doctrine\\ORM\\Cache\\CacheKey` class has an explicit constructor now with\nan optional parameter `$hash`. That parameter will become mandatory in 3.0.\n\n## Deprecated `AttributeDriver::$entityAnnotationClasses`\n\nIf you need to change the behavior of `AttributeDriver::isTransient()`,\noverride that method instead.\n\n## Deprecated incomplete schema updates\n\nUsing `orm:schema-tool:update` without passing the `--complete` flag is\ndeprecated. Use schema asset filtering if you need to preserve assets not\nmanaged by DBAL.\n\nLikewise, calling `SchemaTool::updateSchema()` or\n`SchemaTool::getUpdateSchemaSql()` with a second argument is deprecated.\n\n## Deprecated annotation mapping driver.\n\nPlease switch to one of the other mapping drivers. Native attributes which PHP\nsupports since version 8.0 are probably your best option.\n\nAs a consequence, the following methods are deprecated:\n- `ORMSetup::createAnnotationMetadataConfiguration`\n- `ORMSetup::createDefaultAnnotationDriver`\n\nThe marker interface `Doctrine\\ORM\\Mapping\\Annotation` is deprecated as well.\nAll annotation/attribute classes implement\n`Doctrine\\ORM\\Mapping\\MappingAttribute` now.\n\n## Deprecated `Doctrine\\ORM\\Proxy\\Proxy` interface.\n\nUse `Doctrine\\Persistence\\Proxy` instead to check whether proxies are initialized.\n\n## Deprecated `Doctrine\\ORM\\Event\\LifecycleEventArgs` class.\n\nIt will be removed in 3.0. Use one of the dedicated event classes instead:\n\n* `Doctrine\\ORM\\Event\\PrePersistEventArgs`\n* `Doctrine\\ORM\\Event\\PreUpdateEventArgs`\n* `Doctrine\\ORM\\Event\\PreRemoveEventArgs`\n* `Doctrine\\ORM\\Event\\PostPersistEventArgs`\n* `Doctrine\\ORM\\Event\\PostUpdateEventArgs`\n* `Doctrine\\ORM\\Event\\PostRemoveEventArgs`\n* `Doctrine\\ORM\\Event\\PostLoadEventArgs`\n\n# Upgrade to 2.13\n\n## Deprecated `EntityManager::create()`\n\nThe constructor of `EntityManager` is now public and should be used instead of the `create()` method.\nHowever, the constructor expects a `Connection` while `create()` accepted an array with connection parameters.\nYou can pass that array to DBAL's `Doctrine\\DBAL\\DriverManager::getConnection()` method to bootstrap the\nconnection.\n\n## Deprecated `QueryBuilder` methods and constants.\n\n1. The `QueryBuilder::getState()` method has been deprecated as the builder state is an internal concern.\n2. Relying on the type of the query being built by using `QueryBuilder::getType()` has been deprecated.\n If necessary, track the type of the query being built outside of the builder.\n\nThe following `QueryBuilder` constants related to the above methods have been deprecated:\n\n1. `SELECT`,\n2. `DELETE`,\n3. `UPDATE`,\n4. `STATE_DIRTY`,\n5. `STATE_CLEAN`.\n\n## Deprecated omitting only the alias argument for `QueryBuilder::update` and `QueryBuilder::delete`\n\nWhen building an UPDATE or DELETE query and when passing a class/type to the function, the alias argument must not be omitted.\n\n### Before\n\n```php\n$qb = $em->createQueryBuilder()\n ->delete('User u')\n ->where('u.id = :user_id')\n ->setParameter('user_id', 1);\n```\n\n### After\n\n```php\n$qb = $em->createQueryBuilder()\n ->delete('User', 'u')\n ->where('u.id = :user_id')\n ->setParameter('user_id', 1);\n```\n\n## Deprecated using the `IDENTITY` identifier strategy on platform that do not support identity columns\n\nIf identity columns are emulated with sequences on the platform you are using,\nyou should switch to the `SEQUENCE` strategy.\n\n## Deprecated passing `null` to `Doctrine\\ORM\\Query::setFirstResult()`\n\n`$query->setFirstResult(null);` is equivalent to `$query->setFirstResult(0)`.\n\n## Deprecated calling setters without arguments\n\nThe following methods will require an argument in 3.0. Pass `null` instead of\nomitting the argument.\n\n* `Doctrine\\ORM\\Event\\OnClassMetadataNotFoundEventArgs::setFoundMetadata()`\n* `Doctrine\\ORM\\AbstractQuery::setHydrationCacheProfile()`\n* `Doctrine\\ORM\\AbstractQuery::setResultCache()`\n* `Doctrine\\ORM\\AbstractQuery::setResultCacheProfile()`\n\n## Deprecated passing invalid fetch modes to `AbstractQuery::setFetchMode()`\n\nCalling `AbstractQuery::setFetchMode()` with anything else than\n`Doctrine\\ORM\\Mapping::FETCH_EAGER` results in\n`Doctrine\\ORM\\Mapping::FETCH_LAZY` being used. Relying on that behavior is\ndeprecated and will result in an exception in 3.0.\n\n## Deprecated `getEntityManager()` in `Doctrine\\ORM\\Event\\OnClearEventArgs` and `Doctrine\\ORM\\Event\\*FlushEventArgs`\n\nThis method has been deprecated in:\n\n* `Doctrine\\ORM\\Event\\OnClearEventArgs`\n* `Doctrine\\ORM\\Event\\OnFlushEventArgs`\n* `Doctrine\\ORM\\Event\\PostFlushEventArgs`\n* `Doctrine\\ORM\\Event\\PreFlushEventArgs`\n\nIt will be removed in 3.0. Use `getObjectManager()` instead.\n\n## Prepare split of output walkers and tree walkers\n\nIn 3.0, `SqlWalker` and its child classes won't implement the `TreeWalker`\ninterface anymore. Relying on that inheritance is deprecated.\n\nThe following methods of the `TreeWalker` interface have been deprecated:\n\n* `setQueryComponent()`\n* `walkSelectClause()`\n* `walkFromClause()`\n* `walkFunction()`\n* `walkOrderByClause()`\n* `walkOrderByItem()`\n* `walkHavingClause()`\n* `walkJoin()`\n* `walkSelectExpression()`\n* `walkQuantifiedExpression()`\n* `walkSubselect()`\n* `walkSubselectFromClause()`\n* `walkSimpleSelectClause()`\n* `walkSimpleSelectExpression()`\n* `walkAggregateExpression()`\n* `walkGroupByClause()`\n* `walkGroupByItem()`\n* `walkDeleteClause()`\n* `walkUpdateClause()`\n* `walkUpdateItem()`\n* `walkWhereClause()`\n* `walkConditionalExpression()`\n* `walkConditionalTerm()`\n* `walkConditionalFactor()`\n* `walkConditionalPrimary()`\n* `walkExistsExpression()`\n* `walkCollectionMemberExpression()`\n* `walkEmptyCollectionComparisonExpression()`\n* `walkNullComparisonExpression()`\n* `walkInExpression()`\n* `walkInstanceOfExpression()`\n* `walkLiteral()`\n* `walkBetweenExpression()`\n* `walkLikeExpression()`\n* `walkStateFieldPathExpression()`\n* `walkComparisonExpression()`\n* `walkInputParameter()`\n* `walkArithmeticExpression()`\n* `walkArithmeticTerm()`\n* `walkStringPrimary()`\n* `walkArithmeticFactor()`\n* `walkSimpleArithmeticExpression()`\n* `walkPathExpression()`\n* `walkResultVariable()`\n* `getExecutor()`\n\nThe following changes have been made to the abstract `TreeWalkerAdapter` class:\n\n* All implementations of now-deprecated `TreeWalker` methods have been\n deprecated as well.\n* The method `setQueryComponent()` will become protected in 3.0. Calling it\n publicly is deprecated.\n* The method `_getQueryComponents()` is deprecated, call `getQueryComponents()`\n instead.\n\nOn the `TreeWalkerChain` class, all implementations of now-deprecated\n`TreeWalker` methods have been deprecated as well. However, `SqlWalker` is\nunaffected by those deprecations and will continue to implement all of those\nmethods.\n\n## Deprecated passing `null` to `Doctrine\\ORM\\Query::setDQL()`\n\nDoing `$query->setDQL(null);` achieves nothing.\n\n## Deprecated omitting second argument to `NamingStrategy::joinColumnName`\n\nWhen implementing `NamingStrategy`, it is deprecated to implement\n`joinColumnName()` with only one argument.\n\n### Before\n\n```php\ngetConfiguration();\n-$config->addEntityNamespace('CMS', 'My\\App\\Cms');\n+use My\\App\\Cms\\CmsUser;\n\n-$entityManager->getRepository('CMS:CmsUser');\n+$entityManager->getRepository(CmsUser::class);\n```\n\n## Deprecate `AttributeDriver::getReader()` and `AnnotationDriver::getReader()`\n\nThat method was inherited from the abstract `AnnotationDriver` class of\n`doctrine/persistence`, and does not seem to serve any purpose.\n\n## Un-deprecate `Doctrine\\ORM\\Proxy\\Proxy`\n\nBecause no forward-compatible new proxy solution had been implemented yet, the\ncurrent proxy mechanism is not considered deprecated anymore for the time\nbeing. This applies to the following interfaces/classes:\n\n* `Doctrine\\ORM\\Proxy\\Proxy`\n* `Doctrine\\ORM\\Proxy\\ProxyFactory`\n\nThese methods have been un-deprecated:\n\n* `Doctrine\\ORM\\Configuration::getAutoGenerateProxyClasses()`\n* `Doctrine\\ORM\\Configuration::getProxyDir()`\n* `Doctrine\\ORM\\Configuration::getProxyNamespace()`\n\nNote that the `Doctrine\\ORM\\Proxy\\Autoloader` remains deprecated and will be removed in 3.0.\n\n## Deprecate helper methods from `AbstractCollectionPersister`\n\nThe following protected methods of\n`Doctrine\\ORM\\Cache\\Persister\\Collection\\AbstractCollectionPersister`\nare not in use anymore and will be removed.\n\n* `evictCollectionCache()`\n* `evictElementCache()`\n\n## Deprecate `Doctrine\\ORM\\Query\\TreeWalkerChainIterator`\n\nThis class won't have a replacement.\n\n## Deprecate `OnClearEventArgs::getEntityClass()` and `OnClearEventArgs::clearsAllEntities()`\n\nThese methods will be removed in 3.0 along with the ability to partially clear\nthe entity manager.\n\n## Deprecate `Doctrine\\ORM\\Configuration::newDefaultAnnotationDriver`\n\nThis functionality has been moved to the new `ORMSetup` class. Call\n`Doctrine\\ORM\\ORMSetup::createDefaultAnnotationDriver()` to create\na new annotation driver.\n\n## Deprecate `Doctrine\\ORM\\Tools\\Setup`\n\nIn our effort to migrate from Doctrine Cache to PSR-6, the `Setup` class which\naccepted a Doctrine Cache instance in each method has been deprecated.\n\nThe replacement is `Doctrine\\ORM\\ORMSetup` which accepts a PSR-6\ncache instead.\n\n## Deprecate `Doctrine\\ORM\\Cache\\MultiGetRegion`\n\nThe interface will be merged with `Doctrine\\ORM\\Cache\\Region` in 3.0.\n\n# Upgrade to 2.11\n\n## Rename `AbstractIdGenerator::generate()` to `generateId()`\n\nImplementations of `AbstractIdGenerator` have to override the method\n`generateId()` without calling the parent implementation. Not doing so is\ndeprecated. Calling `generate()` on any `AbstractIdGenerator` implementation\nis deprecated.\n\n## PSR-6-based second level cache\n\nThe second level cache has been reworked to consume a PSR-6 cache. Using a\nDoctrine Cache instance is deprecated.\n\n* `DefaultCacheFactory`: The constructor expects a PSR-6 cache item pool as\n second argument now.\n* `DefaultMultiGetRegion`: This class is deprecated in favor of `DefaultRegion`.\n* `DefaultRegion`:\n * The constructor expects a PSR-6 cache item pool as second argument now.\n * The protected `$cache` property is deprecated.\n * The properties `$name` and `$lifetime` as well as the constant\n `REGION_KEY_SEPARATOR` and the method `getCacheEntryKey()` are flagged as\n `@internal` now. They all will become `private` in 3.0.\n * The method `getCache()` is deprecated without replacement.\n\n## Deprecated: `Doctrine\\ORM\\Mapping\\Driver\\PHPDriver`\n\nUse `StaticPHPDriver` instead when you want to programmatically configure\nentity metadata.\n\nYou can convert mappings with the `orm:convert-mapping` command or more simply\nin this case, `include` the metadata file from the `loadMetadata` static method\nused by the `StaticPHPDriver`.\n\n## Deprecated: `Setup::registerAutoloadDirectory()`\n\nUse Composer's autoloader instead.\n\n## Deprecated: `AbstractHydrator::hydrateRow()`\n\nFollowing the deprecation of the method `AbstractHydrator::iterate()`, the\nmethod `hydrateRow()` has been deprecated as well.\n\n## Deprecate cache settings inspection\n\nDoctrine does not provide its own cache implementation anymore and relies on\nthe PSR-6 standard instead. As a consequence, we cannot determine anymore\nwhether a given cache adapter is suitable for a production environment.\nBecause of that, functionality that aims to do so has been deprecated:\n\n* `Configuration::ensureProductionSettings()`\n* the `orm:ensure-production-settings` console command\n\n# Upgrade to 2.10\n\n## BC Break: `UnitOfWork` now relies on SPL object IDs, not hashes\n\nWhen calling the following methods, you are now supposed to use the result of\n`spl_object_id()`, and not `spl_object_hash()`:\n- `UnitOfWork::clearEntityChangeSet()`\n- `UnitOfWork::setOriginalEntityProperty()`\n\n## BC Break: Removed `TABLE` id generator strategy\n\nThe implementation was unfinished for 14 years.\nIt is now deprecated to rely on:\n- `Doctrine\\ORM\\Id\\TableGenerator`;\n- `Doctrine\\ORM\\Mapping\\ClassMetadata::GENERATOR_TYPE_TABLE`;\n- `Doctrine\\ORM\\Mapping\\ClassMetadata::$tableGeneratorDefinition`;\n- or `Doctrine\\ORM\\Mapping\\ClassMetadata::isIdGeneratorTable()`.\n\n## New method `Doctrine\\ORM\\EntityManagerInterface#wrapInTransaction($func)`\n\nWorks the same as `Doctrine\\ORM\\EntityManagerInterface#transactional()` but returns any value returned from `$func` closure rather than just _non-empty value returned from the closure or true_.\n\nBecause of BC policy, the method does not exist on the interface yet. This is the example of safe usage:\n\n```php\nfunction foo(EntityManagerInterface $entityManager, callable $func) {\n if (method_exists($entityManager, 'wrapInTransaction')) {\n return $entityManager->wrapInTransaction($func);\n }\n\n return $entityManager->transactional($func);\n}\n```\n\n`Doctrine\\ORM\\EntityManagerInterface#transactional()` has been deprecated.\n\n## Minor BC BREAK: some exception methods have been removed\n\nThe following methods were not in use and are very unlikely to be used by\ndownstream packages or applications, and were consequently removed:\n\n- `ORMException::entityMissingForeignAssignedId`\n- `ORMException::entityMissingAssignedIdForField`\n- `ORMException::invalidFlushMode`\n\n## Deprecated: database-side UUID generation\n\n[DB-generated UUIDs are deprecated as of `doctrine/dbal` 2.8][DBAL deprecation].\nAs a consequence, using the `UUID` strategy for generating identifiers is deprecated as well.\nFurthermore, relying on the following classes and methods is deprecated:\n\n- `Doctrine\\ORM\\Id\\UuidGenerator`\n- `Doctrine\\ORM\\Mapping\\ClassMetadataInfo::isIdentifierUuid()`\n\n[DBAL deprecation]: https://github.com/doctrine/dbal/pull/3212\n\n## Minor BC BREAK: Custom hydrators and `toIterable()`\n\nThe type declaration of the `$stmt` parameter of `AbstractHydrator::toIterable()` has been removed. This change might\nbreak custom hydrator implementations that override this very method.\n\nOverriding this method is not recommended, which is why the method is documented as `@final` now.\n\n```diff\n- public function toIterable(ResultStatement $stmt, ResultSetMapping $resultSetMapping, array $hints = []): iterable\n+ public function toIterable($stmt, ResultSetMapping $resultSetMapping, array $hints = []): iterable\n```\n\n## Deprecated: Entity Namespace Aliases\n\nEntity namespace aliases are deprecated, use the magic ::class constant to abbreviate full class names\nin EntityManager, EntityRepository and DQL.\n\n```diff\n- $entityManager->find('MyBundle:User', $id);\n+ $entityManager->find(User::class, $id);\n```\n\n# Upgrade to 2.9\n\n## Minor BC BREAK: Setup tool needs cache implementation\n\nWith the deprecation of doctrine/cache, the setup tool might no longer work as expected without a different cache\nimplementation. To work around this:\n* Install symfony/cache: `composer require symfony/cache`. This will keep previous behaviour without any changes\n* Instantiate caches yourself: to use a different cache implementation, pass a cache instance when calling any\n configuration factory in the setup tool:\n ```diff\n - $config = Setup::createAnnotationMetadataConfiguration($paths, $isDevMode, $proxyDir);\n + $cache = \\Doctrine\\Common\\Cache\\Psr6\\DoctrineProvider::wrap($anyPsr6Implementation);\n + $config = Setup::createAnnotationMetadataConfiguration($paths, $isDevMode, $proxyDir, $cache);\n ```\n* As a quick workaround, you can lock the doctrine/cache dependency to work around this: `composer require doctrine/cache ^1.11`.\n Note that this is only recommended as a bandaid fix, as future versions of ORM will no longer work with doctrine/cache\n 1.11.\n\n## Deprecated: doctrine/cache for metadata caching\n\nThe `Doctrine\\ORM\\Configuration#setMetadataCacheImpl()` method is deprecated and should no longer be used. Please use\n`Doctrine\\ORM\\Configuration#setMetadataCache()` with any PSR-6 cache adapter instead.\n\n## Removed: flushing metadata cache\n\nTo support PSR-6 caches, the `--flush` option for the `orm:clear-cache:metadata` command is ignored. Metadata cache is\nnow always cleared regardless of the cache adapter being used.\n\n# Upgrade to 2.8\n\n## Minor BC BREAK: Failed commit now throw OptimisticLockException\n\nMethod `Doctrine\\ORM\\UnitOfWork#commit()` can throw an OptimisticLockException when a commit silently fails and returns false\nsince `Doctrine\\DBAL\\Connection#commit()` signature changed from returning void to boolean\n\n## Deprecated: `Doctrine\\ORM\\AbstractQuery#iterate()`\n\nThe method `Doctrine\\ORM\\AbstractQuery#iterate()` is deprecated in favor of `Doctrine\\ORM\\AbstractQuery#toIterable()`.\nNote that `toIterable()` yields results of the query, unlike `iterate()` which yielded each result wrapped into an array.\n\n# Upgrade to 2.7\n\n## Added `Doctrine\\ORM\\AbstractQuery#enableResultCache()` and `Doctrine\\ORM\\AbstractQuery#disableResultCache()` methods\n\nMethod `Doctrine\\ORM\\AbstractQuery#useResultCache()` which could be used for both enabling and disabling the cache\n(depending on passed flag) was split into two.\n\n## Minor BC BREAK: paginator output walkers aren't be called anymore on sub-queries for queries without max results\n\nTo optimize DB interaction, `Doctrine\\ORM\\Tools\\Pagination\\Paginator` no longer fetches identifiers to be able to\nperform the pagination with join collections when max results isn't set in the query.\n\n## Minor BC BREAK: tables filtered with `schema_filter` are no longer created\n\nWhen generating schema diffs, if a source table is filtered out by a `schema_filter` expression, then a `CREATE TABLE` was\nalways generated, even if the table already existed. This has been changed in this release and the table will no longer\nbe created.\n\n## Deprecated number unaware `Doctrine\\ORM\\Mapping\\UnderscoreNamingStrategy`\n\nIn the last patch of the `v2.6.x` series, we fixed a bug that was not converting names properly when they had numbers\n(e.g.: `base64Encoded` was wrongly converted to `base64encoded` instead of `base64_encoded`).\n\nIn order to not break BC we've introduced a way to enable the fixed behavior using a boolean constructor argument. This\nargument will be removed in 3.0 and the default behavior will be the fixed one.\n\n## Deprecated: `Doctrine\\ORM\\AbstractQuery#useResultCache()`\n\nMethod `Doctrine\\ORM\\AbstractQuery#useResultCache()` is deprecated because it is split into `enableResultCache()`\nand `disableResultCache()`. It will be removed in 3.0.\n\n## Deprecated code generators and related console commands\n\nThese console commands have been deprecated:\n\n * `orm:convert-mapping`\n * `orm:generate:entities`\n * `orm:generate-repositories`\n\nThese classes have been deprecated:\n\n * `Doctrine\\ORM\\Tools\\EntityGenerator`\n * `Doctrine\\ORM\\Tools\\EntityRepositoryGenerator`\n\nWhole Doctrine\\ORM\\Tools\\Export namespace with all its members have been deprecated as well.\n\n## Deprecated `Doctrine\\ORM\\Proxy\\Proxy` marker interface\n\nProxy objects in Doctrine ORM 3.0 will no longer implement `Doctrine\\ORM\\Proxy\\Proxy` nor\n`Doctrine\\Persistence\\Proxy`: instead, they implement\n`ProxyManager\\Proxy\\GhostObjectInterface`.\n\nThese related classes have been deprecated:\n\n * `Doctrine\\ORM\\Proxy\\ProxyFactory`\n * `Doctrine\\ORM\\Proxy\\Autoloader` - we suggest using the composer autoloader instead\n\nThese methods have been deprecated:\n\n * `Doctrine\\ORM\\Configuration#getAutoGenerateProxyClasses()`\n * `Doctrine\\ORM\\Configuration#getProxyDir()`\n * `Doctrine\\ORM\\Configuration#getProxyNamespace()`\n\n## Deprecated `Doctrine\\ORM\\Version`\n\nThe `Doctrine\\ORM\\Version` class is now deprecated and will be removed in Doctrine ORM 3.0:\nplease refrain from checking the ORM version at runtime or use Composer's [runtime API](https://getcomposer.org/doc/07-runtime.md#knowing-whether-package-x-is-installed-in-version-y).\n\n## Deprecated `EntityManager#merge()` method\n\nMerge semantics was a poor fit for the PHP \"share-nothing\" architecture.\nIn addition to that, merging caused multiple issues with data integrity\nin the managed entity graph, which was constantly spawning more edge-case bugs/scenarios.\n\nThe following API methods were therefore deprecated:\n\n* `EntityManager#merge()`\n* `UnitOfWork#merge()`\n\nAn alternative to `EntityManager#merge()` will not be provided by ORM 3.0, since the merging\nsemantics should be part of the business domain rather than the persistence domain of an\napplication. If your application relies heavily on CRUD-alike interactions and/or `PATCH`\nrestful operations, you should look at alternatives such as [JMSSerializer](https://github.com/schmittjoh/serializer).\n\n## Extending `EntityManager` is deprecated\n\nFinal keyword will be added to the `EntityManager::class` in Doctrine ORM 3.0 in order to ensure that EntityManager\n is not used as valid extension point. Valid extension point should be EntityManagerInterface.\n\n## Deprecated `EntityManager#clear($entityName)`\n\nIf your code relies on clearing a single entity type via `EntityManager#clear($entityName)`,\nthe signature has been changed to `EntityManager#clear()`.\n\nThe main reason is that partial clears caused multiple issues with data integrity\nin the managed entity graph, which was constantly spawning more edge-case bugs/scenarios.\n\n## Deprecated `EntityManager#flush($entity)` and `EntityManager#flush($entities)`\n\nIf your code relies on single entity flushing optimisations via\n`EntityManager#flush($entity)`, the signature has been changed to\n`EntityManager#flush()`.\n\nSaid API was affected by multiple data integrity bugs due to the fact\nthat change tracking was being restricted upon a subset of the managed\nentities. The ORM cannot support committing subsets of the managed\nentities while also guaranteeing data integrity, therefore this\nutility was removed.\n\nThe `flush()` semantics will remain the same, but the change tracking will be performed\non all entities managed by the unit of work, and not just on the provided\n`$entity` or `$entities`, as the parameter is now completely ignored.\n\nThe same applies to `UnitOfWork#commit($entity)`, which will simply be\n`UnitOfWork#commit()`.\n\nIf you would still like to perform batching operations over small `UnitOfWork`\ninstances, it is suggested to follow these paths instead:\n\n * eagerly use `EntityManager#clear()` in conjunction with a specific second level\n cache configuration (see http://docs.doctrine-project.org/projects/doctrine-orm/en/stable/reference/second-level-cache.html)\n * use an explicit change tracking policy (see http://docs.doctrine-project.org/projects/doctrine-orm/en/stable/reference/change-tracking-policies.html)\n\n## Deprecated `YAML` mapping drivers.\n\nIf your code relies on `YamlDriver` or `SimpleYamlDriver`, you **MUST** change to\nannotation or XML drivers instead.\n\n## Deprecated: `Doctrine\\ORM\\EntityManagerInterface#copy()`\n\nMethod `Doctrine\\ORM\\EntityManagerInterface#copy()` never got its implementation and is deprecated.\nIt will be removed in 3.0.\n\n# Upgrade to 2.6\n\n## Added `Doctrine\\ORM\\EntityRepository::count()` method\n\n`Doctrine\\ORM\\EntityRepository::count()` has been added. This new method has different\nsignature than `Countable::count()` (required parameter) and therefore are not compatible.\nIf your repository implemented the `Countable` interface, you will have to use\n`$repository->count([])` instead and not implement `Countable` interface anymore.\n\n## Minor BC BREAK: `Doctrine\\ORM\\Tools\\Console\\ConsoleRunner` is now final\n\nSince it's just an utilitarian class and should not be inherited.\n\n## Minor BC BREAK: removed `Doctrine\\ORM\\Query\\QueryException::associationPathInverseSideNotSupported()`\n\nMethod `Doctrine\\ORM\\Query\\QueryException::associationPathInverseSideNotSupported()`\nnow has a required parameter `$pathExpr`.\n\n## Minor BC BREAK: removed `Doctrine\\ORM\\Query\\Parser#isInternalFunction()`\n\nMethod `Doctrine\\ORM\\Query\\Parser#isInternalFunction()` was removed because\nthe distinction between internal function and user defined DQL was removed.\n[#6500](https://github.com/doctrine/orm/pull/6500)\n\n## Minor BC BREAK: removed `Doctrine\\ORM\\ORMException#overwriteInternalDQLFunctionNotAllowed()`\n\nMethod `Doctrine\\ORM\\Query\\Parser#overwriteInternalDQLFunctionNotAllowed()` was\nremoved because of the choice to allow users to overwrite internal functions, ie\n`AVG`, `SUM`, `COUNT`, `MIN` and `MAX`. [#6500](https://github.com/doctrine/orm/pull/6500)\n\n## PHP 7.1 is now required\n\nDoctrine 2.6 now requires PHP 7.1 or newer.\n\nAs a consequence, automatic cache setup in Doctrine\\ORM\\Tools\\Setup::create*Configuration() was changed:\n- APCu extension (ext-apcu) will now be used instead of abandoned APC (ext-apc).\n- Memcached extension (ext-memcached) will be used instead of obsolete Memcache (ext-memcache).\n- XCache support was dropped as it doesn't work with PHP 7.\n\n# Upgrade to 2.5\n\n## Minor BC BREAK: removed `Doctrine\\ORM\\Query\\SqlWalker#walkCaseExpression()`\n\nMethod `Doctrine\\ORM\\Query\\SqlWalker#walkCaseExpression()` was unused and part\nof the internal API of the ORM, so it was removed. [#5600](https://github.com/doctrine/orm/pull/5600).\n\n## Minor BC BREAK: removed $className parameter on `AbstractEntityInheritancePersister#getSelectJoinColumnSQL()`\n\nAs `$className` parameter was not used in the method, it was safely removed.\n\n## Minor BC BREAK: query cache key time is now a float\n\nAs of 2.5.5, the `QueryCacheEntry#time` property will contain a float value\ninstead of an integer in order to have more precision and also to be consistent\nwith the `TimestampCacheEntry#time`.\n\n## Minor BC BREAK: discriminator map must now include all non-transient classes\n\nIt is now required that you declare the root of an inheritance in the\ndiscriminator map.\n\nWhen declaring an inheritance map, it was previously possible to skip the root\nof the inheritance in the discriminator map. This was actually a validation\nmistake by Doctrine2 and led to problems when trying to persist instances of\nthat class.\n\nIf you don't plan to persist instances some classes in your inheritance, then\neither:\n\n - make those classes `abstract`\n - map those classes as `MappedSuperclass`\n\n## Minor BC BREAK: ``EntityManagerInterface`` instead of ``EntityManager`` in type-hints\n\nAs of 2.5, classes requiring the ``EntityManager`` in any method signature will now require\nan ``EntityManagerInterface`` instead.\nIf you are extending any of the following classes, then you need to check following\nsignatures:\n\n- ``Doctrine\\ORM\\Tools\\DebugUnitOfWorkListener#dumpIdentityMap(EntityManagerInterface $em)``\n- ``Doctrine\\ORM\\Mapping\\ClassMetadataFactory#setEntityManager(EntityManagerInterface $em)``\n\n## Minor BC BREAK: Custom Hydrators API change\n\nAs of 2.5, `AbstractHydrator` does not enforce the usage of cache as part of\nAPI, and now provides you a clean API for column information through the method\n`hydrateColumnInfo($column)`.\nCache variable being passed around by reference is no longer needed since\nHydrators are per query instantiated since Doctrine 2.4.\n\n## Minor BC BREAK: Entity based ``EntityManager#clear()`` calls follow cascade detach\n\nWhenever ``EntityManager#clear()`` method gets called with a given entity class\nname, until 2.4, it was only detaching the specific requested entity.\nAs of 2.5, ``EntityManager`` will follow configured cascades, providing a better\nmemory management since associations will be garbage collected, optimizing\nresources consumption on long running jobs.\n\n## BC BREAK: NamingStrategy interface changes\n\n1. A new method ``embeddedFieldToColumnName($propertyName, $embeddedColumnName)``\n\nThis method generates the column name for fields of embedded objects. If you implement your custom NamingStrategy, you\nnow also need to implement this new method.\n\n2. A change to method ``joinColumnName()`` to include the $className\n\n## Updates on entities scheduled for deletion are no longer processed\n\nIn Doctrine 2.4, if you modified properties of an entity scheduled for deletion, UnitOfWork would\nproduce an UPDATE statement to be executed right before the DELETE statement. The entity in question\nwas therefore present in ``UnitOfWork#entityUpdates``, which means that ``preUpdate`` and ``postUpdate``\nlisteners were (quite pointlessly) called. In ``preFlush`` listeners, it used to be possible to undo\nthe scheduled deletion for updated entities (by calling ``persist()`` if the entity was found in both\n``entityUpdates`` and ``entityDeletions``). This does not work any longer, because the entire changeset\ncalculation logic is optimized away.\n\n## Minor BC BREAK: Default lock mode changed from LockMode::NONE to null in method signatures\n\nA misconception concerning default lock mode values in method signatures lead to unexpected behaviour\nin SQL statements on SQL Server. With a default lock mode of ``LockMode::NONE`` throughout the\nmethod signatures in ORM, the table lock hint ``WITH (NOLOCK)`` was appended to all locking related\nqueries by default. This could result in unpredictable results because an explicit ``WITH (NOLOCK)``\ntable hint tells SQL Server to run a specific query in transaction isolation level READ UNCOMMITTED\ninstead of the default READ COMMITTED transaction isolation level.\nTherefore there now is a distinction between ``LockMode::NONE`` and ``null`` to be able to tell\nDoctrine whether to add table lock hints to queries by intention or not. To achieve this, the following\nmethod signatures have been changed to declare ``$lockMode = null`` instead of ``$lockMode = LockMode::NONE``:\n\n- ``Doctrine\\ORM\\Cache\\Persister\\AbstractEntityPersister#getSelectSQL()``\n- ``Doctrine\\ORM\\Cache\\Persister\\AbstractEntityPersister#load()``\n- ``Doctrine\\ORM\\Cache\\Persister\\AbstractEntityPersister#refresh()``\n- ``Doctrine\\ORM\\Decorator\\EntityManagerDecorator#find()``\n- ``Doctrine\\ORM\\EntityManager#find()``\n- ``Doctrine\\ORM\\EntityRepository#find()``\n- ``Doctrine\\ORM\\Persisters\\BasicEntityPersister#getSelectSQL()``\n- ``Doctrine\\ORM\\Persisters\\BasicEntityPersister#load()``\n- ``Doctrine\\ORM\\Persisters\\BasicEntityPersister#refresh()``\n- ``Doctrine\\ORM\\Persisters\\EntityPersister#getSelectSQL()``\n- ``Doctrine\\ORM\\Persisters\\EntityPersister#load()``\n- ``Doctrine\\ORM\\Persisters\\EntityPersister#refresh()``\n- ``Doctrine\\ORM\\Persisters\\JoinedSubclassPersister#getSelectSQL()``\n\nYou should update signatures for these methods if you have subclassed one of the above classes.\nPlease also check the calling code of these methods in your application and update if necessary.\n\n**Note:**\nThis in fact is really a minor BC BREAK and should not have any affect on database vendors\nother than SQL Server because it is the only one that supports and therefore cares about\n``LockMode::NONE``. It's really just a FIX for SQL Server environments using ORM.\n\n## Minor BC BREAK: `__clone` method not called anymore when entities are instantiated via metadata API\n\nAs of PHP 5.6, instantiation of new entities is deferred to the\n[`doctrine/instantiator`](https://github.com/doctrine/instantiator) library, which will avoid calling `__clone`\nor any public API on instantiated objects.\n\n## BC BREAK: `Doctrine\\ORM\\Repository\\DefaultRepositoryFactory` is now `final`\n\nPlease implement the `Doctrine\\ORM\\Repository\\RepositoryFactory` interface instead of extending\nthe `Doctrine\\ORM\\Repository\\DefaultRepositoryFactory`.\n\n## BC BREAK: New object expression DQL queries now respects user provided aliasing and not return consumed fields\n\nWhen executing DQL queries with new object expressions, instead of returning DTOs numerically indexes, it will now respect user provided aliases. Consider the following query:\n\n SELECT new UserDTO(u.id,u.name) as user,new AddressDTO(a.street,a.postalCode) as address, a.id as addressId FROM User u INNER JOIN u.addresses a WITH a.isPrimary = true\n\nPreviously, your result would be similar to this:\n\n array(\n 0=>array(\n 0=>{UserDTO object},\n 1=>{AddressDTO object},\n 2=>{u.id scalar},\n 3=>{u.name scalar},\n 4=>{a.street scalar},\n 5=>{a.postalCode scalar},\n 'addressId'=>{a.id scalar},\n ),\n ...\n )\n\nFrom now on, the resultset will look like this:\n\n array(\n 0=>array(\n 'user'=>{UserDTO object},\n 'address'=>{AddressDTO object},\n 'addressId'=>{a.id scalar}\n ),\n ...\n )\n\n## Minor BC BREAK: added second parameter $indexBy in EntityRepository#createQueryBuilder method signature\n\nAdded way to access the underlying QueryBuilder#from() method's 'indexBy' parameter when using EntityRepository#createQueryBuilder()\n\n# Upgrade to 2.4\n\n## BC BREAK: Compatibility Bugfix in PersistentCollection#matching()\n\nIn Doctrine 2.3 it was possible to use the new ``matching($criteria)``\nfunctionality by adding constraints for assocations based on ID:\n\n Criteria::expr()->eq('association', $assocation->getId());\n\nThis functionality does not work on InMemory collections however, because\nin memory criteria compares object values based on reference.\nAs of 2.4 the above code will throw an exception. You need to change\noffending code to pass the ``$assocation`` reference directly:\n\n Criteria::expr()->eq('association', $assocation);\n\n## Composer is now the default autoloader\n\nThe test suite now runs with composer autoloading. Support for PEAR, and tarball autoloading is deprecated.\nSupport for GIT submodules is removed.\n\n## OnFlush and PostFlush event always called\n\nBefore 2.4 the postFlush and onFlush events were only called when there were\nactually entities that changed. Now these events are called no matter if there\nare entities in the UoW or changes are found.\n\n## Parenthesis are now considered in arithmetic expression\n\nBefore 2.4 parenthesis are not considered in arithmetic primary expression.\nThat's conceptually wrong, since it might result in wrong values. For example:\n\nThe DQL:\n\n SELECT 100 / ( 2 * 2 ) FROM MyEntity\n\nBefore 2.4 it generates the SQL:\n\n SELECT 100 / 2 * 2 FROM my_entity\n\nNow parenthesis are considered, the previous DQL will generate:\n\n SELECT 100 / (2 * 2) FROM my_entity\n\n# Upgrade to 2.3\n\n## Auto Discriminator Map breaks userland implementations with Listener\n\nThe new feature to detect discriminator maps automatically when none\nare provided breaks userland implementations doing this with a\nlistener in ``loadClassMetadata`` event.\n\n## EntityManager#find() not calls EntityRepository#find() anymore\n\nPrevious to 2.3, calling ``EntityManager#find()`` would be delegated to\n``EntityRepository#find()``. This has lead to some unexpected behavior in the\ncore of Doctrine when people have overwritten the find method in their\nrepositories. That is why this behavior has been reversed in 2.3, and\n``EntityRepository#find()`` calls ``EntityManager#find()`` instead.\n\n## EntityGenerator add*() method generation\n\nWhen generating an add*() method for a collection the EntityGenerator will now not\nuse the Type-Hint to get the singular for the collection name, but use the field-name\nand strip a trailing \"s\" character if there is one.\n\n## Merge copies non persisted properties too\n\nWhen merging an entity in UoW not only mapped properties are copied, but also others.\n\n## Query, QueryBuilder and NativeQuery parameters *BC break*\n\nFrom now on, parameters in queries is an ArrayCollection instead of a simple array.\nThis affects heavily the usage of setParameters(), because it will not append anymore\nparameters to query, but will actually override the already defined ones.\nWhenever you are retrieving a parameter (ie. $query->getParameter(1)), you will\nreceive an instance of Query\\Parameter, which contains the methods \"getName\",\n\"getValue\" and \"getType\". Parameters are also only converted to when necessary, and\nnot when they are set.\n\nAlso, related functions were affected:\n\n* execute($parameters, $hydrationMode) the argument $parameters can be either an key=>value array or an ArrayCollection instance\n* iterate($parameters, $hydrationMode) the argument $parameters can be either an key=>value array or an ArrayCollection instance\n* setParameters($parameters) the argument $parameters can be either an key=>value array or an ArrayCollection instance\n* getParameters() now returns ArrayCollection instead of array\n* getParameter($key) now returns Parameter instance instead of parameter value\n\n## Query TreeWalker method renamed\n\nInternal changes were made to DQL and SQL generation. If you have implemented your own TreeWalker,\nyou probably need to update it. The method walkJoinVariableDeclaration is now named walkJoin.\n\n## New methods in TreeWalker interface *BC break*\n\nTwo methods getQueryComponents() and setQueryComponent() were added to the TreeWalker interface and all its implementations\nincluding TreeWalkerAdapter, TreeWalkerChain and SqlWalker. If you have your own implementation not inheriting from one of the\nabove you must implement these new methods.\n\n## Metadata Drivers\n\nMetadata drivers have been rewritten to reuse code from `Doctrine\\Persistence`. Anyone who is using the\n`Doctrine\\ORM\\Mapping\\Driver\\Driver` interface should instead refer to\n`Doctrine\\Persistence\\Mapping\\Driver\\MappingDriver`. Same applies to\n`Doctrine\\ORM\\Mapping\\Driver\\AbstractFileDriver`: you should now refer to\n`Doctrine\\Persistence\\Mapping\\Driver\\FileDriver`.\n\nAlso, following mapping drivers have been deprecated, please use their replacements in Doctrine\\Common as listed:\n\n * `Doctrine\\ORM\\Mapping\\Driver\\DriverChain` => `Doctrine\\Persistence\\Mapping\\Driver\\MappingDriverChain`\n * `Doctrine\\ORM\\Mapping\\Driver\\PHPDriver` => `Doctrine\\Persistence\\Mapping\\Driver\\PHPDriver`\n * `Doctrine\\ORM\\Mapping\\Driver\\StaticPHPDriver` => `Doctrine\\Persistence\\Mapping\\Driver\\StaticPHPDriver`\n\n# Upgrade to 2.2\n\n## ResultCache implementation rewritten\n\nThe result cache is completely rewritten and now works on the database result level, not inside the ORM AbstractQuery\nanymore. This means that for result cached queries the hydration will now always be performed again, regardless of\nthe hydration mode. Affected areas are:\n\n1. Fixes the problem that entities coming from the result cache were not registered in the UnitOfWork\n leading to problems during EntityManager#flush. Calls to EntityManager#merge are not necessary anymore.\n2. Affects the array hydrator which now includes the overhead of hydration compared to caching the final result.\n\nThe API is backwards compatible however most of the getter methods on the `AbstractQuery` object are now\ndeprecated in favor of calling AbstractQuery#getQueryCacheProfile(). This method returns a `Doctrine\\DBAL\\Cache\\QueryCacheProfile`\ninstance with access to result cache driver, lifetime and cache key.\n\n\n## EntityManager#getPartialReference() creates read-only entity\n\nEntities returned from EntityManager#getPartialReference() are now marked as read-only if they\nhaven't been in the identity map before. This means objects of this kind never lead to changes\nin the UnitOfWork.\n\n\n## Fields omitted in a partial DQL query or a native query are never updated\n\nFields of an entity that are not returned from a partial DQL Query or native SQL query\nwill never be updated through an UPDATE statement.\n\n\n## Removed support for onUpdate in @JoinColumn\n\nThe onUpdate foreign key handling makes absolutely no sense in an ORM. Additionally Oracle doesn't even support it. Support for it is removed.\n\n\n## Changes in Annotation Handling\n\nThere have been some changes to the annotation handling in Common 2.2 again, that affect how people with old configurations\nfrom 2.0 have to configure the annotation driver if they don't use `Configuration::newDefaultAnnotationDriver()`:\n\n // Register the ORM Annotations in the AnnotationRegistry\n AnnotationRegistry::registerFile('path/to/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php');\n\n $reader = new \\Doctrine\\Common\\Annotations\\SimpleAnnotationReader();\n $reader->addNamespace('Doctrine\\ORM\\Mapping');\n $reader = new \\Doctrine\\Common\\Annotations\\CachedReader($reader, new ArrayCache());\n\n $driver = new AnnotationDriver($reader, (array)$paths);\n\n $config->setMetadataDriverImpl($driver);\n\n\n## Scalar mappings can now be omitted from DQL result\n\nYou are now allowed to mark scalar SELECT expressions as HIDDEN and they are not hydrated anymore.\nExample:\n\nSELECT u, SUM(a.id) AS HIDDEN numArticles FROM User u LEFT JOIN u.Articles a ORDER BY numArticles DESC HAVING numArticles > 10\n\nYour result will be a collection of Users, and not an array with key 0 as User object instance and \"numArticles\" as the number of articles per user\n\n\n## Map entities as scalars in DQL result\n\nWhen hydrating to array or even a mixed result in object hydrator, previously you had the 0 index holding you entity instance.\nYou are now allowed to alias this, providing more flexibility for you code.\nExample:\n\nSELECT u AS user FROM User u\n\nWill now return a collection of arrays with index \"user\" pointing to the User object instance.\n\n\n## Performance optimizations\n\nThousands of lines were completely reviewed and optimized for best performance.\nRemoved redundancy and improved code readability made now internal Doctrine code easier to understand.\nAlso, Doctrine 2.2 now is around 10-15% faster than 2.1.\n\n## EntityManager#find(null)\n\nPreviously EntityManager#find(null) returned null. It now throws an exception.\n\n# Upgrade to 2.1\n\n## Interface for EntityRepository\n\nThe EntityRepository now has an interface Doctrine\\Persistence\\ObjectRepository. This means that your classes that override EntityRepository and extend find(), findOneBy() or findBy() must be adjusted to follow this interface.\n\n## AnnotationReader changes\n\nThe annotation reader was heavily refactored between 2.0 and 2.1-RC1. In theory the operation of the new reader should be backwards compatible, but it has to be setup differently to work that way:\n\n // new call to the AnnotationRegistry\n \\Doctrine\\Common\\Annotations\\AnnotationRegistry::registerFile('/doctrine-src/src/Mapping/Driver/DoctrineAnnotations.php');\n\n $reader = new \\Doctrine\\Common\\Annotations\\AnnotationReader();\n $reader->setDefaultAnnotationNamespace('Doctrine\\ORM\\Mapping\\\\');\n // new code necessary starting here\n $reader->setIgnoreNotImportedAnnotations(true);\n $reader->setEnableParsePhpImports(false);\n $reader = new \\Doctrine\\Common\\Annotations\\CachedReader(\n new \\Doctrine\\Common\\Annotations\\IndexedReader($reader), new ArrayCache()\n );\n\nThis is already done inside the ``$config->newDefaultAnnotationDriver``, so everything should automatically work if you are using this method. You can verify if everything still works by executing a console command such as schema-validate that loads all metadata into memory.\n\n# Update from 2.0-BETA3 to 2.0-BETA4\n\n## XML Driver element demoted to attribute\n\nWe changed how the XML Driver allows to define the change-tracking-policy. The working case is now:\n\n \n\n# Update from 2.0-BETA2 to 2.0-BETA3\n\n## Serialization of Uninitialized Proxies\n\nAs of Beta3 you can now serialize uninitialized proxies, an exception will only be thrown when\ntrying to access methods on the unserialized proxy as long as it has not been re-attached to the\nEntityManager using `EntityManager#merge()`. See this example:\n\n $proxy = $em->getReference('User', 1);\n\n $serializedProxy = serialize($proxy);\n $detachedProxy = unserialized($serializedProxy);\n\n echo $em->contains($detachedProxy); // FALSE\n\n try {\n $detachedProxy->getId(); // uninitialized detached proxy\n } catch(Exception $e) {\n\n }\n $attachedProxy = $em->merge($detachedProxy);\n echo $attackedProxy->getId(); // works!\n\n## Changed SQL implementation of Postgres and Oracle DateTime types\n\nThe DBAL Type \"datetime\" included the Timezone Offset in both Postgres and Oracle. As of this version they are now\ngenerated without Timezone (TIMESTAMP WITHOUT TIME ZONE instead of TIMESTAMP WITH TIME ZONE).\nSee [this comment to Ticket DBAL-22](http://www.doctrine-project.org/jira/browse/DBAL-22?focusedCommentId=13396&page=com.atlassian.jira.plugin.system.issuetabpanels%3Acomment-tabpanel#action_13396)\nfor more details as well as migration issues for PostgreSQL and Oracle.\n\nBoth Postgres and Oracle will throw Exceptions during hydration of Objects with \"DateTime\" fields unless migration steps are taken!\n\n## Removed multi-dot/deep-path expressions in DQL\n\nThe support for implicit joins in DQL through the multi-dot/Deep Path Expressions\nwas dropped. For example:\n\n SELECT u FROM User u WHERE u.group.name = ?1\n\nSee the \"u.group.id\" here is using multi dots (deep expression) to walk\nthrough the graph of objects and properties. Internally the DQL parser\nwould rewrite these queries to:\n\n SELECT u FROM User u JOIN u.group g WHERE g.name = ?1\n\nThis explicit notation will be the only supported notation as of now. The internal\nhandling of multi-dots in the DQL Parser was very complex, error prone in edge cases\nand required special treatment for several features we added. Additionally\nit had edge cases that could not be solved without making the DQL Parser\neven much more complex. For this reason we will drop the support for the\ndeep path expressions to increase maintainability and overall performance\nof the DQL parsing process. This will benefit any DQL query being parsed,\neven those not using deep path expressions.\n\nNote that the generated SQL of both notations is exactly the same! You\ndon't loose anything through this.\n\n## Default Allocation Size for Sequences\n\nThe default allocation size for sequences has been changed from 10 to 1. This step was made\nto not cause confusion with users and also because it is partly some kind of premature optimization.\n\n# Update from 2.0-BETA1 to 2.0-BETA2\n\nThere are no backwards incompatible changes in this release.\n\n# Upgrade from 2.0-ALPHA4 to 2.0-BETA1\n\n## EntityRepository deprecates access to protected variables\n\nInstead of accessing protected variables for the EntityManager in\na custom EntityRepository it is now required to use the getter methods\nfor all the three instance variables:\n\n* `$this->_em` now accessible through `$this->getEntityManager()`\n* `$this->_class` now accessible through `$this->getClassMetadata()`\n* `$this->_entityName` now accessible through `$this->getEntityName()`\n\nImportant: For Beta 2 the protected visibility of these three properties will be\nchanged to private!\n\n## Console migrated to Symfony Console\n\nThe Doctrine CLI has been replaced by Symfony Console Configuration\n\nInstead of having to specify:\n\n [php]\n $cliConfig = new CliConfiguration();\n $cliConfig->setAttribute('em', $entityManager);\n\nYou now have to configure the script like:\n\n [php]\n $helperSet = new \\Symfony\\Components\\Console\\Helper\\HelperSet(array(\n 'db' => new \\Doctrine\\DBAL\\Tools\\Console\\Helper\\ConnectionHelper($em->getConnection()),\n 'em' => new \\Doctrine\\ORM\\Tools\\Console\\Helper\\EntityManagerHelper($em)\n ));\n\n## Console: No need for Mapping Paths anymore\n\nIn previous versions you had to specify the --from and --from-path options\nto show where your mapping paths are from the console. However this information\nis already known from the Mapping Driver configuration, so the requirement\nfor this options were dropped.\n\nInstead for each console command all the entities are loaded and to\nrestrict the operation to one or more sub-groups you can use the --filter flag.\n\n## AnnotationDriver is not a default mapping driver anymore\n\nIn conjunction with the recent changes to Console we realized that the\nannotations driver being a default metadata driver lead to lots of glue\ncode in the console components to detect where entities lie and how to load\nthem for batch updates like SchemaTool and other commands. However the\nannotations driver being a default driver does not really help that much\nanyways.\n\nTherefore we decided to break backwards compatibility in this issue and drop\nthe support for Annotations as Default Driver and require our users to\nspecify the driver explicitly (which allows us to ask for the path to all\nentities).\n\nIf you are using the annotations metadata driver as default driver, you\nhave to add the following lines to your bootstrap code:\n\n $driverImpl = $config->newDefaultAnnotationDriver(array(__DIR__.\"/Entities\"));\n $config->setMetadataDriverImpl($driverImpl);\n\nYou have to specify the path to your entities as either string of a single\npath or array of multiple paths\nto your entities. This information will be used by all console commands to\naccess all entities.\n\nXml and Yaml Drivers work as before!\n\n\n## New inversedBy attribute\n\nIt is now *mandatory* that the owning side of a bidirectional association specifies the\n'inversedBy' attribute that points to the name of the field on the inverse side that completes\nthe association. Example:\n\n [php]\n // BEFORE (ALPHA4 AND EARLIER)\n class User\n {\n //...\n /** @OneToOne(targetEntity=\"Address\", mappedBy=\"user\") */\n private $address;\n //...\n }\n class Address\n {\n //...\n /** @OneToOne(targetEntity=\"User\") */\n private $user;\n //...\n }\n\n // SINCE BETA1\n // User class DOES NOT CHANGE\n class Address\n {\n //...\n /** @OneToOne(targetEntity=\"User\", inversedBy=\"address\") */\n private $user;\n //...\n }\n\nThus, the inversedBy attribute is the counterpart to the mappedBy attribute. This change\nwas necessary to enable some simplifications and further performance improvements. We\napologize for the inconvenience.\n\n## Default Property for Field Mappings\n\nThe \"default\" option for database column defaults has been removed. If desired, database column defaults can\nbe implemented by using the columnDefinition attribute of the @Column annotation (or the appropriate XML and YAML equivalents).\nPrefer PHP default values, if possible.\n\n## Selecting Partial Objects\n\nQuerying for partial objects now has a new syntax. The old syntax to query for partial objects\nnow has a different meaning. This is best illustrated by an example. If you previously\nhad a DQL query like this:\n\n [sql]\n SELECT u.id, u.name FROM User u\n\nSince BETA1, simple state field path expressions in the select clause are used to select\nobject fields as plain scalar values (something that was not possible before).\nTo achieve the same result as previously (that is, a partial object with only id and name populated)\nyou need to use the following, explicit syntax:\n\n [sql]\n SELECT PARTIAL u.{id,name} FROM User u\n\n## XML Mapping Driver\n\nThe 'inheritance-type' attribute changed to take last bit of ClassMetadata constant names, i.e.\nNONE, SINGLE_TABLE, INHERITANCE_TYPE_JOINED\n\n## YAML Mapping Driver\n\nThe way to specify lifecycle callbacks in YAML Mapping driver was changed to allow for multiple callbacks\nper event. The Old syntax ways:\n\n [yaml]\n lifecycleCallbacks:\n doStuffOnPrePersist: prePersist\n doStuffOnPostPersist: postPersist\n\nThe new syntax is:\n\n [yaml]\n lifecycleCallbacks:\n prePersist: [ doStuffOnPrePersist, doOtherStuffOnPrePersistToo ]\n postPersist: [ doStuffOnPostPersist ]\n\n## PreUpdate Event Listeners\n\nEvent Listeners listening to the 'preUpdate' event can only affect the primitive values of entity changesets\nby using the API on the `PreUpdateEventArgs` instance passed to the preUpdate listener method. Any changes\nto the state of the entitys properties won't affect the database UPDATE statement anymore. This gives drastic\nperformance benefits for the preUpdate event.\n\n## Collection API\n\nThe Collection interface in the Common package has been updated with some missing methods\nthat were present only on the default implementation, ArrayCollection. Custom collection\nimplementations need to be updated to adhere to the updated interface.\n\n# Upgrade from 2.0-ALPHA3 to 2.0-ALPHA4\n\n## CLI Controller changes\n\nCLI main object changed its name and namespace. Renamed from Doctrine\\ORM\\Tools\\Cli to Doctrine\\Common\\Cli\\CliController.\nDoctrine\\Common\\Cli\\CliController now only deals with namespaces. Ready to go, Core, Dbal and Orm are available and you can subscribe new tasks by retrieving the namespace and including new task. Example:\n\n [php]\n $cli->getNamespace('Core')->addTask('my-example', '\\MyProject\\Tools\\Cli\\Tasks\\MyExampleTask');\n\n\n## CLI Tasks documentation\n\nTasks have implemented a new way to build documentation. Although it is still possible to define the help manually by extending the basicHelp and extendedHelp, they are now optional.\nWith new required method AbstractTask::buildDocumentation, its implementation defines the TaskDocumentation instance (accessible through AbstractTask::getDocumentation()), basicHelp and extendedHelp are now not necessary to be implemented.\n\n## Changes in Method Signatures\n\n * A bunch of Methods on both Doctrine\\DBAL\\Platforms\\AbstractPlatform and Doctrine\\DBAL\\Schema\\AbstractSchemaManager\n have changed quite significantly by adopting the new Schema instance objects.\n\n## Renamed Methods\n\n * Doctrine\\ORM\\AbstractQuery::setExpireResultCache() -> expireResultCache()\n * Doctrine\\ORM\\Query::setExpireQueryCache() -> expireQueryCache()\n\n## SchemaTool Changes\n\n * \"doctrine schema-tool --drop\" now always drops the complete database instead of\n only those tables defined by the current database model. The previous method had\n problems when foreign keys of orphaned tables pointed to tables that were scheduled\n for deletion.\n * Use \"doctrine schema-tool --update\" to get a save incremental update for your\n database schema without deleting any unused tables, sequences or foreign keys.\n * Use \"doctrine schema-tool --complete-update\" to do a full incremental update of\n your schema.\n# Upgrade from 2.0-ALPHA2 to 2.0-ALPHA3\n\nThis section details the changes made to Doctrine 2.0-ALPHA3 to make it easier for you\nto upgrade your projects to use this version.\n\n## CLI Changes\n\nThe $args variable used in the cli-config.php for configuring the Doctrine CLI has been renamed to $globalArguments.\n\n## Proxy class changes\n\nYou are now required to make supply some minimalist configuration with regards to proxy objects. That involves 2 new configuration options. First, the directory where generated proxy classes should be placed needs to be specified. Secondly, you need to configure the namespace used for proxy classes. The following snippet shows an example:\n\n [php]\n // step 1: configure directory for proxy classes\n // $config instanceof Doctrine\\ORM\\Configuration\n $config->setProxyDir('/path/to/myproject/lib/MyProject/Generated/Proxies');\n $config->setProxyNamespace('MyProject\\Generated\\Proxies');\n\nNote that proxy classes behave exactly like any other classes when it comes to class loading. Therefore you need to make sure the proxy classes can be loaded by some class loader. If you place the generated proxy classes in a namespace and directory under your projects class files, like in the example above, it would be sufficient to register the MyProject namespace on a class loader. Since the proxy classes are contained in that namespace and adhere to the standards for class loading, no additional work is required.\nGenerating the proxy classes into a namespace within your class library is the recommended setup.\n\nEntities with initialized proxy objects can now be serialized and unserialized properly from within the same application.\n\nFor more details refer to the Configuration section of the manual.\n\n## Removed allowPartialObjects configuration option\n\nThe allowPartialObjects configuration option together with the `Configuration#getAllowPartialObjects` and `Configuration#setAllowPartialObjects` methods have been removed.\nThe new behavior is as if the option were set to FALSE all the time, basically disallowing partial objects globally. However, you can still use the `Query::HINT_FORCE_PARTIAL_LOAD` query hint to force a query to return partial objects for optimization purposes.\n\n## Renamed Methods\n\n* Doctrine\\ORM\\Configuration#getCacheDir() to getProxyDir()\n* Doctrine\\ORM\\Configuration#setCacheDir($dir) to setProxyDir($dir)\n"
},
{
"path": "ci/github/phpunit/mysqli.xml",
"content": "\n\n \n \n \n \n \n \n \n \n \n \n\n \n \n \n \n\n \n \n ../../../tests\n \n \n\n \n \n ../../../src\n \n \n\n \n \n performance\n locking_functional\n \n \n\n"
},
{
"path": "ci/github/phpunit/pdo_mysql.xml",
"content": "\n\n \n \n \n \n \n \n \n \n \n \n\n \n \n \n \n\n \n \n ../../../tests\n \n \n\n \n \n ../../../src\n \n \n\n \n \n performance\n locking_functional\n \n \n\n"
},
{
"path": "ci/github/phpunit/pdo_pgsql.xml",
"content": "\n\n \n \n \n \n \n \n \n\n \n \n \n \n\n \n \n ../../../tests\n \n \n\n \n \n ../../../src\n \n \n\n \n \n performance\n locking_functional\n \n \n\n"
},
{
"path": "ci/github/phpunit/pdo_sqlite.xml",
"content": "\n\n \n \n \n \n \n\n \n \n \n \n\n \n \n ../../../tests\n \n \n\n \n \n ../../../src\n \n \n\n \n \n performance\n locking_functional\n \n \n\n"
},
{
"path": "ci/github/phpunit/pgsql.xml",
"content": "\n\n \n \n \n \n \n \n \n\n \n \n \n \n\n \n \n ../../../tests\n \n \n\n \n \n ../../../src\n \n \n\n \n \n performance\n locking_functional\n \n \n\n"
},
{
"path": "ci/github/phpunit/sqlite3.xml",
"content": "\n\n \n \n \n \n \n\n \n \n \n \n\n \n \n ../../../tests\n \n \n\n \n \n ../../../src\n \n \n\n \n \n performance\n locking_functional\n \n \n\n"
},
{
"path": "composer.json",
"content": "{\n \"name\": \"doctrine/orm\",\n \"description\": \"Object-Relational-Mapper for PHP\",\n \"license\": \"MIT\",\n \"type\": \"library\",\n \"keywords\": [\n \"orm\",\n \"database\"\n ],\n \"authors\": [\n {\n \"name\": \"Guilherme Blanco\",\n \"email\": \"guilhermeblanco@gmail.com\"\n },\n {\n \"name\": \"Roman Borschel\",\n \"email\": \"roman@code-factory.org\"\n },\n {\n \"name\": \"Benjamin Eberlei\",\n \"email\": \"kontakt@beberlei.de\"\n },\n {\n \"name\": \"Jonathan Wage\",\n \"email\": \"jonwage@gmail.com\"\n },\n {\n \"name\": \"Marco Pivetta\",\n \"email\": \"ocramius@gmail.com\"\n }\n ],\n \"homepage\": \"https://www.doctrine-project.org/projects/orm.html\",\n \"require\": {\n \"php\": \"^8.1\",\n \"ext-ctype\": \"*\",\n \"composer-runtime-api\": \"^2\",\n \"doctrine/collections\": \"^2.2\",\n \"doctrine/dbal\": \"^3.8.2 || ^4\",\n \"doctrine/deprecations\": \"^0.5.3 || ^1\",\n \"doctrine/event-manager\": \"^1.2 || ^2\",\n \"doctrine/inflector\": \"^1.4 || ^2.0\",\n \"doctrine/instantiator\": \"^1.3 || ^2\",\n \"doctrine/lexer\": \"^3\",\n \"doctrine/persistence\": \"^3.3.1 || ^4\",\n \"psr/cache\": \"^1 || ^2 || ^3\",\n \"symfony/console\": \"^5.4 || ^6.0 || ^7.0 || ^8.0\",\n \"symfony/var-exporter\": \"^6.3.9 || ^7.0 || ^8.0\"\n },\n \"require-dev\": {\n \"doctrine/coding-standard\": \"^14.0\",\n \"phpbench/phpbench\": \"^1.0\",\n \"phpstan/extension-installer\": \"^1.4\",\n \"phpstan/phpstan\": \"2.1.23\",\n \"phpstan/phpstan-deprecation-rules\": \"^2\",\n \"phpunit/phpunit\": \"^10.5.0 || ^11.5\",\n \"psr/log\": \"^1 || ^2 || ^3\",\n \"symfony/cache\": \"^5.4 || ^6.2 || ^7.0 || ^8.0\"\n },\n \"suggest\": {\n \"ext-dom\": \"Provides support for XSD validation for XML mapping files\",\n \"symfony/cache\": \"Provides cache support for Setup Tool with doctrine/cache 2.0\"\n },\n \"autoload\": {\n \"psr-4\": {\n \"Doctrine\\\\ORM\\\\\": \"src\"\n }\n },\n \"autoload-dev\": {\n \"psr-4\": {\n \"Doctrine\\\\Performance\\\\\": \"tests/Performance\",\n \"Doctrine\\\\StaticAnalysis\\\\\": \"tests/StaticAnalysis\",\n \"Doctrine\\\\Tests\\\\\": \"tests/Tests\"\n }\n },\n \"config\": {\n \"allow-plugins\": {\n \"composer/package-versions-deprecated\": true,\n \"dealerdirect/phpcodesniffer-composer-installer\": true,\n \"phpstan/extension-installer\": true\n },\n \"sort-packages\": true\n },\n \"scripts\": {\n \"docs\": \"composer --working-dir docs update && ./docs/vendor/bin/build-docs.sh @additional_args\"\n }\n}\n"
},
{
"path": "docs/.gitignore",
"content": "composer.lock\nvendor/\noutput/\n"
},
{
"path": "docs/LICENSE.md",
"content": "The Doctrine ORM documentation is licensed under [CC BY-NC-SA 3.0](https://creativecommons.org/licenses/by-nc-sa/3.0/deed.en_US)\n\nCreative Commons Legal Code\n\nAttribution-NonCommercial-ShareAlike 3.0 Unported\n\n CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE\n LEGAL SERVICES. DISTRIBUTION OF THIS LICENSE DOES NOT CREATE AN\n ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS\n INFORMATION ON AN \"AS-IS\" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES\n REGARDING THE INFORMATION PROVIDED, AND DISCLAIMS LIABILITY FOR\n DAMAGES RESULTING FROM ITS USE.\n\nLicense\n\nTHE WORK (AS DEFINED BELOW) IS PROVIDED UNDER THE TERMS OF THIS CREATIVE\nCOMMONS PUBLIC LICENSE (\"CCPL\" OR \"LICENSE\"). THE WORK IS PROTECTED BY\nCOPYRIGHT AND/OR OTHER APPLICABLE LAW. ANY USE OF THE WORK OTHER THAN AS\nAUTHORIZED UNDER THIS LICENSE OR COPYRIGHT LAW IS PROHIBITED.\n\nBY EXERCISING ANY RIGHTS TO THE WORK PROVIDED HERE, YOU ACCEPT AND AGREE\nTO BE BOUND BY THE TERMS OF THIS LICENSE. TO THE EXTENT THIS LICENSE MAY\nBE CONSIDERED TO BE A CONTRACT, THE LICENSOR GRANTS YOU THE RIGHTS\nCONTAINED HERE IN CONSIDERATION OF YOUR ACCEPTANCE OF SUCH TERMS AND\nCONDITIONS.\n\n1. Definitions\n\n a. \"Adaptation\" means a work based upon the Work, or upon the Work and\n other pre-existing works, such as a translation, adaptation,\n derivative work, arrangement of music or other alterations of a\n literary or artistic work, or phonogram or performance and includes\n cinematographic adaptations or any other form in which the Work may be\n recast, transformed, or adapted including in any form recognizably\n derived from the original, except that a work that constitutes a\n Collection will not be considered an Adaptation for the purpose of\n this License. For the avoidance of doubt, where the Work is a musical\n work, performance or phonogram, the synchronization of the Work in\n timed-relation with a moving image (\"synching\") will be considered an\n Adaptation for the purpose of this License.\n b. \"Collection\" means a collection of literary or artistic works, such as\n encyclopedias and anthologies, or performances, phonograms or\n broadcasts, or other works or subject matter other than works listed\n in Section 1(g) below, which, by reason of the selection and\n arrangement of their contents, constitute intellectual creations, in\n which the Work is included in its entirety in unmodified form along\n with one or more other contributions, each constituting separate and\n independent works in themselves, which together are assembled into a\n collective whole. A work that constitutes a Collection will not be\n considered an Adaptation (as defined above) for the purposes of this\n License.\n c. \"Distribute\" means to make available to the public the original and\n copies of the Work or Adaptation, as appropriate, through sale or\n other transfer of ownership.\n d. \"License Elements\" means the following high-level license attributes\n as selected by Licensor and indicated in the title of this License:\n Attribution, Noncommercial, ShareAlike.\n e. \"Licensor\" means the individual, individuals, entity or entities that\n offer(s) the Work under the terms of this License.\n f. \"Original Author\" means, in the case of a literary or artistic work,\n the individual, individuals, entity or entities who created the Work\n or if no individual or entity can be identified, the publisher; and in\n addition (i) in the case of a performance the actors, singers,\n musicians, dancers, and other persons who act, sing, deliver, declaim,\n play in, interpret or otherwise perform literary or artistic works or\n expressions of folklore; (ii) in the case of a phonogram the producer\n being the person or legal entity who first fixes the sounds of a\n performance or other sounds; and, (iii) in the case of broadcasts, the\n organization that transmits the broadcast.\n g. \"Work\" means the literary and/or artistic work offered under the terms\n of this License including without limitation any production in the\n literary, scientific and artistic domain, whatever may be the mode or\n form of its expression including digital form, such as a book,\n pamphlet and other writing; a lecture, address, sermon or other work\n of the same nature; a dramatic or dramatico-musical work; a\n choreographic work or entertainment in dumb show; a musical\n composition with or without words; a cinematographic work to which are\n assimilated works expressed by a process analogous to cinematography;\n a work of drawing, painting, architecture, sculpture, engraving or\n lithography; a photographic work to which are assimilated works\n expressed by a process analogous to photography; a work of applied\n art; an illustration, map, plan, sketch or three-dimensional work\n relative to geography, topography, architecture or science; a\n performance; a broadcast; a phonogram; a compilation of data to the\n extent it is protected as a copyrightable work; or a work performed by\n a variety or circus performer to the extent it is not otherwise\n considered a literary or artistic work.\n h. \"You\" means an individual or entity exercising rights under this\n License who has not previously violated the terms of this License with\n respect to the Work, or who has received express permission from the\n Licensor to exercise rights under this License despite a previous\n violation.\n i. \"Publicly Perform\" means to perform public recitations of the Work and\n to communicate to the public those public recitations, by any means or\n process, including by wire or wireless means or public digital\n performances; to make available to the public Works in such a way that\n members of the public may access these Works from a place and at a\n place individually chosen by them; to perform the Work to the public\n by any means or process and the communication to the public of the\n performances of the Work, including by public digital performance; to\n broadcast and rebroadcast the Work by any means including signs,\n sounds or images.\n j. \"Reproduce\" means to make copies of the Work by any means including\n without limitation by sound or visual recordings and the right of\n fixation and reproducing fixations of the Work, including storage of a\n protected performance or phonogram in digital form or other electronic\n medium.\n\n2. Fair Dealing Rights. Nothing in this License is intended to reduce,\nlimit, or restrict any uses free from copyright or rights arising from\nlimitations or exceptions that are provided for in connection with the\ncopyright protection under copyright law or other applicable laws.\n\n3. License Grant. Subject to the terms and conditions of this License,\nLicensor hereby grants You a worldwide, royalty-free, non-exclusive,\nperpetual (for the duration of the applicable copyright) license to\nexercise the rights in the Work as stated below:\n\n a. to Reproduce the Work, to incorporate the Work into one or more\n Collections, and to Reproduce the Work as incorporated in the\n Collections;\n b. to create and Reproduce Adaptations provided that any such Adaptation,\n including any translation in any medium, takes reasonable steps to\n clearly label, demarcate or otherwise identify that changes were made\n to the original Work. For example, a translation could be marked \"The\n original work was translated from English to Spanish,\" or a\n modification could indicate \"The original work has been modified.\";\n c. to Distribute and Publicly Perform the Work including as incorporated\n in Collections; and,\n d. to Distribute and Publicly Perform Adaptations.\n\nThe above rights may be exercised in all media and formats whether now\nknown or hereafter devised. The above rights include the right to make\nsuch modifications as are technically necessary to exercise the rights in\nother media and formats. Subject to Section 8(f), all rights not expressly\ngranted by Licensor are hereby reserved, including but not limited to the\nrights described in Section 4(e).\n\n4. Restrictions. The license granted in Section 3 above is expressly made\nsubject to and limited by the following restrictions:\n\n a. You may Distribute or Publicly Perform the Work only under the terms\n of this License. You must include a copy of, or the Uniform Resource\n Identifier (URI) for, this License with every copy of the Work You\n Distribute or Publicly Perform. You may not offer or impose any terms\n on the Work that restrict the terms of this License or the ability of\n the recipient of the Work to exercise the rights granted to that\n recipient under the terms of the License. You may not sublicense the\n Work. You must keep intact all notices that refer to this License and\n to the disclaimer of warranties with every copy of the Work You\n Distribute or Publicly Perform. When You Distribute or Publicly\n Perform the Work, You may not impose any effective technological\n measures on the Work that restrict the ability of a recipient of the\n Work from You to exercise the rights granted to that recipient under\n the terms of the License. This Section 4(a) applies to the Work as\n incorporated in a Collection, but this does not require the Collection\n apart from the Work itself to be made subject to the terms of this\n License. If You create a Collection, upon notice from any Licensor You\n must, to the extent practicable, remove from the Collection any credit\n as required by Section 4(d), as requested. If You create an\n Adaptation, upon notice from any Licensor You must, to the extent\n practicable, remove from the Adaptation any credit as required by\n Section 4(d), as requested.\n b. You may Distribute or Publicly Perform an Adaptation only under: (i)\n the terms of this License; (ii) a later version of this License with\n the same License Elements as this License; (iii) a Creative Commons\n jurisdiction license (either this or a later license version) that\n contains the same License Elements as this License (e.g.,\n Attribution-NonCommercial-ShareAlike 3.0 US) (\"Applicable License\").\n You must include a copy of, or the URI, for Applicable License with\n every copy of each Adaptation You Distribute or Publicly Perform. You\n may not offer or impose any terms on the Adaptation that restrict the\n terms of the Applicable License or the ability of the recipient of the\n Adaptation to exercise the rights granted to that recipient under the\n terms of the Applicable License. You must keep intact all notices that\n refer to the Applicable License and to the disclaimer of warranties\n with every copy of the Work as included in the Adaptation You\n Distribute or Publicly Perform. When You Distribute or Publicly\n Perform the Adaptation, You may not impose any effective technological\n measures on the Adaptation that restrict the ability of a recipient of\n the Adaptation from You to exercise the rights granted to that\n recipient under the terms of the Applicable License. This Section 4(b)\n applies to the Adaptation as incorporated in a Collection, but this\n does not require the Collection apart from the Adaptation itself to be\n made subject to the terms of the Applicable License.\n c. You may not exercise any of the rights granted to You in Section 3\n above in any manner that is primarily intended for or directed toward\n commercial advantage or private monetary compensation. The exchange of\n the Work for other copyrighted works by means of digital file-sharing\n or otherwise shall not be considered to be intended for or directed\n toward commercial advantage or private monetary compensation, provided\n there is no payment of any monetary compensation in con-nection with\n the exchange of copyrighted works.\n d. If You Distribute, or Publicly Perform the Work or any Adaptations or\n Collections, You must, unless a request has been made pursuant to\n Section 4(a), keep intact all copyright notices for the Work and\n provide, reasonable to the medium or means You are utilizing: (i) the\n name of the Original Author (or pseudonym, if applicable) if supplied,\n and/or if the Original Author and/or Licensor designate another party\n or parties (e.g., a sponsor institute, publishing entity, journal) for\n attribution (\"Attribution Parties\") in Licensor's copyright notice,\n terms of service or by other reasonable means, the name of such party\n or parties; (ii) the title of the Work if supplied; (iii) to the\n extent reasonably practicable, the URI, if any, that Licensor\n specifies to be associated with the Work, unless such URI does not\n refer to the copyright notice or licensing information for the Work;\n and, (iv) consistent with Section 3(b), in the case of an Adaptation,\n a credit identifying the use of the Work in the Adaptation (e.g.,\n \"French translation of the Work by Original Author,\" or \"Screenplay\n based on original Work by Original Author\"). The credit required by\n this Section 4(d) may be implemented in any reasonable manner;\n provided, however, that in the case of a Adaptation or Collection, at\n a minimum such credit will appear, if a credit for all contributing\n authors of the Adaptation or Collection appears, then as part of these\n credits and in a manner at least as prominent as the credits for the\n other contributing authors. For the avoidance of doubt, You may only\n use the credit required by this Section for the purpose of attribution\n in the manner set out above and, by exercising Your rights under this\n License, You may not implicitly or explicitly assert or imply any\n connection with, sponsorship or endorsement by the Original Author,\n Licensor and/or Attribution Parties, as appropriate, of You or Your\n use of the Work, without the separate, express prior written\n permission of the Original Author, Licensor and/or Attribution\n Parties.\n e. For the avoidance of doubt:\n\n i. Non-waivable Compulsory License Schemes. In those jurisdictions in\n which the right to collect royalties through any statutory or\n compulsory licensing scheme cannot be waived, the Licensor\n reserves the exclusive right to collect such royalties for any\n exercise by You of the rights granted under this License;\n ii. Waivable Compulsory License Schemes. In those jurisdictions in\n which the right to collect royalties through any statutory or\n compulsory licensing scheme can be waived, the Licensor reserves\n the exclusive right to collect such royalties for any exercise by\n You of the rights granted under this License if Your exercise of\n such rights is for a purpose or use which is otherwise than\n noncommercial as permitted under Section 4(c) and otherwise waives\n the right to collect royalties through any statutory or compulsory\n licensing scheme; and,\n iii. Voluntary License Schemes. The Licensor reserves the right to\n collect royalties, whether individually or, in the event that the\n Licensor is a member of a collecting society that administers\n voluntary licensing schemes, via that society, from any exercise\n by You of the rights granted under this License that is for a\n purpose or use which is otherwise than noncommercial as permitted\n under Section 4(c).\n f. Except as otherwise agreed in writing by the Licensor or as may be\n otherwise permitted by applicable law, if You Reproduce, Distribute or\n Publicly Perform the Work either by itself or as part of any\n Adaptations or Collections, You must not distort, mutilate, modify or\n take other derogatory action in relation to the Work which would be\n prejudicial to the Original Author's honor or reputation. Licensor\n agrees that in those jurisdictions (e.g. Japan), in which any exercise\n of the right granted in Section 3(b) of this License (the right to\n make Adaptations) would be deemed to be a distortion, mutilation,\n modification or other derogatory action prejudicial to the Original\n Author's honor and reputation, the Licensor will waive or not assert,\n as appropriate, this Section, to the fullest extent permitted by the\n applicable national law, to enable You to reasonably exercise Your\n right under Section 3(b) of this License (right to make Adaptations)\n but not otherwise.\n\n5. Representations, Warranties and Disclaimer\n\nUNLESS OTHERWISE MUTUALLY AGREED TO BY THE PARTIES IN WRITING AND TO THE\nFULLEST EXTENT PERMITTED BY APPLICABLE LAW, LICENSOR OFFERS THE WORK AS-IS\nAND MAKES NO REPRESENTATIONS OR WARRANTIES OF ANY KIND CONCERNING THE\nWORK, EXPRESS, IMPLIED, STATUTORY OR OTHERWISE, INCLUDING, WITHOUT\nLIMITATION, WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR\nPURPOSE, NONINFRINGEMENT, OR THE ABSENCE OF LATENT OR OTHER DEFECTS,\nACCURACY, OR THE PRESENCE OF ABSENCE OF ERRORS, WHETHER OR NOT\nDISCOVERABLE. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OF IMPLIED\nWARRANTIES, SO THIS EXCLUSION MAY NOT APPLY TO YOU.\n\n6. Limitation on Liability. EXCEPT TO THE EXTENT REQUIRED BY APPLICABLE\nLAW, IN NO EVENT WILL LICENSOR BE LIABLE TO YOU ON ANY LEGAL THEORY FOR\nANY SPECIAL, INCIDENTAL, CONSEQUENTIAL, PUNITIVE OR EXEMPLARY DAMAGES\nARISING OUT OF THIS LICENSE OR THE USE OF THE WORK, EVEN IF LICENSOR HAS\nBEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n7. Termination\n\n a. This License and the rights granted hereunder will terminate\n automatically upon any breach by You of the terms of this License.\n Individuals or entities who have received Adaptations or Collections\n from You under this License, however, will not have their licenses\n terminated provided such individuals or entities remain in full\n compliance with those licenses. Sections 1, 2, 5, 6, 7, and 8 will\n survive any termination of this License.\n b. Subject to the above terms and conditions, the license granted here is\n perpetual (for the duration of the applicable copyright in the Work).\n Notwithstanding the above, Licensor reserves the right to release the\n Work under different license terms or to stop distributing the Work at\n any time; provided, however that any such election will not serve to\n withdraw this License (or any other license that has been, or is\n required to be, granted under the terms of this License), and this\n License will continue in full force and effect unless terminated as\n stated above.\n\n8. Miscellaneous\n\n a. Each time You Distribute or Publicly Perform the Work or a Collection,\n the Licensor offers to the recipient a license to the Work on the same\n terms and conditions as the license granted to You under this License.\n b. Each time You Distribute or Publicly Perform an Adaptation, Licensor\n offers to the recipient a license to the original Work on the same\n terms and conditions as the license granted to You under this License.\n c. If any provision of this License is invalid or unenforceable under\n applicable law, it shall not affect the validity or enforceability of\n the remainder of the terms of this License, and without further action\n by the parties to this agreement, such provision shall be reformed to\n the minimum extent necessary to make such provision valid and\n enforceable.\n d. No term or provision of this License shall be deemed waived and no\n breach consented to unless such waiver or consent shall be in writing\n and signed by the party to be charged with such waiver or consent.\n e. This License constitutes the entire agreement between the parties with\n respect to the Work licensed here. There are no understandings,\n agreements or representations with respect to the Work not specified\n here. Licensor shall not be bound by any additional provisions that\n may appear in any communication from You. This License may not be\n modified without the mutual written agreement of the Licensor and You.\n f. The rights granted under, and the subject matter referenced, in this\n License were drafted utilizing the terminology of the Berne Convention\n for the Protection of Literary and Artistic Works (as amended on\n September 28, 1979), the Rome Convention of 1961, the WIPO Copyright\n Treaty of 1996, the WIPO Performances and Phonograms Treaty of 1996\n and the Universal Copyright Convention (as revised on July 24, 1971).\n These rights and subject matter take effect in the relevant\n jurisdiction in which the License terms are sought to be enforced\n according to the corresponding provisions of the implementation of\n those treaty provisions in the applicable national law. If the\n standard suite of rights granted under applicable copyright law\n includes additional rights not granted under this License, such\n additional rights are deemed to be included in the License; this\n License is not intended to restrict the license of any rights under\n applicable law.\n\n\nCreative Commons Notice\n\n Creative Commons is not a party to this License, and makes no warranty\n whatsoever in connection with the Work. Creative Commons will not be\n liable to You or any party on any legal theory for any damages\n whatsoever, including without limitation any general, special,\n incidental or consequential damages arising in connection to this\n license. Notwithstanding the foregoing two (2) sentences, if Creative\n Commons has expressly identified itself as the Licensor hereunder, it\n shall have all rights and obligations of Licensor.\n\n Except for the limited purpose of indicating to the public that the\n Work is licensed under the CCPL, Creative Commons does not authorize\n the use by either party of the trademark \"Creative Commons\" or any\n related trademark or logo of Creative Commons without the prior\n written consent of Creative Commons. Any permitted use will be in\n compliance with Creative Commons' then-current trademark usage\n guidelines, as may be published on its website or otherwise made\n available upon request from time to time. For the avoidance of doubt,\n this trademark restriction does not form part of this License.\n\n Creative Commons may be contacted at https://creativecommons.org/.\n"
},
{
"path": "docs/README.md",
"content": "# Doctrine ORM Documentation\n\nThe documentation is written in [ReStructured Text](https://docutils.sourceforge.io/rst.html).\n\n## How to Generate:\n\nIn the project root, run\n\n composer docs\n\nThis will generate the documentation into the `docs/output` subdirectory.\n\nTo browse the documentation, you need to run a webserver:\n\n cd docs/output\n php -S localhost:8000\n\nNow the documentation is available at [http://localhost:8000](http://localhost:8000).\n"
},
{
"path": "docs/composer.json",
"content": "{\n \"name\": \"doctrine/orm-docs\",\n \"description\": \"Documentation for the Object-Relational Mapper\\\"\",\n \"type\": \"library\",\n \"license\": \"MIT\",\n \"require-dev\": {\n \"doctrine/docs-builder\": \"^1.0\"\n }\n}\n"
},
{
"path": "docs/en/cookbook/advanced-field-value-conversion-using-custom-mapping-types.rst",
"content": "Advanced field value conversion using custom mapping types\n==========================================================\n\n.. sectionauthor:: Jan Sorgalla \n\nWhen creating entities, you sometimes have the need to transform field values\nbefore they are saved to the database. In Doctrine you can use Custom Mapping\nTypes to solve this (see: :ref:`reference-basic-mapping-custom-mapping-types`).\n\nThere are several ways to achieve this: converting the value inside the Type\nclass, converting the value on the database-level or a combination of both.\n\nThis article describes the third way by implementing the MySQL specific column\ntype `Point `_.\n\nThe ``Point`` type is part of the `Spatial extension `_\nof MySQL and enables you to store a single location in a coordinate space by\nusing x and y coordinates. You can use the Point type to store a\nlongitude/latitude pair to represent a geographic location.\n\nThe entity\n----------\n\nWe create a simple entity with a field ``$point`` which holds a value object\n``Point`` representing the latitude and longitude of the position.\n\nThe entity class:\n\n.. code-block:: php\n\n point = $point;\n }\n\n public function getPoint(): Point\n {\n return $this->point;\n }\n\n public function setAddress(string $address): void\n {\n $this->address = $address;\n }\n\n public function getAddress(): string\n {\n return $this->address;\n }\n }\n\nWe use the custom type ``point`` in the ``#[Column]`` attribute of the\n``$point`` field. We will create this custom mapping type in the next chapter.\n\nThe point class:\n\n.. code-block:: php\n\n latitude;\n }\n\n public function getLongitude(): float\n {\n return $this->longitude;\n }\n }\n\nThe mapping type\n----------------\n\nNow we're going to create the ``point`` type and implement all required methods.\n\n.. code-block:: php\n\n getLongitude(), $value->getLatitude());\n }\n\n return $value;\n }\n\n public function convertToPHPValueSQL($sqlExpr, AbstractPlatform $platform)\n {\n return sprintf('AsText(%s)', $sqlExpr);\n }\n\n public function convertToDatabaseValueSQL($sqlExpr, AbstractPlatform $platform)\n {\n return sprintf('PointFromText(%s)', $sqlExpr);\n }\n }\n\nWe do a 2-step conversion here. In the first step, we convert the ``Point``\nobject into a string representation before saving to the database (in the\n``convertToDatabaseValue`` method) and back into an object after fetching the\nvalue from the database (in the ``convertToPHPValue`` method).\n\nThe format of the string representation format is called\n`Well-known text (WKT) `_.\nThe advantage of this format is, that it is both human readable and parsable by MySQL.\n\nInternally, MySQL stores geometry values in a binary format that is not\nidentical to the WKT format. So, we need to let MySQL transform the WKT\nrepresentation into its internal format.\n\nThis is where the ``convertToPHPValueSQL`` and ``convertToDatabaseValueSQL``\nmethods come into play.\n\nThis methods wrap a sql expression (the WKT representation of the Point) into\nMySQL functions `ST_PointFromText `_\nand `ST_AsText `_\nwhich convert WKT strings to and from the internal format of MySQL.\n\n.. note::\n\n When using DQL queries, the ``convertToPHPValueSQL`` and\n ``convertToDatabaseValueSQL`` methods only apply to identification variables\n and path expressions in SELECT clauses. Expressions in WHERE clauses are\n **not** wrapped!\n\n If you want to use Point values in WHERE clauses, you have to implement a\n :doc:`user defined function ` for\n ``PointFromText``.\n\nExample usage\n-------------\n\n.. code-block:: php\n\n getConnection()->getDatabasePlatform()->registerDoctrineTypeMapping('point', 'point');\n\n // Store a Location object\n use Geo\\Entity\\Location;\n use Geo\\ValueObject\\Point;\n\n $location = new Location();\n\n $location->setAddress('1600 Amphitheatre Parkway, Mountain View, CA');\n $location->setPoint(new Point(37.4220761, -122.0845187));\n\n $em->persist($location);\n $em->flush();\n $em->clear();\n\n // Fetch the Location object\n $query = $em->createQuery(\"SELECT l FROM Geo\\Entity\\Location l WHERE l.address = '1600 Amphitheatre Parkway, Mountain View, CA'\");\n $location = $query->getSingleResult();\n\n /** @var Geo\\ValueObject\\Point */\n $point = $location->getPoint();\n"
},
{
"path": "docs/en/cookbook/aggregate-fields.rst",
"content": "Aggregate Fields\n================\n\n.. sectionauthor:: Benjamin Eberlei \n\nYou will often come across the requirement to display aggregate\nvalues of data that can be computed by using the MIN, MAX, COUNT or\nSUM SQL functions. For any ORM this is a tricky issue\ntraditionally. Doctrine ORM offers several ways to get access to\nthese values and this article will describe all of them from\ndifferent perspectives.\n\nYou will see that aggregate fields can become very explicit\nfeatures in your domain model and how this potentially complex\nbusiness rules can be easily tested.\n\nAn example model\n----------------\n\nSay you want to model a bank account and all their entries. Entries\ninto the account can either be of positive or negative money\nvalues. Each account has a credit limit and the account is never\nallowed to have a balance below that value.\n\nFor simplicity we live in a world where money is composed of\nintegers only. Also we omit the receiver/sender name, stated reason\nfor transfer and the execution date. These all would have to be\nadded on the ``Entry`` object.\n\nOur entities look like:\n\n.. code-block:: php\n\n entries = new ArrayCollection();\n }\n }\n\n #[ORM\\Entity]\n class Entry\n {\n #[ORM\\Id]\n #[ORM\\GeneratedValue]\n #[ORM\\Column(type: 'integer')]\n private ?int $id;\n\n public function __construct(\n #[ORM\\ManyToOne(targetEntity: Account::class, inversedBy: 'entries')]\n private Account $account,\n\n #[ORM\\Column(type: 'integer')]\n private int $amount,\n ) {\n // more stuff here, from/to whom, stated reason, execution date and such\n }\n\n public function getAmount(): Amount\n {\n return $this->amount;\n }\n }\n\nUsing DQL\n---------\n\nThe Doctrine Query Language allows you to select for aggregate\nvalues computed from fields of your Domain Model. You can select\nthe current balance of your account by calling:\n\n.. code-block:: php\n\n createQuery($dql)\n ->setParameter(1, $myAccountId)\n ->getSingleScalarResult();\n\nThe ``$em`` variable in this (and forthcoming) example holds the\nDoctrine ``EntityManager``. We create a query for the SUM of all\namounts (negative amounts are withdraws) and retrieve them as a\nsingle scalar result, essentially return only the first column of\nthe first row.\n\nThis approach is simple and powerful, however it has a serious\ndrawback. We have to execute a specific query for the balance\nwhenever we need it.\n\nTo implement a powerful domain model we would rather have access to\nthe balance from our ``Account`` entity during all times (even if\nthe Account was not persisted in the database before!).\n\nAlso an additional requirement is the max credit per ``Account``\nrule.\n\nWe cannot reliably enforce this rule in our ``Account`` entity with\nthe DQL retrieval of the balance. There are many different ways to\nretrieve accounts. We cannot guarantee that we can execute the\naggregation query for all these use-cases, let alone that a\nuserland programmer checks this balance against newly added\nentries.\n\nUsing your Domain Model\n-----------------------\n\n``Account`` and all the ``Entry`` instances are connected through a\ncollection, which means we can compute this value at runtime:\n\n.. code-block:: php\n\n entries as $entry) {\n $balance += $entry->getAmount();\n }\n\n return $balance;\n }\n }\n\nNow we can always call ``Account::getBalance()`` to access the\ncurrent account balance.\n\nTo enforce the max credit rule we have to implement the \"Aggregate\nRoot\" pattern as described in Eric Evans book on Domain Driven\nDesign. Described with one sentence, an aggregate root controls the\ninstance creation, access and manipulation of its children.\n\nIn our case we want to enforce that new entries can only added to\nthe ``Account`` by using a designated method. The ``Account`` is\nthe aggregate root of this relation. We can also enforce the\ncorrectness of the bi-directional ``Account`` <-> ``Entry``\nrelation with this method:\n\n.. code-block:: php\n\n assertAcceptEntryAllowed($amount);\n\n $this->entries[] = new Entry($this, $amount);\n }\n }\n\nNow look at the following test-code for our entities:\n\n.. code-block:: php\n\n assertEquals(0, $account->getBalance());\n\n $account->addEntry(500);\n $this->assertEquals(500, $account->getBalance());\n\n $account->addEntry(-700);\n $this->assertEquals(-200, $account->getBalance());\n }\n\n public function testExceedMaxLimit()\n {\n $account = new Account(\"123456\", maxCredit: 200);\n\n $this->expectException(Exception::class);\n $account->addEntry(-1000);\n }\n }\n\nTo enforce our rule we can now implement the assertion in\n``Account::addEntry``:\n\n.. code-block:: php\n\n getBalance() + $amount;\n $allowedMinimalBalance = ($this->maxCredit * -1);\n if ($futureBalance < $allowedMinimalBalance) {\n throw new Exception(\"Credit Limit exceeded, entry is not allowed!\");\n }\n }\n }\n\nWe haven't talked to the entity manager for persistence of our\naccount example before. You can call\n``EntityManager::persist($account)`` and then\n``EntityManager::flush()`` at any point to save the account to the\ndatabase. All the nested ``Entry`` objects are automatically\nflushed to the database also.\n\n.. code-block:: php\n\n addEntry(500);\n $account->addEntry(-200);\n $em->persist($account);\n $em->flush();\n\nThe current implementation has a considerable drawback. To get the\nbalance, we have to initialize the complete ``Account::$entries``\ncollection, possibly a very large one. This can considerably hurt\nthe performance of your application.\n\nUsing an Aggregate Field\n------------------------\n\nTo overcome the previously mentioned issue (initializing the whole\nentries collection) we want to add an aggregate field called\n\"balance\" on the Account and adjust the code in\n``Account::getBalance()`` and ``Account:addEntry()``:\n\n.. code-block:: php\n\n balance;\n }\n\n public function addEntry(int $amount): void\n {\n $this->assertAcceptEntryAllowed($amount);\n\n $this->entries[] = new Entry($this, $amount);\n $this->balance += $amount;\n }\n }\n\nThis is a very simple change, but all the tests still pass. Our\naccount entities return the correct balance. Now calling the\n``Account::getBalance()`` method will not occur the overhead of\nloading all entries anymore. Adding a new Entry to the\n``Account::$entities`` will also not initialize the collection\ninternally.\n\nAdding a new entry is therefore very performant and explicitly\nhooked into the domain model. It will only update the account with\nthe current balance and insert the new entry into the database.\n\nTackling Race Conditions with Aggregate Fields\n----------------------------------------------\n\nWhenever you denormalize your database schema race-conditions can\npotentially lead to inconsistent state. See this example:\n\n.. code-block:: php\n\n find(Account::class, $accId);\n\n // request 2 account\n $account2 = $em->find(Account::class, $accId);\n\n $account1->addEntry(-200);\n $account2->addEntry(-200);\n\n // now request 1 and 2 both flush the changes.\n\nThe aggregate field ``Account::$balance`` is now -200, however the\nSUM over all entries amounts yields -400. A violation of our max\ncredit rule.\n\nYou can use both optimistic or pessimistic locking to safe-guard\nyour aggregate fields against this kind of race-conditions. Reading\nEric Evans DDD carefully he mentions that the \"Aggregate Root\"\n(Account in our example) needs a locking mechanism.\n\nOptimistic locking is as easy as adding a version column:\n\n.. code-block:: php\n\n find(Account::class, $accId, LockMode::PESSIMISTIC_WRITE);\n\nKeeping Updates and Deletes in Sync\n-----------------------------------\n\nThe example shown in this article does not allow changes to the\nvalue in ``Entry``, which considerably simplifies the effort to\nkeep ``Account::$balance`` in sync. If your use-case allows fields\nto be updated or related entities to be removed you have to\nencapsulate this logic in your \"Aggregate Root\" entity and adjust\nthe aggregate field accordingly.\n\nConclusion\n----------\n\nThis article described how to obtain aggregate values using DQL or\nyour domain model. It showed how you can easily add an aggregate\nfield that offers serious performance benefits over iterating all\nthe related objects that make up an aggregate value. Finally I\nshowed how you can ensure that your aggregate fields do not get out\nof sync due to race-conditions and concurrent access.\n"
},
{
"path": "docs/en/cookbook/custom-mapping-types.rst",
"content": "Custom Mapping Types\n====================\n\nDoctrine allows you to create new mapping types. This can come in\nhandy when you're missing a specific mapping type or when you want\nto replace the existing implementation of a mapping type.\n\nIn order to create a new mapping type you need to subclass\n``Doctrine\\DBAL\\Types\\Type`` and implement/override the methods as\nyou wish. Here is an example skeleton of such a custom type class:\n\n.. code-block:: php\n\n getConnection();\n $conn->getDatabasePlatform()->registerDoctrineTypeMapping('db_mytype', 'mytype');\n\nWhen registering the custom types in the configuration you specify a unique\nname for the mapping type and map that to the corresponding fully qualified\nclass name. Now the new type can be used when mapping columns:\n\n.. code-block:: php\n\n \n\nThis recipe will show you a simple example of how you can use\nDoctrine ORM to persist an implementation of the\n`Decorator Pattern `_\n\nComponent\n---------\n\nThe ``Component`` class needs to be persisted, so it's going to\nbe an ``Entity``. As the top of the inheritance hierarchy, it's going\nto have to define the persistent inheritance. For this example, we\nwill use Single Table Inheritance, but Class Table Inheritance\nwould work as well. In the discriminator map, we will define two\nconcrete subclasses, ``ConcreteComponent`` and ``ConcreteDecorator``.\n\n.. code-block:: php\n\n Component\\ConcreteComponent::class,\n 'cd' => Decorator\\ConcreteDecorator::class])]\n abstract class Component\n {\n\n #[Id, Column]\n #[GeneratedValue(strategy: 'AUTO')]\n protected int|null $id = null;\n\n #[Column(type: 'string', nullable: true)]\n protected $name;\n\n public function getId(): int|null\n {\n return $this->id;\n }\n\n public function setName(string $name): void\n {\n $this->name = $name;\n }\n\n public function getName(): string\n {\n return $this->name;\n }\n\n }\n\nConcreteComponent\n-----------------\n\nThe ``ConcreteComponent`` class is pretty simple and doesn't do much\nmore than extend the abstract ``Component`` class (only for the\npurpose of keeping this example simple).\n\n.. code-block:: php\n\n setDecorates($c);\n }\n\n /**\n * (non-PHPdoc)\n * @see Test.Component::getName()\n */\n public function getName(): string\n {\n \t return 'Decorated ' . $this->getDecorates()->getName();\n }\n\n /** the component being decorated */\n protected function getDecorates(): Component\n {\n \t return $this->decorates;\n }\n\n /** sets the component being decorated */\n protected function setDecorates(Component $c): void\n {\n \t $this->decorates = $c;\n }\n\n }\n\nAll operations on the ``Decorator`` (i.e. persist, remove, etc) will\ncascade from the ``Decorator`` to the ``Component``. This means that\nwhen we persist a ``Decorator``, Doctrine will take care of\npersisting the chain of decorated objects for us. A ``Decorator`` can\nbe treated exactly as a ``Component`` when it comes time to\npersisting it.\n\nThe ``Decorator's`` constructor accepts an instance of a\n``Component``, as defined by the ``Decorator`` pattern. The\nsetDecorates/getDecorates methods have been defined as protected to\nhide the fact that a ``Decorator`` is decorating a ``Component`` and\nkeeps the ``Component`` interface and the ``Decorator`` interface\nidentical.\n\nTo illustrate the intended result of the ``Decorator`` pattern, the\ngetName() method has been overridden to append a string to the\n``Component's`` getName() method.\n\nConcreteDecorator\n-----------------\n\nThe final class required to complete a simple implementation of the\nDecorator pattern is the ``ConcreteDecorator``. In order to further\nillustrate how the ``Decorator`` can alter data as it moves through\nthe chain of decoration, a new field, \"special\", has been added to\nthis class. The getName() has been overridden and appends the value\nof the getSpecial() method to its return value.\n\n.. code-block:: php\n\n special = $special;\n }\n\n public function getSpecial(): string|null\n {\n return $this->special;\n }\n\n /**\n * (non-PHPdoc)\n * @see Test.Component::getName()\n */\n public function getName(): string\n {\n return '[' . $this->getSpecial()\n . '] ' . parent::getName();\n }\n\n }\n\nExamples\n--------\n\nHere is an example of how to persist and retrieve your decorated\nobjects\n\n.. code-block:: php\n\n setName('Test Component 1');\n $em->persist($c); // assigned unique ID = 1\n\n // create a new concrete decorator\n $c = new ConcreteComponent();\n $c->setName('Test Component 2');\n\n $d = new ConcreteDecorator($c);\n $d->setSpecial('Really');\n $em->persist($d);\n // assigns c as unique ID = 2, and d as unique ID = 3\n\n $em->flush();\n\n $c = $em->find('Test\\Component', 1);\n $d = $em->find('Test\\Component', 3);\n\n echo get_class($c);\n // prints: Test\\Component\\ConcreteComponent\n\n echo $c->getName();\n // prints: Test Component 1\n\n echo get_class($d)\n // prints: Test\\Component\\ConcreteDecorator\n\n echo $d->getName();\n // prints: [Really] Decorated Test Component 2\n"
},
{
"path": "docs/en/cookbook/dql-custom-walkers/InterpolateParametersSQLOutputWalker.php",
"content": "getQuery()->getParameter($inputParam->name);\n if ($parameter === null) {\n return '?';\n }\n\n $value = $parameter->getValue();\n /** @var ParameterType|ArrayParameterType|int|string $typeName */\n /** @see \\Doctrine\\ORM\\Query\\ParameterTypeInferer::inferType() */\n $typeName = $parameter->getType();\n $platform = $this->getConnection()->getDatabasePlatform();\n $processParameterType = static fn(ParameterType $type) => static fn($value): string =>\n (match ($type) { /** @see Type::getBindingType() */\n ParameterType::NULL => 'NULL',\n ParameterType::INTEGER => $value,\n ParameterType::BOOLEAN => (new BooleanType())->convertToDatabaseValue($value, $platform),\n ParameterType::STRING, ParameterType::ASCII => $platform->quoteStringLiteral($value),\n default => throw new ValueNotConvertible($value, $type->name)\n });\n\n if (is_string($typeName) && Type::hasType($typeName)) {\n return Type::getType($typeName)->convertToDatabaseValue($value, $platform);\n }\n if ($typeName instanceof ParameterType) {\n return $processParameterType($typeName)($value);\n }\n if ($typeName instanceof ArrayParameterType && is_array($value)) {\n $type = ArrayParameterType::toElementParameterType($typeName);\n return implode(', ', array_map($processParameterType($type), $value));\n }\n\n throw new ValueNotConvertible($value, $typeName);\n }\n}\n"
},
{
"path": "docs/en/cookbook/dql-custom-walkers.rst",
"content": "Extending DQL in Doctrine ORM: Custom AST Walkers\n===============================================\n\n.. sectionauthor:: Benjamin Eberlei \n\nThe Doctrine Query Language (DQL) is a proprietary sql-dialect that\nsubstitutes tables and columns for Entity names and their fields.\nUsing DQL you write a query against the database using your\nentities. With the help of the metadata you can write very concise,\ncompact and powerful queries that are then translated into SQL by\nthe Doctrine ORM.\n\nIn Doctrine 1 the DQL language was not implemented using a real\nparser. This made modifications of the DQL by the user impossible.\nDoctrine ORM in contrast has a real parser for the DQL language,\nwhich transforms the DQL statement into an\n`Abstract Syntax Tree `_\nand generates the appropriate SQL statement for it. Since this\nprocess is deterministic Doctrine heavily caches the SQL that is\ngenerated from any given DQL query, which reduces the performance\noverhead of the parsing process to zero.\n\nYou can modify the Abstract syntax tree by hooking into DQL parsing\nprocess by adding a Custom Tree Walker. A walker is an interface\nthat walks each node of the Abstract syntax tree, thereby\ngenerating the SQL statement.\n\nThere are two types of custom tree walkers that you can hook into\nthe DQL parser:\n\n\n- An output walker. This one actually generates the SQL, and there\n is only ever one of them. We implemented the default SqlWalker\n implementation for it.\n- A tree walker. There can be many tree walkers, they cannot\n generate the SQL, however they can modify the AST before its\n rendered to SQL.\n\nNow this is all awfully technical, so let me come to some use-cases\nfast to keep you motivated. Using walker implementation you can for\nexample:\n\n- Modify the Output walker to get the raw SQL via ``Query->getSQL()``\n with interpolated parameters.\n- Modify the AST to generate a Count Query to be used with a\n paginator for any given DQL query.\n- Modify the Output Walker to generate vendor-specific SQL\n (instead of ANSI).\n- Modify the AST to add additional where clauses for specific\n entities (example ACL, country-specific content...)\n- Modify the Output walker to pretty print the SQL for debugging\n purposes.\n\nIn this cookbook-entry I will show examples of the first three\npoints. There are probably much more use-cases.\n\nGeneric count query for pagination\n----------------------------------\n\nSay you have a blog and posts all with one category and one author.\nA query for the front-page or any archive page might look something\nlike:\n\n.. code-block:: sql\n\n SELECT p, c, a FROM BlogPost p JOIN p.category c JOIN p.author a WHERE ...\n\nNow in this query the blog post is the root entity, meaning it's the\none that is hydrated directly from the query and returned as an\narray of blog posts. In contrast the comment and author are loaded\nfor deeper use in the object tree.\n\nA pagination for this query would want to approximate the number of\nposts that match the WHERE clause of this query to be able to\npredict the number of pages to show to the user. A draft of the DQL\nquery for pagination would look like:\n\n.. code-block:: sql\n\n SELECT count(DISTINCT p.id) FROM BlogPost p JOIN p.category c JOIN p.author a WHERE ...\n\nNow you could go and write each of these queries by hand, or you\ncan use a tree walker to modify the AST for you. Let's see how the\nAPI would look for this use-case:\n\n.. code-block:: php\n\n createQuery($dql);\n $query->setFirstResult( ($pageNum-1) * 20)->setMaxResults(20);\n\n $totalResults = Paginate::count($query);\n $results = $query->getResult();\n\nThe ``Paginate::count(Query $query)`` looks like:\n\n.. code-block:: php\n\n getEntityManager());\n $countQuery->setDQL($query->getDQL());\n $countQuery->setParameters(clone $query->getParameters());\n foreach ($query->getHints() as $name => $value) {\n $countQuery->setHint($name, $value);\n }\n\n $countQuery->setHint(Query::HINT_CUSTOM_TREE_WALKERS, array('DoctrineExtensions\\Paginate\\CountSqlWalker'));\n $countQuery->setFirstResult(null)->setMaxResults(null);\n\n return $countQuery->getSingleScalarResult();\n }\n }\n\nThis resets the limit clause first and max results\nand registers the ``CountSqlWalker`` custom tree walker which\nwill modify the AST to execute a count query. The walkers\nimplementation is:\n\n.. code-block:: php\n\n _getQueryComponents() as $dqlAlias => $qComp) {\n if ($qComp['parent'] === null && $qComp['nestingLevel'] == 0) {\n $parent = $qComp;\n $parentName = $dqlAlias;\n break;\n }\n }\n\n $pathExpression = new PathExpression(\n PathExpression::TYPE_STATE_FIELD | PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION, $parentName,\n $parent['metadata']->getSingleIdentifierFieldName()\n );\n $pathExpression->type = PathExpression::TYPE_STATE_FIELD;\n\n $AST->selectClause->selectExpressions = array(\n new SelectExpression(\n new AggregateExpression('count', $pathExpression, true), null\n )\n );\n }\n }\n\nThis will delete any given select expressions and replace them with\na distinct count query for the root entities primary key. This will\nonly work if your entity has only one identifier field (composite\nkeys won't work).\n\nModify the Output Walker to generate Vendor specific SQL\n--------------------------------------------------------\n\nMost RMDBS have vendor-specific features for optimizing select\nquery execution plans. You can write your own output walker to\nintroduce certain keywords using the Query Hint API. A query hint\ncan be set via ``Query::setHint($name, $value)`` as shown in the\nprevious example with the ``HINT_CUSTOM_TREE_WALKERS`` query hint.\n\nWe will implement a custom Output Walker that allows to specify the\n``SQL_NO_CACHE`` query hint.\n\n.. code-block:: php\n\n createQuery($dql);\n $query->setHint(Query::HINT_CUSTOM_OUTPUT_WALKER, 'DoctrineExtensions\\Query\\MysqlWalker');\n $query->setHint(\"mysqlWalker.sqlNoCache\", true);\n $results = $query->getResult();\n\nOur ``MysqlWalker`` will extend the default ``SqlWalker``. We will\nmodify the generation of the SELECT clause, adding the\n``SQL_NO_CACHE`` on those queries that need it:\n\n.. code-block:: php\n\n getQuery()->getHint('mysqlWalker.sqlNoCache') === true) {\n if ($selectClause->isDistinct) {\n $sql = str_replace('SELECT DISTINCT', 'SELECT DISTINCT SQL_NO_CACHE', $sql);\n } else {\n $sql = str_replace('SELECT', 'SELECT SQL_NO_CACHE', $sql);\n }\n }\n\n return $sql;\n }\n }\n\nWriting extensions to the Output Walker requires a very deep\nunderstanding of the DQL Parser and Walkers, but may offer your\nhuge benefits with using vendor specific features. This would still\nallow you write DQL queries instead of NativeQueries to make use of\nvendor specific features.\n\nModifying the Output Walker to get the raw SQL with interpolated parameters\n---------------------------------------------------------------------------\n\nSometimes we may want to log or trace the raw SQL being generated from its DQL\nfor profiling slow queries afterwards or audit queries that changed many rows\n``$query->getSQL()`` will give us the prepared statement being passed to database\nwith all values of SQL parameters being replaced by positional ``?`` or named ``:name``\nas parameters are interpolated into prepared statements by the database while executing the SQL.\n``$query->getParameters()`` will give us details about SQL parameters that we've provided.\nSo we can create an output walker to interpolate all SQL parameters that will be\npassed into prepared statement in PHP before database handle them internally:\n\n.. literalinclude:: dql-custom-walkers/InterpolateParametersSQLOutputWalker.php\n :language: php\n\nThen you may get the raw SQL with this output walker:\n\n.. code-block:: php\n\n where('t.int IN (:ints)')->setParameter(':ints', [1, 2])\n ->orWhere('t.string IN (?0)')->setParameter(0, ['3', '4'])\n ->orWhere(\"t.bool = ?1\")->setParameter('?1', true)\n ->orWhere(\"t.string = :string\")->setParameter(':string', 'ABC')\n ->setHint(\\Doctrine\\ORM\\Query::HINT_CUSTOM_OUTPUT_WALKER, InterpolateParametersSQLOutputWalker::class)\n ->getSQL();\n\nThe where clause of the returned SQL should be like:\n\n.. code-block:: sql\n\n WHERE t0_.int IN (1, 2)\n OR t0_.string IN ('3', '4')\n OR t0_.bool = 1\n OR t0_.string = 'ABC'\n"
},
{
"path": "docs/en/cookbook/dql-user-defined-functions.rst",
"content": "DQL User Defined Functions\n==========================\n\n.. sectionauthor:: Benjamin Eberlei \n\nBy default DQL supports a limited subset of all the vendor-specific\nSQL functions common between all the vendors. However in many cases\nonce you have decided on a specific database vendor, you will never\nchange it during the life of your project. This decision for a\nspecific vendor potentially allows you to make use of powerful SQL\nfeatures that are unique to the vendor.\n\nIt is worth to mention that Doctrine ORM also allows you to handwrite\nyour SQL instead of extending the DQL parser. Extending DQL is sort of an\nadvanced extension point. You can map arbitrary SQL to your objects\nand gain access to vendor specific functionalities using the\n``EntityManager#createNativeQuery()`` API as described in\nthe :doc:`Native Query <../reference/native-sql>` chapter.\n\n\nThe DQL Parser has hooks to register functions that can then be\nused in your DQL queries and transformed into SQL, allowing to\nextend Doctrines Query capabilities to the vendors strength. This\npost explains the User-Defined Functions API (UDF) of the Dql\nParser and shows some examples to give you some hints how you would\nextend DQL.\n\nThere are three types of functions in DQL, those that return a\nnumerical value, those that return a string and those that return a\nDate. Your custom method has to be registered as either one of\nthose. The return type information is used by the DQL parser to\ncheck possible syntax errors during the parsing process, for\nexample using a string function return value in a math expression.\n\nRegistering your own DQL functions\n----------------------------------\n\nYou can register your functions adding them to the ORM\nconfiguration:\n\n.. code-block:: php\n\n addCustomStringFunction($name, $class);\n $config->addCustomNumericFunction($name, $class);\n $config->addCustomDatetimeFunction($name, $class);\n\n $em = new EntityManager($connection, $config);\n\nThe ``$name`` is the name the function will be referred to in the\nDQL query. ``$class`` is a string of a class-name which has to\nextend ``Doctrine\\ORM\\Query\\Node\\FunctionNode``. This is a class\nthat offers all the necessary API and methods to implement a UDF.\n\nInstead of providing the function class name, you can also provide\na callable that returns the function object:\n\n.. code-block:: php\n\n addCustomStringFunction($name, function () {\n return new MyCustomFunction();\n });\n\nIn this post we will implement some MySql specific Date calculation\nmethods, which are quite handy in my opinion:\n\nDate Diff\n---------\n\n`Mysql's DateDiff function `_\ntakes two dates as argument and calculates the difference in days\nwith ``date1-date2``.\n\nThe DQL parser is a top-down recursive descent parser to generate\nthe Abstract-Syntax Tree (AST) and uses a TreeWalker approach to\ngenerate the appropriate SQL from the AST. This makes reading the\nParser/TreeWalker code manageable in a finite amount of time.\n\nThe ``FunctionNode`` class I referred to earlier requires you to\nimplement two methods, one for the parsing process (obviously)\ncalled ``parse`` and one for the TreeWalker process called\n``getSql()``. I show you the code for the DateDiff method and\ndiscuss it step by step:\n\n.. code-block:: php\n\n match(TokenType::T_IDENTIFIER); // (2)\n $parser->match(TokenType::T_OPEN_PARENTHESIS); // (3)\n $this->firstDateExpression = $parser->ArithmeticPrimary(); // (4)\n $parser->match(TokenType::T_COMMA); // (5)\n $this->secondDateExpression = $parser->ArithmeticPrimary(); // (6)\n $parser->match(TokenType::T_CLOSE_PARENTHESIS); // (3)\n }\n\n public function getSql(\\Doctrine\\ORM\\Query\\SqlWalker $sqlWalker)\n {\n return 'DATEDIFF(' .\n $this->firstDateExpression->dispatch($sqlWalker) . ', ' .\n $this->secondDateExpression->dispatch($sqlWalker) .\n ')'; // (7)\n }\n }\n\nThe Parsing process of the DATEDIFF function is going to find two\nexpressions the date1 and the date2 values, whose AST Node\nrepresentations will be saved in the variables of the DateDiff\nFunctionNode instance at (1).\n\nThe parse() method has to cut the function call \"DATEDIFF\" and its\nargument into pieces. Since the parser detects the function using a\nlookahead the T\\_IDENTIFIER of the function name has to be taken\nfrom the stack (2), followed by a detection of the arguments in\n(4)-(6). The opening and closing parenthesis have to be detected\nalso. This happens during the Parsing process and leads to the\ngeneration of a DateDiff FunctionNode somewhere in the AST of the\ndql statement.\n\nThe ``ArithmeticPrimary`` method call is the most common\ndenominator of valid EBNF tokens taken from the :ref:`DQL EBNF grammar\n`\nthat matches our requirements for valid input into the DateDiff Dql\nfunction. Picking the right tokens for your methods is a tricky\nbusiness, but the EBNF grammar is pretty helpful finding it, as is\nlooking at the Parser source code.\n\nNow in the TreeWalker process we have to pick up this node and\ngenerate SQL from it, which apparently is quite easy looking at the\ncode in (7). Since we don't know which type of AST Node the first\nand second Date expression are we are just dispatching them back to\nthe SQL Walker to generate SQL from and then wrap our DATEDIFF\nfunction call around this output.\n\nNow registering this DateDiff FunctionNode with the ORM using:\n\n.. code-block:: php\n\n addCustomStringFunction('DATEDIFF', 'DoctrineExtensions\\Query\\MySql\\DateDiff');\n\nWe can do fancy stuff like:\n\n.. code-block:: sql\n\n SELECT p FROM DoctrineExtensions\\Query\\BlogPost p WHERE DATEDIFF(CURRENT_TIME(), p.created) < 7\n\nDate Add\n--------\n\nOften useful it the ability to do some simple date calculations in\nyour DQL query using\n`MySql's DATE_ADD function `_.\n\nI'll skip the blah and show the code for this function:\n\n.. code-block:: php\n\n match(TokenType::T_IDENTIFIER);\n $parser->match(TokenType::T_OPEN_PARENTHESIS);\n\n $this->firstDateExpression = $parser->ArithmeticPrimary();\n\n $parser->match(TokenType::T_COMMA);\n $parser->match(TokenType::T_IDENTIFIER);\n\n $this->intervalExpression = $parser->ArithmeticPrimary();\n\n $parser->match(TokenType::T_IDENTIFIER);\n\n /** @var Lexer $lexer */\n $lexer = $parser->getLexer();\n $this->unit = $lexer->token['value'];\n\n $parser->match(TokenType::T_CLOSE_PARENTHESIS);\n }\n\n public function getSql(\\Doctrine\\ORM\\Query\\SqlWalker $sqlWalker)\n {\n return 'DATE_ADD(' .\n $this->firstDateExpression->dispatch($sqlWalker) . ', INTERVAL ' .\n $this->intervalExpression->dispatch($sqlWalker) . ' ' . $this->unit .\n ')';\n }\n }\n\nThe only difference compared to the DATEDIFF here is, we\nadditionally need the ``Lexer`` to access the value of the\n``T_IDENTIFIER`` token for the Date Interval unit, for example the\nMONTH in:\n\n.. code-block:: sql\n\n SELECT p FROM DoctrineExtensions\\Query\\BlogPost p WHERE DATE_ADD(CURRENT_TIME(), INTERVAL 4 MONTH) > p.created\n\nThe above method now only supports the specification using\n``INTERVAL``, to also allow a real date in DATE\\_ADD we need to add\nsome decision logic to the parsing process (makes up for a nice\nexercise).\n\nNow as you see, the Parsing process doesn't catch all the possible\nSQL errors, here we don't match for all the valid inputs for the\ninterval unit. However where necessary we rely on the database\nvendors SQL parser to show us further errors in the parsing\nprocess, for example if the Unit would not be one of the supported\nvalues by MySql.\n\nTyped functions\n---------------\nBy default, result of custom functions is fetched as-is from the database driver.\nIf you want to be sure that the type is always the same, then your custom function needs to \nimplement ``Doctrine\\ORM\\Query\\AST\\TypedExpression``. Then, the result is wired\nthrough ``Doctrine\\DBAL\\Types\\Type::convertToPhpValue()`` of the ``Type`` returned in ``getReturnType()``.\n\n.. code-block:: php\n\n `_.\n"
},
{
"path": "docs/en/cookbook/entities-in-session.rst",
"content": "Entities in the Session\n=======================\n\nThere are several use-cases to save entities in the session, for example:\n\n1. User data\n2. Multi-step forms\n\nTo achieve this with Doctrine you have to pay attention to some details to get\nthis working.\n\nUpdating an entity\n------------------\n\nIn Doctrine an entity objects has to be \"managed\" by an EntityManager to be\nupdatable. Entities saved into the session are not managed in the next request\nanymore. This means that you have to update the entities with the stored session\ndata after you fetch the entities from the EntityManager again.\n\nFor a representative User object the code to get data from the session into a\nmanaged Doctrine object can look like these examples:\n\nWorking with scalars\n~~~~~~~~~~~~~~~~~~~~\n\nIn simpler applications there is no need to work with objects in sessions and you can use\nseparate session elements.\n\n.. code-block:: php\n\n find(User::class, $userId);\n\n $user->setValue($_SESSION['storedValue']);\n\n $em->flush();\n }\n\nWorking with custom data transfer objects\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nIf objects are needed, we discourage the storage of entity objects in the session. It's\npreferable to use a `DTO (data transfer object) `_\ninstead and merge the DTO data later with the entity.\n\n.. code-block:: php\n\n find(User::class, $userDto->getId());\n\n $userEntity->populateFromDto($userDto);\n\n $em->flush();\n }\n\nSerializing entity into the session\n-----------------------------------\n\nEntities that are serialized into the session normally contain references to\nother entities as well. Think of the user entity has a reference to their\narticles, groups, photos or many other different entities. If you serialize\nthis object into the session then you don't want to serialize the related\nentities as well. This is why you shouldn't serialize an entity and use\nonly the needed values of it. This can happen with the help of a DTO.\n\n.. code-block:: php\n\n find(\"User\", 1);\n $userDto = new UserDto($user->getId(), $user->getFirstName(), $user->getLastName());\n // or \"UserDto::createFrom($user);\", but don't store an entity in a property. Only its values without relations.\n\n $_SESSION['user'] = $userDto;\n\n\n"
},
{
"path": "docs/en/cookbook/generated-columns/Article.php",
"content": " true])]\n private array $content;\n\n /**\n * Because we specify NOT NULL, inserting will fail if the content does\n * not have a string in the title field.\n */\n #[ORM\\Column(\n insertable: false,\n updatable: false,\n columnDefinition: \"VARCHAR(255) generated always as (content->>'title') stored NOT NULL\",\n generated: 'ALWAYS',\n )]\n private string $title;\n}\n"
},
{
"path": "docs/en/cookbook/generated-columns/Person.php",
"content": "`).\n Be aware that specifying a column definition makes the ``SchemaTool``\n completely ignore all other configuration for this column. See also\n :ref:`#[Column] `\n* ``generated``: Specifying that this column is always generated tells Doctrine\n to update the field on the entity with the value from the database after\n every write operation.\n\nAdvanced example: Extracting a value from a JSON structure\n----------------------------------------------------------\n\nLets assume we have an entity that stores a blogpost as structured JSON.\nTo avoid extracting all titles on the fly when listing the posts, we create a\ngenerated column with the field.\n\n.. literalinclude:: generated-columns/Article.php\n :language: php\n"
},
{
"path": "docs/en/cookbook/implementing-arrayaccess-for-domain-objects.rst",
"content": "Implementing ArrayAccess for Domain Objects\n===========================================\n\n.. sectionauthor:: Roman Borschel \n\nThis recipe will show you how to implement ArrayAccess for your\ndomain objects in order to allow more uniform access, for example\nin templates. In these examples we will implement ArrayAccess on a\n`Layer Supertype `_\nfor all our domain objects.\n\nOption 1\n--------\n\nIn this implementation we will make use of PHPs highly dynamic\nnature to dynamically access properties of a subtype in a supertype\nat runtime. Note that this implementation has 2 main caveats:\n\n\n- It will not work with private fields\n- It will not go through any getters/setters\n\n.. code-block:: php\n\n $offset);\n }\n \n public function offsetSet($offset, $value) {\n $this->$offset = $value;\n }\n \n public function offsetGet($offset) {\n return $this->$offset;\n }\n \n public function offsetUnset($offset) {\n $this->$offset = null;\n }\n }\n\nOption 2\n--------\n\nIn this implementation we will dynamically invoke getters/setters.\nAgain we use PHPs dynamic nature to invoke methods on a subtype\nfrom a supertype at runtime. This implementation has the following\ncaveats:\n\n\n- It relies on a naming convention\n- The semantics of offsetExists can differ\n- offsetUnset will not work with typehinted setters\n\n.. code-block:: php\n\n {\"get$offset\"}();\n return $value !== null;\n }\n \n public function offsetSet($offset, $value) {\n $this->{\"set$offset\"}($value);\n }\n \n public function offsetGet($offset) {\n return $this->{\"get$offset\"}();\n }\n \n public function offsetUnset($offset) {\n $this->{\"set$offset\"}(null);\n }\n }\n\nRead-only\n---------\n\nYou can slightly tweak option 1 or option 2 in order to make array\naccess read-only. This will also circumvent some of the caveats of\neach option. Simply make offsetSet and offsetUnset throw an\nexception (i.e. BadMethodCallException).\n\n.. code-block:: php\n\n getConnection();\n $conn->getDatabasePlatform()->registerDoctrineTypeMapping('enum', 'string');\n\nIn this case you have to ensure that each varchar field that is an enum in the\ndatabase only gets passed the allowed values. You can easily enforce this in your\nentities:\n\n.. code-block:: php\n\n status = $status;\n }\n }\n\nIf you want to actively create enums through the Doctrine Schema-Tool by using\nthe **columnDefinition** attribute.\n\n.. code-block:: php\n\n \"'\".$val.\"'\", $this->values);\n\n return \"ENUM(\".implode(\", \", $values).\")\";\n }\n\n public function convertToPHPValue(mixed $value, AbstractPlatform $platform): mixed\n {\n return $value;\n }\n\n public function convertToDatabaseValue(mixed $value, AbstractPlatform $platform): mixed\n {\n if (!in_array($value, $this->values, true)) {\n throw new \\InvalidArgumentException(\"Invalid '\".$this->name.\"' value.\");\n }\n\n return $value;\n }\n\n public function getName(): string\n {\n return $this->name;\n }\n }\n\nWith this base class you can define an enum as easily as:\n\n.. code-block:: php\n\n addResolveTargetEntity('Acme\\\\InvoiceModule\\\\Model\\\\InvoiceSubjectInterface', 'Acme\\\\CustomerModule\\\\Entity\\\\Customer', array());\n\n // Add the ResolveTargetEntityListener\n $evm->addEventListener(Doctrine\\ORM\\Events::loadClassMetadata, $rtel);\n\n $connection = \\Doctrine\\DBAL\\DriverManager::getConnection($connectionOptions, $config, $evm);\n $em = new \\Doctrine\\ORM\\EntityManager($connection, $config, $evm);\n\nFinal Thoughts\n--------------\n\nWith the ``ResolveTargetEntityListener``, we are able to decouple our\nbundles, keeping them usable by themselves, but still being able to\ndefine relationships between different objects. By using this method,\nI've found my bundles end up being easier to maintain independently.\n"
},
{
"path": "docs/en/cookbook/sql-table-prefixes.rst",
"content": "SQL-Table Prefixes\n==================\n\nThis recipe is intended as an example of implementing a\nloadClassMetadata listener to provide a Table Prefix option for\nyour application. The method used below is not a hack, but fully\nintegrates into the Doctrine system, all SQL generated will include\nthe appropriate table prefix.\n\nIn most circumstances it is desirable to separate different\napplications into individual databases, but in certain cases, it\nmay be beneficial to have a table prefix for your Entities to\nseparate them from other vendor products in the same database.\n\nImplementing the listener\n-------------------------\n\nThe listener in this example has been set up with the\nDoctrineExtensions namespace. You create this file in your\nlibrary/DoctrineExtensions directory, but will need to set up\nappropriate autoloaders.\n\n.. code-block:: php\n\n prefix = (string) $prefix;\n }\n \n public function loadClassMetadata(LoadClassMetadataEventArgs $eventArgs)\n {\n $classMetadata = $eventArgs->getClassMetadata();\n\n if (!$classMetadata->isInheritanceTypeSingleTable() || $classMetadata->getName() === $classMetadata->rootEntityName) {\n $classMetadata->setPrimaryTable([\n 'name' => $this->prefix . $classMetadata->getTableName()\n ]);\n }\n\n foreach ($classMetadata->getAssociationMappings() as $fieldName => $mapping) {\n if ($mapping['type'] == \\Doctrine\\ORM\\Mapping\\ClassMetadata::MANY_TO_MANY && $mapping['isOwningSide']) {\n $mappedTableName = $mapping['joinTable']['name'];\n $classMetadata->associationMappings[$fieldName]['joinTable']['name'] = $this->prefix . $mappedTableName;\n }\n }\n }\n\n }\n\nTelling the EntityManager about our listener\n--------------------------------------------\n\nA listener of this type must be set up before the EntityManager has\nbeen initialised, otherwise an Entity might be created or cached\nbefore the prefix has been set.\n\n.. note::\n\n If you set this listener up, be aware that you will need\n to clear your caches and drop then recreate your database schema.\n\n\n.. code-block:: php\n\n addEventListener(\\Doctrine\\ORM\\Events::loadClassMetadata, $tablePrefix);\n \n $em = new \\Doctrine\\ORM\\EntityManager($connection, $config, $evm);\n"
},
{
"path": "docs/en/cookbook/strategy-cookbook-introduction.rst",
"content": "Strategy-Pattern\n================\n\nThis recipe will give you a short introduction on how to design\nsimilar entities without using expensive (i.e. slow) inheritance\nbut with not more than *the well-known strategy pattern* event\nlisteners\n\nScenario / Problem\n------------------\n\nGiven a Content-Management-System, we probably want to add / edit\nsome so-called \"blocks\" and \"panels\". What are they for?\n\n\n- A block might be a registration form, some text content, a table\n with information. A good example might also be a small calendar.\n- A panel is by definition a block that can itself contain blocks.\n A good example for a panel might be a sidebar box: You could easily\n add a small calendar into it.\n\nSo, in this scenario, when building your CMS, you will surely add\nlots of blocks and panels to your pages and you will find yourself\nhighly uncomfortable because of the following:\n\n\n- Every existing page needs to know about the panels it contains -\n therefore, you'll have an association to your panels. But if you've\n got several types of panels - what do you do? Add an association to\n every panel-type? This wouldn't be flexible. You might be tempted\n to add an AbstractPanelEntity and an AbstractBlockEntity that use\n class inheritance. Your page could then only confer to the\n AbstractPanelType and Doctrine ORM would do the rest for you, i.e.\n load the right entities. But - you'll for sure have lots of panels\n and blocks, and even worse, you'd have to edit the discriminator\n map *manually* every time you or another developer implements a new\n block / entity. This would tear down any effort of modular\n programming.\n\nTherefore, we need something that's far more flexible.\n\nSolution\n--------\n\nThe solution itself is pretty easy. We will have one base class\nthat will be loaded via the page and that has specific behaviour -\na Block class might render the front-end and even the backend, for\nexample. Now, every block that you'll write might look different or\nneed different data - therefore, we'll offer an API to these\nmethods but internally, we use a strategy that exactly knows what\nto do.\n\nFirst of all, we need to make sure that we have an interface that\ncontains every needed action. Such actions would be rendering the\nfront-end or the backend, solving dependencies (blocks that are\nsupposed to be placed in the sidebar could refuse to be placed in\nthe middle of your page, for example).\n\nSuch an interface could look like this:\n\n\n.. code-block:: php\n\n blockStrategy. Will not be persisted by Doctrine ORM.\n *\n * @var BlockStrategyInterface\n */\n protected $strategyInstance;\n\n /**\n * Returns the strategy that is used for this blockitem.\n *\n * The strategy itself defines how this block can be rendered etc.\n *\n * @return string\n */\n public function getStrategyClassName() {\n return $this->strategyClassName;\n }\n\n /**\n * Returns the instantiated strategy\n *\n * @return BlockStrategyInterface\n */\n public function getStrategyInstance() {\n return $this->strategyInstance;\n }\n\n /**\n * Sets the strategy this block / panel should work as. Make sure that you've used\n * this method before persisting the block!\n *\n * @param BlockStrategyInterface $strategy\n */\n public function setStrategy(BlockStrategyInterface $strategy) {\n $this->strategyInstance = $strategy;\n $this->strategyClassName = get_class($strategy);\n $strategy->setBlockEntity($this);\n }\n\nNow, the important point is that $strategyClassName is a Doctrine ORM\nfield, i.e. Doctrine will persist this value. This is only the\nclass name of your strategy and not an instance!\n\nFinishing your strategy pattern, we hook into the Doctrine postLoad\nevent and check whether a block has been loaded. If so, you will\ninitialize it - i.e. get the strategies classname, create an\ninstance of it and set it via setStrategyBlock().\n\nThis might look like this:\n\n.. code-block:: php\n\n view = $view;\n }\n\n public function getSubscribedEvents() {\n return array(Events::postLoad);\n }\n\n public function postLoad(LifecycleEventArgs $args) {\n $blockItem = $args->getObject();\n\n // Both blocks and panels are instances of Block\\AbstractBlock\n if ($blockItem instanceof Block\\AbstractBlock) {\n $strategy = $blockItem->getStrategyClassName();\n $strategyInstance = new $strategy();\n if (null !== $blockItem->getConfig()) {\n $strategyInstance->setConfig($blockItem->getConfig());\n }\n $strategyInstance->setView($this->view);\n $blockItem->setStrategy($strategyInstance);\n }\n }\n }\n\nIn this example, even some variables are set - like a view object\nor a specific configuration object.\n"
},
{
"path": "docs/en/cookbook/validation-of-entities.rst",
"content": "Validation of Entities\n======================\n\n.. sectionauthor:: Benjamin Eberlei \n\nDoctrine ORM does not ship with any internal validators, the reason\nbeing that we think all the frameworks out there already ship with\nquite decent ones that can be integrated into your Domain easily.\nWhat we offer are hooks to execute any kind of validation.\n\n.. note::\n\n You don't need to validate your entities in the lifecycle\n events. It is only one of many options. Of course you can also\n perform validations in value setters or any other method of your\n entities that are used in your code.\n\n\nEntities can register lifecycle event methods with Doctrine that\nare called on different occasions. For validation we would need to\nhook into the events called before persisting and updating. Even\nthough we don't support validation out of the box, the\nimplementation is even simpler than in Doctrine 1 and you will get\nthe additional benefit of being able to re-use your validation in\nany other part of your domain.\n\nSay we have an ``Order`` with several ``OrderLine`` instances. We\nnever want to allow any customer to order for a larger sum than they\nare allowed to:\n\n.. code-block:: php\n\n customer->getOrderLimit();\n\n $amount = 0;\n foreach ($this->orderLines as $line) {\n $amount += $line->getAmount();\n }\n\n if ($amount > $orderLimit) {\n throw new CustomerOrderLimitExceededException();\n }\n }\n }\n\nNow this is some pretty important piece of business logic in your\ncode, enforcing it at any time is important so that customers with\na unknown reputation don't owe your business too much money.\n\nWe can enforce this constraint in any of the metadata drivers.\nFirst Attributes:\n\n.. code-block:: php\n\n \n \n \n \n \n \n \n \n\nNow validation is performed whenever you call\n``EntityManager#persist($order)`` or when you call\n``EntityManager#flush()`` and an order is about to be updated. Any\nException that happens in the lifecycle callbacks will be caught by\nthe EntityManager and the current transaction is rolled back.\n\nOf course you can do any type of primitive checks, not null,\nemail-validation, string size, integer and date ranges in your\nvalidation callbacks.\n\n.. code-block:: php\n\n plannedShipDate instanceof DateTime)) {\n throw new ValidateException();\n }\n\n if ($this->plannedShipDate->format('U') < time()) {\n throw new ValidateException();\n }\n\n if ($this->customer == null) {\n throw new OrderRequiresCustomerException();\n }\n }\n }\n\nWhat is nice about lifecycle events is, you can also re-use the\nmethods at other places in your domain, for example in combination\nwith your form library. Additionally there is no limitation in the\nnumber of methods you register on one particular event, i.e. you\ncan register multiple methods for validation in \"PrePersist\" or\n\"PreUpdate\" or mix and share them in any combinations between those\ntwo events.\n\nThere is no limit to what you can and can't validate in\n\"PrePersist\" and \"PreUpdate\" as long as you don't create new entity\ninstances. This was already discussed in the previous blog post on\nthe Versionable extension, which requires another type of event\ncalled \"onFlush\".\n\nFurther readings: :ref:`reference-events-lifecycle-events`\n"
},
{
"path": "docs/en/cookbook/working-with-datetime.rst",
"content": "Working with DateTime Instances\n===============================\n\nThere are many nitty gritty details when working with PHPs DateTime instances. You have to know their inner\nworkings pretty well not to make mistakes with date handling. This cookbook entry holds several\ninteresting pieces of information on how to work with PHP DateTime instances in ORM.\n\nDateTime changes are detected by Reference\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nWhen calling ``EntityManager#flush()`` Doctrine computes the changesets of all the currently managed entities\nand saves the differences to the database. In case of object properties (@Column(type=\"datetime\") or @Column(type=\"object\"))\nthese comparisons are always made **BY REFERENCE**. That means the following change will **NOT** be saved into the database:\n\n.. code-block:: php\n\n updated->modify(\"now\");\n }\n }\n\nThe way to go would be:\n\n.. code-block:: php\n\n updated = new DateTime(\"now\");\n }\n }\n\nDefault Timezone Gotcha\n~~~~~~~~~~~~~~~~~~~~~~~\n\nBy default Doctrine assumes that you are working with a default timezone. Each DateTime instance that\nis created by Doctrine will be assigned the timezone that is currently the default, either through\nthe ``date.timezone`` ini setting or by calling ``date_default_timezone_set()``.\n\nThis is very important to handle correctly if your application runs on different servers or is moved from one to another server\n(with different timezone settings). You have to make sure that the timezone is the correct one\non all this systems.\n\nHandling different Timezones with the DateTime Type\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nIf you first come across the requirement to save different timezones you may be still optimistic about how\nto manage this mess,\nhowever let me crush your expectations fast. There is not a single database out there (supported by Doctrine ORM)\nthat supports timezones correctly. Correctly here means that you can cover all the use-cases that\ncan come up with timezones. If you don't believe me you should read up on `Storing DateTime\nin Databases `_.\n\nThe problem is simple. Not a single database vendor saves the timezone, only the differences to UTC.\nHowever with frequent daylight saving and political timezone changes you can have a UTC offset that moves\nin different offset directions depending on the real location.\n\nThe solution for this dilemma is simple. Don't use timezones with DateTime and Doctrine ORM. However there is a workaround\nthat even allows correct date-time handling with timezones:\n\n1. Always convert any DateTime instance to UTC.\n2. Only set Timezones for displaying purposes\n3. Save the Timezone in the Entity for persistence.\n\nSay we have an application for an international postal company and employees insert events regarding postal-package\naround the world, in their current timezones. To determine the exact time an event occurred means to save both\nthe UTC time at the time of the booking and the timezone the event happened in.\n\n.. code-block:: php\n\n setTimezone(self::getUtc());\n }\n\n return parent::convertToDatabaseValue($value, $platform);\n }\n\n public function convertToPHPValue($value, AbstractPlatform $platform)\n {\n if (null === $value || $value instanceof \\DateTime) {\n return $value;\n }\n\n $converted = \\DateTime::createFromFormat(\n $platform->getDateTimeFormatString(),\n $value,\n self::getUtc()\n );\n\n if (! $converted) {\n throw ConversionException::conversionFailedFormat(\n $value,\n $this->getName(),\n $platform->getDateTimeFormatString()\n );\n }\n\n return $converted;\n }\n\n private static function getUtc(): DateTimeZone\n {\n return self::$utc ??= new DateTimeZone('UTC');\n }\n }\n\nThis database type makes sure that every DateTime instance is always saved in UTC, relative\nto the current timezone that the passed DateTime instance has.\n\nTo actually use this new type instead of the default ``datetime`` type, you need to run following\ncode before bootstrapping the ORM:\n\n.. code-block:: php\n\n localized = true;\n $this->created = $createDate;\n $this->timezone = $createDate->getTimeZone()->getName();\n }\n\n public function getCreated()\n {\n if (!$this->localized) {\n $this->created->setTimeZone(new \\DateTimeZone($this->timezone));\n }\n return $this->created;\n }\n }\n\nThis snippet makes use of the previously discussed \"changeset by reference only\" property of\nobjects. That means a new DateTime will only be used during updating if the reference\nchanges between retrieval and flush operation. This means we can easily go and modify\nthe instance by setting the previous local timezone.\n"
},
{
"path": "docs/en/index.rst",
"content": "Welcome to Doctrine ORM's documentation!\n==========================================\n\nThe Doctrine documentation is comprised of tutorials, a reference section and\ncookbook articles that explain different parts of the Object Relational mapper.\n\nDoctrine DBAL and Doctrine Common both have their own documentation.\n\nGetting Help\n------------\n\nIf this documentation is not helping to answer questions you have about\nDoctrine ORM don't panic. You can get help from different sources:\n\n- There is a :doc:`FAQ ` with answers to frequent questions.\n- Slack chat room `#orm `_\n- Report a bug on `GitHub `_.\n- On `StackOverflow `_\n\nIf you need more structure over the different topics you can browse the table\nof contents.\n\nGetting Started\n---------------\n\n* **Tutorial**:\n :doc:`Getting Started with Doctrine `\n\n* **Setup**:\n :doc:`Installation & Configuration `\n\nMapping Objects onto a Database\n-------------------------------\n\n* **Mapping**:\n :doc:`Objects ` \\|\n :doc:`Associations ` \\|\n :doc:`Inheritance `\n\n* **Drivers**:\n :doc:`Attributes ` \\|\n :doc:`XML ` \\|\n :doc:`PHP `\n\nWorking with Objects\n--------------------\n\n* **Basic Reference**:\n :doc:`Entities ` \\|\n :doc:`Associations ` \\|\n :doc:`Events `\n\n* **Query Reference**:\n :doc:`DQL ` \\|\n :doc:`QueryBuilder ` \\|\n :doc:`Native SQL `\n\n* **Internals**:\n :doc:`Internals explained ` \\|\n :doc:`Associations `\n\nAdvanced Topics\n---------------\n\n* :doc:`Architecture `\n* :doc:`Advanced Configuration `\n* :doc:`Limitations and known issues `\n* :doc:`Commandline Tools `\n* :doc:`Transactions and Concurrency `\n* :doc:`Filters `\n* :doc:`NamingStrategy `\n* :doc:`TypedFieldMapper `\n* :doc:`Improving Performance `\n* :doc:`Caching `\n* :doc:`Partial Hydration `\n* :doc:`Partial Objects `\n* :doc:`Change Tracking Policies `\n* :doc:`Best Practices `\n* :doc:`Metadata Drivers `\n* :doc:`Batch Processing `\n* :doc:`Second Level Cache `\n\nTutorials\n---------\n\n* :doc:`Indexed associations `\n* :doc:`Extra Lazy Associations `\n* :doc:`Composite Primary Keys `\n* :doc:`Ordered associations `\n* :doc:`Pagination `\n* :doc:`Override Field/Association Mappings In Subclasses `\n* :doc:`Embeddables `\n\nChangelogs\n----------\n\n* `Upgrade `_\n\nCookbook\n--------\n\n* **Patterns**:\n :doc:`Aggregate Fields ` \\|\n :doc:`Generated/Virtual Columns ` \\|\n :doc:`Decorator Pattern ` \\|\n :doc:`Strategy Pattern `\n\n* **DQL Extension Points**:\n :doc:`DQL Custom Walkers ` \\|\n :doc:`DQL User-Defined-Functions `\n\n* **Implementation**:\n :doc:`Array Access ` \\|\n :doc:`Working with DateTime ` \\|\n :doc:`Validation ` \\|\n :doc:`Entities in the Session ` \\|\n :doc:`Keeping your Modules independent `\n\n* **Hidden Gems**\n :doc:`Prefixing Table Name `\n\n* **Custom Datatypes**\n :doc:`MySQL Enums `\n :doc:`Custom Mapping Types `\n :doc:`Advanced Field Value Conversion `\n"
},
{
"path": "docs/en/reference/advanced-configuration.rst",
"content": "Advanced Configuration\n======================\n\nThe configuration of the EntityManager requires a\n``Doctrine\\ORM\\Configuration`` instance as well as some database\nconnection parameters. This example shows all the potential\nsteps of configuration.\n\n.. code-block:: php\n\n setMetadataCache($metadataCache);\n $driverImpl = new AttributeDriver(['/path/to/lib/MyProject/Entities']);\n $config->setMetadataDriverImpl($driverImpl);\n $config->setQueryCache($queryCache);\n\n if (PHP_VERSION_ID > 80400) {\n $config->enableNativeLazyObjects(true);\n } else {\n $config->setProxyDir('/path/to/myproject/lib/MyProject/Proxies');\n $config->setProxyNamespace('MyProject\\Proxies');\n\n if ($applicationMode === \"development\") {\n $config->setAutoGenerateProxyClasses(true);\n } else {\n $config->setAutoGenerateProxyClasses(false);\n }\n }\n\n $connection = DriverManager::getConnection([\n 'driver' => 'pdo_sqlite',\n 'path' => 'database.sqlite',\n ], $config);\n\n $em = new EntityManager($connection, $config);\n\nDoctrine and Caching\n--------------------\n\nDoctrine is optimized for working with caches. The main parts in Doctrine\nthat are optimized for caching are the metadata mapping information with\nthe metadata cache and the DQL to SQL conversions with the query cache.\nThese 2 caches require only an absolute minimum of memory yet they heavily\nimprove the runtime performance of Doctrine.\n\nDoctrine does not bundle its own cache implementation anymore. Instead,\nthe PSR-6 standard interfaces are used to access the cache. In the examples\nin this documentation, Symfony Cache is used as a reference implementation.\n\n.. note::\n\n Do not use Doctrine without a metadata and query cache!\n\nConfiguration Options\n---------------------\n\nThe following sections describe all the configuration options\navailable on a ``Doctrine\\ORM\\Configuration`` instance.\n\n.. _reference-native-lazy-objects:\n\nNative Lazy Objects (**OPTIONAL**)\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nWith PHP 8.4 we recommend that you use native lazy objects instead of\nthe code generation approach using the ``symfony/var-exporter`` Ghost trait.\n\nWith Doctrine 4, the minimal requirement will become PHP 8.4 and native lazy objects\nwill become the only approach to lazy loading.\n\n.. code-block:: php\n\n enableNativeLazyObjects(true);\n\nProxy Directory\n~~~~~~~~~~~~~~~\n\nRequired except if you use native lazy objects with PHP 8.4.\nThis setting will be removed in the future.\n\n.. code-block:: php\n\n setProxyDir($dir);\n $config->getProxyDir();\n\nGets or sets the directory where Doctrine generates any proxy\nclasses. For a detailed explanation on proxy classes and how they\nare used in Doctrine, refer to the \"Proxy Objects\" section further\ndown.\n\nProxy Namespace\n~~~~~~~~~~~~~~~\n\nRequired except if you use native lazy objects with PHP 8.4.\nThis setting will be removed in the future.\n\n.. code-block:: php\n\n setProxyNamespace($namespace);\n $config->getProxyNamespace();\n\nGets or sets the namespace to use for generated proxy classes. For\na detailed explanation on proxy classes and how they are used in\nDoctrine, refer to the \"Proxy Objects\" section further down.\n\nMetadata Driver (**REQUIRED**)\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n.. code-block:: php\n\n setMetadataDriverImpl($driver);\n $config->getMetadataDriverImpl();\n\nGets or sets the metadata driver implementation that is used by\nDoctrine to acquire the object-relational metadata for your\nclasses.\n\nThere are currently 3 available implementations:\n\n\n- ``Doctrine\\ORM\\Mapping\\Driver\\AttributeDriver``\n- ``Doctrine\\ORM\\Mapping\\Driver\\XmlDriver``\n- ``Doctrine\\ORM\\Mapping\\Driver\\DriverChain``\n\nThroughout the most part of this manual the AttributeDriver is\nused in the examples. For information on the usage of the\nXmlDriver please refer to the dedicated chapter ``XML Mapping``.\n\nThe attribute driver can be injected in the ``Doctrine\\ORM\\Configuration``:\n\n.. code-block:: php\n\n setMetadataDriverImpl($driverImpl);\n\nThe path information to the entities is required for the attribute\ndriver, because otherwise mass-operations on all entities through\nthe console could not work correctly. Metadata drivers can accept either\na single directory as a string or an array of directories.\n\nAttributeDriver also accepts ``Doctrine\\Persistence\\Mapping\\Driver\\ClassLocator``,\nallowing one to customize file discovery logic. You may choose to use Symfony Finder, or\nutilize directory scan with ``FileClassLocator::createFromDirectories()``:\n\n.. code-block:: php\n\n setMetadataDriverImpl($driverImpl);\n\nWith this feature, you're empowered to provide a fine-grained iterator of only necessary\nfiles to the Driver. For example, if you are using Vertical Slice architecture, you can\nexclude ``*Test.php``, ``*Controller.php``, ``*Service.php``, etc.:\n\n.. code-block:: php\n\n files()->in($paths)\n\t\t->name('*.php')\n\t\t->notName(['*Test.php', '*Controller.php', '*Service.php']);\n\n\t$classLocator = new FileClassLocator($finder);\n\nIf you know the list of class names you want to track, use\n``Doctrine\\Persistence\\Mapping\\Driver\\ClassNames``:\n\n.. code-block:: php\n\n setMetadataDriverImpl($driverImpl);\n\nMetadata Cache (**RECOMMENDED**)\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n.. code-block:: php\n\n setMetadataCache($cache);\n $config->getMetadataCache();\n\nGets or sets the cache adapter to use for caching metadata\ninformation, that is, all the information you supply via attributes,\nxml, so that they do not need to be parsed and loaded from scratch on\nevery single request which is a waste of resources. The cache\nimplementation must implement the PSR-6\n``Psr\\Cache\\CacheItemPoolInterface`` interface.\n\nUsage of a metadata cache is highly recommended.\n\nFor development you should use an array cache like\n``Symfony\\Component\\Cache\\Adapter\\ArrayAdapter``\nwhich only caches data on a per-request basis.\n\nQuery Cache (**RECOMMENDED**)\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n.. code-block:: php\n\n setQueryCache($cache);\n $config->getQueryCache();\n\nGets or sets the cache implementation to use for caching DQL\nqueries, that is, the result of a DQL parsing process that includes\nthe final SQL as well as meta information about how to process the\nSQL result set of a query. Note that the query cache does not\naffect query results. You do not get stale data. This is a pure\noptimization cache without any negative side-effects (except some\nminimal memory usage in your cache).\n\nUsage of a query cache is highly recommended.\n\nFor development you should use an array cache like\n``Symfony\\Component\\Cache\\Adapter\\ArrayAdapter``\nwhich only caches data on a per-request basis.\n\nSQL Logger (**Optional**)\n~~~~~~~~~~~~~~~~~~~~~~~~~\n\n.. code-block:: php\n\n setSQLLogger($logger);\n $config->getSQLLogger();\n\nGets or sets the logger to use for logging all SQL statements\nexecuted by Doctrine. The logger class must implement the\ndeprecated ``Doctrine\\DBAL\\Logging\\SQLLogger`` interface.\n\nAuto-generating Proxy Classes (**OPTIONAL**)\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nThis setting is not required if you use native lazy objects with PHP 8.4\nand will be removed in the future.\n\nProxy classes can either be generated manually through the Doctrine\nConsole or automatically at runtime by Doctrine. The configuration\noption that controls this behavior is:\n\n.. code-block:: php\n\n setAutoGenerateProxyClasses($mode);\n\nPossible values for ``$mode`` are:\n\n- ``Doctrine\\ORM\\Proxy\\ProxyFactory::AUTOGENERATE_NEVER``\n\nNever autogenerate a proxy. You will need to generate the proxies\nmanually, for this use the Doctrine Console like so:\n\n.. code-block:: php\n\n $ ./doctrine orm:generate-proxies\n\nWhen you do this in a development environment,\nbe aware that you may get class/file not found errors if certain proxies\nare not yet generated. You may also get failing lazy-loads if new\nmethods were added to the entity class that are not yet in the proxy class.\nIn such a case, simply use the Doctrine Console to (re)generate the\nproxy classes.\n\n- ``Doctrine\\ORM\\Proxy\\ProxyFactory::AUTOGENERATE_ALWAYS``\n\nAlways generates a new proxy in every request and writes it to disk.\n\n- ``Doctrine\\ORM\\Proxy\\ProxyFactory::AUTOGENERATE_FILE_NOT_EXISTS``\n\nGenerate the proxy class when the proxy file does not exist.\nThis strategy causes a file exists call whenever any proxy is\nused the first time in a request.\n\n- ``Doctrine\\ORM\\Proxy\\ProxyFactory::AUTOGENERATE_EVAL``\n\nGenerate the proxy classes and evaluate them on the fly via eval(),\navoiding writing the proxies to disk.\nThis strategy is only sane for development.\n\nIn a production environment, it is highly recommended to use\nAUTOGENERATE_NEVER to allow for optimal performances. The other\noptions are interesting in development environment.\n\n``setAutoGenerateProxyClasses`` can accept a boolean\nvalue. This is still possible, ``FALSE`` being equivalent to\nAUTOGENERATE_NEVER and ``TRUE`` to AUTOGENERATE_ALWAYS.\n\nDevelopment vs Production Configuration\n---------------------------------------\n\nYou should code your Doctrine2 bootstrapping with two different\nruntime models in mind. There are some serious benefits of using\nAPCu or Memcache in production. In development however this will\nfrequently give you fatal errors, when you change your entities and\nthe cache still keeps the outdated metadata. That is why we\nrecommend an array cache for development.\n\nFurthermore you should have the Auto-generating Proxy Classes\noption to true in development and to false in production. If this\noption is set to ``TRUE`` it can seriously hurt your script\nperformance if several proxy classes are re-generated during script\nexecution. Filesystem calls of that magnitude can even slower than\nall the database queries Doctrine issues. Additionally writing a\nproxy sets an exclusive file lock which can cause serious\nperformance bottlenecks in systems with regular concurrent\nrequests.\n\nConnection\n----------\n\nThe ``$connection`` passed as the first argument to the constructor of\n``EntityManager`` has to be an instance of ``Doctrine\\DBAL\\Connection``.\nYou can use the factory ``Doctrine\\DBAL\\DriverManager::getConnection()``\nto create such a connection. The DBAL configuration is explained in the\n`DBAL section `_.\n\nProxy Objects\n-------------\n\nA proxy object is an object that is put in place or used instead of\nthe \"real\" object. A proxy object can add behavior to the object\nbeing proxied without that object being aware of it. In ORM,\nproxy objects are used to realize several features but mainly for\ntransparent lazy-loading.\n\nProxy objects with their lazy-loading facilities help to keep the\nsubset of objects that are already in memory connected to the rest\nof the objects. This is an essential property as without it there\nwould always be fragile partial objects at the outer edges of your\nobject graph.\n\nDoctrine ORM implements a variant of the proxy pattern where it\ngenerates classes that extend your entity classes and adds\nlazy-loading capabilities to them. Doctrine can then give you an\ninstance of such a proxy class whenever you request an object of\nthe class being proxied. This happens in two situations:\n\nReference Proxies\n~~~~~~~~~~~~~~~~~\n\nThe method ``EntityManager#getReference($entityName, $identifier)``\nlets you obtain a reference to an entity for which the identifier\nis known, without necessarily loading that entity from the database.\nThis is useful, for example, as a performance enhancement, when you\nwant to establish an association to an entity for which you have the\nidentifier.\n\nConsider the following example:\n\n.. code-block:: php\n\n getReference('MyProject\\Model\\Item', $itemId);\n $cart->addItem($item);\n\nWhether the object being returned from ``EntityManager#getReference()``\nis a proxy or a direct instance of the entity class may depend on different\nfactors, including whether the entity has already been loaded into memory\nor entity inheritance being used. But your code does not need to care\nand in fact it **should not care**. Proxy objects should be transparent to your\ncode.\n\nWhen using the ``EntityManager#getReference()`` method, you need to be aware\nof a few peculiarities.\n\nAt the best case, the ORM can avoid querying the database at all. But, that\nalso means that this method will not throw an exception when an invalid value\nfor the ``$identifier`` parameter is passed. ``$identifier`` values are\nnot checked and there is no guarantee that the requested entity instance even\nexists – the method will still return a proxy object.\n\nIts only when the proxy has to be fully initialized or associations cannot\nbe written to the database that invalid ``$identifier`` values may lead to\nexceptions.\n\nThe ``EntityManager#getReference()`` is mostly useful when you only\nneed a reference to some entity to make an association, like in the example\nabove. In that case, it can save you from loading data from the database\nthat you don't need. But remember – as soon as you read any property values\nbesides those making up the ID, a database request will be made to initialize\nall fields.\n\nAssociation proxies\n~~~~~~~~~~~~~~~~~~~\n\nThe second most important situation where Doctrine uses proxy\nobjects is when querying for objects. Whenever you query for an\nobject that has a single-valued association to another object that\nis configured LAZY, without joining that association in the same\nquery, Doctrine puts proxy objects in place where normally the\nassociated object would be. Just like other proxies it will\ntransparently initialize itself on first access.\n\n.. note::\n\n Joining an association in a DQL or native query\n essentially means eager loading of that association in that query.\n This will override the 'fetch' option specified in the mapping for\n that association, but only for that query.\n\n\nGenerating Proxy classes\n~~~~~~~~~~~~~~~~~~~~~~~~\n\nIn a production environment, it is highly recommended to use\n``AUTOGENERATE_NEVER`` to allow for optimal performances.\nHowever you will be required to generate the proxies manually\nusing the Doctrine Console:\n\n.. code-block:: php\n\n $ ./doctrine orm:generate-proxies\n\nThe other options are interesting in development environment:\n\n- ``AUTOGENERATE_ALWAYS`` will require you to create and configure\n a proxy directory. Proxies will be generated and written to file\n on each request, so any modification to your code will be acknowledged.\n\n- ``AUTOGENERATE_FILE_NOT_EXISTS`` will not overwrite an existing\n proxy file. If your code changes, you will need to regenerate the\n proxies manually.\n\n- ``AUTOGENERATE_EVAL`` will regenerate each proxy on each request,\n but without writing them to disk.\n\nAutoloading Proxies\n-------------------\n\nWhen you deserialize proxy objects from the session or any other storage\nit is necessary to have an autoloading mechanism in place for these classes.\nFor implementation reasons Proxy class names are not PSR-0 compliant. This\nmeans that you have to register a special autoloader for these classes:\n\n.. code-block:: php\n\n addDriver($xmlDriver, 'Doctrine\\Tests\\Models\\Company');\n $chain->addDriver($phpDriver, 'Doctrine\\Tests\\ORM\\Mapping');\n\nBased on the namespace of the entity the loading of entities is\ndelegated to the appropriate driver. The chain semantics come from\nthe fact that the driver loops through all namespaces and matches\nthe entity class name against the namespace using a\n``strpos() === 0`` call. This means you need to order the drivers\ncorrectly if sub-namespaces use different metadata driver\nimplementations.\n\n\nDefault Repository (**OPTIONAL**)\n-----------------------------------\n\nSpecifies the FQCN of a subclass of the EntityRepository.\nThat will be available for all entities without a custom repository class.\n\n.. code-block:: php\n\n setDefaultRepositoryClassName($fqcn);\n $config->getDefaultRepositoryClassName();\n\nThe default value is ``Doctrine\\ORM\\EntityRepository``.\nAny repository class must be a subclass of EntityRepository otherwise you got an ORMException\n\nIgnoring entities (**OPTIONAL**)\n-----------------------------------\n\nSpecifies the Entity FQCNs to ignore.\nSchemaTool will then skip these (e.g. when comparing schemas).\n\n.. code-block:: php\n\n setSchemaIgnoreClasses([$fqcn]);\n $config->getSchemaIgnoreClasses();\n\n\nSetting up the Console\n----------------------\n\nDoctrine uses the Symfony Console component for generating the command\nline interface. You can take a look at the\n:doc:`tools chapter <../reference/tools>` for inspiration how to setup the cli.\n"
},
{
"path": "docs/en/reference/architecture.rst",
"content": "Architecture\n============\n\nThis chapter gives an overview of the overall architecture,\nterminology and constraints of Doctrine ORM. It is recommended to\nread this chapter carefully.\n\nUsing an Object-Relational Mapper\n---------------------------------\n\nAs the term ORM already hints at, Doctrine ORM aims to simplify the\ntranslation between database rows and the PHP object model. The\nprimary use case for Doctrine are therefore applications that\nutilize the Object-Oriented Programming Paradigm. For applications\nthat do not primarily work with objects Doctrine ORM is not suited very\nwell.\n\nRequirements\n------------\n\nDoctrine ORM requires a minimum of PHP 8.1. For greatly improved\nperformance it is also recommended that you use APC with PHP.\n\nDoctrine ORM Packages\n-------------------\n\nDoctrine ORM is divided into four main packages.\n\n- `Collections `_\n- `Event Manager `_\n- `Persistence `_\n- `DBAL `_\n- ORM (depends on DBAL+Persistence+Collections)\n\nThis manual mainly covers the ORM package, sometimes touching parts\nof the underlying DBAL and Persistence packages. The Doctrine codebase\nis split into these packages for a few reasons:\n\n\n- to make things more maintainable and decoupled\n- to allow you to use the code in Doctrine Persistence and Collections without the ORM or DBAL\n- to allow you to use the DBAL without the ORM\n\nCollection, Event Manager and Persistence\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nThe Collection, Event Manager and Persistence packages contain highly\nreusable components that have no dependencies beyond the packages\nthemselves (and PHP, of course). The root namespace of the Persistence\npackage is ``Doctrine\\Persistence``. The root namespace of the\nCollection package is ``Doctrine\\Common\\Collections``, for historical\nreasons. The root namespace of the Event Manager package is just\n``Doctrine\\Common``, also for historical reasons.\n\nThe DBAL Package\n~~~~~~~~~~~~~~~~\n\nThe DBAL package contains an enhanced database abstraction layer on\ntop of PDO but is not strongly bound to PDO. The purpose of this\nlayer is to provide a single API that bridges most of the\ndifferences between the different RDBMS vendors. The root namespace\nof the DBAL package is ``Doctrine\\DBAL``.\n\nThe ORM Package\n~~~~~~~~~~~~~~~\n\nThe ORM package contains the object-relational mapping toolkit that\nprovides transparent relational persistence for plain PHP objects.\nThe root namespace of the ORM package is ``Doctrine\\ORM``.\n\nTerminology\n-----------\n\n.. _terminology_entities:\n\nEntities\n~~~~~~~~\n\nAn entity is a lightweight, persistent domain object. An entity can\nbe any regular PHP class observing the following restrictions:\n\n- An entity class can be final or read-only when\n you use :ref:`native lazy objects `.\n It may contain final methods or read-only properties too.\n- Any two entity classes in a class hierarchy that inherit\n directly or indirectly from one another must not have a mapped\n property with the same name. That is, if B inherits from A then B\n must not have a mapped field with the same name as an already\n mapped field that is inherited from A.\n\nEntities support inheritance, polymorphic associations, and\npolymorphic queries. Both abstract and concrete classes can be\nentities. Entities may extend non-entity classes as well as entity\nclasses, and non-entity classes may extend entity classes.\n\n.. note::\n\n The constructor of an entity is only ever invoked when\n *you* construct a new instance with the *new* keyword. Doctrine\n never calls entity constructors, thus you are free to use them as\n you wish and even have it require arguments of any type.\n\nMapped Superclasses\n~~~~~~~~~~~~~~~~~~~\n\nA mapped superclass is an abstract or concrete class that provides\npersistent entity state and mapping information for its subclasses,\nbut which is not itself an entity.\n\nMapped superclasses are explained in greater detail in the chapter\non :doc:`inheritance mapping `.\n\nTransient Classes\n~~~~~~~~~~~~~~~~~\n\nThe term \"transient class\" appears in some places in the mapping\ndrivers as well as the code dealing with metadata handling.\n\nA transient class is a class that is neither an entity nor a mapped\nsuperclass. From the ORM's point of view, these classes can be\ncompletely ignored, and no class metadata is loaded for them at all.\n\nEntity states\n~~~~~~~~~~~~~\n\nAn entity instance can be characterized as being NEW, MANAGED,\nDETACHED or REMOVED.\n\n\n- A NEW entity instance has no persistent identity, and is not yet\n associated with an EntityManager and a UnitOfWork (i.e. those just\n created with the \"new\" operator).\n- A MANAGED entity instance is an instance with a persistent\n identity that is associated with an EntityManager and whose\n persistence is thus managed.\n- A DETACHED entity instance is an instance with a persistent\n identity that is not (or no longer) associated with an\n EntityManager and a UnitOfWork.\n- A REMOVED entity instance is an instance with a persistent\n identity, associated with an EntityManager, that will be removed\n from the database upon transaction commit.\n\n.. _architecture_persistent_fields:\n\nPersistent fields\n~~~~~~~~~~~~~~~~~\n\nThe persistent state of an entity is represented by instance\nvariables. An instance variable must be directly accessed only from\nwithin the methods of the entity by the entity instance itself.\nInstance variables must not be accessed by clients of the entity.\nThe state of the entity is available to clients only through the\nentity’s methods, i.e. accessor methods (getter/setter methods) or\nother business methods.\n\nCollection-valued persistent fields and properties must be defined\nin terms of the ``Doctrine\\Common\\Collections\\Collection``\ninterface. The collection implementation type may be used by the\napplication to initialize fields or properties before the entity is\nmade persistent. Once the entity becomes managed (or detached),\nsubsequent access must be through the interface type.\n\nSerializing entities\n~~~~~~~~~~~~~~~~~~~~\n\nSerializing entities can be problematic and is not really\nrecommended, at least not as long as an entity instance still holds\nreferences to proxy objects or is still managed by an EntityManager.\nBy default, serializing proxy objects does not initialize them. On\nunserialization, resulting objects are detached from the entity\nmanager and cannot be initialized anymore. You can implement the\n``__serialize()`` method if you want to change that behavior, but\nthen you need to ensure that you won't generate large serialized\nobject graphs and take care of circular associations.\n\nThe EntityManager\n~~~~~~~~~~~~~~~~~\n\nThe ``EntityManager`` class is a central access point to the\nfunctionality provided by Doctrine ORM. The ``EntityManager`` API is\nused to manage the persistence of your objects and to query for\npersistent objects.\n\nTransactional write-behind\n~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nAn ``EntityManager`` and the underlying ``UnitOfWork`` employ a\nstrategy called \"transactional write-behind\" that delays the\nexecution of SQL statements in order to execute them in the most\nefficient way and to execute them at the end of a transaction so\nthat all write locks are quickly released. You should see Doctrine\nas a tool to synchronize your in-memory objects with the database\nin well defined units of work. Work with your objects and modify\nthem as usual and when you're done call ``EntityManager#flush()``\nto make your changes persistent.\n\n.. _unit-of-work:\n\nThe Unit of Work\n~~~~~~~~~~~~~~~~\n\nInternally an ``EntityManager`` uses a ``UnitOfWork``, which is a\ntypical implementation of the\n`Unit of Work pattern `_,\nto keep track of all the things that need to be done the next time\n``flush`` is invoked. You usually do not directly interact with a\n``UnitOfWork`` but with the ``EntityManager`` instead.\n"
},
{
"path": "docs/en/reference/association-mapping.rst",
"content": "Association Mapping\n===================\n\nThis chapter explains mapping associations between objects.\n\nInstead of working with foreign keys in your code, you will always work with\nreferences to objects instead and Doctrine will convert those references\nto foreign keys internally.\n\n- A reference to a single object is represented by a foreign key.\n- A collection of objects is represented by many foreign keys pointing to the object holding the collection\n\nThis chapter is split into three different sections.\n\n- A list of all the possible association mapping use-cases is given.\n- :ref:`association_mapping_defaults` are explained that simplify the use-case examples.\n- :ref:`collections` are introduced that contain entities in associations.\n\nOne tip for working with relations is to read the relation from left to right, where the left word refers to the current Entity. For example:\n\n- OneToMany - One instance of the current Entity has Many instances (references) to the referred Entity.\n- ManyToOne - Many instances of the current Entity refer to One instance of the referred Entity.\n- OneToOne - One instance of the current Entity refers to One instance of the referred Entity.\n\nSee below for all the possible relations.\n\nAn association is considered to be unidirectional if only one side of the association has\na property referring to the other side.\n\nTo gain a full understanding of associations you should also read about :doc:`owning and\ninverse sides of associations `\n\nMany-To-One, Unidirectional\n---------------------------\n\nA many-to-one association is the most common association between objects. Example: Many Users have One Address:\n\n.. configuration-block::\n\n .. code-block:: attribute\n\n \n \n \n \n \n \n \n\n.. note::\n\n The above ``#[JoinColumn]`` is optional as it would default\n to ``address_id`` and ``id`` anyways. You can omit it and let it\n use the defaults.\n Likewise, inside the ``#[ManyToOne]`` attribute you can omit the\n ``targetEntity`` argument and it will default to ``Address``.\n\nGenerated MySQL Schema:\n\n.. code-block:: sql\n\n CREATE TABLE User (\n id INT AUTO_INCREMENT NOT NULL,\n address_id INT DEFAULT NULL,\n PRIMARY KEY(id)\n ) ENGINE = InnoDB;\n\n CREATE TABLE Address (\n id INT AUTO_INCREMENT NOT NULL,\n PRIMARY KEY(id)\n ) ENGINE = InnoDB;\n\n ALTER TABLE User ADD FOREIGN KEY (address_id) REFERENCES Address(id);\n\nOne-To-One, Unidirectional\n--------------------------\n\nHere is an example of a one-to-one association with a ``Product`` entity that\nreferences one ``Shipment`` entity.\n\n.. configuration-block::\n\n .. code-block:: attribute\n\n \n \n \n \n \n \n \n\nNote that the ``#[JoinColumn]`` is not really necessary in this example,\nas the defaults would be the same.\n\nGenerated MySQL Schema:\n\n.. code-block:: sql\n\n CREATE TABLE Product (\n id INT AUTO_INCREMENT NOT NULL,\n shipment_id INT DEFAULT NULL,\n UNIQUE INDEX UNIQ_6FBC94267FE4B2B (shipment_id),\n PRIMARY KEY(id)\n ) ENGINE = InnoDB;\n CREATE TABLE Shipment (\n id INT AUTO_INCREMENT NOT NULL,\n PRIMARY KEY(id)\n ) ENGINE = InnoDB;\n ALTER TABLE Product ADD FOREIGN KEY (shipment_id) REFERENCES Shipment(id);\n\nOne-To-One, Bidirectional\n-------------------------\n\nHere is a one-to-one relationship between a ``Customer`` and a\n``Cart``. The ``Cart`` has a reference back to the ``Customer`` so\nit is bidirectional.\n\nHere we see the ``mappedBy`` and ``inversedBy`` attributes for the first time.\nThey are used to tell Doctrine which property on the other side refers to the\nobject.\n\n.. configuration-block::\n\n .. code-block:: attribute\n\n \n \n \n \n \n \n \n \n \n \n\nNote that the @JoinColumn is not really necessary in this example,\nas the defaults would be the same.\n\nGenerated MySQL Schema:\n\n.. code-block:: sql\n\n CREATE TABLE Cart (\n id INT AUTO_INCREMENT NOT NULL,\n customer_id INT DEFAULT NULL,\n UNIQUE INDEX UNIQ_BA388B79395C3F3 (customer_id),\n PRIMARY KEY(id)\n ) ENGINE = InnoDB;\n CREATE TABLE Customer (\n id INT AUTO_INCREMENT NOT NULL,\n PRIMARY KEY(id)\n ) ENGINE = InnoDB;\n ALTER TABLE Cart ADD FOREIGN KEY (customer_id) REFERENCES Customer(id);\n\nWe had a choice of sides on which to place the ``inversedBy`` attribute. Because it\nis on the ``Cart``, that is the owning side of the relation, and thus holds the\nforeign key.\n\nOne-To-One, Self-referencing\n----------------------------\n\nYou can define a self-referencing one-to-one relationships like\nbelow.\n\n.. code-block:: php\n\n \n */\n #[OneToMany(targetEntity: Feature::class, mappedBy: 'product')]\n private Collection $features;\n // ...\n\n public function __construct() {\n $this->features = new ArrayCollection();\n }\n }\n\n #[Entity]\n class Feature\n {\n // ...\n /** Many features have one product. This is the owning side. */\n #[ManyToOne(targetEntity: Product::class, inversedBy: 'features')]\n #[JoinColumn(name: 'product_id', referencedColumnName: 'id')]\n private Product|null $product = null;\n // ...\n }\n\n .. code-block:: xml\n\n \n \n \n \n \n \n \n \n \n \n\nNote that the @JoinColumn is not really necessary in this example,\nas the defaults would be the same.\n\nGenerated MySQL Schema:\n\n.. code-block:: sql\n\n CREATE TABLE Product (\n id INT AUTO_INCREMENT NOT NULL,\n PRIMARY KEY(id)\n ) ENGINE = InnoDB;\n CREATE TABLE Feature (\n id INT AUTO_INCREMENT NOT NULL,\n product_id INT DEFAULT NULL,\n PRIMARY KEY(id)\n ) ENGINE = InnoDB;\n ALTER TABLE Feature ADD FOREIGN KEY (product_id) REFERENCES Product(id);\n\nOne-To-Many, Unidirectional with Join Table\n-------------------------------------------\n\nA unidirectional one-to-many association can be mapped through a\njoin table. From Doctrine's point of view, it is simply mapped as a\nunidirectional many-to-many whereby a unique constraint on one of\nthe join columns enforces the one-to-many cardinality.\n\nThe following example sets up such a unidirectional one-to-many association:\n\n.. configuration-block::\n\n .. code-block:: attribute\n\n \n */\n #[JoinTable(name: 'users_phonenumbers')]\n #[JoinColumn(name: 'user_id', referencedColumnName: 'id')]\n #[InverseJoinColumn(name: 'phonenumber_id', referencedColumnName: 'id', unique: true)]\n #[ManyToMany(targetEntity: 'Phonenumber')]\n private Collection $phonenumbers;\n\n public function __construct()\n {\n $this->phonenumbers = new ArrayCollection();\n }\n\n // ...\n }\n\n #[Entity]\n class Phonenumber\n {\n // ...\n }\n\n .. code-block:: xml\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\nGenerates the following MySQL Schema:\n\n.. code-block:: sql\n\n CREATE TABLE User (\n id INT AUTO_INCREMENT NOT NULL,\n PRIMARY KEY(id)\n ) ENGINE = InnoDB;\n\n CREATE TABLE users_phonenumbers (\n user_id INT NOT NULL,\n phonenumber_id INT NOT NULL,\n UNIQUE INDEX users_phonenumbers_phonenumber_id_uniq (phonenumber_id),\n PRIMARY KEY(user_id, phonenumber_id)\n ) ENGINE = InnoDB;\n\n CREATE TABLE Phonenumber (\n id INT AUTO_INCREMENT NOT NULL,\n PRIMARY KEY(id)\n ) ENGINE = InnoDB;\n\n ALTER TABLE users_phonenumbers ADD FOREIGN KEY (user_id) REFERENCES User(id);\n ALTER TABLE users_phonenumbers ADD FOREIGN KEY (phonenumber_id) REFERENCES Phonenumber(id);\n\nOne-To-Many, Self-referencing\n-----------------------------\n\nYou can also setup a one-to-many association that is\nself-referencing. In this example we setup a hierarchy of\n``Category`` objects by creating a self referencing relationship.\nThis effectively models a hierarchy of categories and from the\ndatabase perspective is known as an adjacency list approach.\n\n.. configuration-block::\n\n .. code-block:: attribute\n\n \n */\n #[OneToMany(targetEntity: Category::class, mappedBy: 'parent')]\n private Collection $children;\n\n /** Many Categories have One Category. */\n #[ManyToOne(targetEntity: Category::class, inversedBy: 'children')]\n #[JoinColumn(name: 'parent_id', referencedColumnName: 'id')]\n private Category|null $parent = null;\n // ...\n\n public function __construct() {\n $this->children = new ArrayCollection();\n }\n }\n\n .. code-block:: xml\n\n \n \n \n \n \n \n\nNote that the @JoinColumn is not really necessary in this example,\nas the defaults would be the same.\n\nGenerated MySQL Schema:\n\n.. code-block:: sql\n\n CREATE TABLE Category (\n id INT AUTO_INCREMENT NOT NULL,\n parent_id INT DEFAULT NULL,\n PRIMARY KEY(id)\n ) ENGINE = InnoDB;\n ALTER TABLE Category ADD FOREIGN KEY (parent_id) REFERENCES Category(id);\n\nMany-To-Many, Unidirectional\n----------------------------\n\nReal many-to-many associations are less common. The following\nexample shows a unidirectional association between User and Group\nentities:\n\n.. configuration-block::\n\n .. code-block:: attribute\n\n \n */\n #[JoinTable(name: 'users_groups')]\n #[JoinColumn(name: 'user_id', referencedColumnName: 'id')]\n #[InverseJoinColumn(name: 'group_id', referencedColumnName: 'id')]\n #[ManyToMany(targetEntity: Group::class)]\n private Collection $groups;\n\n // ...\n\n public function __construct() {\n $this->groups = new ArrayCollection();\n }\n }\n\n #[Entity]\n class Group\n {\n // ...\n }\n\n .. code-block:: xml\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\nGenerated MySQL Schema:\n\n.. code-block:: sql\n\n CREATE TABLE User (\n id INT AUTO_INCREMENT NOT NULL,\n PRIMARY KEY(id)\n ) ENGINE = InnoDB;\n CREATE TABLE users_groups (\n user_id INT NOT NULL,\n group_id INT NOT NULL,\n PRIMARY KEY(user_id, group_id)\n ) ENGINE = InnoDB;\n CREATE TABLE Group (\n id INT AUTO_INCREMENT NOT NULL,\n PRIMARY KEY(id)\n ) ENGINE = InnoDB;\n ALTER TABLE users_groups ADD FOREIGN KEY (user_id) REFERENCES User(id);\n ALTER TABLE users_groups ADD FOREIGN KEY (group_id) REFERENCES Group(id);\n\n.. note::\n\n Why are many-to-many associations less common? Because\n frequently you want to associate additional attributes with an\n association, in which case you introduce an association class.\n Consequently, the direct many-to-many association disappears and is\n replaced by one-to-many/many-to-one associations between the 3\n participating classes.\n\n.. note::\n\n For many-to-many associations, the ORM takes care of managing rows\n in the join table connecting both sides. Due to the way it deals\n with entity removals, database-level constraints may not work the\n way one might intuitively assume. Thus, be sure not to miss the section\n on :ref:`join table management `.\n\n\nMany-To-Many, Bidirectional\n---------------------------\n\nHere is a similar many-to-many relationship as above except this\none is bidirectional.\n\n.. configuration-block::\n\n .. code-block:: attribute\n\n \n */\n #[ManyToMany(targetEntity: Group::class, inversedBy: 'users')]\n #[JoinTable(name: 'users_groups')]\n private Collection $groups;\n\n public function __construct() {\n $this->groups = new ArrayCollection();\n }\n\n // ...\n }\n\n #[Entity]\n class Group\n {\n // ...\n /**\n * Many Groups have Many Users.\n * @var Collection\n */\n #[ManyToMany(targetEntity: User::class, mappedBy: 'groups')]\n private Collection $users;\n\n public function __construct() {\n $this->users = new ArrayCollection();\n }\n\n // ...\n }\n\n .. code-block:: xml\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n\n \n \n \n \n\nThe MySQL schema is exactly the same as for the Many-To-Many\nuni-directional case above.\n\n.. note::\n\n For many-to-many associations, the ORM takes care of managing rows\n in the join table connecting both sides. Due to the way it deals\n with entity removals, database-level constraints may not work the\n way one might intuitively assume. Thus, be sure not to miss the section\n on :ref:`join table management `.\n\n\nOwning and Inverse Side on a ManyToMany Association\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nFor Many-To-Many associations you can chose which entity is the\nowning and which the inverse side. There is a very simple semantic\nrule to decide which side is more suitable to be the owning side\nfrom a developers perspective. You only have to ask yourself which\nentity is responsible for the connection management, and pick that\nas the owning side.\n\nTake an example of two entities ``Article`` and ``Tag``. Whenever\nyou want to connect an Article to a Tag and vice-versa, it is\nmostly the Article that is responsible for this relation. Whenever\nyou add a new article, you want to connect it with existing or new\ntags. Your \"Create Article\" form will probably support this notion\nand allow specifying the tags directly. This is why you should pick\nthe Article as owning side, as it makes the code more\nunderstandable:\n\n.. code-block:: php\n\n addArticle($this); // synchronously updating inverse side\n $this->tags[] = $tag;\n }\n }\n\n class Tag\n {\n private Collection $articles;\n\n public function addArticle(Article $article): void\n {\n $this->articles[] = $article;\n }\n }\n\nThis allows to group the tag adding on the ``Article`` side of the\nassociation:\n\n.. code-block:: php\n\n addTag($tagA);\n $article->addTag($tagB);\n\nMany-To-Many, Self-referencing\n------------------------------\n\nYou can even have a self-referencing many-to-many association. A\ncommon scenario is where a ``User`` has friends and the target\nentity of that relationship is a ``User`` so it is self\nreferencing. In this example it is bidirectional so ``User`` has a\nfield named ``$friendsWithMe`` and ``$myFriends``.\n\n.. code-block:: php\n\n \n */\n #[ManyToMany(targetEntity: User::class, mappedBy: 'myFriends')]\n private Collection $friendsWithMe;\n\n /**\n * Many Users have many Users.\n * @var Collection\n */\n #[JoinTable(name: 'friends')]\n #[JoinColumn(name: 'user_id', referencedColumnName: 'id')]\n #[InverseJoinColumn(name: 'friend_user_id', referencedColumnName: 'id')]\n #[ManyToMany(targetEntity: 'User', inversedBy: 'friendsWithMe')]\n private Collection $myFriends;\n\n public function __construct() {\n $this->friendsWithMe = new ArrayCollection();\n $this->myFriends = new ArrayCollection();\n }\n\n // ...\n }\n\nGenerated MySQL Schema:\n\n.. code-block:: sql\n\n CREATE TABLE User (\n id INT AUTO_INCREMENT NOT NULL,\n PRIMARY KEY(id)\n ) ENGINE = InnoDB;\n CREATE TABLE friends (\n user_id INT NOT NULL,\n friend_user_id INT NOT NULL,\n PRIMARY KEY(user_id, friend_user_id)\n ) ENGINE = InnoDB;\n ALTER TABLE friends ADD FOREIGN KEY (user_id) REFERENCES User(id);\n ALTER TABLE friends ADD FOREIGN KEY (friend_user_id) REFERENCES User(id);\n\n.. _association_mapping_defaults:\n\nMapping Defaults\n----------------\n\nThe ``@JoinColumn`` and ``@JoinTable`` definitions are usually optional and have\nsensible default values. The defaults for a join column in a\none-to-one/many-to-one association is as follows:\n\n::\n\n name: \"_id\"\n referencedColumnName: \"id\"\n\nAs an example, consider this mapping:\n\n.. configuration-block::\n\n .. code-block:: attribute\n\n \n \n \n \n \n\nThis is essentially the same as the following, more verbose,\nmapping:\n\n.. configuration-block::\n\n .. code-block:: attribute\n\n \n \n \n \n \n \n \n\nThe @JoinTable definition used for many-to-many mappings has\nsimilar defaults. As an example, consider this mapping:\n\n.. configuration-block::\n\n .. code-block:: attribute\n\n */\n #[ManyToMany(targetEntity: Group::class)]\n private Collection $groups;\n // ...\n }\n\n .. code-block:: xml\n\n \n \n \n \n \n\nThis is essentially the same as the following, more verbose, mapping:\n\n.. configuration-block::\n\n .. code-block:: attribute\n\n \n */\n #[JoinTable(name: 'User_Group')]\n #[JoinColumn(name: 'user_id', referencedColumnName: 'id')]\n #[InverseJoinColumn(name: 'group_id', referencedColumnName: 'id')]\n #[ManyToMany(targetEntity: Group::class)]\n private Collection $groups;\n // ...\n }\n\n .. code-block:: xml\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\nIn that case, the name of the join table defaults to a combination\nof the simple, unqualified class names of the participating\nclasses, separated by an underscore character. The names of the\njoin columns default to the simple, unqualified class name of the\ntargeted class followed by \"\\_id\". The referencedColumnName always\ndefaults to \"id\", just as in one-to-one or many-to-one mappings.\n\nAdditionally, when using typed properties with Doctrine 2.9 or newer\nyou can skip ``targetEntity`` in ``ManyToOne`` and ``OneToOne``\nassociations as they will be set based on type. So that:\n\n.. configuration-block::\n\n .. code-block:: attribute\n\n \n \n \n \n \n\nIs essentially the same as following:\n\n.. configuration-block::\n\n .. code-block:: attribute\n\n \n \n \n \n \n \n \n\nIf you accept these defaults, you can reduce the mapping code to a\nminimum.\n\n.. _collections:\n\nCollections\n-----------\n\nUnfortunately, PHP arrays, while being great for many things, are missing\nfeatures that make them suitable for lazy loading in the context of an ORM.\nThis is why in all the examples of many-valued associations in this manual we\nwill make use of a ``Collection`` interface and its\ndefault implementation ``ArrayCollection`` that are both defined in the\n``Doctrine\\Common\\Collections`` namespace. A collection implements\nthe PHP interfaces ``ArrayAccess``, ``Traversable`` and ``Countable``.\n\n.. note::\n\n The Collection interface and ArrayCollection class,\n like everything else in the Doctrine namespace, are neither part of\n the ORM, nor the DBAL, it is a plain PHP class that has no outside\n dependencies apart from dependencies on PHP itself (and the SPL).\n Therefore using this class in your model and elsewhere\n does not introduce a coupling to the ORM.\n\nInitializing Collections\n------------------------\n\nYou should always initialize the collections of your ``@OneToMany``\nand ``@ManyToMany`` associations in the constructor of your entities:\n\n.. code-block:: php\n\n groups = new ArrayCollection();\n }\n\n public function getGroups(): Collection\n {\n return $this->groups;\n }\n }\n\nThe following code will then work even if the Entity hasn't\nbeen associated with an EntityManager yet:\n\n.. code-block:: php\n\n getGroups()->add($group);\n"
},
{
"path": "docs/en/reference/attributes-reference.rst",
"content": "Attributes Reference\n====================\n\nPHP 8 adds native support for metadata with its \"Attributes\" feature.\nDoctrine ORM provides support for mapping metadata using PHP attributes as of version 2.9.\n\nThe attributes metadata support is closely modelled after the already\nexisting and now removed annotation metadata supported since the first\nversion 2.0.\n\nIndex\n-----\n\n- :ref:`#[AssociationOverride] `\n- :ref:`#[AttributeOverride] `\n- :ref:`#[Column] `\n- :ref:`#[Cache] `\n- :ref:`#[ChangeTrackingPolicy] `\n- :ref:`#[CustomIdGenerator] `\n- :ref:`#[DiscriminatorColumn] `\n- :ref:`#[DiscriminatorMap] `\n- :ref:`#[Embeddable] `\n- :ref:`#[Embedded] `\n- :ref:`#[Entity] `\n- :ref:`#[GeneratedValue] `\n- :ref:`#[HasLifecycleCallbacks] `\n- :ref:`#[Index] `\n- :ref:`#[Id] `\n- :ref:`#[InheritanceType] `\n- :ref:`#[JoinColumn] `\n- :ref:`#[JoinTable] `\n- :ref:`#[ManyToOne] `\n- :ref:`#[ManyToMany] `\n- :ref:`#[MappedSuperclass] `\n- :ref:`#[OneToOne] `\n- :ref:`#[OneToMany] `\n- :ref:`#[OrderBy] `\n- :ref:`#[PostLoad] `\n- :ref:`#[PostPersist] `\n- :ref:`#[PostRemove] `\n- :ref:`#[PostUpdate] `\n- :ref:`#[PrePersist] `\n- :ref:`#[PreRemove] `\n- :ref:`#[PreUpdate] `\n- :ref:`#[SequenceGenerator] `\n- :ref:`#[Table] `\n- :ref:`#[UniqueConstraint] `\n- :ref:`#[Version] `\n\n\nReference\n---------\n\n.. _attrref_associationoverride:\n\n#[AssociationOverride]\n~~~~~~~~~~~~~~~~~~~~~~\n\nIn an inheritance hierarchy this attribute allows to override the\nassocation mapping definitions of the parent mappings. It needs to be nested\nwithin a ``#[AssociationOverrides]`` on the class level.\n\nRequired parameters:\n\n- **name**: Name of the association mapping to overwrite.\n\nOptional parameters:\n\n- **joinColumns**: A list of nested ``#[JoinColumn]`` declarations.\n- **joinTable**: A nested ``#[JoinTable]`` declaration in case of a many-to-many overwrite.\n- **inversedBy**: The name of the inversedBy field on the target entity side.\n- **fetch**: The fetch strategy, one of: EAGER, LAZY, EXTRA_LAZY.\n\nExamples:\n\n.. code-block:: php\n\n `.\n If not specified, default value is ``false``.\n\n- **nullable**: Determines if NULL values allowed for this column.\n If not specified, default value is ``false``.\n\n- **insertable**: Boolean value to determine if the column should be\n included when inserting a new row into the underlying entities table.\n If not specified, default value is true.\n\n- **updatable**: Boolean value to determine if the column should be\n included when updating the row of the underlying entities table.\n If not specified, default value is true.\n\n- **generated**: An enum with the possible values ALWAYS, INSERT, NEVER. Is\n used after an INSERT or UPDATE statement to determine if the database\n generated this value and it needs to be fetched using a SELECT statement.\n\n- **options**: Array of additional options:\n\n - ``default``: The default value to set for the column if no value\n is supplied.\n\n - ``unsigned``: Boolean value to determine if the column should\n be capable of representing only non-negative integers\n (applies only for integer column and might not be supported by\n all vendors).\n\n - ``fixed``: Boolean value to determine if the specified length of\n a string column should be fixed or varying (applies only for\n string/binary column and might not be supported by all vendors).\n\n - ``comment``: The comment of the column in the schema (might not\n be supported by all vendors).\n\n - ``charset``: The charset of the column (only supported by Mysql, PostgreSQL, Sqlite and SQLServer).\n\n - ``collation``: The collation of the column (only supported by Mysql, PostgreSQL, Sqlite and SQLServer).\n\n - ``check``: Adds a check constraint type to the column (might not\n be supported by all vendors).\n\n- **columnDefinition**: Specify the DDL SQL snippet that starts after the column\n name and specifies the complete (non-portable!) column definition.\n This attribute allows to make use of advanced RMDBS features.\n However, as this needs to be specified in the DDL native to the database,\n the resulting schema changes are no longer portable. If you specify a\n ``columnDefinition``, the ``SchemaTool`` ignores all other attributes\n that are normally used to build the definition DDL. Changes to the\n ``columnDefinition`` are not detected, you will need to manually create a\n migration to apply changes.\n\n Additionally you should remember that the ``type``\n attribute still handles the conversion between PHP and Database\n values. If you use this attribute on a column that is used for\n joins between tables you should also take a look at\n :ref:`#[JoinColumn] `.\n\n.. note::\n\n For more detailed information on each attribute, please refer to\n the DBAL ``Schema-Representation`` documentation.\n\nExamples:\n\n.. code-block:: php\n\n true,\n \"comment\" => \"Initial letters of first and last name\"\n ])]\n protected $initials;\n\n #[Column(\n type: \"integer\",\n name: \"login_count\",\n nullable: false,\n options: [\"unsigned\" => true, \"default\" => 0]\n )]\n protected $loginCount;\n\n // columnDefinition is raw SQL, not DQL. This example works for MySQL:\n #[Column(\n type: \"string\",\n name: \"user_fullname\",\n columnDefinition: \"VARCHAR(255) GENERATED ALWAYS AS (concat(firstname,' ',lastname))\",\n insertable: false,\n updatable: false\n )]\n protected $fullname;\n\n.. _attrref_cache:\n\n#[Cache]\n~~~~~~~~\nAdd caching strategy to a root entity or a collection.\n\nOptional parameters:\n\n- **usage**: One of ``READ_ONLY``, ``READ_WRITE`` or ``NONSTRICT_READ_WRITE``, By default this is ``READ_ONLY``.\n- **region**: An specific region name\n\n.. _attrref_changetrackingpolicy:\n\n#[ChangeTrackingPolicy]\n~~~~~~~~~~~~~~~~~~~~~~~\n\nThe Change Tracking Policy attribute allows to specify how the\nDoctrine ORM ``UnitOfWork`` should detect changes in properties of\nentities during flush. By default each entity is checked according\nto a deferred implicit strategy, which means upon flush ``UnitOfWork``\ncompares all the properties of an entity to a previously stored\nsnapshot. This works out of the box, however you might want to\ntweak the flush performance where using another change tracking\npolicy is an interesting option.\n\nThe :doc:`details on all the available change tracking policies `\ncan be found in the configuration section.\n\nExample:\n\n.. code-block:: php\n\n ` and :ref:`#[GeneratedValue(strategy: \"CUSTOM\")] ` are specified.\n\nRequired parameters:\n\n- **class**: name of the class which should extend Doctrine\\ORM\\Id\\AbstractIdGenerator\n\nExample:\n\n.. code-block:: php\n\n `\n- **enumType**: By default this is `null`. Allows to map discriminatorColumn value to PHP enum\n- **options**: See \"options\" attribute on :ref:`#[Column] `.\n\n.. _attrref_discriminatormap:\n\n#[DiscriminatorMap]\n~~~~~~~~~~~~~~~~~~~\n\nThe discriminator map is a required attribute on the\nroot entity class in an inheritance hierarchy. Its only argument is an\narray which defines which class should be saved under\nwhich name in the database. Keys are the database value and values\nare the classes, either as fully- or as unqualified class names\ndepending on whether the classes are in the namespace or not.\n\n.. code-block:: php\n\n Person::class, \"employee\" => Employee::class])]\n class Person\n {\n // ...\n }\n\n\n.. _attrref_embeddable:\n\n#[Embeddable]\n~~~~~~~~~~~~~\n\nThe embeddable attribute is required on a class, in order to make it\nembeddable inside an entity. It works together with the :ref:`#[Embedded] `\nattribute to establish the relationship between the two classes.\n\n.. code-block:: php\n\n `. This\nattribute is optional and only has meaning when used in\nconjunction with #[Id].\n\nIf this attribute is not specified with ``#[Id]`` the ``NONE`` strategy is\nused as default.\n\nOptional parameters:\n\n- **strategy**: Set the name of the identifier generation strategy.\n Valid values are ``AUTO``, ``SEQUENCE``, ``IDENTITY``, ``CUSTOM`` and\n ``NONE``. If not specified, the default value is ``AUTO``.\n\nExample:\n\n.. code-block:: php\n\n \"((category IS NOT NULL))\"\n ]\n )]\n class ECommerceProduct\n {\n }\n\n.. _attrref_id:\n\n#[Id]\n~~~~~\n\nThe annotated instance variable will be marked as entity\nidentifier, the primary key in the database. This attribute is a\nmarker only and has no required or optional attributes. For\nentities that have multiple identifier columns each column has to\nbe marked with ``#[Id]``.\n\nExample:\n\n.. code-block:: php\n\n ` and\n:ref:`#[DiscriminatorColumn] ` attributes.\n\nExamples:\n\n.. code-block:: php\n\n \"Person\", \"employee\" => \"Employee\"])]\n class Person\n {\n // ...\n }\n\n #[Entity]\n #[InheritanceType(\"JOINED\")]\n #[DiscriminatorColumn(name: \"discr\", type: \"string\")]\n #[DiscriminatorMap([\"person\" => \"Person\", \"employee\" => \"Employee\"])]\n class Person\n {\n // ...\n }\n\n.. _attrref_joincolumn:\n\n#[JoinColumn], #[InverseJoinColumn]\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nThis attribute is used in the context of relations in\n:ref:`#[ManyToOne] `, :ref:`#[OneToOne] ` fields\nand in the Context of a :ref:`#[ManyToMany] `. If this attribute or both *name* and *referencedColumnName*\nare missing they will be computed considering the field's name and the current\n:doc:`naming strategy `.\n\nOptional parameters:\n\n- **name**: Column name that holds the foreign key identifier for\n this relation. In the context of ``#[JoinTable]`` it specifies the column\n name in the join table.\n- **referencedColumnName**: Name of the primary key identifier that\n is used for joining of this relation. Defaults to ``id``.\n- **unique**: Determines whether this relation is exclusive between the\n affected entities and should be enforced as such on the database\n constraint level. Defaults to false.\n- **deferrable**: Determines whether this relation constraint can be deferred. Defaults to false.\n- **nullable**: Determine whether the related entity is required, or if\n null is an allowed state for the relation. Defaults to true.\n- **onDelete**: Cascade Action (Database-level)\n- **columnDefinition**: DDL SQL snippet that starts after the column\n name and specifies the complete (non-portable!) column definition.\n This attribute enables the use of advanced RMDBS features. Note that you\n need to reference columns by their database name (either explicitly set in\n the mapping or per the current :doc:`naming strategy `).\n Using this attribute on ``#[JoinColumn]`` is necessary if you need\n different column definitions for joining columns, for example\n regarding NULL/NOT NULL defaults. However by default a\n \"columnDefinition\" attribute on :ref:`#[Column] ` also sets\n the related ``#[JoinColumn]``'s columnDefinition. This is necessary to\n make foreign keys work.\n- **options**:\n See \"options\" attribute on :ref:`#[Column] `.\n\nExample:\n\n.. code-block:: php\n\n ` on the owning side of the relation\nrequires to specify the #[JoinTable] attribute which describes the\ndetails of the database join table. If you do not specify\n``#[JoinTable]`` on these relations reasonable mapping defaults apply\nusing the affected table and the column names.\n\nRequired attribute:\n\n- **name**: Database name of the join-table\n\nExample:\n\n.. code-block:: php\n\n ` is an\nadditional, optional attribute that has reasonable default\nconfiguration values using the table and names of the two related\nentities.\n\nRequired parameters:\n\n\n- **targetEntity**: FQCN of the referenced target entity. Can be the\n unqualified class name if both classes are in the same namespace.\n *IMPORTANT:* No leading backslash!\n\nOptional parameters:\n\n\n- **mappedBy**: This option specifies the property name on the\n targetEntity that is the owning side of this relation. It is a\n required attribute for the inverse side of a relationship.\n- **inversedBy**: The inversedBy attribute designates the field in the\n entity that is the inverse side of the relationship.\n- **cascade**: Cascade Option\n- **fetch**: One of ``LAZY``, ``EXTRA_LAZY`` or ``EAGER``\n- **indexBy**: Index the collection by a field on the target entity.\n\n.. note::\n\n For ``ManyToMany`` bidirectional relationships either side may\n be the owning side (the side that defines the ``#[JoinTable]`` and/or\n does not make use of the mappedBy attribute, thus using a default\n join table).\n\nExample:\n\n.. code-block:: php\n\n `.\n\nOptional parameters:\n\n- **repositoryClass**: Specifies the FQCN of a subclass of the EntityRepository.\n That will be inherited for all subclasses of that Mapped Superclass.\n\nExample:\n\n.. code-block:: php\n\n ` with one additional option which can\nbe specified. When no\n:ref:`#[JoinColumn] ` is specified it defaults to using the target entity table and\nprimary key column names and the current naming strategy to determine a name for the join column.\n\nRequired parameters:\n\n- **targetEntity**: FQCN of the referenced target entity. Can be the\n unqualified class name if both classes are in the same namespace.\n *IMPORTANT:* No leading backslash!\n\nOptional parameters:\n\n- **cascade**: Cascade Option\n- **fetch**: One of LAZY or EAGER\n- **orphanRemoval**: Boolean that specifies if orphans, inverse\n OneToOne entities that are not connected to any owning instance,\n should be removed by Doctrine. Defaults to false.\n- **inversedBy**: The inversedBy attribute designates the field in the\n entity that is the inverse side of the relationship.\n\nExample:\n\n.. code-block:: php\n\n ` or :ref:`#[OneToMany] `\nattribute to specify by which criteria the collection should be\nretrieved from the database by using an ORDER BY clause.\n\nExample:\n\n.. code-block:: php\n\n \"ASC\"])]\n private $groups;\n\nThe key in ``OrderBy`` is only allowed to consist of\nunqualified, unquoted field names and of an optional ``ASC``/``DESC``\npositional statement. Multiple Fields are separated by a comma (,).\nThe referenced field names have to exist on the ``targetEntity``\nclass of the ``#[ManyToMany]`` or ``#[OneToMany]`` attribute.\n\n.. _attrref_postload:\n\n#[PostLoad]\n~~~~~~~~~~~~~~\n\nMarks a method on the entity to be called as a ``#[PostLoad]`` event.\nOnly works with ``#[HasLifecycleCallbacks]`` in the entity class PHP\nlevel.\n\n.. _attrref_postpersist:\n\n#[PostPersist]\n~~~~~~~~~~~~~~\n\nMarks a method on the entity to be called as a ``#[PostPersist]`` event.\nOnly works with ``#[HasLifecycleCallbacks]`` in the entity class PHP\nlevel.\n\n.. _attrref_postremove:\n\n#[PostRemove]\n~~~~~~~~~~~~~~\n\nMarks a method on the entity to be called as a ``#[PostRemove]`` event.\nOnly works with ``#[HasLifecycleCallbacks]`` in the entity class PHP\nlevel.\n\n.. _attrref_postupdate:\n\n#[PostUpdate]\n~~~~~~~~~~~~~~\n\nMarks a method on the entity to be called as a ``#[PostUpdate]`` event.\nOnly works with ``#[HasLifecycleCallbacks]`` in the entity class PHP\nlevel.\n\n.. _attrref_prepersist:\n\n#[PrePersist]\n~~~~~~~~~~~~~~\n\nMarks a method on the entity to be called as a ``#[PrePersist]`` event.\nOnly works with ``#[HasLifecycleCallbacks]`` in the entity class PHP\nlevel.\n\n.. _attrref_preremove:\n\n#[PreRemove]\n~~~~~~~~~~~~~~\n\nMarks a method on the entity to be called as a #``[PreRemove]`` event.\nOnly works with ``#[HasLifecycleCallbacks]`` in the entity class PHP\nlevel.\n\n.. _attrref_preupdate:\n\n#[PreUpdate]\n~~~~~~~~~~~~~~\n\nMarks a method on the entity to be called as a ``#[PreUpdate]`` event.\nOnly works with ``#[HasLifecycleCallbacks]`` in the entity class PHP\nlevel.\n\n.. _attrref_sequencegenerator:\n\n#[SequenceGenerator]\n~~~~~~~~~~~~~~~~~~~~~\n\nFor use with ``#[GeneratedValue(strategy: \"SEQUENCE\")]`` this\nattribute allows to specify details about the sequence, such as\nthe increment size and initial values of the sequence.\n\nRequired parameters:\n\n- **sequenceName**: Name of the sequence\n\nOptional parameters:\n\n- **allocationSize**: Increment the sequence by the allocation size\n when its fetched. A value larger than 1 allows optimization for\n scenarios where you create more than one new entity per request.\n Defaults to 10\n- **initialValue**: Where the sequence starts, defaults to 1.\n\nExample:\n\n.. code-block:: php\n\n `\nscenario. It only works on :ref:`#[Column] ` attributes that have\nthe type ``integer`` or ``datetime``. Setting ``#[Version]`` on a property with\n:ref:`#[Id] ` is not supported.\n\nExample:\n\n.. code-block:: php\n\n 'Hello World!'])]\n private string $text;\n\n #[Column(options: ['default' => new CurrentTimestamp()], insertable: false, updatable: false)]\n private DateTime $createdAt;\n}\n"
},
{
"path": "docs/en/reference/basic-mapping/default-values.xml",
"content": "\n \n \n \n \n \n \n \n \n \n \n \n \n\n"
},
{
"path": "docs/en/reference/basic-mapping.rst",
"content": "Basic Mapping\n=============\n\nThis guide explains the basic mapping of entities and properties.\nAfter working through this guide you should know:\n\n- How to create PHP objects that can be saved to the database with Doctrine;\n- How to configure the mapping between columns on tables and properties on\n entities;\n- What Doctrine mapping types are;\n- Defining primary keys and how identifiers are generated by Doctrine;\n- How quoting of reserved symbols works in Doctrine.\n\nMapping of associations will be covered in the next chapter on\n:doc:`Association Mapping `.\n\nCreating Classes for the Database\n---------------------------------\n\nEvery PHP object that you want to save in the database using Doctrine\nis called an *Entity*. The term \"Entity\" describes objects\nthat have an identity over many independent requests. This identity is\nusually achieved by assigning a unique identifier to an entity.\nIn this tutorial the following ``Message`` PHP class will serve as the\nexample Entity:\n\n.. code-block:: php\n\n `\n- :doc:`XML `\n- :doc:`PHP code `\n\nThis manual will usually show mapping metadata via attributes, though\nmany examples also show the equivalent configuration in XML.\n\n.. note::\n\n All metadata drivers perform equally. Once the metadata of a class has been\n read from the source (attributes, XML, etc.) it is stored in an instance\n of the ``Doctrine\\ORM\\Mapping\\ClassMetadata`` class which are\n stored in the metadata cache. If you're not using a metadata cache (not\n recommended!) then the XML driver is the fastest.\n\nMarking our ``Message`` class as an entity for Doctrine is straightforward:\n\n.. configuration-block::\n\n .. code-block:: attribute\n\n \n \n \n \n \n\nWith no additional information, Doctrine expects the entity to be saved\ninto a table with the same name as the class in our case ``Message``.\nYou can change this by configuring information about the table:\n\n.. configuration-block::\n\n .. code-block:: attribute\n\n \n \n \n \n \n\nNow the class ``Message`` will be saved and fetched from the table ``message``.\n\nProperty Mapping\n----------------\n\nThe next step is mapping its properties to columns in the table.\n\nTo configure a property use the ``Column`` attribute. The ``type``\nargument specifies the :ref:`Doctrine Mapping Type\n` to use for the field. If the type is not\nspecified, ``string`` is used as the default.\n\n.. configuration-block::\n\n .. code-block:: attribute\n\n \n \n \n \n \n \n \n\nWhen we don't explicitly specify a column name via the ``name`` option, Doctrine\nassumes the field name is also the column name. So in this example:\n\n* the ``id`` property will map to the column ``id`` using the type ``integer``;\n* the ``text`` property will map to the column ``text`` with the default mapping type ``string``;\n* the ``postedAt`` property will map to the ``posted_at`` column with the ``datetime`` type.\n\nHere is a complete list of ``Column``s attributes (all optional):\n\n- ``type`` (default: 'string'): The mapping type to use for the column.\n- ``name`` (default: name of property): The name of the column in the database.\n- ``length`` (default: 255): The length of the column in the database.\n Applies only if a string-valued column is used.\n- ``unique`` (default: ``false``): Whether the column is a unique key.\n- ``nullable`` (default: ``false``): Whether the column is nullable.\n- ``insertable`` (default: ``true``): Whether the column should be inserted.\n- ``updatable`` (default: ``true``): Whether the column should be updated.\n- ``generated`` (default: ``null``): Whether the generated strategy should be ``'NEVER'``, ``'INSERT'`` and ``ALWAYS``.\n- ``enumType`` (requires PHP 8.1 and ``doctrine/orm`` 2.11): The PHP enum class name to convert the database value into.\n- ``precision`` (default: 0): The precision for a decimal (exact numeric) column\n (applies only for decimal column),\n which is the maximum number of digits that are stored for the values.\n- ``scale`` (default: 0): The scale for a decimal (exact\n numeric) column (applies only for decimal column), which represents\n the number of digits to the right of the decimal point and must\n not be greater than ``precision``.\n- ``columnDefinition``: Allows to define a custom\n DDL snippet that is used to create the column. Warning: This normally\n confuses the :doc:`SchemaTool ` to always detect the column as changed.\n- ``options``: Key-value pairs of options that get passed\n to the underlying database platform when generating DDL statements.\n\nSpecifying default values\n~~~~~~~~~~~~~~~~~~~~~~~~~\n\nWhile it is possible to specify default values for properties in your\nPHP class, Doctrine also allows you to specify default values for\ndatabase columns using the ``default`` key in the ``options`` array of\nthe ``Column`` attribute.\n\nWhen using XML, you can specify object instances using the ``` section on\ndetails how to iterate large result sets.\n\nFunctions\n~~~~~~~~~\n\nThe following methods exist on the ``AbstractQuery`` which both\n``Query`` and ``NativeQuery`` extend from.\n\nParameters\n^^^^^^^^^^\n\nPrepared Statements that use numerical or named wildcards require\nadditional parameters to be executable against the database. To\npass parameters to the query the following methods can be used:\n\n\n- ``AbstractQuery::setParameter($param, $value)`` - Set the\n numerical or named wildcard to the given value.\n- ``AbstractQuery::setParameters(array $params)`` - Set an array\n of parameter key-value pairs.\n- ``AbstractQuery::getParameter($param)``\n- ``AbstractQuery::getParameters()``\n\nBoth named and positional parameters are passed to these methods without their ? or : prefix.\n\nCache related API\n^^^^^^^^^^^^^^^^^\n\nYou can cache query results based either on all variables that\ndefine the result (SQL, Hydration Mode, Parameters and Hints) or on\nuser-defined cache keys. However by default query results are not\ncached at all. You have to enable the result cache on a per query\nbasis. The following example shows a complete workflow using the\nResult Cache API:\n\n.. code-block:: php\n\n createQuery('SELECT u FROM MyProject\\Model\\User u WHERE u.id = ?1');\n $query->setParameter(1, 12);\n\n $query->setResultCacheDriver(new ApcCache());\n\n $query->enableResultCache(3600);\n\n $result = $query->getResult(); // cache miss\n\n $query->expireResultCache(true);\n $result = $query->getResult(); // forced expire, cache miss\n\n $query->setResultCacheId('my_query_result');\n $result = $query->getResult(); // saved in given result cache id.\n\n // or call enableResultCache() with all parameters:\n $query->enableResultCache(3600, 'my_query_result');\n $result = $query->getResult(); // cache hit!\n\n // Introspection\n $queryCacheProfile = $query->getQueryCacheProfile();\n $cacheDriver = $query->getResultCacheDriver();\n $lifetime = $query->getLifetime();\n $key = $query->getCacheKey();\n\n.. note::\n\n You can set the Result Cache Driver globally on the\n ``Doctrine\\ORM\\Configuration`` instance so that it is passed to\n every ``Query`` and ``NativeQuery`` instance.\n\n\nQuery Hints\n^^^^^^^^^^^\n\nYou can pass hints to the query parser and hydrators by using the\n``AbstractQuery::setHint($name, $value)`` method. Currently there\nexist mostly internal query hints that are not be consumed in\nuserland. However the following few hints are to be used in\nuserland:\n\n\n- ``Query::HINT_FORCE_PARTIAL_LOAD`` - Allows to hydrate objects\n although not all their columns are fetched. This query hint can be\n used to handle memory consumption problems with large result-sets\n that contain char or binary data. Doctrine has no way of implicitly\n reloading this data. Partially loaded objects have to be passed to\n ``EntityManager::refresh()`` if they are to be reloaded fully from\n the database. This query hint is deprecated and will be removed\n in the future (\\ `Details `_)\n- ``Query::HINT_REFRESH`` - This query is used internally by\n ``EntityManager::refresh()`` and can be used in userland as well.\n If you specify this hint and a query returns the data for an entity\n that is already managed by the UnitOfWork, the fields of the\n existing entity will be refreshed. In normal operation a result-set\n that loads data of an already existing entity is discarded in favor\n of the already existing entity.\n- ``Query::HINT_CUSTOM_TREE_WALKERS`` - An array of additional\n ``Doctrine\\ORM\\Query\\TreeWalker`` instances that are attached to\n the DQL query parsing process.\n\nQuery Cache (DQL Query Only)\n^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n\nParsing a DQL query and converting it into a SQL query against the\nunderlying database platform obviously has some overhead in\ncontrast to directly executing Native SQL queries. That is why\nthere is a dedicated Query Cache for caching the DQL parser\nresults. In combination with the use of wildcards you can reduce\nthe number of parsed queries in production to zero.\n\nThe Query Cache Driver is passed from the\n``Doctrine\\ORM\\Configuration`` instance to each\n``Doctrine\\ORM\\Query`` instance by default and is also enabled by\ndefault. This also means you don't regularly need to fiddle with\nthe parameters of the Query Cache, however if you do there are\nseveral methods to interact with it:\n\n\n- ``Query::setQueryCacheDriver($driver)`` - Allows to set a Cache\n instance\n- ``Query::setQueryCacheLifeTime($seconds)`` - Set lifetime\n of the query caching.\n- ``Query::expireQueryCache($bool)`` - Enforce the expiring of the\n query cache if set to true.\n- ``Query::getExpireQueryCache()``\n- ``Query::getQueryCacheDriver()``\n- ``Query::getQueryCacheLifeTime()``\n\nFirst and Max Result Items (DQL Query Only)\n^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n\nYou can limit the number of results returned from a DQL query as\nwell as specify the starting offset, Doctrine then uses a strategy\nof manipulating the select query to return only the requested\nnumber of results:\n\n\n- ``Query::setMaxResults($maxResults)``\n- ``Query::setFirstResult($offset)``\n\n.. note::\n\n If your query contains a fetch-joined collection\n specifying the result limit methods are not working as you would\n expect. Set Max Results restricts the number of database result\n rows, however in the case of fetch-joined collections one root\n entity might appear in many rows, effectively hydrating less than\n the specified number of results.\n\n.. _dql-temporarily-change-fetch-mode:\n\nTemporarily change fetch mode in DQL\n^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n\nWhile normally all your associations are marked as lazy or extra lazy you will have cases where you are using DQL and don't want to\nfetch join a second, third or fourth level of entities into your result, because of the increased cost of the SQL JOIN. You\ncan mark a many-to-one or one-to-one association as fetched temporarily to batch fetch these entities using a WHERE .. IN query.\n\n.. code-block:: php\n\n createQuery(\"SELECT u FROM MyProject\\User u\");\n $query->setFetchMode(\"MyProject\\User\", \"address\", \\Doctrine\\ORM\\Mapping\\ClassMetadata::FETCH_EAGER);\n $query->execute();\n\nGiven that there are 10 users and corresponding addresses in the database the executed queries will look something like:\n\n.. code-block:: sql\n\n SELECT * FROM users;\n SELECT * FROM address WHERE id IN (1, 2, 3, 4, 5, 6, 7, 8, 9, 10);\n\n.. note::\n Changing the fetch mode during a query mostly makes sense for one-to-one and many-to-one relations. In that case,\n all the necessary IDs are available after the root entity (``user`` in the above example) has been loaded. So, one\n query per association can be executed to fetch all the referred-to entities (``address``).\n\n For one-to-many relations, changing the fetch mode to eager will cause to execute one query **for every root entity\n loaded**. This gives no improvement over the ``lazy`` fetch mode which will also initialize the associations on\n a one-by-one basis once they are accessed.\n\n\n.. _dql_ebnf_grammar:\n\nEBNF\n----\n\nThe following context-free grammar, written in an EBNF variant,\ndescribes the Doctrine Query Language. You can consult this grammar\nwhenever you are unsure about what is possible with DQL or what the\ncorrect syntax for a particular query should be.\n\nDocument syntax:\n~~~~~~~~~~~~~~~~\n\n\n- non-terminals begin with an upper case character\n- terminals begin with a lower case character\n- parentheses (...) are used for grouping\n- square brackets [...] are used for defining an optional part,\n e.g. zero or one time\n- curly brackets {...} are used for repetition, e.g. zero or more\n times\n- double quotation marks \"...\" define a terminal string\n- a vertical bar \\| represents an alternative\n\nTerminals\n~~~~~~~~~\n\n\n- identifier (name, email, ...) must match ``[a-z_][a-z0-9_]*``\n- fully_qualified_name (Doctrine\\Tests\\Models\\CMS\\CmsUser) matches PHP's fully qualified class names\n- string ('foo', 'bar''s house', '%ninja%', ...)\n- char ('/', '\\\\', ' ', ...)\n- integer (-1, 0, 1, 34, ...)\n- float (-0.23, 0.007, 1.245342E+8, ...)\n- boolean (false, true)\n\nQuery Language\n~~~~~~~~~~~~~~\n\n.. code-block:: php\n\n QueryLanguage ::= SelectStatement | UpdateStatement | DeleteStatement\n\nStatements\n~~~~~~~~~~\n\n.. code-block:: php\n\n SelectStatement ::= SelectClause FromClause [WhereClause] [GroupByClause] [HavingClause] [OrderByClause]\n UpdateStatement ::= UpdateClause [WhereClause]\n DeleteStatement ::= DeleteClause [WhereClause]\n\nIdentifiers\n~~~~~~~~~~~\n\n.. code-block:: php\n\n /* Alias Identification usage (the \"u\" of \"u.name\") */\n IdentificationVariable ::= identifier\n\n /* Alias Identification declaration (the \"u\" of \"FROM User u\") */\n AliasIdentificationVariable :: = identifier\n\n /* identifier that must be a class name (the \"User\" of \"FROM User u\"), possibly as a fully qualified class name */\n AbstractSchemaName ::= fully_qualified_name | identifier\n\n /* Alias ResultVariable declaration (the \"total\" of \"COUNT(*) AS total\") */\n AliasResultVariable = identifier\n\n /* ResultVariable identifier usage of mapped field aliases (the \"total\" of \"COUNT(*) AS total\") */\n ResultVariable = identifier\n\n /* identifier that must be a field (the \"name\" of \"u.name\") */\n /* This is responsible to know if the field exists in Object, no matter if it's a relation or a simple field */\n FieldIdentificationVariable ::= identifier\n\n /* identifier that must be a collection-valued association field (to-many) (the \"Phonenumbers\" of \"u.Phonenumbers\") */\n CollectionValuedAssociationField ::= FieldIdentificationVariable\n\n /* identifier that must be a single-valued association field (to-one) (the \"Group\" of \"u.Group\") */\n SingleValuedAssociationField ::= FieldIdentificationVariable\n\n /* identifier that must be an embedded class state field */\n EmbeddedClassStateField ::= FieldIdentificationVariable\n\n /* identifier that must be a simple state field (name, email, ...) (the \"name\" of \"u.name\") */\n /* The difference between this and FieldIdentificationVariable is only semantical, because it points to a single field (not mapping to a relation) */\n SimpleStateField ::= FieldIdentificationVariable\n\nPath Expressions\n~~~~~~~~~~~~~~~~\n\n.. code-block:: php\n\n /* \"u.Group\" or \"u.Phonenumbers\" declarations */\n JoinAssociationPathExpression ::= IdentificationVariable \".\" (CollectionValuedAssociationField | SingleValuedAssociationField)\n\n /* \"u.Group\" or \"u.Phonenumbers\" usages */\n AssociationPathExpression ::= CollectionValuedPathExpression | SingleValuedAssociationPathExpression\n\n /* \"u.name\" or \"u.Group\" */\n SingleValuedPathExpression ::= StateFieldPathExpression | SingleValuedAssociationPathExpression\n\n /* \"u.name\" or \"u.Group.name\" */\n StateFieldPathExpression ::= IdentificationVariable \".\" StateField\n\n /* \"u.Group\" */\n SingleValuedAssociationPathExpression ::= IdentificationVariable \".\" SingleValuedAssociationField\n\n /* \"u.Group.Permissions\" */\n CollectionValuedPathExpression ::= IdentificationVariable \".\" CollectionValuedAssociationField\n\n /* \"name\" */\n StateField ::= {EmbeddedClassStateField \".\"}* SimpleStateField\n\nClauses\n~~~~~~~\n\n.. code-block:: php\n\n SelectClause ::= \"SELECT\" [\"DISTINCT\"] SelectExpression {\",\" SelectExpression}*\n SimpleSelectClause ::= \"SELECT\" [\"DISTINCT\"] SimpleSelectExpression\n UpdateClause ::= \"UPDATE\" AbstractSchemaName [\"AS\"] AliasIdentificationVariable \"SET\" UpdateItem {\",\" UpdateItem}*\n DeleteClause ::= \"DELETE\" [\"FROM\"] AbstractSchemaName [\"AS\"] AliasIdentificationVariable\n FromClause ::= \"FROM\" IdentificationVariableDeclaration {\",\" IdentificationVariableDeclaration}*\n SubselectFromClause ::= \"FROM\" SubselectIdentificationVariableDeclaration {\",\" SubselectIdentificationVariableDeclaration}*\n WhereClause ::= \"WHERE\" ConditionalExpression\n HavingClause ::= \"HAVING\" ConditionalExpression\n GroupByClause ::= \"GROUP\" \"BY\" GroupByItem {\",\" GroupByItem}*\n OrderByClause ::= \"ORDER\" \"BY\" OrderByItem {\",\" OrderByItem}*\n Subselect ::= SimpleSelectClause SubselectFromClause [WhereClause] [GroupByClause] [HavingClause] [OrderByClause]\n\nItems\n~~~~~\n\n.. code-block:: php\n\n UpdateItem ::= SingleValuedPathExpression \"=\" NewValue\n OrderByItem ::= (SimpleArithmeticExpression | SingleValuedPathExpression | ScalarExpression | ResultVariable | FunctionDeclaration) [\"ASC\" | \"DESC\"]\n GroupByItem ::= IdentificationVariable | ResultVariable | SingleValuedPathExpression\n NewValue ::= SimpleArithmeticExpression | \"NULL\"\n\nFrom, Join and Index by\n~~~~~~~~~~~~~~~~~~~~~~~\n\n.. code-block:: php\n\n IdentificationVariableDeclaration ::= RangeVariableDeclaration [IndexBy] {Join}*\n SubselectIdentificationVariableDeclaration ::= IdentificationVariableDeclaration\n RangeVariableDeclaration ::= AbstractSchemaName [\"AS\"] AliasIdentificationVariable\n JoinAssociationDeclaration ::= JoinAssociationPathExpression [\"AS\"] AliasIdentificationVariable [IndexBy]\n Join ::= [\"LEFT\" [\"OUTER\"] | \"INNER\"] \"JOIN\" (JoinAssociationDeclaration [\"WITH\" ConditionalExpression] | RangeVariableDeclaration [(\"ON\" | \"WITH\") ConditionalExpression])\n IndexBy ::= \"INDEX\" \"BY\" SingleValuedPathExpression\n\n.. note::\n Using the ``WITH`` keyword for the ``ConditionalExpression`` of a\n ``RangeVariableDeclaration`` is deprecated and will be removed in\n ORM 4.0. Use the ``ON`` keyword instead.\n\nSelect Expressions\n~~~~~~~~~~~~~~~~~~\n\n.. code-block:: php\n\n SelectExpression ::= (IdentificationVariable | ScalarExpression | AggregateExpression | FunctionDeclaration | PartialObjectExpression | \"(\" Subselect \")\" | CaseExpression | NewObjectExpression) [[\"AS\"] [\"HIDDEN\"] AliasResultVariable]\n SimpleSelectExpression ::= (StateFieldPathExpression | IdentificationVariable | FunctionDeclaration | AggregateExpression | \"(\" Subselect \")\" | ScalarExpression) [[\"AS\"] AliasResultVariable]\n PartialObjectExpression ::= \"PARTIAL\" IdentificationVariable \".\" PartialFieldSet\n PartialFieldSet ::= \"{\" SimpleStateField {\",\" SimpleStateField}* \"}\"\n NewObjectExpression ::= \"NEW\" AbstractSchemaName \"(\" NewObjectArg {\",\" NewObjectArg}* \")\"\n NewObjectArg ::= (ScalarExpression | \"(\" Subselect \")\" | NewObjectExpression | EntityAsDtoArgumentExpression) [\"AS\" AliasResultVariable]\n EntityAsDtoArgumentExpression ::= IdentificationVariable\n\nConditional Expressions\n~~~~~~~~~~~~~~~~~~~~~~~\n\n.. code-block:: php\n\n ConditionalExpression ::= ConditionalTerm {\"OR\" ConditionalTerm}*\n ConditionalTerm ::= ConditionalFactor {\"AND\" ConditionalFactor}*\n ConditionalFactor ::= [\"NOT\"] ConditionalPrimary\n ConditionalPrimary ::= SimpleConditionalExpression | \"(\" ConditionalExpression \")\"\n SimpleConditionalExpression ::= ComparisonExpression | BetweenExpression | LikeExpression |\n InExpression | NullComparisonExpression | ExistsExpression |\n EmptyCollectionComparisonExpression | CollectionMemberExpression |\n InstanceOfExpression\n\n\nCollection Expressions\n~~~~~~~~~~~~~~~~~~~~~~\n\n.. code-block:: php\n\n EmptyCollectionComparisonExpression ::= CollectionValuedPathExpression \"IS\" [\"NOT\"] \"EMPTY\"\n CollectionMemberExpression ::= EntityExpression [\"NOT\"] \"MEMBER\" [\"OF\"] CollectionValuedPathExpression\n\nLiteral Values\n~~~~~~~~~~~~~~\n\n.. code-block:: php\n\n Literal ::= string | char | integer | float | boolean\n InParameter ::= ArithmeticExpression | InputParameter\n\nInput Parameter\n~~~~~~~~~~~~~~~\n\n.. code-block:: php\n\n InputParameter ::= PositionalParameter | NamedParameter\n PositionalParameter ::= \"?\" integer\n NamedParameter ::= \":\" string\n\nArithmetic Expressions\n~~~~~~~~~~~~~~~~~~~~~~\n\n.. code-block:: php\n\n ArithmeticExpression ::= SimpleArithmeticExpression | \"(\" Subselect \")\"\n SimpleArithmeticExpression ::= ArithmeticTerm {(\"+\" | \"-\") ArithmeticTerm}*\n ArithmeticTerm ::= ArithmeticFactor {(\"*\" | \"/\") ArithmeticFactor}*\n ArithmeticFactor ::= [(\"+\" | \"-\")] ArithmeticPrimary\n ArithmeticPrimary ::= SingleValuedPathExpression | Literal | \"(\" SimpleArithmeticExpression \")\"\n | FunctionsReturningNumerics | AggregateExpression | FunctionsReturningStrings\n | FunctionsReturningDatetime | IdentificationVariable | ResultVariable\n | InputParameter | CaseExpression\n\nScalar and Type Expressions\n~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n.. code-block:: php\n\n ScalarExpression ::= SimpleArithmeticExpression | StringPrimary | DateTimePrimary | StateFieldPathExpression | BooleanPrimary | CaseExpression | InstanceOfExpression\n StringExpression ::= StringPrimary | ResultVariable | \"(\" Subselect \")\"\n StringPrimary ::= StateFieldPathExpression | string | InputParameter | FunctionsReturningStrings | AggregateExpression | CaseExpression\n BooleanExpression ::= BooleanPrimary | \"(\" Subselect \")\"\n BooleanPrimary ::= StateFieldPathExpression | boolean | InputParameter\n EntityExpression ::= SingleValuedAssociationPathExpression | SimpleEntityExpression\n SimpleEntityExpression ::= IdentificationVariable | InputParameter\n DatetimeExpression ::= DatetimePrimary | \"(\" Subselect \")\"\n DatetimePrimary ::= StateFieldPathExpression | InputParameter | FunctionsReturningDatetime | AggregateExpression\n\n.. note::\n\n Parts of CASE expressions are not yet implemented.\n\nAggregate Expressions\n~~~~~~~~~~~~~~~~~~~~~\n\n.. code-block:: php\n\n AggregateExpression ::= (\"AVG\" | \"MAX\" | \"MIN\" | \"SUM\" | \"COUNT\") \"(\" [\"DISTINCT\"] SimpleArithmeticExpression \")\"\n\nCase Expressions\n~~~~~~~~~~~~~~~~\n\n.. code-block:: php\n\n CaseExpression ::= GeneralCaseExpression | SimpleCaseExpression | CoalesceExpression | NullifExpression\n GeneralCaseExpression ::= \"CASE\" WhenClause {WhenClause}* \"ELSE\" ScalarExpression \"END\"\n WhenClause ::= \"WHEN\" ConditionalExpression \"THEN\" ScalarExpression\n SimpleCaseExpression ::= \"CASE\" CaseOperand SimpleWhenClause {SimpleWhenClause}* \"ELSE\" ScalarExpression \"END\"\n CaseOperand ::= StateFieldPathExpression | TypeDiscriminator\n SimpleWhenClause ::= \"WHEN\" ScalarExpression \"THEN\" ScalarExpression\n CoalesceExpression ::= \"COALESCE\" \"(\" ScalarExpression {\",\" ScalarExpression}* \")\"\n NullifExpression ::= \"NULLIF\" \"(\" ScalarExpression \",\" ScalarExpression \")\"\n\nOther Expressions\n~~~~~~~~~~~~~~~~~\n\nQUANTIFIED/BETWEEN/COMPARISON/LIKE/NULL/EXISTS\n\n.. code-block:: php\n\n QuantifiedExpression ::= (\"ALL\" | \"ANY\" | \"SOME\") \"(\" Subselect \")\"\n BetweenExpression ::= ArithmeticExpression [\"NOT\"] \"BETWEEN\" ArithmeticExpression \"AND\" ArithmeticExpression\n ComparisonExpression ::= ArithmeticExpression ComparisonOperator ( QuantifiedExpression | ArithmeticExpression )\n InExpression ::= ArithmeticExpression [\"NOT\"] \"IN\" \"(\" (InParameter {\",\" InParameter}* | Subselect) \")\"\n InstanceOfExpression ::= IdentificationVariable [\"NOT\"] \"INSTANCE\" [\"OF\"] (InstanceOfParameter | \"(\" InstanceOfParameter {\",\" InstanceOfParameter}* \")\")\n InstanceOfParameter ::= AbstractSchemaName | InputParameter\n LikeExpression ::= StringExpression [\"NOT\"] \"LIKE\" StringPrimary [\"ESCAPE\" char]\n NullComparisonExpression ::= (InputParameter | NullIfExpression | CoalesceExpression | AggregateExpression | FunctionDeclaration | IdentificationVariable | SingleValuedPathExpression | ResultVariable) \"IS\" [\"NOT\"] \"NULL\"\n ExistsExpression ::= [\"NOT\"] \"EXISTS\" \"(\" Subselect \")\"\n ComparisonOperator ::= \"=\" | \"<\" | \"<=\" | \"<>\" | \">\" | \">=\" | \"!=\"\n\nFunctions\n~~~~~~~~~\n\n.. code-block:: php\n\n FunctionDeclaration ::= FunctionsReturningStrings | FunctionsReturningNumerics | FunctionsReturningDateTime\n\n FunctionsReturningNumerics ::=\n \"LENGTH\" \"(\" StringPrimary \")\" |\n \"LOCATE\" \"(\" StringPrimary \",\" StringPrimary [\",\" SimpleArithmeticExpression]\")\" |\n \"ABS\" \"(\" SimpleArithmeticExpression \")\" |\n \"SQRT\" \"(\" SimpleArithmeticExpression \")\" |\n \"MOD\" \"(\" SimpleArithmeticExpression \",\" SimpleArithmeticExpression \")\" |\n \"SIZE\" \"(\" CollectionValuedPathExpression \")\" |\n \"DATE_DIFF\" \"(\" ArithmeticPrimary \",\" ArithmeticPrimary \")\" |\n \"BIT_AND\" \"(\" ArithmeticPrimary \",\" ArithmeticPrimary \")\" |\n \"BIT_OR\" \"(\" ArithmeticPrimary \",\" ArithmeticPrimary \")\"\n\n FunctionsReturningDateTime ::=\n \"CURRENT_DATE\" |\n \"CURRENT_TIME\" |\n \"CURRENT_TIMESTAMP\" |\n \"DATE_ADD\" \"(\" ArithmeticPrimary \",\" ArithmeticPrimary \",\" StringPrimary \")\" |\n \"DATE_SUB\" \"(\" ArithmeticPrimary \",\" ArithmeticPrimary \",\" StringPrimary \")\"\n\n FunctionsReturningStrings ::=\n \"CONCAT\" \"(\" StringPrimary \",\" StringPrimary \")\" |\n \"SUBSTRING\" \"(\" StringPrimary \",\" SimpleArithmeticExpression \",\" SimpleArithmeticExpression \")\" |\n \"TRIM\" \"(\" [[\"LEADING\" | \"TRAILING\" | \"BOTH\"] [char] \"FROM\"] StringPrimary \")\" |\n \"LOWER\" \"(\" StringPrimary \")\" |\n \"UPPER\" \"(\" StringPrimary \")\" |\n \"IDENTITY\" \"(\" SingleValuedAssociationPathExpression {\",\" string} \")\"\n"
},
{
"path": "docs/en/reference/events.rst",
"content": "Events\n======\n\nDoctrine ORM features a lightweight event system that is part of the\nCommon package. Doctrine uses it to dispatch system events, mainly\n:ref:`lifecycle events `.\nYou can also use it for your own custom events.\n\nThe Event System\n----------------\n\nThe event system is controlled by the ``EventManager``. It is the\ncentral point of Doctrine's event listener system. Listeners are\nregistered on the manager and events are dispatched through the\nmanager.\n\n.. code-block:: php\n\n addEventListener(array(self::preFoo, self::postFoo), $this);\n }\n\n public function preFoo(EventArgs $e)\n {\n $this->preFooInvoked = true;\n }\n\n public function postFoo(EventArgs $e)\n {\n $this->postFooInvoked = true;\n }\n }\n\n // Create a new instance\n $test = new TestEvent($evm);\n\nEvents can be dispatched by using the ``dispatchEvent()`` method.\n\n.. code-block:: php\n\n dispatchEvent(TestEvent::preFoo);\n $evm->dispatchEvent(TestEvent::postFoo);\n\nYou can easily remove a listener with the ``removeEventListener()``\nmethod.\n\n.. code-block:: php\n\n removeEventListener(array(self::preFoo, self::postFoo), $this);\n\nThe Doctrine ORM event system also has a simple concept of event\nsubscribers. We can define a simple ``TestEventSubscriber`` class\nwhich implements the ``\\Doctrine\\Common\\EventSubscriber`` interface\nand implements a ``getSubscribedEvents()`` method which returns an\narray of events it should be subscribed to.\n\n.. code-block:: php\n\n preFooInvoked = true;\n }\n\n public function getSubscribedEvents()\n {\n return array(TestEvent::preFoo);\n }\n }\n\n $eventSubscriber = new TestEventSubscriber();\n $evm->addEventSubscriber($eventSubscriber);\n\n.. note::\n\n The array to return in the ``getSubscribedEvents`` method is a simple array\n with the values being the event names. The subscriber must have a method\n that is named exactly like the event.\n\nNow when you dispatch an event, any event subscribers will be\nnotified for that event.\n\n.. code-block:: php\n\n dispatchEvent(TestEvent::preFoo);\n\nNow you can test the ``$eventSubscriber`` instance to see if the\n``preFoo()`` method was invoked.\n\n.. code-block:: php\n\n preFooInvoked) {\n echo 'pre foo invoked!';\n }\n\nRegistering Event Handlers\n~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nThere are two ways to set up an event handler:\n\n* For *all events* you can create a Lifecycle Event Listener or Subscriber class and register\nit by calling ``$eventManager->addEventListener()`` or ``eventManager->addEventSubscriber()``,\nsee\n:ref:`Listening and subscribing to Lifecycle Events `\n* For *some events* (see table below), you can create a *Lifecycle Callback* method in the\nentity, see :ref:`Lifecycle Callbacks `.\n\n.. _reference-events-lifecycle-events:\n\nEvents Overview\n---------------\n\n+------------------------------------------------------------------+-----------------------+-----------+-------------------------------------+\n| Event | Dispatched by | Lifecycle | Passed |\n| | | Callback | Argument |\n+==================================================================+=======================+===========+=====================================+\n| :ref:`preRemove ` | ``$em->remove()`` | Yes | `PreRemoveEventArgs`_ |\n+------------------------------------------------------------------+-----------------------+-----------+-------------------------------------+\n| :ref:`postRemove ` | ``$em->flush()`` | Yes | `PostRemoveEventArgs`_ |\n+------------------------------------------------------------------+-----------------------+-----------+-------------------------------------+\n| :ref:`prePersist ` | ``$em->persist()`` | Yes | `PrePersistEventArgs`_ |\n| | on *initial* persist | | |\n+------------------------------------------------------------------+-----------------------+-----------+-------------------------------------+\n| :ref:`postPersist ` | ``$em->flush()`` | Yes | `PostPersistEventArgs`_ |\n+------------------------------------------------------------------+-----------------------+-----------+-------------------------------------+\n| :ref:`preUpdate ` | ``$em->flush()`` | Yes | `PreUpdateEventArgs`_ |\n+------------------------------------------------------------------+-----------------------+-----------+-------------------------------------+\n| :ref:`postUpdate ` | ``$em->flush()`` | Yes | `PostUpdateEventArgs`_ |\n+------------------------------------------------------------------+-----------------------+-----------+-------------------------------------+\n| :ref:`postLoad ` | Loading from database | Yes | `PostLoadEventArgs`_ |\n+------------------------------------------------------------------+-----------------------+-----------+-------------------------------------+\n| :ref:`loadClassMetadata ` | Loading of mapping | No | `LoadClassMetadataEventArgs`_ |\n| | metadata | | |\n+------------------------------------------------------------------+-----------------------+-----------+-------------------------------------+\n| ``onClassMetadataNotFound`` | ``MappingException`` | No | `OnClassMetadataNotFoundEventArgs`_ |\n+------------------------------------------------------------------+-----------------------+-----------+-------------------------------------+\n| :ref:`preFlush ` | ``$em->flush()`` | Yes | `PreFlushEventArgs`_ |\n+------------------------------------------------------------------+-----------------------+-----------+-------------------------------------+\n| :ref:`onFlush ` | ``$em->flush()`` | No | `OnFlushEventArgs`_ |\n+------------------------------------------------------------------+-----------------------+-----------+-------------------------------------+\n| :ref:`postFlush ` | ``$em->flush()`` | No | `PostFlushEventArgs`_ |\n+------------------------------------------------------------------+-----------------------+-----------+-------------------------------------+\n| :ref:`onClear ` | ``$em->clear()`` | No | `OnClearEventArgs`_ |\n+------------------------------------------------------------------+-----------------------+-----------+-------------------------------------+\n\n.. warning::\n\n Making changes to entities and calling ``EntityManager::flush()`` from within\n event handlers dispatched by ``EntityManager::flush()`` itself is strongly\n discouraged, and might be deprecated and eventually prevented in the future.\n\n The reason is that it causes re-entrance into ``UnitOfWork::commit()`` while a commit\n is currently being processed. The ``UnitOfWork`` was never designed to support this,\n and its behavior in this situation is not covered by any tests.\n\n This may lead to entity or collection updates being missed, applied only in parts and\n changes being lost at the end of the commit phase.\n\nNaming convention\n~~~~~~~~~~~~~~~~~\n\nEvents being used with the Doctrine ORM EventManager are best named\nwith camelcase and the value of the corresponding constant should\nbe the name of the constant itself, even with spelling. This has\nseveral reasons:\n\n\n- It is easy to read.\n- Simplicity.\n- Each method within an EventSubscriber is named after the\n corresponding constant's value. If the constant's name and value differ\n it contradicts the intention of using the constant and makes your code\n harder to maintain.\n\nAn example for a correct notation can be found in the example\n``TestEvent`` above.\n\n.. _lifecycle-callbacks:\n\nLifecycle Callbacks\n-------------------\n\nLifecycle Callbacks are defined on an entity class. They allow you to\ntrigger callbacks whenever an instance of that entity class experiences\na relevant lifecycle event. More than one callback can be defined for each\nlifecycle event. Lifecycle Callbacks are best used for simple operations\nspecific to a particular entity class's lifecycle.\n\n\n.. note::\n\n Lifecycle Callbacks are not supported for :doc:`Embeddables `.\n\n.. configuration-block::\n\n .. code-block:: attribute\n\n createdAt = date('Y-m-d H:i:s');\n }\n\n #[PrePersist]\n public function doOtherStuffOnPrePersist()\n {\n $this->value = 'changed from prePersist callback!';\n }\n\n #[PreUpdate]\n public function doStuffOnPreUpdate(PreUpdateEventArgs $eventArgs)\n {\n $this->value = 'changed from preUpdate callback!';\n }\n }\n .. code-block:: xml\n\n \n\n \n \n \n \n \n \n \n \n \n \n\nLifecycle Callbacks Event Argument\n----------------------------------\n\nThe triggered event is also given to the lifecycle-callback.\n\nWith the additional argument you have access to the\n``EntityManager`` and ``UnitOfWork`` APIs inside these callback methods.\n\n.. code-block:: php\n\n hasChangedField('username')) {\n // Do something when the username is changed.\n }\n }\n }\n\n.. _listening-and-subscribing-to-lifecycle-events:\n\nListening and subscribing to Lifecycle Events\n---------------------------------------------\n\nLifecycle event listeners are much more powerful than the simple\nlifecycle callbacks that are defined on the entity classes. They\nsit at a level above the entities and allow you to implement re-usable\nbehaviors across different entity classes.\n\nNote that they require much more detailed knowledge about the inner\nworkings of the ``EntityManager`` and ``UnitOfWork`` classes. Please\nread the :ref:`Implementing Event Listeners ` section\ncarefully if you are trying to write your own listener.\n\nFor event subscribers, there are no surprises. They declare the\nlifecycle events in their ``getSubscribedEvents`` method and provide\npublic methods that expect the relevant arguments.\n\nA lifecycle event listener looks like the following:\n\n.. code-block:: php\n\n getObject();\n $entityManager = $args->getObjectManager();\n\n // perhaps you only want to act on some \"Product\" entity\n if ($entity instanceof Product) {\n // do something with the Product\n }\n }\n }\n\nA lifecycle event subscriber may look like this:\n\n.. code-block:: php\n\n getObject();\n $entityManager = $args->getObjectManager();\n\n // perhaps you only want to act on some \"Product\" entity\n if ($entity instanceof Product) {\n // do something with the Product\n }\n }\n\n.. note::\n\n Lifecycle events are triggered for all entities. It is the responsibility\n of the listeners and subscribers to check if the entity is of a type\n it wants to handle.\n\nTo register an event listener or subscriber, you have to hook it into the\nEventManager that is passed to the EntityManager factory:\n\n.. code-block:: php\n\n addEventListener([Events::preUpdate], new MyEventListener());\n $eventManager->addEventSubscriber(new MyEventSubscriber());\n\n $entityManager = new EntityManager($connection, $config, $eventManager);\n\nYou can also retrieve the event manager instance after the\nEntityManager was created:\n\n.. code-block:: php\n\n getEventManager()->addEventListener([Events::preUpdate], new MyEventListener());\n $entityManager->getEventManager()->addEventSubscriber(new MyEventSubscriber());\n\n.. _reference-events-implementing-listeners:\n\nImplementing Event Listeners\n----------------------------\n\nThis section explains what is and what is not allowed during\nspecific lifecycle events of the ``UnitOfWork`` class. Although you get\npassed the ``EntityManager`` instance in all of these events, you have\nto follow these restrictions very carefully since operations in the\nwrong event may produce lots of different errors, such as inconsistent\ndata and lost updates/persists/removes.\n\nFor the described events that are also lifecycle callback events\nthe restrictions apply as well, with the additional restriction\nthat (prior to version 2.4) you do not have access to the\n``EntityManager`` or ``UnitOfWork`` APIs inside these events.\n\n.. _reference-events-pre-persist:\n\nprePersist\n~~~~~~~~~~\n\nThere are two ways for the ``prePersist`` event to be triggered:\n\n- One is when you call ``EntityManager::persist()``. The\n event is also called for all :ref:`cascaded associations `.\n- The other is inside the ``flush()`` method when changes to associations are computed and\n this association is marked as :ref:`cascade: persist `. Any new entity found\n during this operation is also persisted and ``prePersist`` called\n on it. This is called :ref:`persistence by reachability `.\n\nIn both cases you get passed a ``PrePersistEventArgs`` instance\nwhich has access to the entity and the entity manager.\n\nThis event is only triggered on *initial* persist of an entity\n(i.e. it does not trigger on future updates).\n\nThe following restrictions apply to ``prePersist``:\n\n- If you are using a PrePersist Identity Generator such as\n sequences the ID value will *NOT* be available within any\n PrePersist events.\n- Doctrine will not recognize changes made to relations in a prePersist\n event. This includes modifications to\n collections such as additions, removals or replacement.\n\n.. _reference-events-pre-remove:\n\npreRemove\n~~~~~~~~~\n\nThe ``preRemove`` event is called on every entity immediately when it is passed\nto the ``EntityManager::remove()`` method. It is cascaded for all\nassociations that are marked as :ref:`cascade: remove `\n\nIt is not called for a DQL ``DELETE`` statement.\n\nThere are no restrictions to what methods can be called inside the\n``preRemove`` event, except when the remove method itself was\ncalled during a flush operation.\n\n.. _reference-events-pre-flush:\n\npreFlush\n~~~~~~~~\n\n``preFlush`` is called inside ``EntityManager::flush()`` before\nanything else. ``EntityManager::flush()`` must not be called inside\nits listeners, since it would fire the ``preFlush`` event again, which would\nresult in an infinite loop.\n\n.. code-block:: php\n\n ` API, which grants you access to the previously\nmentioned sets. See this example:\n\n.. code-block:: php\n\n getObjectManager();\n $uow = $em->getUnitOfWork();\n\n foreach ($uow->getScheduledEntityInsertions() as $entity) {\n\n }\n\n foreach ($uow->getScheduledEntityUpdates() as $entity) {\n\n }\n\n foreach ($uow->getScheduledEntityDeletions() as $entity) {\n\n }\n\n foreach ($uow->getScheduledCollectionDeletions() as $col) {\n\n }\n\n foreach ($uow->getScheduledCollectionUpdates() as $col) {\n\n }\n }\n }\n\nThe following restrictions apply to the ``onFlush`` event:\n\n- If you create and persist a new entity in ``onFlush``, then\n calling ``EntityManager::persist()`` is not enough.\n You have to execute an additional call to\n ``$unitOfWork->computeChangeSet($classMetadata, $entity)``.\n- Changing primitive fields or associations requires you to\n explicitly trigger a re-computation of the changeset of the\n affected entity. This can be done by calling\n ``$unitOfWork->recomputeSingleEntityChangeSet($classMetadata, $entity)``.\n\n.. _reference-events-post-flush:\n\npostFlush\n~~~~~~~~~\n\n``postFlush`` is called at the end of ``EntityManager::flush()``.\n``EntityManager::flush()`` can **NOT** be called safely inside its listeners.\nThis event is not a lifecycle callback.\n\n.. code-block:: php\n\n getEntity() instanceof User) {\n if ($eventArgs->hasChangedField('name') && $eventArgs->getNewValue('name') == 'Alice') {\n $eventArgs->setNewValue('name', 'Bob');\n // The following will only work if `status` is already present in the computed changeset.\n // Otherwise it will throw an InvalidArgumentException:\n $eventArgs->setNewValue('status', 'active');\n }\n }\n }\n }\n\nYou could also use this listener to implement validation of all the\nfields that have changed. This is more efficient than using a\nlifecycle callback when there are expensive validations to call:\n\n.. code-block:: php\n\n getEntity() instanceof Account) {\n if ($eventArgs->hasChangedField('creditCard')) {\n $this->validateCreditCard($eventArgs->getNewValue('creditCard'));\n }\n }\n }\n\n private function validateCreditCard($no)\n {\n // throw an exception to interrupt flush event. Transaction will be rolled back.\n }\n }\n\nRestrictions for this event:\n\n- Changes to associations of the passed entities are not\n recognized by the flush operation anymore.\n- Changes to fields of the passed entities are not recognized by\n the flush operation anymore, use the computed change-set passed to\n the event to modify primitive field values, e.g. use\n ``$eventArgs->setNewValue($field, $value);`` as in the Alice to Bob example above.\n- Any calls to ``EntityManager::persist()`` or\n ``EntityManager::remove()``, even in combination with the ``UnitOfWork``\n API are strongly discouraged and don't work as expected outside the\n flush operation.\n\n.. _reference-events-post-update-remove-persist:\n\npostUpdate, postRemove, postPersist\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nThese three ``post*`` events are called inside ``EntityManager::flush()``.\nChanges in here are not relevant to the persistence in the\ndatabase, but you can use these events to alter non-persistable items,\nlike non-mapped fields, logging or even associated classes that are\nnot directly mapped by Doctrine.\n\n- The ``postUpdate`` event occurs after the database\n update operations to entity data, but before the database transaction\n has been committed. It is not called for a DQL ``UPDATE`` statement.\n- The ``postPersist`` event occurs for an entity after the entity has\n been made persistent. It will be invoked after all database insert\n operations for new entities have been performed, but before the database\n transaction has been committed. Generated primary key values will be\n available for all entities at the time this event is triggered.\n- The ``postRemove`` event occurs for an entity after the\n entity has been deleted. It will be invoked after all database\n delete operations for entity rows have been executed, but before the\n database transaction has been committed. This event is not called for\n a DQL ``DELETE`` statement.\n\n.. note::\n\n At the time ``postPersist`` is called, there may still be collection and/or\n \"extra\" updates pending. The database may not yet be completely in\n sync with the entity states in memory, not even for the new entities. Similarly,\n also at the time ``postUpdate`` and ``postRemove`` are called, in-memory collections\n may still be in a \"dirty\" state or still contain removed entities.\n\n.. warning::\n\n The ``postRemove`` event or any events triggered after an entity removal\n can receive an uninitializable proxy in case you have configured an entity to\n cascade remove relations. In this case, you should load yourself the proxy in\n the associated ``pre*`` event.\n\n.. _reference-events-post-load:\n\npostLoad\n~~~~~~~~\n\nThe postLoad event occurs after the entity has been loaded into the current\n``EntityManager`` from the database or after ``refresh()`` has been applied to it.\n\n.. warning::\n\n When using ``Doctrine\\ORM\\AbstractQuery::toIterable()``, ``postLoad``\n events will be executed immediately after objects are being hydrated, and therefore\n associations are not guaranteed to be initialized. It is not safe to combine\n usage of ``Doctrine\\ORM\\AbstractQuery::toIterable()`` and ``postLoad`` event\n handlers.\n\n.. _reference-events-on-clear:\n\nonClear\n~~~~~~~~\n\nThe ``onClear`` event occurs when the ``EntityManager::clear()`` operation is invoked,\nafter all references to entities have been removed from the unit of work.\nThis event is not a lifecycle callback.\n\nEntity listeners\n----------------\n\nAn entity listener is a lifecycle listener class used for an entity.\n\n- The entity listener's mapping may be applied to an entity class or mapped superclass.\n- An entity listener is defined by mapping the entity class with the corresponding mapping.\n\n.. configuration-block::\n\n .. code-block:: attribute\n\n \n \n \n \n \n \n \n \n\n.. _reference-entity-listeners:\n\nEntity listeners class\n~~~~~~~~~~~~~~~~~~~~~~\n\nAn ``Entity Listener`` could be any class, by default it should be a class with a no-arg constructor.\n\n- Different from :ref:`reference-events-implementing-listeners` an ``Entity Listener`` is invoked just to the specified entity\n- An entity listener method receives two arguments, the entity instance and the lifecycle event.\n- The callback method can be defined by naming convention or specifying a method mapping.\n- When a listener mapping is not given the parser will use the naming convention to look for a matching method,\n e.g. it will look for a public ``preUpdate()`` method if you are listening to the ``preUpdate`` event.\n- When a listener mapping is given the parser will not look for any methods using the naming convention.\n\n.. code-block:: php\n\n \n \n \n \n \n \n\n \n \n\n \n \n\n \n \n \n \n \n \n \n\n.. note::\n\n The order of execution of multiple methods for the same event (e.g. multiple @PrePersist) is not guaranteed.\n\n\nEntity listeners resolver\n~~~~~~~~~~~~~~~~~~~~~~~~~\nDoctrine invokes the listener resolver to get the listener instance.\n\n- A resolver allows you register a specific entity listener instance.\n- You can also implement your own resolver by extending ``Doctrine\\ORM\\Mapping\\DefaultEntityListenerResolver`` or implementing ``Doctrine\\ORM\\Mapping\\EntityListenerResolver``\n\nSpecifying an entity listener instance :\n\n.. code-block:: php\n\n service = $service;\n }\n\n public function preUpdate(User $user, PreUpdateEventArgs $event)\n {\n $this->service->doSomething($user);\n }\n }\n\n // register a entity listener.\n $listener = $container->get('user_listener');\n $em->getConfiguration()->getEntityListenerResolver()->register($listener);\n\nImplementing your own resolver:\n\n.. code-block:: php\n\n container = $container;\n }\n\n public function resolve($className)\n {\n // resolve the service id by the given class name;\n $id = 'user_listener';\n\n return $this->container->get($id);\n }\n }\n\n // Configure the listener resolver only before instantiating the EntityManager\n $configurations->setEntityListenerResolver(new MyEntityListenerResolver);\n $entityManager = new EntityManager(.., $configurations, ..);\n\n.. _reference-events-load-class-metadata:\n\nLoad ClassMetadata Event\n------------------------\n\n``loadClassMetadata`` - The ``loadClassMetadata`` event occurs after the\nmapping metadata for a class has been loaded from a mapping source\n(attributes/xml) in to a ``Doctrine\\ORM\\Mapping\\ClassMetadata`` instance.\nYou can hook in to this process and manipulate the instance.\nThis event is not a lifecycle callback.\n\n.. code-block:: php\n\n getEventManager();\n $evm->addEventListener(Doctrine\\ORM\\Events::loadClassMetadata, $test);\n\n class TestEventListener\n {\n public function loadClassMetadata(LoadClassMetadataEventArgs $eventArgs)\n {\n $classMetadata = $eventArgs->getClassMetadata();\n $fieldMapping = array(\n 'fieldName' => 'about',\n 'type' => 'string',\n 'length' => 255\n );\n $classMetadata->mapField($fieldMapping);\n }\n }\n\nIf not class metadata can be found, an ``onClassMetadataNotFound`` event is dispatched.\nManipulating the given event args instance\nallows providing fallback metadata even when no actual metadata exists\nor could be found. This event is not a lifecycle callback.\n\nSchemaTool Events\n-----------------\n\nIt is possible to access the schema metadata during schema changes that are happening in ``Doctrine\\ORM\\Tools\\SchemaTool``.\nThere are two different events where you can hook in.\n\npostGenerateSchemaTable\n~~~~~~~~~~~~~~~~~~~~~~~\n\nThis event is fired for each ``Doctrine\\DBAL\\Schema\\Table`` instance, after one was created and built up with the current class metadata\nof an entity. It is possible to access to the current state of ``Doctrine\\DBAL\\Schema\\Schema``, the current table schema\ninstance and class metadata.\n\n.. code-block:: php\n\n getEventManager();\n $evm->addEventListener(ToolEvents::postGenerateSchemaTable, $test);\n\n class TestEventListener\n {\n public function postGenerateSchemaTable(GenerateSchemaTableEventArgs $eventArgs)\n {\n $classMetadata = $eventArgs->getClassMetadata();\n $schema = $eventArgs->getSchema();\n $table = $eventArgs->getClassTable();\n }\n }\n\npostGenerateSchema\n~~~~~~~~~~~~~~~~~~\n\nThis event is fired after the schema instance was successfully built and before SQL queries are generated from the\nschema information of ``Doctrine\\DBAL\\Schema\\Schema``. It allows to access the full object representation of the database schema\nand the EntityManager.\n\n.. code-block:: php\n\n getEventManager();\n $evm->addEventListener(ToolEvents::postGenerateSchema, $test);\n\n class TestEventListener\n {\n public function postGenerateSchema(GenerateSchemaEventArgs $eventArgs)\n {\n $schema = $eventArgs->getSchema();\n $em = $eventArgs->getEntityManager();\n }\n }\n\n.. _PrePersistEventArgs: https://github.com/doctrine/orm/blob/HEAD/src/Event/PrePersistEventArgs.php\n.. _PreRemoveEventArgs: https://github.com/doctrine/orm/blob/HEAD/src/Event/PreRemoveEventArgs.php\n.. _PreUpdateEventArgs: https://github.com/doctrine/orm/blob/HEAD/src/Event/PreUpdateEventArgs.php\n.. _PostPersistEventArgs: https://github.com/doctrine/orm/blob/HEAD/src/Event/PostPersistEventArgs.php\n.. _PostRemoveEventArgs: https://github.com/doctrine/orm/blob/HEAD/src/Event/PostRemoveEventArgs.php\n.. _PostUpdateEventArgs: https://github.com/doctrine/orm/blob/HEAD/src/Event/PostUpdateEventArgs.php\n.. _PostLoadEventArgs: https://github.com/doctrine/orm/blob/HEAD/src/Event/PostLoadEventArgs.php\n.. _PreFlushEventArgs: https://github.com/doctrine/orm/blob/HEAD/src/Event/PreFlushEventArgs.php\n.. _PostFlushEventArgs: https://github.com/doctrine/orm/blob/HEAD/src/Event/PostFlushEventArgs.php\n.. _OnFlushEventArgs: https://github.com/doctrine/orm/blob/HEAD/src/Event/OnFlushEventArgs.php\n.. _OnClearEventArgs: https://github.com/doctrine/orm/blob/HEAD/src/Event/OnClearEventArgs.php\n.. _LoadClassMetadataEventArgs: https://github.com/doctrine/orm/blob/HEAD/src/Event/LoadClassMetadataEventArgs.php\n.. _OnClassMetadataNotFoundEventArgs: https://github.com/doctrine/orm/blob/HEAD/src/Event/OnClassMetadataNotFoundEventArgs.php\n"
},
{
"path": "docs/en/reference/faq.rst",
"content": "Frequently Asked Questions\n==========================\n\n.. note::\n\n This FAQ is a work in progress. We will add lots of questions and not answer them right away just to remember\n what is often asked. If you stumble across an unanswered question please write a mail to the mailing-list or\n join the #doctrine channel on Freenode IRC.\n\nDatabase Schema\n---------------\n\nHow do I set the charset and collation for MySQL tables?\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nIn your mapping configuration, the column definition (for example, the\n``#[Column]`` attribute) has an ``options`` parameter where you can specify\nthe ``charset`` and ``collation``. The default values are ``utf8`` and\n``utf8_unicode_ci``, respectively.\n\nMapping\n-------\n\nWhy do I get exceptions about unique constraint failures during ``$em->flush()``?\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nDoctrine does not check if you are re-adding entities with a primary key that already exists\nor adding entities to a collection twice. You have to check for both conditions yourself\nin the code before calling ``$em->flush()`` if you know that unique constraint failures\ncan occur.\n\nIn `Symfony2 `_ for example there is a Unique Entity Validator\nto achieve this task.\n\nFor collections you can check with ``$collection->contains($entity)`` if an entity is already\npart of this collection. For a FETCH=LAZY collection this will initialize the collection,\nhowever for FETCH=EXTRA_LAZY this method will use SQL to determine if this entity is already\npart of the collection.\n\nAssociations\n------------\n\nWhat is wrong when I get an InvalidArgumentException \"A new entity was found through the relationship..\"?\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nThis exception is thrown during ``EntityManager#flush()`` when there exists an object in the identity map\nthat contains a reference to an object that Doctrine does not know about. Say for example you grab\na \"User\"-entity from the database with a specific id and set a completely new object into one of the associations\nof the User object. If you then call ``EntityManager#flush()`` without letting Doctrine know about\nthis new object using ``EntityManager#persist($newObject)`` you will see this exception.\n\nYou can solve this exception by:\n\n* Calling ``EntityManager#persist($newObject)`` on the new object\n* Using cascade=persist on the association that contains the new object\n\nHow can I filter an association?\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nYou should use DQL queries to query for the filtered set of entities.\n\nI call clear() on a One-To-Many collection but the entities are not deleted\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nThis is an expected behavior that has to do with the inverse/owning side handling of Doctrine.\nBy definition a One-To-Many association is on the inverse side, that means changes to it\nwill not be recognized by Doctrine.\n\nIf you want to perform the equivalent of the clear operation you have to iterate the\ncollection and set the owning side many-to-one reference to NULL as well to detach all entities\nfrom the collection. This will trigger the appropriate UPDATE statements on the database.\n\nHow can I add columns to a many-to-many table?\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nThe many-to-many association is only supporting foreign keys in the table definition\nTo work with many-to-many tables containing extra columns you have to use the\nforeign keys as primary keys feature of Doctrine ORM.\n\nSee :doc:`the tutorial on composite primary keys for more information <../tutorials/composite-primary-keys>`.\n\n\nHow can i paginate fetch-joined collections?\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nIf you are issuing a DQL statement that fetches a collection as well you cannot easily iterate\nover this collection using a LIMIT statement (or vendor equivalent).\n\nDoctrine does not offer a solution for this out of the box but there are several extensions\nthat do:\n\n* `DoctrineExtensions `_\n* `Pagerfanta `_\n\nWhy does pagination not work correctly with fetch joins?\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nPagination in Doctrine uses a LIMIT clause (or vendor equivalent) to restrict the results.\nHowever when fetch-joining this is not returning the correct number of results since joining\nwith a one-to-many or many-to-many association multiplies the number of rows by the number\nof associated entities.\n\nSee the previous question for a solution to this task.\n\nInheritance\n-----------\n\nCan I use Inheritance with Doctrine ORM?\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nYes, you can use Single- or Joined-Table Inheritance in ORM.\n\nSee the documentation chapter on :doc:`inheritance mapping ` for\nthe details.\n\nWhy does Doctrine not create proxy objects for my inheritance hierarchy?\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nIf you set a many-to-one or one-to-one association target-entity to any parent class of\nan inheritance hierarchy Doctrine does not know what PHP class the foreign is actually of.\nTo find this out it has to execute a SQL query to look this information up in the database.\n\nEntityGenerator\n---------------\n\nWhy does the EntityGenerator not do X?\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nThe EntityGenerator is not a full fledged code-generator that solves all tasks. Code-Generation\nis not a first-class priority in Doctrine 2 anymore (compared to Doctrine 1). The EntityGenerator\nis supposed to kick-start you, but not towards 100%.\n\nWhy does the EntityGenerator not generate inheritance correctly?\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nJust from the details of the discriminator map the EntityGenerator cannot guess the inheritance hierarchy.\nThis is why the generation of inherited entities does not fully work. You have to adjust some additional\ncode to get this one working correctly.\n\nPerformance\n-----------\n\nWhy is an extra SQL query executed every time I fetch an entity with a one-to-one relation?\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nIf Doctrine detects that you are fetching an inverse side one-to-one association\nit has to execute an additional query to load this object, because it cannot know\nif there is no such object (setting null) or if it should set a proxy and which id this proxy has.\n\nTo solve this problem currently a query has to be executed to find out this information.\n\nDoctrine Query Language\n-----------------------\n\nWhat is DQL?\n~~~~~~~~~~~~\n\nDQL stands for Doctrine Query Language, a query language that very much looks like SQL\nbut has some important benefits when using Doctrine:\n\n- It uses class names and fields instead of tables and columns, separating concerns between backend and your object model.\n- It utilizes the metadata defined to offer a range of shortcuts when writing. For example you do not have to specify the ON clause of joins, since Doctrine already knows about them.\n- It adds some functionality that is related to object management and transforms them into SQL.\n\nIt also has some drawbacks of course:\n\n- The syntax is slightly different to SQL so you have to learn and remember the differences.\n- To be vendor independent it can only implement a subset of all the existing SQL dialects. Vendor specific functionality and optimizations cannot be used through DQL unless implemented by you explicitly.\n- For some DQL constructs subselects are used which are known to be slow in MySQL.\n\nCan I sort by a function (for example ORDER BY RAND()) in DQL?\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nNo, it is not supported to sort by function in DQL. If you need this functionality you should either\nuse a native-query or come up with another solution. As a side note: Sorting with ORDER BY RAND() is painfully slow\nstarting with 1000 rows.\n\nIs it better to write DQL or to generate it with the query builder?\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nThe purpose of the ``QueryBuilder`` is to generate DQL dynamically,\nwhich is useful when you have optional filters, conditional joins, etc.\n\nBut the ``QueryBuilder`` is not an alternative to DQL, it actually generates DQL\nqueries at runtime, which are then interpreted by Doctrine. This means that\nusing the ``QueryBuilder`` to build and run a query is actually always slower\nthan only running the corresponding DQL query.\n\nSo if you only need to generate a query and bind parameters to it,\nyou should use plain DQL, as this is a simpler and much more readable solution.\nYou should only use the ``QueryBuilder`` when you can't achieve what you want to do with a DQL query.\n\nA Query fails, how can I debug it?\n----------------------------------\n\nFirst, if you are using the QueryBuilder you can use\n``$queryBuilder->getDQL()`` to get the DQL string of this query. The\ncorresponding SQL you can get from the Query instance by calling\n``$query->getSQL()``.\n\n.. code-block:: php\n\n createQuery($dql);\n var_dump($query->getSQL());\n\n $qb = $entityManager->createQueryBuilder();\n $qb->select('u')->from('User', 'u');\n var_dump($qb->getDQL());\n"
},
{
"path": "docs/en/reference/filters.rst",
"content": "Filters\n=======\n\nDoctrine ORM features a filter system that allows the developer to add SQL to\nthe conditional clauses of queries, regardless the place where the SQL is\ngenerated (e.g. from a DQL query, or by loading associated entities).\n\nThe filter functionality works on SQL level. Whether a SQL query is generated\nin a Persister, during lazy loading, in extra lazy collections or from DQL.\nEach time the system iterates over all the enabled filters, adding a new SQL\npart as a filter returns.\n\nBy adding SQL to the conditional clauses of queries, the filter system filters\nout rows belonging to the entities at the level of the SQL result set. This\nmeans that the filtered entities are never hydrated (which can be expensive).\n\n\nExample filter class\n--------------------\nThroughout this document the example ``MyLocaleFilter`` class will be used to\nillustrate how the filter feature works. A filter class must extend the base\n``Doctrine\\ORM\\Query\\Filter\\SQLFilter`` class and implement the ``addFilterConstraint``\nmethod. The method receives the ``ClassMetadata`` of the filtered entity and the\ntable alias of the SQL table of the entity.\n\n.. note::\n\n In the case of joined or single table inheritance, you always get passed the ClassMetadata of the\n inheritance root. This is necessary to avoid edge cases that would break the SQL when applying the filters.\n\nFor the filter to correctly function, the following rules must be followed. Failure to do so will lead to unexpected results from the query cache.\n 1. Parameters for the query should be set on the filter object by ``SQLFilter#setParameter()`` before the filter is used by the ORM ( i.e. do not set parameters inside ``SQLFilter#addFilterConstraint()`` function ).\n 2. The filter must be deterministic. Don't change the values based on external inputs.\n\nThe ``SQLFilter#getParameter()`` function takes care of the proper quoting of parameters.\n\n.. code-block:: php\n\n reflClass->implementsInterface('LocaleAware')) {\n return \"\";\n }\n\n return $targetTableAlias.'.locale = ' . $this->getParameter('locale'); // getParameter applies quoting automatically\n }\n }\n\nIf the parameter is an array and should be quoted as a list of values for an IN query\nthis is possible with the alternative ``SQLFilter#setParameterList()`` and\n``SQLFilter#getParameterList()`` functions.\n\nConfiguration\n-------------\nFilter classes are added to the configuration as following:\n\n.. code-block:: php\n\n addFilter(\"locale\", \"\\Doctrine\\Tests\\ORM\\Functional\\MyLocaleFilter\");\n\n\nThe ``Configuration#addFilter()`` method takes a name for the filter and the name of the\nclass responsible for the actual filtering.\n\n\nDisabling/Enabling Filters and Setting Parameters\n---------------------------------------------------\nFilters can be disabled and enabled via the ``FilterCollection`` which is\nstored in the ``EntityManager``. The ``FilterCollection#enable($name)`` method\nwill retrieve the filter object. You can set the filter parameters on that\nobject.\n\n.. code-block:: php\n\n getFilters()->enable(\"locale\");\n $filter->setParameter('locale', 'en');\n\n // Disable it\n $filter = $em->getFilters()->disable(\"locale\");\n\n.. warning::\n Disabling and enabling filters has no effect on managed entities. If you\n want to refresh or reload an object after having modified a filter or the\n FilterCollection, then you should clear the EntityManager and re-fetch your\n entities, having the new rules for filtering applied.\n\n\nSuspending/Restoring Filters\n----------------------------\nWhen a filter is disabled, the instance is fully deleted and all the filter\nparameters previously set are lost. Then, if you enable it again, a new filter\nis created without the previous filter parameters. If you want to keep a filter\n(in order to use it later) but temporary disable it, you'll need to use the\n``FilterCollection#suspend($name)`` and ``FilterCollection#restore($name)``\nmethods instead.\n\n.. code-block:: php\n\n getFilters()->enable(\"locale\");\n $filter->setParameter('locale', 'en');\n\n // Temporary suspend the filter\n $filter = $em->getFilters()->suspend(\"locale\");\n\n // Do things\n\n // Then restore it, the locale parameter will still be set\n $filter = $em->getFilters()->restore(\"locale\");\n\n.. warning::\n If you enable a previously disabled filter, doctrine will create a new\n one without keeping any of the previously parameter set with\n ``SQLFilter#setParameter()`` or ``SQLFilter#getParameterList()``. If you\n want to restore the previously disabled filter instead, you must use the\n ``FilterCollection#restore($name)`` method.\n"
},
{
"path": "docs/en/reference/improving-performance.rst",
"content": "Improving Performance\n=====================\n\nBytecode Cache\n--------------\n\nIt is highly recommended to make use of a bytecode cache like OPcache.\nA bytecode cache removes the need for parsing PHP code on every\nrequest and can greatly improve performance.\n\n \"If you care about performance and don't use a bytecode\n cache then you don't really care about performance. Please get one\n and start using it.\"\n\n *Stas Malyshev, Core Contributor to PHP and Zend Employee*\n\n\nMetadata and Query caches\n-------------------------\n\nAs already mentioned earlier in the chapter about configuring\nDoctrine, it is strongly discouraged to use Doctrine without a\nMetadata and Query cache.\n\nOperating Doctrine without these caches means\nDoctrine will need to load your mapping information on every single\nrequest and has to parse each DQL query on every single request.\nThis is a waste of resources.\n\nThe preferred cache adapter for metadata and query caches is a PHP file\ncache like Symfony's\n`PHP files adapter `_.\nThis kind of cache serializes cache items and writes them to a file.\nThis allows for opcode caching to be used and provides high performance in most scenarios.\n\nSee :ref:`types-of-caches`\n\nAlternative Query Result Formats\n--------------------------------\n\nMake effective use of the available alternative query result\nformats like nested array graphs or pure scalar results, especially\nin scenarios where data is loaded for read-only purposes.\n\nRead-Only Entities\n------------------\n\nYou can mark entities as read only. For details, see :ref:`attrref_entity`\n\nThis means that the entity marked as read only is never considered for updates.\nDuring flush on the EntityManager these entities are skipped even if properties\nchanged.\n\nRead-Only allows to persist new entities of a kind and remove existing ones,\nthey are just not considered for updates.\n\nYou can also explicitly mark individual entities read only directly on the\nUnitOfWork via a call to ``markReadOnly()``:\n\n.. code-block:: php\n\n $user = $entityManager->find(User::class, $id);\n $entityManager->getUnitOfWork()->markReadOnly($user);\n\nOr you can set all objects that are the result of a query hydration to be\nmarked as read only with the following query hint:\n\n.. code-block:: php\n\n $query = $entityManager->createQuery('SELECT u FROM App\\\\Entity\\\\User u');\n $query->setHint(Query::HINT_READ_ONLY, true);\n\n $users = $query->getResult();\n\nExtra-Lazy Collections\n----------------------\n\nIf entities hold references to large collections you will get performance and memory problems initializing them.\nTo solve this issue you can use the EXTRA_LAZY fetch-mode feature for collections. See the :doc:`tutorial <../tutorials/extra-lazy-associations>`\nfor more information on how this fetch mode works.\n\nTemporarily change fetch mode in DQL\n------------------------------------\n\nSee :ref:`dql-temporarily-change-fetch-mode`\n\n\nApply Best Practices\n--------------------\n\nA lot of the points mentioned in the Best Practices chapter will\nalso positively affect the performance of Doctrine.\n\nSee :doc:`Best Practices `\n\nChange Tracking policies\n------------------------\n\nSee: :doc:`Change Tracking Policies `\n"
},
{
"path": "docs/en/reference/inheritance-mapping.rst",
"content": "Inheritance Mapping\n===================\n\nThis chapter explains the available options for mapping class\nhierarchies.\n\nMapped Superclasses\n-------------------\n\nA mapped superclass is an abstract or concrete class that provides\npersistent entity state and mapping information for its subclasses,\nbut which is not itself an entity. Typically, the purpose of such a\nmapped superclass is to define state and mapping information that\nis common to multiple entity classes.\n\nMapped superclasses, just as regular, non-mapped classes, can\nappear in the middle of an otherwise mapped inheritance hierarchy\n(through Single Table Inheritance or Class Table Inheritance). They\nare not query-able, and do not require an ``#[Id]`` property.\n\nNo database table will be created for a mapped superclass itself,\nonly for entity classes inheriting from it. That implies that a\nmapped superclass cannot be the ``targetEntity`` in associations.\n\nIn other words, a mapped superclass can use unidirectional One-To-One\nand Many-To-One associations where it is the owning side.\nMany-To-Many associations are only possible if the mapped\nsuperclass is only used in exactly one entity at the moment. For further\nsupport of inheritance, the single or joined table inheritance features\nhave to be used.\n\n.. note::\n\n One-To-Many associations are not generally possible on a mapped\n superclass, since they require the \"many\" side to hold the foreign\n key.\n\n It is, however, possible to use the :doc:`ResolveTargetEntityListener `\n to replace references to a mapped superclass with an entity class at runtime.\n As long as there is only one entity subclass inheriting from the mapped\n superclass and all references to the mapped superclass are resolved to that\n entity class at runtime, the mapped superclass *can* use One-To-Many associations\n and be named as the ``targetEntity`` on the owning sides.\n\n.. warning::\n\n At least when using attributes or annotations to specify your mapping,\n it *seems* as if you could inherit from a base class that is neither\n an entity nor a mapped superclass, but has properties with mapping configuration\n on them that would also be used in the inheriting class.\n\n This, however, is due to how the corresponding mapping\n drivers work and what the PHP reflection API reports for inherited fields.\n\n Such a configuration is explicitly not supported. To give just one example,\n it will break for ``private`` properties.\n\n.. note::\n\n You may be tempted to use traits to mix mapped fields or relationships\n into your entity classes to circumvent some of the limitations of\n mapped superclasses. Before doing that, please read the section on traits\n in the :doc:`Limitations and Known Issues ` chapter.\n\nExample:\n\n.. code-block:: php\n\n `_\nis an inheritance mapping strategy where all classes of a hierarchy are\nmapped to a single database table.\n\nExample:\n\n.. configuration-block::\n\n .. code-block:: attribute\n\n Person::class, 'employee' => Employee::class])]\n class Person\n {\n // ...\n }\n\n #[Entity]\n class Employee extends Person\n {\n // ...\n }\n\n .. code-block:: xml\n\n \n \n \n \n \n \n \n \n \n\n \n \n \n \n\nIn this example, the ``#[DiscriminatorMap]`` specifies that in the\ndiscriminator column, a value of \"person\" identifies a row as being of type\n``Person`` and employee\" identifies a row as being of type ``Employee``.\n\nDesign-time considerations\n~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nThis mapping approach works well when the type hierarchy is fairly\nsimple and stable. Adding a new type to the hierarchy and adding\nfields to existing supertypes simply involves adding new columns to\nthe table, though in large deployments this may have an adverse\nimpact on the index and column layout inside the database.\n\nPerformance impact\n~~~~~~~~~~~~~~~~~~\n\nThis strategy is very efficient for querying across all types in\nthe hierarchy or for specific types. No table joins are required,\nonly a ``WHERE`` clause listing the type identifiers. In particular,\nrelationships involving types that employ this mapping strategy are\nvery performing.\n\nSQL Schema considerations\n~~~~~~~~~~~~~~~~~~~~~~~~~\n\nFor Single-Table-Inheritance to work in scenarios where you are\nusing either a legacy database schema or a self-written database\nschema you have to make sure that all columns that are not in the\nroot entity but in any of the different sub-entities has to allow\nnull values. Columns that have ``NOT NULL`` constraints have to be on\nthe root entity of the single-table inheritance hierarchy.\n\nClass Table Inheritance\n-----------------------\n\n`Class Table Inheritance `_\nis an inheritance mapping strategy where each class in a hierarchy\nis mapped to several tables: its own table and the tables of all\nparent classes. The table of a child class is linked to the table\nof a parent class through a foreign key constraint.\n\nThe discriminator column is placed in the topmost table of the hierarchy,\nbecause this is the easiest way to achieve polymorphic queries with Class\nTable Inheritance.\n\nExample:\n\n.. code-block:: php\n\n Person::class, 'employee' => Employee::class])]\n class Person\n {\n // ...\n }\n\n #[Entity]\n class Employee extends Person\n {\n // ...\n }\n\nAs before, the ``#[DiscriminatorMap]`` specifies that in the\ndiscriminator column, a value of \"person\" identifies a row as being of type\n``Person`` and \"employee\" identifies a row as being of type ``Employee``.\n\n.. note::\n\n When you do not use the SchemaTool to generate the\n required SQL you should know that deleting a class table\n inheritance makes use of the foreign key property\n ``ON DELETE CASCADE`` in all database implementations. A failure to\n implement this yourself will lead to dead rows in the database.\n\n\nDesign-time considerations\n~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nIntroducing a new type to the hierarchy, at any level, simply\ninvolves interjecting a new table into the schema. Subtypes of that\ntype will automatically join with that new type at runtime.\nSimilarly, modifying any entity type in the hierarchy by adding,\nmodifying or removing fields affects only the immediate table\nmapped to that type. This mapping strategy provides the greatest\nflexibility at design time, since changes to any type are always\nlimited to that type's dedicated table.\n\nPerformance impact\n~~~~~~~~~~~~~~~~~~\n\nThis strategy inherently requires multiple JOIN operations to\nperform just about any query which can have a negative impact on\nperformance, especially with large tables and/or large hierarchies.\nWhen partial objects are allowed, either globally or on the\nspecific query, then querying for any type will not cause the\ntables of subtypes to be ``OUTER JOIN``ed which can increase\nperformance but the resulting partial objects will not fully load\nthemselves on access of any subtype fields, so accessing fields of\nsubtypes after such a query is not safe.\n\nThere is also another important performance consideration that it is *not possible*\nto query for the base entity without any ``LEFT JOIN``s to the sub-types.\n\nSQL Schema considerations\n~~~~~~~~~~~~~~~~~~~~~~~~~\n\nFor each entity in the Class-Table Inheritance hierarchy all the\nmapped fields have to be columns on the table of this entity.\nAdditionally each child table has to have an id column that matches\nthe id column definition on the root table (except for any sequence\nor auto-increment details). Furthermore each child table has to\nhave a foreign key pointing from the id column to the root table id\ncolumn and cascading on delete.\n\n.. _inheritence_mapping_overrides:\n\nOverrides\n---------\n\nOverrides can only be applied to entities that extend a mapped superclass or\nuse traits. They are used to override a mapping for an entity field or\nrelationship defined in that mapped superclass or trait.\n\nIt is not supported to use overrides in entity inheritance scenarios.\n\n.. note::\n\n When using traits, make sure not to miss the warnings given in the\n :doc:`Limitations and Known Issues ` chapter.\n\n\nAssociation Override\n~~~~~~~~~~~~~~~~~~~~\nOverride a mapping for an entity relationship.\n\nCould be used by an entity that extends a mapped superclass\nto override a relationship mapping defined by the mapped superclass.\n\nExample:\n\n.. configuration-block::\n\n .. code-block:: attribute\n\n */\n #[JoinTable(name: 'users_groups')]\n #[JoinColumn(name: 'user_id', referencedColumnName: 'id')]\n #[InverseJoinColumn(name: 'group_id', referencedColumnName: 'id')]\n #[ManyToMany(targetEntity: 'Group', inversedBy: 'users')]\n protected Collection $groups;\n\n #[ManyToOne(targetEntity: 'Address')]\n #[JoinColumn(name: 'address_id', referencedColumnName: 'id')]\n protected Address|null $address = null;\n }\n\n // admin mapping\n namespace MyProject\\Model;\n\n #[Entity]\n #[AssociationOverrides([\n new AssociationOverride(\n name: 'groups',\n joinTable: new JoinTable(\n name: 'users_admingroups',\n ),\n joinColumns: [new JoinColumn(name: 'adminuser_id')],\n inverseJoinColumns: [new JoinColumn(name: 'admingroup_id')]\n ),\n new AssociationOverride(\n name: 'address',\n joinColumns: [new JoinColumn(name: 'adminaddress_id', referencedColumnName: 'id')]\n )\n ])]\n class Admin extends User\n {\n }\n\n .. code-block:: xml\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\nThings to note:\n\n- The \"association override\" specifies the overrides based on the property\n name.\n- This feature is available for all kind of associations (OneToOne, OneToMany, ManyToOne, ManyToMany).\n- The association type *cannot* be changed.\n- The override could redefine the ``joinTables`` or ``joinColumns`` depending on the association type.\n- The override could redefine ``inversedBy`` to reference more than one extended entity.\n- The override could redefine fetch to modify the fetch strategy of the extended entity.\n\nAttribute Override\n~~~~~~~~~~~~~~~~~~~~\nOverride the mapping of a field.\n\nCould be used by an entity that extends a mapped superclass to override a field mapping defined by the mapped superclass.\n\n.. configuration-block::\n\n .. code-block:: attribute\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n \n \n \n \n \n \n \n \n \n \n \n \n \n\nThings to note:\n\n- The \"attribute override\" specifies the overrides based on the property name.\n- The column type *cannot* be changed. If the column type is not equal, you get a ``MappingException``.\n- The override can redefine all the attributes except the type.\n\nQuery the Type\n--------------\n\nIt may happen that the entities of a special type should be queried. Because there\nis no direct access to the discriminator column, Doctrine provides the\n``INSTANCE OF`` construct.\n\nThe following example shows how to use ``INSTANCE OF``. There is a three level hierarchy\nwith a base entity ``NaturalPerson`` which is extended by ``Staff`` which in turn\nis extended by ``Technician``.\n\nQuerying for the staffs without getting any technicians can be achieved by this DQL:\n\n.. code-block:: php\n\n createQuery(\"SELECT staff FROM MyProject\\Model\\Staff staff WHERE staff NOT INSTANCE OF MyProject\\Model\\Technician\");\n $staffs = $query->getResult();\n"
},
{
"path": "docs/en/reference/installation.rst",
"content": ":orphan:\n\nInstallation\n============\n\nThe installation chapter has moved to :doc:`Installation and Configuration `.\n"
},
{
"path": "docs/en/reference/limitations-and-known-issues.rst",
"content": "Limitations and Known Issues\n============================\n\nWe try to make using Doctrine ORM a very pleasant experience.\nTherefore we think it is very important to be honest about the\ncurrent limitations to our users. Much like every other piece of\nsoftware the ORM is not perfect and far from feature complete.\nThis section should give you an overview of current limitations of\nDoctrine ORM as well as critical known issues that you should know\nabout.\n\nCurrent Limitations\n-------------------\n\nThere is a set of limitations that exist currently which might be\nsolved in the future. Any of this limitations now stated has at\nleast one ticket in the Tracker and is discussed for future\nreleases.\n\nJoin-Columns with non-primary keys\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nIt is not possible to use join columns pointing to non-primary keys. Doctrine will think these are the primary\nkeys and create lazy-loading proxies with the data, which can lead to unexpected results. Doctrine can for performance\nreasons not validate the correctness of this settings at runtime but only through the Validate Schema command.\n\nMapping Arrays to a Join Table\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nRelated to the previous limitation with \"Foreign Keys as\nIdentifier\" you might be interested in mapping the same table\nstructure as given above to an array. However this is not yet\npossible either. See the following example:\n\n.. code-block:: sql\n\n CREATE TABLE product (\n id INTEGER,\n name VARCHAR,\n PRIMARY KEY(id)\n );\n \n CREATE TABLE product_attributes (\n product_id INTEGER,\n attribute_name VARCHAR,\n attribute_value VARCHAR,\n PRIMARY KEY (product_id, attribute_name)\n );\n\nThis schema should be mapped to a Product Entity as follows:\n\n.. code-block:: php\n\n class Product\n {\n private $id;\n private $name;\n private $attributes = array();\n }\n\nWhere the ``attribute_name`` column contains the key and\n``attribute_value`` contains the value of each array element in\n``$attributes``.\n\nThe feature request for persistence of primitive value arrays\n`is described in the DDC-298 ticket `_.\n\nCustom Persisters\n~~~~~~~~~~~~~~~~~\n\nA Persister in Doctrine is an object that is responsible for the\nhydration and write operations of an entity against the database.\nCurrently there is no way to overwrite the persister implementation\nfor a given entity, however there are several use-cases that can\nbenefit from custom persister implementations:\n\n- `Add Upsert Support `_\n- `Evaluate possible ways in which stored-procedures can be used `_\n\nPersist Keys of Collections\n~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nPHP Arrays are ordered hash-maps and so should be the\n``Doctrine\\Common\\Collections\\Collection`` interface. We plan to\nevaluate a feature that optionally persists and hydrates the keys\nof a Collection instance.\n\n`Ticket DDC-213 `_\n\nMapping many tables to one entity\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nIt is not possible to map several equally looking tables onto one\nentity. For example if you have a production and an archive table\nof a certain business concept then you cannot have both tables map\nto the same entity.\n\nBehaviors\n~~~~~~~~~\n\nDoctrine ORM will **never** include a behavior system like Doctrine 1\nin the core library. We don't think behaviors add more value than\nthey cost pain and debugging hell. Please see the many different\nblog posts we have written on this topics:\n\n- `Doctrine2 \"Behaviors\" in a Nutshell `_\n- `A re-usable Versionable behavior for Doctrine2 `_\n- `Write your own ORM on top of Doctrine2 `_\n- `Doctrine ORM Behavioral Extensions `_\n\nDoctrine ORM has enough hooks and extension points so that **you** can\nadd whatever you want on top of it. None of this will ever become\ncore functionality of Doctrine2 however, you will have to rely on\nthird party extensions for magical behaviors.\n\nNested Set\n~~~~~~~~~~\n\nNestedSet was offered as a behavior in Doctrine 1 and will not be\nincluded in the core of Doctrine ORM. However there are already two\nextensions out there that offer support for Nested Set with\nORM:\n\n- `Doctrine2 Hierarchical-Structural Behavior `_\n- `Doctrine2 NestedSet `_\n\nUsing Traits in Entity Classes\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nThe use of traits in entity or mapped superclasses, at least when they\ninclude mapping configuration or mapped fields, is currently not\nendorsed by the Doctrine project. The reasons for this are as follows.\n\nTraits were added in PHP 5.4 more than 10 years ago, but at the same time\nmore than two years after the initial Doctrine 2 release and the time where\ncore components were designed.\n\nIn fact, this documentation mentions traits only in the context of\n:doc:`overriding field association mappings in subclasses `.\nCoverage of traits in test cases is practically nonexistent.\n\nThus, you should at least be aware that when using traits in your entity and\nmapped superclasses, you will be in uncharted terrain.\n\n.. warning::\n\n There be dragons.\n\nFrom a more technical point of view, traits basically work at the language level\nas if the code contained in them had been copied into the class where the trait\nis used, and even private fields are accessible by the using class. In addition to\nthat, some precedence and conflict resolution rules apply.\n\nWhen it comes to loading mapping configuration, the annotation and attribute drivers\nrely on PHP reflection to inspect class properties including their docblocks.\nAs long as the results are consistent with what a solution *without* traits would\nhave produced, this is probably fine.\n\nHowever, to mention known limitations, it is currently not possible to use \"class\"\nlevel `annotations `_ or\n`attributes `_ on traits, and attempts to\nimprove parser support for traits as `here `_\nor `there `_ have been abandoned\ndue to complexity.\n\nXML mapping configuration probably needs to completely re-configure or otherwise\ncopy-and-paste configuration for fields used from traits.\n\nMapping multiple private fields of the same name\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nWhen two classes, say a mapped superclass and an entity inheriting from it,\nboth contain a ``private`` field of the same name, this will lead to a ``MappingException``.\n\nSince the fields are ``private``, both are technically separate and can contain\ndifferent values at the same time. However, the ``ClassMetadata`` configuration used\ninternally by the ORM currently refers to fields by their name only, without taking the\nclass containing the field into consideration. This makes it impossible to keep separate\nmapping configuration for both fields.\n\nApart from that, in the case of having multiple ``private`` fields of the same name within\nthe class hierarchy an entity or mapped superclass, the Collection filtering API cannot determine\nthe right field to look at. Even if only one of these fields is actually mapped, the ``ArrayCollection``\nwill not be able to tell, since it does not have access to any metadata.\n\nThus, to avoid problems in this regard, it is best to avoid having multiple ``private`` fields of the\nsame name in class hierarchies containing entity and mapped superclasses.\n\nKnown Issues\n------------\n\nThe Known Issues section describes critical/blocker bugs and other\nissues that are either complicated to fix, not fixable due to\nbackwards compatibility issues or where no simple fix exists (yet).\nWe don't plan to add every bug in the tracker there, just those\nissues that can potentially cause nightmares or pain of any sort.\n\nSee bugs, improvement and feature requests on `Github issues `_.\n\nIdentifier Quoting and Legacy Databases\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nFor compatibility reasons between all the supported vendors and\nedge case problems Doctrine ORM does **NOT** do automatic identifier\nquoting. This can lead to problems when trying to get\nlegacy-databases to work with Doctrine ORM.\n\n\n- You can quote column-names as described in the\n :doc:`Basic-Mapping ` section.\n- You cannot quote join column names.\n- You cannot use non [a-zA-Z0-9\\_]+ characters, they will break\n several SQL statements.\n\nHaving problems with these kind of column names? Many databases\nsupport all CRUD operations on views that semantically map to\ncertain tables. You can create views for all your problematic\ntables and column names to avoid the legacy quoting nightmare.\n\nMicrosoft SQL Server and Doctrine \"datetime\"\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nDoctrine assumes that you use ``DateTime2`` data-types. If your legacy database contains DateTime\ndatatypes then you have to add your own data-type (see Basic Mapping for an example).\n\nMySQL with MyISAM tables\n~~~~~~~~~~~~~~~~~~~~~~~~\n\nDoctrine cannot provide atomic operations when calling ``EntityManager#flush()`` if one\nof the tables involved uses the storage engine MyISAM. You must use InnoDB or\nother storage engines that support transactions if you need integrity.\n"
},
{
"path": "docs/en/reference/metadata-drivers.rst",
"content": "Metadata Drivers\n================\n\nThe heart of an object relational mapper is the mapping information\nthat glues everything together. It instructs the EntityManager how\nit should behave when dealing with the different entities.\n\nCore Metadata Drivers\n---------------------\n\nDoctrine provides a few different ways for you to specify your\nmetadata:\n\n\n- **XML files** (XmlDriver)\n- **Attributes** (AttributeDriver)\n- **PHP Code in files or static functions** (PhpDriver)\n\nSomething important to note about the above drivers is they are all\nan intermediate step to the same end result. The mapping\ninformation is populated to ``Doctrine\\ORM\\Mapping\\ClassMetadata``\ninstances. So in the end, Doctrine only ever has to work with the\nAPI of the ``ClassMetadata`` class to get mapping information for\nan entity.\n\n.. note::\n\n The populated ``ClassMetadata`` instances are also cached\n so in a production environment the parsing and populating only ever\n happens once. You can configure the metadata cache implementation\n using the ``setMetadataCacheImpl()`` method on the\n ``Doctrine\\ORM\\Configuration`` class:\n\n .. code-block:: php\n\n getConfiguration()->setMetadataCacheImpl(new ApcuCache());\n\n\nAll the drivers are in the ``Doctrine\\ORM\\Mapping\\Driver`` namespace:\n\n.. code-block:: php\n\n getConfiguration()->setMetadataDriverImpl($driver);\n\nImplementing Metadata Drivers\n-----------------------------\n\nIn addition to the included metadata drivers you can very easily\nimplement your own. All you need to do is define a class which\nimplements the ``MappingDriver`` interface:\n\n.. code-block:: php\n\n $className\n * @param ClassMetadata $metadata\n *\n * @return void\n *\n * @template T of object\n */\n public function loadMetadataForClass(string $className, ClassMetadata $metadata);\n\n /**\n * Gets the names of all mapped classes known to this driver.\n *\n * @return list The names of all mapped classes known to this driver.\n */\n public function getAllClassNames();\n\n /**\n * Returns whether the class with the specified name should have its metadata loaded.\n * This is only the case if it is either mapped as an Entity or a MappedSuperclass.\n *\n * @param class-string $className\n *\n * @return bool\n */\n public function isTransient(string $className);\n }\n\nIf you want to write a metadata driver to parse information from\nsome file format we've made your life a little easier by providing\nthe ``FileDriver`` implementation for you to extend from:\n\n.. code-block:: php\n\n _loadMappingFile($file);\n\n // populate ClassMetadata instance from $data\n }\n\n /**\n * {@inheritDoc}\n */\n protected function _loadMappingFile($file)\n {\n // parse contents of $file and return php data structure\n }\n }\n\n.. note::\n\n When using the ``FileDriver`` it requires that you only have one\n entity defined per file and the file named after the class described\n inside where namespace separators are replaced by periods. So if you\n have an entity named ``Entities\\User`` and you wanted to write a\n mapping file for your driver above you would need to name the file\n ``Entities.User.dcm.ext`` for it to be recognized.\n\n\nNow you can use your ``MyMetadataDriver`` implementation by setting\nit with the ``setMetadataDriverImpl()`` method:\n\n.. code-block:: php\n\n getConfiguration()->setMetadataDriverImpl($driver);\n\nClassMetadata\n-------------\n\nThe last piece you need to know and understand about metadata in\nDoctrine ORM is the API of the ``ClassMetadata`` classes. You need to\nbe familiar with them in order to implement your own drivers but\nmore importantly to retrieve mapping information for a certain\nentity when needed.\n\nYou have all the methods you need to manually specify the mapping\ninformation instead of using some mapping file to populate it from.\n\nYou can read more about the API of the ``ClassMetadata`` classes in\nthe PHP Mapping chapter.\n\nGetting ClassMetadata Instances\n-------------------------------\n\nIf you want to get the ``ClassMetadata`` instance for an entity in\nyour project to programmatically use some mapping information to\ngenerate some HTML or something similar you can retrieve it through\nthe ``ClassMetadataFactory``:\n\n.. code-block:: php\n\n getMetadataFactory();\n $class = $cmf->getMetadataFor('MyEntityName');\n\nNow you can learn about the entity and use the data stored in the\n``ClassMetadata`` instance to get all mapped fields for example and\niterate over them:\n\n.. code-block:: php\n\n fieldMappings as $fieldMapping) {\n echo $fieldMapping['fieldName'] . \"\\n\";\n }\n"
},
{
"path": "docs/en/reference/namingstrategy.rst",
"content": "Implementing a NamingStrategy\n==============================\n\nUsing a naming strategy you can provide rules for generating database identifiers,\ncolumn or table names. This feature helps\nreduce the verbosity of the mapping document, eliminating repetitive noise (eg: ``TABLE_``).\n\n.. warning\n\n The naming strategy is always overridden by entity mapping such as the `Table` attribute.\n\nConfiguring a naming strategy\n-----------------------------\nThe default strategy used by Doctrine is quite minimal.\n\nBy default the ``Doctrine\\ORM\\Mapping\\DefaultNamingStrategy``\nuses the simple class name and the attribute names to generate tables and columns.\n\nYou can specify a different strategy by calling ``Doctrine\\ORM\\Configuration#setNamingStrategy()``:\n\n.. code-block:: php\n\n setNamingStrategy($namingStrategy);\n\nUnderscore naming strategy\n---------------------------\n\n``\\Doctrine\\ORM\\Mapping\\UnderscoreNamingStrategy`` is a built-in strategy.\n\n.. code-block:: php\n\n setNamingStrategy($namingStrategy);\n\nFor SomeEntityName the strategy will generate the table SOME_ENTITY_NAME with the\n``CASE_UPPER`` option, or some_entity_name with the ``CASE_LOWER`` option.\n\nNaming strategy interface\n-------------------------\nThe interface ``Doctrine\\ORM\\Mapping\\NamingStrategy`` allows you to specify\na naming strategy for database tables and columns.\n\n.. code-block:: php\n\n referenceColumnName();\n }\n public function joinTableName(string $sourceEntity, string $targetEntity, string $propertyName): string\n {\n return strtolower($this->classToTableName($sourceEntity) . '_' .\n $this->classToTableName($targetEntity));\n }\n public function joinKeyColumnName(string $entityName, ?string $referencedColumnName): string\n {\n return strtolower($this->classToTableName($entityName) . '_' .\n ($referencedColumnName ?: $this->referenceColumnName()));\n }\n }\n"
},
{
"path": "docs/en/reference/native-sql.rst",
"content": "Native SQL\n==========\n\nWith ``NativeQuery`` you can execute native SELECT SQL statements\nand map the results to Doctrine entities or any other result format\nsupported by Doctrine.\n\nIn order to make this mapping possible, you need to describe\nto Doctrine what columns in the result map to which entity property.\nThis description is represented by a ``ResultSetMapping`` object.\n\nWith this feature you can map arbitrary SQL code to objects, such as highly\nvendor-optimized SQL or stored-procedures.\n\nWriting ``ResultSetMapping`` from scratch is complex, but there is a convenience\nwrapper around it called a ``ResultSetMappingBuilder``. It can generate\nthe mappings for you based on Entities and even generates the ``SELECT``\nclause based on this information for you.\n\n.. note::\n\n If you want to execute DELETE, UPDATE or INSERT statements\n the Native SQL API cannot be used and will probably throw errors.\n Use ``EntityManager#getConnection()`` to access the native database\n connection and call the ``executeUpdate()`` method for these\n queries.\n\nThe NativeQuery class\n---------------------\n\nTo create a ``NativeQuery`` you use the method\n``EntityManager#createNativeQuery($sql, $resultSetMapping)``. As you can see in\nthe signature of this method, it expects 2 ingredients: The SQL you want to\nexecute and the ``ResultSetMapping`` that describes how the results will be\nmapped.\n\nOnce you obtained an instance of a ``NativeQuery``, you can bind parameters to\nit with the same API that ``Query`` has and execute it.\n\n.. code-block:: php\n\n createNativeQuery('SELECT id, name, discr FROM users WHERE name = ?', $rsm);\n $query->setParameter(1, 'romanb');\n\n $users = $query->getResult();\n\nResultSetMappingBuilder\n-----------------------\n\nAn easy start into ResultSet mapping is the ``ResultSetMappingBuilder`` object.\nThis has several benefits:\n\n- The builder takes care of automatically updating your ``ResultSetMapping``\n when the fields or associations change on the metadata of an entity.\n- You can generate the required ``SELECT`` expression for a builder\n by converting it to a string.\n- The API is much simpler than the usual ``ResultSetMapping`` API.\n\nOne downside is that the builder API does not yet support entities\nwith inheritance hierarchies.\n\n.. code-block:: php\n\n addRootEntityFromClassMetadata('MyProject\\User', 'u');\n $rsm->addJoinedEntityFromClassMetadata('MyProject\\Address', 'a', 'u', 'address', array('id' => 'address_id'));\n\nThe builder extends the ``ResultSetMapping`` class and as such has all the functionality of it as well.\n\nThe ``SELECT`` clause can be generated\nfrom a ``ResultSetMappingBuilder``. You can either cast the builder\nobject to ``(string)`` and the DQL aliases are used as SQL table aliases\nor use the ``generateSelectClause($tableAliases)`` method and pass\na mapping from DQL alias (key) to SQL alias (value)\n\n.. code-block:: php\n\n generateSelectClause(array(\n 'u' => 't1',\n 'g' => 't2'\n ));\n $sql = \"SELECT \" . $selectClause . \" FROM users t1 JOIN groups t2 ON t1.group_id = t2.id\";\n\n\nThe ResultSetMapping\n--------------------\n\nUnderstanding the ``ResultSetMapping`` is the key to using a\n``NativeQuery``. A Doctrine result can contain the following\ncomponents:\n\n\n- Entity results. These represent root result elements.\n- Joined entity results. These represent joined entities in\n associations of root entity results.\n- Field results. These represent a column in the result set that\n maps to a field of an entity. A field result always belongs to an\n entity result or joined entity result.\n- Scalar results. These represent scalar values in the result set\n that will appear in each result row. Adding scalar results to a\n ResultSetMapping can also cause the overall result to become\n **mixed** (see DQL - Doctrine Query Language) if the same\n ResultSetMapping also contains entity results.\n- Meta results. These represent columns that contain\n meta-information, such as foreign keys and discriminator columns.\n When querying for objects (``getResult()``), all meta columns of\n root entities or joined entities must be present in the SQL query\n and mapped accordingly using ``ResultSetMapping#addMetaResult``.\n\n.. note::\n\n It might not surprise you that Doctrine uses\n ``ResultSetMapping`` internally when you create DQL queries. As\n the query gets parsed and transformed to SQL, Doctrine fills a\n ``ResultSetMapping`` that describes how the results should be\n processed by the hydration routines.\n\n\nWe will now look at each of the result types that can appear in a\nResultSetMapping in detail.\n\nEntity results\n~~~~~~~~~~~~~~\n\nAn entity result describes an entity type that appears as a root\nelement in the transformed result. You add an entity result through\n``ResultSetMapping#addEntityResult()``. Let's take a look at the\nmethod signature in detail:\n\n.. code-block:: php\n\n addScalarResult('name', 1, 'string');\n $rsm->addScalarResult('email', 2, 'string');\n $rsm->addScalarResult('city', 3, 'string');\n $rsm->newObjectMappings['name'] = [\n 'className' => CmsUserDTO::class,\n 'objIndex' => 0, // a result can contain many DTOs, this is the index of the DTO to map to\n 'argIndex' => 0, // each scalar result can be mapped to a different argument of the DTO constructor\n ];\n $rsm->newObjectMappings['email'] = [\n 'className' => CmsUserDTO::class,\n 'objIndex' => 0,\n 'argIndex' => 1,\n ];\n $rsm->newObjectMappings['city'] = [\n 'className' => CmsUserDTO::class,\n 'objIndex' => 0,\n 'argIndex' => 2,\n ];\n\n\nMeta results\n~~~~~~~~~~~~\n\nA meta result describes a single column in a SQL result set that\nis either a foreign key or a discriminator column. These columns\nare essential for Doctrine to properly construct objects out of SQL\nresult sets. To add a column as a meta result use\n``ResultSetMapping#addMetaResult()``. The method signature in\ndetail:\n\n.. code-block:: php\n\n addEntityResult('User', 'u');\n $rsm->addFieldResult('u', 'id', 'id');\n $rsm->addFieldResult('u', 'name', 'name');\n\n $query = $this->_em->createNativeQuery('SELECT id, name FROM users WHERE name = ?', $rsm);\n $query->setParameter(1, 'romanb');\n\n $users = $query->getResult();\n\nThe result would look like this:\n\n.. code-block:: php\n\n array(\n [0] => User (Object)\n )\n\nNote that this would be a partial object if the entity has more\nfields than just id and name. In the example above the column and\nfield names are identical but that is not necessary, of course.\nAlso note that the query string passed to createNativeQuery is\n**real native SQL**. Doctrine does not touch this SQL in any way.\n\nIn the previous basic example, a User had no relations and the\ntable the class is mapped to owns no foreign keys. The next example\nassumes User has a unidirectional or bidirectional one-to-one\nassociation to a CmsAddress, where the User is the owning side and\nthus owns the foreign key.\n\n.. code-block:: php\n\n addEntityResult('User', 'u');\n $rsm->addFieldResult('u', 'id', 'id');\n $rsm->addFieldResult('u', 'name', 'name');\n $rsm->addMetaResult('u', 'address_id', 'address_id');\n\n $query = $this->_em->createNativeQuery('SELECT id, name, address_id FROM users WHERE name = ?', $rsm);\n $query->setParameter(1, 'romanb');\n\n $users = $query->getResult();\n\nForeign keys are used by Doctrine for lazy-loading purposes when\nquerying for objects. In the previous example, each user object in\nthe result will have a proxy (a \"ghost\") in place of the address\nthat contains the address\\_id. When the ghost proxy is accessed, it\nloads itself based on this key.\n\nConsequently, associations that are *fetch-joined* do not require\nthe foreign keys to be present in the SQL result set, only\nassociations that are lazy.\n\n.. code-block:: php\n\n addEntityResult('User', 'u');\n $rsm->addFieldResult('u', 'id', 'id');\n $rsm->addFieldResult('u', 'name', 'name');\n $rsm->addJoinedEntityResult('Address' , 'a', 'u', 'address');\n $rsm->addFieldResult('a', 'address_id', 'id');\n $rsm->addFieldResult('a', 'street', 'street');\n $rsm->addFieldResult('a', 'city', 'city');\n\n $sql = 'SELECT u.id, u.name, a.id AS address_id, a.street, a.city FROM users u ' .\n 'INNER JOIN address a ON u.address_id = a.id WHERE u.name = ?';\n $query = $this->_em->createNativeQuery($sql, $rsm);\n $query->setParameter(1, 'romanb');\n\n $users = $query->getResult();\n\nIn this case the nested entity ``Address`` is registered with the\n``ResultSetMapping#addJoinedEntityResult`` method, which notifies\nDoctrine that this entity is not hydrated at the root level, but as\na joined entity somewhere inside the object graph. In this case we\nspecify the alias 'u' as third parameter and ``address`` as fourth\nparameter, which means the ``Address`` is hydrated into the\n``User::$address`` property.\n\nIf a fetched entity is part of a mapped hierarchy that requires a\ndiscriminator column, this column must be present in the result set\nas a meta column so that Doctrine can create the appropriate\nconcrete type. This is shown in the following example where we\nassume that there are one or more subclasses that extend User and\neither Class Table Inheritance or Single Table Inheritance is used\nto map the hierarchy (both use a discriminator column).\n\n.. code-block:: php\n\n addEntityResult('User', 'u');\n $rsm->addFieldResult('u', 'id', 'id');\n $rsm->addFieldResult('u', 'name', 'name');\n $rsm->addMetaResult('u', 'discr', 'discr'); // discriminator column\n $rsm->setDiscriminatorColumn('u', 'discr');\n\n $query = $this->_em->createNativeQuery('SELECT id, name, discr FROM users WHERE name = ?', $rsm);\n $query->setParameter(1, 'romanb');\n\n $users = $query->getResult();\n\nNote that in the case of Class Table Inheritance, an example as\nabove would result in partial objects if any objects in the result\nare actually a subtype of User. When using DQL, Doctrine\nautomatically includes the necessary joins for this mapping\nstrategy but with native SQL it is your responsibility.\n"
},
{
"path": "docs/en/reference/partial-hydration.rst",
"content": "Partial Hydration\n=================\n\nPartial hydration of entities is allowed in the array hydrator, when\nonly a subset of the fields of an entity are loaded from the database\nand the nested results are still created based on the entity relationship structure.\n\n.. code-block:: php\n\n createQuery(\"SELECT PARTIAL u.{id,name}, partial a.{id,street} FROM MyApp\\Domain\\User u JOIN u.addresses a\")\n ->getArrayResult();\n\nThis is a useful optimization when you are not interested in all fields of an entity\nfor performance reasons, for example in use-cases for exporting or rendering lots of data.\n"
},
{
"path": "docs/en/reference/partial-objects.rst",
"content": "Partial Objects\n===============\n\nA partial object is an object whose state is not fully initialized\nafter being reconstituted from the database and that is\ndisconnected from the rest of its data. The following section will\ndescribe why partial objects are problematic and what the approach\nof Doctrine to this problem is.\n\n.. note::\n\n The partial object problem in general does not apply to\n methods or queries where you do not retrieve the query result as\n objects. Examples are: ``Query#getArrayResult()``,\n ``Query#getScalarResult()``, ``Query#getSingleScalarResult()``,\n etc.\n\n.. warning::\n\n Use of partial objects is tricky. Fields that are not retrieved\n from the database will not be updated by the UnitOfWork even if they\n get changed in your objects. You can only promote a partial object\n to a fully-loaded object by calling ``EntityManager#refresh()``\n or a DQL query with the refresh flag.\n\n\nWhat is the problem?\n--------------------\n\nIn short, partial objects are problematic because they are usually\nobjects with broken invariants. As such, code that uses these\npartial objects tends to be very fragile and either needs to \"know\"\nwhich fields or methods can be safely accessed or add checks around\nevery field access or method invocation. The same holds true for\nthe internals, i.e. the method implementations, of such objects.\nYou usually simply assume the state you need in the method is\navailable, after all you properly constructed this object before\nyou pushed it into the database, right? These blind assumptions can\nquickly lead to null reference errors when working with such\npartial objects.\n\nIt gets worse with the scenario of an optional association (0..1 to\n1). When the associated field is NULL, you don't know whether this\nobject does not have an associated object or whether it was simply\nnot loaded when the owning object was loaded from the database.\n\nThese are reasons why many ORMs do not allow partial objects at all\nand instead you always have to load an object with all its fields\n(associations being proxied). One secure way to allow partial\nobjects is if the programming language/platform allows the ORM tool\nto hook deeply into the object and instrument it in such a way that\nindividual fields (not only associations) can be loaded lazily on\nfirst access. This is possible in Java, for example, through\nbytecode instrumentation. In PHP though this is not possible, so\nthere is no way to have \"secure\" partial objects in an ORM with\ntransparent persistence.\n\nDoctrine, by default, does not allow partial objects. That means,\nany query that only selects partial object data and wants to\nretrieve the result as objects (i.e. ``Query#getResult()``) will\nraise an exception telling you that partial objects are dangerous.\nIf you want to force a query to return you partial objects,\npossibly as a performance tweak, you can use the ``partial``\nkeyword as follows:\n\n.. code-block:: php\n\n createQuery(\"select partial u.{id,name} from MyApp\\Domain\\User u\");\n\nYou can also get a partial reference instead of a proxy reference by\ncalling:\n\n.. code-block:: php\n\n getPartialReference('MyApp\\Domain\\User', 1);\n\nPartial references are objects with only the identifiers set as they\nare passed to the second argument of the ``getPartialReference()`` method.\nAll other fields are null.\n\nWhen should I force partial objects?\n------------------------------------\n\nMainly for optimization purposes, but be careful of premature\noptimization as partial objects lead to potentially more fragile\ncode.\n"
},
{
"path": "docs/en/reference/php-mapping.rst",
"content": "PHP Mapping\n===========\n\nDoctrine ORM also allows you to provide the ORM metadata in the form of plain\nPHP code using the ``ClassMetadata`` API. You can write the code in inside of a\nstatic function named ``loadMetadata($class)`` on the entity class itself.\n\nStatic Function\n---------------\n\nIn addition to other drivers using configuration languages you can also\nprogramatically specify your mapping information inside of a static function\ndefined on the entity class itself.\n\nThis is useful for cases where you want to keep your entity and mapping\ninformation together but don't want to use attributes. For this you just\nneed to use the ``StaticPHPDriver``:\n\n.. code-block:: php\n\n getConfiguration()->setMetadataDriverImpl($driver);\n\nNow you just need to define a static function named\n``loadMetadata($metadata)`` on your entity:\n\n.. code-block:: php\n\n mapField(array(\n 'id' => true,\n 'fieldName' => 'id',\n 'type' => 'integer'\n ));\n\n $metadata->mapField(array(\n 'fieldName' => 'username',\n 'type' => 'string'\n ));\n }\n }\n\nClassMetadataBuilder\n--------------------\n\nTo ease the use of the ClassMetadata API (which is very raw) there is a ``ClassMetadataBuilder`` that you can use.\n\n.. code-block:: php\n\n createField('id', 'integer')->isPrimaryKey()->generatedValue()->build();\n $builder->addField('username', 'string');\n }\n }\n\nThe API of the ClassMetadataBuilder has the following methods with a fluent interface:\n\n- ``addField($name, $type, array $mapping)``\n- ``setMappedSuperclass()``\n- ``setReadOnly()``\n- ``setCustomRepositoryClass($className)``\n- ``setTable($name)``\n- ``addIndex(array $columns, $indexName)``\n- ``addUniqueConstraint(array $columns, $constraintName)``\n- ``setJoinedTableInheritance()``\n- ``setSingleTableInheritance()``\n- ``setDiscriminatorColumn($name, $type = 'string', $length = 255, $columnDefinition = null, $enumType = null, $options = [])``\n- ``addDiscriminatorMapClass($name, $class)``\n- ``setChangeTrackingPolicyDeferredExplicit()``\n- ``addLifecycleEvent($methodName, $event)``\n- ``addManyToOne($name, $targetEntity, $inversedBy = null)``\n- ``addInverseOneToOne($name, $targetEntity, $mappedBy)``\n- ``addOwningOneToOne($name, $targetEntity, $inversedBy = null)``\n- ``addOwningManyToMany($name, $targetEntity, $inversedBy = null)``\n- ``addInverseManyToMany($name, $targetEntity, $mappedBy)``\n- ``addOneToMany($name, $targetEntity, $mappedBy)``\n\nIt also has several methods that create builders (which are necessary for advanced mappings):\n\n- ``createField($name, $type)`` returns a ``FieldBuilder`` instance\n- ``createManyToOne($name, $targetEntity)`` returns an ``AssociationBuilder`` instance\n- ``createOneToOne($name, $targetEntity)`` returns an ``AssociationBuilder`` instance\n- ``createManyToMany($name, $targetEntity)`` returns an ``ManyToManyAssociationBuilder`` instance\n- ``createOneToMany($name, $targetEntity)`` returns an ``OneToManyAssociationBuilder`` instance\n\nClassMetadata API\n-----------------\n\nThe ``ClassMetadata`` class is the data object for storing the mapping\nmetadata for a single entity. It contains all the getters and setters\nyou need populate and retrieve information for an entity.\n\nGeneral Setters\n~~~~~~~~~~~~~~~\n\n\n- ``setTableName($tableName)``\n- ``setPrimaryTable(array $primaryTableDefinition)``\n- ``setCustomRepositoryClass($repositoryClassName)``\n- ``setIdGeneratorType($generatorType)``\n- ``setIdGenerator($generator)``\n- ``setSequenceGeneratorDefinition(array $definition)``\n- ``setChangeTrackingPolicy($policy)``\n- ``setIdentifier(array $identifier)``\n\nInheritance Setters\n~~~~~~~~~~~~~~~~~~~\n\n\n- ``setInheritanceType($type)``\n- ``setSubclasses(array $subclasses)``\n- ``setParentClasses(array $classNames)``\n- ``setDiscriminatorColumn($columnDef)``\n- ``setDiscriminatorMap(array $map)``\n\nField Mapping Setters\n~~~~~~~~~~~~~~~~~~~~~\n\n\n- ``mapField(array $mapping)``\n- ``mapOneToOne(array $mapping)``\n- ``mapOneToMany(array $mapping)``\n- ``mapManyToOne(array $mapping)``\n- ``mapManyToMany(array $mapping)``\n\nLifecycle Callback Setters\n~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n\n- ``addLifecycleCallback($callback, $event)``\n- ``setLifecycleCallbacks(array $callbacks)``\n\nVersioning Setters\n~~~~~~~~~~~~~~~~~~\n\n\n- ``setVersionMapping(array &$mapping)``\n- ``setVersioned($bool)``\n- ``setVersionField()``\n\nGeneral Getters\n~~~~~~~~~~~~~~~\n\n\n- ``getTableName()``\n- ``getSchemaName()``\n- ``getTemporaryIdTableName()``\n\nIdentifier Getters\n~~~~~~~~~~~~~~~~~~\n\n\n- ``getIdentifierColumnNames()``\n- ``usesIdGenerator()``\n- ``isIdentifier($fieldName)``\n- ``isIdGeneratorIdentity()``\n- ``isIdGeneratorSequence()``\n- ``isIdGeneratorTable()``\n- ``isIdentifierNatural()``\n- ``getIdentifierFieldNames()``\n- ``getSingleIdentifierFieldName()``\n- ``getSingleIdentifierColumnName()``\n\nInheritance Getters\n~~~~~~~~~~~~~~~~~~~\n\n\n- ``isInheritanceTypeNone()``\n- ``isInheritanceTypeJoined()``\n- ``isInheritanceTypeSingleTable()``\n- ``isInheritedField($fieldName)``\n- ``isInheritedAssociation($fieldName)``\n\nChange Tracking Getters\n~~~~~~~~~~~~~~~~~~~~~~~\n\n\n- ``isChangeTrackingDeferredExplicit()``\n- ``isChangeTrackingDeferredImplicit()``\n\nField & Association Getters\n~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n\n- ``isUniqueField($fieldName)``\n- ``isNullable($fieldName)``\n- ``isIndexed($fieldName)``\n- ``getColumnName($fieldName)``\n- ``getFieldMapping($fieldName)``\n- ``getAssociationMapping($fieldName)``\n- ``getAssociationMappings()``\n- ``getFieldName($columnName)``\n- ``hasField($fieldName)``\n- ``getColumnNames(array $fieldNames = null)``\n- ``getTypeOfField($fieldName)``\n- ``getTypeOfColumn($columnName)``\n- ``hasAssociation($fieldName)``\n- ``isSingleValuedAssociation($fieldName)``\n- ``isCollectionValuedAssociation($fieldName)``\n\nLifecycle Callback Getters\n~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n\n- ``hasLifecycleCallbacks($lifecycleEvent)``\n- ``getLifecycleCallbacks($event)``\n\nRuntime reflection methods\n~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nThese are methods related to runtime reflection for working with the\nentities themselves.\n\n\n- ``getReflectionClass()``\n- ``getReflectionProperties()``\n- ``getReflectionProperty($name)``\n- ``getSingleIdReflectionProperty()``\n- ``getIdentifierValues($entity)``\n- ``setIdentifierValues($entity, $id)``\n- ``setFieldValue($entity, $field, $value)``\n- ``getFieldValue($entity, $field)``\n"
},
{
"path": "docs/en/reference/query-builder.rst",
"content": "The QueryBuilder\n================\n\nA ``QueryBuilder`` provides an API that is designed for\nconditionally constructing a DQL query in several steps.\n\nIt provides a set of classes and methods that is able to\nprogrammatically build queries, and also provides a fluent API.\nThis means that you can change between one methodology to the other\nas you want, or just pick a preferred one.\n\n.. note::\n\n The ``QueryBuilder`` is not an abstraction of DQL, but merely a tool to dynamically build it.\n You should still use plain DQL when you can, as it is simpler and more readable.\n More about this in the :doc:`FAQ `.\n\nConstructing a new QueryBuilder object\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nThe same way you build a normal Query, you build a ``QueryBuilder``\nobject. Here is an example of how to build a ``QueryBuilder``\nobject:\n\n.. code-block:: php\n\n createQueryBuilder();\n\nAn instance of QueryBuilder has several informative methods. One\ngood example is to inspect what type of object the\n``QueryBuilder`` is.\n\n.. code-block:: php\n\n getType(); // Prints: 0\n\nThere're currently 3 possible return values for ``getType()``:\n\n\n- ``QueryBuilder::SELECT``, which returns value 0\n- ``QueryBuilder::DELETE``, returning value 1\n- ``QueryBuilder::UPDATE``, which returns value 2\n\nIt is possible to retrieve the associated ``EntityManager`` of the\ncurrent ``QueryBuilder``, its DQL and also a ``Query`` object when\nyou finish building your DQL.\n\n.. code-block:: php\n\n getEntityManager();\n\n // example4: retrieve the DQL string of what was defined in QueryBuilder\n $dql = $qb->getDql();\n\n // example5: retrieve the associated Query object with the processed DQL\n $q = $qb->getQuery();\n\nInternally, ``QueryBuilder`` works with a DQL cache to increase\nperformance. Any changes that may affect the generated DQL actually\nmodifies the state of ``QueryBuilder`` to a stage we call\nSTATE\\_DIRTY. One ``QueryBuilder`` can be in two different states:\n\n\n- ``QueryBuilder::STATE_CLEAN``, which means DQL haven't been\n altered since last retrieval or nothing were added since its\n instantiation\n- ``QueryBuilder::STATE_DIRTY``, means DQL query must (and will)\n be processed on next retrieval\n\nWorking with QueryBuilder\n~~~~~~~~~~~~~~~~~~~~~~~~~\n\n\nHigh level API methods\n^^^^^^^^^^^^^^^^^^^^^^\n\nThe most straightforward way to build a dynamic query with the ``QueryBuilder`` is by taking\nadvantage of Helper methods. For all base code, there is a set of\nuseful methods to simplify a programmer's life. To illustrate how\nto work with them, here is the same example 6 re-written using\n``QueryBuilder`` helper methods:\n\n.. code-block:: php\n\n select('u')\n ->from('User', 'u')\n ->where('u.id = ?1')\n ->orderBy('u.name', 'ASC');\n\n``QueryBuilder`` helper methods are considered the standard way to\nuse the ``QueryBuilder``. The ``$qb->expr()->*`` methods can help you\nbuild conditional expressions dynamically. Here is a converted example 8 to\nsuggested way to build queries with dynamic conditions:\n\n.. code-block:: php\n\n select(array('u')) // string 'u' is converted to array internally\n ->from('User', 'u')\n ->where($qb->expr()->orX(\n $qb->expr()->eq('u.id', '?1'),\n $qb->expr()->like('u.nickname', '?2')\n ))\n ->orderBy('u.surname', 'ASC');\n\nHere is a complete list of helper methods available in ``QueryBuilder``:\n\n.. code-block:: php\n\n select('u')\n // Example - $qb->select(array('u', 'p'))\n // Example - $qb->select($qb->expr()->select('u', 'p'))\n public function select($select = null);\n\n // addSelect does not override previous calls to select\n //\n // Example - $qb->select('u');\n // ->addSelect('p.area_code');\n public function addSelect($select = null);\n\n // Example - $qb->delete('User', 'u')\n public function delete($delete = null, $alias = null);\n\n // Example - $qb->update('Group', 'g')\n public function update($update = null, $alias = null);\n\n // Example - $qb->set('u.firstName', $qb->expr()->literal('Arnold'))\n // Example - $qb->set('u.numChilds', 'u.numChilds + ?1')\n // Example - $qb->set('u.numChilds', $qb->expr()->sum('u.numChilds', '?1'))\n public function set($key, $value);\n\n // Example - $qb->from('Phonenumber', 'p')\n // Example - $qb->from('Phonenumber', 'p', 'p.id')\n public function from($from, $alias, $indexBy = null);\n\n // Example - $qb->join('u.Group', 'g', Expr\\Join::WITH, $qb->expr()->eq('u.status_id', '?1'))\n // Example - $qb->join('u.Group', 'g', 'WITH', 'u.status = ?1')\n // Example - $qb->join('u.Group', 'g', 'WITH', 'u.status = ?1', 'g.id')\n public function join($join, $alias, $conditionType = null, $condition = null, $indexBy = null);\n\n // Example - $qb->innerJoin('u.Group', 'g', Expr\\Join::WITH, $qb->expr()->eq('u.status_id', '?1'))\n // Example - $qb->innerJoin('u.Group', 'g', 'WITH', 'u.status = ?1')\n // Example - $qb->innerJoin('u.Group', 'g', 'WITH', 'u.status = ?1', 'g.id')\n public function innerJoin($join, $alias, $conditionType = null, $condition = null, $indexBy = null);\n\n // Example - $qb->leftJoin('u.Phonenumbers', 'p', Expr\\Join::WITH, $qb->expr()->eq('p.area_code', 55))\n // Example - $qb->leftJoin('u.Phonenumbers', 'p', 'WITH', 'p.area_code = 55')\n // Example - $qb->leftJoin('u.Phonenumbers', 'p', 'WITH', 'p.area_code = 55', 'p.id')\n public function leftJoin($join, $alias, $conditionType = null, $condition = null, $indexBy = null);\n\n // NOTE: ->where() overrides all previously set conditions\n //\n // Example - $qb->where('u.firstName = ?1', $qb->expr()->eq('u.surname', '?2'))\n // Example - $qb->where($qb->expr()->andX($qb->expr()->eq('u.firstName', '?1'), $qb->expr()->eq('u.surname', '?2')))\n // Example - $qb->where('u.firstName = ?1 AND u.surname = ?2')\n public function where($where);\n\n // NOTE: ->andWhere() can be used directly, without any ->where() before\n //\n // Example - $qb->andWhere($qb->expr()->orX($qb->expr()->lte('u.age', 40), 'u.numChild = 0'))\n public function andWhere($where);\n\n // Example - $qb->orWhere($qb->expr()->between('u.id', 1, 10));\n public function orWhere($where);\n\n // NOTE: -> groupBy() overrides all previously set grouping conditions\n //\n // Example - $qb->groupBy('u.id')\n public function groupBy($groupBy);\n\n // Example - $qb->addGroupBy('g.name')\n public function addGroupBy($groupBy);\n\n // NOTE: -> having() overrides all previously set having conditions\n //\n // Example - $qb->having('u.salary >= ?1')\n // Example - $qb->having($qb->expr()->gte('u.salary', '?1'))\n public function having($having);\n\n // Example - $qb->andHaving($qb->expr()->gt($qb->expr()->count('u.numChild'), 0))\n public function andHaving($having);\n\n // Example - $qb->orHaving($qb->expr()->lte('g.managerLevel', '100'))\n public function orHaving($having);\n\n // NOTE: -> orderBy() overrides all previously set ordering conditions\n //\n // Example - $qb->orderBy('u.surname', 'DESC')\n public function orderBy($sort, $order = null);\n\n // Example - $qb->addOrderBy('u.firstName')\n public function addOrderBy($sort, $order = null); // Default $order = 'ASC'\n }\n\nBinding parameters to your query\n^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n\nDoctrine supports dynamic binding of parameters to your query,\nsimilar to preparing queries. You can use both strings and numbers\nas placeholders, although both have a slightly different syntax.\nAdditionally, you must make your choice: Mixing both styles is not\nallowed. Binding parameters can simply be achieved as follows:\n\n.. code-block:: php\n\n select('u')\n ->from('User', 'u')\n ->where('u.id = ?1')\n ->orderBy('u.name', 'ASC')\n ->setParameter(1, 100); // Sets ?1 to 100, and thus we will fetch a user with u.id = 100\n\nYou are not forced to enumerate your placeholders as the\nalternative syntax is available:\n\n.. code-block:: php\n\n select('u')\n ->from('User', 'u')\n ->where('u.id = :identifier')\n ->orderBy('u.name', 'ASC')\n ->setParameter('identifier', 100); // Sets :identifier to 100, and thus we will fetch a user with u.id = 100\n\nNote that numeric placeholders start with a ? followed by a number\nwhile the named placeholders start with a : followed by a string.\n\nCalling ``setParameter()`` automatically infers which type you are setting as\nvalue. This works for integers, arrays of strings/integers, DateTime instances\nand for managed entities. If you want to set a type explicitly you can call\nthe third argument to ``setParameter()`` explicitly. It accepts either a DBAL\n``Doctrine\\DBAL\\ParameterType::*`` or a DBAL Type name for conversion.\n\n.. note::\n\n Even though passing DateTime instance is allowed, it impacts performance \n as by default there is an attempt to load metadata for object, and if it's not found, \n type is inferred from the original value.\n \n.. code-block:: php\n\n setParameter('date', new \\DateTimeImmutable(), Types::DATETIME_IMMUTABLE)\n\nIf you've got several parameters to bind to your query, you can\nalso use setParameters() instead of setParameter() with the\nfollowing syntax:\n\n.. code-block:: php\n\n setParameters(new ArrayCollection([\n new Parameter('1', 'value for ?1'),\n new Parameter('2', 'value for ?2')\n ]));\n\nGetting already bound parameters is easy - simply use the above\nmentioned syntax with \"getParameter()\" or \"getParameters()\":\n\n.. code-block:: php\n\n getParameters();\n // $params instanceof \\Doctrine\\Common\\Collections\\ArrayCollection\n\n // Equivalent to\n $param = $qb->getParameter(1);\n // $param instanceof \\Doctrine\\ORM\\Query\\Parameter\n\nNote: If you try to get a parameter that was not bound yet,\ngetParameter() simply returns NULL.\n\nThe API of a Query Parameter is:\n\n.. code-block:: php\n\n namespace Doctrine\\ORM\\Query;\n\n class Parameter\n {\n public function getName();\n public function getValue();\n public function getType();\n public function setValue($value, $type = null);\n }\n\nLimiting the Result\n^^^^^^^^^^^^^^^^^^^\n\nTo limit a result the query builder has some methods in common with\nthe Query object which can be retrieved from ``EntityManager#createQuery()``.\n\n.. code-block:: php\n\n add('select', 'u')\n ->add('from', 'User u')\n ->add('orderBy', 'u.name ASC')\n ->setFirstResult( $offset )\n ->setMaxResults( $limit );\n\nExecuting a Query\n^^^^^^^^^^^^^^^^^\n\nThe QueryBuilder is only a builder object - it has no means of actually\nexecuting the Query. Additional functionality, such as enabling the result cache,\ncannot be set on the QueryBuilder itself. This is why you must always convert\na QueryBuilder instance into a Query object:\n\n.. code-block:: php\n\n getQuery();\n\n // Enable the result cache\n $query->enableResultCache(3600, 'my_custom_id');\n\n // Execute Query\n $result = $query->getResult();\n $iterableResult = $query->toIterable();\n $single = $query->getSingleResult();\n $array = $query->getArrayResult();\n $scalar = $query->getScalarResult();\n $singleScalar = $query->getSingleScalarResult();\n\nThe Expr class\n^^^^^^^^^^^^^^\n\nTo workaround some of the issues that ``add()`` method may cause,\nDoctrine created a class that can be considered as a helper for\nbuilding expressions. This class is called ``Expr``, which provides a\nset of useful methods to help build expressions:\n\n.. code-block:: php\n\n add('select', new Expr\\Select(array('u')))\n ->add('from', new Expr\\From('User', 'u'))\n ->add('where', $qb->expr()->orX(\n $qb->expr()->eq('u.id', '?1'),\n $qb->expr()->like('u.nickname', '?2')\n ))\n ->add('orderBy', new Expr\\OrderBy('u.name', 'ASC'));\n\nAlthough it still sounds complex, the ability to programmatically\ncreate conditions are the main feature of ``Expr``. Here it is a\ncomplete list of supported helper methods available:\n\n.. code-block:: php\n\n expr()->andX($cond1 [, $condN])->add(...)->...\n public function andX($x = null); // Returns Expr\\AndX instance\n\n // Example - $qb->expr()->orX($cond1 [, $condN])->add(...)->...\n public function orX($x = null); // Returns Expr\\OrX instance\n\n\n /** Comparison objects **/\n\n // Example - $qb->expr()->eq('u.id', '?1') => u.id = ?1\n public function eq($x, $y); // Returns Expr\\Comparison instance\n\n // Example - $qb->expr()->neq('u.id', '?1') => u.id <> ?1\n public function neq($x, $y); // Returns Expr\\Comparison instance\n\n // Example - $qb->expr()->lt('u.id', '?1') => u.id < ?1\n public function lt($x, $y); // Returns Expr\\Comparison instance\n\n // Example - $qb->expr()->lte('u.id', '?1') => u.id <= ?1\n public function lte($x, $y); // Returns Expr\\Comparison instance\n\n // Example - $qb->expr()->gt('u.id', '?1') => u.id > ?1\n public function gt($x, $y); // Returns Expr\\Comparison instance\n\n // Example - $qb->expr()->gte('u.id', '?1') => u.id >= ?1\n public function gte($x, $y); // Returns Expr\\Comparison instance\n\n // Example - $qb->expr()->isNull('u.id') => u.id IS NULL\n public function isNull($x); // Returns string\n\n // Example - $qb->expr()->isNotNull('u.id') => u.id IS NOT NULL\n public function isNotNull($x); // Returns string\n\n // Example - $qb->expr()->isMemberOf('?1', 'u.groups') => ?1 MEMBER OF u.groups\n public function isMemberOf($x, $y); // Returns Expr\\Comparison instance\n\n // Example - $qb->expr()->isInstanceOf('u', Employee::class) => u INSTANCE OF Employee\n public function isInstanceOf($x, $y); // Returns Expr\\Comparison instance\n\n\n /** Arithmetic objects **/\n\n // Example - $qb->expr()->prod('u.id', '2') => u.id * 2\n public function prod($x, $y); // Returns Expr\\Math instance\n\n // Example - $qb->expr()->diff('u.id', '2') => u.id - 2\n public function diff($x, $y); // Returns Expr\\Math instance\n\n // Example - $qb->expr()->sum('u.id', '2') => u.id + 2\n public function sum($x, $y); // Returns Expr\\Math instance\n\n // Example - $qb->expr()->quot('u.id', '2') => u.id / 2\n public function quot($x, $y); // Returns Expr\\Math instance\n\n\n /** Pseudo-function objects **/\n\n // Example - $qb->expr()->exists($qb2->getDql())\n public function exists($subquery); // Returns Expr\\Func instance\n\n // Example - $qb->expr()->all($qb2->getDql())\n public function all($subquery); // Returns Expr\\Func instance\n\n // Example - $qb->expr()->some($qb2->getDql())\n public function some($subquery); // Returns Expr\\Func instance\n\n // Example - $qb->expr()->any($qb2->getDql())\n public function any($subquery); // Returns Expr\\Func instance\n\n // Example - $qb->expr()->not($qb->expr()->eq('u.id', '?1'))\n public function not($restriction); // Returns Expr\\Func instance\n\n // Example - $qb->expr()->in('u.id', array(1, 2, 3))\n // Make sure that you do NOT use something similar to $qb->expr()->in('value', array('stringvalue')) as this will cause Doctrine to throw an Exception.\n // Instead, use $qb->expr()->in('value', array('?1')) and bind your parameter to ?1 (see section above)\n public function in($x, $y); // Returns Expr\\Func instance\n\n // Example - $qb->expr()->notIn('u.id', '2')\n public function notIn($x, $y); // Returns Expr\\Func instance\n\n // Example - $qb->expr()->like('u.firstname', $qb->expr()->literal('Gui%'))\n public function like($x, $y); // Returns Expr\\Comparison instance\n\n // Example - $qb->expr()->notLike('u.firstname', $qb->expr()->literal('Gui%'))\n public function notLike($x, $y); // Returns Expr\\Comparison instance\n\n // Example - $qb->expr()->between('u.id', '1', '10')\n public function between($val, $x, $y); // Returns Expr\\Func\n\n\n /** Function objects **/\n\n // Example - $qb->expr()->trim('u.firstname')\n public function trim($x); // Returns Expr\\Func\n\n // Example - $qb->expr()->concat('u.firstname', $qb->expr()->concat($qb->expr()->literal(' '), 'u.lastname'))\n public function concat($x, $y); // Returns Expr\\Func\n\n // Example - $qb->expr()->substring('u.firstname', 0, 1)\n public function substring($x, $from, $len); // Returns Expr\\Func\n\n // Example - $qb->expr()->lower('u.firstname')\n public function lower($x); // Returns Expr\\Func\n\n // Example - $qb->expr()->upper('u.firstname')\n public function upper($x); // Returns Expr\\Func\n\n // Example - $qb->expr()->length('u.firstname')\n public function length($x); // Returns Expr\\Func\n\n // Example - $qb->expr()->avg('u.age')\n public function avg($x); // Returns Expr\\Func\n\n // Example - $qb->expr()->max('u.age')\n public function max($x); // Returns Expr\\Func\n\n // Example - $qb->expr()->min('u.age')\n public function min($x); // Returns Expr\\Func\n\n // Example - $qb->expr()->abs('u.currentBalance')\n public function abs($x); // Returns Expr\\Func\n\n // Example - $qb->expr()->sqrt('u.currentBalance')\n public function sqrt($x); // Returns Expr\\Func\n\n // Example - $qb->expr()->mod('u.currentBalance', '10')\n public function mod($x); // Returns Expr\\Func\n\n // Example - $qb->expr()->count('u.firstname')\n public function count($x); // Returns Expr\\Func\n\n // Example - $qb->expr()->countDistinct('u.surname')\n public function countDistinct($x); // Returns Expr\\Func\n }\n\nAdding a Criteria to a Query\n^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n\nYou can also add a :ref:`filtering-collections` to a QueryBuilder by\nusing ``addCriteria``:\n\n.. code-block:: php\n\n orderBy(['firstName' => Criteria::ASC]);\n\n // $qb instanceof QueryBuilder\n $qb->addCriteria($criteria);\n // then execute your query like normal\n\nAdding hints to a Query\n^^^^^^^^^^^^^^^^^^^^^^^\n\nYou can also set query hints to a QueryBuilder by using ``setHint``:\n\n.. code-block:: php\n\n setHint('hintName', 'hintValue');\n // then execute your query like normal\n\nThe query hint can hold anything the usual query hints can hold\nexcept null. Those hints will be applied to the query when the\nquery is created.\n\nLow Level API\n^^^^^^^^^^^^^\n\nNow we will describe the low level method of creating queries.\nIt may be useful to work at this level for optimization purposes,\nbut most of the time it is preferred to work at a higher level of\nabstraction.\n\nAll helper methods in ``QueryBuilder`` actually rely on a single\none: ``add()``. This method is responsible of building every piece\nof DQL. It takes 3 parameters: ``$dqlPartName``, ``$dqlPart`` and\n``$append`` (default=false)\n\n\n- ``$dqlPartName``: Where the ``$dqlPart`` should be placed.\n Possible values: select, from, where, groupBy, having, orderBy\n- ``$dqlPart``: What should be placed in ``$dqlPartName``. Accepts\n a string or any instance of ``Doctrine\\ORM\\Query\\Expr\\*``\n- ``$append``: Optional flag (default=false) if the ``$dqlPart``\n should override all previously defined items in ``$dqlPartName`` or\n not (no effect on the ``where`` and ``having`` DQL query parts,\n which always override all previously defined items)\n\n.. code-block:: php\n\n add('select', 'u')\n ->add('from', 'User u')\n ->add('where', 'u.id = ?1')\n ->add('orderBy', 'u.name ASC');\n\nExpr\\* classes\n^^^^^^^^^^^^^^\n\nWhen you call ``add()`` with string, it internally evaluates to an\ninstance of ``Doctrine\\ORM\\Query\\Expr\\Expr\\*`` class. Here is the\nsame query of example 6 written using\n``Doctrine\\ORM\\Query\\Expr\\Expr\\*`` classes:\n\n.. code-block:: php\n\n add('select', new Expr\\Select(array('u')))\n ->add('from', new Expr\\From('User', 'u'))\n ->add('where', new Expr\\Comparison('u.id', '=', '?1'))\n ->add('orderBy', new Expr\\OrderBy('u.name', 'ASC'));\n\nBinding Parameters to Placeholders\n----------------------------------\n\nIt is often not necessary to know about the exact placeholder names when\nbuilding a query. You can use a helper method to bind a value to a placeholder\nand directly use that placeholder in your query as a return value:\n\n.. code-block:: php\n\n select('u')\n ->from('User', 'u')\n ->where('u.email = ' . $qb->createNamedParameter($userInputEmail))\n ;\n // SELECT u FROM User u WHERE email = :dcValue1\n"
},
{
"path": "docs/en/reference/second-level-cache.rst",
"content": "The Second Level Cache\n======================\n\n.. note::\n\n The second level cache functionality is marked as experimental for now. It\n is a very complex feature and we cannot guarantee yet that it works stable\n in all cases.\n\nThe Second Level Cache is designed to reduce the amount of necessary database access.\nIt sits between your application and the database to avoid the number of database hits as much as possible.\n\nWhen turned on, entities will be first searched in cache and if they are not found,\na database query will be fired and then the entity result will be stored in a cache provider.\n\nThere are some flavors of caching available, but is better to cache read-only data.\n\nBe aware that caches are not aware of changes made to the persistent store by another application.\nThey can, however, be configured to regularly expire cached data.\n\n\nCaching Regions\n---------------\n\nSecond level cache does not store instances of an entity, instead it caches only entity identifier and values.\nEach entity class, collection association and query has its region, where values of each instance are stored.\n\nCaching Regions are specific region into the cache provider that might store entities, collection or queries.\nEach cache region resides in a specific cache namespace and has its own lifetime configuration.\n\nNotice that when caching collection and queries only identifiers are stored.\nThe entity values will be stored in its own region\n\nSomething like below for an entity region:\n\n.. code-block:: php\n\n ['id' => 1, 'name' => 'FooBar', 'associationName' => null],\n 'region_name:entity_2_hash' => ['id' => 2, 'name' => 'Foo', 'associationName' => ['id' => 11]],\n 'region_name:entity_3_hash' => ['id' => 3, 'name' => 'Bar', 'associationName' => ['id' => 22]]\n ];\n\n\nIf the entity holds a collection that also needs to be cached.\nA collection region could look something like:\n\n.. code-block:: php\n\n ['ownerId' => 1, 'list' => [1, 2, 3]],\n 'region_name:entity_2_coll_assoc_name_hash' => ['ownerId' => 2, 'list' => [2, 3]],\n 'region_name:entity_3_coll_assoc_name_hash' => ['ownerId' => 3, 'list' => [2, 4]]\n ];\n\nA query region might be something like:\n\n.. code-block:: php\n\n ['list' => [1, 2, 3]],\n 'region_name:query_2_hash' => ['list' => [2, 3]],\n 'region_name:query_3_hash' => ['list' => [2, 4]]\n ];\n\n\n.. note::\n\n The following data structures represents now the cache will looks like, this is not actual cached data.\n\n\n.. _reference-second-level-cache-regions:\n\nCache Regions\n-------------\n\n``Doctrine\\ORM\\Cache\\Region\\DefaultRegion`` is the default implementation.\n A simplest cache region compatible with all doctrine-cache drivers but does not support locking.\n``Doctrine\\ORM\\Cache\\Region`` and ``Doctrine\\ORM\\Cache\\ConcurrentRegion``\ndefine contracts that should be implemented by a cache provider.\n\nIt allows you to provide your own cache implementation that might take advantage of specific cache driver.\n\nIf you want to support locking for ``READ_WRITE`` strategies you should implement ``ConcurrentRegion``; ``CacheRegion`` otherwise.\n\n\nCache region\n~~~~~~~~~~~~\n\n``Doctrine\\ORM\\Cache\\Region`` defines a contract for accessing a particular\ncache region.\n\nConcurrent cache region\n~~~~~~~~~~~~~~~~~~~~~~~\n\nA ``Doctrine\\ORM\\Cache\\ConcurrentRegion`` is designed to store concurrently managed data region.\nBy default, Doctrine provides a very simple implementation based on file locks ``Doctrine\\ORM\\Cache\\Region\\FileLockRegion``.\n\nIf you want to use an ``READ_WRITE`` cache, you should consider providing your own cache region.\n\n``Doctrine\\ORM\\Cache\\ConcurrentRegion`` defines a contract for concurrently managed data region.\n\nTimestamp region\n~~~~~~~~~~~~~~~~\n\n``Doctrine\\ORM\\Cache\\TimestampRegion``\n\nTracks the timestamps of the most recent updates to particular entity.\n\n.. _reference-second-level-cache-mode:\n\nCaching mode\n------------\n\n* ``READ_ONLY`` (DEFAULT)\n\n * Can do reads, inserts and deletes, cannot perform updates or employ any locks.\n * Useful for data that is read frequently but never updated.\n * Best performer.\n * It is Simple.\n\n* ``NONSTRICT_READ_WRITE``\n\n * Read Write Cache doesn’t employ any locks but can do reads, inserts, updates and deletes.\n * Good if the application needs to update data rarely.\n\n\n* ``READ_WRITE``\n\n * Read Write cache employs locks before update/delete.\n * Use if data needs to be updated.\n * Slowest strategy.\n * To use it the cache region implementation must support locking.\n\n\nBuilt-in cached persisters\n~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nCached persisters are responsible to access cache regions.\n\n +-----------------------+------------------------------------------------------------------------------------------+\n | Cache Usage | Persister |\n +=======================+==========================================================================================+\n | READ_ONLY | ``Doctrine\\ORM\\Cache\\Persister\\Entity\\ReadOnlyCachedEntityPersister`` |\n +-----------------------+------------------------------------------------------------------------------------------+\n | READ_WRITE | ``Doctrine\\ORM\\Cache\\Persister\\Entity\\ReadWriteCachedEntityPersister`` |\n +-----------------------+------------------------------------------------------------------------------------------+\n | NONSTRICT_READ_WRITE | ``Doctrine\\ORM\\Cache\\Persister\\Entity\\NonStrictReadWriteCachedEntityPersister`` |\n +-----------------------+------------------------------------------------------------------------------------------+\n | READ_ONLY | ``Doctrine\\ORM\\Cache\\Persister\\Collection\\ReadOnlyCachedCollectionPersister`` |\n +-----------------------+------------------------------------------------------------------------------------------+\n | READ_WRITE | ``Doctrine\\ORM\\Cache\\Persister\\Collection\\ReadWriteCachedCollectionPersister`` |\n +-----------------------+------------------------------------------------------------------------------------------+\n | NONSTRICT_READ_WRITE | ``Doctrine\\ORM\\Cache\\Persister\\Collection\\NonStrictReadWriteCachedCollectionPersister`` |\n +-----------------------+------------------------------------------------------------------------------------------+\n\nConfiguration\n-------------\nDoctrine allows you to specify configurations and some points of extension for the second-level-cache\n\n\nEnable Second Level Cache\n~~~~~~~~~~~~~~~~~~~~~~~~~\n\nTo enable the second-level-cache, you should provide a cache factory.\n``Doctrine\\ORM\\Cache\\DefaultCacheFactory`` is the default implementation.\n\n.. code-block:: php\n\n setSecondLevelCacheEnabled();\n\n // Cache factory\n $config->getSecondLevelCacheConfiguration()\n ->setCacheFactory($factory);\n\n\nCache Factory\n~~~~~~~~~~~~~\n\nCache Factory is the main point of extension.\n\nIt allows you to provide a specific implementation of the following components:\n\n``QueryCache``\n stores and retrieves query cache results.\n``CachedEntityPersister``\n stores and retrieves entity results.\n``CachedCollectionPersister``\n stores and retrieves query results.\n``EntityHydrator``\n transforms entities into a cache entries and cache entries into entities\n``CollectionHydrator``\n transforms collections into cache entries and cache entries into collections\n\nRegion Lifetime\n~~~~~~~~~~~~~~~\n\nTo specify a default lifetime for all regions or specify a different lifetime for a specific region.\n\n.. code-block:: php\n\n getSecondLevelCacheConfiguration();\n $regionConfig = $cacheConfig->getRegionsConfiguration();\n\n // Cache Region lifetime\n $regionConfig->setLifetime('my_entity_region', 3600); // Time to live for a specific region (in seconds)\n $regionConfig->setDefaultLifetime(7200); // Default time to live (in seconds)\n\n\nCache Log\n~~~~~~~~~\nBy providing a cache logger you should be able to get information about all cache operations such as hits, misses and puts.\n\n``Doctrine\\ORM\\Cache\\Logging\\StatisticsCacheLogger`` is a built-in implementation that provides basic statistics.\n\n .. code-block:: php\n\n setSecondLevelCacheEnabled(true);\n $config->getSecondLevelCacheConfiguration()\n ->setCacheLogger($logger);\n\n\n // Collect cache statistics\n\n // Get the number of entries successfully retrieved from a specific region.\n $logger->getRegionHitCount('my_entity_region');\n\n // Get the number of cached entries *not* found in a specific region.\n $logger->getRegionMissCount('my_entity_region');\n\n // Get the number of cacheable entries put in cache.\n $logger->getRegionPutCount('my_entity_region');\n\n // Get the total number of put in all regions.\n $logger->getPutCount();\n\n // Get the total number of entries successfully retrieved from all regions.\n $logger->getHitCount();\n\n // Get the total number of cached entries *not* found in all regions.\n $logger->getMissCount();\n\nIf you want to get more information you should implement\n``Doctrine\\ORM\\Cache\\Logging\\CacheLogger`` and collect\nall the information you want.\n\nEntity cache definition\n-----------------------\n* Entity cache configuration allows you to define the caching strategy and region for an entity.\n\n * ``usage`` specifies the caching strategy: ``READ_ONLY``,\n``NONSTRICT_READ_WRITE``, ``READ_WRITE``.\nSee :ref:`reference-second-level-cache-mode`.\n * ``region`` is an optional value that specifies the name of the second\nlevel cache region.\n\n\n.. configuration-block::\n\n .. code-block:: attribute\n\n \n \n \n \n \n \n \n \n \n \n\nAssociation cache definition\n----------------------------\nThe most common use case is to cache entities. But we can also cache relationships.\nIt caches the primary keys of association and cache each element will be cached into its region.\n\n\n.. configuration-block::\n\n .. code-block:: attribute\n\n */\n #[Cache(usage: 'NONSTRICT_READ_WRITE')]\n #[OneToMany(targetEntity: City::class, mappedBy: 'state')]\n protected Collection $cities;\n\n // other properties and methods\n }\n\n .. code-block:: xml\n\n \n \n \n\n \n\n \n \n \n\n \n\n \n \n\n \n \n \n \n\n \n \n \n \n \n\n.. note::\n\n for this to work, the target entity must also be marked as cacheable.\n\nCache usage\n~~~~~~~~~~~\n\nBasic entity cache\n\n.. code-block:: php\n\n persist(new Country($name));\n $em->flush(); // Hit database to insert the row and put into cache\n\n $em->clear(); // Clear entity manager\n\n $country1 = $em->find('Country', 1); // Retrieve item from cache\n\n $country1->setName('New Name');\n\n $em->flush(); // Hit database to update the row and update cache\n\n $em->clear(); // Clear entity manager\n\n $country2 = $em->find('Country', 1); // Retrieve item from cache\n // Notice that $country1 and $country2 are not the same instance.\n\n\nAssociation cache\n\n.. code-block:: php\n\n persist(new State($name, $country));\n $em->flush();\n\n // Clear entity manager\n $em->clear();\n\n // Retrieve item from cache\n $state = $em->find('State', 1);\n\n // Hit database to update the row and update cache entry\n $state->setName('New Name');\n $em->persist($state);\n $em->flush();\n\n // Create a new collection item\n $city = new City($name, $state);\n $state->addCity($city);\n\n // Hit database to insert new collection item,\n // put entity and collection cache into cache.\n $em->persist($city);\n $em->persist($state);\n $em->flush();\n\n // Clear entity manager\n $em->clear();\n\n // Retrieve item from cache\n $state = $em->find('State', 1);\n\n // Retrieve association from cache\n $country = $state->getCountry();\n\n // Retrieve collection from cache\n $cities = $state->getCities();\n\n echo $country->getName();\n echo $state->getName();\n\n // Retrieve each collection item from cache\n foreach ($cities as $city) {\n echo $city->getName();\n }\n\n.. note::\n\n Notice that all entities should be marked as cacheable.\n\nUsing the query cache\n---------------------\n\nThe second level cache stores the entities, associations and collections.\nThe query cache stores the results of the query but as identifiers, entity values are actually stored in the 2nd level cache.\n\n.. note::\n\n Query cache should always be used in conjunction with the second-level-cache for those entities which should be cached.\n\n.. code-block:: php\n\n createQuery('SELECT c FROM Country c ORDER BY c.name')\n ->setCacheable(true)\n ->getResult();\n\n $em->clear();\n\n // Check if query result is valid and load entities from cache\n $result2 = $em->createQuery('SELECT c FROM Country c ORDER BY c.name')\n ->setCacheable(true)\n ->getResult();\n\nCache mode\n~~~~~~~~~~\n\nThe Cache Mode controls how a particular query interacts with the second-level cache:\n\n* ``Cache::MODE_GET`` - May read items from the cache, but will not add items.\n* ``Cache::MODE_PUT`` - Will never read items from the cache, but will add items to the cache as it reads them from the database.\n* ``Cache::MODE_NORMAL`` - May read items from the cache, and add items to the cache.\n* ``Cache::MODE_REFRESH`` - The query will never read items from the cache, but will refresh items to the cache as it reads them from the database.\n\n.. code-block:: php\n\n createQuery('SELECT c FROM Country c ORDER BY c.name')\n ->setCacheMode(\\Doctrine\\ORM\\Cache::MODE_GET)\n ->setCacheable(true)\n ->getResult();\n\n.. note::\n\n The default query cache mode is ```Cache::MODE_NORMAL```\n\nDELETE / UPDATE queries\n~~~~~~~~~~~~~~~~~~~~~~~\n\nDQL UPDATE / DELETE statements are ported directly into a database and bypass\nthe second-level cache.\nEntities that are already cached will NOT be invalidated.\nHowever the cached data could be evicted using the cache API or a special query hint.\n\n\nExecute the ``UPDATE`` and invalidate ``all cache entries`` using ``Query::HINT_CACHE_EVICT``\n\n.. code-block:: php\n\n _em->createQuery(\"UPDATE Entity\\Country u SET u.name = 'unknown' WHERE u.id = 1\")\n ->setHint(\\Doctrine\\ORM\\Query::HINT_CACHE_EVICT, true)\n ->execute();\n\n\nExecute the ``UPDATE`` and invalidate ``all cache entries`` using the cache API\n\n.. code-block:: php\n\n _em->createQuery(\"UPDATE Entity\\Country u SET u.name = 'unknown' WHERE u.id = 1\")\n ->execute();\n // Invoke Cache API\n $em->getCache()->evictEntityRegion('Entity\\Country');\n\n\nExecute the ``UPDATE`` and invalidate ``a specific cache entry`` using the cache API\n\n.. code-block:: php\n\n _em->createQuery(\"UPDATE Entity\\Country u SET u.name = 'unknown' WHERE u.id = 1\")\n ->execute();\n // Invoke Cache API\n $em->getCache()->evictEntity('Entity\\Country', 1);\n\nUsing the repository query cache\n--------------------------------\n\nAs well as ``Query Cache`` all persister queries store only identifier values for an individual query.\nAll persisters use a single timestamp cache region to keep track of the last update for each persister,\nWhen a query is loaded from cache, the timestamp region is checked for the last update for that persister.\nUsing the last update timestamps as part of the query key invalidate the cache key when an update occurs.\n\n.. code-block:: php\n\n getRepository('Entity\\Country')->findAll();\n\n // load from query and entities from cache..\n $entities = $em->getRepository('Entity\\Country')->findAll();\n\n // update the timestamp cache region for Country\n $em->persist(new Country('zombieland'));\n $em->flush();\n $em->clear();\n\n // Reload from database.\n // At this point the query cache key is no longer valid, the select goes straight to the database\n $entities = $em->getRepository('Entity\\Country')->findAll();\n\nCache API\n---------\n\nCaches are not aware of changes made by another application.\nHowever, you can use the cache API to check / invalidate cache entries.\n\n.. code-block:: php\n\n getCache();\n\n $cache->containsEntity('Entity\\State', 1) // Check if the cache exists\n $cache->evictEntity('Entity\\State', 1); // Remove an entity from cache\n $cache->evictEntityRegion('Entity\\State'); // Remove all entities from cache\n\n $cache->containsCollection('Entity\\State', 'cities', 1); // Check if the cache exists\n $cache->evictCollection('Entity\\State', 'cities', 1); // Remove an entity collection from cache\n $cache->evictCollectionRegion('Entity\\State', 'cities'); // Remove all collections from cache\n\nLimitations\n-----------\n\nComposite primary key\n~~~~~~~~~~~~~~~~~~~~~\n\nComposite primary key are supported by second level cache,\nhowever when one of the keys is an association the cached entity should always be retrieved using the association identifier.\nFor performance reasons the cache API does not extract from composite primary key.\n\n.. code-block:: php\n\n find('Article', 1);\n\n // Supported\n /** @var Article $article */\n $article = $em->find('Article', $article);\n\n // Supported\n $id = ['source' => 1, 'target' => 2];\n $reference = $em->find('Reference', $id);\n\n // NOT Supported\n $id = ['source' => new Article(1), 'target' => new Article(2)];\n $reference = $em->find('Reference', $id);\n\nDistributed environments\n~~~~~~~~~~~~~~~~~~~~~~~~\n\nSome cache driver are not meant to be used in a distributed environment.\nLoad-balancer for distributing workloads across multiple computing resources\nshould be used in conjunction with distributed caching system such as memcached, redis, riak ...\n\nCaches should be used with care when using a load-balancer if you don't share the cache.\nWhile using APC or any file based cache update occurred in a specific machine would not reflect to the cache in other machines.\n\n\nPaginator\n~~~~~~~~~\n\nCount queries generated by ``Doctrine\\ORM\\Tools\\Pagination\\Paginator`` are not cached by second-level cache.\nAlthough entities and query result are cached, count queries will hit the\ndatabase every time.\n"
},
{
"path": "docs/en/reference/security.rst",
"content": "Security\n========\n\nThe Doctrine library is operating very close to your database and as such needs\nto handle and make assumptions about SQL injection vulnerabilities.\n\nIt is vital that you understand how Doctrine approaches security, because\nwe cannot protect you from SQL injection.\n\nPlease also read the documentation chapter on Security in Doctrine DBAL. This\npage only handles Security issues in the ORM.\n\n- `DBAL Security Page `\n\nIf you find a Security bug in Doctrine, please follow our\n`Security reporting guidelines `_.\n\nUser input and Doctrine ORM\n---------------------------\n\nThe ORM is much better at protecting against SQL injection than the DBAL alone.\nYou can consider the following APIs to be safe from SQL injection:\n\n- ``\\Doctrine\\ORM\\EntityManager#find()`` and ``getReference()``.\n- All values on Objects inserted and updated through ``Doctrine\\ORM\\EntityManager#persist()``\n- All find methods on ``Doctrine\\ORM\\EntityRepository``.\n- User Input set to DQL Queries or QueryBuilder methods through\n - ``setParameter()`` or variants\n - ``setMaxResults()``\n - ``setFirstResult()``\n- Queries through the Criteria API on ``Doctrine\\ORM\\PersistentCollection`` and\n ``Doctrine\\ORM\\EntityRepository``.\n\nYou are **NOT** safe from SQL injection when using user input with:\n\n- Expression API of ``Doctrine\\ORM\\QueryBuilder``\n- Concatenating user input into DQL SELECT, UPDATE or DELETE statements or\n Native SQL.\n\nThis means SQL injections can only occur with Doctrine ORM when working with\nQuery Objects of any kind. The safe rule is to always use prepared statement\nparameters for user objects when using a Query object.\n\n.. warning::\n\n Insecure code follows, don't copy paste this.\n\nThe following example shows insecure DQL usage:\n\n.. code-block:: php\n\n createQuery($dql);\n $query->setParameter(1, $_GET['status']);\n\n\nPreventing Mass Assignment Vulnerabilities\n------------------------------------------\n\nORMs are very convenient for CRUD applications and Doctrine is no exception.\nHowever CRUD apps are often vulnerable to mass assignment security problems\nwhen implemented naively.\n\nDoctrine is not vulnerable to this problem out of the box, but you can easily\nmake your entities vulnerable to mass assignment when you add methods of\nthe kind ``updateFromArray()`` or ``updateFromJson()`` to them. A vulnerable\nentity might look like this:\n\n.. code-block:: php\n\n $userInput */\n public function fromArray(array $userInput): void\n {\n foreach ($userInput as $key => $value) {\n $this->$key = $value;\n }\n }\n }\n\nNow the possibility of mass-assignment exists on this entity and can\nbe exploited by attackers to set the \"isAdmin\" flag to true on any\nobject when you pass the whole request data to this method like:\n\n.. code-block:: php\n\n fromArray($_POST);\n\n $entityManager->persist($entity);\n $entityManager->flush();\n\nYou can spot this problem in this very simple example easily. However\nin combination with frameworks and form libraries it might not be\nso obvious when this issue arises. Be careful to avoid this\nkind of mistake.\n\nHow to fix this problem? You should always have a whitelist\nof allowed key to set via mass assignment functions.\n\n.. code-block:: php\n\n public function fromArray(array $userInput, $allowedFields = array())\n {\n foreach ($userInput as $key => $value) {\n if (in_array($key, $allowedFields)) {\n $this->$key = $value;\n }\n }\n }\n"
},
{
"path": "docs/en/reference/tools.rst",
"content": "Tools\n=====\n\nDoctrine Console\n----------------\n\nThe Doctrine Console is a Command Line Interface tool for simplifying common\nadministration tasks during the development of a project that uses ORM.\n\nFor the following examples, we will set up the CLI as ``bin/doctrine``.\n\nSetting Up the Console\n~~~~~~~~~~~~~~~~~~~~~~\n\nWhenever the ``doctrine`` command line tool is invoked, it can\naccess all Commands that were registered by a developer. There is no\nauto-detection mechanism at work. The Doctrine binary\nalready registers all the commands that currently ship with\nDoctrine DBAL and ORM. If you want to use additional commands you\nhave to register them yourself.\n\nAll the commands of the Doctrine Console require access to the\n``EntityManager``. You have to inject it into the console application.\n\nHere is an example of a project-specific ``bin/doctrine`` binary.\n\n.. code-block:: php\n\n #!/usr/bin/env php\n php bin/doctrine orm:generate-entities --help\n\nCommand Overview\n~~~~~~~~~~~~~~~~\n\nThe following Commands are currently available:\n\n\n- ``help`` Displays help for a command (?)\n- ``list`` Lists commands\n- ``dbal:import`` Import SQL file(s) directly to Database.\n- ``dbal:run-sql`` Executes arbitrary SQL directly from the\n command line.\n- ``orm:clear-cache:metadata`` Clear all metadata cache of the\n various cache drivers.\n- ``orm:clear-cache:query`` Clear all query cache of the various\n cache drivers.\n- ``orm:clear-cache:result`` Clear result cache of the various\n cache drivers.\n- ``orm:generate-proxies`` Generates proxy classes for entity\n classes. Deprecated in favor of using native lazy objects.\n- ``orm:run-dql`` Executes arbitrary DQL directly from the command\n line.\n- ``orm:schema-tool:create`` Processes the schema and either\n create it directly on EntityManager Storage Connection or generate\n the SQL output.\n- ``orm:schema-tool:drop`` Processes the schema and either drop\n the database schema of EntityManager Storage Connection or generate\n the SQL output.\n- ``orm:schema-tool:update`` Processes the schema and either\n update the database schema of EntityManager Storage Connection or\n generate the SQL output.\n- ``orm:debug:event-manager`` Lists event listeners for an entity\n manager, optionally filtered by event name.\n- ``orm:debug:entity-listeners`` Lists entity listeners for a given\n entity, optionally filtered by event name.\n\nThe following alias is defined:\n\n\n- ``orm:generate:proxies`` is alias for ``orm:generate-proxies``.\n\n.. note::\n\n Console also supports auto completion, for example, instead of\n ``orm:clear-cache:query`` you can use just ``o:c:q``.\n\nDatabase Schema Generation\n--------------------------\n\n.. note::\n\n SchemaTool can do harm to your database. It will drop or alter\n tables, indexes, sequences and such. Please use this tool with\n caution in development and not on a production server. It is meant\n for helping you develop your Database Schema, but NOT with\n migrating schema from A to B in production. A safe approach would\n be generating the SQL on development server and saving it into SQL\n Migration files that are executed manually on the production\n server.\n\n SchemaTool assumes your Doctrine Project uses the given database on\n its own. Update and Drop commands will mess with other tables if\n they are not related to the current project that is using Doctrine.\n Please be careful!\n\n\nTo generate your database schema from your Doctrine mapping files\nyou can use the ``SchemaTool`` class or the ``schema-tool`` Console\nCommand.\n\nWhen using the SchemaTool class directly, create your schema using\nthe ``createSchema()`` method. First create an instance of the\n``SchemaTool`` and pass it an instance of the ``EntityManager``\nthat you want to use to create the schema. This method receives an\narray of ``ClassMetadata`` instances.\n\n.. code-block:: php\n\n getClassMetadata('Entities\\User'),\n $em->getClassMetadata('Entities\\Profile')\n );\n $tool->createSchema($classes);\n\nTo drop the schema you can use the ``dropSchema()`` method.\n\n.. code-block:: php\n\n dropSchema($classes);\n\nThis drops all the tables that are currently used by your metadata\nmodel. When you are changing your metadata a lot during development\nyou might want to drop the complete database instead of only the\ntables of the current model to clean up with orphaned tables.\n\n.. code-block:: php\n\n dropSchema($classes, \\Doctrine\\ORM\\Tools\\SchemaTool::DROP_DATABASE);\n\nYou can also use database introspection to update your schema\neasily with the ``updateSchema()`` method. It will compare your\nexisting database schema to the passed array of ``ClassMetadata``\ninstances.\n\n.. code-block:: php\n\n updateSchema($classes);\n\nIf you want to use this functionality from the command line you can\nuse the ``schema-tool`` command.\n\nTo create the schema use the ``create`` command:\n\n.. code-block:: php\n\n $ php bin/doctrine orm:schema-tool:create\n\nTo drop the schema use the ``drop`` command:\n\n.. code-block:: php\n\n $ php bin/doctrine orm:schema-tool:drop\n\nIf you want to drop and then recreate the schema then use both\noptions:\n\n.. code-block:: php\n\n $ php bin/doctrine orm:schema-tool:drop\n $ php bin/doctrine orm:schema-tool:create\n\nAs you would think, if you want to update your schema use the\n``update`` command:\n\n.. code-block:: php\n\n $ php bin/doctrine orm:schema-tool:update\n\nAll of the above commands also accept a ``--dump-sql`` option that\nwill output the SQL for the ran operation.\n\n.. code-block:: php\n\n $ php bin/doctrine orm:schema-tool:create --dump-sql\n\nRuntime vs Development Mapping Validation\n-----------------------------------------\n\nFor performance reasons Doctrine ORM has to skip some of the\nnecessary validation of metadata mappings. You have to execute\nthis validation in your development workflow to verify the\nassociations are correctly defined.\n\nYou can either use the Doctrine Command Line Tool:\n\n.. code-block:: php\n\n doctrine orm:validate-schema\n\nIf the validation fails, you can change the verbosity level to\ncheck the detected errors:\n\n doctrine orm:validate-schema -v\n\nOr you can trigger the validation manually:\n\n.. code-block:: php\n\n validateMapping();\n\n if (count($errors) > 0) {\n // Lots of errors!\n echo implode(\"\\n\\n\", $errors);\n }\n\nIf the mapping is invalid the errors array contains a positive\nnumber of elements with error messages.\n\n.. warning::\n\n One mapping option that is not validated is the use of the referenced column name.\n It has to point to the equivalent primary key otherwise Doctrine will not work.\n\n.. note::\n\n One common error is to use a backlash in front of the\n fully-qualified class-name. Whenever a FQCN is represented inside a\n string (such as in your mapping definitions) you have to drop the\n prefix backslash. PHP does this with ``get_class()`` or Reflection\n methods for backwards compatibility reasons.\n\n\nAdding own commands\n-------------------\n\nYou can also add your own commands on-top of the Doctrine supported\ntools if you are using a manually built console script.\n\nTo include a new command on Doctrine Console, you need to do modify the\n``doctrine.php`` file a little:\n\n.. code-block:: php\n\n setCatchExceptions(true);\n $cli->setHelperSet($helperSet);\n\n // Register All Doctrine Commands\n ConsoleRunner::addCommands($cli);\n\n // Register your own command\n $cli->addCommand(new \\MyProject\\Tools\\Console\\Commands\\MyCustomCommand);\n\n // Runs console application\n $cli->run();\n\nAdditionally, include multiple commands (and overriding previously\ndefined ones) is possible through the command:\n\n.. code-block:: php\n\n addCommands(array(\n new \\MyProject\\Tools\\Console\\Commands\\MyCustomCommand(),\n new \\MyProject\\Tools\\Console\\Commands\\SomethingCommand(),\n new \\MyProject\\Tools\\Console\\Commands\\AnotherCommand(),\n new \\MyProject\\Tools\\Console\\Commands\\OneMoreCommand(),\n ));\n\n\nRe-use console application\n--------------------------\n\nYou are also able to retrieve and re-use the default console application.\nJust call ``ConsoleRunner::createApplication(...)`` with an appropriate\nHelperSet, like it is described in the configuration section.\n\n.. code-block:: php\n\n run();\n"
},
{
"path": "docs/en/reference/transactions-and-concurrency.rst",
"content": "Transactions and Concurrency\n============================\n\n.. _transactions-and-concurrency_transaction-demarcation:\n\nTransaction Demarcation\n-----------------------\n\nTransaction demarcation is the task of defining your transaction\nboundaries. Proper transaction demarcation is very important\nbecause if not done properly it can negatively affect the\nperformance of your application. Many databases and database\nabstraction layers like PDO by default operate in auto-commit mode,\nwhich means that every single SQL statement is wrapped in a small\ntransaction. Without any explicit transaction demarcation from your\nside, this quickly results in poor performance because transactions\nare not cheap.\n\nFor the most part, Doctrine ORM already takes care of proper\ntransaction demarcation for you: All the write operations\n(INSERT/UPDATE/DELETE) are queued until ``EntityManager#flush()``\nis invoked which wraps all of these changes in a single\ntransaction.\n\nHowever, Doctrine ORM also allows (and encourages) you to take over\nand control transaction demarcation yourself.\n\nThese are two ways to deal with transactions when using the\nDoctrine ORM and are now described in more detail.\n\n.. _transactions-and-concurrency_approach-implicitly:\n\nApproach 1: Implicitly\n~~~~~~~~~~~~~~~~~~~~~~\n\nThe first approach is to use the implicit transaction handling\nprovided by the Doctrine ORM EntityManager. Given the following\ncode snippet, without any explicit transaction demarcation:\n\n.. code-block:: php\n\n setName('George');\n $em->persist($user);\n $em->flush();\n\nSince we do not do any custom transaction demarcation in the above\ncode, ``EntityManager#flush()`` will begin and commit/rollback a\ntransaction. This behavior is made possible by the aggregation of\nthe DML operations by the Doctrine ORM and is sufficient if all the\ndata manipulation that is part of a unit of work happens through\nthe domain model and thus the ORM.\n\n.. _transactions-and-concurrency_approach-explicitly:\n\nApproach 2: Explicitly\n~~~~~~~~~~~~~~~~~~~~~~\n\nThe explicit alternative is to use the ``Doctrine\\DBAL\\Connection``\nAPI directly to control the transaction boundaries. The code then\nlooks like this:\n\n.. code-block:: php\n\n getConnection()->beginTransaction(); // suspend auto-commit\n try {\n // ... do some work\n $user = new User;\n $user->setName('George');\n $em->persist($user);\n $em->flush();\n $em->getConnection()->commit();\n } catch (Exception $e) {\n $em->getConnection()->rollBack();\n throw $e;\n }\n\nExplicit transaction demarcation is required when you want to\ninclude custom DBAL operations in a unit of work or when you want\nto make use of some methods of the ``EntityManager`` API that\nrequire an active transaction. Such methods will throw a\n``TransactionRequiredException`` to inform you of that\nrequirement.\n\nA more convenient alternative for explicit transaction demarcation is the use\nof provided control abstractions in the form of\n``Connection#transactional($func)`` and ``EntityManager#wrapInTransaction($func)``.\nWhen used, these control abstractions ensure that you never forget to rollback\nthe transaction, in addition to the obvious code reduction. An example that is\nfunctionally equivalent to the previously shown code looks as follows:\n\n.. code-block:: php\n\n transactional(function($conn) {\n // ... do some work\n $user = new User;\n $user->setName('George');\n });\n\n // transactional with EntityManager instance\n // $em instanceof EntityManager\n $em->wrapInTransaction(function($em) {\n // ... do some work\n $user = new User;\n $user->setName('George');\n $em->persist($user);\n });\n\nThe difference between ``Connection#transactional($func)`` and\n``EntityManager#transactional($func)`` is that the latter\nabstraction flushes the ``EntityManager`` prior to transaction\ncommit and in case of an exception the ``EntityManager`` gets closed\nin addition to the transaction rollback.\n\n.. _transactions-and-concurrency_exception-handling:\n\nException Handling\n~~~~~~~~~~~~~~~~~~\n\nWhen using implicit transaction demarcation and an exception occurs\nduring ``EntityManager#flush()``, the transaction is automatically\nrolled back and the ``EntityManager`` closed.\n\nWhen using explicit transaction demarcation and an exception\noccurs, the transaction should be rolled back immediately and the\n``EntityManager`` closed by invoking ``EntityManager#close()`` and\nsubsequently discarded, as demonstrated in the example above. This\ncan be handled elegantly by the control abstractions shown earlier.\nNote that when catching ``Exception`` you should generally re-throw\nthe exception. If you intend to recover from some exceptions, catch\nthem explicitly in earlier catch blocks (but do not forget to\nrollback the transaction and close the ``EntityManager`` there as\nwell). All other best practices of exception handling apply\nsimilarly (i.e. either log or re-throw, not both, etc.).\n\nAs a result of this procedure, all previously managed or removed\ninstances of the ``EntityManager`` become detached. The state of\nthe detached objects will be the state at the point at which the\ntransaction was rolled back. The state of the objects is in no way\nrolled back and thus the objects are now out of synch with the\ndatabase. The application can continue to use the detached objects,\nknowing that their state is potentially no longer accurate.\n\nIf you intend to start another unit of work after an exception has\noccurred you should do that with a new ``EntityManager``.\n\n.. _transactions-and-concurrency_locking-support:\n\nLocking Support\n---------------\n\nDoctrine ORM offers support for Pessimistic- and Optimistic-locking\nstrategies natively. This allows to take very fine-grained control\nover what kind of locking is required for your Entities in your\napplication.\n\n.. _transactions-and-concurrency_optimistic-locking:\n\nOptimistic Locking\n~~~~~~~~~~~~~~~~~~\n\nDatabase transactions are fine for concurrency control during a\nsingle request. However, a database transaction should not span\nacross requests, the so-called \"user think time\". Therefore a\nlong-running \"business transaction\" that spans multiple requests\nneeds to involve several database transactions. Thus, database\ntransactions alone can no longer control concurrency during such a\nlong-running business transaction. Concurrency control becomes the\npartial responsibility of the application itself.\n\nDoctrine has integrated support for automatic optimistic locking\nvia a version field. In this approach any entity that should be\nprotected against concurrent modifications during long-running\nbusiness transactions gets a version field that is either a simple\nnumber (mapping type: integer) or a timestamp (mapping type:\ndatetime). When changes to such an entity are persisted at the end\nof a long-running conversation the version of the entity is\ncompared to the version in the database and if they don't match, an\n``OptimisticLockException`` is thrown, indicating that the entity\nhas been modified by someone else already.\n\nYou designate a version field in an entity as follows. In this\nexample we'll use an integer.\n\n.. configuration-block::\n\n .. code-block:: attribute\n\n \n \n \n \n \n\nAlternatively a datetime type can be used (which maps to a SQL\ntimestamp or datetime):\n\n.. configuration-block::\n\n .. code-block:: attribute\n\n \n \n \n \n \n\nVersion numbers (not timestamps) should however be preferred as\nthey can not potentially conflict in a highly concurrent\nenvironment, unlike timestamps where this is a possibility,\ndepending on the resolution of the timestamp on the particular\ndatabase platform.\n\nWhen a version conflict is encountered during\n``EntityManager#flush()``, an ``OptimisticLockException`` is thrown\nand the active transaction rolled back (or marked for rollback).\nThis exception can be caught and handled. Potential responses to an\nOptimisticLockException are to present the conflict to the user or\nto refresh or reload objects in a new transaction and then retrying\nthe transaction.\n\nWith PHP promoting a share-nothing architecture, the time between\nshowing an update form and actually modifying the entity can in the\nworst scenario be as long as your applications session timeout. If\nchanges happen to the entity in that time frame you want to know\ndirectly when retrieving the entity that you will hit an optimistic\nlocking exception:\n\nYou can always verify the version of an entity during a request\neither when calling ``EntityManager#find()``:\n\n.. code-block:: php\n\n find('User', $theEntityId, LockMode::OPTIMISTIC, $expectedVersion);\n\n // do the work\n\n $em->flush();\n } catch(OptimisticLockException $e) {\n echo \"Sorry, but someone else has already changed this entity. Please apply the changes again!\";\n }\n\nOr you can use ``EntityManager#lock()`` to find out:\n\n.. code-block:: php\n\n find('User', $theEntityId);\n\n try {\n // assert version\n $em->lock($entity, LockMode::OPTIMISTIC, $expectedVersion);\n\n } catch(OptimisticLockException $e) {\n echo \"Sorry, but someone else has already changed this entity. Please apply the changes again!\";\n }\n\nImportant Implementation Notes\n^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n\nYou can easily get the optimistic locking workflow wrong if you\ncompare the wrong versions. Say you have Alice and Bob editing a\nhypothetical blog post:\n\n- Alice reads the headline of the blog post being \"Foo\", at\n optimistic lock version 1 (GET Request)\n- Bob reads the headline of the blog post being \"Foo\", at\n optimistic lock version 1 (GET Request)\n- Bob updates the headline to \"Bar\", upgrading the optimistic lock\n version to 2 (POST Request of a Form)\n- Alice updates the headline to \"Baz\", ... (POST Request of a\n Form)\n\nNow at the last stage of this scenario the blog post has to be read\nagain from the database before Alice's headline can be applied. At\nthis point you will want to check if the blog post is still at\nversion 1 (which it is not in this scenario).\n\nUsing optimistic locking correctly, you *have* to add the version\nas an additional hidden field (or into the SESSION for more\nsafety). Otherwise you cannot verify the version is still the one\nbeing originally read from the database when Alice performed her\nGET request for the blog post. If this happens you might see lost\nupdates you wanted to prevent with Optimistic Locking.\n\nSee the example code, The form (GET Request):\n\n.. code-block:: php\n\n find('BlogPost', 123456);\n\n echo 'getId() . '\" />';\n echo 'getCurrentVersion() . '\" />';\n\nAnd the change headline action (POST Request):\n\n.. code-block:: php\n\n find('BlogPost', $postId, \\Doctrine\\DBAL\\LockMode::OPTIMISTIC, $postVersion);\n\n.. _transactions-and-concurrency_pessimistic-locking:\n\nPessimistic Locking\n~~~~~~~~~~~~~~~~~~~\n\nDoctrine ORM supports Pessimistic Locking at the database level. No\nattempt is being made to implement pessimistic locking inside\nDoctrine, rather vendor-specific and ANSI-SQL commands are used to\nacquire row-level locks. Every Entity can be part of a pessimistic\nlock, there is no special metadata required to use this feature.\n\nHowever for Pessimistic Locking to work you have to disable the\nAuto-Commit Mode of your Database and start a transaction around\nyour pessimistic lock use-case using the \"Approach 2: Explicit\nTransaction Demarcation\" described above. Doctrine ORM will throw an\nException if you attempt to acquire an pessimistic lock and no\ntransaction is running.\n\nDoctrine ORM currently supports two pessimistic lock modes:\n\n\n- Pessimistic Write\n (``Doctrine\\DBAL\\LockMode::PESSIMISTIC_WRITE``), locks the\n underlying database rows for concurrent Read and Write Operations.\n- Pessimistic Read (``Doctrine\\DBAL\\LockMode::PESSIMISTIC_READ``),\n locks other concurrent requests that attempt to update or lock rows\n in write mode.\n\nYou can use pessimistic locks in four different scenarios:\n\n\n1. Using\n ``EntityManager#find($className, $id, \\Doctrine\\DBAL\\LockMode::PESSIMISTIC_WRITE)``\n or\n ``EntityManager#find($className, $id, \\Doctrine\\DBAL\\LockMode::PESSIMISTIC_READ)``\n2. Using\n ``EntityManager#lock($entity, \\Doctrine\\DBAL\\LockMode::PESSIMISTIC_WRITE)``\n or\n ``EntityManager#lock($entity, \\Doctrine\\DBAL\\LockMode::PESSIMISTIC_READ)``\n3. Using\n ``EntityManager#refresh($entity, \\Doctrine\\DBAL\\LockMode::PESSIMISTIC_WRITE)``\n or\n ``EntityManager#refresh($entity, \\Doctrine\\DBAL\\LockMode::PESSIMISTIC_READ)``\n4. Using\n ``Query#setLockMode(\\Doctrine\\DBAL\\LockMode::PESSIMISTIC_WRITE)``\n or\n ``Query#setLockMode(\\Doctrine\\DBAL\\LockMode::PESSIMISTIC_READ)``\n"
},
{
"path": "docs/en/reference/typedfieldmapper.rst",
"content": "Implementing a TypedFieldMapper\n===============================\n\n.. versionadded:: 2.14\n\nYou can specify custom typed field mapping between PHP type and DBAL type using ``Doctrine\\ORM\\Configuration``\nand a custom ``Doctrine\\ORM\\Mapping\\TypedFieldMapper`` implementation.\n\n.. code-block:: php\n\n setTypedFieldMapper(new CustomTypedFieldMapper());\n\n\nDefaultTypedFieldMapper\n-----------------------\n\nBy default the ``Doctrine\\ORM\\Mapping\\DefaultTypedFieldMapper`` is used, and you can pass an array of\nPHP type => DBAL type mappings into its constructor to override the default behavior or add new mappings.\n\n.. code-block:: php\n\n setTypedFieldMapper(new DefaultTypedFieldMapper([\n CustomIdObject::class => CustomIdObjectType::class,\n ]));\n\nThen, an entity using the ``CustomIdObject`` typed field will be correctly assigned its DBAL type\n(``CustomIdObjectType``) without the need of explicit declaration.\n\n.. configuration-block::\n\n .. code-block:: attribute\n\n \n \n \n \n \n \n\n .. code-block:: yaml\n\n UserTypedWithCustomTypedField:\n type: entity\n fields:\n customId: ~\n\nIt is perfectly valid to override even the \"automatic\" mapping rules mentioned above:\n\n.. code-block:: php\n\n setTypedFieldMapper(new DefaultTypedFieldMapper([\n 'int' => CustomIntType::class,\n ]));\n\n.. note::\n\n If chained, once the first ``TypedFieldMapper`` assigns a type to a field, the ``DefaultTypedFieldMapper`` will\n ignore its mapping and not override it anymore (if it is later in the chain). See below for chaining type mappers.\n\n\nTypedFieldMapper interface\n-------------------------\nThe interface ``Doctrine\\ORM\\Mapping\\TypedFieldMapper`` allows you to implement your own\ntyped field mapping logic. It consists of just one function\n\n\n.. code-block:: php\n\n setTypedFieldMapper(\n new ChainTypedFieldMapper(\n new DefaultTypedFieldMapper(['int' => CustomIntType::class,]),\n new CustomTypedFieldMapper()\n )\n );\n\n\nImplementing a TypedFieldMapper\n-------------------------------\n\nIf you want to assign all ``BackedEnum`` fields to your custom ``BackedEnumDBALType`` or you want to use different\nDBAL types based on whether the entity field is nullable or not, you can achieve this by implementing your own\ntyped field mapper.\n\nYou need to create a class which implements ``Doctrine\\ORM\\Mapping\\TypedFieldMapper``.\n\n.. code-block:: php\n\n getType();\n\n if (\n ! isset($mapping['type'])\n && ($type instanceof ReflectionNamedType)\n ) {\n if (! $type->isBuiltin() && enum_exists($type->getName())) {\n $mapping['type'] = BackedEnumDBALType::class;\n }\n }\n\n return $mapping;\n }\n }\n\n.. note::\n\n Note that this case checks whether the mapping is already assigned, and if yes, it skips it. This is up to your\n implementation. You can make a \"greedy\" mapper which will always override the mapping with its own type, or one\n that behaves like the ``DefaultTypedFieldMapper`` and does not modify the type once its set prior in the chain.\n"
},
{
"path": "docs/en/reference/unitofwork-associations.rst",
"content": "Association Updates: Owning Side and Inverse Side\n=================================================\n\nWhen mapping bidirectional associations it is important to\nunderstand the concept of the owning and inverse sides. The\nfollowing general rules apply:\n\n- Relationships may be bidirectional or unidirectional.\n- A bidirectional relationship has both an owning side and an inverse side\n- A unidirectional relationship only has an owning side.\n- Doctrine will **only** check the owning side of an association for changes.\n\nBidirectional Associations\n--------------------------\n\nThe following rules apply to **bidirectional** associations:\n\n- The inverse side has to have the ``mappedBy`` attribute of the OneToOne,\n OneToMany, or ManyToMany mapping declaration. The ``mappedBy``\n attribute contains the name of the association-field on the owning side.\n- The owning side has to have the ``inversedBy`` attribute of the\n OneToOne, ManyToOne, or ManyToMany mapping declaration.\n The ``inversedBy`` attribute contains the name of the association-field\n on the inverse-side.\n- ManyToOne is always the owning side of a bidirectional association.\n- OneToMany is always the inverse side of a bidirectional association.\n- The owning side of a OneToOne association is the entity with the table\n containing the foreign key.\n- You can pick the owning side of a many-to-many association yourself.\n\nImportant concepts\n------------------\n\n**Doctrine will only check the owning side of an association for changes.**\n\nTo fully understand this, remember how bidirectional associations\nare maintained in the object world. There are 2 references on each\nside of the association and these 2 references both represent the\nsame association but can change independently of one another. Of\ncourse, in a correct application the semantics of the bidirectional\nassociation are properly maintained by the application developer\n(that's their responsibility). Doctrine needs to know which of these\ntwo in-memory references is the one that should be persisted and\nwhich not. This is what the owning/inverse concept is mainly used\nfor.\n\n**Changes made only to the inverse side of an association are ignored. Make sure to update both sides of a bidirectional association (or at least the owning side, from Doctrine's point of view)**\n\nThe owning side of a bidirectional association is the side Doctrine\n\"looks at\" when determining the state of the association, and\nconsequently whether there is anything to do to update the\nassociation in the database.\n\n.. note::\n\n \"Owning side\" and \"inverse side\" are technical concepts of\n the ORM technology, not concepts of your domain model. What you\n consider as the owning side in your domain model can be different\n from what the owning side is for Doctrine. These are unrelated.\n\n"
},
{
"path": "docs/en/reference/unitofwork.rst",
"content": "Doctrine Internals explained\n============================\n\nObject relational mapping is a complex topic and sufficiently understanding how Doctrine works internally helps you use its full power.\n\nHow Doctrine keeps track of Objects\n-----------------------------------\n\nDoctrine uses the Identity Map pattern to track objects. Whenever you fetch an\nobject from the database, Doctrine will keep a reference to this object inside\nits UnitOfWork. The array holding all the entity references is two-levels deep\nand has the keys \"root entity name\" and \"id\". Since Doctrine allows composite\nkeys the id is a sorted, serialized version of all the key columns.\n\nThis allows Doctrine room for optimizations. If you call the EntityManager and\nask for an entity with a specific ID twice, it will return the same instance:\n\n.. code-block:: php\n\n public function testIdentityMap(): void\n {\n $objectA = $this->entityManager->find('EntityName', 1);\n $objectB = $this->entityManager->find('EntityName', 1);\n\n $this->assertSame($objectA, $objectB)\n }\n\nOnly one SELECT query will be fired against the database here. In the second\n``EntityManager#find()`` call Doctrine will check the identity map first and\ndoesn't need to make that database roundtrip.\n\nEven if you get a proxy object first then fetch the object by the same id you\nwill still end up with the same reference:\n\n.. code-block:: php\n\n public function testIdentityMapReference(): void\n {\n $objectA = $this->entityManager->getReference('EntityName', 1);\n // check entity is not initialized\n $this->assertTrue($this->entityManager->isUninitializedObject($objectA));\n\n $objectB = $this->entityManager->find('EntityName', 1);\n\n $this->assertSame($objectA, $objectB)\n }\n\nThe identity map being indexed by primary keys only allows shortcuts when you\nask for objects by primary key. Assume you have the following ``persons``\ntable:\n\n::\n\n id | name\n -------------\n 1 | Benjamin\n 2 | Bud\n\nTake the following example where two\nconsecutive calls are made against a repository to fetch an entity by a set of\ncriteria:\n\n.. code-block:: php\n\n public function testIdentityMapRepositoryFindBy()\n {\n $repository = $this->entityManager->getRepository('Person');\n $objectA = $repository->findOneBy(array('name' => 'Benjamin'));\n $objectB = $repository->findOneBy(array('name' => 'Benjamin'));\n\n $this->assertSame($objectA, $objectB);\n }\n\nThis query will still return the same references and `$objectA` and `$objectB`\nare indeed referencing the same object. However when checking your SQL logs you\nwill realize that two queries have been executed against the database. Doctrine\nonly knows objects by id, so a query for different criteria has to go to the\ndatabase, even if it was executed just before.\n\nBut instead of creating a second Person object Doctrine first gets the primary\nkey from the row and check if it already has an object inside the UnitOfWork\nwith that primary key. In our example it finds an object and decides to return\nthis instead of creating a new one.\n\nThe identity map has a second use-case. When you call ``EntityManager#flush``\nDoctrine will ask the identity map for all objects that are currently managed.\nThis means you don't have to call ``EntityManager#persist`` over and over again\nto pass known objects to the EntityManager. This is a NO-OP for known entities,\nbut leads to much code written that is confusing to other developers.\n\nThe following code WILL update your database with the changes made to the\n``Person`` object, even if you did not call ``EntityManager#persist``:\n\n.. code-block:: php\n\n find(\"Person\", 1);\n $user->setName(\"Guilherme\");\n $entityManager->flush();\n\nHow Doctrine Detects Changes\n----------------------------\n\nDoctrine is a data-mapper that tries to achieve persistence-ignorance (PI).\nThis means you map PHP objects into a relational database that don't\nnecessarily know about the database at all. A natural question would now be,\n\"how does Doctrine even detect objects have changed?\".\n\nFor this Doctrine keeps a second map inside the UnitOfWork. Whenever you fetch\nan object from the database Doctrine will keep a copy of all the properties and\nassociations inside the UnitOfWork. Because variables in the PHP language are\nsubject to \"copy-on-write\" the memory usage of a PHP request that only reads\nobjects from the database is the same as if Doctrine did not keep this variable\ncopy. Only if you start changing variables PHP will create new variables internally\nthat consume new memory.\n\nNow whenever you call ``EntityManager#flush`` Doctrine will iterate over the\nIdentity Map and for each object compares the original property and association\nvalues with the values that are currently set on the object. If changes are\ndetected then the object is queued for a SQL UPDATE operation. Only the fields\nthat actually changed are updated.\n\nThis process has an obvious performance impact. The larger the size of the\nUnitOfWork is, the longer this computation takes. There are several ways to\noptimize the performance of the Flush Operation:\n\n- Mark entities as read only. These entities can only be inserted or removed,\n but are never updated. They are omitted in the changeset calculation.\n- Temporarily mark entities as read only. If you have a very large UnitOfWork\n but know that a large set of entities has not changed, just mark them as read\n only with ``$entityManager->getUnitOfWork()->markReadOnly($entity)``.\n- Use :doc:`Change Tracking Policies ` to use more\n explicit strategies of notifying the UnitOfWork what objects/properties\n changed.\n\nQuery Internals\n---------------\n\nThe different ORM Layers\n------------------------\n\nDoctrine ships with a set of layers with different responsibilities. This\nsection gives a short explanation of each layer.\n\nHydration\n~~~~~~~~~\n\nResponsible for creating a final result from a raw database statement and a\nresult-set mapping object. The developer can choose which kind of result they\nwish to be hydrated. Default result-types include:\n\n- SQL to Entities\n- SQL to structured Arrays\n- SQL to simple scalar result arrays\n- SQL to a single result variable\n\nHydration to entities and arrays is one of the most complex parts of Doctrine\nalgorithm-wise. It can build results with for example:\n\n- Single table selects\n- Joins with n:1 or 1:n cardinality, grouping belonging to the same parent.\n- Mixed results of objects and scalar values\n- Hydration of results by a given scalar value as key.\n\nPersisters\n~~~~~~~~~~\n\ntbr\n\nUnitOfWork\n~~~~~~~~~~\n\ntbr\n\nResultSetMapping\n~~~~~~~~~~~~~~~~\n\ntbr\n\nDQL Parser\n~~~~~~~~~~\n\ntbr\n\nSQLWalker\n~~~~~~~~~\n\ntbr\n\nEntityManager\n~~~~~~~~~~~~~\n\ntbr\n\nClassMetadataFactory\n~~~~~~~~~~~~~~~~~~~~\n\ntbr\n"
},
{
"path": "docs/en/reference/working-with-associations.rst",
"content": "Working with Associations\n=========================\n\nAssociations between entities are represented just like in regular\nobject-oriented PHP code using references to other objects or\ncollections of objects.\n\nChanges to associations in your code are not synchronized to the\ndatabase directly, only when calling ``EntityManager#flush()``.\n\nThere are other concepts you should know about when working\nwith associations in Doctrine:\n\n- If an entity is removed from a collection, the association is\n removed, not the entity itself. A collection of entities always\n only represents the association to the containing entities, not the\n entity itself.\n- When a bidirectional association is updated, Doctrine only checks\n on one of both sides for these changes. This is called the :doc:`owning side `\n of the association.\n- A property with a reference to many entities has to be instances of the\n ``Doctrine\\Common\\Collections\\Collection`` interface.\n\nAssociation Example Entities\n----------------------------\n\nWe will use a simple comment system with Users and Comments as\nentities to show examples of association management. See the PHP\ndocblocks of each association in the following example for\ninformation about its type and if it's the owning or inverse side.\n\n.. code-block:: php\n\n \n */\n #[ManyToMany(targetEntity: Comment::class, inversedBy: 'userFavorites')]\n #[JoinTable(name: 'user_favorite_comments')]\n private Collection $favorites;\n\n /**\n * Unidirectional - Many users have marked many comments as read\n *\n * @var Collection\n */\n #[ManyToMany(targetEntity: Comment::class)]\n #[JoinTable(name: 'user_read_comments')]\n private Collection $commentsRead;\n\n /**\n * Bidirectional - One-To-Many (INVERSE SIDE)\n *\n * @var Collection\n */\n #[OneToMany(targetEntity: Comment::class, mappedBy: 'author')]\n private Collection $commentsAuthored;\n\n /** Unidirectional - Many-To-One */\n #[ManyToOne(targetEntity: Comment::class)]\n private Comment|null $firstComment = null;\n }\n\n #[Entity]\n class Comment\n {\n #[Id, GeneratedValue, Column]\n private string $id;\n\n /**\n * Bidirectional - Many comments are favorited by many users (INVERSE SIDE)\n *\n * @var Collection\n */\n #[ManyToMany(targetEntity: User::class, mappedBy: 'favorites')]\n private Collection $userFavorites;\n\n /**\n * Bidirectional - Many Comments are authored by one user (OWNING SIDE)\n */\n #[ManyToOne(targetEntity: User::class, inversedBy: 'commentsAuthored')]\n private User|null $author = null;\n }\n\nThis two entities generate the following MySQL Schema (Foreign Key\ndefinitions omitted):\n\n.. code-block:: sql\n\n CREATE TABLE User (\n id VARCHAR(255) NOT NULL,\n firstComment_id VARCHAR(255) DEFAULT NULL,\n PRIMARY KEY(id)\n ) ENGINE = InnoDB;\n\n CREATE TABLE Comment (\n id VARCHAR(255) NOT NULL,\n author_id VARCHAR(255) DEFAULT NULL,\n PRIMARY KEY(id)\n ) ENGINE = InnoDB;\n\n CREATE TABLE user_favorite_comments (\n user_id VARCHAR(255) NOT NULL,\n favorite_comment_id VARCHAR(255) NOT NULL,\n PRIMARY KEY(user_id, favorite_comment_id)\n ) ENGINE = InnoDB;\n\n CREATE TABLE user_read_comments (\n user_id VARCHAR(255) NOT NULL,\n comment_id VARCHAR(255) NOT NULL,\n PRIMARY KEY(user_id, comment_id)\n ) ENGINE = InnoDB;\n\nEstablishing Associations\n-------------------------\n\nEstablishing an association between two entities is\nstraight-forward. Here are some examples for the unidirectional\nrelations of the ``User``:\n\n.. code-block:: php\n\n */\n public function getReadComments(): Collection {\n return $this->commentsRead;\n }\n\n public function setFirstComment(Comment $c): void {\n $this->firstComment = $c;\n }\n }\n\nThe interaction code would then look like in the following snippet\n(``$em`` here is an instance of the EntityManager):\n\n.. code-block:: php\n\n find('User', $userId);\n\n // unidirectional many to many\n $comment = $em->find('Comment', $readCommentId);\n $user->getReadComments()->add($comment);\n\n $em->flush();\n\n // unidirectional many to one\n $myFirstComment = new Comment();\n $user->setFirstComment($myFirstComment);\n\n $em->persist($myFirstComment);\n $em->flush();\n\nIn the case of bi-directional associations you have to update the\nfields on both sides:\n\n.. code-block:: php\n\n */\n public function getAuthoredComments(): Collection {\n return $this->commentsAuthored;\n }\n\n /** @return Collection */\n public function getFavoriteComments(): Collection {\n return $this->favorites;\n }\n }\n\n class Comment\n {\n // ...\n\n /** @return Collection */\n public function getUserFavorites(): Collection {\n return $this->userFavorites;\n }\n\n public function setAuthor(User|null $author = null): void {\n $this->author = $author;\n }\n }\n\n // Many-to-Many\n $user->getFavorites()->add($favoriteComment);\n $favoriteComment->getUserFavorites()->add($user);\n\n $em->flush();\n\n // Many-To-One / One-To-Many Bidirectional\n $newComment = new Comment();\n $user->getAuthoredComments()->add($newComment);\n $newComment->setAuthor($user);\n\n $em->persist($newComment);\n $em->flush();\n\nNotice how always both sides of the bidirectional association are\nupdated. The previous unidirectional associations were simpler to\nhandle.\n\nRemoving Associations\n---------------------\n\nRemoving an association between two entities is similarly\nstraight-forward. There are two strategies to do so, by key and by\nelement. Here are some examples:\n\n.. code-block:: php\n\n getComments()->removeElement($comment);\n $comment->setAuthor(null);\n\n $user->getFavorites()->removeElement($comment);\n $comment->getUserFavorites()->removeElement($user);\n\n // Remove by Key\n $user->getComments()->remove($ithComment);\n $comment->setAuthor(null);\n\nYou need to call ``$em->flush()`` to make persist these changes in\nthe database permanently.\n\nNotice how both sides of the bidirectional association are always\nupdated. Unidirectional associations are consequently simpler to\nhandle.\n\nAlso note that if you use type-hinting in your methods, you will\nhave to specify a nullable type, i.e. ``setAddress(?Address $address)``,\notherwise ``setAddress(null)`` will fail to remove the association.\nAnother way to deal with this is to provide a special method, like\n``removeAddress()``. This can also provide better encapsulation as\nit hides the internal meaning of not having an address.\n\nWhen working with collections, keep in mind that a Collection is\nessentially an ordered map (just like a PHP array). That is why the\n``remove`` operation accepts an index/key. ``removeElement`` is a\nseparate method that has O(n) complexity using ``array_search``,\nwhere n is the size of the map.\n\n.. note::\n\n Since Doctrine always only looks at the owning side of a\n bidirectional association for updates, it is not necessary for\n write operations that an inverse collection of a bidirectional\n one-to-many or many-to-many association is updated. This knowledge\n can often be used to improve performance by avoiding the loading of\n the inverse collection.\n\n\nYou can also clear the contents of a whole collection using the\n``Collections::clear()`` method. You should be aware that using\nthis method can lead to a straight and optimized database delete or\nupdate call during the flush operation that is not aware of\nentities that have been re-added to the collection.\n\nSay you clear a collection of tags by calling\n``$post->getTags()->clear();`` and then call\n``$post->getTags()->add($tag)``. This will not recognize the tag having\nalready been added previously and will consequently issue two separate database\ncalls.\n\nAssociation Management Methods\n------------------------------\n\nIt is generally a good idea to encapsulate proper association\nmanagement inside the entity classes. This makes it easier to use\nthe class correctly and can encapsulate details about how the\nassociation is maintained.\n\nThe following code shows updates to the previous User and Comment\nexample that encapsulate much of the association management code:\n\n.. code-block:: php\n\n commentsRead[] = $comment;\n }\n\n public function addComment(Comment $comment): void {\n if (count($this->commentsAuthored) == 0) {\n $this->setFirstComment($comment);\n }\n $this->comments[] = $comment;\n $comment->setAuthor($this);\n }\n\n private function setFirstComment(Comment $c): void {\n $this->firstComment = $c;\n }\n\n public function addFavorite(Comment $comment): void {\n $this->favorites->add($comment);\n $comment->addUserFavorite($this);\n }\n\n public function removeFavorite(Comment $comment): void {\n $this->favorites->removeElement($comment);\n $comment->removeUserFavorite($this);\n }\n }\n\n class Comment\n {\n // ..\n\n public function addUserFavorite(User $user): void {\n $this->userFavorites[] = $user;\n }\n\n public function removeUserFavorite(User $user): void {\n $this->userFavorites->removeElement($user);\n }\n }\n\nYou will notice that ``addUserFavorite`` and ``removeUserFavorite``\ndo not call ``addFavorite`` and ``removeFavorite``, thus the\nbidirectional association is strictly-speaking still incomplete.\nHowever if you would naively add the ``addFavorite`` in\n``addUserFavorite``, you end up with an infinite loop, so more work\nis needed. As you can see, proper bidirectional association\nmanagement in plain OOP is a non-trivial task and encapsulating all\nthe details inside the classes can be challenging.\n\n.. note::\n\n If you want to make sure that your collections are perfectly\n encapsulated you should not return them from a\n ``getCollectionName()`` method directly, but call\n ``$collection->toArray()``. This way a client programmer for the\n entity cannot circumvent the logic you implement on your entity for\n association management. For example:\n\n\n.. code-block:: php\n\n */\n public function getReadComments(): array {\n return $this->commentsRead->toArray();\n }\n }\n\nThis will however always initialize the collection, with all the\nperformance penalties given the size. In some scenarios of large\ncollections it might even be a good idea to completely hide the\nread access behind methods on the EntityRepository.\n\nThere is no single, best way for association management. It greatly\ndepends on the requirements of your concrete domain model as well\nas your preferences.\n\nSynchronizing Bidirectional Collections\n---------------------------------------\n\nIn the case of Many-To-Many associations you as the developer have the\nresponsibility of keeping the collections on the owning and inverse side\nin sync when you apply changes to them. Doctrine can only\nguarantee a consistent state for the hydration, not for your client\ncode.\n\nUsing the User-Comment entities from above, a very simple example\ncan show the possible caveats you can encounter:\n\n.. code-block:: php\n\n getFavorites()->add($favoriteComment);\n // not calling $favoriteComment->getUserFavorites()->add($user);\n\n $user->getFavorites()->contains($favoriteComment); // TRUE\n $favoriteComment->getUserFavorites()->contains($user); // FALSE\n\nThere are two approaches to handle this problem in your code:\n\n\n1. Ignore updating the inverse side of bidirectional collections,\n BUT never read from them in requests that changed their state. In\n the next request Doctrine hydrates the consistent collection state\n again.\n2. Always keep the bidirectional collections in sync through\n association management methods. Reads of the Collections directly\n after changes are consistent then.\n\n.. _transitive-persistence:\n\nTransitive persistence / Cascade Operations\n-------------------------------------------\n\nDoctrine ORM provides a mechanism for transitive persistence through cascading of certain operations.\nEach association to another entity or a collection of\nentities can be configured to automatically cascade the following operations to the associated entities:\n``persist``, ``remove``, ``detach``, ``refresh`` or ``all``.\n\nThe main use case for ``cascade: persist`` is to avoid \"exposing\" associated entities to your PHP application.\nContinuing with the User-Comment example of this chapter, this is how the creation of a new user and a new\ncomment might look like in your controller (without ``cascade: persist``):\n\n.. code-block:: php\n\n addComment($myFirstComment);\n\n $em->persist($user);\n $em->persist($myFirstComment); // required, if `cascade: persist` is not set\n $em->flush();\n\nNote that the Comment entity is instantiated right here in the controller.\nTo avoid this, ``cascade: persist`` allows you to \"hide\" the Comment entity from the controller,\nonly accessing it through the User entity:\n\n.. code-block:: php\n\n */\n private Collection $comments;\n\n public function __construct()\n {\n $this->id = User::new();\n $this->comments = new ArrayCollection();\n }\n\n public function comment(string $text, DateTimeInterface $time) : void\n {\n $newComment = Comment::create($text, $time);\n $newComment->setUser($this);\n $this->comments->add($newComment);\n }\n\n // ...\n }\n\nIf you then set up the cascading to the ``User#commentsAuthored`` property...\n\n.. code-block:: php\n\n comment('Lorem ipsum', new DateTime());\n\n $em->persist($user);\n $em->flush();\n\n.. note::\n\n The idea of ``cascade: persist`` is not to save you any lines of code in the controller.\n If you instantiate the comment object in the controller (i.e. don't set up the user entity as shown above),\n even with ``cascade: persist`` you still have to call ``$myFirstComment->setUser($user);``.\n\nThanks to ``cascade: remove``, you can easily delete a user and all linked comments without having to loop through them:\n\n.. code-block:: php\n\n find('User', $deleteUserId);\n\n $em->remove($user);\n $em->flush();\n\n.. note::\n\n Cascade operations are performed in memory. That means collections and related entities\n are fetched into memory (even if they are marked as lazy) when\n the cascade operation is about to be performed. This approach allows\n entity lifecycle events to be performed for each of these operations.\n\n However, pulling object graphs into memory on cascade can cause considerable performance\n overhead, especially when the cascaded collections are large. Make sure\n to weigh the benefits and downsides of each cascade operation that you define.\n\n To rely on the database level cascade operations for the delete operation instead, you can\n configure each join column with :doc:`the onDelete option `.\n\nEven though automatic cascading is convenient, it should be used\nwith care. Do not blindly apply ``cascade=all`` to all associations as\nit will unnecessarily degrade the performance of your application.\nFor each cascade operation that gets activated, Doctrine also\napplies that operation to the association, be it single or\ncollection valued.\n\n.. _persistence-by-reachability:\n\nPersistence by Reachability: Cascade Persist\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nThere are additional semantics that apply to the Cascade Persist\noperation. During each ``flush()`` operation Doctrine detects if there\nare new entities in any collection and three possible cases can\nhappen:\n\n\n1. New entities in a collection marked as ``cascade: persist`` will be\n directly persisted by Doctrine.\n2. New entities in a collection not marked as ``cascade: persist`` will\n produce an Exception and rollback the ``flush()`` operation.\n3. Collections without new entities are skipped.\n\nThis concept is called Persistence by Reachability: New entities\nthat are found on already managed entities are automatically\npersisted as long as the association is defined as ``cascade: persist``.\n\nOrphan Removal\n--------------\n\nThere is another concept of cascading that is relevant only when removing entities\nfrom collections. If an Entity of type ``A`` contains references to privately\nowned Entities ``B`` then if the reference from ``A`` to ``B`` is removed the\nentity ``B`` should also be removed, because it is not used anymore.\n\nOrphanRemoval works with one-to-one, one-to-many and many-to-many associations.\n\n.. note::\n\n When using the ``orphanRemoval=true`` option Doctrine makes the assumption\n that the entities are privately owned and will **NOT** be reused by other entities.\n If you neglect this assumption your entities will get deleted by Doctrine even if\n you assigned the orphaned entity to another one.\n\n.. note::\n\n ``orphanRemoval=true`` option should be used in combination with ``cascade=[\"persist\"]`` option\n as the child entity, that is manually persisted, will not be deleted automatically by Doctrine\n when a collection is still an instance of ArrayCollection (before first flush / hydration).\n This is a Doctrine limitation since ArrayCollection does not have access to a UnitOfWork.\n\nAs a better example consider an Addressbook application where you have Contacts, Addresses\nand StandingData:\n\n.. code-block:: php\n\n */\n #[OneToMany(targetEntity: Address::class, mappedBy: 'contact', cascade: ['persist'], orphanRemoval: true)]\n private Collection $addresses;\n\n public function __construct()\n {\n $this->addresses = new ArrayCollection();\n }\n\n public function newStandingData(StandingData $sd): void\n {\n $this->standingData = $sd;\n }\n\n public function removeAddress(int $pos): void\n {\n unset($this->addresses[$pos]);\n }\n }\n\nNow two examples of what happens when you remove the references:\n\n.. code-block:: php\n\n find(\"Addressbook\\Contact\", $contactId);\n $contact->newStandingData(new StandingData(\"Firstname\", \"Lastname\", \"Street\"));\n $contact->removeAddress(1);\n\n $em->flush();\n\nIn this case you have not only changed the ``Contact`` entity itself but\nyou have also removed the references for standing data and as well as one\naddress reference. When flush is called not only are the references removed\nbut both the old standing data and the one address entity are also deleted\nfrom the database.\n\n.. _filtering-collections:\n\nFiltering Collections\n---------------------\n\nCollections have a filtering API that allows to slice parts of data from\na collection. If the collection has not been loaded from the database yet,\nthe filtering API can work on the SQL level to make optimized access to\nlarge collections.\n\n.. code-block:: php\n\n find('Group', $groupId);\n $userCollection = $group->getUsers();\n\n $criteria = Criteria::create()\n ->where(Criteria::expr()->eq(\"birthday\", \"1982-02-17\"))\n ->orderBy(array(\"username\" => Criteria::ASC))\n ->setFirstResult(0)\n ->setMaxResults(20)\n ;\n\n $birthdayUsers = $userCollection->matching($criteria);\n\n.. tip::\n\n You can move the access of slices of collections into dedicated methods of\n an entity. For example ``Group#getTodaysBirthdayUsers()``.\n\nThe Criteria has a limited matching language that works both on the\nSQL and on the PHP collection level. This means you can use collection matching\ninterchangeably, independent of in-memory or sql-backed collections.\n\n.. code-block:: php\n\n `.\n In this case, field names passed to expressions are being used to derive accessor\n method names. Strict type comparisons are used for equal and not-equal checks,\n and generally PHP language rules are being used for other comparison operators\n or sorting.\n\n As a general guidance, for consistent results use the Criteria API with scalar\n values only. Note that ``DateTime`` and ``DateTimeImmutable`` are two predominant\n examples of value objects that are *not* scalars.\n\n Refrain from using special database-level column types or custom Doctrine Types\n that may lead to database-specific comparison or sorting rules being applied, or\n to database-level values being different from object field values.\n\n Provide accessor methods for all entity fields used in criteria expressions,\n and implement those methods in a way that their return value is the\n same as the database-level value.\n"
},
{
"path": "docs/en/reference/working-with-objects.rst",
"content": "Working with Objects\n====================\n\nIn this chapter we will help you understand the ``EntityManager``\nand the ``UnitOfWork``. A Unit of Work is similar to an\nobject-level transaction. A new Unit of Work is implicitly started\nwhen an EntityManager is initially created or after\n``EntityManager#flush()`` has been invoked. A Unit of Work is\ncommitted (and a new one started) by invoking\n``EntityManager#flush()``.\n\nA Unit of Work can be manually closed by calling\nEntityManager#close(). Any changes to objects within this Unit of\nWork that have not yet been persisted are lost.\n\n.. note::\n\n It is very important to understand that only\n ``EntityManager#flush()`` ever causes write operations against the\n database to be executed. Any other methods such as\n ``EntityManager#persist($entity)`` or\n ``EntityManager#remove($entity)`` only notify the UnitOfWork to\n perform these operations during flush.\n\n Not calling ``EntityManager#flush()`` will lead to all changes\n during that request being lost.\n\n.. note::\n\n Doctrine NEVER touches the public API of methods in your entity\n classes (like getters and setters) nor the constructor method.\n Instead, it uses reflection to get/set data from/to your entity objects.\n When Doctrine fetches data from DB and saves it back,\n any code put in your get/set methods won't be implicitly taken into account.\n\nEntities and the Identity Map\n-----------------------------\n\nEntities are objects with identity. Their identity has a conceptual\nmeaning inside your domain. In a CMS application each article has a\nunique id. You can uniquely identify each article by that id.\n\nTake the following example, where you find an article with the\nheadline \"Hello World\" with the ID 1234:\n\n.. code-block:: php\n\n find('CMS\\Article', 1234);\n $article->setHeadline('Hello World dude!');\n\n $article2 = $entityManager->find('CMS\\Article', 1234);\n echo $article2->getHeadline();\n\nIn this case the Article is accessed from the entity manager twice,\nbut modified in between. Doctrine ORM realizes this and will only\never give you access to one instance of the Article with ID 1234,\nno matter how often do you retrieve it from the EntityManager and\neven no matter what kind of Query method you are using (find,\nRepository Finder or DQL). This is called \"Identity Map\" pattern,\nwhich means Doctrine keeps a map of each entity and ids that have\nbeen retrieved per PHP request and keeps returning you the same\ninstances.\n\nIn the previous example the echo prints \"Hello World dude!\" to the\nscreen. You can even verify that ``$article`` and ``$article2`` are\nindeed pointing to the same instance by running the following\ncode:\n\n.. code-block:: php\n\n */\n #[OneToMany(targetEntity: Comment::class, mappedBy: 'article')]\n private Collection $comments;\n\n public function __construct()\n {\n $this->comments = new ArrayCollection();\n }\n\n public function getAuthor(): User|null { return $this->author; }\n public function getComments(): Collection { return $this->comments; }\n }\n\n $article = $em->find('Article', 1);\n\nThis code only retrieves the ``Article`` instance with id 1 executing\na single SELECT statement against the articles table in the database.\nYou can still access the associated properties author and comments\nand the associated objects they contain.\n\nThis works by utilizing the lazy loading pattern. Instead of\npassing you back a real Author instance and a collection of\ncomments Doctrine will create proxy instances for you. Only if you\naccess these proxies for the first time they will go through the\nEntityManager and load their state from the database.\n\nThis lazy-loading process happens behind the scenes, hidden from\nyour code. See the following code:\n\n.. code-block:: php\n\n find('Article', 1);\n\n // accessing a method of the user instance triggers the lazy-load\n echo \"Author: \" . $article->getAuthor()->getName() . \"\\n\";\n\n // Lazy Loading Proxies pass instanceof tests:\n if ($article->getAuthor() instanceof User) {\n // a User Proxy is a generated \"UserProxy\" class\n }\n\n // accessing the comments as an iterator triggers the lazy-load\n // retrieving ALL the comments of this article from the database\n // using a single SELECT statement\n foreach ($article->getComments() as $comment) {\n echo $comment->getText() . \"\\n\\n\";\n }\n\n // Article::$comments passes instanceof tests for the Collection interface\n // But it will NOT pass for the ArrayCollection interface\n if ($article->getComments() instanceof \\Doctrine\\Common\\Collections\\Collection) {\n echo \"This will always be true!\";\n }\n\n.. warning::\n\n Traversing the object graph for parts that are lazy-loaded will\n easily trigger lots of SQL queries and will perform badly if used\n too heavily. Make sure to use DQL to fetch-join all the parts of the\n object-graph that you need as efficiently as possible.\n\n\nPersisting entities\n-------------------\n\nAn entity can be made persistent by passing it to the\n``EntityManager#persist($entity)`` method. By applying the persist\noperation on some entity, that entity becomes MANAGED, which means\nthat its persistence is from now on managed by an EntityManager. As\na result the persistent state of such an entity will subsequently\nbe properly synchronized with the database when\n``EntityManager#flush()`` is invoked.\n\n.. note::\n\n Invoking the ``persist`` method on an entity does NOT\n cause an immediate SQL INSERT to be issued on the database.\n Doctrine applies a strategy called \"transactional write-behind\",\n which means that it will delay most SQL commands until\n ``EntityManager#flush()`` is invoked which will then issue all\n necessary SQL statements to synchronize your objects with the\n database in the most efficient way and a single, short transaction,\n taking care of maintaining referential integrity.\n\n.. note::\n\n Do not make any assumptions in your code about the number of queries\n it takes to flush changes, about the ordering of ``INSERT``, ``UPDATE``\n and ``DELETE`` queries or the order in which entities will be processed.\n\nExample:\n\n.. code-block:: php\n\n setName('Mr.Right');\n $em->persist($user);\n $em->flush();\n\n.. note::\n\n Generated entity identifiers / primary keys are\n guaranteed to be available after the next successful flush\n operation that involves the entity in question. You can not rely on\n a generated identifier to be available directly after invoking\n ``persist``. The inverse is also true. You can not rely on a\n generated identifier being not available after a failed flush\n operation.\n\n\nThe semantics of the persist operation, applied on an entity X, are\nas follows:\n\n\n- If X is a new entity, it becomes managed. The entity X will be\n entered into the database as a result of the flush operation.\n- If X is a preexisting managed entity, it is ignored by the\n persist operation. However, the persist operation is cascaded to\n entities referenced by X, if the relationships from X to these\n other entities are mapped with cascade=PERSIST or cascade=ALL (see\n \":ref:`transitive-persistence`\").\n- If X is a removed entity, it becomes managed.\n- If X is a detached entity, an exception will be thrown on\n flush.\n\n.. caution::\n\n Do not pass detached entities to the persist operation. The persist operation always\n considers entities that are not yet known to the ``EntityManager`` as new entities\n (refer to the ``STATE_NEW`` constant inside the ``UnitOfWork``).\n\nRemoving entities\n-----------------\n\nAn entity can be removed from persistent storage by passing it to\nthe ``EntityManager#remove($entity)`` method. By applying the\n``remove`` operation on some entity, that entity becomes REMOVED,\nwhich means that its persistent state will be deleted once\n``EntityManager#flush()`` is invoked.\n\n.. note::\n\n Just like ``persist``, invoking ``remove`` on an entity\n does NOT cause an immediate SQL DELETE to be issued on the\n database. The entity will be deleted on the next invocation of\n ``EntityManager#flush()`` that involves that entity. This\n means that entities scheduled for removal can still be queried\n for and appear in query and collection results. See\n the section on :ref:`Database and UnitOfWork Out-Of-Sync `\n for more information.\n\n\nExample:\n\n.. code-block:: php\n\n remove($user);\n $em->flush();\n\nThe semantics of the remove operation, applied to an entity X are\nas follows:\n\n\n- If X is a new entity, it is ignored by the remove operation.\n However, the remove operation is cascaded to entities referenced by\n X, if the relationship from X to these other entities is mapped\n with cascade=REMOVE or cascade=ALL (see \":ref:`transitive-persistence`\").\n- If X is a managed entity, the remove operation causes it to\n become removed. The remove operation is cascaded to entities\n referenced by X, if the relationships from X to these other\n entities is mapped with cascade=REMOVE or cascade=ALL (see\n \":ref:`transitive-persistence`\").\n- If X is a detached entity, an InvalidArgumentException will be\n thrown.\n- If X is a removed entity, it is ignored by the remove operation.\n- A removed entity X will be removed from the database as a result\n of the flush operation.\n\nAfter an entity has been removed, its in-memory state is the same as\nbefore the removal, except for generated identifiers.\n\nDuring the ``EntityManager#flush()`` operation, the removed entity\nwill also be removed from all collections in entities currently\nloaded into memory.\n\n.. _remove_object_many_to_many_join_tables:\n\nJoin-table management when removing from many-to-many collections\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nRegarding existing rows in many-to-many join tables that refer to\nan entity being removed, the following applies.\n\nWhen the entity being removed does not declare the many-to-many association\nitself (that is, the many-to-many association is unidirectional and\nthe entity is on the inverse side), the ORM has no reasonable way to\ndetect associations targeting the entity's class. Thus, no ORM-level handling\nof join-table rows is attempted and database-level constraints apply.\nIn case of database-level ``ON DELETE RESTRICT`` constraints, the\n``EntityManager#flush()`` operation may abort and a ``ConstraintViolationException``\nmay be thrown. No in-memory collections will be modified in this case.\nWith ``ON DELETE CASCADE``, the RDBMS will take care of removing rows\nfrom join tables.\n\nWhen the entity being removed is part of bi-directional many-to-many\nassociation, either as the owning or inverse side, the ORM will\ndelete rows from join tables before removing the entity itself. That means\ndatabase-level ``ON DELETE RESTRICT`` constraints on join tables are not\neffective, since the join table rows are removed first. Removal of join table\nrows happens through specialized methods in entity and collection persister\nclasses and take one query per entity and join table. In case the association\nuses a ``@JoinColumn`` configuration with ``onDelete=\"CASCADE\"``, instead\nof using a dedicated ``DELETE`` query the database-level operation will be\nrelied upon.\n\n.. note::\n\n In case you rely on database-level ``ON DELETE RESTRICT`` constraints,\n be aware that by making many-to-many associations bidirectional the\n assumed protection may be lost.\n\n\nPerformance of different deletion strategies\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nDeleting an object with all its associated objects can be achieved\nin multiple ways with very different performance impacts.\n\n1. If an association is marked as ``CASCADE=REMOVE`` Doctrine ORM will\n fetch this association. If it's a Single association it will pass\n this entity to ``EntityManager#remove()``. If the association is a\n collection, Doctrine will loop over all its elements and pass them to\n ``EntityManager#remove()``.\n In both cases the cascade remove semantics are applied recursively.\n For large object graphs this removal strategy can be very costly.\n2. Using a DQL ``DELETE`` statement allows you to delete multiple\n entities of a type with a single command and without hydrating\n these entities. This can be very efficient to delete large object\n graphs from the database.\n3. Using foreign key semantics ``onDelete=\"CASCADE\"`` can force the\n database to remove all associated objects internally. This strategy\n is a bit tricky to get right but can be very powerful and fast. You\n should be aware however that using strategy 1 (``CASCADE=REMOVE``)\n completely by-passes any foreign key ``onDelete=CASCADE`` option,\n because Doctrine will fetch and remove all associated entities\n explicitly nevertheless.\n\n.. note::\n\n Calling ``remove`` on an entity will remove the object from the identity\n map and therefore detach it. Querying the same entity again, for example\n via a lazy loaded relation, will return a new object.\n\n\nDetaching entities\n------------------\n\nAn entity is detached from an EntityManager and thus no longer\nmanaged by invoking the ``EntityManager#detach($entity)`` method on\nit or by cascading the detach operation to it. Changes made to the\ndetached entity, if any (including removal of the entity), will not\nbe synchronized to the database after the entity has been\ndetached.\n\nDoctrine will not hold on to any references to a detached entity.\n\nExample:\n\n.. code-block:: php\n\n detach($entity);\n\nThe semantics of the detach operation, applied to an entity X are\nas follows:\n\n\n- If X is a managed entity, the detach operation causes it to\n become detached. The detach operation is cascaded to entities\n referenced by X, if the relationships from X to these other\n entities is mapped with cascade=DETACH or cascade=ALL (see\n \":ref:`transitive-persistence`\"). Entities which previously referenced X\n will continue to reference X.\n- If X is a new or detached entity, it is ignored by the detach\n operation.\n- If X is a removed entity, the detach operation is cascaded to\n entities referenced by X, if the relationships from X to these\n other entities is mapped with cascade=DETACH or cascade=ALL (see\n \":ref:`transitive-persistence`\"). Entities which previously referenced X\n will continue to reference X.\n\nThere are several situations in which an entity is detached\nautomatically without invoking the ``detach`` method:\n\n\n- When ``EntityManager#clear()`` is invoked, all entities that are\n currently managed by the EntityManager instance become detached.\n- When serializing an entity. The entity retrieved upon subsequent\n unserialization will be detached (This is the case for all entities\n that are serialized and stored in some cache).\n\nThe ``detach`` operation is usually not as frequently needed and\nused as ``persist`` and ``remove``.\n\n\nSynchronization with the Database\n---------------------------------\n\nThe state of persistent entities is synchronized with the database\non flush of an ``EntityManager`` which commits the underlying\n``UnitOfWork``. The synchronization involves writing any updates to\npersistent entities and their relationships to the database.\nThereby bidirectional relationships are persisted based on the\nreferences held by the owning side of the relationship as explained\nin the Association Mapping chapter.\n\nWhen ``EntityManager#flush()`` is called, Doctrine inspects all\nmanaged, new and removed entities and will perform the following\noperations.\n\n.. _workingobjects_database_uow_outofsync:\n\nEffects of Database and UnitOfWork being Out-Of-Sync\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nAs soon as you begin to change the state of entities, call persist or remove the\ncontents of the UnitOfWork and the database will drive out of sync. They can\nonly be synchronized by calling ``EntityManager#flush()``. This section\ndescribes the effects of database and UnitOfWork being out of sync.\n\n- Entities that are scheduled for removal can still be queried from the database.\n They are returned from DQL and Repository queries and are visible in collections.\n- Entities that are passed to ``EntityManager#persist`` do not turn up in query\n results.\n- Entities that have changed will not be overwritten with the state from the database.\n This is because the identity map will detect the construction of an already existing\n entity and assumes its the most up to date version.\n\n``EntityManager#flush()`` is never called implicitly by Doctrine. You always have to trigger it manually.\n\nSynchronizing New and Managed Entities\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nThe flush operation applies to a managed entity with the following\nsemantics:\n\n\n- The entity itself is synchronized to the database using a SQL\n UPDATE statement, only if at least one persistent field has\n changed.\n- No SQL updates are executed if the entity did not change.\n\nThe flush operation applies to a new entity with the following\nsemantics:\n\n\n- The entity itself is synchronized to the database using a SQL\n INSERT statement.\n\nFor all (initialized) relationships of the new or managed entity\nthe following semantics apply to each associated entity X:\n\n\n- If X is new and persist operations are configured to cascade on\n the relationship, X will be persisted.\n- If X is new and no persist operations are configured to cascade\n on the relationship, an exception will be thrown as this indicates\n a programming error.\n- If X is removed and persist operations are configured to cascade\n on the relationship, an exception will be thrown as this indicates\n a programming error (X would be re-persisted by the cascade).\n- If X is detached and persist operations are configured to\n cascade on the relationship, an exception will be thrown (This is\n semantically the same as passing X to persist()).\n\nSynchronizing Removed Entities\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nThe flush operation applies to a removed entity by deleting its\npersistent state from the database. No cascade options are relevant\nfor removed entities on flush, the cascade remove option is already\nexecuted during ``EntityManager#remove($entity)``.\n\nThe size of a Unit of Work\n~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nThe size of a Unit of Work mainly refers to the number of managed\nentities at a particular point in time.\n\nThe cost of flushing\n~~~~~~~~~~~~~~~~~~~~\n\nHow costly a flush operation is, mainly depends on two factors:\n\n\n- The size of the EntityManager's current UnitOfWork.\n- The configured change tracking policies\n\nYou can get the size of a UnitOfWork as follows:\n\n.. code-block:: php\n\n getUnitOfWork()->size();\n\nThe size represents the number of managed entities in the Unit of\nWork. This size affects the performance of flush() operations due\nto change tracking (see \"Change Tracking Policies\") and, of course,\nmemory consumption, so you may want to check it from time to time\nduring development.\n\n.. note::\n\n Do not invoke ``flush`` after every change to an entity\n or every single invocation of persist/remove/... This is an\n anti-pattern and unnecessarily reduces the performance of your\n application. Instead, form units of work that operate on your\n objects and call ``flush`` when you are done. While serving a\n single HTTP request there should be usually no need for invoking\n ``flush`` more than 0-2 times.\n\n\nDirect access to a Unit of Work\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nYou can get direct access to the Unit of Work by calling\n``EntityManager#getUnitOfWork()``. This will return the UnitOfWork\ninstance the EntityManager is currently using.\n\n.. code-block:: php\n\n getUnitOfWork();\n\n.. note::\n\n Directly manipulating a UnitOfWork is not recommended.\n When working directly with the UnitOfWork API, respect methods\n marked as INTERNAL by not using them and carefully read the API\n documentation.\n\n\nEntity State\n~~~~~~~~~~~~\n\nAs outlined in the architecture overview an entity can be in one of\nfour possible states: NEW, MANAGED, REMOVED, DETACHED. If you\nexplicitly need to find out what the current state of an entity is\nin the context of a certain ``EntityManager`` you can ask the\nunderlying ``UnitOfWork``:\n\n.. code-block:: php\n\n getUnitOfWork()->getEntityState($entity)) {\n case UnitOfWork::STATE_MANAGED:\n ...\n case UnitOfWork::STATE_REMOVED:\n ...\n case UnitOfWork::STATE_DETACHED:\n ...\n case UnitOfWork::STATE_NEW:\n ...\n }\n\nAn entity is in MANAGED state if it is associated with an\n``EntityManager`` and it is not REMOVED.\n\nAn entity is in REMOVED state after it has been passed to\n``EntityManager#remove()`` until the next flush operation of the\nsame EntityManager. A REMOVED entity is still associated with an\n``EntityManager`` until the next flush operation.\n\nAn entity is in DETACHED state if it has persistent state and\nidentity but is currently not associated with an\n``EntityManager``.\n\nAn entity is in NEW state if has no persistent state and identity\nand is not associated with an ``EntityManager`` (for example those\njust created via the \"new\" operator).\n\nQuerying\n--------\n\nDoctrine ORM provides the following ways, in increasing level of\npower and flexibility, to query for persistent objects. You should\nalways start with the simplest one that suits your needs.\n\nBy Primary Key\n~~~~~~~~~~~~~~\n\nThe most basic way to query for a persistent object is by its\nidentifier / primary key using the\n``EntityManager#find($entityName, $id)`` method. Here is an\nexample:\n\n.. code-block:: php\n\n find('MyProject\\Domain\\User', $id);\n\nThe return value is either the found entity instance or null if no\ninstance could be found with the given identifier.\n\nEssentially, ``EntityManager#find()`` is just a shortcut for the\nfollowing:\n\n.. code-block:: php\n\n getRepository('MyProject\\Domain\\User')->find($id);\n\n``EntityManager#getRepository($entityName)`` returns a repository\nobject which provides many ways to retrieve entities of the\nspecified type. By default, the repository instance is of type\n``Doctrine\\ORM\\EntityRepository``. You can also use custom\nrepository classes as shown later.\n\nBy Simple Conditions\n~~~~~~~~~~~~~~~~~~~~\n\nTo query for one or more entities based on several conditions that\nform a logical conjunction, use the ``findBy`` and ``findOneBy``\nmethods on a repository as follows:\n\n.. code-block:: php\n\n getRepository('MyProject\\Domain\\User')->findBy(array('age' => 20));\n\n // All users that are 20 years old and have a surname of 'Miller'\n $users = $em->getRepository('MyProject\\Domain\\User')->findBy(array('age' => 20, 'surname' => 'Miller'));\n\n // A single user by its nickname\n $user = $em->getRepository('MyProject\\Domain\\User')->findOneBy(array('nickname' => 'romanb'));\n\nYou can also load by owning side associations through the repository:\n\n.. code-block:: php\n\n find('MyProject\\Domain\\Phonenumber', 1234);\n $user = $em->getRepository('MyProject\\Domain\\User')->findOneBy(array('phone' => $number->getId()));\n\nThe ``EntityRepository#findBy()`` method additionally accepts orderings, limit and offset as second to fourth parameters:\n\n.. code-block:: php\n\n getRepository('MyProject\\Domain\\User')->findBy(array('age' => 20), array('name' => 'ASC'), 10, 0);\n\nIf you pass an array of values Doctrine will convert the query into a WHERE field IN (..) query automatically:\n\n.. code-block:: php\n\n getRepository('MyProject\\Domain\\User')->findBy(array('age' => array(20, 30, 40)));\n // translates roughly to: SELECT * FROM users WHERE age IN (20, 30, 40)\n\nAn EntityRepository also provides a mechanism for more concise\ncalls through its use of ``__call``. Thus, the following two\nexamples are equivalent:\n\n.. code-block:: php\n\n getRepository('MyProject\\Domain\\User')->findOneBy(array('nickname' => 'romanb'));\n\n // A single user by its nickname (__call magic)\n $user = $em->getRepository('MyProject\\Domain\\User')->findOneByNickname('romanb');\n\nAdditionally, you can just count the result of the provided conditions when you don't really need the data:\n\n.. code-block:: php\n\n getRepository('MyProject\\Domain\\User')->count(['nickname' => 'nonexistent']);\n\nBy Criteria\n~~~~~~~~~~~\n\nThe Repository implement the ``Doctrine\\Common\\Collections\\Selectable``\ninterface. That means you can build ``Doctrine\\Common\\Collections\\Criteria``\nand pass them to the ``matching($criteria)`` method.\n\nSee section `Filtering collections` of chapter :doc:`Working with Associations `\n\nBy Eager Loading\n~~~~~~~~~~~~~~~~\n\nWhenever you query for an entity that has persistent associations\nand these associations are mapped as EAGER, they will automatically\nbe loaded together with the entity being queried and is thus\nimmediately available to your application.\n\nEager Loading can also be configured at runtime through\n``AbstractQuery::setFetchMode`` in DQL or Native Queries.\n\nEager loading for many-to-one and one-to-one associations is using either a\nLEFT JOIN or a second query for fetching the related entity eagerly.\n\nEager loading for many-to-one associations uses a second query to load\nthe collections for several entities at the same time.\n\nWhen many-to-many, one-to-one or one-to-many associations are eagerly loaded,\nthen the global batch size configuration is used to avoid IN(?) queries with\ntoo many arguments. The default batch size is 100 and can be changed with\n``Configuration::setEagerFetchBatchSize()``.\n\nFor eagerly loaded Many-To-Many associations one query has to be made for each\ncollection.\n\nBy Lazy Loading\n~~~~~~~~~~~~~~~\n\nWhenever you have a managed entity instance at hand, you can\ntraverse and use any associations of that entity that are\nconfigured LAZY as if they were in-memory already. Doctrine will\nautomatically load the associated objects on demand through the\nconcept of lazy-loading.\n\nBy DQL\n~~~~~~\n\nThe most powerful and flexible method to query for persistent\nobjects is the Doctrine Query Language, an object query language.\nDQL enables you to query for persistent objects in the language of\nobjects. DQL understands classes, fields, inheritance and\nassociations. DQL is syntactically very similar to the familiar SQL\nbut *it is not SQL*.\n\nA DQL query is represented by an instance of the\n``Doctrine\\ORM\\Query`` class. You create a query using\n``EntityManager#createQuery($dql)``. Here is a simple example:\n\n.. code-block:: php\n\n createQuery(\"select u from MyDomain\\Model\\User u where u.age >= 20 and u.age <= 30\");\n $users = $q->getResult();\n\nNote that this query contains no knowledge about the relational\nschema, only about the object model. DQL supports positional as\nwell as named parameters, many functions, (fetch) joins,\naggregates, subqueries and much more. Detailed information about\nDQL and its syntax as well as the Doctrine class can be found in\n:doc:`the dedicated chapter `.\nFor programmatically building up queries based on conditions that\nare only known at runtime, Doctrine provides the special\n``Doctrine\\ORM\\QueryBuilder`` class. While this a powerful tool,\nit also brings more complexity to your code compared to plain DQL,\nso you should only use it when you need it. More information on\nconstructing queries with a QueryBuilder can be found\n:doc:`in Query Builder chapter `.\n\nBy Native Queries\n~~~~~~~~~~~~~~~~~\n\nAs an alternative to DQL or as a fallback for special SQL\nstatements native queries can be used. Native queries are built by\nusing a hand-crafted SQL query and a ResultSetMapping that\ndescribes how the SQL result set should be transformed by Doctrine.\nMore information about native queries can be found in\n:doc:`the dedicated chapter `.\n\nCustom Repositories\n~~~~~~~~~~~~~~~~~~~\n\nBy default the EntityManager returns a default implementation of\n``Doctrine\\ORM\\EntityRepository`` when you call\n``EntityManager#getRepository($entityClass)``. You can overwrite\nthis behaviour by specifying the class name of your own Entity\nRepository in the Attribute or XML metadata. In large\napplications that require lots of specialized DQL queries using a\ncustom repository is one recommended way of grouping these queries\nin a central location.\n\n.. code-block:: php\n\n */\n public function getAllAdminUsers(): Collection\n {\n return $this->_em->createQuery('SELECT u FROM MyDomain\\Model\\User u WHERE u.status = \"admin\"')\n ->getResult();\n }\n }\n\nYou can access your repository now by calling:\n\n.. code-block:: php\n\n getRepository('MyDomain\\Model\\User')->getAllAdminUsers();\n"
},
{
"path": "docs/en/reference/xml-mapping.rst",
"content": "XML Mapping\n===========\n\nThe XML mapping driver enables you to provide the ORM metadata in\nform of XML documents. It requires the ``dom`` extension in order to be\nable to validate your mapping documents against its XML Schema.\n\nThe XML driver is backed by an XML Schema document that describes\nthe structure of a mapping document. The most recent version of the\nXML Schema document is available online at\n`https://www.doctrine-project.org/schemas/orm/doctrine-mapping.xsd `_.\nThe most convenient way to work with\nXML mapping files is to use an IDE/editor that can provide\ncode-completion based on such an XML Schema document. The following\nis an outline of a XML mapping document with the proper xmlns/xsi\nsetup for the latest code in trunk.\n\n.. code-block:: xml\n\n \n\n ...\n\n \n\nThe XML mapping document of a class is loaded on-demand the first\ntime it is requested and subsequently stored in the metadata cache.\nIn order to work, this requires certain conventions:\n\n\n- Each entity/mapped superclass must get its own dedicated XML\n mapping document.\n- The name of the mapping document must consist of the fully\n qualified name of the class, where namespace separators are\n replaced by dots (.). For example an Entity with the fully\n qualified class-name \"MyProject\" would require a mapping file\n \"MyProject.Entities.User.dcm.xml\" unless the extension is changed.\n- All mapping documents should get the extension \".dcm.xml\" to\n identify it as a Doctrine mapping file. This is more of a\n convention and you are not forced to do this. You can change the\n file extension easily enough.\n\n.. code-block:: php\n\n getLocator()->setFileExtension('.xml');\n\nIt is recommended to put all XML mapping documents in a single\nfolder but you can spread the documents over several folders if you\nwant to. In order to tell the XmlDriver where to look for your\nmapping documents, supply an array of paths as the first argument\nof the constructor, like this:\n\n.. code-block:: php\n\n setMetadataDriverImpl($driver);\n\n.. warning::\n\n Note that Doctrine ORM does not modify any settings for ``libxml``,\n therefore, external XML entities may or may not be enabled or\n configured correctly.\n XML mappings are not XXE/XEE attack vectors since they are not\n related with user input, but it is recommended that you do not\n use external XML entities in your mapping files to avoid running\n into unexpected behaviour.\n\nSimplified XML Driver\n~~~~~~~~~~~~~~~~~~~~~\n\nThe Symfony project sponsored a driver that simplifies usage of the XML Driver.\nThe changes between the original driver are:\n\n1. File Extension is .orm.xml\n2. Filenames are shortened, \"MyProject\\Entities\\User\" will become User.orm.xml\n3. You can add a global file and add multiple entities in this file.\n\nConfiguration of this client works a little bit different:\n\n.. code-block:: php\n\n 'MyProject\\Entities',\n '/path/to/files2' => 'OtherProject\\Entities'\n );\n $driver = new \\Doctrine\\ORM\\Mapping\\Driver\\SimplifiedXmlDriver($namespaces);\n $driver->setGlobalBasename('global'); // global.orm.xml\n\nExample\n-------\n\nAs a quick start, here is a small example document that makes use\nof several common elements:\n\n.. code-block:: xml\n\n // Doctrine.Tests.ORM.Mapping.User.dcm.xml\n \n \n\n \n\n \n \n \n\n \n \n \n\n \n \n \n \n \n\n \n \n \n \n\n \n \n\n \n \n \n \n\n \n \n \n \n \n \n \n \n\n \n \n \n \n \n \n \n \n \n \n \n \n \n\n \n\n \n\nBe aware that class-names specified in the XML files should be\nfully qualified.\n\nXML-Element Reference\n---------------------\n\nThe XML-Element reference explains all the tags and attributes that\nthe Doctrine Mapping XSD Schema defines. You should read the\nBasic-, Association- and Inheritance Mapping chapters to understand\nwhat each of this definitions means in detail.\n\nDefining an Entity\n~~~~~~~~~~~~~~~~~~\n\nEach XML Mapping File contains the definition of one entity,\nspecified as the ```` element as a direct child of the\n```` element:\n\n.. code-block:: xml\n\n \n \n \n \n \n\nRequired attributes:\n\n\n- name - The fully qualified class-name of the entity.\n\nOptional attributes:\n\n\n- **table** - The Table-Name to be used for this entity. Otherwise the\n Unqualified Class-Name is used by default.\n- **repository-class** - The fully qualified class-name of an\n alternative ``Doctrine\\ORM\\EntityRepository`` implementation to be\n used with this entity.\n- **inheritance-type** - The type of inheritance, defaults to none. A\n more detailed description follows in the\n *Defining Inheritance Mappings* section.\n- **read-only** - Specifies that this entity is marked as read only and not\n considered for change-tracking. Entities of this type can be persisted\n and removed though.\n- **schema** - The schema the table lies in, for platforms that support schemas\n\nDefining Fields\n~~~~~~~~~~~~~~~\n\nEach entity class can contain zero to infinite fields that are\nmanaged by Doctrine. You can define them using the ````\nelement as a children to the ```` element. The field\nelement is only used for primitive types that are not the ID of the\nentity. For the ID mapping you have to use the ```` element.\n\n.. code-block:: xml\n\n \n\n \n \n \n \n \n \n \n \n \n \n \n \n\nRequired attributes:\n\n\n- name - The name of the Property/Field on the given Entity PHP\n class.\n\nOptional attributes:\n\n\n- type - The ``Doctrine\\DBAL\\Types\\Type`` name, defaults to\n \"string\"\n- column - Name of the column in the database, defaults to the\n field name.\n- length - The length of the given type, for use with strings\n only.\n- unique - Should this field contain a unique value across the\n table? Defaults to false.\n- index - Should an index be created for this column? Defaults to\n false.\n- nullable - Should this field allow NULL as a value? Defaults to\n false.\n- insertable - Should this field be inserted? Defaults to true.\n- updatable - Should this field be updated? Defaults to true.\n- generated - Enum of the values ALWAYS, INSERT, NEVER that determines if\n generated value must be fetched from database after INSERT or UPDATE.\n Defaults to \"NEVER\".\n- version - Should this field be used for optimistic locking? Only\n works on fields with type integer or datetime.\n- scale - Scale of a decimal type.\n- precision - Precision of a decimal type.\n- options - Array of additional options:\n\n - default - The default value to set for the column if no value\n is supplied.\n - unsigned - Boolean value to determine if the column should\n be capable of representing only non-negative integers\n (applies only for integer column and might not be supported by\n all vendors).\n - fixed - Boolean value to determine if the specified length of\n a string column should be fixed or varying (applies only for\n string/binary column and might not be supported by all vendors).\n - comment - The comment of the column in the schema (might not\n be supported by all vendors).\n - customSchemaOptions - Array of additional schema options\n which are mostly vendor specific.\n- column-definition - Optional alternative SQL representation for\n this column. This definition begin after the field-name and has to\n specify the complete column definition. Using this feature will\n turn this field dirty for Schema-Tool update commands at all\n times.\n\n.. note::\n\n For more detailed information on each attribute, please refer to\n the DBAL ``Schema-Representation`` documentation.\n\nDefining Identity and Generator Strategies\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nAn entity has to have at least one ```` element. For\ncomposite keys you can specify more than one id-element, however\nsurrogate keys are recommended for use with Doctrine ORM. The Id\nfield allows to define properties of the identifier and allows a\nsubset of the ```` element attributes:\n\n.. code-block:: xml\n\n \n \n \n\nRequired attributes:\n\n\n- name - The name of the Property/Field on the given Entity PHP\n class.\n- type - The ``Doctrine\\DBAL\\Types\\Type`` name, preferably\n \"string\" or \"integer\".\n\nOptional attributes:\n\n\n- column - Name of the column in the database, defaults to the\n field name.\n\nUsing the simplified definition above Doctrine will use no\nidentifier strategy for this entity. That means you have to\nmanually set the identifier before calling\n``EntityManager#persist($entity)``. This is the so called\n``NONE`` strategy.\n\nIf you want to switch the identifier generation strategy you have\nto nest a ```` element inside the id-element. This of\ncourse only works for surrogate keys. For composite keys you always\nhave to use the ``NONE`` strategy.\n\n.. code-block:: xml\n\n \n \n \n \n \n\nThe following values are allowed for the ```` strategy\nattribute:\n\n\n- AUTO - Automatic detection of the identifier strategy based on\n the preferred solution of the database vendor.\n- IDENTITY - Use of a IDENTIFY strategy such as Auto-Increment IDs\n available to Doctrine AFTER the INSERT statement has been executed.\n- SEQUENCE - Use of a database sequence to retrieve the\n entity-ids. This is possible before the INSERT statement is\n executed.\n\nIf you are using the SEQUENCE strategy you can define an additional\nelement to describe the sequence:\n\n.. code-block:: xml\n\n \n \n \n \n \n \n\nRequired attributes for ````:\n\n\n- sequence-name - The name of the sequence\n\nOptional attributes for ````:\n\n\n- allocation-size - By how much steps should the sequence be\n incremented when a value is retrieved. Defaults to 1\n- initial-value - What should the initial value of the sequence\n be.\n\n **NOTE**\n\n If you want to implement a cross-vendor compatible application you\n have to specify and additionally define the \n element, if Doctrine chooses the sequence strategy for a\n platform.\n\n\nDefining a Mapped Superclass\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nSometimes you want to define a class that multiple entities inherit\nfrom, which itself is not an entity however. The chapter on\n*Inheritance Mapping* describes a Mapped Superclass in detail. You\ncan define it in XML using the ```` tag.\n\n.. code-block:: xml\n\n \n \n \n \n \n \n\nRequired attributes:\n\n\n- name - Class name of the mapped superclass.\n\nYou can nest any number of ```` and unidirectional\n```` or ```` associations inside a\nmapped superclass.\n\nDefining Inheritance Mappings\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nThere are currently two inheritance persistence strategies that you\ncan choose from when defining entities that inherit from each\nother. Single Table inheritance saves the fields of the complete\ninheritance hierarchy in a single table, joined table inheritance\ncreates a table for each entity combining the fields using join\nconditions.\n\nYou can specify the inheritance type in the ```` element\nand then use the ```` and\n```` attributes.\n\n.. code-block:: xml\n\n \n \n \n \n \n \n \n \n\nThe allowed values for inheritance-type attribute are ``JOINED`` or\n``SINGLE_TABLE``.\n\n.. note::\n\n All inheritance related definitions have to be defined on the root\n entity of the hierarchy.\n\n\nDefining Lifecycle Callbacks\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nYou can define the lifecycle callback methods on your entities\nusing the ```` element:\n\n.. code-block:: xml\n\n \n\n \n \n \n \n\nDefining One-To-One Relations\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nYou can define One-To-One Relations/Associations using the\n```` element. The required and optional attributes\ndepend on the associations being on the inverse or owning side.\n\nFor the inverse side the mapping is as simple as:\n\n.. code-block:: xml\n\n \n \n \n\nRequired attributes for inverse One-To-One:\n\n\n- field - Name of the property/field on the entity's PHP class.\n- target-entity - Name of the entity associated entity class. If\n this is not qualified the namespace of the current class is\n prepended. *IMPORTANT:* No leading backslash!\n- mapped-by - Name of the field on the owning side (here Address\n entity) that contains the owning side association.\n\nFor the owning side this mapping would look like:\n\n.. code-block:: xml\n\n \n \n \n\nRequired attributes for owning One-to-One:\n\n\n- field - Name of the property/field on the entity's PHP class.\n- target-entity - Name of the entity associated entity class. If\n this is not qualified the namespace of the current class is\n prepended. *IMPORTANT:* No leading backslash!\n\nOptional attributes for owning One-to-One:\n\n\n- inversed-by - If the association is bidirectional the\n inversed-by attribute has to be specified with the name of the\n field on the inverse entity that contains the back-reference.\n- orphan-removal - If true, the inverse side entity is always\n deleted when the owning side entity is. Defaults to false.\n- fetch - Either LAZY or EAGER, defaults to LAZY. This attribute\n makes only sense on the owning side, the inverse side *ALWAYS* has\n to use the ``FETCH`` strategy.\n\nThe definition for the owning side relies on a bunch of mapping\ndefaults for the join column names. Without the nested\n```` element Doctrine assumes to foreign key to be\ncalled ``user_id`` on the Address Entities table. This is because\nthe ``MyProject\\Address`` entity is the owning side of this\nassociation, which means it contains the foreign key.\n\nThe completed explicitly defined mapping is:\n\n.. code-block:: xml\n\n \n \n \n \n \n\nDefining Many-To-One Associations\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nThe many-to-one association is *ALWAYS* the owning side of any\nbidirectional association. This simplifies the mapping compared to\nthe one-to-one case. The minimal mapping for this association looks\nlike:\n\n.. code-block:: xml\n\n \n \n \n\nRequired attributes:\n\n\n- field - Name of the property/field on the entity's PHP class.\n- target-entity - Name of the entity associated entity class. If\n this is not qualified the namespace of the current class is\n prepended. *IMPORTANT:* No leading backslash!\n\nOptional attributes:\n\n\n- inversed-by - If the association is bidirectional the\n inversed-by attribute has to be specified with the name of the\n field on the inverse entity that contains the back-reference.\n- orphan-removal - If true the entity on the inverse side is\n always deleted when the owning side entity is and it is not\n connected to any other owning side entity anymore. Defaults to\n false.\n- fetch - Either LAZY or EAGER, defaults to LAZY.\n\nThis definition relies on a bunch of mapping defaults with regards\nto the naming of the join-column/foreign key. The explicitly\ndefined mapping includes a ```` tag nested inside\nthe many-to-one association tag:\n\n.. code-block:: xml\n\n \n \n \n \n \n\nThe join-column attribute ``name`` specifies the column name of the\nforeign key and the ``referenced-column-name`` attribute specifies\nthe name of the primary key column on the User entity.\n\nDefining One-To-Many Associations\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nThe one-to-many association is *ALWAYS* the inverse side of any\nassociation. There exists no such thing as a uni-directional\none-to-many association, which means this association only ever\nexists for bi-directional associations.\n\n.. code-block:: xml\n\n \n \n \n\nRequired attributes:\n\n\n- field - Name of the property/field on the entity's PHP class.\n- target-entity - Name of the entity associated entity class. If\n this is not qualified the namespace of the current class is\n prepended. *IMPORTANT:* No leading backslash!\n- mapped-by - Name of the field on the owning side (here\n Phonenumber entity) that contains the owning side association.\n\nOptional attributes:\n\n\n- fetch - Either LAZY, EXTRA_LAZY or EAGER, defaults to LAZY.\n- index-by: Index the collection by a field on the target entity.\n\nDefining Many-To-Many Associations\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nFrom all the associations the many-to-many has the most complex\ndefinition. When you rely on the mapping defaults you can omit many\ndefinitions and rely on their implicit values.\n\n.. code-block:: xml\n\n \n \n \n\nRequired attributes:\n\n\n- field - Name of the property/field on the entity's PHP class.\n- target-entity - Name of the entity associated entity class. If\n this is not qualified the namespace of the current class is\n prepended. *IMPORTANT:* No leading backslash!\n\nOptional attributes:\n\n\n- mapped-by - Name of the field on the owning side that contains\n the owning side association if the defined many-to-many association\n is on the inverse side.\n- inversed-by - If the association is bidirectional the\n inversed-by attribute has to be specified with the name of the\n field on the inverse entity that contains the back-reference.\n- fetch - Either LAZY, EXTRA_LAZY or EAGER, defaults to LAZY.\n- index-by: Index the collection by a field on the target entity.\n\nThe mapping defaults would lead to a join-table with the name\n\"User\\_Group\" being created that contains two columns \"user\\_id\"\nand \"group\\_id\". The explicit definition of this mapping would be:\n\n.. code-block:: xml\n\n \n \n \n \n \n \n \n \n \n \n \n \n\nHere both the ```` and ````\ntags are necessary to tell Doctrine for which side the specified\njoin-columns apply. These are nested inside a ````\nattribute which allows to specify the table name of the\nmany-to-many join-table.\n\nCascade Element\n~~~~~~~~~~~~~~~\n\nDoctrine allows cascading of several UnitOfWork operations to\nrelated entities. You can specify the cascade operations in the\n```` element inside any of the association mapping\ntags.\n\n.. code-block:: xml\n\n \n \n \n \n \n \n \n\nBesides ```` the following operations can be\nspecified by their respective tags:\n\n\n- ````\n- ````\n- ````\n- ````\n\nJoin Column Element\n~~~~~~~~~~~~~~~~~~~\n\nIn any explicitly defined association mapping you will need the\n```` tag. It defines how the foreign key and primary\nkey names are called that are used for joining two entities.\n\nRequired attributes:\n\n\n- name - The column name of the foreign key.\n- referenced-column-name - The column name of the associated\n entities primary key\n\nOptional attributes:\n\n\n- unique - If the join column should contain a UNIQUE constraint.\n This makes sense for Many-To-Many join-columns only to simulate a\n one-to-many unidirectional using a join-table.\n- nullable - should the join column be nullable, defaults to true.\n- on-delete - Foreign Key Cascade action to perform when entity is\n deleted, defaults to NO ACTION/RESTRICT but can be set to\n \"CASCADE\".\n\nDefining Order of To-Many Associations\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nYou can require one-to-many or many-to-many associations to be\nretrieved using an additional ``ORDER BY``.\n\n.. code-block:: xml\n\n \n \n \n \n \n \n \n\nDefining Indexes or Unique Constraints\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nTo define additional indexes or unique constraints on the entities\ntable you can use the ```` and\n```` elements:\n\n.. code-block:: xml\n\n \n\n \n \n \n \n\n \n \n \n \n\nYou have to specify the column and not the entity-class field names\nin the index and unique-constraint definitions.\n\nDerived Entities ID syntax\n~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nIf the primary key of an entity contains a foreign key to another entity we speak of a derived\nentity relationship. You can define this in XML with the \"association-key\" attribute in the ```` tag.\n\n.. code-block:: xml\n\n \n\n \n \n \n\n \n\n \n \n\n \n"
},
{
"path": "docs/en/sidebar.rst",
"content": ":orphan:\n\n.. toctree::\n :caption: Tutorials\n :depth: 3\n\n tutorials/getting-started\n tutorials/working-with-indexed-associations\n tutorials/extra-lazy-associations\n tutorials/composite-primary-keys\n tutorials/ordered-associations\n tutorials/override-field-association-mappings-in-subclasses\n tutorials/pagination\n tutorials/embeddables\n\n.. toctree::\n :caption: Reference\n :depth: 3\n\n reference/architecture\n reference/configuration\n reference/faq\n reference/basic-mapping\n reference/association-mapping\n reference/inheritance-mapping\n reference/working-with-objects\n reference/working-with-associations\n reference/typedfieldmapper\n reference/events\n reference/unitofwork\n reference/unitofwork-associations\n reference/transactions-and-concurrency\n reference/batch-processing\n reference/dql-doctrine-query-language\n reference/query-builder\n reference/native-sql\n reference/change-tracking-policies\n reference/partial-hydration\n reference/partial-objects\n reference/attributes-reference\n reference/xml-mapping\n reference/php-mapping\n reference/caching\n reference/improving-performance\n reference/tools\n reference/metadata-drivers\n reference/best-practices\n reference/limitations-and-known-issues\n tutorials/pagination\n reference/filters\n reference/namingstrategy\n reference/advanced-configuration\n reference/second-level-cache\n reference/security\n\n.. toctree::\n :caption: Cookbook\n :depth: 3\n\n cookbook/aggregate-fields\n cookbook/custom-mapping-types\n cookbook/decorator-pattern\n cookbook/dql-custom-walkers\n cookbook/dql-user-defined-functions\n cookbook/generated-columns\n cookbook/implementing-arrayaccess-for-domain-objects\n cookbook/resolve-target-entity-listener\n cookbook/sql-table-prefixes\n cookbook/strategy-cookbook-introduction\n cookbook/validation-of-entities\n cookbook/working-with-datetime\n cookbook/mysql-enums\n cookbook/advanced-field-value-conversion-using-custom-mapping-types\n cookbook/entities-in-session\n"
},
{
"path": "docs/en/tutorials/composite-primary-keys.rst",
"content": "Composite and Foreign Keys as Primary Key\n=========================================\n\nDoctrine ORM supports composite primary keys natively. Composite keys are a very powerful relational database concept\nand we took good care to make sure Doctrine ORM supports as many of the composite primary key use-cases.\nFor Doctrine ORM composite keys of primitive data-types are supported, even foreign keys as\nprimary keys are supported.\n\nThis tutorial shows how the semantics of composite primary keys work and how they map to the database.\n\nGeneral Considerations\n~~~~~~~~~~~~~~~~~~~~~~\n\nEvery entity with a composite key cannot use an id generator other than \"NONE\". That means\nthe ID fields have to have their values set before you call ``EntityManager#persist($entity)``.\n\nPrimitive Types only\n~~~~~~~~~~~~~~~~~~~~\n\nYou can have composite keys as long as they only consist of the primitive types\n``integer`` and ``string``. Suppose you want to create a database of cars and use the model-name\nand year of production as primary keys:\n\n.. configuration-block::\n\n .. code-block:: attribute\n\n name;\n }\n\n public function getYearOfProduction(): int\n {\n return $this->year;\n }\n }\n\n .. code-block:: xml\n\n \n \n\n \n \n \n \n \n\nNow you can use this entity:\n\n.. code-block:: php\n\n persist($car);\n $em->flush();\n\nAnd for querying you can use arrays to both DQL and EntityRepositories:\n\n.. code-block:: php\n\n find(\"VehicleCatalogue\\Model\\Car\", [\"name\" => \"Audi A8\", \"year\" => 2010]);\n\n $dql = \"SELECT c FROM VehicleCatalogue\\Model\\Car c WHERE c.name = ?1 AND c.year = ?2\";\n $audi = $em->createQuery($dql)\n ->setParameter(1, \"Audi A8\")\n ->setParameter(2, 2010)\n ->getSingleResult();\n\nYou can also use this entity in associations. Doctrine will then generate two foreign keys one for ``name``\nand to ``year`` to the related entities.\n\n.. note::\n\n This example shows how you can nicely solve the requirement for existing\n values before ``EntityManager#persist()``: By adding them as mandatory values for the constructor.\n\nIdentity through foreign Entities\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nThere are tons of use-cases where the identity of an Entity should be determined by the entity\nof one or many parent entities.\n\n- Dynamic Attributes of an Entity (for example Article). Each Article has many\n attributes with primary key \"article_id\" and \"attribute_name\".\n- Address object of a Person, the primary key of the address is \"user_id\". This is not a case of a composite primary\n key, but the identity is derived through a foreign entity and a foreign key.\n- Join Tables with metadata can be modelled as Entity, for example connections between two articles\n with a little description and a score.\n\nThe semantics of mapping identity through foreign entities are easy:\n\n- Only allowed on Many-To-One or One-To-One associations.\n- Plug an ``#[Id]`` attribute onto every association.\n- Set an attribute ``association-key`` with the field name of the association in XML.\n\nUse-Case 1: Dynamic Attributes\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nWe keep up the example of an Article with arbitrary attributes, the mapping looks like this:\n\n.. configuration-block::\n\n .. code-block:: attribute\n\n */\n #[OneToMany(targetEntity: ArticleAttribute::class, mappedBy: 'article', cascade: ['ALL'], indexBy: 'attribute')]\n private Collection $attributes;\n\n public function addAttribute(string $name, string $value): void\n {\n $this->attributes[$name] = new ArticleAttribute($name, $value, $this);\n }\n }\n\n #[Entity]\n class ArticleAttribute\n {\n #[Id, ManyToOne(targetEntity: Article::class, inversedBy: 'attributes')]\n private Article $article;\n\n #[Id, Column]\n private string $attribute;\n\n #[Column]\n private string $value;\n\n public function __construct(string $name, string $value, Article $article)\n {\n $this->attribute = $name;\n $this->value = $value;\n $this->article = $article;\n }\n }\n\n .. code-block:: xml\n\n \n\n \n \n \n\n \n\n \n \n\n \n\nUse-Case 2: Simple Derived Identity\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nSometimes you have the requirement that two objects are related by a One-To-One association\nand that the dependent class should re-use the primary key of the class it depends on.\nOne good example for this is a user-address relationship:\n\n.. configuration-block::\n\n .. code-block:: attribute\n\n */\n #[OneToMany(targetEntity: OrderItem::class, mappedBy: 'order')]\n private Collection $items;\n\n #[Column]\n private bool $paid = false;\n #[Column]\n private bool $shipped = false;\n #[Column]\n private DateTime $created;\n\n public function __construct(\n #[ManyToOne(targetEntity: Customer::class)]\n private Customer $customer\n ) {\n $this->items = new ArrayCollection();\n $this->created = new DateTime(\"now\");\n }\n }\n\n #[Entity]\n class Product\n {\n #[Id, Column, GeneratedValue]\n private int|null $id = null;\n\n #[Column]\n private string $name;\n\n #[Column]\n private int $currentPrice;\n\n public function getCurrentPrice(): int\n {\n return $this->currentPrice;\n }\n }\n\n #[Entity]\n class OrderItem\n {\n #[Id, ManyToOne(targetEntity: Order::class)]\n private Order|null $order = null;\n\n #[Id, ManyToOne(targetEntity: Product::class)]\n private Product|null $product = null;\n\n #[Column]\n private int $amount = 1;\n\n #[Column]\n private int $offeredPrice;\n\n public function __construct(Order $order, Product $product, int $amount = 1)\n {\n $this->order = $order;\n $this->product = $product;\n $this->offeredPrice = $product->getCurrentPrice();\n $this->amount = $amount;\n }\n }\n\n\nPerformance Considerations\n~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nUsing composite keys always comes with a performance hit compared to using entities with\na simple surrogate key. This performance impact is mostly due to additional PHP code that is\nnecessary to handle this kind of keys, most notably when using derived identifiers.\n\nOn the SQL side there is not much overhead as no additional or unexpected queries have to be\nexecuted to manage entities with derived foreign keys.\n"
},
{
"path": "docs/en/tutorials/embeddables.rst",
"content": "Separating Concerns using Embeddables\n=====================================\n\nEmbeddables are classes which are not entities themselves, but are embedded\nin entities and can also be queried in DQL. You'll mostly want to use them\nto reduce duplication or separating concerns. Value objects such as date range\nor address are the primary use case for this feature.\n\n.. note::\n\n Embeddables can only contain properties with basic ``@Column`` mapping.\n\nFor the purposes of this tutorial, we will assume that you have a ``User``\nclass in your application and you would like to store an address in\nthe ``User`` class. We will model the ``Address`` class as an embeddable\ninstead of simply adding the respective columns to the ``User`` class.\n\n.. configuration-block::\n\n .. code-block:: attribute\n\n \n \n \n \n\n \n \n \n \n \n \n \n\nIn terms of your database schema, Doctrine will automatically inline all\ncolumns from the ``Address`` class into the table of the ``User`` class,\njust as if you had declared them directly there.\n\nInitializing embeddables\n------------------------\n\nIn case all fields in the embeddable are ``nullable``, you might want\nto initialize the embeddable, to avoid getting a null value instead of\nthe embedded object.\n\n.. code-block:: php\n\n public function __construct()\n {\n $this->address = new Address();\n }\n\nColumn Prefixing\n----------------\n\nBy default, Doctrine names your columns by prefixing them, using the value\nobject name.\n\nFollowing the example above, your columns would be named as ``address_street``,\n``address_postalCode``...\n\nYou can change this behaviour to meet your needs by changing the\n``columnPrefix`` attribute in the ``@Embedded`` notation.\n\nThe following example shows you how to set your prefix to ``myPrefix_``:\n\n.. configuration-block::\n\n .. code-block:: attribute\n\n \n \n \n\nTo have Doctrine drop the prefix and use the value object's property name\ndirectly, set ``columnPrefix=false`` (``use-column-prefix=\"false\"`` for XML):\n\n.. configuration-block::\n\n .. code-block:: attribute\n\n \n \n \n\n\nDQL\n---\n\nYou can also use mapped fields of embedded classes in DQL queries, just\nas if they were declared in the ``User`` class:\n\n.. code-block:: sql\n\n SELECT u FROM User u WHERE u.address.city = :myCity\n"
},
{
"path": "docs/en/tutorials/extra-lazy-associations.rst",
"content": "Extra Lazy Associations\n=======================\n\n.. versionadded:: 2.1\n\nIn many cases associations between entities can get pretty large. Even in a simple scenario like a blog.\nwhere posts can be commented, you always have to assume that a post draws hundreds of comments.\nIn Doctrine ORM if you accessed an association it would always get loaded completely into memory. This\ncan lead to pretty serious performance problems, if your associations contain several hundreds or thousands\nof entities.\n\nDoctrine ORM includes a feature called **Extra Lazy** for associations. Associations\nare marked as **Lazy** by default, which means the whole collection object for an association is populated\nthe first time its accessed. If you mark an association as extra lazy the following methods on collections\ncan be called without triggering a full load of the collection:\n\n- ``Collection#contains($entity)``\n- ``Collection#containsKey($key)``\n- ``Collection#count()``\n- ``Collection#first()``\n- ``Collection#get($key)``\n- ``Collection#isEmpty()``\n- ``Collection#slice($offset, $length = null)``\n\nFor each of the above methods the following semantics apply:\n\n- For each call, if the Collection is not yet loaded, issue a straight SELECT statement against the database.\n- For each call, if the collection is already loaded, fallback to the default functionality for lazy collections. No additional SELECT statements are executed.\n\nAdditionally even with Doctrine ORM the following methods do not trigger the collection load:\n\n- ``Collection#add($entity)``\n- ``Collection#offsetSet($key, $entity)`` - ArrayAccess with no specific key ``$coll[] = $entity``, it does\n not work when setting specific keys like ``$coll[0] = $entity``.\n\nWith extra lazy collections you can now not only add entities to large collections but also paginate them\neasily using a combination of ``count`` and ``slice``.\n\n\n.. warning::\n\n ``removeElement`` directly issued DELETE queries to the database from\n version 2.4.0 to 2.7.0. This circumvents the flush operation and might run\n outside a transactional boundary if you don't create one yourself. We\n consider this a critical bug in the assumption of how the ORM works and\n reverted ``removeElement`` EXTRA_LAZY behavior in 2.7.1.\n\n\nEnabling Extra-Lazy Associations\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nThe mapping configuration is simple. Instead of using the default value of ``fetch=\"LAZY\"`` you have to\nswitch to extra lazy as shown in these examples:\n\n.. configuration-block::\n\n .. code-block:: attribute\n\n */\n #[ManyToMany(targetEntity: CmsUser::class, mappedBy: 'groups', fetch: 'EXTRA_LAZY')]\n public Collection $users;\n }\n\n .. code-block:: xml\n\n \n \n\n \n \n \n \n \n"
},
{
"path": "docs/en/tutorials/getting-started.rst",
"content": "Getting Started with Doctrine\n=============================\n\nThis guide covers getting started with the Doctrine ORM. After working\nthrough the guide you should know:\n\n- How to install and configure Doctrine by connecting it to a database\n- Mapping PHP objects to database tables\n- Generating a database schema from PHP objects\n- Using the ``EntityManager`` to insert, update, delete and find\n objects in the database.\n\nGuide Assumptions\n-----------------\n\nThis guide is designed for beginners that haven't worked with Doctrine ORM\nbefore. There are some prerequisites for the tutorial that have to be\ninstalled:\n\n- PHP (latest stable version)\n- Composer Package Manager (\\ `Install Composer\n `_)\n\nThe code of this tutorial is `available on Github `_.\n\nWhat is Doctrine?\n-----------------\n\nDoctrine ORM is an `object-relational mapper (ORM) `_\nfor PHP that provides transparent persistence for PHP objects. It uses the Data Mapper\npattern at the heart, aiming for a complete separation of your domain/business\nlogic from the persistence in a relational database management system.\n\nThe benefit of Doctrine for the programmer is the ability to focus\non the object-oriented business logic and worry about persistence only\nas a secondary problem. This doesn't mean persistence is downplayed by Doctrine\n2, however it is our belief that there are considerable benefits for\nobject-oriented programming if persistence and entities are kept\nseparated.\n\nWhat are Entities?\n~~~~~~~~~~~~~~~~~~\n\nEntities are PHP Objects that can be identified over many requests\nby a unique identifier or primary key. These classes don't need to extend any\nabstract base class or interface.\n\nAn entity contains persistable properties. A persistable property\nis an instance variable of the entity that is saved into and retrieved from the database\nby Doctrine's data mapping capabilities.\n\nAn entity class can be final or read-only when you use\n:ref:`native lazy objects `.\nIt may contain final methods or read-only properties too.\n\nAn Example Model: Bug Tracker\n-----------------------------\n\nFor this Getting Started Guide for Doctrine we will implement the\nBug Tracker domain model from the\n`Zend_Db_Table `_\ndocumentation. Reading their documentation we can extract the\nrequirements:\n\n- A Bug has a description, creation date, status, reporter and\n engineer\n- A Bug can occur on different Products (platforms)\n- A Product has a name.\n- Bug reporters and engineers are both Users of the system.\n- A User can create new Bugs.\n- The assigned engineer can close a Bug.\n- A User can see all their reported or assigned Bugs.\n- Bugs can be paginated through a list-view.\n\nProject Setup\n-------------\n\nCreate a new empty folder for this tutorial project, for example\n``doctrine2-tutorial`` and create a new file ``composer.json`` inside\nthat directory with the following contents:\n\n::\n\n {\n \"require\": {\n \"doctrine/orm\": \"^3\",\n \"doctrine/dbal\": \"^4\",\n \"symfony/cache\": \"^7\"\n },\n \"autoload\": {\n \"psr-0\": {\"\": \"src/\"}\n }\n }\n\n\nInstall Doctrine using the Composer Dependency Management tool, by calling:\n\n::\n\n $ composer install\n\nThis will install the packages Doctrine Common, Doctrine DBAL, Doctrine ORM,\ninto the ``vendor`` directory.\n\nAdd the following directories::\n\n doctrine2-tutorial\n |-- config\n | `-- xml\n `-- src\n\n.. note::\n It is strongly recommended that you require ``doctrine/dbal`` in your\n ``composer.json`` as well, because using the ORM means mapping objects\n and their fields to database tables and their columns, and that\n requires mentioning so-called types that are defined in ``doctrine/dbal``\n in your application. Having an explicit requirement means you control\n when the upgrade to the next major version happens, so that you can\n do the necessary changes in your application beforehand.\n\nObtaining the EntityManager\n---------------------------\n\nDoctrine's public interface is through the ``EntityManager``. This class\nprovides access points to the complete lifecycle management for your entities,\nand transforms entities from and back to persistence. You have to\nconfigure and create it to use your entities with Doctrine ORM. I\nwill show the configuration steps and then discuss them step by\nstep:\n\n.. code-block:: php\n\n 'pdo_sqlite',\n 'path' => __DIR__ . '/db.sqlite',\n ], $config);\n\n // obtaining the entity manager\n $entityManager = new EntityManager($connection, $config);\n\nThe ``require_once`` statement sets up the class autoloading for Doctrine and\nits dependencies using Composer's autoloader.\n\nThe second block consists of the instantiation of the ORM\n``Configuration`` object using the ``ORMSetup`` helper. It assumes a bunch\nof defaults that you don't have to bother about for now. You can\nread up on the configuration details in the\n:doc:`reference chapter on configuration <../reference/configuration>`.\n\nThe third block shows the configuration options required to connect to\na database. In this case, we'll use a file-based SQLite database. All the\nconfiguration options for all the shipped drivers are given in the\n`DBAL Configuration section of the manual `_.\n\nThe last block shows how the ``EntityManager`` is obtained from a\nfactory method.\n\nGenerating the Database Schema\n------------------------------\n\nDoctrine has a command-line interface that allows you to access the SchemaTool,\na component that can generate a relational database schema based entirely on the\ndefined entity classes and their metadata. For this tool to work, you need to\ncreate an executable console script as described in the\n:doc:`tools chapter <../reference/tools>`.\n\nIf you created the ``bootstrap.php`` file as described in the previous section,\nthat script could look like this:\n\n.. code-block:: php\n\n #!/usr/bin/env php\n `_)\n where methods should represent real business operations and not simple\n property change, And business invariants should be maintained both in the\n application state (entities in this case) and in the database, with no\n space for data corruption.\n\nHere is an example of a simple **anemic entity**:\n\n.. configuration-block::\n\n .. code-block:: php\n\n username;\n }\n\n public function setUsername(string $username): void\n {\n $this->username = $username;\n }\n\n public function getPasswordHash(): string\n {\n return $this->passwordHash;\n }\n\n public function setPasswordHash(string $passwordHash): void\n {\n $this->passwordHash = $passwordHash;\n }\n\n public function getBans(): array\n {\n return $this->bans;\n }\n\n public function addBan(Ban $ban): void\n {\n $this->bans[] = $ban;\n }\n }\n\nIn the example above, we avoid all possible logic in the entity and only care\nabout putting and retrieving data into it without validation (except the one\nprovided by type-hints) nor consideration about the object's state.\n\nAs Doctrine ORM is a persistence tool for your domain, the state of an object is\nreally important. This is why we strongly recommend using rich entities.\n\n**Rich entities: Mutators and DTOs**\n\nWe recommend using a rich entity design and rely on more complex mutators,\nand if needed based on DTOs.\nIn this design, you should **not** use getters nor setters, and instead,\nimplement methods that represent the **behavior** of your domain.\n\nFor example, when having a ``User`` entity, we could foresee\nthe following kind of optimization.\n\nExample of a rich entity with proper accessors and mutators:\n\n.. configuration-block::\n\n .. code-block:: php\n username;\n }\n\n public function authenticate(string $password, callable $checkHash): bool\n {\n return $checkHash($password, $this->passwordHash) && ! $this->hasActiveBans();\n }\n\n public function changePassword(string $password, callable $hash): void\n {\n $this->passwordHash = $hash($password);\n }\n\n public function ban(\\DateInterval $duration): void\n {\n assert($duration->invert !== 1);\n\n $this->bans[] = new Ban($this);\n }\n }\n\n.. note::\n\n Please note that this example is only a stub. When going further in the\n documentation, we will update this object with more behavior and maybe\n update some methods.\n\nThe entities should only mutate state after checking that all business logic\ninvariants are being respected.\nAdditionally, our entities should never see their state change without\nvalidation. For example, creating a ``new Product()`` object without any data\nmakes it an **invalid object**.\nRich entities should represent **behavior**, not **data**, therefore\nthey should be valid even after a ``__construct()`` call.\n\nTo help creating such objects, we can rely on ``DTOs``, and/or make\nour entities always up-to-date. This can be performed with static constructors,\nor rich mutators that accept ``DTOs`` as parameters.\n\nThe role of the ``DTO`` is to maintain the entity's state and to help us rely\nupon objects that correctly represent the data that is used to mutate the\nentity.\n\n.. note::\n\n A `DTO `_ is an object\n that only carries data without any logic. Its only goal is to be transferred\n from one service to another.\n A ``DTO`` often represents data sent by a client and that has to be validated,\n but can also be used as simple data carrier for other cases.\n\nBy using ``DTOs``, if we take our previous ``User`` example, we could create\na ``ProfileEditingForm`` DTO that will be a plain model, totally unrelated to\nour database, that will be populated via a form and validated.\nThen we can add a new mutator to our ``User``:\n\n.. configuration-block::\n\n .. code-block:: php\n \n \n\n \n \n \n \n\n \n \n \n\nThe top-level ``entity`` definition specifies information about\nthe class and table name. The primitive type ``Product#name`` is\ndefined as a ``field`` attribute. The ``id`` property is defined with\nthe ``id`` tag. It has a ``generator`` tag nested inside, which\nspecifies that the primary key generation mechanism should automatically\nuse the database platform's native id generation strategy (for\nexample, AUTO INCREMENT in the case of MySql, or Sequences in the\ncase of PostgreSQL and Oracle).\n\nNow that we have defined our first entity and its metadata,\nlet's update the database schema:\n\n::\n\n $ php bin/doctrine orm:schema-tool:update --force --dump-sql\n\nSpecifying both flags ``--force`` and ``--dump-sql`` will cause the DDL\nstatements to be executed and then printed to the screen.\n\nNow, we'll create a new script to insert products into the database:\n\n.. code-block:: php\n\n \n require_once \"bootstrap.php\";\n\n $newProductName = $argv[1];\n\n $product = new Product();\n $product->setName($newProductName);\n\n $entityManager->persist($product);\n $entityManager->flush();\n\n echo \"Created Product with ID \" . $product->getId() . \"\\n\";\n\nCall this script from the command-line to see how new products are created:\n\n::\n\n $ php create_product.php ORM\n $ php create_product.php DBAL\n\nWhat is happening here? Using the ``Product`` class is pretty standard OOP.\nThe interesting bits are the use of the ``EntityManager`` service. To\nnotify the EntityManager that a new entity should be inserted into the database,\nyou have to call ``persist()``. To initiate a transaction to actually *perform*\nthe insertion, you have to explicitly call ``flush()`` on the ``EntityManager``.\n\nThis distinction between persist and flush is what allows the aggregation of\nall database writes (INSERT, UPDATE, DELETE) into one single transaction, which\nis executed when ``flush()`` is called. Using this approach, the write-performance\nis significantly better than in a scenario in which writes are performed on\neach entity in isolation.\n\nNext, we'll fetch a list of all the Products in the database. Let's create a\nnew script for this:\n\n.. code-block:: php\n\n getRepository('Product');\n $products = $productRepository->findAll();\n\n foreach ($products as $product) {\n echo sprintf(\"-%s\\n\", $product->getName());\n }\n\nThe ``EntityManager#getRepository()`` method can create a finder object (called\na repository) for every type of entity. It is provided by Doctrine and contains\nsome finder methods like ``findAll()``.\n\nLet's continue by creating a script to display the name of a product based on its ID:\n\n.. code-block:: php\n\n \n require_once \"bootstrap.php\";\n\n $id = $argv[1];\n $product = $entityManager->find('Product', $id);\n\n if ($product === null) {\n echo \"No product found.\\n\";\n exit(1);\n }\n\n echo sprintf(\"-%s\\n\", $product->getName());\n\nNext we'll update a product's name, given its id. This simple example will\nhelp demonstrate Doctrine's implementation of the :ref:`UnitOfWork pattern `. Doctrine\nkeeps track of all the entities that were retrieved from the Entity Manager,\nand can detect when any of those entities' properties have been modified.\nAs a result, rather than needing to call ``persist($entity)`` for each individual\nentity whose properties were changed, a single call to ``flush()`` at the end of a\nrequest is sufficient to update the database for all of the modified entities.\n\n.. code-block:: php\n\n \n require_once \"bootstrap.php\";\n\n $id = $argv[1];\n $newName = $argv[2];\n\n $product = $entityManager->find('Product', $id);\n\n if ($product === null) {\n echo \"Product $id does not exist.\\n\";\n exit(1);\n }\n\n $product->setName($newName);\n\n $entityManager->flush();\n\nAfter calling this script on one of the existing products, you can verify the\nproduct name changed by calling the ``show_product.php`` script.\n\nAdding Bug and User Entities\n----------------------------\n\nWe continue with the bug tracker example by creating the ``Bug`` and ``User``\nclasses. We'll store them in ``src/Bug.php`` and ``src/User.php``, respectively.\n\n.. code-block:: php\n\n id;\n }\n\n public function getDescription(): string\n {\n return $this->description;\n }\n\n public function setDescription(string $description): void\n {\n $this->description = $description;\n }\n\n public function setCreated(DateTime $created)\n {\n $this->created = $created;\n }\n\n public function getCreated(): DateTime\n {\n return $this->created;\n }\n\n public function setStatus($status): void\n {\n $this->status = $status;\n }\n\n public function getStatus():string\n {\n return $this->status;\n }\n }\n\n.. code-block:: php\n\n id;\n }\n\n public function getName(): string\n {\n return $this->name;\n }\n\n public function setName(string $name): void\n {\n $this->name = $name;\n }\n }\n\nAll of the properties we've seen so far are of simple types (integer, string,\nand datetime). But now, we'll add properties that will store objects of\nspecific *entity types* in order to model the relationships between different\nentities.\n\nAt the database level, relationships between entities are represented by foreign\nkeys. But with Doctrine, you'll never have to (and never should) work with\nthe foreign keys directly. You should only work with objects that represent\nforeign keys through their own identities.\n\nFor every foreign key you either have a Doctrine ManyToOne or OneToOne\nassociation. On the inverse sides of these foreign keys you can have\nOneToMany associations. Obviously you can have ManyToMany associations\nthat connect two tables with each other through a join table with\ntwo foreign keys.\n\nNow that you know the basics about references in Doctrine, we can extend the\ndomain model to match the requirements:\n\n.. code-block:: php\n\n */\n private Collection $products;\n\n public function __construct()\n {\n $this->products = new ArrayCollection();\n }\n }\n\n.. code-block:: php\n\n */\n private Collection $reportedBugs;\n /** @var Collection */\n private Collection $assignedBugs;\n\n public function __construct()\n {\n $this->reportedBugs = new ArrayCollection();\n $this->assignedBugs = new ArrayCollection();\n }\n }\n\n.. note::\n\n Whenever an entity is created from the database, a ``Collection``\n implementation of the type ``PersistentCollection`` will be injected into\n your entity instead of an ``ArrayCollection``. This helps Doctrine ORM\n understand the changes that have happened to the collection that are\n noteworthy for persistence.\n\nBecause we only work with collections for the references we must be\ncareful to implement a bidirectional reference in the domain model.\nThe concept of owning or inverse side of a relation is central to\nthis notion and should always be kept in mind. The following\nassumptions are made about relations and have to be followed to be\nable to work with Doctrine ORM. These assumptions are not unique to\nDoctrine ORM but are best practices in handling database relations\nand Object-Relational Mapping.\n\n- In a one-to-one relation, the entity holding the foreign key of\n the related entity on its own database table is *always* the owning\n side of the relation.\n- In a many-to-one relation, the Many-side is the owning side by\n default because it holds the foreign key. Accordingly, the One-side\n is the inverse side by default.\n- In a many-to-one relation, the One-side can only be the owning side if\n the relation is implemented as a ManyToMany with a join table, and the\n One-side is restricted to allow only UNIQUE values per database constraint.\n- In a many-to-many relation, both sides can be the owning side of\n the relation. However, in a bi-directional many-to-many relation,\n only one side is allowed to be the owning side.\n- Changes to Collections are saved or updated, when the entity on\n the *owning* side of the collection is saved or updated.\n- Saving an Entity at the inverse side of a relation never\n triggers a persist operation to changes to the collection.\n\n.. note::\n\n Consistency of bi-directional references on the inverse side of a\n relation have to be managed in userland application code. Doctrine\n cannot magically update your collections to be consistent.\n\n\nIn the case of Users and Bugs we have references back and forth to\nthe assigned and reported bugs from a user, making this relation\nbi-directional. We have to change the code to ensure consistency of\nthe bi-directional reference:\n\n.. code-block:: php\n\n assignedToBug($this);\n $this->engineer = $engineer;\n }\n\n public function setReporter(User $reporter): void\n {\n $reporter->addReportedBug($this);\n $this->reporter = $reporter;\n }\n\n public function getEngineer(): User\n {\n return $this->engineer;\n }\n\n public function getReporter(): User\n {\n return $this->reporter;\n }\n }\n\n.. code-block:: php\n\n */\n private Collection $reportedBugs;\n /** @var Collection */\n private Collection $assignedBugs;\n\n public function addReportedBug(Bug $bug): void\n {\n $this->reportedBugs[] = $bug;\n }\n\n public function assignedToBug(Bug $bug): void\n {\n $this->assignedBugs[] = $bug;\n }\n }\n\nI chose to name the inverse methods in past-tense, which should\nindicate that the actual assigning has already taken place and the\nmethods are only used for ensuring consistency of the references.\nThis approach is my personal preference, you can choose whatever\nmethod to make this work.\n\nYou can see from ``User#addReportedBug()`` and\n``User#assignedToBug()`` that using this method in userland alone\nwould not add the Bug to the collection of the owning side in\n``Bug#reporter`` or ``Bug#engineer``. Using these methods and\ncalling Doctrine for persistence would not update the Collections'\nrepresentation in the database.\n\nOnly using ``Bug#setEngineer()`` or ``Bug#setReporter()``\ncorrectly saves the relation information.\n\nThe ``Bug#reporter`` and ``Bug#engineer`` properties are\nMany-To-One relations, which point to a User. In a normalized\nrelational model, the foreign key is saved on the Bug's table, hence\nin our object-relation model the Bug is at the owning side of the\nrelation. You should always make sure that the use-cases of your\ndomain model should drive which side is an inverse or owning one in\nyour Doctrine mapping. In our example, whenever a new bug is saved\nor an engineer is assigned to the bug, we don't want to update the\nUser to persist the reference, but the Bug. This is the case with\nthe Bug being at the owning side of the relation.\n\nBugs reference Products by a uni-directional ManyToMany relation in\nthe database that points from Bugs to Products.\n\n.. code-block:: php\n\n */\n private Collection $products;\n\n public function assignToProduct(Product $product): void\n {\n $this->products[] = $product;\n }\n\n /** @return Collection */\n public function getProducts(): Collection\n {\n return $this->products;\n }\n }\n\nWe are now finished with the domain model given the requirements.\nLets add metadata mappings for the ``Bug`` entity, as we did for\nthe ``Product`` before:\n\n.. configuration-block::\n .. code-block:: attribute\n\n */\n #[ORM\\ManyToMany(targetEntity: Product::class)]\n private Collection $products;\n\n // ... (other code)\n }\n\n .. code-block:: xml\n\n \n \n\n \n \n \n \n\n \n \n \n\n \n \n\n \n \n \n\nHere we have the entity, id and primitive type definitions.\nFor the \"created\" field we have used the ``datetime`` type,\nwhich translates the YYYY-mm-dd HH:mm:ss database format\ninto a PHP DateTime instance and back.\n\nAfter the field definitions, the two qualified references to the\nuser entity are defined. They are created by the ``ManyToOne``\nattribute. The class name of the related entity has to be specified with\nthe ``targetEntity`` parameter, which is enough information for\nthe database mapper to access the foreign table. Since\n``reporter`` and ``engineer`` are on the owning side of a\nbi-directional relation, we also have to specify the ``inversedBy``\nparameter. They have to point to the field names on the inverse\nside of the relationship. We will see in the next example that the ``inversedBy``\nparameter has a counterpart ``mappedBy`` which makes that\nthe inverse side.\n\nThe last definition is for the ``Bug#products`` collection. It\nholds all products where the specific bug occurs. Again\nyou have to define the ``targetEntity`` and ``field`` parameters\non the ``ManyToMany`` attribute.\n\nFinally, we'll add metadata mappings for the ``User`` entity.\n\n.. configuration-block::\n\n .. code-block:: attribute\n\n An ArrayCollection of Bug objects. */\n #[ORM\\OneToMany(targetEntity: Bug::class, mappedBy: 'reporter')]\n private Collection $reportedBugs;\n\n /** @var Collection An ArrayCollection of Bug objects. */\n #[ORM\\OneToMany(targetEntity: Bug::class, mappedBy: 'engineer')]\n private $assignedBugs;\n\n // .. (other code)\n }\n\n .. code-block:: xml\n\n \n \n\n \n \n \n \n\n \n\n \n \n \n \n\nHere are some new things to mention about the ``one-to-many`` tags.\nRemember that we discussed about the inverse and owning side. Now\nboth reportedBugs and assignedBugs are inverse relations, which\nmeans the join details have already been defined on the owning\nside. Therefore we only have to specify the property on the Bug\nclass that holds the owning sides.\n\nUpdate your database schema by running::\n\n $ php bin/doctrine orm:schema-tool:update --force\n\n\nImplementing more Requirements\n------------------------------\n\nSo far, we've seen the most basic features of the metadata definition language.\nTo explore additional functionality, let's first create new ``User`` entities:\n\n.. code-block:: php\n\n setName($newUsername);\n\n $entityManager->persist($user);\n $entityManager->flush();\n\n echo \"Created User with ID \" . $user->getId() . \"\\n\";\n\nNow call:\n\n::\n\n $ php create_user.php beberlei\n\nWe now have the necessary data to create a new Bug entity:\n\n.. code-block:: php\n\n \n require_once \"bootstrap.php\";\n\n $reporterId = $argv[1];\n $engineerId = $argv[2];\n $productIds = explode(\",\", $argv[3]);\n\n $reporter = $entityManager->find(\"User\", $reporterId);\n $engineer = $entityManager->find(\"User\", $engineerId);\n if (!$reporter || !$engineer) {\n echo \"No reporter and/or engineer found for the given id(s).\\n\";\n exit(1);\n }\n\n $bug = new Bug();\n $bug->setDescription(\"Something does not work!\");\n $bug->setCreated(new DateTime(\"now\"));\n $bug->setStatus(\"OPEN\");\n\n foreach ($productIds as $productId) {\n $product = $entityManager->find(\"Product\", $productId);\n $bug->assignToProduct($product);\n }\n\n $bug->setReporter($reporter);\n $bug->setEngineer($engineer);\n\n $entityManager->persist($bug);\n $entityManager->flush();\n\n echo \"Your new Bug Id: \".$bug->getId().\"\\n\";\n\nSince we only have one user and product, probably with the ID of 1, we can\ncall this script as follows:\n\n::\n\n php create_bug.php 1 1 1\n\nSee how simple it is to relate a Bug, Reporter, Engineer and Products?\nAlso recall that thanks to the :ref:`UnitOfWork pattern `, Doctrine will detect\nthese relations and update all of the modified entities in the database\nautomatically when ``flush()`` is called.\n\nQueries for Application Use-Cases\n---------------------------------\n\nList of Bugs\n~~~~~~~~~~~~\n\nUsing the previous examples we can fill up the database quite a\nbit. However, we now need to discuss how to query the underlying\nmapper for the required view representations. When opening the\napplication, bugs can be paginated through a list-view, which is\nthe first read-only use-case:\n\n.. code-block:: php\n\n createQuery($dql);\n $query->setMaxResults(30);\n $bugs = $query->getResult();\n\n foreach ($bugs as $bug) {\n echo $bug->getDescription().\" - \".$bug->getCreated()->format('d.m.Y').\"\\n\";\n echo \" Reported by: \".$bug->getReporter()->getName().\"\\n\";\n echo \" Assigned to: \".$bug->getEngineer()->getName().\"\\n\";\n foreach ($bug->getProducts() as $product) {\n echo \" Platform: \".$product->getName().\"\\n\";\n }\n echo \"\\n\";\n }\n\nThe DQL Query in this example fetches the 30 most recent bugs with\ntheir respective engineer and reporter in one single SQL statement.\nThe console output of this script is then:\n\n::\n\n Something does not work! - 02.04.2010\n Reported by: beberlei\n Assigned to: beberlei\n Platform: My Product\n\n.. note::\n\n **DQL is not SQL**\n\n You may wonder why we start writing SQL at the beginning of this\n use-case. Don't we use an ORM to get rid of all the endless\n hand-writing of SQL? Doctrine introduces DQL which is best\n described as **object-query-language** and is a dialect of\n `OQL `_ and\n similar to `HQL `_ or\n `JPQL `_.\n It does not know the concept of columns and tables, but only those\n of Entity-Class and property. Using the Metadata we defined before\n it allows for very short distinctive and powerful queries.\n\n\n An important reason why DQL is favourable to the Query API of most\n ORMs is its similarity to SQL. The DQL language allows query\n constructs that most ORMs don't: GROUP BY even with HAVING,\n Sub-selects, Fetch-Joins of nested classes, mixed results with\n entities and scalar data such as COUNT() results and much more.\n Using DQL you should seldom come to the point where you want to\n throw your ORM into the dumpster, because it doesn't support some\n the more powerful SQL concepts.\n\n If you need to build your query dynamically, you can use the ``QueryBuilder`` retrieved\n by calling ``$entityManager->createQueryBuilder()``. There are more\n details about this in the relevant part of the documentation.\n\n\n As a last resort you can still use Native SQL and a description of the\n result set to retrieve entities from the database. DQL boils down to a\n Native SQL statement and a ``ResultSetMapping`` instance itself. Using\n Native SQL you could even use stored procedures for data retrieval, or\n make use of advanced non-portable database queries like PostgreSQL's\n recursive queries.\n\n\nArray Hydration of the Bug List\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nIn the previous use-case we retrieved the results as their\nrespective object instances. We are not limited to retrieving\nobjects only from Doctrine however. For a simple list view like the\nprevious one we only need read access to our entities and can\nswitch the hydration from objects to simple PHP arrays instead.\n\nHydration can be an expensive process so only retrieving what you need can\nyield considerable performance benefits for read-only requests.\n\nImplementing the same list view as before using array hydration we\ncan rewrite our code:\n\n.. code-block:: php\n\n createQuery($dql);\n $bugs = $query->getArrayResult();\n\n foreach ($bugs as $bug) {\n echo $bug['description'] . \" - \" . $bug['created']->format('d.m.Y').\"\\n\";\n echo \" Reported by: \".$bug['reporter']['name'].\"\\n\";\n echo \" Assigned to: \".$bug['engineer']['name'].\"\\n\";\n foreach ($bug['products'] as $product) {\n echo \" Platform: \".$product['name'].\"\\n\";\n }\n echo \"\\n\";\n }\n\nThere is one significant difference in the DQL query however, we\nhave to add an additional fetch-join for the products connected to\na bug. The resulting SQL query for this single select statement is\npretty large, however still more efficient to retrieve compared to\nhydrating objects.\n\nFind by Primary Key\n~~~~~~~~~~~~~~~~~~~\n\nThe next Use-Case is displaying a Bug by primary key. This could be\ndone using DQL as in the previous example with a where clause,\nhowever there is a convenience method on the ``EntityManager`` that\nhandles loading by primary key, which we have already seen in the\nwrite scenarios:\n\n.. code-block:: php\n\n \n require_once \"bootstrap.php\";\n\n $theBugId = $argv[1];\n\n $bug = $entityManager->find(\"Bug\", (int)$theBugId);\n\n echo \"Bug: \".$bug->getDescription().\"\\n\";\n echo \"Engineer: \".$bug->getEngineer()->getName().\"\\n\";\n\nThe output of the engineer’s name is fetched from the database! What is happening?\n\nSince we only retrieved the bug by primary key both the engineer and reporter\nare not immediately loaded from the database but are replaced by LazyLoading\nproxies. These proxies will load behind the scenes, when attempting to access\nany of their un-initialized state.\n\nThe call prints:\n\n::\n\n $ php show_bug.php 1\n Bug: Something does not work!\n Engineer: beberlei\n\n.. warning::\n\n Lazy loading additional data can be very convenient but the additional\n queries create an overhead. If you know that certain fields will always\n (or usually) be required by the query then you will get better performance\n by explicitly retrieving them all in the first query.\n\n\nDashboard of the User\n---------------------\n\nFor the next use-case we want to retrieve the dashboard view, a\nlist of all open bugs the user reported or was assigned to. This\nwill be achieved using DQL again, this time with some WHERE clauses\nand usage of bound parameters:\n\n.. code-block:: php\n\n \n require_once \"bootstrap.php\";\n\n $theUserId = $argv[1];\n\n $dql = \"SELECT b, e, r FROM Bug b JOIN b.engineer e JOIN b.reporter r \".\n \"WHERE b.status = 'OPEN' AND (e.id = ?1 OR r.id = ?1) ORDER BY b.created DESC\";\n\n $myBugs = $entityManager->createQuery($dql)\n ->setParameter(1, $theUserId)\n ->setMaxResults(15)\n ->getResult();\n\n echo \"You have created or assigned to \" . count($myBugs) . \" open bugs:\\n\\n\";\n\n foreach ($myBugs as $bug) {\n echo $bug->getId() . \" - \" . $bug->getDescription().\"\\n\";\n }\n\nNumber of Bugs\n--------------\n\nUntil now we only retrieved entities or their array representation.\nDoctrine also supports the retrieval of non-entities through DQL.\nThese values are called \"scalar result values\" and may even be\naggregate values using COUNT, SUM, MIN, MAX or AVG functions.\n\nWe will need this knowledge to retrieve the number of open bugs\ngrouped by product:\n\n.. code-block:: php\n\n createQuery($dql)->getScalarResult();\n\n foreach ($productBugs as $productBug) {\n echo $productBug['name'].\" has \" . $productBug['openBugs'] . \" open bugs!\\n\";\n }\n\nUpdating Entities\n-----------------\n\nThere is a single use-case missing from the requirements, Engineers\nshould be able to close a bug. This looks like:\n\n.. code-block:: php\n\n status = \"CLOSE\";\n }\n }\n\n.. code-block:: php\n\n \n require_once \"bootstrap.php\";\n\n $theBugId = $argv[1];\n\n $bug = $entityManager->find(\"Bug\", (int)$theBugId);\n $bug->close();\n\n $entityManager->flush();\n\nWhen retrieving the Bug from the database it is inserted into the\nIdentityMap inside the UnitOfWork of Doctrine. This means your Bug\nwith exactly this id can only exist once during the whole request\nno matter how often you call ``EntityManager#find()``. It even\ndetects entities that are hydrated using DQL and are already\npresent in the Identity Map.\n\nWhen flush is called the EntityManager loops over all the entities\nin the identity map and performs a comparison between the values\noriginally retrieved from the database and those values the entity\ncurrently has. If at least one of these properties is different the\nentity is scheduled for an UPDATE against the database. Only the\nchanged columns are updated, which offers a pretty good performance\nimprovement compared to updating all the properties.\n\nEntity Repositories\n-------------------\n\nFor now we have not discussed how to separate the Doctrine query logic from your model.\nIn Doctrine 1 there was the concept of ``Doctrine_Table`` instances for this\nseparation. The similar concept in Doctrine2 is called Entity Repositories, integrating\nthe `repository pattern `_ at the heart of Doctrine.\n\nEvery Entity uses a default repository by default and offers a bunch of convenience\nmethods that you can use to query for instances of that Entity. Take for example\nour Product entity. If we wanted to Query by name, we can use:\n\n.. code-block:: php\n\n getRepository('Product')\n ->findOneBy(array('name' => $productName));\n\nThe method ``findOneBy()`` takes an array of fields or association keys and the values to match against.\n\nIf you want to find all entities matching a condition you can use ``findBy()``, for\nexample querying for all closed bugs:\n\n.. code-block:: php\n\n getRepository('Bug')\n ->findBy(array('status' => 'CLOSED'));\n\n foreach ($bugs as $bug) {\n // do stuff\n }\n\nCompared to DQL these query methods are falling short of functionality very fast.\nDoctrine offers you a convenient way to extend the functionalities of the default ``EntityRepository``\nand put all the specialized DQL query logic on it. For this you have to create a subclass\nof ``Doctrine\\ORM\\EntityRepository``, in our case a ``BugRepository`` and group all\nthe previously discussed query functionality in it:\n\n.. code-block:: php\n\n getEntityManager()->createQuery($dql);\n $query->setMaxResults($number);\n return $query->getResult();\n }\n\n public function getRecentBugsArray($number = 30)\n {\n $dql = \"SELECT b, e, r, p FROM Bug b JOIN b.engineer e \".\n \"JOIN b.reporter r JOIN b.products p ORDER BY b.created DESC\";\n $query = $this->getEntityManager()->createQuery($dql);\n $query->setMaxResults($number);\n return $query->getArrayResult();\n }\n\n public function getUsersBugs($userId, $number = 15)\n {\n $dql = \"SELECT b, e, r FROM Bug b JOIN b.engineer e JOIN b.reporter r \".\n \"WHERE b.status = 'OPEN' AND e.id = ?1 OR r.id = ?1 ORDER BY b.created DESC\";\n\n return $this->getEntityManager()->createQuery($dql)\n ->setParameter(1, $userId)\n ->setMaxResults($number)\n ->getResult();\n }\n\n public function getOpenBugsByProduct()\n {\n $dql = \"SELECT p.id, p.name, count(b.id) AS openBugs FROM Bug b \".\n \"JOIN b.products p WHERE b.status = 'OPEN' GROUP BY p.id\";\n return $this->getEntityManager()->createQuery($dql)->getScalarResult();\n }\n }\n\nTo be able to use this query logic through ``$this->getEntityManager()->getRepository('Bug')``\nwe have to adjust the metadata slightly.\n\n.. configuration-block::\n\n .. code-block:: attribute\n\n \n\n \n\n \n \n\nNow we can remove our query logic in all the places and instead use them through the EntityRepository.\nAs an example here is the code of the first use case \"List of Bugs\":\n\n.. code-block:: php\n\n getRepository('Bug')->getRecentBugs();\n\n foreach ($bugs as $bug) {\n echo $bug->getDescription().\" - \".$bug->getCreated()->format('d.m.Y').\"\\n\";\n echo \" Reported by: \".$bug->getReporter()->getName().\"\\n\";\n echo \" Assigned to: \".$bug->getEngineer()->getName().\"\\n\";\n foreach ($bug->getProducts() as $product) {\n echo \" Platform: \".$product->getName().\"\\n\";\n }\n echo \"\\n\";\n }\n\nUsing EntityRepositories you can avoid coupling your model with specific query logic.\nYou can also re-use query logic easily throughout your application.\n\nThe method ``count()`` takes an array of fields or association keys and the values to match against.\nThis provides you with a convenient and lightweight way to count a resultset when you don't need to\ndeal with it:\n\n.. code-block:: php\n\n getRepository(Product::class)\n ->count(['name' => $productName]);\n\nConclusion\n----------\n\nThis tutorial is over here, I hope you had fun. Additional content\nwill be added to this tutorial incrementally, topics will include:\n\n- More on Association Mappings\n- Lifecycle Events triggered in the UnitOfWork\n- Ordering of Collections\n\nAdditional details on all the topics discussed here can be found in\nthe respective manual chapters.\n"
},
{
"path": "docs/en/tutorials/ordered-associations.rst",
"content": "Ordering To-Many Associations\n-----------------------------\n\nThere are use-cases when you'll want to sort collections when they are\nretrieved from the database. In userland you do this as long as you\nhaven't initially saved an entity with its associations into the\ndatabase. To retrieve a sorted collection from the database you can\nuse the ``#[OrderBy]`` attribute with a collection that specifies\na DQL snippet that is appended to all queries with this\ncollection.\n\nAdditional to any ``#[OneToMany]`` or ``#[ManyToMany]`` attribute you\ncan specify the ``#[OrderBy]`` in the following way:\n\n.. configuration-block::\n\n .. code-block:: attribute\n\n \"ASC\"])]\n private Collection $groups;\n }\n\n .. code-block:: xml\n\n \n \n \n \n \n \n \n \n \n\nThe DQL Snippet in OrderBy is only allowed to consist of\nunqualified, unquoted field names and of an optional ASC/DESC\npositional statement. Multiple Fields are separated by a comma (,).\nThe referenced field names have to exist on the ``targetEntity``\nclass of the ``#[ManyToMany]`` or ``#[OneToMany]`` attribute.\n\nThe semantics of this feature can be described as follows:\n\n\n- ``@OrderBy`` acts as an implicit ORDER BY clause for the given\n fields, that is appended to all the explicitly given ORDER BY\n items.\n- All collections of the ordered type are always retrieved in an\n ordered fashion.\n- To keep the database impact low, these implicit ORDER BY items\n are only added to a DQL Query if the collection is fetch joined in\n the DQL query.\n\nGiven our previously defined example, the following would not add\nORDER BY, since g is not fetch joined:\n\n.. code-block:: sql\n\n SELECT u FROM User u JOIN u.groups g WHERE SIZE(g) > 10\n\nHowever the following:\n\n.. code-block:: sql\n\n SELECT u, g FROM User u JOIN u.groups g WHERE u.id = 10\n\n...would internally be rewritten to:\n\n.. code-block:: sql\n\n SELECT u, g FROM User u JOIN u.groups g WHERE u.id = 10 ORDER BY g.name ASC\n\nYou can reverse the order with an explicit DQL ORDER BY:\n\n.. code-block:: sql\n\n SELECT u, g FROM User u JOIN u.groups g WHERE u.id = 10 ORDER BY g.name DESC\n\n...is internally rewritten to:\n\n.. code-block:: sql\n\n SELECT u, g FROM User u JOIN u.groups g WHERE u.id = 10 ORDER BY g.name DESC, g.name ASC\n"
},
{
"path": "docs/en/tutorials/override-field-association-mappings-in-subclasses.rst",
"content": "Override Field Association Mappings In Subclasses\n-------------------------------------------------\n\nSometimes there is a need to persist entities but override all or part of the\nmapping metadata. Sometimes also the mapping to override comes from entities\nusing traits where the traits have mapping metadata.\nThis tutorial explains how to override mapping metadata,\ni.e. attributes and associations metadata in particular. The example here shows\nthe overriding of a class that uses a trait but is similar when extending a base\nclass as shown at the end of this tutorial.\n\nSuppose we have a class ``ExampleEntityWithOverride``. This class uses trait ``ExampleTrait``:\n\n.. code-block:: php\n\n `).\n"
},
{
"path": "docs/en/tutorials/pagination.rst",
"content": "Pagination\n==========\n\nDoctrine ORM ships with a Paginator for DQL queries. It\nhas a very simple API and implements the SPL interfaces ``Countable`` and\n``IteratorAggregate``.\n\n.. code-block:: php\n\n createQuery($dql)\n ->setFirstResult(0)\n ->setMaxResults(100);\n\n $paginator = new Paginator($query, fetchJoinCollection: true);\n\n $c = count($paginator);\n foreach ($paginator as $post) {\n echo $post->getHeadline() . \"\\n\";\n }\n\nPaginating Doctrine queries is not as simple as you might think in the\nbeginning. If you have complex fetch-join scenarios with one-to-many or\nmany-to-many associations using the \"default\" LIMIT functionality of database\nvendors is not sufficient to get the correct results.\n\nBy default the pagination extension does the following steps to compute the\ncorrect result:\n\n- Perform a Count query using `DISTINCT` keyword.\n- Perform a Limit Subquery with `DISTINCT` to find all ids of the entity in from on the current page.\n- Perform a WHERE IN query to get all results for the current page.\n\nThis behavior is only necessary if you actually fetch join a to-many\ncollection. You can disable this behavior by setting the\n``fetchJoinCollection`` argument to ``false``; in that case only 2 instead of the 3 queries\ndescribed are executed. We hope to automate the detection for this in\nthe future.\n\n.. note::\n\n ``fetchJoinCollection`` argument set to ``true`` might affect results if you use aggregations in your query.\n\nBy using the ``Paginator::HINT_ENABLE_DISTINCT`` you can instruct doctrine that the query to be executed\nwill not produce \"duplicate\" rows (only to-one relations are joined), thus the SQL limit will work as expected.\nIn this way the `DISTINCT` keyword will be omitted and can bring important performance improvements.\n\n.. code-block:: php\n\n createQuery($dql)\n ->setHint(Paginator::HINT_ENABLE_DISTINCT, false)\n ->setFirstResult(0)\n ->setMaxResults(100);\n"
},
{
"path": "docs/en/tutorials/working-with-indexed-associations/Market.php",
"content": " */\n #[OneToMany(targetEntity: Stock::class, mappedBy: 'market', indexBy: 'symbol')]\n private Collection $stocks;\n\n public function __construct(string $name)\n {\n $this->name = $name;\n $this->stocks = new ArrayCollection();\n }\n\n public function getId(): int|null\n {\n return $this->id;\n }\n\n public function getName(): string\n {\n return $this->name;\n }\n\n public function addStock(Stock $stock): void\n {\n $this->stocks[$stock->getSymbol()] = $stock;\n }\n\n public function getStock(string $symbol): Stock\n {\n if (! isset($this->stocks[$symbol])) {\n throw new InvalidArgumentException('Symbol is not traded on this market.');\n }\n\n return $this->stocks[$symbol];\n }\n\n /** @return array */\n public function getStocks(): array\n {\n return $this->stocks->toArray();\n }\n}\n"
},
{
"path": "docs/en/tutorials/working-with-indexed-associations/market.xml",
"content": "\n\n\n \n\t\n\t \n\t\n\n\t\n\n\t\n \n\n"
},
{
"path": "docs/en/tutorials/working-with-indexed-associations.rst",
"content": "Working with Indexed Associations\n=================================\n\nDoctrine ORM collections are modelled after PHPs native arrays. PHP arrays are an ordered hashmap, but in\nthe first version of Doctrine keys retrieved from the database were always numerical unless ``INDEX BY``\nwas used. You can index your collections by a value in the related entity.\nThis is a first step towards full ordered hashmap support through the Doctrine ORM.\nThe feature works like an implicit ``INDEX BY`` for the selected association but has several\ndownsides also:\n\n- You have to manage both the key and field if you want to change the index by field value.\n- On each request the keys are regenerated from the field value, and not from the previous collection key.\n- Values of the Index-By keys are never considered during persistence. They only exist for accessing purposes.\n- Fields that are used for the index by feature **HAVE** to be unique in the database. The behavior for multiple entities\n with the same index-by field value is undefined.\n\nAs an example we will design a simple stock exchange list view. The domain consists of the entity ``Stock``\nand ``Market`` where each Stock has a symbol and is traded on a single market. Instead of having a numerical\nlist of stocks traded on a market they will be indexed by their symbol, which is unique across all markets.\n\nMapping Indexed Associations\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nYou can map indexed associations by adding:\n\n * ``indexBy`` argument to any ``#[OneToMany]`` or ``#[ManyToMany]`` attribute.\n * ``index-by`` attribute to any ```` or ```` xml element.\n\nThe code and mappings for the Market entity looks like this:\n\n.. configuration-block::\n .. literalinclude:: working-with-indexed-associations/Market.php\n :language: attribute\n\n .. literalinclude:: working-with-indexed-associations/market.xml\n :language: xml\n\nInside the ``addStock()`` method you can see how we directly set the key of the association to the symbol,\nso that we can work with the indexed association directly after invoking ``addStock()``. Inside ``getStock($symbol)``\nwe pick a stock traded on the particular market by symbol. If this stock doesn't exist an exception is thrown.\n\nThe ``Stock`` entity doesn't contain any special instructions that are new, but for completeness\nhere are the code and mappings for it:\n\n.. configuration-block::\n .. code-block:: attribute\n\n symbol = $symbol;\n $this->market = $market;\n $market->addStock($this);\n }\n\n public function getSymbol(): string\n {\n return $this->symbol;\n }\n }\n\n .. code-block:: xml\n\n \n \n\n \n \n \n \n\n \n \n \n \n\nQuerying indexed associations\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nNow that we defined the stocks collection to be indexed by symbol, we can take a look at some code\nthat makes use of the indexing.\n\nFirst we will populate our database with two example stocks traded on a single market:\n\n.. code-block:: php\n\n persist($market);\n $em->persist($stock1);\n $em->persist($stock2);\n $em->flush();\n\nThis code is not particular interesting since the indexing feature is not yet used. In a new request we could\nnow query for the market:\n\n.. code-block:: php\n\n find(\"Doctrine\\Tests\\Models\\StockExchange\\Market\", $marketId);\n\n // Access the stocks by symbol now:\n $stock = $market->getStock($symbol);\n\n echo $stock->getSymbol(); // will print \"AAPL\"\n\nThe implementation of ``Market::addStock()``, in combination with ``indexBy``, allows us to access the collection\nconsistently by the Stock symbol. It does not matter if Stock is managed by Doctrine or not.\n\nThe same applies to DQL queries: The ``indexBy`` configuration acts as implicit \"INDEX BY\" to a join association.\n\n.. code-block:: php\n\n createQuery($dql)\n ->setParameter(1, $marketId)\n ->getSingleResult();\n\n // Access the stocks by symbol now:\n $stock = $market->getStock($symbol);\n\n echo $stock->getSymbol(); // will print \"AAPL\"\n\nIf you want to use ``INDEX BY`` explicitly on an indexed association you are free to do so. Additionally,\nindexed associations also work with the ``Collection::slice()`` functionality, even if the association's fetch mode is\nLAZY or EXTRA_LAZY.\n\nOutlook into the Future\n~~~~~~~~~~~~~~~~~~~~~~~\n\nFor the inverse side of a many-to-many associations there will be a way to persist the keys and the order\nas a third and fourth parameter into the join table. This feature is discussed in `#2817 `_\nThis feature cannot be implemented for one-to-many associations, because they are never the owning side.\n"
},
{
"path": "doctrine-mapping.xsd",
"content": "\n\n\n\n \n \n \n\n \n \n \n \n \n \n \n \n \n \n \n\n \n \n \n \n \n \n\n \n \n \n \n \n \n \n \n \n \n \n\n \n \n \n \n \n \n \n \n \n \n \n \n\n \n \n \n \n \n \n \n\n \n \n \n \n \n \n \n \n\n \n \n \n \n \n \n \n\n \n \n \n \n \n \n \n\n \n \n \n \n \n\n \n \n \n\n \n \n \n \n\n \n \n \n \n \n \n \n\n \n \n \n \n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n \n \n \n \n \n \n\n \n \n \n \n\n \n \n \n \n \n \n \n \n \n \n \n \n \n\n \n \n \n \n \n \n \n\n \n \n \n \n \n\n \n \n \n \n \n\n \n \n \n \n \n \n\n \n \n \n \n \n \n\n \n \n \n \n \n \n \n \n \n\n \n \n \n \n \n \n \n\n \n \n \n \n \n \n \n\n \n \n \n \n \n \n \n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n \n \n \n \n \n \n \n \n \n\n \n \n \n \n \n \n \n \n \n \n \n \n \n\n \n \n \n \n \n \n \n \n \n \n\n \n \n \n \n \n \n \n\n \n \n \n \n \n \n \n \n \n \n \n\n \n \n \n \n \n \n \n\n \n \n \n \n \n \n \n \n\n \n \n \n \n \n \n \n\n \n \n \n \n \n \n \n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n \n \n \n \n \n \n \n \n \n\n \n \n \n \n \n \n\n \n \n \n \n \n \n\n \n \n \n \n \n \n\n \n \n \n \n \n \n \n\n \n \n \n \n \n \n \n \n \n \n \n \n\n \n \n \n \n \n \n \n\n \n \n \n \n \n \n \n \n \n \n\n \n \n \n \n \n \n \n\n \n \n \n \n \n \n \n \n\n \n \n \n \n \n \n\n \n \n \n \n \n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n \n \n \n \n \n \n\n \n \n \n \n \n \n \n \n \n \n\n \n \n \n\n \n \n \n \n \n \n\n \n \n \n \n \n \n \n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n\n"
},
{
"path": "phpbench.json",
"content": "{\n \"runner.bootstrap\": \"tests/Tests/TestInit.php\",\n \"runner.path\": \"tests/Performance\",\n \"runner.file_pattern\": \"*Bench.php\",\n\n \"core.extensions\": [\n \"PhpBench\\\\Extensions\\\\XDebug\\\\XDebugExtension\"\n ]\n}\n"
},
{
"path": "phpcs.xml.dist",
"content": "\n\n \n \n \n \n \n\n \n \n\n \n\n src\n tests\n\n */tests/Tests/Proxies/__CG__*\n */tests/Tests/ORM/Tools/Export/export/*\n\n \n \n \n \n \n \n \n\n \n \n tests/Tests/Mocks/HydratorMockStatement.php\n tests/Tests/Models/Cache/ComplexAction.php\n tests/Tests/Models/DDC117/DDC117ArticleDetails.php\n tests/Tests/Models/DDC117/DDC117Translation.php\n tests/Tests/ORM/Functional/Ticket/DDC2579Test.php\n tests/Tests/ORM/Functional/ValueObjectsTest.php\n \n\n \n tests/*\n \n\n \n tests/*\n \n\n \n src/Mapping/Driver/LoadMappingFileImplementation.php\n src/Mapping/GetReflectionClassImplementation.php\n tests/*\n \n\n \n src/Tools/Console/Helper/EntityManagerHelper.php\n tests/*\n \n\n \n src/Tools/Debug.php\n tests/Tests/ORM/Tools/DebugTest.php\n \n\n \n src/Events.php\n src/Tools/ToolEvents.php\n \n\n \n src/Internal/Hydration/AbstractHydrator.php\n \n\n \n src/Query/Parser.php\n \n\n \n src/Mapping/AssociationOverride.php\n src/Mapping/AssociationOverrides.php\n src/Mapping/AttributeOverride.php\n src/Mapping/AttributeOverrides.php\n src/Mapping/Cache.php\n src/Mapping/ChangeTrackingPolicy.php\n src/Mapping/Column.php\n src/Mapping/CustomIdGenerator.php\n src/Mapping/DiscriminatorColumn.php\n src/Mapping/DiscriminatorMap.php\n src/Mapping/Embeddable.php\n src/Mapping/Embedded.php\n src/Mapping/Entity.php\n src/Mapping/EntityListeners.php\n src/Mapping/GeneratedValue.php\n src/Mapping/HasLifecycleCallbacks.php\n src/Mapping/Id.php\n src/Mapping/Index.php\n src/Mapping/InheritanceType.php\n src/Mapping/JoinColumn.php\n src/Mapping/JoinColumns.php\n src/Mapping/JoinTable.php\n src/Mapping/ManyToMany.php\n src/Mapping/ManyToOne.php\n src/Mapping/MappedSuperclass.php\n src/Mapping/OneToMany.php\n src/Mapping/OneToOne.php\n src/Mapping/OrderBy.php\n src/Mapping/PostLoad.php\n src/Mapping/PostPersist.php\n src/Mapping/PostRemove.php\n src/Mapping/PostUpdate.php\n src/Mapping/PreFlush.php\n src/Mapping/PrePersist.php\n src/Mapping/PreRemove.php\n src/Mapping/PreUpdate.php\n src/Mapping/SequenceGenerator.php\n src/Mapping/Table.php\n src/Mapping/UniqueConstraint.php\n src/Mapping/Version.php\n \n\n \n src/Cache/DefaultQueryCache.php\n \n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n \n \n \n \n \n \n \n \n \n \n \n\n \n src/EntityManagerInterface.php\n \n\n \n tests/Tests/Models/DDC1872/DDC1872ExampleTrait.php\n \n\n \n */tests/*\n \n\n \n */tests/*\n \n\n \n */tests/*\n \n\n \n */tests/*\n \n\n \n \n tests/Tests/Models/Global/GlobalNamespaceModel.php\n tests/Tests/Models/DDC3231/DDC3231User1NoNamespace.php\n tests/Tests/Models/DDC3231/DDC3231User2NoNamespace.php\n \n\n \n \n tests/Tests/ORM/Functional/Ticket/DDC2084Test.php\n \n\n \n \n tests/Tests/ORM/Functional/Ticket/DDC2084Test.php\n \n\n \n \n tests/Tests/ORM/Functional/Ticket/DDC1301Test.php\n tests/Tests/ORM/Functional/ExtraLazyCollectionTest.php\n \n\n \n \n tests/Tests/Models/DDC1590/DDC1590User.php\n \n\n\n \n \n tests/Tests/Proxy/DefaultProxyClassNameResolverTest.php\n \n\n \n \n tests/Tests/Mocks/DatabasePlatformMock.php\n tests/Tests/Mocks/DriverMock.php\n tests/Tests/ORM/UnitOfWorkTest.php\n tests/Tests/ORM/Query/DeleteSqlGenerationTest.php\n \n \n \n src/Query/AST/Node.php\n \n\n \n tests/Tests/ORM/Mapping/php/Doctrine.Tests*\n \n\n \n src/AbstractQuery.php\n src/Mapping/ClassMetadata.php\n src/NativeQuery.php\n src/Query.php\n src/Query/TreeWalkerAdapter.php\n src/Tools/Export/Driver/AbstractExporter.php\n src/Tools/Export/Driver/PhpExporter.php\n \n tests/Tests/Mocks/DatabasePlatformMock.php\n tests/Tests/Mocks/SchemaManagerMock.php\n tests/Tests/ORM/AbstractQueryTest.php\n tests/Tests/ORM/Functional/Ticket/DDC3634Test.php\n \n\n \n \n tests/Tests/OrmFunctionalTestCase.php\n \n \n \n src/Proxy/ProxyFactory.php\n \n tests/Tests/ORM/Functional/ProxiesLikeEntitiesTest.php\n \n\n \n \n tests/Tests/ORM/Functional/Ticket/DDC1885Test.php\n tests/Tests/ORM/Functional/Ticket/DDC1843Test.php\n tests/Tests/ORM/Mapping/ClassMetadataFactoryTest.php\n \n\n \n \n src/Id/TableGenerator.php\n \n \n \n src/Id/TableGenerator.php\n \n \n \n src/QueryBuilder.php\n \n\n"
},
{
"path": "phpstan-baseline.neon",
"content": "parameters:\n\tignoreErrors:\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\AbstractQuery\\:\\:getParameter\\(\\) should return Doctrine\\\\ORM\\\\Query\\\\Parameter\\|null but returns Doctrine\\\\ORM\\\\Query\\\\Parameter\\|false\\|null\\.$#'\n\t\t\tidentifier: return.type\n\t\t\tcount: 1\n\t\t\tpath: src/AbstractQuery.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$stmt of method Doctrine\\\\ORM\\\\Internal\\\\Hydration\\\\AbstractHydrator\\:\\:toIterable\\(\\) expects Doctrine\\\\DBAL\\\\Result, Doctrine\\\\DBAL\\\\Result\\|int given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/AbstractQuery.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\CacheFactory\\:\\:buildCachedEntityPersister\\(\\) has parameter \\$metadata with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/CacheFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\CacheFactory\\:\\:buildEntityHydrator\\(\\) has parameter \\$metadata with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/CacheFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\CollectionHydrator\\:\\:buildCacheEntry\\(\\) has parameter \\$collection with generic interface Doctrine\\\\Common\\\\Collections\\\\Collection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/CollectionHydrator.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\CollectionHydrator\\:\\:buildCacheEntry\\(\\) has parameter \\$collection with no value type specified in iterable type array\\.$#'\n\t\t\tidentifier: missingType.iterableValue\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/CollectionHydrator.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\CollectionHydrator\\:\\:buildCacheEntry\\(\\) has parameter \\$collection with no value type specified in iterable type array\\|\\(Doctrine\\\\Common\\\\Collections\\\\Collection&iterable\\)\\.$#'\n\t\t\tidentifier: missingType.iterableValue\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/CollectionHydrator.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\CollectionHydrator\\:\\:buildCacheEntry\\(\\) has parameter \\$metadata with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/CollectionHydrator.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\CollectionHydrator\\:\\:loadCacheEntry\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/CollectionHydrator.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\CollectionHydrator\\:\\:loadCacheEntry\\(\\) has parameter \\$metadata with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/CollectionHydrator.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\DefaultCache\\:\\:buildCollectionCacheKey\\(\\) has parameter \\$metadata with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/DefaultCache.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\DefaultCache\\:\\:buildEntityCacheKey\\(\\) has parameter \\$metadata with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/DefaultCache.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\DefaultCache\\:\\:toIdentifierArray\\(\\) has parameter \\$metadata with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/DefaultCache.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\DefaultCacheFactory\\:\\:buildCachedEntityPersister\\(\\) has parameter \\$metadata with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/DefaultCacheFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\DefaultCacheFactory\\:\\:buildEntityHydrator\\(\\) has parameter \\$metadata with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/DefaultCacheFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\DefaultCollectionHydrator\\:\\:buildCacheEntry\\(\\) has parameter \\$collection with generic interface Doctrine\\\\Common\\\\Collections\\\\Collection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/DefaultCollectionHydrator.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\DefaultCollectionHydrator\\:\\:buildCacheEntry\\(\\) has parameter \\$collection with no value type specified in iterable type array\\.$#'\n\t\t\tidentifier: missingType.iterableValue\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/DefaultCollectionHydrator.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\DefaultCollectionHydrator\\:\\:buildCacheEntry\\(\\) has parameter \\$collection with no value type specified in iterable type array\\|\\(Doctrine\\\\Common\\\\Collections\\\\Collection&iterable\\)\\.$#'\n\t\t\tidentifier: missingType.iterableValue\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/DefaultCollectionHydrator.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\DefaultCollectionHydrator\\:\\:buildCacheEntry\\(\\) has parameter \\$metadata with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/DefaultCollectionHydrator.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\DefaultCollectionHydrator\\:\\:loadCacheEntry\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/DefaultCollectionHydrator.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\DefaultCollectionHydrator\\:\\:loadCacheEntry\\(\\) has parameter \\$metadata with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/DefaultCollectionHydrator.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$joinColumnFieldNames\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/DefaultEntityHydrator.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$targetToSourceKeyColumns\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/DefaultEntityHydrator.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$targetToSourceKeyColumns\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/DefaultEntityHydrator.php\n\n\t\t-\n\t\t\tmessage: '#^Call to an undefined method Doctrine\\\\ORM\\\\Persisters\\\\Entity\\\\EntityPersister\\:\\:getCacheRegion\\(\\)\\.$#'\n\t\t\tidentifier: method.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/DefaultEntityHydrator.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\DefaultEntityHydrator\\:\\:buildCacheEntry\\(\\) has parameter \\$metadata with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/DefaultEntityHydrator.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\DefaultEntityHydrator\\:\\:loadCacheEntry\\(\\) has parameter \\$metadata with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/DefaultEntityHydrator.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#2 \\$data of class Doctrine\\\\ORM\\\\Cache\\\\EntityCacheEntry constructor expects array\\, array\\ given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/DefaultEntityHydrator.php\n\n\t\t-\n\t\t\tmessage: '#^Unable to resolve the template type T in call to method Doctrine\\\\ORM\\\\EntityManagerInterface\\:\\:getReference\\(\\)$#'\n\t\t\tidentifier: argument.templateType\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/DefaultEntityHydrator.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Cache\\\\CacheEntry\\:\\:\\$class\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 2\n\t\t\tpath: src/Cache/DefaultQueryCache.php\n\n\t\t-\n\t\t\tmessage: '#^Call to an undefined method Doctrine\\\\ORM\\\\Cache\\\\CacheEntry\\:\\:resolveAssociationEntries\\(\\)\\.$#'\n\t\t\tidentifier: method.notFound\n\t\t\tcount: 2\n\t\t\tpath: src/Cache/DefaultQueryCache.php\n\n\t\t-\n\t\t\tmessage: '#^Call to an undefined method Doctrine\\\\ORM\\\\Persisters\\\\Entity\\\\EntityPersister\\:\\:getCacheRegion\\(\\)\\.$#'\n\t\t\tidentifier: method.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/DefaultQueryCache.php\n\n\t\t-\n\t\t\tmessage: '#^Call to an undefined method Doctrine\\\\ORM\\\\Persisters\\\\Entity\\\\EntityPersister\\:\\:storeEntityCache\\(\\)\\.$#'\n\t\t\tidentifier: method.notFound\n\t\t\tcount: 2\n\t\t\tpath: src/Cache/DefaultQueryCache.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\DefaultQueryCache\\:\\:storeAssociationCache\\(\\) return type has no value type specified in iterable type array\\.$#'\n\t\t\tidentifier: missingType.iterableValue\n\t\t\tcount: 2\n\t\t\tpath: src/Cache/DefaultQueryCache.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$className of method Doctrine\\\\ORM\\\\EntityManagerInterface\\:\\:getClassMetadata\\(\\) expects string, class\\-string\\|false given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 2\n\t\t\tpath: src/Cache/DefaultQueryCache.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$entityName of method Doctrine\\\\ORM\\\\UnitOfWork\\:\\:getEntityPersister\\(\\) expects class\\-string, class\\-string\\|false given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 2\n\t\t\tpath: src/Cache/DefaultQueryCache.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$entityName of static method Doctrine\\\\ORM\\\\Cache\\\\Exception\\\\NonCacheableEntity\\:\\:fromEntity\\(\\) expects string, class\\-string\\|false given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/DefaultQueryCache.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#2 \\$key of method Doctrine\\\\ORM\\\\Cache\\\\Logging\\\\CacheLogger\\:\\:entityCacheHit\\(\\) expects Doctrine\\\\ORM\\\\Cache\\\\EntityCacheKey, Doctrine\\\\ORM\\\\Cache\\\\CacheKey given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 2\n\t\t\tpath: src/Cache/DefaultQueryCache.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#2 \\$key of method Doctrine\\\\ORM\\\\Cache\\\\Logging\\\\CacheLogger\\:\\:entityCacheMiss\\(\\) expects Doctrine\\\\ORM\\\\Cache\\\\EntityCacheKey, Doctrine\\\\ORM\\\\Cache\\\\CacheKey given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 2\n\t\t\tpath: src/Cache/DefaultQueryCache.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\EntityHydrator\\:\\:buildCacheEntry\\(\\) has parameter \\$metadata with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/EntityHydrator.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\EntityHydrator\\:\\:loadCacheEntry\\(\\) has parameter \\$metadata with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/EntityHydrator.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Cache\\\\CacheEntry\\:\\:\\$identifiers\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/Persister/Collection/AbstractCollectionPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\Persister\\\\Collection\\\\AbstractCollectionPersister\\:\\:contains\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/Persister/Collection/AbstractCollectionPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\Persister\\\\Collection\\\\AbstractCollectionPersister\\:\\:containsKey\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/Persister/Collection/AbstractCollectionPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\Persister\\\\Collection\\\\AbstractCollectionPersister\\:\\:count\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/Persister/Collection/AbstractCollectionPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\Persister\\\\Collection\\\\AbstractCollectionPersister\\:\\:get\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/Persister/Collection/AbstractCollectionPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\Persister\\\\Collection\\\\AbstractCollectionPersister\\:\\:getSourceEntityMetadata\\(\\) return type with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/Persister/Collection/AbstractCollectionPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\Persister\\\\Collection\\\\AbstractCollectionPersister\\:\\:getTargetEntityMetadata\\(\\) return type with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/Persister/Collection/AbstractCollectionPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\Persister\\\\Collection\\\\AbstractCollectionPersister\\:\\:loadCollectionCache\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/Persister/Collection/AbstractCollectionPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\Persister\\\\Collection\\\\AbstractCollectionPersister\\:\\:loadCriteria\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/Persister/Collection/AbstractCollectionPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\Persister\\\\Collection\\\\AbstractCollectionPersister\\:\\:slice\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/Persister/Collection/AbstractCollectionPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\Persister\\\\Collection\\\\AbstractCollectionPersister\\:\\:storeCollectionCache\\(\\) has parameter \\$elements with generic interface Doctrine\\\\Common\\\\Collections\\\\Collection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/Persister/Collection/AbstractCollectionPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\Persister\\\\Collection\\\\AbstractCollectionPersister\\:\\:storeCollectionCache\\(\\) has parameter \\$elements with no value type specified in iterable type array\\.$#'\n\t\t\tidentifier: missingType.iterableValue\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/Persister/Collection/AbstractCollectionPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\Persister\\\\Collection\\\\AbstractCollectionPersister\\:\\:storeCollectionCache\\(\\) has parameter \\$elements with no value type specified in iterable type array\\|\\(Doctrine\\\\Common\\\\Collections\\\\Collection&iterable\\)\\.$#'\n\t\t\tidentifier: missingType.iterableValue\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/Persister/Collection/AbstractCollectionPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#2 \\$key of method Doctrine\\\\ORM\\\\Cache\\\\EntityHydrator\\:\\:buildCacheEntry\\(\\) expects Doctrine\\\\ORM\\\\Cache\\\\EntityCacheKey, Doctrine\\\\ORM\\\\Cache\\\\CacheKey given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/Persister/Collection/AbstractCollectionPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#3 \\$entry of method Doctrine\\\\ORM\\\\Cache\\\\CollectionHydrator\\:\\:loadCacheEntry\\(\\) expects Doctrine\\\\ORM\\\\Cache\\\\CollectionCacheEntry, Doctrine\\\\ORM\\\\Cache\\\\CacheEntry given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/Persister/Collection/AbstractCollectionPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Property Doctrine\\\\ORM\\\\Cache\\\\Persister\\\\Collection\\\\AbstractCollectionPersister\\:\\:\\$sourceEntity with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/Persister/Collection/AbstractCollectionPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Property Doctrine\\\\ORM\\\\Cache\\\\Persister\\\\Collection\\\\AbstractCollectionPersister\\:\\:\\$targetEntity with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/Persister/Collection/AbstractCollectionPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\Persister\\\\Collection\\\\CachedCollectionPersister\\:\\:getSourceEntityMetadata\\(\\) return type with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/Persister/Collection/CachedCollectionPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\Persister\\\\Collection\\\\CachedCollectionPersister\\:\\:getTargetEntityMetadata\\(\\) return type with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/Persister/Collection/CachedCollectionPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\Persister\\\\Collection\\\\CachedCollectionPersister\\:\\:loadCollectionCache\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/Persister/Collection/CachedCollectionPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\Persister\\\\Collection\\\\CachedCollectionPersister\\:\\:storeCollectionCache\\(\\) has parameter \\$elements with generic interface Doctrine\\\\Common\\\\Collections\\\\Collection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/Persister/Collection/CachedCollectionPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\Persister\\\\Collection\\\\CachedCollectionPersister\\:\\:storeCollectionCache\\(\\) has parameter \\$elements with no value type specified in iterable type array\\.$#'\n\t\t\tidentifier: missingType.iterableValue\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/Persister/Collection/CachedCollectionPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\Persister\\\\Collection\\\\CachedCollectionPersister\\:\\:storeCollectionCache\\(\\) has parameter \\$elements with no value type specified in iterable type array\\|\\(Doctrine\\\\Common\\\\Collections\\\\Collection&iterable\\)\\.$#'\n\t\t\tidentifier: missingType.iterableValue\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/Persister/Collection/CachedCollectionPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\Persister\\\\Collection\\\\NonStrictReadWriteCachedCollectionPersister\\:\\:delete\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/Persister/Collection/NonStrictReadWriteCachedCollectionPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\Persister\\\\Collection\\\\NonStrictReadWriteCachedCollectionPersister\\:\\:update\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/Persister/Collection/NonStrictReadWriteCachedCollectionPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\Persister\\\\Collection\\\\ReadOnlyCachedCollectionPersister\\:\\:update\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/Persister/Collection/ReadOnlyCachedCollectionPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Call to an undefined method Doctrine\\\\ORM\\\\Cache\\\\Region\\:\\:lock\\(\\)\\.$#'\n\t\t\tidentifier: method.notFound\n\t\t\tcount: 2\n\t\t\tpath: src/Cache/Persister/Collection/ReadWriteCachedCollectionPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\Persister\\\\Collection\\\\ReadWriteCachedCollectionPersister\\:\\:delete\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/Persister/Collection/ReadWriteCachedCollectionPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\Persister\\\\Collection\\\\ReadWriteCachedCollectionPersister\\:\\:update\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/Persister/Collection/ReadWriteCachedCollectionPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Cache\\\\CacheEntry\\:\\:\\$class\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 2\n\t\t\tpath: src/Cache/Persister/Entity/AbstractEntityPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Call to an undefined method Doctrine\\\\ORM\\\\Cache\\\\Persister\\\\CachedPersister&Doctrine\\\\ORM\\\\Persisters\\\\Collection\\\\CollectionPersister\\:\\:loadCollectionCache\\(\\)\\.$#'\n\t\t\tidentifier: method.notFound\n\t\t\tcount: 2\n\t\t\tpath: src/Cache/Persister/Entity/AbstractEntityPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Call to an undefined method Doctrine\\\\ORM\\\\Cache\\\\Persister\\\\CachedPersister&Doctrine\\\\ORM\\\\Persisters\\\\Collection\\\\CollectionPersister\\:\\:storeCollectionCache\\(\\)\\.$#'\n\t\t\tidentifier: method.notFound\n\t\t\tcount: 2\n\t\t\tpath: src/Cache/Persister/Entity/AbstractEntityPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Call to an undefined method Doctrine\\\\ORM\\\\Persisters\\\\Entity\\\\EntityPersister\\:\\:storeEntityCache\\(\\)\\.$#'\n\t\t\tidentifier: method.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/Persister/Entity/AbstractEntityPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\Persister\\\\Entity\\\\AbstractEntityPersister\\:\\:__construct\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/Persister/Entity/AbstractEntityPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\Persister\\\\Entity\\\\AbstractEntityPersister\\:\\:getClassMetadata\\(\\) return type with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/Persister/Entity/AbstractEntityPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\Persister\\\\Entity\\\\AbstractEntityPersister\\:\\:loadManyToManyCollection\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/Persister/Entity/AbstractEntityPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\Persister\\\\Entity\\\\AbstractEntityPersister\\:\\:loadOneToManyCollection\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/Persister/Entity/AbstractEntityPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#3 \\$entry of method Doctrine\\\\ORM\\\\Cache\\\\EntityHydrator\\:\\:loadCacheEntry\\(\\) expects Doctrine\\\\ORM\\\\Cache\\\\EntityCacheEntry, Doctrine\\\\ORM\\\\Cache\\\\CacheEntry given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/Persister/Entity/AbstractEntityPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Call to an undefined method Doctrine\\\\ORM\\\\Cache\\\\Region\\:\\:lock\\(\\)\\.$#'\n\t\t\tidentifier: method.notFound\n\t\t\tcount: 2\n\t\t\tpath: src/Cache/Persister/Entity/ReadWriteCachedEntityPersister.php\n\n\t\t-\n\t\t\tmessage: '#^If condition is always true\\.$#'\n\t\t\tidentifier: if.alwaysTrue\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/Persister/Entity/ReadWriteCachedEntityPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Cache\\\\Persister\\\\Entity\\\\ReadWriteCachedEntityPersister\\:\\:__construct\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/Persister/Entity/ReadWriteCachedEntityPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Cache\\\\CacheEntry\\:\\:\\$time\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Cache/TimestampQueryCacheValidator.php\n\n\t\t-\n\t\t\tmessage: '#^Call to function is_a\\(\\) with arguments class\\-string\\, ''Doctrine\\\\\\\\ORM\\\\\\\\EntityRepository'' and true will always evaluate to true\\.$#'\n\t\t\tidentifier: function.alreadyNarrowedType\n\t\t\tcount: 1\n\t\t\tpath: src/Configuration.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Configuration\\:\\:getDefaultRepositoryClassName\\(\\) return type with generic class Doctrine\\\\ORM\\\\EntityRepository does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Configuration.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Configuration\\:\\:setDefaultRepositoryClassName\\(\\) has parameter \\$className with generic class Doctrine\\\\ORM\\\\EntityRepository but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Configuration.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#2 \\$className of method Doctrine\\\\ORM\\\\Configuration\\:\\:addCustomNumericFunction\\(\\) expects \\(callable\\(string\\)\\: Doctrine\\\\ORM\\\\Query\\\\AST\\\\Functions\\\\FunctionNode\\)\\|class\\-string\\, class\\-string given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Configuration.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Decorator\\\\EntityManagerDecorator\\:\\:getClassMetadata\\(\\) return type with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Decorator/EntityManagerDecorator.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Decorator\\\\EntityManagerDecorator\\:\\:getRepository\\(\\) return type with generic class Doctrine\\\\ORM\\\\EntityRepository does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Decorator/EntityManagerDecorator.php\n\n\t\t-\n\t\t\tmessage: '#^Return type \\(Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadataFactory\\) of method Doctrine\\\\ORM\\\\Decorator\\\\EntityManagerDecorator\\:\\:getMetadataFactory\\(\\) should be compatible with return type \\(Doctrine\\\\Persistence\\\\Mapping\\\\ClassMetadataFactory\\\\>\\) of method Doctrine\\\\Persistence\\\\ObjectManager\\:\\:getMetadataFactory\\(\\)$#'\n\t\t\tidentifier: method.childReturnType\n\t\t\tcount: 1\n\t\t\tpath: src/Decorator/EntityManagerDecorator.php\n\n\t\t-\n\t\t\tmessage: '#^Return type \\(Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadataFactory\\) of method Doctrine\\\\ORM\\\\Decorator\\\\EntityManagerDecorator\\:\\:getMetadataFactory\\(\\) should be compatible with return type \\(Doctrine\\\\Persistence\\\\Mapping\\\\ClassMetadataFactory\\\\>\\) of method Doctrine\\\\Persistence\\\\ObjectManagerDecorator\\\\:\\:getMetadataFactory\\(\\)$#'\n\t\t\tidentifier: method.childReturnType\n\t\t\tcount: 1\n\t\t\tpath: src/Decorator/EntityManagerDecorator.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\EntityManager\\:\\:checkLockRequirements\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/EntityManager.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\EntityManager\\:\\:find\\(\\) should return \\(T of object\\)\\|null but returns object\\.$#'\n\t\t\tidentifier: return.type\n\t\t\tcount: 1\n\t\t\tpath: src/EntityManager.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\EntityManager\\:\\:find\\(\\) should return \\(T of object\\)\\|null but returns object\\|null\\.$#'\n\t\t\tidentifier: return.type\n\t\t\tcount: 3\n\t\t\tpath: src/EntityManager.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\EntityManager\\:\\:getReference\\(\\) should return \\(T of object\\)\\|null but returns object\\.$#'\n\t\t\tidentifier: return.type\n\t\t\tcount: 1\n\t\t\tpath: src/EntityManager.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\EntityManager\\:\\:getReference\\(\\) should return \\(T of object\\)\\|null but returns object\\|null\\.$#'\n\t\t\tidentifier: return.type\n\t\t\tcount: 1\n\t\t\tpath: src/EntityManager.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\EntityManager\\:\\:isUninitializedObject\\(\\) has parameter \\$value with no type specified\\.$#'\n\t\t\tidentifier: missingType.parameter\n\t\t\tcount: 1\n\t\t\tpath: src/EntityManager.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$className of method Doctrine\\\\Persistence\\\\Mapping\\\\AbstractClassMetadataFactory\\\\:\\:getMetadataFor\\(\\) expects class\\-string, string given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/EntityManager.php\n\n\t\t-\n\t\t\tmessage: '#^Property Doctrine\\\\ORM\\\\EntityManager\\:\\:\\$metadataFactory \\(Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadataFactory\\) does not accept object\\.$#'\n\t\t\tidentifier: assign.propertyType\n\t\t\tcount: 1\n\t\t\tpath: src/EntityManager.php\n\n\t\t-\n\t\t\tmessage: '#^Return type \\(Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadataFactory\\) of method Doctrine\\\\ORM\\\\EntityManager\\:\\:getMetadataFactory\\(\\) should be compatible with return type \\(Doctrine\\\\Persistence\\\\Mapping\\\\ClassMetadataFactory\\\\>\\) of method Doctrine\\\\Persistence\\\\ObjectManager\\:\\:getMetadataFactory\\(\\)$#'\n\t\t\tidentifier: method.childReturnType\n\t\t\tcount: 1\n\t\t\tpath: src/EntityManager.php\n\n\t\t-\n\t\t\tmessage: '#^Return type \\(Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadataFactory\\) of method Doctrine\\\\ORM\\\\EntityManagerInterface\\:\\:getMetadataFactory\\(\\) should be compatible with return type \\(Doctrine\\\\Persistence\\\\Mapping\\\\ClassMetadataFactory\\\\>\\) of method Doctrine\\\\Persistence\\\\ObjectManager\\:\\:getMetadataFactory\\(\\)$#'\n\t\t\tidentifier: method.childReturnType\n\t\t\tcount: 1\n\t\t\tpath: src/EntityManagerInterface.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\EntityRepository\\:\\:findBy\\(\\) should return list\\ but returns array\\\\.$#'\n\t\t\tidentifier: return.type\n\t\t\tcount: 1\n\t\t\tpath: src/EntityRepository.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\EntityRepository\\:\\:findOneBy\\(\\) should return \\(T of object\\)\\|null but returns object\\|null\\.$#'\n\t\t\tidentifier: return.type\n\t\t\tcount: 1\n\t\t\tpath: src/EntityRepository.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\EntityRepository\\:\\:matching\\(\\) should return Doctrine\\\\Common\\\\Collections\\\\AbstractLazyCollection\\ but returns Doctrine\\\\ORM\\\\LazyCriteriaCollection\\<\\(int\\|string\\), object\\>\\.$#'\n\t\t\tidentifier: return.type\n\t\t\tcount: 1\n\t\t\tpath: src/EntityRepository.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Event\\\\ListenersInvoker\\:\\:getSubscribedSystems\\(\\) has parameter \\$metadata with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Event/ListenersInvoker.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Event\\\\ListenersInvoker\\:\\:invoke\\(\\) has parameter \\$metadata with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Event/ListenersInvoker.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Event\\\\OnClassMetadataNotFoundEventArgs\\:\\:getFoundMetadata\\(\\) return type with generic interface Doctrine\\\\Persistence\\\\Mapping\\\\ClassMetadata does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Event/OnClassMetadataNotFoundEventArgs.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Event\\\\OnClassMetadataNotFoundEventArgs\\:\\:setFoundMetadata\\(\\) has parameter \\$classMetadata with generic interface Doctrine\\\\Persistence\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Event/OnClassMetadataNotFoundEventArgs.php\n\n\t\t-\n\t\t\tmessage: '#^Property Doctrine\\\\ORM\\\\Event\\\\OnClassMetadataNotFoundEventArgs\\:\\:\\$foundMetadata with generic interface Doctrine\\\\Persistence\\\\Mapping\\\\ClassMetadata does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Event/OnClassMetadataNotFoundEventArgs.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Event\\\\PreUpdateEventArgs\\:\\:__construct\\(\\) has parameter \\$changeSet with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Event/PreUpdateEventArgs.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Event\\\\PreUpdateEventArgs\\:\\:getEntityChangeSet\\(\\) return type with generic class Doctrine\\\\ORM\\\\PersistentCollection does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Event/PreUpdateEventArgs.php\n\n\t\t-\n\t\t\tmessage: '#^Property Doctrine\\\\ORM\\\\Event\\\\PreUpdateEventArgs\\:\\:\\$entityChangeSet with generic class Doctrine\\\\ORM\\\\PersistentCollection does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Event/PreUpdateEventArgs.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Id\\\\AssignedGenerator\\:\\:generateId\\(\\) return type has no value type specified in iterable type array\\.$#'\n\t\t\tidentifier: missingType.iterableValue\n\t\t\tcount: 1\n\t\t\tpath: src/Id/AssignedGenerator.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$joinColumns\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 2\n\t\t\tpath: src/Internal/Hydration/AbstractHydrator.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Internal\\\\Hydration\\\\AbstractHydrator\\:\\:gatherRowData\\(\\) return type has no value type specified in iterable type array\\.$#'\n\t\t\tidentifier: missingType.iterableValue\n\t\t\tcount: 3\n\t\t\tpath: src/Internal/Hydration/AbstractHydrator.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Internal\\\\Hydration\\\\AbstractHydrator\\:\\:gatherRowData\\(\\) return type with generic class ReflectionClass does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Internal/Hydration/AbstractHydrator.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Internal\\\\Hydration\\\\AbstractHydrator\\:\\:getClassMetadata\\(\\) return type with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Internal/Hydration/AbstractHydrator.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Internal\\\\Hydration\\\\AbstractHydrator\\:\\:getDiscriminatorValues\\(\\) has parameter \\$classMetadata with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Internal/Hydration/AbstractHydrator.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Internal\\\\Hydration\\\\AbstractHydrator\\:\\:registerManaged\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Internal/Hydration/AbstractHydrator.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter &\\$id by\\-ref type of method Doctrine\\\\ORM\\\\Internal\\\\Hydration\\\\AbstractHydrator\\:\\:gatherRowData\\(\\) expects array\\, array\\ given\\.$#'\n\t\t\tidentifier: parameterByRef.type\n\t\t\tcount: 1\n\t\t\tpath: src/Internal/Hydration/AbstractHydrator.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter &\\$nonemptyComponents by\\-ref type of method Doctrine\\\\ORM\\\\Internal\\\\Hydration\\\\AbstractHydrator\\:\\:gatherRowData\\(\\) expects array\\, array\\ given\\.$#'\n\t\t\tidentifier: parameterByRef.type\n\t\t\tcount: 1\n\t\t\tpath: src/Internal/Hydration/AbstractHydrator.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Internal\\\\Hydration\\\\ArrayHydrator\\:\\:hydrateAllData\\(\\) return type has no value type specified in iterable type array\\.$#'\n\t\t\tidentifier: missingType.iterableValue\n\t\t\tcount: 1\n\t\t\tpath: src/Internal/Hydration/ArrayHydrator.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter &\\$result by\\-ref type of method Doctrine\\\\ORM\\\\Internal\\\\Hydration\\\\ArrayHydrator\\:\\:hydrateRowData\\(\\) expects array\\, array\\\\|null given\\.$#'\n\t\t\tidentifier: parameterByRef.type\n\t\t\tcount: 1\n\t\t\tpath: src/Internal/Hydration/ArrayHydrator.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$inversedBy\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 2\n\t\t\tpath: src/Internal/Hydration/ObjectHydrator.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$joinColumns\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 2\n\t\t\tpath: src/Internal/Hydration/ObjectHydrator.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$mappedBy\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 3\n\t\t\tpath: src/Internal/Hydration/ObjectHydrator.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Internal\\\\Hydration\\\\ObjectHydrator\\:\\:hydrateAllData\\(\\) return type has no value type specified in iterable type array\\.$#'\n\t\t\tidentifier: missingType.iterableValue\n\t\t\tcount: 1\n\t\t\tpath: src/Internal/Hydration/ObjectHydrator.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Internal\\\\Hydration\\\\ObjectHydrator\\:\\:initRelatedCollection\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Internal/Hydration/ObjectHydrator.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Internal\\\\Hydration\\\\ObjectHydrator\\:\\:initRelatedCollection\\(\\) return type with generic class Doctrine\\\\ORM\\\\PersistentCollection does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Internal/Hydration/ObjectHydrator.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#2 \\$assoc of method Doctrine\\\\ORM\\\\PersistentCollection\\<\\(int\\|string\\),mixed\\>\\:\\:setOwner\\(\\) expects Doctrine\\\\ORM\\\\Mapping\\\\AssociationMapping&Doctrine\\\\ORM\\\\Mapping\\\\ToManyAssociationMapping, Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Internal/Hydration/ObjectHydrator.php\n\n\t\t-\n\t\t\tmessage: '#^Property Doctrine\\\\ORM\\\\Internal\\\\Hydration\\\\ObjectHydrator\\:\\:\\$uninitializedCollections with generic class Doctrine\\\\ORM\\\\PersistentCollection does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Internal/Hydration/ObjectHydrator.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Internal\\\\Hydration\\\\ScalarColumnHydrator\\:\\:hydrateAllData\\(\\) return type has no value type specified in iterable type array\\.$#'\n\t\t\tidentifier: missingType.iterableValue\n\t\t\tcount: 1\n\t\t\tpath: src/Internal/Hydration/ScalarColumnHydrator.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Internal\\\\Hydration\\\\ScalarHydrator\\:\\:hydrateAllData\\(\\) return type has no value type specified in iterable type array\\.$#'\n\t\t\tidentifier: missingType.iterableValue\n\t\t\tcount: 1\n\t\t\tpath: src/Internal/Hydration/ScalarHydrator.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Internal\\\\Hydration\\\\SimpleObjectHydrator\\:\\:hydrateAllData\\(\\) return type has no value type specified in iterable type array\\.$#'\n\t\t\tidentifier: missingType.iterableValue\n\t\t\tcount: 1\n\t\t\tpath: src/Internal/Hydration/SimpleObjectHydrator.php\n\n\t\t-\n\t\t\tmessage: '#^Property Doctrine\\\\ORM\\\\Internal\\\\Hydration\\\\SimpleObjectHydrator\\:\\:\\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Internal/Hydration/SimpleObjectHydrator.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Internal\\\\HydrationCompleteHandler\\:\\:deferPostLoadInvoking\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Internal/HydrationCompleteHandler.php\n\n\t\t-\n\t\t\tmessage: '#^Offset int\\|null might not exist on array\\\\.$#'\n\t\t\tidentifier: offsetAccess.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Internal/StronglyConnectedComponents.php\n\n\t\t-\n\t\t\tmessage: '#^Property Doctrine\\\\ORM\\\\Internal\\\\StronglyConnectedComponents\\:\\:\\$representingNodes \\(array\\\\) does not accept array\\\\.$#'\n\t\t\tidentifier: assign.propertyType\n\t\t\tcount: 1\n\t\t\tpath: src/Internal/StronglyConnectedComponents.php\n\n\t\t-\n\t\t\tmessage: '#^Property Doctrine\\\\ORM\\\\Internal\\\\StronglyConnectedComponents\\:\\:\\$states \\(array\\\\) does not accept non\\-empty\\-array\\<''''\\|int, 1\\|2\\|3\\>\\.$#'\n\t\t\tidentifier: assign.propertyType\n\t\t\tcount: 1\n\t\t\tpath: src/Internal/StronglyConnectedComponents.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\AnsiQuoteStrategy\\:\\:getColumnAlias\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/AnsiQuoteStrategy.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\AnsiQuoteStrategy\\:\\:getColumnName\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/AnsiQuoteStrategy.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\AnsiQuoteStrategy\\:\\:getIdentifierColumnNames\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/AnsiQuoteStrategy.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\AnsiQuoteStrategy\\:\\:getJoinColumnName\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/AnsiQuoteStrategy.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\AnsiQuoteStrategy\\:\\:getJoinTableName\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/AnsiQuoteStrategy.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\AnsiQuoteStrategy\\:\\:getReferencedJoinColumnName\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/AnsiQuoteStrategy.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\AnsiQuoteStrategy\\:\\:getSequenceName\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/AnsiQuoteStrategy.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\AnsiQuoteStrategy\\:\\:getTableName\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/AnsiQuoteStrategy.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$mappingArray of static method Doctrine\\\\ORM\\\\Mapping\\\\JoinTableMapping\\:\\:fromMappingArray\\(\\) expects array\\{name\\: string, quoted\\?\\: bool\\|null, joinColumns\\?\\: array\\, inverseJoinColumns\\?\\: array\\, schema\\?\\: string\\|null, options\\?\\: array\\\\}, non\\-empty\\-array\\ given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/AssociationMapping.php\n\n\t\t-\n\t\t\tmessage: '#^Property Doctrine\\\\ORM\\\\Mapping\\\\AssociationMapping\\:\\:\\$cache type has no value type specified in iterable type array\\.$#'\n\t\t\tidentifier: missingType.iterableValue\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/AssociationMapping.php\n\n\t\t-\n\t\t\tmessage: '#^Instanceof between Doctrine\\\\ORM\\\\Mapping\\\\AssociationOverride and Doctrine\\\\ORM\\\\Mapping\\\\AssociationOverride will always evaluate to true\\.$#'\n\t\t\tidentifier: instanceof.alwaysTrue\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/AssociationOverrides.php\n\n\t\t-\n\t\t\tmessage: '#^Instanceof between Doctrine\\\\ORM\\\\Mapping\\\\AttributeOverride and Doctrine\\\\ORM\\\\Mapping\\\\AttributeOverride will always evaluate to true\\.$#'\n\t\t\tidentifier: instanceof.alwaysTrue\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/AttributeOverrides.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\Builder\\\\ClassMetadataBuilder\\:\\:__construct\\(\\) has parameter \\$cm with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/Builder/ClassMetadataBuilder.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\Builder\\\\ClassMetadataBuilder\\:\\:getClassMetadata\\(\\) return type with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/Builder/ClassMetadataBuilder.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$repositoryClassName of method Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata\\\\:\\:setCustomRepositoryClass\\(\\) expects class\\-string\\\\|null, string given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/Builder/ClassMetadataBuilder.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$mapping of method Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata\\\\:\\:mapEmbedded\\(\\) expects array\\{fieldName\\: string, class\\?\\: class\\-string, declaredField\\?\\: string, columnPrefix\\?\\: string\\|false\\|null, originalField\\?\\: string\\}, array\\ given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/Builder/EmbeddedBuilder.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\Builder\\\\EntityListenerBuilder\\:\\:bindEntityListener\\(\\) has parameter \\$metadata with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/Builder/EntityListenerBuilder.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$joinColumns\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 4\n\t\t\tpath: src/Mapping/ClassMetadata.php\n\n\t\t-\n\t\t\tmessage: '#^If condition is always true\\.$#'\n\t\t\tidentifier: if.alwaysTrue\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadata.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata\\:\\:inlineEmbeddable\\(\\) has parameter \\$embeddable with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadata.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata\\:\\:setAssociationOverride\\(\\) has parameter \\$overrideMapping with no value type specified in iterable type array\\.$#'\n\t\t\tidentifier: missingType.iterableValue\n\t\t\tcount: 2\n\t\t\tpath: src/Mapping/ClassMetadata.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata\\:\\:setCustomRepositoryClass\\(\\) has parameter \\$repositoryClassName with generic class Doctrine\\\\ORM\\\\EntityRepository but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadata.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$array \\(list\\\\) of array_values is already a list, call has no effect\\.$#'\n\t\t\tidentifier: arrayValues.list\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadata.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$mapping of method Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata\\\\:\\:validateAndCompleteTypedAssociationMapping\\(\\) expects array\\{type\\: 1\\|2\\|4\\|8, fieldName\\: string, targetEntity\\?\\: class\\-string\\}, non\\-empty\\-array\\ given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadata.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$mappingArray of static method Doctrine\\\\ORM\\\\Mapping\\\\AssociationMapping\\:\\:fromMappingArray\\(\\) expects array\\{fieldName\\: string, sourceEntity\\: class\\-string, targetEntity\\: class\\-string, cascade\\?\\: list\\<''all''\\|''detach''\\|''persist''\\|''refresh''\\|''remove''\\>, fetch\\?\\: 2\\|3\\|4\\|null, inherited\\?\\: class\\-string\\|null, declared\\?\\: class\\-string\\|null, cache\\?\\: array\\\\|null, \\.\\.\\.\\}, non\\-empty\\-array given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadata.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$mappingArray of static method Doctrine\\\\ORM\\\\Mapping\\\\EmbeddedClassMapping\\:\\:fromMappingArray\\(\\) expects array\\{class\\: class\\-string, columnPrefix\\?\\: string\\|false\\|null, declaredField\\?\\: string\\|null, originalField\\?\\: string\\|null, inherited\\?\\: class\\-string\\|null, declared\\?\\: class\\-string\\|null\\}, array\\{class\\: string, columnPrefix\\: string\\|false\\|null, declaredField\\: string\\|null, originalField\\: string\\|null\\} given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadata.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$mappingArray of static method Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\:\\:fromMappingArrayAndNamingStrategy\\(\\) expects array\\{fieldName\\: string, sourceEntity\\: class\\-string, targetEntity\\: class\\-string, cascade\\?\\: list\\<''all''\\|''detach''\\|''persist''\\|''refresh''\\|''remove''\\>, fetch\\?\\: 2\\|3\\|4\\|null, inherited\\?\\: class\\-string\\|null, declared\\?\\: class\\-string\\|null, cache\\?\\: array\\\\|null, \\.\\.\\.\\}, non\\-empty\\-array given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadata.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$mappingArray of static method Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\:\\:fromMappingArrayAndName\\(\\) expects array\\{fieldName\\: string, sourceEntity\\: class\\-string, targetEntity\\: class\\-string, cascade\\?\\: list\\<''all''\\|''detach''\\|''persist''\\|''refresh''\\|''remove''\\>, fetch\\?\\: 2\\|3\\|4\\|null, inherited\\?\\: class\\-string\\|null, declared\\?\\: class\\-string\\|null, cache\\?\\: array\\\\|null, \\.\\.\\.\\}, non\\-empty\\-array given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadata.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$mappingArray of static method Doctrine\\\\ORM\\\\Mapping\\\\ToOneInverseSideMapping\\:\\:fromMappingArrayAndName\\(\\) expects array\\{fieldName\\: string, sourceEntity\\: class\\-string, targetEntity\\: class\\-string, cascade\\?\\: list\\<''all''\\|''detach''\\|''persist''\\|''refresh''\\|''remove''\\>, fetch\\?\\: 2\\|3\\|4\\|null, inherited\\?\\: class\\-string\\|null, declared\\?\\: class\\-string\\|null, cache\\?\\: array\\\\|null, \\.\\.\\.\\}, non\\-empty\\-array given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadata.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$mappingArray of static method Doctrine\\\\ORM\\\\Mapping\\\\ToOneOwningSideMapping\\:\\:fromMappingArrayAndName\\(\\) expects array\\{fieldName\\: string, sourceEntity\\: class\\-string, targetEntity\\: class\\-string, cascade\\?\\: list\\<''all''\\|''detach''\\|''persist''\\|''refresh''\\|''remove''\\>, fetch\\?\\: 2\\|3\\|4\\|null, inherited\\?\\: class\\-string\\|null, declared\\?\\: class\\-string\\|null, cache\\?\\: array\\\\|null, \\.\\.\\.\\}, non\\-empty\\-array given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 2\n\t\t\tpath: src/Mapping/ClassMetadata.php\n\n\t\t-\n\t\t\tmessage: '#^Property Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata\\:\\:\\$customRepositoryClassName with generic class Doctrine\\\\ORM\\\\EntityRepository does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadata.php\n\n\t\t-\n\t\t\tmessage: '#^Property Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata\\:\\:\\$table type has no value type specified in iterable type array\\.$#'\n\t\t\tidentifier: missingType.iterableValue\n\t\t\tcount: 2\n\t\t\tpath: src/Mapping/ClassMetadata.php\n\n\t\t-\n\t\t\tmessage: '#^Property Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata\\\\:\\:\\$customRepositoryClassName \\(class\\-string\\\\|null\\) does not accept class\\-string\\.$#'\n\t\t\tidentifier: assign.propertyType\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadata.php\n\n\t\t-\n\t\t\tmessage: '#^Property Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata\\\\:\\:\\$discriminatorMap \\(array\\\\) does not accept array\\\\.$#'\n\t\t\tidentifier: assign.propertyType\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadata.php\n\n\t\t-\n\t\t\tmessage: '#^Property Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata\\\\:\\:\\$entityListeners \\(array\\\\>\\) does not accept non\\-empty\\-array\\\\>\\.$#'\n\t\t\tidentifier: assign.propertyType\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadata.php\n\n\t\t-\n\t\t\tmessage: '#^Property Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata\\\\:\\:\\$subClasses \\(list\\\\) does not accept non\\-empty\\-list\\\\.$#'\n\t\t\tidentifier: assign.propertyType\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadata.php\n\n\t\t-\n\t\t\tmessage: '#^Strict comparison using \\!\\=\\= between Doctrine\\\\ORM\\\\Mapping\\\\FieldMapping and false will always evaluate to true\\.$#'\n\t\t\tidentifier: notIdentical.alwaysTrue\n\t\t\tcount: 2\n\t\t\tpath: src/Mapping/ClassMetadata.php\n\n\t\t-\n\t\t\tmessage: '#^Template type T is declared as covariant, but occurs in invariant position in property Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata\\:\\:\\$name\\.$#'\n\t\t\tidentifier: generics.variance\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadata.php\n\n\t\t-\n\t\t\tmessage: '#^Template type T is declared as covariant, but occurs in invariant position in property Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata\\:\\:\\$reflClass\\.$#'\n\t\t\tidentifier: generics.variance\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadata.php\n\n\t\t-\n\t\t\tmessage: '#^Template type T is declared as covariant, but occurs in invariant position in return type of method Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata\\:\\:getReflectionClass\\(\\)\\.$#'\n\t\t\tidentifier: generics.variance\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadata.php\n\n\t\t-\n\t\t\tmessage: '#^Unable to resolve the template type C in call to method Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata\\\\:\\:fullyQualifiedClassName\\(\\)$#'\n\t\t\tidentifier: argument.templateType\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadata.php\n\n\t\t-\n\t\t\tmessage: '#^If condition is always true\\.$#'\n\t\t\tidentifier: if.alwaysTrue\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadataFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadataFactory\\:\\:addDefaultDiscriminatorMap\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadataFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadataFactory\\:\\:addInheritedEmbeddedClasses\\(\\) has parameter \\$parentClass with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadataFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadataFactory\\:\\:addInheritedEmbeddedClasses\\(\\) has parameter \\$subClass with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadataFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadataFactory\\:\\:addInheritedFields\\(\\) has parameter \\$parentClass with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadataFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadataFactory\\:\\:addInheritedFields\\(\\) has parameter \\$subClass with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadataFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadataFactory\\:\\:addInheritedIndexes\\(\\) has parameter \\$parentClass with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadataFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadataFactory\\:\\:addInheritedIndexes\\(\\) has parameter \\$subClass with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadataFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadataFactory\\:\\:addInheritedRelations\\(\\) has parameter \\$parentClass with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadataFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadataFactory\\:\\:addInheritedRelations\\(\\) has parameter \\$subClass with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadataFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadataFactory\\:\\:addMappingInheritanceInformation\\(\\) has parameter \\$parentClass with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadataFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadataFactory\\:\\:addNestedEmbeddedClasses\\(\\) has parameter \\$parentClass with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadataFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadataFactory\\:\\:addNestedEmbeddedClasses\\(\\) has parameter \\$subClass with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadataFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadataFactory\\:\\:completeIdGeneratorMapping\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadataFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadataFactory\\:\\:doLoadMetadata\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadataFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadataFactory\\:\\:doLoadMetadata\\(\\) has parameter \\$parent with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadataFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadataFactory\\:\\:findAbstractEntityClassesNotListedInDiscriminatorMap\\(\\) has parameter \\$rootEntityClass with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadataFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadataFactory\\:\\:inheritIdGeneratorMapping\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadataFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadataFactory\\:\\:inheritIdGeneratorMapping\\(\\) has parameter \\$parent with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadataFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadataFactory\\:\\:initializeReflection\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadataFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadataFactory\\:\\:isEntity\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadataFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadataFactory\\:\\:newClassMetadataInstance\\(\\) return type with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadataFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadataFactory\\:\\:onNotFoundMetadata\\(\\) return type with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadataFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadataFactory\\:\\:validateRuntimeMetadata\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadataFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadataFactory\\:\\:validateRuntimeMetadata\\(\\) has parameter \\$parent with generic interface Doctrine\\\\Persistence\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadataFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadataFactory\\:\\:wakeupReflection\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadataFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$generator of method Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata\\\\:\\:setIdGenerator\\(\\) expects Doctrine\\\\ORM\\\\Id\\\\AbstractIdGenerator, object given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadataFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$rootEntityClass of static method Doctrine\\\\ORM\\\\Mapping\\\\MappingException\\:\\:missingInheritanceTypeDeclaration\\(\\) expects class\\-string, class\\-string\\|false given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ClassMetadataFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Property Doctrine\\\\ORM\\\\Mapping\\\\DefaultEntityListenerResolver\\:\\:\\$instances \\(array\\\\) does not accept array\\\\.$#'\n\t\t\tidentifier: assign.propertyType\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/DefaultEntityListenerResolver.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$joinColumns\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/DefaultQuoteStrategy.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\DefaultQuoteStrategy\\:\\:getColumnAlias\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/DefaultQuoteStrategy.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\DefaultQuoteStrategy\\:\\:getColumnName\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/DefaultQuoteStrategy.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\DefaultQuoteStrategy\\:\\:getIdentifierColumnNames\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/DefaultQuoteStrategy.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\DefaultQuoteStrategy\\:\\:getJoinColumnName\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/DefaultQuoteStrategy.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\DefaultQuoteStrategy\\:\\:getJoinTableName\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/DefaultQuoteStrategy.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\DefaultQuoteStrategy\\:\\:getReferencedJoinColumnName\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/DefaultQuoteStrategy.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\DefaultQuoteStrategy\\:\\:getSequenceName\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/DefaultQuoteStrategy.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\DefaultQuoteStrategy\\:\\:getTableName\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/DefaultQuoteStrategy.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\Driver\\\\AttributeDriver\\:\\:isRepeatedPropertyDeclaration\\(\\) has parameter \\$metadata with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/Driver/AttributeDriver.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$mapping of method Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata\\\\:\\:mapEmbedded\\(\\) expects array\\{fieldName\\: string, class\\?\\: class\\-string, declaredField\\?\\: string, columnPrefix\\?\\: string\\|false\\|null, originalField\\?\\: string\\}, array\\{fieldName\\: string, cache\\?\\: array\\{usage\\: int, region\\: string\\|null\\}, class\\: string\\|null, columnPrefix\\: bool\\|string\\|null\\} given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/Driver/AttributeDriver.php\n\n\t\t-\n\t\t\tmessage: '#^Unable to resolve the template type C in call to method Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata\\\\:\\:fullyQualifiedClassName\\(\\)$#'\n\t\t\tidentifier: argument.templateType\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/Driver/AttributeDriver.php\n\n\t\t-\n\t\t\tmessage: '#^Call to function method_exists\\(\\) with ''Doctrine\\\\\\\\DBAL\\\\\\\\Schema\\\\\\\\ForeignKeyConstraint'' and ''getReferencedColumn…'' will always evaluate to true\\.$#'\n\t\t\tidentifier: function.alreadyNarrowedType\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/Driver/DatabaseDriver.php\n\n\t\t-\n\t\t\tmessage: '#^Call to function method_exists\\(\\) with ''Doctrine\\\\\\\\DBAL\\\\\\\\Schema\\\\\\\\ForeignKeyConstraint'' and ''getReferencedTableN…'' will always evaluate to true\\.$#'\n\t\t\tidentifier: function.alreadyNarrowedType\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/Driver/DatabaseDriver.php\n\n\t\t-\n\t\t\tmessage: '#^Call to function method_exists\\(\\) with ''Doctrine\\\\\\\\DBAL\\\\\\\\Schema\\\\\\\\ForeignKeyConstraint'' and ''getReferencingColum…'' will always evaluate to true\\.$#'\n\t\t\tidentifier: function.alreadyNarrowedType\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/Driver/DatabaseDriver.php\n\n\t\t-\n\t\t\tmessage: '#^Call to function method_exists\\(\\) with ''Doctrine\\\\\\\\DBAL\\\\\\\\Schema\\\\\\\\Index'' and ''getIndexedColumns'' will always evaluate to true\\.$#'\n\t\t\tidentifier: function.alreadyNarrowedType\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/Driver/DatabaseDriver.php\n\n\t\t-\n\t\t\tmessage: '#^Call to function method_exists\\(\\) with ''Doctrine\\\\\\\\DBAL\\\\\\\\Schema\\\\\\\\Table'' and ''getPrimaryKeyConstr…'' will always evaluate to true\\.$#'\n\t\t\tidentifier: function.alreadyNarrowedType\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/Driver/DatabaseDriver.php\n\n\t\t-\n\t\t\tmessage: '#^Call to function method_exists\\(\\) with Doctrine\\\\DBAL\\\\Schema\\\\Index and ''getType'' will always evaluate to true\\.$#'\n\t\t\tidentifier: function.alreadyNarrowedType\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/Driver/DatabaseDriver.php\n\n\t\t-\n\t\t\tmessage: '#^Call to function method_exists\\(\\) with Doctrine\\\\DBAL\\\\Schema\\\\Table and ''getPrimaryKeyConstr…'' will always evaluate to true\\.$#'\n\t\t\tidentifier: function.alreadyNarrowedType\n\t\t\tcount: 2\n\t\t\tpath: src/Mapping/Driver/DatabaseDriver.php\n\n\t\t-\n\t\t\tmessage: '#^Instanceof between Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata\\ and Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata will always evaluate to true\\.$#'\n\t\t\tidentifier: instanceof.alwaysTrue\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/Driver/DatabaseDriver.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\Driver\\\\DatabaseDriver\\:\\:__construct\\(\\) has parameter \\$sm with generic class Doctrine\\\\DBAL\\\\Schema\\\\AbstractSchemaManager but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/Driver/DatabaseDriver.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\Driver\\\\DatabaseDriver\\:\\:buildFieldMappings\\(\\) has parameter \\$metadata with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/Driver/DatabaseDriver.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\Driver\\\\DatabaseDriver\\:\\:buildIndexes\\(\\) has parameter \\$metadata with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/Driver/DatabaseDriver.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\Driver\\\\DatabaseDriver\\:\\:buildToOneAssociationMappings\\(\\) has parameter \\$metadata with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/Driver/DatabaseDriver.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\Driver\\\\DatabaseDriver\\:\\:getAssetName\\(\\) has parameter \\$asset with generic class Doctrine\\\\DBAL\\\\Schema\\\\AbstractAsset but does not specify its types\\: N$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/Driver/DatabaseDriver.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\Driver\\\\DatabaseDriver\\:\\:getClassNameForTable\\(\\) should return class\\-string but returns string\\.$#'\n\t\t\tidentifier: return.type\n\t\t\tcount: 2\n\t\t\tpath: src/Mapping/Driver/DatabaseDriver.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#2 \\$columnName of method Doctrine\\\\ORM\\\\Mapping\\\\Driver\\\\DatabaseDriver\\:\\:getFieldNameForColumn\\(\\) expects string, string\\|false given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 4\n\t\t\tpath: src/Mapping/Driver/DatabaseDriver.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\Driver\\\\SimplifiedXmlDriver\\:\\:__construct\\(\\) has parameter \\$fileExtension with no type specified\\.$#'\n\t\t\tidentifier: missingType.parameter\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/Driver/SimplifiedXmlDriver.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\Driver\\\\SimplifiedXmlDriver\\:\\:__construct\\(\\) has parameter \\$prefixes with no type specified\\.$#'\n\t\t\tidentifier: missingType.parameter\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/Driver/SimplifiedXmlDriver.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\Driver\\\\XmlDriver\\:\\:cacheToArray\\(\\) should return array\\{usage\\: int\\|null, region\\?\\: string\\} but returns array\\{usage\\: ''''\\|''0''\\|int\\|null, region\\: string\\|null\\}\\.$#'\n\t\t\tidentifier: return.type\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/Driver/XmlDriver.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\Driver\\\\XmlDriver\\:\\:columnToArray\\(\\) return type has no value type specified in iterable type array\\.$#'\n\t\t\tidentifier: missingType.iterableValue\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/Driver/XmlDriver.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$columnDef of method Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata\\\\:\\:setDiscriminatorColumn\\(\\) expects array\\{name\\: string\\|null, fieldName\\?\\: string\\|null, type\\?\\: string\\|null, length\\?\\: int\\|null, columnDefinition\\?\\: string\\|null, enumType\\?\\: class\\-string\\\\|null, options\\?\\: array\\\\|null\\}\\|Doctrine\\\\ORM\\\\Mapping\\\\DiscriminatorColumnMapping\\|null, array\\{name\\: string\\|null, type\\: string, length\\: int, columnDefinition\\: string\\|null, enumType\\: string\\|null, options\\?\\: array\\\\|bool\\|object\\|string\\>\\} given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/Driver/XmlDriver.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$data of function simplexml_load_string expects string, string\\|false given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/Driver/XmlDriver.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$mapping of method Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata\\\\:\\:mapEmbedded\\(\\) expects array\\{fieldName\\: string, class\\?\\: class\\-string, declaredField\\?\\: string, columnPrefix\\?\\: string\\|false\\|null, originalField\\?\\: string\\}, array\\{fieldName\\: string, class\\: string\\|null, columnPrefix\\: string\\|false\\|null\\} given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/Driver/XmlDriver.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$repositoryClassName of method Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata\\\\:\\:setCustomRepositoryClass\\(\\) expects class\\-string\\\\|null, string given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/Driver/XmlDriver.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$repositoryClassName of method Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata\\\\:\\:setCustomRepositoryClass\\(\\) expects class\\-string\\\\|null, string\\|null given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/Driver/XmlDriver.php\n\n\t\t-\n\t\t\tmessage: '#^Property Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata\\\\:\\:\\$table \\(array\\{name\\: string, schema\\?\\: string, indexes\\?\\: array, uniqueConstraints\\?\\: array, options\\?\\: array\\, quoted\\?\\: bool\\}\\) does not accept array\\{name\\: string, schema\\?\\: string, indexes\\?\\: array, uniqueConstraints\\?\\: array, options\\: array\\\\|bool\\|object\\|string\\>, quoted\\?\\: bool\\}\\.$#'\n\t\t\tidentifier: assign.propertyType\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/Driver/XmlDriver.php\n\n\t\t-\n\t\t\tmessage: '#^Property Doctrine\\\\ORM\\\\Mapping\\\\FieldMapping\\:\\:\\$declared \\(class\\-string\\|null\\) does not accept string\\|null\\.$#'\n\t\t\tidentifier: assign.propertyType\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/FieldMapping.php\n\n\t\t-\n\t\t\tmessage: '#^Property Doctrine\\\\ORM\\\\Mapping\\\\FieldMapping\\:\\:\\$enumType \\(class\\-string\\\\|null\\) does not accept string\\|null\\.$#'\n\t\t\tidentifier: assign.propertyType\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/FieldMapping.php\n\n\t\t-\n\t\t\tmessage: '#^Property Doctrine\\\\ORM\\\\Mapping\\\\FieldMapping\\:\\:\\$inherited \\(class\\-string\\|null\\) does not accept string\\|null\\.$#'\n\t\t\tidentifier: assign.propertyType\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/FieldMapping.php\n\n\t\t-\n\t\t\tmessage: '#^Property Doctrine\\\\ORM\\\\Mapping\\\\FieldMapping\\:\\:\\$options type has no value type specified in iterable type array\\.$#'\n\t\t\tidentifier: missingType.iterableValue\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/FieldMapping.php\n\n\t\t-\n\t\t\tmessage: '#^Property Doctrine\\\\ORM\\\\Mapping\\\\JoinTableMapping\\:\\:\\$options \\(array\\\\) does not accept array\\\\|bool\\|string\\.$#'\n\t\t\tidentifier: assign.propertyType\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/JoinTableMapping.php\n\n\t\t-\n\t\t\tmessage: '#^Property Doctrine\\\\ORM\\\\Mapping\\\\JoinTableMapping\\:\\:\\$quoted \\(bool\\|null\\) does not accept array\\\\|bool\\|string\\.$#'\n\t\t\tidentifier: assign.propertyType\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/JoinTableMapping.php\n\n\t\t-\n\t\t\tmessage: '#^Property Doctrine\\\\ORM\\\\Mapping\\\\JoinTableMapping\\:\\:\\$schema \\(string\\|null\\) does not accept array\\\\|bool\\|string\\.$#'\n\t\t\tidentifier: assign.propertyType\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/JoinTableMapping.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\LegacyReflectionFields\\:\\:__construct\\(\\) has parameter \\$classMetadata with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/LegacyReflectionFields.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$class of method Doctrine\\\\Persistence\\\\Mapping\\\\ReflectionService\\:\\:getAccessibleProperty\\(\\) expects class\\-string, string given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/LegacyReflectionFields.php\n\n\t\t-\n\t\t\tmessage: '#^Strict comparison using \\!\\=\\= between array\\ and null will always evaluate to true\\.$#'\n\t\t\tidentifier: notIdentical.alwaysTrue\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ManyToManyOwningSideMapping.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\MappedSuperclass\\:\\:__construct\\(\\) has parameter \\$repositoryClass with generic class Doctrine\\\\ORM\\\\EntityRepository but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/MappedSuperclass.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\PropertyAccessors\\\\EnumPropertyAccessor\\:\\:toEnum\\(\\) should return array\\\\|BackedEnum but returns array\\\\.$#'\n\t\t\tidentifier: return.type\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/PropertyAccessors/EnumPropertyAccessor.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$callback of function array_map expects \\(callable\\(BackedEnum\\|int\\|string\\)\\: mixed\\)\\|null, array\\{class\\-string\\, ''from''\\} given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/PropertyAccessors/EnumPropertyAccessor.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\QuoteStrategy\\:\\:getColumnAlias\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/QuoteStrategy.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\QuoteStrategy\\:\\:getColumnName\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/QuoteStrategy.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\QuoteStrategy\\:\\:getIdentifierColumnNames\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/QuoteStrategy.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\QuoteStrategy\\:\\:getJoinColumnName\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/QuoteStrategy.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\QuoteStrategy\\:\\:getJoinTableName\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/QuoteStrategy.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\QuoteStrategy\\:\\:getReferencedJoinColumnName\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/QuoteStrategy.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\QuoteStrategy\\:\\:getSequenceName\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/QuoteStrategy.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\QuoteStrategy\\:\\:getTableName\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/QuoteStrategy.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\ReflectionEnumProperty\\:\\:getValue\\(\\) return type has no value type specified in iterable type array\\.$#'\n\t\t\tidentifier: missingType.iterableValue\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ReflectionEnumProperty.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\ToOneOwningSideMapping\\:\\:fromMappingArray\\(\\) should return static\\(Doctrine\\\\ORM\\\\Mapping\\\\ToOneOwningSideMapping\\) but returns Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\.$#'\n\t\t\tidentifier: return.type\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ToOneOwningSideMapping.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\ToOneOwningSideMapping\\:\\:fromMappingArrayAndName\\(\\) has parameter \\$table with no value type specified in iterable type array\\.$#'\n\t\t\tidentifier: missingType.iterableValue\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ToOneOwningSideMapping.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Mapping\\\\ToOneOwningSideMapping\\:\\:fromMappingArrayAndName\\(\\) should return static\\(Doctrine\\\\ORM\\\\Mapping\\\\ToOneOwningSideMapping\\) but returns Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\.$#'\n\t\t\tidentifier: return.type\n\t\t\tcount: 1\n\t\t\tpath: src/Mapping/ToOneOwningSideMapping.php\n\n\t\t-\n\t\t\tmessage: '#^Call to function is_int\\(\\) with string will always evaluate to false\\.$#'\n\t\t\tidentifier: function.impossibleType\n\t\t\tcount: 1\n\t\t\tpath: src/NativeQuery.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\NativeQuery\\:\\:_doExecute\\(\\) never returns int so it can be removed from the return type\\.$#'\n\t\t\tidentifier: return.unusedType\n\t\t\tcount: 1\n\t\t\tpath: src/NativeQuery.php\n\n\t\t-\n\t\t\tmessage: '#^Result of && is always false\\.$#'\n\t\t\tidentifier: booleanAnd.alwaysFalse\n\t\t\tcount: 1\n\t\t\tpath: src/NativeQuery.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\ORMInvalidArgumentException\\:\\:invalidAssociation\\(\\) has parameter \\$targetClass with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/ORMInvalidArgumentException.php\n\n\t\t-\n\t\t\tmessage: '#^Call to method Doctrine\\\\ORM\\\\Mapping\\\\AssociationMapping\\:\\:isToMany\\(\\) will always evaluate to true\\.$#'\n\t\t\tidentifier: method.alreadyNarrowedType\n\t\t\tcount: 1\n\t\t\tpath: src/PersistentCollection.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\PersistentCollection\\:\\:__construct\\(\\) has parameter \\$typeClass with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/PersistentCollection.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\PersistentCollection\\:\\:get\\(\\) should return T\\|null but returns object\\|null\\.$#'\n\t\t\tidentifier: return.type\n\t\t\tcount: 1\n\t\t\tpath: src/PersistentCollection.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\PersistentCollection\\:\\:getTypeClass\\(\\) return type with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/PersistentCollection.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\PersistentCollection\\:\\:matching\\(\\) should return Doctrine\\\\Common\\\\Collections\\\\Collection\\ but returns Doctrine\\\\Common\\\\Collections\\\\ArrayCollection\\<\\(int\\|string\\), mixed\\>\\|Doctrine\\\\ORM\\\\LazyCriteriaCollection\\<\\(int\\|string\\), object\\>\\.$#'\n\t\t\tidentifier: return.type\n\t\t\tcount: 1\n\t\t\tpath: src/PersistentCollection.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\PersistentCollection\\:\\:matching\\(\\) should return Doctrine\\\\Common\\\\Collections\\\\Collection\\ but returns Doctrine\\\\Common\\\\Collections\\\\ReadableCollection\\&Doctrine\\\\Common\\\\Collections\\\\Selectable\\\\.$#'\n\t\t\tidentifier: return.type\n\t\t\tcount: 1\n\t\t\tpath: src/PersistentCollection.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$key of method Doctrine\\\\ORM\\\\PersistentCollection\\\\:\\:set\\(\\) expects TKey of \\(int\\|string\\), int\\|string given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/PersistentCollection.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#2 \\$callback of function array_walk expects callable\\(object, int\\)\\: mixed, array\\{Doctrine\\\\Common\\\\Collections\\\\Collection\\&Doctrine\\\\Common\\\\Collections\\\\Selectable\\, ''add''\\} given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/PersistentCollection.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Collection\\\\CollectionPersister\\:\\:contains\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Collection/CollectionPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Collection\\\\CollectionPersister\\:\\:containsKey\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Collection/CollectionPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Collection\\\\CollectionPersister\\:\\:count\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Collection/CollectionPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Collection\\\\CollectionPersister\\:\\:delete\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Collection/CollectionPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Collection\\\\CollectionPersister\\:\\:get\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Collection/CollectionPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Collection\\\\CollectionPersister\\:\\:loadCriteria\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Collection/CollectionPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Collection\\\\CollectionPersister\\:\\:slice\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Collection/CollectionPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Collection\\\\CollectionPersister\\:\\:update\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Collection/CollectionPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$joinTable\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Collection/ManyToManyPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$joinTableColumns\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Collection/ManyToManyPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$relationToSourceKeyColumns\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Collection/ManyToManyPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$relationToTargetKeyColumns\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Collection/ManyToManyPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$joinTable\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 2\n\t\t\tpath: src/Persisters/Collection/ManyToManyPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Call to function assert\\(\\) with true will always evaluate to true\\.$#'\n\t\t\tidentifier: function.alreadyNarrowedType\n\t\t\tcount: 2\n\t\t\tpath: src/Persisters/Collection/ManyToManyPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Call to method Doctrine\\\\ORM\\\\Mapping\\\\AssociationMapping\\:\\:isIndexed\\(\\) will always evaluate to true\\.$#'\n\t\t\tidentifier: method.alreadyNarrowedType\n\t\t\tcount: 2\n\t\t\tpath: src/Persisters/Collection/ManyToManyPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Instanceof between Doctrine\\\\ORM\\\\Mapping\\\\InverseSideMapping&Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyAssociationMapping and Doctrine\\\\ORM\\\\Mapping\\\\InverseSideMapping will always evaluate to true\\.$#'\n\t\t\tidentifier: instanceof.alwaysTrue\n\t\t\tcount: 2\n\t\t\tpath: src/Persisters/Collection/ManyToManyPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Collection\\\\ManyToManyPersister\\:\\:collectJoinTableColumnParameters\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Collection/ManyToManyPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Collection\\\\ManyToManyPersister\\:\\:contains\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Collection/ManyToManyPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Collection\\\\ManyToManyPersister\\:\\:containsKey\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Collection/ManyToManyPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Collection\\\\ManyToManyPersister\\:\\:count\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Collection/ManyToManyPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Collection\\\\ManyToManyPersister\\:\\:delete\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Collection/ManyToManyPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Collection\\\\ManyToManyPersister\\:\\:generateFilterConditionSQL\\(\\) has parameter \\$targetEntity with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Collection/ManyToManyPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Collection\\\\ManyToManyPersister\\:\\:get\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Collection/ManyToManyPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Collection\\\\ManyToManyPersister\\:\\:getDeleteRowSQL\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Collection/ManyToManyPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Collection\\\\ManyToManyPersister\\:\\:getDeleteRowSQLParameters\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Collection/ManyToManyPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Collection\\\\ManyToManyPersister\\:\\:getDeleteSQL\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Collection/ManyToManyPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Collection\\\\ManyToManyPersister\\:\\:getDeleteSQLParameters\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Collection/ManyToManyPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Collection\\\\ManyToManyPersister\\:\\:getInsertRowSQL\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Collection/ManyToManyPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Collection\\\\ManyToManyPersister\\:\\:getInsertRowSQLParameters\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Collection/ManyToManyPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Collection\\\\ManyToManyPersister\\:\\:getJoinTableRestrictions\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Collection/ManyToManyPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Collection\\\\ManyToManyPersister\\:\\:getJoinTableRestrictionsWithKey\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Collection/ManyToManyPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Collection\\\\ManyToManyPersister\\:\\:getMapping\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Collection/ManyToManyPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Collection\\\\ManyToManyPersister\\:\\:getOrderingSql\\(\\) has parameter \\$targetClass with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Collection/ManyToManyPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Collection\\\\ManyToManyPersister\\:\\:loadCriteria\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Collection/ManyToManyPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Collection\\\\ManyToManyPersister\\:\\:slice\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Collection/ManyToManyPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Collection\\\\ManyToManyPersister\\:\\:update\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Collection/ManyToManyPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$association of method Doctrine\\\\ORM\\\\Mapping\\\\QuoteStrategy\\:\\:getJoinTableName\\(\\) expects Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping, Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Collection/ManyToManyPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Collection\\\\OneToManyPersister\\:\\:contains\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Collection/OneToManyPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Collection\\\\OneToManyPersister\\:\\:containsKey\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Collection/OneToManyPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Collection\\\\OneToManyPersister\\:\\:count\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Collection/OneToManyPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Collection\\\\OneToManyPersister\\:\\:delete\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Collection/OneToManyPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Collection\\\\OneToManyPersister\\:\\:deleteEntityCollection\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Collection/OneToManyPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Collection\\\\OneToManyPersister\\:\\:deleteJoinedEntityCollection\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Collection/OneToManyPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Collection\\\\OneToManyPersister\\:\\:get\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Collection/OneToManyPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Collection\\\\OneToManyPersister\\:\\:getMapping\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Collection/OneToManyPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Collection\\\\OneToManyPersister\\:\\:loadCriteria\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Collection/OneToManyPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Collection\\\\OneToManyPersister\\:\\:slice\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Collection/OneToManyPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Collection\\\\OneToManyPersister\\:\\:update\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Collection/OneToManyPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$columns of method Doctrine\\\\DBAL\\\\Platforms\\\\AbstractPlatform\\:\\:getColumnDeclarationListSQL\\(\\) expects list\\, array\\ given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Collection/OneToManyPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Entity\\\\AbstractEntityInheritancePersister\\:\\:getSelectColumnSQL\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Entity/AbstractEntityInheritancePersister.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$joinColumns\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 5\n\t\t\tpath: src/Persisters/Entity/BasicEntityPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$mappedBy\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Entity/BasicEntityPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$targetToSourceKeyColumns\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Entity/BasicEntityPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$joinTable\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 4\n\t\t\tpath: src/Persisters/Entity/BasicEntityPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Call to an undefined method Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:indexBy\\(\\)\\.$#'\n\t\t\tidentifier: method.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Entity/BasicEntityPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Entity\\\\BasicEntityPersister\\:\\:__construct\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Entity/BasicEntityPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Entity\\\\BasicEntityPersister\\:\\:expandToManyParameters\\(\\) return type has no value type specified in iterable type array\\.$#'\n\t\t\tidentifier: missingType.iterableValue\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Entity/BasicEntityPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Entity\\\\BasicEntityPersister\\:\\:extractIdentifierTypes\\(\\) has parameter \\$versionedClass with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Entity/BasicEntityPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Entity\\\\BasicEntityPersister\\:\\:fetchVersionAndNotUpsertableValues\\(\\) has parameter \\$versionedClass with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Entity/BasicEntityPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Entity\\\\BasicEntityPersister\\:\\:generateFilterConditionSQL\\(\\) has parameter \\$targetEntity with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Entity/BasicEntityPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Entity\\\\BasicEntityPersister\\:\\:getClassIdentifiersTypes\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Entity/BasicEntityPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Entity\\\\BasicEntityPersister\\:\\:getClassMetadata\\(\\) return type with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Entity/BasicEntityPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Entity\\\\BasicEntityPersister\\:\\:getSelectColumnAssociationSQL\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Entity/BasicEntityPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Entity\\\\BasicEntityPersister\\:\\:getSelectColumnSQL\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Entity/BasicEntityPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Entity\\\\BasicEntityPersister\\:\\:loadCollectionFromStatement\\(\\) has parameter \\$coll with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Entity/BasicEntityPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Entity\\\\BasicEntityPersister\\:\\:loadManyToManyCollection\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Entity/BasicEntityPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Entity\\\\BasicEntityPersister\\:\\:loadOneToManyCollection\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Entity/BasicEntityPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$association of method Doctrine\\\\ORM\\\\Mapping\\\\QuoteStrategy\\:\\:getJoinTableName\\(\\) expects Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping, Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Entity/BasicEntityPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#2 \\$lockMode of method Doctrine\\\\DBAL\\\\Platforms\\\\AbstractPlatform\\:\\:appendLockHint\\(\\) expects Doctrine\\\\DBAL\\\\LockMode, Doctrine\\\\DBAL\\\\LockMode\\:\\:NONE\\|Doctrine\\\\DBAL\\\\LockMode\\:\\:OPTIMISTIC\\|Doctrine\\\\DBAL\\\\LockMode\\:\\:PESSIMISTIC_READ\\|Doctrine\\\\DBAL\\\\LockMode\\:\\:PESSIMISTIC_WRITE\\|int given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 2\n\t\t\tpath: src/Persisters/Entity/BasicEntityPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#3 \\$hints of method Doctrine\\\\ORM\\\\Internal\\\\Hydration\\\\AbstractHydrator\\:\\:hydrateAll\\(\\) expects array\\, array\\ given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Entity/BasicEntityPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#3 \\$hints of method Doctrine\\\\ORM\\\\Internal\\\\Hydration\\\\AbstractHydrator\\:\\:hydrateAll\\(\\) expects array\\, array\\ given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 4\n\t\t\tpath: src/Persisters/Entity/BasicEntityPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Property Doctrine\\\\ORM\\\\Persisters\\\\Entity\\\\CachedPersisterContext\\:\\:\\$sqlTableAliases \\(array\\\\) does not accept array\\\\.$#'\n\t\t\tidentifier: assign.propertyType\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Entity/BasicEntityPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Strict comparison using \\!\\=\\= between mixed and null will always evaluate to true\\.$#'\n\t\t\tidentifier: notIdentical.alwaysTrue\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Entity/BasicEntityPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Entity\\\\CachedPersisterContext\\:\\:__construct\\(\\) has parameter \\$class with generic interface Doctrine\\\\Persistence\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Entity/CachedPersisterContext.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Entity\\\\EntityPersister\\:\\:getClassMetadata\\(\\) return type with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Entity/EntityPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Entity\\\\EntityPersister\\:\\:loadManyToManyCollection\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Entity/EntityPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Entity\\\\EntityPersister\\:\\:loadOneToManyCollection\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Entity/EntityPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$joinColumns\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 2\n\t\t\tpath: src/Persisters/Entity/JoinedSubclassPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$targetToSourceKeyColumns\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Entity/JoinedSubclassPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Entity\\\\JoinedSubclassPersister\\:\\:fetchVersionAndNotUpsertableValues\\(\\) has parameter \\$versionedClass with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Entity/JoinedSubclassPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Entity\\\\JoinedSubclassPersister\\:\\:getVersionedClassMetadata\\(\\) return type with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Entity/JoinedSubclassPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#2 \\$lockMode of method Doctrine\\\\DBAL\\\\Platforms\\\\AbstractPlatform\\:\\:appendLockHint\\(\\) expects Doctrine\\\\DBAL\\\\LockMode, Doctrine\\\\DBAL\\\\LockMode\\:\\:NONE\\|Doctrine\\\\DBAL\\\\LockMode\\:\\:OPTIMISTIC\\|Doctrine\\\\DBAL\\\\LockMode\\:\\:PESSIMISTIC_READ\\|Doctrine\\\\DBAL\\\\LockMode\\:\\:PESSIMISTIC_WRITE\\|int given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Entity/JoinedSubclassPersister.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$joinColumns\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Entity/SingleTablePersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\Entity\\\\SingleTablePersister\\:\\:generateFilterConditionSQL\\(\\) has parameter \\$targetEntity with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/Entity/SingleTablePersister.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\SqlExpressionVisitor\\:\\:__construct\\(\\) has parameter \\$classMetadata with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/SqlExpressionVisitor.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Persisters\\\\SqlValueVisitor\\:\\:getParamsAndTypes\\(\\) return type has no value type specified in iterable type array\\.$#'\n\t\t\tidentifier: missingType.iterableValue\n\t\t\tcount: 1\n\t\t\tpath: src/Persisters/SqlValueVisitor.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#3 \\$className of static method Doctrine\\\\ORM\\\\Proxy\\\\Autoloader\\:\\:resolveFile\\(\\) expects class\\-string, string given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Proxy/Autoloader.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#3 of closure expects class\\-string, string given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Proxy/Autoloader.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Proxy\\\\DefaultProxyClassNameResolver\\:\\:resolveClassName\\(\\) should return class\\-string\\ but returns class\\-string\\\\>\\|class\\-string\\\\.$#'\n\t\t\tidentifier: return.type\n\t\t\tcount: 1\n\t\t\tpath: src/Proxy/DefaultProxyClassNameResolver.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Proxy\\\\DefaultProxyClassNameResolver\\:\\:resolveClassName\\(\\) should return class\\-string\\ but returns string\\.$#'\n\t\t\tidentifier: return.type\n\t\t\tcount: 1\n\t\t\tpath: src/Proxy/DefaultProxyClassNameResolver.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\Persistence\\\\Mapping\\\\ClassMetadata\\:\\:\\$isEmbeddedClass\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Proxy/ProxyFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\Persistence\\\\Mapping\\\\ClassMetadata\\:\\:\\$isMappedSuperclass\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Proxy/ProxyFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Call to an undefined static method Doctrine\\\\ORM\\\\Proxy\\\\ProxyFactory\\:\\:createLazyGhost\\(\\)\\.$#'\n\t\t\tidentifier: staticMethod.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Proxy/ProxyFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Call to function is_bool\\(\\) with bool will always evaluate to true\\.$#'\n\t\t\tidentifier: function.alreadyNarrowedType\n\t\t\tcount: 1\n\t\t\tpath: src/Proxy/ProxyFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Comparison operation \"\\<\" between 0\\|1\\|2\\|3\\|4 and 0 is always false\\.$#'\n\t\t\tidentifier: smaller.alwaysFalse\n\t\t\tcount: 1\n\t\t\tpath: src/Proxy/ProxyFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Comparison operation \"\\>\" between 0\\|1\\|2\\|3\\|4 and 4 is always false\\.$#'\n\t\t\tidentifier: greater.alwaysFalse\n\t\t\tcount: 1\n\t\t\tpath: src/Proxy/ProxyFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Proxy\\\\ProxyFactory\\:\\:createLazyInitializer\\(\\) has Doctrine\\\\ORM\\\\EntityNotFoundException in PHPDoc @throws tag but it''s not thrown\\.$#'\n\t\t\tidentifier: throws.unusedType\n\t\t\tcount: 1\n\t\t\tpath: src/Proxy/ProxyFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Proxy\\\\ProxyFactory\\:\\:createLazyInitializer\\(\\) has parameter \\$classMetadata with generic interface Doctrine\\\\Persistence\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Proxy/ProxyFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Proxy\\\\ProxyFactory\\:\\:createLazyInitializer\\(\\) return type has no value type specified in iterable type array\\.$#'\n\t\t\tidentifier: missingType.iterableValue\n\t\t\tcount: 1\n\t\t\tpath: src/Proxy/ProxyFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Proxy\\\\ProxyFactory\\:\\:createLazyInitializer\\(\\) return type with generic interface Doctrine\\\\ORM\\\\Proxy\\\\InternalProxy does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Proxy/ProxyFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Proxy\\\\ProxyFactory\\:\\:generateProxyClass\\(\\) has parameter \\$class with generic interface Doctrine\\\\Persistence\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Proxy/ProxyFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Proxy\\\\ProxyFactory\\:\\:generateProxyClasses\\(\\) has parameter \\$classes with generic interface Doctrine\\\\Persistence\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Proxy/ProxyFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Proxy\\\\ProxyFactory\\:\\:generateSerializeImpl\\(\\) has parameter \\$class with generic interface Doctrine\\\\Persistence\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Proxy/ProxyFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Proxy\\\\ProxyFactory\\:\\:generateUseLazyGhostTrait\\(\\) has parameter \\$class with generic interface Doctrine\\\\Persistence\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Proxy/ProxyFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Proxy\\\\ProxyFactory\\:\\:loadProxyClass\\(\\) has parameter \\$class with generic interface Doctrine\\\\Persistence\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Proxy/ProxyFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Proxy\\\\ProxyFactory\\:\\:skipClass\\(\\) has parameter \\$metadata with generic interface Doctrine\\\\Persistence\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Proxy/ProxyFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$class of method Doctrine\\\\ORM\\\\Utility\\\\IdentifierFlattener\\:\\:flattenIdentifier\\(\\) expects Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata, Doctrine\\\\Persistence\\\\Mapping\\\\ClassMetadata given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Proxy/ProxyFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$filename of function filemtime expects string, string\\|false given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Proxy/ProxyFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#3 \\$length of function substr expects int\\|null, int\\|false given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Proxy/ProxyFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#3 \\$newScope of static method Closure\\:\\:bind\\(\\) expects ''static''\\|class\\-string\\|object\\|null, string given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Proxy/ProxyFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Result of \\|\\| is always false\\.$#'\n\t\t\tidentifier: booleanOr.alwaysFalse\n\t\t\tcount: 1\n\t\t\tpath: src/Proxy/ProxyFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Query\\:\\:processParameterMappings\\(\\) return type has no value type specified in iterable type array\\.$#'\n\t\t\tidentifier: missingType.iterableValue\n\t\t\tcount: 1\n\t\t\tpath: src/Query.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$parameters of method Doctrine\\\\ORM\\\\AbstractQuery\\:\\:toIterable\\(\\) expects array\\\\|Doctrine\\\\Common\\\\Collections\\\\ArrayCollection\\, iterable\\<\\(int\\|string\\), mixed\\> given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Query.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#2 \\$sqlParams of method Doctrine\\\\ORM\\\\Query\\:\\:evictResultSetCache\\(\\) expects array\\, list\\ given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Query.php\n\n\t\t-\n\t\t\tmessage: '#^Property Doctrine\\\\ORM\\\\Query\\\\AST\\\\Functions\\\\BitAndFunction\\:\\:\\$firstArithmetic \\(Doctrine\\\\ORM\\\\Query\\\\AST\\\\Node\\) does not accept Doctrine\\\\ORM\\\\Query\\\\AST\\\\Node\\|string\\.$#'\n\t\t\tidentifier: assign.propertyType\n\t\t\tcount: 1\n\t\t\tpath: src/Query/AST/Functions/BitAndFunction.php\n\n\t\t-\n\t\t\tmessage: '#^Property Doctrine\\\\ORM\\\\Query\\\\AST\\\\Functions\\\\BitAndFunction\\:\\:\\$secondArithmetic \\(Doctrine\\\\ORM\\\\Query\\\\AST\\\\Node\\) does not accept Doctrine\\\\ORM\\\\Query\\\\AST\\\\Node\\|string\\.$#'\n\t\t\tidentifier: assign.propertyType\n\t\t\tcount: 1\n\t\t\tpath: src/Query/AST/Functions/BitAndFunction.php\n\n\t\t-\n\t\t\tmessage: '#^Property Doctrine\\\\ORM\\\\Query\\\\AST\\\\Functions\\\\BitOrFunction\\:\\:\\$firstArithmetic \\(Doctrine\\\\ORM\\\\Query\\\\AST\\\\Node\\) does not accept Doctrine\\\\ORM\\\\Query\\\\AST\\\\Node\\|string\\.$#'\n\t\t\tidentifier: assign.propertyType\n\t\t\tcount: 1\n\t\t\tpath: src/Query/AST/Functions/BitOrFunction.php\n\n\t\t-\n\t\t\tmessage: '#^Property Doctrine\\\\ORM\\\\Query\\\\AST\\\\Functions\\\\BitOrFunction\\:\\:\\$secondArithmetic \\(Doctrine\\\\ORM\\\\Query\\\\AST\\\\Node\\) does not accept Doctrine\\\\ORM\\\\Query\\\\AST\\\\Node\\|string\\.$#'\n\t\t\tidentifier: assign.propertyType\n\t\t\tcount: 1\n\t\t\tpath: src/Query/AST/Functions/BitOrFunction.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Query\\\\AST\\\\Node\\:\\:\\$value\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Query/AST/Functions/DateAddFunction.php\n\n\t\t-\n\t\t\tmessage: '#^Property Doctrine\\\\ORM\\\\Query\\\\AST\\\\Functions\\\\DateAddFunction\\:\\:\\$firstDateExpression \\(Doctrine\\\\ORM\\\\Query\\\\AST\\\\Node\\) does not accept Doctrine\\\\ORM\\\\Query\\\\AST\\\\Node\\|string\\.$#'\n\t\t\tidentifier: assign.propertyType\n\t\t\tcount: 1\n\t\t\tpath: src/Query/AST/Functions/DateAddFunction.php\n\n\t\t-\n\t\t\tmessage: '#^Property Doctrine\\\\ORM\\\\Query\\\\AST\\\\Functions\\\\DateAddFunction\\:\\:\\$intervalExpression \\(Doctrine\\\\ORM\\\\Query\\\\AST\\\\Node\\) does not accept Doctrine\\\\ORM\\\\Query\\\\AST\\\\Node\\|string\\.$#'\n\t\t\tidentifier: assign.propertyType\n\t\t\tcount: 1\n\t\t\tpath: src/Query/AST/Functions/DateAddFunction.php\n\n\t\t-\n\t\t\tmessage: '#^Property Doctrine\\\\ORM\\\\Query\\\\AST\\\\Functions\\\\DateDiffFunction\\:\\:\\$date1 \\(Doctrine\\\\ORM\\\\Query\\\\AST\\\\Node\\) does not accept Doctrine\\\\ORM\\\\Query\\\\AST\\\\Node\\|string\\.$#'\n\t\t\tidentifier: assign.propertyType\n\t\t\tcount: 1\n\t\t\tpath: src/Query/AST/Functions/DateDiffFunction.php\n\n\t\t-\n\t\t\tmessage: '#^Property Doctrine\\\\ORM\\\\Query\\\\AST\\\\Functions\\\\DateDiffFunction\\:\\:\\$date2 \\(Doctrine\\\\ORM\\\\Query\\\\AST\\\\Node\\) does not accept Doctrine\\\\ORM\\\\Query\\\\AST\\\\Node\\|string\\.$#'\n\t\t\tidentifier: assign.propertyType\n\t\t\tcount: 1\n\t\t\tpath: src/Query/AST/Functions/DateDiffFunction.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Query\\\\AST\\\\Node\\:\\:\\$value\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Query/AST/Functions/DateSubFunction.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$joinColumns\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 2\n\t\t\tpath: src/Query/AST/Functions/IdentityFunction.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$joinColumn of method Doctrine\\\\ORM\\\\Mapping\\\\QuoteStrategy\\:\\:getJoinColumnName\\(\\) expects Doctrine\\\\ORM\\\\Mapping\\\\JoinColumnMapping, Doctrine\\\\ORM\\\\Mapping\\\\JoinColumnMapping\\|false given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Query/AST/Functions/IdentityFunction.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$simpleArithmeticExpr of method Doctrine\\\\ORM\\\\Query\\\\SqlWalker\\:\\:walkSimpleArithmeticExpression\\(\\) expects Doctrine\\\\ORM\\\\Query\\\\AST\\\\Node\\|string, Doctrine\\\\ORM\\\\Query\\\\AST\\\\Node\\|string\\|true given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Query/AST/Functions/LocateFunction.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$mappedBy\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Query/AST/Functions/SizeFunction.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$targetToSourceKeyColumns\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Query/AST/Functions/SizeFunction.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$joinTable\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Query/AST/Functions/SizeFunction.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$association of method Doctrine\\\\ORM\\\\Mapping\\\\QuoteStrategy\\:\\:getJoinTableName\\(\\) expects Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping, Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Query/AST/Functions/SizeFunction.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#2 \\$mode of method Doctrine\\\\DBAL\\\\Platforms\\\\AbstractPlatform\\:\\:getTrimExpression\\(\\) expects Doctrine\\\\DBAL\\\\Platforms\\\\TrimMode, Doctrine\\\\DBAL\\\\Platforms\\\\TrimMode\\:\\:BOTH\\|Doctrine\\\\DBAL\\\\Platforms\\\\TrimMode\\:\\:LEADING\\|Doctrine\\\\DBAL\\\\Platforms\\\\TrimMode\\:\\:TRAILING\\|Doctrine\\\\DBAL\\\\Platforms\\\\TrimMode\\:\\:UNSPECIFIED\\|int given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 2\n\t\t\tpath: src/Query/AST/Functions/TrimFunction.php\n\n\t\t-\n\t\t\tmessage: '#^Call to an undefined method Doctrine\\\\ORM\\\\Query\\\\SqlWalker\\:\\:walkJoinPathExpression\\(\\)\\.$#'\n\t\t\tidentifier: method.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Query/AST/JoinClassPathExpression.php\n\n\t\t-\n\t\t\tmessage: '#^Call to an undefined method Doctrine\\\\ORM\\\\Query\\\\SqlWalker\\:\\:walkJoinVariableDeclaration\\(\\)\\.$#'\n\t\t\tidentifier: method.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Query/AST/JoinVariableDeclaration.php\n\n\t\t-\n\t\t\tmessage: '#^Call to an undefined method Doctrine\\\\ORM\\\\Query\\\\SqlWalker\\:\\:walkWhenClauseExpression\\(\\)\\.$#'\n\t\t\tidentifier: method.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Query/AST/SimpleWhenClause.php\n\n\t\t-\n\t\t\tmessage: '#^Call to an undefined method Doctrine\\\\ORM\\\\Query\\\\SqlWalker\\:\\:walkWhenClauseExpression\\(\\)\\.$#'\n\t\t\tidentifier: method.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Query/AST/WhenClause.php\n\n\t\t-\n\t\t\tmessage: '#^Argument of an invalid type list\\\\|string supplied for foreach, only iterables are supported\\.$#'\n\t\t\tidentifier: foreach.nonIterable\n\t\t\tcount: 1\n\t\t\tpath: src/Query/Exec/MultiTableDeleteExecutor.php\n\n\t\t-\n\t\t\tmessage: '#^Cannot assign new offset to list\\\\|string\\.$#'\n\t\t\tidentifier: offsetAssign.dimType\n\t\t\tcount: 1\n\t\t\tpath: src/Query/Exec/MultiTableDeleteExecutor.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Query\\\\Exec\\\\MultiTableDeleteExecutor\\:\\:execute\\(\\) should return int but returns int\\|string\\.$#'\n\t\t\tidentifier: return.type\n\t\t\tcount: 1\n\t\t\tpath: src/Query/Exec/MultiTableDeleteExecutor.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$columns of method Doctrine\\\\DBAL\\\\Platforms\\\\AbstractPlatform\\:\\:getColumnDeclarationListSQL\\(\\) expects list\\, array\\ given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Query/Exec/MultiTableDeleteExecutor.php\n\n\t\t-\n\t\t\tmessage: '#^Argument of an invalid type list\\\\|string supplied for foreach, only iterables are supported\\.$#'\n\t\t\tidentifier: foreach.nonIterable\n\t\t\tcount: 1\n\t\t\tpath: src/Query/Exec/MultiTableUpdateExecutor.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Query\\\\Exec\\\\MultiTableUpdateExecutor\\:\\:execute\\(\\) should return int but returns int\\|string\\.$#'\n\t\t\tidentifier: return.type\n\t\t\tcount: 1\n\t\t\tpath: src/Query/Exec/MultiTableUpdateExecutor.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$columns of method Doctrine\\\\DBAL\\\\Platforms\\\\AbstractPlatform\\:\\:getColumnDeclarationListSQL\\(\\) expects list\\, array\\ given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Query/Exec/MultiTableUpdateExecutor.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#3 \\$types of method Doctrine\\\\DBAL\\\\Connection\\:\\:executeStatement\\(\\) expects array\\\\|string, Doctrine\\\\DBAL\\\\ArrayParameterType\\|Doctrine\\\\DBAL\\\\ParameterType\\|Doctrine\\\\DBAL\\\\Types\\\\Type\\|string\\>, list\\ given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Query/Exec/MultiTableUpdateExecutor.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$sql of method Doctrine\\\\DBAL\\\\Connection\\:\\:executeQuery\\(\\) expects string, list\\\\|string given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Query/Exec/SingleSelectExecutor.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Query\\\\Exec\\\\SingleTableDeleteUpdateExecutor\\:\\:execute\\(\\) should return int but returns int\\|string\\.$#'\n\t\t\tidentifier: return.type\n\t\t\tcount: 1\n\t\t\tpath: src/Query/Exec/SingleTableDeleteUpdateExecutor.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$sql of method Doctrine\\\\DBAL\\\\Connection\\:\\:executeStatement\\(\\) expects string, list\\\\|string given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Query/Exec/SingleTableDeleteUpdateExecutor.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Query\\\\Expr\\\\Func\\:\\:getArguments\\(\\) should return list\\ but returns array\\\\.$#'\n\t\t\tidentifier: return.type\n\t\t\tcount: 1\n\t\t\tpath: src/Query/Expr/Func.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Query\\\\ParameterTypeInferer\\:\\:inferType\\(\\) never returns int so it can be removed from the return type\\.$#'\n\t\t\tidentifier: return.unusedType\n\t\t\tcount: 1\n\t\t\tpath: src/Query/ParameterTypeInferer.php\n\n\t\t-\n\t\t\tmessage: '#^@readonly property cannot have a default value\\.$#'\n\t\t\tidentifier: property.readOnlyByPhpDocDefaultValue\n\t\t\tcount: 3\n\t\t\tpath: src/Query/Parser.php\n\n\t\t-\n\t\t\tmessage: '#^Call to an undefined method object\\:\\:parse\\(\\)\\.$#'\n\t\t\tidentifier: method.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Query/Parser.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Query\\\\Parser\\:\\:CustomFunctionsReturningStrings\\(\\) should return Doctrine\\\\ORM\\\\Query\\\\AST\\\\Functions\\\\FunctionNode but returns object\\.$#'\n\t\t\tidentifier: return.type\n\t\t\tcount: 1\n\t\t\tpath: src/Query/Parser.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Query\\\\Parser\\:\\:getMetadataForDqlAlias\\(\\) return type with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Query/Parser.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$AST of method Doctrine\\\\ORM\\\\Query\\\\Parser\\:\\:processDeferredNewObjectExpressions\\(\\) expects Doctrine\\\\ORM\\\\Query\\\\AST\\\\SelectStatement, Doctrine\\\\ORM\\\\Query\\\\AST\\\\DeleteStatement\\|Doctrine\\\\ORM\\\\Query\\\\AST\\\\SelectStatement\\|Doctrine\\\\ORM\\\\Query\\\\AST\\\\UpdateStatement given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Query/Parser.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$expected of method Doctrine\\\\ORM\\\\Query\\\\Parser\\:\\:syntaxError\\(\\) expects string, int\\|string given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 3\n\t\t\tpath: src/Query/Parser.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$expression of class Doctrine\\\\ORM\\\\Query\\\\AST\\\\ParenthesisExpression constructor expects Doctrine\\\\ORM\\\\Query\\\\AST\\\\Node, Doctrine\\\\ORM\\\\Query\\\\AST\\\\Node\\|string given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Query/Parser.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#2 \\$stringPattern of class Doctrine\\\\ORM\\\\Query\\\\AST\\\\LikeExpression constructor expects Doctrine\\\\ORM\\\\Query\\\\AST\\\\Functions\\\\FunctionNode\\|Doctrine\\\\ORM\\\\Query\\\\AST\\\\InputParameter\\|Doctrine\\\\ORM\\\\Query\\\\AST\\\\Literal\\|Doctrine\\\\ORM\\\\Query\\\\AST\\\\PathExpression, Doctrine\\\\ORM\\\\Query\\\\AST\\\\Node given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Query/Parser.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#3 \\$length of function substr expects int\\|null, int\\|false given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Query/Parser.php\n\n\t\t-\n\t\t\tmessage: '#^Strict comparison using \\=\\=\\= between 102 and 102 will always evaluate to true\\.$#'\n\t\t\tidentifier: identical.alwaysTrue\n\t\t\tcount: 1\n\t\t\tpath: src/Query/Parser.php\n\n\t\t-\n\t\t\tmessage: '#^Unreachable statement \\- code above always terminates\\.$#'\n\t\t\tidentifier: deadCode.unreachable\n\t\t\tcount: 2\n\t\t\tpath: src/Query/Parser.php\n\n\t\t-\n\t\t\tmessage: '#^Using nullsafe property access \"\\?\\-\\>position\" on left side of \\?\\? is unnecessary\\. Use \\-\\> instead\\.$#'\n\t\t\tidentifier: nullsafe.neverNull\n\t\t\tcount: 1\n\t\t\tpath: src/Query/Parser.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$joinColumns\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 2\n\t\t\tpath: src/Query/ResultSetMappingBuilder.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Query\\\\ResultSetMappingBuilder\\:\\:isInheritanceSupported\\(\\) has parameter \\$classMetadata with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Query/ResultSetMappingBuilder.php\n\n\t\t-\n\t\t\tmessage: '#^Instanceof between Doctrine\\\\ORM\\\\Query\\\\AST\\\\DeleteStatement and Doctrine\\\\ORM\\\\Query\\\\AST\\\\DeleteStatement will always evaluate to true\\.$#'\n\t\t\tidentifier: instanceof.alwaysTrue\n\t\t\tcount: 1\n\t\t\tpath: src/Query/SqlOutputWalker.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$joinColumns\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 2\n\t\t\tpath: src/Query/SqlWalker.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$mappedBy\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Query/SqlWalker.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$sourceToTargetKeyColumns\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 2\n\t\t\tpath: src/Query/SqlWalker.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$targetToSourceKeyColumns\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 3\n\t\t\tpath: src/Query/SqlWalker.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$joinColumns\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Query/SqlWalker.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$joinTable\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 6\n\t\t\tpath: src/Query/SqlWalker.php\n\n\t\t-\n\t\t\tmessage: '#^Cannot assign new offset to list\\\\|string\\.$#'\n\t\t\tidentifier: offsetAssign.dimType\n\t\t\tcount: 2\n\t\t\tpath: src/Query/SqlWalker.php\n\n\t\t-\n\t\t\tmessage: '#^Match arm comparison between 3 and 3 is always true\\.$#'\n\t\t\tidentifier: match.alwaysTrue\n\t\t\tcount: 1\n\t\t\tpath: src/Query/SqlWalker.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Query\\\\SqlWalker\\:\\:generateClassTableInheritanceJoins\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Query/SqlWalker.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Query\\\\SqlWalker\\:\\:generateFilterConditionSQL\\(\\) has parameter \\$targetEntity with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Query/SqlWalker.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Query\\\\SqlWalker\\:\\:getChildDiscriminatorsFromClassMetadata\\(\\) has parameter \\$rootClass with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Query/SqlWalker.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Query\\\\SqlWalker\\:\\:getMetadataForDqlAlias\\(\\) return type with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Query/SqlWalker.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$association of method Doctrine\\\\ORM\\\\Mapping\\\\QuoteStrategy\\:\\:getJoinTableName\\(\\) expects Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping, Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 2\n\t\t\tpath: src/Query/SqlWalker.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$condTerm of method Doctrine\\\\ORM\\\\Query\\\\SqlWalker\\:\\:walkConditionalTerm\\(\\) expects Doctrine\\\\ORM\\\\Query\\\\AST\\\\ConditionalFactor\\|Doctrine\\\\ORM\\\\Query\\\\AST\\\\ConditionalPrimary\\|Doctrine\\\\ORM\\\\Query\\\\AST\\\\ConditionalTerm, Doctrine\\\\ORM\\\\Query\\\\AST\\\\Phase2OptimizableConditional given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Query/SqlWalker.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$identVariable of method Doctrine\\\\ORM\\\\Query\\\\SqlWalker\\:\\:walkEntityIdentificationVariable\\(\\) expects string, Doctrine\\\\ORM\\\\Query\\\\AST\\\\Node\\|string given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Query/SqlWalker.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#2 \\$fieldName of method Doctrine\\\\ORM\\\\Query\\\\ResultSetMapping\\:\\:addIndexBy\\(\\) expects string, string\\|false given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Query/SqlWalker.php\n\n\t\t-\n\t\t\tmessage: '#^Property Doctrine\\\\ORM\\\\Query\\\\SqlWalker\\:\\:\\$selectedClasses with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Query/SqlWalker.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Query\\\\TreeWalkerAdapter\\:\\:getMetadataForDqlAlias\\(\\) return type with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Query/TreeWalkerAdapter.php\n\n\t\t-\n\t\t\tmessage: '#^Argument of an invalid type array\\\\|object\\|string\\>\\|object\\|string\\|false supplied for foreach, only iterables are supported\\.$#'\n\t\t\tidentifier: foreach.nonIterable\n\t\t\tcount: 1\n\t\t\tpath: src/QueryBuilder.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\QueryBuilder\\:\\:getParameter\\(\\) should return Doctrine\\\\ORM\\\\Query\\\\Parameter\\|null but returns Doctrine\\\\ORM\\\\Query\\\\Parameter\\|false\\|null\\.$#'\n\t\t\tidentifier: return.type\n\t\t\tcount: 1\n\t\t\tpath: src/QueryBuilder.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#2 \\$dqlPart of method Doctrine\\\\ORM\\\\QueryBuilder\\:\\:add\\(\\) expects array\\<''join''\\|int\\<0, max\\>, array\\\\|string\\>\\|object\\|string, array\\{Doctrine\\\\ORM\\\\Query\\\\Expr\\\\Andx\\|Doctrine\\\\ORM\\\\Query\\\\Expr\\\\Orx\\}\\|Doctrine\\\\ORM\\\\Query\\\\Expr\\\\Andx given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/QueryBuilder.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#2 \\$dqlPart of method Doctrine\\\\ORM\\\\QueryBuilder\\:\\:add\\(\\) expects array\\<''join''\\|int\\<0, max\\>, array\\\\|string\\>\\|object\\|string, array\\{Doctrine\\\\ORM\\\\Query\\\\Expr\\\\Composite\\}\\|Doctrine\\\\ORM\\\\Query\\\\Expr\\\\Andx given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/QueryBuilder.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#2 \\$dqlPart of method Doctrine\\\\ORM\\\\QueryBuilder\\:\\:add\\(\\) expects array\\<''join''\\|int\\<0, max\\>, array\\\\|string\\>\\|object\\|string, non\\-empty\\-array\\ given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 2\n\t\t\tpath: src/QueryBuilder.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#3 \\$length of function substr expects int\\|null, int\\|false given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 2\n\t\t\tpath: src/QueryBuilder.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Repository\\\\DefaultRepositoryFactory\\:\\:createRepository\\(\\) return type with generic class Doctrine\\\\ORM\\\\EntityRepository does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Repository/DefaultRepositoryFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Property Doctrine\\\\ORM\\\\Repository\\\\DefaultRepositoryFactory\\:\\:\\$repositoryList with generic class Doctrine\\\\ORM\\\\EntityRepository does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Repository/DefaultRepositoryFactory.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\Persistence\\\\Mapping\\\\ClassMetadata\\:\\:\\$name\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/Console/Command/GenerateProxiesCommand.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$filename of function file_exists expects string, string\\|false given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/Console/Command/GenerateProxiesCommand.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$filename of function is_writable expects string, string\\|false given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/Console/Command/GenerateProxiesCommand.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Tools\\\\Console\\\\Command\\\\MappingDescribeCommand\\:\\:getClassMetadata\\(\\) return type with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/Console/Command/MappingDescribeCommand.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$entityListeners of method Doctrine\\\\ORM\\\\Tools\\\\Console\\\\Command\\\\MappingDescribeCommand\\:\\:formatEntityListeners\\(\\) expects list\\, array\\\\> given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/Console/Command/MappingDescribeCommand.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#2 \\$callback of function array_filter expects \\(callable\\(class\\-string\\)\\: bool\\)\\|null, Closure\\(mixed\\)\\: \\(0\\|1\\|false\\) given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/Console/Command/MappingDescribeCommand.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$classes of method Doctrine\\\\ORM\\\\Tools\\\\SchemaTool\\:\\:createSchema\\(\\) expects list\\, array\\ given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/Console/Command/SchemaTool/CreateCommand.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$classes of method Doctrine\\\\ORM\\\\Tools\\\\SchemaTool\\:\\:getCreateSchemaSql\\(\\) expects list\\, array\\ given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/Console/Command/SchemaTool/CreateCommand.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$classes of method Doctrine\\\\ORM\\\\Tools\\\\SchemaTool\\:\\:dropSchema\\(\\) expects list\\, array\\ given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/Console/Command/SchemaTool/DropCommand.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$classes of method Doctrine\\\\ORM\\\\Tools\\\\SchemaTool\\:\\:getDropSchemaSQL\\(\\) expects list\\, array\\ given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 2\n\t\t\tpath: src/Tools/Console/Command/SchemaTool/DropCommand.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$classes of method Doctrine\\\\ORM\\\\Tools\\\\SchemaTool\\:\\:getUpdateSchemaSql\\(\\) expects list\\, array\\ given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/Console/Command/SchemaTool/UpdateCommand.php\n\n\t\t-\n\t\t\tmessage: '#^Class Doctrine\\\\ORM\\\\Tools\\\\Console\\\\MetadataFilter extends generic class FilterIterator but does not specify its types\\: TKey, TValue, TIterator$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/Console/MetadataFilter.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Tools\\\\Console\\\\MetadataFilter\\:\\:__construct\\(\\) has parameter \\$metadata with generic class ArrayIterator but does not specify its types\\: TKey, TValue$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/Console/MetadataFilter.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Tools\\\\Console\\\\MetadataFilter\\:\\:filter\\(\\) has parameter \\$metadatas with generic interface Doctrine\\\\Persistence\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/Console/MetadataFilter.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Tools\\\\Console\\\\MetadataFilter\\:\\:filter\\(\\) return type with generic interface Doctrine\\\\Persistence\\\\Mapping\\\\ClassMetadata does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/Console/MetadataFilter.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Tools\\\\Console\\\\MetadataFilter\\:\\:getInnerIterator\\(\\) return type with generic interface Doctrine\\\\Persistence\\\\Mapping\\\\ClassMetadata does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/Console/MetadataFilter.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$string of function html_entity_decode expects string, string\\|false given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/Debug.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$stream of function fclose expects resource, resource\\|false given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/DebugUnitOfWorkListener.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$stream of function fwrite expects resource, resource\\|false given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 14\n\t\t\tpath: src/Tools/DebugUnitOfWorkListener.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Tools\\\\Event\\\\GenerateSchemaTableEventArgs\\:\\:__construct\\(\\) has parameter \\$classMetadata with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/Event/GenerateSchemaTableEventArgs.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Tools\\\\Event\\\\GenerateSchemaTableEventArgs\\:\\:getClassMetadata\\(\\) return type with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/Event/GenerateSchemaTableEventArgs.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$joinColumns\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/Pagination/CountOutputWalker.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$joinColumns\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/Pagination/LimitSubqueryOutputWalker.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Tools\\\\Pagination\\\\LimitSubqueryOutputWalker\\:\\:walkSelectStatement\\(\\) should return string but returns list\\\\|string\\.$#'\n\t\t\tidentifier: return.type\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/Pagination/LimitSubqueryOutputWalker.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#3 \\$length of function substr expects int\\|null, int\\|false given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/Pagination/LimitSubqueryOutputWalker.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Tools\\\\Pagination\\\\Paginator\\:\\:count\\(\\) should return int\\<0, max\\> but returns int\\.$#'\n\t\t\tidentifier: return.type\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/Pagination/Paginator.php\n\n\t\t-\n\t\t\tmessage: '#^PHPDoc tag @var for variable \\$parameters contains generic interface Doctrine\\\\Common\\\\Collections\\\\Collection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/Pagination/Paginator.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$parameters of method Doctrine\\\\ORM\\\\AbstractQuery\\:\\:setParameters\\(\\) expects array\\\\|Doctrine\\\\Common\\\\Collections\\\\ArrayCollection\\, Doctrine\\\\Common\\\\Collections\\\\Collection&iterable\\ given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/Pagination/Paginator.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Tools\\\\ResolveTargetEntityListener\\:\\:remapAssociation\\(\\) has parameter \\$classMetadata with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/ResolveTargetEntityListener.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$joinColumns\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 3\n\t\t\tpath: src/Tools/SchemaTool.php\n\n\t\t-\n\t\t\tmessage: '''\n\t\t\t\t#^Call to deprecated method getColumns\\(\\) of class Doctrine\\\\DBAL\\\\Schema\\\\Index\\:\n\t\t\t\tUse \\{@see getIndexedColumns\\(\\)\\} instead\\.$#\n\t\t\t'''\n\t\t\tidentifier: method.deprecated\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/SchemaTool.php\n\n\t\t-\n\t\t\tmessage: '''\n\t\t\t\t#^Call to deprecated method getForeignColumns\\(\\) of class Doctrine\\\\DBAL\\\\Schema\\\\ForeignKeyConstraint\\:\n\t\t\t\tUse \\{@see getReferencedColumnNames\\(\\)\\} instead\\.\n\n\t\t\t\tReturns the names of the referenced table columns\n\t\t\t\tthe foreign key constraint is associated with\\.$#\n\t\t\t'''\n\t\t\tidentifier: method.deprecated\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/SchemaTool.php\n\n\t\t-\n\t\t\tmessage: '''\n\t\t\t\t#^Call to deprecated method getForeignTableName\\(\\) of class Doctrine\\\\DBAL\\\\Schema\\\\ForeignKeyConstraint\\:\n\t\t\t\tUse \\{@see getReferencedTableName\\(\\)\\} instead\\.\n\n\t\t\t\tReturns the name of the referenced table\n\t\t\t\tthe foreign key constraint is associated with\\.$#\n\t\t\t'''\n\t\t\tidentifier: method.deprecated\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/SchemaTool.php\n\n\t\t-\n\t\t\tmessage: '''\n\t\t\t\t#^Call to deprecated method getLocalColumns\\(\\) of class Doctrine\\\\DBAL\\\\Schema\\\\ForeignKeyConstraint\\:\n\t\t\t\tUse \\{@see getReferencingColumnNames\\(\\)\\} instead\\.$#\n\t\t\t'''\n\t\t\tidentifier: method.deprecated\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/SchemaTool.php\n\n\t\t-\n\t\t\tmessage: '''\n\t\t\t\t#^Call to deprecated method getPrimaryKey\\(\\) of class Doctrine\\\\DBAL\\\\Schema\\\\Table\\:\n\t\t\t\tUse \\{@see getPrimaryKeyConstraint\\(\\)\\} instead\\.$#\n\t\t\t'''\n\t\t\tidentifier: method.deprecated\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/SchemaTool.php\n\n\t\t-\n\t\t\tmessage: '''\n\t\t\t\t#^Call to deprecated method removeForeignKey\\(\\) of class Doctrine\\\\DBAL\\\\Schema\\\\Table\\:\n\t\t\t\tUse \\{@link dropForeignKey\\(\\)\\} instead\\.$#\n\t\t\t'''\n\t\t\tidentifier: method.deprecated\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/SchemaTool.php\n\n\t\t-\n\t\t\tmessage: '''\n\t\t\t\t#^Call to deprecated method setPrimaryKey\\(\\) of class Doctrine\\\\DBAL\\\\Schema\\\\Table\\:\n\t\t\t\tUse \\{@see addPrimaryKeyConstraint\\(\\)\\} instead\\.$#\n\t\t\t'''\n\t\t\tidentifier: method.deprecated\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/SchemaTool.php\n\n\t\t-\n\t\t\tmessage: '#^Call to function is_numeric\\(\\) with int\\<0, max\\> will always evaluate to true\\.$#'\n\t\t\tidentifier: function.alreadyNarrowedType\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/SchemaTool.php\n\n\t\t-\n\t\t\tmessage: '#^Call to function method_exists\\(\\) with ''Doctrine\\\\\\\\DBAL\\\\\\\\Schema\\\\\\\\Index'' and ''getIndexedColumns'' will always evaluate to true\\.$#'\n\t\t\tidentifier: function.alreadyNarrowedType\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/SchemaTool.php\n\n\t\t-\n\t\t\tmessage: '#^Call to function method_exists\\(\\) with Doctrine\\\\DBAL\\\\Schema\\\\Table and ''getPrimaryKeyConstr…'' will always evaluate to true\\.$#'\n\t\t\tidentifier: function.alreadyNarrowedType\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/SchemaTool.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Tools\\\\SchemaTool\\:\\:addDiscriminatorColumnDefinition\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/SchemaTool.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Tools\\\\SchemaTool\\:\\:createSchema\\(\\) has parameter \\$classes with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/SchemaTool.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Tools\\\\SchemaTool\\:\\:dropSchema\\(\\) has parameter \\$classes with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/SchemaTool.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Tools\\\\SchemaTool\\:\\:gatherColumn\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/SchemaTool.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Tools\\\\SchemaTool\\:\\:gatherColumns\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/SchemaTool.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Tools\\\\SchemaTool\\:\\:gatherRelationJoinColumns\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/SchemaTool.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Tools\\\\SchemaTool\\:\\:gatherRelationsSql\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/SchemaTool.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Tools\\\\SchemaTool\\:\\:getAssetName\\(\\) has parameter \\$asset with generic class Doctrine\\\\DBAL\\\\Schema\\\\AbstractAsset but does not specify its types\\: N$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/SchemaTool.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Tools\\\\SchemaTool\\:\\:getCreateSchemaSql\\(\\) has parameter \\$classes with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/SchemaTool.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Tools\\\\SchemaTool\\:\\:getDefiningClass\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/SchemaTool.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Tools\\\\SchemaTool\\:\\:getDefiningClass\\(\\) return type with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/SchemaTool.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Tools\\\\SchemaTool\\:\\:getDropSchemaSQL\\(\\) has parameter \\$classes with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/SchemaTool.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Tools\\\\SchemaTool\\:\\:getIndexColumns\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/SchemaTool.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Tools\\\\SchemaTool\\:\\:getSchemaFromMetadata\\(\\) has parameter \\$classes with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/SchemaTool.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Tools\\\\SchemaTool\\:\\:getUpdateSchemaSql\\(\\) has parameter \\$classes with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/SchemaTool.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Tools\\\\SchemaTool\\:\\:processingNotRequired\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/SchemaTool.php\n\n\t\t-\n\t\t\tmessage: '#^Negated boolean expression is always false\\.$#'\n\t\t\tidentifier: booleanNot.alwaysFalse\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/SchemaTool.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$classes of method Doctrine\\\\ORM\\\\Tools\\\\SchemaTool\\:\\:getUpdateSchemaSql\\(\\) expects list\\, array\\ given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/SchemaTool.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$columnNames of method Doctrine\\\\DBAL\\\\Schema\\\\Table\\:\\:addIndex\\(\\) expects non\\-empty\\-list\\, list\\ given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/SchemaTool.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#1 \\$columnNames of method Doctrine\\\\DBAL\\\\Schema\\\\Table\\:\\:addUniqueIndex\\(\\) expects non\\-empty\\-list\\, array\\ given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/SchemaTool.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#2 \\$columns of class Doctrine\\\\DBAL\\\\Schema\\\\Index constructor expects non\\-empty\\-list\\, list\\ given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/SchemaTool.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#2 \\$localColumnNames of method Doctrine\\\\DBAL\\\\Schema\\\\Table\\:\\:addForeignKeyConstraint\\(\\) expects non\\-empty\\-list\\, list\\ given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/SchemaTool.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#2 \\$primaryKeyColumns of method Doctrine\\\\ORM\\\\Tools\\\\SchemaTool\\:\\:addPrimaryKeyConstraint\\(\\) expects non\\-empty\\-array\\, list\\ given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 2\n\t\t\tpath: src/Tools/SchemaTool.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#2 \\$primaryKeyColumns of method Doctrine\\\\ORM\\\\Tools\\\\SchemaTool\\:\\:addPrimaryKeyConstraint\\(\\) expects non\\-empty\\-array\\, non\\-empty\\-list\\ given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/SchemaTool.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#3 \\$foreignColumnNames of method Doctrine\\\\DBAL\\\\Schema\\\\Table\\:\\:addForeignKeyConstraint\\(\\) expects non\\-empty\\-list\\, list\\ given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/SchemaTool.php\n\n\t\t-\n\t\t\tmessage: '#^Property Doctrine\\\\ORM\\\\Tools\\\\SchemaTool\\:\\:\\$schemaManager with generic class Doctrine\\\\DBAL\\\\Schema\\\\AbstractSchemaManager does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/SchemaTool.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$inversedBy\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 2\n\t\t\tpath: src/Tools/SchemaValidator.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$joinColumns\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/SchemaValidator.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$joinTable\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 6\n\t\t\tpath: src/Tools/SchemaValidator.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$mappedBy\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 9\n\t\t\tpath: src/Tools/SchemaValidator.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$relationToSourceKeyColumns\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/SchemaValidator.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$relationToTargetKeyColumns\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/SchemaValidator.php\n\n\t\t-\n\t\t\tmessage: '#^Call to an undefined method Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:orderBy\\(\\)\\.$#'\n\t\t\tidentifier: method.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/SchemaValidator.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Tools\\\\SchemaValidator\\:\\:validateClass\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/SchemaValidator.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Tools\\\\SchemaValidator\\:\\:validatePropertiesTypes\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Tools/SchemaValidator.php\n\n\t\t-\n\t\t\tmessage: '#^ Parameter \\#3 \\$changeSet of class Doctrine\\\\ORM\\\\Event\\\\PreUpdateEventArgs constructor is passed by reference, so it expects variables only$#'\n\t\t\tidentifier: argument.byRef\n\t\t\tcount: 1\n\t\t\tpath: src/UnitOfWork.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\AssociationMapping\\:\\:\\$joinColumns\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/UnitOfWork.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$inversedBy\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/UnitOfWork.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$joinColumns\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 3\n\t\t\tpath: src/UnitOfWork.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$mappedBy\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 3\n\t\t\tpath: src/UnitOfWork.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$targetToSourceKeyColumns\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/UnitOfWork.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\UnitOfWork\\:\\:convertSingleFieldIdentifierToPHPValue\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/UnitOfWork.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\UnitOfWork\\:\\:eagerLoadCollections\\(\\) has parameter \\$collections with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/UnitOfWork.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\UnitOfWork\\:\\:getEntityChangeSet\\(\\) return type with generic class Doctrine\\\\ORM\\\\PersistentCollection does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/UnitOfWork.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\UnitOfWork\\:\\:hasMissingIdsWhichAreForeignKeys\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/UnitOfWork.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\UnitOfWork\\:\\:isCollectionScheduledForDeletion\\(\\) has parameter \\$coll with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/UnitOfWork.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\UnitOfWork\\:\\:loadCollection\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/UnitOfWork.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\UnitOfWork\\:\\:normalizeIdentifier\\(\\) has parameter \\$targetClass with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/UnitOfWork.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\UnitOfWork\\:\\:scheduleCollectionDeletion\\(\\) has parameter \\$coll with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/UnitOfWork.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\UnitOfWork\\:\\:scheduleCollectionForBatchLoading\\(\\) has parameter \\$collection with generic class Doctrine\\\\ORM\\\\PersistentCollection but does not specify its types\\: TKey, T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/UnitOfWork.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\UnitOfWork\\:\\:scheduleCollectionForBatchLoading\\(\\) has parameter \\$sourceClass with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/UnitOfWork.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#2 \\$assoc of method Doctrine\\\\ORM\\\\PersistentCollection\\<\\(int\\|string\\),mixed\\>\\:\\:setOwner\\(\\) expects Doctrine\\\\ORM\\\\Mapping\\\\AssociationMapping&Doctrine\\\\ORM\\\\Mapping\\\\ToManyAssociationMapping, Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 4\n\t\t\tpath: src/UnitOfWork.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#2 \\$assoc of method Doctrine\\\\ORM\\\\PersistentCollection\\<\\*NEVER\\*,\\*NEVER\\*\\>\\:\\:setOwner\\(\\) expects Doctrine\\\\ORM\\\\Mapping\\\\AssociationMapping&Doctrine\\\\ORM\\\\Mapping\\\\ToManyAssociationMapping, Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/UnitOfWork.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#2 \\$length of function array_chunk expects int\\<1, max\\>, int given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 2\n\t\t\tpath: src/UnitOfWork.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#3 \\$collection of class Doctrine\\\\ORM\\\\PersistentCollection constructor expects Doctrine\\\\Common\\\\Collections\\\\Collection\\<\\(int\\|string\\), mixed\\>&Doctrine\\\\Common\\\\Collections\\\\Selectable\\<\\(int\\|string\\), mixed\\>, Doctrine\\\\Common\\\\Collections\\\\Collection given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/UnitOfWork.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter \\#5 \\$invoke of method Doctrine\\\\ORM\\\\Event\\\\ListenersInvoker\\:\\:invoke\\(\\) expects int\\<0, 7\\>, int\\\\|int\\<1, max\\> given\\.$#'\n\t\t\tidentifier: argument.type\n\t\t\tcount: 1\n\t\t\tpath: src/UnitOfWork.php\n\n\t\t-\n\t\t\tmessage: '#^Parameter &\\$visited by\\-ref type of method Doctrine\\\\ORM\\\\UnitOfWork\\:\\:cascadeDetach\\(\\) expects array\\, array\\ given\\.$#'\n\t\t\tidentifier: parameterByRef.type\n\t\t\tcount: 2\n\t\t\tpath: src/UnitOfWork.php\n\n\t\t-\n\t\t\tmessage: '#^Property Doctrine\\\\ORM\\\\UnitOfWork\\:\\:\\$entityChangeSets \\(array\\\\>\\) does not accept non\\-empty\\-array\\\\>\\.$#'\n\t\t\tidentifier: assign.propertyType\n\t\t\tcount: 1\n\t\t\tpath: src/UnitOfWork.php\n\n\t\t-\n\t\t\tmessage: '#^Unable to resolve the template type T in call to method static method Symfony\\\\Component\\\\VarExporter\\\\Hydrator\\:\\:hydrate\\(\\)$#'\n\t\t\tidentifier: argument.templateType\n\t\t\tcount: 1\n\t\t\tpath: src/UnitOfWork.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\Persistence\\\\Mapping\\\\ClassMetadata\\:\\:\\$name\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Utility/HierarchyDiscriminatorResolver.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\Persistence\\\\Mapping\\\\ClassMetadata\\:\\:\\$subClasses\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Utility/HierarchyDiscriminatorResolver.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Utility\\\\HierarchyDiscriminatorResolver\\:\\:resolveDiscriminatorsForClass\\(\\) has parameter \\$rootClassMetadata with generic interface Doctrine\\\\Persistence\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Utility/HierarchyDiscriminatorResolver.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$joinColumns\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Utility/IdentifierFlattener.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Utility\\\\IdentifierFlattener\\:\\:__construct\\(\\) has parameter \\$metadataFactory with generic interface Doctrine\\\\Persistence\\\\Mapping\\\\ClassMetadataFactory but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Utility/IdentifierFlattener.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Utility\\\\IdentifierFlattener\\:\\:flattenIdentifier\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Utility/IdentifierFlattener.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\JoinTableMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$joinColumns\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Utility/PersisterHelper.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$joinColumns\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Utility/PersisterHelper.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$joinTable\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 2\n\t\t\tpath: src/Utility/PersisterHelper.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToManyAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneInverseSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$mappedBy\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Utility/PersisterHelper.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$relationToTargetKeyColumns\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Utility/PersisterHelper.php\n\n\t\t-\n\t\t\tmessage: '#^Access to an undefined property Doctrine\\\\ORM\\\\Mapping\\\\ManyToManyOwningSideMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\ManyToOneAssociationMapping\\|Doctrine\\\\ORM\\\\Mapping\\\\OneToOneOwningSideMapping\\:\\:\\$sourceToTargetKeyColumns\\.$#'\n\t\t\tidentifier: property.notFound\n\t\t\tcount: 1\n\t\t\tpath: src/Utility/PersisterHelper.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Utility\\\\PersisterHelper\\:\\:getTypeOfColumn\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Utility/PersisterHelper.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Utility\\\\PersisterHelper\\:\\:getTypeOfField\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Utility/PersisterHelper.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Utility\\\\PersisterHelper\\:\\:inferParameterTypes\\(\\) has parameter \\$class with generic class Doctrine\\\\ORM\\\\Mapping\\\\ClassMetadata but does not specify its types\\: T$#'\n\t\t\tidentifier: missingType.generics\n\t\t\tcount: 1\n\t\t\tpath: src/Utility/PersisterHelper.php\n\n\t\t-\n\t\t\tmessage: '#^Method Doctrine\\\\ORM\\\\Utility\\\\PersisterHelper\\:\\:inferParameterTypes\\(\\) should return list\\ but returns list\\\\.$#'\n\t\t\tidentifier: return.type\n\t\t\tcount: 1\n\t\t\tpath: src/Utility/PersisterHelper.php\n"
},
{
"path": "phpstan-dbal3.neon",
"content": "includes:\n - phpstan-baseline.neon\n - phpstan-params.neon\n\nparameters:\n reportUnmatchedIgnoredErrors: false # Some errors in the baseline only apply to DBAL 4\n ignoreErrors:\n # Symfony cache supports passing a key prefix to the clear method.\n - '/^Method Psr\\\\Cache\\\\CacheItemPoolInterface\\:\\:clear\\(\\) invoked with 1 parameter, 0 required\\.$/'\n\n # We can be certain that those values are not matched.\n -\n message: '~^Match expression does not handle remaining values:~'\n path: src/Utility/PersisterHelper.php\n\n # DBAL 4 compatibility\n -\n message: '~^Method Doctrine\\\\ORM\\\\Query\\\\AST\\\\Functions\\\\TrimFunction::getTrimMode\\(\\) never returns .* so it can be removed from the return type\\.$~'\n path: src/Query/AST/Functions/TrimFunction.php\n\n -\n message: '~.*getTrimExpression.*expects int.*~'\n path: src/Query/AST/Functions/TrimFunction.php\n\n -\n message: '~^Call to static method unquoted\\(\\) on an unknown class Doctrine\\\\DBAL\\\\Schema\\\\Name\\\\Identifier\\.$~'\n path: src/Tools/SchemaTool.php\n\n -\n message: '~^Instantiated class Doctrine\\\\DBAL\\\\Schema\\\\Name\\\\UnqualifiedName not found\\.$~'\n path: src/Tools/SchemaTool.php\n\n -\n message: '~^Call to an undefined method Doctrine\\\\DBAL\\\\Schema\\\\Table::addPrimaryKeyConstraint\\(\\)\\.$~'\n path: src/Tools/SchemaTool.php\n\n -\n message: '~^Call to static method quoted\\(\\) on an unknown class Doctrine\\\\DBAL\\\\Schema\\\\Name\\\\Identifier\\.$~'\n path: src/Tools/SchemaTool.php\n\n -\n message: '~^Call to an undefined method Doctrine\\\\DBAL\\\\Schema\\\\Table\\:\\:getObjectName\\(\\)\\.$~'\n path: src/Mapping/Driver/DatabaseDriver.php\n\n -\n message: '~^Call to an undefined method Doctrine\\\\DBAL\\\\Schema\\\\ForeignKeyConstraint::get.*\\.$~'\n identifier: method.notFound\n\n -\n message: '~createComparator~'\n identifier: arguments.count\n\n -\n message: '~UnqualifiedName~'\n identifier: class.notFound\n\n -\n message: '~IndexedColumn~'\n identifier: class.notFound\n\n -\n message: '~PrimaryKeyConstraint~'\n identifier: class.notFound\n\n -\n message: '~IndexType~'\n identifier: class.notFound\n\n -\n message: '~dropForeignKey~'\n identifier: method.notFound\n\n -\n message: '~getIndexedColumns~'\n identifier: method.notFound\n\n -\n message: '~getPrimaryKeyConstraint~'\n identifier: method.notFound\n\n -\n message: '~PrimaryKeyConstraint~'\n identifier: class.notFound\n path: src/Tools/SchemaTool.php\n\n -\n message: '~^Call to method toString.*UnqualifiedName\\.$~'\n path: src/Tools/SchemaTool.php\n\n - '~^Call to method getObjectName\\(\\) on an unknown class Doctrine\\\\DBAL\\\\Schema\\\\NamedObject\\.$~'\n\n - '~^Class Doctrine\\\\DBAL\\\\Platforms\\\\SQLitePlatform not found\\.$~'\n\n - '~^Class Doctrine\\\\DBAL\\\\Schema\\\\NamedObject not found\\.$~'\n\n -\n message: '~sort~'\n identifier: argument.unresolvableType\n path: src/Mapping/Driver/DatabaseDriver.php\n\n -\n message: '#^Parameter \\#1 \\$asset of static method Doctrine\\\\ORM\\\\Mapping\\\\Driver\\\\DatabaseDriver\\:\\:getAssetName\\(\\) expects Doctrine\\\\DBAL\\\\Schema\\\\AbstractAsset, Doctrine\\\\DBAL\\\\Schema\\\\Column\\|false given\\.$#'\n identifier: argument.type\n path: src/Mapping/Driver/DatabaseDriver.php\n\n -\n message: '#^Instantiated class Doctrine\\\\DBAL\\\\Schema\\\\DefaultExpression\\\\\\w+ not found\\.$#'\n identifier: class.notFound\n path: src/Tools/SchemaTool.php\n\n\n # To be removed in 4.0\n -\n message: '#Negated boolean expression is always false\\.#'\n paths:\n - src/Mapping/Driver/AttributeDriver.php\n\n -\n message: '~^Call to deprecated method getEventManager\\(\\) of class Doctrine\\\\DBAL\\\\Connection\\.$~'\n path: src/EntityManager.php\n -\n message: '~deprecated class Doctrine\\\\DBAL\\\\Tools\\\\Console\\\\Command\\\\ReservedWordsCommand\\:~'\n path: src/Tools/Console/ConsoleRunner.php\n\n # Compatibility with Persistence 3\n -\n message: '#Expression on left side of \\?\\? is not nullable.#'\n path: src/Mapping/Driver/AttributeDriver.php\n\n -\n message: '~^Method Doctrine\\\\ORM\\\\Utility\\\\PersisterHelper\\:\\:getArrayBindingType\\(\\) never returns .* so it can be removed from the return type\\.$~'\n path: src/Utility/PersisterHelper.php\n\n -\n message: '~inferParameterTypes.*should return~'\n path: src/Utility/PersisterHelper.php\n\n -\n message: '~.*appendLockHint.*expects.*LockMode given~'\n paths:\n - src/Persisters/Entity/BasicEntityPersister.php\n - src/Persisters/Entity/JoinedSubclassPersister.php\n\n -\n message: '~.*executeStatement.*expects~'\n path: src/Query/Exec/MultiTableUpdateExecutor.php\n\n -\n message: '~method_exists.*getEventManager~'\n path: src/EntityManager.php\n\n -\n message: '~method_exists.*getIdentitySequence~'\n path: src/Mapping/ClassMetadataFactory.php\n\n -\n message: '~expand(Criteria)?Parameters.*should return array~'\n path: src/Persisters/Entity/BasicEntityPersister.php\n\n -\n message: '~inferType.*never returns~'\n path: src/Query/ParameterTypeInferer.php\n"
},
{
"path": "phpstan-params.neon",
"content": "parameters:\n level: 7\n paths:\n - src\n - tests/StaticAnalysis\n excludePaths:\n - src/Mapping/Driver/AttributeReader.php\n earlyTerminatingMethodCalls:\n Doctrine\\ORM\\Query\\Parser:\n - syntaxError\n phpVersion: 80400\n"
},
{
"path": "phpstan.neon",
"content": "includes:\n - phpstan-baseline.neon\n - phpstan-params.neon\n\nparameters:\n ignoreErrors:\n # Symfony cache supports passing a key prefix to the clear method.\n - '/^Method Psr\\\\Cache\\\\CacheItemPoolInterface\\:\\:clear\\(\\) invoked with 1 parameter, 0 required\\.$/'\n\n # We can be certain that those values are not matched.\n -\n message: '~^Match expression does not handle remaining values:~'\n path: src/Utility/PersisterHelper.php\n\n # The return type is already narrow enough.\n - '~^Method Doctrine\\\\ORM\\\\Query\\\\ParameterTypeInferer\\:\\:inferType\\(\\) never returns ''[a-z_]+'' so it can be removed from the return type\\.$~'\n - '~^Method Doctrine\\\\ORM\\\\Query\\\\ParameterTypeInferer\\:\\:inferType\\(\\) never returns Doctrine\\\\DBAL\\\\(?:Array)?ParameterType\\:\\:[A-Z_]+ so it can be removed from the return type\\.$~'\n\n # DBAL 4 compatibility\n -\n message: '~^Method Doctrine\\\\ORM\\\\Query\\\\AST\\\\Functions\\\\TrimFunction::getTrimMode\\(\\) never returns .* so it can be removed from the return type\\.$~'\n path: src/Query/AST/Functions/TrimFunction.php\n -\n message: '~^Method Doctrine\\\\ORM\\\\Utility\\\\PersisterHelper\\:\\:getArrayBindingType\\(\\) never returns .* so it can be removed from the return type\\.$~'\n path: src/Utility/PersisterHelper.php\n\n # Compatibility with DBAL 3\n # See https://github.com/doctrine/dbal/pull/3480\n -\n message: '~^Result of method Doctrine\\\\DBAL\\\\Connection::commit\\(\\) \\(void\\) is used\\.$~'\n path: src/UnitOfWork.php\n -\n message: '~^Strict comparison using === between null and false will always evaluate to false\\.$~'\n path: src/UnitOfWork.php\n -\n message: '~^Variable \\$e on left side of \\?\\? always exists and is not nullable\\.$~'\n path: src/UnitOfWork.php\n\n -\n message: '~^Parameter #2 \\$command of static method Doctrine\\\\ORM\\\\Tools\\\\Console\\\\ConsoleRunner::addCommandToApplication\\(\\) expects Symfony\\\\Component\\\\Console\\\\Command\\\\Command, Doctrine\\\\DBAL\\\\Tools\\\\Console\\\\Command\\\\ReservedWordsCommand given\\.$~'\n path: src/Tools/Console/ConsoleRunner.php\n\n -\n message: '~Strict comparison using \\=\\=\\= between callable\\(\\)\\: mixed and null will always evaluate to false\\.~'\n path: src/Tools/SchemaTool.php\n\n # To be removed in 4.0\n -\n message: '#Negated boolean expression is always false\\.#'\n paths:\n - src/Mapping/Driver/AttributeDriver.php\n\n # Compatibility with Persistence 3\n -\n message: '#Expression on left side of \\?\\? is not nullable.#'\n path: src/Mapping/Driver/AttributeDriver.php\n"
},
{
"path": "phpunit.xml.dist",
"content": "\n\n\n \n \n ./tests/Tests/ORM\n \n \n\n \n \n performance\n locking_functional\n \n \n \n \n \n \n \n \n \n \n \n \n \n\n \n \n src\n \n \n\n"
},
{
"path": "src/AbstractQuery.php",
"content": "\n */\n protected ArrayCollection $parameters;\n\n /**\n * The user-specified ResultSetMapping to use.\n */\n protected ResultSetMapping|null $resultSetMapping = null;\n\n /**\n * The map of query hints.\n *\n * @phpstan-var array\n */\n protected array $hints = [];\n\n /**\n * The hydration mode.\n *\n * @phpstan-var string|AbstractQuery::HYDRATE_*\n */\n protected string|int $hydrationMode = self::HYDRATE_OBJECT;\n\n protected QueryCacheProfile|null $queryCacheProfile = null;\n\n /**\n * Whether or not expire the result cache.\n */\n protected bool $expireResultCache = false;\n\n protected QueryCacheProfile|null $hydrationCacheProfile = null;\n\n /**\n * Whether to use second level cache, if available.\n */\n protected bool $cacheable = false;\n\n protected bool $hasCache = false;\n\n /**\n * Second level cache region name.\n */\n protected string|null $cacheRegion = null;\n\n /**\n * Second level query cache mode.\n *\n * @phpstan-var Cache::MODE_*|null\n */\n protected int|null $cacheMode = null;\n\n protected CacheLogger|null $cacheLogger = null;\n\n protected int $lifetime = 0;\n\n /**\n * Initializes a new instance of a class derived from AbstractQuery.\n */\n public function __construct(\n /**\n * The entity manager used by this query object.\n */\n protected EntityManagerInterface $em,\n ) {\n $this->parameters = new ArrayCollection();\n $this->hints = $em->getConfiguration()->getDefaultQueryHints();\n $this->hasCache = $this->em->getConfiguration()->isSecondLevelCacheEnabled();\n\n if ($this->hasCache) {\n $this->cacheLogger = $em->getConfiguration()\n ->getSecondLevelCacheConfiguration()\n ->getCacheLogger();\n }\n }\n\n /**\n * Enable/disable second level query (result) caching for this query.\n *\n * @return $this\n */\n public function setCacheable(bool $cacheable): static\n {\n $this->cacheable = $cacheable;\n\n return $this;\n }\n\n /** @return bool TRUE if the query results are enabled for second level cache, FALSE otherwise. */\n public function isCacheable(): bool\n {\n return $this->cacheable;\n }\n\n /** @return $this */\n public function setCacheRegion(string $cacheRegion): static\n {\n $this->cacheRegion = $cacheRegion;\n\n return $this;\n }\n\n /**\n * Obtain the name of the second level query cache region in which query results will be stored\n *\n * @return string|null The cache region name; NULL indicates the default region.\n */\n public function getCacheRegion(): string|null\n {\n return $this->cacheRegion;\n }\n\n /** @return bool TRUE if the query cache and second level cache are enabled, FALSE otherwise. */\n protected function isCacheEnabled(): bool\n {\n return $this->cacheable && $this->hasCache;\n }\n\n public function getLifetime(): int\n {\n return $this->lifetime;\n }\n\n /**\n * Sets the life-time for this query into second level cache.\n *\n * @return $this\n */\n public function setLifetime(int $lifetime): static\n {\n $this->lifetime = $lifetime;\n\n return $this;\n }\n\n /** @phpstan-return Cache::MODE_*|null */\n public function getCacheMode(): int|null\n {\n return $this->cacheMode;\n }\n\n /**\n * @phpstan-param Cache::MODE_* $cacheMode\n *\n * @return $this\n */\n public function setCacheMode(int $cacheMode): static\n {\n $this->cacheMode = $cacheMode;\n\n return $this;\n }\n\n /**\n * Gets the SQL query that corresponds to this query object.\n * The returned SQL syntax depends on the connection driver that is used\n * by this query object at the time of this method call.\n *\n * @return list|string SQL query\n */\n abstract public function getSQL(): string|array;\n\n /**\n * Retrieves the associated EntityManager of this Query instance.\n */\n public function getEntityManager(): EntityManagerInterface\n {\n return $this->em;\n }\n\n /**\n * Frees the resources used by the query object.\n *\n * Resets Parameters, Parameter Types and Query Hints.\n */\n public function free(): void\n {\n $this->parameters = new ArrayCollection();\n\n $this->hints = $this->em->getConfiguration()->getDefaultQueryHints();\n }\n\n /**\n * Get all defined parameters.\n *\n * @phpstan-return ArrayCollection\n */\n public function getParameters(): ArrayCollection\n {\n return $this->parameters;\n }\n\n /**\n * Gets a query parameter.\n *\n * @param int|string $key The key (index or name) of the bound parameter.\n *\n * @return Parameter|null The value of the bound parameter, or NULL if not available.\n */\n public function getParameter(int|string $key): Parameter|null\n {\n $key = Parameter::normalizeName($key);\n\n $filteredParameters = $this->parameters->filter(\n static fn (Parameter $parameter): bool => $parameter->getName() === $key,\n );\n\n return ! $filteredParameters->isEmpty() ? $filteredParameters->first() : null;\n }\n\n /**\n * Sets a collection of query parameters.\n *\n * @param ArrayCollection|mixed[] $parameters\n * @phpstan-param ArrayCollection|mixed[] $parameters\n *\n * @return $this\n */\n public function setParameters(ArrayCollection|array $parameters): static\n {\n if (is_array($parameters)) {\n /** @phpstan-var ArrayCollection $parameterCollection */\n $parameterCollection = new ArrayCollection();\n\n foreach ($parameters as $key => $value) {\n $parameterCollection->add(new Parameter($key, $value));\n }\n\n $parameters = $parameterCollection;\n }\n\n $this->parameters = $parameters;\n\n return $this;\n }\n\n /**\n * Sets a query parameter.\n *\n * @param string|int $key The parameter position or name.\n * @param mixed $value The parameter value.\n * @param ParameterType|ArrayParameterType|string|int|null $type The parameter type. If specified, the given value\n * will be run through the type conversion of this\n * type. This is usually not needed for strings and\n * numeric types.\n *\n * @return $this\n */\n public function setParameter(string|int $key, mixed $value, ParameterType|ArrayParameterType|string|int|null $type = null): static\n {\n $existingParameter = $this->getParameter($key);\n\n if ($existingParameter !== null) {\n $existingParameter->setValue($value, $type);\n\n return $this;\n }\n\n $this->parameters->add(new Parameter($key, $value, $type));\n\n return $this;\n }\n\n /**\n * Processes an individual parameter value.\n *\n * @throws ORMInvalidArgumentException\n */\n public function processParameterValue(mixed $value): mixed\n {\n if (is_scalar($value)) {\n return $value;\n }\n\n if ($value instanceof Collection) {\n $value = iterator_to_array($value);\n }\n\n if (is_array($value)) {\n $value = $this->processArrayParameterValue($value);\n\n return $value;\n }\n\n if ($value instanceof ClassMetadata) {\n return $value->name;\n }\n\n if ($value instanceof BackedEnum) {\n return $value->value;\n }\n\n if (! is_object($value)) {\n return $value;\n }\n\n try {\n $class = DefaultProxyClassNameResolver::getClass($value);\n $value = $this->em->getUnitOfWork()->getSingleIdentifierValue($value);\n\n if ($value === null) {\n throw ORMInvalidArgumentException::invalidIdentifierBindingEntity($class);\n }\n } catch (MappingException | ORMMappingException) {\n /* Silence any mapping exceptions. These can occur if the object in\n question is not a mapped entity, in which case we just don't do\n any preparation on the value.\n Depending on MappingDriver, either MappingException or\n ORMMappingException is thrown. */\n\n $value = $this->potentiallyProcessIterable($value);\n }\n\n return $value;\n }\n\n /**\n * If no mapping is detected, trying to resolve the value as a Traversable\n */\n private function potentiallyProcessIterable(mixed $value): mixed\n {\n if ($value instanceof Traversable) {\n $value = iterator_to_array($value);\n $value = $this->processArrayParameterValue($value);\n }\n\n return $value;\n }\n\n /**\n * Process a parameter value which was previously identified as an array\n *\n * @param mixed[] $value\n *\n * @return mixed[]\n */\n private function processArrayParameterValue(array $value): array\n {\n foreach ($value as $key => $paramValue) {\n $paramValue = $this->processParameterValue($paramValue);\n $value[$key] = is_array($paramValue) ? reset($paramValue) : $paramValue;\n }\n\n return $value;\n }\n\n /**\n * Sets the ResultSetMapping that should be used for hydration.\n *\n * @return $this\n */\n public function setResultSetMapping(ResultSetMapping $rsm): static\n {\n $this->translateNamespaces($rsm);\n $this->resultSetMapping = $rsm;\n\n return $this;\n }\n\n /**\n * Gets the ResultSetMapping used for hydration.\n */\n protected function getResultSetMapping(): ResultSetMapping|null\n {\n return $this->resultSetMapping;\n }\n\n /**\n * Allows to translate entity namespaces to full qualified names.\n */\n private function translateNamespaces(ResultSetMapping $rsm): void\n {\n $translate = fn ($alias): string => $this->em->getClassMetadata($alias)->getName();\n\n $rsm->aliasMap = array_map($translate, $rsm->aliasMap);\n $rsm->declaringClasses = array_map($translate, $rsm->declaringClasses);\n }\n\n /**\n * Set a cache profile for hydration caching.\n *\n * If no result cache driver is set in the QueryCacheProfile, the default\n * result cache driver is used from the configuration.\n *\n * Important: Hydration caching does NOT register entities in the\n * UnitOfWork when retrieved from the cache. Never use result cached\n * entities for requests that also flush the EntityManager. If you want\n * some form of caching with UnitOfWork registration you should use\n * {@see AbstractQuery::setResultCacheProfile()}.\n *\n * @return $this\n *\n * @example\n * $lifetime = 100;\n * $resultKey = \"abc\";\n * $query->setHydrationCacheProfile(new QueryCacheProfile());\n * $query->setHydrationCacheProfile(new QueryCacheProfile($lifetime, $resultKey));\n */\n public function setHydrationCacheProfile(QueryCacheProfile|null $profile): static\n {\n if ($profile === null) {\n $this->hydrationCacheProfile = null;\n\n return $this;\n }\n\n if (! $profile->getResultCache()) {\n $defaultHydrationCacheImpl = $this->em->getConfiguration()->getHydrationCache();\n if ($defaultHydrationCacheImpl) {\n $profile = $profile->setResultCache($defaultHydrationCacheImpl);\n }\n }\n\n $this->hydrationCacheProfile = $profile;\n\n return $this;\n }\n\n public function getHydrationCacheProfile(): QueryCacheProfile|null\n {\n return $this->hydrationCacheProfile;\n }\n\n /**\n * Set a cache profile for the result cache.\n *\n * If no result cache driver is set in the QueryCacheProfile, the default\n * result cache driver is used from the configuration.\n *\n * @return $this\n */\n public function setResultCacheProfile(QueryCacheProfile|null $profile): static\n {\n if ($profile === null) {\n $this->queryCacheProfile = null;\n\n return $this;\n }\n\n if (! $profile->getResultCache()) {\n $defaultResultCache = $this->em->getConfiguration()->getResultCache();\n if ($defaultResultCache) {\n $profile = $profile->setResultCache($defaultResultCache);\n }\n }\n\n $this->queryCacheProfile = $profile;\n\n return $this;\n }\n\n /**\n * Defines a cache driver to be used for caching result sets and implicitly enables caching.\n */\n public function setResultCache(CacheItemPoolInterface|null $resultCache): static\n {\n if ($resultCache === null) {\n if ($this->queryCacheProfile) {\n $this->queryCacheProfile = new QueryCacheProfile($this->queryCacheProfile->getLifetime(), $this->queryCacheProfile->getCacheKey());\n }\n\n return $this;\n }\n\n $this->queryCacheProfile = $this->queryCacheProfile\n ? $this->queryCacheProfile->setResultCache($resultCache)\n : new QueryCacheProfile(0, null, $resultCache);\n\n return $this;\n }\n\n /**\n * Enables caching of the results of this query, for given or default amount of seconds\n * and optionally specifies which ID to use for the cache entry.\n *\n * @param int|null $lifetime How long the cache entry is valid, in seconds.\n * @param string|null $resultCacheId ID to use for the cache entry.\n *\n * @return $this\n */\n public function enableResultCache(int|null $lifetime = null, string|null $resultCacheId = null): static\n {\n $this->setResultCacheLifetime($lifetime);\n $this->setResultCacheId($resultCacheId);\n\n return $this;\n }\n\n /**\n * Disables caching of the results of this query.\n *\n * @return $this\n */\n public function disableResultCache(): static\n {\n $this->queryCacheProfile = null;\n\n return $this;\n }\n\n /**\n * Defines how long the result cache will be active before expire.\n *\n * @param int|null $lifetime How long the cache entry is valid, in seconds.\n *\n * @return $this\n */\n public function setResultCacheLifetime(int|null $lifetime): static\n {\n $lifetime = (int) $lifetime;\n\n if ($this->queryCacheProfile) {\n $this->queryCacheProfile = $this->queryCacheProfile->setLifetime($lifetime);\n\n return $this;\n }\n\n $this->queryCacheProfile = new QueryCacheProfile($lifetime);\n\n $cache = $this->em->getConfiguration()->getResultCache();\n if (! $cache) {\n return $this;\n }\n\n $this->queryCacheProfile = $this->queryCacheProfile->setResultCache($cache);\n\n return $this;\n }\n\n /**\n * Defines if the result cache is active or not.\n *\n * @param bool $expire Whether or not to force resultset cache expiration.\n *\n * @return $this\n */\n public function expireResultCache(bool $expire = true): static\n {\n $this->expireResultCache = $expire;\n\n return $this;\n }\n\n /**\n * Retrieves if the resultset cache is active or not.\n */\n public function getExpireResultCache(): bool\n {\n return $this->expireResultCache;\n }\n\n public function getQueryCacheProfile(): QueryCacheProfile|null\n {\n return $this->queryCacheProfile;\n }\n\n /**\n * Change the default fetch mode of an association for this query.\n *\n * @param class-string $class\n * @phpstan-param Mapping\\ClassMetadata::FETCH_EAGER|Mapping\\ClassMetadata::FETCH_LAZY $fetchMode\n */\n public function setFetchMode(string $class, string $assocName, int $fetchMode): static\n {\n $this->hints['fetchMode'][$class][$assocName] = $fetchMode;\n\n return $this;\n }\n\n /**\n * Defines the processing mode to be used during hydration / result set transformation.\n *\n * @param string|int $hydrationMode Doctrine processing mode to be used during hydration process.\n * One of the Query::HYDRATE_* constants.\n * @phpstan-param string|AbstractQuery::HYDRATE_* $hydrationMode\n *\n * @return $this\n */\n public function setHydrationMode(string|int $hydrationMode): static\n {\n $this->hydrationMode = $hydrationMode;\n\n return $this;\n }\n\n /**\n * Gets the hydration mode currently used by the query.\n *\n * @phpstan-return string|AbstractQuery::HYDRATE_*\n */\n public function getHydrationMode(): string|int\n {\n return $this->hydrationMode;\n }\n\n /**\n * Gets the list of results for the query.\n *\n * Alias for execute(null, $hydrationMode = HYDRATE_OBJECT).\n *\n * @phpstan-param string|AbstractQuery::HYDRATE_* $hydrationMode\n */\n public function getResult(string|int $hydrationMode = self::HYDRATE_OBJECT): mixed\n {\n return $this->execute(null, $hydrationMode);\n }\n\n /**\n * Gets the array of results for the query.\n *\n * Alias for execute(null, HYDRATE_ARRAY).\n *\n * @return mixed[]\n */\n public function getArrayResult(): array\n {\n return $this->execute(null, self::HYDRATE_ARRAY);\n }\n\n /**\n * Gets one-dimensional array of results for the query.\n *\n * Alias for execute(null, HYDRATE_SCALAR_COLUMN).\n *\n * @return mixed[]\n */\n public function getSingleColumnResult(): array\n {\n return $this->execute(null, self::HYDRATE_SCALAR_COLUMN);\n }\n\n /**\n * Gets the scalar results for the query.\n *\n * Alias for execute(null, HYDRATE_SCALAR).\n *\n * @return mixed[]\n */\n public function getScalarResult(): array\n {\n return $this->execute(null, self::HYDRATE_SCALAR);\n }\n\n /**\n * Get exactly one result or null.\n *\n * @phpstan-param string|AbstractQuery::HYDRATE_*|null $hydrationMode\n *\n * @throws NonUniqueResultException\n */\n public function getOneOrNullResult(string|int|null $hydrationMode = null): mixed\n {\n try {\n $result = $this->execute(null, $hydrationMode);\n } catch (NoResultException) {\n return null;\n }\n\n if ($this->hydrationMode !== self::HYDRATE_SINGLE_SCALAR && ! $result) {\n return null;\n }\n\n if (! is_array($result)) {\n return $result;\n }\n\n if (count($result) > 1) {\n throw new NonUniqueResultException();\n }\n\n return array_shift($result);\n }\n\n /**\n * Gets the single result of the query.\n *\n * Enforces the presence as well as the uniqueness of the result.\n *\n * If the result is not unique, a NonUniqueResultException is thrown.\n * If there is no result, a NoResultException is thrown.\n *\n * @phpstan-param string|AbstractQuery::HYDRATE_*|null $hydrationMode\n *\n * @throws NonUniqueResultException If the query result is not unique.\n * @throws NoResultException If the query returned no result.\n */\n public function getSingleResult(string|int|null $hydrationMode = null): mixed\n {\n $result = $this->execute(null, $hydrationMode);\n\n if ($this->hydrationMode !== self::HYDRATE_SINGLE_SCALAR && ! $result) {\n throw new NoResultException();\n }\n\n if (! is_array($result)) {\n return $result;\n }\n\n if (count($result) > 1) {\n throw new NonUniqueResultException();\n }\n\n return array_shift($result);\n }\n\n /**\n * Gets the single scalar result of the query.\n *\n * Alias for getSingleResult(HYDRATE_SINGLE_SCALAR).\n *\n * @return bool|float|int|string|null The scalar result.\n *\n * @throws NoResultException If the query returned no result.\n * @throws NonUniqueResultException If the query result is not unique.\n */\n public function getSingleScalarResult(): mixed\n {\n return $this->getSingleResult(self::HYDRATE_SINGLE_SCALAR);\n }\n\n /**\n * Sets a query hint. If the hint name is not recognized, it is silently ignored.\n *\n * @return $this\n */\n public function setHint(string $name, mixed $value): static\n {\n $this->hints[$name] = $value;\n\n return $this;\n }\n\n /**\n * Gets the value of a query hint. If the hint name is not recognized, FALSE is returned.\n *\n * @return mixed The value of the hint or FALSE, if the hint name is not recognized.\n */\n public function getHint(string $name): mixed\n {\n return $this->hints[$name] ?? false;\n }\n\n public function hasHint(string $name): bool\n {\n return isset($this->hints[$name]);\n }\n\n /**\n * Return the key value map of query hints that are currently set.\n *\n * @return array\n */\n public function getHints(): array\n {\n return $this->hints;\n }\n\n /**\n * Executes the query and returns an iterable that can be used to incrementally\n * iterate over the result.\n *\n * @phpstan-param ArrayCollection|mixed[] $parameters\n * @phpstan-param string|AbstractQuery::HYDRATE_*|null $hydrationMode\n *\n * @return iterable\n */\n public function toIterable(\n ArrayCollection|array $parameters = [],\n string|int|null $hydrationMode = null,\n ): iterable {\n if ($hydrationMode !== null) {\n $this->setHydrationMode($hydrationMode);\n }\n\n if (count($parameters) !== 0) {\n $this->setParameters($parameters);\n }\n\n $rsm = $this->getResultSetMapping();\n if ($rsm === null) {\n throw new LogicException('Uninitialized result set mapping.');\n }\n\n $stmt = $this->_doExecute();\n\n return $this->em->newHydrator($this->hydrationMode)->toIterable($stmt, $rsm, $this->hints);\n }\n\n /**\n * Executes the query.\n *\n * @phpstan-param ArrayCollection|mixed[]|null $parameters\n * @phpstan-param string|AbstractQuery::HYDRATE_*|null $hydrationMode\n */\n public function execute(\n ArrayCollection|array|null $parameters = null,\n string|int|null $hydrationMode = null,\n ): mixed {\n if ($this->cacheable && $this->isCacheEnabled()) {\n return $this->executeUsingQueryCache($parameters, $hydrationMode);\n }\n\n return $this->executeIgnoreQueryCache($parameters, $hydrationMode);\n }\n\n /**\n * Execute query ignoring second level cache.\n *\n * @phpstan-param ArrayCollection|mixed[]|null $parameters\n * @phpstan-param string|AbstractQuery::HYDRATE_*|null $hydrationMode\n */\n private function executeIgnoreQueryCache(\n ArrayCollection|array|null $parameters = null,\n string|int|null $hydrationMode = null,\n ): mixed {\n if ($hydrationMode !== null) {\n $this->setHydrationMode($hydrationMode);\n }\n\n if (! empty($parameters)) {\n $this->setParameters($parameters);\n }\n\n $setCacheEntry = static function ($data): void {\n };\n\n if ($this->hydrationCacheProfile !== null) {\n [$cacheKey, $realCacheKey] = $this->getHydrationCacheId();\n\n $cache = $this->getHydrationCache();\n $cacheItem = $cache->getItem($cacheKey);\n $result = $cacheItem->isHit() ? $cacheItem->get() : [];\n\n if (isset($result[$realCacheKey])) {\n return $result[$realCacheKey];\n }\n\n if (! $result) {\n $result = [];\n }\n\n $setCacheEntry = static function ($data) use ($cache, $result, $cacheItem, $realCacheKey): void {\n $cache->save($cacheItem->set($result + [$realCacheKey => $data]));\n };\n }\n\n $stmt = $this->_doExecute();\n\n if (is_numeric($stmt)) {\n $setCacheEntry($stmt);\n\n return $stmt;\n }\n\n $rsm = $this->getResultSetMapping();\n if ($rsm === null) {\n throw new LogicException('Uninitialized result set mapping.');\n }\n\n $data = $this->em->newHydrator($this->hydrationMode)->hydrateAll($stmt, $rsm, $this->hints);\n\n $setCacheEntry($data);\n\n return $data;\n }\n\n private function getHydrationCache(): CacheItemPoolInterface\n {\n assert($this->hydrationCacheProfile !== null);\n\n $cache = $this->hydrationCacheProfile->getResultCache();\n assert($cache !== null);\n\n return $cache;\n }\n\n /**\n * Load from second level cache or executes the query and put into cache.\n *\n * @phpstan-param ArrayCollection|mixed[]|null $parameters\n * @phpstan-param string|AbstractQuery::HYDRATE_*|null $hydrationMode\n */\n private function executeUsingQueryCache(\n ArrayCollection|array|null $parameters = null,\n string|int|null $hydrationMode = null,\n ): mixed {\n $rsm = $this->getResultSetMapping();\n if ($rsm === null) {\n throw new LogicException('Uninitialized result set mapping.');\n }\n\n $queryCache = $this->em->getCache()->getQueryCache($this->cacheRegion);\n $queryKey = new QueryCacheKey(\n $this->getHash(),\n $this->lifetime,\n $this->cacheMode ?: Cache::MODE_NORMAL,\n $this->getTimestampKey(),\n );\n\n $result = $queryCache->get($queryKey, $rsm, $this->hints);\n\n if ($result !== null) {\n if ($this->cacheLogger) {\n $this->cacheLogger->queryCacheHit($queryCache->getRegion()->getName(), $queryKey);\n }\n\n return $result;\n }\n\n $result = $this->executeIgnoreQueryCache($parameters, $hydrationMode);\n $cached = $queryCache->put($queryKey, $rsm, $result, $this->hints);\n\n if ($this->cacheLogger) {\n $this->cacheLogger->queryCacheMiss($queryCache->getRegion()->getName(), $queryKey);\n\n if ($cached) {\n $this->cacheLogger->queryCachePut($queryCache->getRegion()->getName(), $queryKey);\n }\n }\n\n return $result;\n }\n\n private function getTimestampKey(): TimestampCacheKey|null\n {\n assert($this->resultSetMapping !== null);\n $entityName = reset($this->resultSetMapping->aliasMap);\n\n if (empty($entityName)) {\n return null;\n }\n\n $metadata = $this->em->getClassMetadata($entityName);\n\n return new TimestampCacheKey($metadata->rootEntityName);\n }\n\n /**\n * Get the result cache id to use to store the result set cache entry.\n * Will return the configured id if it exists otherwise a hash will be\n * automatically generated for you.\n *\n * @return string[] ($key, $hash)\n * @phpstan-return array{string, string} ($key, $hash)\n */\n protected function getHydrationCacheId(): array\n {\n $parameters = [];\n $types = [];\n\n foreach ($this->getParameters() as $parameter) {\n $parameters[$parameter->getName()] = $this->processParameterValue($parameter->getValue());\n $types[$parameter->getName()] = $parameter->getType();\n }\n\n $sql = $this->getSQL();\n assert(is_string($sql));\n $queryCacheProfile = $this->getHydrationCacheProfile();\n $hints = $this->getHints();\n $hints['hydrationMode'] = $this->getHydrationMode();\n\n ksort($hints);\n assert($queryCacheProfile !== null);\n\n return $queryCacheProfile->generateCacheKeys($sql, $parameters, $types, $hints);\n }\n\n /**\n * Set the result cache id to use to store the result set cache entry.\n * If this is not explicitly set by the developer then a hash is automatically\n * generated for you.\n */\n public function setResultCacheId(string|null $id): static\n {\n if (! $this->queryCacheProfile) {\n return $this->setResultCacheProfile(new QueryCacheProfile(0, $id));\n }\n\n $this->queryCacheProfile = $this->queryCacheProfile->setCacheKey($id);\n\n return $this;\n }\n\n /**\n * Executes the query and returns the resulting Statement object.\n *\n * @return Result|int The executed database statement that holds\n * the results, or an integer indicating how\n * many rows were affected.\n */\n abstract protected function _doExecute(): Result|int;\n\n /**\n * Cleanup Query resource when clone is called.\n */\n public function __clone()\n {\n $this->parameters = new ArrayCollection();\n\n $this->hints = [];\n $this->hints = $this->em->getConfiguration()->getDefaultQueryHints();\n }\n\n /**\n * Generates a string of currently query to use for the cache second level cache.\n */\n protected function getHash(): string\n {\n $query = $this->getSQL();\n assert(is_string($query));\n $hints = $this->getHints();\n $params = array_map(function (Parameter $parameter) {\n $value = $parameter->getValue();\n\n // Small optimization\n // Does not invoke processParameterValue for scalar value\n if (is_scalar($value)) {\n return $value;\n }\n\n return $this->processParameterValue($value);\n }, $this->parameters->getValues());\n\n ksort($hints);\n\n return sha1($query . '-' . serialize($params) . '-' . serialize($hints));\n }\n}\n"
},
{
"path": "src/Cache/AssociationCacheEntry.php",
"content": " $identifier The entity identifier.\n * @param class-string $class The entity class name\n */\n public function __construct(\n public readonly string $class,\n public readonly array $identifier,\n ) {\n }\n\n /**\n * Creates a new AssociationCacheEntry\n *\n * This method allow Doctrine\\Common\\Cache\\PhpFileCache compatibility\n *\n * @param array $values array containing property values\n */\n public static function __set_state(array $values): self\n {\n return new self($values['class'], $values['identifier']);\n }\n}\n"
},
{
"path": "src/Cache/CacheConfiguration.php",
"content": "cacheFactory;\n }\n\n public function setCacheFactory(CacheFactory $factory): void\n {\n $this->cacheFactory = $factory;\n }\n\n public function getCacheLogger(): CacheLogger|null\n {\n return $this->cacheLogger;\n }\n\n public function setCacheLogger(CacheLogger $logger): void\n {\n $this->cacheLogger = $logger;\n }\n\n public function getRegionsConfiguration(): RegionsConfiguration\n {\n return $this->regionsConfig ??= new RegionsConfiguration();\n }\n\n public function setRegionsConfiguration(RegionsConfiguration $regionsConfig): void\n {\n $this->regionsConfig = $regionsConfig;\n }\n\n public function getQueryValidator(): QueryCacheValidator\n {\n return $this->queryValidator ??= new TimestampQueryCacheValidator(\n $this->cacheFactory->getTimestampRegion(),\n );\n }\n\n public function setQueryValidator(QueryCacheValidator $validator): void\n {\n $this->queryValidator = $validator;\n }\n}\n"
},
{
"path": "src/Cache/CacheEntry.php",
"content": "IMPORTANT NOTE:\n *\n * Fields of classes that implement CacheEntry are public for performance reason.\n */\ninterface CacheEntry\n{\n}\n"
},
{
"path": "src/Cache/CacheException.php",
"content": " $cache The cache configuration.\n */\n public function getRegion(array $cache): Region;\n\n /**\n * Build timestamp cache region\n */\n public function getTimestampRegion(): TimestampRegion;\n\n /**\n * Build \\Doctrine\\ORM\\Cache\n */\n public function createCache(EntityManagerInterface $entityManager): Cache;\n}\n"
},
{
"path": "src/Cache/CacheKey.php",
"content": " $values array containing property values\n */\n public static function __set_state(array $values): CollectionCacheEntry\n {\n return new self($values['identifiers']);\n }\n}\n"
},
{
"path": "src/Cache/CollectionCacheKey.php",
"content": "\n */\n public readonly array $ownerIdentifier;\n\n /**\n * @param class-string $entityClass The owner entity class.\n * @param array $ownerIdentifier The identifier of the owning entity.\n */\n public function __construct(\n public readonly string $entityClass,\n public readonly string $association,\n array $ownerIdentifier,\n string $filterHash = '',\n ) {\n ksort($ownerIdentifier);\n\n $this->ownerIdentifier = $ownerIdentifier;\n\n $filterHash = $filterHash === '' ? '' : '_' . $filterHash;\n\n parent::__construct(str_replace('\\\\', '.', strtolower($entityClass)) . '_' . implode(' ', $ownerIdentifier) . '__' . $association . $filterHash);\n }\n}\n"
},
{
"path": "src/Cache/CollectionHydrator.php",
"content": "\n */\n private array $queryCaches = [];\n\n private QueryCache|null $defaultQueryCache = null;\n\n public function __construct(\n private readonly EntityManagerInterface $em,\n ) {\n $this->uow = $em->getUnitOfWork();\n $this->cacheFactory = $em->getConfiguration()\n ->getSecondLevelCacheConfiguration()\n ->getCacheFactory();\n }\n\n public function getEntityCacheRegion(string $className): Region|null\n {\n $metadata = $this->em->getClassMetadata($className);\n $persister = $this->uow->getEntityPersister($metadata->rootEntityName);\n\n if (! ($persister instanceof CachedPersister)) {\n return null;\n }\n\n return $persister->getCacheRegion();\n }\n\n public function getCollectionCacheRegion(string $className, string $association): Region|null\n {\n $metadata = $this->em->getClassMetadata($className);\n $persister = $this->uow->getCollectionPersister($metadata->getAssociationMapping($association));\n\n if (! ($persister instanceof CachedPersister)) {\n return null;\n }\n\n return $persister->getCacheRegion();\n }\n\n public function containsEntity(string $className, mixed $identifier): bool\n {\n $metadata = $this->em->getClassMetadata($className);\n $persister = $this->uow->getEntityPersister($metadata->rootEntityName);\n\n if (! ($persister instanceof CachedPersister)) {\n return false;\n }\n\n return $persister->getCacheRegion()->contains($this->buildEntityCacheKey($metadata, $identifier));\n }\n\n public function evictEntity(string $className, mixed $identifier): void\n {\n $metadata = $this->em->getClassMetadata($className);\n $persister = $this->uow->getEntityPersister($metadata->rootEntityName);\n\n if (! ($persister instanceof CachedPersister)) {\n return;\n }\n\n $persister->getCacheRegion()->evict($this->buildEntityCacheKey($metadata, $identifier));\n }\n\n public function evictEntityRegion(string $className): void\n {\n $metadata = $this->em->getClassMetadata($className);\n $persister = $this->uow->getEntityPersister($metadata->rootEntityName);\n\n if (! ($persister instanceof CachedPersister)) {\n return;\n }\n\n $persister->getCacheRegion()->evictAll();\n }\n\n public function evictEntityRegions(): void\n {\n $metadatas = $this->em->getMetadataFactory()->getAllMetadata();\n\n foreach ($metadatas as $metadata) {\n $persister = $this->uow->getEntityPersister($metadata->rootEntityName);\n\n if (! ($persister instanceof CachedPersister)) {\n continue;\n }\n\n $persister->getCacheRegion()->evictAll();\n }\n }\n\n public function containsCollection(string $className, string $association, mixed $ownerIdentifier): bool\n {\n $metadata = $this->em->getClassMetadata($className);\n $persister = $this->uow->getCollectionPersister($metadata->getAssociationMapping($association));\n\n if (! ($persister instanceof CachedPersister)) {\n return false;\n }\n\n return $persister->getCacheRegion()->contains($this->buildCollectionCacheKey($metadata, $association, $ownerIdentifier));\n }\n\n public function evictCollection(string $className, string $association, mixed $ownerIdentifier): void\n {\n $metadata = $this->em->getClassMetadata($className);\n $persister = $this->uow->getCollectionPersister($metadata->getAssociationMapping($association));\n\n if (! ($persister instanceof CachedPersister)) {\n return;\n }\n\n $persister->getCacheRegion()->evict($this->buildCollectionCacheKey($metadata, $association, $ownerIdentifier));\n }\n\n public function evictCollectionRegion(string $className, string $association): void\n {\n $metadata = $this->em->getClassMetadata($className);\n $persister = $this->uow->getCollectionPersister($metadata->getAssociationMapping($association));\n\n if (! ($persister instanceof CachedPersister)) {\n return;\n }\n\n $persister->getCacheRegion()->evictAll();\n }\n\n public function evictCollectionRegions(): void\n {\n $metadatas = $this->em->getMetadataFactory()->getAllMetadata();\n\n foreach ($metadatas as $metadata) {\n foreach ($metadata->associationMappings as $association) {\n if (! $association->isToMany()) {\n continue;\n }\n\n $persister = $this->uow->getCollectionPersister($association);\n\n if (! ($persister instanceof CachedPersister)) {\n continue;\n }\n\n $persister->getCacheRegion()->evictAll();\n }\n }\n }\n\n public function containsQuery(string $regionName): bool\n {\n return isset($this->queryCaches[$regionName]);\n }\n\n public function evictQueryRegion(string|null $regionName = null): void\n {\n if ($regionName === null && $this->defaultQueryCache !== null) {\n $this->defaultQueryCache->clear();\n\n return;\n }\n\n if (isset($this->queryCaches[$regionName])) {\n $this->queryCaches[$regionName]->clear();\n }\n }\n\n public function evictQueryRegions(): void\n {\n $this->getQueryCache()->clear();\n\n foreach ($this->queryCaches as $queryCache) {\n $queryCache->clear();\n }\n }\n\n public function getQueryCache(string|null $regionName = null): QueryCache\n {\n if ($regionName === null) {\n return $this->defaultQueryCache ??= $this->cacheFactory->buildQueryCache($this->em);\n }\n\n return $this->queryCaches[$regionName] ??= $this->cacheFactory->buildQueryCache($this->em, $regionName);\n }\n\n private function buildEntityCacheKey(ClassMetadata $metadata, mixed $identifier): EntityCacheKey\n {\n if (! is_array($identifier)) {\n $identifier = $this->toIdentifierArray($metadata, $identifier);\n }\n\n return new EntityCacheKey($metadata->rootEntityName, $identifier);\n }\n\n private function buildCollectionCacheKey(\n ClassMetadata $metadata,\n string $association,\n mixed $ownerIdentifier,\n ): CollectionCacheKey {\n if (! is_array($ownerIdentifier)) {\n $ownerIdentifier = $this->toIdentifierArray($metadata, $ownerIdentifier);\n }\n\n return new CollectionCacheKey($metadata->rootEntityName, $association, $ownerIdentifier);\n }\n\n /** @return array