Commit changes resulting from delete() or undeleteAll() operations.

@todo undeleteAll processing.
359433
public function commit()
    {
        if ($this->_hasChanges) {
            $this->_getIndexWriter()->commit();

            $this->_updateDocCount();

            $this->_hasChanges = false;
        }
    }
78099
protected function commit_transaction() {
        if (!$this->transactions_supported()) {
            return;
        }

        $sql = "COMMIT";
        $this->query_start($sql, NULL, SQL_QUERY_AUX);
        $result = $this->mysqli->query($sql);
        $this->query_end($result);
    }
906504
public function onAfterDelete()
    {
        // Prepare blank manipulation
        $manipulations = new AssetManipulationList();

        // Add all assets for deletion
        $this->addAssetsFromRecord($manipulations, $this->owner, AssetManipulationList::STATE_DELETED);

        // Whitelist assets that exist in other stages
        $this->addAssetsFromOtherStages($manipulations);

        // Apply visibility rules based on the final manipulation
        $this->processManipulation($manipulations);
    }
290027
void commit() {
		if (connection != null) {
			try {
				connection.commit();
			} catch (SQLException e) {
				throw new UroborosqlSQLException(e);
			}
		}
		clearState();
	}
360228
public void commit() {
        log.debug("Performing commit");
        for (CompensatingTransactionOperationExecutor operationExecutor : operationExecutors) {
            try {
                operationExecutor.commit();
            } catch (Exception e) {
                throw new TransactionSystemException(
                        "Error occurred during commit", e);
            }
        }
    }
1214167
void commit(ByteBuffer bb)
    {
        content.limit(Math.max(content.limit(), bb.position()));
        boolean removed = refSet.removeItem(content, bb);
        assert removed;
    }
172231
public function deleteRecord(): void
    {
        // Create a pending change
        if (!$this->isPendingDeletion()) {
            DB::table('change')->insert([
                'gedcom_id'  => $this->tree->id(),
                'xref'       => $this->xref,
                'old_gedcom' => $this->gedcom(),
                'new_gedcom' => '',
                'user_id'    => Auth::id(),
            ]);
        }

        // Auto-accept this pending change
        if (Auth::user()->getPreference('auto_accept')) {
            FunctionsImport::acceptAllChanges($this->xref, $this->tree);
        }

        // Clear the cache
        self::$gedcom_record_cache  = [];
        self::$pending_record_cache = [];

        Log::addEditLog('Delete: ' . static::RECORD_TYPE . ' ' . $this->xref, $this->tree);
    }
594093
def commit(self):
        """"""
        if (not self._add_cache and
                not self._remove_cache and
                not self._undefined_cache):
            return

        for store_key, hash_values in self._add_cache.items():
            for hash_value in hash_values:
                super(TransactionalIndex, self).add_hashed_value(
                    hash_value, store_key)
        for store_key in self._remove_cache:
            super(TransactionalIndex, self).remove_key(store_key)
        for store_key in self._undefined_cache:
            super(TransactionalIndex, self).add_undefined(store_key)
        if not self.ephemeral:
            self.save_to_store()

        self._init_cache()
        self._in_transaction = True
949970
final public function commitChanges()
    {
        if (null !== $this->changes) {
            $this->lastCommittedEventSequenceNumber = $this->changes->lastSequenceNumber();
            $this->changes->commit();
        }
    }
1270135
public final function commit()
   {
       foreach ($this->queue as $key => $value) {
           if (!$this->save($value)) {
               return false;
           }
           unset($this->queue[$key]);
       }
       return true;
   }
965068
private function commit()
    {
        //====================================================================//
        // Safety Checks
        if (empty($this->new)) {
            return true;
        }
        //====================================================================//
        // Create Field List
        if (empty($this->fields)) {
            $this->fields = array();
        }
        //====================================================================//
        // Validate New Field
        if (!$this->verify()) {
            $this->new = null;

            return false;
        }
        //====================================================================//
        // Insert Field List
        $this->fields[] = $this->new;
        $this->new = null;

        return true;
    }
806275
public function commit($delete = true)
    {
        $diff = $this->getDiff();

        if ($delete) {
            foreach ($diff['unknown'] as $index) {
                $this->deleteIndex($index['name']);
            }
        }

        foreach ($diff['missing'] as $name => $index) {
            $this->ensureIndex($index['keys'], $index['options']);
        }

        return true;
    }
104849
public function commit()
    {
        try {
            $this->gateway->commit();
        } catch (\RuntimeException $e) {
            throw new OrmException("Unable to commit changes.\n" . $e->getMessage(), 0, $e);
        }
    }
247073
private function commit()
    {
        if ($this->inTransaction) {
            try {
                // commit read-write transaction which also releases the lock
                if ('sqlite' === $this->driver) {
                    $this->pdo->exec('COMMIT');
                } else {
                    $this->pdo->commit();
                }
                $this->inTransaction = false;
            } catch (\PDOException $e) {
                $this->rollback();

                throw $e;
            }
        }
    }
318852
protected function runSoftDelete()
    {
        $query = $this->setKeysForSaveQuery($this->newModelQuery());

        $time = $this->freshTimestamp();

        $columns = [$this->getDeletedAtColumn() => $this->fromDateTime($time)];

        $this->{$this->getDeletedAtColumn()} = $time;

        if ($this->timestamps && ! is_null($this->getUpdatedAtColumn())) {
            $this->{$this->getUpdatedAtColumn()} = $time;

            $columns[$this->getUpdatedAtColumn()] = $this->fromDateTime($time);
        }

        $query->update($columns);
    }
1048029
public function commit()
    {
        if (!$this->transactor instanceof TransactionInterface) {
            throw new OrmException("Connection not set");
        }

        $this->checkForChangedRelations();
        $this->checkForUpdates();
        $this->preCommit();
        $this->transactor->beginTransaction();

        try {
            $this->insert();
            $this->update();
            $this->delete();
            $this->transactor->commit();
        } catch (\Exception $e) {
            $this->transactor->rollBack();
            $this->postRollback();
            throw new OrmException("Commit failed.\n" . $e->getMessage(), 0, $e);
        }

        $this->postCommit();

        // Clear our schedules
        $this->scheduledForInsertion = [];
        $this->scheduledForUpdate    = [];
        $this->scheduledForDeletion  = [];
        $this->entityRegistry->clearAggregateRoots();
    }
956077
protected function undelete()
    {
        if($this->saveButtonPushed())
        {
            $nodeRef = $this->buildCmsNodeRef();
            $node = $nodeRef->generateNode();
            $location = 'load';

            $this->Events->trigger('NodeCmsController.undelete'.'.'.$location,
                                    $this->errors, $this->templateVars, $node);

            foreach((array)$nodeRef->getElement()->getAspects() as $aspect)
                $this->Events->trigger('NodeCmsController.@'.$aspect->Slug.'.'.'undelete'.'.'.$location,
                                        $this->errors, $this->templateVars, $node);

            if (!$node->hasTitle())
                //get default form backing object
                $node = $this->RegulatedNodeService->getByNodeRef($node->getNodeRef());

            if (empty($node))
                throw new NotFoundException('Record not found for NodeRef: '.$nodeRef);

            // check permissions
            // $this->checkUndeletePermission($node);

            $location = 'pre';
            $this->Events->trigger('NodeCmsController.undelete'.'.'.$location,
                                            $this->errors, $this->templateVars, $node);

            foreach ((array)$nodeRef->getElement()->getAspects() as $aspect)
                $this->Events->trigger('NodeCmsController.@'.$aspect->Slug.'.'.'undelete'.'.'.$location,
                                            $this->errors, $this->templateVars, $node);

            $this->getErrors()->throwOnError();

            $this->RegulatedNodeService->undelete($nodeRef);

            $location = 'post';
            $this->Events->trigger('NodeCmsController.undelete'.'.'.$location, $this->errors, $this->templateVars, $node);
            foreach ((array)$nodeRef->getElement()->getAspects() as $aspect)
                $this->Events->trigger('NodeCmsController.@'.$aspect->Slug.'.'.'undelete'.'.'.$location, $this->errors, $this->templateVars, $node);


            //redirect to edit news (action_success_view)
            return new View($this->successView(), array('slug'=> $nodeRef->getSlug()));
        }
    }