How to Revert Database Changes Made in a Session Without Using Transaction Management?

Question

I'm working on a simple Java application where I need to perform database operations using Java Persistence API (JPA). I want to know if there's a way to revert changes made in the session if an error occurs during the process, without relying on explicit transaction management.

Here is the function that does the db transaction.

  public void insertOrUpdateEntity(final Object entityObject) throws SqlException {
    Transaction transaction = this.session.beginTransaction();
    try {
      this.session.merge(entityObject);
      transaction.commit();
    }
    catch (PersistenceException e) {
      if (transaction != null) {
        transaction.rollback();
      }
      this.session.flush();
    }
  }

Here is the function that uses above function

  private void performDatabaseUpdate() {
    DataBaseOperations dbOperations = null;
    DataBaseConfigurator dbConfiguration = this.databaseConnectionDetails.getDatabaseConnection();

    try {
      dbOperations = dbConfiguration.getSession();

      dbOperations.insertOrUpdateEntity(entityObject1);
      dbOperations.insertOrUpdateEntity(entityObject2);
      dbOperations.insertOrUpdateEntity(entityObject3);
      dbOperations.insertOrUpdateEntity(entityObject4);
      
    }
    catch (Exception e) {
          e.getMessage();
    }
    finally {
      dbOperations.close();
    }
  }

Specifically, I'm looking for features or techniques within JPA that allow me to:

Begin a session for performing database operations. Save a series of annotated entity objects in the session. Revert changes made in the session if any exception occurs during the saving process, ensuring that changes are not persisted to the database. Which means, when any exception occurs while saving theentityObject4 i want to revert back the changes made into the database wrt entityObject1, entityObject2, entityObject3.

I tried following

 Transaction transaction = this.session.beginTransaction();
    try {
      this.session.merge(entityObject);
      transaction.commit();
    }
    catch (PersistenceException e) {
      if (transaction != null) {
        transaction.rollback();
      }
      **this.session.flush();**
    }

Is there any built-in functionality or recommended approach within JPA to achieve this, without explicitly managing transactions? Any insights or examples demonstrating how to implement this in a simple Java application would be greatly appreciated. Thank you.