Commits the current transaction behind the CpoTrxAdapter
336035
@Override
  public void commit() throws CpoException {
    JdbcCpoAdapter currentResource = getCurrentResource();
    if (currentResource != getLocalResource())
      ((JdbcCpoTrxAdapter)currentResource).commit();
  }
443752
def commit(self):
        """"""
        try:
            self._con.commit()
            self._con.autocommit(True)
        except Exception as e:
            try:
                self._con.rollback()
            except Exception as e_:
                LOGGER.error('When transaction happend error: %s', e_)
            raise e
        finally:
            self._db.pool.push(self._con)
            self._con = None
            self._db = None
1039883
void commitTransaction(HotRodHeader header, Subject subject, XidImpl xid) {
      CommitTransactionOperation operation = new CommitTransactionOperation(header, server, subject, xid,
            this::writeTransactionResponse);
      executor.execute(operation);
   }
580707
public void commit(DBTransaction dbTran) {
        try {
            applyUpdates(dbTran);
        } catch (Exception e) {
            // All retries, if needed, failed.
            m_logger.error("Commit failed", e);
            throw e;
        } finally {
            dbTran.clear();
        }
    }
1276543
public void batchPrecommit(TransactionCommon currentTran)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(this, tc, "batchPrecommit", currentTran);
 
    // Holds TickRanges of all messages to be sent downstream
    TickRange tr1 = null;
    TickRange tickRange = null;
    
    synchronized (this)
    {
      // 316010 : It is possible for the sourcestream to have
      // been removed when the batch timer triggers (if destination
      // is deleted). So check the streamset is still in the store.
      if ( !streamSet.isPersistent() || streamSet.isInStore() )
      {
        for (int i = 0; i < batchList.size(); i++)
        {
          tickRange = (TickRange)batchList.get(i);
          try
          {
            if ((tr1 = msgRemoved(tickRange.valuestamp, oststream, currentTran)) != null)
            {
              batchSendList.add(tr1);
              lastMsgSent = tr1.valuestamp;
            }
          }
          catch (SIResourceException e)
          {
            //FFDC
            FFDCFilter.processException(
              e,
              "com.ibm.ws.sib.processor.gd.SourceStream.batchPrecommit",
              "1:2558:1.138",
              this);
  
            SibTr.exception(tc, e);
          }
        } 
      }  
    }  
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "batchPrecommit");
  }
110807
@Override
	public void commit() throws TransactionManagementException {
		logger.entering(CLASSNAME, "commit");
		try {
			userTran.commit();
			logger.log(Level.FINE, "javax.transaction.Status: {0}", userTran.getStatus());
		} catch (SecurityException e) {
			throw new TransactionManagementException(e);
		} catch (IllegalStateException e) {
			throw new TransactionManagementException(e);
		} catch (RollbackException e) {
			throw new TransactionManagementException(e);
		} catch (HeuristicMixedException e) {
			throw new TransactionManagementException(e);
		} catch (HeuristicRollbackException e) {
			throw new TransactionManagementException(e);
		} catch (SystemException e) {
			throw new TransactionManagementException(e);
		}
		logger.exiting(CLASSNAME, "commit");
	}
796838
def commit(self):
        
        self._check_thread()
        if self.state != _STATE_ACTIVE:
            raise TransactionError("Transaction is not active.")
        try:
            self._check_timeout()
            request = transaction_commit_codec.encode_request(self.id, self.thread_id)
            self.client.invoker.invoke_on_connection(request, self.connection).result()
            self.state = _STATE_COMMITTED
        except:
            self.state = _STATE_PARTIAL_COMMIT
            raise
        finally:
            self._locals.transaction_exists = False
855752
public void commitTransaction()
   {
      CompressedISPNChangesBuffer changesContainer = getChangesBufferSafe();
      final TransactionManager tm = getTransactionManager();
      try
      {
         final List<ChangesContainer> containers = changesContainer.getSortedList();
         commitChanges(tm, containers);
      }
      finally
      {
         changesList.set(null);
         changesContainer = null;
      }
   }
1248565
public function commit()
    {
        --$this->currentTransactionLevel;
        if ($this->currentTransactionLevel == 0 || !$this->nestable()) {
            parent::commit();
        } else {
            $this->exec("RELEASE SAVEPOINT LEVEL{$this->currentTransactionLevel}");
        }
    }
77189
@Override
	public void commit() throws RemoteException {
		tx.commit();
		try {
			tx = VanillaDb.txMgr().newTransaction(isolationLevel, readOnly);
		} catch (Exception e) {
			throw new RemoteException("error creating transaction ", e);
		}
	}
1090384
public CompletableFuture<Void> commit(){
        if(!(delegate instanceof PgTransaction)){
            throw new IllegalStateException("Not in transaction");
        }
        CompletableFuture<Void> commit = new VertxCompletableFuture<>(vertx);
        ((PgTransaction) delegate).commit(createCompletionHandler(commit));
        return commit;
    }
948230
public function commit() {
		if (!$this->inTransaction()) {
			throw new Exception('There is no active transaction');
		}

		$res = @oci_commit($this->_dbh);
		$this->checkError($res);

		$this->_inTransaction = false;
		$this->_commitMode = null;

		return $res;
	}
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();
            }
        }
    }
1208584
public function commitTransaction() {
		$request = new CPS_CommitTransactionRequest();
		$this->_lastResponse = $this->_connection->sendRequest($request);
		return true;
	}
875490
def commit(self, transaction=None, headers=None, **keyword_headers):
        
        assert transaction is not None, "'transaction' is required"
        headers = utils.merge_headers([headers, keyword_headers])
        headers[HDR_TRANSACTION] = transaction
        self.send_frame(CMD_COMMIT, headers)
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);
    }
330803
public void commit() {
		for (TransactionLifecycleListener l : lifecycleListeners)
			l.onTxCommit(this);

		if (logger.isLoggable(Level.FINE))
			logger.fine("transaction " + txNum + " committed");
	}