Commit the journal to the point where the snapshot was taken.  This
        will merge in any changesets that were recorded *after* the snapshot changeset.
327385
def commit(self, snapshot: Tuple[Hash32, UUID]) -> None:
        
        _, account_snapshot = snapshot
        self._account_db.commit(account_snapshot)
869622
def commit(self, session=None):
        
        if self.__cleared:
            return

        if self._parent:
            # nested transaction
            self._commit_parent()
        else:
            self._commit_repository()
        self._clear()
654031
public void commit() {
        if (checkSession()) {
            return;
        }

        if (log.isDebugEnabled()) {
            log.debug(String.format("Committing transactional %s@%x",
                    sqlSession.getClass().getSimpleName(),
                    sqlSession.hashCode()));
        }

        sqlSession.commit();
    }
157795
protected void completeSnapshot(Snapshot snapshot) {
    Assert.notNull(snapshot, "snapshot");
    snapshots.put(snapshot.index(), snapshot);

    if (currentSnapshot == null || snapshot.index() > currentSnapshot.index()) {
      currentSnapshot = snapshot;
    }

    // Delete old snapshots if necessary.
    if (!storage.retainStaleSnapshots()) {
      Iterator<Map.Entry<Long, Snapshot>> iterator = snapshots.entrySet().iterator();
      while (iterator.hasNext()) {
        Snapshot oldSnapshot = iterator.next().getValue();
        if (oldSnapshot.index() < currentSnapshot.index()) {
          iterator.remove();
          oldSnapshot.close();
          oldSnapshot.delete();
        }
      }
    }
  }
532621
public function afterVersionedSave()
    {
        if ($this->wasDirty && static::$createRevisionOnSave) {
            // save a copy to history table
            $recordValues = $this->_prepareRecordValues();
            $set = static::_mapValuesToSet($recordValues);
            DB::nonQuery(
                'INSERT INTO `%s` SET %s',
                [
                    static::getHistoryTable(),
                    join(',', $set),
                ]
            );
        }
    }
378832
def commit_changeset(self, changeset_id: uuid.UUID) -> Dict[bytes, Union[bytes, DeletedEntry]]:
        
        does_clear = self.has_clear(changeset_id)
        changeset_data = self.pop_changeset(changeset_id)
        if not self.is_empty():
            # we only have to assign changeset data into the latest changeset if
            # there is one.
            if does_clear:
                # if there was a clear and more changesets underneath then clear the latest
                # changeset, and replace with a new clear changeset
                self.latest = {}
                self._clears_at.add(self.latest_id)
                self.record_changeset()
                self.latest = changeset_data
            else:
                # otherwise, merge in all the current data
                self.latest = merge(
                    self.latest,
                    changeset_data,
                )
        return changeset_data
1082706
public function commit()
	{
		$this->sourceWidth = $this->frameWidth;
		$this->sourceHeight = $this->frameHeight;
		$this->offsetX = 0;
		$this->offsetY = 0;
		$this->scaleWidth = $this->frameWidth;
		$this->scaleHeight = $this->frameHeight;

		$this->getFocalPoint();
	}
620693
public function commit(): void
	{
		// Replace old flash data with new

		$this->sessionData['mako.flashdata'] = $this->flashData;

		// Write session data

		if(!$this->destroyed)
		{
			$this->store->write($this->sessionId, $this->sessionData, $this->options['data_ttl']);
		}
	}
358771
void commit() {
    long index = this.index;
    for (ServerSessionContext session : sessions.sessions.values()) {
      session.commit(index);
    }
  }
984773
def commit(self):
        """"""
        self.send_buffered_operations()
        retry_until_ok(self.elastic.indices.refresh, index="")
1123930
def commit(self):
        
        if self.textAfter is None:
            # If this is the first 'commit' call then do not make
            # any changes but store the current document state
            # and its style.
            line, col = self.qteWidget.getNumLinesAndColumns()
            text, style = self.qteWidget.SCIGetStyledText((0, 0, line, col))
            self.styleAfter = style
            self.textAfter = text.decode('utf-8')
        else:
            # Put the document into the 'after' state.
            self.baseClass.setText(self.textAfter)
            self.qteWidget.SCISetStylingEx(0, 0, self.styleAfter)
        self.placeCursor(*self.origPosition)
648968
def commit(self):
        '''
        
        '''
        if self._fetched is None:
            raise RuntimeError('commit() was called but nothing was fetched')
        self._cache = self._cache[self._fetched:]
        self._fetched = None
620885
private void changeState() {
        if (m_state == State.RESTORE) {
            fetchSnapshotTxnId();

            exitRestore();
            m_state = State.REPLAY;

            /*
             * Add the interest here so that we can use the barriers in replay
             * agent to synchronize.
             */
            m_snapshotMonitor.addInterest(this);
            m_replayAgent.replay();
        } else if (m_state == State.REPLAY) {
            m_state = State.TRUNCATE;
        } else if (m_state == State.TRUNCATE) {
            m_snapshotMonitor.removeInterest(this);
            if (m_callback != null) {
                m_callback.onReplayCompletion(m_truncationSnapshot, m_truncationSnapshotPerPartition);
            }

            // Call balance partitions after enabling transactions on the node to shorten the recovery time
            if (m_isLeader) {
                m_replayAgent.resumeElasticOperationIfNecessary();
            }
        }
    }
911372
private void finish(boolean commit)
   {
      for (Synchronization s : syncs)
      {
         s.beforeCompletion();
      }

      if (commit)
      {
         status = Status.STATUS_COMMITTED;
      }
      else
      {
         status = Status.STATUS_ROLLEDBACK;
      }

      for (Synchronization s : syncs)
      {
         s.afterCompletion(status);
      }

      status = Status.STATUS_UNKNOWN;
      syncs.clear();
      resources.clear();
   }
918972
def snapshot
      { state: @state.root_hash,
        gas: gas_used,
        txs: @transactions,
        txcount: @transaction_count,
        refunds: refunds,
        suicides: suicides,
        suicides_size: suicides.size,
        logs: logs,
        logs_size: logs.size,
        journal: @journal, # pointer to reference, so is not static
        journal_size: @journal.size,
        ether_delta: ether_delta
      }
    end
250051
def save(self, commit=True, **kwargs):
        
        if self.post:
            for form in self.forms:
                form.instance.post = self.post
        super().save(commit)
827094
def Commit(self):
		
		self.lock.acquire()
		try:
			for bucket in self.connections.values():
				try:
					for conn in bucket:
						conn.lock()
						try:
							conn.commit()
							conn.release()
						except Exception:
							conn.release()
				except Exception:
					pass
		finally:
			self.lock.release()