Pada era monolithic, adalah raja yang tak terbantahkan dari pengidentifikasi database. Itu sederhana, kecil (4 byte) dan diatur secara alami. Tetapi ketika kita bergerak ke arah sistem terdistribusi, microservices dan API yang sangat kompetitif, ID integer mulai menunjukkan celah-celahnya. Ini bocor intelijen bisnis (pesaing dapat menebak volume Anda), itu mempersulit penggabungan / pemisahan database dan membutuhkan perjalanan ke database hanya untuk mengetahui identitas objek baru. id INT AUTO_INCREMENT Sebagian besar pengembang berhenti mereka kehilangan kedalaman arsitektur yang ditawarkan komponen ini. dalam panduan ini, kita akan mengeksplorasi implementasi lanjutan dari Dalam Symfony 7.3, bergerak melampaui generasi dasar untuk mengatasi fragmentasi database, paginasi berbasis kursor dan idempotensi determinis. “let’s just use UUID v4” symfony/uid Instalasi & Persyaratan Kami menggunakan (menerima fitur modern 7.x) dan . Symfony 7.3 Doctrine ORM 3 Ensure your  mencakup ketergantungan berikut. kami menggunakan ketat dan nya . composer.json symfony/uid Doctrine integration composer require symfony/uid symfony/doctrine-bridge doctrine/orm
 Perbaikan kinerja database: UUID v7 Kesalahan yang paling umum dalam aplikasi Symfony modern adalah menggunakan sebagai a . UUID v4 primary key The Problem: Index Fragmentation UUID v4 benar-benar acak.Ketika Anda memasukkan ID acak ke dalam indeks yang dikelompokkan MySQL/PostgreSQL (B-Tree), database harus terus-menerus menyeimbangkan kembali pohon untuk memasukkan halaman baru di “middle” dari indeks. , membunuh insert kinerja saat meja tumbuh. massive page splitting and fragmentation Spesifikasi UUID v7 UUID v7 (standar dalam RFC 9562 dan sepenuhnya didukung dalam Symfony 7.x) menggabungkan dengan data acak. ini membuat mereka Mereka memasukkan di ujung B-Tree, seperti bilangan keseluruhan auto-increment, tetapi mempertahankan keunikan dan sifat yang didistribusikan UUID. Unix timestamp (millisecond precision) strictly monotonic Implementasi Jangan bergantung pada doktrin Magik, yang sering default ke v4. sebaliknya, memulakan ID di konstruktor. Ini menciptakan entitas “Persistensi Ignorant” di mana ID tersedia sebelum flush. Nilai Generasi Nilai Generasi //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
}
 Jenis Doktrin :  automatically handles the conversion. By default, it stores as  yang dapat dibaca) atau  (efficient) depending on your platform configuration. For high-volume systems, always configure Doctrine to use   to  Ruang penyimpanan per ID. ‘uuid’ CHAR(36) BINARY(16) BINARY(16) save 55% Verifikasi 
 
 
 
 Menghasilkan migrasi: php bin/console make:migration Periksa SQL. Anda harus melihat kolom didefinisikan. Periksa DB; ID harus bertambah berturut-turut (karakter pertama akan identik). Paginasi kinerja tinggi dengan ULID Paginasi menggunakan dan Database harus menghitung dan membuang ribuan baris untuk mencapai halaman 100. , tetapi ini biasanya membutuhkan kolom yang unik dan dapat diatur (seperti Timestamps berisiko karena dua peristiwa dapat terjadi pada mikrosekunder yang sama. OFFSET LIMIT Keyset Pagination (Cursor-based) created_at adalah 128-bit kompatibel identifier yang  sortable. ULIDs (Universally Unique Lexicographically Sortable Identifier) lexicographically Strategi yang Kami akan menggunakan a Karena ULID adalah string yang dapat disortir, kita hanya bisa mengatakan: 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();
    }
}
 Pertanyaan ini langsung memukul indeks Primary Key. Tidak peduli apakah Anda berada di halaman 1 atau halaman 1.000.000. Why this matters? O(1) Idempotensi dan Identifikasi Determinis (UUID v5) Dalam sistem terdistribusi (misalnya, CQRS atau Event Sourcing), Anda sering menerima pesan yang sama dua kali (setidaknya sekali pengiriman). adalah deterministik. diberikan a  and a  (input string), itu selalu menghasilkan UUID yang sama. UUID v5 Namespace Name Skenario: Mengimpor Produk dari CSV Anda mengimpor produk dari sistem lama yang memiliki SKU, tetapi tidak UUID. Anda ingin memastikan bahwa jika Anda menjalankan script impor dua kali, Anda tidak membuat baris duplikat, tetapi memperbarui "identitas" yang ada. //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);
 URL Vanity: Pendekatan UID untuk Manusia UUIDs ( YouTube menggunakan Base64/Base58. Symfony Uid memiliki dukungan built-in untuk (Bitcoin gaya, tidak ada karakter ambigu seperti 0/O, I/l) dan . 123e4567-e89b-12d3-a456–426614174000 Base58 Base32 Kita bisa menciptakan a  that automatically converts UIDs to Base58 when sending JSON responses and back to UUIDs when receiving requests. 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: Toko yang dioptimalkan 16-byte biner. Jawaban API: {“id”: “BukQLMwS8W5g32”} (Teman, copy-pasteable) API Request: Klien mengirimkan BukQLMwS8W5g32, Symfony mengonversinya kembali ke UUID yang benar untuk kueri database. Judul: Mengejek yang Tidak Diprediksi Pengujian UUID sangat sulit karena perubahan setiap milisekunder. Symfony 7 menyediakan untuk memecahkan hal ini. 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));
    }
}
 Untuk melakukan pekerjaan ini dalam kode aplikasi Anda, Anda harus menyuntikkan dalam layanan Anda, bukannya menggunakan  directly if you require strict testability. Symfony\Component\Uid\Factory\UuidFactory new UuidV7() Untuk benchmark Untuk menunjukkan dampak kinerja dari vs Random ID memaksa database untuk terus-menerus menyeimbangkan kembali indeks B-Tree, sementara Monotonic ID ditambahkan ke ujungnya. UUID v7 (Monotonic) UUID v4 (Random) This benchmark requires: 
 
 
 PhpBench diinstal (composer require — dev phpbench/phpbench). Sebuah instansi yang berjalan MySQL/MariaDB (ditentukan dalam .env Anda). Buat file ini di Script ini bootstraps Symfony Kernel untuk mendapatkan koneksi database, memastikan tabel ada dan kemudian mengukur kecepatan input mentah. 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: Lakukan perintah berikut di terminal Anda: # 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: Anda mungkin akan melihat output yang mirip dengan ini (waktu akan bervariasi tergantung pada perangkat keras): +-----------------+-------+---------+----------+----------+---------+
| 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 |
+-----------------+-------+---------+----------+----------+---------+
 Anda harus memperhatikan bahwa memiliki jangka waktu yang lebih lama dan secara signifikan . Key Takeaway: benchInsertV7 lower standard deviation (stdev) 
 
 
 Artinya: V7 lebih cepat karena database hanya menempelkan halaman ke sisi kanan B-Tree. Stdev: V4 tidak teratur. kadang-kadang menabrak titik “beruntung”, tetapi sering kali memicu “Page Split” (operasi mahal untuk memindahkan data), menyebabkan puncak latensi. Kesimpulan Selama terlalu lama, para pengembang telah memperlakukan pengidentifikasi database sebagai rincian implementasi sederhana – secara default. dari kebiasaan atau Seperti yang telah kita lihat, pilihan ini memiliki efek mendalam pada fragmentasi aplikasi Anda, kecepatan paginasi dan integritas didistribusikan. AUTO_INCREMENT UUID v4 With Symfony 7.3 and the Uid component, we no longer have to compromise. We can have the  dari suatu UUID dengan  of an integer (UUID v7). We can have  tanpa mengekspos timestamps yang bocor (ULID). kita dapat berkomunikasi dengan frontend kita di format (Base58) sambil menjaga penyimpanan kami secara ketat biner. distributed uniqueness insert performance cursor-based pagination human-friendly Beralih ke standar modern ini adalah salah satu refaktor ROI tertinggi yang dapat Anda lakukan pada aplikasi Symfony yang berkembang. Let’s Build Better Systems Saya secara teratur menulis tentang arsitektur Symfony kinerja tinggi, internal Doktrin dan pola yang didistribusikan. Untuk Legacy Stack: UUID v7 
 
 
 Hubungi saya: https://www.linkedin.com/in/matthew-mochalkin/ Diskusi: Tinggalkan komentar di bawah ini dengan pengalaman Anda tentang fragmentasi indeks. https://www.linkedin.com/in/matthew-mochalkin/ Mari kita tetap terhubung dan terus mendorong standar.

Read My Stories

Audio ini diproduksi dalam bahasa asli cerita!

The Quiet Bottleneck di aplikasi Symfony Anda: Indeks yang terfragmentasi dan UUID acak

About Author

KOMENTAR

HANG TAG

ARTIKEL INI DISAJIKAN PADA

Related Stories

Building an API-Powered Platform

THE BEGINNING OF THE SEARCH FOR THE KEY AND THE COAT.

THE CAVERNS OF VENUS

THE DAWN COMES, AND MY UNCLE APPEARS IN A NEW SILK HAT

Building an API-Powered Platform

THE BEGINNING OF THE SEARCH FOR THE KEY AND THE COAT.

THE CAVERNS OF VENUS

THE DAWN COMES, AND MY UNCLE APPEARS IN A NEW SILK HAT

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps