vendor/doctrine/orm/src/Id/SequenceGenerator.php line 54

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace Doctrine\ORM\Id;
  7. use Doctrine\DBAL\Connections\PrimaryReadReplicaConnection;
  8. use Doctrine\ORM\EntityManagerInterface;
  9. use Serializable;
  11. use function serialize;
  12. use function unserialize;
  14. /**
  15.  * Represents an ID generator that uses a database sequence.
  16.  */
  17. class SequenceGenerator extends AbstractIdGenerator implements Serializable
  18. {
  19.     /**
  20.      * The allocation size of the sequence.
  21.      *
  22.      * @var int
  23.      */
  24.     private $allocationSize;
  26.     /**
  27.      * The name of the sequence.
  28.      *
  29.      * @var string
  30.      */
  31.     private $sequenceName;
  33.     /** @var int */
  34.     private $nextValue = 0;
  36.     /** @var int|null */
  37.     private $maxValue = null;
  39.     /**
  40.      * Initializes a new sequence generator.
  41.      *
  42.      * @param string $sequenceName   The name of the sequence.
  43.      * @param int    $allocationSize The allocation size of the sequence.
  44.      */
  45.     public function __construct($sequenceName, $allocationSize)
  46.     {
  47.         $this->sequenceName   = $sequenceName;
  48.         $this->allocationSize = $allocationSize;
  49.     }
  51.     /**
  52.      * {@inheritDoc}
  53.      */
  54.     public function generateId(EntityManagerInterface $em, $entity)
  55.     {
  56.         if ($this->maxValue === null || $this->nextValue === $this->maxValue) {
  57.             // Allocate new values
  58.             $connection = $em->getConnection();
  59.             $sql        = $connection->getDatabasePlatform()->getSequenceNextValSQL($this->sequenceName);
  61.             if ($connection instanceof PrimaryReadReplicaConnection) {
  62.                 $connection->ensureConnectedToPrimary();
  63.             }
  65.             $this->nextValue = (int) $connection->fetchOne($sql);
  66.             $this->maxValue  = $this->nextValue + $this->allocationSize;
  67.         }
  69.         return $this->nextValue++;
  70.     }
  72.     /**
  73.      * Gets the maximum value of the currently allocated bag of values.
  74.      *
  75.      * @return int|null
  76.      */
  77.     public function getCurrentMaxValue()
  78.     {
  79.         return $this->maxValue;
  80.     }
  82.     /**
  83.      * Gets the next value that will be returned by generate().
  84.      *
  85.      * @return int
  86.      */
  87.     public function getNextValue()
  88.     {
  89.         return $this->nextValue;
  90.     }
  92.     /**
  93.      * @return string
  94.      *
  95.      * @final
  96.      */
  97.     public function serialize()
  98.     {
  99.         return serialize($this->__serialize());
  100.     }
  102.     /** @return array<string, mixed> */
  103.     public function __serialize(): array
  104.     {
  105.         return [
  106.             'allocationSize' => $this->allocationSize,
  107.             'sequenceName' => $this->sequenceName,
  108.         ];
  109.     }
  111.     /**
  112.      * @param string $serialized
  113.      *
  114.      * @return void
  115.      *
  116.      * @final
  117.      */
  118.     public function unserialize($serialized)
  119.     {
  120.         $this->__unserialize(unserialize($serialized));
  121.     }
  123.     /** @param array<string, mixed> $data */
  124.     public function __unserialize(array $data): void
  125.     {
  126.         $this->sequenceName   = $data['sequenceName'];
  127.         $this->allocationSize = $data['allocationSize'];
  128.     }
  129. }