Monolitinės eros metu, buvo neginčijamas duomenų bazių identifikatorių karalius. Tai buvo paprasta, maža (4 bytai) ir natūraliai rūšiuojama. Tačiau, kai mes pereiname prie paskirstytų sistemų, mikroservizų ir labai konkurencingų API, sveiko ID pradėjo rodyti savo įtrūkimus. Tai išsklaido verslo žvalgybos duomenis (konkurentai gali atspėti jūsų tūrį), tai apsunkina duomenų bazės susijungimą / suskaidymą ir reikalauja apsilankyti duomenų bazėje tik norint sužinoti naujo objekto tapatybę. id INT AUTO_INCREMENT Nors dauguma kūrėjų sustoja jie praleidžia architektūrinį gylį, kurį siūlo šis komponentas. Šiame vadove mes išnagrinėsime pažangias  in Symfony 7.3, moving beyond basic generation to tackle database fragmentation, cursor-based pagination and deterministic idempotency. “let’s just use UUID v4” symfony/uid Įrengimas ir sąlygos We are using   (assuming modern 7.x features) and  . Symfony 7.3 Doctrine ORM 3 Užtikrinkite savo Atspindi šias priklausomybes. mes griežtai naudojame ir jos . composer.json symfony/uid Doctrine integration composer require symfony/uid symfony/doctrine-bridge doctrine/orm
 Duomenų bazės veikimo taisyklė: UUID v7 Dažniausia klaida šiuolaikinėse „Symfony“ programose yra Kaip a . UUID v4 primary key Žyma: indeksų susiskaidymas UUID v4 yra visiškai atsitiktinis. Kai įtraukiate atsitiktinį ID į MySQL / PostgreSQL klasterinį indeksą (B-Tree), duomenų bazė turi nuolat persbalansuoti medį, kad įterptų naują puslapį į indeksą. , žudyti įterpimo efektyvumą, kai stalas auga. massive page splitting and fragmentation Atsiliepimai apie UUID v7 UUID v7 (standartizuotas RFC 9562 ir visiškai palaikomas „Symfony 7.x“) sujungia  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 Įgyvendinimas Do not rely on Doctrine’s   magic, which often defaults to v4. Instead, initialize the ID in the constructor. This creates a “Persistence Ignorant” entity where the ID is available before the flush. @GeneratedValue Gyventojų vertė //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
}
 Doktrinos tipai: automatiškai tvarko konvertavimą. pagal numatytuosius nustatymus jis saugomas kaip Skaityti daugiau (arba  (efficient) depending on your platform configuration. For high-volume systems, always configure Doctrine to use  dviejų  of storage space per ID. ‘uuid’ CHAR(36) BINARY(16) BINARY(16) save 55% Verification 
 
 
 
 Sukurkite migraciją: php bin/console make:migration Patikrinkite SQL. Turėtumėte matyti nustatytą stulpelį. Patikrinkite DB; ID turėtų būti nuosekliai didinamas (pirmieji simboliai bus identiški). High-Performance Pagination with ULIDs Puslapio naudojimas ir duomenų bazė turi suskaičiuoti ir išmesti tūkstančius eilučių, kad pasiektų puslapį 100. , tačiau tai paprastai reikalauja unikalios, rūšiuojamos stulpelio (pvz., ). Timestamps are risky because two events can happen at the exact same microsecond. OFFSET LIMIT Keyset Pagination (Cursor-based) created_at  are 128-bit compatible identifiers that are  Išsiskyrė ULIDs (Universally Unique Lexicographically Sortable Identifier) lexicographically Strategijos Mes naudosime 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) In distributed systems (e.g., CQRS or Event Sourcing), you often receive the same message twice (at-least-once delivery). If you generate a random ID every time you process an import, you create duplicates. yra deterministinis. duodamas a ir a (įvesti eilutę), ji visada gamina tą patį UUID. UUID v5 Namespace Name Scenarijus: Produktų importavimas iš CSV Importuojate produktus iš įprastos sistemos, kurioje yra SKU, bet nėra UUID. Norite įsitikinti, kad jei paleisite importavimo scenarijų du kartus, nesukursite dvigubų eilučių, bet atnaujinsite esamą „tapatybę“. //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: sutrumpinti UID žmonėms Šilutės ( ) 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 Galime sukurti a kuris automatiškai konvertuoja UID į Base58 siunčiant JSON atsakymus ir grįžta į UUID, kai gauna užklausas. 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 atsakymas: {“id”: “BukQLMwS8W5g32”} (Draugiškas, kopijuojamas įklijuojamas). API prašymas: Klientas siunčia BukQLMwS8W5g32, „Symfony“ konvertuoja jį atgal į teisingą duomenų bazės užklausos UUID. Žymos archyvas: neprognozuojamas Išbandyti UUID yra žinoma, kad sunku, nes pakeičiasi kas milisekundę. „Symfony 7“ suteikia Norėdami tai išspręsti. 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));
    }
}
 Norėdami tai padaryti savo programos kodą, turėtumėte švirkšti Į savo paslaugas, o ne naudoti Tiesiogiai, jei jums reikia griežto patikrinimo. Symfony\Component\Uid\Factory\UuidFactory new UuidV7() „Benchmark“ Norėdami parodyti veiklos poveikį vs Atsitiktiniai ID priverčia duomenų bazę nuolat iš naujo subalansuoti B-Tree indeksą, o monotoniški ID pridedami prie pabaigos. UUID v7 (Monotonic) UUID v4 (Random) This benchmark requires: 
 
 
 PhpBench įdiegta (kompozitorius reikalauja - dev phpbench/phpbench). Veikianti MySQL/MariaDB instancija (apibrėžta jūsų .env). Create this file at  Šis scenarijus paleidžia "Symfony" branduolį, kad gautų duomenų bazės ryšį, užtikrina, kad lentelės egzistuoja, o tada matuoja žaliavinio įterpimo greitį. 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: Įveskite šią komandą į savo 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: Jūs tikriausiai pamatysite panašią išvestį (laikai skirsis priklausomai nuo aparatūros): +-----------------+-------+---------+----------+----------+---------+
| 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 |
+-----------------+-------+---------+----------+----------+---------+
 Turėtumėte stebėti, kad  has a lower mean time and significantly  . Key Takeaway: benchInsertV7 lower standard deviation (stdev) 
 
 
  V7 is faster because the database simply appends the page to the right side of the B-Tree. Mean: Kartais jis pasiekia „laimingą“ tašką, bet dažnai sukelia „Slapties suskaidymą“ (brangią operaciją, kad duomenys būtų perkeliami), o tai sukelia vėlavimo spikes. Išvada Per ilgą laiką kūrėjai duomenų bazių identifikatorius laikė paprastu įgyvendinimo detalu – pagal nutylėjimą iš įpročio arba  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 Su „Symfony 7.3“ ir „Uid“ komponentu mums nebereikia daryti kompromisų. Iš UŽDARYTI > Su iš viso (UUID v7). mes galime turėti be atskleidžiant nuotėkio laiko žymes (ULID). Mes galime bendrauti su mūsų formatus (Base58) išlaikant mūsų saugojimo griežtai dvejetainis. distributed uniqueness insert performance cursor-based pagination human-friendly Perėjimas prie šių šiuolaikinių standartų yra vienas iš didžiausių ROI refaktorių, kuriuos galite atlikti augančioje „Symfony“ programoje. Kurkime geresnes sistemas Aš reguliariai rašau apie aukštos kokybės „Symfony“ architektūrą, „Doctrine internals“ ir paskirstytus modelius. Jūsų paveldėtoje lentelėje: UUID v7 
 
 
 Susisiekite su manimi: https://www.linkedin.com/in/matthew-mochalkin/ Diskusija: Palikite komentarą žemiau su savo patirtimi, susijusia su indeksų susiskaidymu. https://www.linkedin.com/in/matthew-mochalkin/ Let’s stay in touch and keep pushing the standard.

Read My Stories

Šis garso įrašas sukurtas originalia istorijos kalba!

Ramus buteliukas jūsų „Symfony“ programoje: fragmentizuoti indeksai ir atsitiktiniai UUID

About Author

KOMENTARAI

PABAIGTI ŽYMES

ŠIS STRAIPSNIS BUVO PRISTATYMAS

Related Stories

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps