Monolīta laikmetā bija neapstrīdams datu bāzes identifikatoru karalis. Tas bija vienkāršs, mazs (4 bytes) un dabiski sakārtots. Bet, kad mēs virzāmies uz izplatītām sistēmām, mikroservisiem un augsti konkurētspējīgiem API, veselais ID sāka parādīt savas plaisas. Tas noplūda biznesa inteliģenci (konkurenti var uzminēt jūsu apjomu), tas sarežģī datu bāzes apvienošanu / sadalīšanu un tas prasa apļveida braucienu uz datu bāzi tikai, lai uzzinātu jauna objekta identitāti. id INT AUTO_INCREMENT Lai gan lielākā daļa ražotāju pārtrauc Viņiem trūkst arhitektūras dziļuma, ko piedāvā šī sastāvdaļa. Šajā rokasgrāmatā mēs izpētīsim Symfony 7.3 iet ārpus pamata ģenerācijas, lai risinātu datu bāzes fragmentāciju, kursora pagināciju un deterministisko idempotenci. “let’s just use UUID v4” symfony/uid Uzstādīšana un priekšnoteikumi Mēs izmantojam (pieņemot mūsdienu 7.x funkcijas) un . Symfony 7.3 Doctrine ORM 3 Nodrošiniet savu Tas atspoguļo sekojošas atkarības. mēs stingri izmantojam un tās . composer.json symfony/uid Doctrine integration composer require symfony/uid symfony/doctrine-bridge doctrine/orm
 Datu bāzes veiktspējas labojums: UUID v7 Visbiežāk sastopamā kļūda mūsdienu Symfony lietotnēs ir kā a . UUID v4 primary key Problēma: indeksa sadrumstalotība UUID v4 ir pilnīgi nejauša.Kad jūs ievietojat nejaušu ID MySQL/PostgreSQL klasterizētā indeksā (B-Tree), datu bāzei pastāvīgi ir jāpārbalansē koks, lai ievietotu jaunu lapu indeksa “vidū”. , nogalinot ievietošanas veiktspēju, jo tabula aug. massive page splitting and fragmentation Atslēgas vārdi: UUID v7 UUID v7 (standartizēts RFC 9562 un pilnībā atbalstīts Symfony 7.x) apvieno ar nejaušiem datiem. tas padara tos Tie ievieto B-koka galā, tāpat kā automātiski palielinātais vesels skaitlis, bet saglabā UUID unikalitāti un izplatīto raksturu. Unix timestamp (millisecond precision) strictly monotonic īstenošana Nelietojiet uzticēties doktrīnai burvju, kas bieži noklusē v4. vietā, inicializējiet ID konstruktorā. Augstākā vērtība Augstākā vērtība //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
}
 Doktrīnas veids: automātiski apstrādā konversiju. pēc noklusējuma tā saglabā kā (Lasāmi) vai (efektīva) atkarībā no jūsu platformas konfigurācijas. liela apjoma sistēmām vienmēr konfigurējiet Doctrine, lai izmantotu Divi Uzglabāšanas vieta ID. ‘uuid’ CHAR(36) BINARY(16) BINARY(16) save 55% Pārbaude 
 
 
 
 Migrācijas ģenerēšana: php bin/console make:migration Pārbaudiet SQL. Jums vajadzētu redzēt kolonnu definēts. Pārbaudiet DB; ID jāpalielina secīgi (pirmie burti būs identiski). Augstas veiktspējas paginēšana ar ULID Paginācijas izmantošana un Datubāzei ir jāaprēķina un jāiznīcina tūkstošiem rindu, lai sasniegtu lapu 100. , bet tas parasti prasa unikālu, šķirošu kolonnas (piemēram, Laika zīmes ir riskanti, jo divi notikumi var notikt tieši tajā pašā mikrosekundē. OFFSET LIMIT Keyset Pagination (Cursor-based) created_at ir 128 bitu saderīgi identifikatori, kas ir Izvēlieties . ULIDs (Universally Unique Lexicographically Sortable Identifier) lexicographically Stratēģija Mēs izmantosim a Tā kā ULID ir šķirošanas strēmeles, mēs varam vienkārši teikt: ULID as the primary key “Dodiet man 10 priekšmetus, kur 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();
    }
}
 Šis vaicājums tieši nokļūst primārās atslēgas indeksā. Neatkarīgi no tā, vai esat 1. lappusē vai 1000 000 lappusē. Why this matters? O(1) Idempotences un deterministisko ID (UUID v5) Izplatītās sistēmās (piemēram, CQRS vai Event Sourcing) jūs bieži saņemsiet vienu un to pašu ziņojumu divas reizes (vismaz vienu piegādi). ir deterministisks. Ņemot vērā a un a (ieejas virkne), tas vienmēr rada to pašu UUID. UUID v5 Namespace Name Scenārijs: Produktu importēšana no CSV Jūs importējat produktus no vecās sistēmas, kurai ir SKU, bet nav UUID. Jūs vēlaties pārliecināties, ka, ja importēšanas skriptu palaidāt divreiz, jūs neradīsiet dublētas rindas, bet atjauniniet esošo “identitāti”. //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: UID saīsināšana cilvēkiem Ieceltas amatpersonas ( YouTube izmanto Base64/Base58. Symfony Uid ir iebūvēts atbalsts (Bitcoin stils, nav neskaidru rakstzīmju, piemēram, 0/O, I/l) un . 123e4567-e89b-12d3-a456–426614174000 Base58 Base32 Mēs varam izveidot a kas automātiski pārveido UID uz Base58, nosūtot JSON atbildes un atpakaļ uz UUID, saņemot pieprasījumus. 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: 
 
 
 
 Datubāze: Uzglabā optimizētu 16 bitu bināro. API Atbilde: {”id”: “BukQLMwS8W5g32”} (Draudzīgi, kopēt-pasteable) API pieprasījums: Klients nosūta BukQLMwS8W5g32, Symfony to pārvērš atpakaļ pareizajā UUID datu bāzes vaicājumā. Nosaukums oriģinālvalodā: Mocking the Unpredictable Testēt UUID ir notoriāli grūti, jo mainās katru milisekundu. Symfony 7 nodrošina Lai to atrisinātu. 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));
    }
}
 Lai veiktu šo darbu jūsu pieteikuma kodā, jums vajadzētu ievadīt uz jūsu pakalpojumiem, nevis izmantot tieši, ja jums ir nepieciešama stingra testējamība. Symfony\Component\Uid\Factory\UuidFactory new UuidV7() Benchmark vērtība Lai pierādītu rezultātu ietekmi VS , mums ir nepieciešams izmērīt “lapu sadalīšanas” efektu datu bāzē. Random ID piespieda datu bāzi pastāvīgi pārbalansēt B-Tree indeksu, bet Monotonic ID piestiprina līdz galam. UUID v7 (Monotonic) UUID v4 (Random) This benchmark requires: 
 
 
 PhpBench instalēts (komponents ir nepieciešams — dev phpbench/phpbench). Darbojas MySQL/MariaDB instance (definēts jūsu .env). Izveidojiet šo failu Šis skripts bootstraps Symfony kodolu, lai iegūtu datu bāzes savienojumu, nodrošina, ka tabulas pastāv un pēc tam mēra neapstrādātu ievietošanas ātrumu. 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: Izpildiet šādu komandu savā terminālā: # 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, visticamāk, redzēsiet šādu izeju (laiki atšķiras atkarībā no aparatūras): +-----------------+-------+---------+----------+----------+---------+
| 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 |
+-----------------+-------+---------+----------+----------+---------+
 Jums vajadzētu ievērot, ka ir zemāks vidējais laiks un ievērojami . Key Takeaway: benchInsertV7 lower standard deviation (stdev) 
 
 
 Tas nozīmē, ka V7 ir ātrāks, jo datu bāze vienkārši piestiprina lapu B-Tree labajā pusē. Dažreiz tas nokļūst “laimīgā” vietā, bet bieži tas izraisa “lapu sadalīšanu” (dārgu operāciju, lai pārvietotu datus), izraisot aizkavēšanos. Secinājums Pārāk ilgi izstrādātāji datu bāzes identifikatorus ir uzskatījuši par vienkāršu īstenošanas detaļu – pēc noklusējuma No ieraduma vai Kā mēs esam redzējuši, šai izvēlei ir dziļa ietekme uz jūsu lietojumprogrammas fragmentāciju, pagatavošanas ātrumu un izplatīto integritāti. AUTO_INCREMENT UUID v4 Ar Symfony 7.3 un Uid komponentu mums vairs nav jākompromitē.  of a UUID with the  no vesela skaitļa (UUID v7). mēs varam bez noplūdes laika zīmēm (ULID). Mēs varam sazināties ar mūsu frontēnu formātus (Base58) saglabājot mūsu uzglabāšanu stingri bināro. distributed uniqueness insert performance cursor-based pagination human-friendly Pārslēgšanās uz šiem mūsdienu standartiem ir viens no augstākajiem ROI refaktoriem, ko varat veikt ar augošu Symfony lietojumprogrammu. Veidosim labākas sistēmas Es regulāri rakstu par augstas veiktspējas Symfony arhitektūru, doktrīnas iekšējiem un izplatītiem modeļiem. Savā mantojuma stacijā: UUID v7 
 
 
 Sazinieties ar mani: https://www.linkedin.com/in/matthew-mochalkin/ Diskusija: Atstājiet komentāru zemāk ar savu pieredzi attiecībā uz indeksa fragmentāciju. https://www.linkedin.com/in/matthew-mochalkin/ Palieciet saskarē un turpiniet virzīt standartu.

Read My Stories

Šis audio ir izveidots stāsta oriģinālvalodā!

The Quiet Bottleneck in Your Symfony App: Fragmented Indexes and Random UUIDs

About Author

KOMENTĀRI

PAKARINĀT TAGUS

ŠIS RAKSTS TIKS PĀRSTRĀDĀTS

Related Stories

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps