I den monolithiske tidsalder, var den ubestridte konge af database-identifikatorer. Det var simpelt, lille (4 byte) og naturligt sorteret. Men da vi bevægede os mod distribuerede systemer, microservices og højt konkurrencedygtige API'er, begyndte hele ID'en at vise sine revner. Det lækker business intelligence (konkurrenter kan gætte dit volumen), det komplicerer database fusion / sharding og det kræver en rundtur til databasen bare for at kende identiteten af et nyt objekt. id INT AUTO_INCREMENT Mens de fleste udviklere holder op de savner den arkitektoniske dybde, som denne komponent tilbyder. I denne guide vil vi udforske avancerede implementeringer af i Symfony 7.3, bevæger sig ud over grundlæggende generation for at tackle database fragmentering, cursor-baseret pagination og deterministisk idempotens. “let’s just use UUID v4” symfony/uid Installation og forudsætninger Vi bruger (forudsat moderne 7.x funktioner) og . Symfony 7.3 Doctrine ORM 3 Sørg for din afhængighederne. vi anvender strengt og dens . composer.json symfony/uid Doctrine integration composer require symfony/uid symfony/doctrine-bridge doctrine/orm
 Databasens ydeevne Fix: UUID v7 Den mest almindelige fejl i moderne Symfony apps er at bruge som a . UUID v4 primary key Uddybende artikel: Index fragmentering UUID v4 er helt tilfældigt. Når du indsætter et tilfældigt ID i et MySQL/PostgreSQL-klusteret indeks (B-Tree), skal databasen konstant genbalancere træet for at indsætte den nye side i indeksets "middle". , dræber indsæt ydeevne som bordet vokser. massive page splitting and fragmentation Løsning: UUID v7 UUID v7 (standardiseret i RFC 9562 og fuldt understøttet i Symfony 7.x) kombinerer en med tilfældige data. Dette gør dem De indsætter i slutningen af B-træet, ligesom en auto-increment helhed, men bevarer den unikke og distribuerede karakter af en UUID. Unix timestamp (millisecond precision) strictly monotonic gennemførelse Du skal ikke stole på doktrinen I stedet skal du initialisere ID'et i konstruktoren. Dette skaber en "Persistence Ignorant" entitet, hvor ID'et er tilgængeligt før flush. Genereret værdi Genereret værdi //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
}
 Typer af doktrin: automatisk håndterer konverteringen. Som standard gemmer den som (Læseligt) eller (effektiv) afhængigt af din platformkonfiguration. For store systemer skal du altid konfigurere Doctrine til at bruge To af lagringsplads pr. ID. ‘uuid’ CHAR(36) BINARY(16) BINARY(16) save 55% Verifikation 
 
 
 
 Generer en migration: php bin/console make:migration Undersøg SQL. Du bør se kolonnen defineret. Tjek DB; ID'erne skal være sekventielt stigende (de første tegn vil være identiske). Høj ydeevne Pagination med ULIDs Pagination ved brug og Databasen skal tælle og kassere tusindvis af rækker for at nå side 100. , men dette kræver normalt en unik, sorterbar kolonne (som Timestamps er risikable, fordi to begivenheder kan ske på nøjagtig samme mikrosekund. OFFSET LIMIT Keyset Pagination (Cursor-based) created_at er 128-bit kompatible identifikatorer, der er Sorteret af. ULIDs (Universally Unique Lexicographically Sortable Identifier) lexicographically Strategien Vi vil bruge en Eftersom ULID'er er sorterbare strenge, kan vi simpelthen sige: ULID as the primary key “Giv mig 10 elementer, hvor 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();
    }
}
 Denne forespørgsel rammer primærnøgleindekset direkte. Uanset om du er på side 1 eller side 1.000.000. Why this matters? O(1) Idempotens og deterministiske ID'er (UUID v5) I distribuerede systemer (f.eks. CQRS eller Event Sourcing) modtager du ofte den samme besked to gange (mindst én gang). Det er afgørende. giv a og a (indtast strengen), det producerer altid den samme UUID. UUID v5 Namespace Name Scenario: Import af produkter fra CSV Du importerer produkter fra et forældet system, der har SKU'er, men ingen UUID'er. Du vil sikre, at hvis du kører importskriptet to gange, opretter du ikke duplikerede rækker, men opdaterer den eksisterende "identitet". //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'er: Forkortelse af UID'er til mennesker Håndværker ( ) er grimme i URL'er. YouTube bruger Base64 / Base58. Symfony Uid har indbygget (Bitcoin stil, ingen tvetydige tegn som 0/O, I/l) og . 123e4567-e89b-12d3-a456–426614174000 Base58 Base32 Vi kan skabe en som automatisk konverterer UID'er til Base58 ved afsendelse af JSON-svar og tilbage til UUID'er ved modtagelse af anmodninger. 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: Store optimeret 16-byte binære. API svar: {”id”: “BukQLMwS8W5g32”} (Friendly, copy-pasteable) API-anmodning: Klienten sender BukQLMwS8W5g32, og Symfony konverterer den tilbage til den korrekte UUID for databaseforespørgslen. Test: Spøg af det uforudsigelige Test af UUIDs er notorisk vanskeligt, fordi ændres hvert millisekund. Symfony 7 giver for at løse dette. 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));
    }
}
 For at gøre dette arbejde i din applikationskode, skal du injicere I stedet for at bruge dine tjenester Hvis du har brug for en stram test. Symfony\Component\Uid\Factory\UuidFactory new UuidV7() Det benchmark For at demonstrere virkningen af vs Random ID'er tvinger databasen til konstant at genbalancere B-Tree-indekset, mens Monotonic ID'er vedhæftes til slutningen. UUID v7 (Monotonic) UUID v4 (Random) This benchmark requires: 
 
 
 PhpBench installeret (composer require — dev phpbench/phpbench). En kørende MySQL/MariaDB-instans (defineret i din .env). Opret denne fil på Dette script bootstraps Symfony Kernel for at få databasen forbindelse, sikrer tabeller eksisterer og derefter måler rå indsættelse hastighed. 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: Kør følgende kommando i din 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: Du vil sandsynligvis se lignende output (tider vil variere afhængigt af 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 |
+-----------------+-------+---------+----------+----------+---------+
 Du bør observere, at har en lavere gennemsnitlig tid og betydeligt . Key Takeaway: benchInsertV7 lower standard deviation (stdev) 
 
 
 Betydning: V7 er hurtigere, fordi databasen simpelthen vedhæfter siden til højre side af B-træet. Sommetider rammer det et "heldigt" sted, men ofte udløser det en "Page Split" (dyr operation for at flytte data rundt), hvilket forårsager spikes i latens. Konklusionen I alt for lang tid har udviklere behandlet database-id'er som en simpel implementeringsdetalje - som standard Ud af vane eller Som vi har set, har dette valg dybe downstream-virkninger på din ansøgnings fragmentering, sideringshastighed og distribueret integritet. AUTO_INCREMENT UUID v4 Med Symfony 7.3 og Uid-komponenten behøver vi ikke længere at gå på kompromis. af en UUID med den af et heltal (UUID v7). vi kan have uden at udsætte lækage tidsstempler (ULID). Vi kan kommunikere med vores frontend i formater (Base58) samtidig med at vores lagring er strengt binær. distributed uniqueness insert performance cursor-based pagination human-friendly Skift til disse moderne standarder er en af de højeste ROI refaktorer, du kan udføre på en voksende Symfony-applikation. Vi bygger bedre systemer Jeg skriver regelmæssigt om højtydende Symfony-arkitektur, Doctrine internals og distribuerede mønstre, hvis du løser lignende avancerede udfordringer eller har spørgsmål om implementering I din legacy stack: UUID v7 
 
 
 Kontakt mig: https://www.linkedin.com/in/matthew-mochalkin/ Diskuter: Skriv en kommentar nedenfor med din erfaring med indeksfragmentering. https://www.linkedin.com/in/matthew-mochalkin/ Lad os holde kontakten og fortsætte med at skubbe standarden.

Read My Stories

Denne lyd er produceret på historiens originalsprog!

The Quiet Bottleneck i din Symfony-app: Fragmenterede indekser og tilfældige UUIDs

About Author

KOMMENTARER

HÆNG TAGS

DENNE ARTIKEL BLEV PRÆsenterET I

Related Stories

Avoid These Mistakes to Monetize Internet Products Profitably

Meet Google Cloud: HackerNoon Company of the Week

Meet Octopus Network: HackerNoon Company of the Week

Yale Media Relations for Entrepreneurs with Journalist Walter Thompson & HackerNoon CEO David Smooke

Avoid These Mistakes to Monetize Internet Products Profitably

Meet Google Cloud: HackerNoon Company of the Week

Meet Octopus Network: HackerNoon Company of the Week

Yale Media Relations for Entrepreneurs with Journalist Walter Thompson & HackerNoon CEO David Smooke

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps