好的，我正在使用 PHP 为 MySQL 中的“嵌套”事务寻找解决方案，正如您在 MySQL 文档中所知道的那样，不可能在事务中包含事务 (Mysql transactions within transactions)。我试图使用 http://php.net/manual/en/pdo.begintransaction.php 中提出的数据库类但不幸的是，这对我来说是错误的，因为它的计数器范围是对象级别而不是类级别，为了解决这个问题，我创建了这个类(TransactionController)，它有计数器(名为$nest) static 并且它带来了使交易“线性”所需的类级别(“线性”我是说:它显然是嵌套的，但如果你看起来很它不是嵌套的，那么交易会运作良好，你怎么看？(看最后的例子，CarOwner)

        class TransactionController extends \\PDO {
            public static $warn_rollback_was_thrown = false;
            public static $transaction_rollbacked = false;
            public function __construct()
            {
                parent :: __construct( ... connection info ... );
            }
            public static $nest = 0;
            public function reset()
            {
                TransactionController :: $transaction_rollbacked = false;
                TransactionController :: $warn_rollback_was_thrown = false;
                TransactionController :: $nest = 0;
            }
            function beginTransaction()
            {
                $result = null;
                if (TransactionController :: $nest == 0) {
                    $this->reset();
                    $result = parent :: beginTransaction();
                }
                TransactionController :: $nest++;
                return $result;
            }

            public function commit()
            {

                $result = null;

                if (TransactionController :: $nest == 0 &&
                        !TransactionController :: $transaction_rollbacked &&
                        !TransactionController :: $warn_rollback_was_thrown) {
                            $result = parent :: commit();
                        }
                        TransactionController :: $nest--;
                        return $result;
            }

            public function rollback()
            {
                $result = null;
                if (TransactionController :: $nest >= 0) {
                    if (TransactionController :: $nest == 0) {
                        $result = parent :: rollback();
                        TransactionController :: $transaction_rollbacked = true;
                    }
                    else {
                        TransactionController  :: $warn_rollback_was_thrown = true;
                    }
                }
TransactionController :: $nest--;
                return $result;
            }

    public function transactionFailed()
    {
        return TransactionController :: $warn_rollback_was_thrown === true;
    }
    // to force rollback you can only do it from $nest = 0
    public function forceRollback()
    {
        if (TransactionController :: $nest === 0) {
            throw new \PDOException();
}
    }
        }

        class CarData extends TransactionController {
            public function insertCar()
            {

                try {
                    $this->beginTransaction();
                    ... (operations) ...
                    $this->commit();
                }
                catch (\PDOException $e) {
                    $this->rollback();
                }
            }
        }
        class PersonData extends TransactionController {
            public function insertPerson(  $person=null )
            {
                try {
                    $this->beginTransaction();
                    ... (operations) ...
                    $this->commit();
                }
                catch (\PDOException $e) {
                    $this->rollback();
                }
            }
        }

        class CarOwnerData extends TransactionController {
            public function createOwner()
            {
                try {
                    $this->beginTransaction();

                    $car = new CarData();
                    $car->insertCar();

                    $person = new PersonData();
                    $person->insertPerson();

                    ... (operations) ...

                    $this->commit();
                }
                catch (\PDOException $e) {
                    $this->rollback();
                }
            }
        }


        $sellCar = new CarOwnerData();
        $sellCar->createOwner();

UPDATE1:static attribute $warn_rollback_was_thrown 被添加到 TransactionController 以警告事务在执行的某个时刻失败，但没有回滚。

UPDATE2:当事务在某个时刻失败时，您可以让代码继续运行到最后，或者使用 forceRollback() 最终停止它，例如看下面的代码:

<?php    // inside the class PersonData

    public function insertMultiplePersons( $arrayPersons )
    {
        try {
        $this->beginTransaction();
        if (is_array( $arrayPersons )) {
            foreach ($arrayPersons as $k => $person) {
                $this->insertPerson( $person ); 
                if ($this->transactionFailed()) {
                    $this->forceRollback();                    
                }
            }
        }
        $this->commit();
        }
        catch (\PDOException $e) {
            $this->rollback();
        }
    } ?>

最佳答案

正如@YourCommonSense 在评论中指出的那样，您实际上并没有实现嵌套事务。

我不确定我是否喜欢在我的代码中的任何地方调用 commit() 而它实际上并没有提交任何东西的想法。

您的整个解决方案似乎是在尝试减轻将事务代码放入插入函数并忘记它的设计决策。

您可以将插入操作与事务逻辑分开，并将这些函数调用包装在一个执行事务的单独函数中:

public/private function insertPerson(  $person=null )
{
  ... (operations) ...
}

public function createPerson()
{
    $person = new Person();
    ... (setup person) ...

    $this->beginTransaction();
    try {
        $this->insertPerson($person);
        $this->commit();
    }
    catch (\PDOException $e) {
        $this->rollback();
    }
} 

如果您完全确定需要始终将此人插入事务中，则可以在调用时检查您是否在事务中:

public/private function insertPerson($person=null)
{
  if (!$this->hasActiveTransaction){ // Needs implementing
     throw new Exception('Must be called within a transaction');
  }
  ...(operations)...
}

在我们的项目中，所有保存逻辑都在模型中，所有事务逻辑都在 Controller 级别。

我假设您知道对于单个语句不需要事务，因为这些是原子操作，并且您的代码代表更复杂的情况。

关于MySQL 中的 PHP "Nested"事务可以使用以下代码实现吗？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/39805501/