Commits nested transaction

$db->commit_transaction();

@return bool
486055
public function commit_transaction()
	{
		// Fake call of the commit
		if ($this->_transaction_depth <= 0)
		{
			return false;
		}

		if ($this->_transaction_depth - 1)
		{
			$result = $this->release_savepoint($this->_transaction_depth - 1);
			// If savepoint is not supported it is not an error
			! isset($result) and $result = true;
		}
		else
		{
			$this->_in_transaction = false;
			$result = $this->driver_commit();
		}

		$result and $this->_transaction_depth --;

		return $result;
	}
556119
def commit(self):
        """"""
        if self._transaction_nesting_level == 0:
            raise DBALConnectionError.no_active_transaction()
        if self._is_rollback_only:
            raise DBALConnectionError.commit_failed_rollback_only()

        self.ensure_connected()
        if self._transaction_nesting_level == 1:
            self._driver.commit()
        elif self._nest_transactions_with_savepoints:
            self.release_savepoint(self._get_nested_transaction_savepoint_name())

        self._transaction_nesting_level -= 1

        if not self._auto_commit and self._transaction_nesting_level == 0:
            self.begin_transaction()
1270135
public final function commit()
   {
       foreach ($this->queue as $key => $value) {
           if (!$this->save($value)) {
               return false;
           }
           unset($this->queue[$key]);
       }
       return true;
   }
1138076
public function commit()
    {
        list($old, $new) = $this->generateRollback();
        $updates = $this->generateUpdates();
        $updates = $this->combineUpdates($updates);
        usort($updates, array($this, 'sortUpdates'));

        foreach ($updates as $update) {
            // apply update to cache & receive a simple bool to indicate
            // success (true) or failure (false)
            $success = call_user_func_array($update[1], $update[2]);
            if ($success === false) {
                $this->rollback($old, $new);

                return false;
            }
        }

        $this->clear();

        return true;
    }
553736
function commit()
    {
        if ($this->transaction_level > 0){
            $this->transaction_level--;
            if ($this->transaction_level == 0){
                return parent::commit();
            }
            return true;
        }
        return false;
    }
1242362
public function commit()
    {

        if (empty($this->body)) {
            return false;
        }

        $result = $this->query->connection->bulk($this->body);
        $this->operationCount = 0;
        $this->body = [];

        return $result;
    }
85496
public function rollback()
    {
        $res = null;

        if (empty($this->pendingTransactionBegin[$this->transLevel])
            && isset($this->transLevelRolledBack[$this->transLevel])
            && $this->transLevelRolledBack[$this->transLevel] == false
        ) {
            $this->dbRollback();
        }

        if ($this->transLevel == 0) {
            throw $this->createException('Rollback without transaction');
        }

        $this->cleanAfterCommit();
        $this->transLevel--;

        return $this;
    }
197169
public function forceRollBack()
    {
        $return = true;

        if ($this->nestedTransactionCount) {
            // If we're in a transaction, always roll it back
            // regardless of nesting level.
            $return = parent::rollBack();

            // reset nested transaction count to 0 so that we don't
            // try to commit (or rollback) the transaction outside this scope.
            $this->nestedTransactionCount = 0;

            if ($this->useDebug) {
                $this->log('Rollback transaction', null, __METHOD__);
            }
        }

        return $return;
    }
307829
public function closeTransaction() {
		if ($this->transaction) {
			if ($this->values_saved) { // we commit
				$this->collection_object->primary_model->db_object->commit();
			} else if (!$this->rollback) {
				$this->collection_object->primary_model->db_object->rollback();
				$this->rollback = true;
			}
			$this->transaction = false;
		}
	}
1166453
public function rollBack() : bool
    {
        return $this->isConnected() && $this->getConnection()->inTransaction() && $this->getConnection()->rollBack();
    }
24228
public static function commit()
  {
    if (is_null(self::$_transaction)) {
      $result = false;
    } else {
      $result = true;
      
      $aTran = self::$_transaction;
      $aCurr = $aTran->_stored;
      
      if (!is_null($aCurr)) {
        foreach ($aTran->_data as $name => $value) {
          /* @var $value Config */
          if (is_null($value)) {
            $aCurr->delete($name);
          } else {
            $aCurr->save($name, $value);
          }
        }
      }
      
      self::_stop();
      self::$_transaction = null;
    }
    
    return $result;
  }
478340
public function commit ()
	{

		if (--$this->transactionCount === 0)
		{
			
			$status	= parent::commit ();
			
			// Commit any hooked databases
			
			if ($this->_transaction_hooks)
			{
				
				if ($status)
				{
					foreach ($this->_transaction_hooks as $dsn => &$db)
					{
						$db->commit ();
					}
				}
				
				$this->_transaction_hooks	= array ();
				
			}
			
			return $status;
			
		}
		else
		{
			return FALSE;
		}

	}
1073966
public static function database_transaction_commited() {
        if (self::$dispatching or empty(self::$extbuffer)) {
            return;
        }

        self::$dispatching = true;
        self::process_buffers();
        self::$dispatching = false;
    }
699801
protected function commit_transaction() {
        $this->query_start('native sqlsrv_commit', NULL, SQL_QUERY_AUX);
        $result = sqlsrv_commit($this->sqlsrv);
        $this->query_end($result);
    }
358409
public function commit() {
        if ($this->dialect) {
            $dialect = $this->dialect;
            if ($dialect->inTransaction()) {
                $this->transLevel -= 1;
                if ($this->transLevel > 0) {
                    return true;
                }
                try {
                    if ($this->commitType == 'rollback') {
                        $dialect->rollBack();

                        //提交失败，因为在提交之前有人要回滚.
                        return false;
                    } else {
                        return $dialect->commit();
                    }
                } catch (\PDOException $e) {
                    $this->error = $e->getMessage();
                } finally {
                    $this->transLevel = 0;
                    $this->commitType = null;
                }
            }
        }

        return false;
    }
878069
public function commit()
    {
        if (count($this->transactions) <= 1) {
            throw new UnbegunTransaction('Attempted to commit without having begun a transaction.');
        }

        /** @var Transaction $transaction */
        $transaction = array_pop($this->transactions);

        return $transaction->commit();
    }
187696
public function commitTransaction(): bool
    {
        --$this->transactionLevel;

        if ($this->transactionLevel == 0) {
            $this->isProfiling() && $this->getLogger()->info('Commit transaction');

            try {
                return $this->getPDO()->commit();
            } catch (\PDOException $e) {
                throw $this->mapException($e, "COMMIT TRANSACTION");
            }
        }

        $this->savepointRelease($this->transactionLevel + 1);

        return true;
    }