/**
* 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);
}
}
public void setup() {
getSession().getIdentityMapAccessor().initializeIdentityMaps();
getAbstractSession().beginTransaction();
descriptor = getSession().getProject().getDescriptors().get(Employee.class);
// Read Object
readObjectQuery = descriptor.getQueryManager().getReadObjectQuery();
QueryRedirector redirector =
new MethodBaseQueryRedirector(RedirectorOnDescriptorTest.class, "readObject");
ReadObjectQuery roq = new ReadObjectQuery(descriptor.getJavaClass());
roq.setRedirector(redirector);
descriptor.getQueryManager().setReadObjectQuery(roq);
// Read All
readAllQuery = descriptor.getQueryManager().getReadAllQuery();
redirector = new MethodBaseQueryRedirector(RedirectorOnDescriptorTest.class, "readAll");
ReadAllQuery raq = new ReadAllQuery(descriptor.getJavaClass());
raq.setRedirector(redirector);
descriptor.getQueryManager().setReadAllQuery(raq);
// Delete Object
deleteObjectQuery = descriptor.getQueryManager().getDeleteQuery();
redirector = new MethodBaseQueryRedirector(RedirectorOnDescriptorTest.class, "deleteObject");
DeleteObjectQuery doq = new DeleteObjectQuery();
doq.setRedirector(redirector);
descriptor.getQueryManager().setDeleteQuery(doq);
// Insert Object
insertQuery = descriptor.getQueryManager().getInsertQuery();
redirector = new MethodBaseQueryRedirector(RedirectorOnDescriptorTest.class, "insertObject");
InsertObjectQuery ioq = new InsertObjectQuery();
ioq.setRedirector(redirector);
descriptor.getQueryManager().setInsertQuery(ioq);
// Update Object
updateQuery = descriptor.getQueryManager().getUpdateQuery();
redirector = new MethodBaseQueryRedirector(RedirectorOnDescriptorTest.class, "updateObject");
UpdateObjectQuery uoq = new UpdateObjectQuery();
uoq.setRedirector(redirector);
descriptor.getQueryManager().setUpdateQuery(uoq);
}
/** INTERNAL: Select one object of any concrete subclass. */
protected Object selectOneObject(ReadObjectQuery query) throws DescriptorException {
ReadObjectQuery concreteQuery = (ReadObjectQuery) query.clone();
Class javaClass = descriptor.getJavaClass();
concreteQuery.setReferenceClass(javaClass);
concreteQuery.setDescriptor(descriptor);
return query.getSession().executeQuery(concreteQuery, concreteQuery.getTranslationRow());
}
public void executeUntilStopped() {
Session session =
ConcurrentTestRefreshWithOptimisticLocking.server.serverSession.acquireClientSession();
DeadLockAddress address =
(DeadLockAddress)
session.readObject(
org.eclipse.persistence.testing.tests.clientserver.DeadLockAddress.class);
DeadLockEmployee employee = (DeadLockEmployee) session.readObject(DeadLockEmployee.class);
ReadObjectQuery query;
if ((this.index % 2) != 0) {
query = new ReadObjectQuery(address);
query.refreshIdentityMapResult();
query.setCascadePolicy(DatabaseQuery.CascadeAllParts);
} else {
query = new ReadObjectQuery(employee);
query.refreshIdentityMapResult();
query.setCascadePolicy(DatabaseQuery.CascadeAllParts);
}
while (ConcurrentTestRefreshWithOptimisticLocking.execute) {
ConcurrentTestRefreshWithOptimisticLocking.timeList[this.index] = System.currentTimeMillis();
session.executeQuery(query);
}
// System.out.println("BeingShutDown");
}
/**
* INTERNAL: Build and return the nested rows from the specified field value. This method allows
* the field value to be an ARRAY containing other structures such as arrays or Struct, or direct
* values.
*/
public static Object buildContainerFromArray(
Array fieldValue, ObjectRelationalDatabaseField arrayField, AbstractSession session)
throws DatabaseException {
if (arrayField.getType() == null) {
return fieldValue;
}
Object[] objects = null;
try {
objects = (Object[]) fieldValue.getArray();
} catch (java.sql.SQLException ex) {
throw DatabaseException.sqlException(ex, session, false);
}
if (objects == null) {
return null;
}
boolean isNestedStructure = false;
ObjectRelationalDataTypeDescriptor ord = null;
DatabaseField nestedType = null;
if (arrayField != null) {
nestedType = arrayField.getNestedTypeField();
if ((nestedType != null) && nestedType.getSqlType() == Types.STRUCT) {
ClassDescriptor descriptor = session.getDescriptor(nestedType.getType());
if ((descriptor != null) && (descriptor.isObjectRelationalDataTypeDescriptor())) {
// this is used to convert non-null objects passed through stored procedures and custom
// SQL to structs
ord = (ObjectRelationalDataTypeDescriptor) descriptor;
}
} else if ((nestedType != null) && (nestedType instanceof ObjectRelationalDatabaseField)) {
isNestedStructure = true;
}
}
// handle ARRAY conversions
ReadObjectQuery query = new ReadObjectQuery();
query.setSession(session);
ContainerPolicy cp = ContainerPolicy.buildPolicyFor(arrayField.getType());
Object container = cp.containerInstance(objects.length);
for (int i = 0; i < objects.length; i++) {
Object arrayValue = objects[i];
if (arrayValue == null) {
return null;
}
if (ord != null) {
AbstractRecord nestedRow = ord.buildRowFromStructure((Struct) arrayValue);
ClassDescriptor descriptor = ord;
if (descriptor.hasInheritance()) {
Class newElementClass =
descriptor.getInheritancePolicy().classFromRow(nestedRow, session);
if (!descriptor.getJavaClass().equals(newElementClass)) {
descriptor = session.getDescriptor(newElementClass);
if (descriptor == null) {
descriptor = ord;
}
}
}
arrayValue = descriptor.getObjectBuilder().buildNewInstance();
descriptor
.getObjectBuilder()
.buildAttributesIntoObject(arrayValue, nestedRow, query, null, false);
} else if (isNestedStructure && (arrayValue instanceof Array)) {
arrayValue =
buildContainerFromArray(
(Array) arrayValue, (ObjectRelationalDatabaseField) nestedType, session);
}
cp.addInto(arrayValue, container, session);
}
return container;
}
