Come riprovare la transazione dopo un deadlock utilizzando Doctrine?

Question

Sto scrivendo una funzione PHP che memorizza/aggiorna grandi serie di dati in una tabella e può causare un deadlock. Ho provato a indagare su come riprovare una transazione fallita con Doctrine ma purtroppo non ho trovato alcuna informazione online. Alla fine ho scritto il seguente codice

$retry = 0; 
$done = false; 
while (!$done and $retry < 3) { 
    try { 

     $this->entityManager->flush(); 
     $done = true; 

    } catch (\Exception $e) { 
     sleep(1); 

     $retry++; 
    } 
} 

if ($retry == 3) { 
    throw new Exception(
     "[Exception: MySQL Deadlock] Too many people accessing the server at the same time. Try again in few minutes" 
    ); 
} 

La mia domanda: c'è una possibilità di questo approccio inserirà i duplicati nel database? In tal caso, come posso forzare Doctrine a ripristinare le transazioni?

Answer 1

Un deadlock restituisce l'errore 1213 che si dovrebbe elaborare sul lato client

Si noti che una situazione di stallo e di attesa di blocco sono cose diverse. In una situazione di stallo, non vi è alcuna transazione "fallita": sono entrambi colpevoli. Non vi è alcuna garanzia su quale verrà eseguito il rollback.

È necessario utilizzare rollback, il codice dello stile inserirà duplicato. per esempio dovresti:

$retry = 0; 

$done = false; 


$this->entityManager->getConnection()->beginTransaction(); // suspend auto-commit 

while (!$done and $retry < 3) { 

    try { 

     $this->entityManager->flush(); 

     $this->entityManager->getConnection()->commit(); // commit if succesfull 

     $done = true; 

    } catch (\Exception $e) { 

     $this->entityManager->getConnection()->rollback(); // transaction marked for rollback only 

     $retry++; 

    } 

} 

Spero che questo aiuto.

Answer 2

Se non si utilizza ORM, utilizzare la situazione di deadlock gestita automaticamente.

Answer 3

Questo è come mi occupo di riprovare le transazioni fallite con Sf2.7 e dottrina 2.4.7:

use Doctrine\Bundle\DoctrineBundle\Registry; 
use Doctrine\ORM\EntityManager; 

class Foo 
{ 
    /** 
    * @var Registry 
    */ 
    protected $doctrine; 

    public function __construct(Registry $registry) 
    { 
     $this->doctrine = $registry; 
    } 

    protected function doSomething($entity, $attempt) 
    { 
     $em = $this->getEntityManager(); 
     $conn = $em->getConnection(); 
     try{ 
      $conn->beginTransaction(); 
      $entity->setBar("baz"); 
      $em->flush(); 
      $conn->commit(); 
     } catch(\PDOException $e){ 
      $conn->rollBack(); 
      $attempt++; 
      if($attempt <= 3){ 
       $this->doSomething($repayment, $attempt); 
      } 
     } 
    } 

    /** 
    * @return EntityManager 
    */ 
    protected function getEntityManager() 
    { 
     /** @var EntityManager $em */ 
     $em = $this->doctrine->getManager(); 
     if(!$em->isOpen()){ 
      $this->doctrine->resetManager(); 
      $em = $this->doctrine->getManager(); 
     } 

     return $em; 
    } 
}