2137_20221114a.patch

     **     OM  20210917          Code maintenance.
     **     OM  20220112          Added implementation of SKIP-DELETED-RECORD attribute.
     **     AL2 20220412          Do proxy checks for values used as query parameters.
     **     CA  20221109          Implemented runtime for EXCEPT/FIELDS options - only NO-LOCK records are loaded
     **                           as 'partial/incomplete'.
     */
     /*
-...
     import java.util.logging.*;
     import com.goldencode.p2j.persist.event.*;
     import com.goldencode.p2j.persist.lock.*;
     import com.goldencode.p2j.persist.orm.*;
     import com.goldencode.p2j.util.*;
     import com.goldencode.p2j.util.ErrorManager;
-...
        /** Flag to indicate if this query is optimized using indexed reposition */
        protected boolean indexedReposition = false;
        /** The included properties for each DMO (FIELDS option). */
        protected Map<DataModelObject, Property[]> included = null;
        /** The excluded properties for each DMO (EXCEPT option). */
        protected Map<DataModelObject, Property[]> excluded = null;
        /** Flag indicating fatal error was encountered processing query substitution parameters */
        private boolean fatalError = false;
-...
         */
        public void include(DataModelObject dmo, String ... fields)
+       {
           // UnimplementedFeature.missing("RECORD-PHRASE: FIELDS (...) option");
           // TODO: implement
           RecordBuffer buffer = (RecordBuffer) ((BufferReference) dmo).buffer();
           if (buffer.isTemporary())
+          {
              return;
+          }
           if (included == null)
+          {
              included = new IdentityHashMap<>();
+          }
           collectFields(included, dmo, fields, buffer);
+       }
        /**
-...
         */
        public void exclude(DataModelObject dmo, String ... fields)
+       {
           // UnimplementedFeature.missing("RECORD-PHRASE: EXCLUDE (...) option");
           // TODO: implement
           RecordBuffer buffer = (RecordBuffer) ((BufferReference) dmo).buffer();
           if (buffer.isTemporary())
+          {
              return;
+          }
           if (excluded == null)
+          {
              excluded = new IdentityHashMap<>();
+          }
           collectFields(excluded, dmo, fields, buffer);
+       }
        /**
-...
              return new logical(false);
+          }
+       }
        /**
         * Populate the map of with the ORM properties specified in the given fields.
+        *
         * @param    target
         *           The target map.
         * @param    dmo
         *           The DMO instance.
         * @param    fields
         *           The fields to resolve.
         * @param    buffer
         *           The buffer instance.
         */
        private void collectFields(Map<DataModelObject, Property[]> target,
                                   DataModelObject                  dmo,
                                   String[]                         fields,
                                   RecordBuffer                     buffer)
+       {
           DmoMeta meta = buffer.getDmoInfo();
           Property[] props = target.computeIfAbsent(dmo, (d) ->
+          {
              return new Property[meta.getFieldSize()];
           });
           for (int i = 0; i < fields.length; i++)
+          {
              Property field = meta.getFieldInfo(fields[i]);
              if (field == null)
+             {
                 // must be a custom extent
                 List<Property> extFields = meta.getCustomExtentFieldInfo(fields[i]);
                 for (int j = 0; j < extFields.size(); j++)
+                {
                    field = extFields.get(j);
                    props[field.propId - 1] = field;
+                }
+             }
              else if (field.extent == 0)
+             {
                 props[field.propId - 1] = field;
+             }
+          }
+       }
+    }

     **                  negative result (i.e., no record is found) do not have the negative result cached.
     **     CA  20220104 Node.l3Cache must be a weak reference, otherwise once the direct cache invalidates a key,
     **                  the reverse lookup has no chance of being cleaned up, as this is not done explicitly.
     **     CA  20221109 Partial/Incomplete records (loaded with EXCEPT/FIELDS options) can't be cached.
     */
     /*
-...
         */
        public void put(Key k, Record value)
+       {
           // if no key or record represents a housekeeping (e.g., dirty database) copy, don't store it
           if (k == null || (value != null && value.checkState(DmoState.COPY)))
           // if no key or record represents a housekeeping (e.g., dirty database) copy or an incomplete record
           // (partial fields are populated due to EXCEPT/FIELDS options), don't store it
           if (k == null ||
               (value != null && (value.checkState(DmoState.COPY) || value.checkState(DmoState.INCOMPLETE))))
+          {
              return; // throw some error?
+          }

     **                           allows a lazy registration of scopeables, to avoid the unnecessary overhead of
     **                           processing all the scopeables for each and every block.
     **     TJD 20220504          Upgrade do Java 11 minor changes
     **     CA  20221109          Implemented runtime for EXCEPT/FIELDS options - only NO-LOCK records are loaded
     **                           as 'partial/incomplete'.
     */
     /*
-...
     package com.goldencode.p2j.persist;
     import java.lang.*;
     import java.sql.*;
     import java.util.*;
     import java.util.BitSet;
     import java.util.Date;
     import java.util.function.*;
     import java.util.logging.*;
-...
                 // have to take another hit retrieving the data almost immediately after this method
                 // returns, which is the common case for dynamic record retrieval.
                 Class<? extends Record> dmoClass = buffer.getDMOImplementationClass();
                 initialResult = result = session.get(dmoClass, id);
                 initialResult = result = session.get(dmoClass, id, null);
                 if (result == null)
+                {
-...
        throws PersistenceException,
               LockTimeoutException
+       {
           return load(implClass, id, lockType, timeout, updateLock, null);
+       }
        /**
         * Load a single record from the session-level cache or, optionally, refresh it from the
         * database. The record will be locked with the specified lock type upon return from this
         * method. Note that the lock refers to a runtime-level lock, not a database-level lock.
+        *
         * @param   implClass
         *          The DMO implementation class of record being read.
         * @param   id
         *          Primary key of the record to be loaded into the buffer.  May not be {@code null}.
         * @param   lockType
         *          Type of lock the lock manager should register on the resulting record for the
         *          current user context.
         * @param   timeout
         *          Number of milliseconds to wait to acquire the requested lock type. Throws
         *          {@link LockTimeoutException} if this time elapses before the lock is acquired.
         *          Specify 0 to wait indefinitely for the lock. Ignored if {@code lockType} is
         *          {@code NONE}.
         * @param   updateLock
         *          {@code true} to update the current lock state;
         *          {@code false} to leave the current lock state unchanged.
         * @param   partialFields
         *          For an incomplete record, read only these fields.
+        *
         * @return  A single DMO instance loaded from the database, or {@code null} if no result was
         *          found.
+        *
         * @throws  LockTimeoutException
         *          if a record was found, but its lock could not be acquired within the positive
         *          {@code timeout} period specified.
         * @throws  LockUnavailableException
         *          if a record was found and a no-wait lock type was specified, but the lock could
         *          not be acquired immediately.
         * @throws  PersistenceException
         *          if there was an error loading the DMO from the ORM session and/or database.
         */
        public Record load(Class<? extends Record> implClass,
                           Long id,
                           LockType lockType,
                           long timeout,
                           boolean updateLock,
                           BitSet partialFields)
        throws PersistenceException,
               LockTimeoutException
+       {
           boolean trace = LOG.isLoggable(Level.FINEST);
           boolean warn = (trace || LOG.isLoggable(Level.WARNING));
           boolean trackSlow = warn && loadThreshold > 0L;
-...
+             }
              Session session = local.getSession();
              result = session.get(implClass, id);
              result = session.get(implClass, id, partialFields);
              if (result == null)
+             {

     **     CA  20221006          Added JMX instrumentation for query assemble. Refs #6814
     **     CA  20221013          In 'repositionByID', if the row number is after the last row in the ResultSet,
     **                           assume an error (query off-end) and do not try to fetch the record.
     **     CA  20221109          Implemented runtime for EXCEPT/FIELDS options - only NO-LOCK records are loaded
     **                           as 'partial/incomplete'.   At this time, extent fields are always loaded.
     */
     /*
-...
              boolean qualified = !isOmitAlias();
              RecordBuffer buffer = comp.getBuffer();
              if (qualified)
+             {
                 RecordBuffer buffer = comp.getBuffer();
                 buf.append(buffer.getDMOAlias());
+             }
-...
                 buf.append(DatabaseManager.PRIMARY_KEY);
+             }
              else
+             {
                 Property[] iprops = included == null ? null : included.get(buffer.getDMOProxy());
                 Property[] xprops = excluded == null ? null : excluded.get(buffer.getDMOProxy());
                 if (iprops != null || xprops != null)
+                {
                    Property[] props = null;
                    // only permanent buffers can use include/exclude
                    if (iprops == null)
+                   {
                       DmoMeta meta = buffer.getDmoInfo();
                       props = new Property[meta.getFieldSize()];
                       // include all fields
                       Iterator<Property> piter = meta.getFields(false);
                       while (piter.hasNext())
+                      {
                          Property p = piter.next();
                          if (p.propId > 0)
+                         {
                             props[p.id - 1] = p;
+                         }
+                      }
+                   }
                    else
+                   {
                       props = new Property[iprops.length];
                       System.arraycopy(iprops, 0, props, 0, props.length);
+                   }
                    if (xprops != null)
+                   {
                       // exclude properties
                       for (int j = 0; j < xprops.length; j++)
+                      {
                          Property xprop = xprops[j];
                          if (xprop != null)
+                         {
                             props[j] = null;
+                         }
+                      }
+                   }
                    String alias = buffer.getDMOAlias();
                    buf.append('.').append(DatabaseManager.PRIMARY_KEY);
                    for (int j = 0; j < props.length; j++)
+                   {
                       Property p = props[j];
                       // normalized extents are always loaded (can't be skipped) at this time.
                       if (p == null || (p.extent != 0 && !p.denormalized))
+                      {
                          continue;
+                      }
                       buf.append(", ").append(alias).append(".").append(p.name);
+                   }
+                }
+             }
+          }
           buf.append(" ");
-...
+                      {
                          try
+                         {
                             dmo = p.load(buffer.getDMOImplementationClass(), id, lt, timeout, updateLock);
                             // force the load of the entire record
                             dmo = p.load(buffer.getDMOImplementationClass(), id, lt, timeout, updateLock, null);
                             break;
+                         }
-...
+                   }
                    else
+                   {
                       dmo = p.load(buffer.getDMOImplementationClass(), id, lt, 0L, updateLock);
                       dmo = p.load(buffer.getDMOImplementationClass(),
                                    id,
                                    lt,
 L,
                                    updateLock,
                                    // the entire record is loaded if the lock is not NONE
                                    updateLock || dmo == null ? null : dmo._getReadFields());
+                   }
+                }

     **     OM  20220713 Added support for converting to/from POJOs.
     **     OM  20220718 Fixed looping in getPropertyValues(). Added to the returned list the denormalized props.
     **     TJD 20220504 Upgrade do Java 11 minor changes
     **     CA  20221109 Implemented runtime for EXCEPT/FIELDS options - only NO-LOCK records are loaded as
     **                  'partial/incomplete'.
     */
     /*
-...
         */
        public final integer _getInteger(int offset)
+       {
           checkIncomplete(offset);
           Integer datum = (Integer) data[offset];
           return datum != null ? new integer(datum) : new integer();
-...
         */
        public final datetimetz _getDatetimetz(int offset)
+       {
           checkIncomplete(offset);
           OffsetDateTime datum = (OffsetDateTime) data[offset];
           return datum != null ? new datetimetz(datum) : new datetimetz();
-...
         */
        public final datetime _getDatetime(int offset)
+       {
           checkIncomplete(offset);
           Timestamp datum = (Timestamp) data[offset];
           return datum != null ? new datetime(datum) : new datetime();
-...
         */
        public final date _getDate(int offset)
+       {
           checkIncomplete(offset);
           Date datum = (Date) data[offset];
           return datum != null ? new date(datum) : new date();
-...
         */
        public final logical _isLogical(int offset)
+       {
           checkIncomplete(offset);
           Boolean datum = (Boolean) data[offset];
           return datum != null ? new logical(datum) : new logical();
-...
         */
        public final decimal _getDecimal(int offset)
+       {
           checkIncomplete(offset);
           BigDecimal datum = (BigDecimal) data[offset];
           return datum != null ? new decimal(datum) : new decimal();
-...
         */
        public final character _getCharacter(int offset)
+       {
           checkIncomplete(offset);
           String datum = (String) data[offset];
           if (datum != null)
-...
         */
        public final rowid _getRowid(int offset)
+       {
           checkIncomplete(offset);
           Long datum = (Long) data[offset];
           return datum != null ? new rowid(datum) : new rowid();
-...
         */
        public final handle _getHandle(int offset)
+       {
           checkIncomplete(offset);
           Long datum = (Long) data[offset];
           return datum != null ? handle.fromResourceId(datum, false) : new handle();
-...
         */
        public final recid _getRecid(int offset)
+       {
           checkIncomplete(offset);
           Integer datum = (Integer) data[offset];
           return datum != null ? new recid(datum) : new recid();
-...
         */
        public final blob _getBlob(int offset)
+       {
           checkIncomplete(offset);
           byte[] datum = (byte[]) data[offset];
           return datum != null ? new blob(datum) : new blob();
-...
         */
        public final clob _getClob(int offset)
+       {
           checkIncomplete(offset);
           return new clob((String) data[offset], getCodePage(offset));
+       }
-...
         */
        public final comhandle _getComhandle(int offset)
+       {
           checkIncomplete(offset);
           String datum = (String) data[offset];
           return datum != null ? comhandle.fromString(datum) : new comhandle();
-...
         */
        public final object<?> _getObject(int offset)
+       {
           checkIncomplete(offset);
           Long datum = (Long) data[offset];
           return datum != null ? object.fromResourceId(datum) : new object<>();
-...
         */
        public final raw _getRaw(int offset)
+       {
           checkIncomplete(offset);
           byte[] datum = (byte[]) data[offset];
           return datum != null ? new raw(datum) : raw.instantiateUnknownRaw();
-...
+                {
                    sb.append("\"");
+                }
                 sb.append(data[i] == null ? "?" : data[i]);
                 boolean incomplete = readFields != null && !readFields.get(i);
                 sb.append(data[i] == null ? incomplete ? "n/a" : "?" : data[i]);
                 if (isChar)
+                {
                    sb.append("\"");

     **                  used in a Java REST service, which must not be associated with a session.
     **     ECF 20221005 Added support for dynamic initial values.
     **     TJD 20220504 Upgrade do Java 11 minor changes
     **     CA  20221109 Implemented runtime for EXCEPT/FIELDS options - only NO-LOCK records are loaded as
     **                  'partial/incomplete'.
     */
     /*
-...
        /** The data represented by this record, in it's low-level (database friendly) form */
        protected final Object[] data;
        /** For an incomplete record, this holds the fields which were read or assigned in this record. */
        protected BitSet readFields = null;
        /** Current state of the record */
        protected final RecordState state = new RecordState();
-...
+       }
        /**
         * Get the {@link #readFields}.
+        *
         * @return   The {@link #readFields}.
         */
        public BitSet _getReadFields()
+       {
           return readFields;
+       }
        /**
         * Set a single datum into the data array, and update the record and property state accordingly.
+        *
         * @param   offset
-...
         */
        protected void setDatum(int offset, Object datum)
+       {
           if (readFields != null)
+          {
              readFields.set(offset);
+          }
           if (activeBuffer != null)
+          {
              activeOffset = offset;
-...
+       }
        /**
         * Check if for an incomplete record, the specified field was read or assigned.
+        *
         * @param    index
         *           The field index.
         */
        protected void checkIncomplete(int index)
+       {
           if (checkState(DmoState.INCOMPLETE) && !readFields.get(index))
+          {
              RecordMeta meta = _recordMeta();
              String tname = meta.legacyName;
              String fname = meta.getPropertyMeta(false)[index].getLegacyName();
              String msg = "Field " + fname + " from " + tname + " record (recid " + primaryKey() +
                            ") was missing from FIELDS phrase";
              ErrorManager.recordOrThrowError(8826, msg, false);
+          }
+       }
        /**
         * Mark this record as incomplete.
+        *
         * @param    session
         *           Database session (used for UNDO purposes).
         */
        void markIncomplete(Session session)
+       {
           updateState(session, DmoState.INCOMPLETE, true);
           readFields = new BitSet(data.length);
+       }
        /**
         * An index was updated.
+        *
         * @param   idxUid
-...
        final int readProperty(int propOffset, ResultSet rs, int rsOffset)
        throws PersistenceException
+       {
           return readProperty(propOffset, rs, rsOffset, false);
+       }
        /**
         * Read a property directly from a {@code ResultSet}.
+        *
         * @param   propOffset
         *          The index of the property to be read.
         * @param   rs
         *          The result set to read from.
         * @param   rsOffset
         *          The index in {@code ResultSet} to read from. If the property is a multiple column
         *          then more than one column will ve read from {@code ResultSet}.
         * @param   skip
         *          Flag indicating if this property will not be read from the result-set.
+        *
         * @return  The number of columns actually read from the {@code ResultSet}.
         */
        final int readProperty(int propOffset, ResultSet rs, int rsOffset, boolean skip)
        throws PersistenceException
+       {
           PropertyMeta pm = _recordMeta().getPropertyMeta(false)[propOffset];
           PropertyReader propertyReader = pm.getDataHandler();
           if (skip)
+          {
              return propertyReader.propertySize();
+          }
           try
+          {
              if (readFields != null)
+             {
                 readFields.set(propOffset);
+             }
              return propertyReader.readProperty(rs, rsOffset, data, propOffset);
+          }
           catch (java.sql.SQLException sqle)

     **                  DmoMeta to avoid duplicating their collection and storage.
     **     OM  20220727 FieldId and PropertyId are different for denormalized extent fields. Renamed some fields
     **                  to a better suited name.
     **     TJD 20220504 Upgrade do Java 11 minor changes
     **     TJD 20220504 Upgrade do Java 11 minor changes.
     **     CA  20221114 Added API to get the denormalized properties for a DMO extent property name.
     */
     /*
-...
+       }
        /**
         * Get the list of denormalized properties associated with this extent DMO property.
+        *
         * @param    propName
         *           The field's property name.
+        *
         * @return   The list of {@link #customExtents denormalized} properties, or <code>null</code> if this is
         *           not a denormalized or not a extent property.
         */
        public List<Property> getCustomExtentFieldInfo(String propName)
+       {
           return customExtents.get(propName);
+       }
        /**
         * Get the number of properties in this DMO.
+        *
         * @return   The size of {@link #propsByName}.
         */
        public int getFieldSize()
+       {
           return propsByName.size();
+       }
        /**
         * Looks up a {@code Property} by its legacy field name.<p>
         * <b>Note:</b><br>
         *    This method is rather slow. Do not use it unless you have no other solution.<br>

     ** Module   : DmoState.java
     ** Abstract : DMO states which govern persistence behavior.
     **
     ** Copyright (c) 2020-2021, Golden Code Development Corporation.
     ** Copyright (c) 2020-2022, Golden Code Development Corporation.
     **
     ** -#- -I- --Date-- ---------------------------------------Description---------------------------------------
     ** 001 ECF 20200315 First revision.
     ** 002 ECF 20210519 Added TRACKED state.
     **     ECF 20210923 Added DELETING state.
     **     CA  20221109 Implemented runtime for EXCEPT/FIELDS options - only NO-LOCK records are loaded as
     **                  'partial/incomplete'.
     */
     /*
-...
        /** DMO currently is being tracked for possible UNDO processing */
        public static final int TRACKED = 0x0400;
        /** DMO is read incomplete (due to EXCEPT/FIELDS options) and can't be cached. */
        public static final int INCOMPLETE = 0x0800;
+    }

     **                  (Temporary?) set the properties to be accessed with old-fashioned accessors.
     **     CA  20201005 Fixed the sort order when loading a child extent table.
     **     TJD 20220504 Upgrade do Java 11 minor changes
     **     CA  20221109 Implemented runtime for EXCEPT/FIELDS options - only NO-LOCK records are loaded as
     **                  'partial/incomplete'.  Extent fields are always loaded at this time.
     */
     /*
-...
     package com.goldencode.p2j.persist.orm;
     import com.goldencode.p2j.persist.*;
     import com.goldencode.p2j.util.*;
     import java.sql.*;
     import java.util.*;
-...
+       }
        /**
         * Compose the index where each group of normalized extent properties start in the DMO properties array.
+        *
         * @param   allPropMeta
         *          Array of {@link PropertyMeta} objects in their natural order.
+        *
         * @return  An integer array with the start index of each group of normalized extent properties.  The
         *          first element is always zero.
         */
        static int[] composeLoadStatementsIndexes(PropertyMeta[] allPropMeta)
+       {
           List<Integer> indexes = new ArrayList<>();
           int i = 0;
           int len = allPropMeta.length;
           int seriesSize = 0;
           // primary record (if it contains scalar data)
           if (len > 0 && allPropMeta[0].getExtent() == 0)
+          {
              // first one is always zero for primary record
              indexes.add(i);
              seriesSize = allPropMeta[0].seriesSize;
              i = seriesSize;
+          }
           // secondary records (if any)
           while (i < len)
+          {
              indexes.add(i);
              PropertyMeta propMeta = allPropMeta[i];
              int extent = propMeta.getExtent();
              seriesSize = propMeta.seriesSize;
              for (int j = 0; j < seriesSize; j++)
+             {
                 propMeta = allPropMeta[i];
                 i += extent;
+             }
+          }
           return Utils.integerCollectionToPrimitive(indexes);
+       }
        /**
         * Load a single record from the database, given its DMO class and primary key. The primary
         * key is assumed to represent a valid identifier; if not, {@code null} will be returned.
         * <p>
-...
         *          DMO implementation class.
         * @param   id
         *          Surrogate primary key.
+        *
+        *
         * @return  An instance of {@code dmoClass}, loaded with data from the database, or {@code
         *          null} if the record was not found. The DMO is instantiated either way, but it will
         *          be discarded if the record is not found.
-...
        <T extends BaseRecord> T load(Class<T> dmoClass, Long id)
        throws PersistenceException
+       {
           return load(dmoClass, id, null);
+       }
        /**
         * Load a single record from the database, given its DMO class and primary key. The primary
         * key is assumed to represent a valid identifier; if not, {@code null} will be returned.
         * <p>
         * TODO: a SQL statement is prepared and closed for each load statement executed by this
         * method. We rely on statement caching at the connection pool level to make this performant,
         * but perhaps there is some predictive analysis we can do to make this more efficient.
+        *
         * @param   dmoClass
         *          DMO implementation class.
         * @param   id
         *          Surrogate primary key.
         * @param   partialFields
         *          For an incomplete record, read only these fields.
+        *
         * @return  An instance of {@code dmoClass}, loaded with data from the database, or {@code
         *          null} if the record was not found. The DMO is instantiated either way, but it will
         *          be discarded if the record is not found.
+        *
         * @throws  PersistenceException
         *          if an error occurred accessing the database.
         */
        <T extends BaseRecord> T load(Class<T> dmoClass, Long id, BitSet partialFields)
        throws PersistenceException
+       {
           try
+          {
              T dmo = dmoClass.getDeclaredConstructor().newInstance();
              dmo.primaryKey(id);
              return load(dmo, id);
              return load(dmo, id, partialFields);
+          }
           catch (ReflectiveOperationException  exc)
+          {
-...
         *          DMO implementation class.
         * @param   id
         *          Surrogate primary key.
         * @param   partialFields
         *          For an incomplete record, read only these fields.
+        *
         * @return  An instance of {@code dmoClass}, loaded with data from the database, or {@code
         *          null} if the record was not found. The DMO is instantiated either way, but it will
-...
         * @throws  PersistenceException
         *          if an error occurred accessing the database.
         */
        <T extends BaseRecord> T load(T dmo, Long id)
        <T extends BaseRecord> T load(T dmo, Long id, BitSet partialFields)
        throws PersistenceException
+       {
           try
-...
              boolean hasScalarData = props.length > 0 && props[0].getExtent() == 0;
              int start = 0;
              if (partialFields != null)
+             {
                 dmo.markIncomplete(session);
+             }
              for (String sql : loadSql)
+             {
-...
+                      }
                       // the first query is always on the primary table, if the DMO has scalar data
                       start = readScalarData(dmo, rs, 0, props);
                       start = readScalarData(dmo, rs, 0, props, partialFields);
+                   }
                    else
+                   {
-...
         *          use 0. If the record data is prepended by a single column (Ex: primaryKey), pass 1.
         * @param   props
         *          Array of property metadata objects.
         * @param   partialFields
         *          For an incomplete record, read only these fields.
+        *
         * @return  Index of next slot in the data array to be filled (if any) after this series of
         *          scalar data has been read, or -1 to indicate the result set was empty (record
-...
        private static int readScalarData(BaseRecord r,
                                          ResultSet rs,
                                          int rowOffset,
                                          PropertyMeta[] props)
                                          PropertyMeta[] props,
                                          BitSet partialFields)
        throws SQLException, PersistenceException
+       {
           // the current row is expected to be already selected, since the filter is the primary
-...
                 break;
+             }
              int colCnt = r.readProperty(pm.offset, rs, pm.columnIndex + rowOffset);
              boolean skip = partialFields != null && !partialFields.get(pm.offset);
              int colCnt = r.readProperty(pm.offset, rs, pm.columnIndex + rowOffset, skip);
              if (colCnt != pm.columnCount)
+             {

     **     OM  20201218 Fixed implementation for error and rejected attributes/hidden fields.
     **     CA  20210831 Track the getter method for TempRecord reserved properties.
     **     OM  20220722 Added property identifier.
     **     CA  20221114 Added flag to mark a denormalized extent property.
     */
     /*
-...
         */
        public final int extent;
        /** Flag indicating if this extent property has been denormalized. */
        public final boolean denormalized;
        /**
         * One-based index in the legacy extent field associated with a DMO property. Will be set only
         * for field with custom extents.
-...
        Property(com.goldencode.p2j.persist.annotation.Property source, Method annotatedMethod)
+       {
           this.id = source.id();
           this.propId = (source.propertyId() == Integer.MIN_VALUE) ? this.id : source.propertyId();
           this.denormalized = source.propertyId() != Integer.MIN_VALUE;
           this.propId = !this.denormalized ? this.id : source.propertyId();
           this.name = source.name().intern();
           this.legacy = source.legacy().intern();
           this.column = source.column().intern();
-...
+       {
           this.id = this.propId = id; // this constructor is only invoked for reserved properties which have
                                       // negative and equal values for both [id] and [propId]
           this.denormalized = false;
           this.name = name.intern();
           this.legacy = (legacy == null) ? null : legacy.intern();
           this.column = column.intern();

     ** Abstract : Functional interface for reading a (possibly multiple column) property from a SQL
     **            result set.
     **
     ** Copyright (c) 2020, Golden Code Development Corporation.
     ** Copyright (c) 2020-2022, Golden Code Development Corporation.
     **
     ** -#- -I- --Date-- ---------------------------------Description---------------------------------
     ** 001 OM  20200212 Created initial version.
     ** 002 CA  20221109 Added 'propertySize' method which returns the number of columns in the result-set for this
     **                  property type.
     */
     /*
-...
         */
        public int readProperty(ResultSet rs, int rsOffset, Object[] data, int propIndex)
        throws SQLException;
        /**
         * Get the size (number of columns in the result-set) required by this property.
+        *
         * @return   Defaults to 1.
         */
        public default int propertySize()
+       {
           return 1;
+       }
+    }

     **     OM  20220727 FieldId and PropertyId are different for denormalized extent fields. Both are computed
     **                  at conversion time.
     **     ECF 20221005 Added support for dynamic initial values.
     **     CA  20221114 Added a helper array to keep the index of the normalized extent properties in the DMO
     **                  'props' array.
     */
     /*
-...
        /** SQL query statement(s) to access data needed to load a single DMO instance */
        final String[] loadSql;
        /**
         * The index in {@link #props} array where each {@link #loadSql} statement has the properties
         * (with the same extent) stored.  The value of <code>loadSqlIndexes[0]</code> is always zero, as the
         * {@link #loadSql}'s first element is the scalar properties SELET.
         */
        final int[] loadSqlIndexes;
        /** SQL insert statement(s) which insert a single DMO's data into the database */
        final String[] insertSql;
-...
           props = RecordMeta.readPropertyMeta(dmoMeta);
           tables = RecordMeta.tableNames(dmoMeta, props);
           loadSql = Loader.composeLoadStatements(tables[0], props, temporary);
           loadSqlIndexes = Loader.composeLoadStatementsIndexes(props);
           insertSql = Persister.composeInsertStatements(tables[0], props, temporary);
           deleteSql = Persister.composeDeleteStatements(tables);

     ** Module   : RecordState.java
     ** Abstract : Current state of a database record in an application.
     **
     ** Copyright (c) 2019-2021, Golden Code Development Corporation.
     ** Copyright (c) 2019-2022, Golden Code Development Corporation.
     **
     ** -#- -I- --Date-- ---------------------------------------Description---------------------------------------
     ** 001 ECF 20191001 First revision. Object which tracks DMO state as changes are applied to it.
     ** 002 ECF 20210519 Added TRACKED state to toString.
     **     ECF 20210924 Added DELETING state to toString.
     **     CA  20221109 Implemented runtime for EXCEPT/FIELDS options - only NO-LOCK records are loaded as
     **                  'partial/incomplete'.
     */
     /*
-...
+             }
              if ((state & DmoState.TRACKED) == DmoState.TRACKED)
+             {
                 sb.append("TRACKED");
                 sb.append("TRACKED ");
+             }
              if ((state & DmoState.INCOMPLETE) == DmoState.INCOMPLETE)
+             {
                 sb.append("INCOMPLETE");
+             }
+          }
           sb.append("}");

     **                  a wrapper for two separate parameters, changed hydrateRecordImpl logic to skip fields that are not
     **                  queried.
     **     TJD 20220504 Upgrade do Java 11 minor changes
     **     CA  20221109 Implemented runtime for EXCEPT/FIELDS options - only NO-LOCK records are loaded as
     **                  'partial/incomplete'.  Extent fields are always loaded at this time.
     */
     /*
-...
           return res[0];
+       }
        /**
         * Hydrate a {@code Record} from a {@code ResultSet}, ie a new object that implements the DMO
         * interface and having the properties set from the current row of the record set. The method
-...
+             }
              int k = 0;
              int recOffset = 0;
              boolean hasExtents = false;
              // TODO: EXCEPT/FIELDS for extent fields; for now, load all extents
              boolean incomplete = fieldEntries != allFieldEntries;
              boolean hasExtents = incomplete;
              if (incomplete)
+             {
                 r.markIncomplete(session);
+             }
              for (Map.Entry<String, Property> prop : fieldEntries)
+             {
-...
                          rsOffset += r.readProperty(recOffset++, resultSet, rsOffset);
                          break;
                       default:
                          if (fieldEntries != allFieldEntries)
                          if (incomplete)
+                         {
                             recOffset = dmoInfo.recordMeta.getIndexOfProperty(key);
+                         }
                          rsOffset += r.readProperty(recOffset++, resultSet, rsOffset);
                             rsOffset += r.readProperty(recOffset, resultSet, rsOffset);
+                         }
                          else
+                         {
                             rsOffset += r.readProperty(recOffset++, resultSet, rsOffset);
+                         }
                          break;
+                   }
+                }
-...
              if (hasExtents)
+             {
                 RecordMeta recordMeta = r._recordMeta();
                 PropertyMeta[] props = recordMeta.getPropertyMeta(false);
                 String[] loadSqls = recordMeta.loadSql;
                 int[] loadSqlsIndexes = recordMeta.loadSqlIndexes;
                 // only use the extent queries, skip the loadSqls[0] which contains the simple properties
                 for (int i = 1; i < loadSqls.length; i++) // skip "plain" columns
+                {
                    if (incomplete)
+                   {
                       // resolve the offset in the 'props' array where this sql starts.
                       // all normalized extent fields are loaded even for incomplete records.
                       recOffset = loadSqlsIndexes[i];
+                   }
                    ResultSet rs = null;
                    try (PreparedStatement ps = conn.prepareStatement(loadSqls[i]))
+                   {
                       // set the [parent_id] parameter
                       ps.setLong(1, r.primaryKey());
                       rs = ps.executeQuery();
                       recOffset = Loader.readExtentData(r, rs, recordMeta.getPropertyMeta(false), recOffset);
                       recOffset = Loader.readExtentData(r, rs, props, recOffset);
+                   }
                    finally
+                   {

     **     ECF 20211022 A cache expiration is not tracked as an undoable event.
     **     ECF 20211230 Do not attempt to delete a newly created record that was never flushed to the database.
     **     OM  20220628 Signature change for createSQLQuery() method.
     **     CA  20221109 Implemented runtime for EXCEPT/FIELDS options - only NO-LOCK records are loaded as
     **                  'partial/incomplete'.  Partial/Incomplete records are being cached, but when they try to
     **                  be loaded with no 'partial field information', the cached record is fully refreshed from
     **                  the database, and not just returned.
     */
     /*
-...
        public <T extends BaseRecord> T get(Class<T> dmoImplClass, Long id)
        throws PersistenceException
+       {
           return getImpl(dmoImplClass, id, new RecordIdentifier<>(dmoImplClass.getName(), id));
           return getImpl(dmoImplClass, id, new RecordIdentifier<>(dmoImplClass.getName(), id), null);
+       }
        /**
         * Gets a specified record of a table. To lookup the record local cache is analyzed first. If
         * the record is not found in cache, the backing database is queried. If the specified record
         * is not found in database, {@code null} is returned. If the record was fetched from the
         * database at this moment, it is kept in cache for further access.
+        *
         * @param   <T>
         *          The type of the record.
         * @param   dmoImplClass
         *          The class of the entity (class that implements the table's DMO interface).
         * @param   id
         *          The id/rowid of the record to be returned.
         * @param   partialFields
         *          For an incomplete record, read only these fields.
+        *
         * @return  The requested record, if found in cache or database and {@code null} otherwise.
+        *
         * @throws  PersistenceException
         *          In case some error occurs in the process.
         */
        public <T extends BaseRecord> T get(Class<T> dmoImplClass, Long id, BitSet partialFields)
        throws PersistenceException
+       {
           return getImpl(dmoImplClass, id, new RecordIdentifier<>(dmoImplClass.getName(), id), partialFields);
+       }
        /**
-...
        public <T extends BaseRecord> T get(RecordIdentifier<String> key)
        throws PersistenceException
+       {
           return getImpl(null, key.getRecordID(), key);
           return getImpl(null, key.getRecordID(), key, null);
+       }
        /**
-...
        public <T extends BaseRecord> T get(String entity, Long id)
        throws PersistenceException
+       {
           return getImpl(null, id, new RecordIdentifier<>(entity, id));
           return getImpl(null, id, new RecordIdentifier<>(entity, id), null);
+       }
        /**
-...
         * @param   key
         *          The cache key of the entity. If {@code null} the returned value is {@code null};
         *          provided.
         * @param   partialFields
         *          For an incomplete record, read only these fields.
         * @param   <T>
         *          The compile type of the record to be returned.
+        *
-...
         * @throws  PersistenceException
         *          if there is an error getting a JDBC connection from the data source.
         */
        private <T extends BaseRecord> T getImpl(Class<T> dmoImplClass, Long id, RecordIdentifier<String> key)
        private <T extends BaseRecord> T getImpl(Class<T> dmoImplClass,
                                                 Long id,
                                                 RecordIdentifier<String> key,
                                                 BitSet partialFields)
        throws PersistenceException
+       {
           // quick out
-...
           T dmo = getCached(key);
           boolean refreshIncomplete = false;
           if (dmo != null)
+          {
              // assert that we have the right DMO type for this primary key
-...
                 throw new PersistenceException(msg);
+             }
              return dmo;
              if (dmo.checkState(DmoState.INCOMPLETE) && partialFields == null)
+             {
                 // we have a cached record which is incomplete, and this requires to refresh the incomplete record
                 // from the database
                 refreshIncomplete = true;
+             }
              else
+             {
                 return dmo;
+             }
+          }
           if (dmoImplClass == null)
-...
              throw new PersistenceException("Invalid entity name: " + dmoImplClass.getName());
+          }
           dmo = loader.load(dmoImplClass, id);
           T loaded = loader.load(dmoImplClass, id, partialFields);
           if (refreshIncomplete)
+          {
              // evict the incomplete record from the cache, will be recached if one was found
              evict(dmo);
              if (loaded == null)
+             {
                 dmo = null;
+             }
              else
+             {
                 System.arraycopy(loaded.data, 0, dmo.data, 0, dmo.data.length);
                 // set the incomplete record as complete
                 dmo.updateState(this, DmoState.INCOMPLETE, false);
                 dmo.readFields = null;
+             }
+          }
           else
+          {
              dmo = loaded;
+          }
           if (dmo != null)
+          {
-...
           // ignore the cache and go directly to underlying database
           // use the variant of load which overwrites the DMOs current field values with data
           // fetched from the database
           T loaded = loader.load(dmo, dmo.id);
           T loaded = loader.load(dmo, dmo.id, null);
           RecordIdentifier<String> key = new RecordIdentifier<>(dmo.getClass().getName(), dmo.id);

     **     CA  20210304 Fixed datetimetz literal parsing.
     **     OM  20220218 Fixed timezone when the dtz is rehydrated.
     **     ECF 20221005 Added support for dynamic initial values.
     **     CA  20221109 Added 'propertySize' method which returns the number of columns in the result-set for this
     **                  property type.
     */
     /*
-...
+       }
        /**
         * Get the number of columns read from the result-set.
+        *
         * @return   always 2.
         */
        @Override
        public int propertySize()
+       {
           return 2;
+       }
        /**
         * Instantiate a low-level initial value suitable for storage in a {@link BaseRecord}'s data
         * array, parsed from a string representation.
+        *

Project

General

Profile

FWD » Core Development » Database