/** * Walk the association tree for an entity, adding associations which should be join fetched to * the {@link #associations} inst var. This form is the entry point into the walking for a given * entity, starting the recursive calls into {@link * #walkEntityTree(org.hibernate.persister.entity.OuterJoinLoadable, String, PropertyPath ,int)}. * * @param persister The persister representing the entity to be walked. * @param alias The (root) alias to use for this entity/persister. * @param path The property path to the entity being walked * @param currentDepth The current join depth * @throws org.hibernate.MappingException ??? */ private void walkEntityTree( final OuterJoinLoadable persister, final String alias, final PropertyPath path, final int currentDepth) throws MappingException { int n = persister.countSubclassProperties(); for (int i = 0; i < n; i++) { Type type = persister.getSubclassPropertyType(i); if (type.isAssociationType()) { walkEntityAssociationTree( (AssociationType) type, persister, i, alias, path, persister.isSubclassPropertyNullable(i), currentDepth); } else if (type.isComponentType()) { walkComponentTree( (CompositeType) type, i, 0, persister, alias, path.append(persister.getSubclassPropertyName(i)), currentDepth); } } }
/** * Walk the association tree for an entity, adding associations which should be join fetched to * the {@link #associations} inst var. This form is the entry point into the walking for a given * entity, starting the recursive calls into {@link * #walkEntityTree(org.hibernate.persister.entity.OuterJoinLoadable, String, PropertyPath ,int)}. * * @param persister The persister representing the entity to be walked. * @param alias The (root) alias to use for this entity/persister. * @param path The property path to the entity being walked * @param currentDepth The current join depth * @throws org.hibernate.MappingException ??? */ private void walkEntityTree( final OuterJoinLoadable persister, final String alias, final PropertyPath path, final int currentDepth) throws MappingException { int n = persister.countSubclassProperties(); for (int i = 0; i < n; i++) { Type type = persister.getSubclassPropertyType(i); if (type.isAssociationType()) { walkEntityAssociationTree( (AssociationType) type, persister, i, alias, path, persister.isSubclassPropertyNullable(i), currentDepth); } else if (type.isComponentType()) { walkComponentTree( (CompositeType) type, i, 0, persister, alias, path.append(persister.getSubclassPropertyName(i)), currentDepth); } } // if the entity has a composite identifier, see if we need to handle // its sub-properties separately final Type idType = persister.getIdentifierType(); if (idType.isComponentType()) { final CompositeType cidType = (CompositeType) idType; if (cidType.isEmbedded()) { // we have an embedded composite identifier. Most likely we need to process the composite // properties separately, although there is an edge case where the identifier is really // a simple identifier (single value) wrapped in a JPA @IdClass or even in the case of a // a simple identifier (single value) wrapped in a Hibernate composite type. // // We really do not have a built-in method to determine that. However, generally the // persister would report that there is single, physical identifier property which is // explicitly at odds with the notion of "embedded composite". So we use that for now if (persister.getEntityMetamodel().getIdentifierProperty().isEmbedded()) { walkComponentTree(cidType, -1, 0, persister, alias, path.append(""), currentDepth); } } } }