/** INTERNAL: Get a value from the object and set that in the respective field of the row. */
@Override
public Object valueFromObject(Object object, DatabaseField field, AbstractSession session) {
// First check if the value can be obtained from the value holder's row.
AbstractRecord referenceRow =
getIndirectionPolicy().extractReferenceRow(getAttributeValueFromObject(object));
if (referenceRow != null) {
Object value = referenceRow.get(field);
// Must ensure the classification to get a cache hit.
try {
value = session.getDatasourcePlatform().convertObject(value, getFieldClassification(field));
} catch (ConversionException e) {
throw ConversionException.couldNotBeConverted(this, getDescriptor(), e);
}
return value;
}
// 2.5.1.6 PWK. added to support batch reading on variable one to ones
Object referenceObject = getRealAttributeValueFromObject(object, session);
String queryKeyName = (String) getSourceToTargetQueryKeyNames().get(field);
ClassDescriptor objectDescriptor = session.getDescriptor(referenceObject.getClass());
DatabaseField targetField =
objectDescriptor.getObjectBuilder().getTargetFieldForQueryKeyName(queryKeyName);
if (targetField == null) {
return null;
}
return objectDescriptor
.getObjectBuilder()
.extractValueFromObjectForField(referenceObject, targetField, session);
}
/**
* INTERNAL: Return the value of the field from the row or a value holder on the query to obtain
* the object. Check for batch + aggregation reading.
*/
@Override
public Object valueFromRow(
AbstractRecord row,
JoinedAttributeManager joinManager,
ObjectBuildingQuery sourceQuery,
AbstractSession executionSession)
throws DatabaseException {
// If any field in the foreign key is null then it means there are no referenced objects
for (Enumeration enumeration = getFields().elements(); enumeration.hasMoreElements(); ) {
DatabaseField field = (DatabaseField) enumeration.nextElement();
if (row.get(field) == null) {
return getIndirectionPolicy().nullValueFromRow();
}
}
if (getTypeField() != null) {
// If the query used batched reading, return a special value holder,
// or retrieve the object from the query property.
if (sourceQuery.isReadAllQuery()
&& (((ReadAllQuery) sourceQuery).isAttributeBatchRead(getDescriptor(), getAttributeName())
|| shouldUseBatchReading())) {
return batchedValueFromRow(row, ((ReadAllQuery) sourceQuery));
}
// If the field is empty we cannot load the object because we do not know what class it will
// be
if (row.get(getTypeField()) == null) {
return getIndirectionPolicy().nullValueFromRow();
}
Class implementerClass =
(Class) getImplementorForType(row.get(getTypeField()), executionSession);
ReadObjectQuery query = (ReadObjectQuery) getSelectionQuery().clone();
query.setReferenceClass(implementerClass);
query.setSelectionCriteria(getSelectionCriteria());
query.setDescriptor(null); // Must set to null so the right descriptor is used
if (sourceQuery.isObjectLevelReadQuery()
&& (sourceQuery.shouldCascadeAllParts()
|| (sourceQuery.shouldCascadePrivateParts() && isPrivateOwned())
|| (sourceQuery.shouldCascadeByMapping() && this.cascadeRefresh))) {
query.setShouldRefreshIdentityMapResult(sourceQuery.shouldRefreshIdentityMapResult());
query.setCascadePolicy(sourceQuery.getCascadePolicy());
query.setShouldMaintainCache(sourceQuery.shouldMaintainCache());
// For flashback.
if (((ObjectLevelReadQuery) sourceQuery).hasAsOfClause()) {
query.setAsOfClause(((ObjectLevelReadQuery) sourceQuery).getAsOfClause());
}
// CR #4365 - used to prevent infinit recursion on refresh object cascade all
query.setQueryId(sourceQuery.getQueryId());
}
return getIndirectionPolicy().valueFromQuery(query, row, executionSession);
} else {
return super.valueFromRow(row, joinManager, sourceQuery, executionSession);
}
}
/** INTERNAL: Clone the row and its values. */
public AbstractRecord clone() {
try {
AbstractRecord clone = (AbstractRecord) super.clone();
clone.fields = (Vector) this.fields.clone();
clone.values = (Vector) this.values.clone();
return clone;
} catch (CloneNotSupportedException exception) {
throw new InternalError();
}
}
/** INTERNAL: Get a value from the object and set that in the respective field of the row. */
protected void writeFromNullObjectIntoRow(AbstractRecord record) {
if (isReadOnly()) {
return;
}
if (isForeignKeyRelationship()) {
Enumeration foreignKeys = getForeignKeyFields().elements();
while (foreignKeys.hasMoreElements()) {
record.put((DatabaseField) foreignKeys.nextElement(), null);
}
}
if (getTypeField() != null) {
record.put(getTypeField(), null);
}
}
/** INTERNAL: Write fields needed for insert into the template for with null values. */
public void writeInsertFieldsIntoRow(AbstractRecord record, AbstractSession session) {
if (isReadOnly()) {
return;
}
record.put(getField(), null);
}
/**
* INTERNAL: Return the value of the field from the row or a value holder on the query to obtain
* the object. Check for batch + aggregation reading.
*/
public Object valueFromRow(
AbstractRecord row,
JoinedAttributeManager joinManager,
ObjectBuildingQuery query,
AbstractSession executionSession)
throws DatabaseException {
Ref ref = (Ref) row.get(getField());
if (ref == null) {
return null;
}
Struct struct;
try {
((DatabaseAccessor) executionSession.getAccessor()).incrementCallCount(executionSession);
java.sql.Connection connection =
((DatabaseAccessor) executionSession.getAccessor()).getConnection();
struct =
(Struct) executionSession.getPlatform().getRefValue(ref, executionSession, connection);
} catch (java.sql.SQLException exception) {
throw DatabaseException.sqlException(exception, executionSession, false);
}
AbstractRecord targetRow =
((ObjectRelationalDataTypeDescriptor) getReferenceDescriptor())
.buildRowFromStructure(struct);
((DatabaseAccessor) executionSession.getAccessor()).decrementCallCount();
return getReferenceDescriptor().getObjectBuilder().buildObject(query, targetRow, joinManager);
}
/**
* INTERNAL: This row is built for shallow insert which happens in case of bidirectional inserts.
* The foreign keys must be set to null to avoid constraints.
*/
public void writeFromObjectIntoRowForShallowInsertWithChangeRecord(
ChangeRecord changeRecord, AbstractRecord record, AbstractSession session) {
if (isReadOnly()) {
return;
}
record.put(getField(), null);
}
/** INTERNAL: Get a value from the object and set that in the respective field of the row. */
@Override
public void writeFromObjectIntoRowForWhereClause(
ObjectLevelModifyQuery query, AbstractRecord record) {
if (isReadOnly()) {
return;
}
Object object;
if (query.isDeleteObjectQuery()) {
object = query.getObject();
} else {
object = query.getBackupClone();
}
Object referenceObject = getRealAttributeValueFromObject(object, query.getSession());
if (referenceObject == null) {
writeFromNullObjectIntoRow(record);
} else {
if (isForeignKeyRelationship()) {
Enumeration sourceFields = getForeignKeyFields().elements();
ClassDescriptor descriptor = query.getSession().getDescriptor(referenceObject.getClass());
while (sourceFields.hasMoreElements()) {
DatabaseField sourceKey = (DatabaseField) sourceFields.nextElement();
String targetQueryKey = (String) getSourceToTargetQueryKeyNames().get(sourceKey);
DatabaseField targetKeyField =
descriptor.getObjectBuilder().getFieldForQueryKeyName(targetQueryKey);
if (targetKeyField == null) {
throw DescriptorException.variableOneToOneMappingIsNotDefinedProperly(
this, descriptor, targetQueryKey);
}
Object referenceValue =
descriptor
.getObjectBuilder()
.extractValueFromObjectForField(
referenceObject, targetKeyField, query.getSession());
record.put(sourceKey, referenceValue);
}
}
if (getTypeField() != null) {
record.put(getTypeField(), getTypeForImplementor(referenceObject.getClass()));
}
}
}
/** INTERNAL: Get a value from the object and set that in the respective field of the row. */
public void writeFromObjectIntoRow(
Object object, AbstractRecord record, AbstractSession session) {
if (isReadOnly()) {
return;
}
Object referenceObject = getRealAttributeValueFromObject(object, session);
if (referenceObject == null) {
// Fix for 2730536, must put something in modify row, even if it is null.
record.put(getField(), null);
return;
}
Ref ref =
((ObjectRelationalDataTypeDescriptor) getReferenceDescriptor())
.getRef(referenceObject, session);
record.put(getField(), ref);
}
/**
* INTERNAL: Get a value from the object and set that in the respective field of the row. If the
* mapping id target foreign key, you must only write the type into the roe, the rest will be
* updated when the object itself is written
*/
@Override
public void writeFromObjectIntoRowWithChangeRecord(
ChangeRecord changeRecord, AbstractRecord record, AbstractSession session) {
if (isReadOnly()) {
return;
}
ObjectChangeSet changeSet =
(ObjectChangeSet) ((ObjectReferenceChangeRecord) changeRecord).getNewValue();
if (changeSet == null) {
writeFromNullObjectIntoRow(record);
} else {
Object referenceObject = changeSet.getUnitOfWorkClone();
if (isForeignKeyRelationship()) {
Enumeration sourceFields = getForeignKeyFields().elements();
ClassDescriptor descriptor = session.getDescriptor(referenceObject.getClass());
while (sourceFields.hasMoreElements()) {
DatabaseField sourceKey = (DatabaseField) sourceFields.nextElement();
String targetQueryKey = (String) getSourceToTargetQueryKeyNames().get(sourceKey);
DatabaseField targetKeyField =
descriptor.getObjectBuilder().getFieldForQueryKeyName(targetQueryKey);
if (targetKeyField == null) {
throw DescriptorException.variableOneToOneMappingIsNotDefinedProperly(
this, descriptor, targetQueryKey);
}
Object referenceValue =
descriptor
.getObjectBuilder()
.extractValueFromObjectForField(referenceObject, targetKeyField, session);
record.put(sourceKey, referenceValue);
}
}
if (getTypeField() != null) {
record.put(getTypeField(), getTypeForImplementor(referenceObject.getClass()));
}
}
}
/** INTERNAL: Get a value from the object and set that in the respective field of the row. */
public void writeFromObjectIntoRowWithChangeRecord(
ChangeRecord changeRecord, AbstractRecord record, AbstractSession session) {
if (isReadOnly()) {
return;
}
ObjectChangeSet changeSet =
(ObjectChangeSet) ((ObjectReferenceChangeRecord) changeRecord).getNewValue();
Object referenceObject = changeSet.getUnitOfWorkClone();
if (referenceObject == null) {
return;
}
Ref ref =
((ObjectRelationalDataTypeDescriptor) getReferenceDescriptor())
.getRef(referenceObject, session);
record.put(getField(), ref);
}
/**
* INTERNAL: Merge the provided row into this row. Existing field values in this row will be
* replaced with values from the provided row. Fields not in this row will be added from provided
* row. Values not in provided row will remain in this row.
*/
public void mergeFrom(AbstractRecord row) {
for (int index = 0; index < row.size(); ++index) {
this.put(row.getFields().get(index), row.getValues().get(index));
}
}