In the monolithic era,   was the undisputed king of database identifiers. It was simple, small (4 bytes) and naturally sorted. But as we moved toward distributed systems, microservices and high-concurrency APIs, the integer ID began to show its cracks. It leaks business intelligence (competitors can guess your volume), it complicates database merging/sharding and it requires a round-trip to the database just to know the identity of a new object. id INT AUTO_INCREMENT Hoewel de meeste ontwikkelaars stoppen ze missen de architecturale diepte die deze component biedt. In deze gids zullen we geavanceerde implementaties van In Symfony 7.3 gaan we verder dan de basisgeneratie om databankfragmentatie, cursor-gebaseerde paginatie en deterministische idempotentie aan te pakken. “let’s just use UUID v4” symfony/uid Installatie & voorwaarden We are using   (assuming modern 7.x features) and  . Symfony 7.3 Doctrine ORM 3 Zorg voor uw  reflects the following dependencies. We strictly use  en zijn . composer.json symfony/uid Doctrine integration composer require symfony/uid symfony/doctrine-bridge doctrine/orm
 The Database Performance Fix: UUID v7 The most common mistake in modern Symfony apps is using   as a  . UUID v4 primary key Het probleem: indexfragmentatie UUID v4 is volledig willekeurig.Wanneer u een willekeurige ID invoegt in een MySQL/PostgreSQL geclusterde index (B-Tree), moet de database de boom voortdurend opnieuw in evenwicht brengen om de nieuwe pagina in de "middle" van de index te plaatsen. , killing insert performance as the table grows. massive page splitting and fragmentation De oplossing: UUID v7 UUID v7 (gestandaardiseerd in RFC 9562 en volledig ondersteund in Symfony 7.x) combineert een  with random data. This makes them  Ze voegen aan het einde van de B-boom, net als een auto-increment integer, maar behouden de uniciteit en gedistribueerde aard van een UUID. Unix timestamp (millisecond precision) strictly monotonic Uitvoering Vertrouw niet op de doctrine magie, die vaak standaard naar v4 gaat.In plaats daarvan, initialiseren de ID in de constructor.Dit creëert een "Persistentie Ignorant" entiteit waar de ID beschikbaar is voor de flush. @GeneratedValue @GeneratedValue //src/Entity/Transaction.php

namespace App\Entity;

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

#[ORM\Entity]
#[ORM\Table(name: 'transactions')]
class Transaction
{
    #[ORM\Id]
    #[ORM\Column(type: 'uuid', unique: true)]
    private Uuid $id;

    #[ORM\Column(type: 'string', length: 255)]
    private string $status;

    public function __construct(string $status)
    {
        // Explicitly generate v7 for time-ordered performance
        $this->id = new UuidV7(); 
        $this->status = $status;
    }

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

    // ... getters and setters
}
 Doctrine’s type:  automatisch de conversie verwerkt. Standaard wordt de conversie als (leesbaar) of  (efficient) depending on your platform configuration. For high-volume systems, always configure Doctrine to use  Twee opslagruimte per ID. ‘uuid’ CHAR(36) BINARY(16) BINARY(16) save 55% Verificatie 
 
 
 
 Een migratie genereren: php bin/console make:migration Inspect the SQL. You should see the column defined. Run a test script creating 10 entities. Check the DB; the IDs should be sequentially increasing (the first characters will be identical). Hoogwaardige paginatie met ULIDs Paginatie Gebruik  and  De database moet duizenden rijen tellen en weggooien om pagina 100 te bereiken. , but this usually requires a unique, sortable column (like  Timestamps zijn risicovol omdat twee gebeurtenissen op exact dezelfde microseconde kunnen gebeuren. OFFSET LIMIT Keyset Pagination (Cursor-based) created_at  are 128-bit compatible identifiers that are  Sorteerbaar zijn. ULIDs (Universally Unique Lexicographically Sortable Identifier) lexicographically The Strategy We will use a  . Because ULIDs are sortable strings, we can simply say:  ULID as the primary key “Geef me 10 items waar ID > [Last Seen ULID]”. //src/Entity/EventLog.php

namespace App\Entity;

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

#[ORM\Entity(repositoryClass: \App\Repository\EventLogRepository::class)]
class EventLog
{
    #[ORM\Id]
    #[ORM\Column(type: 'ulid', unique: true)]
    private Ulid $id;

    #[ORM\Column(type: 'text')]
    private string $payload;

    public function __construct(string $payload)
    {
        $this->id = new Ulid();
        $this->payload = $payload;
    }

    public function getId(): Ulid
    {
        return $this->id;
    }
}
 //src/Repository/EventLogRepository.php

namespace App\Repository;

use App\Entity\EventLog;
use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
use Doctrine\Persistence\ManagerRegistry;
use Symfony\Component\Uid\Ulid;

class EventLogRepository extends ServiceEntityRepository
{
    public function __construct(ManagerRegistry $registry)
    {
        parent::__construct($registry, EventLog::class);
    }

    /**
     * @return EventLog[]
     */
    public function findAfterCursor(?Ulid $cursor, int $limit = 20): array
    {
        $qb = $this->createQueryBuilder('e')
            ->orderBy('e.id', 'ASC')
            ->setMaxResults($limit);

        if ($cursor) {
            // Efficient index seek
            $qb->andWhere('e.id > :cursor')
               ->setParameter('cursor', $cursor->toBinary()); 
               // Note: Depending on your DB type setup, you might pass the object or binary.
               // The symfony bridge usually handles the object, but explicit binary prevents ambiguity.
        }

        return $qb->getQuery()->getResult();
    }
}
  This query hits the Primary Key index directly. It is   complexity regardless of whether you are on page 1 or page 1,000,000. Why this matters? O(1) Idempotency & Deterministic IDs (UUID v5) In gedistribueerde systemen (bijv. CQRS of Event Sourcing) ontvangt u vaak hetzelfde bericht twee keer (ten minste één keer).  is deterministic. Given a   and a  (input string), het produceert altijd dezelfde UUID. UUID v5 Namespace Name Scenario: Producten importeren uit CSV You are importing products from a legacy system that has SKUs, but no UUIDs. You want to ensure that if you run the import script twice, you don’t create duplicate rows, but update the existing “identity”. //src/Service/ProductIdGenerator.php

namespace App\Service;

use Symfony\Component\Uid\Uuid;

class ProductIdGenerator
{
    // A random UUID v4 constant serving as our private Namespace
    // Generated once via `php bin/console uuid:generate`
    private const PRODUCT_NAMESPACE = 'd2e294c8-3829-410e-8baf-7359a58f7051';

    public function generateForSku(string $sku): Uuid
    {
        // v5 uses SHA-1 hashing to ensure uniqueness based on input
        return Uuid::v5(Uuid::fromString(self::PRODUCT_NAMESPACE), $sku);
    }
}
 Usage in a Command: // Inside a command or service
$sku = 'WIDGET-ABC-123';
$deterministicId = $this->idGenerator->generateForSku($sku);

// $deterministicId will ALWAYS be '...' for SKU 'WIDGET-ABC-123'
// You can now safely use:
// $em->getReference(Product::class, $deterministicId);
 Vanity URL's: UID's voor mensen verkorten van de ( ) are ugly in URLs. YouTube uses Base64/Base58. Symfony Uid has built-in support for   (Bitcoin style, no ambiguous characters like 0/O, I/l) and  . 123e4567-e89b-12d3-a456–426614174000 Base58 Base32 We can create a  dat UID's automatisch converteert naar Base58 bij het verzenden van JSON-reacties en terug naar UUID's bij het ontvangen van verzoeken. Symfony Serializer Normalizer // src/Serializer/UuidBase58Normalizer.php

namespace App\Serializer;

use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
use Symfony\Component\Uid\Uuid;
use Symfony\Component\DependencyInjection\Attribute\Autowire;

class UuidBase58Normalizer implements NormalizerInterface, DenormalizerInterface
{
    public function normalize(mixed $object, ?string $format = null, array $context = []): string|array
    {
        /** @var Uuid $object */
        return $object->toBase58();
    }

    public function supportsNormalization(mixed $data, ?string $format = null, array $context = []): bool
    {
        return $data instanceof Uuid;
    }

    public function denormalize(mixed $data, string $type, ?string $format = null, array $context = []): Uuid
    {
        // Automatically handle incoming Base58 strings back to UUID objects
        return Uuid::fromBase58($data);
    }

    public function supportsDenormalization(mixed $data, string $type, ?string $format = null, array $context = []): bool
    {
        return is_string($data) && is_a($type, Uuid::class, true);
    }
    
    public function getSupportedTypes(?string $format): array
    {
        return [
            Uuid::class => true,
        ];
    }
}
 The Result: 
 
 
 
 Database: Opslagplaatsen geoptimaliseerd 16-byte binaire. API Response:   (Friendly, copy-pasteable). {“id”: “BukQLMwS8W5g32”} API Verzoek: Client stuurt BukQLMwS8W5g32, Symfony converteert het terug naar de juiste UUID voor de database query. Test: Het onvoorspelbare belachelijk maken Testing UUIDs is notoriously difficult because  elke milliseconde verandert. Symfony 7 biedt de  to solve this. Uuid::v7() MockUuidFactory // tests/Service/TransactionTest.php

namespace App\Tests\Service;

use PHPUnit\Framework\TestCase;
use Symfony\Component\Uid\Factory\MockUuidFactory;
use Symfony\Component\Uid\Uuid;
use Symfony\Component\Uid\UuidV7;

class TransactionTest extends TestCase
{
    public function testItGeneratesPredictableIds(): void
    {
        // Define a sequence of IDs the factory should return
        $expectedId1 = Uuid::fromString('018e69c0-1c00-7c22-b9d6-5c4d00000001');
        $expectedId2 = Uuid::fromString('018e69c0-1c00-7c22-b9d6-5c4d00000002');

        $factory = new MockUuidFactory([$expectedId1, $expectedId2]);

        // In your real service, you would inject UuidFactory and use it
        // $service = new TransactionService($factory);
        
        // Simulating usage:
        $id1 = $factory->create();
        $id2 = $factory->create();

        $this->assertTrue($id1->equals($expectedId1));
        $this->assertTrue($id2->equals($expectedId2));
    }
}
 To make this work in your application code, you should inject  In plaats van uw diensten te gebruiken direct als u strenge testbaarheid vereist. Symfony\Component\Uid\Factory\UuidFactory new UuidV7() De benchmark Om de prestatie-impact van de VS Willekeurige ID's dwingen de database om voortdurend de B-Tree-index opnieuw in evenwicht te brengen, terwijl Monotonic ID's aan het einde worden gehecht. UUID v7 (Monotonic) UUID v4 (Random) This benchmark requires: 
 
 
 PhpBench geïnstalleerd (composer vereist — dev phpbench/phpbench). Een lopende MySQL/MariaDB-instantie (definieerd in uw .env). Create this file at  . This script bootstraps the Symfony Kernel to get the database connection, ensures tables exist and then measures raw insert speed. benchmark/UuidInsertBench.php // benchmark/UuidInsertBench.php

namespace App\Benchmark;

use App\Kernel;
use Doctrine\DBAL\Connection;
use PhpBench\Attributes as Bench;
use Symfony\Component\Dotenv\Dotenv;
use Symfony\Component\Uid\Uuid;
use Symfony\Component\Uid\UuidV7;

#[Bench\BeforeMethods('setUp')]
#[Bench\AfterMethods('tearDown')]
class UuidInsertBench
{
    private Connection $connection;
    private Kernel $kernel;

    public function setUp(): void
    {
        // Bootstrap Symfony to get the DB connection
        require_once __DIR__ . '/../vendor/autoload.php';
        (new Dotenv())->bootEnv(__DIR__ . '/../.env');
        
        $this->kernel = new Kernel($_SERVER['APP_ENV'], (bool) $_SERVER['APP_DEBUG']);
        $this->kernel->boot();
        
        $this->connection = $this->kernel->getContainer()->get('doctrine.dbal.default_connection');

        // distinct tables to isolate index behavior
        $this->createTable('bench_uuid_v4');
        $this->createTable('bench_uuid_v7');
        
        // Seed with initial data to ensure the index has depth
        // Fragmentation issues only appear when the table isn't empty
        $this->seedTable('bench_uuid_v4', false);
        $this->seedTable('bench_uuid_v7', true);
    }

    /**
     * Scenario: Insert into a fragmented index (Random IDs)
     */
    #[Bench\Revs(100)]
    #[Bench\Iterations(5)]
    public function benchInsertV4(): void
    {
        $uuid = Uuid::v4()->toBinary();
        $this->connection->executeStatement(
            'INSERT INTO bench_uuid_v4 (id, payload) VALUES (:id, :payload)',
            ['id' => $uuid, 'payload' => 'benchmark_payload']
        );
    }

    /**
     * Scenario: Insert into a sorted index (Monotonic IDs)
     */
    #[Bench\Revs(100)]
    #[Bench\Iterations(5)]
    public function benchInsertV7(): void
    {
        $uuid = new UuidV7(); // Explicitly V7
        $this->connection->executeStatement(
            'INSERT INTO bench_uuid_v7 (id, payload) VALUES (:id, :payload)',
            ['id' => $uuid->toBinary(), 'payload' => 'benchmark_payload']
        );
    }

    private function createTable(string $tableName): void
    {
        $sql = <<<SQL
            CREATE TABLE IF NOT EXISTS $tableName (
                id BINARY(16) NOT NULL,
                payload VARCHAR(255),
                PRIMARY KEY(id)
            ) ENGINE=InnoDB; 
SQL;
        $this->connection->executeStatement($sql);
        // Truncate to ensure clean state per run if needed, 
        // though for this test growing the table is part of the stress test.
        $this->connection->executeStatement("TRUNCATE TABLE $tableName");
    }

    private function seedTable(string $tableName, bool $isV7): void
    {
        // Pre-fill 5,000 rows to create an initial B-Tree structure
        $sql = "INSERT INTO $tableName (id, payload) VALUES (:id, 'seed_data')";
        
        $stmt = $this->connection->prepare($sql);
        
        for ($i = 0; $i < 5000; $i++) {
            $id = $isV7 ? (new UuidV7())->toBinary() : Uuid::v4()->toBinary();
            $stmt->bindValue('id', $id);
            $stmt->executeQuery();
        }
    }

    public function tearDown(): void
    {
        $this->connection->executeStatement('DROP TABLE IF EXISTS bench_uuid_v4');
        $this->connection->executeStatement('DROP TABLE IF EXISTS bench_uuid_v7');
    }
}
 Running the Benchmark: Voer de volgende opdracht uit in uw terminal: # Allow 2GB memory for the seeding process if necessary
php -d memory_limit=2G vendor/bin/phpbench run benchmark/UuidInsertBench.php --report=default
 Interpreting Results: You will likely see output similar to this (times will vary based on hardware): +-----------------+-------+---------+----------+----------+---------+
| subject         | revs  | mem_peak| mode     | mean     | stdev   |
+-----------------+-------+---------+----------+----------+---------+
| benchInsertV4   | 100   | 14.20Mb | 850.12μs | 910.45μs | 55.12μs |
| benchInsertV7   | 100   | 14.20Mb | 520.40μs | 535.10μs | 12.05μs |
+-----------------+-------+---------+----------+----------+---------+
  You should observe that  heeft een lagere gemiddelde tijd en aanzienlijk . Key Takeaway: benchInsertV7 lower standard deviation (stdev) 
 
 
 Betekenis: V7 is sneller omdat de database gewoon de pagina aan de rechterkant van de B-Tree hecht. Soms treft het een "geluksvolle" plek, maar vaak triggert het een "pagina splitsing" ( dure operatie om gegevens te verplaatsen), waardoor spikes in latentie. Conclusion Te lang hebben ontwikkelaars database-id's behandeld als een eenvoudige implementatiedetails - standaard  out of habit or   out of necessity. As we’ve seen, this choice has profound downstream effects on your application’s fragmentation, pagination speed and distributed integrity. AUTO_INCREMENT UUID v4 With Symfony 7.3 and the Uid component, we no longer have to compromise. We can have the  van een UUID met de  of an integer (UUID v7). We can have   without exposing leaky timestamps (ULID). We can communicate with our frontend in   formats (Base58) while keeping our storage strictly binary. distributed uniqueness insert performance cursor-based pagination human-friendly Het overschakelen naar deze moderne normen is een van de hoogste ROI-refactoren die u kunt uitvoeren op een groeiende Symfony-toepassing. Bouw betere systemen Ik schrijf regelmatig over high-performance Symfony architectuur, Doctrine internals en gedistribueerde patronen. In uw legacy stack: UUID v7 
 
 
 Neem contact op met mij: https://www.linkedin.com/in/matthew-mochalkin/ Discussie: Laat een commentaar hieronder achter met uw ervaring met indexfragmentatie. https://www.linkedin.com/in/matthew-mochalkin/ Laten we in contact blijven en de standaard blijven duwen.

Read My Stories

Deze audio wordt geproduceerd in de originele taal van het verhaal!

De stille bottleneck in je Symfony-app: gefragmenteerde indexen en willekeurige UUID's

About Author

OPMERKINGEN

LABELS

DIT ARTIKEL WERD GEPRESENTEERD IN

Related Stories

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps