FWD » Core Development » Database

**     OM  20230112 Added finer-granulation instrumentation for processing of dynamic queries. 

** 004 RAA 20230302 Removed OrmRedo and OrmNoUndoTrace.

** 005 GBB 20230512 Logging methods replaced by CentralLogger/ConversionStatus.

*/ 

/*

   public static enum Counter 

   implements OptionalCounter

   {

      /** Incomning network traffic */

      NetworkReads,

      /** Outgoing network traffic */

**                  more straight-forward.

**     RAA 20230623 Instead of appending "validate" to the insert SQL, insertValidateSql is now used.

**     RAA 20230704 Changed name of validateMode to allowDBUniqueCheck.

*/

/*

import java.util.*;

import java.util.logging.*;

import com.goldencode.cache.*;

import com.goldencode.p2j.persist.*;

import com.goldencode.p2j.persist.orm.types.*;

import com.goldencode.p2j.util.logging.*;

   /** Cache of FQL strings, with or without max results and start offsets, to queries. */

   private static ExpiryCache<UpdateInfo, UpdateInfo> updateCache = new LRUCache<>(4096);

   /**

    * Constructor.

    * 

               LOG.log(Level.FINE, "FWD ORM: " + ps);

            }

            int[] result = new int[1];

            SQLStatementLogger.getLogger().log(session.getDatabase(), ps,

                                               () -> result[0] = ps.executeUpdate());

            updateCount += result[0];

            if (updateCount == 0 && LOG.isLoggable(Level.WARNING))

            {

               LOG.log(Level.WARNING,

               }

               else

               {

                  // non-batch insert is executed inline here

                  SQLStatementLogger.getLogger().log(session.getDatabase(), ps, () -> ps.execute());

                  count++;

               }

            }

            // executes the batches (since the scope of the batch is larger than a single DMO)

            if (batch && !bulk)

            {

               int[] result = new int[1];

               SQLStatementLogger.getLogger().log(session.getDatabase(), ps,

                                                  () -> result[0] = executeBatch(ps));

               count += result[0];

            }

            // [i] was only advanced through first element in the extent series; need to push

**     RAA 20230619 Split flush function into two for more straight-forward use when dealing with VALIDATE.

**     RAA 20230704 Changed name of validateMode to allowDBUniqueCheck.

**     RAA 20230704 In case a flush with VALIDATE fails, but it gets cured, a second flush is now attempted.

*/

/*

import java.sql.*;

import java.util.*;

import com.goldencode.p2j.directory.*;

import com.goldencode.p2j.persist.*;

import com.goldencode.p2j.persist.dialect.*;

import com.goldencode.p2j.persist.orm.types.*;

   /** Flag indicating the record was flushed to the database (either newly inserted or updated) */

   private boolean flushed = false;

   /**

    * The maximum permitted size for all combined fields of an index. By default this

    * is equal to Progress version 10.x limit of 1971 bytes.

         if ((multiplex != null || !flush) && !allowDBUniqueCheck)

         {

            // validate by executing unique index queries

         }

         if (willFlush)

            {

               // if the right index is found, this method will not return normally, instead it will

               // throw a specific exception

               if (allowDBUniqueCheck)

               {

                  // We were not able to execute the query with VALIDATE, but a "cure" occurred,

    * @param   check

    *          A bit set whose set bits represent the positions of the unique indices in the DMO's array

    *          of unique indices to be checked. If {@code null}, check all the unique indices.

    * 

    * @throws  ValidationException

    *          when the method detects a collision of current DMO with another record stored in the database.

    * @throws  PersistenceException

    *          if an error occurred while accessing the database.

    */

   throws PersistenceException,

          ValidationException

   {

            {

               throw new ValidationException(getFailUniqueIndexMessage(uIndex, bufferName, dmo), 132);

            }

            // if we exit the loop normally, all violations are cured by in-memory changes (which may yet

            // have to be validated and flushed themselves)