function TransactionTest::testTransactionWithDdlStatement

Tests the compatibility of transactions with DDL statements.

File

core/tests/Drupal/KernelTests/Core/Database/TransactionTest.php, line 489

Class

TransactionTest

Tests the transactions, using the explicit ::commitOrRelease method.

Namespace

Code

public function testTransactionWithDdlStatement() : void {
  // First, test that a commit works normally, even with DDL statements.
  $transaction = $this->createRootTransaction('', FALSE);
  $this->insertRow('row');
  $this->executeDDLStatement();
  if ($this->connection
    ->supportsTransactionalDDL()) {
    $transaction->commitOrRelease();
  }
  else {
    set_error_handler(static function (int $errno, string $errstr) : bool {
      throw new \ErrorException($errstr);
    });
    try {
      $transaction->commitOrRelease();
    } catch (\ErrorException $e) {
      $this->assertSame('Transaction::commitOrRelease() was not processed because a prior execution of a DDL statement already committed the transaction.', $e->getMessage());
    } finally {
      restore_error_handler();
    }
  }
  $this->assertRowPresent('row');
  // Even in different order.
  $this->cleanUp();
  $transaction = $this->createRootTransaction('', FALSE);
  $this->executeDDLStatement();
  $this->insertRow('row');
  if ($this->connection
    ->supportsTransactionalDDL()) {
    $transaction->commitOrRelease();
  }
  else {
    set_error_handler(static function (int $errno, string $errstr) : bool {
      throw new \ErrorException($errstr);
    });
    try {
      $transaction->commitOrRelease();
    } catch (\ErrorException $e) {
      $this->assertSame('Transaction::commitOrRelease() was not processed because a prior execution of a DDL statement already committed the transaction.', $e->getMessage());
    } finally {
      restore_error_handler();
    }
  }
  $this->assertRowPresent('row');
  // Even with stacking.
  $this->cleanUp();
  $transaction = $this->createRootTransaction('', FALSE);
  $transaction2 = $this->createFirstSavepointTransaction('', FALSE);
  $this->executeDDLStatement();
  if ($this->connection
    ->supportsTransactionalDDL()) {
    $transaction2->commitOrRelease();
  }
  else {
    set_error_handler(static function (int $errno, string $errstr) : bool {
      throw new \ErrorException($errstr);
    });
    try {
      $transaction2->commitOrRelease();
    } catch (\ErrorException $e) {
      $this->assertSame('Transaction::commitOrRelease() was not processed because a prior execution of a DDL statement already committed the transaction.', $e->getMessage());
    } finally {
      restore_error_handler();
    }
  }
  $transaction3 = $this->connection
    ->startTransaction();
  $this->insertRow('row');
  $transaction3->commitOrRelease();
  if ($this->connection
    ->supportsTransactionalDDL()) {
    $transaction->commitOrRelease();
  }
  else {
    try {
      $transaction->commitOrRelease();
      $this->fail('TransactionOutOfOrderException was expected, but did not throw.');
    } catch (TransactionOutOfOrderException) {
      // Just continue, this is out or order since $transaction3 started a
      // new root.
    }
  }
  $this->assertRowPresent('row');
  // A transaction after a DDL statement should still work the same.
  $this->cleanUp();
  $transaction = $this->createRootTransaction('', FALSE);
  $transaction2 = $this->createFirstSavepointTransaction('', FALSE);
  $this->executeDDLStatement();
  if ($this->connection
    ->supportsTransactionalDDL()) {
    $transaction2->commitOrRelease();
  }
  else {
    set_error_handler(static function (int $errno, string $errstr) : bool {
      throw new \ErrorException($errstr);
    });
    try {
      $transaction2->commitOrRelease();
    } catch (\ErrorException $e) {
      $this->assertSame('Transaction::commitOrRelease() was not processed because a prior execution of a DDL statement already committed the transaction.', $e->getMessage());
    } finally {
      restore_error_handler();
    }
  }
  $transaction3 = $this->connection
    ->startTransaction();
  $this->insertRow('row');
  $transaction3->rollBack();
  if ($this->connection
    ->supportsTransactionalDDL()) {
    $transaction->commitOrRelease();
  }
  else {
    try {
      $transaction->commitOrRelease();
      $this->fail('TransactionOutOfOrderException was expected, but did not throw.');
    } catch (TransactionOutOfOrderException) {
      // Just continue, this is out or order since $transaction3 started a
      // new root.
    }
  }
  $this->assertRowAbsent('row');
  // The behavior of a rollback depends on the type of database server.
  if ($this->connection
    ->supportsTransactionalDDL()) {
    // For database servers that support transactional DDL, a rollback
    // of a transaction including DDL statements should be possible.
    $this->cleanUp();
    $transaction = $this->createRootTransaction('', FALSE);
    $this->insertRow('row');
    $this->executeDDLStatement();
    $transaction->rollBack();
    $this->assertRowAbsent('row');
    // Including with stacking.
    $this->cleanUp();
    $transaction = $this->createRootTransaction('', FALSE);
    $transaction2 = $this->createFirstSavepointTransaction('', FALSE);
    $this->executeDDLStatement();
    $transaction2->commitOrRelease();
    $transaction3 = $this->connection
      ->startTransaction();
    $this->insertRow('row');
    $transaction3->commitOrRelease();
    $this->assertRowPresent('row');
    $transaction->rollBack();
    $this->assertRowAbsent('row');
  }
}