En la era monolítica, era el indiscutible rey de los identificadores de bases de datos. Era simple, pequeño (4 bytes) y ordenado de forma natural. Pero a medida que nos movíamos hacia sistemas distribuidos, microservicios y APIs altamente competitivas, el ID de números enteros comenzó a mostrar sus grietas. Cubre la inteligencia empresarial (los competidores pueden adivinar su volumen), complica la fusión / división de bases de datos y requiere una vuelta a la base de datos solo para conocer la identidad de un nuevo objeto. id INT AUTO_INCREMENT Mientras que la mayoría de los desarrolladores se falta la profundidad arquitectónica que ofrece este componente. En esta guía, exploraremos las implementaciones avanzadas de En Symfony 7.3, se va más allá de la generación básica para abordar la fragmentación de bases de datos, la paginación basada en cursores y la idempotencia determinista. “let’s just use UUID v4” symfony/uid Instalación y Prerequisitos Estamos utilizando (suponiendo características modernas de 7.x) y . Symfony 7.3 Doctrine ORM 3 Asegúrese de su Refleja las siguientes dependencias. usamos estrictamente y su . composer.json symfony/uid Doctrine integration composer require symfony/uid symfony/doctrine-bridge doctrine/orm
 Fijar el rendimiento de la base de datos: UUID v7 El error más común en las aplicaciones modernas de Symfony es usar como a . UUID v4 primary key The Problem: Index Fragmentation UUID v4 es completamente aleatorio. Cuando se inserta una ID aleatoria en un índice agrupado MySQL/PostgreSQL (B-Tree), la base de datos tiene que reequilibrar constantemente el árbol para insertar la nueva página en el “medio” del índice. , matando el rendimiento de inserción a medida que la mesa crece. massive page splitting and fragmentation Solución: UUID v7 UUID v7 (estandarizado en RFC 9562 y totalmente soportado en Symfony 7.x) combina una con los datos aleatorios. Esto los hace Insertan al final del Árbol B, al igual que un número entero de autoincremento, pero conservan la singularidad y la naturaleza distribuida de un UUID. Unix timestamp (millisecond precision) strictly monotonic Implementación No confíe en la doctrina magia, que a menudo está por defecto en v4. En lugar de esto, inicialice el ID en el constructor. Esto crea una entidad "Persistencia Ignorante" donde el ID está disponible antes del flush. El valor generado El valor generado //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
}
 El tipo de doctrina: automáticamente la conversión. Por defecto, se almacena como (Leer más) o (eficiente) dependiendo de la configuración de su plataforma. Para sistemas de alto volumen, siempre configure Doctrine para Dos Espacio de almacenamiento por ID. ‘uuid’ CHAR(36) BINARY(16) BINARY(16) save 55% Verificación 
 
 
 
 Generar una migración: php bin/console make:migración Revisa el SQL. Debes ver la columna definida. Compruebe el DB; los IDs deben ser secuencialmente aumentando (los primeros caracteres serán idénticos). Paginado de alto rendimiento con ULIDs Página Usando y La base de datos debe contar y descartar miles de líneas para llegar a la página 100. , pero esto generalmente requiere una columna única y ordenable (como Los timestamps son arriesgados porque dos eventos pueden ocurrir en el mismo microsegundo. OFFSET LIMIT Keyset Pagination (Cursor-based) created_at son identificadores compatibles de 128 bits que son SORTABLE ULIDs (Universally Unique Lexicographically Sortable Identifier) lexicographically La estrategia Nosotros utilizaremos a Debido a que los ULIDs son cadenas ordenables, podemos decir simplemente: ULID as the primary key “Dame 10 elementos donde ID > [Última vista 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();
    }
}
 Esta consulta ataca directamente el índice de clave primaria. La complejidad no importa si estás en la página 1 o la página 1.000.000. Why this matters? O(1) Idempotencia y Identificadores Deterministas (UUID v5) En sistemas distribuidos (por ejemplo, CQRS o Event Sourcing), a menudo recibe el mismo mensaje dos veces (al menos una vez de entrega). es determinista. dado a y a (entrada de cadena), siempre produce el mismo UUID. UUID v5 Namespace Name Importación de productos de CSV Usted está importando productos de un sistema heredado que tiene SKUs, pero no UUIDs. desea asegurarse de que si ejecuta el script de importación dos veces, no crea filas duplicadas, sino que actualiza la "identidad" existente. //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 vanidad: abreviando UIDs para humanos En la actualidad ( YouTube utiliza Base64/Base58. Symfony Uid tiene soporte (estilo Bitcoin, sin caracteres ambiguos como 0/O, I/l) y . 123e4567-e89b-12d3-a456–426614174000 Base58 Base32 Podemos crear una que automáticamente convierte UIDs a Base58 cuando se envían respuestas JSON y de vuelta a UUIDs cuando se reciben solicitudes. 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: 
 
 
 
 Base de datos: Almacena optimizado binario de 16 bytes. API Respuesta: {“id”: “BukQLMwS8W5g32”} (Friendly, copy-pasteable) API Request: El cliente envía BukQLMwS8W5g32, Symfony lo convierte de vuelta al UUID correcto para la consulta de la base de datos. Título: Imitar lo impredecible Las pruebas de los UUID son notoriamente difíciles porque cambios cada milisegundo. Symfony 7 proporciona la para resolver esto. 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));
    }
}
 Para hacer este trabajo en su código de aplicación, debe inyectar En lugar de utilizar sus servicios directamente si necesita una estricta probabilidad. Symfony\Component\Uid\Factory\UuidFactory new UuidV7() El Benchmark Para demostrar el impacto de vs Los ID aleatorios obligan a la base de datos a reequilibrar constantemente el índice B-Tree, mientras que los ID monotónicos se añaden al final. UUID v7 (Monotonic) UUID v4 (Random) This benchmark requires: 
 
 
 PhpBench instalado (compositor requiere — dev phpbench/phpbench). Una instancia MySQL/MariaDB en ejecución (definida en su .env). Crea este archivo en Este script arranca el núcleo de la sinfonía para obtener la conexión de la base de datos, asegura la existencia de las tablas y luego mide la velocidad de inserción cruda. 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 siguiente comando en tu 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: Probablemente verá una salida similar a esta (los tiempos varían según el 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 |
+-----------------+-------+---------+----------+----------+---------+
 Usted debe observar que Tiene un tiempo medio más bajo y significativamente . Key Takeaway: benchInsertV7 lower standard deviation (stdev) 
 
 
 Significado: V7 es más rápido porque la base de datos simplemente adhiere la página al lado derecho del B-Tree. Stdev: V4 es errático.A veces golpea un punto "afortunado", pero a menudo desencadena una "Página dividida" (operación costosa para mover los datos), causando picos en la latencia. Conclusión Durante demasiado tiempo, los desarrolladores han tratado los identificadores de bases de datos como un simple detalle de implementación - por defecto fuera del hábito o Como hemos visto, esta elección tiene profundos efectos descendentes en la fragmentación de su aplicación, la velocidad de paginado y la integridad distribuida. AUTO_INCREMENT UUID v4 Con Symfony 7.3 y el componente Uid, ya no tenemos que comprometernos. de una UDI con la de un número entero (UUID v7). podemos tener sin exponer los timestamps de fuga (ULID).Podemos comunicarnos con nuestro frontend en formatos (Base58) manteniendo nuestro almacenamiento estrictamente binario. distributed uniqueness insert performance cursor-based pagination human-friendly El cambio a estos estándares modernos es uno de los refactores de ROI más altos que puede realizar en una aplicación Symfony en crecimiento. Construimos mejores sistemas Regularmente escribo sobre la arquitectura Symfony de alto rendimiento, los internos de la Doctrina y los patrones distribuidos. Si está abordando desafíos avanzados similares o tiene preguntas sobre la implementación En su legado: UUID v7 
 
 
 Contacta conmigo: https://www.linkedin.com/in/matthew-mochalkin/ Discusión: Deje un comentario a continuación con su experiencia con respecto a la fragmentación de índices. https://www.linkedin.com/in/matthew-mochalkin/ Manténgase en contacto y siga empujando el estándar.

Read My Stories

Este audio es producido en el idioma original de la historia!

The Quiet Bottleneck in Your Symfony App: Índices fragmentados y UUID aleatorios

About Author

COMENTARIOS

ETIQUETAS

ESTE ARTÍCULO FUE PRESENTADO EN

Related Stories

Las capas invisibles: por qué las entrevistas con los usuarios son un activo irremplazable

Valhalla de Floki se une como patrocinador asociado de la gira de la India por Sri Lanka

Una guía del arquitecto para crear una arquitectura de referencia para un lago de datos de IA/ML

El modelo Bitcoin UTXO, impulsando un ecosistema único

Las capas invisibles: por qué las entrevistas con los usuarios son un activo irremplazable

Valhalla de Floki se une como patrocinador asociado de la gira de la India por Sri Lanka

Una guía del arquitecto para crear una arquitectura de referencia para un lago de datos de IA/ML

El modelo Bitcoin UTXO, impulsando un ecosistema único

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps