6995-6129b.patch

Radu Apetrii, 01/26/2023 08:16 AM

     **     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 20230126          Removed the checks for no-undo as they are no longer necessary.
     */
     /*
-...
              Query query = getQuery(local, fql, 0, 0, values, false);
              count = query.executeUpdate(session);
              if (noUndo)
+             {
                 session.noUndoBulkUpdate(query);
+             }
              if (LOG.isLoggable(Level.FINER))
+             {
-...
              rc = query.executeUpdate(session);
              if (noUndo)
+             {
                 session.noUndoBulkUpdate(query);
+             }
              if (LOG.isLoggable(Level.FINER))
+             {
                 LOG.log(Level.FINER, "[" + sql + "] rc = " + rc);

     **     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 20230126          Added "no-undo" as a temp table postfix in constructor.
     */
     /*
-...
           String primarySqlIndexName = null;
           String createTemporaryTablePostfix = dialect.getCreateTemporaryTablePostfix();
           String createTemporaryNoUndoTablePostfix = dialect.getCreateTemporaryTableNoUndoPostfix();
           String delimiter = dialect.getDelimiter();
           String suffix = createTemporaryTablePostfix + delimiter;
           while (databaseIndexes.hasNext())
-...
+             {
                 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);

     **     RAA 20230109          Added method getSequenceSetValString().
     **     SVL 20230110          P2JIndex.components() provides direct access to the components array in order to
     **                           improve performance.
     **     RAA 20230126          Added method for creating a temp table postfix responsible with the "no-undo"
     **                           keyword. By default it is null, representing the string of an undoable table.
     */
     /*
-...
        public abstract String getCreateTemporaryTablePostfix();
        /**
         * Return the ending of the DDL statement that creates a temporary no-undo table.
+        *
         * @return  A string representing the ending of the DDL statement that creates a temporary
         *          no-undo table, or empty string if the table is undoable.
         */
        public String getCreateTemporaryTableNoUndoPostfix()
+       {
           return null;
+       }
        /**
         * Returns the beginning of the DDL statement for creating an index.
+        *
         * @param   unique

     **     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 20230126          Overrided method for returning the postfix of a no-undo temp-table.
     */
     /*
-...
+       }
        /**
         * Return the ending of the DDL statement that creates a temporary no-undo table.
+        *
         * @return  A string representing the ending of the DDL statement that creates a temporary
         *          no-undo table.
         */
        @Override
        public String getCreateTemporaryTableNoUndoPostfix()
+       {
           return " noundo";
+       }
        /**
         * Obtain a DDL statement which drops a SQL index.
+        *
         * @param   ifExists

     /*
     ** 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));
+          }
+       }
+    }

     **                  with a Savepoint at a later time when the invoker requires.
     **     CA  20220630 Cleanup the 'redoable' list once the full transaction ends.
     **     CA  20230116 Avoid creating a collection until is needed.
     **     RAA 20230126 Removed all code that was linked to redo operations as it is no longer needed.
     */
     /*
-...
        /** 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;
-...
        /**
         * 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
-...
+       }
        /**
         * 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)
+          {
              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))
+          {
              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)
+          {
              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)
+          {
              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>
-...
        private void prepareBlock()
+       {
           parentBlock = blocks.peek();
           activeBlock = new Block(blocks.size(), redoable);
           activeBlock = new Block(blocks.size());
           blocks.push(activeBlock);
           if (debug)
-...
           Block lastActiveBlock = activeBlock;
           Block popped = blocks.pop();
           // reapply undone changes for any NO-UNDO temporary tables
           if (session != null && lastActiveBlock != null)
+          {
              lastActiveBlock.maybeReapplyNoUndo(session);
+          }
           // reactivate the next block in the stack (if any)
           activeBlock = blocks.isEmpty() ? null : blocks.pop();
           parentBlock = blocks.isEmpty() ? null : blocks.peek();
-...
+          {
              // full transaction is finished, deactivate savepoint manager (i.e., remove session)
              this.session = null;
              if (redoable != null)
+             {
                 redoable.clear();
+             }
+          }
+       }
-...
           /** The current element being processed or the last one which was processed. */
           private BaseRecord changedLastIteration = 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();
+          }
           /**
-...
+          }
           /**
            * 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;
+             }
-...
                    changedIsIterated = false;
+                }
+             }
              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. */
-...
+          }
           /**
            * 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.

     **                  the database, and not just returned.
     **     CA  20230104 If a cached record is incomplete, preserve the dirty properties when loading the full
     **                  record.
     **     RAA 20230126 Removed everything that had to do with redo operations as it is no longer needed.
     */
     /*
-...
           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)
+          {
-...
           // 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);
+          }
-...
              @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);
+          }
-...
+       }
        /**
         * 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

Project

General

Profile

FWD » Core Development » Database

6995-6129b.patch