### Install DoctrineBundle via Composer

Source: https://context7.com/doctrine/doctrinebundle/llms.txt

Install the DoctrineBundle using Composer. Symfony Flex handles automatic enabling and configuration file generation. Verify configuration with `debug:config doctrine`.

```bash
composer require doctrine/doctrine-bundle

# Flex also scaffolds config/packages/doctrine.yaml automatically.
# Verify with:
php bin/console debug:config doctrine
```

--------------------------------

### Autowire Entity Managers

Source: https://github.com/doctrine/doctrinebundle/blob/3.2.x/docs/en/configuration.rst

Example of how to autowire different entity managers by type-hinting service arguments with the EntityManagerInterface.

```diff
-     public function __construct(EntityManagerInterface $entityManager)
+     public function __construct(EntityManagerInterface $purchaseLogsEntityManager)
        {
            $this->entityManager = $purchaseLogsEntityManager;
        }
```

--------------------------------

### Install DoctrineBundle using Composer

Source: https://github.com/doctrine/doctrinebundle/blob/3.2.x/docs/en/installation.rst

Use this command to download the latest stable version of the DoctrineBundle. Requires Composer to be installed globally.

```bash
$ composer require doctrine/doctrine-bundle
```

--------------------------------

### Doctrine DBAL Configuration Options

Source: https://github.com/doctrine/doctrinebundle/blob/3.2.x/docs/en/configuration.rst

Comprehensive example showcasing various configuration keys for Doctrine DBAL, including connection details and driver-specific options.

```yaml
doctrine:
    dbal:
        url:                      mysql://user:secret@localhost:1234/otherdatabase
        dbname:                   database
        host:                     localhost
        port:                     1234
        user:                     user
        password:                 secret
        dbname_suffix:            _test
        driver:                   pdo_mysql
        driver_class:             MyNamespace\MyDriverImpl
        options:
            foo: bar
        path:                     "%kernel.project_dir%/var/data.db" # SQLite specific
        memory:                   true                               # SQLite specific
        unix_socket:              /tmp/mysql.sock
        persistent:               true
        MultipleActiveResultSets: true                # pdo_sqlsrv driver specific
        pooled:                   true                # Oracle specific (SERVER=POOLED)
        protocol:                 TCPIP               # IBM DB2 specific (PROTOCOL)
        server:                   my_database_server  # SQL Anywhere specific (ServerName)
        service:                  true                # Oracle specific (SERVICE_NAME instead of SID)
        servicename:              MyOracleServiceName # Oracle specific (SERVICE_NAME)
        sessionMode:              2                   # oci8 driver specific (session_mode)
        default_dbname:           database            # PostgreSQL specific (default_dbname)
        sslmode:                  require             # PostgreSQL specific (LIBPQ-CONNECT-SSLMODE)
        sslrootcert:              postgresql-ca.pem   # PostgreSQL specific (LIBPQ-CONNECT-SSLROOTCERT)
        sslcert:                  postgresql-cert.pem # PostgreSQL specific (LIBPQ-CONNECT-SSLCERT)
        sslkey:                   postgresql-key.pem  # PostgreSQL specific (LIBPQ-CONNECT-SSLKEY)
```

--------------------------------

### Default ORM Configuration

Source: https://github.com/doctrine/doctrinebundle/blob/3.2.x/docs/en/configuration.rst

Example of default ORM configuration settings, including auto-mapping and default entity manager.

```yaml
doctrine:
    orm:
        auto_mapping: true
        # the standard distribution overrides this to be true in debug, false otherwise
        default_entity_manager: default
        metadata_cache_driver: ~
        query_cache_driver: ~
        result_cache_driver: ~
```

--------------------------------

### Get Help for a Specific Doctrine Command

Source: https://github.com/doctrine/doctrinebundle/blob/3.2.x/docs/en/doctrine-console.rst

Use this command to get detailed help and usage information for a specific Doctrine command, such as doctrine:schema:update.

```console
php bin/console doctrine:schema:update --help
```

--------------------------------

### Decorate Driver Connection Logic

Source: https://github.com/doctrine/doctrinebundle/blob/3.2.x/docs/en/middlewares.rst

Extend `AbstractDriverMiddleware` to decorate specific driver methods. This example prevents connections using the 'root' user.

```php
<?php

namespace App\Middleware;

use Doctrine\DBAL\Driver\Connection;
use Doctrine\DBAL\Driver\Middleware\AbstractDriverMiddleware;
use SensitiveParameter;

final class PreventRootConnectionDriver extends AbstractDriverMiddleware
{
    public function connect(array $params): Connection
    {
        if (isset($params['user']) && $params['user'] === 'root') {
            throw new \LogicException('Connecting to the database with the root user is not allowed.');
        }

        return parent::connect($params);
    }
}
```

--------------------------------

### Create Custom Repository with ServiceEntityRepository

Source: https://context7.com/doctrine/doctrinebundle/llms.txt

Extend ServiceEntityRepository to create type-safe, service-container-aware repositories. This example shows how to add custom methods like findActiveByCategory and findExpensiveProducts.

```php
<?php
// src/Repository/ProductRepository.php
namespace App\Repository;

use App\Entity\Product;
use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
use Doctrine\Persistence\ManagerRegistry;
use Doctrine\ORM\QueryBuilder;

/**
 * @extends ServiceEntityRepository<Product>
 */
class ProductRepository extends ServiceEntityRepository
{
    public function __construct(ManagerRegistry $registry)
    {
        parent::__construct($registry, Product::class);
    }

    /** @return Product[] */
    public function findActiveByCategory(string $category, int $limit = 20): array
    {
        return $this->findBy(
            ['category' => $category, 'active' => true],
            ['createdAt' => 'DESC'],
            $limit,
        );
    }

    public function findExpensiveProducts(float $minPrice): QueryBuilder
    {
        return $this->createQueryBuilder('p')
            ->where('p.price >= :minPrice')
            ->setParameter('minPrice', $minPrice)
            ->orderBy('p.price', 'DESC');
    }
}

```

--------------------------------

### Doctrine Migrations Commands

Source: https://context7.com/doctrine/doctrinebundle/llms.txt

Manage database schema changes over time using Doctrine Migrations. Requires the 'doctrine/migrations' package to be installed.

```bash
php bin/console doctrine:migrations:diff
```

```bash
php bin/console doctrine:migrations:migrate
```

--------------------------------

### Entity with Second Level Cache Annotation

Source: https://context7.com/doctrine/doctrinebundle/llms.txt

Example of an entity class annotated for second-level caching. Specify usage and region for entities and collections.

```php
<?php
// src/Entity/Product.php
namespace App\Entity;

use Doctrine\ORM\Mapping as ORM;

#[ORM\Entity]
#[ORM\Cache(usage: 'READ_WRITE', region: 'product_region')]
class Product
{
    #[ORM\Id, ORM\GeneratedValue, ORM\Column]
    public int $id;

    #[ORM\Column]
    public string $name;

    #[ORM\ManyToMany(targetEntity: Tag::class)]
    #[ORM\Cache(usage: 'READ_ONLY', region: 'product_region')]
    public array $tags = [];
}
```

--------------------------------

### Register Global Doctrine Event Listener with #[AsDoctrineListener]

Source: https://context7.com/doctrine/doctrinebundle/llms.txt

Register a service as a Doctrine lifecycle event listener for all entities using the #[AsDoctrineListener] attribute. This example sets up listeners for postPersist and postUpdate events.

```php
<?php
// src/EventListener/AuditListener.php
namespace App\EventListener;

use Doctrine\Bundle\DoctrineBundle\Attribute\AsDoctrineListener;
use Doctrine\ORM\Events;
use Doctrine\ORM\Event\PostPersistEventArgs;
use Doctrine\ORM\Event\PostUpdateEventArgs;
use Psr\Log\LoggerInterface;

#[AsDoctrineListener(event: Events::postPersist, priority: 100, connection: 'default')]
#[AsDoctrineListener(event: Events::postUpdate,  priority: 100, connection: 'default')]
class AuditListener
{
    public function __construct(private readonly LoggerInterface $logger) {}

    public function postPersist(PostPersistEventArgs $args): void
    {
        $entity = $args->getObject();
        $this->logger->info('Entity created', [
            'class' => $entity::class,
            'id'    => $args->getObjectManager()->getUnitOfWork()->getEntityIdentifier($entity),
        ]);
    }

    public function postUpdate(PostUpdateEventArgs $args): void
    {
        $entity     = $args->getObject();
        $changeSet  = $args->getObjectManager()->getUnitOfWork()->getEntityChangeSet($entity);
        $this->logger->info('Entity updated', ['class' => $entity::class, 'changes' => array_keys($changeSet)]);
    }
}

```

--------------------------------

### Resolve Target Entities in Entity Class

Source: https://context7.com/doctrine/doctrinebundle/llms.txt

Example of an entity class using an interface for a ManyToOne relationship, which will be resolved by the configuration.

```php
<?php
// src/Entity/Order.php
namespace App\Entity;

use App\Contract\UserInterface;
use Doctrine\ORM\Mapping as ORM;

#[ORM\Entity]
class Order
{
    #[ORM\ManyToOne(targetEntity: UserInterface::class)]
    private UserInterface $customer; // resolved to App\Entity\User at compile time
}
```

--------------------------------

### Use Custom Repository in a Symfony Controller

Source: https://context7.com/doctrine/doctrinebundle/llms.txt

Inject and use a custom repository (ProductRepository) within a Symfony controller to fetch data. This example demonstrates calling the findActiveByCategory method.

```php
<?php
// src/Controller/ProductController.php
namespace App\Controller;

use App\Repository\ProductRepository;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\Routing\Attribute\Route;

class ProductController extends AbstractController
{
    #[Route('/products/{category}', methods: ['GET'])]
    public function list(string $category, ProductRepository $repo): JsonResponse
    {
        $products = $repo->findActiveByCategory($category);
        // $repo->find(42)               — find by primary key
        // $repo->findOneBy(['sku' => 'ABC-123'])
        // $repo->count(['active' => true])

        return $this->json($products);
    }
}

```

--------------------------------

### Built-in UUID ID Generator

Source: https://context7.com/doctrine/doctrinebundle/llms.txt

Example of using the built-in UUID generator for entity IDs. Requires the symfony/uid component.

```php
<?php
// src/Entity/Article.php
namespace App\Entity;

use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\Uid\Uuid;

#[ORM\Entity]
class Article
{
    // Built-in UUID generator (requires symfony/uid)
    #[ORM\Id]
    #[ORM\Column(type: 'uuid', unique: true)]
    #[ORM\GeneratedValue(strategy: 'CUSTOM')]
    #[ORM\CustomIdGenerator('doctrine.uuid_generator')]
    private Uuid $id;

    #[ORM\Column(length: 255)]
    public string $title;

    public function getId(): Uuid { return $this->id; }
}
```

--------------------------------

### Custom DBAL Money Type

Source: https://context7.com/doctrine/doctrinebundle/llms.txt

Example of creating a custom DBAL type for handling monetary values. This involves defining SQL declarations and conversion methods for database interaction.

```php
<?php
// src/DBAL/Type/MoneyType.php
namespace App\DBAL\Type;

use Doctrine\DBAL\Platforms\AbstractPlatform;
use Doctrine\DBAL\Types\Type;

class MoneyType extends Type
{
    public function getName(): string { return 'money'; }

    public function getSQLDeclaration(array $column, AbstractPlatform $platform): string
    {
        return 'DECIMAL(19,4)';
    }

    public function convertToPHPValue(mixed $value, AbstractPlatform $platform): ?float
    {
        return $value !== null ? (float) $value : null;
    }

    public function convertToDatabaseValue(mixed $value, AbstractPlatform $platform): ?string
    {
        return $value !== null ? number_format((float) $value, 4, '.', '') : null;
    }
}
```

```yaml
# config/packages/doctrine.yaml
doctrine:
    dbal:
        types:
            money: App\DBAL\Type\MoneyType
        connections:
            default:
                mapping_types:
                    # Map DB-native "enum" columns to Doctrine "string" type
                    enum: string
```

--------------------------------

### Configure Doctrine DBAL with Primary and Replica Connections

Source: https://context7.com/doctrine/doctrinebundle/llms.txt

Sets up the default database connection and defines read replicas for load balancing. Ensure environment variables for DB credentials are set.

```yaml
doctrine:
    dbal:
        driver: pdo_mysql
        # Primary (write) connection
        host:     primary-db.example.com
        dbname:   app_db
        user:     '%env(DB_USER)%'
        password: '%env(DB_PASSWORD)%'
        server_version: '8.0'
        # Read replicas
        replicas:
            replica1:
                host:     replica1.example.com
                dbname:   app_db
                user:     '%env(DB_REPLICA_USER)%'
                password: '%env(DB_REPLICA_PASSWORD)%'
            replica2:
                host:     replica2.example.com
                dbname:   app_db
                user:     '%env(DB_REPLICA_USER)%'
                password: '%env(DB_REPLICA_PASSWORD)%'
```

--------------------------------

### Create a Custom Middleware

Source: https://github.com/doctrine/doctrinebundle/blob/3.2.x/docs/en/middlewares.rst

Implement the `Middleware` interface to create a custom middleware. The `wrap` method should return a decorated `Driver` instance.

```php
<?php

namespace App\Middleware;

use Doctrine\DBAL\Driver;
use Doctrine\DBAL\Driver\Middleware;

class PreventRootConnectionMiddleware implements Middleware
{
    public function wrap(Driver $driver): Driver
    {
        return new PreventRootConnectionDriver($driver);
    }
}
```

--------------------------------

### List All Doctrine Commands

Source: https://github.com/doctrine/doctrinebundle/blob/3.2.x/docs/en/doctrine-console.rst

Run this command to see a list of all available Doctrine console commands registered by the bundle.

```console
php bin/console list doctrine
```

--------------------------------

### Configure ORM Entity Manager

Source: https://github.com/doctrine/doctrinebundle/blob/3.2.x/docs/en/configuration.rst

Sets up an ORM entity manager. Configure metadata, repository classes, and caching drivers.

```xml
<doctrine:entity-manager
                        name="default"
                        connection=""
                        class-metadata-factory-name="Doctrine\ORM\Mapping\ClassMetadataFactory"
                        default-repository-class="Doctrine\ORM\EntityRepository"
                        auto-mapping="false"
                        naming-strategy="doctrine.orm.naming_strategy.default"
                        quote-strategy="doctrine.orm.quote_strategy.default"
                        typed-field-mapper="doctrine.orm.typed_field_mapper.default"
                        entity-listener-resolver="null"
                        repository-factory="null"
                    >
```

--------------------------------

### Doctrine Mapping Information Commands

Source: https://context7.com/doctrine/doctrinebundle/llms.txt

Inspect your Doctrine entity mappings. Use 'info' to list all mapped entities and 'describe' for details on a specific entity.

```bash
php bin/console doctrine:mapping:info
```

```bash
php bin/console doctrine:mapping:describe 'App\Entity\User'
```

--------------------------------

### Enable DoctrineBundle in config/bundles.php

Source: https://github.com/doctrine/doctrinebundle/blob/3.2.x/docs/en/installation.rst

Manually enable the DoctrineBundle by adding its class to the config/bundles.php file if you are not using Flex.

```php
<?php
// config/bundles.php

return [
    // ...
    Doctrine\Bundle\DoctrineBundle\DoctrineBundle::class => ['all' => true],
    // ...
];
```

--------------------------------

### Configure Listener with Event, Entity, and Method (XML)

Source: https://github.com/doctrine/doctrinebundle/blob/3.2.x/docs/en/entity-listeners.rst

Configure entity listener registration using XML in the service definition, specifying the event, entity, and method. The 'entity_manager' and 'method' attributes are optional.

```xml
<?xml version="1.0" ?>

<container xmlns="http://symfony.com/schema/dic/services"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

    <services>
        <service id="App\UserListener">
            <!-- entity_manager attribute is optional -->
            <!-- method attribute is optional -->
            <tag
                name="doctrine.orm.entity_listener" 
                event="preUpdate"
                entity="App\Entity\User"
                entity_manager="custom"
                method="validateEmail"
            />
        </service>
    </services>
</container>

```

--------------------------------

### Doctrine Console Commands

Source: https://context7.com/doctrine/doctrinebundle/llms.txt

Lists available Doctrine console commands for database management, including creation and dropping of databases.

```bash
# List all available Doctrine commands
php bin/console list doctrine
```

```bash
# --- Database management ---
php bin/console doctrine:database:create                # Create the configured database
php bin/console doctrine:database:drop --force          # Drop the database (--force required)
```

--------------------------------

### Configure Multiple DBAL Connections

Source: https://context7.com/doctrine/doctrinebundle/llms.txt

Set up multiple named database connections in `config/packages/doctrine.yaml`. These connections can be injected into services by name using the `$<name>Connection` convention.

```yaml
# config/packages/doctrine.yaml
doctrine:
    dbal:
        default_connection: default
        connections:
            default:
                url: '%env(resolve:DATABASE_URL)%'
            legacy:
                driver:   pdo_pgsql
                host:     legacy-db.example.com
                dbname:   legacy
                user:     '%env(LEGACY_DB_USER)%'
                password: '%env(LEGACY_DB_PASSWORD)%'
```

--------------------------------

### Doctrine Query Command

Source: https://context7.com/doctrine/doctrinebundle/llms.txt

Execute DQL queries directly from the command line for testing or data retrieval.

```bash
php bin/console doctrine:query:dql "SELECT u FROM App\Entity\User u WHERE u.active = true"
```

--------------------------------

### Enable DoctrineBundle in app/AppKernel.php (older Symfony versions)

Source: https://github.com/doctrine/doctrinebundle/blob/3.2.x/docs/en/installation.rst

For older Symfony versions without config/bundles.php, enable the DoctrineBundle by adding it to the AppKernel.php file.

```php
<?php
// app/AppKernel.php

// ...
class AppKernel extends Kernel
{
    public function registerBundles()
    {
        $bundles = [
            // ...

            new Doctrine\Bundle\DoctrineBundle\DoctrineBundle(),
        ];

        // ...
    }

    // ...
}
```

--------------------------------

### Configure Entity Listener Service (YAML)

Source: https://github.com/doctrine/doctrinebundle/blob/3.2.x/docs/en/entity-listeners.rst

Register the entity listener service and tag it appropriately. The 'entity_manager' attribute is optional.

```yaml
services:
    App\UserListener:
        tags:
            # Minimal configuration below
            - { name: doctrine.orm.entity_listener }
            # Or, optionally, you can give the entity manager name as below
            #- { name: doctrine.orm.entity_listener, entity_manager: custom }

```

--------------------------------

### Configure Entity Listener Service (XML)

Source: https://github.com/doctrine/doctrinebundle/blob/3.2.x/docs/en/entity-listeners.rst

Register the entity listener service using XML and tag it appropriately. The 'entity_manager' attribute is optional.

```xml
<?xml version="1.0" ?>

<container xmlns="http://symfony.com/schema/dic/services"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

    <services>
        <service id="App\UserListener">
            <!-- entity_manager attribute is optional -->
            <tag name="doctrine.orm.entity_listener" entity_manager="custom" />
        </service>
    </services>
</container>

```

--------------------------------

### Configure Listener with Event, Entity, and Method (YAML)

Source: https://github.com/doctrine/doctrinebundle/blob/3.2.x/docs/en/entity-listeners.rst

Configure entity listener registration directly in the service definition, specifying the event, entity, and method. The 'entity_manager' and 'method' attributes are optional.

```yaml
services:
    App\UserListener:
        tags:
            - 
                name: doctrine.orm.entity_listener
                event: preUpdate
                entity: App\Entity\User
                # entity_manager attribute is optional
                entity_manager: custom
                # method attribute is optional
                method: validateEmail

```

--------------------------------

### Configure Database Connection Option

Source: https://github.com/doctrine/doctrinebundle/blob/3.2.x/docs/en/configuration.rst

Adds a specific option to the database connection. This is useful for setting driver-specific parameters not covered by the main attributes.

```xml
<doctrine:option key="key">value</doctrine:option>
```

--------------------------------

### Create Custom DBAL Middleware with #[AsMiddleware]

Source: https://context7.com/doctrine/doctrinebundle/llms.txt

Implement the Doctrine\DBAL\Driver\Middleware interface and use the #[AsMiddleware] attribute to register your custom middleware. This allows you to intercept and modify DBAL operations, such as logging slow queries. You can specify which connections the middleware applies to and its priority.

```php
<?php
// src/Middleware/QueryTimingMiddleware.php
namespace App\Middleware;

use Doctrine\Bundle\DoctrineBundle\Attribute\AsMiddleware;
use Doctrine\DBAL\Driver;
use Doctrine\DBAL\Driver\Middleware;
use Doctrine\DBAL\Driver\Middleware\AbstractDriverMiddleware;
use Doctrine\DBAL\Driver\Connection;
use Doctrine\DBAL\Driver\Statement;
use Doctrine\DBAL\ParameterType;

// Apply only to 'default' connection, run before other middlewares (priority 10)
#[AsMiddleware(connections: ['default'], priority: 10)]
class QueryTimingMiddleware implements Middleware
{
    public function wrap(Driver $driver): Driver
    {
        return new class($driver) extends AbstractDriverMiddleware {
            public function connect(array $params): Connection
            {
                return new TimingConnection(parent::connect($params));
            }
        };
    }
}

class TimingConnection implements Connection
{
    public function __construct(private readonly Connection $wrapped) {}

    public function prepare(string $sql): Statement
    {
        $start     = hrtime(true);
        $statement = $this->wrapped->prepare($sql);
        $elapsed   = (hrtime(true) - $start) / 1e6;

        if ($elapsed > 100) { // log slow query preparations > 100ms
            error_log(sprintf('[SLOW PREPARE] %s — %.2fms', $sql, $elapsed));
        }

        return $statement;
    }

    // Delegate all other methods to $this->wrapped ...
    public function exec(string $sql): int           { return $this->wrapped->exec($sql); }
    public function query(string $sql): 

	Doctrine\DBAL\Driver\Result { return $this->wrapped->query($sql); }
    public function quote(string $value): string     { return $this->wrapped->quote($value); }
    public function beginTransaction(): void         { $this->wrapped->beginTransaction(); }
    public function commit(): void                   { $this->wrapped->commit(); }
    public function rollBack(): void                 { $this->wrapped->rollBack(); }
    public function lastInsertId(): int|string       { return $this->wrapped->lastInsertId(); }
    public function getNativeConnection(): mixed     { return $this->wrapped->getNativeConnection(); }
}
```

--------------------------------

### Configure Entity Listener with #[AsEntityListener]

Source: https://context7.com/doctrine/doctrinebundle/llms.txt

Use the #[AsEntityListener] attribute on your listener service to register it for specific entity lifecycle events. This approach is useful when you don't want to modify the entity class directly or need more granular control over events and lazy loading.

```php
<?php
// src/EventListener/UserListener.php
namespace App\EventListener;

use App\Entity\User;
use Doctrine\Bundle\DoctrineBundle\Attribute\AsEntityListener;
use Doctrine\ORM\Events;
use Doctrine\ORM\Event\PrePersistEventArgs;
use Doctrine\ORM\Event\PreUpdateEventArgs;
use Symfony\Component\PasswordHasher\Hasher\UserPasswordHasherInterface;

// Without #[ORM\EntityListeners] on the entity, use entity + event on the attribute:
#[AsEntityListener(event: Events::prePersist, entity: User::class, lazy: true)]
#[AsEntityListener(event: Events::preUpdate,  entity: User::class, lazy: true)]
class UserListener
{
    public function __construct(
        private readonly UserPasswordHasherInterface $hasher,
    ) {}

    public function prePersist(User $user, PrePersistEventArgs $args): void
    {
        // Auto-hash plain password on creation
        if (isset($user->plainPassword)) {
            $user->passwordHash = $this->hasher->hashPassword($user, $user->plainPassword);
        }
    }

    public function preUpdate(User $user, PreUpdateEventArgs $args): void
    {
        if ($args->hasChangedField('plainPassword')) {
            $user->passwordHash = $this->hasher->hashPassword($user, $user->plainPassword);
        }
    }
}
```

--------------------------------

### Set Middleware Execution Priority

Source: https://github.com/doctrine/doctrinebundle/blob/3.2.x/docs/en/middlewares.rst

Use the `AsMiddleware` attribute with the `priority` option to control the execution order of middlewares. Higher values execute earlier.

```php
<?php

namespace App\Middleware;

use Doctrine\Bundle\DoctrineBundle\Attribute\AsMiddleware;
use Doctrine\DBAL\Driver;
use Doctrine\DBAL\Driver\Middleware;

#[AsMiddleware(priority: 10)]
class PreventRootConnectionMiddleware implements Middleware
{
    public function wrap(Driver $driver): Driver
    {
        return new PreventRootConnectionDriver($driver);
    }
}
```

--------------------------------

### Configure DBAL Connection in doctrine.yaml

Source: https://context7.com/doctrine/doctrinebundle/llms.txt

Configure a Doctrine DBAL connection using either a DSN URL (recommended for environment variables) or explicit parameters in `config/packages/doctrine.yaml`. Supports various RDBMS.

```yaml
# config/packages/doctrine.yaml
doctrine:
    dbal:
        # Option 1: DSN URL (recommended for environment variables)
        url: '%env(resolve:DATABASE_URL)%'
        # DATABASE_URL="mysql://app_user:secret@localhost:3306/app_db?serverVersion=8.0"

        # Option 2: Explicit parameters
        driver:   pdo_mysql
        host:     '%env(DB_HOST)%'
        port:     '%env(int:DB_PORT)%'
        dbname:   '%env(DB_NAME)%'
        user:     '%env(DB_USER)%'
        password: '%env(DB_PASSWORD)%'
        charset:  utf8mb4
        server_version: '8.0'

        # Default table options for schema generation
        default_table_options:
            charset:   utf8mb4
            collation: utf8mb4_unicode_ci
            engine:    InnoDB

        # Schema filter: ignore tables not matching this regex
        schema_filter: '/^app_/'

        # Enable query profiling in debug mode
        logging:    '%kernel.debug%'
        profiling:  '%kernel.debug%'
        profiling_collect_backtrace: false
```

--------------------------------

### Configure Multiple Doctrine ORM Entity Managers

Source: https://context7.com/doctrine/doctrinebundle/llms.txt

Sets up two distinct entity managers, 'default' and 'customer', each connected to a different database. This is useful for multi-database applications. Ensure environment variables for database URLs are correctly set.

```yaml
# config/packages/doctrine.yaml
doctrine:
    dbal:
        default_connection: default
        connections:
            default:
                url: '%env(resolve:DATABASE_URL)%'
            customer:
                url: '%env(resolve:CUSTOMER_DATABASE_URL)%'
    orm:
        default_entity_manager: default
        entity_managers:
            default:
                connection: default
                mappings: { App: { dir: '%kernel.project_dir%/src/Entity/Core', prefix: 'App\Entity\Core' } }
            customer:
                connection: customer
                mappings: { Customer: { dir: '%kernel.project_dir%/src/Entity/Customer', prefix: 'App\Entity\Customer' } }
```

--------------------------------

### Register Event Listener with PHP Configuration

Source: https://github.com/doctrine/doctrinebundle/blob/3.2.x/docs/en/event-listeners.rst

Register event listeners in PHP configuration files by setting the service and tagging it with 'doctrine.event_listener'. The 'event' key is required, and 'priority' and 'connection' can be provided as optional parameters.

```php
namespace Symfony\Component\DependencyInjection\Loader\Configurator;

use App\EventListener\SearchIndexer;

return static function (ContainerConfigurator $configurator) {
    $services = $configurator->services();

    // listeners are applied by default to all Doctrine connections
    $services->set(SearchIndexer::class)
        ->tag('doctrine.event_listener', [
            // this is the only required option for the lifecycle listener tag
            'event' => 'postPersist',

            // listeners can define their priority in case multiple subscribers or listeners are associated
            // to the same event (default priority = 0; higher numbers = listener is run earlier)
            'priority' => 500,

            // you can also restrict listeners to a specific Doctrine connection
            'connection' => 'default',
        ])
    ;
};
```

--------------------------------

### Configure Multiple DBAL Connections in YAML

Source: https://github.com/doctrine/doctrinebundle/blob/3.2.x/docs/en/configuration.rst

Define multiple database connections by nesting them under the 'connections' key in your YAML configuration. Ensure each connection has a unique name. The 'default_connection' parameter specifies which connection is used by default.

```yaml
doctrine:
    dbal:
        default_connection:       default
        connections:
            default:
                dbname:           Symfony2
                user:             root
                password:         null
                host:             localhost
            customer:
                dbname:           customer
                user:             root
                password:         null
                host:             localhost
```

--------------------------------

### Doctrine Caching Drivers Configuration

Source: https://github.com/doctrine/doctrinebundle/blob/3.2.x/docs/en/configuration.rst

Overview of Doctrine ORM caching configurations, showing how to use Symfony Cache pools or custom services.

```yaml
doctrine:
    orm:
        auto_mapping: true
        # With no cache set, this defaults to a sane 'pool' configuration
        metadata_cache_driver: ~
        # the 'pool' type requires to define the 'pool' option and configure a cache pool using the FrameworkBundle
        result_cache_driver:
            type: pool
            pool: doctrine.result_cache_pool
        # the 'service' type requires to define the 'id' option too
        query_cache_driver:
            type: service
            id: App\ORM\MyCacheService

framework:
    cache:
        pools:
            doctrine.result_cache_pool:
                adapter: cache.app
```

--------------------------------

### Register Event Listener with YAML Configuration

Source: https://github.com/doctrine/doctrinebundle/blob/3.2.x/docs/en/event-listeners.rst

Configure services in YAML to act as event listeners by tagging them with 'doctrine.event_listener'. The 'event' option is required, while 'priority' and 'connection' are optional.

```yaml
services:
    # ...

    App\EventListener\SearchIndexer:
        tags:
            - 
                name: 'doctrine.event_listener'
                # this is the only required option for the lifecycle listener tag
                event: 'postPersist'

                # listeners can define their priority in case multiple subscribers or listeners are associated
                # to the same event (default priority = 0; higher numbers = listener is run earlier)
                priority: 500

                # you can also restrict listeners to a specific Doctrine connection
                connection: 'default'
```

--------------------------------

### Configure Doctrine DBAL Connections

Source: https://github.com/doctrine/doctrinebundle/blob/3.2.x/docs/en/configuration.rst

Defines database connection parameters for Doctrine DBAL. Includes settings for database name, host, user, password, charset, and RDBMS-specific options. Use this to set up your primary database connection.

```yaml
doctrine:
    dbal:
        default_connection:           default

        # A collection of custom types
        types:
            # example
            some_custom_type:
                class:                Acme\HelloBundle\MyCustomType

        connections:
            # A collection of different named connections (e.g. default, conn2, etc)
            default:
                dbname:               ~
                host:                 localhost
                port:                 ~
                user:                 root
                password:             ~

                # RDBMS specific; Refer to the manual of your RDBMS for more information
                charset:              ~

                # Adds the given suffix to the configured database name, this option has no effects for the SQLite platform
                dbname_suffix:        ~

                # SQLite specific
                path:                 ~

                # SQLite specific
                memory:               ~

                # MySQL specific. The unix socket to use for MySQL
                unix_socket:          ~

                # IBM DB2 specific. True to use as persistent connection for the ibm_db2 driver
                persistent:           ~

                # IBM DB2 specific. The protocol to use for the ibm_db2 driver (default to TCPIP if omitted)
                protocol:             ~

                # Oracle specific. True to use SERVICE_NAME as connection parameter instead of SID for Oracle
                service:              ~

                # Oracle specific. Overrules dbname parameter if given and used as SERVICE_NAME or SID connection
                # parameter for Oracle depending on the service parameter.
                servicename:          ~

                # oci8 driver specific. The session mode to use for the oci8 driver.
                sessionMode:          ~

                # SQL Anywhere specific (ServerName). The name of a running database server to connect to for SQL Anywhere.
                server:               ~

                # PostgreSQL specific (default_dbname).
                # Override the default database (postgres) to connect to.
                default_dbname:       ~

                # PostgreSQL specific (LIBPQ-CONNECT-SSLMODE).
                # Determines whether or with what priority a SSL TCP/IP connection will be negotiated with the server for PostgreSQL.
                sslmode:              ~

                # PostgreSQL specific (LIBPQ-CONNECT-SSLROOTCERT).
                # The name of a file containing SSL certificate authority (CA) certificate(s).
                # If the file exists, the server's certificate will be verified to be signed by one of these authorities.
                sslrootcert:          ~

                # PostgreSQL specific (LIBPQ-CONNECT-SSLCERT).
                # The name of a file containing the client SSL certificate.
                sslcert:              ~

                # PostgreSQL specific (LIBPQ-CONNECT-SSLKEY).
                # The name of a file containing the private key for the client SSL certificate.
                sslkey:               ~

                # PostgreSQL specific (LIBPQ-CONNECT-SSLCRL).
                # The name of a file containing the SSL certificate revocation list (CRL).
                sslcrl:               ~

                # Oracle specific (SERVER=POOLED). True to use a pooled server with the oci8/pdo_oracle driver
                pooled:               ~

                # pdo_sqlsrv driver specific. Configuring MultipleActiveResultSets for the pdo_sqlsrv driver
                MultipleActiveResultSets:  ~

                driver:               pdo_mysql
                platform_service:     ~
                auto_commit:          ~

                # If set to "/^sf2_/" all tables, and any named objects such as sequences
                # not prefixed with "sf2_" will be ignored by the schema tool.
                # This is for custom tables which should not be altered automatically.
                schema_filter:        ~

                # When true, queries are logged to a "doctrine" monolog channel
                logging:              "%kernel.debug%"
```

--------------------------------

### Inject Multiple Entity Managers in a Service

Source: https://context7.com/doctrine/doctrinebundle/llms.txt

Demonstrates how to inject multiple Doctrine Entity Managers into a service using constructor property promotion. The entity managers are injected by their configured names (e.g., $defaultEntityManager, $customerEntityManager).

```php
<?php
// src/Service/CustomerService.php
namespace App\Service;

use Doctrine\ORM\EntityManagerInterface;

class CustomerService
{
    public function __construct(
        // Inject by name: $<name>EntityManager
        private readonly EntityManagerInterface $defaultEntityManager,
        private readonly EntityManagerInterface $customerEntityManager,
    ) {}

    public function syncCustomer(int $id): void
    {
        $order    = $this->defaultEntityManager->find(\App\Entity\Core\Order::class, $id);
        $customer = $this->customerEntityManager->find(\App\Entity\Customer\Profile::class, $order->getCustomerId());
        // ...
    }
}
```

--------------------------------

### Configure Default Database Connection

Source: https://github.com/doctrine/doctrinebundle/blob/3.2.x/docs/en/configuration.rst

Defines the primary database connection for the application. Ensure all required parameters like host, port, user, and password are set correctly. Logging and profiling can be enabled based on the kernel debug mode.

```xml
<doctrine:connection
    name="default"
    dbname=""
    host="localhost"
    port="null"
    user="root"
    password="null"
    charset="null"
    path=""
    memory=""
    unix-socket=""
    persistent=""
    protocol=""
    service=""
    servicename=""
    sessionMode=""
    server=""
    default_dbname=""
    sslmode=""
    sslrootcert=""
    sslcert=""
    sslkey=""
    sslcrl=""
    pooled=""
    MultipleActiveResultSets=""
    driver="pdo_mysql"
    auto-commit=""
    schema-filter=""
    logging="%kernel.debug%"
    profiling="%kernel.debug%"
    profiling-collect-backtrace="false"
    profiling-collect-schema-errors="true"
    server-version=""
    driver-class=""
    wrapper-class=""
    keep-replica=""
>

    <!-- example -->
    <doctrine:option key="key">value</doctrine:option>

    <!-- example -->
    <doctrine:mapping-type name="enum">string</doctrine:mapping-type>

    <!-- example -->
    <doctrine:default-table-option name="charset">utf8mb4</doctrine:default-table-option>
    <doctrine:default-table-option name="collation">utf8_unicode_ci</doctrine:default-table-option>
    <doctrine:default-table-option name="engine">InnoDB</doctrine:default-table-option>

</doctrine:connection>
```

--------------------------------

### Register Event Listener with PHP Attributes

Source: https://github.com/doctrine/doctrinebundle/blob/3.2.x/docs/en/event-listeners.rst

Use the AsDoctrineListener attribute to tag a service as an event listener. Specify the event name and optionally priority and connection.

```php
namespace App\EventListener;

use Doctrine\Bundle\DoctrineBundle\Attribute\AsDoctrineListener;
use Doctrine\ORM\Event\LifecycleEventArgs;

#[AsDoctrineListener('postPersist'/*, 500, 'default'*/)]
class SearchIndexer
{
    public function postPersist(LifecycleEventArgs $event): void
    {
        // ...
    }
}
```

--------------------------------

### Configure Lazy Entity Listener (YAML)

Source: https://github.com/doctrine/doctrinebundle/blob/3.2.x/docs/en/entity-listeners.rst

Use the 'lazy: true' attribute in the tag to ensure the listener service is only instantiated when actually used.

```yaml
services:
    App\UserListener:
        tags:
            - { name: doctrine.orm.entity_listener, lazy: true }

```

--------------------------------

### Configure ORM Mapping

Source: https://github.com/doctrine/doctrinebundle/blob/3.2.x/docs/en/configuration.rst

Defines ORM mapping information. Specify bundle name, directory, and type.

```xml
<doctrine:mapping
                            name="AcmeHelloBundle"
                            mapping="true"
                            type=""
                            dir=""
                            alias=""
                            prefix=""
                            is-bundle=""
                        />
```

--------------------------------

### Configure Lazy Entity Listener (XML)

Source: https://github.com/doctrine/doctrinebundle/blob/3.2.x/docs/en/entity-listeners.rst

Use the 'lazy: true' attribute in the tag to ensure the listener service is only instantiated when actually used.

```xml
<?xml version="1.0" ?>

<container xmlns="http://symfony.com/schema/dic/services"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

    <services>
        <service id="App\UserListener">
            <tag name="doctrine.orm.entity_listener" event="preUpdate" entity="App\Entity\User" lazy="true" />            
        </service>
    </services>
</container>

```

--------------------------------

### Configure Doctrine DBAL Connection in XML

Source: https://github.com/doctrine/doctrinebundle/blob/3.2.x/docs/en/configuration.rst

Defines a DBAL connection with various parameters like name, URL, host, port, user, password, driver, and specific driver options. This is useful for setting up database connections in Symfony applications.

```xml
<?xml version="1.0" encoding="UTF-8" ?>
<container xmlns="http://symfony.com/schema/dic/services"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:doctrine="http://symfony.com/schema/dic/doctrine"
    xsi:schemaLocation="http://symfony.com/schema/dic/services
        http://symfony.com/schema/dic/services/services-1.0.xsd
        http://symfony.com/schema/dic/doctrine
        http://symfony.com/schema/dic/doctrine/doctrine-1.0.xsd">

    <doctrine:config>
        <!--
            SQLite specific options:
            - path
            - memory
        -->
        <!--
            Oracle specific options:
            - pooled (SERVER=POOLED)
            - service (SERVICE_NAME instead of SID)
            - servicename (SERVICE_NAME)
        -->
        <!--
            PostgreSQL specific options:
            - default_dbname (default_dbname)
            - sslmode (LIBPQ-CONNECT-SSLMODE)
            - sslrootcert (LIBPQ-CONNECT-SSLROOTCERT)
            - sslcert (LIBPQ-CONNECT-SSLCERT)
            - sslkey (LIBPQ-CONNECT-SSLKEY)
            - sslcrl (LIBPQ-CONNECT-SSLCRL)
        -->
        <!--
            IBM DB2 specific options:
            - protocol (PROTOCOL)
        -->
        <!--
            SQL Anywhere specific options:
            - server (ServerName)
        -->
        <!--
            oci8 specific options:
            - sessionMode (session_mode)
        -->

        <doctrine:dbal
            name="default"
            url="mysql://user:secret@localhost:1234/otherdatabase"
            dbname="database"
            host="localhost"
            port="1234"
            user="user"
            password="secret"
            driver="pdo_mysql"
            driver-class="MyNamespace\MyDriverImpl"
            path="%kernel.project_dir%/var/data.db"
            memory="true"
            unix-socket="/tmp/mysql.sock"
            persistent="true"
            multiple-active-result-sets="true"
            pooled="true"
            protocol="TCPIP"
            server="my_database_server"
            service="true"
            servicename="MyOracleServiceName"
            sessionMode="2"
            default_dbname="database"
            sslmode="require"
            sslrootcert="postgresql-ca.pem"
            sslcert="postgresql-cert.pem"
            sslkey="postgresql-key.pem"
            sslcrl="postgresql.crl"
            wrapper-class="MyDoctrineDbalConnectionWrapper"
            charset=""
            logging="%kernel.debug%"
            auto-commit="false"
            schema-filter="^sf2_"
        >
            <doctrine:option key="foo">bar</doctrine:option>
            <doctrine:mapping-type name="enum">string</doctrine:mapping-type>
            <doctrine:default-table-option name="charset">utf8mb4</doctrine:default-table-option>
            <doctrine:default-table-option name="collation">utf8_unicode_ci</doctrine:default-table-option>
            <doctrine:default-table-option name="engine">InnoDB</doctrine:default-table-option>
            <doctrine:type name="custom">Acme\HelloBundle\MyCustomType</doctrine:type>
        </doctrine:dbal>
    </doctrine:config>
</container>
```

--------------------------------

### Doctrine Schema Management Commands

Source: https://context7.com/doctrine/doctrinebundle/llms.txt

Use these commands to manage your database schema based on entity mappings. Ensure you understand the implications before running update or drop commands.

```bash
php bin/console doctrine:schema:create
```

```bash
php bin/console doctrine:schema:update --dump-sql
```

```bash
php bin/console doctrine:schema:update --force
```

```bash
php bin/console doctrine:schema:drop --force
```

```bash
php bin/console doctrine:schema:validate
```

--------------------------------

### Register Entity Listener with #[ORM\EntityListeners]

Source: https://context7.com/doctrine/doctrinebundle/llms.txt

Use the #[ORM\EntityListeners] attribute on your entity class to specify which listener services should handle its lifecycle events. This is a straightforward way to associate listeners with specific entities.

```php
<?php
// src/Entity/User.php
namespace App\Entity;

use Doctrine\ORM\Mapping as ORM;
use App\EventListener\UserListener;

#[ORM\Entity]
#[ORM\EntityListeners([UserListener::class])]
class User
{
    #[ORM\Id, ORM\GeneratedValue, ORM\Column]
    public int $id;

    #[ORM\Column(length: 255)]
    public string $email;

    #[ORM\Column]
    public string $passwordHash;
}
```

--------------------------------

### Configure Doctrine Filters

Source: https://github.com/doctrine/doctrinebundle/blob/3.2.x/docs/en/configuration.rst

Define custom Doctrine filters in your configuration file. Specify the filter class, enable/disable status, and default parameters.

```yaml
doctrine:
    orm:
        filters:
            myFilter:
                class: MyVendor\MyBundle\Filters\MyFilter
                enabled: true
                parameters:
                    myParameter: myValue
                    mySecondParameter: mySecondValue
```

--------------------------------

### Configure Doctrine ORM with Custom Caching and DQL Extensions

Source: https://context7.com/doctrine/doctrinebundle/llms.txt

Configures the default entity manager with auto-mapping, custom cache drivers using Symfony's pool, and custom DQL functions for string and datetime operations. Also includes SQL filter configuration.

```yaml
# config/packages/doctrine.yaml
doctrine:
    orm:
        default_entity_manager: default
        entity_managers:
            default:
                connection: default
                auto_mapping: true
                # Namespace -> directory mapping
                mappings:
                    App:
                        is_bundle: false
                        type:      attribute
                        dir:       '%kernel.project_dir%/src/Entity'
                        prefix:    'App\Entity'
                        alias:     App
                # Cache pools (use Symfony Cache)
                metadata_cache_driver:
                    type: pool
                    pool: doctrine.system_cache_pool
                query_cache_driver:
                    type: pool
                    pool: doctrine.system_cache_pool
                result_cache_driver:
                    type: pool
                    pool: doctrine.result_cache_pool
                # Custom DQL functions
                dql:
                    string_functions:
                        GROUP_CONCAT: App\DQL\GroupConcatFunction
                    datetime_functions:
                        DATE_FORMAT: App\DQL\DateFormatFunction
                # SQL Filters
                filters:
                    soft_delete:
                        class:   App\Filter\SoftDeleteFilter
                        enabled: true

framework:
    cache:
        pools:
            doctrine.system_cache_pool:
                adapter: cache.system
            doctrine.result_cache_pool:
                adapter: cache.app
```

--------------------------------

### Oracle DB Middleware Configuration

Source: https://github.com/doctrine/doctrinebundle/blob/3.2.x/docs/en/configuration.rst

Configure a middleware for Oracle DB to ensure Doctrine is aware of the specific format used by Oracle DB.

```yaml
services:
    oracle.middleware:
        class: Doctrine\DBAL\Driver\OCI8\Middleware\InitializeSession
        tags:
            - { name: doctrine.middleware, connection: default }
```

--------------------------------

### Autowire Specific DBAL Connections by Type-Hinting

Source: https://github.com/doctrine/doctrinebundle/blob/3.2.x/docs/en/configuration.rst

Inject specific DBAL connections into your services by type-hinting the argument with the pattern `Doctrine\DBAL\Connection $<connection name>Connection`. This allows for clear dependency injection of different database connections.

```diff
-     public function __construct(Connection $connection)
+     public function __construct(Connection $purchaseLogsConnection)
        {
            $this->connection = $purchaseLogsConnection;
        }
```

--------------------------------

### Configure Replica Database Connection

Source: https://github.com/doctrine/doctrinebundle/blob/3.2.x/docs/en/configuration.rst

Defines a replica database connection. This is typically used for read-only replicas to distribute read traffic.

```xml
<doctrine:replica
    name="replica1"
    dbname=""
    host="localhost"
    port="null"
    user="root"
    password="null"
    charset=""
    dbname_suffix=""
    path=""
    memory=""
    unix-socket=""
    persistent=""
    protocol=""
    service=""
>
```

--------------------------------

### Limit Middleware Scope to a Connection

Source: https://github.com/doctrine/doctrinebundle/blob/3.2.x/docs/en/middlewares.rst

Use the `AsMiddleware` attribute with the `connections` option to apply the middleware only to the specified connection(s).

```php
<?php

namespace App\Middleware;

use Doctrine\Bundle\DoctrineBundle\Attribute\AsMiddleware;
use Doctrine\DBAL\Driver;
use Doctrine\DBAL\Driver\Middleware;

#[AsMiddleware(connections: ['legacy'])]
class PreventRootConnectionMiddleware implements Middleware
{
    public function wrap(Driver $driver): Driver
    {
        return new PreventRootConnectionDriver($driver);
    }
}
```

--------------------------------

### Configure DBAL Connection

Source: https://github.com/doctrine/doctrinebundle/blob/3.2.x/docs/en/configuration.rst

Defines a database connection for Doctrine DBAL. Specify connection parameters like server, database name, and SSL mode.

```xml
<doctrine:connection
                            name="default"
                            driver="pdo_mysql"
                            charset="utf8mb4"
                            server="127.0.0.1"
                            port="3306"
                            default_dbname="test"
                            user="root"
                            password=""
                            options=""
                            service=""
                            servicename=""
                            sessionMode=""
                            sslmode=""
                            sslrootcert=""
                            sslcert=""
                            sslkey=""
                            sslcrl=""
                            pooled=""
                            MultipleActiveResultSets=""
                        />
```

--------------------------------

### Register Event Listener with XML Configuration

Source: https://github.com/doctrine/doctrinebundle/blob/3.2.x/docs/en/event-listeners.rst

Define event listeners in XML by using the 'doctrine.event_listener' tag on a service. The 'event' attribute is mandatory, and 'priority' and 'connection' can be specified for finer control.

```xml
<!-- config/services.xml -->
<?xml version="1.0" encoding="UTF-8" ?>
<container xmlns="http://symfony.com/schema/dic/services"
    xmlns:doctrine="http://symfony.com/schema/dic/doctrine">
    <services>
        <!-- ... -->

        <!--
            * 'event' is the only required option that defines the lifecycle listener
            * 'priority': used when multiple subscribers or listeners are associated to the same event
            *             (default priority = 0; higher numbers = listener is run earlier)
            * 'connection': restricts the listener to a specific Doctrine connection
        -->
        <service id="App\EventListener\SearchIndexer">
            <tag name="doctrine.event_listener"
                event="postPersist"
                priority="500"
                connection="default"/>
        </service>
    </services>
</container>
```

--------------------------------

### Configure Default Table Options

Source: https://github.com/doctrine/doctrinebundle/blob/3.2.x/docs/en/configuration.rst

Sets default options for all tables created by Doctrine ORM. This includes character set, collation, and storage engine.

```xml
<doctrine:default-table-option name="charset">utf8mb4</doctrine:default-table-option>
<doctrine:default-table-option name="collation">utf8_unicode_ci</doctrine:default-table-option>
<doctrine:default-table-option name="engine">InnoDB</doctrine:default-table-option>
```

--------------------------------

### Configure ORM Second-Level Cache Logger

Source: https://github.com/doctrine/doctrinebundle/blob/3.2.x/docs/en/configuration.rst

Configures a logger for ORM's second-level cache operations. Specify the logger name and service.

```xml
<doctrine:logger
                                name=""
                                service=""
                            />
```