Roll back changes to JDBDT save-point.
@param callInfo Call info.
490951
void restore(CallInfo callInfo) {
    // Note: this is a conservative implementation, it sets another save-point
    // after roll-back, some engines seem to implicitly release the save point on roll-back
    // (an issue with HSQLDB)
    access(callInfo, () -> {
      logSetup(callInfo);
      try {
        if (!savepointSupport) {
          throw new UnsupportedOperationException("Savepoints are not supported by the database driver.");
        }
        if (savepoint == null) {
          throw new InvalidOperationException("Save point is not set.");
        }
        Savepoint s = savepoint;
        savepoint = null;
        connection.rollback(s);
        return 0;
      }
      finally {
        clearSavePointIfSet();
      }
    });
  }
1143837
void save(CallInfo callInfo) {
    access(callInfo, () -> {
      if (!savepointSupport) {
        throw new UnsupportedOperationException("Savepoints are not supported by the database driver.");
      }
      logSetup(callInfo);
      clearSavePointIfSet();
      if (connection.getAutoCommit()) {
        throw new InvalidOperationException("Auto-commit is set for database connection.");
      }      
      savepoint = connection.setSavepoint();
      return 0;
    });
  }
1108284
public void rollback() throws DBCleanException
   {
      try
      {
         execute(rollbackingScripts);
      }
      catch (SQLException e)
      {
         throw new DBCleanException(JDBCUtils.getFullMessage(e), e);
      }
   }
1330974
@Override
    public void rollback() throws BackendException {
        Throwable excep = null;
        for (IndexTransaction itx : indexTx.values()) {
            try {
                itx.rollback();
            } catch (Throwable e) {
                excep = e;
            }
        }
        storeTx.rollback();
        if (excep!=null) { //throw any encountered index transaction rollback exceptions
            if (excep instanceof BackendException) throw (BackendException)excep;
            else throw new PermanentBackendException("Unexpected exception",excep);
        }
    }
1235606
public void rollbackSetRollbackOnly(List objects)
    {
        log.info("rollbackSetRollbackOnly method was called");
        storeObjects(objects);
        /*
        setRollbackOnly does only rollback the transaction, the client will not be
        notified by an RemoteException (tested on JBoss)
        */
        getSessionContext().setRollbackOnly();
        /*
        seems that some appServer expect that all used resources will be closed before
        the JTA-TXManager does call Synchronization#beforeCompletion(), so we have
        to cleanup used resources. This could be done by call abort on odmg-api
        */
        getImplementation().currentTransaction().abort();
    }
831314
final void setCallId(long newId) {
        if (newId <= 0) {
            throw new IllegalArgumentException(String.format("Attempted to set non-positive call ID %d on %s",
                    newId, this));
        }
        final long c = callId;
        if (c > 0) {
            throw new IllegalStateException(String.format(
                    "Attempt to overwrite the call ID of an active operation: current %d, requested %d. %s",
                    callId, newId, this));
        }
        if (!CALL_ID.compareAndSet(this, c, newId)) {
            throw new IllegalStateException(String.format("Concurrent modification of call ID. Initially observed %d,"
                    + " then attempted to set %d, then observed %d. %s", c, newId, callId, this));
        }
        onSetCallId(newId);
    }
1153702
protected void updateMSIdinCallDetailRecord(final String msId, final Sid callSid){
        if(callSid == null){
            if(logger.isDebugEnabled())
                logger.debug("Call Id is not specisfied, it can be an outbound call.");
        }else{
            CallDetailRecordsDao dao = storage.getCallDetailRecordsDao();
            CallDetailRecord cdr = dao.getCallDetailRecord(callSid);
            if(cdr != null){
                cdr = cdr.setMsId(msId);
                dao.updateCallDetailRecord(cdr);
            }else{
                logger.error("provided call id did not found");
            }
        }

    }
978207
public function rollbackSavepoint($savepoint)
    {
        if (! $this->getDatabasePlatform()->supportsSavepoints()) {
            throw ConnectionException::savepointsNotSupported();
        }

        $this->getWrappedConnection()->exec($this->platform->rollbackSavePoint($savepoint));
    }
222345
protected void reloadChangesInfoAfterUC(ImportNodeData currentNodeInfo, String identifier)
      throws PathNotFoundException, IllegalPathException, RepositoryException
   {
      reloadChangesInfoAfterUC(getParent(), currentNodeInfo, identifier);
   }
977148
@Override
    public void rollback() throws SQLException
    {
        checkClosed();
        if (props.getProperty(ROLLBACK_THROW_EXCEPTION, "true").equalsIgnoreCase("true")) {
            throw SQLError.noSupport();
        }
    }
925521
public function rollBack () {
        $this->transaction_level--;

        if(!$this->nestable() || $this->transaction_level == 0) {
            parent::rollBack();
        } else {
            $this->exec("ROLLBACK TO SAVEPOINT LEVEL{$this->transaction_level}");
        }
    }
363057
void write(CallInfo callInfo, SimpleAssertion assertion) {
    Element rootNode = root(callInfo);
    if (assertion.getSource() != null) {
      write(rootNode, assertion.getSource());
    }
    Element saNode = createNode(rootNode, SIMPLE_ASSERTION_TAG);
    if (! assertion.passed()) {
      Element errorsNode = createNode(saNode, ERRORS_TAG);
      createNode(errorsNode, EXPECTED_TAG)
        .setAttribute(VALUE_ATTR, assertion.getExpectedResult().toString());
      createNode(errorsNode, ACTUAL_TAG)
        .setAttribute(VALUE_ATTR, assertion.getActualResult().toString());
    }
    flush(rootNode);
  }
568623
public void put(CallbackType callbackType, CallbackMetadata callbackMetadata) {
    if (callbacks == null) {
      callbacks = new EnumMap<>(CallbackType.class);
    }
    List<CallbackMetadata> callbackMetadataList = callbacks.get(callbackType);
    if (callbackMetadataList == null) {
      callbackMetadataList = new ArrayList<>();
      callbacks.put(callbackType, callbackMetadataList);
    }
    callbackMetadataList.add(callbackMetadata);
  }
1114375
protected void saveProperties(CmsPropertyChangeSet changes, AsyncCallback<Void> callback) {

        if (m_propertySaver != null) {
            m_propertySaver.saveProperties(changes, callback);
        } else {
            CmsCoreProvider.getVfsService().saveProperties(changes, callback);
        }
    }
642081
static void truncate(CallInfo callInfo, Table table) {
    final DB db = table.getDB();   
    db.access(callInfo, () -> {
      String sql = "TRUNCATE TABLE " + table.getName();
      table.setDirtyStatus(true);
      db.logSetup(callInfo, sql);
      try (WrappedStatement ws = db.compile(sql)) {
        ws.getStatement().execute();
      }
      return 0;
    });

  }
233022
function _createCallBack(callBack, callBackEventData, triggerInformation) {
            return function () {
                try {
                    callBack.func.call(callBack.context, callBackEventData, triggerInformation);
                    callBackEventData = null;//Delete local pointer
                    if (callBack.triggerOnce) {
                        unbind(callBack);
                    }
                    callBack = null;
                } catch (err) {
                    //noinspection JSUnresolvedVariable
                    evUtil.log("Error executing " + triggerInformation.eventName + " eventId: " + callBack.id + "e=" + err.message, "ERROR", "Events");
                }
            };
        }
111223
@Override
    public void batchRolledBack()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "batchRolledBack");

        resetDoubtHorizon();

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "batchRolledBack");

    }