}
}
// Find the statement mappings and field numbers to use for the result class
// Caters for persistent-interfaces and the result class being an implementation
AbstractClassMetaData cmd = ec.getMetaDataManager().getMetaDataForClass(pcClassForObject, clr);
if (cmd == null)
{
// No way of identifying the object type so assumed to be null
// This can happen when selecting a class and also a related class via LEFT OUTER JOIN
// and the LEFT OUTER JOIN results in no related object, hence null discriminator etc
// TODO Improve this and check PK cols
return null;
}
int[] fieldNumbers = stmtMapping.getMemberNumbers();
StatementClassMapping mappingDefinition;
int[] mappedFieldNumbers;
if (acmd instanceof InterfaceMetaData)
{
// Persistent-interface : create new mapping definition for a result type of the implementation
mappingDefinition = new StatementClassMapping();
mappingDefinition.setNucleusTypeColumnName(stmtMapping.getNucleusTypeColumnName());
mappedFieldNumbers = new int[fieldNumbers.length];
for (int i = 0; i < fieldNumbers.length; i++)
{
AbstractMemberMetaData mmd = acmd.getMetaDataForManagedMemberAtAbsolutePosition(fieldNumbers[i]);
mappedFieldNumbers[i] = cmd.getAbsolutePositionOfMember(mmd.getName());
mappingDefinition.addMappingForMember(mappedFieldNumbers[i],
stmtMapping.getMappingForMemberPosition(fieldNumbers[i]));
}
}
else
{
// Persistent class
mappingDefinition = stmtMapping;
mappedFieldNumbers = fieldNumbers;
}
// Extract any surrogate version
VersionMetaData vermd = cmd.getVersionMetaDataForClass();
Object surrogateVersion = null;
StatementMappingIndex versionMapping = null;
if (vermd != null)
{
if (vermd.getFieldName() == null)
{
versionMapping = stmtMapping.getMappingForMemberPosition(StatementClassMapping.MEMBER_VERSION);
}
else
{
AbstractMemberMetaData vermmd = cmd.getMetaDataForMember(vermd.getFieldName());
versionMapping = stmtMapping.getMappingForMemberPosition(vermmd.getAbsoluteFieldNumber());
}
}
if (versionMapping != null)
{
// Surrogate version column returned by query
JavaTypeMapping mapping = versionMapping.getMapping();
surrogateVersion = mapping.getObject(ec, rs, versionMapping.getColumnPositions());
}
// Extract the object from the ResultSet
Object obj = null;
boolean needToSetVersion = false;
if (persistentClass.isInterface() && !cmd.isImplementationOfPersistentDefinition())
{
// Querying by interface, and not a generated implementation so use the metadata for the interface
cmd = ec.getMetaDataManager().getMetaDataForInterface(persistentClass, clr);
}
if (cmd.getIdentityType() == IdentityType.APPLICATION)
{
// Check if the PK field(s) are all null (implies null object, when using OUTER JOIN)
int[] pkNumbers = cmd.getPKMemberPositions();
ResultSet resultSet = (ResultSet)rs;
boolean nullObject = true;
for (int i=0;i<pkNumbers.length;i++)
{
StatementMappingIndex pkIdx = mappingDefinition.getMappingForMemberPosition(pkNumbers[i]);
if (pkIdx == null)
{
throw new NucleusException("You have just executed an SQL statement yet the information " +
"for the primary key column(s) is not available! " +
"Please generate a testcase and report this issue");
}
int[] colPositions = pkIdx.getColumnPositions();
for (int j=0;j<colPositions.length;j++)
{
try
{
Object pkObj = resultSet.getObject(colPositions[j]);
if (pkObj != null)
{
nullObject = false;
break;
}
}
catch (SQLException sqle)
{
NucleusLogger.DATASTORE_RETRIEVE.warn("Exception thrown while retrieving results ", sqle);
}
if (!nullObject)
{
break;
}
}
}
if (nullObject)
{
obj = null;
}
else
{
// Retrieve the object with this application-identity
if (warnMsg != null)
{
NucleusLogger.DATASTORE_RETRIEVE.warn(warnMsg);
}
obj = getObjectForApplicationId(ec, rs, mappingDefinition, mappedFieldNumbers,
pcClassForObject, cmd, requiresInheritanceCheck, surrogateVersion);
}
}
else if (cmd.getIdentityType() == IdentityType.DATASTORE)
{
// Generate the "oid" for this object (of type pcClassForObject), and find the object for that
StatementMappingIndex datastoreIdMapping =
stmtMapping.getMappingForMemberPosition(StatementClassMapping.MEMBER_DATASTORE_ID);
JavaTypeMapping mapping = datastoreIdMapping.getMapping();
OID oid = (OID)mapping.getObject(ec, rs, datastoreIdMapping.getColumnPositions());
if (oid != null)
{
Object id = oid;
if (!pcClassForObject.getName().equals(oid.getPcClass()))
{
// Get an OID for the right inheritance level
id = OIDFactory.getInstance(ec.getNucleusContext(), pcClassForObject.getName(), oid.getKeyValue());
}
if (warnMsg != null)
{
NucleusLogger.DATASTORE_RETRIEVE.warn(warnMsg);
}
if (mappedFieldNumbers == null)
{
obj = ec.findObject(id, false, requiresInheritanceCheck, null);
needToSetVersion = true;
}
else
{
obj = getObjectForDatastoreId(ec, rs, mappingDefinition, mappedFieldNumbers,
id, requiresInheritanceCheck ? null : pcClassForObject, cmd, surrogateVersion);
}
}
else
{
obj = null;
}
}
else if (cmd.getIdentityType() == IdentityType.NONDURABLE)
{
Object id = ec.newObjectId(className, null);
if (mappedFieldNumbers == null)
{
obj = ec.findObject(id, false, requiresInheritanceCheck, null);