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 While most developers stop at  no tenen la profunditat arquitectònica que ofereix aquest component. En aquesta guia, explorarem les implementacions avançades de a Symfony 7.3, avançant més enllà de la generació bàsica per abordar la fragmentació de la base de dades, la paginació basada en cursor i la idempotència determinista. “let’s just use UUID v4” symfony/uid Installation & Prerequisites We are using   (assuming modern 7.x features) and  . Symfony 7.3 Doctrine ORM 3 Ensure your   reflects the following dependencies. We strictly use   and its  . composer.json symfony/uid Doctrine integration composer require symfony/uid symfony/doctrine-bridge doctrine/orm
 Correcció del rendiment de la base de dades: UUID v7 L'error més comú en les aplicacions modernes de Symfony és utilitzar  as a  . UUID v4 primary key The Problem: Index Fragmentation UUID v4 is completely random. When you insert a random ID into a MySQL/PostgreSQL clustered index (B-Tree), the database has to constantly rebalance the tree to insert the new page in the “middle” of the index. This causes  , killing insert performance as the table grows. massive page splitting and fragmentation La solució: UUID v7 UUID v7 (standardized in RFC 9562 and fully supported in Symfony 7.x) combines a   with random data. This makes them   (time-ordered). They insert at the end of the B-Tree, just like an auto-increment integer, but retain the uniqueness and distributed nature of a UUID. Unix timestamp (millisecond precision) strictly monotonic Implementation Do not rely on Doctrine’s  magia, que sovint està predeterminat a v4. en comptes d'això, inicialitzar l'ID en el constructor. Això crea una entitat "Persistència Ignorant" on l'ID està disponible abans de la 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:  automàticament gestiona la conversió. per defecte, emmagatzema com  (readable) or   (efficient) depending on your platform configuration. For high-volume systems, always configure Doctrine to use   to  Espai d’emmagatzematge per ID. ‘uuid’ CHAR(36) BINARY(16) BINARY(16) save 55% Verificació 
 
 
 
 Generate a migration:  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). High-Performance Pagination with ULIDs Pàgines utilitzades  and  La base de dades ha de comptar i descartar milers de files per arribar a la pàgina 100. , but this usually requires a unique, sortable column (like  ). Timestamps are risky because two events can happen at the exact same microsecond. OFFSET LIMIT Keyset Pagination (Cursor-based) created_at Identificadors compatibles de 128 bits Sortida de sort. ULIDs (Universally Unique Lexicographically Sortable Identifier) lexicographically La estratègia We will use a  . Because ULIDs are sortable strings, we can simply say:  ULID as the primary key “Give me 10 items where 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) En els sistemes distribuïts (per exemple, CQRS o Event Sourcing), sovint rebeu el mateix missatge dues vegades (almenys un cop de lliurament).  is deterministic. Given a   and a   (input string), it always produces the same UUID. UUID v5 Namespace Name Escenari: Importar productes des de 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);
 URLs de vanitat: abreujant UIDs per a humans i de l’esquerra ( ) are ugly in URLs. YouTube uses Base64/Base58. Symfony Uid has built-in support for  (estil Bitcoin, sense caràcters ambigus com 0/O, I/l) i . 123e4567-e89b-12d3-a456–426614174000 Base58 Base32 Podem crear una que converteix automàticament UIDs a Base58 quan s'envien respostes JSON i de tornada a UUIDs quan es reben sol·licituds. 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: Stores optimized 16-byte binary. API Response:   (Friendly, copy-pasteable). {“id”: “BukQLMwS8W5g32”} API Request: Client sends  , Symfony converts it back to the correct UUID for the database query. BukQLMwS8W5g32 Testing: Mocking the Unpredictable Provar UUIDs és notoriament difícil perquè  changes every millisecond. Symfony 7 provides the  per resoldre això. 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   into your services rather than using   directly if you require strict testability. Symfony\Component\Uid\Factory\UuidFactory new UuidV7() The Benchmark Demostrar l’impacte de les actuacions  vs  , we need to measure the “Page Splitting” effect in the database. Random IDs force the database to constantly re-balance the B-Tree index, while Monotonic IDs append to the end. UUID v7 (Monotonic) UUID v4 (Random) This benchmark requires: 
 
 
  installed (composer require — dev phpbench/phpbench). PhpBench Una instància MySQL/MariaDB en execució (definida en el seu .env). Create this file at  Aquest guió inicia el nucli de la simfonia per obtenir la connexió de la base de dades, assegura l'existència de les taules i després mesura la velocitat d'inserció crua. 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: Executa el següent comandament al teu 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: Probablement veureu una sortida similar a aquesta (els temps variaran segons el maquinari): +-----------------+-------+---------+----------+----------+---------+
| 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   has a lower mean time and significantly  . Key Takeaway: benchInsertV7 lower standard deviation (stdev) 
 
 
 V7 és més ràpid perquè la base de dades simplement aplega la pàgina al costat dret del B-arbre. Stdev: V4 és erràtic. de vegades arriba a un punt "afortunat", però sovint desencadena un "Page Split" (operació cara per moure les dades), causant pics en la latència. Conclusió For too long, developers have treated database identifiers as a simple implementation detail — defaulting to   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   of a UUID with the  d’un nombre sencer (UUID v7). podem tenir  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 La transició a aquests estàndards moderns és un dels refactors de ROI més alts que podeu realitzar en una aplicació de Symfony en creixement. costa poc en codi però paga dividends en salut de la base de dades i usabilitat d'API. Let’s Build Better Systems Escric regularment sobre l'arquitectura de Simfonia d'alt rendiment, els interns de la Doctrina i els patrons distribuïts.  in your legacy stack: UUID v7 
 
 
   Connect with me: https://www.linkedin.com/in/matthew-mochalkin/  Drop a comment below with your experience regarding index fragmentation. Discuss: https://www.linkedin.com/in/matthew-mochalkin/ Let’s stay in touch and keep pushing the standard.

Read My Stories

Aquest àudio és produït a l'idioma original de la història!

The Quiet Bottleneck in Your Symfony App: Índexs fragmentats i UUIDs aleatoris

About Author

COMENTARIS

Etiquetes penjant

AQUEST ARTICLE VA SER PRESENTAT A

Related Stories

What Are Writers' Biggest Struggles in 2025?

Startups of The Year: Meet the Commerce Industry

Startups of The Year: Meet the Cybersecurity Industry

Startups of The Year: Meet the Programming Industry

What Are Writers' Biggest Struggles in 2025?

Startups of The Year: Meet the Commerce Industry

Startups of The Year: Meet the Cybersecurity Industry

Startups of The Year: Meet the Programming Industry

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps