Commits work done.
5163
@Override
    public void commit() throws DataCorruptedException, IOException, IllegalStateException{
        try {
            tranManager.commit(t1);
        } catch (RollbackException e) {
            rollback();
            throw new IOException("Error trying to commit transaction.", e);
        } catch (TransactionException e) {
            rollback();
            throw new IOException("Error trying to commit transaction.", e);
        }
    }
326802
def commit(self):
        """"""
        request = self.edits().commit(**self.build_params()).execute()

        print 'Edit "%s" has been committed' % (request['id'])
        self.edit_id = None
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()
255234
@Override
  public void commit() throws IOException {
    try {
      LOG.info("Flushing pending insert.");
      this.commands.flush();
      LOG.info("Commiting transaction.");
      this.conn.commit();
    } catch (Exception e) {
      this.failed = true;
      throw new RuntimeException(e);
    }
  }
1020846
public function commit()
    {
        $this->assert();

        $current = $this->current;
        $this->current = $current->getParentKeepingChildren();

        if (!$this->current instanceof Transaction) {
            // There are no transactions, dispatch all reserved payloads
            foreach ($current->flatten() as $payload) {
                $payload->fire();
            }
        }
    }
901552
public function commit() : void
    {
        $this->eventDispatcher->dispatchPreFlush();

        if ($this->objectsToPersist === [] &&
            $this->objectsToUpdate === [] &&
            $this->objectsToRemove === []
        ) {
            return; // Nothing to do.
        }

        $objects = array_merge(
            $this->objectsToPersist,
            $this->objectsToUpdate,
            $this->objectsToRemove
        );
        $this->eventDispatcher->dispatchPreFlushLifecycleCallbacks($objects);

        $this->eventDispatcher->dispatchOnFlush();

        $this->persister->executePersists();
        $this->persister->executeUpdates();
        $this->persister->executeRemoves();

        $this->eventDispatcher->dispatchPostFlush();

        $this->objectsToPersist = [];
        $this->objectsToUpdate  = [];
        $this->objectsToRemove  = [];
        $this->objectChangeSets = new ChangeSets();
    }
1308966
void commit()
        throws IOException
    {
        if (_writer!=null && _writer.isWritten())
            _writer.flush();
        else
            _httpResponse.commit();
    }
1081129
def commit(self):
        ""
        if self._meta.path:
            with open(self._meta.path, 'wb') as fd:
                raw = deepcopy(self.raw)
                # LAZY INDEX PROCESSING
                # Save indexes only if not lazy
                lazy_indexes = self.lazy_indexes  # Keep this list safe
                if not self._meta.lazy_indexes:
                    # Remove indexes if needed
                    for idx_name in lazy_indexes:
                        del raw['indexes'][idx_name]
                    for index_name, values in raw['indexes'].items():
                        for value, keys in values.items():
                            raw['indexes'][index_name][value] = list(keys)
                # don't store indexes if not needed
                if not raw['indexes'] or self._meta.lazy_indexes:
                    del raw['indexes']
                try:
                    fd.write(six.u(self.serialize(raw)))
                except TypeError:
                    fd.write(six.b(self.serialize(raw)))
330803
public void commit() {
		for (TransactionLifecycleListener l : lifecycleListeners)
			l.onTxCommit(this);

		if (logger.isLoggable(Level.FINE))
			logger.fine("transaction " + txNum + " committed");
	}
745706
def commit(self):
        """"""
        out = open(self.name,'wb')
        cPickle.dump(self.fields,out,self.protocol)
        cPickle.dump(self.next_id,out,self.protocol)
        cPickle.dump(self.records,out,self.protocol)
        cPickle.dump(self.indices,out,self.protocol)
        out.close()
1067619
public function commit()
    {
        $this->assertIsSupported($this->supportsTransactions, __METHOD__);
        $this->wrapped->getConnection()->commit();
    }
1324896
def commit(self):
        '''
        
        '''

        commit = self._log(num=-1, format='%H')
        if commit.get('returncode') == 0:
            return commit.get('stdout')
984773
def commit(self):
        """"""
        self.send_buffered_operations()
        retry_until_ok(self.elastic.indices.refresh, index="")
957324
public function commit()
    {
        if (! $this->isValid()) return;

        if ($this->_depth > 1) {
            $this->_depth --;
            return;
        }

        foreach ($this->getConnections() as $connection) {
            $connection->commit();
        }

        $this->_depth = 0;
    }
1058851
public synchronized void commitPending(TaskAttemptID taskid,
                                         TaskStatus taskStatus)
  throws IOException {
    LOG.info("Task " + taskid + " is in commit-pending," +"" +
             " task state:" +taskStatus.getRunState());
    statusUpdate(taskid, taskStatus);
    reportTaskFinished(taskid, true);
  }
226635
private function commit()
    {
        //====================================================================//
        // Safety Checks
        if (empty($this->new)) {
            return true;
        }
        //====================================================================//
        // Create Field List
        if (empty($this->blocks)) {
            $this->blocks = array();
        }
        //====================================================================//
        // Insert Field List
        $this->blocks[] = $this->new;
        $this->new = null;

        return true;
    }
1107516
public void commit(ICommitChanges changes, boolean incrementVersions, Runnable r) {
        beginWrite();

        try {
            checkForConcurrentModifications(changes, incrementVersions);

            saveChanges(changes);
            
            if (r != null) {
                r.run();
            }
        } finally {
            endWrite();
        }
    }