DataSet.createDynamicDataSet. */
OrmDynamicDataSetParam,
+
+ /** Lazily hydrated an new record (not rehydrated from cache) */
+ HydratorNewRecord,
+ /** Lazily hydrated a record (including rehydration from cache) */
+ HydratorLazyRecord,
+ /** Fully or partially hydrated a record, but not lazy */
+ HydratorNonLazyRecord,
+ /** The hydrator token matched the result-set token */
+ HydratorHit,
+ /** The hydrator token mismatched the result-set token */
+ HydratorMiss,
+ /** The hydrator fallbacked to refresh and succeeded */
+ HyratorSuccessfullRefresh,
+ /** The hydrator fallbacked to refresh and failed */
+ HyratorUnsuccessfullRefresh,
+ /** Created a {@code ScrollableResults} instance with lazy results */
+ HydratorLazyScrollable,
+ /** Created a {@code ScrollableResults} instance without lazy results */
+ HydratorNonLazyScrollable,
+ /** Executed uniqueResult instance with lazy results */
+ HydratorLazyUnique,
+ /** Executed uniqueResult instance without lazy results */
+ HydratorNonLazyUnique,
/** Instrumentation for OutputTableCopier.finished */
OutputTableCopier,
@@ -489,6 +512,41 @@
public static enum Counter
implements OptionalCounter
{
+ TempTotalFields,
+ PersistentTotalFields,
+ TempHydratedRecordsWhenSessionCloses,
+ PersistentHydratedRecordsWhenSessionCloses,
+ TempHydratedFieldsWhenSessionCloses,
+ PersistentHydratedFieldsWhenSessionCloses,
+ PersistentHydratedFieldsWithLZS,
+ PersistentHydratedFieldsWithLoader,
+ TempHydratedFieldsWithLZS,
+ TempHydratedFieldsWithLoader,
+
+
+ /** Lazily hydrated an new record (not rehydrated from cache) */
+ HydratorNewRecord,
+ /** Lazily hydrated a record (including rehydration from cache) */
+ HydratorLazyRecord,
+ /** Fully or partially hydrated a record, but not lazy */
+ HydratorNonLazyRecord,
+ /** The hydrator token matched the result-set token */
+ HydratorHit,
+ /** The hydrator token mismatched the result-set token */
+ HydratorMiss,
+ /** The hydrator fallbacked to refresh and succeeded */
+ HyratorSuccessfullRefresh,
+ /** The hydrator fallbacked to refresh and failed */
+ HyratorUnsuccessfullRefresh,
+ /** Created a {@code ScrollableResults} instance with lazy results */
+ HydratorLazyScrollable,
+ /** Created a {@code ScrollableResults} instance without lazy results */
+ HydratorNonLazyScrollable,
+ /** Executed uniqueResult instance with lazy results */
+ HydratorLazyUnique,
+ /** Executed uniqueResult instance without lazy results */
+ HydratorNonLazyUnique,
+
/** Incomning network traffic */
NetworkReads,
/** Outgoing network traffic */
=== modified file 'src/com/goldencode/p2j/persist/BufferImpl.java'
--- old/src/com/goldencode/p2j/persist/BufferImpl.java 2026-05-15 11:20:28 +0000
+++ new/src/com/goldencode/p2j/persist/BufferImpl.java 2026-05-22 13:57:10 +0000
@@ -1030,12 +1030,18 @@
* Get the record ID of the current buffer's current record, if any. P2J
* implementation of the RECID function.
*
- * This method will return a 64-bit recid which represents the internal
- * row ID of the given record.
+ * This method will return a 32-bit recid which represents the internal
+ * row ID of the given record. If the actual row ID (which is implemented
+ * as a wider integer) cannot fit due to overflow, an error condition will
+ * be raised.
*
* @return Record ID of the underlying data record. If no record currently
* backs the buffer associated with
@@ -378,7 +423,7 @@
{
checkIncomplete(offset);
- Timestamp datum = (Timestamp) data[offset];
+ Timestamp datum = (Timestamp) getDatum(offset);
return datum != null ? new datetime(datum) : new datetime();
}
@@ -483,7 +528,7 @@
{
checkIncomplete(offset);
- Date datum = (Date) data[offset];
+ Date datum = (Date) getDatum(offset);
return datum != null ? new date(datum) : new date();
}
@@ -588,7 +633,7 @@
{
checkIncomplete(offset);
- Boolean datum = (Boolean) data[offset];
+ Boolean datum = (Boolean) getDatum(offset);
return datum != null ? new logical(datum) : new logical();
}
@@ -691,7 +736,9 @@
*/
public final int64 _getInt64(int offset)
{
- Long datum = (Long) data[offset];
+ checkIncomplete(offset);
+
+ Long datum = (Long) getDatum(offset);
return datum != null ? new int64(datum) : new int64();
}
@@ -800,7 +847,7 @@
{
checkIncomplete(offset);
- BigDecimal datum = (BigDecimal) data[offset];
+ BigDecimal datum = (BigDecimal) getDatum(offset);
return datum != null ? new decimal(datum) : new decimal();
}
@@ -917,8 +964,8 @@
public final character _getCharacter(int offset)
{
checkIncomplete(offset);
-
- String datum = (String) data[offset];
+
+ String datum = (String) getDatum(offset);
if (datum != null)
{
@@ -1030,7 +1077,7 @@
{
checkIncomplete(offset);
- Long datum = (Long) data[offset];
+ Long datum = (Long) getDatum(offset);
return datum != null ? new rowid(datum) : new rowid();
}
@@ -1137,7 +1184,7 @@
{
checkIncomplete(offset);
- Long datum = (Long) data[offset];
+ Long datum = (Long) getDatum(offset);
return datum != null ? handle.fromResourceId(datum, false) : new handle();
}
@@ -1244,7 +1291,7 @@
{
checkIncomplete(offset);
- Long datum = (Long) data[offset];
+ Integer datum = (Integer) getDatum(offset);
return datum != null ? new recid(datum) : new recid();
}
@@ -1263,10 +1310,10 @@
*/
protected final void _setRecid(int offset, NumberType w)
{
- Long datum = null;
+ Integer datum = null;
if (w != null && !w.isUnknown())
{
- datum = w.longValue();
+ datum = w.intValue();
}
setDatum(offset, datum);
@@ -1350,7 +1397,7 @@
{
checkIncomplete(offset);
- byte[] datum = (byte[]) data[offset];
+ byte[] datum = (byte[]) getDatum(offset);
return datum != null ? new blob(datum) : new blob();
}
@@ -1457,7 +1504,7 @@
{
checkIncomplete(offset);
- return new clob((String) data[offset], getCodePage(offset));
+ return new clob((String) getDatum(offset), getCodePage(offset));
}
/**
@@ -1560,7 +1607,7 @@
{
checkIncomplete(offset);
- String datum = (String) data[offset];
+ String datum = (String) getDatum(offset);
return datum != null ? comhandle.fromString(datum) : new comhandle();
}
@@ -1665,7 +1712,7 @@
{
checkIncomplete(offset);
- Long datum = (Long) data[offset];
+ Long datum = (Long) getDatum(offset);
// the instance must be typed to Progress.Lang.Object
object res = new object<>(BaseObject.class);
@@ -1781,7 +1828,7 @@
{
checkIncomplete(offset);
- byte[] datum = (byte[]) data[offset];
+ byte[] datum = (byte[]) getDatum(offset);
return datum != null ? new raw(datum) : raw.instantiateUnknownRaw();
}
@@ -1956,7 +2003,7 @@
RecordMeta meta = _recordMeta();
if (oneLine)
{
- int last = data.length;
+ int last = getLength();
int start = (this instanceof TempTableRecord) ? 5 : 0;
sb.append(meta.legacyName).append('/').append(meta.tables[0]).append(':').append(id).append(" {");
for (int i = start; i < last; i++)
@@ -1966,7 +2013,7 @@
sb.append(", ");
}
- boolean isChar = data[i] instanceof String;
+ boolean isChar = getSimpleDatum(i) instanceof String;
if (isChar)
{
sb.append("\"");
@@ -1974,7 +2021,8 @@
boolean incomplete = readFields != null && !readFields.get(i);
- sb.append(data[i] == null ? incomplete ? "n/a" : "?" : data[i]);
+ Object datum = getSimpleDatum(i);
+ sb.append(datum == null ? incomplete ? "n/a" : "?" : datum);
if (isChar)
{
sb.append("\"");
@@ -1997,14 +2045,14 @@
int extent = pms[i].getExtent();
if (extent == 0)
{
- sb.append(data[i]);
+ sb.append(getSimpleDatum(i));
}
else
{
for (int k = 0; k < extent; k++)
{
sb.append(k == 0 ? "[" : "");
- sb.append(data[i + k]);
+ sb.append(getSimpleDatum(i + k));
}
i += extent - 1;
@@ -2042,6 +2090,7 @@
Object val = properties.get(prop.getLegacyName());
val = f.apply(prop, val);
+ Object[] data = getData();
if (prop.getExtent() > 0)
{
for (int j = 0; j < prop.getExtent(); j++, i++)
@@ -2050,11 +2099,13 @@
BaseDataType fval = (BaseDataType) Array.get(val, j);
prop.getDataHandler().setField(data, fval, i, prop);
+ setLivePropsAtOffset(i);
}
}
else
{
prop.getDataHandler().setField(data, (BaseDataType) val, i, prop);
+ setLivePropsAtOffset(i);
}
}
}
@@ -2127,23 +2178,6 @@
}
/**
- * Check if two {@link Record} objects are equal from the point of view of the {@code data} array.
- *
- * To be noted, that this method accesses the {@code data} arrays directly without using
- * any getter. This provides faster access, however should be changed if not all fields are hydrated and
- * access is mandatory from a getter.
- *
- * @param otherRecord
- * The instance to compare against.
- *
- * @return True if the {@code data} arrays are equal, false - otherwise
- */
- public boolean equalData(Record otherRecord)
- {
- return Arrays.equals(this.data, otherRecord.data);
- }
-
- /**
* Converts this {@code Record} into a POJO, if POJO class is available.
* To be implemented by DMO implementations.
*
=== modified file 'src/com/goldencode/p2j/persist/RecordBuffer.java'
--- old/src/com/goldencode/p2j/persist/RecordBuffer.java 2026-05-15 11:20:28 +0000
+++ new/src/com/goldencode/p2j/persist/RecordBuffer.java 2026-05-22 13:57:10 +0000
@@ -1437,8 +1437,7 @@
** 412 SP 20251029 Refactor propsMap to use destination as key and source as value.
** 413 TG 20250925 Avoid openScope call for the same buffer in the current scope.
** 414 RNC 20251118 Log DirectAccessException in 'setCurrentRecord()' only if it is not expected.
-** 415 AS 20251210 When -rereadfields is active, fully hydrate a record instaead of throwing 8826 error.
-** 416 RNC 20260401 Migrate RECID from 32-bit to 64-bit values.
+** 415 AS 20251210 When -rereadfields is active, fully hydrate a record instaead of throwing 8826 error.
*/
/*
@@ -7181,16 +7180,41 @@
* Get the record ID of the current buffer's current record, if any. P2J
* implementation of the RECID function.
*
- * This method will return a 64-bit recid which represents the internal
- * row ID of the given record.
+ * This method will return a 32-bit recid which represents the internal
+ * row ID of the given record. If the actual row ID (which is implemented
+ * as a wider integer) cannot fit due to overflow, an error condition will
+ * be raised.
*
* @return Record ID of the underlying data record. If no record currently
* backs the buffer associated with
* No locking is attempted.
=== modified file 'src/com/goldencode/p2j/persist/hql/DataTypeHelper.java'
--- old/src/com/goldencode/p2j/persist/hql/DataTypeHelper.java 2026-05-15 11:20:28 +0000
+++ new/src/com/goldencode/p2j/persist/hql/DataTypeHelper.java 2026-05-22 13:57:10 +0000
@@ -45,7 +45,6 @@
** 026 SP 20240516 Process the function name in getTypeFunction() when there is an underscore
** 027 CA 20241107 Added character constant support.
** 028 ICP 20250123 Added support for integer and int64 constants.
-** 029 RNC 20260401 Migrate RECID from 32-bit to 64-bit values.
*/
/*
@@ -561,7 +560,7 @@
// P2J wrapper types.
classes.put(logical.class , FqlType.BOOLEAN);
classes.put(integer.class , FqlType.INTEGER);
- classes.put(recid.class , FqlType.LONG);
+ classes.put(recid.class , FqlType.INTEGER);
classes.put(decimal.class , FqlType.DECIMAL);
classes.put(date.class , FqlType.DATE);
classes.put(raw.class , FqlType.RAW);
=== modified file 'src/com/goldencode/p2j/persist/meta/MetadataManager.java'
--- old/src/com/goldencode/p2j/persist/meta/MetadataManager.java 2026-05-15 11:20:28 +0000
+++ new/src/com/goldencode/p2j/persist/meta/MetadataManager.java 2026-05-22 13:57:10 +0000
@@ -73,7 +73,6 @@
** 032 OM 20250331 Make sure the [byName] map's keys are in lowercase. Avoid possible duplication of default
** tenant record in _tenant meta table.
** 033 SP 20250321 Removed support for custom denormalized extents.
-** 034 RNC 20260401 Migrate RECID from 32-bit to 64-bit values.
*/
/*
@@ -215,7 +214,7 @@
private static final boolean LOG_INFO = log.isLoggable(Level.INFO);
/** The recid of the database in {@code _Db} table. */
- private static final long DB_RECID = 4032;
+ private static final int DB_RECID = 4032;
/** Map of data type names to associated _Field._dtype value */
private static final Map
+ * To be noted, that this method accesses the {@code data} arrays directly without using
+ * any getter. This provides faster access, however should be changed if not all fields are hydrated and
+ * access is mandatory from a getter.
+ *
+ * @param otherRecord
+ * The instance to compare against.
+ *
+ * @return True if the {@code data} arrays are equal, false - otherwise
+ */
+ public boolean equalData(BaseRecord otherRecord)
+ {
+ if (this.getLength() != otherRecord.getLength())
+ {
+ return false;
+ }
+ for (int i = 0; i < this.getLength(); i++)
+ {
+ if (this.areAllPropertiesLive() && otherRecord.areAllPropertiesLive())
+ {
+ return Arrays.equals(this.getData(), otherRecord.getData());
+ }
+ }
+
+ for (int i = 0; i < this.getLength(); i++)
+ {
+ if (!Objects.equals(getDatum(i), otherRecord.getDatum(i)))
+ {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+
+ /**
+ * Copy an array of objects into data.
+ *
+ * @param from
+ * The source to copy from.
+ */
+ public void copyArray(Object[] from)
+ {
+ System.arraycopy(from, 0, data, 0, getLength());
}
/**
@@ -695,7 +761,7 @@
// previous state and roll this back as well
for (int i = activeOffsets.nextSetBit(0); i != -1; i = activeOffsets.nextSetBit(i + 1))
{
- data[i] = activePropPreviousValues[i];
+ setSimpleDatum(i, activePropPreviousValues[i]);
}
}
@@ -728,12 +794,14 @@
buf.append(':').append(primaryKey()).append(sep)
.append(state).append(sep)
.append("references: ").append(references).append(sep)
+ .append("read: ").append(readFields).append(sep)
+ .append("live: ").append(liveProps).append(sep)
.append("dirty: ").append(dirtyProps).append(sep)
.append("unvalidated: ").append(unvalidated);
if (includeData)
{
- int len = data.length;
+ int len = getLength();
buf.append(sep).append("data: {");
for (int i = 0; i < len; i++)
{
@@ -742,7 +810,7 @@
buf.append(", ");
}
- buf.append(data[i]);
+ buf.append(getSimpleDatum(i));
}
buf.append('}');
@@ -772,7 +840,7 @@
{
Objects.requireNonNull(pm);
- return data;
+ return getData();
}
/**
@@ -791,9 +859,29 @@
public Object[] getData(RecordBuffer rb)
{
Objects.requireNonNull(rb);
-
+
+ return getData();
+ }
+
+ /**
+ * Get the data property.
+ *
+ * @return The value of the data property.
+ */
+ public Object[] getData()
+ {
return data;
}
+
+ /**
+ * Get the size of the data property.
+ *
+ * @return Size of the data property.
+ */
+ public int getLength()
+ {
+ return data.length;
+ }
/**
* Indicate whether any of this record's validatable properties are dirty and have not been validated.
@@ -860,12 +948,14 @@
public Object[] getActiveUpdateDiff(int ormIndex, int extentIndex)
{
int actualIndex = ormIndex + extentIndex;
- if (dirtyProps.get(actualIndex) && !Objects.equals(activePropPreviousValues[actualIndex],
- data[actualIndex]))
+ Object activeOffsetDatum = getDatum(actualIndex);
+
+ if (dirtyProps.get(actualIndex) &&
+ !Objects.equals(activePropPreviousValues[actualIndex], activeOffsetDatum))
{
Object[] res = new Object[2];
res[0] = activePropPreviousValues[actualIndex];
- res[1] = data[actualIndex];
+ res[1] = activeOffsetDatum;
return res;
}
return null;
@@ -890,8 +980,60 @@
public BitSet _getReadFields()
{
return readFields;
- }
-
+ }
+
+ /**
+ * This should be called when the record is re-attached to a new session. This way, we refresh the
+ * underlying session in hydrator (if any) to properly refresh the record when needed. If this is
+ * not used, we may face {@link LazyHydrationException} due to stale sessions in the hydrator.
+ *
+ * First time a hydrator is created, it will take the session from the generator result-set, thus,
+ * there is no need to call this method in that case.
+ *
+ * @param session
+ * The session to which this record is re-attached.
+ */
+ public void refreshHydrator(Session session)
+ {
+ if (hydrator != null)
+ {
+ hydrator.refresh(session);
+ }
+ }
+
+ /**
+ * Sets the bit in {@link BaseRecord#liveProps} to true, meaning that the field at that index has been
+ * read or written.
+ *
+ * @param offset
+ * Zero-based offset of the datum in the data array, which corresponds to the index in
+ * {@link BaseRecord#liveProps}
+ */
+ protected void setLivePropsAtOffset(int offset)
+ {
+ if (liveProps != null)
+ {
+ if (!liveProps.get(offset))
+ {
+ livePropsCardinality++;
+ }
+
+ liveProps.set(offset);
+ }
+ }
+
+ protected void setAllLiveProps()
+ {
+ if (liveProps == null)
+ {
+ return;
+ }
+ for (int i = 0; i < data.length; i++)
+ {
+ liveProps.set(i);
+ }
+ }
+
/**
* Set a single datum into the data array, and update the record and property state accordingly.
*
@@ -901,12 +1043,7 @@
* Value to be set into the data array.
*/
protected void setDatum(int offset, Object datum)
- {
- if (readFields != null)
- {
- readFields.set(offset);
- }
-
+ {
if (activeBuffer != null)
{
activeOffsets.set(offset);
@@ -915,15 +1052,22 @@
// update the bitset of dirty (touched) properties
dirtyProps.set(offset);
+ Object offsetDatum = getDatum(offset);
+
// temporarily save the old value (even if it is the same as the new value)
- activePropPreviousValues[offset] = data[offset];
+ activePropPreviousValues[offset] = offsetDatum;
+
+ if (readFields != null)
+ {
+ readFields.set(offset);
+ }
// for BigDecimal, equals checks the scale - we need compareTo, to check if the values are really the
// same, regardless of the scale value.
- if (!(Objects.equals(data[offset], datum) ||
+ if (!(Objects.equals(offsetDatum, datum) ||
(datum instanceof Comparable &&
- data[offset] != null &&
- ((Comparable) datum).compareTo(data[offset]) == 0)))
+ offsetDatum != null &&
+ ((Comparable) datum).compareTo(offsetDatum) == 0)))
{
// ensure we have an exclusive lock on the record
if (!lockForUpdate())
@@ -942,7 +1086,7 @@
}
// update the value in the data array
- data[offset] = datum;
+ setSimpleDatum(offset, datum);
}
}
@@ -980,8 +1124,7 @@
continue;
}
- if (fromProp.getType() != toProp.getType() ||
- fromProp.getExtent() != toProp.getExtent())
+ if (fromProp.getType() != toProp.getType() || fromProp.getExtent() != toProp.getExtent())
{
return false;
}
@@ -1012,10 +1155,11 @@
// for BigDecimal, equals checks the scale - we need compareTo, to check if the values are really the
// same, regardless of the scale value.
- if (!(Objects.equals(data[toOffset], datum) ||
+ Object offsetDatum = getDatum(toOffset);
+ if (!(Objects.equals(offsetDatum, datum) ||
(datum instanceof Comparable &&
- data[toOffset] != null &&
- ((Comparable) datum).compareTo(data[toOffset]) == 0)))
+ offsetDatum != null &&
+ ((Comparable) datum).compareTo(offsetDatum) == 0)))
{
if (updatedOffsets == null)
{
@@ -1056,25 +1200,83 @@
{
int offset = updatedOffsets.get(idx);
Object datum = updatedDatums.get(idx);
- data[offset] = datum;
+ setSimpleDatum(offset, datum);
}
return true;
}
/**
- * Get the field's value on the specified offset.
- *
- * @param offset
- * Zero-based offset of the datum in the data array.
- *
- * @return The field's value.
+ * Get the field's value at the specified offset, with {@code null} indicating unknown value.
+ *
+ * N.B.: if lazy hydration can be active for this record, callers must catch and handle the unchecked
+ * {@code LazyHydrationException}.
+ *
+ * @param offset
+ * Zero-based offset of the datum in the data array.
+ *
+ * @return The field's value, with {@code null} indicating unknown value.
+ *
+ * @throws LazyHydrationException
+ * if this record is enabled for lazy hydration, but the attached hydrator was no longer valid.
+ * Although this is an unchecked exception to allow the DMO to be generated with simple getter
+ * methods, callers which invoke this method when lazy hydration could be active MUST catch and
+ * handle this exception.
*/
protected Object getDatum(int offset)
+ throws LazyHydrationException
{
+ if (hydrator != null && liveProps != null && !liveProps.get(offset))
+ {
+ boolean success = hydrator.hydrate(this, offset, getHydratorRowOffset(), true);
+ if (success)
+ {
+ countHydratedFieldsWithLZS(1);
+ }
+ if (!success)
+ {
+ BitSet unhydratedFields = getUnhydratedFields();
+ hydrator.refresh(this, id, unhydratedFields);
+ countHydratedFieldsWithLoader(unhydratedFields.cardinality());
+ }
+ if (!success || livePropsCardinality == data.length)
+ {
+ hydrator = null;
+ liveProps = null;
+ livePropsCardinality = data.length;
+ }
+ }
+
return data[offset];
}
+ public void hydrateRemainingFields()
+ {
+ BitSet unhydratedFields = getUnhydratedFields();
+ if (unhydratedFields == null)
+ {
+ return;
+ }
+ int unhydratedIndex = unhydratedFields.nextSetBit(0);
+ if (unhydratedIndex != -1)
+ {
+ countHydrateRecordWhenSessionCloses(1);
+ countHydratedFieldWhenSessionCloses(unhydratedFields.cardinality());
+ }
+ while (unhydratedIndex != -1 && hydrator != null)
+ {
+ getDatum(unhydratedIndex);
+ unhydratedIndex = unhydratedFields.nextSetBit(unhydratedIndex + 1);
+ }
+ }
+
+ public void clearHydrator()
+ {
+ hydrator = null;
+ liveProps = null;
+ livePropsCardinality = data.length;
+ }
+
/**
* Get the static record metadata for the concrete subclass.
*
@@ -1161,17 +1363,85 @@
}
}
}
-
+
+ /**
+ * Retrieve the row offset required by the hydrator to skip any eventual fields that may
+ * reside the in the result set and not in {@link #data}. For instance, recid is not part
+ * of the data array, but is part of the result-set.
+ *
+ * @return Always 1 as we need to skip only the leading recid.
+ */
+ protected int getHydratorRowOffset()
+ {
+ return 1;
+ }
+
+ /**
+ * Retrieve the fields that are not live due to lazy hydration. This is used to identify which fields
+ * are left to hydrate by the hydrator. This array is used only when a refresh is needed (the record
+ * should be re-loaded from the database). Therefore, don't use this for any hydrate call. Let the
+ * hydrator decide when this is needed.
+ *
+ * @return A bit-set representing the fields that still require hydration.
+ */
+ protected BitSet getUnhydratedFields()
+ {
+ if (liveProps == null)
+ {
+ return null;
+ }
+
+ BitSet partialFields;
+ if (readFields != null)
+ {
+ partialFields = (BitSet) readFields.clone();
+ partialFields.andNot(liveProps);
+ }
+ else
+ {
+ partialFields = (BitSet) liveProps.clone();
+ partialFields.flip(0, data.length);
+ }
+ return partialFields;
+ }
+
+ /**
+ * Checks if a field at the specified index has been hydrated.
+ *
+ * @param index
+ * The index of the field to check.
+ *
+ * @return {@code true} if the field has been hydrated, {@code false} otherwise.
+ */
+ protected boolean isFieldHydrated(int index)
+ {
+ return liveProps.get(index);
+ }
+
+ protected abstract void countHydrateRecordWhenSessionCloses(long count);
+
+ protected abstract void countTotalFields(long count);
+
+ protected abstract void countHydratedFieldsWithLZS(long count);
+ protected abstract void countHydratedFieldsWithLoader(long count);
+
+
+ protected abstract void countHydratedFieldWhenSessionCloses(long count);
+
+
/**
* Mark this record as incomplete.
*
* @param session
* Database session (used for UNDO purposes).
+ *
+ * @param loadedFields
+ * Fields that were loaded from database.
*/
- void markIncomplete(Session session)
+ void markIncomplete(Session session, BitSet loadedFields)
{
updateState(session, DmoState.INCOMPLETE, true);
- readFields = new BitSet(data.length);
+ readFields = loadedFields;
}
/**
@@ -1387,7 +1657,7 @@
* 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}.
+ * then more than one column will be read from {@code ResultSet}.
*
* @return The number of columns actually read from the {@code ResultSet}.
*/
@@ -1424,14 +1694,21 @@
try
{
- if (readFields != null)
+ int count = propertyReader.readProperty(rs, rsOffset, data, propOffset);
+
+ if (liveProps != null)
{
- readFields.set(propOffset);
+ // this should always hold; we shouldn't ever read a field twice
+ // otherwise, the cardinality will fail
+ livePropsCardinality++;
+
+ // mark this property as live
+ liveProps.set(propOffset);
}
- return propertyReader.readProperty(rs, rsOffset, data, propOffset);
+ return count;
}
- catch (java.sql.SQLException sqle)
+ catch (SQLException sqle)
{
throw new PersistenceException(sqle);
}
@@ -1529,6 +1806,40 @@
}
/**
+ * Indicate whether all properties are live; that is, have all properties been initialized, either by
+ * hydration from a result set, explicitly setting them, or initializing them to their default values.
+ *
+ * @return {@code true} if all properties are live, else {@code false}.
+ */
+ boolean areAllPropertiesLive()
+ {
+ return hydrator == null;
+ }
+
+ /**
+ * Create a lazy hydration helper object for the given result set, at the given offset into the column
+ * results, for the current result set row.
+ *
+ * @param rowStruct
+ * The row structure of the of the result-set.
+ * @param lazyResultSet
+ * Backing result set for lazy hydration.
+ * @param rsOffset
+ * Offset of the primary key column for this record in the current row of the result set.
+ */
+ void createHydrator(RowStructure rowStruct, LazyResultSet lazyResultSet, int rsOffset)
+ {
+ hydrator = lazyResultSet.createHydrator(rowStruct, rsOffset, _recordMeta());
+ // don't reset liveProps as we want to avoid hydrating properties that were already hydrated
+ if (liveProps == null)
+ {
+ liveProps = new BitSet(data.length);
+ livePropsCardinality = 0;
+ }
+ countTotalFields(data.length);
+ }
+
+ /**
* Perform a sub-transaction level changeset reset of this record
* @param txLevel
* The nesting level of sub-transactions of the block being rolled back, where 0 represents
@@ -1668,6 +1979,7 @@
int txLevel = prepareChangeSet(activeBuffer.getSession());
if (txLevel >= 0)
{
+ changeSet.updateBaseline(offset, getDatum(offset));
changeSet.logStateChange(flags, txLevel);
changeSet.logDataChange(txLevel, offset, datum);
}
@@ -1715,6 +2027,7 @@
for (int i = 0; i < offsets.size(); i++)
{
int offset = offsets.get(i);
+ changeSet.updateBaseline(offset, getDatum(offset));
Object datum = datums.get(i);
changeSet.logDataChange(txLevel, offset, datum);
}
@@ -1792,9 +2105,8 @@
// create a change set if one with the same transaction ID does not already exist
if (changeSet == null || !changeSet.verify(session, txId))
{
- changeSet = new ChangeSet(session, txId, data, state.state, txLevel);
+ changeSet = new ChangeSet(session, txId, data, liveProps, state.state, txLevel);
}
-
// register this undoable record with the savepoint manager at the current transaction nesting
// level
session.trackUndoable(this);
@@ -1871,4 +2183,49 @@
}
return size;
}
+
+ /**
+ * Simple method to retrieve the effective value at a specified offset.
+ * Note that this doesn't honor the lazy hydration technique and should be used
+ * ONLY for logging / debugging purposes. This method shouldn't be used functionally
+ * in the orm architecture.
+ *
+ * @param offset
+ * Zero-based offset of the datum in the data array.
+ */
+ protected Object getSimpleDatum(int offset)
+ {
+ return data[offset];
+ }
+
+ /**
+ * Set a single datum into the data array, and update the record.
+ * This is a simple version of {@link #setDatum(int, Object)} used
+ * by BaseRecord.
+ *
+ * @param offset
+ * Zero-based offset of the datum in the data array.
+ * @param datum
+ * Value to be set into the data array.
+ */
+ public void setSimpleDatum(int offset, Object datum)
+ {
+ if (readFields != null)
+ {
+ readFields.set(offset);
+ }
+
+ if (liveProps != null)
+ {
+ if (!liveProps.get(offset))
+ {
+ livePropsCardinality++;
+ }
+
+ liveProps.set(offset);
+ }
+
+ data[offset] = datum;
+ }
+
}
=== modified file 'src/com/goldencode/p2j/persist/orm/ChangeSet.java'
--- old/src/com/goldencode/p2j/persist/orm/ChangeSet.java 2025-11-18 12:38:12 +0000
+++ new/src/com/goldencode/p2j/persist/orm/ChangeSet.java 2026-05-22 13:58:35 +0000
@@ -145,7 +145,7 @@
/** Baseline snapshot of data before first change is made */
private final Object[] baselineData;
-
+ private final BitSet activeFieldsInBaseline;
/** Baseline state before first change is made */
private final int baselineState;
@@ -180,13 +180,14 @@
* Anticipated maximum number of transaction nesting levels to record. It will be increased
* dynamically later, if this capacity is exceeded.
*/
- ChangeSet(Session session, int txId, Object[] data, int state, int capacity)
+ ChangeSet(Session session, int txId, Object[] data, BitSet liveProps, int state, int capacity)
{
this.session = session;
this.txId = txId;
int len = data.length;
this.baselineData = new Object[len];
System.arraycopy(data, 0, this.baselineData, 0, len);
+ this.activeFieldsInBaseline = liveProps == null ? new BitSet(len) : (BitSet) liveProps.clone();
this.baselineState = state;
ensureCapacity(capacity);
@@ -263,9 +264,6 @@
return;
}
- // live data to be updated by rollback
- Object[] liveData = dmo.data;
-
// gather the positions of all the data elements that were changed at this block and in more
// deeply nested blocks and clear those data structures after collecting this information
BitSet touched = new BitSet(baselineData.length);
@@ -314,8 +312,7 @@
for (int j = copy.nextSetBit(0); j >= 0; j = copy.nextSetBit(j + 1))
{
// overlay the live data
- liveData[j] = changes[i][j];
-
+ dmo.setSimpleDatum(j, changes[i][j]);
// remember that we've rolled back this data element
touched.clear(j);
}
@@ -326,7 +323,7 @@
{
for (int j = touched.nextSetBit(0); j >= 0; j = touched.nextSetBit(j + 1))
{
- liveData[j] = baselineData[j];
+ dmo.setSimpleDatum(j, baselineData[j]);
}
}
@@ -406,6 +403,17 @@
}
}
+ public void updateBaseline(int offset, Object datum)
+ {
+ if (activeFieldsInBaseline.get(offset))
+ {
+ return;
+ }
+
+ baselineData[offset] = datum;
+ activeFieldsInBaseline.set(offset);
+ }
+
/**
* Prepare for a log entry into the change set by updating the outermost and innermost transaction
* nesting levels at which changes occur, and by ensuring the internal data structures have enough
=== modified file 'src/com/goldencode/p2j/persist/orm/DirectAccessHelper.java'
--- old/src/com/goldencode/p2j/persist/orm/DirectAccessHelper.java 2025-11-18 12:38:12 +0000
+++ new/src/com/goldencode/p2j/persist/orm/DirectAccessHelper.java 2026-05-22 13:58:35 +0000
@@ -524,7 +524,7 @@
*
*/
private static Record interpretResponse(Session session, DmoMeta meta, DirectAccessResponse response)
- throws PersistenceException,
+ throws PersistenceException,
SQLException
{
if (response.recid == null)
@@ -540,6 +540,11 @@
}
ResultSet rs = response.getResultSet();
+ if (Query.getDialect(session).useLazyHydration())
+ {
+ rs = new LazyResultSet(rs.getStatement(), rs, session);
+ }
+
if (rs.next())
{
RowStructure rowStructure = new FullRowStructure(meta);
=== modified file 'src/com/goldencode/p2j/persist/orm/DmoClass.java'
--- old/src/com/goldencode/p2j/persist/orm/DmoClass.java 2026-05-15 11:20:28 +0000
+++ new/src/com/goldencode/p2j/persist/orm/DmoClass.java 2026-05-22 13:57:10 +0000
@@ -20,7 +20,6 @@
** 006 AD 20240313 Added method that assembles implementation and returns the new DmoClass object.
** AD 20240403 Added callback method when assembling dmo implementation.
** 007 SP 20250206 Removed support for custom denormalized extents.
-** 008 RNC 20260401 Migrate RECID from 32-bit to 64-bit values.
*/
/*
@@ -229,7 +228,7 @@
converters.put(logical.class, new Dmo2Pojo("java/lang/Boolean", null, null, null));
converters.put(object.class, new Dmo2Pojo("java/lang/Long", null, null, null));
converters.put(raw.class, new Dmo2Pojo("[B", null, null, null));
- converters.put(recid.class, new Dmo2Pojo("java/lang/Long", null, null, null));
+ converters.put(recid.class, new Dmo2Pojo("java/lang/Integer", null, null, null));
converters.put(rowid.class, new Dmo2Pojo("java/lang/Long", null, null, null));
}
=== modified file 'src/com/goldencode/p2j/persist/orm/DmoMeta.java'
--- old/src/com/goldencode/p2j/persist/orm/DmoMeta.java 2025-11-10 10:38:44 +0000
+++ new/src/com/goldencode/p2j/persist/orm/DmoMeta.java 2026-05-22 13:58:35 +0000
@@ -679,8 +679,8 @@
* Obtain the list of properties for this DMO.
*
* @param extra
- * If {@code true} the surrogate/hidden properties ({@code id}, {@code _multiplex})
- * are also added, otherwise only the original fields are returned.
+ * If {@code true} the surrogate/hidden properties ({@code id}, {@code _multiplex})
+ * are also added, otherwise only the original fields are returned.
*
* @return An iterator for list of properties for this DMO.
*/
=== modified file 'src/com/goldencode/p2j/persist/orm/DmoMetadataManager.java'
--- old/src/com/goldencode/p2j/persist/orm/DmoMetadataManager.java 2025-04-02 14:49:50 +0000
+++ new/src/com/goldencode/p2j/persist/orm/DmoMetadataManager.java 2026-05-22 13:58:35 +0000
@@ -94,6 +94,7 @@
import com.goldencode.p2j.persist.Record;
import com.goldencode.p2j.persist.annotation.*;
import com.goldencode.p2j.persist.meta.*;
+import com.goldencode.p2j.persist.dialect.*;
import com.goldencode.p2j.util.*;
import com.goldencode.p2j.util.logging.*;
import java.util.*;
@@ -560,7 +561,6 @@
*
* @return Unmodifiable map.
*
- *
* @throws PersistenceException
* if there is an error querying index information from the JDBC driver.
*/
=== modified file 'src/com/goldencode/p2j/persist/orm/FullRowStructure.java'
--- old/src/com/goldencode/p2j/persist/orm/FullRowStructure.java 2025-07-16 14:01:50 +0000
+++ new/src/com/goldencode/p2j/persist/orm/FullRowStructure.java 2026-05-22 13:58:35 +0000
@@ -12,6 +12,7 @@
** 002 OM 20240712 Added support for hydrating expanded extent fields.
** SP 20250321 Removed usage of property.index. Fixed typos.
** 003 LS 20250714 Added 'getNeededFields' implementation.
+** 004 AL2 20231214 Added implementation for hydrateAt
*/
/*
@@ -71,8 +72,7 @@
import java.sql.ResultSet;
import java.sql.SQLException;
-import java.util.BitSet;
-import java.util.Iterator;
+import java.util.*;
import com.goldencode.p2j.persist.PersistenceException;
import com.goldencode.p2j.persist.TempRecord;
@@ -241,11 +241,62 @@
{
hydrateExtents(session, r, recOffset);
}
+
+ r.clearHydrator();
return rsOffset;
}
/**
+ * Hydrate only one property in the base-record. This is largely used by the lazy hydrator,
+ * allowing it to hydrate only the property that is accessed now. The other hydration method
+ * ({@link #hydrate}) eagerly hydrates all properties, is a slow process and may do useless
+ * hydrations on properties that are not accessed.
+ *
+ * @param resultSet
+ * The ResultSet from which the hydration should be done
+ * @param rsOffset
+ * The result set offset from which the reading should be done. This is relevant as
+ * the result set may contain a joined row, but we are interested only in a specific
+ * record that may start at a specific offset.
+ * @param r
+ * The record that should be hydrated.
+ * @param propOffset
+ * The property that should be hydrated. The caller is responsible in assuring that
+ * this property wasn't hydrated before.
+ *
+ * @return {@code true} if this worked due to the fact that it was a scalar value. {@code false}
+ * in case the property was a non-expanded
+ *
+ * @throws PersistenceException
+ * This is thrown when reading the scalar property fails.
+ */
+ @Override
+ public boolean hydrateAt(ResultSet resultSet, int rsOffset, BaseRecord r, int propOffset)
+ throws PersistenceException
+ {
+ // we know the result-set if properly formatted and matched the data in the dataIndex
+ PropertyMeta pm = getPropertyMeta()[propOffset];
+ if (pm.getExtent() == 0)
+ {
+ r.readProperty(propOffset, resultSet, (rsOffset - 1) + pm.columnIndex, false);
+ return true;
+ }
+ else if(pm.dmoProperty.expanded)
+ {
+ int extentIndex = (propOffset - pm.offset) * pm.columnCount;
+ // pm.columnIndex refers to the index of the 1st element in the extent,
+ // so we need to add the current extent index
+ // Multiplication by pm.columnCount is needed for cases when the extent element is represented on
+ // more SQL columns
+ r.readProperty(propOffset, resultSet, (rsOffset - 1) + pm.columnIndex + extentIndex);
+ return true;
+ }
+
+ return false;
+ }
+
+ /**
* Check if this structure is used for an incomplete record.
*
* This specific row structure (full) will always retrieve the whole record.
@@ -266,4 +317,18 @@
{
return null;
}
+
+ /**
+ * Retrieve the fields that were loaded from the database.
+ *
+ * @return A BitSet object, where true means that the field associated with that position in the {@code
+ * data} array has been loaded from database, and false - otherwise.
+ */
+ @Override
+ public BitSet getLoadedFields()
+ {
+ BitSet fields = new BitSet(getPropertyMeta().length);
+ fields.flip(0, fields.size());
+ return fields;
+ }
}
=== added file 'src/com/goldencode/p2j/persist/orm/Hydrator.java'
--- old/src/com/goldencode/p2j/persist/orm/Hydrator.java 1970-01-01 00:00:00 +0000
+++ new/src/com/goldencode/p2j/persist/orm/Hydrator.java 2026-05-22 13:46:08 +0000
@@ -0,0 +1,324 @@
+/*
+** Module : Hydrator.java
+** Abstract : Stores a lazy result set to enable lazy (just-in-time) hydration of a DMO.
+**
+** Copyright (c) 2023, Golden Code Development Corporation.
+**
+** -#- -I- --Date-- ---------------------------------------Description---------------------------------------
+** 001 ECF 20230102 Created initial version.
+** AL2 20231102 Added a loader as a fallback if the result-set is closed.
+** AL2 20231103 Added a JMX to track lazy hydration
+** AL2 20231106 Allow refresh with partial fields.
+** AL2 20231110 Support hydration of normalized extent field in this class. The record will rely on this
+** instance to handle the whole hydration boilerplate.
+*/
+
+/*
+** 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 java.lang.ref.*;
+import java.sql.*;
+import java.util.BitSet;
+
+import com.goldencode.p2j.jmx.*;
+import com.goldencode.p2j.persist.PersistenceException;
+
+/**
+ * This class stores a lazy result set to enable deferred/lazy (just-in-time) hydration of a DMO. One or
+ * more instances of this class is created when a scrollable result set is positioned at a new row, when
+ * reading through the results of a query. One instance is created per DMO that needs to be hydrated from
+ * that result row. At that moment, a token is retrieved from the result set. When the result set is needed
+ * for lazy hydration later, the token is compared to the internal state of the result set. If any state has
+ * changed which prevents lazy hydration (e.g., the result set was closed, repositioned to a new row, etc.),
+ * {@link #getResultSet()} will return {@code null} instead of the result set. It is expected that the use
+ * pattern for this object is to invoke {@link #getResultSet()} and then immediately retrieve data from the
+ * returned result set (if not {@code null}).
+ */
+class Hydrator
+{
+ /** Instrumentation for {@link #getResultSet}. */
+ private static final SimpleCounter VALID_HYDRATOR =
+ SimpleCounter.getInstance(FwdServerJMX.Counter.HydratorHit);
+
+ /** Instrumentation for {@link #getResultSet}. */
+ private static final SimpleCounter HYDRATOR_MISS =
+ SimpleCounter.getInstance(FwdServerJMX.Counter.HydratorMiss);
+
+ /** Instrumentation for {@link #refresh}. */
+ private static final SimpleCounter SUCCESSFULL_REFRESH =
+ SimpleCounter.getInstance(FwdServerJMX.Counter.HyratorSuccessfullRefresh);
+
+ /** Instrumentation for {@link #refresh}. */
+ private static final SimpleCounter UNSUCCESSFULL_REFRESH =
+ SimpleCounter.getInstance(FwdServerJMX.Counter.HyratorUnsuccessfullRefresh);
+
+ /** Token which is used to track validity of the hydrator vis-a-vis the backing result set */
+ final long token;
+
+ /** Offset of the starting point in a result set row from which to begin reading DMO data */
+ final int rsOffset;
+
+ /** Weak reference to the backing result set */
+ private final WeakReference
+ * The result set returned from this method is meant to be accessed immediately upon return from this
+ * method. If such access is deferred, the result set may become invalid (closed, repositioned on
+ * another record, etc.). In such a case, an error or undefined behavior might result.
+ *
+ * @return Result set backing this hydrator, or {@code null} if it has become invalid for lazy hydration
+ * purposes.
+ */
+ LazyResultSet getResultSet()
+ {
+ LazyResultSet rs = rsRef.get();
+ if (rs != null && rs.isHydratorValid(this))
+ {
+ VALID_HYDRATOR.update(1);
+ return rs;
+ }
+
+ HYDRATOR_MISS.update(1);
+ return null;
+ }
+
+ /**
+ * Allow refreshing a dmo based on the fallback loader here. this may fail if the loader is no longer
+ * available. This is because the session may be closed.
+ *
+ * It is enough to do a quick load without doing any session cache work.
+ *
+ * @param dmo
+ * The dmo to be refreshed
+ * @param recid
+ * The id based on which the refreshing should be done.
+ *
+ * @return {@code true} if the loading succeeded. This may fail if the session was closed.
+ */
+ public void refresh(BaseRecord dmo, Long recid, BitSet partialFields)
+ {
+ Loader loader;
+ if (loaderRef == null || (loader = loaderRef.get()) == null)
+ {
+ UNSUCCESSFULL_REFRESH.update(1);
+ throw new LazyHydrationException(recid, -1);
+ }
+
+ try
+ {
+ // don't mark as incomplete; the other fields were hydrated on-time
+ loader.load(dmo, recid, partialFields);
+ }
+ catch (PersistenceException e)
+ {
+ UNSUCCESSFULL_REFRESH.update(1);
+ throw new LazyHydrationException(recid, -1, e);
+ }
+
+ SUCCESSFULL_REFRESH.update(1);
+ }
+
+ /**
+ * Hydrate a specific field in a record based on the underlying result-set. This is used
+ * to honor lazy hydration. When a record field is accessed and not yet hydrated, this method
+ * will read from the result-set. If the result-set was closed, attempt to reload from database
+ * using the loader. This is an expensive call, but empirically it happens very rarely.
+ *
+ * @param r
+ * The record to be hydrated.
+ * @param propOffset
+ * The property which should be hydrated. This has the index of the data.
+ * @param rowOffset
+ * An eventual offset to skip leading fields (i.e. recid or multiplex).
+ * @param allowOtherImplicitHydration
+ * Allow other implicit hydration (e.g. hydrate the other fields in unique indices).
+ *
+ * @return {@code true} if this requires a refresh or {@code false} otherwise. This information
+ * is used by the record to know if the hydrator should be dropped or not. If a refresh
+ * happened, lazy hydration is no longer needed.
+ */
+ public boolean hydrate(BaseRecord r, int propOffset, int rowOffset, boolean allowOtherImplicitHydration)
+ {
+ ResultSet rs = getResultSet();
+ Long id = r.primaryKey();
+
+ if (rs != null)
+ {
+ try
+ {
+ boolean wasScalar = rowStruct.hydrateAt(rs, rsOffset + rowOffset, r, propOffset);
+ if (!wasScalar)
+ {
+ Session session = null;
+ if (sessionRef == null || (session = sessionRef.get()) == null)
+ {
+ throw new LazyHydrationException(r.primaryKey(), -1);
+ }
+ rowStruct.hydrateExtents(session, r, -1);
+ }
+
+ if (allowOtherImplicitHydration)
+ {
+ hydrateRemainingFieldsInUniqueIndexes(r, propOffset, rowOffset);
+ }
+ }
+ catch (PersistenceException e)
+ {
+ throw new LazyHydrationException(id, propOffset, e);
+ }
+
+ return true;
+ }
+
+ return false;
+ }
+
+ /**
+ * Hydrates other unhydrated fields that belong to the same unique indexes as the specified property.
+ *
+ *
+ * @param r
+ * The record to be hydrated.
+ * @param propOffset
+ * The property whose unique indices should be checked. This has the index of the data.
+ * @param rowOffset
+ * An eventual offset to skip leading fields (i.e. recid or multiplex).
+ */
+ private void hydrateRemainingFieldsInUniqueIndexes(BaseRecord r, int propOffset, int rowOffset)
+ {
+ BitSet[] uniqueIndices = r._recordMeta().getUniqueIndices();
+
+ for(BitSet uIndex : uniqueIndices)
+ {
+ if (uIndex.get(propOffset))
+ {
+ for (int i = uIndex.nextSetBit(0); i >= 0; i = uIndex.nextSetBit(i + 1))
+ {
+ // don't hydrate if the field is the current one or if the field has already been hydrated
+ if (i == propOffset || r.isFieldHydrated(i))
+ {
+ continue;
+ }
+
+ hydrate(r, i, rowOffset, false);
+ }
+ }
+ }
+ }
+
+
+ /**
+ * Always attempt to refresh the session to the new one. Otherwise, this could still reference
+ * a stale session which waits to be garbage collected (or reclaimed).
+ *
+ * @param session
+ * The session to which we attempt to attach this hydrator.
+ */
+ public void refresh(Session session)
+ {
+ this.sessionRef = new WeakReference<>(session);
+ this.loaderRef = session.getLoader();
+ }
+}
=== added file 'src/com/goldencode/p2j/persist/orm/LazyHydrationException.java'
--- old/src/com/goldencode/p2j/persist/orm/LazyHydrationException.java 1970-01-01 00:00:00 +0000
+++ new/src/com/goldencode/p2j/persist/orm/LazyHydrationException.java 2026-05-22 13:46:08 +0000
@@ -0,0 +1,136 @@
+/*
+** Module : LazyHydrationException.java
+** Abstract : An exception type for lazy hydration runtime errors.
+**
+** Copyright (c) 2023, Golden Code Development Corporation.
+**
+** -#- -I- --Date-- ---------------------------------------Description---------------------------------------
+** 001 ECF 20230619 Created initial version.
+** AL2 20231102 Added constructor with clause.
+*/
+
+/*
+** 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;
+
+/**
+ * This exception type is used with lazy hydration of DMOs from result sets. It is raised when a {@link
+ * Hydrator} associated with a {@link BaseRecord} is no longer valid, or when a database error occurs during
+ * lazy hydration of a DMO's data.
+ *
+ * This class extends {@code RuntimeException} rather than {@code Exception} to avoid complicating all
+ * generated DMO interface getter and setter methods. Lazy hydration is used only by the persistence runtime,
+ * while DMO interfaces are used in proxy form by application logic. It is undesirable to clutter application
+ * logic with checked exception handling, since these exceptions will be caught and handled at lower levels
+ * within the runtime environment and must not propagate beyond the DMO proxy invocation handlers to the
+ * application level.
+ */
+@SuppressWarnings("serial")
+public class LazyHydrationException
+extends RuntimeException
+{
+ private final Long primaryKey;
+
+ private final int offset;
+
+ /**
+ * Constructor used when hydrating a datum lazily and the hydrator is no longer valid.
+ *
+ * @param primaryKey
+ * Primary key of record which failed lazy hydration.
+ * @param offset
+ * Starting offset of the datum which could not be retrieved, in the record's data array.
+ */
+ LazyHydrationException(Long primaryKey, int offset)
+ {
+ this(primaryKey, offset, null);
+ }
+
+ /**
+ * Constructor used when hydrating a datum lazily and the hydrator is no longer valid.
+ *
+ * @param primaryKey
+ * Primary key of record which failed lazy hydration.
+ * @param offset
+ * Starting offset of the datum which could not be retrieved, in the record's data array.
+ */
+ LazyHydrationException(Long primaryKey, int offset, Throwable cause)
+ {
+ super(cause);
+ this.primaryKey = primaryKey;
+ this.offset = offset;
+ }
+
+ public long getPrimaryKey()
+ {
+ return primaryKey;
+ }
+
+ public int getOffset()
+ {
+ return offset;
+ }
+
+ /**
+ * Since this exception is only thrown from one location, override the default implementation to avoid
+ * the overhead of filling in the stack trace.
+ *
+ * @return This object.
+ */
+ @Override
+ public LazyHydrationException fillInStackTrace()
+ {
+ return this;
+ }
+}
=== added file 'src/com/goldencode/p2j/persist/orm/LazyResultSet.java'
--- old/src/com/goldencode/p2j/persist/orm/LazyResultSet.java 1970-01-01 00:00:00 +0000
+++ new/src/com/goldencode/p2j/persist/orm/LazyResultSet.java 2026-05-22 13:46:08 +0000
@@ -0,0 +1,2097 @@
+/*
+** Module : LazyResultSet.java
+** Abstract : Delegating result set wrapper which tracks validity for lazy hydration.
+**
+** Copyright (c) 2023, Golden Code Development Corporation.
+**
+** -#- -I- --Date-- ---------------------------------------Description---------------------------------------
+** 001 ECF 20230804 Created initial version.
+** AL2 20231102 Added loader to the hydrator to fall-back in case the result-set expires.
+** AL2 20231110 Store a weak reference to the session instead of loader. Allow this to store the statement
+** to eventually return the statement that created this result-set, not the one that created
+** the underlying result-set (see UnclosablePreparedStatement).
+*/
+
+/*
+** 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 java.io.*;
+import java.lang.ref.WeakReference;
+import java.math.*;
+import java.net.*;
+import java.sql.*;
+import java.sql.Date;
+import java.util.*;
+
+/**
+ * A wrapper for a {@code ResultSet} which delegates all methods to the wrapped result set and which
+ * additionally can create and validate {@link Hydrator} objects. A hydrator can extract data from a
+ * particular row in the result set, but becomes invalid if that row is no longer accessible.
+ *
+ * Hydrator validity is determined by comparing a counter's value at the time the hydrator instance is
+ * created with that counter's value at the time validity is checked. When {@link #createHydrator}
+ * creates a new hydrator instance, the counter's current value is saved as a token in the hydrator object.
+ * The counter is incremented every time the wrapped result set's state is changed to move to another row,
+ * or to otherwise make the result set unreadable (e.g., it is closed).
+ *
+ * If the current value of the counter does not match a hydrator's stored token at the moment {@link
+ * #isHydratorValid(Hydrator)} is invoked, the validation fails.
+ *
+ */
+public final class LazyResultSet
+implements ResultSet
+{
+ /** Delegate statement */
+ private final Statement stmt;
+
+ /** Delegate result set */
+ private final ResultSet rs;
+
+ /** Counter which is updated for every change which could invalidate a hydrator */
+ private long changes = 0L;
+
+ /** The fallback loader to help generated hydrators to recover from invalidated result-sets */
+ private WeakReferencedmo, a recid
* initialized as unknown value is returned.
+ *
+ * @throws ErrorConditionException
+ * if the actual record ID is too wide to fit within a 32-bit
+ * integer.
*/
public recid recordID()
{
=== modified file 'src/com/goldencode/p2j/persist/Cursor.java'
--- old/src/com/goldencode/p2j/persist/Cursor.java 2026-05-15 11:20:28 +0000
+++ new/src/com/goldencode/p2j/persist/Cursor.java 2026-05-22 13:57:10 +0000
@@ -77,7 +77,6 @@
** account for the case when its state can become invalid. Refs #9402.
** 032 AL2 20250415 Allow consumers of repositionByID to decide if it should be a scan or not.
** 033 AL2 20250521 Repositioning to a row is done with NO_LOCK.
-** 034 RNC 20260401 Modified method 'repositionByID()' to use a 64-bit integer.
*/
/*
@@ -263,7 +262,7 @@
* @throws ErrorConditionException
* if the specified ID represents the unknown value.
*/
- boolean repositionByID(boolean scan, int64 id)
+ boolean repositionByID(boolean scan, integer id)
{
Long[] serIDs = new Long[] { id.longValue() };
=== modified file 'src/com/goldencode/p2j/persist/FqlType.java'
--- old/src/com/goldencode/p2j/persist/FqlType.java 2026-05-15 11:20:28 +0000
+++ new/src/com/goldencode/p2j/persist/FqlType.java 2026-05-22 13:57:10 +0000
@@ -2,7 +2,7 @@
** Module : FqlType.java
** Abstract : Enumeration of data types for various SQL constructs
**
-** Copyright (c) 2004-2026, Golden Code Development Corporation.
+** Copyright (c) 2004-2020, Golden Code Development Corporation.
**
** -#- -I- --Date-- --JPRM-- -----------------------------Description-----------------------------
** 001 ECF 20080310 @37500 Created initial version. Enumeration of data types for various HQL
@@ -11,7 +11,6 @@
** 003 SVL 20120331 Added DATETIME and DATETIMETZ types.
** 004 OM 20200402 Renamed class to FqlType and move to persist package.
** 005 IAS 20201123 Added ARRAY type
-** 006 RNC 20260401 Modified the underlying recid class to use BIGINT instead of INTEGER.
*/
/*
@@ -120,7 +119,7 @@
types.put(comhandle.class, Types.VARCHAR);
types.put(handle.class , Types.VARCHAR);
types.put(object.class , Types.VARCHAR);
- types.put(recid.class , Types.BIGINT);
+ types.put(recid.class , Types.INTEGER);
types.put(rowid.class , Types.BIGINT);
*/
=== modified file 'src/com/goldencode/p2j/persist/Persistence.java'
--- old/src/com/goldencode/p2j/persist/Persistence.java 2025-11-06 15:39:50 +0000
+++ new/src/com/goldencode/p2j/persist/Persistence.java 2026-05-22 13:58:35 +0000
@@ -751,6 +751,7 @@
import java.util.function.*;
import java.util.logging.*;
import com.goldencode.cache.*;
+import com.goldencode.p2j.jmx.*;
import com.goldencode.p2j.persist.deploy.*;
import com.goldencode.p2j.persist.dialect.*;
import com.goldencode.p2j.persist.dirty.DirtyShareSupport;
@@ -1947,15 +1948,14 @@
{
local.closeSession(true);
ErrorEntry ee = exc.getErrorEntry();
- ErrorManager.recordOrShowError(
- new int[] {ee.num},
- new String[] {ee.text},
- true,
- ee.prefix,
- false,
- false,
- false,
- true);
+ ErrorManager.recordOrShowError(new int[] {ee.num},
+ new String[] {ee.text},
+ true,
+ ee.prefix,
+ false,
+ false,
+ false,
+ true);
handleException(ErrorManager.buildErrorText(ee.num, ee.text, ee.prefix, false), exc);
}
catch (PersistenceException exc)
@@ -5248,6 +5248,9 @@
/** FQL statement */
private final String fql;
+ /** Database dialect */
+ private final Dialect dialect;
+
/** Does the query was generated with maximum results option? */
private final boolean hasMaxResults;
@@ -5268,21 +5271,25 @@
*
* @param hql
* FQL statement
+ * @param dialect
+ * Database dialect.
* @param maxResults
* Maximum results.
* @param startOffset
* Starting row offset.
*/
- QueryKey(String hql, int maxResults, int startOffset, DataRelation relation, boolean lazyMode)
+ QueryKey(String hql, Dialect dialect, int maxResults, int startOffset, DataRelation relation, boolean lazyMode)
{
this.fql = hql;
+ this.dialect = dialect;
this.hasMaxResults = maxResults > 0;
this.hasStartOffset = startOffset > 0;
this.whereStr = relation == null ? "" : relation.getWhereString().toJavaType();
this.lazyMode = lazyMode;
int result = 17;
- result = 37 * result + hql.hashCode();
+ result = 37 * result + fql.hashCode();
+ result = 37 * result + dialect.hashCode();
result = 37 * result + (hasMaxResults ? 1 : 0) + (hasStartOffset ? 2 : 0);
result = 37 * result + whereStr.hashCode();
result = 37 * result + (lazyMode ? 1 : 0);
@@ -5308,6 +5315,7 @@
QueryKey that = (QueryKey) o;
return this.hash == that.hash &&
+ this.dialect.equals(that.dialect) &&
this.hasMaxResults == that.hasMaxResults &&
this.hasStartOffset == that.hasStartOffset &&
this.fql.equals(that.fql) &&
@@ -5334,7 +5342,7 @@
@Override
public String toString()
{
- return fql + "[" + hasMaxResults + ":" + hasStartOffset + "];" + whereStr;
+ return fql + "[" + hasMaxResults + ":" + hasStartOffset + "] (" + dialect + ") " + whereStr;
}
}
@@ -5561,28 +5569,21 @@
Query query = null;
fql = fql.trim(); // just in case
- // TODO: use the dialect also? I.e: is it possible to have different SQL for same FQL
- // if different dialects are used?
- QueryKey key = new QueryKey(fql, maxResults, startOffset, relation, lazyMode);
+ QueryKey key = new QueryKey(fql, dialect, maxResults, startOffset, relation, lazyMode);
- synchronized (staticQueryCache)
+ query = staticQueryCache.get(key);
+ if (query == null)
{
- query = staticQueryCache.get(key);
- if (query == null)
+ Consumerdmo, a recid
* initialized as unknown value is returned.
+ *
+ * @throws ErrorConditionException
+ * if the actual record ID is too wide to fit within a 32-bit
+ * integer.
*/
public recid recordID()
{
- return isAvailable() ? new recid(getCurrentRecord().primaryKey()) : new recid();
+ if (isAvailable())
+ {
+ Record record = getCurrentRecord();
+ long id = record.primaryKey();
+ if (id < Integer.MIN_VALUE || id > Integer.MAX_VALUE)
+ {
+ // TODO: don't know what 4GL's overflow behavior is or whether the corresponding
+ // error is more serious than an ERROR condition; internally, we support a 64-bit
+ // value, but the recid object follows the 32-bit constraint in terms of not
+ // formatting this
+ txHelper.errHlp.noRecordOrThrowError(
+ "Row id of " + id + " is too wide to fit within a 32-bit record ID");
+ }
+
+ return new recid(id);
+ }
+ else
+ {
+ return new recid();
+ }
}
/**
=== modified file 'src/com/goldencode/p2j/persist/TempRecord.java'
--- old/src/com/goldencode/p2j/persist/TempRecord.java 2024-10-21 07:34:01 +0000
+++ new/src/com/goldencode/p2j/persist/TempRecord.java 2026-05-22 13:58:35 +0000
@@ -17,6 +17,7 @@
** 004 CA 20240918 Removed default methods from interfaces and moved them as concrete implementations, as
** default methods cause the Java metaspace to spike one order of magnitude.
** 005 AS 20241009 Refactored activeOffset into activeOffsets(Bitset).
+** 006 AL2 20231102 Added computeIndexForHydrator for lazy hydration.
*/
/*
@@ -74,6 +75,7 @@
package com.goldencode.p2j.persist;
+import com.goldencode.p2j.jmx.*;
import com.goldencode.p2j.persist.orm.*;
import com.goldencode.p2j.util.object;
@@ -87,6 +89,21 @@
extends Record
implements TempTableRecord
{
+ private static final SimpleCounter HYDRATE_RECORDS_WHEN_SESSION_CLOSE =
+ SimpleCounter.getInstance(FwdServerJMX.Counter.TempHydratedRecordsWhenSessionCloses);
+
+ private static final SimpleCounter TOTAL_FIELDS =
+ SimpleCounter.getInstance(FwdServerJMX.Counter.TempTotalFields);
+
+ private static final SimpleCounter HYDRATE_FIELD_WHEN_SESSION_CLOSES =
+ SimpleCounter.getInstance(FwdServerJMX.Counter.TempHydratedFieldsWhenSessionCloses);
+
+ private static final SimpleCounter HYDRATED_FIELDS_LZS =
+ SimpleCounter.getInstance(FwdServerJMX.Counter.TempHydratedFieldsWithLZS);
+
+ private static final SimpleCounter HYDRATED_FIELDS_LOADER =
+ SimpleCounter.getInstance(FwdServerJMX.Counter.TempHydratedFieldsWithLoader);
+
/** The property/column name of "__error-flag__" field. */
public static final String _ERROR_FLAG = "_errorFlag";
@@ -197,7 +214,7 @@
@Override
public final Long _peerRowid()
{
- return (Long) data[_PEER_ROWID_DATA_INDEX];
+ return (Long) getDatum(_PEER_ROWID_DATA_INDEX);
}
/**
@@ -237,7 +254,7 @@
@Override
public final Integer _rowState()
{
- return (Integer) data[_ROW_STATE_DATA_INDEX];
+ return (Integer) getDatum(_ROW_STATE_DATA_INDEX);
}
/**
@@ -278,7 +295,7 @@
@Override
public final Long _originRowid()
{
- return (Long) data[_ORIGIN_ROWID_DATA_INDEX];
+ return (Long) getDatum(_ORIGIN_ROWID_DATA_INDEX);
}
/**
@@ -318,7 +335,7 @@
@Override
public final Long _datasourceRowid()
{
- return (Long) data[_DATASOURCE_ROWID_INDEX];
+ return (Long) getDatum(_DATASOURCE_ROWID_INDEX);
}
/**
@@ -356,7 +373,7 @@
@Override
public final Integer _errorFlags()
{
- return (Integer) data[_ERROR_FLAG_DATA_INDEX];
+ return (Integer) getDatum(_ERROR_FLAG_DATA_INDEX);
}
/**
@@ -392,7 +409,7 @@
@Override
public final String _errorString()
{
- return (String) data[_ERROR_STRING_DATA_INDEX];
+ return (String) getDatum(_ERROR_STRING_DATA_INDEX);
}
/**
@@ -507,4 +524,40 @@
Class implIFace = _recordMeta().getDmoMeta().getAnnotatedInterface();
TemporaryBuffer.updateObjectRefCount(implIFace, oldVal, newVal);
}
+
+ @Override
+ protected int getHydratorRowOffset()
+ {
+ return 2;
+ }
+
+ @Override
+ protected void countHydrateRecordWhenSessionCloses(long count)
+ {
+ HYDRATE_RECORDS_WHEN_SESSION_CLOSE.update(count);
+ }
+
+ @Override
+ protected void countTotalFields(long count)
+ {
+ TOTAL_FIELDS.update(count);
+ }
+
+ @Override
+ protected void countHydratedFieldsWithLZS(long count)
+ {
+ HYDRATED_FIELDS_LZS.update(count);
+ }
+
+ @Override
+ protected void countHydratedFieldsWithLoader(long count)
+ {
+ HYDRATED_FIELDS_LOADER.update(count);
+ }
+
+ @Override
+ protected void countHydratedFieldWhenSessionCloses(long count)
+ {
+ HYDRATE_FIELD_WHEN_SESSION_CLOSES.update(count);
+ }
}
=== modified file 'src/com/goldencode/p2j/persist/dialect/Dialect.java'
--- old/src/com/goldencode/p2j/persist/dialect/Dialect.java 2026-04-15 05:49:39 +0000
+++ new/src/com/goldencode/p2j/persist/dialect/Dialect.java 2026-05-22 13:58:35 +0000
@@ -605,8 +605,8 @@
}
/**
- * Create the error descriptor from the SQLException message.
- *
+ * Create the error descriptor from the {@code SQLException} message.
+ *
* @param message
* The SQLException message.
*
@@ -620,7 +620,7 @@
/**
* Check if Common Table Expressions should be used for converted CONTAINS operator
*
- * @return true if Common Table Expressions should be used for converted CONTAINS operator
+ * @return true if Common Table Expressions should be used for converted CONTAINS operator
*/
public boolean useCTE4Contains()
{
@@ -718,7 +718,7 @@
public abstract void generateWordTablesDDLImpl(String dbName,
PrintStream out,
String eoln,
- CollectionloadSqlIndexes[0] is always zero, as the
- * {@link #loadSql}'s first element is the scalar properties SELET.
+ * {@link #loadSql}'s first element is the scalar properties SELECT.
*/
final int[] loadSqlIndexes;
@@ -1101,6 +1101,11 @@
return temporary;
}
+ public boolean isSingleResultSetLoad()
+ {
+ return loadSql.length == 1;
+ }
+
/**
* Get the array of {@link PropertyMeta property metadata} objects which describe how the core
* data of this record is organized.
=== modified file 'src/com/goldencode/p2j/persist/orm/RowStructure.java'
--- old/src/com/goldencode/p2j/persist/orm/RowStructure.java 2025-07-16 14:01:50 +0000
+++ new/src/com/goldencode/p2j/persist/orm/RowStructure.java 2026-05-22 13:58:35 +0000
@@ -10,6 +10,7 @@
** 003 AL2 20231123 Refactored this as an interface. Moved implementation in AbstractRowStructure.
** AL2 20231211 Added getDmoMeta.
** 004 LS 20250714 Added 'getNeededFields'.
+** 005 AL2 20231214 Added hydrateAt and hydrateExtents
*/
/*
@@ -69,8 +70,7 @@
import java.sql.ResultSet;
import java.sql.SQLException;
-import java.util.BitSet;
-import java.util.Iterator;
+import java.util.*;
import com.goldencode.p2j.persist.DataModelObject;
import com.goldencode.p2j.persist.PersistenceException;
@@ -184,6 +184,49 @@
public int hydrate(Session session, ResultSet resultSet, int rsOffset, BaseRecord r)
throws PersistenceException,
SQLException;
+
+ /**
+ * Hydrate only one property in the base-record. This is largely used by the lazy hydrator,
+ * allowing it to hydrate only the property that is accessed now. The other hydration method
+ * ({@link #hydrate}) eagerly hydrates all properties, is a slow process and may do useless
+ * hydrations on properties that are not accessed.
+ *
+ * @param resultSet
+ * The ResultSet from which the hydration should be done
+ * @param rsOffset
+ * The result set offset from which the reading should be done. This is relevant as
+ * the result set may contain a joined row, but we are interested only in a specific
+ * record that may start at a specific offset.
+ * @param r
+ * The record that should be hydrated.
+ * @param propOffset
+ * The property that should be hydrated. The caller is responsible in assuring that
+ * this property wasn't hydrated before.
+ *
+ * @return {@code true} if this worked due to the fact that it was a scalar value. {@code false}
+ * in case the property was a non-expanded
+ *
+ * @throws PersistenceException
+ * This is thrown when reading the scalar property fails.
+ */
+ public boolean hydrateAt(ResultSet resultSet, int rsOffset, BaseRecord r, int propOffset)
+ throws PersistenceException;
+
+ /**
+ * Hydrate record's non-expanded extents.
+ *
+ * @param session
+ * The session to be used to query the non-expanded extent tables.
+ * @param r
+ * The record to be hydrated.
+ * @param recOffset
+ * The offset to which the extent data should be added into the record.
+ *
+ * @throws PersistenceException
+ * thrown when hydrating extents fails (as it requires extra SQL queries to be run).
+ */
+ public void hydrateExtents(Session session, BaseRecord r, int recOffset)
+ throws PersistenceException;
/**
* Retrieve the DMO meta used by the underlying DMO of this structure.
@@ -219,4 +262,12 @@
{
return true;
}
+
+ /**
+ * Retrieve the fields that were loaded from the database.
+ *
+ * @return A BitSet object, where true means that the field associated with that position in the {@code
+ * data} array has been loaded from database, and false - otherwise.
+ */
+ public BitSet getLoadedFields();
}
=== modified file 'src/com/goldencode/p2j/persist/orm/SQLQuery.java'
--- old/src/com/goldencode/p2j/persist/orm/SQLQuery.java 2025-09-10 11:27:41 +0000
+++ new/src/com/goldencode/p2j/persist/orm/SQLQuery.java 2026-05-22 13:58:35 +0000
@@ -2,7 +2,7 @@
** Module : SQLQuery.java
** Abstract : Object which performs an SQL query and processes the results.
**
-** Copyright (c) 2019-2025, Golden Code Development Corporation.
+** Copyright (c) 2019-2026, Golden Code Development Corporation.
**
** -#- -I- --Date-- ---------------------------------------Description---------------------------------------
** 001 ECF 20191001 Created initial version with stubbed methods.
@@ -133,6 +133,7 @@
import java.lang.reflect.Array;
import java.sql.*;
import java.util.*;
+import java.util.function.*;
import java.util.concurrent.atomic.*;
import java.util.logging.*;
import com.goldencode.p2j.directory.*;
@@ -155,7 +156,31 @@
* Note: internally, the object is NOT synchronized, so the usage intervals MUST NOT overlap.
*/
public class SQLQuery
-{
+
+{ /** Instrumentation for cases where we lazily hydrate or rehydrate a records. */
+ private static final SimpleCounter LAZY_HYDRATE_RECORD =
+ SimpleCounter.getInstance(FwdServerJMX.Counter.HydratorLazyRecord);
+
+ /** Instrumentation for cases where we lazily hydrate a record (not from cache). */
+ private static final SimpleCounter NEW_LAZY_RECORD =
+ SimpleCounter.getInstance(FwdServerJMX.Counter.HydratorNewRecord);
+
+ /** Instrumentation for cases where we fully hydrate a record. */
+ private static final SimpleCounter NON_LAZY_HYDRATE_RECORD =
+ SimpleCounter.getInstance(FwdServerJMX.Counter.HydratorNonLazyRecord);
+
+ /** Instrumentation for cases where we lazily hydrate a record (not from cache). */
+ private static final SimpleCounter LAZY_UNIQUE =
+ SimpleCounter.getInstance(FwdServerJMX.Counter.HydratorLazyUnique);
+
+ /** Instrumentation for cases where we fully hydrate a record. */
+ private static final SimpleCounter NON_LAZY_UNIQUE =
+ SimpleCounter.getInstance(FwdServerJMX.Counter.HydratorNonLazyUnique);
+
+ /** Profiler done for queries: cache hits, cache misses, etc. */
+ private static final QueryProfilerJMX SIMPLE_QUERY_PROFILER =
+ QueryProfilerJMX.getInstance(FwdServerJMX.QueryProfiler.QueryProfiler);
+
/** Logger */
private static final CentralLogger LOG = CentralLogger.get(SQLQuery.class);
@@ -180,10 +205,6 @@
fetchSize = dir.getInt(Directory.ID_RELATIVE_SERVER, CFG_FETCH_SIZE, DEFAULT_FETCH_SIZE);
LOG.fine("JDBC fetch size initialized to: " + fetchSize);
}
-
- /** Profiler done for queries: cache hits, cache misses, etc. */
- private static final QueryProfilerJMX SIMPLE_QUERY_PROFILER =
- QueryProfilerJMX.getInstance(FwdServerJMX.QueryProfiler.QueryProfiler);
/** The SQL statement, possibly with placeholders. */
private final String baseSql;
@@ -383,6 +404,9 @@
try
{
activateErrorHandler(session);
+ // Make sure we close result-set still opened on this sql. Otherwise, the statement will be reparsed.
+ session.unownResultSet(sql);
+
stmt = conn.prepareStatement(sql, scrollMode, ResultSet.CONCUR_READ_ONLY);
if (bindParam2SessionVar)
{
@@ -451,6 +475,9 @@
try
{
activateErrorHandler(session);
+ // Make sure we close result-set still opened on this sql. Otherwise, the statement will be reparsed.
+ session.unownResultSet(sql);
+
stmt = conn.prepareStatement(sql);
if (bindParam2SessionVar)
{
@@ -530,10 +557,16 @@
Connection conn = session.getConnection();
checkClosed(conn);
+ boolean sessionOwner = false;
+ ResultSet rs = null;
+ boolean shouldCloseSession = false;
try
{
activateErrorHandler(session);
- stmt = conn.prepareStatement(sql);
+ // Make sure we close result-set still opened on this sql. Otherwise, the statement will be reparsed.
+ session.evictResultSet(sql);
+
+ stmt = conn.prepareStatement(sql, ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
if (bindParam2SessionVar)
{
setSessionVars(conn);
@@ -549,11 +582,24 @@
}
QueryStatement f = PreparedStatement::executeQuery;
- ResultSet resultSet = SQLExecutor.getInstance().execute(session.getDatabase(), sql, f, stmt);
+ rs = SQLExecutor.getInstance().execute(session.getDatabase(), sql, f, stmt);
+ // TODO: apply lazy hydration. Mind that this instantly closes the statement, so the result-set
+ // so the lazy won't lasy for very long.
+ Dialect dialect = Query.getDialect(session);
+ if (dialect != null && dialect.useLazyHydration())
+ {
+ rs = new LazyResultSet(stmt, rs, session);
+ sessionOwner = true;
+ LAZY_UNIQUE.update(1);
+ }
+ else
+ {
+ NON_LAZY_UNIQUE.update(1);
+ }
reportSQLWarnings(session);
- if (!resultSet.next()) // same effect as first()
+ if (!rs.next()) // same effect as first()
{
return null; // no record matching predicate
}
@@ -562,21 +608,20 @@
if (rowStructure == null || rowStructure.getCount() == 1)
{
// only the PK or other scalar value is returned by the query
- ret = (T) resultSet.getObject(1);
+ ret = (T) rs.getObject(1);
}
else
{
- // when multiple values are returned in a row then a fully hydrated Record is expected
- ret = (T) hydrateRecord(resultSet, rowStructure, 1, session);
+ // when multiple values are returned in a row then a full Record is expected
+ ret = (T) hydrateRecord(rs, rowStructure, 1, session);
}
-
- if (resultSet.next())
+ // don't call any further next as it will invalidate lazy hydration
+ if (!rs.isLast())
{
- close(); // ???
+ shouldCloseSession = true;
throw new UniqueResultException("Result not unique for " + stmt);
}
-
- SIMPLE_QUERY_PROFILER.updateRowsCount(resultSet, 1);
+ SIMPLE_QUERY_PROFILER.updateRowsCount(rs, 1);
return ret;
}
catch (SQLException exc)
@@ -589,9 +634,18 @@
}
throw new PersistenceException("Error uniqueResult", exc);
}
- finally
+ finally
{
- close();
+ if (sessionOwner && rs != null && !shouldCloseSession)
+ {
+ // don't eagerly close it now as it will instantly invalidate lazy hydration
+ // let the result-set live more being managed by the session
+ session.ownResultSet(sql, rs);
+ }
+ else
+ {
+ close();
+ }
resetErrorHandler(session);
}
}
@@ -700,6 +754,9 @@
{
activateErrorHandler(session);
int rowSize = rowStructures.size();
+ // Make sure we close result-set still opened on this sql. Otherwise, the statement will be reparsed.
+ session.unownResultSet(sql);
+
List