=== modified file 'src/com/goldencode/p2j/persist/Persistence.java'
--- old/src/com/goldencode/p2j/persist/Persistence.java	2023-01-20 12:07:41 +0000
+++ new/src/com/goldencode/p2j/persist/Persistence.java	2023-02-08 14:13:43 +0000
@@ -584,6 +584,7 @@
 **     OM  20221103          New class names for FQLPreprocessor, FQLExpression, FQLBundle, and FQLCache.
 **     CA  20221109          Implemented runtime for EXCEPT/FIELDS options - only NO-LOCK records are loaded 
 **                           as 'partial/incomplete'.
+**     RAA 20230208          Removed the checks for no-undo as they are no longer necessary. 
 */
 
 /*
@@ -2871,10 +2872,6 @@
          
          Query query = getQuery(local, fql, 0, 0, values, false);
          count = query.executeUpdate(session);
-         if (noUndo)
-         {
-            session.noUndoBulkUpdate(query);
-         }
          
          if (LOG.isLoggable(Level.FINER))
          {
@@ -3477,11 +3474,6 @@
          
          rc = query.executeUpdate(session);
          
-         if (noUndo)
-         {
-            session.noUndoBulkUpdate(query);
-         }
-         
          if (LOG.isLoggable(Level.FINER))
          {
             LOG.log(Level.FINER, "[" + sql + "] rc = " + rc);

=== modified file 'src/com/goldencode/p2j/persist/TempTableHelper.java'
--- old/src/com/goldencode/p2j/persist/TempTableHelper.java	2023-01-10 16:58:00 +0000
+++ new/src/com/goldencode/p2j/persist/TempTableHelper.java	2023-02-08 14:30:56 +0000
@@ -54,6 +54,7 @@
 **     OM  20221027          H2 dialect requires that the index names to be truly unique.
 **     SVL 20230110          P2JIndex.components() provides direct access to the components array in order to
 **                           improve performance.
+**     RAA 20230208          Added "no-undo" as a temp table postfix in constructor.
 */
 
 /*
@@ -391,7 +392,8 @@
       String primaryIndexName = null;
       String primarySqlIndexName = null;
       
-      String createTemporaryTablePostfix = dialect.getCreateTemporaryTablePostfix();
+      String createTemporaryTablePostfix = dialect.getCreateTemporaryTablePostfix(false);
+      String createTemporaryNoUndoTablePostfix = dialect.getCreateTemporaryTablePostfix(true);
       String delimiter = dialect.getDelimiter();
       String suffix = createTemporaryTablePostfix + delimiter;
       while (databaseIndexes.hasNext())
@@ -622,7 +624,14 @@
          {
             table.append(tab).append("primary key (").append(Session.PK).append(")\n");
          }
-         table.append(")").append(createTemporaryTablePostfix).append(delimiter);
+         
+         table.append(")").append(createTemporaryTablePostfix);
+         if (dmo.noUndo)
+         {
+            table.append(createTemporaryNoUndoTablePostfix);
+         }
+         
+         table.append(delimiter);
          
          String tableDDL = table.toString();
          ddlCreateTables.add(tableDDL);

=== modified file 'src/com/goldencode/p2j/persist/dialect/Dialect.java'
--- old/src/com/goldencode/p2j/persist/dialect/Dialect.java	2023-01-28 04:45:51 +0000
+++ new/src/com/goldencode/p2j/persist/dialect/Dialect.java	2023-02-08 14:31:55 +0000
@@ -95,6 +95,9 @@
 **     SVL 20230110          P2JIndex.components() provides direct access to the components array in order to
 **                           improve performance.
 **     ECF 20230127          Added resolveBooleanConstant method.
+**     RAA 20230208          Modified function for creating a temp table postfix. Depending on the parameter,
+**                           it can resume its initial purpose or it can return the keyword specific to
+**                           no-undo temp-tables.
 */
 
 /*
@@ -1312,10 +1315,13 @@
    /**
     * Return the ending of the DDL statement that creates a temporary table.
     *
+    * @param   noUndo
+    *          If {@code true}, this function will return the keyword specific to no-undo temp-tables.
+    *           
     * @return  A string representing the ending of the DDL statement that creates a temporary
     *          table, if any, or empty string otherwise.
     */
-   public abstract String getCreateTemporaryTablePostfix();
+   public abstract String getCreateTemporaryTablePostfix(boolean noUndo);
    
    /**
     * Returns the beginning of the DDL statement for creating an index.

=== modified file 'src/com/goldencode/p2j/persist/dialect/MariaDbLenientDialect.java'
--- old/src/com/goldencode/p2j/persist/dialect/MariaDbLenientDialect.java	2023-01-31 20:57:34 +0000
+++ new/src/com/goldencode/p2j/persist/dialect/MariaDbLenientDialect.java	2023-02-08 14:24:51 +0000
@@ -14,6 +14,7 @@
 **     BS  20230126 Added support for SAVE CACHE.
 **     ECF 20230127 Data type adjustment for SAVE CACHE.
 **     OM  20230131 Code cleanup.
+**     RAA 20230208 Added parameter for getCreateTemporaryTablePostfix.
 */
 
 /*
@@ -1471,13 +1472,17 @@
    /**
     * Return the ending of the DDL statement that creates a temporary table.
     *
+    * @param   noUndo
+    *          This parameter is not used at the moment. The intention was to generate a keyword for
+    *          no-undo tables. Only {@link P2JH2Dialect} benefits from this parameter.
+    * 
     * @return  A string representing the ending of the DDL statement that creates a temporary table, if any,
     *          or empty string otherwise.
     *
     * @see <a href="https://mariadb.com/kb/en/create-table/#transactional">CREATE TABLE TRANSACTIONAL</a>
     */
    @Override
-   public String getCreateTemporaryTablePostfix()
+   public String getCreateTemporaryTablePostfix(boolean noUndo)
    {
       return " transactional";
    }

=== modified file 'src/com/goldencode/p2j/persist/dialect/P2JH2Dialect.java'
--- old/src/com/goldencode/p2j/persist/dialect/P2JH2Dialect.java	2023-01-10 09:20:39 +0000
+++ new/src/com/goldencode/p2j/persist/dialect/P2JH2Dialect.java	2023-02-08 14:26:29 +0000
@@ -106,6 +106,7 @@
 **     OM  20221026          Excluded table name from index name by default. It will be added as needed by
 **                           dialects.
 **     RAA 20230109          Overrided methods getSequenceSetValString() and getSequenceCurrValString().
+**     RAA 20230208          Overrided method for returning the postfix of a no-undo temp-table.
 */
 
 /*
@@ -1321,13 +1322,22 @@
    /**
     * Return the ending of the DDL statement that creates a temporary table.
     *
+    * @param   noUndo
+    *          Parameter that indicates what keyword should be returned. The choices are "transactional"
+    *          and "noundo".
+    *
     * @return  A string representing the ending of the DDL statement that creates a temporary
     *          table.
     */
    @Override
-   public String getCreateTemporaryTablePostfix()
+   public String getCreateTemporaryTablePostfix(boolean noUndo)
    {
-      return " transactional";
+      if (!noUndo)
+      {
+         return " transactional";
+      }
+      
+      return " noundo";
    }
    
    /**

=== modified file 'src/com/goldencode/p2j/persist/dialect/P2JPostgreSQLDialect.java'
--- old/src/com/goldencode/p2j/persist/dialect/P2JPostgreSQLDialect.java	2023-02-04 14:43:34 +0000
+++ new/src/com/goldencode/p2j/persist/dialect/P2JPostgreSQLDialect.java	2023-02-08 14:27:50 +0000
@@ -123,6 +123,7 @@
 **     OM  20221026          Excluded table name from index name by default. It will be added as needed by
 **                           dialects.
 **     RAA 20230109          Overrided method getSequenceSetValString().
+**     RAA 20230208          Added parameter for getCreateTemporaryTablePostfix.
 */
 
 /*
@@ -1679,11 +1680,15 @@
    /**
     * Return the ending of the DDL statement that creates a temporary table.
     *
+    * @param   noUndo
+    *          This parameter is not used at the moment. The intention was to generate a keyword for
+    *          no-undo tables. Only {@link P2JH2Dialect} benefits from this parameter.
+    *
     * @return  A string representing the ending of the DDL statement that creates a temporary
     *          table.
     */
    @Override
-   public String getCreateTemporaryTablePostfix()
+   public String getCreateTemporaryTablePostfix(boolean noUndo)
    {
       return " on commit drop";
    }

=== modified file 'src/com/goldencode/p2j/persist/dialect/P2JSQLServer2008Dialect.java'
--- old/src/com/goldencode/p2j/persist/dialect/P2JSQLServer2008Dialect.java	2023-01-10 16:58:00 +0000
+++ new/src/com/goldencode/p2j/persist/dialect/P2JSQLServer2008Dialect.java	2023-02-08 14:28:55 +0000
@@ -43,6 +43,7 @@
 **     RAA 20230109 Overrided method getSequenceSetValString().
 **     SVL 20230110 P2JIndex.components() provides direct access to the components array in order to improve
 **                  performance.
+**     RAA 20230208 Added parameter for getCreateTemporaryTablePostfix.
 */
 
 /*
@@ -1163,10 +1164,14 @@
    /**
     * Return the ending of the DDL statement that creates a temporary table.
     *
+    * @param   noUndo
+    *          This parameter is not used at the moment. The intention was to generate a keyword for
+    *          no-undo tables. Only {@link P2JH2Dialect} benefits from this parameter.
+    *
     * @return  An empty string. This dialect does not support this feature.
     */
    @Override
-   public String getCreateTemporaryTablePostfix()
+   public String getCreateTemporaryTablePostfix(boolean noUndo)
    {
       return "";
    }

=== removed file 'src/com/goldencode/p2j/persist/orm/SQLRedo.java'
--- old/src/com/goldencode/p2j/persist/orm/SQLRedo.java	2020-06-14 21:34:40 +0000
+++ new/src/com/goldencode/p2j/persist/orm/SQLRedo.java	1970-01-01 00:00:00 +0000
@@ -1,184 +0,0 @@
-/*
-** Module   : SQLRedo.java
-** Abstract : Redoable SQL operation for NO-UNDO temp-table use.
-**
-** Copyright (c) 2020, Golden Code Development Corporation.
-**
-** -#- -I- --Date-- ---------------------------------Description---------------------------------
-** 001 ECF 20200413 First revision. A redoable SQL operation for use with NO-UNDO temp-tables.
-*/
-
-/*
-** This program is free software: you can redistribute it and/or modify
-** it under the terms of the GNU Affero General Public License as
-** published by the Free Software Foundation, either version 3 of the
-** License, or (at your option) any later version.
-**
-** This program is distributed in the hope that it will be useful,
-** but WITHOUT ANY WARRANTY; without even the implied warranty of
-** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-** GNU Affero General Public License for more details.
-**
-** You may find a copy of the GNU Affero GPL version 3 at the following
-** location: https://www.gnu.org/licenses/agpl-3.0.en.html
-**
-** Additional terms under GNU Affero GPL version 3 section 7:
-**
-**   Under Section 7 of the GNU Affero GPL version 3, the following additional
-**   terms apply to the works covered under the License.  These additional terms
-**   are non-permissive additional terms allowed under Section 7 of the GNU
-**   Affero GPL version 3 and may not be removed by you.
-**
-**   0. Attribution Requirement.
-**
-**     You must preserve all legal notices or author attributions in the covered
-**     work or Appropriate Legal Notices displayed by works containing the covered
-**     work.  You may not remove from the covered work any author or developer
-**     credit already included within the covered work.
-**
-**   1. No License To Use Trademarks.
-**
-**     This license does not grant any license or rights to use the trademarks
-**     Golden Code, FWD, any Golden Code or FWD logo, or any other trademarks
-**     of Golden Code Development Corporation. You are not authorized to use the
-**     name Golden Code, FWD, or the names of any author or contributor, for
-**     publicity purposes without written authorization.
-**
-**   2. No Misrepresentation of Affiliation.
-**
-**     You may not represent yourself as Golden Code Development Corporation or FWD.
-**
-**     You may not represent yourself for publicity purposes as associated with
-**     Golden Code Development Corporation, FWD, or any author or contributor to
-**     the covered work, without written authorization.
-**
-**   3. No Misrepresentation of Source or Origin.
-**
-**     You may not represent the covered work as solely your work.  All modified
-**     versions of the covered work must be marked in a reasonable way to make it
-**     clear that the modified work is not originating from Golden Code Development
-**     Corporation or FWD.  All modified versions must contain the notices of
-**     attribution required in this license.
-*/
-
-package com.goldencode.p2j.persist.orm;
-
-import com.goldencode.p2j.persist.*;
-
-/**
- * This class re-applies a single database insert, update, or [bulk] delete action, in order to
- * redo such an action that was undone by a database rollback (savepoint or full transaction).
- * It is needed to implement the NO-UNDO feature of 4GL temp-tables.
- * <p>
- * The top-level class is abstract. To use this class, instantiate one of the specialized,
- * concrete, inner subclasses.
- */
-abstract class SQLRedo
-{
-   /** Lambda which performs the redo action and possibly throws a persistence exception */
-   private final ThrowingAction action;
-   
-   /** Flag indicating that the original action was rolled back and redo is required */
-   private boolean active = false;
-   
-   /**
-    * Constructor.
-    * 
-    * @param   action
-    *          Lambda which performs the redo action and possibly throws a persistence exception.
-    */
-   protected SQLRedo(ThrowingAction action)
-   {
-      this.action = action;
-   }
-   
-   /**
-    * Mark this redo action as active, meaning the original action which this object was undone
-    * by a full or sub-transaction rollback, and needs to be re-applied. If an instance of this
-    * class is not marked active, it is a no-op.
-    */
-   void setActive()
-   {
-      active = true;
-   }
-   
-   /**
-    * Perform this object's redo action, if it was marked active.
-    * 
-    * @throws  PersistenceException
-    *          if there is an error executing the action.
-    */
-   void perform()
-   throws PersistenceException
-   {
-      if (active)
-      {
-         action.run();
-      }
-   }
-   
-   /**
-    * A no-arg functional interface which throws PersistenceException, to avoid having to handle
-    * this exception in every defined lambda expression.
-    */
-   @FunctionalInterface
-   protected interface ThrowingAction
-   {
-      /**
-       * Run a SQL operation.
-       * 
-       * @throws  PersistenceException
-       *          if a persistence error occurs.
-       */
-      public void run()
-      throws PersistenceException;
-   }
-   
-   /**
-    * An insert action for a single record.
-    */
-   static class Insert
-   extends SQLRedo
-   {
-      Insert(Persister persister, BaseRecord dmo)
-      {
-         super(() -> persister.insert(dmo));
-      }
-   }
-   
-   /**
-    * An update action for a single record.
-    */
-   static class Update
-   extends SQLRedo
-   {
-      Update(Persister persister, BaseRecord dmo)
-      {
-         super(() -> persister.update(dmo));
-      }
-   }
-   
-   /**
-    * A delete action for a single record.
-    */
-   static class Delete
-   extends SQLRedo
-   {
-      Delete(Persister persister, Class<? extends BaseRecord> dmoClass, Long id)
-      {
-         super(() -> persister.delete(dmoClass, id));
-      }
-   }
-   
-   /**
-    * A bulk action (delete or update) which affects 0 or more records.
-    */
-   static class BulkUpdate
-   extends SQLRedo
-   {
-      BulkUpdate(Session session, SQLQuery query)
-      {
-         super(() -> query.executeUpdate(session));
-      }
-   }
-}

=== modified file 'src/com/goldencode/p2j/persist/orm/SavepointManager.java'
--- old/src/com/goldencode/p2j/persist/orm/SavepointManager.java	2023-02-03 19:01:50 +0000
+++ new/src/com/goldencode/p2j/persist/orm/SavepointManager.java	2023-02-08 14:29:25 +0000
@@ -26,6 +26,7 @@
 **                  Added JMX for profiling NO-UNDO operation tracing.
 **     CA  20220630 Cleanup the 'redoable' list once the full transaction ends.
 **     CA  20230116 Avoid creating a collection until is needed.
+**     RAA 20230208 Removed all code that was linked to redo operations as it is no longer needed.
 */
 
 /*
@@ -150,9 +151,6 @@
    /** Stack of block states which coincide with transaction block scopes */
    private final Deque<Block> blocks = new ArrayDeque<>();
    
-   /** The list of redoable insert, update, and delete SQL operations for NO-UNDO temp-tables */
-   private final List<SQLRedo> redoable = new ArrayList<>(64);
-   
    /** Database session used for savepoint processing */
    private Session session = null;
    
@@ -331,8 +329,7 @@
    
    /**
     * Roll back the active block, which entails rolling back any savepoint, rolling up tracked
-    * resources, and marking any tracked undoable records as stale and any redoable operations
-    * as active.
+    * resources, and marking any tracked undoable records as stale.
     * 
     * @param   transaction
     *          {@code true} if the current block is a full transaction; {@code false} if it is
@@ -461,85 +458,6 @@
    }
    
    /**
-    * Create a redoable SQL operation for the insertion of a NO-UNDO record into the database. If
-    * the original operation is rolled back at the database, this operation must be re-applied
-    * after the full or sub-transaction which rolled it back completes.
-    * 
-    * @param   dmo
-    *          DMO which was updated.
-    */
-   void noUndoInsert(BaseRecord dmo)
-   {
-      if (session != null && activeBlock != null)
-      {
-         NO_UNDO_TRACE.timer(() -> {
-            SQLRedo.Insert redo = new SQLRedo.Insert(session.getPersister(), dmo.deepCopy());
-            redoable.add(redo);
-         });
-      }
-   }
-   
-   /**
-    * Create a redoable SQL operation for the update of a NO-UNDO record in the database. If
-    * the original operation is rolled back at the database, this operation must be re-applied
-    * after the full or sub-transaction which rolled it back completes.
-    * 
-    * @param   dmo
-    *          DMO which was updated.
-    */
-   void noUndoUpdate(BaseRecord dmo)
-   {
-      if (session != null && activeBlock != null && dmo.checkState(CHANGED))
-      {
-         NO_UNDO_TRACE.timer(() -> {
-            SQLRedo.Update redo = new SQLRedo.Update(session.getPersister(), dmo.deepCopy());
-            redoable.add(redo);
-         });
-      }
-   }
-   
-   /**
-    * Create a redoable SQL operation for the deletion of a NO-UNDO record from the database. If
-    * the original operation is rolled back at the database, this operation must be re-applied
-    * after the full or sub-transaction which rolled it back completes.
-    * 
-    * @param   dmoClass
-    *          Implementation class of the DMO which was deleted.
-    * @param   id
-    *          Primary key of the record which was deleted.
-    */
-   void noUndoDelete(Class<? extends BaseRecord> dmoClass, Long id)
-   {
-      if (session != null && activeBlock != null)
-      {
-         NO_UNDO_TRACE.timer(() -> {
-            SQLRedo.Delete redo = new SQLRedo.Delete(session.getPersister(), dmoClass, id);
-            redoable.add(redo);
-         });
-      }
-   }
-   
-   /**
-    * Create a redoable SQL operation for the bulk update of zero or more NO-UNDO records in
-    * the database. The operation may be an update or a delete. If the original operation is
-    * rolled back at the database, this operation must be re-applied after the full or
-    * sub-transaction which rolled it back completes.
-    * 
-    * @param   query
-    *          SQL query which performed the original bulk operation.
-    */
-   void noUndoBulkUpdate(SQLQuery query)
-   {
-      if (session != null && activeBlock != null)
-      {
-         NO_UNDO_TRACE.timer(() -> {
-            SQLRedo.BulkUpdate redo = new SQLRedo.BulkUpdate(session, query);
-            redoable.add(redo);
-         });
-      }
-   }
-   
-   /**
     * Set a savepoint in the active block and in every previous block which has not yet had one set,
     * except for the outermost (which represents the full transaction block).
     * <p>
@@ -622,7 +540,7 @@
    private void prepareBlock()
    {
       parentBlock = blocks.peek();
-      activeBlock = new Block(blocks.size(), redoable);
+      activeBlock = new Block(blocks.size());
       blocks.push(activeBlock);
       
       if (debug)
@@ -643,13 +561,6 @@
       Block lastActiveBlock = activeBlock;
       Block popped = blocks.pop();
       
-      // reapply undone changes for any NO-UNDO temporary tables
-      // let the noUndoRolledBack flag check here to avoid profiling disabled redo
-      if (session != null && lastActiveBlock != null && lastActiveBlock.noUndoRolledBack)
-      {
-         REDO.timer(() -> lastActiveBlock.maybeReapplyNoUndo(session));
-      }
-      
       // reactivate the next block in the stack (if any)
       activeBlock = blocks.isEmpty() ? null : blocks.pop();
       parentBlock = blocks.isEmpty() ? null : blocks.peek();
@@ -667,10 +578,6 @@
       {
          // full transaction is finished, deactivate savepoint manager (i.e., remove session)
          this.session = null;
-         if (redoable != null)
-         {
-            redoable.clear();
-         }
       }
    }
    
@@ -735,26 +642,15 @@
       /** Records which have been changed in the scope of this block */
       private Set<BaseRecord> changed = null;
       
-      /** List of SQL redo helpers for NO-UNDO records, shared among all blocks */
-      private final List<SQLRedo> redoable;
-      
-      /** Starting index for this block in full transaction redoable list */
-      private final int redoHead;
-      
       /** Database savepoint for a sub-transaction block ({@code null} for full transaction */
       private Savepoint savepoint = null;
       
-      /** Have we rolled back NO-UNDO changes in this block which will need to be re-applied? */
-      private boolean noUndoRolledBack = false;
-      
       /**
        * Constructor.
        */
-      Block(int txLevel, List<SQLRedo> redoable)
+      Block(int txLevel)
       {
          this.txLevel = txLevel;
-         this.redoable = redoable;
-         this.redoHead = redoable.size();
       }
       
       /**
@@ -808,14 +704,14 @@
       }
       
       /**
-       * Roll back changes to undoable records and activate redoable actions for NO-UNDO records.
+       * Roll back changes to undoable records.
        */
       void rollback()
       throws PersistenceException
       {
          if (txLevel > 0 && savepoint == null)
          {
-            // no DMOs were updated within this block, so nothing to undo nor mark for deferred redo
+            // no DMOs were updated within this block, so nothing to undo
             return;
          }
          
@@ -826,17 +722,6 @@
                dmo.rollback(txLevel);
             }
          }
-         
-         int redoSize = redoable.size();
-         if (redoSize > redoHead)
-         {
-            noUndoRolledBack = true;
-            
-            for (int i = redoHead; i < redoSize; i++)
-            {
-               redoable.get(i).setActive();
-            }
-         }
       }
       
       /** Notify the FastFind cache that the changed tables need to be invalidated. */
@@ -868,84 +753,6 @@
       }
       
       /**
-       * Indicate whether this block is tracking any NO-UNDO records.
-       * 
-       * @return  {@code true} if there are any NO-UNDO records associated with this block, else
-       *          {@code false}.
-       */
-      boolean isTrackingNoUndo()
-      {
-         return redoable.size() > redoHead;
-      }
-      
-      /**
-       * Re-apply any changes to no-undo records which were rolled back in the most recent
-       * savepoint or full transaction.
-       * 
-       * @param   session
-       *          Database session helper object.
-       */
-      void maybeReapplyNoUndo(Session session)
-      {
-         if (!noUndoRolledBack)
-         {
-            // nothing to do
-            return;
-         }
-         
-         boolean fullTx = false;
-         
-         try
-         {
-            // if the active block was a full transaction block, we need to start a separate,
-            // full, transaction to re-roll forward any NO-UNDO changes that were rolled back
-            // at the database; for sub-transactions, we will still be in the context of the
-            // existing transaction
-            if (txLevel == 0)
-            {
-               fullTx = session.beginTransaction(null);
-            }
-            
-            int redoSize = redoable.size();
-            for (int i = redoHead; i < redoSize; i++)
-            {
-               SQLRedo redo = redoable.get(i);
-               redo.perform();
-            }
-            
-            if (fullTx)
-            {
-               session.commit();
-            }
-         }
-         catch (PersistenceException exc)
-         {
-            if (fullTx)
-            {
-               if (log.isLoggable(Level.SEVERE))
-               {
-                  log.log(Level.SEVERE, "Error reapplying rolled back NO-UNDO changes", exc);
-               }
-               
-               try
-               {
-                  session.rollback();
-               }
-               catch (PersistenceException exc1)
-               {
-                  if (log.isLoggable(Level.SEVERE))
-                  {
-                     log.log(Level.SEVERE, "Error rolling back NO-UNDO reapply transaction", exc1);
-                  }
-               }
-            }
-            
-            // TODO: proper error handling
-            throw new StopConditionException(exc);
-         }
-      }
-      
-      /**
        * Get a debug text representation of this object.
        * 
        * @return  Text representation of state.

=== modified file 'src/com/goldencode/p2j/persist/orm/Session.java'
--- old/src/com/goldencode/p2j/persist/orm/Session.java	2023-01-20 12:07:41 +0000
+++ new/src/com/goldencode/p2j/persist/orm/Session.java	2023-02-08 14:29:58 +0000
@@ -38,6 +38,7 @@
 **                  the database, and not just returned.
 **     CA  20230104 If a cached record is incomplete, preserve the dirty properties when loading the full
 **                  record.
+**     RAA 20230208 Removed everything that had to do with redo operations as it is no longer needed.
 */
 
 /*
@@ -743,25 +744,6 @@
       boolean wasNew = dmo.checkState(NEW);
       boolean wasDirty = wasNew || dmo.isDirty();
       
-      if (wasDirty && savepointManager != null)
-      {
-         // undoable events must be logged with the DMO before the insert/update takes place, because
-         // the logging might trigger a database savepoint to be lazily set, and this savepoint must
-         // include the insert/update
-         
-         if (dmo.checkState(NOUNDO))
-         {
-            if (wasNew)
-            {
-               savepointManager.noUndoInsert(dmo);
-            }
-            else
-            {
-               savepointManager.noUndoUpdate(dmo);
-            }
-         }
-      }
-      
       // decide what to do with the record
       if (wasNew)
       {
@@ -873,12 +855,7 @@
       
       // attempt to delete the record if it is not newly created (i.e., as of yet unflushed)
       if (!dmo.checkState(NEW))
-      {
-         if (savepointManager != null && dmo.checkState(NOUNDO))
-         {
-            savepointManager.noUndoDelete(dmo.getClass(), dmo.primaryKey());
-         }
-         
+      {  
          success = persister.delete(dmo);
       }
       
@@ -957,11 +934,6 @@
          @SuppressWarnings("unchecked")
          Class<? extends Record> recordClass = (Class<? extends Record>) dmoClass;
          
-         if (savepointManager != null && cached != null && cached.checkState(NOUNDO))
-         {
-            savepointManager.noUndoDelete(recordClass, id);
-         }
-         
          success = persister.delete(recordClass, id);
       }
       
@@ -1518,43 +1490,6 @@
    }
    
    /**
-    * Create a redoable SQL operation for the bulk update of zero or more NO-UNDO records in
-    * the database. The operation may be an update or a delete. If the original operation is
-    * rolled back at the database, this operation must be re-applied after the full or
-    * sub-transaction which rolled it back completes.
-    * <p>
-    * This method delegates to the session's savepoint manager, if any, whose responsibility it
-    * is to track and apply the corresponding redoable SQL operation at the appropriate moment.
-    * 
-    * @param   query
-    *          FQL query which performed the original bulk operation.
-    */
-   public void noUndoBulkUpdate(Query query)
-   {
-      noUndoBulkUpdate(query.getSqlQuery());
-   }
-   
-   /**
-    * Create a redoable SQL operation for the bulk update of zero or more NO-UNDO records in
-    * the database. The operation may be an update or a delete. If the original operation is
-    * rolled back at the database, this operation must be re-applied after the full or
-    * sub-transaction which rolled it back completes.
-    * <p>
-    * This method delegates to the session's savepoint manager, if any, whose responsibility it
-    * is to track and apply the corresponding redoable SQL operation at the appropriate moment.
-    * 
-    * @param   query
-    *          SQL query which performed the original bulk operation.
-    */
-   public void noUndoBulkUpdate(SQLQuery query)
-   {
-      if (savepointManager != null)
-      {
-         savepointManager.noUndoBulkUpdate(query);
-      }
-   }
-   
-   /**
     * Get the zero-based transaction block nesting level, where 0 indicates the current block is a full
     * transaction block, 1 indicates the current block is the first level of nested subtransaction, and so
     * on. Note that this includes only blocks with transaction properties; no-transaction blocks which may

