rollback_wip_ecf_20200609.patch

         *          validation failure and is recoverable.
         */
        private Object[] validateMaybeFlush(Session session,
                                            BaseRecord dmo,
                                            Record dmo,
                                            String bufferName,
                                            UniqueTracker uniqueTracker,
                                            UniqueTracker.Context uniqueTrackerCtx,
-...
        throws PersistenceException,
               ValidationException
+       {
           if (currentRecord == null)
           if (dmo == null)
+          {
              return null;
+          }
           boolean insert = currentRecord.checkState(DmoState.NEW);
           boolean insert = dmo.checkState(DmoState.NEW);
           Validation validation = new Validation(session,
                                                  dmo,
-...
                                                  force);
           Object[] diffs = validation.validateMaybeFlush();
           if (validation.wasFlushed())
           if (dmo == currentRecord && validation.wasFlushed())
+          {
              if (insert)
+             {
                 markPersisted();
+             }
              reportChange(currentRecord, insert, false);
              reportChange(dmo, insert, false);
+          }
           return diffs;
-...
         *          if there is no record loaded into the buffer and the error
         *          manager is not in silent mode.
         */
        private void load(Record target,
                          LockType lockType,
                          boolean undo,
                          boolean allowWriteTrigger)
        private void load(Record target, LockType lockType, boolean undo, boolean allowWriteTrigger)
+       {
           if (target == currentRecord && undo && isTemporary())
+          {
-...
         * This class also ensures uncommitted updates to permanent tables are
         * shared across contexts via the dirty share manager.
+        *
         * @deprecated
         * @deprecated This class must be removed entirely once the dirty share manager
         *             is re-integrated.
         */
        protected class ValidationHelper
+       {
-...
              LightweightUndoable copy = (LightweightUndoable) from;
              // Reset current record and snapshot to what they were before backup.
              // reset current record, snapshot, and pinned lock type to what they were before backup
              /*
              Record active = copy.activeRecord;
              if (active != null)
+             {
-...
                    setCurrentRecord(null, true, false, false, false);
+                }
+             }
              */
              setCurrentRecord(copy.activeRecord, true, false, false, false);
              snapshot = copy.activeSnapshot;
              LockType lockType = copy.pinnedLockType;
              Long id = copy.activeRecord.primaryKey();
              LockType pinned = getPinnedLockType(id);
              if (lockType == null)
+             {
                 lockType = pinned;
+             }
              if (!lockType.equals(pinned))
+             {
                 setPinnedLockType(id, lockType);
+             }
+          }
           /**

+       }
        /**
         * Does the table to which this record belongs have any unique index defined?
+        *
         * @return  {@code true} if at least on unique index exists, else {@code false}.
         */
        public boolean hasUniqueConstraints()
+       {
           return _recordMeta().uniqueIndices.length > 0;
+       }
        /**
         * Indicate whether all index components for any index on this record are dirty (i.e., have been touched,
         * not necessarily changed..
+        *
-...
         *          sub-transactions.
         */
        void rollback(Session session, int txLevel)
        throws PersistenceException
+       {
           if (changeSet == null)
+          {

     import java.util.*;
     import java.util.logging.*;
     import com.goldencode.p2j.persist.*;
     import com.goldencode.p2j.util.*;
     /**
-...
         *          Record to be rolled back.
         */
        void rollback(Session session, int txLevel, BaseRecord dmo)
        throws PersistenceException
+       {
           if (changes == null || txLevel < outer || txLevel > inner)
+          {
-...
                 // TODO: is this needed?
+             }
              if ((next & Event.INSERT) == Event.INSERT)
              if ((next & Event.CREATE) == Event.CREATE)
+             {
                 dmo.updateState(DmoState.NEW, false);
+             }
              boolean insert = (next & Event.INSERT) == Event.INSERT;
              boolean delete = (next & Event.DELETE) == Event.DELETE;
              if (insert)
+             {
                 dmo.updateState(DmoState.NEW, true);
                 if (!delete)
+                {
                    // if not deleted in the same block, evict record from session cache
                    session.evict(dmo);
+                }
+             }
              // handle create and/or delete
              if ((next & (Event.CREATE | Event.DELETE)) != Event.NONE)
              if (delete)
+             {
                 // mark record stale to allow higher level recovery code to restore record; this essentially
                 // ignores any data-level rollback done above, since the database's state will be used instead
                 // FOR CREATE: whether or not the record was also inserted at this block, the database will
                 // have rolled back its existence at this or an inner block, so we should end up with a null
                 // record after sync'ing with the database
                 // FOR DELETE: since an application delete and database delete will happen within the same
                 // block scope, the state of the record in the database should be what we want in the DMO at
                 // the time of rollback
                 dmo.updateState(DmoState.STALE, true);
                 dmo.updateState(DmoState.DELETED, false);
                 if (!insert)
+                {
                    // if not inserted in the same block, add record to session cache
                    // TODO: optimization: if insert is rolled back in an outer block, this effort is wasted
                    session.associate(dmo);
+                }
+             }
              // events have been rolled back; clear the flags

src/com/goldencode/p2j/persist/orm/SavepointManager.java 2020-06-08 22:22:53 +0000
634	634	* Roll back changes to undoable records and activate redoable actions for NO-UNDO records.
635	635	*/
636	636	void rollback(Session session)
	637	throws PersistenceException
637	638	{
638	639	for (BaseRecord dmo : changed)
639	640	{

Project

General

Profile

FWD » Core Development » Database